From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 16727 invoked by alias); 18 Jan 2013 07:41:06 -0000 Received: (qmail 16688 invoked by uid 22791); 18 Jan 2013 07:41:02 -0000 X-SWARE-Spam-Status: No, hits=-4.6 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_THREADED,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 co9ehsobe002.messaging.microsoft.com (HELO co9outboundpool.messaging.microsoft.com) (207.46.163.25) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 18 Jan 2013 07:40:53 +0000 Received: from mail132-co9-R.bigfish.com (10.236.132.225) by CO9EHSOBE030.bigfish.com (10.236.130.93) with Microsoft SMTP Server id 14.1.225.23; Fri, 18 Jan 2013 07:40:52 +0000 Received: from mail132-co9 (localhost [127.0.0.1]) by mail132-co9-R.bigfish.com (Postfix) with ESMTP id 77538600138; Fri, 18 Jan 2013 07:40:52 +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: -1 X-BigFish: VPS-1(zz936eIc85fh154dI1102I148cIc8kzz1ee6h1de0h1202h1e76h1d1ah1d2ahzz17326ah8275bh8275dhz2dh2a8h668h839hd25hf0ah1288h12a5h12bdh137ah1441h14ddh1504h1537h153bh15d0h162dh1631h1758h34h1155h) Received: from mail132-co9 (localhost.localdomain [127.0.0.1]) by mail132-co9 (MessageSwitch) id 1358494849295086_17556; Fri, 18 Jan 2013 07:40:49 +0000 (UTC) Received: from CO9EHSMHS017.bigfish.com (unknown [10.236.132.234]) by mail132-co9.bigfish.com (Postfix) with ESMTP id 39556240059; Fri, 18 Jan 2013 07:40:49 +0000 (UTC) Received: from KCHJEXHC02.kpit.com (59.163.77.177) by CO9EHSMHS017.bigfish.com (10.236.130.27) with Microsoft SMTP Server (TLS) id 14.1.225.23; Fri, 18 Jan 2013 07:40:47 +0000 Received: from KCHJEXMB02.kpit.com ([169.254.2.126]) by KCHJEXHC02.kpit.com ([172.10.15.74]) with mapi id 14.02.0247.003; Fri, 18 Jan 2013 13:10:44 +0530 From: Kaushik Phatak To: Joel Brobecker CC: "gdb-patches@sourceware.org" , "binutils@sourceware.org" , Pedro Alves , Yao Qi , nick clifton , Tom Tromey Subject: RE: [RFA 3/5] New port: CR16: gdb port Date: Fri, 18 Jan 2013 07:41: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> <20130117085919.GA3564@adacore.com> In-Reply-To: <20130117085919.GA3564@adacore.com> Content-Type: multipart/mixed; boundary="_002_C6CA53A2A46BA7469348BDBD663AB65848569146KCHJEXMB02kpitc_" 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/msg00404.txt.bz2 --_002_C6CA53A2A46BA7469348BDBD663AB65848569146KCHJEXMB02kpitc_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Content-length: 36573 Hi Joel, Thanks for spending time on this. I have tried to address all your=20 points in this updated patch. > Or you could have simply attached the new file,=20 > instead of making a diff version /dev/null. Either way works for me. I have continued to use the diff here. > Copyright (C) 2012-2013 Free Softward Foundation, Inc. Fixed the copyright to add 2012. >> + case CR16_RA_REGNUM: /* Return address reg. */ >> + return builtin_type (gdbarch)->builtin_data_ptr; >> + break; > Pedro remarked on one of my patches that the "break" statement > after a return is useless, and he's right.=20 Removed all unnecessary breaks from this function. Ran through rest=20 of the code as well. Should not contain unnecessary breaks now. > Missing space after "target_gdbarch". Fixed this at two places. >> + is_decoded =3D cr16_match_opcode (); >> + cr16_make_instruction (); > It hurts every time I read this code... Nothing you can do short > of improving opcode, but this is really awful :-(. Yes, the bfd code has been lying around for a long time. Using this as-is except that these symbols are prefixed and exported in cr16.h >> + Otherwise, we can pass up to four arguments on the stack. > Up to 4 arguments on the stack? Or by register? Fixed this comment to "up to four arguments via registers" >> + if (tdep =3D=3D NULL || tdep->breakpoint =3D=3D NULL) >> + return breakpoint_elf; > The above does not look right. tdep should never be NULL, and > I suggest that tdep->breakpoint always be initialized (by > cr16_gdbarch_init). OK. I have removed this code. The gdbarch_init is able to take care=20 of this for elf and uclinux variants. Ran some tests on hardware and sim. >> + return tdep->breakpoint; >So the contents of the function should be limited to this last line. This function is now limited to this line. > The rest still looks pretty good to me :) Thanks :) Regards, Kaushik 2013-01-18 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. =09 Index: configure =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/configure,v retrieving revision 1.441 diff -u -r1.441 configure --- configure 15 Jan 2013 21:47:01 -0000 1.441 +++ configure 18 Jan 2013 05:52:41 -0000 @@ -3600,6 +3600,9 @@ tic54x-*-*) noconfigdirs=3D"$noconfigdirs target-libgloss gdb" ;; + cr16-*-*) + noconfigdirs=3D"$noconfigdirs target-libgloss" + ;; d10v-*-*) noconfigdirs=3D"$noconfigdirs target-libgloss" ;; Index: configure.ac =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/configure.ac,v retrieving revision 1.185 diff -u -r1.185 configure.ac --- configure.ac 15 Jan 2013 21:47:02 -0000 1.185 +++ configure.ac 18 Jan 2013 05:52:41 -0000 @@ -939,6 +939,9 @@ tic54x-*-*) noconfigdirs=3D"$noconfigdirs target-libgloss gdb" ;; + cr16-*-*) + noconfigdirs=3D"$noconfigdirs target-libgloss" + ;; d10v-*-*) noconfigdirs=3D"$noconfigdirs target-libgloss" ;; 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 -r1.261 configure.tgt --- gdb/configure.tgt 18 Dec 2012 14:52:58 -0000 1.261 +++ gdb/configure.tgt 18 Jan 2013 05:52:42 -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 18 Jan 2013 05:52:42 -0000 @@ -0,0 +1,107 @@ +/* Target-dependent code for GNU/Linux on the Sitel CR16 processors. + + Copyright (C) 2012-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 18 Jan 2013 05:52:42 -0000 @@ -0,0 +1,888 @@ +/* Target-dependent code for the Sitel CR16 for GDB, the GNU debugger. +=20 + Copyright (C) 2012-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; + + case CR16_FP_REGNUM: /* Frame Pointer reg. */ + case CR16_SP_REGNUM: /* Stack Pointer reg. */ + return builtin_type (gdbarch)->builtin_data_ptr; + + 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; + + 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; + + case SIM_CR16_R12_REGNUM: + return builtin_type (gdbarch)->builtin_int32; + + default: + return builtin_type (gdbarch)->builtin_int32; + } +} + +/* 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 via registers. + + 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; + 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; + tdep->breakpoint =3D breakpoint_elf; + 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 18 Jan 2013 05:52:42 -0000 @@ -0,0 +1,32 @@ +/* GNU/Linux on CR16 target support. + Copyright (C) 2012-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_C6CA53A2A46BA7469348BDBD663AB65848569146KCHJEXMB02kpitc_ Content-Type: application/octet-stream; name="cr16_gdb.diff" Content-Description: cr16_gdb.diff Content-Disposition: attachment; filename="cr16_gdb.diff"; size=33128; creation-date="Fri, 18 Jan 2013 06:00:35 GMT"; modification-date="Fri, 18 Jan 2013 07:38:09 GMT" Content-Transfer-Encoding: base64 Content-length: 44909 SW5kZXg6IGNvbmZpZ3VyZQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBm aWxlOiAvY3ZzL3NyYy9zcmMvY29uZmlndXJlLHYKcmV0cmlldmluZyByZXZp c2lvbiAxLjQ0MQpkaWZmIC11IC1yMS40NDEgY29uZmlndXJlCi0tLSBjb25m aWd1cmUJMTUgSmFuIDIwMTMgMjE6NDc6MDEgLTAwMDAJMS40NDEKKysrIGNv bmZpZ3VyZQkxOCBKYW4gMjAxMyAwNTo1Mjo0MSAtMDAwMApAQCAtMzYwMCw2 ICszNjAwLDkgQEAKICAgdGljNTR4LSotKikKICAgICBub2NvbmZpZ2RpcnM9 IiRub2NvbmZpZ2RpcnMgdGFyZ2V0LWxpYmdsb3NzIGdkYiIKICAgICA7Owor ICBjcjE2LSotKikKKyAgICBub2NvbmZpZ2RpcnM9IiRub2NvbmZpZ2RpcnMg dGFyZ2V0LWxpYmdsb3NzIgorICAgIDs7CiAgIGQxMHYtKi0qKQogICAgIG5v Y29uZmlnZGlycz0iJG5vY29uZmlnZGlycyB0YXJnZXQtbGliZ2xvc3MiCiAg ICAgOzsKSW5kZXg6IGNvbmZpZ3VyZS5hYwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09ClJDUyBmaWxlOiAvY3ZzL3NyYy9zcmMvY29uZmlndXJlLmFjLHYKcmV0 cmlldmluZyByZXZpc2lvbiAxLjE4NQpkaWZmIC11IC1yMS4xODUgY29uZmln dXJlLmFjCi0tLSBjb25maWd1cmUuYWMJMTUgSmFuIDIwMTMgMjE6NDc6MDIg LTAwMDAJMS4xODUKKysrIGNvbmZpZ3VyZS5hYwkxOCBKYW4gMjAxMyAwNTo1 Mjo0MSAtMDAwMApAQCAtOTM5LDYgKzkzOSw5IEBACiAgIHRpYzU0eC0qLSop CiAgICAgbm9jb25maWdkaXJzPSIkbm9jb25maWdkaXJzIHRhcmdldC1saWJn bG9zcyBnZGIiCiAgICAgOzsKKyAgY3IxNi0qLSopCisgICAgbm9jb25maWdk aXJzPSIkbm9jb25maWdkaXJzIHRhcmdldC1saWJnbG9zcyIKKyAgICA7Owog ICBkMTB2LSotKikKICAgICBub2NvbmZpZ2RpcnM9IiRub2NvbmZpZ2RpcnMg dGFyZ2V0LWxpYmdsb3NzIgogICAgIDs7CkluZGV4OiBnZGIvY29uZmlndXJl LnRndAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBmaWxlOiAvY3ZzL3Ny Yy9zcmMvZ2RiL2NvbmZpZ3VyZS50Z3QsdgpyZXRyaWV2aW5nIHJldmlzaW9u IDEuMjYxCmRpZmYgLXUgLXIxLjI2MSBjb25maWd1cmUudGd0Ci0tLSBnZGIv Y29uZmlndXJlLnRndAkxOCBEZWMgMjAxMiAxNDo1Mjo1OCAtMDAwMAkxLjI2 MQorKysgZ2RiL2NvbmZpZ3VyZS50Z3QJMTggSmFuIDIwMTMgMDU6NTI6NDIg LTAwMDAKQEAgLTExNiw2ICsxMTYsMTggQEAKIAlnZGJfc2ltPS4uL3NpbS9i ZmluL2xpYnNpbS5hCiAJOzsKIAorY3IxNiotKi0qbGludXgpCisJIyBUYXJn ZXQ6IENSMTYgcHJvY2Vzc29yCisJZ2RiX3RhcmdldF9vYnM9ImNyMTYtdGRl cC5vIGNyMTYtbGludXgtdGRlcC5vIGxpbnV4LXRkZXAubyIKKwlnZGJfc2lt PS4uL3NpbS9jcjE2L2xpYnNpbS5hCisJOzsKKworY3IxNiotKi0qKQorCSMg VGFyZ2V0OiBDUjE2IHByb2Nlc3NvcgorCWdkYl90YXJnZXRfb2JzPSJjcjE2 LXRkZXAubyIKKwlnZGJfc2ltPS4uL3NpbS9jcjE2L2xpYnNpbS5hCisJOzsK KwogY3JpcyopCiAJIyBUYXJnZXQ6IENSSVMKIAlnZGJfdGFyZ2V0X29icz0i Y3Jpcy10ZGVwLm8gc29saWItc3ZyNC5vIgpJbmRleDogZ2RiL2NyMTYtbGlu dXgtdGRlcC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6IGdk Yi9jcjE2LWxpbnV4LXRkZXAuYwpkaWZmIC1OIGdkYi9jcjE2LWxpbnV4LXRk ZXAuYwotLS0gL2Rldi9udWxsCTEgSmFuIDE5NzAgMDA6MDA6MDAgLTAwMDAK KysrIGdkYi9jcjE2LWxpbnV4LXRkZXAuYwkxOCBKYW4gMjAxMyAwNTo1Mjo0 MiAtMDAwMApAQCAtMCwwICsxLDEwNyBAQAorLyogVGFyZ2V0LWRlcGVuZGVu dCBjb2RlIGZvciBHTlUvTGludXggb24gdGhlIFNpdGVsIENSMTYgcHJvY2Vz c29ycy4KKworICAgQ29weXJpZ2h0IChDKSAyMDEyLTIwMTMgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisKKyAgIENvbnRyaWJ1dGVkIGJ5IEth dXNoaWsgUGhhdGFrIChrYXVzaGlrLnBoYXRha0BrcGl0Y3VtbWlucy5jb20p CisgICBLUElUIEN1bW1pbnMgSW5mb3N5c3RlbXMgTGltaXRlZCwgUHVuZSBJ bmRpYS4KKworICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgR0RCLgorCisgICBU aGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICAgaXQgdW5kZXIgdGhlIHRlcm1z IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNo ZWQgYnkKKyAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhl ciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCisgICAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBUaGlzIHByb2dyYW0g aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVz ZWZ1bCwKKyAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgICBNRVJDSEFOVEFCSUxJ VFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlCisgICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBk ZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAgYWxvbmcg d2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5n bnUub3JnL2xpY2Vuc2VzLz4uICAqLworCisjaW5jbHVkZSAiZGVmcy5oIgor I2luY2x1ZGUgIm9zYWJpLmgiCisjaW5jbHVkZSAiZWxmLWJmZC5oIgorI2lu Y2x1ZGUgImVsZi9jcjE2LmgiCisjaW5jbHVkZSAibGludXgtdGRlcC5oIgor I2luY2x1ZGUgInN5bXRhYi5oIgorI2luY2x1ZGUgImNyMTYtdGRlcC5oIgor CisvKiBOdW1iZXIgb2YgcmVnaXN0ZXJzIGF2YWlsYWJsZSBmb3IgTGludXgg dGFyZ2V0cyAgKi8KKyNkZWZpbmUgQ1IxNl9MSU5VWF9OVU1fUkVHUyAgMjEK KworLyogVGhlIGJyZWFrcG9pbnQgaW5zdHJ1Y3Rpb24gdXNlZCBieSB1Q2xp bnV4IHRhcmdldCAgKi8KK3N0YXRpYyBjb25zdCBnZGJfYnl0ZSBicmVha3Bv aW50X3VjbGludXhbXSA9IHsgMHhDNywgMHgwMCB9OworCitzdGF0aWMgY29u c3QgY2hhciAqY29uc3QgcmVnX25hbWVzW10gPQoreworICAicjAiLAorICAi cjEiLAorICAicjIiLAorICAicjMiLAorICAicjQiLAorICAicjUiLAorICAi cjYiLAorICAicjciLAorICAicjgiLAorICAicjkiLAorICAicjEwIiwKKyAg InIxMSIsCisgICJyMTIiLAorICAicjEzIiwKKyAgInJhIiwKKyAgInBzciIs CisgICJwYyIsCisgICJyMHIxX29yaWciLAorICAiaW50YmFzZSIsCisgICJ1 c3AiLAorICAiY2ZnIgorfTsKKworLyogVmVyaWZ5IHJlZ2lzdGVyIGFycmF5 IHNpemUgaXMgd2l0aGluIGhhcmR3YXJlIHJlZ2lzdGVyIGxpbWl0LiAgKi8K KworZ2RiX3N0YXRpY19hc3NlcnQgKEFSUkFZX1NJWkUgKHJlZ19uYW1lcykg PD0gQ1IxNl9MSU5VWF9OVU1fUkVHUyk7CisKKy8qIEltcGxlbWVudCB0aGUg InJlZ2lzdGVyX25hbWUiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGlj IGNvbnN0IGNoYXIgKgorY3IxNl9saW51eF9yZWdpc3Rlcl9uYW1lIChzdHJ1 Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgaW50IHJlZ25yKQoreworICBnZGJfYXNz ZXJ0IChyZWduciA+PSAwICYmIHJlZ25yIDwgQ1IxNl9MSU5VWF9OVU1fUkVH Uyk7CisgIHJldHVybiByZWdfbmFtZXNbcmVnbnJdOworfQorCisvKiBPUyBz cGVjaWZpYyBpbml0aWFsaXphdGlvbiBvZiBnZGJhcmNoLiAgKi8KKworc3Rh dGljIHZvaWQKK2NyMTZfdWNsaW51eF9pbml0X2FiaSAoc3RydWN0IGdkYmFy Y2hfaW5mbyBpbmZvLCBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCkKK3sKKyAg c3RydWN0IGdkYmFyY2hfdGRlcCAqdGRlcCA9IGdkYmFyY2hfdGRlcCAoZ2Ri YXJjaCk7CisKKyAgbGludXhfaW5pdF9hYmkgKGluZm8sIGdkYmFyY2gpOwor CisgIHNldF9nZGJhcmNoX251bV9yZWdzIChnZGJhcmNoLCBDUjE2X0xJTlVY X05VTV9SRUdTKTsKKyAgc2V0X2dkYmFyY2hfcmVnaXN0ZXJfbmFtZSAoZ2Ri YXJjaCwgY3IxNl9saW51eF9yZWdpc3Rlcl9uYW1lKTsKKworICAvKiBUaGUg b3Bjb2RlIG9mIGV4Y3AgYnB0IGlzIDB4MDBDOCwgaG93ZXZlciBmb3IgdWNs aW51eCB3ZSB3aWxsCisgICAgIHVzZSB0aGUgZXhjcCBmbGcgKDB4MDBDNykg dG8gaW5zZXJ0IGEgYnJlYWtwb2ludC4gIFRoZSBleGNwIGJwdAorICAgICBy ZXF1aXJlcyBleHRlcm5hbCBoYXJkd2FyZSBzdXBwb3J0IGZvciBicmVha3Bv aW50cyB0byB3b3JrIG9uCisgICAgIENSMTYgdGFyZ2V0LiAgU29mdHdhcmUg YmFzZWQgYnJlYWtwb2ludHMgYXJlIGltcGxlbWVudGVkIGluIHRoZQorICAg ICBrZXJuZWwgdXNpbmcgZXhjcCBmbGcgYW5kIHRlc3RlZCBvbiB0aGUgU0Mx NDQ1MiB0YXJnZXQuICBVc2UKKyAgICAgMHgwMEM3IHdpdGggZ2Ric2VydmVy L2tlcm5lbCBhbmQgMHgwMEM4IGZvciBzaW0vRUxGLiAgV2UKKyAgICAgcmVw cmVzZW50IHRoZSBicmVha3BvaW50IGluIGxpdHRsZSBlbmRpYW4gZm9ybWF0 IHNpbmNlIENSMTYKKyAgICAgc3VwcG9ydHMgb25seSBsaXR0bGUgZW5kaWFu LiAgKi8KKyAgdGRlcC0+YnJlYWtwb2ludCA9IGJyZWFrcG9pbnRfdWNsaW51 eDsKKworfQorCisvKiBQcm92aWRlIGEgcHJvdG90eXBlIHRvIHNpbGVuY2Ug LVdtaXNzaW5nLXByb3RvdHlwZXMuICAqLworZXh0ZXJuIGluaXRpYWxpemVf ZmlsZV9mdHlwZSBfaW5pdGlhbGl6ZV9jcjE2X2xpbnV4X3RkZXA7CisKK3Zv aWQKK19pbml0aWFsaXplX2NyMTZfbGludXhfdGRlcCAodm9pZCkKK3sKKyAg Z2RiYXJjaF9yZWdpc3Rlcl9vc2FiaSAoYmZkX2FyY2hfY3IxNiwgMCwgR0RC X09TQUJJX0xJTlVYLAorCQkJICBjcjE2X3VjbGludXhfaW5pdF9hYmkpOwor fQpJbmRleDogZ2RiL2NyMTYtdGRlcC5jCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KUkNTIGZpbGU6IGdkYi9jcjE2LXRkZXAuYwpkaWZmIC1OIGdkYi9jcjE2 LXRkZXAuYwotLS0gL2Rldi9udWxsCTEgSmFuIDE5NzAgMDA6MDA6MDAgLTAw MDAKKysrIGdkYi9jcjE2LXRkZXAuYwkxOCBKYW4gMjAxMyAwNTo1Mjo0MiAt MDAwMApAQCAtMCwwICsxLDg4OCBAQAorLyogVGFyZ2V0LWRlcGVuZGVudCBj b2RlIGZvciB0aGUgU2l0ZWwgQ1IxNiBmb3IgR0RCLCB0aGUgR05VIGRlYnVn Z2VyLgorIAorICAgQ29weXJpZ2h0IChDKSAyMDEyLTIwMTMgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisgCisgICBDb250cmlidXRlZCBieSBL YXVzaGlrIFBoYXRhayAoa2F1c2hpay5waGF0YWtAa3BpdGN1bW1pbnMuY29t KQorICAgS1BJVCBDdW1taW5zIEluZm9zeXN0ZW1zIExpbWl0ZWQsIFB1bmUg SW5kaWEuCisgICBUaGlzIGZpbGUgaXMgcGFydCBvZiBHREIuCisKKyAgVGhp cyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkKKyAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZl cnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IKKyAgKGF0IHlvdXIgb3B0aW9u KSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAKKyAgVGhpcyBwcm9ncmFtIGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWws CisgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgIE1FUkNIQU5UQUJJTElUWSBvciBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAg R05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4K KyAKKyAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgYWxvbmcgd2l0aCB0aGlz IHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xp Y2Vuc2VzLz4uICAqLworCisjaW5jbHVkZSAiZGVmcy5oIgorI2luY2x1ZGUg ImFyY2gtdXRpbHMuaCIKKyNpbmNsdWRlICJwcm9sb2d1ZS12YWx1ZS5oIgor I2luY2x1ZGUgInRhcmdldC5oIgorI2luY2x1ZGUgInJlZ2NhY2hlLmgiCisj aW5jbHVkZSAib3Bjb2RlL2NyMTYuaCIKKyNpbmNsdWRlICJkaXMtYXNtLmgi CisjaW5jbHVkZSAiZ2RidHlwZXMuaCIKKyNpbmNsdWRlICJmcmFtZS5oIgor I2luY2x1ZGUgImZyYW1lLXVud2luZC5oIgorI2luY2x1ZGUgImZyYW1lLWJh c2UuaCIKKyNpbmNsdWRlICJ2YWx1ZS5oIgorI2luY2x1ZGUgImdkYmNvcmUu aCIKKyNpbmNsdWRlICJkd2FyZjItZnJhbWUuaCIKKyNpbmNsdWRlICJnZGIv c2ltLWNyMTYuaCIKKyNpbmNsdWRlICJlbGYvY3IxNi5oIgorI2luY2x1ZGUg ImVsZi1iZmQuaCIKKyNpbmNsdWRlICJvc2FiaS5oIgorI2luY2x1ZGUgImNy MTYtdGRlcC5oIgorCisvKiBOdW1iZXIgb2YgcmVnaXN0ZXJzIGF2YWlsYWJs ZSBmb3IgRUxGIHRhcmdldHMuICAqLworI2RlZmluZSBDUjE2X05VTV9SRUdT ICAyMgorCisvKiBUaGUgYnJlYWtwb2ludCBpbnN0cnVjdGlvbiB1c2VkIHdp dGggc2ltIGZvciBFTEYgdGFyZ2V0cy4gICovCitzdGF0aWMgY29uc3QgZ2Ri X2J5dGUgYnJlYWtwb2ludF9lbGZbXSA9IHsgMHhDOCwgMHgwMCB9OworCisv KiBDZXJ0YWluIGltcG9ydGFudCByZWdpc3RlciBudW1iZXJzLiAgKi8KK2Vu dW0KK3sKKyAgQ1IxNl9SMF9SRUdOVU0gPSAwLAorICBDUjE2X1I3X1JFR05V TSA9IDcsCisgIENSMTZfUjEyX1JFR05VTSA9IDEyLAorICBDUjE2X0ZQX1JF R05VTSA9IDEzLAorICBDUjE2X1JBX1JFR05VTSA9IDE0LAorICBDUjE2X1NQ X1JFR05VTSA9IDE1LAorICBDUjE2X1BDX1JFR05VTSA9IDE2LAorfTsKKwor LyogVGhpcyBzdHJ1Y3R1cmUgaG9sZHMgdGhlIHJlc3VsdHMgb2YgYSBwcm9s b2d1ZSBhbmFseXNpcy4gICovCitzdHJ1Y3QgY3IxNl9wcm9sb2d1ZQorewor ICAvKiBUaGUgb2Zmc2V0IGZyb20gdGhlIGZyYW1lIGJhc2UgdG8gdGhlIHN0 YWNrIHBvaW50ZXIgLS0tIGFsd2F5cworICAgICB6ZXJvIG9yIG5lZ2F0aXZl LgorCisgICAgIENhbGxpbmcgdGhpcyBhICJzaXplIiBpcyBhIGJpdCBtaXNs ZWFkaW5nLCBidXQgZ2l2ZW4gdGhhdCB0aGUKKyAgICAgc3RhY2sgZ3Jvd3Mg ZG93bndhcmRzLCB1c2luZyBvZmZzZXRzIGZvciBldmVyeXRoaW5nIGtlZXBz IG9uZQorICAgICBmcm9tIGdvaW5nIGNvbXBsZXRlbHkgc2lnbi1jcmF6eTog eW91IG5ldmVyIGNoYW5nZSBhbnl0aGluZydzCisgICAgIHNpZ24gZm9yIGFu IEFERCBpbnN0cnVjdGlvbjsgYWx3YXlzIGNoYW5nZSB0aGUgc2Vjb25kIG9w ZXJhbmQncworICAgICBzaWduIGZvciBhIFNVQiBpbnN0cnVjdGlvbjsgYW5k IGV2ZXJ5dGhpbmcgdGFrZXMgY2FyZSBvZgorICAgICBpdHNlbGYuICAqLwor ICBpbnQgZnJhbWVfc2l6ZTsKKworICAvKiBOb24temVybyBpZiB0aGlzIGZ1 bmN0aW9uIGhhcyBpbml0aWFsaXplZCB0aGUgZnJhbWUgcG9pbnRlciBmcm9t CisgICAgIHRoZSBzdGFjayBwb2ludGVyLCB6ZXJvIG90aGVyd2lzZS4gICov CisgIGludCBoYXNfZnJhbWVfcHRyOworCisgIC8qIElmIGhhc19mcmFtZV9w dHIgaXMgbm9uLXplcm8sIHRoaXMgaXMgdGhlIG9mZnNldCBmcm9tIHRoZSBm cmFtZQorICAgICBiYXNlIHRvIHdoZXJlIHRoZSBmcmFtZSBwb2ludGVyIHBv aW50cy4gIFRoaXMgaXMgYWx3YXlzIHplcm8gb3IKKyAgICAgbmVnYXRpdmUu ICAqLworICBpbnQgZnJhbWVfcHRyX29mZnNldDsKKworICAvKiBUaGUgYWRk cmVzcyBvZiB0aGUgZmlyc3QgaW5zdHJ1Y3Rpb24gYXQgd2hpY2ggdGhlIGZy YW1lIGhhcyBiZWVuCisgICAgIHNldCB1cCBhbmQgdGhlIGFyZ3VtZW50cyBh cmUgd2hlcmUgdGhlIGRlYnVnIGluZm8gc2F5cyB0aGV5IGFyZQorICAgICAt LS0gYXMgYmVzdCBhcyB3ZSBjYW4gdGVsbC4gICovCisgIENPUkVfQUREUiBw cm9sb2d1ZV9lbmQ7CisKKyAgLyogcmVnX29mZnNldFtSXSBpcyB0aGUgb2Zm c2V0IGZyb20gdGhlIENGQSBhdCB3aGljaCByZWdpc3RlciBSIGlzCisgICAg IHNhdmVkLCBvciAxIGlmIHJlZ2lzdGVyIFIgaGFzIG5vdCBiZWVuIHNhdmVk LiAgKFJlYWwgdmFsdWVzIGFyZQorICAgICBhbHdheXMgemVybyBvciBuZWdh dGl2ZS4pICAqLworICBpbnQgcmVnX29mZnNldFtDUjE2X05VTV9SRUdTXTsK K307CisKKy8qIEhhcmR3YXJlIHJlZ2lzdGVyIG5hbWUgZGVjbGFyYXRpb24u ICAqLworc3RhdGljIGNvbnN0IGNoYXIgKmNvbnN0IHJlZ19uYW1lc1tdID0K K3sKKyAgInIwIiwKKyAgInIxIiwKKyAgInIyIiwKKyAgInIzIiwKKyAgInI0 IiwKKyAgInI1IiwKKyAgInI2IiwKKyAgInI3IiwKKyAgInI4IiwKKyAgInI5 IiwKKyAgInIxMCIsCisgICJyMTEiLAorICAicjEyIiwKKyAgInIxMyIsCisg ICJyYSIsCisgICJzcCIsCisgICJwYyIsCisgICJpc3AiLAorICAidXNwIiwK KyAgImludGJhc2UiLAorICAicHNyIiwKKyAgImNmZyIKK307CisKKy8qIFZl cmlmeSByZWdpc3RlciBhcnJheSBzaXplIGlzIHdpdGhpbiBoYXJkd2FyZSBy ZWdpc3RlciBsaW1pdC4gICovCisKK2dkYl9zdGF0aWNfYXNzZXJ0IChBUlJB WV9TSVpFIChyZWdfbmFtZXMpIDw9IENSMTZfTlVNX1JFR1MpOworCisvKiBJ bXBsZW1lbnQgdGhlICJyZWdpc3Rlcl9uYW1lIiBnZGJhcmNoIG1ldGhvZC4g ICovCisKK3N0YXRpYyBjb25zdCBjaGFyICoKK2NyMTZfcmVnaXN0ZXJfbmFt ZSAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIGludCByZWducikKK3sKKyAg Z2RiX2Fzc2VydCAocmVnbnIgPj0gMCAmJiByZWduciA8IENSMTZfTlVNX1JF R1MpOworICByZXR1cm4gcmVnX25hbWVzW3JlZ25yXTsKK30KKworLyogSW1w bGVtZW50IHRoZSAicmVnaXN0ZXJfdHlwZSIgZ2RiYXJjaCBtZXRob2QuICAq LworCitzdGF0aWMgc3RydWN0IHR5cGUgKgorY3IxNl9yZWdpc3Rlcl90eXBl IChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgaW50IHJlZ19ucikKK3sKKyAg c3dpdGNoIChyZWdfbnIpCisgICAgeworICAgIGNhc2UgQ1IxNl9QQ19SRUdO VU06CS8qIE5vdGU6IFBDIGluIENSMTYgaXMgb2YgMjQgYml0cy4gICovCisg ICAgICByZXR1cm4gYnVpbHRpbl90eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9m dW5jX3B0cjsKKworICAgIGNhc2UgQ1IxNl9SQV9SRUdOVU06CS8qIFJldHVy biBhZGRyZXNzIHJlZy4gICovCisgICAgICByZXR1cm4gYnVpbHRpbl90eXBl IChnZGJhcmNoKS0+YnVpbHRpbl9kYXRhX3B0cjsKKworICAgIGNhc2UgQ1Ix Nl9GUF9SRUdOVU06CS8qIEZyYW1lIFBvaW50ZXIgcmVnLiAgKi8KKyAgICBj YXNlIENSMTZfU1BfUkVHTlVNOgkvKiBTdGFjayBQb2ludGVyIHJlZy4gICov CisgICAgICByZXR1cm4gYnVpbHRpbl90eXBlIChnZGJhcmNoKS0+YnVpbHRp bl9kYXRhX3B0cjsKKworICAgIGNhc2UgU0lNX0NSMTZfSVNQX1JFR05VTToK KyAgICBjYXNlIFNJTV9DUjE2X1VTUF9SRUdOVU06CisgICAgY2FzZSBTSU1f Q1IxNl9JTlRCQVNFX1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1BTUl9S RUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9DRkdfUkVHTlVNOgorICAgICAg cmV0dXJuIGJ1aWx0aW5fdHlwZSAoZ2RiYXJjaCktPmJ1aWx0aW5faW50MzI7 CisKKyAgICBjYXNlIFNJTV9DUjE2X1IwX1JFR05VTToKKyAgICBjYXNlIFNJ TV9DUjE2X1IxX1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1IyX1JFR05V TToKKyAgICBjYXNlIFNJTV9DUjE2X1IzX1JFR05VTToKKyAgICBjYXNlIFNJ TV9DUjE2X1I0X1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1I1X1JFR05V TToKKyAgICBjYXNlIFNJTV9DUjE2X1I2X1JFR05VTToKKyAgICBjYXNlIFNJ TV9DUjE2X1I3X1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1I4X1JFR05V TToKKyAgICBjYXNlIFNJTV9DUjE2X1I5X1JFR05VTToKKyAgICBjYXNlIFNJ TV9DUjE2X1IxMF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SMTFfUkVH TlVNOgorICAgICAgcmV0dXJuIGJ1aWx0aW5fdHlwZSAoZ2RiYXJjaCktPmJ1 aWx0aW5faW50MTY7CisKKyAgICBjYXNlIFNJTV9DUjE2X1IxMl9SRUdOVU06 CisgICAgICByZXR1cm4gYnVpbHRpbl90eXBlIChnZGJhcmNoKS0+YnVpbHRp bl9pbnQzMjsKKworICAgIGRlZmF1bHQ6CisgICAgICByZXR1cm4gYnVpbHRp bl90eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9pbnQzMjsKKyAgICB9Cit9CisK Ky8qIEZ1bmN0aW9uIGZvciBmaW5kaW5nIHNhdmVkIHJlZ2lzdGVycyBpbiBh ICdzdHJ1Y3QgcHZfYXJlYSc7IHRoaXMKKyAgIGZ1bmN0aW9uIGlzIHBhc3Nl ZCB0byBwdl9hcmVhX3NjYW4uCisKKyAgIElmIFZBTFVFIGlzIGEgc2F2ZWQg cmVnaXN0ZXIsIEFERFIgc2F5cyBpdCB3YXMgc2F2ZWQgYXQgYSBjb25zdGFu dAorICAgb2Zmc2V0IGZyb20gdGhlIGZyYW1lIGJhc2UsIGFuZCBTSVpFIGlu ZGljYXRlcyB0aGF0IHRoZSB3aG9sZQorICAgcmVnaXN0ZXIgd2FzIHNhdmVk LCByZWNvcmQgaXRzIG9mZnNldC4gICovCisKK3N0YXRpYyB2b2lkCitjaGVj a19mb3Jfc2F2ZWQgKHZvaWQgKnJlc3VsdF91bnR5cGVkLCBwdl90IGFkZHIs IENPUkVfQUREUiBzaXplLCBwdl90IHZhbHVlKQoreworICBzdHJ1Y3QgY3Ix Nl9wcm9sb2d1ZSAqcmVzdWx0ID0gKHN0cnVjdCBjcjE2X3Byb2xvZ3VlICop IHJlc3VsdF91bnR5cGVkOworCisgIGlmICh2YWx1ZS5raW5kID09IHB2a19y ZWdpc3RlcgorICAgICAgJiYgdmFsdWUuayA9PSAwCisgICAgICAmJiBwdl9p c19yZWdpc3RlciAoYWRkciwgQ1IxNl9TUF9SRUdOVU0pCisgICAgICAmJiBz aXplID09IHJlZ2lzdGVyX3NpemUgKHRhcmdldF9nZGJhcmNoICgpLCB2YWx1 ZS5yZWcpKQorICAgIHJlc3VsdC0+cmVnX29mZnNldFt2YWx1ZS5yZWddID0g YWRkci5rOworfQorCisvKiBEZWZpbmUgYSAiaGFuZGxlIiBzdHJ1Y3QgZm9y IGZldGNoaW5nIHRoZSBuZXh0IG9wY29kZS4gICovCisKK3N0cnVjdCBjcjE2 X2dldF9vcGNvZGVfYnl0ZV9oYW5kbGUKK3sKKyAgQ09SRV9BRERSIHBjOwor fTsKKworLyogQW5hbHl6ZSBhIHByb2xvZ3VlIHN0YXJ0aW5nIGF0IFNUQVJU X1BDLCBnb2luZyBubyBmdXJ0aGVyIHRoYW4KKyAgIExJTUlUX1BDLiAgRmls bCBpbiBSRVNVTFQgYXMgYXBwcm9wcmlhdGUuICAqLworCitzdGF0aWMgdm9p ZAorY3IxNl9hbmFseXplX3Byb2xvZ3VlIChDT1JFX0FERFIgc3RhcnRfcGMs CisJCSAgICAgICBDT1JFX0FERFIgbGltaXRfcGMsIHN0cnVjdCBjcjE2X3By b2xvZ3VlICpyZXN1bHQpCit7CisgIENPUkVfQUREUiBwYywgbmV4dF9wYzsK KyAgZ2RiX2J5dGUgaW5zbl9ieXRlMSwgaW5zbl9ieXRlMjsKKyAgaW50IHJu OworICBpbnQgbGVuZ3RoOworICBwdl90IHJlZ1tDUjE2X05VTV9SRUdTXTsK KyAgc3RydWN0IHB2X2FyZWEgKnN0YWNrOworICBzdHJ1Y3QgY2xlYW51cCAq YmFja190bzsKKyAgQ09SRV9BRERSIGFmdGVyX2xhc3RfZnJhbWVfc2V0dXBf aW5zbiA9IHN0YXJ0X3BjOworICBpbnQgaXNfZGVjb2RlZDsKKworICBtZW1z ZXQgKHJlc3VsdCwgMCwgc2l6ZW9mICgqcmVzdWx0KSk7CisKKyAgZm9yIChy biA9IDA7IHJuIDwgQ1IxNl9OVU1fUkVHUzsgcm4rKykKKyAgICB7CisgICAg ICByZWdbcm5dID0gcHZfcmVnaXN0ZXIgKHJuLCAwKTsKKyAgICAgIHJlc3Vs dC0+cmVnX29mZnNldFtybl0gPSAxOworICAgIH0KKworICBzdGFjayA9IG1h a2VfcHZfYXJlYSAoQ1IxNl9TUF9SRUdOVU0sIGdkYmFyY2hfYWRkcl9iaXQg KHRhcmdldF9nZGJhcmNoICgpKSk7CisgIGJhY2tfdG8gPSBtYWtlX2NsZWFu dXBfZnJlZV9wdl9hcmVhIChzdGFjayk7CisKKyAgcGMgPSBzdGFydF9wYzsK KyAgd2hpbGUgKHBjIDwgbGltaXRfcGMpCisgICAgeworICAgICAgZ2RiX2J5 dGUgYnVmWzZdOworCisgICAgICAvKiBSZWFkIDYgYnl0ZXMsIG1heCA0OCBi aXQgb3Bjb2RlLiAgKi8KKyAgICAgIHRhcmdldF9yZWFkX21lbW9yeSAocGMs IGJ1ZiwgNik7CisgICAgICBjcjE2X3dvcmRzWzBdID0gYnVmWzFdIDw8IDgg fCBidWZbMF07CisgICAgICBjcjE2X3dvcmRzWzFdID0gYnVmWzNdIDw8IDgg fCBidWZbMl07CisgICAgICBjcjE2X3dvcmRzWzJdID0gYnVmWzVdIDw8IDgg fCBidWZbNF07CisgICAgICBjcjE2X2FsbFdvcmRzID0gKCgoVUxPTkdMT05H KSBjcjE2X3dvcmRzWzBdIDw8IDMyKQorCQkgICAgICArICgoVUxPTkdMT05H KSBjcjE2X3dvcmRzWzFdIDw8IDE2KQorCQkgICAgICArIGNyMTZfd29yZHNb Ml0pOworCisgICAgICAvKiBGaW5kIGEgbWF0Y2hpbmcgb3Bjb2RlIGluIHRh YmxlLgorICAgICAgICAgTm9uemVybyBtZWFucyBpbnN0cnVjdGlvbiBoYXMg YSBtYXRjaC4gICovCisgICAgICBpc19kZWNvZGVkID0gY3IxNl9tYXRjaF9v cGNvZGUgKCk7CisgICAgICBjcjE2X21ha2VfaW5zdHJ1Y3Rpb24gKCk7Cisg ICAgICBsZW5ndGggPSBjcjE2X2N1cnJJbnNuLnNpemU7CisgICAgICBuZXh0 X3BjID0gcGMgKyBsZW5ndGg7CisgICAgICBpbnNuX2J5dGUxID0gKGNyMTZf d29yZHNbMF0gPj4gOCkgJiAweEZGOworCisgICAgICAvKiBJZiBQVVNILCB0 aGVuIHNhdmUgUkEgYW5kIG90aGVyIHJlZ3MuICAqLworICAgICAgaWYgKGlu c25fYnl0ZTEgPT0gMHgwMSkKKwl7CisJICBpbnQgcjEsIHIyOworCSAgaW50 IHI7CisKKwkgIGluc25fYnl0ZTIgPSBjcjE2X3dvcmRzWzBdOworCisJICBp ZiAoaW5zbl9ieXRlMiAmIDB4ODApCisJICAgIHsKKwkgICAgICByZWdbQ1Ix Nl9TUF9SRUdOVU1dID0gcHZfYWRkX2NvbnN0YW50IChyZWdbQ1IxNl9TUF9S RUdOVU1dLCAtNCk7CisJICAgICAgcHZfYXJlYV9zdG9yZSAoc3RhY2ssIHJl Z1tDUjE2X1NQX1JFR05VTV0sIDQsCisJCQkgICAgIHJlZ1tDUjE2X1JBX1JF R05VTV0pOworCSAgICB9CisJICAvKiBTdGFydCBSZWdpc3Rlcj1yMSwgMyBi aXQgaW1tIGNvdW50PXIyLiAgKi8KKwkgIHIxID0gaW5zbl9ieXRlMiAmIDB4 MEY7CisJICByMiA9ICgoaW5zbl9ieXRlMiAmIDB4NzApID4+IDQpOworCSAg cjIgPSByMiArIHIxICsgMTsKKworCSAgZm9yIChyID0gcjE7IHIgPCByMjsg cisrKQorCSAgICB7CisJICAgICAgaWYgKHIgPj0gQ1IxNl9SMTJfUkVHTlVN KQorCQl7CisJCSAgcmVnW0NSMTZfU1BfUkVHTlVNXSA9CisJCSAgICBwdl9h ZGRfY29uc3RhbnQgKHJlZ1tDUjE2X1NQX1JFR05VTV0sIC00KTsKKwkJICBw dl9hcmVhX3N0b3JlIChzdGFjaywgcmVnW0NSMTZfU1BfUkVHTlVNXSwgNCwg cmVnW3JdKTsKKwkJICByKys7CisJCX0KKwkgICAgICBlbHNlCisJCXsKKwkJ ICByZWdbQ1IxNl9TUF9SRUdOVU1dID0KKwkJICAgIHB2X2FkZF9jb25zdGFu dCAocmVnW0NSMTZfU1BfUkVHTlVNXSwgLTIpOworCQkgIHB2X2FyZWFfc3Rv cmUgKHN0YWNrLCByZWdbQ1IxNl9TUF9SRUdOVU1dLCAyLCByZWdbcl0pOwor CQl9CisJICAgIH0KKwkgIGFmdGVyX2xhc3RfZnJhbWVfc2V0dXBfaW5zbiA9 IG5leHRfcGM7CisJfQorICAgICAgLyogQWRkIGNvbnN0YW50IHRvIFNQLiAg Ki8KKyAgICAgIGVsc2UgaWYgKGluc25fYnl0ZTEgPT0gMHg2MCkKKwl7CisJ ICBpbnQgcmRzdDsKKwkgIHNpZ25lZCBzaG9ydCBhZGRlbmQ7CisKKwkgIGlu c25fYnl0ZTIgPSBjcjE2X3dvcmRzWzBdOworCSAgcmRzdCA9IGluc25fYnl0 ZTIgJiAweDBGOworCSAgaWYgKHJkc3QgPT0gQ1IxNl9TUF9SRUdOVU0pCisJ ICAgIHsKKwkgICAgICBpZiAobGVuZ3RoID09IDIpCisJCXsKKwkJICBhZGRl bmQgPSAoaW5zbl9ieXRlMiAmIDB4RjApID4+IDQ7CisJCSAgcmVnW3Jkc3Rd ID0gcHZfYWRkX2NvbnN0YW50IChyZWdbcmRzdF0sIGFkZGVuZCk7CisJCX0K KwkgICAgICBpZiAobGVuZ3RoID09IDQpCisJCXsKKwkJICBhZGRlbmQgPSBj cjE2X3dvcmRzWzFdOworCQkgIHJlZ1tyZHN0XSA9IHB2X2FkZF9jb25zdGFu dCAocmVnW3Jkc3RdLCBhZGRlbmQpOworCQl9CisJICAgICAgYWZ0ZXJfbGFz dF9mcmFtZV9zZXR1cF9pbnNuID0gbmV4dF9wYzsKKwkgICAgfQorCX0KKyAg ICAgIC8qIENoZWNrIGZvciBNT1ZEIGluc24uICAqLworICAgICAgZWxzZSBp ZiAoaW5zbl9ieXRlMSA9PSAweDU1KQorCXsKKwkgIGludCByZHN0LCByc3Jj OworCisJICBpbnNuX2J5dGUyID0gY3IxNl93b3Jkc1swXTsKKwkgIHJzcmMg PSAoaW5zbl9ieXRlMiAmIDB4RjApID4+IDQ7CisJICByZHN0ID0gKGluc25f Ynl0ZTIgJiAweDBGKTsKKwkgIHJlZ1tyZHN0XSA9IHJlZ1tyc3JjXTsKKwkg IGlmIChyc3JjID09IENSMTZfU1BfUkVHTlVNICYmIHJkc3QgPT0gQ1IxNl9G UF9SRUdOVU0pCisJICAgIGFmdGVyX2xhc3RfZnJhbWVfc2V0dXBfaW5zbiA9 IG5leHRfcGM7CisJfQorICAgICAgZWxzZSBpZiAoKChpbnNuX2J5dGUxID4+ IDQpICYgMHgwRikgPT0gMHhkKQorCXsKKwkgIC8qIFRoaXMgbW92ZXMgYW4g YXJndW1lbnQgcmVnaXN0ZXIgdG8gdGhlIHN0YWNrLiAgRG9uJ3QKKwkgICAg IHJlY29yZCBpdCwgYnV0IGFsbG93IGl0IHRvIGJlIGEgcGFydCBvZiB0aGUg cHJvbG9ndWUuICAqLworCSAgYWZ0ZXJfbGFzdF9mcmFtZV9zZXR1cF9pbnNu ID0gbmV4dF9wYzsKKwl9CisgICAgICBlbHNlCisJYnJlYWs7CQkvKiBUZXJt aW5hdGUgdGhlIHByb2xvZ3VlIHNjYW4uICAqLworCisgICAgICBwYyA9IG5l eHRfcGM7CisgICAgfQorCisgIC8qIElzIHRoZSBmcmFtZSBzaXplIChvZmZz ZXQsIHJlYWxseSkgYSBrbm93biBjb25zdGFudD8gICovCisgIGlmIChwdl9p c19yZWdpc3RlciAocmVnW0NSMTZfU1BfUkVHTlVNXSwgQ1IxNl9TUF9SRUdO VU0pKQorICAgIHJlc3VsdC0+ZnJhbWVfc2l6ZSA9IHJlZ1tDUjE2X1NQX1JF R05VTV0uazsKKworICAvKiBXYXMgdGhlIGZyYW1lIHBvaW50ZXIgaW5pdGlh bGl6ZWQ/ICAqLworICBpZiAocHZfaXNfcmVnaXN0ZXIgKHJlZ1tDUjE2X0ZQ X1JFR05VTV0sIENSMTZfU1BfUkVHTlVNKSkKKyAgICB7CisgICAgICByZXN1 bHQtPmhhc19mcmFtZV9wdHIgPSAxOworICAgICAgcmVzdWx0LT5mcmFtZV9w dHJfb2Zmc2V0ID0gcmVnW0NSMTZfRlBfUkVHTlVNXS5rOworICAgIH0KKwor ICAvKiBSZWNvcmQgd2hlcmUgYWxsIHRoZSByZWdpc3RlcnMgd2VyZSBzYXZl ZC4gICovCisgIHB2X2FyZWFfc2NhbiAoc3RhY2ssIGNoZWNrX2Zvcl9zYXZl ZCwgKHZvaWQgKikgcmVzdWx0KTsKKworICByZXN1bHQtPnByb2xvZ3VlX2Vu ZCA9IGFmdGVyX2xhc3RfZnJhbWVfc2V0dXBfaW5zbjsKKyAgZG9fY2xlYW51 cHMgKGJhY2tfdG8pOworfQorCisKKy8qIEltcGxlbWVudCB0aGUgInNraXBf cHJvbG9ndWUiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGljIENPUkVf QUREUgorY3IxNl9za2lwX3Byb2xvZ3VlIChzdHJ1Y3QgZ2RiYXJjaCAqZ2Ri YXJjaCwgQ09SRV9BRERSIHBjKQoreworICBjb25zdCBjaGFyICpuYW1lOwor ICBDT1JFX0FERFIgZnVuY19hZGRyLCBmdW5jX2VuZDsKKyAgc3RydWN0IGNy MTZfcHJvbG9ndWUgcDsKKworICAvKiBUcnkgdG8gZmluZCB0aGUgZXh0ZW50 IG9mIHRoZSBmdW5jdGlvbiB0aGF0IGNvbnRhaW5zIFBDLiAgKi8KKyAgaWYg KCFmaW5kX3BjX3BhcnRpYWxfZnVuY3Rpb24gKHBjLCAmbmFtZSwgJmZ1bmNf YWRkciwgJmZ1bmNfZW5kKSkKKyAgICByZXR1cm4gcGM7CisKKyAgY3IxNl9h bmFseXplX3Byb2xvZ3VlIChwYywgZnVuY19lbmQsICZwKTsKKyAgcmV0dXJu IHAucHJvbG9ndWVfZW5kOworfQorCisvKiBHaXZlbiBhIGZyYW1lIGRlc2Ny aWJlZCBieSBUSElTX0ZSQU1FLCBkZWNvZGUgdGhlIHByb2xvZ3VlIG9mIGl0 cworICAgYXNzb2NpYXRlZCBmdW5jdGlvbiBpZiB0aGVyZSBpcyBub3QgY2Fj aGUgZW50cnkgYXMgc3BlY2lmaWVkIGJ5CisgICBUSElTX1BST0xPR1VFX0NB Q0hFLiAgU2F2ZSB0aGUgZGVjb2RlZCBwcm9sb2d1ZSBpbiB0aGUgY2FjaGUg YW5kCisgICByZXR1cm4gdGhhdCBzdHJ1Y3QgYXMgdGhlIHZhbHVlIG9mIHRo aXMgZnVuY3Rpb24uICAqLworCitzdGF0aWMgc3RydWN0IGNyMTZfcHJvbG9n dWUgKgorY3IxNl9hbmFseXplX2ZyYW1lX3Byb2xvZ3VlIChzdHJ1Y3QgZnJh bWVfaW5mbyAqdGhpc19mcmFtZSwKKwkJCSAgICAgdm9pZCAqKnRoaXNfcHJv bG9ndWVfY2FjaGUpCit7CisgIGlmICgqdGhpc19wcm9sb2d1ZV9jYWNoZSkK KyAgICByZXR1cm4gKnRoaXNfcHJvbG9ndWVfY2FjaGU7CisKKyAgQ09SRV9B RERSIGZ1bmNfc3RhcnQsIHN0b3BfYWRkcjsKKworICAqdGhpc19wcm9sb2d1 ZV9jYWNoZSA9IEZSQU1FX09CU1RBQ0tfWkFMTE9DIChzdHJ1Y3QgY3IxNl9w cm9sb2d1ZSk7CisgIGZ1bmNfc3RhcnQgPSBnZXRfZnJhbWVfZnVuYyAodGhp c19mcmFtZSk7CisgIHN0b3BfYWRkciA9IGdldF9mcmFtZV9wYyAodGhpc19m cmFtZSk7CisKKyAvKiBJZiB3ZSBjb3VsZG4ndCBmaW5kIGFueSBmdW5jdGlv biBjb250YWluaW5nIHRoZSBQQywgdGhlbgorICAgICBqdXN0IGluaXRpYWxp emUgdGhlIHByb2xvZ3VlIGNhY2hlLCBidXQgZG9uJ3QgZG8gYW55dGhpbmcu ICAqLworICBpZiAoIWZ1bmNfc3RhcnQpCisgICAgc3RvcF9hZGRyID0gZnVu Y19zdGFydDsKKworICBjcjE2X2FuYWx5emVfcHJvbG9ndWUgKGZ1bmNfc3Rh cnQsIHN0b3BfYWRkciwgKnRoaXNfcHJvbG9ndWVfY2FjaGUpOworCisgIHJl dHVybiAqdGhpc19wcm9sb2d1ZV9jYWNoZTsKK30KKworLyogR2l2ZW4gdGhl IG5leHQgZnJhbWUgYW5kIGEgcHJvbG9ndWUgY2FjaGUsIHJldHVybiB0aGlz IGZyYW1lJ3MKKyAgIGJhc2UuICAqLworCitzdGF0aWMgQ09SRV9BRERSCitj cjE2X2ZyYW1lX2Jhc2UgKHN0cnVjdCBmcmFtZV9pbmZvICp0aGlzX2ZyYW1l LCB2b2lkICoqdGhpc19wcm9sb2d1ZV9jYWNoZSkKK3sKKyAgc3RydWN0IGNy MTZfcHJvbG9ndWUgKnAKKyAgICA9IGNyMTZfYW5hbHl6ZV9mcmFtZV9wcm9s b2d1ZSAodGhpc19mcmFtZSwgdGhpc19wcm9sb2d1ZV9jYWNoZSk7CisKKyAg LyogSW4gZnVuY3Rpb25zIHRoYXQgdXNlIGFsbG9jYSwgdGhlIGRpc3RhbmNl IGJldHdlZW4gdGhlIHN0YWNrCisgICAgIHBvaW50ZXIgYW5kIHRoZSBmcmFt ZSBiYXNlIHZhcmllcyBkeW5hbWljYWxseSwgc28gd2UgY2FuJ3QgdXNlCisg ICAgIHRoZSBTUCBwbHVzIHN0YXRpYyBpbmZvcm1hdGlvbiBsaWtlIHByb2xv Z3VlIGFuYWx5c2lzIHRvIGZpbmQgdGhlCisgICAgIGZyYW1lIGJhc2UuICBI b3dldmVyLCBzdWNoIGZ1bmN0aW9ucyBtdXN0IGhhdmUgYSBmcmFtZSBwb2lu dGVyLAorICAgICB0byBiZSBhYmxlIHRvIHJlc3RvcmUgdGhlIFNQIG9uIGV4 aXQuICBTbyB3aGVuZXZlciB3ZSBkbyBoYXZlIGEKKyAgICAgZnJhbWUgcG9p bnRlciwgdXNlIHRoYXQgdG8gZmluZCB0aGUgYmFzZS4gICovCisgIGlmIChw LT5oYXNfZnJhbWVfcHRyKQorICAgIHsKKyAgICAgIENPUkVfQUREUiBmcCA9 IGdldF9mcmFtZV9yZWdpc3Rlcl91bnNpZ25lZCAodGhpc19mcmFtZSwgQ1Ix Nl9GUF9SRUdOVU0pOworCisgICAgICByZXR1cm4gZnAgLSBwLT5mcmFtZV9w dHJfb2Zmc2V0OworICAgIH0KKyAgZWxzZQorICAgIHsKKyAgICAgIENPUkVf QUREUiBzcCA9IGdldF9mcmFtZV9yZWdpc3Rlcl91bnNpZ25lZCAodGhpc19m cmFtZSwgQ1IxNl9TUF9SRUdOVU0pOworCisgICAgICByZXR1cm4gc3AgLSBw LT5mcmFtZV9zaXplOworICAgIH0KK30KKworLyogSW1wbGVtZW50IHRoZSAi ZnJhbWVfdGhpc19pZCIgbWV0aG9kIGZvciB1bndpbmRpbmcgZnJhbWVzLiAg Ki8KKworc3RhdGljIHZvaWQKK2NyMTZfZnJhbWVfdGhpc19pZCAoc3RydWN0 IGZyYW1lX2luZm8gKnRoaXNfZnJhbWUsCisJCSAgICB2b2lkICoqdGhpc19w cm9sb2d1ZV9jYWNoZSwgc3RydWN0IGZyYW1lX2lkICp0aGlzX2lkKQorewor ICAqdGhpc19pZCA9CisgICAgZnJhbWVfaWRfYnVpbGQgKGNyMTZfZnJhbWVf YmFzZSAodGhpc19mcmFtZSwgdGhpc19wcm9sb2d1ZV9jYWNoZSksCisJCSAg ICBnZXRfZnJhbWVfZnVuYyAodGhpc19mcmFtZSkpOworfQorCisvKiBJbXBs ZW1lbnQgdGhlICJmcmFtZV9wcmV2X3JlZ2lzdGVyIiBtZXRob2QgZm9yIHVu d2luZGluZyBmcmFtZXMuICAqLworCitzdGF0aWMgc3RydWN0IHZhbHVlICoK K2NyMTZfZnJhbWVfcHJldl9yZWdpc3RlciAoc3RydWN0IGZyYW1lX2luZm8g KnRoaXNfZnJhbWUsCisJCQkgIHZvaWQgKip0aGlzX3Byb2xvZ3VlX2NhY2hl LCBpbnQgcmVnbnVtKQoreworICBzdHJ1Y3QgY3IxNl9wcm9sb2d1ZSAqcCA9 CisgICAgY3IxNl9hbmFseXplX2ZyYW1lX3Byb2xvZ3VlICh0aGlzX2ZyYW1l LCB0aGlzX3Byb2xvZ3VlX2NhY2hlKTsKKyAgQ09SRV9BRERSIGZyYW1lX2Jh c2UgPSBjcjE2X2ZyYW1lX2Jhc2UgKHRoaXNfZnJhbWUsIHRoaXNfcHJvbG9n dWVfY2FjaGUpOworCisgIGlmIChyZWdudW0gPT0gQ1IxNl9TUF9SRUdOVU0p CisgICAgcmV0dXJuIGZyYW1lX3Vud2luZF9nb3RfY29uc3RhbnQgKHRoaXNf ZnJhbWUsIHJlZ251bSwgZnJhbWVfYmFzZSk7CisKKyAgLyogVGhlIGNhbGwg aW5zdHJ1Y3Rpb24gaGFzIHNhdmVkIHRoZSByZXR1cm4gYWRkcmVzcyBvbiB0 aGUgUkEKKyAgICAgcmVnaXN0ZXIsIENSMTZfUjEzX1JFR05VTS4gIFNvLCB3 ZSBuZWVkIG5vdCBhZGp1c3QgYW55dGhpbmcKKyAgICAgZGlyZWN0bHkuICBX ZSB3aWxsIGFuYWx5emUgcHJvbG9ndWUgYXMgdGhpcyBSQSByZWdpc3RlciBp cworICAgICBwdXNoZWQgb250byBzdGFjayBmb3IgZnVydGhlciBsZWFmIGZ1 bmN0aW9uIGNhbGxzIHRvIHdvcmsuICAqLworICBlbHNlIGlmIChyZWdudW0g PT0gQ1IxNl9QQ19SRUdOVU0pCisgICAgeworICAgICAgVUxPTkdFU1QgcmFf cHJldjsKKworICAgICAgcmFfcHJldiA9IGZyYW1lX3Vud2luZF9yZWdpc3Rl cl91bnNpZ25lZCAodGhpc19mcmFtZSwgQ1IxNl9SQV9SRUdOVU0pOworICAg ICAgcmFfcHJldiA9IHJhX3ByZXYgPDwgMTsKKyAgICAgIHJldHVybiBmcmFt ZV91bndpbmRfZ290X2NvbnN0YW50ICh0aGlzX2ZyYW1lLCBDUjE2X1BDX1JF R05VTSwgcmFfcHJldik7CisgICAgfQorCisgIC8qIElmIHByb2xvZ3VlIGFu YWx5c2lzIHNheXMgd2Ugc2F2ZWQgdGhpcyByZWdpc3RlciBzb21ld2hlcmUs CisgICAgIHJldHVybiBhIGRlc2NyaXB0aW9uIG9mIHRoZSBzdGFjayBzbG90 IGhvbGRpbmcgaXQuICAqLworICBlbHNlIGlmIChwLT5yZWdfb2Zmc2V0W3Jl Z251bV0gIT0gMSkKKyAgICAgIHJldHVybiBmcmFtZV91bndpbmRfZ290X21l bW9yeSAodGhpc19mcmFtZSwgcmVnbnVtLAorCQkJCSAgICAgIGZyYW1lX2Jh c2UgKyBwLT5yZWdfb2Zmc2V0W3JlZ251bV0pOworCisgIC8qIE90aGVyd2lz ZSwgcHJlc3VtZSB3ZSBoYXZlbid0IGNoYW5nZWQgdGhlIHZhbHVlIG9mIHRo aXMKKyAgICAgcmVnaXN0ZXIsIGFuZCBnZXQgaXQgZnJvbSB0aGUgbmV4dCBm cmFtZS4gICovCisgIGVsc2UKKyAgICAgIHJldHVybiBmcmFtZV91bndpbmRf Z290X3JlZ2lzdGVyICh0aGlzX2ZyYW1lLCByZWdudW0sIHJlZ251bSk7Cit9 CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZnJhbWVfdW53aW5kIGNyMTZfZnJh bWVfdW53aW5kID0KK3sKKyAgTk9STUFMX0ZSQU1FLAorICBkZWZhdWx0X2Zy YW1lX3Vud2luZF9zdG9wX3JlYXNvbiwKKyAgY3IxNl9mcmFtZV90aGlzX2lk LAorICBjcjE2X2ZyYW1lX3ByZXZfcmVnaXN0ZXIsCisgIE5VTEwsCisgIGRl ZmF1bHRfZnJhbWVfc25pZmZlcgorfTsKKworLyogSW1wbGVtZW50IHRoZSAi dW53aW5kX3BjIiBnZGJhcmNoIG1ldGhvZC4gICovCisKK3N0YXRpYyBDT1JF X0FERFIKK2NyMTZfdW53aW5kX3BjIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJj aCwgc3RydWN0IGZyYW1lX2luZm8gKnRoaXNfZnJhbWUpCit7CisgIENPUkVf QUREUiBwYzsKKworICBwYyA9IGZyYW1lX3Vud2luZF9yZWdpc3Rlcl91bnNp Z25lZCAodGhpc19mcmFtZSwgQ1IxNl9QQ19SRUdOVU0pOworICByZXR1cm4g cGM7Cit9CisKKy8qIEltcGxlbWVudCB0aGUgInVud2luZF9zcCIgZ2RiYXJj aCBtZXRob2QuICAqLworCitzdGF0aWMgQ09SRV9BRERSCitjcjE2X3Vud2lu ZF9zcCAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIHN0cnVjdCBmcmFtZV9p bmZvICp0aGlzX2ZyYW1lKQoreworICBDT1JFX0FERFIgc3A7CisKKyAgc3Ag PSBmcmFtZV91bndpbmRfcmVnaXN0ZXJfdW5zaWduZWQgKHRoaXNfZnJhbWUs IENSMTZfU1BfUkVHTlVNKTsKKyAgcmV0dXJuIHNwOworfQorCisvKiBJbXBs ZW1lbnQgdGhlICJkdW1teV9pZCIgZ2RiYXJjaCBtZXRob2QuICAqLworCitz dGF0aWMgc3RydWN0IGZyYW1lX2lkCitjcjE2X2R1bW15X2lkIChzdHJ1Y3Qg Z2RiYXJjaCAqZ2RiYXJjaCwgc3RydWN0IGZyYW1lX2luZm8gKnRoaXNfZnJh bWUpCit7CisgIHJldHVybgorICAgIGZyYW1lX2lkX2J1aWxkIChnZXRfZnJh bWVfcmVnaXN0ZXJfdW5zaWduZWQgKHRoaXNfZnJhbWUsIENSMTZfU1BfUkVH TlVNKSwKKwkJICAgIGdldF9mcmFtZV9wYyAodGhpc19mcmFtZSkpOworfQor CisvKiBJbXBsZW1lbnQgdGhlICJwdXNoX2R1bW15X2NhbGwiIGdkYmFyY2gg bWV0aG9kLiAgKi8KKworc3RhdGljIENPUkVfQUREUgorY3IxNl9wdXNoX2R1 bW15X2NhbGwgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBzdHJ1Y3QgdmFs dWUgKmZ1bmN0aW9uLAorCQkgICAgICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2Nh Y2hlLCBDT1JFX0FERFIgYnBfYWRkciwgaW50IG5hcmdzLAorCQkgICAgICBz dHJ1Y3QgdmFsdWUgKiphcmdzLCBDT1JFX0FERFIgc3AsIGludCBzdHJ1Y3Rf cmV0dXJuLAorCQkgICAgICBDT1JFX0FERFIgc3RydWN0X2FkZHIpCit7Cisg IGVudW0gYmZkX2VuZGlhbiBieXRlX29yZGVyID0gZ2RiYXJjaF9ieXRlX29y ZGVyIChnZGJhcmNoKTsKKyAgaW50IHdyaXRlX3Bhc3M7CisgIGludCBzcF9v ZmYgPSAwOworICBDT1JFX0FERFIgY2ZhOworICBpbnQgbnVtX3JlZ2lzdGVy X2NhbmRpZGF0ZV9hcmdzOworCisgIHN0cnVjdCB0eXBlICpmdW5jX3R5cGUg PSB2YWx1ZV90eXBlIChmdW5jdGlvbik7CisKKyAgLyogRGVyZWZlcmVuY2Ug ZnVuY3Rpb24gcG9pbnRlciB0eXBlcy4gICovCisgIHdoaWxlIChUWVBFX0NP REUgKGZ1bmNfdHlwZSkgPT0gVFlQRV9DT0RFX1BUUikKKyAgICBmdW5jX3R5 cGUgPSBUWVBFX1RBUkdFVF9UWVBFIChmdW5jX3R5cGUpOworCisgIC8qIFRo ZSBlbmQgcmVzdWx0IGhhZCBiZXR0ZXIgYmUgYSBmdW5jdGlvbiBvciBhIG1l dGhvZC4gICovCisgIGdkYl9hc3NlcnQgKFRZUEVfQ09ERSAoZnVuY190eXBl KSA9PSBUWVBFX0NPREVfRlVOQworCSAgICAgIHx8IFRZUEVfQ09ERSAoZnVu Y190eXBlKSA9PSBUWVBFX0NPREVfTUVUSE9EKTsKKworICAvKiBGdW5jdGlv bnMgd2l0aCBhIHZhcmlhYmxlIG51bWJlciBvZiBhcmd1bWVudHMgaGF2ZSBh bGwgb2YgdGhlaXIKKyAgICAgdmFyaWFibGUgYXJndW1lbnRzIGFuZCB0aGUg bGFzdCBub24tdmFyaWFibGUgYXJndW1lbnQgcGFzc2VkCisgICAgIG9uIHRo ZSBzdGFjay4KKworICAgICBPdGhlcndpc2UsIHdlIGNhbiBwYXNzIHVwIHRv IGZvdXIgYXJndW1lbnRzIHZpYSByZWdpc3RlcnMuCisKKyAgICAgT25jZSBj b21wdXRlZCwgd2UgbGVhdmUgdGhpcyB2YWx1ZSBhbG9uZS4gIEkuZS4gd2Ug ZG9uJ3QgdXBkYXRlCisgICAgIGl0IGluIGNhc2Ugb2YgYSBzdHJ1Y3QgcmV0 dXJuIGdvaW5nIGluIGEgcmVnaXN0ZXIgb3IgYW4gYXJndW1lbnQKKyAgICAg cmVxdWlyaW5nIG11bHRpcGxlIHJlZ2lzdGVycywgZXRjLiAgV2UgcmVseSBp bnN0ZWFkIG9uIHRoZSB2YWx1ZQorICAgICBvZiB0aGUgYGBhcmdfcmVnJycg dmFyaWFibGUgdG8gZ2V0IHRoZXNlIG90aGVyIGRldGFpbHMgY29ycmVjdC4g ICovCisKKyAgaWYgKFRZUEVfVkFSQVJHUyAoZnVuY190eXBlKSkKKyAgICBu dW1fcmVnaXN0ZXJfY2FuZGlkYXRlX2FyZ3MgPSBUWVBFX05GSUVMRFMgKGZ1 bmNfdHlwZSkgLSAxOworICBlbHNlCisgICAgbnVtX3JlZ2lzdGVyX2NhbmRp ZGF0ZV9hcmdzID0gNDsKKworICAvKiBXZSBtYWtlIHR3byBwYXNzZXM7IHRo ZSBmaXJzdCBkb2VzIHRoZSBzdGFjayBhbGxvY2F0aW9uLAorICAgICB0aGUg c2Vjb25kIGFjdHVhbGx5IHN0b3JlcyB0aGUgYXJndW1lbnRzLiAgKi8KKyAg Zm9yICh3cml0ZV9wYXNzID0gMDsgd3JpdGVfcGFzcyA8PSAxOyB3cml0ZV9w YXNzKyspCisgICAgeworICAgICAgaW50IGk7CisgICAgICBpbnQgYXJnX3Jl ZyA9IENSMTZfUjBfUkVHTlVNOworCisgICAgICBpZiAod3JpdGVfcGFzcykK KwlzcCA9IGFsaWduX2Rvd24gKHNwIC0gc3Bfb2ZmLCA0KTsKKyAgICAgIHNw X29mZiA9IDA7CisKKyAgICAgIGlmIChzdHJ1Y3RfcmV0dXJuKQorCXsKKwkg IHN0cnVjdCB0eXBlICpyZXR1cm5fdHlwZSA9IFRZUEVfVEFSR0VUX1RZUEUg KGZ1bmNfdHlwZSk7CisKKwkgIGdkYl9hc3NlcnQgKFRZUEVfQ09ERSAocmV0 dXJuX3R5cGUpID09IFRZUEVfQ09ERV9TVFJVQ1QKKwkJICAgICAgfHwgVFlQ RV9DT0RFIChmdW5jX3R5cGUpID09IFRZUEVfQ09ERV9VTklPTik7CisKKwkg IGlmIChUWVBFX0xFTkdUSCAocmV0dXJuX3R5cGUpID4gMTYKKwkgICAgICB8 fCBUWVBFX0xFTkdUSCAocmV0dXJuX3R5cGUpICUgNCAhPSAwKQorCSAgICB7 CisJICAgICAgaWYgKHdyaXRlX3Bhc3MpCisJCXJlZ2NhY2hlX2Nvb2tlZF93 cml0ZV91bnNpZ25lZCAocmVnY2FjaGUsIENSMTZfUjEyX1JFR05VTSwKKwkJ CQkJCXN0cnVjdF9hZGRyKTsKKwkgICAgfQorCX0KKworICAgICAgLyogUHVz aCB0aGUgYXJndW1lbnRzLiAgKi8KKyAgICAgIGZvciAoaSA9IDA7IGkgPCBu YXJnczsgaSsrKQorCXsKKwkgIHN0cnVjdCB2YWx1ZSAqYXJnID0gYXJnc1tp XTsKKwkgIGNvbnN0IGdkYl9ieXRlICphcmdfYml0cyA9IHZhbHVlX2NvbnRl bnRzX2FsbCAoYXJnKTsKKwkgIHN0cnVjdCB0eXBlICphcmdfdHlwZSA9IGNo ZWNrX3R5cGVkZWYgKHZhbHVlX3R5cGUgKGFyZykpOworCSAgVUxPTkdFU1Qg YXJnX3NpemUgPSBUWVBFX0xFTkdUSCAoYXJnX3R5cGUpOworCisJICBpZiAo aSA9PSAwICYmIHN0cnVjdF9hZGRyICE9IDAgJiYgIXN0cnVjdF9yZXR1cm4K KwkgICAgICAmJiBUWVBFX0NPREUgKGFyZ190eXBlKSA9PSBUWVBFX0NPREVf UFRSCisJICAgICAgJiYgZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2VyIChhcmdf Yml0cywgNCwKKwkJCQkJICAgYnl0ZV9vcmRlcikgPT0gc3RydWN0X2FkZHIp CisJICAgIHsKKwkgICAgICAvKiBUaGlzIGFyZ3VtZW50IHJlcHJlc2VudHMg dGhlIGFkZHJlc3MgYXQgd2hpY2ggQysrIChhbmQKKwkgICAgICAgICBwb3Nz aWJseSBvdGhlciBsYW5ndWFnZXMpIHN0b3JlIHRoZWlyIHJldHVybiB2YWx1 ZS4KKwkgICAgICAgICBQdXQgdGhpcyB2YWx1ZSBpbiBSMTIuICAqLworCSAg ICAgIGlmICh3cml0ZV9wYXNzKQorCQlyZWdjYWNoZV9jb29rZWRfd3JpdGVf dW5zaWduZWQgKHJlZ2NhY2hlLCBDUjE2X1IxMl9SRUdOVU0sCisJCQkJCQlz dHJ1Y3RfYWRkcik7CisJICAgIH0KKwkgIGVsc2UgaWYgKFRZUEVfQ09ERSAo YXJnX3R5cGUpICE9IFRZUEVfQ09ERV9TVFJVQ1QKKwkJICAgJiYgVFlQRV9D T0RFIChhcmdfdHlwZSkgIT0gVFlQRV9DT0RFX1VOSU9OKQorCSAgICB7CisJ ICAgICAgLyogQXJndW1lbnQgaXMgYSBzY2FsYXIuICAqLworCSAgICAgIGlm IChhcmdfc2l6ZSA9PSA4KQorCQl7CisJCSAgaWYgKGkgPCBudW1fcmVnaXN0 ZXJfY2FuZGlkYXRlX2FyZ3MKKwkJICAgICAgJiYgYXJnX3JlZyA8PSBDUjE2 X1I3X1JFR05VTSAtIDEpCisJCSAgICB7CisJCSAgICAgIC8qIElmIGFyZ3Vt ZW50IHJlZ2lzdGVycyBhcmUgZ29pbmcgdG8gYmUgdXNlZCB0byBwYXNzCisJ CSAgICAgICAgIGFuIDggYnl0ZSBzY2FsYXIsIHRoZSBBQkkgc3BlY2lmaWVz IHRoYXQgdHdvIHJlZ2lzdGVycworCQkgICAgICAgICBtdXN0IGJlIGF2YWls YWJsZS4gICovCisJCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJeworCQkJ ICByZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWduZWQgKHJlZ2NhY2hlLCBh cmdfcmVnLAorCQkJCQkJCSAgZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2VyCisJ CQkJCQkJICAoYXJnX2JpdHMsIDQsCisJCQkJCQkJICAgYnl0ZV9vcmRlcikp OworCQkJICByZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWduZWQgKHJlZ2Nh Y2hlLAorCQkJCQkJCSAgYXJnX3JlZyArIDEsCisJCQkJCQkJICBleHRyYWN0 X3Vuc2lnbmVkX2ludGVnZXIKKwkJCQkJCQkgIChhcmdfYml0cyArIDQsIDQs CisJCQkJCQkJICAgYnl0ZV9vcmRlcikpOworCQkJfQorCQkgICAgICBhcmdf cmVnICs9IDI7CisJCSAgICB9CisJCSAgZWxzZQorCQkgICAgeworCQkgICAg ICBzcF9vZmYgPSBhbGlnbl91cCAoc3Bfb2ZmLCA0KTsKKwkJICAgICAgLyog T3RoZXJ3aXNlLCBwYXNzIHRoZSA4IGJ5dGUgc2NhbGFyIG9uIHRoZSBzdGFj ay4gICovCisJCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJd3JpdGVfbWVt b3J5IChzcCArIHNwX29mZiwgYXJnX2JpdHMsIDgpOworCQkgICAgICBzcF9v ZmYgKz0gODsKKwkJICAgIH0KKwkJfQorCSAgICAgIGVsc2UKKwkJeworCQkg IFVMT05HRVNUIHU7CisKKwkJICBnZGJfYXNzZXJ0IChhcmdfc2l6ZSA8PSA0 KTsKKworCQkgIHUgPSBleHRyYWN0X3Vuc2lnbmVkX2ludGVnZXIgKGFyZ19i aXRzLCBhcmdfc2l6ZSwgYnl0ZV9vcmRlcik7CisKKwkJICBpZiAoaSA8IG51 bV9yZWdpc3Rlcl9jYW5kaWRhdGVfYXJncworCQkgICAgICAmJiBhcmdfcmVn IDw9IENSMTZfUjdfUkVHTlVNKQorCQkgICAgeworCQkgICAgICBpZiAod3Jp dGVfcGFzcykKKwkJCXJlZ2NhY2hlX2Nvb2tlZF93cml0ZV91bnNpZ25lZCAo cmVnY2FjaGUsIGFyZ19yZWcsIHUpOworCQkgICAgICBhcmdfcmVnICs9IDE7 CisJCSAgICB9CisJCSAgZWxzZQorCQkgICAgeworCQkgICAgICBpbnQgcF9h cmdfc2l6ZSA9IDQ7CisKKwkJICAgICAgaWYgKFRZUEVfUFJPVE9UWVBFRCAo ZnVuY190eXBlKQorCQkJICAmJiBpIDwgVFlQRV9ORklFTERTIChmdW5jX3R5 cGUpKQorCQkJeworCQkJICBzdHJ1Y3QgdHlwZSAqcF9hcmdfdHlwZSA9CisJ CQkgICAgVFlQRV9GSUVMRF9UWVBFIChmdW5jX3R5cGUsIGkpOworCQkJICBw X2FyZ19zaXplID0gVFlQRV9MRU5HVEggKHBfYXJnX3R5cGUpOworCQkJfQor CisJCSAgICAgIHNwX29mZiA9IGFsaWduX3VwIChzcF9vZmYsIHBfYXJnX3Np emUpOworCisJCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJd3JpdGVfbWVt b3J5X3Vuc2lnbmVkX2ludGVnZXIgKHNwICsgc3Bfb2ZmLAorCQkJCQkJICAg ICAgIHBfYXJnX3NpemUsIGJ5dGVfb3JkZXIsCisJCQkJCQkgICAgICAgdSk7 CisJCSAgICAgIHNwX29mZiArPSBwX2FyZ19zaXplOworCQkgICAgfQorCQl9 CisJICAgIH0KKwkgIGVsc2UKKwkgICAgeworCSAgICAgIC8qIEFyZ3VtZW50 IGlzIGEgc3RydWN0IG9yIHVuaW9uLiAgUGFzcyBhcyBtdWNoIG9mIHRoZSBz dHJ1Y3QKKwkgICAgICAgICBpbiByZWdpc3RlcnMsIGFzIHBvc3NpYmxlLiAg UGFzcyB0aGUgcmVzdCBvbiB0aGUgc3RhY2suICAqLworCSAgICAgIHdoaWxl IChhcmdfc2l6ZSA+IDApCisJCXsKKwkJICBpZiAoaSA8IG51bV9yZWdpc3Rl cl9jYW5kaWRhdGVfYXJncworCQkgICAgICAmJiBhcmdfcmVnIDw9IENSMTZf UjdfUkVHTlVNCisJCSAgICAgICYmIGFyZ19zaXplIDw9IDQgKiAoQ1IxNl9S N19SRUdOVU0gLSBhcmdfcmVnICsgMSkKKwkJICAgICAgJiYgYXJnX3NpemUg JSA0ID09IDApCisJCSAgICB7CisJCSAgICAgIGludCBsZW4gPSBtaW4gKGFy Z19zaXplLCA0KTsKKworCQkgICAgICBpZiAod3JpdGVfcGFzcykKKwkJCXJl Z2NhY2hlX2Nvb2tlZF93cml0ZV91bnNpZ25lZCAocmVnY2FjaGUsIGFyZ19y ZWcsCisJCQkJCQkJZXh0cmFjdF91bnNpZ25lZF9pbnRlZ2VyCisJCQkJCQkJ KGFyZ19iaXRzLCBsZW4sCisJCQkJCQkJIGJ5dGVfb3JkZXIpKTsKKwkJICAg ICAgYXJnX2JpdHMgKz0gbGVuOworCQkgICAgICBhcmdfc2l6ZSAtPSBsZW47 CisJCSAgICAgIGFyZ19yZWcrKzsKKwkJICAgIH0KKwkJICBlbHNlCisJCSAg ICB7CisJCSAgICAgIHNwX29mZiA9IGFsaWduX3VwIChzcF9vZmYsIDQpOwor CQkgICAgICBpZiAod3JpdGVfcGFzcykKKwkJCXdyaXRlX21lbW9yeSAoc3Ag KyBzcF9vZmYsIGFyZ19iaXRzLCBhcmdfc2l6ZSk7CisJCSAgICAgIHNwX29m ZiArPSBhbGlnbl91cCAoYXJnX3NpemUsIDQpOworCQkgICAgICBhcmdfc2l6 ZSA9IDA7CisJCSAgICB9CisJCX0KKwkgICAgfQorCX0KKyAgICB9CisKKyAg LyogS2VlcCB0cmFjayBvZiB0aGUgc3RhY2sgYWRkcmVzcyBwcmlvciB0byBw dXNoaW5nIHRoZSByZXR1cm4gYWRkcmVzcy4KKyAgICAgVGhpcyBpcyB0aGUg dmFsdWUgdGhhdCB3ZSdsbCByZXR1cm4uICAqLworICBjZmEgPSBzcDsKKwor ICAvKiBQdXNoIHRoZSByZXR1cm4gYWRkcmVzcy4gICovCisgIHNwID0gc3Ag LSA0OworICB3cml0ZV9tZW1vcnlfdW5zaWduZWRfaW50ZWdlciAoc3AsIDQs IGJ5dGVfb3JkZXIsIGJwX2FkZHIpOworCisgIC8qIFVwZGF0ZSB0aGUgc3Rh Y2sgcG9pbnRlci4gICovCisgIHJlZ2NhY2hlX2Nvb2tlZF93cml0ZV91bnNp Z25lZCAocmVnY2FjaGUsIENSMTZfU1BfUkVHTlVNLCBzcCk7CisKKyAgcmV0 dXJuIGNmYTsKK30KKworLyogSW1wbGVtZW50IHRoZSAicmV0dXJuX3ZhbHVl IiBnZGJhcmNoIG1ldGhvZC4gICovCisKK3N0YXRpYyBlbnVtIHJldHVybl92 YWx1ZV9jb252ZW50aW9uCitjcjE2X3JldHVybl92YWx1ZSAoc3RydWN0IGdk YmFyY2ggKmdkYmFyY2gsCisJCSAgIHN0cnVjdCB0eXBlICpmdW5jX3R5cGUs CisJCSAgIHN0cnVjdCB0eXBlICp2YWx0eXBlLAorCQkgICBzdHJ1Y3QgcmVn Y2FjaGUgKnJlZ2NhY2hlLAorCQkgICBnZGJfYnl0ZSAqIHJlYWRidWYsIGNv bnN0IGdkYl9ieXRlICogd3JpdGVidWYpCit7CisgIGVudW0gYmZkX2VuZGlh biBieXRlX29yZGVyID0gZ2RiYXJjaF9ieXRlX29yZGVyIChnZGJhcmNoKTsK KyAgVUxPTkdFU1QgdmFsdHlwZV9sZW4gPSBUWVBFX0xFTkdUSCAodmFsdHlw ZSk7CisKKyAgaWYgKFRZUEVfTEVOR1RIICh2YWx0eXBlKSA+IDE2CisgICAg ICB8fCAoKFRZUEVfQ09ERSAodmFsdHlwZSkgPT0gVFlQRV9DT0RFX1NUUlVD VAorCSAgIHx8IFRZUEVfQ09ERSAodmFsdHlwZSkgPT0gVFlQRV9DT0RFX1VO SU9OKQorCSAgJiYgVFlQRV9MRU5HVEggKHZhbHR5cGUpICUgNCAhPSAwKSkK KyAgICByZXR1cm4gUkVUVVJOX1ZBTFVFX1NUUlVDVF9DT05WRU5USU9OOwor CisgIGlmIChyZWFkYnVmKQorICAgIHsKKyAgICAgIFVMT05HRVNUIHU7Cisg ICAgICBpbnQgYXJncmVnID0gQ1IxNl9SMF9SRUdOVU07CisgICAgICBpbnQg b2Zmc2V0ID0gMDsKKworICAgICAgd2hpbGUgKHZhbHR5cGVfbGVuID4gMCkK Kwl7CisJICBpbnQgbGVuID0gbWluICh2YWx0eXBlX2xlbiwgNCk7CisKKwkg IHJlZ2NhY2hlX2Nvb2tlZF9yZWFkX3Vuc2lnbmVkIChyZWdjYWNoZSwgYXJn cmVnLCAmdSk7CisJICBzdG9yZV91bnNpZ25lZF9pbnRlZ2VyIChyZWFkYnVm ICsgb2Zmc2V0LCBsZW4sIGJ5dGVfb3JkZXIsIHUpOworCSAgdmFsdHlwZV9s ZW4gLT0gbGVuOworCSAgb2Zmc2V0ICs9IGxlbjsKKwkgIGFyZ3JlZysrOwor CX0KKyAgICB9CisKKyAgaWYgKHdyaXRlYnVmKQorICAgIHsKKyAgICAgIFVM T05HRVNUIHU7CisgICAgICBpbnQgYXJncmVnID0gQ1IxNl9SMF9SRUdOVU07 CisgICAgICBpbnQgb2Zmc2V0ID0gMDsKKworICAgICAgd2hpbGUgKHZhbHR5 cGVfbGVuID4gMCkKKwl7CisJICBpbnQgbGVuID0gbWluICh2YWx0eXBlX2xl biwgNCk7CisKKwkgIHUgPSBleHRyYWN0X3Vuc2lnbmVkX2ludGVnZXIgKHdy aXRlYnVmICsgb2Zmc2V0LCBsZW4sIGJ5dGVfb3JkZXIpOworCSAgcmVnY2Fj aGVfY29va2VkX3dyaXRlX3Vuc2lnbmVkIChyZWdjYWNoZSwgYXJncmVnLCB1 KTsKKwkgIHZhbHR5cGVfbGVuIC09IGxlbjsKKwkgIG9mZnNldCArPSBsZW47 CisJICBhcmdyZWcrKzsKKwl9CisgICAgfQorCisgIHJldHVybiBSRVRVUk5f VkFMVUVfUkVHSVNURVJfQ09OVkVOVElPTjsKK30KKworLyogSW1wbGVtZW50 IHRoZSAiYnJlYWtwb2ludF9mcm9tX3BjIiBnZGJhcmNoIG1ldGhvZC4gICov CisKK3N0YXRpYyBjb25zdCBnZGJfYnl0ZSAqCitjcjE2X2JyZWFrcG9pbnRf ZnJvbV9wYyAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIENPUkVfQUREUiAq IHBjcHRyLAorCQkJIGludCAqbGVucHRyKQoreworICAvKiBXZSB1c2UgZGlm ZmVyZW50IGJyZWFrcG9pbnQgaW5zdHJ1Y3Rpb25zIGZvciBFTEYgYW5kIHVD bGludXguCisgICAgIFNlZSBjcjE2LWxpbnV4LXRkZXAuYyBmb3IgbW9yZSBk ZXRhaWxzLiAgKi8KKyAgc3RydWN0IGdkYmFyY2hfdGRlcCAqdGRlcCA9IGdk YmFyY2hfdGRlcCAoZ2RiYXJjaCk7CisKKyAgKmxlbnB0ciA9IDI7CisgIHJl dHVybiB0ZGVwLT5icmVha3BvaW50OworfQorCisvKiBBbGxvY2F0ZSBhbmQg aW5pdGlhbGl6ZSBhIGdkYmFyY2ggb2JqZWN0LiAgKi8KKworc3RhdGljIHN0 cnVjdCBnZGJhcmNoICoKK2NyMTZfZ2RiYXJjaF9pbml0IChzdHJ1Y3QgZ2Ri YXJjaF9pbmZvIGluZm8sIHN0cnVjdCBnZGJhcmNoX2xpc3QgKmFyY2hlcykK K3sKKyAgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2g7CisgIHN0cnVjdCBnZGJh cmNoX3RkZXAgKnRkZXA7CisgIGludCBlbGZfZmxhZ3M7CisKKyAgLyogRXh0 cmFjdCB0aGUgZWxmX2ZsYWdzIGlmIGF2YWlsYWJsZS4gICovCisgIGlmIChp bmZvLmFiZmQgIT0gTlVMTAorICAgICAgJiYgYmZkX2dldF9mbGF2b3VyIChp bmZvLmFiZmQpID09IGJmZF90YXJnZXRfZWxmX2ZsYXZvdXIpCisgICAgZWxm X2ZsYWdzID0gZWxmX2VsZmhlYWRlciAoaW5mby5hYmZkKS0+ZV9mbGFnczsK KyAgZWxzZQorICAgIGVsZl9mbGFncyA9IDA7CisKKyAgLyogVHJ5IHRvIGZp bmQgdGhlIGFyY2hpdGVjdHVyZSBpbiB0aGUgbGlzdCBvZiBhbHJlYWR5IGRl ZmluZWQKKyAgICAgYXJjaGl0ZWN0dXJlcy4gICovCisgIGZvciAoYXJjaGVz ID0gZ2RiYXJjaF9saXN0X2xvb2t1cF9ieV9pbmZvIChhcmNoZXMsICZpbmZv KTsKKyAgICAgICBhcmNoZXMgIT0gTlVMTDsKKyAgICAgICBhcmNoZXMgPSBn ZGJhcmNoX2xpc3RfbG9va3VwX2J5X2luZm8gKGFyY2hlcy0+bmV4dCwgJmlu Zm8pKQorICAgIHsKKyAgICAgIGlmIChnZGJhcmNoX3RkZXAgKGFyY2hlcy0+ Z2RiYXJjaCktPmVsZl9mbGFncyAhPSBlbGZfZmxhZ3MpCisJY29udGludWU7 CisKKyAgICAgIHJldHVybiBhcmNoZXMtPmdkYmFyY2g7CisgICAgfQorICAv KiBOb25lIGZvdW5kLCBjcmVhdGUgYSBuZXcgYXJjaGl0ZWN0dXJlIGZyb20g dGhlIGluZm9ybWF0aW9uCisgICAgIHByb3ZpZGVkLiAgKi8KKyAgdGRlcCA9 IChzdHJ1Y3QgZ2RiYXJjaF90ZGVwICopIHhjYWxsb2MgKDEsIHNpemVvZiAo c3RydWN0IGdkYmFyY2hfdGRlcCkpOworICB0ZGVwLT5lbGZfZmxhZ3MgPSBl bGZfZmxhZ3M7CisgIHRkZXAtPmJyZWFrcG9pbnQgPSBicmVha3BvaW50X2Vs ZjsKKyAgZ2RiYXJjaCA9IGdkYmFyY2hfYWxsb2MgKCZpbmZvLCB0ZGVwKTsK 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 aAkxOCBKYW4gMjAxMyAwNTo1Mjo0MiAtMDAwMApAQCAtMCwwICsxLDMyIEBA CisvKiBHTlUvTGludXggb24gIENSMTYgdGFyZ2V0IHN1cHBvcnQuCisgICBD b3B5cmlnaHQgKEMpIDIwMTItMjAxMyBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b24sIEluYy4KKworICAgQ29udHJpYnV0ZWQgYnkgS2F1c2hpayBQaGF0YWsg KGthdXNoaWsucGhhdGFrQGtwaXRjdW1taW5zLmNvbSkKKyAgIEtQSVQgQ3Vt bWlucyBJbmZvc3lzdGVtcyBMaW1pdGVkLCBQdW5lIEluZGlhLgorCisgICBU aGlzIGZpbGUgaXMgcGFydCBvZiBHREIuCisKKyAgIFRoaXMgcHJvZ3JhbSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQv b3IgbW9kaWZ5CisgICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICAgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMyBv ZiB0aGUgTGljZW5zZSwgb3IKKyAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCisKKyAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAgYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAgIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAg IFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgICBhbG9uZyB3aXRoIHRoaXMgcHJv Z3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5z ZXMvPi4gICovCisKKworLyogVGFyZ2V0LWRlcGVuZGVudCBzdHJ1Y3R1cmUg aW4gZ2RiYXJjaC4gICovCisKK3N0cnVjdCBnZGJhcmNoX3RkZXAKK3sKKyAg LyogVGhlIEVMRiBoZWFkZXIgZmxhZ3Mgc3BlY2lmeSB0aGUgbXVsdGlsaWIg dXNlZC4gICovCisgIGludCBlbGZfZmxhZ3M7CisKKyAgLyogQnJlYWtwb2lu dCBpbnN0cnVjdGlvbi4gICovCisgIGNvbnN0IGdkYl9ieXRlICpicmVha3Bv aW50OworfTs= --_002_C6CA53A2A46BA7469348BDBD663AB65848569146KCHJEXMB02kpitc_--