From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 15404 invoked by alias); 19 Jun 2013 13:25:02 -0000 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 Received: (qmail 15347 invoked by uid 89); 19 Jun 2013 13:25:01 -0000 X-Spam-SWARE-Status: No, score=-4.7 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_THREADED,RCVD_IN_DNSWL_NONE,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,TW_EG,TW_PV autolearn=ham version=3.3.1 Received: from mail-db8lp0186.outbound.messaging.microsoft.com (HELO db8outboundpool.messaging.microsoft.com) (213.199.154.186) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Wed, 19 Jun 2013 13:24:58 +0000 Received: from mail80-db8-R.bigfish.com (10.174.8.247) by DB8EHSOBE029.bigfish.com (10.174.4.92) with Microsoft SMTP Server id 14.1.225.23; Wed, 19 Jun 2013 13:24:54 +0000 Received: from mail80-db8 (localhost [127.0.0.1]) by mail80-db8-R.bigfish.com (Postfix) with ESMTP id 9D407D60271; Wed, 19 Jun 2013 13:24:54 +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: 1 X-BigFish: VPS1(zz936eIc85fh154dIde40hc8kzz1f42h1ee6h1de0h1fdah1202h1e76h1d1ah1d2ah1fc6hzz177df4h17326ah8275bh8275dhz2dh2a8h668h839hd25hf0ah1288h12a5h12bdh137ah1441h14ddh1504h1537h153bh15d0h162dh1631h1758h18e1h1946h19b5h1b0ah1bceh1d0ch1d2eh1d3fh1dfeh1dffh1e1dh34h1155h) Received: from mail80-db8 (localhost.localdomain [127.0.0.1]) by mail80-db8 (MessageSwitch) id 1371648291248368_16081; Wed, 19 Jun 2013 13:24:51 +0000 (UTC) Received: from DB8EHSMHS031.bigfish.com (unknown [10.174.8.253]) by mail80-db8.bigfish.com (Postfix) with ESMTP id 21FFDDA00B8; Wed, 19 Jun 2013 13:24:51 +0000 (UTC) Received: from KCHJEXHC01.kpit.com (59.163.77.45) by DB8EHSMHS031.bigfish.com (10.174.4.41) with Microsoft SMTP Server (TLS) id 14.16.227.3; Wed, 19 Jun 2013 13:24:20 +0000 Received: from KCHJEXMB02.kpit.com ([169.254.2.54]) by KCHJEXHC01.kpit.com ([172.10.15.73]) with mapi id 14.03.0123.003; Wed, 19 Jun 2013 18:44:23 +0530 From: Kaushik Phatak To: "gdb-patches@sourceware.org" CC: Pedro Alves , Joel Brobecker , "gcc-patches@gcc.gnu.org" Subject: RE: [RFA 3/5] New port: CR16: gdb port Date: Wed, 19 Jun 2013 13:30:00 -0000 Message-ID: References: <20121022224107.GB3713@adacore.com> <20121023135502.GA3555@adacore.com> <20121115174313.GC3790@adacore.com> <20121122175010.GG9964@adacore.com> <20130117085919.GA3564@adacore.com> <20130118141649.GK3564@adacore.com> <50FEABC8.2040805@redhat.com> <510002E0.7070806@redhat.com> In-Reply-To: <510002E0.7070806@redhat.com> Content-Type: multipart/mixed; boundary="_002_C6CA53A2A46BA7469348BDBD663AB6585308FA27KCHJEXMB02kpitc_" MIME-Version: 1.0 X-OriginatorOrg: kpitcummins.com X-FOPE-CONNECTOR: Id%0$Dn%*$RO%0$TLS%0$FQDN%$TlsDn% X-Virus-Found: No X-SW-Source: 2013-06/txt/msg00490.txt.bz2 --_002_C6CA53A2A46BA7469348BDBD663AB6585308FA27KCHJEXMB02kpitc_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Content-length: 36038 Hi, Please find below an updated patch for the gdb port of the CR16 target. This has been updated from my previous attempts of the same, http://sourceware.org/ml/gdb-patches/2013-01/msg00299.html The gdb port required cleanup and some tweaking and is largely unchanged,=20 however the gdbserver port required some structural changes in the RSP for= =20 register access. The below gdb port has following changes, 1. Removed pseudo register "r0r1_orig" which is not part of user visible=20 registers and used internally by the kernel. 2. Added support for debug registers in the ELF port. This will make it con= sistent=20 with the current simulator port which already supports them. 3. Use gdb_insn_length to read the length of the current instruction. This = removes a lot of the bfd code that used exported functions and globals. Pedro and J= oel had concerns over using this piece of code, which is now removed. 4. Use local variable "cr16_insn_words" instead of global "cr16_words" for = opcode analysis in cr16_analyze_prologue. I will also be posting an updated gdbserver port which will compliment this= port. I am copying gcc-patches here, as there are changes to configure.ac. 2013-06-19 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. * configure.ac : Add support for cr16-*-* * configure: Regenerate. 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.445 diff -u -r1.445 configure --- configure 22 Apr 2013 15:25:08 -0000 1.445 +++ configure 19 Jun 2013 12:44:08 -0000 @@ -3622,6 +3622,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.188 diff -u -r1.188 configure.ac --- configure.ac 22 Apr 2013 15:25:09 -0000 1.188 +++ configure.ac 19 Jun 2013 12:44:09 -0000 @@ -961,6 +961,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.276 diff -u -r1.276 configure.tgt --- gdb/configure.tgt 7 May 2013 01:09:28 -0000 1.276 +++ gdb/configure.tgt 19 Jun 2013 12:44:10 -0000 @@ -129,6 +129,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 2013-05-10 19:36:04.372328500 +0530 +++ ./gdb/cr16-linux-tdep.c 2013-06-17 12:49:05.000000000 +0530 @@ -0,0 +1,106 @@ +/* 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 20 + +/* 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", + "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 2013-05-10 19:36:04.372328500 +0530 +++ ./gdb/cr16-tdep.c 2013-06-18 10:11:46.000000000 +0530 @@ -0,0 +1,894 @@ +/* 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 27 + +/* 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", + "dbs", + "dcrl", + "dsr", + "car0", + "car1", + "cfg", + "psr" +}; + +/* 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: + case SIM_CR16_DBS_REGNUM: + case SIM_CR16_DCR_REGNUM: + case SIM_CR16_DSR_REGNUM: + case SIM_CR16_CAR0_REGNUM: + case SIM_CR16_CAR1_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; + short cr16_insn_words[3]; + struct gdbarch *gdbarch; + + gdbarch =3D target_gdbarch (); + 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_insn_words[0] =3D buf[1] << 8 | buf[0]; + cr16_insn_words[1] =3D buf[3] << 8 | buf[2]; + cr16_insn_words[2] =3D buf[5] << 8 | buf[4]; + + /* Read the length of the instruction */ + length =3D gdb_insn_length (gdbarch, pc); + next_pc =3D pc + length; + insn_byte1 =3D (cr16_insn_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_insn_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_insn_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_insn_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_insn_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 2013-05-10 19:36:04.372328500 +0530 +++ ./gdb/cr16-tdep.h 2013-06-17 12:49:05.000000000 +0530 @@ -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_C6CA53A2A46BA7469348BDBD663AB6585308FA27KCHJEXMB02kpitc_ Content-Type: application/octet-stream; name="cr16_gdb.diff" Content-Description: cr16_gdb.diff Content-Disposition: attachment; filename="cr16_gdb.diff"; size=33271; creation-date="Wed, 19 Jun 2013 12:48:48 GMT"; modification-date="Wed, 19 Jun 2013 12:58:07 GMT" Content-Transfer-Encoding: base64 Content-length: 45104 SW5kZXg6IGNvbmZpZ3VyZQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBm aWxlOiAvY3ZzL3NyYy9zcmMvY29uZmlndXJlLHYKcmV0cmlldmluZyByZXZp c2lvbiAxLjQ0NQpkaWZmIC11IC1yMS40NDUgY29uZmlndXJlCi0tLSBjb25m aWd1cmUJMjIgQXByIDIwMTMgMTU6MjU6MDggLTAwMDAJMS40NDUKKysrIGNv bmZpZ3VyZQkxOSBKdW4gMjAxMyAxMjo0NDowOCAtMDAwMApAQCAtMzYyMiw2 ICszNjIyLDkgQEAKICAgdGljNTR4LSotKikKICAgICBub2NvbmZpZ2RpcnM9 IiRub2NvbmZpZ2RpcnMgdGFyZ2V0LWxpYmdsb3NzIGdkYiIKICAgICA7Owor ICBjcjE2LSotKikKKyAgICBub2NvbmZpZ2RpcnM9IiRub2NvbmZpZ2RpcnMg dGFyZ2V0LWxpYmdsb3NzIgorICAgIDs7CiAgIGQxMHYtKi0qKQogICAgIG5v Y29uZmlnZGlycz0iJG5vY29uZmlnZGlycyB0YXJnZXQtbGliZ2xvc3MiCiAg ICAgOzsKSW5kZXg6IGNvbmZpZ3VyZS5hYwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09ClJDUyBmaWxlOiAvY3ZzL3NyYy9zcmMvY29uZmlndXJlLmFjLHYKcmV0 cmlldmluZyByZXZpc2lvbiAxLjE4OApkaWZmIC11IC1yMS4xODggY29uZmln dXJlLmFjCi0tLSBjb25maWd1cmUuYWMJMjIgQXByIDIwMTMgMTU6MjU6MDkg LTAwMDAJMS4xODgKKysrIGNvbmZpZ3VyZS5hYwkxOSBKdW4gMjAxMyAxMjo0 NDowOSAtMDAwMApAQCAtOTYxLDYgKzk2MSw5IEBACiAgIHRpYzU0eC0qLSop CiAgICAgbm9jb25maWdkaXJzPSIkbm9jb25maWdkaXJzIHRhcmdldC1saWJn bG9zcyBnZGIiCiAgICAgOzsKKyAgY3IxNi0qLSopCisgICAgbm9jb25maWdk aXJzPSIkbm9jb25maWdkaXJzIHRhcmdldC1saWJnbG9zcyIKKyAgICA7Owog ICBkMTB2LSotKikKICAgICBub2NvbmZpZ2RpcnM9IiRub2NvbmZpZ2RpcnMg dGFyZ2V0LWxpYmdsb3NzIgogICAgIDs7CkluZGV4OiBnZGIvY29uZmlndXJl LnRndAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBmaWxlOiAvY3ZzL3Ny Yy9zcmMvZ2RiL2NvbmZpZ3VyZS50Z3QsdgpyZXRyaWV2aW5nIHJldmlzaW9u IDEuMjc2CmRpZmYgLXUgLXIxLjI3NiBjb25maWd1cmUudGd0Ci0tLSBnZGIv Y29uZmlndXJlLnRndAk3IE1heSAyMDEzIDAxOjA5OjI4IC0wMDAwCTEuMjc2 CisrKyBnZGIvY29uZmlndXJlLnRndAkxOSBKdW4gMjAxMyAxMjo0NDoxMCAt MDAwMApAQCAtMTI5LDYgKzEyOSwxOCBAQAogCWdkYl9zaW09Li4vc2ltL2Jm aW4vbGlic2ltLmEKIAk7OwogCitjcjE2Ki0qLSpsaW51eCkKKwkjIFRhcmdl dDogQ1IxNiBwcm9jZXNzb3IKKwlnZGJfdGFyZ2V0X29icz0iY3IxNi10ZGVw Lm8gY3IxNi1saW51eC10ZGVwLm8gbGludXgtdGRlcC5vIgorCWdkYl9zaW09 Li4vc2ltL2NyMTYvbGlic2ltLmEKKwk7OworCitjcjE2Ki0qLSopCisJIyBU YXJnZXQ6IENSMTYgcHJvY2Vzc29yCisJZ2RiX3RhcmdldF9vYnM9ImNyMTYt dGRlcC5vIgorCWdkYl9zaW09Li4vc2ltL2NyMTYvbGlic2ltLmEKKwk7Owor CiBjcmlzKikKIAkjIFRhcmdldDogQ1JJUwogCWdkYl90YXJnZXRfb2JzPSJj cmlzLXRkZXAubyBzb2xpYi1zdnI0Lm8iCkluZGV4OiBnZGIvY3IxNi1saW51 eC10ZGVwLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1MgZmlsZTogZ2Ri L2NyMTYtbGludXgtdGRlcC5jCmRpZmYgLU4gZ2RiL2NyMTYtbGludXgtdGRl cC5jCi0tLSAvZGV2L251bGwJMjAxMy0wNS0xMCAxOTozNjowNC4zNzIzMjg1 MDAgKzA1MzAKKysrIC4vZ2RiL2NyMTYtbGludXgtdGRlcC5jCTIwMTMtMDYt MTcgMTI6NDk6MDUuMDAwMDAwMDAwICswNTMwCkBAIC0wLDAgKzEsMTA2IEBA CisvKiBUYXJnZXQtZGVwZW5kZW50IGNvZGUgZm9yIEdOVS9MaW51eCBvbiB0 aGUgU2l0ZWwgQ1IxNiBwcm9jZXNzb3JzLgorCisgICBDb3B5cmlnaHQgKEMp IDIwMTItMjAxMyBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKwor ICAgQ29udHJpYnV0ZWQgYnkgS2F1c2hpayBQaGF0YWsgKGthdXNoaWsucGhh dGFrQGtwaXRjdW1taW5zLmNvbSkKKyAgIEtQSVQgQ3VtbWlucyBJbmZvc3lz dGVtcyBMaW1pdGVkLCBQdW5lIEluZGlhLgorCisgICBUaGlzIGZpbGUgaXMg cGFydCBvZiBHREIuCisKKyAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cisg ICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICAgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5z ZSwgb3IKKyAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisKKyAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAgYnV0IFdJVEhPVVQgQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAgIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgIFlvdSBzaG91bGQg aGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlCisgICBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5v dCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4gICovCisK KyNpbmNsdWRlICJkZWZzLmgiCisjaW5jbHVkZSAib3NhYmkuaCIKKyNpbmNs dWRlICJlbGYtYmZkLmgiCisjaW5jbHVkZSAiZWxmL2NyMTYuaCIKKyNpbmNs dWRlICJsaW51eC10ZGVwLmgiCisjaW5jbHVkZSAic3ltdGFiLmgiCisjaW5j bHVkZSAiY3IxNi10ZGVwLmgiCisKKy8qIE51bWJlciBvZiByZWdpc3RlcnMg YXZhaWxhYmxlIGZvciBMaW51eCB0YXJnZXRzICAqLworI2RlZmluZSBDUjE2 X0xJTlVYX05VTV9SRUdTICAyMAorCisvKiBUaGUgYnJlYWtwb2ludCBpbnN0 cnVjdGlvbiB1c2VkIGJ5IHVDbGludXggdGFyZ2V0ICAqLworc3RhdGljIGNv bnN0IGdkYl9ieXRlIGJyZWFrcG9pbnRfdWNsaW51eFtdID0geyAweEM3LCAw eDAwIH07CisKK3N0YXRpYyBjb25zdCBjaGFyICpjb25zdCByZWdfbmFtZXNb XSA9Cit7CisgICJyMCIsCisgICJyMSIsCisgICJyMiIsCisgICJyMyIsCisg ICJyNCIsCisgICJyNSIsCisgICJyNiIsCisgICJyNyIsCisgICJyOCIsCisg ICJyOSIsCisgICJyMTAiLAorICAicjExIiwKKyAgInIxMiIsCisgICJyMTMi LAorICAicmEiLAorICAicHNyIiwKKyAgInBjIiwKKyAgImludGJhc2UiLAor ICAidXNwIiwKKyAgImNmZyIKK307CisKKy8qIFZlcmlmeSByZWdpc3RlciBh cnJheSBzaXplIGlzIHdpdGhpbiBoYXJkd2FyZSByZWdpc3RlciBsaW1pdC4g ICovCisKK2dkYl9zdGF0aWNfYXNzZXJ0IChBUlJBWV9TSVpFIChyZWdfbmFt ZXMpIDw9IENSMTZfTElOVVhfTlVNX1JFR1MpOworCisvKiBJbXBsZW1lbnQg dGhlICJyZWdpc3Rlcl9uYW1lIiBnZGJhcmNoIG1ldGhvZC4gICovCisKK3N0 YXRpYyBjb25zdCBjaGFyICoKK2NyMTZfbGludXhfcmVnaXN0ZXJfbmFtZSAo c3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIGludCByZWducikKK3sKKyAgZ2Ri X2Fzc2VydCAocmVnbnIgPj0gMCAmJiByZWduciA8IENSMTZfTElOVVhfTlVN X1JFR1MpOworICByZXR1cm4gcmVnX25hbWVzW3JlZ25yXTsKK30KKworLyog T1Mgc3BlY2lmaWMgaW5pdGlhbGl6YXRpb24gb2YgZ2RiYXJjaC4gICovCisK K3N0YXRpYyB2b2lkCitjcjE2X3VjbGludXhfaW5pdF9hYmkgKHN0cnVjdCBn ZGJhcmNoX2luZm8gaW5mbywgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gpCit7 CisgIHN0cnVjdCBnZGJhcmNoX3RkZXAgKnRkZXAgPSBnZGJhcmNoX3RkZXAg KGdkYmFyY2gpOworCisgIGxpbnV4X2luaXRfYWJpIChpbmZvLCBnZGJhcmNo KTsKKworICBzZXRfZ2RiYXJjaF9udW1fcmVncyAoZ2RiYXJjaCwgQ1IxNl9M SU5VWF9OVU1fUkVHUyk7CisgIHNldF9nZGJhcmNoX3JlZ2lzdGVyX25hbWUg KGdkYmFyY2gsIGNyMTZfbGludXhfcmVnaXN0ZXJfbmFtZSk7CisKKyAgLyog VGhlIG9wY29kZSBvZiBleGNwIGJwdCBpcyAweDAwQzgsIGhvd2V2ZXIgZm9y IHVjbGludXggd2Ugd2lsbAorICAgICB1c2UgdGhlIGV4Y3AgZmxnICgweDAw QzcpIHRvIGluc2VydCBhIGJyZWFrcG9pbnQuICBUaGUgZXhjcCBicHQKKyAg ICAgcmVxdWlyZXMgZXh0ZXJuYWwgaGFyZHdhcmUgc3VwcG9ydCBmb3IgYnJl YWtwb2ludHMgdG8gd29yayBvbgorICAgICBDUjE2IHRhcmdldC4gIFNvZnR3 YXJlIGJhc2VkIGJyZWFrcG9pbnRzIGFyZSBpbXBsZW1lbnRlZCBpbiB0aGUK KyAgICAga2VybmVsIHVzaW5nIGV4Y3AgZmxnIGFuZCB0ZXN0ZWQgb24gdGhl IFNDMTQ0NTIgdGFyZ2V0LiAgVXNlCisgICAgIDB4MDBDNyB3aXRoIGdkYnNl cnZlci9rZXJuZWwgYW5kIDB4MDBDOCBmb3Igc2ltL0VMRi4gIFdlCisgICAg IHJlcHJlc2VudCB0aGUgYnJlYWtwb2ludCBpbiBsaXR0bGUgZW5kaWFuIGZv cm1hdCBzaW5jZSBDUjE2CisgICAgIHN1cHBvcnRzIG9ubHkgbGl0dGxlIGVu ZGlhbi4gICovCisgIHRkZXAtPmJyZWFrcG9pbnQgPSBicmVha3BvaW50X3Vj bGludXg7CisKK30KKworLyogUHJvdmlkZSBhIHByb3RvdHlwZSB0byBzaWxl bmNlIC1XbWlzc2luZy1wcm90b3R5cGVzLiAgKi8KK2V4dGVybiBpbml0aWFs aXplX2ZpbGVfZnR5cGUgX2luaXRpYWxpemVfY3IxNl9saW51eF90ZGVwOwor Cit2b2lkCitfaW5pdGlhbGl6ZV9jcjE2X2xpbnV4X3RkZXAgKHZvaWQpCit7 CisgIGdkYmFyY2hfcmVnaXN0ZXJfb3NhYmkgKGJmZF9hcmNoX2NyMTYsIDAs IEdEQl9PU0FCSV9MSU5VWCwKKwkJCSAgY3IxNl91Y2xpbnV4X2luaXRfYWJp KTsKK30KSW5kZXg6IGdkYi9jcjE2LXRkZXAuYwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09ClJDUyBmaWxlOiBnZGIvY3IxNi10ZGVwLmMKZGlmZiAtTiBnZGIv Y3IxNi10ZGVwLmMKLS0tIC9kZXYvbnVsbAkyMDEzLTA1LTEwIDE5OjM2OjA0 LjM3MjMyODUwMCArMDUzMAorKysgLi9nZGIvY3IxNi10ZGVwLmMJMjAxMy0w Ni0xOCAxMDoxMTo0Ni4wMDAwMDAwMDAgKzA1MzAKQEAgLTAsMCArMSw4OTQg QEAKKy8qIFRhcmdldC1kZXBlbmRlbnQgY29kZSBmb3IgdGhlIFNpdGVsIENS MTYgZm9yIEdEQiwgdGhlIEdOVSBkZWJ1Z2dlci4KKyAKKyAgIENvcHlyaWdo dCAoQykgMjAxMi0yMDEzIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LgorIAorICAgQ29udHJpYnV0ZWQgYnkgS2F1c2hpayBQaGF0YWsgKGthdXNo aWsucGhhdGFrQGtwaXRjdW1taW5zLmNvbSkKKyAgIEtQSVQgQ3VtbWlucyBJ bmZvc3lzdGVtcyBMaW1pdGVkLCBQdW5lIEluZGlhLgorICAgVGhpcyBmaWxl IGlzIHBhcnQgb2YgR0RCLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5 CisgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgIHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vu c2UsIG9yCisgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisgCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv ZgorICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlCisgIEdOVSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgIFlvdSBzaG91bGQgaGF2 ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlCisgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBz ZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LiAgKi8KKworI2lu Y2x1ZGUgImRlZnMuaCIKKyNpbmNsdWRlICJhcmNoLXV0aWxzLmgiCisjaW5j bHVkZSAicHJvbG9ndWUtdmFsdWUuaCIKKyNpbmNsdWRlICJ0YXJnZXQuaCIK KyNpbmNsdWRlICJyZWdjYWNoZS5oIgorI2luY2x1ZGUgIm9wY29kZS9jcjE2 LmgiCisjaW5jbHVkZSAiZGlzLWFzbS5oIgorI2luY2x1ZGUgImdkYnR5cGVz LmgiCisjaW5jbHVkZSAiZnJhbWUuaCIKKyNpbmNsdWRlICJmcmFtZS11bndp bmQuaCIKKyNpbmNsdWRlICJmcmFtZS1iYXNlLmgiCisjaW5jbHVkZSAidmFs dWUuaCIKKyNpbmNsdWRlICJnZGJjb3JlLmgiCisjaW5jbHVkZSAiZHdhcmYy LWZyYW1lLmgiCisjaW5jbHVkZSAiZ2RiL3NpbS1jcjE2LmgiCisjaW5jbHVk ZSAiZWxmL2NyMTYuaCIKKyNpbmNsdWRlICJlbGYtYmZkLmgiCisjaW5jbHVk ZSAib3NhYmkuaCIKKyNpbmNsdWRlICJjcjE2LXRkZXAuaCIKKworLyogTnVt YmVyIG9mIHJlZ2lzdGVycyBhdmFpbGFibGUgZm9yIEVMRiB0YXJnZXRzLiAg Ki8KKyNkZWZpbmUgQ1IxNl9OVU1fUkVHUyAgMjcKKworLyogVGhlIGJyZWFr cG9pbnQgaW5zdHJ1Y3Rpb24gdXNlZCB3aXRoIHNpbSBmb3IgRUxGIHRhcmdl dHMuICAqLworc3RhdGljIGNvbnN0IGdkYl9ieXRlIGJyZWFrcG9pbnRfZWxm W10gPSB7IDB4QzgsIDB4MDAgfTsKKworLyogQ2VydGFpbiBpbXBvcnRhbnQg cmVnaXN0ZXIgbnVtYmVycy4gICovCitlbnVtCit7CisgIENSMTZfUjBfUkVH TlVNID0gMCwKKyAgQ1IxNl9SN19SRUdOVU0gPSA3LAorICBDUjE2X1IxMl9S RUdOVU0gPSAxMiwKKyAgQ1IxNl9GUF9SRUdOVU0gPSAxMywKKyAgQ1IxNl9S QV9SRUdOVU0gPSAxNCwKKyAgQ1IxNl9TUF9SRUdOVU0gPSAxNSwKKyAgQ1Ix Nl9QQ19SRUdOVU0gPSAxNiwKK307CisKKy8qIFRoaXMgc3RydWN0dXJlIGhv bGRzIHRoZSByZXN1bHRzIG9mIGEgcHJvbG9ndWUgYW5hbHlzaXMuICAqLwor c3RydWN0IGNyMTZfcHJvbG9ndWUKK3sKKyAgLyogVGhlIG9mZnNldCBmcm9t IHRoZSBmcmFtZSBiYXNlIHRvIHRoZSBzdGFjayBwb2ludGVyIC0tLSBhbHdh eXMKKyAgICAgemVybyBvciBuZWdhdGl2ZS4KKworICAgICBDYWxsaW5nIHRo aXMgYSAic2l6ZSIgaXMgYSBiaXQgbWlzbGVhZGluZywgYnV0IGdpdmVuIHRo YXQgdGhlCisgICAgIHN0YWNrIGdyb3dzIGRvd253YXJkcywgdXNpbmcgb2Zm c2V0cyBmb3IgZXZlcnl0aGluZyBrZWVwcyBvbmUKKyAgICAgZnJvbSBnb2lu ZyBjb21wbGV0ZWx5IHNpZ24tY3Jhenk6IHlvdSBuZXZlciBjaGFuZ2UgYW55 dGhpbmcncworICAgICBzaWduIGZvciBhbiBBREQgaW5zdHJ1Y3Rpb247IGFs d2F5cyBjaGFuZ2UgdGhlIHNlY29uZCBvcGVyYW5kJ3MKKyAgICAgc2lnbiBm b3IgYSBTVUIgaW5zdHJ1Y3Rpb247IGFuZCBldmVyeXRoaW5nIHRha2VzIGNh cmUgb2YKKyAgICAgaXRzZWxmLiAgKi8KKyAgaW50IGZyYW1lX3NpemU7CisK KyAgLyogTm9uLXplcm8gaWYgdGhpcyBmdW5jdGlvbiBoYXMgaW5pdGlhbGl6 ZWQgdGhlIGZyYW1lIHBvaW50ZXIgZnJvbQorICAgICB0aGUgc3RhY2sgcG9p bnRlciwgemVybyBvdGhlcndpc2UuICAqLworICBpbnQgaGFzX2ZyYW1lX3B0 cjsKKworICAvKiBJZiBoYXNfZnJhbWVfcHRyIGlzIG5vbi16ZXJvLCB0aGlz IGlzIHRoZSBvZmZzZXQgZnJvbSB0aGUgZnJhbWUKKyAgICAgYmFzZSB0byB3 aGVyZSB0aGUgZnJhbWUgcG9pbnRlciBwb2ludHMuICBUaGlzIGlzIGFsd2F5 cyB6ZXJvIG9yCisgICAgIG5lZ2F0aXZlLiAgKi8KKyAgaW50IGZyYW1lX3B0 cl9vZmZzZXQ7CisKKyAgLyogVGhlIGFkZHJlc3Mgb2YgdGhlIGZpcnN0IGlu c3RydWN0aW9uIGF0IHdoaWNoIHRoZSBmcmFtZSBoYXMgYmVlbgorICAgICBz ZXQgdXAgYW5kIHRoZSBhcmd1bWVudHMgYXJlIHdoZXJlIHRoZSBkZWJ1ZyBp bmZvIHNheXMgdGhleSBhcmUKKyAgICAgLS0tIGFzIGJlc3QgYXMgd2UgY2Fu IHRlbGwuICAqLworICBDT1JFX0FERFIgcHJvbG9ndWVfZW5kOworCisgIC8q IHJlZ19vZmZzZXRbUl0gaXMgdGhlIG9mZnNldCBmcm9tIHRoZSBDRkEgYXQg d2hpY2ggcmVnaXN0ZXIgUiBpcworICAgICBzYXZlZCwgb3IgMSBpZiByZWdp c3RlciBSIGhhcyBub3QgYmVlbiBzYXZlZC4gIChSZWFsIHZhbHVlcyBhcmUK KyAgICAgYWx3YXlzIHplcm8gb3IgbmVnYXRpdmUuKSAgKi8KKyAgaW50IHJl Z19vZmZzZXRbQ1IxNl9OVU1fUkVHU107Cit9OworCisvKiBIYXJkd2FyZSBy ZWdpc3RlciBuYW1lIGRlY2xhcmF0aW9uLiAgKi8KK3N0YXRpYyBjb25zdCBj aGFyICpjb25zdCByZWdfbmFtZXNbXSA9Cit7CisgICJyMCIsCisgICJyMSIs CisgICJyMiIsCisgICJyMyIsCisgICJyNCIsCisgICJyNSIsCisgICJyNiIs CisgICJyNyIsCisgICJyOCIsCisgICJyOSIsCisgICJyMTAiLAorICAicjEx IiwKKyAgInIxMiIsCisgICJyMTMiLAorICAicmEiLAorICAic3AiLAorICAi cGMiLAorICAiaXNwIiwKKyAgInVzcCIsCisgICJpbnRiYXNlIiwKKyAgImRi cyIsCisgICJkY3JsIiwKKyAgImRzciIsCisgICJjYXIwIiwKKyAgImNhcjEi LAorICAiY2ZnIiwKKyAgInBzciIKK307CisKKy8qIFZlcmlmeSByZWdpc3Rl ciBhcnJheSBzaXplIGlzIHdpdGhpbiBoYXJkd2FyZSByZWdpc3RlciBsaW1p dC4gICovCisKK2dkYl9zdGF0aWNfYXNzZXJ0IChBUlJBWV9TSVpFIChyZWdf bmFtZXMpIDw9IENSMTZfTlVNX1JFR1MpOworCisvKiBJbXBsZW1lbnQgdGhl ICJyZWdpc3Rlcl9uYW1lIiBnZGJhcmNoIG1ldGhvZC4gICovCisKK3N0YXRp YyBjb25zdCBjaGFyICoKK2NyMTZfcmVnaXN0ZXJfbmFtZSAoc3RydWN0IGdk YmFyY2ggKmdkYmFyY2gsIGludCByZWducikKK3sKKyAgZ2RiX2Fzc2VydCAo cmVnbnIgPj0gMCAmJiByZWduciA8IENSMTZfTlVNX1JFR1MpOworICByZXR1 cm4gcmVnX25hbWVzW3JlZ25yXTsKK30KKworLyogSW1wbGVtZW50IHRoZSAi cmVnaXN0ZXJfdHlwZSIgZ2RiYXJjaCBtZXRob2QuICAqLworCitzdGF0aWMg c3RydWN0IHR5cGUgKgorY3IxNl9yZWdpc3Rlcl90eXBlIChzdHJ1Y3QgZ2Ri YXJjaCAqZ2RiYXJjaCwgaW50IHJlZ19ucikKK3sKKyAgc3dpdGNoIChyZWdf bnIpCisgICAgeworICAgIGNhc2UgQ1IxNl9QQ19SRUdOVU06CS8qIE5vdGU6 IFBDIGluIENSMTYgaXMgb2YgMjQgYml0cy4gICovCisgICAgICByZXR1cm4g YnVpbHRpbl90eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9mdW5jX3B0cjsKKwor ICAgIGNhc2UgQ1IxNl9SQV9SRUdOVU06CS8qIFJldHVybiBhZGRyZXNzIHJl Zy4gICovCisgICAgICByZXR1cm4gYnVpbHRpbl90eXBlIChnZGJhcmNoKS0+ YnVpbHRpbl9kYXRhX3B0cjsKKworICAgIGNhc2UgQ1IxNl9GUF9SRUdOVU06 CS8qIEZyYW1lIFBvaW50ZXIgcmVnLiAgKi8KKyAgICBjYXNlIENSMTZfU1Bf UkVHTlVNOgkvKiBTdGFjayBQb2ludGVyIHJlZy4gICovCisgICAgICByZXR1 cm4gYnVpbHRpbl90eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9kYXRhX3B0cjsK KworICAgIGNhc2UgU0lNX0NSMTZfSVNQX1JFR05VTToKKyAgICBjYXNlIFNJ TV9DUjE2X1VTUF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9JTlRCQVNF X1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X1BTUl9SRUdOVU06CisgICAg Y2FzZSBTSU1fQ1IxNl9DRkdfUkVHTlVNOgorICAgIGNhc2UgU0lNX0NSMTZf REJTX1JFR05VTToKKyAgICBjYXNlIFNJTV9DUjE2X0RDUl9SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9EU1JfUkVHTlVNOgorICAgIGNhc2UgU0lNX0NS MTZfQ0FSMF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9DQVIxX1JFR05V TToKKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUgKGdkYmFyY2gpLT5idWls dGluX2ludDMyOworCisgICAgY2FzZSBTSU1fQ1IxNl9SMF9SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9SMV9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1Ix Nl9SMl9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SM19SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9SNF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1Ix Nl9SNV9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SNl9SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9SN19SRUdOVU06CisgICAgY2FzZSBTSU1fQ1Ix Nl9SOF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SOV9SRUdOVU06Cisg ICAgY2FzZSBTSU1fQ1IxNl9SMTBfUkVHTlVNOgorICAgIGNhc2UgU0lNX0NS MTZfUjExX1JFR05VTToKKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUgKGdk YmFyY2gpLT5idWlsdGluX2ludDE2OworCisgICAgY2FzZSBTSU1fQ1IxNl9S MTJfUkVHTlVNOgorICAgICAgcmV0dXJuIGJ1aWx0aW5fdHlwZSAoZ2RiYXJj aCktPmJ1aWx0aW5faW50MzI7CisKKyAgICBkZWZhdWx0OgorICAgICAgcmV0 dXJuIGJ1aWx0aW5fdHlwZSAoZ2RiYXJjaCktPmJ1aWx0aW5faW50MzI7Cisg ICAgfQorfQorCisvKiBGdW5jdGlvbiBmb3IgZmluZGluZyBzYXZlZCByZWdp c3RlcnMgaW4gYSAnc3RydWN0IHB2X2FyZWEnOyB0aGlzCisgICBmdW5jdGlv biBpcyBwYXNzZWQgdG8gcHZfYXJlYV9zY2FuLgorCisgICBJZiBWQUxVRSBp cyBhIHNhdmVkIHJlZ2lzdGVyLCBBRERSIHNheXMgaXQgd2FzIHNhdmVkIGF0 IGEgY29uc3RhbnQKKyAgIG9mZnNldCBmcm9tIHRoZSBmcmFtZSBiYXNlLCBh bmQgU0laRSBpbmRpY2F0ZXMgdGhhdCB0aGUgd2hvbGUKKyAgIHJlZ2lzdGVy IHdhcyBzYXZlZCwgcmVjb3JkIGl0cyBvZmZzZXQuICAqLworCitzdGF0aWMg dm9pZAorY2hlY2tfZm9yX3NhdmVkICh2b2lkICpyZXN1bHRfdW50eXBlZCwg cHZfdCBhZGRyLCBDT1JFX0FERFIgc2l6ZSwgcHZfdCB2YWx1ZSkKK3sKKyAg c3RydWN0IGNyMTZfcHJvbG9ndWUgKnJlc3VsdCA9IChzdHJ1Y3QgY3IxNl9w cm9sb2d1ZSAqKSByZXN1bHRfdW50eXBlZDsKKworICBpZiAodmFsdWUua2lu ZCA9PSBwdmtfcmVnaXN0ZXIKKyAgICAgICYmIHZhbHVlLmsgPT0gMAorICAg ICAgJiYgcHZfaXNfcmVnaXN0ZXIgKGFkZHIsIENSMTZfU1BfUkVHTlVNKQor ICAgICAgJiYgc2l6ZSA9PSByZWdpc3Rlcl9zaXplICh0YXJnZXRfZ2RiYXJj aCAoKSwgdmFsdWUucmVnKSkKKyAgICByZXN1bHQtPnJlZ19vZmZzZXRbdmFs dWUucmVnXSA9IGFkZHIuazsKK30KKworLyogRGVmaW5lIGEgImhhbmRsZSIg c3RydWN0IGZvciBmZXRjaGluZyB0aGUgbmV4dCBvcGNvZGUuICAqLworCitz dHJ1Y3QgY3IxNl9nZXRfb3Bjb2RlX2J5dGVfaGFuZGxlCit7CisgIENPUkVf QUREUiBwYzsKK307CisKKy8qIEFuYWx5emUgYSBwcm9sb2d1ZSBzdGFydGlu ZyBhdCBTVEFSVF9QQywgZ29pbmcgbm8gZnVydGhlciB0aGFuCisgICBMSU1J VF9QQy4gIEZpbGwgaW4gUkVTVUxUIGFzIGFwcHJvcHJpYXRlLiAgKi8KKwor c3RhdGljIHZvaWQKK2NyMTZfYW5hbHl6ZV9wcm9sb2d1ZSAoQ09SRV9BRERS IHN0YXJ0X3BjLAorCQkgICAgICAgQ09SRV9BRERSIGxpbWl0X3BjLCBzdHJ1 Y3QgY3IxNl9wcm9sb2d1ZSAqcmVzdWx0KQoreworICBDT1JFX0FERFIgcGMs IG5leHRfcGM7CisgIGdkYl9ieXRlIGluc25fYnl0ZTEsIGluc25fYnl0ZTI7 CisgIGludCBybjsKKyAgaW50IGxlbmd0aDsKKyAgcHZfdCByZWdbQ1IxNl9O VU1fUkVHU107CisgIHN0cnVjdCBwdl9hcmVhICpzdGFjazsKKyAgc3RydWN0 IGNsZWFudXAgKmJhY2tfdG87CisgIENPUkVfQUREUiBhZnRlcl9sYXN0X2Zy YW1lX3NldHVwX2luc24gPSBzdGFydF9wYzsKKyAgaW50IGlzX2RlY29kZWQ7 CisgIHNob3J0IGNyMTZfaW5zbl93b3Jkc1szXTsKKyAgc3RydWN0IGdkYmFy Y2ggKmdkYmFyY2g7CisKKyAgZ2RiYXJjaCA9IHRhcmdldF9nZGJhcmNoICgp OworICBtZW1zZXQgKHJlc3VsdCwgMCwgc2l6ZW9mICgqcmVzdWx0KSk7CisK KyAgZm9yIChybiA9IDA7IHJuIDwgQ1IxNl9OVU1fUkVHUzsgcm4rKykKKyAg ICB7CisgICAgICByZWdbcm5dID0gcHZfcmVnaXN0ZXIgKHJuLCAwKTsKKyAg ICAgIHJlc3VsdC0+cmVnX29mZnNldFtybl0gPSAxOworICAgIH0KKworICBz dGFjayA9IG1ha2VfcHZfYXJlYSAoQ1IxNl9TUF9SRUdOVU0sIGdkYmFyY2hf YWRkcl9iaXQgKHRhcmdldF9nZGJhcmNoICgpKSk7CisgIGJhY2tfdG8gPSBt YWtlX2NsZWFudXBfZnJlZV9wdl9hcmVhIChzdGFjayk7CisKKyAgcGMgPSBz dGFydF9wYzsKKyAgd2hpbGUgKHBjIDwgbGltaXRfcGMpCisgICAgeworICAg ICAgZ2RiX2J5dGUgYnVmWzZdOworCisgICAgICAvKiBSZWFkIDYgYnl0ZXMs IG1heCA0OCBiaXQgb3Bjb2RlLiAgKi8KKyAgICAgIHRhcmdldF9yZWFkX21l bW9yeSAocGMsIGJ1ZiwgNik7CisgICAgICBjcjE2X2luc25fd29yZHNbMF0g PSBidWZbMV0gPDwgOCB8IGJ1ZlswXTsKKyAgICAgIGNyMTZfaW5zbl93b3Jk c1sxXSA9IGJ1ZlszXSA8PCA4IHwgYnVmWzJdOworICAgICAgY3IxNl9pbnNu X3dvcmRzWzJdID0gYnVmWzVdIDw8IDggfCBidWZbNF07CisKKyAgICAgIC8q IFJlYWQgdGhlIGxlbmd0aCBvZiB0aGUgaW5zdHJ1Y3Rpb24gICovCisgICAg ICBsZW5ndGggPSBnZGJfaW5zbl9sZW5ndGggKGdkYmFyY2gsIHBjKTsKKyAg ICAgIG5leHRfcGMgPSBwYyArIGxlbmd0aDsKKyAgICAgIGluc25fYnl0ZTEg PSAoY3IxNl9pbnNuX3dvcmRzWzBdID4+IDgpICYgMHhGRjsKKworICAgICAg LyogSWYgUFVTSCwgdGhlbiBzYXZlIFJBIGFuZCBvdGhlciByZWdzLiAgKi8K KyAgICAgIGlmIChpbnNuX2J5dGUxID09IDB4MDEpCisJeworCSAgaW50IHIx LCByMjsKKwkgIGludCByOworCisJICBpbnNuX2J5dGUyID0gY3IxNl9pbnNu X3dvcmRzWzBdOworCisJICBpZiAoaW5zbl9ieXRlMiAmIDB4ODApCisJICAg IHsKKwkgICAgICByZWdbQ1IxNl9TUF9SRUdOVU1dID0gcHZfYWRkX2NvbnN0 YW50IChyZWdbQ1IxNl9TUF9SRUdOVU1dLCAtNCk7CisJICAgICAgcHZfYXJl YV9zdG9yZSAoc3RhY2ssIHJlZ1tDUjE2X1NQX1JFR05VTV0sIDQsCisJCQkg ICAgIHJlZ1tDUjE2X1JBX1JFR05VTV0pOworCSAgICB9CisJICAvKiBTdGFy dCBSZWdpc3Rlcj1yMSwgMyBiaXQgaW1tIGNvdW50PXIyLiAgKi8KKwkgIHIx ID0gaW5zbl9ieXRlMiAmIDB4MEY7CisJICByMiA9ICgoaW5zbl9ieXRlMiAm IDB4NzApID4+IDQpOworCSAgcjIgPSByMiArIHIxICsgMTsKKworCSAgZm9y IChyID0gcjE7IHIgPCByMjsgcisrKQorCSAgICB7CisJICAgICAgaWYgKHIg Pj0gQ1IxNl9SMTJfUkVHTlVNKQorCQl7CisJCSAgcmVnW0NSMTZfU1BfUkVH TlVNXSA9CisJCSAgICBwdl9hZGRfY29uc3RhbnQgKHJlZ1tDUjE2X1NQX1JF R05VTV0sIC00KTsKKwkJICBwdl9hcmVhX3N0b3JlIChzdGFjaywgcmVnW0NS MTZfU1BfUkVHTlVNXSwgNCwgcmVnW3JdKTsKKwkJICByKys7CisJCX0KKwkg ICAgICBlbHNlCisJCXsKKwkJICByZWdbQ1IxNl9TUF9SRUdOVU1dID0KKwkJ ICAgIHB2X2FkZF9jb25zdGFudCAocmVnW0NSMTZfU1BfUkVHTlVNXSwgLTIp OworCQkgIHB2X2FyZWFfc3RvcmUgKHN0YWNrLCByZWdbQ1IxNl9TUF9SRUdO VU1dLCAyLCByZWdbcl0pOworCQl9CisJICAgIH0KKwkgIGFmdGVyX2xhc3Rf ZnJhbWVfc2V0dXBfaW5zbiA9IG5leHRfcGM7CisJfQorICAgICAgLyogQWRk IGNvbnN0YW50IHRvIFNQLiAgKi8KKyAgICAgIGVsc2UgaWYgKGluc25fYnl0 ZTEgPT0gMHg2MCkKKwl7CisJICBpbnQgcmRzdDsKKwkgIHNpZ25lZCBzaG9y dCBhZGRlbmQ7CisKKwkgIGluc25fYnl0ZTIgPSBjcjE2X2luc25fd29yZHNb MF07CisJICByZHN0ID0gaW5zbl9ieXRlMiAmIDB4MEY7CisJICBpZiAocmRz dCA9PSBDUjE2X1NQX1JFR05VTSkKKwkgICAgeworCSAgICAgIGlmIChsZW5n dGggPT0gMikKKwkJeworCQkgIGFkZGVuZCA9IChpbnNuX2J5dGUyICYgMHhG MCkgPj4gNDsKKwkJICByZWdbcmRzdF0gPSBwdl9hZGRfY29uc3RhbnQgKHJl Z1tyZHN0XSwgYWRkZW5kKTsKKwkJfQorCSAgICAgIGlmIChsZW5ndGggPT0g NCkKKwkJeworCQkgIGFkZGVuZCA9IGNyMTZfaW5zbl93b3Jkc1sxXTsKKwkJ ICByZWdbcmRzdF0gPSBwdl9hZGRfY29uc3RhbnQgKHJlZ1tyZHN0XSwgYWRk ZW5kKTsKKwkJfQorCSAgICAgIGFmdGVyX2xhc3RfZnJhbWVfc2V0dXBfaW5z biA9IG5leHRfcGM7CisJICAgIH0KKwl9CisgICAgICAvKiBDaGVjayBmb3Ig TU9WRCBpbnNuLiAgKi8KKyAgICAgIGVsc2UgaWYgKGluc25fYnl0ZTEgPT0g MHg1NSkKKwl7CisJICBpbnQgcmRzdCwgcnNyYzsKKworCSAgaW5zbl9ieXRl MiA9IGNyMTZfaW5zbl93b3Jkc1swXTsKKwkgIHJzcmMgPSAoaW5zbl9ieXRl MiAmIDB4RjApID4+IDQ7CisJICByZHN0ID0gKGluc25fYnl0ZTIgJiAweDBG KTsKKwkgIHJlZ1tyZHN0XSA9IHJlZ1tyc3JjXTsKKwkgIGlmIChyc3JjID09 IENSMTZfU1BfUkVHTlVNICYmIHJkc3QgPT0gQ1IxNl9GUF9SRUdOVU0pCisJ ICAgIGFmdGVyX2xhc3RfZnJhbWVfc2V0dXBfaW5zbiA9IG5leHRfcGM7CisJ fQorICAgICAgZWxzZSBpZiAoKChpbnNuX2J5dGUxID4+IDQpICYgMHgwRikg PT0gMHhkKQorCXsKKwkgIC8qIFRoaXMgbW92ZXMgYW4gYXJndW1lbnQgcmVn aXN0ZXIgdG8gdGhlIHN0YWNrLiAgRG9uJ3QKKwkgICAgIHJlY29yZCBpdCwg YnV0IGFsbG93IGl0IHRvIGJlIGEgcGFydCBvZiB0aGUgcHJvbG9ndWUuICAq LworCSAgYWZ0ZXJfbGFzdF9mcmFtZV9zZXR1cF9pbnNuID0gbmV4dF9wYzsK Kwl9CisgICAgICBlbHNlCisJYnJlYWs7CQkvKiBUZXJtaW5hdGUgdGhlIHBy b2xvZ3VlIHNjYW4uICAqLworCisgICAgICBwYyA9IG5leHRfcGM7CisgICAg fQorCisgIC8qIElzIHRoZSBmcmFtZSBzaXplIChvZmZzZXQsIHJlYWxseSkg YSBrbm93biBjb25zdGFudD8gICovCisgIGlmIChwdl9pc19yZWdpc3RlciAo cmVnW0NSMTZfU1BfUkVHTlVNXSwgQ1IxNl9TUF9SRUdOVU0pKQorICAgIHJl c3VsdC0+ZnJhbWVfc2l6ZSA9IHJlZ1tDUjE2X1NQX1JFR05VTV0uazsKKwor ICAvKiBXYXMgdGhlIGZyYW1lIHBvaW50ZXIgaW5pdGlhbGl6ZWQ/ICAqLwor ICBpZiAocHZfaXNfcmVnaXN0ZXIgKHJlZ1tDUjE2X0ZQX1JFR05VTV0sIENS MTZfU1BfUkVHTlVNKSkKKyAgICB7CisgICAgICByZXN1bHQtPmhhc19mcmFt ZV9wdHIgPSAxOworICAgICAgcmVzdWx0LT5mcmFtZV9wdHJfb2Zmc2V0ID0g cmVnW0NSMTZfRlBfUkVHTlVNXS5rOworICAgIH0KKworICAvKiBSZWNvcmQg d2hlcmUgYWxsIHRoZSByZWdpc3RlcnMgd2VyZSBzYXZlZC4gICovCisgIHB2 X2FyZWFfc2NhbiAoc3RhY2ssIGNoZWNrX2Zvcl9zYXZlZCwgKHZvaWQgKikg cmVzdWx0KTsKKworICByZXN1bHQtPnByb2xvZ3VlX2VuZCA9IGFmdGVyX2xh c3RfZnJhbWVfc2V0dXBfaW5zbjsKKyAgZG9fY2xlYW51cHMgKGJhY2tfdG8p OworfQorCisvKiBJbXBsZW1lbnQgdGhlICJza2lwX3Byb2xvZ3VlIiBnZGJh cmNoIG1ldGhvZC4gICovCisKK3N0YXRpYyBDT1JFX0FERFIKK2NyMTZfc2tp cF9wcm9sb2d1ZSAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIENPUkVfQURE UiBwYykKK3sKKyAgY29uc3QgY2hhciAqbmFtZTsKKyAgQ09SRV9BRERSIGZ1 bmNfYWRkciwgZnVuY19lbmQ7CisgIHN0cnVjdCBjcjE2X3Byb2xvZ3VlIHA7 CisKKyAgLyogVHJ5IHRvIGZpbmQgdGhlIGV4dGVudCBvZiB0aGUgZnVuY3Rp b24gdGhhdCBjb250YWlucyBQQy4gICovCisgIGlmICghZmluZF9wY19wYXJ0 aWFsX2Z1bmN0aW9uIChwYywgJm5hbWUsICZmdW5jX2FkZHIsICZmdW5jX2Vu ZCkpCisgICAgcmV0dXJuIHBjOworCisgIGNyMTZfYW5hbHl6ZV9wcm9sb2d1 ZSAocGMsIGZ1bmNfZW5kLCAmcCk7CisgIHJldHVybiBwLnByb2xvZ3VlX2Vu ZDsKK30KKworLyogR2l2ZW4gYSBmcmFtZSBkZXNjcmliZWQgYnkgVEhJU19G UkFNRSwgZGVjb2RlIHRoZSBwcm9sb2d1ZSBvZiBpdHMKKyAgIGFzc29jaWF0 ZWQgZnVuY3Rpb24gaWYgdGhlcmUgaXMgbm90IGNhY2hlIGVudHJ5IGFzIHNw ZWNpZmllZCBieQorICAgVEhJU19QUk9MT0dVRV9DQUNIRS4gIFNhdmUgdGhl IGRlY29kZWQgcHJvbG9ndWUgaW4gdGhlIGNhY2hlIGFuZAorICAgcmV0dXJu IHRoYXQgc3RydWN0IGFzIHRoZSB2YWx1ZSBvZiB0aGlzIGZ1bmN0aW9uLiAg Ki8KKworc3RhdGljIHN0cnVjdCBjcjE2X3Byb2xvZ3VlICoKK2NyMTZfYW5h bHl6ZV9mcmFtZV9wcm9sb2d1ZSAoc3RydWN0IGZyYW1lX2luZm8gKnRoaXNf ZnJhbWUsCisJCQkgICAgIHZvaWQgKip0aGlzX3Byb2xvZ3VlX2NhY2hlKQor eworICBpZiAoKnRoaXNfcHJvbG9ndWVfY2FjaGUpCisgICAgcmV0dXJuICp0 aGlzX3Byb2xvZ3VlX2NhY2hlOworCisgIENPUkVfQUREUiBmdW5jX3N0YXJ0 LCBzdG9wX2FkZHI7CisKKyAgKnRoaXNfcHJvbG9ndWVfY2FjaGUgPSBGUkFN RV9PQlNUQUNLX1pBTExPQyAoc3RydWN0IGNyMTZfcHJvbG9ndWUpOworICBm dW5jX3N0YXJ0ID0gZ2V0X2ZyYW1lX2Z1bmMgKHRoaXNfZnJhbWUpOworICBz dG9wX2FkZHIgPSBnZXRfZnJhbWVfcGMgKHRoaXNfZnJhbWUpOworCisgIC8q IElmIHdlIGNvdWxkbid0IGZpbmQgYW55IGZ1bmN0aW9uIGNvbnRhaW5pbmcg dGhlIFBDLCB0aGVuCisgICAgIGp1c3QgaW5pdGlhbGl6ZSB0aGUgcHJvbG9n dWUgY2FjaGUsIGJ1dCBkb24ndCBkbyBhbnl0aGluZy4gICovCisgIGlmICgh ZnVuY19zdGFydCkKKyAgICBzdG9wX2FkZHIgPSBmdW5jX3N0YXJ0OworCisg IGNyMTZfYW5hbHl6ZV9wcm9sb2d1ZSAoZnVuY19zdGFydCwgc3RvcF9hZGRy LCAqdGhpc19wcm9sb2d1ZV9jYWNoZSk7CisKKyAgcmV0dXJuICp0aGlzX3By b2xvZ3VlX2NhY2hlOworfQorCisvKiBHaXZlbiB0aGUgbmV4dCBmcmFtZSBh bmQgYSBwcm9sb2d1ZSBjYWNoZSwgcmV0dXJuIHRoaXMgZnJhbWUncworICAg YmFzZS4gICovCisKK3N0YXRpYyBDT1JFX0FERFIKK2NyMTZfZnJhbWVfYmFz ZSAoc3RydWN0IGZyYW1lX2luZm8gKnRoaXNfZnJhbWUsIHZvaWQgKip0aGlz X3Byb2xvZ3VlX2NhY2hlKQoreworICBzdHJ1Y3QgY3IxNl9wcm9sb2d1ZSAq cAorICAgID0gY3IxNl9hbmFseXplX2ZyYW1lX3Byb2xvZ3VlICh0aGlzX2Zy YW1lLCB0aGlzX3Byb2xvZ3VlX2NhY2hlKTsKKworICAvKiBJbiBmdW5jdGlv bnMgdGhhdCB1c2UgYWxsb2NhLCB0aGUgZGlzdGFuY2UgYmV0d2VlbiB0aGUg c3RhY2sKKyAgICAgcG9pbnRlciBhbmQgdGhlIGZyYW1lIGJhc2UgdmFyaWVz IGR5bmFtaWNhbGx5LCBzbyB3ZSBjYW4ndCB1c2UKKyAgICAgdGhlIFNQIHBs dXMgc3RhdGljIGluZm9ybWF0aW9uIGxpa2UgcHJvbG9ndWUgYW5hbHlzaXMg dG8gZmluZCB0aGUKKyAgICAgZnJhbWUgYmFzZS4gIEhvd2V2ZXIsIHN1Y2gg ZnVuY3Rpb25zIG11c3QgaGF2ZSBhIGZyYW1lIHBvaW50ZXIsCisgICAgIHRv IGJlIGFibGUgdG8gcmVzdG9yZSB0aGUgU1Agb24gZXhpdC4gIFNvIHdoZW5l dmVyIHdlIGRvIGhhdmUgYQorICAgICBmcmFtZSBwb2ludGVyLCB1c2UgdGhh dCB0byBmaW5kIHRoZSBiYXNlLiAgKi8KKyAgaWYgKHAtPmhhc19mcmFtZV9w dHIpCisgICAgeworICAgICAgQ09SRV9BRERSIGZwID0gZ2V0X2ZyYW1lX3Jl Z2lzdGVyX3Vuc2lnbmVkICh0aGlzX2ZyYW1lLCBDUjE2X0ZQX1JFR05VTSk7 CisKKyAgICAgIHJldHVybiBmcCAtIHAtPmZyYW1lX3B0cl9vZmZzZXQ7Cisg ICAgfQorICBlbHNlCisgICAgeworICAgICAgQ09SRV9BRERSIHNwID0gZ2V0 X2ZyYW1lX3JlZ2lzdGVyX3Vuc2lnbmVkICh0aGlzX2ZyYW1lLCBDUjE2X1NQ X1JFR05VTSk7CisKKyAgICAgIHJldHVybiBzcCAtIHAtPmZyYW1lX3NpemU7 CisgICAgfQorfQorCisvKiBJbXBsZW1lbnQgdGhlICJmcmFtZV90aGlzX2lk IiBtZXRob2QgZm9yIHVud2luZGluZyBmcmFtZXMuICAqLworCitzdGF0aWMg dm9pZAorY3IxNl9mcmFtZV90aGlzX2lkIChzdHJ1Y3QgZnJhbWVfaW5mbyAq dGhpc19mcmFtZSwKKwkJICAgIHZvaWQgKip0aGlzX3Byb2xvZ3VlX2NhY2hl LCBzdHJ1Y3QgZnJhbWVfaWQgKnRoaXNfaWQpCit7CisgICp0aGlzX2lkID0K KyAgICBmcmFtZV9pZF9idWlsZCAoY3IxNl9mcmFtZV9iYXNlICh0aGlzX2Zy YW1lLCB0aGlzX3Byb2xvZ3VlX2NhY2hlKSwKKwkJICAgIGdldF9mcmFtZV9m dW5jICh0aGlzX2ZyYW1lKSk7Cit9CisKKy8qIEltcGxlbWVudCB0aGUgImZy YW1lX3ByZXZfcmVnaXN0ZXIiIG1ldGhvZCBmb3IgdW53aW5kaW5nIGZyYW1l cy4gICovCisKK3N0YXRpYyBzdHJ1Y3QgdmFsdWUgKgorY3IxNl9mcmFtZV9w cmV2X3JlZ2lzdGVyIChzdHJ1Y3QgZnJhbWVfaW5mbyAqdGhpc19mcmFtZSwK KwkJCSAgdm9pZCAqKnRoaXNfcHJvbG9ndWVfY2FjaGUsIGludCByZWdudW0p Cit7CisgIHN0cnVjdCBjcjE2X3Byb2xvZ3VlICpwID0KKyAgICBjcjE2X2Fu YWx5emVfZnJhbWVfcHJvbG9ndWUgKHRoaXNfZnJhbWUsIHRoaXNfcHJvbG9n dWVfY2FjaGUpOworICBDT1JFX0FERFIgZnJhbWVfYmFzZSA9IGNyMTZfZnJh bWVfYmFzZSAodGhpc19mcmFtZSwgdGhpc19wcm9sb2d1ZV9jYWNoZSk7CisK KyAgaWYgKHJlZ251bSA9PSBDUjE2X1NQX1JFR05VTSkKKyAgICByZXR1cm4g ZnJhbWVfdW53aW5kX2dvdF9jb25zdGFudCAodGhpc19mcmFtZSwgcmVnbnVt LCBmcmFtZV9iYXNlKTsKKworICAvKiBUaGUgY2FsbCBpbnN0cnVjdGlvbiBo YXMgc2F2ZWQgdGhlIHJldHVybiBhZGRyZXNzIG9uIHRoZSBSQQorICAgICBy ZWdpc3RlciwgQ1IxNl9SMTNfUkVHTlVNLiAgU28sIHdlIG5lZWQgbm90IGFk anVzdCBhbnl0aGluZworICAgICBkaXJlY3RseS4gIFdlIHdpbGwgYW5hbHl6 ZSBwcm9sb2d1ZSBhcyB0aGlzIFJBIHJlZ2lzdGVyIGlzCisgICAgIHB1c2hl ZCBvbnRvIHN0YWNrIGZvciBmdXJ0aGVyIGxlYWYgZnVuY3Rpb24gY2FsbHMg dG8gd29yay4gICovCisgIGVsc2UgaWYgKHJlZ251bSA9PSBDUjE2X1BDX1JF R05VTSkKKyAgICB7CisgICAgICBVTE9OR0VTVCByYV9wcmV2OworCisgICAg ICByYV9wcmV2ID0gZnJhbWVfdW53aW5kX3JlZ2lzdGVyX3Vuc2lnbmVkICh0 aGlzX2ZyYW1lLCBDUjE2X1JBX1JFR05VTSk7CisgICAgICByYV9wcmV2ID0g cmFfcHJldiA8PCAxOworICAgICAgcmV0dXJuIGZyYW1lX3Vud2luZF9nb3Rf Y29uc3RhbnQgKHRoaXNfZnJhbWUsIENSMTZfUENfUkVHTlVNLCByYV9wcmV2 KTsKKyAgICB9CisKKyAgLyogSWYgcHJvbG9ndWUgYW5hbHlzaXMgc2F5cyB3 ZSBzYXZlZCB0aGlzIHJlZ2lzdGVyIHNvbWV3aGVyZSwKKyAgICAgcmV0dXJu IGEgZGVzY3JpcHRpb24gb2YgdGhlIHN0YWNrIHNsb3QgaG9sZGluZyBpdC4g ICovCisgIGVsc2UgaWYgKHAtPnJlZ19vZmZzZXRbcmVnbnVtXSAhPSAxKQor ICAgICAgcmV0dXJuIGZyYW1lX3Vud2luZF9nb3RfbWVtb3J5ICh0aGlzX2Zy YW1lLCByZWdudW0sCisJCQkJICAgICAgZnJhbWVfYmFzZSArIHAtPnJlZ19v ZmZzZXRbcmVnbnVtXSk7CisKKyAgLyogT3RoZXJ3aXNlLCBwcmVzdW1lIHdl IGhhdmVuJ3QgY2hhbmdlZCB0aGUgdmFsdWUgb2YgdGhpcworICAgICByZWdp c3RlciwgYW5kIGdldCBpdCBmcm9tIHRoZSBuZXh0IGZyYW1lLiAgKi8KKyAg ZWxzZQorICAgICAgcmV0dXJuIGZyYW1lX3Vud2luZF9nb3RfcmVnaXN0ZXIg KHRoaXNfZnJhbWUsIHJlZ251bSwgcmVnbnVtKTsKK30KKworc3RhdGljIGNv bnN0IHN0cnVjdCBmcmFtZV91bndpbmQgY3IxNl9mcmFtZV91bndpbmQgPQor eworICBOT1JNQUxfRlJBTUUsCisgIGRlZmF1bHRfZnJhbWVfdW53aW5kX3N0 b3BfcmVhc29uLAorICBjcjE2X2ZyYW1lX3RoaXNfaWQsCisgIGNyMTZfZnJh bWVfcHJldl9yZWdpc3RlciwKKyAgTlVMTCwKKyAgZGVmYXVsdF9mcmFtZV9z bmlmZmVyCit9OworCisvKiBJbXBsZW1lbnQgdGhlICJ1bndpbmRfcGMiIGdk YmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGljIENPUkVfQUREUgorY3IxNl91 bndpbmRfcGMgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBzdHJ1Y3QgZnJh bWVfaW5mbyAqdGhpc19mcmFtZSkKK3sKKyAgQ09SRV9BRERSIHBjOworCisg IHBjID0gZnJhbWVfdW53aW5kX3JlZ2lzdGVyX3Vuc2lnbmVkICh0aGlzX2Zy YW1lLCBDUjE2X1BDX1JFR05VTSk7CisgIHJldHVybiBwYzsKK30KKworLyog SW1wbGVtZW50IHRoZSAidW53aW5kX3NwIiBnZGJhcmNoIG1ldGhvZC4gICov CisKK3N0YXRpYyBDT1JFX0FERFIKK2NyMTZfdW53aW5kX3NwIChzdHJ1Y3Qg Z2RiYXJjaCAqZ2RiYXJjaCwgc3RydWN0IGZyYW1lX2luZm8gKnRoaXNfZnJh bWUpCit7CisgIENPUkVfQUREUiBzcDsKKworICBzcCA9IGZyYW1lX3Vud2lu ZF9yZWdpc3Rlcl91bnNpZ25lZCAodGhpc19mcmFtZSwgQ1IxNl9TUF9SRUdO VU0pOworICByZXR1cm4gc3A7Cit9CisKKy8qIEltcGxlbWVudCB0aGUgImR1 bW15X2lkIiBnZGJhcmNoIG1ldGhvZC4gICovCisKK3N0YXRpYyBzdHJ1Y3Qg ZnJhbWVfaWQKK2NyMTZfZHVtbXlfaWQgKHN0cnVjdCBnZGJhcmNoICpnZGJh cmNoLCBzdHJ1Y3QgZnJhbWVfaW5mbyAqdGhpc19mcmFtZSkKK3sKKyAgcmV0 dXJuCisgICAgZnJhbWVfaWRfYnVpbGQgKGdldF9mcmFtZV9yZWdpc3Rlcl91 bnNpZ25lZCAodGhpc19mcmFtZSwgQ1IxNl9TUF9SRUdOVU0pLAorCQkgICAg Z2V0X2ZyYW1lX3BjICh0aGlzX2ZyYW1lKSk7Cit9CisKKy8qIEltcGxlbWVu dCB0aGUgInB1c2hfZHVtbXlfY2FsbCIgZ2RiYXJjaCBtZXRob2QuICAqLwor CitzdGF0aWMgQ09SRV9BRERSCitjcjE2X3B1c2hfZHVtbXlfY2FsbCAoc3Ry dWN0IGdkYmFyY2ggKmdkYmFyY2gsIHN0cnVjdCB2YWx1ZSAqZnVuY3Rpb24s CisJCSAgICAgIHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUsIENPUkVfQURE UiBicF9hZGRyLCBpbnQgbmFyZ3MsCisJCSAgICAgIHN0cnVjdCB2YWx1ZSAq KmFyZ3MsIENPUkVfQUREUiBzcCwgaW50IHN0cnVjdF9yZXR1cm4sCisJCSAg ICAgIENPUkVfQUREUiBzdHJ1Y3RfYWRkcikKK3sKKyAgZW51bSBiZmRfZW5k aWFuIGJ5dGVfb3JkZXIgPSBnZGJhcmNoX2J5dGVfb3JkZXIgKGdkYmFyY2gp OworICBpbnQgd3JpdGVfcGFzczsKKyAgaW50IHNwX29mZiA9IDA7CisgIENP UkVfQUREUiBjZmE7CisgIGludCBudW1fcmVnaXN0ZXJfY2FuZGlkYXRlX2Fy Z3M7CisKKyAgc3RydWN0IHR5cGUgKmZ1bmNfdHlwZSA9IHZhbHVlX3R5cGUg KGZ1bmN0aW9uKTsKKworICAvKiBEZXJlZmVyZW5jZSBmdW5jdGlvbiBwb2lu dGVyIHR5cGVzLiAgKi8KKyAgd2hpbGUgKFRZUEVfQ09ERSAoZnVuY190eXBl KSA9PSBUWVBFX0NPREVfUFRSKQorICAgIGZ1bmNfdHlwZSA9IFRZUEVfVEFS R0VUX1RZUEUgKGZ1bmNfdHlwZSk7CisKKyAgLyogVGhlIGVuZCByZXN1bHQg aGFkIGJldHRlciBiZSBhIGZ1bmN0aW9uIG9yIGEgbWV0aG9kLiAgKi8KKyAg Z2RiX2Fzc2VydCAoVFlQRV9DT0RFIChmdW5jX3R5cGUpID09IFRZUEVfQ09E RV9GVU5DCisJICAgICAgfHwgVFlQRV9DT0RFIChmdW5jX3R5cGUpID09IFRZ UEVfQ09ERV9NRVRIT0QpOworCisgIC8qIEZ1bmN0aW9ucyB3aXRoIGEgdmFy aWFibGUgbnVtYmVyIG9mIGFyZ3VtZW50cyBoYXZlIGFsbCBvZiB0aGVpcgor ICAgICB2YXJpYWJsZSBhcmd1bWVudHMgYW5kIHRoZSBsYXN0IG5vbi12YXJp YWJsZSBhcmd1bWVudCBwYXNzZWQKKyAgICAgb24gdGhlIHN0YWNrLgorCisg ICAgIE90aGVyd2lzZSwgd2UgY2FuIHBhc3MgdXAgdG8gZm91ciBhcmd1bWVu dHMgdmlhIHJlZ2lzdGVycy4KKworICAgICBPbmNlIGNvbXB1dGVkLCB3ZSBs ZWF2ZSB0aGlzIHZhbHVlIGFsb25lLiAgSS5lLiB3ZSBkb24ndCB1cGRhdGUK KyAgICAgaXQgaW4gY2FzZSBvZiBhIHN0cnVjdCByZXR1cm4gZ29pbmcgaW4g YSByZWdpc3RlciBvciBhbiBhcmd1bWVudAorICAgICByZXF1aXJpbmcgbXVs dGlwbGUgcmVnaXN0ZXJzLCBldGMuICBXZSByZWx5IGluc3RlYWQgb24gdGhl IHZhbHVlCisgICAgIG9mIHRoZSAnJ2FyZ19yZWcnJyB2YXJpYWJsZSB0byBn ZXQgdGhlc2Ugb3RoZXIgZGV0YWlscyBjb3JyZWN0LiAgKi8KKworICBpZiAo VFlQRV9WQVJBUkdTIChmdW5jX3R5cGUpKQorICAgIG51bV9yZWdpc3Rlcl9j YW5kaWRhdGVfYXJncyA9IFRZUEVfTkZJRUxEUyAoZnVuY190eXBlKSAtIDE7 CisgIGVsc2UKKyAgICBudW1fcmVnaXN0ZXJfY2FuZGlkYXRlX2FyZ3MgPSA0 OworCisgIC8qIFdlIG1ha2UgdHdvIHBhc3NlczsgdGhlIGZpcnN0IGRvZXMg dGhlIHN0YWNrIGFsbG9jYXRpb24sCisgICAgIHRoZSBzZWNvbmQgYWN0dWFs bHkgc3RvcmVzIHRoZSBhcmd1bWVudHMuICAqLworICBmb3IgKHdyaXRlX3Bh c3MgPSAwOyB3cml0ZV9wYXNzIDw9IDE7IHdyaXRlX3Bhc3MrKykKKyAgICB7 CisgICAgICBpbnQgaTsKKyAgICAgIGludCBhcmdfcmVnID0gQ1IxNl9SMF9S RUdOVU07CisKKyAgICAgIGlmICh3cml0ZV9wYXNzKQorCXNwID0gYWxpZ25f ZG93biAoc3AgLSBzcF9vZmYsIDQpOworICAgICAgc3Bfb2ZmID0gMDsKKwor ICAgICAgaWYgKHN0cnVjdF9yZXR1cm4pCisJeworCSAgc3RydWN0IHR5cGUg KnJldHVybl90eXBlID0gVFlQRV9UQVJHRVRfVFlQRSAoZnVuY190eXBlKTsK KworCSAgZ2RiX2Fzc2VydCAoVFlQRV9DT0RFIChyZXR1cm5fdHlwZSkgPT0g VFlQRV9DT0RFX1NUUlVDVAorCQkgICAgICB8fCBUWVBFX0NPREUgKGZ1bmNf dHlwZSkgPT0gVFlQRV9DT0RFX1VOSU9OKTsKKworCSAgaWYgKFRZUEVfTEVO R1RIIChyZXR1cm5fdHlwZSkgPiAxNgorCSAgICAgIHx8IFRZUEVfTEVOR1RI IChyZXR1cm5fdHlwZSkgJSA0ICE9IDApCisJICAgIHsKKwkgICAgICBpZiAo d3JpdGVfcGFzcykKKwkJcmVnY2FjaGVfY29va2VkX3dyaXRlX3Vuc2lnbmVk IChyZWdjYWNoZSwgQ1IxNl9SMTJfUkVHTlVNLAorCQkJCQkJc3RydWN0X2Fk ZHIpOworCSAgICB9CisJfQorCisgICAgICAvKiBQdXNoIHRoZSBhcmd1bWVu dHMuICAqLworICAgICAgZm9yIChpID0gMDsgaSA8IG5hcmdzOyBpKyspCisJ eworCSAgc3RydWN0IHZhbHVlICphcmcgPSBhcmdzW2ldOworCSAgY29uc3Qg Z2RiX2J5dGUgKmFyZ19iaXRzID0gdmFsdWVfY29udGVudHNfYWxsIChhcmcp OworCSAgc3RydWN0IHR5cGUgKmFyZ190eXBlID0gY2hlY2tfdHlwZWRlZiAo dmFsdWVfdHlwZSAoYXJnKSk7CisJICBVTE9OR0VTVCBhcmdfc2l6ZSA9IFRZ UEVfTEVOR1RIIChhcmdfdHlwZSk7CisKKwkgIGlmIChpID09IDAgJiYgc3Ry dWN0X2FkZHIgIT0gMCAmJiAhc3RydWN0X3JldHVybgorCSAgICAgICYmIFRZ UEVfQ09ERSAoYXJnX3R5cGUpID09IFRZUEVfQ09ERV9QVFIKKwkgICAgICAm JiBleHRyYWN0X3Vuc2lnbmVkX2ludGVnZXIgKGFyZ19iaXRzLCA0LAorCQkJ CQkgICBieXRlX29yZGVyKSA9PSBzdHJ1Y3RfYWRkcikKKwkgICAgeworCSAg ICAgIC8qIFRoaXMgYXJndW1lbnQgcmVwcmVzZW50cyB0aGUgYWRkcmVzcyBh dCB3aGljaCBDKysgKGFuZAorCSAgICAgICAgIHBvc3NpYmx5IG90aGVyIGxh bmd1YWdlcykgc3RvcmUgdGhlaXIgcmV0dXJuIHZhbHVlLgorCSAgICAgICAg IFB1dCB0aGlzIHZhbHVlIGluIFIxMi4gICovCisJICAgICAgaWYgKHdyaXRl X3Bhc3MpCisJCXJlZ2NhY2hlX2Nvb2tlZF93cml0ZV91bnNpZ25lZCAocmVn Y2FjaGUsIENSMTZfUjEyX1JFR05VTSwKKwkJCQkJCXN0cnVjdF9hZGRyKTsK KwkgICAgfQorCSAgZWxzZSBpZiAoVFlQRV9DT0RFIChhcmdfdHlwZSkgIT0g VFlQRV9DT0RFX1NUUlVDVAorCQkgICAmJiBUWVBFX0NPREUgKGFyZ190eXBl KSAhPSBUWVBFX0NPREVfVU5JT04pCisJICAgIHsKKwkgICAgICAvKiBBcmd1 bWVudCBpcyBhIHNjYWxhci4gICovCisJICAgICAgaWYgKGFyZ19zaXplID09 IDgpCisJCXsKKwkJICBpZiAoaSA8IG51bV9yZWdpc3Rlcl9jYW5kaWRhdGVf YXJncworCQkgICAgICAmJiBhcmdfcmVnIDw9IENSMTZfUjdfUkVHTlVNIC0g MSkKKwkJICAgIHsKKwkJICAgICAgLyogSWYgYXJndW1lbnQgcmVnaXN0ZXJz IGFyZSBnb2luZyB0byBiZSB1c2VkIHRvIHBhc3MKKwkJICAgICAgICAgYW4g OCBieXRlIHNjYWxhciwgdGhlIEFCSSBzcGVjaWZpZXMgdGhhdCB0d28gcmVn aXN0ZXJzCisJCSAgICAgICAgIG11c3QgYmUgYXZhaWxhYmxlLiAgKi8KKwkJ ICAgICAgaWYgKHdyaXRlX3Bhc3MpCisJCQl7CisJCQkgIHJlZ2NhY2hlX2Nv b2tlZF93cml0ZV91bnNpZ25lZCAocmVnY2FjaGUsIGFyZ19yZWcsCisJCQkJ CQkJICBleHRyYWN0X3Vuc2lnbmVkX2ludGVnZXIKKwkJCQkJCQkgIChhcmdf Yml0cywgNCwKKwkJCQkJCQkgICBieXRlX29yZGVyKSk7CisJCQkgIHJlZ2Nh Y2hlX2Nvb2tlZF93cml0ZV91bnNpZ25lZCAocmVnY2FjaGUsCisJCQkJCQkJ ICBhcmdfcmVnICsgMSwKKwkJCQkJCQkgIGV4dHJhY3RfdW5zaWduZWRfaW50 ZWdlcgorCQkJCQkJCSAgKGFyZ19iaXRzICsgNCwgNCwKKwkJCQkJCQkgICBi eXRlX29yZGVyKSk7CisJCQl9CisJCSAgICAgIGFyZ19yZWcgKz0gMjsKKwkJ ICAgIH0KKwkJICBlbHNlCisJCSAgICB7CisJCSAgICAgIHNwX29mZiA9IGFs aWduX3VwIChzcF9vZmYsIDQpOworCQkgICAgICAvKiBPdGhlcndpc2UsIHBh c3MgdGhlIDggYnl0ZSBzY2FsYXIgb24gdGhlIHN0YWNrLiAgKi8KKwkJICAg ICAgaWYgKHdyaXRlX3Bhc3MpCisJCQl3cml0ZV9tZW1vcnkgKHNwICsgc3Bf b2ZmLCBhcmdfYml0cywgOCk7CisJCSAgICAgIHNwX29mZiArPSA4OworCQkg ICAgfQorCQl9CisJICAgICAgZWxzZQorCQl7CisJCSAgVUxPTkdFU1QgdTsK KworCQkgIGdkYl9hc3NlcnQgKGFyZ19zaXplIDw9IDQpOworCisJCSAgdSA9 IGV4dHJhY3RfdW5zaWduZWRfaW50ZWdlciAoYXJnX2JpdHMsIGFyZ19zaXpl LCBieXRlX29yZGVyKTsKKworCQkgIGlmIChpIDwgbnVtX3JlZ2lzdGVyX2Nh bmRpZGF0ZV9hcmdzCisJCSAgICAgICYmIGFyZ19yZWcgPD0gQ1IxNl9SN19S RUdOVU0pCisJCSAgICB7CisJCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJ cmVnY2FjaGVfY29va2VkX3dyaXRlX3Vuc2lnbmVkIChyZWdjYWNoZSwgYXJn X3JlZywgdSk7CisJCSAgICAgIGFyZ19yZWcgKz0gMTsKKwkJICAgIH0KKwkJ ICBlbHNlCisJCSAgICB7CisJCSAgICAgIGludCBwX2FyZ19zaXplID0gNDsK KworCQkgICAgICBpZiAoVFlQRV9QUk9UT1RZUEVEIChmdW5jX3R5cGUpCisJ CQkgICYmIGkgPCBUWVBFX05GSUVMRFMgKGZ1bmNfdHlwZSkpCisJCQl7CisJ CQkgIHN0cnVjdCB0eXBlICpwX2FyZ190eXBlID0KKwkJCSAgICBUWVBFX0ZJ RUxEX1RZUEUgKGZ1bmNfdHlwZSwgaSk7CisJCQkgIHBfYXJnX3NpemUgPSBU WVBFX0xFTkdUSCAocF9hcmdfdHlwZSk7CisJCQl9CisKKwkJICAgICAgc3Bf b2ZmID0gYWxpZ25fdXAgKHNwX29mZiwgcF9hcmdfc2l6ZSk7CisKKwkJICAg ICAgaWYgKHdyaXRlX3Bhc3MpCisJCQl3cml0ZV9tZW1vcnlfdW5zaWduZWRf aW50ZWdlciAoc3AgKyBzcF9vZmYsCisJCQkJCQkgICAgICAgcF9hcmdfc2l6 ZSwgYnl0ZV9vcmRlciwKKwkJCQkJCSAgICAgICB1KTsKKwkJICAgICAgc3Bf b2ZmICs9IHBfYXJnX3NpemU7CisJCSAgICB9CisJCX0KKwkgICAgfQorCSAg ZWxzZQorCSAgICB7CisJICAgICAgLyogQXJndW1lbnQgaXMgYSBzdHJ1Y3Qg b3IgdW5pb24uICBQYXNzIGFzIG11Y2ggb2YgdGhlIHN0cnVjdAorCSAgICAg ICAgIGluIHJlZ2lzdGVycywgYXMgcG9zc2libGUuICBQYXNzIHRoZSByZXN0 IG9uIHRoZSBzdGFjay4gICovCisJICAgICAgd2hpbGUgKGFyZ19zaXplID4g MCkKKwkJeworCQkgIGlmIChpIDwgbnVtX3JlZ2lzdGVyX2NhbmRpZGF0ZV9h cmdzCisJCSAgICAgICYmIGFyZ19yZWcgPD0gQ1IxNl9SN19SRUdOVU0KKwkJ ICAgICAgJiYgYXJnX3NpemUgPD0gNCAqIChDUjE2X1I3X1JFR05VTSAtIGFy Z19yZWcgKyAxKQorCQkgICAgICAmJiBhcmdfc2l6ZSAlIDQgPT0gMCkKKwkJ ICAgIHsKKwkJICAgICAgaW50IGxlbiA9IG1pbiAoYXJnX3NpemUsIDQpOwor CisJCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJcmVnY2FjaGVfY29va2Vk X3dyaXRlX3Vuc2lnbmVkIChyZWdjYWNoZSwgYXJnX3JlZywKKwkJCQkJCQll eHRyYWN0X3Vuc2lnbmVkX2ludGVnZXIKKwkJCQkJCQkoYXJnX2JpdHMsIGxl biwKKwkJCQkJCQkgYnl0ZV9vcmRlcikpOworCQkgICAgICBhcmdfYml0cyAr PSBsZW47CisJCSAgICAgIGFyZ19zaXplIC09IGxlbjsKKwkJICAgICAgYXJn X3JlZysrOworCQkgICAgfQorCQkgIGVsc2UKKwkJICAgIHsKKwkJICAgICAg c3Bfb2ZmID0gYWxpZ25fdXAgKHNwX29mZiwgNCk7CisJCSAgICAgIGlmICh3 cml0ZV9wYXNzKQorCQkJd3JpdGVfbWVtb3J5IChzcCArIHNwX29mZiwgYXJn X2JpdHMsIGFyZ19zaXplKTsKKwkJICAgICAgc3Bfb2ZmICs9IGFsaWduX3Vw IChhcmdfc2l6ZSwgNCk7CisJCSAgICAgIGFyZ19zaXplID0gMDsKKwkJICAg IH0KKwkJfQorCSAgICB9CisJfQorICAgIH0KKworICAvKiBLZWVwIHRyYWNr IG9mIHRoZSBzdGFjayBhZGRyZXNzIHByaW9yIHRvIHB1c2hpbmcgdGhlIHJl dHVybiBhZGRyZXNzLgorICAgICBUaGlzIGlzIHRoZSB2YWx1ZSB0aGF0IHdl J2xsIHJldHVybi4gICovCisgIGNmYSA9IHNwOworCisgIC8qIFB1c2ggdGhl IHJldHVybiBhZGRyZXNzLiAgKi8KKyAgc3AgPSBzcCAtIDQ7CisgIHdyaXRl X21lbW9yeV91bnNpZ25lZF9pbnRlZ2VyIChzcCwgNCwgYnl0ZV9vcmRlciwg YnBfYWRkcik7CisKKyAgLyogVXBkYXRlIHRoZSBzdGFjayBwb2ludGVyLiAg Ki8KKyAgcmVnY2FjaGVfY29va2VkX3dyaXRlX3Vuc2lnbmVkIChyZWdjYWNo ZSwgQ1IxNl9TUF9SRUdOVU0sIHNwKTsKKworICByZXR1cm4gY2ZhOworfQor CisvKiBJbXBsZW1lbnQgdGhlICJyZXR1cm5fdmFsdWUiIGdkYmFyY2ggbWV0 aG9kLiAgKi8KKworc3RhdGljIGVudW0gcmV0dXJuX3ZhbHVlX2NvbnZlbnRp b24KK2NyMTZfcmV0dXJuX3ZhbHVlIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJj aCwKKwkJICAgc3RydWN0IHR5cGUgKmZ1bmNfdHlwZSwKKwkJICAgc3RydWN0 IHR5cGUgKnZhbHR5cGUsCisJCSAgIHN0cnVjdCByZWdjYWNoZSAqcmVnY2Fj aGUsCisJCSAgIGdkYl9ieXRlICogcmVhZGJ1ZiwgY29uc3QgZ2RiX2J5dGUg KiB3cml0ZWJ1ZikKK3sKKyAgZW51bSBiZmRfZW5kaWFuIGJ5dGVfb3JkZXIg PSBnZGJhcmNoX2J5dGVfb3JkZXIgKGdkYmFyY2gpOworICBVTE9OR0VTVCB2 YWx0eXBlX2xlbiA9IFRZUEVfTEVOR1RIICh2YWx0eXBlKTsKKworICBpZiAo VFlQRV9MRU5HVEggKHZhbHR5cGUpID4gMTYKKyAgICAgIHx8ICgoVFlQRV9D T0RFICh2YWx0eXBlKSA9PSBUWVBFX0NPREVfU1RSVUNUCisJICAgfHwgVFlQ RV9DT0RFICh2YWx0eXBlKSA9PSBUWVBFX0NPREVfVU5JT04pCisJICAmJiBU WVBFX0xFTkdUSCAodmFsdHlwZSkgJSA0ICE9IDApKQorICAgIHJldHVybiBS RVRVUk5fVkFMVUVfU1RSVUNUX0NPTlZFTlRJT047CisKKyAgaWYgKHJlYWRi dWYpCisgICAgeworICAgICAgVUxPTkdFU1QgdTsKKyAgICAgIGludCBhcmdy ZWcgPSBDUjE2X1IwX1JFR05VTTsKKyAgICAgIGludCBvZmZzZXQgPSAwOwor CisgICAgICB3aGlsZSAodmFsdHlwZV9sZW4gPiAwKQorCXsKKwkgIGludCBs ZW4gPSBtaW4gKHZhbHR5cGVfbGVuLCA0KTsKKworCSAgcmVnY2FjaGVfY29v a2VkX3JlYWRfdW5zaWduZWQgKHJlZ2NhY2hlLCBhcmdyZWcsICZ1KTsKKwkg IHN0b3JlX3Vuc2lnbmVkX2ludGVnZXIgKHJlYWRidWYgKyBvZmZzZXQsIGxl biwgYnl0ZV9vcmRlciwgdSk7CisJICB2YWx0eXBlX2xlbiAtPSBsZW47CisJ ICBvZmZzZXQgKz0gbGVuOworCSAgYXJncmVnKys7CisJfQorICAgIH0KKwor ICBpZiAod3JpdGVidWYpCisgICAgeworICAgICAgVUxPTkdFU1QgdTsKKyAg ICAgIGludCBhcmdyZWcgPSBDUjE2X1IwX1JFR05VTTsKKyAgICAgIGludCBv ZmZzZXQgPSAwOworCisgICAgICB3aGlsZSAodmFsdHlwZV9sZW4gPiAwKQor CXsKKwkgIGludCBsZW4gPSBtaW4gKHZhbHR5cGVfbGVuLCA0KTsKKworCSAg dSA9IGV4dHJhY3RfdW5zaWduZWRfaW50ZWdlciAod3JpdGVidWYgKyBvZmZz ZXQsIGxlbiwgYnl0ZV9vcmRlcik7CisJICByZWdjYWNoZV9jb29rZWRfd3Jp dGVfdW5zaWduZWQgKHJlZ2NhY2hlLCBhcmdyZWcsIHUpOworCSAgdmFsdHlw ZV9sZW4gLT0gbGVuOworCSAgb2Zmc2V0ICs9IGxlbjsKKwkgIGFyZ3JlZysr OworCX0KKyAgICB9CisKKyAgcmV0dXJuIFJFVFVSTl9WQUxVRV9SRUdJU1RF Ul9DT05WRU5USU9OOworfQorCisvKiBJbXBsZW1lbnQgdGhlICJicmVha3Bv aW50X2Zyb21fcGMiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGljIGNv bnN0IGdkYl9ieXRlICoKK2NyMTZfYnJlYWtwb2ludF9mcm9tX3BjIChzdHJ1 Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgQ09SRV9BRERSICogcGNwdHIsCisJCQkg aW50ICpsZW5wdHIpCit7CisgIC8qIFdlIHVzZSBkaWZmZXJlbnQgYnJlYWtw b2ludCBpbnN0cnVjdGlvbnMgZm9yIEVMRiBhbmQgdUNsaW51eC4KKyAgICAg U2VlIGNyMTYtbGludXgtdGRlcC5jIGZvciBtb3JlIGRldGFpbHMuICAqLwor ICBzdHJ1Y3QgZ2RiYXJjaF90ZGVwICp0ZGVwID0gZ2RiYXJjaF90ZGVwIChn ZGJhcmNoKTsKKworICAqbGVucHRyID0gMjsKKyAgcmV0dXJuIHRkZXAtPmJy ZWFrcG9pbnQ7Cit9CisKKy8qIEFsbG9jYXRlIGFuZCBpbml0aWFsaXplIGEg Z2RiYXJjaCBvYmplY3QuICAqLworCitzdGF0aWMgc3RydWN0IGdkYmFyY2gg KgorY3IxNl9nZGJhcmNoX2luaXQgKHN0cnVjdCBnZGJhcmNoX2luZm8gaW5m bywgc3RydWN0IGdkYmFyY2hfbGlzdCAqYXJjaGVzKQoreworICBzdHJ1Y3Qg Z2RiYXJjaCAqZ2RiYXJjaDsKKyAgc3RydWN0IGdkYmFyY2hfdGRlcCAqdGRl cDsKKyAgaW50IGVsZl9mbGFnczsKKworICAvKiBFeHRyYWN0IHRoZSBlbGZf ZmxhZ3MgaWYgYXZhaWxhYmxlLiAgKi8KKyAgaWYgKGluZm8uYWJmZCAhPSBO VUxMCisgICAgICAmJiBiZmRfZ2V0X2ZsYXZvdXIgKGluZm8uYWJmZCkgPT0g YmZkX3RhcmdldF9lbGZfZmxhdm91cikKKyAgICBlbGZfZmxhZ3MgPSBlbGZf ZWxmaGVhZGVyIChpbmZvLmFiZmQpLT5lX2ZsYWdzOworICBlbHNlCisgICAg ZWxmX2ZsYWdzID0gMDsKKworICAvKiBUcnkgdG8gZmluZCB0aGUgYXJjaGl0 ZWN0dXJlIGluIHRoZSBsaXN0IG9mIGFscmVhZHkgZGVmaW5lZAorICAgICBh cmNoaXRlY3R1cmVzLiAgKi8KKyAgZm9yIChhcmNoZXMgPSBnZGJhcmNoX2xp c3RfbG9va3VwX2J5X2luZm8gKGFyY2hlcywgJmluZm8pOworICAgICAgIGFy Y2hlcyAhPSBOVUxMOworICAgICAgIGFyY2hlcyA9IGdkYmFyY2hfbGlzdF9s b29rdXBfYnlfaW5mbyAoYXJjaGVzLT5uZXh0LCAmaW5mbykpCisgICAgewor ICAgICAgaWYgKGdkYmFyY2hfdGRlcCAoYXJjaGVzLT5nZGJhcmNoKS0+ZWxm X2ZsYWdzICE9IGVsZl9mbGFncykKKwljb250aW51ZTsKKworICAgICAgcmV0 dXJuIGFyY2hlcy0+Z2RiYXJjaDsKKyAgICB9CisgIC8qIE5vbmUgZm91bmQs IGNyZWF0ZSBhIG5ldyBhcmNoaXRlY3R1cmUgZnJvbSB0aGUgaW5mb3JtYXRp b24KKyAgICAgcHJvdmlkZWQuICAqLworICB0ZGVwID0gKHN0cnVjdCBnZGJh cmNoX3RkZXAgKikgeGNhbGxvYyAoMSwgc2l6ZW9mIChzdHJ1Y3QgZ2RiYXJj aF90ZGVwKSk7CisgIHRkZXAtPmVsZl9mbGFncyA9IGVsZl9mbGFnczsKKyAg dGRlcC0+YnJlYWtwb2ludCA9IGJyZWFrcG9pbnRfZWxmOworICBnZGJhcmNo ID0gZ2RiYXJjaF9hbGxvYyAoJmluZm8sIHRkZXApOworCisgIHNldF9nZGJh cmNoX251bV9wc2V1ZG9fcmVncyAoZ2RiYXJjaCwgMCk7CisgIHNldF9nZGJh cmNoX251bV9yZWdzIChnZGJhcmNoLCBDUjE2X05VTV9SRUdTKTsKKyAgc2V0 X2dkYmFyY2hfcmVnaXN0ZXJfbmFtZSAoZ2RiYXJjaCwgY3IxNl9yZWdpc3Rl cl9uYW1lKTsKKyAgc2V0X2dkYmFyY2hfcmVnaXN0ZXJfdHlwZSAoZ2RiYXJj aCwgY3IxNl9yZWdpc3Rlcl90eXBlKTsKKyAgc2V0X2dkYmFyY2hfcGNfcmVn bnVtIChnZGJhcmNoLCBDUjE2X1BDX1JFR05VTSk7CisgIHNldF9nZGJhcmNo X3NwX3JlZ251bSAoZ2RiYXJjaCwgQ1IxNl9TUF9SRUdOVU0pOworICBzZXRf Z2RiYXJjaF9pbm5lcl90aGFuIChnZGJhcmNoLCBjb3JlX2FkZHJfbGVzc3Ro YW4pOworICBzZXRfZ2RiYXJjaF9kZWNyX3BjX2FmdGVyX2JyZWFrIChnZGJh cmNoLCAyKTsKKyAgc2V0X2dkYmFyY2hfYnJlYWtwb2ludF9mcm9tX3BjIChn ZGJhcmNoLCBjcjE2X2JyZWFrcG9pbnRfZnJvbV9wYyk7CisgIHNldF9nZGJh cmNoX3NraXBfcHJvbG9ndWUgKGdkYmFyY2gsIGNyMTZfc2tpcF9wcm9sb2d1 ZSk7CisgIHNldF9nZGJhcmNoX3ByaW50X2luc24gKGdkYmFyY2gsIHByaW50 X2luc25fY3IxNik7CisgIHNldF9nZGJhcmNoX3Vud2luZF9wYyAoZ2RiYXJj aCwgY3IxNl91bndpbmRfcGMpOworICBzZXRfZ2RiYXJjaF91bndpbmRfc3Ag KGdkYmFyY2gsIGNyMTZfdW53aW5kX3NwKTsKKworICAvKiBNZXRob2RzIGZv ciBzYXZpbmcgLyBleHRyYWN0aW5nIGEgZHVtbXkgZnJhbWUncyBJRC4gICov CisgIHNldF9nZGJhcmNoX2R1bW15X2lkIChnZGJhcmNoLCBjcjE2X2R1bW15 X2lkKTsKKyAgc2V0X2dkYmFyY2hfcHVzaF9kdW1teV9jYWxsIChnZGJhcmNo LCBjcjE2X3B1c2hfZHVtbXlfY2FsbCk7CisgIC8qIFRhcmdldCBidWlsdGlu IGRhdGEgdHlwZXMuICAqLworICBzZXRfZ2RiYXJjaF9jaGFyX3NpZ25lZCAo Z2RiYXJjaCwgOCk7CisgIHNldF9nZGJhcmNoX3Nob3J0X2JpdCAoZ2RiYXJj aCwgMTYpOworICBzZXRfZ2RiYXJjaF9pbnRfYml0IChnZGJhcmNoLCAxNik7 CisgIHNldF9nZGJhcmNoX2xvbmdfYml0IChnZGJhcmNoLCAzMik7CisgIHNl dF9nZGJhcmNoX2xvbmdfbG9uZ19iaXQgKGdkYmFyY2gsIDY0KTsKKyAgc2V0 X2dkYmFyY2hfZmxvYXRfYml0IChnZGJhcmNoLCAzMik7CisKKyAgc2V0X2dk YmFyY2hfcHRyX2JpdCAoZ2RiYXJjaCwgMzIpOworICBzZXRfZ2RiYXJjaF9m bG9hdF9mb3JtYXQgKGdkYmFyY2gsIGZsb2F0Zm9ybWF0c19pZWVlX3Npbmds ZSk7CisgIHNldF9nZGJhcmNoX2RvdWJsZV9iaXQgKGdkYmFyY2gsIDY0KTsK KyAgc2V0X2dkYmFyY2hfbG9uZ19kb3VibGVfYml0IChnZGJhcmNoLCA2NCk7 CisgIHNldF9nZGJhcmNoX2RvdWJsZV9mb3JtYXQgKGdkYmFyY2gsIGZsb2F0 Zm9ybWF0c19pZWVlX2RvdWJsZSk7CisgIHNldF9nZGJhcmNoX2xvbmdfZG91 YmxlX2Zvcm1hdCAoZ2RiYXJjaCwgZmxvYXRmb3JtYXRzX2llZWVfZG91Ymxl KTsKKworICBmcmFtZV91bndpbmRfYXBwZW5kX3Vud2luZGVyIChnZGJhcmNo LCAmY3IxNl9mcmFtZV91bndpbmQpOworICBzZXRfZ2RiYXJjaF9yZXR1cm5f dmFsdWUgKGdkYmFyY2gsIGNyMTZfcmV0dXJuX3ZhbHVlKTsKKworICAvKiBI b29rIGluIEFCSS1zcGVjaWZpYyBvdmVycmlkZXMsIGlmIHRoZXkgaGF2ZSBi ZWVuIHJlZ2lzdGVyZWQuICAqLworICBnZGJhcmNoX2luaXRfb3NhYmkgKGlu Zm8sIGdkYmFyY2gpOworCisgIHJldHVybiBnZGJhcmNoOworCit9CisKKy8q IC1XbWlzc2luZy1wcm90b3R5cGVzLiAgKi8KK2V4dGVybiBpbml0aWFsaXpl X2ZpbGVfZnR5cGUgX2luaXRpYWxpemVfY3IxNl90ZGVwOworCisvKiBSZWdp c3RlciB0aGUgYWJvdmUgaW5pdGlhbGl6YXRpb24gcm91dGluZS4gICovCisK K3ZvaWQKK19pbml0aWFsaXplX2NyMTZfdGRlcCAodm9pZCkKK3sKKyAgcmVn aXN0ZXJfZ2RiYXJjaF9pbml0IChiZmRfYXJjaF9jcjE2LCBjcjE2X2dkYmFy Y2hfaW5pdCk7Cit9CkluZGV4OiBnZGIvY3IxNi10ZGVwLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQpSQ1MgZmlsZTogZ2RiL2NyMTYtdGRlcC5oCmRpZmYg LU4gZ2RiL2NyMTYtdGRlcC5oCi0tLSAvZGV2L251bGwJMjAxMy0wNS0xMCAx OTozNjowNC4zNzIzMjg1MDAgKzA1MzAKKysrIC4vZ2RiL2NyMTYtdGRlcC5o CTIwMTMtMDYtMTcgMTI6NDk6MDUuMDAwMDAwMDAwICswNTMwCkBAIC0wLDAg KzEsMzIgQEAKKy8qIEdOVS9MaW51eCBvbiAgQ1IxNiB0YXJnZXQgc3VwcG9y dC4KKyAgIENvcHlyaWdodCAoQykgMjAxMi0yMDEzIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLgorCisgICBDb250cmlidXRlZCBieSBLYXVzaGlr IFBoYXRhayAoa2F1c2hpay5waGF0YWtAa3BpdGN1bW1pbnMuY29tKQorICAg S1BJVCBDdW1taW5zIEluZm9zeXN0ZW1zIExpbWl0ZWQsIFB1bmUgSW5kaWEu CisKKyAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIEdEQi4KKworICAgVGhpcyBw cm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVy c2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICAgKGF0IHlvdXIgb3B0aW9u KSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhpcyBwcm9ncmFtIGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWws CisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVSQ0hBTlRBQklMSVRZIG9y IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQor ICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgIGFsb25nIHdpdGgg dGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9y Zy9saWNlbnNlcy8+LiAgKi8KKworCisvKiBUYXJnZXQtZGVwZW5kZW50IHN0 cnVjdHVyZSBpbiBnZGJhcmNoLiAgKi8KKworc3RydWN0IGdkYmFyY2hfdGRl cAoreworICAvKiBUaGUgRUxGIGhlYWRlciBmbGFncyBzcGVjaWZ5IHRoZSBt dWx0aWxpYiB1c2VkLiAgKi8KKyAgaW50IGVsZl9mbGFnczsKKworICAvKiBC cmVha3BvaW50IGluc3RydWN0aW9uLiAgKi8KKyAgY29uc3QgZ2RiX2J5dGUg KmJyZWFrcG9pbnQ7Cit9Ow== --_002_C6CA53A2A46BA7469348BDBD663AB6585308FA27KCHJEXMB02kpitc_--