From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 10795 invoked by alias); 15 Jan 2013 09:31:01 -0000 Received: (qmail 10768 invoked by uid 22791); 15 Jan 2013 09:30:58 -0000 X-SWARE-Spam-Status: No, hits=-5.0 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_THREADED,RCVD_IN_DNSWL_LOW,RCVD_IN_HOSTKARMA_NO,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,TW_EG,TW_PV X-Spam-Check-By: sourceware.org Received: from ch1ehsobe004.messaging.microsoft.com (HELO ch1outboundpool.messaging.microsoft.com) (216.32.181.184) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 15 Jan 2013 09:30:45 +0000 Received: from mail182-ch1-R.bigfish.com (10.43.68.243) by CH1EHSOBE016.bigfish.com (10.43.70.66) with Microsoft SMTP Server id 14.1.225.23; Tue, 15 Jan 2013 09:30:43 +0000 Received: from mail182-ch1 (localhost [127.0.0.1]) by mail182-ch1-R.bigfish.com (Postfix) with ESMTP id 56B251200D0; Tue, 15 Jan 2013 09:30:43 +0000 (UTC) X-Forefront-Antispam-Report: CIP:59.163.77.45;KIP:(null);UIP:(null);IPV:NLI;H:KCHJEXHC01.kpit.com;RD:59.163.77.45.static.vsnl.net.in;EFVD:NLI X-SpamScore: 2 X-BigFish: VPS2(zzc85fh154dIc8kzz1ee6h1de0h1202h1e76h1d1ah1d2ahzz177df4h17326ah8275dhz2dh2a8h668h839hd25hf0ah1288h12a5h12bdh137ah1441h14ddh1504h1537h153bh15d0h162dh1631h1758h34h1155h) Received: from mail182-ch1 (localhost.localdomain [127.0.0.1]) by mail182-ch1 (MessageSwitch) id 1358242239888731_31213; Tue, 15 Jan 2013 09:30:39 +0000 (UTC) Received: from CH1EHSMHS038.bigfish.com (snatpool2.int.messaging.microsoft.com [10.43.68.235]) by mail182-ch1.bigfish.com (Postfix) with ESMTP id CE4172005B; Tue, 15 Jan 2013 09:30:39 +0000 (UTC) Received: from KCHJEXHC01.kpit.com (59.163.77.45) by CH1EHSMHS038.bigfish.com (10.43.69.247) with Microsoft SMTP Server (TLS) id 14.1.225.23; Tue, 15 Jan 2013 09:30:38 +0000 Received: from KCHJEXMB02.kpit.com ([169.254.2.126]) by KCHJEXHC01.kpit.com ([172.10.15.73]) with mapi id 14.02.0247.003; Tue, 15 Jan 2013 15:00:35 +0530 From: Kaushik Phatak To: "gdb-patches@sourceware.org" CC: "binutils@sourceware.org" , Pedro Alves , Yao Qi , nick clifton , Tom Tromey , Joel Brobecker Subject: RE: [RFA 3/5] New port: CR16: gdb port Date: Tue, 15 Jan 2013 09:31:00 -0000 Message-ID: References: <507279C7.8080401@codesourcery.com> <20121022224107.GB3713@adacore.com> <20121023135502.GA3555@adacore.com> <20121115174313.GC3790@adacore.com> <20121122175010.GG9964@adacore.com> Content-Type: multipart/mixed; boundary="_002_C6CA53A2A46BA7469348BDBD663AB65848567829KCHJEXMB02kpitc_" 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: 2013-01/txt/msg00299.txt.bz2 --_002_C6CA53A2A46BA7469348BDBD663AB65848567829KCHJEXMB02kpitc_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Content-length: 33775 Hi, > Pedro Alves wrote "Please always base the work you submit against the cur= rent > development. For GDB, that is: http://sourceware.org/gdb/current/" I have extracted a cvs diff below. A read only CVS did not allow me to add new files, so I had to add them to CVS/Entries. The diff appears to be=20 against /dev/null. Please let me know if this is OK. Regards, Kaushik 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. =09 Index: gdb/configure.tgt =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D RCS file: /cvs/src/src/gdb/configure.tgt,v retrieving revision 1.261 diff -u -a -r1.261 configure.tgt --- gdb/configure.tgt 18 Dec 2012 14:52:58 -0000 1.261 +++ gdb/configure.tgt 15 Jan 2013 07:30:06 -0000 @@ -116,6 +116,18 @@ 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" Index: gdb/cr16-linux-tdep.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D RCS file: gdb/cr16-linux-tdep.c diff -N gdb/cr16-linux-tdep.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ gdb/cr16-linux-tdep.c 15 Jan 2013 07:30:06 -0000 @@ -0,0 +1,107 @@ +/* Target-dependent code for GNU/Linux on the Sitel CR16 processors. + + Copyright (C) 2013 Free Software Foundation, Inc. + + Contributed by Kaushik Phatak (kaushik.phatak@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 "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 }; + +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" +}; + +/* Verify register array size is within hardware register limit. */ + +gdb_static_assert (ARRAY_SIZE (reg_names) <=3D CR16_LINUX_NUM_REGS); + +/* Implement the "register_name" gdbarch method. */ + +static const char * +cr16_linux_register_name (struct gdbarch *gdbarch, int regnr) +{ + gdb_assert (regnr >=3D 0 && regnr < CR16_LINUX_NUM_REGS); + 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 + 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); +} Index: gdb/cr16-tdep.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D RCS file: gdb/cr16-tdep.c diff -N gdb/cr16-tdep.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ gdb/cr16-tdep.c 15 Jan 2013 07:30:07 -0000 @@ -0,0 +1,896 @@ +/* Target-dependent code for the Sitel CR16 for GDB, the GNU debugger. +=20 + Copyright (C) 2013 Free Software Foundation, Inc. +=20 + Contributed by Kaushik Phatak (kaushik.phatak@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 "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 }; + +/* 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]; +}; + +/* Hardware register name declaration. */ +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" +}; + +/* Verify register array size is within hardware register limit. */ + +gdb_static_assert (ARRAY_SIZE (reg_names) <=3D CR16_NUM_REGS); + +/* Implement the "register_name" gdbarch method. */ + +static const char * +cr16_register_name (struct gdbarch *gdbarch, int regnr) +{ + gdb_assert (regnr >=3D 0 && regnr < CR16_NUM_REGS); + 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: + case SIM_CR16_PSR_REGNUM: + case SIM_CR16_CFG_REGNUM: + return builtin_type (gdbarch)->builtin_int32; + 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: + return builtin_type (gdbarch)->builtin_int32; + break; + } +} + +/* Function for finding saved registers in a 'struct pv_area'; this + function is passed to pv_area_scan. + + 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 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) + { + gdb_byte buf[6]; + + /* Read 6 bytes, max 48 bit opcode. */ + target_read_memory (pc, buf, 6); + cr16_words[0] =3D buf[1] << 8 | buf[0]; + cr16_words[1] =3D buf[3] << 8 | buf[2]; + cr16_words[2] =3D buf[5] << 8 | buf[4]; + cr16_allWords =3D (((ULONGLONG) cr16_words[0] << 32) + + ((ULONGLONG) cr16_words[1] << 16) + + cr16_words[2]); + + /* Find a matching opcode in table. + Nonzero means instruction has a match. */ + is_decoded =3D cr16_match_opcode (); + cr16_make_instruction (); + length =3D cr16_currInsn.size; + next_pc =3D pc + length; + insn_byte1 =3D (cr16_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 cr16_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 cr16_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 cr16_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 cr16_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) + return *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); + + 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 + 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) + { + ULONGEST ra_prev; + + 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 +{ + 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) +{ + CORE_ADDR 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) +{ + CORE_ADDR 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); + 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. */ + 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); + 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); +} Index: gdb/cr16-tdep.h =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D RCS file: gdb/cr16-tdep.h diff -N gdb/cr16-tdep.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ gdb/cr16-tdep.h 15 Jan 2013 07:30:07 -0000 @@ -0,0 +1,32 @@ +/* GNU/Linux on CR16 target support. + Copyright (C) 2013 Free Software Foundation, Inc. + + Contributed by Kaushik Phatak (kaushik.phatak@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_C6CA53A2A46BA7469348BDBD663AB65848567829KCHJEXMB02kpitc_ Content-Type: application/octet-stream; name="cr16_gdb.diff" Content-Description: cr16_gdb.diff Content-Disposition: attachment; filename="cr16_gdb.diff"; size=32223; creation-date="Tue, 15 Jan 2013 08:38:36 GMT"; modification-date="Tue, 15 Jan 2013 09:19:33 GMT" Content-Transfer-Encoding: base64 Content-length: 43681 SW5kZXg6IGdkYi9jb25maWd1cmUudGd0Cj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KUkNTIGZpbGU6IC9jdnMvc3JjL3NyYy9nZGIvY29uZmlndXJlLnRndCx2 CnJldHJpZXZpbmcgcmV2aXNpb24gMS4yNjEKZGlmZiAtdSAtYSAtcjEuMjYx IGNvbmZpZ3VyZS50Z3QKLS0tIGdkYi9jb25maWd1cmUudGd0CTE4IERlYyAy MDEyIDE0OjUyOjU4IC0wMDAwCTEuMjYxCisrKyBnZGIvY29uZmlndXJlLnRn dAkxNSBKYW4gMjAxMyAwNzozMDowNiAtMDAwMApAQCAtMTE2LDYgKzExNiwx OCBAQAogCWdkYl9zaW09Li4vc2ltL2JmaW4vbGlic2ltLmEKIAk7OwogCitj cjE2Ki0qLSpsaW51eCkKKwkjIFRhcmdldDogQ1IxNiBwcm9jZXNzb3IKKwln ZGJfdGFyZ2V0X29icz0iY3IxNi10ZGVwLm8gY3IxNi1saW51eC10ZGVwLm8g bGludXgtdGRlcC5vIgorCWdkYl9zaW09Li4vc2ltL2NyMTYvbGlic2ltLmEK Kwk7OworCitjcjE2Ki0qLSopCisJIyBUYXJnZXQ6IENSMTYgcHJvY2Vzc29y CisJZ2RiX3RhcmdldF9vYnM9ImNyMTYtdGRlcC5vIgorCWdkYl9zaW09Li4v c2ltL2NyMTYvbGlic2ltLmEKKwk7OworCiBjcmlzKikKIAkjIFRhcmdldDog Q1JJUwogCWdkYl90YXJnZXRfb2JzPSJjcmlzLXRkZXAubyBzb2xpYi1zdnI0 Lm8iCkluZGV4OiBnZGIvY3IxNi1saW51eC10ZGVwLmMKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQpSQ1MgZmlsZTogZ2RiL2NyMTYtbGludXgtdGRlcC5jCmRp ZmYgLU4gZ2RiL2NyMTYtbGludXgtdGRlcC5jCi0tLSAvZGV2L251bGwJMSBK YW4gMTk3MCAwMDowMDowMCAtMDAwMAorKysgZ2RiL2NyMTYtbGludXgtdGRl cC5jCTE1IEphbiAyMDEzIDA3OjMwOjA2IC0wMDAwCkBAIC0wLDAgKzEsMTA3 IEBACisvKiBUYXJnZXQtZGVwZW5kZW50IGNvZGUgZm9yIEdOVS9MaW51eCBv biB0aGUgU2l0ZWwgQ1IxNiBwcm9jZXNzb3JzLgorCisgICBDb3B5cmlnaHQg KEMpIDIwMTMgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisKKyAg IENvbnRyaWJ1dGVkIGJ5IEthdXNoaWsgUGhhdGFrIChrYXVzaGlrLnBoYXRh a0BrcGl0Y3VtbWlucy5jb20pCisgICBLUElUIEN1bW1pbnMgSW5mb3N5c3Rl bXMgTGltaXRlZCwgUHVuZSBJbmRpYS4KKworICAgVGhpcyBmaWxlIGlzIHBh cnQgb2YgR0RCLgorCisgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICAg aXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2Us IG9yCisgICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor CisgICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1dCBXSVRIT1VUIEFOWSBX QVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlCisgICBHTlUgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhh dmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMg TGljZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3Qs IHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLworCisj aW5jbHVkZSAiZGVmcy5oIgorI2luY2x1ZGUgIm9zYWJpLmgiCisjaW5jbHVk ZSAiZWxmLWJmZC5oIgorI2luY2x1ZGUgImVsZi9jcjE2LmgiCisjaW5jbHVk ZSAibGludXgtdGRlcC5oIgorI2luY2x1ZGUgInN5bXRhYi5oIgorI2luY2x1 ZGUgImNyMTYtdGRlcC5oIgorCisvKiBOdW1iZXIgb2YgcmVnaXN0ZXJzIGF2 YWlsYWJsZSBmb3IgTGludXggdGFyZ2V0cyAgKi8KKyNkZWZpbmUgQ1IxNl9M SU5VWF9OVU1fUkVHUyAgMjEKKworLyogVGhlIGJyZWFrcG9pbnQgaW5zdHJ1 Y3Rpb24gdXNlZCBieSB1Q2xpbnV4IHRhcmdldCAgKi8KK3N0YXRpYyBjb25z dCBnZGJfYnl0ZSBicmVha3BvaW50X3VjbGludXhbXSA9IHsgMHhDNywgMHgw MCB9OworCitzdGF0aWMgY29uc3QgY2hhciAqY29uc3QgcmVnX25hbWVzW10g PQoreworICAicjAiLAorICAicjEiLAorICAicjIiLAorICAicjMiLAorICAi cjQiLAorICAicjUiLAorICAicjYiLAorICAicjciLAorICAicjgiLAorICAi cjkiLAorICAicjEwIiwKKyAgInIxMSIsCisgICJyMTIiLAorICAicjEzIiwK KyAgInJhIiwKKyAgInBzciIsCisgICJwYyIsCisgICJyMHIxX29yaWciLAor ICAiaW50YmFzZSIsCisgICJ1c3AiLAorICAiY2ZnIgorfTsKKworLyogVmVy aWZ5IHJlZ2lzdGVyIGFycmF5IHNpemUgaXMgd2l0aGluIGhhcmR3YXJlIHJl Z2lzdGVyIGxpbWl0LiAgKi8KKworZ2RiX3N0YXRpY19hc3NlcnQgKEFSUkFZ X1NJWkUgKHJlZ19uYW1lcykgPD0gQ1IxNl9MSU5VWF9OVU1fUkVHUyk7CisK Ky8qIEltcGxlbWVudCB0aGUgInJlZ2lzdGVyX25hbWUiIGdkYmFyY2ggbWV0 aG9kLiAgKi8KKworc3RhdGljIGNvbnN0IGNoYXIgKgorY3IxNl9saW51eF9y ZWdpc3Rlcl9uYW1lIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgaW50IHJl Z25yKQoreworICBnZGJfYXNzZXJ0IChyZWduciA+PSAwICYmIHJlZ25yIDwg Q1IxNl9MSU5VWF9OVU1fUkVHUyk7CisgIHJldHVybiByZWdfbmFtZXNbcmVn bnJdOworfQorCisvKiBPUyBzcGVjaWZpYyBpbml0aWFsaXphdGlvbiBvZiBn ZGJhcmNoLiAgKi8KKworc3RhdGljIHZvaWQKK2NyMTZfdWNsaW51eF9pbml0 X2FiaSAoc3RydWN0IGdkYmFyY2hfaW5mbyBpbmZvLCBzdHJ1Y3QgZ2RiYXJj aCAqZ2RiYXJjaCkKK3sKKyAgc3RydWN0IGdkYmFyY2hfdGRlcCAqdGRlcCA9 IGdkYmFyY2hfdGRlcCAoZ2RiYXJjaCk7CisKKyAgbGludXhfaW5pdF9hYmkg KGluZm8sIGdkYmFyY2gpOworCisgIHNldF9nZGJhcmNoX251bV9yZWdzIChn ZGJhcmNoLCBDUjE2X0xJTlVYX05VTV9SRUdTKTsKKyAgc2V0X2dkYmFyY2hf cmVnaXN0ZXJfbmFtZSAoZ2RiYXJjaCwgY3IxNl9saW51eF9yZWdpc3Rlcl9u YW1lKTsKKworICAvKiBUaGUgb3Bjb2RlIG9mIGV4Y3AgYnB0IGlzIDB4MDBD OCwgaG93ZXZlciBmb3IgdWNsaW51eCB3ZSB3aWxsCisgICAgIHVzZSB0aGUg ZXhjcCBmbGcgKDB4MDBDNykgdG8gaW5zZXJ0IGEgYnJlYWtwb2ludC4gIFRo ZSBleGNwIGJwdAorICAgICByZXF1aXJlcyBleHRlcm5hbCBoYXJkd2FyZSBz dXBwb3J0IGZvciBicmVha3BvaW50cyB0byB3b3JrIG9uCisgICAgIENSMTYg dGFyZ2V0LiAgU29mdHdhcmUgYmFzZWQgYnJlYWtwb2ludHMgYXJlIGltcGxl bWVudGVkIGluIHRoZQorICAgICBrZXJuZWwgdXNpbmcgZXhjcCBmbGcgYW5k IHRlc3RlZCBvbiB0aGUgU0MxNDQ1MiB0YXJnZXQuICBVc2UKKyAgICAgMHgw MEM3IHdpdGggZ2Ric2VydmVyL2tlcm5lbCBhbmQgMHgwMEM4IGZvciBzaW0v RUxGLiAgV2UKKyAgICAgcmVwcmVzZW50IHRoZSBicmVha3BvaW50IGluIGxp dHRsZSBlbmRpYW4gZm9ybWF0IHNpbmNlIENSMTYKKyAgICAgc3VwcG9ydHMg b25seSBsaXR0bGUgZW5kaWFuLiAgKi8KKyAgdGRlcC0+YnJlYWtwb2ludCA9 IGJyZWFrcG9pbnRfdWNsaW51eDsKKworfQorCisvKiBQcm92aWRlIGEgcHJv dG90eXBlIHRvIHNpbGVuY2UgLVdtaXNzaW5nLXByb3RvdHlwZXMuICAqLwor ZXh0ZXJuIGluaXRpYWxpemVfZmlsZV9mdHlwZSBfaW5pdGlhbGl6ZV9jcjE2 X2xpbnV4X3RkZXA7CisKK3ZvaWQKK19pbml0aWFsaXplX2NyMTZfbGludXhf dGRlcCAodm9pZCkKK3sKKyAgZ2RiYXJjaF9yZWdpc3Rlcl9vc2FiaSAoYmZk X2FyY2hfY3IxNiwgMCwgR0RCX09TQUJJX0xJTlVYLAorCQkJICBjcjE2X3Vj bGludXhfaW5pdF9hYmkpOworfQpJbmRleDogZ2RiL2NyMTYtdGRlcC5jCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6IGdkYi9jcjE2LXRkZXAu YwpkaWZmIC1OIGdkYi9jcjE2LXRkZXAuYwotLS0gL2Rldi9udWxsCTEgSmFu IDE5NzAgMDA6MDA6MDAgLTAwMDAKKysrIGdkYi9jcjE2LXRkZXAuYwkxNSBK YW4gMjAxMyAwNzozMDowNyAtMDAwMApAQCAtMCwwICsxLDg5NiBAQAorLyog VGFyZ2V0LWRlcGVuZGVudCBjb2RlIGZvciB0aGUgU2l0ZWwgQ1IxNiBmb3Ig R0RCLCB0aGUgR05VIGRlYnVnZ2VyLgorIAorICAgQ29weXJpZ2h0IChDKSAy MDEzIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLgorIAorICAgQ29u dHJpYnV0ZWQgYnkgS2F1c2hpayBQaGF0YWsgKGthdXNoaWsucGhhdGFrQGtw aXRjdW1taW5zLmNvbSkKKyAgIEtQSVQgQ3VtbWlucyBJbmZvc3lzdGVtcyBM aW1pdGVkLCBQdW5lIEluZGlhLgorICAgVGhpcyBmaWxlIGlzIHBhcnQgb2Yg R0RCLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgIGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5CisgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCisgIChh dCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgCisgIFRoaXMg cHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdp bGwgYmUgdXNlZnVsLAorICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCisgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgCisgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgIGFs b25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93 d3cuZ251Lm9yZy9saWNlbnNlcy8+LiAgKi8KKworI2luY2x1ZGUgImRlZnMu aCIKKyNpbmNsdWRlICJhcmNoLXV0aWxzLmgiCisjaW5jbHVkZSAicHJvbG9n dWUtdmFsdWUuaCIKKyNpbmNsdWRlICJ0YXJnZXQuaCIKKyNpbmNsdWRlICJy ZWdjYWNoZS5oIgorI2luY2x1ZGUgIm9wY29kZS9jcjE2LmgiCisjaW5jbHVk ZSAiZGlzLWFzbS5oIgorI2luY2x1ZGUgImdkYnR5cGVzLmgiCisjaW5jbHVk ZSAiZnJhbWUuaCIKKyNpbmNsdWRlICJmcmFtZS11bndpbmQuaCIKKyNpbmNs dWRlICJmcmFtZS1iYXNlLmgiCisjaW5jbHVkZSAidmFsdWUuaCIKKyNpbmNs dWRlICJnZGJjb3JlLmgiCisjaW5jbHVkZSAiZHdhcmYyLWZyYW1lLmgiCisj aW5jbHVkZSAiZ2RiL3NpbS1jcjE2LmgiCisjaW5jbHVkZSAiZWxmL2NyMTYu aCIKKyNpbmNsdWRlICJlbGYtYmZkLmgiCisjaW5jbHVkZSAib3NhYmkuaCIK KyNpbmNsdWRlICJjcjE2LXRkZXAuaCIKKworLyogTnVtYmVyIG9mIHJlZ2lz dGVycyBhdmFpbGFibGUgZm9yIEVMRiB0YXJnZXRzLiAgKi8KKyNkZWZpbmUg Q1IxNl9OVU1fUkVHUyAgMjIKKworLyogVGhlIGJyZWFrcG9pbnQgaW5zdHJ1 Y3Rpb24gdXNlZCB3aXRoIHNpbSBmb3IgRUxGIHRhcmdldHMuICAqLworc3Rh dGljIGNvbnN0IGdkYl9ieXRlIGJyZWFrcG9pbnRfZWxmW10gPSB7IDB4Qzgs IDB4MDAgfTsKKworLyogQ2VydGFpbiBpbXBvcnRhbnQgcmVnaXN0ZXIgbnVt YmVycy4gICovCitlbnVtCit7CisgIENSMTZfUjBfUkVHTlVNID0gMCwKKyAg Q1IxNl9SN19SRUdOVU0gPSA3LAorICBDUjE2X1IxMl9SRUdOVU0gPSAxMiwK KyAgQ1IxNl9GUF9SRUdOVU0gPSAxMywKKyAgQ1IxNl9SQV9SRUdOVU0gPSAx NCwKKyAgQ1IxNl9TUF9SRUdOVU0gPSAxNSwKKyAgQ1IxNl9QQ19SRUdOVU0g PSAxNiwKK307CisKKy8qIFRoaXMgc3RydWN0dXJlIGhvbGRzIHRoZSByZXN1 bHRzIG9mIGEgcHJvbG9ndWUgYW5hbHlzaXMuICAqLworc3RydWN0IGNyMTZf cHJvbG9ndWUKK3sKKyAgLyogVGhlIG9mZnNldCBmcm9tIHRoZSBmcmFtZSBi YXNlIHRvIHRoZSBzdGFjayBwb2ludGVyIC0tLSBhbHdheXMKKyAgICAgemVy byBvciBuZWdhdGl2ZS4KKworICAgICBDYWxsaW5nIHRoaXMgYSAic2l6ZSIg aXMgYSBiaXQgbWlzbGVhZGluZywgYnV0IGdpdmVuIHRoYXQgdGhlCisgICAg IHN0YWNrIGdyb3dzIGRvd253YXJkcywgdXNpbmcgb2Zmc2V0cyBmb3IgZXZl cnl0aGluZyBrZWVwcyBvbmUKKyAgICAgZnJvbSBnb2luZyBjb21wbGV0ZWx5 IHNpZ24tY3Jhenk6IHlvdSBuZXZlciBjaGFuZ2UgYW55dGhpbmcncworICAg ICBzaWduIGZvciBhbiBBREQgaW5zdHJ1Y3Rpb247IGFsd2F5cyBjaGFuZ2Ug dGhlIHNlY29uZCBvcGVyYW5kJ3MKKyAgICAgc2lnbiBmb3IgYSBTVUIgaW5z dHJ1Y3Rpb247IGFuZCBldmVyeXRoaW5nIHRha2VzIGNhcmUgb2YKKyAgICAg aXRzZWxmLiAgKi8KKyAgaW50IGZyYW1lX3NpemU7CisKKyAgLyogTm9uLXpl cm8gaWYgdGhpcyBmdW5jdGlvbiBoYXMgaW5pdGlhbGl6ZWQgdGhlIGZyYW1l IHBvaW50ZXIgZnJvbQorICAgICB0aGUgc3RhY2sgcG9pbnRlciwgemVybyBv dGhlcndpc2UuICAqLworICBpbnQgaGFzX2ZyYW1lX3B0cjsKKworICAvKiBJ ZiBoYXNfZnJhbWVfcHRyIGlzIG5vbi16ZXJvLCB0aGlzIGlzIHRoZSBvZmZz ZXQgZnJvbSB0aGUgZnJhbWUKKyAgICAgYmFzZSB0byB3aGVyZSB0aGUgZnJh bWUgcG9pbnRlciBwb2ludHMuICBUaGlzIGlzIGFsd2F5cyB6ZXJvIG9yCisg ICAgIG5lZ2F0aXZlLiAgKi8KKyAgaW50IGZyYW1lX3B0cl9vZmZzZXQ7CisK KyAgLyogVGhlIGFkZHJlc3Mgb2YgdGhlIGZpcnN0IGluc3RydWN0aW9uIGF0 IHdoaWNoIHRoZSBmcmFtZSBoYXMgYmVlbgorICAgICBzZXQgdXAgYW5kIHRo ZSBhcmd1bWVudHMgYXJlIHdoZXJlIHRoZSBkZWJ1ZyBpbmZvIHNheXMgdGhl eSBhcmUKKyAgICAgLS0tIGFzIGJlc3QgYXMgd2UgY2FuIHRlbGwuICAqLwor ICBDT1JFX0FERFIgcHJvbG9ndWVfZW5kOworCisgIC8qIHJlZ19vZmZzZXRb Ul0gaXMgdGhlIG9mZnNldCBmcm9tIHRoZSBDRkEgYXQgd2hpY2ggcmVnaXN0 ZXIgUiBpcworICAgICBzYXZlZCwgb3IgMSBpZiByZWdpc3RlciBSIGhhcyBu b3QgYmVlbiBzYXZlZC4gIChSZWFsIHZhbHVlcyBhcmUKKyAgICAgYWx3YXlz IHplcm8gb3IgbmVnYXRpdmUuKSAgKi8KKyAgaW50IHJlZ19vZmZzZXRbQ1Ix Nl9OVU1fUkVHU107Cit9OworCisvKiBIYXJkd2FyZSByZWdpc3RlciBuYW1l IGRlY2xhcmF0aW9uLiAgKi8KK3N0YXRpYyBjb25zdCBjaGFyICpjb25zdCBy ZWdfbmFtZXNbXSA9Cit7CisgICJyMCIsCisgICJyMSIsCisgICJyMiIsCisg ICJyMyIsCisgICJyNCIsCisgICJyNSIsCisgICJyNiIsCisgICJyNyIsCisg ICJyOCIsCisgICJyOSIsCisgICJyMTAiLAorICAicjExIiwKKyAgInIxMiIs CisgICJyMTMiLAorICAicmEiLAorICAic3AiLAorICAicGMiLAorICAiaXNw IiwKKyAgInVzcCIsCisgICJpbnRiYXNlIiwKKyAgInBzciIsCisgICJjZmci Cit9OworCisvKiBWZXJpZnkgcmVnaXN0ZXIgYXJyYXkgc2l6ZSBpcyB3aXRo aW4gaGFyZHdhcmUgcmVnaXN0ZXIgbGltaXQuICAqLworCitnZGJfc3RhdGlj X2Fzc2VydCAoQVJSQVlfU0laRSAocmVnX25hbWVzKSA8PSBDUjE2X05VTV9S RUdTKTsKKworLyogSW1wbGVtZW50IHRoZSAicmVnaXN0ZXJfbmFtZSIgZ2Ri YXJjaCBtZXRob2QuICAqLworCitzdGF0aWMgY29uc3QgY2hhciAqCitjcjE2 X3JlZ2lzdGVyX25hbWUgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBpbnQg cmVnbnIpCit7CisgIGdkYl9hc3NlcnQgKHJlZ25yID49IDAgJiYgcmVnbnIg PCBDUjE2X05VTV9SRUdTKTsKKyAgcmV0dXJuIHJlZ19uYW1lc1tyZWducl07 Cit9CisKKy8qIEltcGxlbWVudCB0aGUgInJlZ2lzdGVyX3R5cGUiIGdkYmFy Y2ggbWV0aG9kLiAgKi8KKworc3RhdGljIHN0cnVjdCB0eXBlICoKK2NyMTZf cmVnaXN0ZXJfdHlwZSAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIGludCBy ZWdfbnIpCit7CisgIHN3aXRjaCAocmVnX25yKQorICAgIHsKKyAgICBjYXNl IENSMTZfUENfUkVHTlVNOgkvKiBOb3RlOiBQQyBpbiBDUjE2IGlzIG9mIDI0 IGJpdHMuICAqLworICAgICAgcmV0dXJuIGJ1aWx0aW5fdHlwZSAoZ2RiYXJj aCktPmJ1aWx0aW5fZnVuY19wdHI7CisKKyAgICBjYXNlIENSMTZfUkFfUkVH TlVNOgkvKiBSZXR1cm4gYWRkcmVzcyByZWcuICAqLworICAgICAgcmV0dXJu IGJ1aWx0aW5fdHlwZSAoZ2RiYXJjaCktPmJ1aWx0aW5fZGF0YV9wdHI7Cisg ICAgICBicmVhazsKKworICAgIGNhc2UgQ1IxNl9GUF9SRUdOVU06CS8qIEZy YW1lIFBvaW50ZXIgcmVnLiAgKi8KKyAgICBjYXNlIENSMTZfU1BfUkVHTlVN OgkvKiBTdGFjayBQb2ludGVyIHJlZy4gICovCisgICAgICByZXR1cm4gYnVp bHRpbl90eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9kYXRhX3B0cjsKKyAgICAg IGJyZWFrOworCisgICAgY2FzZSBTSU1fQ1IxNl9JU1BfUkVHTlVNOgorICAg IGNhc2UgU0lNX0NSMTZfVVNQX1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2 X0lOVEJBU0VfUkVHTlVNOgorICAgIGNhc2UgU0lNX0NSMTZfUFNSX1JFR05V TToKKyAgICBjYXNlIFNJTV9DUjE2X0NGR19SRUdOVU06CisgICAgICByZXR1 cm4gYnVpbHRpbl90eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9pbnQzMjsKKyAg ICAgIGJyZWFrOworCisgICAgY2FzZSBTSU1fQ1IxNl9SMF9SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9SMV9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1Ix Nl9SMl9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SM19SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9SNF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1Ix Nl9SNV9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SNl9SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9SN19SRUdOVU06CisgICAgY2FzZSBTSU1fQ1Ix Nl9SOF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SOV9SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9SMTBfUkVHTlVNOgorICAgIGNhc2UgU0lNX0NS MTZfUjExX1JFR05VTToKKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUgKGdk YmFyY2gpLT5idWlsdGluX2ludDE2OworICAgICAgYnJlYWs7CisKKyAgICBj YXNlIFNJTV9DUjE2X1IxMl9SRUdOVU06CisgICAgICByZXR1cm4gYnVpbHRp bl90eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9pbnQzMjsKKyAgICAgIGJyZWFr OworCisgICAgZGVmYXVsdDoKKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUg KGdkYmFyY2gpLT5idWlsdGluX2ludDMyOworICAgICAgYnJlYWs7CisgICAg fQorfQorCisvKiBGdW5jdGlvbiBmb3IgZmluZGluZyBzYXZlZCByZWdpc3Rl cnMgaW4gYSAnc3RydWN0IHB2X2FyZWEnOyB0aGlzCisgICBmdW5jdGlvbiBp cyBwYXNzZWQgdG8gcHZfYXJlYV9zY2FuLgorCisgICBJZiBWQUxVRSBpcyBh IHNhdmVkIHJlZ2lzdGVyLCBBRERSIHNheXMgaXQgd2FzIHNhdmVkIGF0IGEg Y29uc3RhbnQKKyAgIG9mZnNldCBmcm9tIHRoZSBmcmFtZSBiYXNlLCBhbmQg U0laRSBpbmRpY2F0ZXMgdGhhdCB0aGUgd2hvbGUKKyAgIHJlZ2lzdGVyIHdh cyBzYXZlZCwgcmVjb3JkIGl0cyBvZmZzZXQuICAqLworCitzdGF0aWMgdm9p ZAorY2hlY2tfZm9yX3NhdmVkICh2b2lkICpyZXN1bHRfdW50eXBlZCwgcHZf dCBhZGRyLCBDT1JFX0FERFIgc2l6ZSwgcHZfdCB2YWx1ZSkKK3sKKyAgc3Ry dWN0IGNyMTZfcHJvbG9ndWUgKnJlc3VsdCA9IChzdHJ1Y3QgY3IxNl9wcm9s b2d1ZSAqKSByZXN1bHRfdW50eXBlZDsKKworICBpZiAodmFsdWUua2luZCA9 PSBwdmtfcmVnaXN0ZXIKKyAgICAgICYmIHZhbHVlLmsgPT0gMAorICAgICAg JiYgcHZfaXNfcmVnaXN0ZXIgKGFkZHIsIENSMTZfU1BfUkVHTlVNKQorICAg ICAgJiYgc2l6ZSA9PSByZWdpc3Rlcl9zaXplICh0YXJnZXRfZ2RiYXJjaCgp LCB2YWx1ZS5yZWcpKQorICAgIHJlc3VsdC0+cmVnX29mZnNldFt2YWx1ZS5y ZWddID0gYWRkci5rOworfQorCisvKiBEZWZpbmUgYSAiaGFuZGxlIiBzdHJ1 Y3QgZm9yIGZldGNoaW5nIHRoZSBuZXh0IG9wY29kZS4gICovCisKK3N0cnVj dCBjcjE2X2dldF9vcGNvZGVfYnl0ZV9oYW5kbGUKK3sKKyAgQ09SRV9BRERS IHBjOworfTsKKworLyogQW5hbHl6ZSBhIHByb2xvZ3VlIHN0YXJ0aW5nIGF0 IFNUQVJUX1BDLCBnb2luZyBubyBmdXJ0aGVyIHRoYW4KKyAgIExJTUlUX1BD LiAgRmlsbCBpbiBSRVNVTFQgYXMgYXBwcm9wcmlhdGUuICAqLworCitzdGF0 aWMgdm9pZAorY3IxNl9hbmFseXplX3Byb2xvZ3VlIChDT1JFX0FERFIgc3Rh cnRfcGMsCisJCSAgICAgICBDT1JFX0FERFIgbGltaXRfcGMsIHN0cnVjdCBj cjE2X3Byb2xvZ3VlICpyZXN1bHQpCit7CisgIENPUkVfQUREUiBwYywgbmV4 dF9wYzsKKyAgZ2RiX2J5dGUgaW5zbl9ieXRlMSwgaW5zbl9ieXRlMjsKKyAg aW50IHJuOworICBpbnQgbGVuZ3RoOworICBwdl90IHJlZ1tDUjE2X05VTV9S RUdTXTsKKyAgc3RydWN0IHB2X2FyZWEgKnN0YWNrOworICBzdHJ1Y3QgY2xl YW51cCAqYmFja190bzsKKyAgQ09SRV9BRERSIGFmdGVyX2xhc3RfZnJhbWVf c2V0dXBfaW5zbiA9IHN0YXJ0X3BjOworICBpbnQgaXNfZGVjb2RlZDsKKwor ICBtZW1zZXQgKHJlc3VsdCwgMCwgc2l6ZW9mICgqcmVzdWx0KSk7CisKKyAg Zm9yIChybiA9IDA7IHJuIDwgQ1IxNl9OVU1fUkVHUzsgcm4rKykKKyAgICB7 CisgICAgICByZWdbcm5dID0gcHZfcmVnaXN0ZXIgKHJuLCAwKTsKKyAgICAg IHJlc3VsdC0+cmVnX29mZnNldFtybl0gPSAxOworICAgIH0KKworICBzdGFj ayA9IG1ha2VfcHZfYXJlYSAoQ1IxNl9TUF9SRUdOVU0sIGdkYmFyY2hfYWRk cl9iaXQgKHRhcmdldF9nZGJhcmNoKCkpKTsKKyAgYmFja190byA9IG1ha2Vf Y2xlYW51cF9mcmVlX3B2X2FyZWEgKHN0YWNrKTsKKworICBwYyA9IHN0YXJ0 X3BjOworICB3aGlsZSAocGMgPCBsaW1pdF9wYykKKyAgICB7CisgICAgICBn ZGJfYnl0ZSBidWZbNl07CisKKyAgICAgIC8qIFJlYWQgNiBieXRlcywgbWF4 IDQ4IGJpdCBvcGNvZGUuICAqLworICAgICAgdGFyZ2V0X3JlYWRfbWVtb3J5 IChwYywgYnVmLCA2KTsKKyAgICAgIGNyMTZfd29yZHNbMF0gPSBidWZbMV0g PDwgOCB8IGJ1ZlswXTsKKyAgICAgIGNyMTZfd29yZHNbMV0gPSBidWZbM10g PDwgOCB8IGJ1ZlsyXTsKKyAgICAgIGNyMTZfd29yZHNbMl0gPSBidWZbNV0g PDwgOCB8IGJ1Zls0XTsKKyAgICAgIGNyMTZfYWxsV29yZHMgPSAoKChVTE9O R0xPTkcpIGNyMTZfd29yZHNbMF0gPDwgMzIpCisJCSAgICAgICsgKChVTE9O R0xPTkcpIGNyMTZfd29yZHNbMV0gPDwgMTYpCisJCSAgICAgICsgY3IxNl93 b3Jkc1syXSk7CisKKyAgICAgIC8qIEZpbmQgYSBtYXRjaGluZyBvcGNvZGUg aW4gdGFibGUuCisgICAgICAgICBOb256ZXJvIG1lYW5zIGluc3RydWN0aW9u IGhhcyBhIG1hdGNoLiAgKi8KKyAgICAgIGlzX2RlY29kZWQgPSBjcjE2X21h dGNoX29wY29kZSAoKTsKKyAgICAgIGNyMTZfbWFrZV9pbnN0cnVjdGlvbiAo KTsKKyAgICAgIGxlbmd0aCA9IGNyMTZfY3Vyckluc24uc2l6ZTsKKyAgICAg IG5leHRfcGMgPSBwYyArIGxlbmd0aDsKKyAgICAgIGluc25fYnl0ZTEgPSAo Y3IxNl93b3Jkc1swXSA+PiA4KSAmIDB4RkY7CisKKyAgICAgIC8qIElmIFBV U0gsIHRoZW4gc2F2ZSBSQSBhbmQgb3RoZXIgcmVncy4gICovCisgICAgICBp ZiAoaW5zbl9ieXRlMSA9PSAweDAxKQorCXsKKwkgIGludCByMSwgcjI7CisJ ICBpbnQgcjsKKworCSAgaW5zbl9ieXRlMiA9IGNyMTZfd29yZHNbMF07CisK KwkgIGlmIChpbnNuX2J5dGUyICYgMHg4MCkKKwkgICAgeworCSAgICAgIHJl Z1tDUjE2X1NQX1JFR05VTV0gPSBwdl9hZGRfY29uc3RhbnQgKHJlZ1tDUjE2 X1NQX1JFR05VTV0sIC00KTsKKwkgICAgICBwdl9hcmVhX3N0b3JlIChzdGFj aywgcmVnW0NSMTZfU1BfUkVHTlVNXSwgNCwKKwkJCSAgICAgcmVnW0NSMTZf UkFfUkVHTlVNXSk7CisJICAgIH0KKwkgIC8qIFN0YXJ0IFJlZ2lzdGVyPXIx LCAzIGJpdCBpbW0gY291bnQ9cjIuICAqLworCSAgcjEgPSBpbnNuX2J5dGUy ICYgMHgwRjsKKwkgIHIyID0gKChpbnNuX2J5dGUyICYgMHg3MCkgPj4gNCk7 CisJICByMiA9IHIyICsgcjEgKyAxOworCisJICBmb3IgKHIgPSByMTsgciA8 IHIyOyByKyspCisJICAgIHsKKwkgICAgICBpZiAociA+PSBDUjE2X1IxMl9S RUdOVU0pCisJCXsKKwkJICByZWdbQ1IxNl9TUF9SRUdOVU1dID0KKwkJICAg IHB2X2FkZF9jb25zdGFudCAocmVnW0NSMTZfU1BfUkVHTlVNXSwgLTQpOwor CQkgIHB2X2FyZWFfc3RvcmUgKHN0YWNrLCByZWdbQ1IxNl9TUF9SRUdOVU1d LCA0LCByZWdbcl0pOworCQkgIHIrKzsKKwkJfQorCSAgICAgIGVsc2UKKwkJ eworCQkgIHJlZ1tDUjE2X1NQX1JFR05VTV0gPQorCQkgICAgcHZfYWRkX2Nv bnN0YW50IChyZWdbQ1IxNl9TUF9SRUdOVU1dLCAtMik7CisJCSAgcHZfYXJl YV9zdG9yZSAoc3RhY2ssIHJlZ1tDUjE2X1NQX1JFR05VTV0sIDIsIHJlZ1ty XSk7CisJCX0KKwkgICAgfQorCSAgYWZ0ZXJfbGFzdF9mcmFtZV9zZXR1cF9p bnNuID0gbmV4dF9wYzsKKwl9CisgICAgICAvKiBBZGQgY29uc3RhbnQgdG8g U1AuICAqLworICAgICAgZWxzZSBpZiAoaW5zbl9ieXRlMSA9PSAweDYwKQor CXsKKwkgIGludCByZHN0OworCSAgc2lnbmVkIHNob3J0IGFkZGVuZDsKKwor CSAgaW5zbl9ieXRlMiA9IGNyMTZfd29yZHNbMF07CisJICByZHN0ID0gaW5z bl9ieXRlMiAmIDB4MEY7CisJICBpZiAocmRzdCA9PSBDUjE2X1NQX1JFR05V TSkKKwkgICAgeworCSAgICAgIGlmIChsZW5ndGggPT0gMikKKwkJeworCQkg IGFkZGVuZCA9IChpbnNuX2J5dGUyICYgMHhGMCkgPj4gNDsKKwkJICByZWdb cmRzdF0gPSBwdl9hZGRfY29uc3RhbnQgKHJlZ1tyZHN0XSwgYWRkZW5kKTsK KwkJfQorCSAgICAgIGlmIChsZW5ndGggPT0gNCkKKwkJeworCQkgIGFkZGVu ZCA9IGNyMTZfd29yZHNbMV07CisJCSAgcmVnW3Jkc3RdID0gcHZfYWRkX2Nv bnN0YW50IChyZWdbcmRzdF0sIGFkZGVuZCk7CisJCX0KKwkgICAgICBhZnRl cl9sYXN0X2ZyYW1lX3NldHVwX2luc24gPSBuZXh0X3BjOworCSAgICB9CisJ fQorICAgICAgLyogQ2hlY2sgZm9yIE1PVkQgaW5zbi4gICovCisgICAgICBl bHNlIGlmIChpbnNuX2J5dGUxID09IDB4NTUpCisJeworCSAgaW50IHJkc3Qs IHJzcmM7CisKKwkgIGluc25fYnl0ZTIgPSBjcjE2X3dvcmRzWzBdOworCSAg cnNyYyA9IChpbnNuX2J5dGUyICYgMHhGMCkgPj4gNDsKKwkgIHJkc3QgPSAo aW5zbl9ieXRlMiAmIDB4MEYpOworCSAgcmVnW3Jkc3RdID0gcmVnW3JzcmNd OworCSAgaWYgKHJzcmMgPT0gQ1IxNl9TUF9SRUdOVU0gJiYgcmRzdCA9PSBD UjE2X0ZQX1JFR05VTSkKKwkgICAgYWZ0ZXJfbGFzdF9mcmFtZV9zZXR1cF9p bnNuID0gbmV4dF9wYzsKKwl9CisgICAgICBlbHNlIGlmICgoKGluc25fYnl0 ZTEgPj4gNCkgJiAweDBGKSA9PSAweGQpCisJeworCSAgLyogVGhpcyBtb3Zl cyBhbiBhcmd1bWVudCByZWdpc3RlciB0byB0aGUgc3RhY2suICBEb24ndAor CSAgICAgcmVjb3JkIGl0LCBidXQgYWxsb3cgaXQgdG8gYmUgYSBwYXJ0IG9m IHRoZSBwcm9sb2d1ZS4gICovCisJICBhZnRlcl9sYXN0X2ZyYW1lX3NldHVw X2luc24gPSBuZXh0X3BjOworCX0KKyAgICAgIGVsc2UKKwlicmVhazsJCS8q IFRlcm1pbmF0ZSB0aGUgcHJvbG9ndWUgc2Nhbi4gICovCisKKyAgICAgIHBj ID0gbmV4dF9wYzsKKyAgICB9CisKKyAgLyogSXMgdGhlIGZyYW1lIHNpemUg KG9mZnNldCwgcmVhbGx5KSBhIGtub3duIGNvbnN0YW50PyAgKi8KKyAgaWYg KHB2X2lzX3JlZ2lzdGVyIChyZWdbQ1IxNl9TUF9SRUdOVU1dLCBDUjE2X1NQ X1JFR05VTSkpCisgICAgcmVzdWx0LT5mcmFtZV9zaXplID0gcmVnW0NSMTZf U1BfUkVHTlVNXS5rOworCisgIC8qIFdhcyB0aGUgZnJhbWUgcG9pbnRlciBp bml0aWFsaXplZD8gICovCisgIGlmIChwdl9pc19yZWdpc3RlciAocmVnW0NS MTZfRlBfUkVHTlVNXSwgQ1IxNl9TUF9SRUdOVU0pKQorICAgIHsKKyAgICAg IHJlc3VsdC0+aGFzX2ZyYW1lX3B0ciA9IDE7CisgICAgICByZXN1bHQtPmZy YW1lX3B0cl9vZmZzZXQgPSByZWdbQ1IxNl9GUF9SRUdOVU1dLms7CisgICAg fQorCisgIC8qIFJlY29yZCB3aGVyZSBhbGwgdGhlIHJlZ2lzdGVycyB3ZXJl IHNhdmVkLiAgKi8KKyAgcHZfYXJlYV9zY2FuIChzdGFjaywgY2hlY2tfZm9y X3NhdmVkLCAodm9pZCAqKSByZXN1bHQpOworCisgIHJlc3VsdC0+cHJvbG9n dWVfZW5kID0gYWZ0ZXJfbGFzdF9mcmFtZV9zZXR1cF9pbnNuOworICBkb19j bGVhbnVwcyAoYmFja190byk7Cit9CisKKworLyogSW1wbGVtZW50IHRoZSAi c2tpcF9wcm9sb2d1ZSIgZ2RiYXJjaCBtZXRob2QuICAqLworCitzdGF0aWMg Q09SRV9BRERSCitjcjE2X3NraXBfcHJvbG9ndWUgKHN0cnVjdCBnZGJhcmNo ICpnZGJhcmNoLCBDT1JFX0FERFIgcGMpCit7CisgIGNvbnN0IGNoYXIgKm5h bWU7CisgIENPUkVfQUREUiBmdW5jX2FkZHIsIGZ1bmNfZW5kOworICBzdHJ1 Y3QgY3IxNl9wcm9sb2d1ZSBwOworCisgIC8qIFRyeSB0byBmaW5kIHRoZSBl eHRlbnQgb2YgdGhlIGZ1bmN0aW9uIHRoYXQgY29udGFpbnMgUEMuICAqLwor ICBpZiAoIWZpbmRfcGNfcGFydGlhbF9mdW5jdGlvbiAocGMsICZuYW1lLCAm ZnVuY19hZGRyLCAmZnVuY19lbmQpKQorICAgIHJldHVybiBwYzsKKworICBj cjE2X2FuYWx5emVfcHJvbG9ndWUgKHBjLCBmdW5jX2VuZCwgJnApOworICBy ZXR1cm4gcC5wcm9sb2d1ZV9lbmQ7Cit9CisKKy8qIEdpdmVuIGEgZnJhbWUg ZGVzY3JpYmVkIGJ5IFRISVNfRlJBTUUsIGRlY29kZSB0aGUgcHJvbG9ndWUg b2YgaXRzCisgICBhc3NvY2lhdGVkIGZ1bmN0aW9uIGlmIHRoZXJlIGlzIG5v dCBjYWNoZSBlbnRyeSBhcyBzcGVjaWZpZWQgYnkKKyAgIFRISVNfUFJPTE9H VUVfQ0FDSEUuICBTYXZlIHRoZSBkZWNvZGVkIHByb2xvZ3VlIGluIHRoZSBj YWNoZSBhbmQKKyAgIHJldHVybiB0aGF0IHN0cnVjdCBhcyB0aGUgdmFsdWUg b2YgdGhpcyBmdW5jdGlvbi4gICovCisKK3N0YXRpYyBzdHJ1Y3QgY3IxNl9w cm9sb2d1ZSAqCitjcjE2X2FuYWx5emVfZnJhbWVfcHJvbG9ndWUgKHN0cnVj dCBmcmFtZV9pbmZvICp0aGlzX2ZyYW1lLAorCQkJICAgICB2b2lkICoqdGhp c19wcm9sb2d1ZV9jYWNoZSkKK3sKKyAgaWYgKCp0aGlzX3Byb2xvZ3VlX2Nh Y2hlKQorICAgIHJldHVybiAqdGhpc19wcm9sb2d1ZV9jYWNoZTsKKworICBD T1JFX0FERFIgZnVuY19zdGFydCwgc3RvcF9hZGRyOworCisgICp0aGlzX3By b2xvZ3VlX2NhY2hlID0gRlJBTUVfT0JTVEFDS19aQUxMT0MgKHN0cnVjdCBj cjE2X3Byb2xvZ3VlKTsKKyAgZnVuY19zdGFydCA9IGdldF9mcmFtZV9mdW5j ICh0aGlzX2ZyYW1lKTsKKyAgc3RvcF9hZGRyID0gZ2V0X2ZyYW1lX3BjICh0 aGlzX2ZyYW1lKTsKKworIC8qIElmIHdlIGNvdWxkbid0IGZpbmQgYW55IGZ1 bmN0aW9uIGNvbnRhaW5pbmcgdGhlIFBDLCB0aGVuCisgICAgIGp1c3QgaW5p dGlhbGl6ZSB0aGUgcHJvbG9ndWUgY2FjaGUsIGJ1dCBkb24ndCBkbyBhbnl0 aGluZy4gICovCisgIGlmICghZnVuY19zdGFydCkKKyAgICBzdG9wX2FkZHIg PSBmdW5jX3N0YXJ0OworCisgIGNyMTZfYW5hbHl6ZV9wcm9sb2d1ZSAoZnVu Y19zdGFydCwgc3RvcF9hZGRyLCAqdGhpc19wcm9sb2d1ZV9jYWNoZSk7CisK KyAgcmV0dXJuICp0aGlzX3Byb2xvZ3VlX2NhY2hlOworfQorCisvKiBHaXZl biB0aGUgbmV4dCBmcmFtZSBhbmQgYSBwcm9sb2d1ZSBjYWNoZSwgcmV0dXJu IHRoaXMgZnJhbWUncworICAgYmFzZS4gICovCisKK3N0YXRpYyBDT1JFX0FE RFIKK2NyMTZfZnJhbWVfYmFzZSAoc3RydWN0IGZyYW1lX2luZm8gKnRoaXNf ZnJhbWUsIHZvaWQgKip0aGlzX3Byb2xvZ3VlX2NhY2hlKQoreworICBzdHJ1 Y3QgY3IxNl9wcm9sb2d1ZSAqcAorICAgID0gY3IxNl9hbmFseXplX2ZyYW1l X3Byb2xvZ3VlICh0aGlzX2ZyYW1lLCB0aGlzX3Byb2xvZ3VlX2NhY2hlKTsK KworICAvKiBJbiBmdW5jdGlvbnMgdGhhdCB1c2UgYWxsb2NhLCB0aGUgZGlz dGFuY2UgYmV0d2VlbiB0aGUgc3RhY2sKKyAgICAgcG9pbnRlciBhbmQgdGhl IGZyYW1lIGJhc2UgdmFyaWVzIGR5bmFtaWNhbGx5LCBzbyB3ZSBjYW4ndCB1 c2UKKyAgICAgdGhlIFNQIHBsdXMgc3RhdGljIGluZm9ybWF0aW9uIGxpa2Ug cHJvbG9ndWUgYW5hbHlzaXMgdG8gZmluZCB0aGUKKyAgICAgZnJhbWUgYmFz ZS4gIEhvd2V2ZXIsIHN1Y2ggZnVuY3Rpb25zIG11c3QgaGF2ZSBhIGZyYW1l IHBvaW50ZXIsCisgICAgIHRvIGJlIGFibGUgdG8gcmVzdG9yZSB0aGUgU1Ag b24gZXhpdC4gIFNvIHdoZW5ldmVyIHdlIGRvIGhhdmUgYQorICAgICBmcmFt ZSBwb2ludGVyLCB1c2UgdGhhdCB0byBmaW5kIHRoZSBiYXNlLiAgKi8KKyAg aWYgKHAtPmhhc19mcmFtZV9wdHIpCisgICAgeworICAgICAgQ09SRV9BRERS IGZwID0gZ2V0X2ZyYW1lX3JlZ2lzdGVyX3Vuc2lnbmVkICh0aGlzX2ZyYW1l LCBDUjE2X0ZQX1JFR05VTSk7CisKKyAgICAgIHJldHVybiBmcCAtIHAtPmZy YW1lX3B0cl9vZmZzZXQ7CisgICAgfQorICBlbHNlCisgICAgeworICAgICAg Q09SRV9BRERSIHNwID0gZ2V0X2ZyYW1lX3JlZ2lzdGVyX3Vuc2lnbmVkICh0 aGlzX2ZyYW1lLCBDUjE2X1NQX1JFR05VTSk7CisKKyAgICAgIHJldHVybiBz cCAtIHAtPmZyYW1lX3NpemU7CisgICAgfQorfQorCisvKiBJbXBsZW1lbnQg dGhlICJmcmFtZV90aGlzX2lkIiBtZXRob2QgZm9yIHVud2luZGluZyBmcmFt ZXMuICAqLworCitzdGF0aWMgdm9pZAorY3IxNl9mcmFtZV90aGlzX2lkIChz dHJ1Y3QgZnJhbWVfaW5mbyAqdGhpc19mcmFtZSwKKwkJICAgIHZvaWQgKip0 aGlzX3Byb2xvZ3VlX2NhY2hlLCBzdHJ1Y3QgZnJhbWVfaWQgKnRoaXNfaWQp Cit7CisgICp0aGlzX2lkID0KKyAgICBmcmFtZV9pZF9idWlsZCAoY3IxNl9m cmFtZV9iYXNlICh0aGlzX2ZyYW1lLCB0aGlzX3Byb2xvZ3VlX2NhY2hlKSwK KwkJICAgIGdldF9mcmFtZV9mdW5jICh0aGlzX2ZyYW1lKSk7Cit9CisKKy8q IEltcGxlbWVudCB0aGUgImZyYW1lX3ByZXZfcmVnaXN0ZXIiIG1ldGhvZCBm b3IgdW53aW5kaW5nIGZyYW1lcy4gICovCisKK3N0YXRpYyBzdHJ1Y3QgdmFs dWUgKgorY3IxNl9mcmFtZV9wcmV2X3JlZ2lzdGVyIChzdHJ1Y3QgZnJhbWVf aW5mbyAqdGhpc19mcmFtZSwKKwkJCSAgdm9pZCAqKnRoaXNfcHJvbG9ndWVf Y2FjaGUsIGludCByZWdudW0pCit7CisgIHN0cnVjdCBjcjE2X3Byb2xvZ3Vl ICpwID0KKyAgICBjcjE2X2FuYWx5emVfZnJhbWVfcHJvbG9ndWUgKHRoaXNf ZnJhbWUsIHRoaXNfcHJvbG9ndWVfY2FjaGUpOworICBDT1JFX0FERFIgZnJh bWVfYmFzZSA9IGNyMTZfZnJhbWVfYmFzZSAodGhpc19mcmFtZSwgdGhpc19w cm9sb2d1ZV9jYWNoZSk7CisKKyAgaWYgKHJlZ251bSA9PSBDUjE2X1NQX1JF R05VTSkKKyAgICByZXR1cm4gZnJhbWVfdW53aW5kX2dvdF9jb25zdGFudCAo dGhpc19mcmFtZSwgcmVnbnVtLCBmcmFtZV9iYXNlKTsKKworICAvKiBUaGUg Y2FsbCBpbnN0cnVjdGlvbiBoYXMgc2F2ZWQgdGhlIHJldHVybiBhZGRyZXNz IG9uIHRoZSBSQQorICAgICByZWdpc3RlciwgQ1IxNl9SMTNfUkVHTlVNLiAg U28sIHdlIG5lZWQgbm90IGFkanVzdCBhbnl0aGluZworICAgICBkaXJlY3Rs eS4gIFdlIHdpbGwgYW5hbHl6ZSBwcm9sb2d1ZSBhcyB0aGlzIFJBIHJlZ2lz dGVyIGlzCisgICAgIHB1c2hlZCBvbnRvIHN0YWNrIGZvciBmdXJ0aGVyIGxl YWYgZnVuY3Rpb24gY2FsbHMgdG8gd29yay4gICovCisgIGVsc2UgaWYgKHJl Z251bSA9PSBDUjE2X1BDX1JFR05VTSkKKyAgICB7CisgICAgICBVTE9OR0VT VCByYV9wcmV2OworCisgICAgICByYV9wcmV2ID0gZnJhbWVfdW53aW5kX3Jl Z2lzdGVyX3Vuc2lnbmVkICh0aGlzX2ZyYW1lLCBDUjE2X1JBX1JFR05VTSk7 CisgICAgICByYV9wcmV2ID0gcmFfcHJldiA8PCAxOworICAgICAgcmV0dXJu IGZyYW1lX3Vud2luZF9nb3RfY29uc3RhbnQgKHRoaXNfZnJhbWUsIENSMTZf UENfUkVHTlVNLCByYV9wcmV2KTsKKyAgICB9CisKKyAgLyogSWYgcHJvbG9n dWUgYW5hbHlzaXMgc2F5cyB3ZSBzYXZlZCB0aGlzIHJlZ2lzdGVyIHNvbWV3 aGVyZSwKKyAgICAgcmV0dXJuIGEgZGVzY3JpcHRpb24gb2YgdGhlIHN0YWNr IHNsb3QgaG9sZGluZyBpdC4gICovCisgIGVsc2UgaWYgKHAtPnJlZ19vZmZz ZXRbcmVnbnVtXSAhPSAxKQorICAgICAgcmV0dXJuIGZyYW1lX3Vud2luZF9n b3RfbWVtb3J5ICh0aGlzX2ZyYW1lLCByZWdudW0sCisJCQkJICAgICAgZnJh bWVfYmFzZSArIHAtPnJlZ19vZmZzZXRbcmVnbnVtXSk7CisKKyAgLyogT3Ro ZXJ3aXNlLCBwcmVzdW1lIHdlIGhhdmVuJ3QgY2hhbmdlZCB0aGUgdmFsdWUg b2YgdGhpcworICAgICByZWdpc3RlciwgYW5kIGdldCBpdCBmcm9tIHRoZSBu ZXh0IGZyYW1lLiAgKi8KKyAgZWxzZQorICAgICAgcmV0dXJuIGZyYW1lX3Vu d2luZF9nb3RfcmVnaXN0ZXIgKHRoaXNfZnJhbWUsIHJlZ251bSwgcmVnbnVt KTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBmcmFtZV91bndpbmQgY3Ix Nl9mcmFtZV91bndpbmQgPQoreworICBOT1JNQUxfRlJBTUUsCisgIGRlZmF1 bHRfZnJhbWVfdW53aW5kX3N0b3BfcmVhc29uLAorICBjcjE2X2ZyYW1lX3Ro aXNfaWQsCisgIGNyMTZfZnJhbWVfcHJldl9yZWdpc3RlciwKKyAgTlVMTCwK KyAgZGVmYXVsdF9mcmFtZV9zbmlmZmVyCit9OworCisvKiBJbXBsZW1lbnQg dGhlICJ1bndpbmRfcGMiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGlj IENPUkVfQUREUgorY3IxNl91bndpbmRfcGMgKHN0cnVjdCBnZGJhcmNoICpn ZGJhcmNoLCBzdHJ1Y3QgZnJhbWVfaW5mbyAqdGhpc19mcmFtZSkKK3sKKyAg Q09SRV9BRERSIHBjOworCisgIHBjID0gZnJhbWVfdW53aW5kX3JlZ2lzdGVy X3Vuc2lnbmVkICh0aGlzX2ZyYW1lLCBDUjE2X1BDX1JFR05VTSk7CisgIHJl dHVybiBwYzsKK30KKworLyogSW1wbGVtZW50IHRoZSAidW53aW5kX3NwIiBn ZGJhcmNoIG1ldGhvZC4gICovCisKK3N0YXRpYyBDT1JFX0FERFIKK2NyMTZf dW53aW5kX3NwIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgc3RydWN0IGZy YW1lX2luZm8gKnRoaXNfZnJhbWUpCit7CisgIENPUkVfQUREUiBzcDsKKwor ICBzcCA9IGZyYW1lX3Vud2luZF9yZWdpc3Rlcl91bnNpZ25lZCAodGhpc19m cmFtZSwgQ1IxNl9TUF9SRUdOVU0pOworICByZXR1cm4gc3A7Cit9CisKKy8q IEltcGxlbWVudCB0aGUgImR1bW15X2lkIiBnZGJhcmNoIG1ldGhvZC4gICov CisKK3N0YXRpYyBzdHJ1Y3QgZnJhbWVfaWQKK2NyMTZfZHVtbXlfaWQgKHN0 cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBzdHJ1Y3QgZnJhbWVfaW5mbyAqdGhp c19mcmFtZSkKK3sKKyAgcmV0dXJuCisgICAgZnJhbWVfaWRfYnVpbGQgKGdl dF9mcmFtZV9yZWdpc3Rlcl91bnNpZ25lZCAodGhpc19mcmFtZSwgQ1IxNl9T UF9SRUdOVU0pLAorCQkgICAgZ2V0X2ZyYW1lX3BjICh0aGlzX2ZyYW1lKSk7 Cit9CisKKy8qIEltcGxlbWVudCB0aGUgInB1c2hfZHVtbXlfY2FsbCIgZ2Ri YXJjaCBtZXRob2QuICAqLworCitzdGF0aWMgQ09SRV9BRERSCitjcjE2X3B1 c2hfZHVtbXlfY2FsbCAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIHN0cnVj dCB2YWx1ZSAqZnVuY3Rpb24sCisJCSAgICAgIHN0cnVjdCByZWdjYWNoZSAq cmVnY2FjaGUsIENPUkVfQUREUiBicF9hZGRyLCBpbnQgbmFyZ3MsCisJCSAg ICAgIHN0cnVjdCB2YWx1ZSAqKmFyZ3MsIENPUkVfQUREUiBzcCwgaW50IHN0 cnVjdF9yZXR1cm4sCisJCSAgICAgIENPUkVfQUREUiBzdHJ1Y3RfYWRkcikK K3sKKyAgZW51bSBiZmRfZW5kaWFuIGJ5dGVfb3JkZXIgPSBnZGJhcmNoX2J5 dGVfb3JkZXIgKGdkYmFyY2gpOworICBpbnQgd3JpdGVfcGFzczsKKyAgaW50 IHNwX29mZiA9IDA7CisgIENPUkVfQUREUiBjZmE7CisgIGludCBudW1fcmVn aXN0ZXJfY2FuZGlkYXRlX2FyZ3M7CisKKyAgc3RydWN0IHR5cGUgKmZ1bmNf dHlwZSA9IHZhbHVlX3R5cGUgKGZ1bmN0aW9uKTsKKworICAvKiBEZXJlZmVy ZW5jZSBmdW5jdGlvbiBwb2ludGVyIHR5cGVzLiAgKi8KKyAgd2hpbGUgKFRZ UEVfQ09ERSAoZnVuY190eXBlKSA9PSBUWVBFX0NPREVfUFRSKQorICAgIGZ1 bmNfdHlwZSA9IFRZUEVfVEFSR0VUX1RZUEUgKGZ1bmNfdHlwZSk7CisKKyAg LyogVGhlIGVuZCByZXN1bHQgaGFkIGJldHRlciBiZSBhIGZ1bmN0aW9uIG9y IGEgbWV0aG9kLiAgKi8KKyAgZ2RiX2Fzc2VydCAoVFlQRV9DT0RFIChmdW5j X3R5cGUpID09IFRZUEVfQ09ERV9GVU5DCisJICAgICAgfHwgVFlQRV9DT0RF IChmdW5jX3R5cGUpID09IFRZUEVfQ09ERV9NRVRIT0QpOworCisgIC8qIEZ1 bmN0aW9ucyB3aXRoIGEgdmFyaWFibGUgbnVtYmVyIG9mIGFyZ3VtZW50cyBo YXZlIGFsbCBvZiB0aGVpcgorICAgICB2YXJpYWJsZSBhcmd1bWVudHMgYW5k IHRoZSBsYXN0IG5vbi12YXJpYWJsZSBhcmd1bWVudCBwYXNzZWQKKyAgICAg b24gdGhlIHN0YWNrLgorCisgICAgIE90aGVyd2lzZSwgd2UgY2FuIHBhc3Mg dXAgdG8gZm91ciBhcmd1bWVudHMgb24gdGhlIHN0YWNrLgorCisgICAgIE9u Y2UgY29tcHV0ZWQsIHdlIGxlYXZlIHRoaXMgdmFsdWUgYWxvbmUuICBJLmUu IHdlIGRvbid0IHVwZGF0ZQorICAgICBpdCBpbiBjYXNlIG9mIGEgc3RydWN0 IHJldHVybiBnb2luZyBpbiBhIHJlZ2lzdGVyIG9yIGFuIGFyZ3VtZW50Cisg ICAgIHJlcXVpcmluZyBtdWx0aXBsZSByZWdpc3RlcnMsIGV0Yy4gIFdlIHJl bHkgaW5zdGVhZCBvbiB0aGUgdmFsdWUKKyAgICAgb2YgdGhlIGBgYXJnX3Jl ZycnIHZhcmlhYmxlIHRvIGdldCB0aGVzZSBvdGhlciBkZXRhaWxzIGNvcnJl Y3QuICAqLworCisgIGlmIChUWVBFX1ZBUkFSR1MgKGZ1bmNfdHlwZSkpCisg ICAgbnVtX3JlZ2lzdGVyX2NhbmRpZGF0ZV9hcmdzID0gVFlQRV9ORklFTERT IChmdW5jX3R5cGUpIC0gMTsKKyAgZWxzZQorICAgIG51bV9yZWdpc3Rlcl9j YW5kaWRhdGVfYXJncyA9IDQ7CisKKyAgLyogV2UgbWFrZSB0d28gcGFzc2Vz OyB0aGUgZmlyc3QgZG9lcyB0aGUgc3RhY2sgYWxsb2NhdGlvbiwKKyAgICAg dGhlIHNlY29uZCBhY3R1YWxseSBzdG9yZXMgdGhlIGFyZ3VtZW50cy4gICov CisgIGZvciAod3JpdGVfcGFzcyA9IDA7IHdyaXRlX3Bhc3MgPD0gMTsgd3Jp dGVfcGFzcysrKQorICAgIHsKKyAgICAgIGludCBpOworICAgICAgaW50IGFy Z19yZWcgPSBDUjE2X1IwX1JFR05VTTsKKworICAgICAgaWYgKHdyaXRlX3Bh c3MpCisJc3AgPSBhbGlnbl9kb3duIChzcCAtIHNwX29mZiwgNCk7CisgICAg ICBzcF9vZmYgPSAwOworCisgICAgICBpZiAoc3RydWN0X3JldHVybikKKwl7 CisJICBzdHJ1Y3QgdHlwZSAqcmV0dXJuX3R5cGUgPSBUWVBFX1RBUkdFVF9U WVBFIChmdW5jX3R5cGUpOworCisJICBnZGJfYXNzZXJ0IChUWVBFX0NPREUg KHJldHVybl90eXBlKSA9PSBUWVBFX0NPREVfU1RSVUNUCisJCSAgICAgIHx8 IFRZUEVfQ09ERSAoZnVuY190eXBlKSA9PSBUWVBFX0NPREVfVU5JT04pOwor CisJICBpZiAoVFlQRV9MRU5HVEggKHJldHVybl90eXBlKSA+IDE2CisJICAg ICAgfHwgVFlQRV9MRU5HVEggKHJldHVybl90eXBlKSAlIDQgIT0gMCkKKwkg ICAgeworCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQlyZWdjYWNoZV9jb29r ZWRfd3JpdGVfdW5zaWduZWQgKHJlZ2NhY2hlLCBDUjE2X1IxMl9SRUdOVU0s CisJCQkJCQlzdHJ1Y3RfYWRkcik7CisJICAgIH0KKwl9CisKKyAgICAgIC8q IFB1c2ggdGhlIGFyZ3VtZW50cy4gICovCisgICAgICBmb3IgKGkgPSAwOyBp IDwgbmFyZ3M7IGkrKykKKwl7CisJICBzdHJ1Y3QgdmFsdWUgKmFyZyA9IGFy Z3NbaV07CisJICBjb25zdCBnZGJfYnl0ZSAqYXJnX2JpdHMgPSB2YWx1ZV9j b250ZW50c19hbGwgKGFyZyk7CisJICBzdHJ1Y3QgdHlwZSAqYXJnX3R5cGUg PSBjaGVja190eXBlZGVmICh2YWx1ZV90eXBlIChhcmcpKTsKKwkgIFVMT05H RVNUIGFyZ19zaXplID0gVFlQRV9MRU5HVEggKGFyZ190eXBlKTsKKworCSAg aWYgKGkgPT0gMCAmJiBzdHJ1Y3RfYWRkciAhPSAwICYmICFzdHJ1Y3RfcmV0 dXJuCisJICAgICAgJiYgVFlQRV9DT0RFIChhcmdfdHlwZSkgPT0gVFlQRV9D T0RFX1BUUgorCSAgICAgICYmIGV4dHJhY3RfdW5zaWduZWRfaW50ZWdlciAo YXJnX2JpdHMsIDQsCisJCQkJCSAgIGJ5dGVfb3JkZXIpID09IHN0cnVjdF9h ZGRyKQorCSAgICB7CisJICAgICAgLyogVGhpcyBhcmd1bWVudCByZXByZXNl bnRzIHRoZSBhZGRyZXNzIGF0IHdoaWNoIEMrKyAoYW5kCisJICAgICAgICAg cG9zc2libHkgb3RoZXIgbGFuZ3VhZ2VzKSBzdG9yZSB0aGVpciByZXR1cm4g dmFsdWUuCisJICAgICAgICAgUHV0IHRoaXMgdmFsdWUgaW4gUjEyLiAgKi8K KwkgICAgICBpZiAod3JpdGVfcGFzcykKKwkJcmVnY2FjaGVfY29va2VkX3dy aXRlX3Vuc2lnbmVkIChyZWdjYWNoZSwgQ1IxNl9SMTJfUkVHTlVNLAorCQkJ CQkJc3RydWN0X2FkZHIpOworCSAgICB9CisJICBlbHNlIGlmIChUWVBFX0NP REUgKGFyZ190eXBlKSAhPSBUWVBFX0NPREVfU1RSVUNUCisJCSAgICYmIFRZ UEVfQ09ERSAoYXJnX3R5cGUpICE9IFRZUEVfQ09ERV9VTklPTikKKwkgICAg eworCSAgICAgIC8qIEFyZ3VtZW50IGlzIGEgc2NhbGFyLiAgKi8KKwkgICAg ICBpZiAoYXJnX3NpemUgPT0gOCkKKwkJeworCQkgIGlmIChpIDwgbnVtX3Jl Z2lzdGVyX2NhbmRpZGF0ZV9hcmdzCisJCSAgICAgICYmIGFyZ19yZWcgPD0g Q1IxNl9SN19SRUdOVU0gLSAxKQorCQkgICAgeworCQkgICAgICAvKiBJZiBh cmd1bWVudCByZWdpc3RlcnMgYXJlIGdvaW5nIHRvIGJlIHVzZWQgdG8gcGFz cworCQkgICAgICAgICBhbiA4IGJ5dGUgc2NhbGFyLCB0aGUgQUJJIHNwZWNp ZmllcyB0aGF0IHR3byByZWdpc3RlcnMKKwkJICAgICAgICAgbXVzdCBiZSBh dmFpbGFibGUuICAqLworCQkgICAgICBpZiAod3JpdGVfcGFzcykKKwkJCXsK KwkJCSAgcmVnY2FjaGVfY29va2VkX3dyaXRlX3Vuc2lnbmVkIChyZWdjYWNo ZSwgYXJnX3JlZywKKwkJCQkJCQkgIGV4dHJhY3RfdW5zaWduZWRfaW50ZWdl cgorCQkJCQkJCSAgKGFyZ19iaXRzLCA0LAorCQkJCQkJCSAgIGJ5dGVfb3Jk ZXIpKTsKKwkJCSAgcmVnY2FjaGVfY29va2VkX3dyaXRlX3Vuc2lnbmVkIChy ZWdjYWNoZSwKKwkJCQkJCQkgIGFyZ19yZWcgKyAxLAorCQkJCQkJCSAgZXh0 cmFjdF91bnNpZ25lZF9pbnRlZ2VyCisJCQkJCQkJICAoYXJnX2JpdHMgKyA0 LCA0LAorCQkJCQkJCSAgIGJ5dGVfb3JkZXIpKTsKKwkJCX0KKwkJICAgICAg YXJnX3JlZyArPSAyOworCQkgICAgfQorCQkgIGVsc2UKKwkJICAgIHsKKwkJ ICAgICAgc3Bfb2ZmID0gYWxpZ25fdXAgKHNwX29mZiwgNCk7CisJCSAgICAg IC8qIE90aGVyd2lzZSwgcGFzcyB0aGUgOCBieXRlIHNjYWxhciBvbiB0aGUg c3RhY2suICAqLworCQkgICAgICBpZiAod3JpdGVfcGFzcykKKwkJCXdyaXRl X21lbW9yeSAoc3AgKyBzcF9vZmYsIGFyZ19iaXRzLCA4KTsKKwkJICAgICAg c3Bfb2ZmICs9IDg7CisJCSAgICB9CisJCX0KKwkgICAgICBlbHNlCisJCXsK KwkJICBVTE9OR0VTVCB1OworCisJCSAgZ2RiX2Fzc2VydCAoYXJnX3NpemUg PD0gNCk7CisKKwkJICB1ID0gZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2VyIChh cmdfYml0cywgYXJnX3NpemUsIGJ5dGVfb3JkZXIpOworCisJCSAgaWYgKGkg PCBudW1fcmVnaXN0ZXJfY2FuZGlkYXRlX2FyZ3MKKwkJICAgICAgJiYgYXJn X3JlZyA8PSBDUjE2X1I3X1JFR05VTSkKKwkJICAgIHsKKwkJICAgICAgaWYg KHdyaXRlX3Bhc3MpCisJCQlyZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWdu ZWQgKHJlZ2NhY2hlLCBhcmdfcmVnLCB1KTsKKwkJICAgICAgYXJnX3JlZyAr PSAxOworCQkgICAgfQorCQkgIGVsc2UKKwkJICAgIHsKKwkJICAgICAgaW50 IHBfYXJnX3NpemUgPSA0OworCisJCSAgICAgIGlmIChUWVBFX1BST1RPVFlQ RUQgKGZ1bmNfdHlwZSkKKwkJCSAgJiYgaSA8IFRZUEVfTkZJRUxEUyAoZnVu Y190eXBlKSkKKwkJCXsKKwkJCSAgc3RydWN0IHR5cGUgKnBfYXJnX3R5cGUg PQorCQkJICAgIFRZUEVfRklFTERfVFlQRSAoZnVuY190eXBlLCBpKTsKKwkJ CSAgcF9hcmdfc2l6ZSA9IFRZUEVfTEVOR1RIIChwX2FyZ190eXBlKTsKKwkJ CX0KKworCQkgICAgICBzcF9vZmYgPSBhbGlnbl91cCAoc3Bfb2ZmLCBwX2Fy Z19zaXplKTsKKworCQkgICAgICBpZiAod3JpdGVfcGFzcykKKwkJCXdyaXRl X21lbW9yeV91bnNpZ25lZF9pbnRlZ2VyIChzcCArIHNwX29mZiwKKwkJCQkJ CSAgICAgICBwX2FyZ19zaXplLCBieXRlX29yZGVyLAorCQkJCQkJICAgICAg IHUpOworCQkgICAgICBzcF9vZmYgKz0gcF9hcmdfc2l6ZTsKKwkJICAgIH0K KwkJfQorCSAgICB9CisJICBlbHNlCisJICAgIHsKKwkgICAgICAvKiBBcmd1 bWVudCBpcyBhIHN0cnVjdCBvciB1bmlvbi4gIFBhc3MgYXMgbXVjaCBvZiB0 aGUgc3RydWN0CisJICAgICAgICAgaW4gcmVnaXN0ZXJzLCBhcyBwb3NzaWJs ZS4gIFBhc3MgdGhlIHJlc3Qgb24gdGhlIHN0YWNrLiAgKi8KKwkgICAgICB3 aGlsZSAoYXJnX3NpemUgPiAwKQorCQl7CisJCSAgaWYgKGkgPCBudW1fcmVn aXN0ZXJfY2FuZGlkYXRlX2FyZ3MKKwkJICAgICAgJiYgYXJnX3JlZyA8PSBD UjE2X1I3X1JFR05VTQorCQkgICAgICAmJiBhcmdfc2l6ZSA8PSA0ICogKENS MTZfUjdfUkVHTlVNIC0gYXJnX3JlZyArIDEpCisJCSAgICAgICYmIGFyZ19z aXplICUgNCA9PSAwKQorCQkgICAgeworCQkgICAgICBpbnQgbGVuID0gbWlu IChhcmdfc2l6ZSwgNCk7CisKKwkJICAgICAgaWYgKHdyaXRlX3Bhc3MpCisJ CQlyZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWduZWQgKHJlZ2NhY2hlLCBh cmdfcmVnLAorCQkJCQkJCWV4dHJhY3RfdW5zaWduZWRfaW50ZWdlcgorCQkJ CQkJCShhcmdfYml0cywgbGVuLAorCQkJCQkJCSBieXRlX29yZGVyKSk7CisJ CSAgICAgIGFyZ19iaXRzICs9IGxlbjsKKwkJICAgICAgYXJnX3NpemUgLT0g bGVuOworCQkgICAgICBhcmdfcmVnKys7CisJCSAgICB9CisJCSAgZWxzZQor CQkgICAgeworCQkgICAgICBzcF9vZmYgPSBhbGlnbl91cCAoc3Bfb2ZmLCA0 KTsKKwkJICAgICAgaWYgKHdyaXRlX3Bhc3MpCisJCQl3cml0ZV9tZW1vcnkg KHNwICsgc3Bfb2ZmLCBhcmdfYml0cywgYXJnX3NpemUpOworCQkgICAgICBz cF9vZmYgKz0gYWxpZ25fdXAgKGFyZ19zaXplLCA0KTsKKwkJICAgICAgYXJn X3NpemUgPSAwOworCQkgICAgfQorCQl9CisJICAgIH0KKwl9CisgICAgfQor CisgIC8qIEtlZXAgdHJhY2sgb2YgdGhlIHN0YWNrIGFkZHJlc3MgcHJpb3Ig dG8gcHVzaGluZyB0aGUgcmV0dXJuIGFkZHJlc3MuCisgICAgIFRoaXMgaXMg dGhlIHZhbHVlIHRoYXQgd2UnbGwgcmV0dXJuLiAgKi8KKyAgY2ZhID0gc3A7 CisKKyAgLyogUHVzaCB0aGUgcmV0dXJuIGFkZHJlc3MuICAqLworICBzcCA9 IHNwIC0gNDsKKyAgd3JpdGVfbWVtb3J5X3Vuc2lnbmVkX2ludGVnZXIgKHNw LCA0LCBieXRlX29yZGVyLCBicF9hZGRyKTsKKworICAvKiBVcGRhdGUgdGhl IHN0YWNrIHBvaW50ZXIuICAqLworICByZWdjYWNoZV9jb29rZWRfd3JpdGVf dW5zaWduZWQgKHJlZ2NhY2hlLCBDUjE2X1NQX1JFR05VTSwgc3ApOworCisg IHJldHVybiBjZmE7Cit9CisKKy8qIEltcGxlbWVudCB0aGUgInJldHVybl92 YWx1ZSIgZ2RiYXJjaCBtZXRob2QuICAqLworCitzdGF0aWMgZW51bSByZXR1 cm5fdmFsdWVfY29udmVudGlvbgorY3IxNl9yZXR1cm5fdmFsdWUgKHN0cnVj dCBnZGJhcmNoICpnZGJhcmNoLAorCQkgICBzdHJ1Y3QgdHlwZSAqZnVuY190 eXBlLAorCQkgICBzdHJ1Y3QgdHlwZSAqdmFsdHlwZSwKKwkJICAgc3RydWN0 IHJlZ2NhY2hlICpyZWdjYWNoZSwKKwkJICAgZ2RiX2J5dGUgKiByZWFkYnVm LCBjb25zdCBnZGJfYnl0ZSAqIHdyaXRlYnVmKQoreworICBlbnVtIGJmZF9l bmRpYW4gYnl0ZV9vcmRlciA9IGdkYmFyY2hfYnl0ZV9vcmRlciAoZ2RiYXJj aCk7CisgIFVMT05HRVNUIHZhbHR5cGVfbGVuID0gVFlQRV9MRU5HVEggKHZh bHR5cGUpOworCisgIGlmIChUWVBFX0xFTkdUSCAodmFsdHlwZSkgPiAxNgor ICAgICAgfHwgKChUWVBFX0NPREUgKHZhbHR5cGUpID09IFRZUEVfQ09ERV9T VFJVQ1QKKwkgICB8fCBUWVBFX0NPREUgKHZhbHR5cGUpID09IFRZUEVfQ09E RV9VTklPTikKKwkgICYmIFRZUEVfTEVOR1RIICh2YWx0eXBlKSAlIDQgIT0g MCkpCisgICAgcmV0dXJuIFJFVFVSTl9WQUxVRV9TVFJVQ1RfQ09OVkVOVElP TjsKKworICBpZiAocmVhZGJ1ZikKKyAgICB7CisgICAgICBVTE9OR0VTVCB1 OworICAgICAgaW50IGFyZ3JlZyA9IENSMTZfUjBfUkVHTlVNOworICAgICAg aW50IG9mZnNldCA9IDA7CisKKyAgICAgIHdoaWxlICh2YWx0eXBlX2xlbiA+ IDApCisJeworCSAgaW50IGxlbiA9IG1pbiAodmFsdHlwZV9sZW4sIDQpOwor CisJICByZWdjYWNoZV9jb29rZWRfcmVhZF91bnNpZ25lZCAocmVnY2FjaGUs IGFyZ3JlZywgJnUpOworCSAgc3RvcmVfdW5zaWduZWRfaW50ZWdlciAocmVh ZGJ1ZiArIG9mZnNldCwgbGVuLCBieXRlX29yZGVyLCB1KTsKKwkgIHZhbHR5 cGVfbGVuIC09IGxlbjsKKwkgIG9mZnNldCArPSBsZW47CisJICBhcmdyZWcr KzsKKwl9CisgICAgfQorCisgIGlmICh3cml0ZWJ1ZikKKyAgICB7CisgICAg ICBVTE9OR0VTVCB1OworICAgICAgaW50IGFyZ3JlZyA9IENSMTZfUjBfUkVH TlVNOworICAgICAgaW50IG9mZnNldCA9IDA7CisKKyAgICAgIHdoaWxlICh2 YWx0eXBlX2xlbiA+IDApCisJeworCSAgaW50IGxlbiA9IG1pbiAodmFsdHlw ZV9sZW4sIDQpOworCisJICB1ID0gZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2Vy ICh3cml0ZWJ1ZiArIG9mZnNldCwgbGVuLCBieXRlX29yZGVyKTsKKwkgIHJl Z2NhY2hlX2Nvb2tlZF93cml0ZV91bnNpZ25lZCAocmVnY2FjaGUsIGFyZ3Jl ZywgdSk7CisJICB2YWx0eXBlX2xlbiAtPSBsZW47CisJICBvZmZzZXQgKz0g bGVuOworCSAgYXJncmVnKys7CisJfQorICAgIH0KKworICByZXR1cm4gUkVU VVJOX1ZBTFVFX1JFR0lTVEVSX0NPTlZFTlRJT047Cit9CisKKy8qIEltcGxl bWVudCB0aGUgImJyZWFrcG9pbnRfZnJvbV9wYyIgZ2RiYXJjaCBtZXRob2Qu ICAqLworCitzdGF0aWMgY29uc3QgZ2RiX2J5dGUgKgorY3IxNl9icmVha3Bv aW50X2Zyb21fcGMgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBDT1JFX0FE RFIgKiBwY3B0ciwKKwkJCSBpbnQgKmxlbnB0cikKK3sKKyAgLyogV2UgdXNl IGRpZmZlcmVudCBicmVha3BvaW50IGluc3RydWN0aW9ucyBmb3IgRUxGIGFu ZCB1Q2xpbnV4LgorICAgICBTZWUgY3IxNi1saW51eC10ZGVwLmMgZm9yIG1v cmUgZGV0YWlscy4gICovCisgIHN0cnVjdCBnZGJhcmNoX3RkZXAgKnRkZXAg PSBnZGJhcmNoX3RkZXAgKGdkYmFyY2gpOworCisgICpsZW5wdHIgPSAyOwor ICBpZiAodGRlcCA9PSBOVUxMIHx8IHRkZXAtPmJyZWFrcG9pbnQgPT0gTlVM TCkKKyAgICByZXR1cm4gYnJlYWtwb2ludF9lbGY7CisKKyAgcmV0dXJuIHRk ZXAtPmJyZWFrcG9pbnQ7Cit9CisKKy8qIEFsbG9jYXRlIGFuZCBpbml0aWFs aXplIGEgZ2RiYXJjaCBvYmplY3QuICAqLworCitzdGF0aWMgc3RydWN0IGdk YmFyY2ggKgorY3IxNl9nZGJhcmNoX2luaXQgKHN0cnVjdCBnZGJhcmNoX2lu Zm8gaW5mbywgc3RydWN0IGdkYmFyY2hfbGlzdCAqYXJjaGVzKQoreworICBz dHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaDsKKyAgc3RydWN0IGdkYmFyY2hfdGRl cCAqdGRlcDsKKyAgaW50IGVsZl9mbGFnczsKKworICAvKiBFeHRyYWN0IHRo ZSBlbGZfZmxhZ3MgaWYgYXZhaWxhYmxlLiAgKi8KKyAgaWYgKGluZm8uYWJm ZCAhPSBOVUxMCisgICAgICAmJiBiZmRfZ2V0X2ZsYXZvdXIgKGluZm8uYWJm ZCkgPT0gYmZkX3RhcmdldF9lbGZfZmxhdm91cikKKyAgICBlbGZfZmxhZ3Mg PSBlbGZfZWxmaGVhZGVyIChpbmZvLmFiZmQpLT5lX2ZsYWdzOworICBlbHNl CisgICAgZWxmX2ZsYWdzID0gMDsKKworICAvKiBUcnkgdG8gZmluZCB0aGUg YXJjaGl0ZWN0dXJlIGluIHRoZSBsaXN0IG9mIGFscmVhZHkgZGVmaW5lZAor ICAgICBhcmNoaXRlY3R1cmVzLiAgKi8KKyAgZm9yIChhcmNoZXMgPSBnZGJh cmNoX2xpc3RfbG9va3VwX2J5X2luZm8gKGFyY2hlcywgJmluZm8pOworICAg ICAgIGFyY2hlcyAhPSBOVUxMOworICAgICAgIGFyY2hlcyA9IGdkYmFyY2hf bGlzdF9sb29rdXBfYnlfaW5mbyAoYXJjaGVzLT5uZXh0LCAmaW5mbykpCisg ICAgeworICAgICAgaWYgKGdkYmFyY2hfdGRlcCAoYXJjaGVzLT5nZGJhcmNo KS0+ZWxmX2ZsYWdzICE9IGVsZl9mbGFncykKKwljb250aW51ZTsKKworICAg ICAgcmV0dXJuIGFyY2hlcy0+Z2RiYXJjaDsKKyAgICB9CisgIC8qIE5vbmUg Zm91bmQsIGNyZWF0ZSBhIG5ldyBhcmNoaXRlY3R1cmUgZnJvbSB0aGUgaW5m b3JtYXRpb24KKyAgICAgcHJvdmlkZWQuICAqLworICB0ZGVwID0gKHN0cnVj dCBnZGJhcmNoX3RkZXAgKikgeGNhbGxvYyAoMSwgc2l6ZW9mIChzdHJ1Y3Qg Z2RiYXJjaF90ZGVwKSk7CisgIHRkZXAtPmVsZl9mbGFncyA9IGVsZl9mbGFn czsKKyAgZ2RiYXJjaCA9IGdkYmFyY2hfYWxsb2MgKCZpbmZvLCB0ZGVwKTsK KworICBzZXRfZ2RiYXJjaF9udW1fcHNldWRvX3JlZ3MgKGdkYmFyY2gsIDAp OworICBzZXRfZ2RiYXJjaF9udW1fcmVncyAoZ2RiYXJjaCwgQ1IxNl9OVU1f UkVHUyk7CisgIHNldF9nZGJhcmNoX3JlZ2lzdGVyX25hbWUgKGdkYmFyY2gs IGNyMTZfcmVnaXN0ZXJfbmFtZSk7CisgIHNldF9nZGJhcmNoX3JlZ2lzdGVy X3R5cGUgKGdkYmFyY2gsIGNyMTZfcmVnaXN0ZXJfdHlwZSk7CisgIHNldF9n ZGJhcmNoX3BjX3JlZ251bSAoZ2RiYXJjaCwgQ1IxNl9QQ19SRUdOVU0pOwor ICBzZXRfZ2RiYXJjaF9zcF9yZWdudW0gKGdkYmFyY2gsIENSMTZfU1BfUkVH TlVNKTsKKyAgc2V0X2dkYmFyY2hfaW5uZXJfdGhhbiAoZ2RiYXJjaCwgY29y ZV9hZGRyX2xlc3N0aGFuKTsKKyAgc2V0X2dkYmFyY2hfZGVjcl9wY19hZnRl cl9icmVhayAoZ2RiYXJjaCwgMik7CisgIHNldF9nZGJhcmNoX2JyZWFrcG9p bnRfZnJvbV9wYyAoZ2RiYXJjaCwgY3IxNl9icmVha3BvaW50X2Zyb21fcGMp OworICBzZXRfZ2RiYXJjaF9za2lwX3Byb2xvZ3VlIChnZGJhcmNoLCBjcjE2 X3NraXBfcHJvbG9ndWUpOworICBzZXRfZ2RiYXJjaF9wcmludF9pbnNuIChn ZGJhcmNoLCBwcmludF9pbnNuX2NyMTYpOworICBzZXRfZ2RiYXJjaF91bndp bmRfcGMgKGdkYmFyY2gsIGNyMTZfdW53aW5kX3BjKTsKKyAgc2V0X2dkYmFy Y2hfdW53aW5kX3NwIChnZGJhcmNoLCBjcjE2X3Vud2luZF9zcCk7CisKKyAg LyogTWV0aG9kcyBmb3Igc2F2aW5nIC8gZXh0cmFjdGluZyBhIGR1bW15IGZy YW1lJ3MgSUQuICAqLworICBzZXRfZ2RiYXJjaF9kdW1teV9pZCAoZ2RiYXJj aCwgY3IxNl9kdW1teV9pZCk7CisgIHNldF9nZGJhcmNoX3B1c2hfZHVtbXlf Y2FsbCAoZ2RiYXJjaCwgY3IxNl9wdXNoX2R1bW15X2NhbGwpOworICAvKiBU YXJnZXQgYnVpbHRpbiBkYXRhIHR5cGVzLiAgKi8KKyAgc2V0X2dkYmFyY2hf Y2hhcl9zaWduZWQgKGdkYmFyY2gsIDgpOworICBzZXRfZ2RiYXJjaF9zaG9y dF9iaXQgKGdkYmFyY2gsIDE2KTsKKyAgc2V0X2dkYmFyY2hfaW50X2JpdCAo Z2RiYXJjaCwgMTYpOworICBzZXRfZ2RiYXJjaF9sb25nX2JpdCAoZ2RiYXJj aCwgMzIpOworICBzZXRfZ2RiYXJjaF9sb25nX2xvbmdfYml0IChnZGJhcmNo LCA2NCk7CisgIHNldF9nZGJhcmNoX2Zsb2F0X2JpdCAoZ2RiYXJjaCwgMzIp OworCisgIHNldF9nZGJhcmNoX3B0cl9iaXQgKGdkYmFyY2gsIDMyKTsKKyAg c2V0X2dkYmFyY2hfZmxvYXRfZm9ybWF0IChnZGJhcmNoLCBmbG9hdGZvcm1h dHNfaWVlZV9zaW5nbGUpOworICBzZXRfZ2RiYXJjaF9kb3VibGVfYml0IChn ZGJhcmNoLCA2NCk7CisgIHNldF9nZGJhcmNoX2xvbmdfZG91YmxlX2JpdCAo Z2RiYXJjaCwgNjQpOworICBzZXRfZ2RiYXJjaF9kb3VibGVfZm9ybWF0IChn ZGJhcmNoLCBmbG9hdGZvcm1hdHNfaWVlZV9kb3VibGUpOworICBzZXRfZ2Ri YXJjaF9sb25nX2RvdWJsZV9mb3JtYXQgKGdkYmFyY2gsIGZsb2F0Zm9ybWF0 c19pZWVlX2RvdWJsZSk7CisKKyAgZnJhbWVfdW53aW5kX2FwcGVuZF91bndp bmRlciAoZ2RiYXJjaCwgJmNyMTZfZnJhbWVfdW53aW5kKTsKKyAgc2V0X2dk YmFyY2hfcmV0dXJuX3ZhbHVlIChnZGJhcmNoLCBjcjE2X3JldHVybl92YWx1 ZSk7CisKKyAgLyogSG9vayBpbiBBQkktc3BlY2lmaWMgb3ZlcnJpZGVzLCBp ZiB0aGV5IGhhdmUgYmVlbiByZWdpc3RlcmVkLiAgKi8KKyAgZ2RiYXJjaF9p bml0X29zYWJpIChpbmZvLCBnZGJhcmNoKTsKKworICByZXR1cm4gZ2RiYXJj aDsKKworfQorCisvKiAtV21pc3NpbmctcHJvdG90eXBlcy4gICovCitleHRl cm4gaW5pdGlhbGl6ZV9maWxlX2Z0eXBlIF9pbml0aWFsaXplX2NyMTZfdGRl cDsKKworLyogUmVnaXN0ZXIgdGhlIGFib3ZlIGluaXRpYWxpemF0aW9uIHJv dXRpbmUuICAqLworCit2b2lkCitfaW5pdGlhbGl6ZV9jcjE2X3RkZXAgKHZv aWQpCit7CisgIHJlZ2lzdGVyX2dkYmFyY2hfaW5pdCAoYmZkX2FyY2hfY3Ix NiwgY3IxNl9nZGJhcmNoX2luaXQpOworfQpJbmRleDogZ2RiL2NyMTYtdGRl cC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6IGdkYi9jcjE2 LXRkZXAuaApkaWZmIC1OIGdkYi9jcjE2LXRkZXAuaAotLS0gL2Rldi9udWxs CTEgSmFuIDE5NzAgMDA6MDA6MDAgLTAwMDAKKysrIGdkYi9jcjE2LXRkZXAu aAkxNSBKYW4gMjAxMyAwNzozMDowNyAtMDAwMApAQCAtMCwwICsxLDMyIEBA CisvKiBHTlUvTGludXggb24gIENSMTYgdGFyZ2V0IHN1cHBvcnQuCisgICBD b3B5cmlnaHQgKEMpIDIwMTMgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJ bmMuCisKKyAgIENvbnRyaWJ1dGVkIGJ5IEthdXNoaWsgUGhhdGFrIChrYXVz aGlrLnBoYXRha0BrcGl0Y3VtbWlucy5jb20pCisgICBLUElUIEN1bW1pbnMg SW5mb3N5c3RlbXMgTGltaXRlZCwgUHVuZSBJbmRpYS4KKworICAgVGhpcyBm aWxlIGlzIHBhcnQgb2YgR0RCLgorCisgICBUaGlzIHByb2dyYW0gaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1v ZGlmeQorICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhl IExpY2Vuc2UsIG9yCisgICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorCisgICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1dCBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgICBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0u ICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4u ICAqLworCisKKy8qIFRhcmdldC1kZXBlbmRlbnQgc3RydWN0dXJlIGluIGdk YmFyY2guICAqLworCitzdHJ1Y3QgZ2RiYXJjaF90ZGVwCit7CisgIC8qIFRo ZSBFTEYgaGVhZGVyIGZsYWdzIHNwZWNpZnkgdGhlIG11bHRpbGliIHVzZWQu ICAqLworICBpbnQgZWxmX2ZsYWdzOworCisgIC8qIEJyZWFrcG9pbnQgaW5z dHJ1Y3Rpb24uICAqLworICBjb25zdCBnZGJfYnl0ZSAqYnJlYWtwb2ludDsK K307 --_002_C6CA53A2A46BA7469348BDBD663AB65848567829KCHJEXMB02kpitc_--