From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 32267 invoked by alias); 9 Oct 2012 15:03:53 -0000 Received: (qmail 32255 invoked by uid 22791); 9 Oct 2012 15:03:50 -0000 X-SWARE-Spam-Status: No, hits=-4.8 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_SPAMHAUS_DROP,KHOP_THREADED,RCVD_IN_DNSWL_LOW,RCVD_IN_HOSTKARMA_NO,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,RCVD_IN_HOSTKARMA_YE,TW_EG,TW_PV X-Spam-Check-By: sourceware.org Received: from am1ehsobe004.messaging.microsoft.com (HELO am1outboundpool.messaging.microsoft.com) (213.199.154.207) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 09 Oct 2012 15:03:33 +0000 Received: from mail98-am1-R.bigfish.com (10.3.201.241) by AM1EHSOBE004.bigfish.com (10.3.204.24) with Microsoft SMTP Server id 14.1.225.23; Tue, 9 Oct 2012 15:03:31 +0000 Received: from mail98-am1 (localhost [127.0.0.1]) by mail98-am1-R.bigfish.com (Postfix) with ESMTP id 01829C0129; Tue, 9 Oct 2012 15:03:31 +0000 (UTC) X-Forefront-Antispam-Report: CIP:59.163.77.177;KIP:(null);UIP:(null);IPV:NLI;H:KCHJEXHC02.kpit.com;RD:59.163.77.177.static.vsnl.net.in;EFVD:NLI X-SpamScore: -4 X-BigFish: VPS-4(zz936eIc85fh154dM1447Ic8kzz1202h1d1ah1d2ahzz17326ah8275bh8275dh177df4hz2dh2a8h668h839hd25hf0ah107ah1288h12a5h12bdh137ah1441h34h1155h) Received: from mail98-am1 (localhost.localdomain [127.0.0.1]) by mail98-am1 (MessageSwitch) id 1349795006469730_20696; Tue, 9 Oct 2012 15:03:26 +0000 (UTC) Received: from AM1EHSMHS004.bigfish.com (unknown [10.3.201.236]) by mail98-am1.bigfish.com (Postfix) with ESMTP id 6ED902A0049; Tue, 9 Oct 2012 15:03:26 +0000 (UTC) Received: from KCHJEXHC02.kpit.com (59.163.77.177) by AM1EHSMHS004.bigfish.com (10.3.207.104) with Microsoft SMTP Server (TLS) id 14.1.225.23; Tue, 9 Oct 2012 15:03:21 +0000 Received: from KCHJEXMB02.kpit.com ([169.254.2.237]) by KCHJEXHC02.kpit.com ([172.10.15.74]) with mapi id 14.01.0289.001; Tue, 9 Oct 2012 20:33:12 +0530 From: Kaushik Phatak To: Yao Qi CC: "gdb-patches@sourceware.org" , Joel Brobecker Subject: RE: [RFA 3/5] New port: CR16: gdb port Date: Tue, 09 Oct 2012 15:03:00 -0000 Message-ID: References: <507279C7.8080401@codesourcery.com> In-Reply-To: <507279C7.8080401@codesourcery.com> Content-Type: multipart/mixed; boundary="_002_C6CA53A2A46BA7469348BDBD663AB65845B39A2FKCHJEXMB02kpitc_" MIME-Version: 1.0 X-OriginatorOrg: kpitcummins.com Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-10/txt/msg00151.txt.bz2 --_002_C6CA53A2A46BA7469348BDBD663AB65845B39A2FKCHJEXMB02kpitc_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Content-length: 34050 Hi Yao, Thanks for the review. > Add 'static'. It is not used out of this file. Ok, added this. > + set_gdbarch_num_regs (gdbarch, CR16_LINUX_NUM_REGS); > + set_gdbarch_register_name (gdbarch, cr16_linux_register_name); > This part should be moved to function cr16_uclinux_init_abi, Moved these setup calls into cr16-linux-tdep.c file. > These two macros can be defined in cr16-tdep.c and cr16-linux-tdep.c=20 > respectively. After making above changes, moved these macros into respective files. > They are not needed. 'breakpoint_elf' is only used in cr16-tdep.c,=20 > and 'breakpoint_linux' doesn't exist at all. Removed these declarations, they were probably used in an earlier version. Additionally, apart from these gdb specific changes, I have also merged my patch [2/5] with this, which updates configure.tgt.=20 Please find the updated patch below. I have also attached the same.=20 I have tried to incorporate all the comments from Joel as mentioned=20 in my reply, http://sourceware.org/ml/gdb-patches/2012-10/msg00149.html Please let me know if any further modification would be needed. Regards, Kaushik ---- 2012-10-09 Kaushik Phatak gdb/Changelog * configure.tgt: Handle cr16*-*-*linux and cr16*-*-*. * cr16-linux-tdep.c: New file. * cr16-tdep.c: New file. * cr16-tdep.h: New file. --- ./gdb_src.orig/gdb/configure.tgt 2012-08-02 01:18:44.000000000 +0530 +++ ./gdb_src/gdb/configure.tgt 2012-10-09 19:12:54.000000000 +0530 @@ -116,6 +116,18 @@ bfin-*-*) gdb_sim=3D../sim/bfin/libsim.a ;; =20 +cr16*-*-*linux) + # Target: CR16 processor + gdb_target_obs=3D"cr16-tdep.o cr16-linux-tdep.o linux-tdep.o" + gdb_sim=3D../sim/cr16/libsim.a + ;; + +cr16*-*-*) + # Target: CR16 processor + gdb_target_obs=3D"cr16-tdep.o" + gdb_sim=3D../sim/cr16/libsim.a + ;; + cris*) # Target: CRIS gdb_target_obs=3D"cris-tdep.o solib-svr4.o" --- ./gdb_src.orig/gdb/cr16-linux-tdep.c 1970-01-01 05:30:00.000000000 +0530 +++ ./gdb_src/gdb/cr16-linux-tdep.c 2012-10-09 17:30:21.000000000 +0530 @@ -0,0 +1,102 @@ +/* Target-dependent code for GNU/Linux on the Sitel CR16 processors. + + Copyright 2012 Free Software Foundation, Inc. + + Contributed by Kaushik Phatak (kaushik.pahatk@kpitcummins.com) + KPIT Cummins Infosystems Limited, Pune India. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . = */ + +#include "defs.h" +#include "osabi.h" +#include "elf-bfd.h" +#include "elf/cr16.h" +#include "linux-tdep.h" +#include "solib-svr4.h" +#include "symtab.h" +#include "cr16-tdep.h" + +/* Number of registers available for Linux targets */ +#define CR16_LINUX_NUM_REGS 21 + +/* The breakpoint instruction used by uClinux target */ +static const gdb_byte breakpoint_uclinux[] =3D { 0xC7, 0x00 }; + +/* Implement the "register_name" gdbarch method. */ + +static const char * +cr16_linux_register_name (struct gdbarch *gdbarch, int regnr) +{ + static const char *const reg_names[] =3D { + "r0", + "r1", + "r2", + "r3", + "r4", + "r5", + "r6", + "r7", + "r8", + "r9", + "r10", + "r11", + "r12", + "r13", + "ra", + "psr", + "pc", + "r0r1_orig", + "intbase", + "usp", + "cfg" + }; + + return reg_names[regnr]; +} + +/* OS specific initialization of gdbarch. */ + +static void +cr16_uclinux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +{ + struct gdbarch_tdep *tdep =3D gdbarch_tdep (gdbarch); + + linux_init_abi (info, gdbarch); + + set_gdbarch_num_regs (gdbarch, CR16_LINUX_NUM_REGS); + set_gdbarch_register_name (gdbarch, cr16_linux_register_name); + + /* The opcode of excp bpt is 0x00C8, however for uclinux we will + use the excp flg (0x00C7) to insert a breakpoint. The excp bpt + requires external hardware support for breakpoints to work on + CR16 target. Software based breakpoints are implemented in the + kernel using excp flg and tested on the SC14452 target. Use + 0x00C7 with gdbserver/kernel and 0x00C8 for sim/ELF. We=20 + represent the breakpoint in little endian format since CR16 + supports only little endian. */ + tdep->breakpoint =3D breakpoint_uclinux; + +} + +/* Provide a prototype to silence -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_cr16_linux_tdep; + +void +_initialize_cr16_linux_tdep (void) +{ + gdbarch_register_osabi (bfd_arch_cr16, 0, GDB_OSABI_LINUX, + cr16_uclinux_init_abi); +} --- ./gdb_src.orig/gdb/cr16-tdep.c 1970-01-01 05:30:00.000000000 +0530 +++ ./gdb_src/gdb/cr16-tdep.c 2012-10-09 18:47:25.000000000 +0530 @@ -0,0 +1,915 @@ +/* Target-dependent code for the Sitel CR16 for GDB, the GNU debugger. +=20 + Copyright (C) 2012 Free Software Foundation, Inc. +=20 + Contributed by Kaushik Phatak (kaushik.pahatk@kpitcummins.com) + KPIT Cummins Infosystems Limited, Pune India. + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. +=20 + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. +=20 + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "defs.h" +#include "arch-utils.h" +#include "prologue-value.h" +#include "target.h" +#include "regcache.h" +#include "opcode/cr16.h" +#include "dis-asm.h" +#include "gdbtypes.h" +#include "frame.h" +#include "frame-unwind.h" +#include "frame-base.h" +#include "value.h" +#include "gdbcore.h" +#include "dwarf2-frame.h" +#include "gdb/sim-cr16.h" +#include "elf/cr16.h" +#include "elf-bfd.h" +#include "linux-tdep.h" +#include "osabi.h" +#include "cr16-tdep.h" + +/* Number of registers available for ELF targets. */ +#define CR16_NUM_REGS 22 + +/* The breakpoint instruction used with sim for ELF targets. */ +static const gdb_byte breakpoint_elf[] =3D { 0xC8, 0x00 }; + +/* Data type to store instruction opcodes. */ +typedef unsigned short wordU; + +/* Globals to store opcode related information. */ +wordU words[3]; +ULONGLONG allWords; +ins currInsn; + +/* Certain important register numbers. */ +enum +{ + CR16_R0_REGNUM =3D 0, + CR16_R7_REGNUM =3D 7, + CR16_R12_REGNUM =3D 12, + CR16_FP_REGNUM =3D 13, + CR16_RA_REGNUM =3D 14, + CR16_SP_REGNUM =3D 15, + CR16_PC_REGNUM =3D 16, +}; + +/* This structure holds the results of a prologue analysis. */ +struct cr16_prologue +{ + /* The offset from the frame base to the stack pointer --- always + zero or negative. + + Calling this a "size" is a bit misleading, but given that the + stack grows downwards, using offsets for everything keeps one + from going completely sign-crazy: you never change anything's + sign for an ADD instruction; always change the second operand's + sign for a SUB instruction; and everything takes care of + itself. */ + int frame_size; + + /* Non-zero if this function has initialized the frame pointer from + the stack pointer, zero otherwise. */ + int has_frame_ptr; + + /* If has_frame_ptr is non-zero, this is the offset from the frame + base to where the frame pointer points. This is always zero or + negative. */ + int frame_ptr_offset; + + /* The address of the first instruction at which the frame has been + set up and the arguments are where the debug info says they are + --- as best as we can tell. */ + CORE_ADDR prologue_end; + + /* reg_offset[R] is the offset from the CFA at which register R is + saved, or 1 if register R has not been saved. (Real values are + always zero or negative.) */ + int reg_offset[CR16_NUM_REGS]; +}; + +/* Implement the "register_name" gdbarch method. */ + +static const char * +cr16_register_name (struct gdbarch *gdbarch, int regnr) +{ + static const char *const reg_names[] =3D { + "r0", + "r1", + "r2", + "r3", + "r4", + "r5", + "r6", + "r7", + "r8", + "r9", + "r10", + "r11", + "r12", + "r13", + "ra", + "sp", + "pc", + "isp", + "usp", + "intbase", + "psr", + "cfg" + }; + + return reg_names[regnr]; +} + + +/* Implement the "register_type" gdbarch method. */ + +static struct type * +cr16_register_type (struct gdbarch *gdbarch, int reg_nr) +{ + switch (reg_nr) + { + case CR16_PC_REGNUM: /* Note:PC in CR16 is of 24 bits. */ + return builtin_type (gdbarch)->builtin_func_ptr; + + case CR16_RA_REGNUM: /* Return address reg. */ + return builtin_type (gdbarch)->builtin_data_ptr; + break; + + case CR16_FP_REGNUM: /*Frame Pointer reg. */ + case CR16_SP_REGNUM: /*Stack Pointer reg. */ + return builtin_type (gdbarch)->builtin_data_ptr; + break; + + case SIM_CR16_ISP_REGNUM: + case SIM_CR16_USP_REGNUM: + case SIM_CR16_INTBASE_REGNUM: + return builtin_type (gdbarch)->builtin_int32; + break; + + case SIM_CR16_PSR_REGNUM: + case SIM_CR16_CFG_REGNUM: + return builtin_type (gdbarch)->builtin_uint32; + break; + + case SIM_CR16_R0_REGNUM: + case SIM_CR16_R1_REGNUM: + case SIM_CR16_R2_REGNUM: + case SIM_CR16_R3_REGNUM: + case SIM_CR16_R4_REGNUM: + case SIM_CR16_R5_REGNUM: + case SIM_CR16_R6_REGNUM: + case SIM_CR16_R7_REGNUM: + case SIM_CR16_R8_REGNUM: + case SIM_CR16_R9_REGNUM: + case SIM_CR16_R10_REGNUM: + case SIM_CR16_R11_REGNUM: + return builtin_type (gdbarch)->builtin_int16; + break; + + case SIM_CR16_R12_REGNUM: + return builtin_type (gdbarch)->builtin_int32; + break; + + default: + printf + ("\nRegister Type not supported\nFunction : cr16_register_type\n"); + return 0; + break; + } +} + +/* Function for finding saved registers in a 'struct pv_area'; this + function is passed to pv_area_scan. +=20 + If VALUE is a saved register, ADDR says it was saved at a constant + offset from the frame base, and SIZE indicates that the whole + register was saved, record its offset. */ + +static void +check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t val= ue) +{ + struct cr16_prologue *result =3D (struct cr16_prologue *) result_untyped; + + if (value.kind =3D=3D pvk_register + && value.k =3D=3D 0 + && pv_is_register (addr, CR16_SP_REGNUM) + && size =3D=3D register_size (target_gdbarch, value.reg)) + result->reg_offset[value.reg] =3D addr.k; +} + +/* Define a "handle" struct for fetching the next opcode. */ + +struct cr16_get_opcode_byte_handle +{ + CORE_ADDR pc; +}; + +/* Analyze a prologue starting at START_PC, going no further than + LIMIT_PC. Fill in RESULT as appropriate. */ + +static void +cr16_analyze_prologue (CORE_ADDR start_pc, + CORE_ADDR limit_pc, struct cr16_prologue *result) +{ + CORE_ADDR pc, next_pc; + gdb_byte buf[6]; + char insn_byte1, insn_byte2; + int rn; + int length; + pv_t reg[CR16_NUM_REGS]; + struct pv_area *stack; + struct cleanup *back_to; + CORE_ADDR after_last_frame_setup_insn =3D start_pc; + int is_decoded; + + memset (result, 0, sizeof (*result)); + + for (rn =3D 0; rn < CR16_NUM_REGS; rn++) + { + reg[rn] =3D pv_register (rn, 0); + result->reg_offset[rn] =3D 1; + } + + stack =3D make_pv_area (CR16_SP_REGNUM, gdbarch_addr_bit (target_gdbarch= )); + back_to =3D make_cleanup_free_pv_area (stack); + + pc =3D start_pc; + while (pc < limit_pc) + { + /* Read 6 bytes, max 48 bit opcode. */ + target_read_memory (pc, buf, 6); + words[0] =3D buf[1] << 8 | buf[0]; + words[1] =3D buf[3] << 8 | buf[2]; + words[2] =3D buf[5] << 8 | buf[4]; + allWords =3D + ((ULONGLONG) words[0] << 32) + ((unsigned long) words[1] << 16) + + words[2]; + + /* Find a matching opcode in table.=20=20 + Nonzero means instruction has a match. */ + is_decoded =3D match_opcode (); + make_instruction (); + length =3D currInsn.size; + next_pc =3D pc + length; + insn_byte1 =3D (words[0] >> 8) & 0xFF; + + /* If PUSH, then save RA and other regs. */ + if (insn_byte1 =3D=3D 0x01) + { + int r1, r2; + int r; + insn_byte2 =3D words[0]; + + if (insn_byte2 & 0x80) + { + reg[CR16_SP_REGNUM] =3D pv_add_constant (reg[CR16_SP_REGNUM], -4); + pv_area_store (stack, reg[CR16_SP_REGNUM], 4, + reg[CR16_RA_REGNUM]); + } + /* Start Register=3Dr1, 3 bit imm count=3Dr2. */ + r1 =3D insn_byte2 & 0x0F; + r2 =3D ((insn_byte2 & 0x70) >> 4); + r2 =3D r2 + r1 + 1; + + for (r =3D r1; r < r2; r++) + { + if (r >=3D CR16_R12_REGNUM) + { + reg[CR16_SP_REGNUM] =3D + pv_add_constant (reg[CR16_SP_REGNUM], -4); + pv_area_store (stack, reg[CR16_SP_REGNUM], 4, reg[r]); + r++; + } + else + { + reg[CR16_SP_REGNUM] =3D + pv_add_constant (reg[CR16_SP_REGNUM], -2); + pv_area_store (stack, reg[CR16_SP_REGNUM], 2, reg[r]); + } + } + after_last_frame_setup_insn =3D next_pc; + } + /* Add constant to SP. */ + else if (insn_byte1 =3D=3D 0x60) + { + int rdst; + signed short addend; + insn_byte2 =3D words[0]; + rdst =3D insn_byte2 & 0x0F; + if (rdst =3D=3D CR16_SP_REGNUM) + { + if (length =3D=3D 2) + { + addend =3D (insn_byte2 & 0xF0) >> 4; + reg[rdst] =3D pv_add_constant (reg[rdst], addend); + } + if (length =3D=3D 4) + { + addend =3D words[1]; + reg[rdst] =3D pv_add_constant (reg[rdst], addend); + } + after_last_frame_setup_insn =3D next_pc; + } + } + /* Check for MOVD insn. */ + else if (insn_byte1 =3D=3D 0x55) + { + int rdst, rsrc; + insn_byte2 =3D words[0]; + rsrc =3D (insn_byte2 & 0xF0) >> 4; + rdst =3D (insn_byte2 & 0x0F); + reg[rdst] =3D reg[rsrc]; + if (rsrc =3D=3D CR16_SP_REGNUM && rdst =3D=3D CR16_FP_REGNUM) + after_last_frame_setup_insn =3D next_pc; + } + else if (((insn_byte1 >> 4) & 0x0F) =3D=3D 0xd) + { + /* This moves an argument register to the stack. Don't + record it, but allow it to be a part of the prologue. */ + after_last_frame_setup_insn =3D next_pc; + } + else + { + break; /* Terminate the prologue scan. */ + } + + pc =3D next_pc; + } + + /* Is the frame size (offset, really) a known constant? */ + if (pv_is_register (reg[CR16_SP_REGNUM], CR16_SP_REGNUM)) + result->frame_size =3D reg[CR16_SP_REGNUM].k; + + /* Was the frame pointer initialized? */ + if (pv_is_register (reg[CR16_FP_REGNUM], CR16_SP_REGNUM)) + { + result->has_frame_ptr =3D 1; + result->frame_ptr_offset =3D reg[CR16_FP_REGNUM].k; + } + + /* Record where all the registers were saved. */ + pv_area_scan (stack, check_for_saved, (void *) result); + + result->prologue_end =3D after_last_frame_setup_insn; + do_cleanups (back_to); +} + + +/* Implement the "skip_prologue" gdbarch method. */ + +static CORE_ADDR +cr16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + const char *name; + CORE_ADDR func_addr, func_end; + struct cr16_prologue p; + + /* Try to find the extent of the function that contains PC. */ + if (!find_pc_partial_function (pc, &name, &func_addr, &func_end)) + return pc; + + cr16_analyze_prologue (pc, func_end, &p); + return p.prologue_end; +} + +/* Given a frame described by THIS_FRAME, decode the prologue of its + associated function if there is not cache entry as specified by + THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and + return that struct as the value of this function. */ + +static struct cr16_prologue * +cr16_analyze_frame_prologue (struct frame_info *this_frame, + void **this_prologue_cache) +{ + if (!*this_prologue_cache) + { + CORE_ADDR func_start, stop_addr; + + *this_prologue_cache =3D FRAME_OBSTACK_ZALLOC (struct cr16_prologue); + + func_start =3D get_frame_func (this_frame); + stop_addr =3D get_frame_pc (this_frame); + + /* If we couldn't find any function containing the PC, then + just initialize the prologue cache, but don't do anything. */ + if (!func_start) + stop_addr =3D func_start; + + cr16_analyze_prologue (func_start, stop_addr, *this_prologue_cache); + } + + return *this_prologue_cache; +} + +/* Given the next frame and a prologue cache, return this frame's + base. */ + +static CORE_ADDR +cr16_frame_base (struct frame_info *this_frame, void **this_prologue_cache) +{ + struct cr16_prologue *p + =3D cr16_analyze_frame_prologue (this_frame, this_prologue_cache); + + /* In functions that use alloca, the distance between the stack + pointer and the frame base varies dynamically, so we can't use + the SP plus static information like prologue analysis to find the + frame base. However, such functions must have a frame pointer, + to be able to restore the SP on exit. So whenever we do have a + frame pointer, use that to find the base. */ + if (p->has_frame_ptr) + { + CORE_ADDR fp =3D get_frame_register_unsigned (this_frame, CR16_FP_RE= GNUM); + return fp - p->frame_ptr_offset; + } + else + { + CORE_ADDR sp =3D get_frame_register_unsigned (this_frame, CR16_SP_RE= GNUM); + return sp - p->frame_size; + } +} + +/* Implement the "frame_this_id" method for unwinding frames. */ + +static void +cr16_frame_this_id (struct frame_info *this_frame, + void **this_prologue_cache, struct frame_id *this_id) +{ + *this_id =3D + frame_id_build (cr16_frame_base (this_frame, this_prologue_cache), + get_frame_func (this_frame)); +} + +/* Implement the "frame_prev_register" method for unwinding frames. */ + +static struct value * +cr16_frame_prev_register (struct frame_info *this_frame, + void **this_prologue_cache, int regnum) +{ + struct cr16_prologue *p =3D + cr16_analyze_frame_prologue (this_frame, this_prologue_cache); + CORE_ADDR frame_base =3D cr16_frame_base (this_frame, this_prologue_cach= e); + int reg_size =3D register_size (get_frame_arch (this_frame), regnum); + ULONGEST ra_prev; + + if (regnum =3D=3D CR16_SP_REGNUM) + return frame_unwind_got_constant (this_frame, regnum, frame_base); + + /* The call instruction has saved the return address on the RA=20 + register, CR16_R13_REGNUM. So, we need not adjust anything + directly. We will analyze prologue as this RA register is + pushed onto stack for further leaf function calls to work. */ + else if (regnum =3D=3D CR16_PC_REGNUM) + { + ra_prev =3D frame_unwind_register_unsigned (this_frame, CR16_RA_REGN= UM); + ra_prev =3D ra_prev << 1; + return frame_unwind_got_constant (this_frame, CR16_PC_REGNUM, ra_pre= v); + } + + /* If prologue analysis says we saved this register somewhere, + return a description of the stack slot holding it. */ + else if (p->reg_offset[regnum] !=3D 1) + { + return frame_unwind_got_memory (this_frame, regnum, + frame_base + p->reg_offset[regnum]); + } + + /* Otherwise, presume we haven't changed the value of this + register, and get it from the next frame. */ + else + { + return frame_unwind_got_register (this_frame, regnum, regnum); + } +} + +static const struct frame_unwind cr16_frame_unwind =3D=20 +{ + NORMAL_FRAME, + default_frame_unwind_stop_reason, + cr16_frame_this_id, + cr16_frame_prev_register, + NULL, + default_frame_sniffer +}; + +/* Implement the "unwind_pc" gdbarch method. */ + +static CORE_ADDR +cr16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame) +{ + ULONGEST pc; + + pc =3D frame_unwind_register_unsigned (this_frame, CR16_PC_REGNUM); + return pc; +} + +/* Implement the "unwind_sp" gdbarch method. */ + +static CORE_ADDR +cr16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame) +{ + ULONGEST sp; + + sp =3D frame_unwind_register_unsigned (this_frame, CR16_SP_REGNUM); + return sp; +} + +/* Implement the "dummy_id" gdbarch method. */ + +static struct frame_id +cr16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) +{ + return + frame_id_build (get_frame_register_unsigned (this_frame, CR16_SP_REGNU= M), + get_frame_pc (this_frame)); +} + +/* Implement the "push_dummy_call" gdbarch method. */ + +static CORE_ADDR +cr16_push_dummy_call (struct gdbarch *gdbarch, struct value *function, + struct regcache *regcache, CORE_ADDR bp_addr, int nargs, + struct value **args, CORE_ADDR sp, int struct_return, + CORE_ADDR struct_addr) +{ + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + int write_pass; + int sp_off =3D 0; + CORE_ADDR cfa; + int num_register_candidate_args; + + struct type *func_type =3D value_type (function); + + /* Dereference function pointer types. */ + while (TYPE_CODE (func_type) =3D=3D TYPE_CODE_PTR) + func_type =3D TYPE_TARGET_TYPE (func_type); + + /* The end result had better be a function or a method. */ + gdb_assert (TYPE_CODE (func_type) =3D=3D TYPE_CODE_FUNC + || TYPE_CODE (func_type) =3D=3D TYPE_CODE_METHOD); + + /* Functions with a variable number of arguments have all of their + variable arguments and the last non-variable argument passed + on the stack. + + Otherwise, we can pass up to four arguments on the stack. + + Once computed, we leave this value alone. I.e. we don't update + it in case of a struct return going in a register or an argument + requiring multiple registers, etc. We rely instead on the value + of the ``arg_reg'' variable to get these other details correct. */ + + if (TYPE_VARARGS (func_type)) + num_register_candidate_args =3D TYPE_NFIELDS (func_type) - 1; + else + num_register_candidate_args =3D 4; + + /* We make two passes; the first does the stack allocation, + the second actually stores the arguments. */ + for (write_pass =3D 0; write_pass <=3D 1; write_pass++) + { + int i; + int arg_reg =3D CR16_R0_REGNUM; + + if (write_pass) + sp =3D align_down (sp - sp_off, 4); + sp_off =3D 0; + + if (struct_return) + { + struct type *return_type =3D TYPE_TARGET_TYPE (func_type); + + gdb_assert (TYPE_CODE (return_type) =3D=3D TYPE_CODE_STRUCT + || TYPE_CODE (func_type) =3D=3D TYPE_CODE_UNION); + + if (TYPE_LENGTH (return_type) > 16 + || TYPE_LENGTH (return_type) % 4 !=3D 0) + { + if (write_pass) + regcache_cooked_write_unsigned (regcache, CR16_R12_REGNUM, + struct_addr); + } + } + + /* Push the arguments. */ + for (i =3D 0; i < nargs; i++) + { + struct value *arg =3D args[i]; + const gdb_byte *arg_bits =3D value_contents_all (arg); + struct type *arg_type =3D check_typedef (value_type (arg)); + ULONGEST arg_size =3D TYPE_LENGTH (arg_type); + + if (i =3D=3D 0 && struct_addr !=3D 0 && !struct_return + && TYPE_CODE (arg_type) =3D=3D TYPE_CODE_PTR + && extract_unsigned_integer (arg_bits, 4, + byte_order) =3D=3D struct_addr) + { + /* This argument represents the address at which C++ (and + possibly other languages) store their return value. + Put this value in R12. */ + if (write_pass) + regcache_cooked_write_unsigned (regcache, CR16_R12_REGNUM, + struct_addr); + } + else if (TYPE_CODE (arg_type) !=3D TYPE_CODE_STRUCT + && TYPE_CODE (arg_type) !=3D TYPE_CODE_UNION) + { + /* Argument is a scalar. */ + if (arg_size =3D=3D 8) + { + if (i < num_register_candidate_args + && arg_reg <=3D CR16_R7_REGNUM - 1) + { + /* If argument registers are going to be used to pass + an 8 byte scalar, the ABI specifies that two registers + must be available. */ + if (write_pass) + { + regcache_cooked_write_unsigned (regcache, arg_reg, + extract_unsigned_integer + (arg_bits, 4, + byte_order)); + regcache_cooked_write_unsigned (regcache, + arg_reg + 1, + extract_unsigned_integer + (arg_bits + 4, 4, + byte_order)); + } + arg_reg +=3D 2; + } + else + { + sp_off =3D align_up (sp_off, 4); + /* Otherwise, pass the 8 byte scalar on the stack. */ + if (write_pass) + write_memory (sp + sp_off, arg_bits, 8); + sp_off +=3D 8; + } + } + else + { + ULONGEST u; + + gdb_assert (arg_size <=3D 4); + + u =3D + extract_unsigned_integer (arg_bits, arg_size, byte_order); + + if (i < num_register_candidate_args + && arg_reg <=3D CR16_R7_REGNUM) + { + if (write_pass) + regcache_cooked_write_unsigned (regcache, arg_reg, u); + arg_reg +=3D 1; + } + else + { + int p_arg_size =3D 4; + + if (TYPE_PROTOTYPED (func_type) + && i < TYPE_NFIELDS (func_type)) + { + struct type *p_arg_type =3D + TYPE_FIELD_TYPE (func_type, i); + p_arg_size =3D TYPE_LENGTH (p_arg_type); + } + + sp_off =3D align_up (sp_off, p_arg_size); + + if (write_pass) + write_memory_unsigned_integer (sp + sp_off, + p_arg_size, byte_order, + u); + sp_off +=3D p_arg_size; + } + } + } + else + { + /* Argument is a struct or union. Pass as much of the struct + in registers, as possible. Pass the rest on the stack. */ + while (arg_size > 0) + { + if (i < num_register_candidate_args + && arg_reg <=3D CR16_R7_REGNUM + && arg_size <=3D 4 * (CR16_R7_REGNUM - arg_reg + 1) + && arg_size % 4 =3D=3D 0) + { + int len =3D min (arg_size, 4); + + if (write_pass) + regcache_cooked_write_unsigned (regcache, arg_reg, + extract_unsigned_integer + (arg_bits, len, + byte_order)); + arg_bits +=3D len; + arg_size -=3D len; + arg_reg++; + } + else + { + sp_off =3D align_up (sp_off, 4); + if (write_pass) + write_memory (sp + sp_off, arg_bits, arg_size); + sp_off +=3D align_up (arg_size, 4); + arg_size =3D 0; + } + } + } + } + } + + /* Keep track of the stack address prior to pushing the return address. + This is the value that we'll return. */ + cfa =3D sp; + + /* Push the return address. */ + sp =3D sp - 4; + write_memory_unsigned_integer (sp, 4, byte_order, bp_addr); + + /* Update the stack pointer. */ + regcache_cooked_write_unsigned (regcache, CR16_SP_REGNUM, sp); + + return cfa; +} + +/* Implement the "return_value" gdbarch method. */ + +static enum return_value_convention +cr16_return_value (struct gdbarch *gdbarch, + struct type *func_type, + struct type *valtype, + struct regcache *regcache, + gdb_byte * readbuf, const gdb_byte * writebuf) +{ + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + ULONGEST valtype_len =3D TYPE_LENGTH (valtype); + + if (TYPE_LENGTH (valtype) > 16 + || ((TYPE_CODE (valtype) =3D=3D TYPE_CODE_STRUCT + || TYPE_CODE (valtype) =3D=3D TYPE_CODE_UNION) + && TYPE_LENGTH (valtype) % 4 !=3D 0)) + return RETURN_VALUE_STRUCT_CONVENTION; + + if (readbuf) + { + ULONGEST u; + int argreg =3D CR16_R0_REGNUM; + int offset =3D 0; + + while (valtype_len > 0) + { + int len =3D min (valtype_len, 4); + + regcache_cooked_read_unsigned (regcache, argreg, &u); + store_unsigned_integer (readbuf + offset, len, byte_order, u); + valtype_len -=3D len; + offset +=3D len; + argreg++; + } + } + + if (writebuf) + { + ULONGEST u; + int argreg =3D CR16_R0_REGNUM; + int offset =3D 0; + + while (valtype_len > 0) + { + int len =3D min (valtype_len, 4); + + u =3D extract_unsigned_integer (writebuf + offset, len, byte_order); + regcache_cooked_write_unsigned (regcache, argreg, u); + valtype_len -=3D len; + offset +=3D len; + argreg++; + } + } + + return RETURN_VALUE_REGISTER_CONVENTION; +} + +/* Implement the "breakpoint_from_pc" gdbarch method. */ + +static const gdb_byte * +cr16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, + int *lenptr) +{ + /* We use different breakpoint instructions for ELF and uClinux. + See cr16-linux-tdep.c for more details. */ + struct gdbarch_tdep *tdep =3D gdbarch_tdep (gdbarch); + *lenptr =3D 2; + if (tdep =3D=3D NULL || tdep->breakpoint =3D=3D NULL) + { + return breakpoint_elf; + } + return tdep->breakpoint; +} + +/* Allocate and initialize a gdbarch object. */ + +static struct gdbarch * +cr16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) +{ + struct gdbarch *gdbarch; + struct gdbarch_tdep *tdep; + int elf_flags; + + /* Extract the elf_flags if available. */ + if (info.abfd !=3D NULL + && bfd_get_flavour (info.abfd) =3D=3D bfd_target_elf_flavour) + elf_flags =3D elf_elfheader (info.abfd)->e_flags; + else + elf_flags =3D 0; + + /* Try to find the architecture in the list of already defined + architectures. */ + for (arches =3D gdbarch_list_lookup_by_info (arches, &info); + arches !=3D NULL; + arches =3D gdbarch_list_lookup_by_info (arches->next, &info)) + { + if (gdbarch_tdep (arches->gdbarch)->elf_flags !=3D elf_flags) + continue; + + return arches->gdbarch; + } + /* None found, create a new architecture from the information + provided. */ + tdep =3D (struct gdbarch_tdep *) xcalloc (1, sizeof (struct gdbarch_tdep= )); + tdep->elf_flags =3D elf_flags; + gdbarch =3D gdbarch_alloc (&info, tdep); + + set_gdbarch_num_pseudo_regs (gdbarch, 0); + set_gdbarch_num_regs (gdbarch, CR16_NUM_REGS); + set_gdbarch_register_name (gdbarch, cr16_register_name); + set_gdbarch_register_type (gdbarch, cr16_register_type); + set_gdbarch_pc_regnum (gdbarch, CR16_PC_REGNUM); + set_gdbarch_sp_regnum (gdbarch, CR16_SP_REGNUM); + set_gdbarch_inner_than (gdbarch, core_addr_lessthan); + set_gdbarch_decr_pc_after_break (gdbarch, 2); + set_gdbarch_breakpoint_from_pc (gdbarch, cr16_breakpoint_from_pc); + set_gdbarch_skip_prologue (gdbarch, cr16_skip_prologue); + + /* Passing NULL values in the following two functions + for the time being, to fix later. */ + set_gdbarch_print_insn (gdbarch, print_insn_cr16); + set_gdbarch_unwind_pc (gdbarch, cr16_unwind_pc); + set_gdbarch_unwind_sp (gdbarch, cr16_unwind_sp); + + /* Methods for saving / extracting a dummy frame's ID. + The ID's stack address must match the SP value returned by + PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ + set_gdbarch_dummy_id (gdbarch, cr16_dummy_id); + set_gdbarch_push_dummy_call (gdbarch, cr16_push_dummy_call); + /* Target builtin data types. */ + set_gdbarch_char_signed (gdbarch, 8); + set_gdbarch_short_bit (gdbarch, 16); + + /* If we don't pass the option -mint32 + FIXME: add if else case depending on the option passed, + sp that we can have int size as 16 or 32 bits both. */ + set_gdbarch_int_bit (gdbarch, 16); + set_gdbarch_long_bit (gdbarch, 32); + set_gdbarch_long_long_bit (gdbarch, 64); + set_gdbarch_float_bit (gdbarch, 32); + + set_gdbarch_ptr_bit (gdbarch, 32); + set_gdbarch_float_format (gdbarch, floatformats_ieee_single); + set_gdbarch_double_bit (gdbarch, 64); + set_gdbarch_long_double_bit (gdbarch, 64); + set_gdbarch_double_format (gdbarch, floatformats_ieee_double); + set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double); + + frame_unwind_append_unwinder (gdbarch, &cr16_frame_unwind); + set_gdbarch_return_value (gdbarch, cr16_return_value); + + /* Hook in ABI-specific overrides, if they have been registered. */ + gdbarch_init_osabi (info, gdbarch); + + return gdbarch; + +} + +/* -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_cr16_tdep; + +/* Register the above initialization routine. */ + +void +_initialize_cr16_tdep (void) +{ + register_gdbarch_init (bfd_arch_cr16, cr16_gdbarch_init); +} --- ./gdb_src.orig/gdb/cr16-tdep.h 1970-01-01 05:30:00.000000000 +0530 +++ ./gdb_src/gdb/cr16-tdep.h 2012-10-09 18:48:38.000000000 +0530 @@ -0,0 +1,32 @@ +/* GNU/Linux on CR16 target support. + Copyright (C) 2012 Free Software Foundation, Inc. + + Contributed by Kaushik Phatak (kaushik.pahatk@kpitcummins.com) + KPIT Cummins Infosystems Limited, Pune India. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . = */ + + +/* Target-dependent structure in gdbarch. */ + +struct gdbarch_tdep +{ + /* The ELF header flags specify the multilib used. */ + int elf_flags; + + /* Breakpoint instruction. */ + const gdb_byte *breakpoint; +}; --_002_C6CA53A2A46BA7469348BDBD663AB65845B39A2FKCHJEXMB02kpitc_ Content-Type: application/octet-stream; name="cr16_gdb.diff" Content-Description: cr16_gdb.diff Content-Disposition: attachment; filename="cr16_gdb.diff"; size=32230; creation-date="Tue, 09 Oct 2012 13:42:12 GMT"; modification-date="Tue, 09 Oct 2012 13:43:15 GMT" Content-Transfer-Encoding: base64 Content-length: 43693 LS0tIC4vZ2RiX3NyYy5vcmlnL2dkYi9jb25maWd1cmUudGd0CTIwMTItMDgt MDIgMDE6MTg6NDQuMDAwMDAwMDAwICswNTMwCisrKyAuL2dkYl9zcmMvZ2Ri L2NvbmZpZ3VyZS50Z3QJMjAxMi0xMC0wOSAxOToxMjo1NC4wMDAwMDAwMDAg KzA1MzAKQEAgLTExNiw2ICsxMTYsMTggQEAgYmZpbi0qLSopCiAJZ2RiX3Np bT0uLi9zaW0vYmZpbi9saWJzaW0uYQogCTs7CiAKK2NyMTYqLSotKmxpbnV4 KQorCSMgVGFyZ2V0OiBDUjE2IHByb2Nlc3NvcgorCWdkYl90YXJnZXRfb2Jz PSJjcjE2LXRkZXAubyBjcjE2LWxpbnV4LXRkZXAubyBsaW51eC10ZGVwLm8i CisJZ2RiX3NpbT0uLi9zaW0vY3IxNi9saWJzaW0uYQorCTs7CisKK2NyMTYq LSotKikKKwkjIFRhcmdldDogQ1IxNiBwcm9jZXNzb3IKKwlnZGJfdGFyZ2V0 X29icz0iY3IxNi10ZGVwLm8iCisJZ2RiX3NpbT0uLi9zaW0vY3IxNi9saWJz aW0uYQorCTs7CisKIGNyaXMqKQogCSMgVGFyZ2V0OiBDUklTCiAJZ2RiX3Rh cmdldF9vYnM9ImNyaXMtdGRlcC5vIHNvbGliLXN2cjQubyIKLS0tIC4vZ2Ri X3NyYy5vcmlnL2dkYi9jcjE2LWxpbnV4LXRkZXAuYwkxOTcwLTAxLTAxIDA1 OjMwOjAwLjAwMDAwMDAwMCArMDUzMAorKysgLi9nZGJfc3JjL2dkYi9jcjE2 LWxpbnV4LXRkZXAuYwkyMDEyLTEwLTA5IDE3OjMwOjIxLjAwMDAwMDAwMCAr MDUzMApAQCAtMCwwICsxLDEwMiBAQAorLyogVGFyZ2V0LWRlcGVuZGVudCBj b2RlIGZvciBHTlUvTGludXggb24gdGhlIFNpdGVsIENSMTYgcHJvY2Vzc29y cy4KKworICAgQ29weXJpZ2h0IDIwMTIgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuCisKKyAgIENvbnRyaWJ1dGVkIGJ5IEthdXNoaWsgUGhhdGFr IChrYXVzaGlrLnBhaGF0a0BrcGl0Y3VtbWlucy5jb20pCisgICBLUElUIEN1 bW1pbnMgSW5mb3N5c3RlbXMgTGltaXRlZCwgUHVuZSBJbmRpYS4KKworICAg VGhpcyBmaWxlIGlzIHBhcnQgb2YgR0RCLgorCisgICBUaGlzIHByb2dyYW0g aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yIG1vZGlmeQorICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMg b2YgdGhlIExpY2Vuc2UsIG9yCisgICAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorCisgICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgICBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisg ICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHBy b2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vu c2VzLz4uICAqLworCisjaW5jbHVkZSAiZGVmcy5oIgorI2luY2x1ZGUgIm9z YWJpLmgiCisjaW5jbHVkZSAiZWxmLWJmZC5oIgorI2luY2x1ZGUgImVsZi9j cjE2LmgiCisjaW5jbHVkZSAibGludXgtdGRlcC5oIgorI2luY2x1ZGUgInNv bGliLXN2cjQuaCIKKyNpbmNsdWRlICJzeW10YWIuaCIKKyNpbmNsdWRlICJj cjE2LXRkZXAuaCIKKworLyogTnVtYmVyIG9mIHJlZ2lzdGVycyBhdmFpbGFi bGUgZm9yIExpbnV4IHRhcmdldHMgICovCisjZGVmaW5lIENSMTZfTElOVVhf TlVNX1JFR1MgIDIxCisKKy8qIFRoZSBicmVha3BvaW50IGluc3RydWN0aW9u IHVzZWQgYnkgdUNsaW51eCB0YXJnZXQgICovCitzdGF0aWMgY29uc3QgZ2Ri X2J5dGUgYnJlYWtwb2ludF91Y2xpbnV4W10gPSB7IDB4QzcsIDB4MDAgfTsK KworLyogSW1wbGVtZW50IHRoZSAicmVnaXN0ZXJfbmFtZSIgZ2RiYXJjaCBt ZXRob2QuICAqLworCitzdGF0aWMgY29uc3QgY2hhciAqCitjcjE2X2xpbnV4 X3JlZ2lzdGVyX25hbWUgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBpbnQg cmVnbnIpCit7CisgIHN0YXRpYyBjb25zdCBjaGFyICpjb25zdCByZWdfbmFt ZXNbXSA9IHsKKyAgICAicjAiLAorICAgICJyMSIsCisgICAgInIyIiwKKyAg ICAicjMiLAorICAgICJyNCIsCisgICAgInI1IiwKKyAgICAicjYiLAorICAg ICJyNyIsCisgICAgInI4IiwKKyAgICAicjkiLAorICAgICJyMTAiLAorICAg ICJyMTEiLAorICAgICJyMTIiLAorICAgICJyMTMiLAorICAgICJyYSIsCisg ICAgInBzciIsCisgICAgInBjIiwKKyAgICAicjByMV9vcmlnIiwKKyAgICAi aW50YmFzZSIsCisgICAgInVzcCIsCisgICAgImNmZyIKKyAgfTsKKworICBy ZXR1cm4gcmVnX25hbWVzW3JlZ25yXTsKK30KKworLyogT1Mgc3BlY2lmaWMg aW5pdGlhbGl6YXRpb24gb2YgZ2RiYXJjaC4gICovCisKK3N0YXRpYyB2b2lk CitjcjE2X3VjbGludXhfaW5pdF9hYmkgKHN0cnVjdCBnZGJhcmNoX2luZm8g aW5mbywgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gpCit7CisgIHN0cnVjdCBn ZGJhcmNoX3RkZXAgKnRkZXAgPSBnZGJhcmNoX3RkZXAgKGdkYmFyY2gpOwor CisgIGxpbnV4X2luaXRfYWJpIChpbmZvLCBnZGJhcmNoKTsKKworICBzZXRf Z2RiYXJjaF9udW1fcmVncyAoZ2RiYXJjaCwgQ1IxNl9MSU5VWF9OVU1fUkVH Uyk7CisgIHNldF9nZGJhcmNoX3JlZ2lzdGVyX25hbWUgKGdkYmFyY2gsIGNy MTZfbGludXhfcmVnaXN0ZXJfbmFtZSk7CisKKyAgLyogVGhlIG9wY29kZSBv ZiBleGNwIGJwdCBpcyAweDAwQzgsIGhvd2V2ZXIgZm9yIHVjbGludXggd2Ug d2lsbAorICAgICB1c2UgdGhlIGV4Y3AgZmxnICgweDAwQzcpIHRvIGluc2Vy dCBhIGJyZWFrcG9pbnQuICBUaGUgZXhjcCBicHQKKyAgICAgcmVxdWlyZXMg ZXh0ZXJuYWwgaGFyZHdhcmUgc3VwcG9ydCBmb3IgYnJlYWtwb2ludHMgdG8g d29yayBvbgorICAgICBDUjE2IHRhcmdldC4gIFNvZnR3YXJlIGJhc2VkIGJy ZWFrcG9pbnRzIGFyZSBpbXBsZW1lbnRlZCBpbiB0aGUKKyAgICAga2VybmVs IHVzaW5nIGV4Y3AgZmxnIGFuZCB0ZXN0ZWQgb24gdGhlIFNDMTQ0NTIgdGFy Z2V0LiAgVXNlCisgICAgIDB4MDBDNyB3aXRoIGdkYnNlcnZlci9rZXJuZWwg YW5kIDB4MDBDOCBmb3Igc2ltL0VMRi4gIFdlIAorICAgICByZXByZXNlbnQg dGhlIGJyZWFrcG9pbnQgaW4gbGl0dGxlIGVuZGlhbiBmb3JtYXQgc2luY2Ug Q1IxNgorICAgICBzdXBwb3J0cyBvbmx5IGxpdHRsZSBlbmRpYW4uICAqLwor ICB0ZGVwLT5icmVha3BvaW50ID0gYnJlYWtwb2ludF91Y2xpbnV4OworCit9 CisKKy8qIFByb3ZpZGUgYSBwcm90b3R5cGUgdG8gc2lsZW5jZSAtV21pc3Np bmctcHJvdG90eXBlcy4gICovCitleHRlcm4gaW5pdGlhbGl6ZV9maWxlX2Z0 eXBlIF9pbml0aWFsaXplX2NyMTZfbGludXhfdGRlcDsKKwordm9pZAorX2lu aXRpYWxpemVfY3IxNl9saW51eF90ZGVwICh2b2lkKQoreworICBnZGJhcmNo X3JlZ2lzdGVyX29zYWJpIChiZmRfYXJjaF9jcjE2LCAwLCBHREJfT1NBQklf TElOVVgsCisJCQkgIGNyMTZfdWNsaW51eF9pbml0X2FiaSk7Cit9Ci0tLSAu L2dkYl9zcmMub3JpZy9nZGIvY3IxNi10ZGVwLmMJMTk3MC0wMS0wMSAwNToz MDowMC4wMDAwMDAwMDAgKzA1MzAKKysrIC4vZ2RiX3NyYy9nZGIvY3IxNi10 ZGVwLmMJMjAxMi0xMC0wOSAxODo0NzoyNS4wMDAwMDAwMDAgKzA1MzAKQEAg LTAsMCArMSw5MTUgQEAKKy8qIFRhcmdldC1kZXBlbmRlbnQgY29kZSBmb3Ig dGhlIFNpdGVsIENSMTYgZm9yIEdEQiwgdGhlIEdOVSBkZWJ1Z2dlci4KKyAK KyAgIENvcHlyaWdodCAoQykgMjAxMiBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b24sIEluYy4KKyAKKyAgIENvbnRyaWJ1dGVkIGJ5IEthdXNoaWsgUGhhdGFr IChrYXVzaGlrLnBhaGF0a0BrcGl0Y3VtbWlucy5jb20pCisgICBLUElUIEN1 bW1pbnMgSW5mb3N5c3RlbXMgTGltaXRlZCwgUHVuZSBJbmRpYS4KKyAgIFRo aXMgZmlsZSBpcyBwYXJ0IG9mIEdEQi4KKworICBUaGlzIHByb2dyYW0gaXMg ZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y IG1vZGlmeQorICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRo ZSBMaWNlbnNlLCBvcgorICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorIAorICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICBHTlUgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorIAorICBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZQorICBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElm IG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4gICov CisKKyNpbmNsdWRlICJkZWZzLmgiCisjaW5jbHVkZSAiYXJjaC11dGlscy5o IgorI2luY2x1ZGUgInByb2xvZ3VlLXZhbHVlLmgiCisjaW5jbHVkZSAidGFy Z2V0LmgiCisjaW5jbHVkZSAicmVnY2FjaGUuaCIKKyNpbmNsdWRlICJvcGNv ZGUvY3IxNi5oIgorI2luY2x1ZGUgImRpcy1hc20uaCIKKyNpbmNsdWRlICJn ZGJ0eXBlcy5oIgorI2luY2x1ZGUgImZyYW1lLmgiCisjaW5jbHVkZSAiZnJh bWUtdW53aW5kLmgiCisjaW5jbHVkZSAiZnJhbWUtYmFzZS5oIgorI2luY2x1 ZGUgInZhbHVlLmgiCisjaW5jbHVkZSAiZ2RiY29yZS5oIgorI2luY2x1ZGUg ImR3YXJmMi1mcmFtZS5oIgorI2luY2x1ZGUgImdkYi9zaW0tY3IxNi5oIgor I2luY2x1ZGUgImVsZi9jcjE2LmgiCisjaW5jbHVkZSAiZWxmLWJmZC5oIgor I2luY2x1ZGUgImxpbnV4LXRkZXAuaCIKKyNpbmNsdWRlICJvc2FiaS5oIgor I2luY2x1ZGUgImNyMTYtdGRlcC5oIgorCisvKiBOdW1iZXIgb2YgcmVnaXN0 ZXJzIGF2YWlsYWJsZSBmb3IgRUxGIHRhcmdldHMuICAqLworI2RlZmluZSBD UjE2X05VTV9SRUdTICAyMgorCisvKiBUaGUgYnJlYWtwb2ludCBpbnN0cnVj dGlvbiB1c2VkIHdpdGggc2ltIGZvciBFTEYgdGFyZ2V0cy4gICovCitzdGF0 aWMgY29uc3QgZ2RiX2J5dGUgYnJlYWtwb2ludF9lbGZbXSA9IHsgMHhDOCwg MHgwMCB9OworCisvKiBEYXRhIHR5cGUgdG8gc3RvcmUgaW5zdHJ1Y3Rpb24g b3Bjb2Rlcy4gICovCit0eXBlZGVmIHVuc2lnbmVkIHNob3J0IHdvcmRVOwor CisvKiBHbG9iYWxzIHRvIHN0b3JlIG9wY29kZSByZWxhdGVkIGluZm9ybWF0 aW9uLiAgKi8KK3dvcmRVIHdvcmRzWzNdOworVUxPTkdMT05HIGFsbFdvcmRz OworaW5zIGN1cnJJbnNuOworCisvKiBDZXJ0YWluIGltcG9ydGFudCByZWdp c3RlciBudW1iZXJzLiAgKi8KK2VudW0KK3sKKyAgQ1IxNl9SMF9SRUdOVU0g PSAwLAorICBDUjE2X1I3X1JFR05VTSA9IDcsCisgIENSMTZfUjEyX1JFR05V TSA9IDEyLAorICBDUjE2X0ZQX1JFR05VTSA9IDEzLAorICBDUjE2X1JBX1JF R05VTSA9IDE0LAorICBDUjE2X1NQX1JFR05VTSA9IDE1LAorICBDUjE2X1BD X1JFR05VTSA9IDE2LAorfTsKKworLyogVGhpcyBzdHJ1Y3R1cmUgaG9sZHMg dGhlIHJlc3VsdHMgb2YgYSBwcm9sb2d1ZSBhbmFseXNpcy4gICovCitzdHJ1 Y3QgY3IxNl9wcm9sb2d1ZQoreworICAvKiBUaGUgb2Zmc2V0IGZyb20gdGhl IGZyYW1lIGJhc2UgdG8gdGhlIHN0YWNrIHBvaW50ZXIgLS0tIGFsd2F5cwor ICAgICB6ZXJvIG9yIG5lZ2F0aXZlLgorCisgICAgIENhbGxpbmcgdGhpcyBh ICJzaXplIiBpcyBhIGJpdCBtaXNsZWFkaW5nLCBidXQgZ2l2ZW4gdGhhdCB0 aGUKKyAgICAgc3RhY2sgZ3Jvd3MgZG93bndhcmRzLCB1c2luZyBvZmZzZXRz IGZvciBldmVyeXRoaW5nIGtlZXBzIG9uZQorICAgICBmcm9tIGdvaW5nIGNv bXBsZXRlbHkgc2lnbi1jcmF6eTogeW91IG5ldmVyIGNoYW5nZSBhbnl0aGlu ZydzCisgICAgIHNpZ24gZm9yIGFuIEFERCBpbnN0cnVjdGlvbjsgYWx3YXlz IGNoYW5nZSB0aGUgc2Vjb25kIG9wZXJhbmQncworICAgICBzaWduIGZvciBh IFNVQiBpbnN0cnVjdGlvbjsgYW5kIGV2ZXJ5dGhpbmcgdGFrZXMgY2FyZSBv ZgorICAgICBpdHNlbGYuICAqLworICBpbnQgZnJhbWVfc2l6ZTsKKworICAv KiBOb24temVybyBpZiB0aGlzIGZ1bmN0aW9uIGhhcyBpbml0aWFsaXplZCB0 aGUgZnJhbWUgcG9pbnRlciBmcm9tCisgICAgIHRoZSBzdGFjayBwb2ludGVy LCB6ZXJvIG90aGVyd2lzZS4gICovCisgIGludCBoYXNfZnJhbWVfcHRyOwor CisgIC8qIElmIGhhc19mcmFtZV9wdHIgaXMgbm9uLXplcm8sIHRoaXMgaXMg dGhlIG9mZnNldCBmcm9tIHRoZSBmcmFtZQorICAgICBiYXNlIHRvIHdoZXJl IHRoZSBmcmFtZSBwb2ludGVyIHBvaW50cy4gIFRoaXMgaXMgYWx3YXlzIHpl cm8gb3IKKyAgICAgbmVnYXRpdmUuICAqLworICBpbnQgZnJhbWVfcHRyX29m ZnNldDsKKworICAvKiBUaGUgYWRkcmVzcyBvZiB0aGUgZmlyc3QgaW5zdHJ1 Y3Rpb24gYXQgd2hpY2ggdGhlIGZyYW1lIGhhcyBiZWVuCisgICAgIHNldCB1 cCBhbmQgdGhlIGFyZ3VtZW50cyBhcmUgd2hlcmUgdGhlIGRlYnVnIGluZm8g c2F5cyB0aGV5IGFyZQorICAgICAtLS0gYXMgYmVzdCBhcyB3ZSBjYW4gdGVs bC4gICovCisgIENPUkVfQUREUiBwcm9sb2d1ZV9lbmQ7CisKKyAgLyogcmVn X29mZnNldFtSXSBpcyB0aGUgb2Zmc2V0IGZyb20gdGhlIENGQSBhdCB3aGlj aCByZWdpc3RlciBSIGlzCisgICAgIHNhdmVkLCBvciAxIGlmIHJlZ2lzdGVy IFIgaGFzIG5vdCBiZWVuIHNhdmVkLiAgKFJlYWwgdmFsdWVzIGFyZQorICAg ICBhbHdheXMgemVybyBvciBuZWdhdGl2ZS4pICAqLworICBpbnQgcmVnX29m ZnNldFtDUjE2X05VTV9SRUdTXTsKK307CisKKy8qIEltcGxlbWVudCB0aGUg InJlZ2lzdGVyX25hbWUiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGlj IGNvbnN0IGNoYXIgKgorY3IxNl9yZWdpc3Rlcl9uYW1lIChzdHJ1Y3QgZ2Ri YXJjaCAqZ2RiYXJjaCwgaW50IHJlZ25yKQoreworICBzdGF0aWMgY29uc3Qg Y2hhciAqY29uc3QgcmVnX25hbWVzW10gPSB7CisgICAgInIwIiwKKyAgICAi cjEiLAorICAgICJyMiIsCisgICAgInIzIiwKKyAgICAicjQiLAorICAgICJy NSIsCisgICAgInI2IiwKKyAgICAicjciLAorICAgICJyOCIsCisgICAgInI5 IiwKKyAgICAicjEwIiwKKyAgICAicjExIiwKKyAgICAicjEyIiwKKyAgICAi cjEzIiwKKyAgICAicmEiLAorICAgICJzcCIsCisgICAgInBjIiwKKyAgICAi aXNwIiwKKyAgICAidXNwIiwKKyAgICAiaW50YmFzZSIsCisgICAgInBzciIs CisgICAgImNmZyIKKyAgfTsKKworICByZXR1cm4gcmVnX25hbWVzW3JlZ25y XTsKK30KKworCisvKiBJbXBsZW1lbnQgdGhlICJyZWdpc3Rlcl90eXBlIiBn ZGJhcmNoIG1ldGhvZC4gICovCisKK3N0YXRpYyBzdHJ1Y3QgdHlwZSAqCitj cjE2X3JlZ2lzdGVyX3R5cGUgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBp bnQgcmVnX25yKQoreworICBzd2l0Y2ggKHJlZ19ucikKKyAgICB7CisgICAg Y2FzZSBDUjE2X1BDX1JFR05VTToJLyogTm90ZTpQQyBpbiBDUjE2IGlzIG9m IDI0IGJpdHMuICAqLworICAgICAgcmV0dXJuIGJ1aWx0aW5fdHlwZSAoZ2Ri YXJjaCktPmJ1aWx0aW5fZnVuY19wdHI7CisKKyAgICBjYXNlIENSMTZfUkFf UkVHTlVNOgkvKiBSZXR1cm4gYWRkcmVzcyByZWcuICAqLworICAgICAgcmV0 dXJuIGJ1aWx0aW5fdHlwZSAoZ2RiYXJjaCktPmJ1aWx0aW5fZGF0YV9wdHI7 CisgICAgICBicmVhazsKKworICAgIGNhc2UgQ1IxNl9GUF9SRUdOVU06CS8q RnJhbWUgUG9pbnRlciByZWcuICAqLworICAgIGNhc2UgQ1IxNl9TUF9SRUdO VU06CS8qU3RhY2sgUG9pbnRlciByZWcuICAqLworICAgICAgcmV0dXJuIGJ1 aWx0aW5fdHlwZSAoZ2RiYXJjaCktPmJ1aWx0aW5fZGF0YV9wdHI7CisgICAg ICBicmVhazsKKworICAgIGNhc2UgU0lNX0NSMTZfSVNQX1JFR05VTToKKyAg ICBjYXNlIFNJTV9DUjE2X1VTUF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1Ix Nl9JTlRCQVNFX1JFR05VTToKKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUg KGdkYmFyY2gpLT5idWlsdGluX2ludDMyOworICAgICAgYnJlYWs7CisKKyAg ICBjYXNlIFNJTV9DUjE2X1BTUl9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1Ix Nl9DRkdfUkVHTlVNOgorICAgICAgcmV0dXJuIGJ1aWx0aW5fdHlwZSAoZ2Ri YXJjaCktPmJ1aWx0aW5fdWludDMyOworICAgICAgYnJlYWs7CisKKyAgICBj YXNlIFNJTV9DUjE2X1IwX1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1Ix X1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1IyX1JFR05VTToKKyAgICBj YXNlIFNJTV9DUjE2X1IzX1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1I0 X1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1I1X1JFR05VTToKKyAgICBj YXNlIFNJTV9DUjE2X1I2X1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1I3 X1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1I4X1JFR05VTToKKyAgICBj YXNlIFNJTV9DUjE2X1I5X1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1Ix MF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SMTFfUkVHTlVNOgorICAg ICAgcmV0dXJuIGJ1aWx0aW5fdHlwZSAoZ2RiYXJjaCktPmJ1aWx0aW5faW50 MTY7CisgICAgICBicmVhazsKKworICAgIGNhc2UgU0lNX0NSMTZfUjEyX1JF R05VTToKKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUgKGdkYmFyY2gpLT5i dWlsdGluX2ludDMyOworICAgICAgYnJlYWs7CisKKyAgICBkZWZhdWx0Ogor ICAgICAgcHJpbnRmCisJKCJcblJlZ2lzdGVyIFR5cGUgbm90IHN1cHBvcnRl ZFxuRnVuY3Rpb24gOiBjcjE2X3JlZ2lzdGVyX3R5cGVcbiIpOworICAgICAg cmV0dXJuIDA7CisgICAgICBicmVhazsKKyAgICB9Cit9CisKKy8qIEZ1bmN0 aW9uIGZvciBmaW5kaW5nIHNhdmVkIHJlZ2lzdGVycyBpbiBhICdzdHJ1Y3Qg cHZfYXJlYSc7IHRoaXMKKyAgIGZ1bmN0aW9uIGlzIHBhc3NlZCB0byBwdl9h cmVhX3NjYW4uCisgCisgICBJZiBWQUxVRSBpcyBhIHNhdmVkIHJlZ2lzdGVy LCBBRERSIHNheXMgaXQgd2FzIHNhdmVkIGF0IGEgY29uc3RhbnQKKyAgIG9m ZnNldCBmcm9tIHRoZSBmcmFtZSBiYXNlLCBhbmQgU0laRSBpbmRpY2F0ZXMg dGhhdCB0aGUgd2hvbGUKKyAgIHJlZ2lzdGVyIHdhcyBzYXZlZCwgcmVjb3Jk IGl0cyBvZmZzZXQuICAqLworCitzdGF0aWMgdm9pZAorY2hlY2tfZm9yX3Nh dmVkICh2b2lkICpyZXN1bHRfdW50eXBlZCwgcHZfdCBhZGRyLCBDT1JFX0FE RFIgc2l6ZSwgcHZfdCB2YWx1ZSkKK3sKKyAgc3RydWN0IGNyMTZfcHJvbG9n dWUgKnJlc3VsdCA9IChzdHJ1Y3QgY3IxNl9wcm9sb2d1ZSAqKSByZXN1bHRf dW50eXBlZDsKKworICBpZiAodmFsdWUua2luZCA9PSBwdmtfcmVnaXN0ZXIK KyAgICAgICYmIHZhbHVlLmsgPT0gMAorICAgICAgJiYgcHZfaXNfcmVnaXN0 ZXIgKGFkZHIsIENSMTZfU1BfUkVHTlVNKQorICAgICAgJiYgc2l6ZSA9PSBy ZWdpc3Rlcl9zaXplICh0YXJnZXRfZ2RiYXJjaCwgdmFsdWUucmVnKSkKKyAg ICByZXN1bHQtPnJlZ19vZmZzZXRbdmFsdWUucmVnXSA9IGFkZHIuazsKK30K KworLyogRGVmaW5lIGEgImhhbmRsZSIgc3RydWN0IGZvciBmZXRjaGluZyB0 aGUgbmV4dCBvcGNvZGUuICAqLworCitzdHJ1Y3QgY3IxNl9nZXRfb3Bjb2Rl X2J5dGVfaGFuZGxlCit7CisgIENPUkVfQUREUiBwYzsKK307CisKKy8qIEFu YWx5emUgYSBwcm9sb2d1ZSBzdGFydGluZyBhdCBTVEFSVF9QQywgZ29pbmcg bm8gZnVydGhlciB0aGFuCisgICBMSU1JVF9QQy4gIEZpbGwgaW4gUkVTVUxU IGFzIGFwcHJvcHJpYXRlLiAgKi8KKworc3RhdGljIHZvaWQKK2NyMTZfYW5h bHl6ZV9wcm9sb2d1ZSAoQ09SRV9BRERSIHN0YXJ0X3BjLAorCQkgICAgICAg Q09SRV9BRERSIGxpbWl0X3BjLCBzdHJ1Y3QgY3IxNl9wcm9sb2d1ZSAqcmVz dWx0KQoreworICBDT1JFX0FERFIgcGMsIG5leHRfcGM7CisgIGdkYl9ieXRl IGJ1Zls2XTsKKyAgY2hhciBpbnNuX2J5dGUxLCBpbnNuX2J5dGUyOworICBp bnQgcm47CisgIGludCBsZW5ndGg7CisgIHB2X3QgcmVnW0NSMTZfTlVNX1JF R1NdOworICBzdHJ1Y3QgcHZfYXJlYSAqc3RhY2s7CisgIHN0cnVjdCBjbGVh bnVwICpiYWNrX3RvOworICBDT1JFX0FERFIgYWZ0ZXJfbGFzdF9mcmFtZV9z ZXR1cF9pbnNuID0gc3RhcnRfcGM7CisgIGludCBpc19kZWNvZGVkOworCisg IG1lbXNldCAocmVzdWx0LCAwLCBzaXplb2YgKCpyZXN1bHQpKTsKKworICBm b3IgKHJuID0gMDsgcm4gPCBDUjE2X05VTV9SRUdTOyBybisrKQorICAgIHsK KyAgICAgIHJlZ1tybl0gPSBwdl9yZWdpc3RlciAocm4sIDApOworICAgICAg cmVzdWx0LT5yZWdfb2Zmc2V0W3JuXSA9IDE7CisgICAgfQorCisgIHN0YWNr ID0gbWFrZV9wdl9hcmVhIChDUjE2X1NQX1JFR05VTSwgZ2RiYXJjaF9hZGRy X2JpdCAodGFyZ2V0X2dkYmFyY2gpKTsKKyAgYmFja190byA9IG1ha2VfY2xl YW51cF9mcmVlX3B2X2FyZWEgKHN0YWNrKTsKKworICBwYyA9IHN0YXJ0X3Bj OworICB3aGlsZSAocGMgPCBsaW1pdF9wYykKKyAgICB7CisgICAgICAvKiBS ZWFkIDYgYnl0ZXMsIG1heCA0OCBiaXQgb3Bjb2RlLiAgKi8KKyAgICAgIHRh cmdldF9yZWFkX21lbW9yeSAocGMsIGJ1ZiwgNik7CisgICAgICB3b3Jkc1sw XSA9IGJ1ZlsxXSA8PCA4IHwgYnVmWzBdOworICAgICAgd29yZHNbMV0gPSBi dWZbM10gPDwgOCB8IGJ1ZlsyXTsKKyAgICAgIHdvcmRzWzJdID0gYnVmWzVd IDw8IDggfCBidWZbNF07CisgICAgICBhbGxXb3JkcyA9CisJKChVTE9OR0xP TkcpIHdvcmRzWzBdIDw8IDMyKSArICgodW5zaWduZWQgbG9uZykgd29yZHNb MV0gPDwgMTYpICsKKwl3b3Jkc1syXTsKKworICAgICAgLyogRmluZCBhIG1h dGNoaW5nIG9wY29kZSBpbiB0YWJsZS4gIAorICAgICAgICAgTm9uemVybyBt ZWFucyBpbnN0cnVjdGlvbiBoYXMgYSBtYXRjaC4gICovCisgICAgICBpc19k ZWNvZGVkID0gbWF0Y2hfb3Bjb2RlICgpOworICAgICAgbWFrZV9pbnN0cnVj dGlvbiAoKTsKKyAgICAgIGxlbmd0aCA9IGN1cnJJbnNuLnNpemU7CisgICAg ICBuZXh0X3BjID0gcGMgKyBsZW5ndGg7CisgICAgICBpbnNuX2J5dGUxID0g KHdvcmRzWzBdID4+IDgpICYgMHhGRjsKKworICAgICAgLyogSWYgUFVTSCwg dGhlbiBzYXZlIFJBIGFuZCBvdGhlciByZWdzLiAgKi8KKyAgICAgIGlmIChp bnNuX2J5dGUxID09IDB4MDEpCisJeworCSAgaW50IHIxLCByMjsKKwkgIGlu dCByOworCSAgaW5zbl9ieXRlMiA9IHdvcmRzWzBdOworCisJICBpZiAoaW5z bl9ieXRlMiAmIDB4ODApCisJICAgIHsKKwkgICAgICByZWdbQ1IxNl9TUF9S RUdOVU1dID0gcHZfYWRkX2NvbnN0YW50IChyZWdbQ1IxNl9TUF9SRUdOVU1d LCAtNCk7CisJICAgICAgcHZfYXJlYV9zdG9yZSAoc3RhY2ssIHJlZ1tDUjE2 X1NQX1JFR05VTV0sIDQsCisJCQkgICAgIHJlZ1tDUjE2X1JBX1JFR05VTV0p OworCSAgICB9CisJICAvKiBTdGFydCBSZWdpc3Rlcj1yMSwgMyBiaXQgaW1t IGNvdW50PXIyLiAgKi8KKwkgIHIxID0gaW5zbl9ieXRlMiAmIDB4MEY7CisJ ICByMiA9ICgoaW5zbl9ieXRlMiAmIDB4NzApID4+IDQpOworCSAgcjIgPSBy MiArIHIxICsgMTsKKworCSAgZm9yIChyID0gcjE7IHIgPCByMjsgcisrKQor CSAgICB7CisJICAgICAgaWYgKHIgPj0gQ1IxNl9SMTJfUkVHTlVNKQorCQl7 CisJCSAgcmVnW0NSMTZfU1BfUkVHTlVNXSA9CisJCSAgICBwdl9hZGRfY29u c3RhbnQgKHJlZ1tDUjE2X1NQX1JFR05VTV0sIC00KTsKKwkJICBwdl9hcmVh X3N0b3JlIChzdGFjaywgcmVnW0NSMTZfU1BfUkVHTlVNXSwgNCwgcmVnW3Jd KTsKKwkJICByKys7CisJCX0KKwkgICAgICBlbHNlCisJCXsKKwkJICByZWdb Q1IxNl9TUF9SRUdOVU1dID0KKwkJICAgIHB2X2FkZF9jb25zdGFudCAocmVn W0NSMTZfU1BfUkVHTlVNXSwgLTIpOworCQkgIHB2X2FyZWFfc3RvcmUgKHN0 YWNrLCByZWdbQ1IxNl9TUF9SRUdOVU1dLCAyLCByZWdbcl0pOworCQl9CisJ ICAgIH0KKwkgIGFmdGVyX2xhc3RfZnJhbWVfc2V0dXBfaW5zbiA9IG5leHRf cGM7CisJfQorICAgICAgLyogQWRkIGNvbnN0YW50IHRvIFNQLiAgKi8KKyAg ICAgIGVsc2UgaWYgKGluc25fYnl0ZTEgPT0gMHg2MCkKKwl7CisJICBpbnQg cmRzdDsKKwkgIHNpZ25lZCBzaG9ydCBhZGRlbmQ7CisJICBpbnNuX2J5dGUy ID0gd29yZHNbMF07CisJICByZHN0ID0gaW5zbl9ieXRlMiAmIDB4MEY7CisJ ICBpZiAocmRzdCA9PSBDUjE2X1NQX1JFR05VTSkKKwkgICAgeworCSAgICAg IGlmIChsZW5ndGggPT0gMikKKwkJeworCQkgIGFkZGVuZCA9IChpbnNuX2J5 dGUyICYgMHhGMCkgPj4gNDsKKwkJICByZWdbcmRzdF0gPSBwdl9hZGRfY29u c3RhbnQgKHJlZ1tyZHN0XSwgYWRkZW5kKTsKKwkJfQorCSAgICAgIGlmIChs ZW5ndGggPT0gNCkKKwkJeworCQkgIGFkZGVuZCA9IHdvcmRzWzFdOworCQkg IHJlZ1tyZHN0XSA9IHB2X2FkZF9jb25zdGFudCAocmVnW3Jkc3RdLCBhZGRl bmQpOworCQl9CisJICAgICAgYWZ0ZXJfbGFzdF9mcmFtZV9zZXR1cF9pbnNu ID0gbmV4dF9wYzsKKwkgICAgfQorCX0KKyAgICAgIC8qIENoZWNrIGZvciBN T1ZEIGluc24uICAqLworICAgICAgZWxzZSBpZiAoaW5zbl9ieXRlMSA9PSAw eDU1KQorCXsKKwkgIGludCByZHN0LCByc3JjOworCSAgaW5zbl9ieXRlMiA9 IHdvcmRzWzBdOworCSAgcnNyYyA9IChpbnNuX2J5dGUyICYgMHhGMCkgPj4g NDsKKwkgIHJkc3QgPSAoaW5zbl9ieXRlMiAmIDB4MEYpOworCSAgcmVnW3Jk c3RdID0gcmVnW3JzcmNdOworCSAgaWYgKHJzcmMgPT0gQ1IxNl9TUF9SRUdO VU0gJiYgcmRzdCA9PSBDUjE2X0ZQX1JFR05VTSkKKwkgICAgYWZ0ZXJfbGFz dF9mcmFtZV9zZXR1cF9pbnNuID0gbmV4dF9wYzsKKwl9CisgICAgICBlbHNl IGlmICgoKGluc25fYnl0ZTEgPj4gNCkgJiAweDBGKSA9PSAweGQpCisJewor CSAgLyogVGhpcyBtb3ZlcyBhbiBhcmd1bWVudCByZWdpc3RlciB0byB0aGUg c3RhY2suICBEb24ndAorCSAgICAgcmVjb3JkIGl0LCBidXQgYWxsb3cgaXQg dG8gYmUgYSBwYXJ0IG9mIHRoZSBwcm9sb2d1ZS4gICovCisJICBhZnRlcl9s YXN0X2ZyYW1lX3NldHVwX2luc24gPSBuZXh0X3BjOworCX0KKyAgICAgIGVs c2UKKwl7CisJICBicmVhazsJCS8qIFRlcm1pbmF0ZSB0aGUgcHJvbG9ndWUg c2Nhbi4gICovCisJfQorCisgICAgICBwYyA9IG5leHRfcGM7CisgICAgfQor CisgIC8qIElzIHRoZSBmcmFtZSBzaXplIChvZmZzZXQsIHJlYWxseSkgYSBr bm93biBjb25zdGFudD8gICovCisgIGlmIChwdl9pc19yZWdpc3RlciAocmVn W0NSMTZfU1BfUkVHTlVNXSwgQ1IxNl9TUF9SRUdOVU0pKQorICAgIHJlc3Vs dC0+ZnJhbWVfc2l6ZSA9IHJlZ1tDUjE2X1NQX1JFR05VTV0uazsKKworICAv KiBXYXMgdGhlIGZyYW1lIHBvaW50ZXIgaW5pdGlhbGl6ZWQ/ICAqLworICBp ZiAocHZfaXNfcmVnaXN0ZXIgKHJlZ1tDUjE2X0ZQX1JFR05VTV0sIENSMTZf U1BfUkVHTlVNKSkKKyAgICB7CisgICAgICByZXN1bHQtPmhhc19mcmFtZV9w dHIgPSAxOworICAgICAgcmVzdWx0LT5mcmFtZV9wdHJfb2Zmc2V0ID0gcmVn W0NSMTZfRlBfUkVHTlVNXS5rOworICAgIH0KKworICAvKiBSZWNvcmQgd2hl cmUgYWxsIHRoZSByZWdpc3RlcnMgd2VyZSBzYXZlZC4gICovCisgIHB2X2Fy ZWFfc2NhbiAoc3RhY2ssIGNoZWNrX2Zvcl9zYXZlZCwgKHZvaWQgKikgcmVz dWx0KTsKKworICByZXN1bHQtPnByb2xvZ3VlX2VuZCA9IGFmdGVyX2xhc3Rf ZnJhbWVfc2V0dXBfaW5zbjsKKyAgZG9fY2xlYW51cHMgKGJhY2tfdG8pOwor fQorCisKKy8qIEltcGxlbWVudCB0aGUgInNraXBfcHJvbG9ndWUiIGdkYmFy Y2ggbWV0aG9kLiAgKi8KKworc3RhdGljIENPUkVfQUREUgorY3IxNl9za2lw X3Byb2xvZ3VlIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgQ09SRV9BRERS IHBjKQoreworICBjb25zdCBjaGFyICpuYW1lOworICBDT1JFX0FERFIgZnVu Y19hZGRyLCBmdW5jX2VuZDsKKyAgc3RydWN0IGNyMTZfcHJvbG9ndWUgcDsK KworICAvKiBUcnkgdG8gZmluZCB0aGUgZXh0ZW50IG9mIHRoZSBmdW5jdGlv biB0aGF0IGNvbnRhaW5zIFBDLiAgKi8KKyAgaWYgKCFmaW5kX3BjX3BhcnRp YWxfZnVuY3Rpb24gKHBjLCAmbmFtZSwgJmZ1bmNfYWRkciwgJmZ1bmNfZW5k KSkKKyAgICByZXR1cm4gcGM7CisKKyAgY3IxNl9hbmFseXplX3Byb2xvZ3Vl IChwYywgZnVuY19lbmQsICZwKTsKKyAgcmV0dXJuIHAucHJvbG9ndWVfZW5k OworfQorCisvKiBHaXZlbiBhIGZyYW1lIGRlc2NyaWJlZCBieSBUSElTX0ZS QU1FLCBkZWNvZGUgdGhlIHByb2xvZ3VlIG9mIGl0cworICAgYXNzb2NpYXRl ZCBmdW5jdGlvbiBpZiB0aGVyZSBpcyBub3QgY2FjaGUgZW50cnkgYXMgc3Bl Y2lmaWVkIGJ5CisgICBUSElTX1BST0xPR1VFX0NBQ0hFLiAgU2F2ZSB0aGUg ZGVjb2RlZCBwcm9sb2d1ZSBpbiB0aGUgY2FjaGUgYW5kCisgICByZXR1cm4g dGhhdCBzdHJ1Y3QgYXMgdGhlIHZhbHVlIG9mIHRoaXMgZnVuY3Rpb24uICAq LworCitzdGF0aWMgc3RydWN0IGNyMTZfcHJvbG9ndWUgKgorY3IxNl9hbmFs eXplX2ZyYW1lX3Byb2xvZ3VlIChzdHJ1Y3QgZnJhbWVfaW5mbyAqdGhpc19m cmFtZSwKKwkJCSAgICAgdm9pZCAqKnRoaXNfcHJvbG9ndWVfY2FjaGUpCit7 CisgIGlmICghKnRoaXNfcHJvbG9ndWVfY2FjaGUpCisgICAgeworICAgICAg Q09SRV9BRERSIGZ1bmNfc3RhcnQsIHN0b3BfYWRkcjsKKworICAgICAgKnRo aXNfcHJvbG9ndWVfY2FjaGUgPSBGUkFNRV9PQlNUQUNLX1pBTExPQyAoc3Ry dWN0IGNyMTZfcHJvbG9ndWUpOworCisgICAgICBmdW5jX3N0YXJ0ID0gZ2V0 X2ZyYW1lX2Z1bmMgKHRoaXNfZnJhbWUpOworICAgICAgc3RvcF9hZGRyID0g Z2V0X2ZyYW1lX3BjICh0aGlzX2ZyYW1lKTsKKworICAgICAgLyogSWYgd2Ug Y291bGRuJ3QgZmluZCBhbnkgZnVuY3Rpb24gY29udGFpbmluZyB0aGUgUEMs IHRoZW4KKyAgICAgICAgIGp1c3QgaW5pdGlhbGl6ZSB0aGUgcHJvbG9ndWUg Y2FjaGUsIGJ1dCBkb24ndCBkbyBhbnl0aGluZy4gICovCisgICAgICBpZiAo IWZ1bmNfc3RhcnQpCisJc3RvcF9hZGRyID0gZnVuY19zdGFydDsKKworICAg ICAgY3IxNl9hbmFseXplX3Byb2xvZ3VlIChmdW5jX3N0YXJ0LCBzdG9wX2Fk ZHIsICp0aGlzX3Byb2xvZ3VlX2NhY2hlKTsKKyAgICB9CisKKyAgcmV0dXJu ICp0aGlzX3Byb2xvZ3VlX2NhY2hlOworfQorCisvKiBHaXZlbiB0aGUgbmV4 dCBmcmFtZSBhbmQgYSBwcm9sb2d1ZSBjYWNoZSwgcmV0dXJuIHRoaXMgZnJh bWUncworICAgYmFzZS4gICovCisKK3N0YXRpYyBDT1JFX0FERFIKK2NyMTZf ZnJhbWVfYmFzZSAoc3RydWN0IGZyYW1lX2luZm8gKnRoaXNfZnJhbWUsIHZv aWQgKip0aGlzX3Byb2xvZ3VlX2NhY2hlKQoreworICBzdHJ1Y3QgY3IxNl9w cm9sb2d1ZSAqcAorICAgID0gY3IxNl9hbmFseXplX2ZyYW1lX3Byb2xvZ3Vl ICh0aGlzX2ZyYW1lLCB0aGlzX3Byb2xvZ3VlX2NhY2hlKTsKKworICAvKiBJ biBmdW5jdGlvbnMgdGhhdCB1c2UgYWxsb2NhLCB0aGUgZGlzdGFuY2UgYmV0 d2VlbiB0aGUgc3RhY2sKKyAgICAgcG9pbnRlciBhbmQgdGhlIGZyYW1lIGJh c2UgdmFyaWVzIGR5bmFtaWNhbGx5LCBzbyB3ZSBjYW4ndCB1c2UKKyAgICAg dGhlIFNQIHBsdXMgc3RhdGljIGluZm9ybWF0aW9uIGxpa2UgcHJvbG9ndWUg YW5hbHlzaXMgdG8gZmluZCB0aGUKKyAgICAgZnJhbWUgYmFzZS4gIEhvd2V2 ZXIsIHN1Y2ggZnVuY3Rpb25zIG11c3QgaGF2ZSBhIGZyYW1lIHBvaW50ZXIs CisgICAgIHRvIGJlIGFibGUgdG8gcmVzdG9yZSB0aGUgU1Agb24gZXhpdC4g IFNvIHdoZW5ldmVyIHdlIGRvIGhhdmUgYQorICAgICBmcmFtZSBwb2ludGVy LCB1c2UgdGhhdCB0byBmaW5kIHRoZSBiYXNlLiAgKi8KKyAgaWYgKHAtPmhh c19mcmFtZV9wdHIpCisgICAgeworICAgICAgQ09SRV9BRERSIGZwID0gZ2V0 X2ZyYW1lX3JlZ2lzdGVyX3Vuc2lnbmVkICh0aGlzX2ZyYW1lLCBDUjE2X0ZQ X1JFR05VTSk7CisgICAgICByZXR1cm4gZnAgLSBwLT5mcmFtZV9wdHJfb2Zm c2V0OworICAgIH0KKyAgZWxzZQorICAgIHsKKyAgICAgIENPUkVfQUREUiBz cCA9IGdldF9mcmFtZV9yZWdpc3Rlcl91bnNpZ25lZCAodGhpc19mcmFtZSwg Q1IxNl9TUF9SRUdOVU0pOworICAgICAgcmV0dXJuIHNwIC0gcC0+ZnJhbWVf c2l6ZTsKKyAgICB9Cit9CisKKy8qIEltcGxlbWVudCB0aGUgImZyYW1lX3Ro aXNfaWQiIG1ldGhvZCBmb3IgdW53aW5kaW5nIGZyYW1lcy4gICovCisKK3N0 YXRpYyB2b2lkCitjcjE2X2ZyYW1lX3RoaXNfaWQgKHN0cnVjdCBmcmFtZV9p bmZvICp0aGlzX2ZyYW1lLAorCQkgICAgdm9pZCAqKnRoaXNfcHJvbG9ndWVf Y2FjaGUsIHN0cnVjdCBmcmFtZV9pZCAqdGhpc19pZCkKK3sKKyAgKnRoaXNf aWQgPQorICAgIGZyYW1lX2lkX2J1aWxkIChjcjE2X2ZyYW1lX2Jhc2UgKHRo aXNfZnJhbWUsIHRoaXNfcHJvbG9ndWVfY2FjaGUpLAorCQkgICAgZ2V0X2Zy YW1lX2Z1bmMgKHRoaXNfZnJhbWUpKTsKK30KKworLyogSW1wbGVtZW50IHRo ZSAiZnJhbWVfcHJldl9yZWdpc3RlciIgbWV0aG9kIGZvciB1bndpbmRpbmcg ZnJhbWVzLiAgKi8KKworc3RhdGljIHN0cnVjdCB2YWx1ZSAqCitjcjE2X2Zy YW1lX3ByZXZfcmVnaXN0ZXIgKHN0cnVjdCBmcmFtZV9pbmZvICp0aGlzX2Zy YW1lLAorCQkJICB2b2lkICoqdGhpc19wcm9sb2d1ZV9jYWNoZSwgaW50IHJl Z251bSkKK3sKKyAgc3RydWN0IGNyMTZfcHJvbG9ndWUgKnAgPQorICAgIGNy MTZfYW5hbHl6ZV9mcmFtZV9wcm9sb2d1ZSAodGhpc19mcmFtZSwgdGhpc19w cm9sb2d1ZV9jYWNoZSk7CisgIENPUkVfQUREUiBmcmFtZV9iYXNlID0gY3Ix Nl9mcmFtZV9iYXNlICh0aGlzX2ZyYW1lLCB0aGlzX3Byb2xvZ3VlX2NhY2hl KTsKKyAgaW50IHJlZ19zaXplID0gcmVnaXN0ZXJfc2l6ZSAoZ2V0X2ZyYW1l X2FyY2ggKHRoaXNfZnJhbWUpLCByZWdudW0pOworICBVTE9OR0VTVCByYV9w cmV2OworCisgIGlmIChyZWdudW0gPT0gQ1IxNl9TUF9SRUdOVU0pCisgICAg cmV0dXJuIGZyYW1lX3Vud2luZF9nb3RfY29uc3RhbnQgKHRoaXNfZnJhbWUs IHJlZ251bSwgZnJhbWVfYmFzZSk7CisKKyAgLyogVGhlIGNhbGwgaW5zdHJ1 Y3Rpb24gaGFzIHNhdmVkIHRoZSByZXR1cm4gYWRkcmVzcyBvbiB0aGUgUkEg CisgICAgIHJlZ2lzdGVyLCBDUjE2X1IxM19SRUdOVU0uICBTbywgd2UgbmVl ZCBub3QgYWRqdXN0IGFueXRoaW5nCisgICAgIGRpcmVjdGx5LiAgV2Ugd2ls bCBhbmFseXplIHByb2xvZ3VlIGFzIHRoaXMgUkEgcmVnaXN0ZXIgaXMKKyAg ICAgcHVzaGVkIG9udG8gc3RhY2sgZm9yIGZ1cnRoZXIgbGVhZiBmdW5jdGlv biBjYWxscyB0byB3b3JrLiAgKi8KKyAgZWxzZSBpZiAocmVnbnVtID09IENS MTZfUENfUkVHTlVNKQorICAgIHsKKyAgICAgIHJhX3ByZXYgPSBmcmFtZV91 bndpbmRfcmVnaXN0ZXJfdW5zaWduZWQgKHRoaXNfZnJhbWUsIENSMTZfUkFf UkVHTlVNKTsKKyAgICAgIHJhX3ByZXYgPSByYV9wcmV2IDw8IDE7CisgICAg ICByZXR1cm4gZnJhbWVfdW53aW5kX2dvdF9jb25zdGFudCAodGhpc19mcmFt ZSwgQ1IxNl9QQ19SRUdOVU0sIHJhX3ByZXYpOworICAgIH0KKworICAvKiBJ ZiBwcm9sb2d1ZSBhbmFseXNpcyBzYXlzIHdlIHNhdmVkIHRoaXMgcmVnaXN0 ZXIgc29tZXdoZXJlLAorICAgICByZXR1cm4gYSBkZXNjcmlwdGlvbiBvZiB0 aGUgc3RhY2sgc2xvdCBob2xkaW5nIGl0LiAgKi8KKyAgZWxzZSBpZiAocC0+ cmVnX29mZnNldFtyZWdudW1dICE9IDEpCisgICAgeworICAgICAgcmV0dXJu IGZyYW1lX3Vud2luZF9nb3RfbWVtb3J5ICh0aGlzX2ZyYW1lLCByZWdudW0s CisJCQkJICAgICAgZnJhbWVfYmFzZSArIHAtPnJlZ19vZmZzZXRbcmVnbnVt XSk7CisgICAgfQorCisgIC8qIE90aGVyd2lzZSwgcHJlc3VtZSB3ZSBoYXZl bid0IGNoYW5nZWQgdGhlIHZhbHVlIG9mIHRoaXMKKyAgICAgcmVnaXN0ZXIs IGFuZCBnZXQgaXQgZnJvbSB0aGUgbmV4dCBmcmFtZS4gICovCisgIGVsc2UK KyAgICB7CisgICAgICByZXR1cm4gZnJhbWVfdW53aW5kX2dvdF9yZWdpc3Rl ciAodGhpc19mcmFtZSwgcmVnbnVtLCByZWdudW0pOworICAgIH0KK30KKwor c3RhdGljIGNvbnN0IHN0cnVjdCBmcmFtZV91bndpbmQgY3IxNl9mcmFtZV91 bndpbmQgPSAKK3sKKyAgTk9STUFMX0ZSQU1FLAorICBkZWZhdWx0X2ZyYW1l X3Vud2luZF9zdG9wX3JlYXNvbiwKKyAgY3IxNl9mcmFtZV90aGlzX2lkLAor ICBjcjE2X2ZyYW1lX3ByZXZfcmVnaXN0ZXIsCisgIE5VTEwsCisgIGRlZmF1 bHRfZnJhbWVfc25pZmZlcgorfTsKKworLyogSW1wbGVtZW50IHRoZSAidW53 aW5kX3BjIiBnZGJhcmNoIG1ldGhvZC4gICovCisKK3N0YXRpYyBDT1JFX0FE RFIKK2NyMTZfdW53aW5kX3BjIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwg c3RydWN0IGZyYW1lX2luZm8gKnRoaXNfZnJhbWUpCit7CisgIFVMT05HRVNU IHBjOworCisgIHBjID0gZnJhbWVfdW53aW5kX3JlZ2lzdGVyX3Vuc2lnbmVk ICh0aGlzX2ZyYW1lLCBDUjE2X1BDX1JFR05VTSk7CisgIHJldHVybiBwYzsK K30KKworLyogSW1wbGVtZW50IHRoZSAidW53aW5kX3NwIiBnZGJhcmNoIG1l dGhvZC4gICovCisKK3N0YXRpYyBDT1JFX0FERFIKK2NyMTZfdW53aW5kX3Nw IChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgc3RydWN0IGZyYW1lX2luZm8g KnRoaXNfZnJhbWUpCit7CisgIFVMT05HRVNUIHNwOworCisgIHNwID0gZnJh bWVfdW53aW5kX3JlZ2lzdGVyX3Vuc2lnbmVkICh0aGlzX2ZyYW1lLCBDUjE2 X1NQX1JFR05VTSk7CisgIHJldHVybiBzcDsKK30KKworLyogSW1wbGVtZW50 IHRoZSAiZHVtbXlfaWQiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGlj IHN0cnVjdCBmcmFtZV9pZAorY3IxNl9kdW1teV9pZCAoc3RydWN0IGdkYmFy Y2ggKmdkYmFyY2gsIHN0cnVjdCBmcmFtZV9pbmZvICp0aGlzX2ZyYW1lKQor eworICByZXR1cm4KKyAgICBmcmFtZV9pZF9idWlsZCAoZ2V0X2ZyYW1lX3Jl Z2lzdGVyX3Vuc2lnbmVkICh0aGlzX2ZyYW1lLCBDUjE2X1NQX1JFR05VTSks CisJCSAgICBnZXRfZnJhbWVfcGMgKHRoaXNfZnJhbWUpKTsKK30KKworLyog SW1wbGVtZW50IHRoZSAicHVzaF9kdW1teV9jYWxsIiBnZGJhcmNoIG1ldGhv ZC4gICovCisKK3N0YXRpYyBDT1JFX0FERFIKK2NyMTZfcHVzaF9kdW1teV9j YWxsIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgc3RydWN0IHZhbHVlICpm dW5jdGlvbiwKKwkJICAgICAgc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSwg Q09SRV9BRERSIGJwX2FkZHIsIGludCBuYXJncywKKwkJICAgICAgc3RydWN0 IHZhbHVlICoqYXJncywgQ09SRV9BRERSIHNwLCBpbnQgc3RydWN0X3JldHVy biwKKwkJICAgICAgQ09SRV9BRERSIHN0cnVjdF9hZGRyKQoreworICBlbnVt IGJmZF9lbmRpYW4gYnl0ZV9vcmRlciA9IGdkYmFyY2hfYnl0ZV9vcmRlciAo Z2RiYXJjaCk7CisgIGludCB3cml0ZV9wYXNzOworICBpbnQgc3Bfb2ZmID0g MDsKKyAgQ09SRV9BRERSIGNmYTsKKyAgaW50IG51bV9yZWdpc3Rlcl9jYW5k aWRhdGVfYXJnczsKKworICBzdHJ1Y3QgdHlwZSAqZnVuY190eXBlID0gdmFs dWVfdHlwZSAoZnVuY3Rpb24pOworCisgIC8qIERlcmVmZXJlbmNlIGZ1bmN0 aW9uIHBvaW50ZXIgdHlwZXMuICAqLworICB3aGlsZSAoVFlQRV9DT0RFIChm dW5jX3R5cGUpID09IFRZUEVfQ09ERV9QVFIpCisgICAgZnVuY190eXBlID0g VFlQRV9UQVJHRVRfVFlQRSAoZnVuY190eXBlKTsKKworICAvKiBUaGUgZW5k IHJlc3VsdCBoYWQgYmV0dGVyIGJlIGEgZnVuY3Rpb24gb3IgYSBtZXRob2Qu ICAqLworICBnZGJfYXNzZXJ0IChUWVBFX0NPREUgKGZ1bmNfdHlwZSkgPT0g VFlQRV9DT0RFX0ZVTkMKKwkgICAgICB8fCBUWVBFX0NPREUgKGZ1bmNfdHlw ZSkgPT0gVFlQRV9DT0RFX01FVEhPRCk7CisKKyAgLyogRnVuY3Rpb25zIHdp dGggYSB2YXJpYWJsZSBudW1iZXIgb2YgYXJndW1lbnRzIGhhdmUgYWxsIG9m IHRoZWlyCisgICAgIHZhcmlhYmxlIGFyZ3VtZW50cyBhbmQgdGhlIGxhc3Qg bm9uLXZhcmlhYmxlIGFyZ3VtZW50IHBhc3NlZAorICAgICBvbiB0aGUgc3Rh Y2suCisKKyAgICAgT3RoZXJ3aXNlLCB3ZSBjYW4gcGFzcyB1cCB0byBmb3Vy IGFyZ3VtZW50cyBvbiB0aGUgc3RhY2suCisKKyAgICAgT25jZSBjb21wdXRl ZCwgd2UgbGVhdmUgdGhpcyB2YWx1ZSBhbG9uZS4gIEkuZS4gd2UgZG9uJ3Qg dXBkYXRlCisgICAgIGl0IGluIGNhc2Ugb2YgYSBzdHJ1Y3QgcmV0dXJuIGdv aW5nIGluIGEgcmVnaXN0ZXIgb3IgYW4gYXJndW1lbnQKKyAgICAgcmVxdWly aW5nIG11bHRpcGxlIHJlZ2lzdGVycywgZXRjLiAgV2UgcmVseSBpbnN0ZWFk IG9uIHRoZSB2YWx1ZQorICAgICBvZiB0aGUgYGBhcmdfcmVnJycgdmFyaWFi bGUgdG8gZ2V0IHRoZXNlIG90aGVyIGRldGFpbHMgY29ycmVjdC4gICovCisK KyAgaWYgKFRZUEVfVkFSQVJHUyAoZnVuY190eXBlKSkKKyAgICBudW1fcmVn aXN0ZXJfY2FuZGlkYXRlX2FyZ3MgPSBUWVBFX05GSUVMRFMgKGZ1bmNfdHlw ZSkgLSAxOworICBlbHNlCisgICAgbnVtX3JlZ2lzdGVyX2NhbmRpZGF0ZV9h cmdzID0gNDsKKworICAvKiBXZSBtYWtlIHR3byBwYXNzZXM7IHRoZSBmaXJz dCBkb2VzIHRoZSBzdGFjayBhbGxvY2F0aW9uLAorICAgICB0aGUgc2Vjb25k IGFjdHVhbGx5IHN0b3JlcyB0aGUgYXJndW1lbnRzLiAgKi8KKyAgZm9yICh3 cml0ZV9wYXNzID0gMDsgd3JpdGVfcGFzcyA8PSAxOyB3cml0ZV9wYXNzKysp CisgICAgeworICAgICAgaW50IGk7CisgICAgICBpbnQgYXJnX3JlZyA9IENS MTZfUjBfUkVHTlVNOworCisgICAgICBpZiAod3JpdGVfcGFzcykKKwlzcCA9 IGFsaWduX2Rvd24gKHNwIC0gc3Bfb2ZmLCA0KTsKKyAgICAgIHNwX29mZiA9 IDA7CisKKyAgICAgIGlmIChzdHJ1Y3RfcmV0dXJuKQorCXsKKwkgIHN0cnVj dCB0eXBlICpyZXR1cm5fdHlwZSA9IFRZUEVfVEFSR0VUX1RZUEUgKGZ1bmNf dHlwZSk7CisKKwkgIGdkYl9hc3NlcnQgKFRZUEVfQ09ERSAocmV0dXJuX3R5 cGUpID09IFRZUEVfQ09ERV9TVFJVQ1QKKwkJICAgICAgfHwgVFlQRV9DT0RF IChmdW5jX3R5cGUpID09IFRZUEVfQ09ERV9VTklPTik7CisKKwkgIGlmIChU WVBFX0xFTkdUSCAocmV0dXJuX3R5cGUpID4gMTYKKwkgICAgICB8fCBUWVBF X0xFTkdUSCAocmV0dXJuX3R5cGUpICUgNCAhPSAwKQorCSAgICB7CisJICAg ICAgaWYgKHdyaXRlX3Bhc3MpCisJCXJlZ2NhY2hlX2Nvb2tlZF93cml0ZV91 bnNpZ25lZCAocmVnY2FjaGUsIENSMTZfUjEyX1JFR05VTSwKKwkJCQkJCXN0 cnVjdF9hZGRyKTsKKwkgICAgfQorCX0KKworICAgICAgLyogUHVzaCB0aGUg YXJndW1lbnRzLiAgKi8KKyAgICAgIGZvciAoaSA9IDA7IGkgPCBuYXJnczsg aSsrKQorCXsKKwkgIHN0cnVjdCB2YWx1ZSAqYXJnID0gYXJnc1tpXTsKKwkg IGNvbnN0IGdkYl9ieXRlICphcmdfYml0cyA9IHZhbHVlX2NvbnRlbnRzX2Fs bCAoYXJnKTsKKwkgIHN0cnVjdCB0eXBlICphcmdfdHlwZSA9IGNoZWNrX3R5 cGVkZWYgKHZhbHVlX3R5cGUgKGFyZykpOworCSAgVUxPTkdFU1QgYXJnX3Np emUgPSBUWVBFX0xFTkdUSCAoYXJnX3R5cGUpOworCisJICBpZiAoaSA9PSAw ICYmIHN0cnVjdF9hZGRyICE9IDAgJiYgIXN0cnVjdF9yZXR1cm4KKwkgICAg ICAmJiBUWVBFX0NPREUgKGFyZ190eXBlKSA9PSBUWVBFX0NPREVfUFRSCisJ ICAgICAgJiYgZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2VyIChhcmdfYml0cywg NCwKKwkJCQkJICAgYnl0ZV9vcmRlcikgPT0gc3RydWN0X2FkZHIpCisJICAg IHsKKwkgICAgICAvKiBUaGlzIGFyZ3VtZW50IHJlcHJlc2VudHMgdGhlIGFk ZHJlc3MgYXQgd2hpY2ggQysrIChhbmQKKwkgICAgICAgICBwb3NzaWJseSBv dGhlciBsYW5ndWFnZXMpIHN0b3JlIHRoZWlyIHJldHVybiB2YWx1ZS4KKwkg ICAgICAgICBQdXQgdGhpcyB2YWx1ZSBpbiBSMTIuICAqLworCSAgICAgIGlm ICh3cml0ZV9wYXNzKQorCQlyZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWdu ZWQgKHJlZ2NhY2hlLCBDUjE2X1IxMl9SRUdOVU0sCisJCQkJCQlzdHJ1Y3Rf YWRkcik7CisJICAgIH0KKwkgIGVsc2UgaWYgKFRZUEVfQ09ERSAoYXJnX3R5 cGUpICE9IFRZUEVfQ09ERV9TVFJVQ1QKKwkJICAgJiYgVFlQRV9DT0RFIChh cmdfdHlwZSkgIT0gVFlQRV9DT0RFX1VOSU9OKQorCSAgICB7CisJICAgICAg LyogQXJndW1lbnQgaXMgYSBzY2FsYXIuICAqLworCSAgICAgIGlmIChhcmdf c2l6ZSA9PSA4KQorCQl7CisJCSAgaWYgKGkgPCBudW1fcmVnaXN0ZXJfY2Fu ZGlkYXRlX2FyZ3MKKwkJICAgICAgJiYgYXJnX3JlZyA8PSBDUjE2X1I3X1JF R05VTSAtIDEpCisJCSAgICB7CisJCSAgICAgIC8qIElmIGFyZ3VtZW50IHJl Z2lzdGVycyBhcmUgZ29pbmcgdG8gYmUgdXNlZCB0byBwYXNzCisJCSAgICAg ICAgIGFuIDggYnl0ZSBzY2FsYXIsIHRoZSBBQkkgc3BlY2lmaWVzIHRoYXQg dHdvIHJlZ2lzdGVycworCQkgICAgICAgICBtdXN0IGJlIGF2YWlsYWJsZS4g ICovCisJCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJeworCQkJICByZWdj YWNoZV9jb29rZWRfd3JpdGVfdW5zaWduZWQgKHJlZ2NhY2hlLCBhcmdfcmVn LAorCQkJCQkJCSAgZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2VyCisJCQkJCQkJ ICAoYXJnX2JpdHMsIDQsCisJCQkJCQkJICAgYnl0ZV9vcmRlcikpOworCQkJ ICByZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWduZWQgKHJlZ2NhY2hlLAor CQkJCQkJCSAgYXJnX3JlZyArIDEsCisJCQkJCQkJICBleHRyYWN0X3Vuc2ln bmVkX2ludGVnZXIKKwkJCQkJCQkgIChhcmdfYml0cyArIDQsIDQsCisJCQkJ CQkJICAgYnl0ZV9vcmRlcikpOworCQkJfQorCQkgICAgICBhcmdfcmVnICs9 IDI7CisJCSAgICB9CisJCSAgZWxzZQorCQkgICAgeworCQkgICAgICBzcF9v ZmYgPSBhbGlnbl91cCAoc3Bfb2ZmLCA0KTsKKwkJICAgICAgLyogT3RoZXJ3 aXNlLCBwYXNzIHRoZSA4IGJ5dGUgc2NhbGFyIG9uIHRoZSBzdGFjay4gICov CisJCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJd3JpdGVfbWVtb3J5IChz cCArIHNwX29mZiwgYXJnX2JpdHMsIDgpOworCQkgICAgICBzcF9vZmYgKz0g ODsKKwkJICAgIH0KKwkJfQorCSAgICAgIGVsc2UKKwkJeworCQkgIFVMT05H RVNUIHU7CisKKwkJICBnZGJfYXNzZXJ0IChhcmdfc2l6ZSA8PSA0KTsKKwor CQkgIHUgPQorCQkgICAgZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2VyIChhcmdf Yml0cywgYXJnX3NpemUsIGJ5dGVfb3JkZXIpOworCisJCSAgaWYgKGkgPCBu dW1fcmVnaXN0ZXJfY2FuZGlkYXRlX2FyZ3MKKwkJICAgICAgJiYgYXJnX3Jl ZyA8PSBDUjE2X1I3X1JFR05VTSkKKwkJICAgIHsKKwkJICAgICAgaWYgKHdy aXRlX3Bhc3MpCisJCQlyZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWduZWQg KHJlZ2NhY2hlLCBhcmdfcmVnLCB1KTsKKwkJICAgICAgYXJnX3JlZyArPSAx OworCQkgICAgfQorCQkgIGVsc2UKKwkJICAgIHsKKwkJICAgICAgaW50IHBf YXJnX3NpemUgPSA0OworCisJCSAgICAgIGlmIChUWVBFX1BST1RPVFlQRUQg KGZ1bmNfdHlwZSkKKwkJCSAgJiYgaSA8IFRZUEVfTkZJRUxEUyAoZnVuY190 eXBlKSkKKwkJCXsKKwkJCSAgc3RydWN0IHR5cGUgKnBfYXJnX3R5cGUgPQor CQkJICAgIFRZUEVfRklFTERfVFlQRSAoZnVuY190eXBlLCBpKTsKKwkJCSAg cF9hcmdfc2l6ZSA9IFRZUEVfTEVOR1RIIChwX2FyZ190eXBlKTsKKwkJCX0K KworCQkgICAgICBzcF9vZmYgPSBhbGlnbl91cCAoc3Bfb2ZmLCBwX2FyZ19z aXplKTsKKworCQkgICAgICBpZiAod3JpdGVfcGFzcykKKwkJCXdyaXRlX21l bW9yeV91bnNpZ25lZF9pbnRlZ2VyIChzcCArIHNwX29mZiwKKwkJCQkJCSAg ICAgICBwX2FyZ19zaXplLCBieXRlX29yZGVyLAorCQkJCQkJICAgICAgIHUp OworCQkgICAgICBzcF9vZmYgKz0gcF9hcmdfc2l6ZTsKKwkJICAgIH0KKwkJ fQorCSAgICB9CisJICBlbHNlCisJICAgIHsKKwkgICAgICAvKiBBcmd1bWVu dCBpcyBhIHN0cnVjdCBvciB1bmlvbi4gIFBhc3MgYXMgbXVjaCBvZiB0aGUg c3RydWN0CisJICAgICAgICAgaW4gcmVnaXN0ZXJzLCBhcyBwb3NzaWJsZS4g IFBhc3MgdGhlIHJlc3Qgb24gdGhlIHN0YWNrLiAgKi8KKwkgICAgICB3aGls ZSAoYXJnX3NpemUgPiAwKQorCQl7CisJCSAgaWYgKGkgPCBudW1fcmVnaXN0 ZXJfY2FuZGlkYXRlX2FyZ3MKKwkJICAgICAgJiYgYXJnX3JlZyA8PSBDUjE2 X1I3X1JFR05VTQorCQkgICAgICAmJiBhcmdfc2l6ZSA8PSA0ICogKENSMTZf UjdfUkVHTlVNIC0gYXJnX3JlZyArIDEpCisJCSAgICAgICYmIGFyZ19zaXpl ICUgNCA9PSAwKQorCQkgICAgeworCQkgICAgICBpbnQgbGVuID0gbWluIChh cmdfc2l6ZSwgNCk7CisKKwkJICAgICAgaWYgKHdyaXRlX3Bhc3MpCisJCQly ZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWduZWQgKHJlZ2NhY2hlLCBhcmdf cmVnLAorCQkJCQkJCWV4dHJhY3RfdW5zaWduZWRfaW50ZWdlcgorCQkJCQkJ CShhcmdfYml0cywgbGVuLAorCQkJCQkJCSBieXRlX29yZGVyKSk7CisJCSAg ICAgIGFyZ19iaXRzICs9IGxlbjsKKwkJICAgICAgYXJnX3NpemUgLT0gbGVu OworCQkgICAgICBhcmdfcmVnKys7CisJCSAgICB9CisJCSAgZWxzZQorCQkg ICAgeworCQkgICAgICBzcF9vZmYgPSBhbGlnbl91cCAoc3Bfb2ZmLCA0KTsK KwkJICAgICAgaWYgKHdyaXRlX3Bhc3MpCisJCQl3cml0ZV9tZW1vcnkgKHNw ICsgc3Bfb2ZmLCBhcmdfYml0cywgYXJnX3NpemUpOworCQkgICAgICBzcF9v ZmYgKz0gYWxpZ25fdXAgKGFyZ19zaXplLCA0KTsKKwkJICAgICAgYXJnX3Np emUgPSAwOworCQkgICAgfQorCQl9CisJICAgIH0KKwl9CisgICAgfQorCisg IC8qIEtlZXAgdHJhY2sgb2YgdGhlIHN0YWNrIGFkZHJlc3MgcHJpb3IgdG8g cHVzaGluZyB0aGUgcmV0dXJuIGFkZHJlc3MuCisgICAgIFRoaXMgaXMgdGhl IHZhbHVlIHRoYXQgd2UnbGwgcmV0dXJuLiAgKi8KKyAgY2ZhID0gc3A7CisK KyAgLyogUHVzaCB0aGUgcmV0dXJuIGFkZHJlc3MuICAqLworICBzcCA9IHNw IC0gNDsKKyAgd3JpdGVfbWVtb3J5X3Vuc2lnbmVkX2ludGVnZXIgKHNwLCA0 LCBieXRlX29yZGVyLCBicF9hZGRyKTsKKworICAvKiBVcGRhdGUgdGhlIHN0 YWNrIHBvaW50ZXIuICAqLworICByZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5z aWduZWQgKHJlZ2NhY2hlLCBDUjE2X1NQX1JFR05VTSwgc3ApOworCisgIHJl dHVybiBjZmE7Cit9CisKKy8qIEltcGxlbWVudCB0aGUgInJldHVybl92YWx1 ZSIgZ2RiYXJjaCBtZXRob2QuICAqLworCitzdGF0aWMgZW51bSByZXR1cm5f dmFsdWVfY29udmVudGlvbgorY3IxNl9yZXR1cm5fdmFsdWUgKHN0cnVjdCBn ZGJhcmNoICpnZGJhcmNoLAorCQkgICBzdHJ1Y3QgdHlwZSAqZnVuY190eXBl LAorCQkgICBzdHJ1Y3QgdHlwZSAqdmFsdHlwZSwKKwkJICAgc3RydWN0IHJl Z2NhY2hlICpyZWdjYWNoZSwKKwkJICAgZ2RiX2J5dGUgKiByZWFkYnVmLCBj b25zdCBnZGJfYnl0ZSAqIHdyaXRlYnVmKQoreworICBlbnVtIGJmZF9lbmRp YW4gYnl0ZV9vcmRlciA9IGdkYmFyY2hfYnl0ZV9vcmRlciAoZ2RiYXJjaCk7 CisgIFVMT05HRVNUIHZhbHR5cGVfbGVuID0gVFlQRV9MRU5HVEggKHZhbHR5 cGUpOworCisgIGlmIChUWVBFX0xFTkdUSCAodmFsdHlwZSkgPiAxNgorICAg ICAgfHwgKChUWVBFX0NPREUgKHZhbHR5cGUpID09IFRZUEVfQ09ERV9TVFJV Q1QKKwkgICB8fCBUWVBFX0NPREUgKHZhbHR5cGUpID09IFRZUEVfQ09ERV9V TklPTikKKwkgICYmIFRZUEVfTEVOR1RIICh2YWx0eXBlKSAlIDQgIT0gMCkp CisgICAgcmV0dXJuIFJFVFVSTl9WQUxVRV9TVFJVQ1RfQ09OVkVOVElPTjsK KworICBpZiAocmVhZGJ1ZikKKyAgICB7CisgICAgICBVTE9OR0VTVCB1Owor ICAgICAgaW50IGFyZ3JlZyA9IENSMTZfUjBfUkVHTlVNOworICAgICAgaW50 IG9mZnNldCA9IDA7CisKKyAgICAgIHdoaWxlICh2YWx0eXBlX2xlbiA+IDAp CisJeworCSAgaW50IGxlbiA9IG1pbiAodmFsdHlwZV9sZW4sIDQpOworCisJ ICByZWdjYWNoZV9jb29rZWRfcmVhZF91bnNpZ25lZCAocmVnY2FjaGUsIGFy Z3JlZywgJnUpOworCSAgc3RvcmVfdW5zaWduZWRfaW50ZWdlciAocmVhZGJ1 ZiArIG9mZnNldCwgbGVuLCBieXRlX29yZGVyLCB1KTsKKwkgIHZhbHR5cGVf bGVuIC09IGxlbjsKKwkgIG9mZnNldCArPSBsZW47CisJICBhcmdyZWcrKzsK Kwl9CisgICAgfQorCisgIGlmICh3cml0ZWJ1ZikKKyAgICB7CisgICAgICBV TE9OR0VTVCB1OworICAgICAgaW50IGFyZ3JlZyA9IENSMTZfUjBfUkVHTlVN OworICAgICAgaW50IG9mZnNldCA9IDA7CisKKyAgICAgIHdoaWxlICh2YWx0 eXBlX2xlbiA+IDApCisJeworCSAgaW50IGxlbiA9IG1pbiAodmFsdHlwZV9s ZW4sIDQpOworCisJICB1ID0gZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2VyICh3 cml0ZWJ1ZiArIG9mZnNldCwgbGVuLCBieXRlX29yZGVyKTsKKwkgIHJlZ2Nh Y2hlX2Nvb2tlZF93cml0ZV91bnNpZ25lZCAocmVnY2FjaGUsIGFyZ3JlZywg dSk7CisJICB2YWx0eXBlX2xlbiAtPSBsZW47CisJICBvZmZzZXQgKz0gbGVu OworCSAgYXJncmVnKys7CisJfQorICAgIH0KKworICByZXR1cm4gUkVUVVJO X1ZBTFVFX1JFR0lTVEVSX0NPTlZFTlRJT047Cit9CisKKy8qIEltcGxlbWVu dCB0aGUgImJyZWFrcG9pbnRfZnJvbV9wYyIgZ2RiYXJjaCBtZXRob2QuICAq LworCitzdGF0aWMgY29uc3QgZ2RiX2J5dGUgKgorY3IxNl9icmVha3BvaW50 X2Zyb21fcGMgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBDT1JFX0FERFIg KiBwY3B0ciwKKwkJCSBpbnQgKmxlbnB0cikKK3sKKyAgLyogV2UgdXNlIGRp ZmZlcmVudCBicmVha3BvaW50IGluc3RydWN0aW9ucyBmb3IgRUxGIGFuZCB1 Q2xpbnV4LgorICAgICBTZWUgY3IxNi1saW51eC10ZGVwLmMgZm9yIG1vcmUg ZGV0YWlscy4gICovCisgIHN0cnVjdCBnZGJhcmNoX3RkZXAgKnRkZXAgPSBn ZGJhcmNoX3RkZXAgKGdkYmFyY2gpOworICAqbGVucHRyID0gMjsKKyAgaWYg KHRkZXAgPT0gTlVMTCB8fCB0ZGVwLT5icmVha3BvaW50ID09IE5VTEwpCisg ICAgeworICAgICAgcmV0dXJuIGJyZWFrcG9pbnRfZWxmOworICAgIH0KKyAg cmV0dXJuIHRkZXAtPmJyZWFrcG9pbnQ7Cit9CisKKy8qIEFsbG9jYXRlIGFu ZCBpbml0aWFsaXplIGEgZ2RiYXJjaCBvYmplY3QuICAqLworCitzdGF0aWMg c3RydWN0IGdkYmFyY2ggKgorY3IxNl9nZGJhcmNoX2luaXQgKHN0cnVjdCBn ZGJhcmNoX2luZm8gaW5mbywgc3RydWN0IGdkYmFyY2hfbGlzdCAqYXJjaGVz KQoreworICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaDsKKyAgc3RydWN0IGdk YmFyY2hfdGRlcCAqdGRlcDsKKyAgaW50IGVsZl9mbGFnczsKKworICAvKiBF eHRyYWN0IHRoZSBlbGZfZmxhZ3MgaWYgYXZhaWxhYmxlLiAgKi8KKyAgaWYg KGluZm8uYWJmZCAhPSBOVUxMCisgICAgICAmJiBiZmRfZ2V0X2ZsYXZvdXIg KGluZm8uYWJmZCkgPT0gYmZkX3RhcmdldF9lbGZfZmxhdm91cikKKyAgICBl bGZfZmxhZ3MgPSBlbGZfZWxmaGVhZGVyIChpbmZvLmFiZmQpLT5lX2ZsYWdz OworICBlbHNlCisgICAgZWxmX2ZsYWdzID0gMDsKKworICAvKiBUcnkgdG8g ZmluZCB0aGUgYXJjaGl0ZWN0dXJlIGluIHRoZSBsaXN0IG9mIGFscmVhZHkg ZGVmaW5lZAorICAgICBhcmNoaXRlY3R1cmVzLiAgKi8KKyAgZm9yIChhcmNo ZXMgPSBnZGJhcmNoX2xpc3RfbG9va3VwX2J5X2luZm8gKGFyY2hlcywgJmlu Zm8pOworICAgICAgIGFyY2hlcyAhPSBOVUxMOworICAgICAgIGFyY2hlcyA9 IGdkYmFyY2hfbGlzdF9sb29rdXBfYnlfaW5mbyAoYXJjaGVzLT5uZXh0LCAm aW5mbykpCisgICAgeworICAgICAgaWYgKGdkYmFyY2hfdGRlcCAoYXJjaGVz LT5nZGJhcmNoKS0+ZWxmX2ZsYWdzICE9IGVsZl9mbGFncykKKwljb250aW51 ZTsKKworICAgICAgcmV0dXJuIGFyY2hlcy0+Z2RiYXJjaDsKKyAgICB9Cisg IC8qIE5vbmUgZm91bmQsIGNyZWF0ZSBhIG5ldyBhcmNoaXRlY3R1cmUgZnJv bSB0aGUgaW5mb3JtYXRpb24KKyAgICAgcHJvdmlkZWQuICAqLworICB0ZGVw ID0gKHN0cnVjdCBnZGJhcmNoX3RkZXAgKikgeGNhbGxvYyAoMSwgc2l6ZW9m IChzdHJ1Y3QgZ2RiYXJjaF90ZGVwKSk7CisgIHRkZXAtPmVsZl9mbGFncyA9 IGVsZl9mbGFnczsKKyAgZ2RiYXJjaCA9IGdkYmFyY2hfYWxsb2MgKCZpbmZv LCB0ZGVwKTsKKworICBzZXRfZ2RiYXJjaF9udW1fcHNldWRvX3JlZ3MgKGdk YmFyY2gsIDApOworICBzZXRfZ2RiYXJjaF9udW1fcmVncyAoZ2RiYXJjaCwg Q1IxNl9OVU1fUkVHUyk7CisgIHNldF9nZGJhcmNoX3JlZ2lzdGVyX25hbWUg KGdkYmFyY2gsIGNyMTZfcmVnaXN0ZXJfbmFtZSk7CisgIHNldF9nZGJhcmNo X3JlZ2lzdGVyX3R5cGUgKGdkYmFyY2gsIGNyMTZfcmVnaXN0ZXJfdHlwZSk7 CisgIHNldF9nZGJhcmNoX3BjX3JlZ251bSAoZ2RiYXJjaCwgQ1IxNl9QQ19S RUdOVU0pOworICBzZXRfZ2RiYXJjaF9zcF9yZWdudW0gKGdkYmFyY2gsIENS MTZfU1BfUkVHTlVNKTsKKyAgc2V0X2dkYmFyY2hfaW5uZXJfdGhhbiAoZ2Ri YXJjaCwgY29yZV9hZGRyX2xlc3N0aGFuKTsKKyAgc2V0X2dkYmFyY2hfZGVj cl9wY19hZnRlcl9icmVhayAoZ2RiYXJjaCwgMik7CisgIHNldF9nZGJhcmNo X2JyZWFrcG9pbnRfZnJvbV9wYyAoZ2RiYXJjaCwgY3IxNl9icmVha3BvaW50 X2Zyb21fcGMpOworICBzZXRfZ2RiYXJjaF9za2lwX3Byb2xvZ3VlIChnZGJh cmNoLCBjcjE2X3NraXBfcHJvbG9ndWUpOworCisgIC8qIFBhc3NpbmcgTlVM TCAgdmFsdWVzIGluIHRoZSBmb2xsb3dpbmcgdHdvIGZ1bmN0aW9ucworICAg ICBmb3IgdGhlIHRpbWUgYmVpbmcsIHRvIGZpeCBsYXRlci4gICovCisgIHNl dF9nZGJhcmNoX3ByaW50X2luc24gKGdkYmFyY2gsIHByaW50X2luc25fY3Ix Nik7CisgIHNldF9nZGJhcmNoX3Vud2luZF9wYyAoZ2RiYXJjaCwgY3IxNl91 bndpbmRfcGMpOworICBzZXRfZ2RiYXJjaF91bndpbmRfc3AgKGdkYmFyY2gs IGNyMTZfdW53aW5kX3NwKTsKKworICAvKiBNZXRob2RzIGZvciBzYXZpbmcg LyBleHRyYWN0aW5nIGEgZHVtbXkgZnJhbWUncyBJRC4KKyAgICAgVGhlIElE J3Mgc3RhY2sgYWRkcmVzcyBtdXN0IG1hdGNoIHRoZSBTUCB2YWx1ZSByZXR1 cm5lZCBieQorICAgICBQVVNIX0RVTU1ZX0NBTEwsIGFuZCBzYXZlZCBieSBn ZW5lcmljX3NhdmVfZHVtbXlfZnJhbWVfdG9zLiAgKi8KKyAgc2V0X2dkYmFy Y2hfZHVtbXlfaWQgKGdkYmFyY2gsIGNyMTZfZHVtbXlfaWQpOworICBzZXRf Z2RiYXJjaF9wdXNoX2R1bW15X2NhbGwgKGdkYmFyY2gsIGNyMTZfcHVzaF9k dW1teV9jYWxsKTsKKyAgLyogVGFyZ2V0IGJ1aWx0aW4gZGF0YSB0eXBlcy4g ICovCisgIHNldF9nZGJhcmNoX2NoYXJfc2lnbmVkIChnZGJhcmNoLCA4KTsK KyAgc2V0X2dkYmFyY2hfc2hvcnRfYml0IChnZGJhcmNoLCAxNik7CisKKyAg LyogSWYgd2UgZG9uJ3QgcGFzcyB0aGUgb3B0aW9uIC1taW50MzIKKyAgICAg RklYTUU6IGFkZCBpZiBlbHNlIGNhc2UgZGVwZW5kaW5nIG9uIHRoZSBvcHRp b24gcGFzc2VkLAorICAgICBzcCB0aGF0IHdlIGNhbiBoYXZlIGludCBzaXpl IGFzIDE2IG9yIDMyIGJpdHMgYm90aC4gICovCisgIHNldF9nZGJhcmNoX2lu dF9iaXQgKGdkYmFyY2gsIDE2KTsKKyAgc2V0X2dkYmFyY2hfbG9uZ19iaXQg KGdkYmFyY2gsIDMyKTsKKyAgc2V0X2dkYmFyY2hfbG9uZ19sb25nX2JpdCAo Z2RiYXJjaCwgNjQpOworICBzZXRfZ2RiYXJjaF9mbG9hdF9iaXQgKGdkYmFy Y2gsIDMyKTsKKworICBzZXRfZ2RiYXJjaF9wdHJfYml0IChnZGJhcmNoLCAz Mik7CisgIHNldF9nZGJhcmNoX2Zsb2F0X2Zvcm1hdCAoZ2RiYXJjaCwgZmxv YXRmb3JtYXRzX2llZWVfc2luZ2xlKTsKKyAgc2V0X2dkYmFyY2hfZG91Ymxl X2JpdCAoZ2RiYXJjaCwgNjQpOworICBzZXRfZ2RiYXJjaF9sb25nX2RvdWJs ZV9iaXQgKGdkYmFyY2gsIDY0KTsKKyAgc2V0X2dkYmFyY2hfZG91YmxlX2Zv cm1hdCAoZ2RiYXJjaCwgZmxvYXRmb3JtYXRzX2llZWVfZG91YmxlKTsKKyAg c2V0X2dkYmFyY2hfbG9uZ19kb3VibGVfZm9ybWF0IChnZGJhcmNoLCBmbG9h dGZvcm1hdHNfaWVlZV9kb3VibGUpOworCisgIGZyYW1lX3Vud2luZF9hcHBl bmRfdW53aW5kZXIgKGdkYmFyY2gsICZjcjE2X2ZyYW1lX3Vud2luZCk7Cisg IHNldF9nZGJhcmNoX3JldHVybl92YWx1ZSAoZ2RiYXJjaCwgY3IxNl9yZXR1 cm5fdmFsdWUpOworCisgIC8qIEhvb2sgaW4gQUJJLXNwZWNpZmljIG92ZXJy aWRlcywgaWYgdGhleSBoYXZlIGJlZW4gcmVnaXN0ZXJlZC4gICovCisgIGdk YmFyY2hfaW5pdF9vc2FiaSAoaW5mbywgZ2RiYXJjaCk7CisKKyAgcmV0dXJu IGdkYmFyY2g7CisKK30KKworLyogLVdtaXNzaW5nLXByb3RvdHlwZXMuICAq LworZXh0ZXJuIGluaXRpYWxpemVfZmlsZV9mdHlwZSBfaW5pdGlhbGl6ZV9j cjE2X3RkZXA7CisKKy8qIFJlZ2lzdGVyIHRoZSBhYm92ZSBpbml0aWFsaXph dGlvbiByb3V0aW5lLiAgKi8KKwordm9pZAorX2luaXRpYWxpemVfY3IxNl90 ZGVwICh2b2lkKQoreworICByZWdpc3Rlcl9nZGJhcmNoX2luaXQgKGJmZF9h cmNoX2NyMTYsIGNyMTZfZ2RiYXJjaF9pbml0KTsKK30KLS0tIC4vZ2RiX3Ny Yy5vcmlnL2dkYi9jcjE2LXRkZXAuaAkxOTcwLTAxLTAxIDA1OjMwOjAwLjAw MDAwMDAwMCArMDUzMAorKysgLi9nZGJfc3JjL2dkYi9jcjE2LXRkZXAuaAky MDEyLTEwLTA5IDE4OjQ4OjM4LjAwMDAwMDAwMCArMDUzMApAQCAtMCwwICsx LDMyIEBACisvKiBHTlUvTGludXggb24gIENSMTYgdGFyZ2V0IHN1cHBvcnQu CisgICBDb3B5cmlnaHQgKEMpIDIwMTIgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuCisKKyAgIENvbnRyaWJ1dGVkIGJ5IEthdXNoaWsgUGhhdGFr IChrYXVzaGlrLnBhaGF0a0BrcGl0Y3VtbWlucy5jb20pCisgICBLUElUIEN1 bW1pbnMgSW5mb3N5c3RlbXMgTGltaXRlZCwgUHVuZSBJbmRpYS4KKworICAg VGhpcyBmaWxlIGlzIHBhcnQgb2YgR0RCLgorCisgICBUaGlzIHByb2dyYW0g aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yIG1vZGlmeQorICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMg b2YgdGhlIExpY2Vuc2UsIG9yCisgICAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorCisgICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgICBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisg ICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHBy b2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vu c2VzLz4uICAqLworCisKKy8qIFRhcmdldC1kZXBlbmRlbnQgc3RydWN0dXJl IGluIGdkYmFyY2guICAqLworCitzdHJ1Y3QgZ2RiYXJjaF90ZGVwCit7Cisg IC8qIFRoZSBFTEYgaGVhZGVyIGZsYWdzIHNwZWNpZnkgdGhlIG11bHRpbGli IHVzZWQuICAqLworICBpbnQgZWxmX2ZsYWdzOworCisgIC8qIEJyZWFrcG9p bnQgaW5zdHJ1Y3Rpb24uICAqLworICBjb25zdCBnZGJfYnl0ZSAqYnJlYWtw b2ludDsKK307Cg== --_002_C6CA53A2A46BA7469348BDBD663AB65845B39A2FKCHJEXMB02kpitc_--