From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 17531 invoked by alias); 26 Oct 2012 05:15:10 -0000 Received: (qmail 17509 invoked by uid 22791); 26 Oct 2012 05:15:07 -0000 X-SWARE-Spam-Status: No, hits=-5.0 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_THREADED,RCVD_IN_DNSWL_LOW,RCVD_IN_HOSTKARMA_NO,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,RCVD_IN_HOSTKARMA_YE,TW_EG,TW_PV X-Spam-Check-By: sourceware.org Received: from am1ehsobe005.messaging.microsoft.com (HELO am1outboundpool.messaging.microsoft.com) (213.199.154.208) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 26 Oct 2012 05:14:54 +0000 Received: from mail82-am1-R.bigfish.com (10.3.201.226) by AM1EHSOBE008.bigfish.com (10.3.204.28) with Microsoft SMTP Server id 14.1.225.23; Fri, 26 Oct 2012 05:14:52 +0000 Received: from mail82-am1 (localhost [127.0.0.1]) by mail82-am1-R.bigfish.com (Postfix) with ESMTP id DBB702400F0; Fri, 26 Oct 2012 05:14:51 +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: 0 X-BigFish: VPS0(zz936eIc85fh154dI111aIc8kzz1202h1d1ah1d2ahzz17326ah8275bh8275dhz2dh2a8h668h839hd25hf0ah1288h12a5h12bdh137ah1441h14ddh1504h1537h153bh34h1155h) Received: from mail82-am1 (localhost.localdomain [127.0.0.1]) by mail82-am1 (MessageSwitch) id 135122848910088_23982; Fri, 26 Oct 2012 05:14:49 +0000 (UTC) Received: from AM1EHSMHS001.bigfish.com (unknown [10.3.201.233]) by mail82-am1.bigfish.com (Postfix) with ESMTP id E9472C008D; Fri, 26 Oct 2012 05:14:48 +0000 (UTC) Received: from KCHJEXHC01.kpit.com (59.163.77.45) by AM1EHSMHS001.bigfish.com (10.3.207.101) with Microsoft SMTP Server (TLS) id 14.1.225.23; Fri, 26 Oct 2012 05:14:48 +0000 Received: from KCHJEXMB02.kpit.com ([169.254.2.237]) by KCHJEXHC01.kpit.com ([172.10.15.73]) with mapi id 14.01.0289.001; Fri, 26 Oct 2012 10:44:07 +0530 From: Kaushik Phatak To: Joel Brobecker CC: Yao Qi , "gdb-patches@sourceware.org" Subject: RE: [RFA 3/5] New port: CR16: gdb port Date: Fri, 26 Oct 2012 05:15:00 -0000 Message-ID: References: <507279C7.8080401@codesourcery.com> <20121022224107.GB3713@adacore.com> <20121023135502.GA3555@adacore.com> In-Reply-To: <20121023135502.GA3555@adacore.com> Content-Type: multipart/mixed; boundary="_003_C6CA53A2A46BA7469348BDBD663AB65845B3EB9EKCHJEXMB02kpitc_" MIME-Version: 1.0 X-OriginatorOrg: kpitcummins.com Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-10/txt/msg00516.txt.bz2 --_003_C6CA53A2A46BA7469348BDBD663AB65845B3EB9EKCHJEXMB02kpitc_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Content-length: 33181 Hi Joel, >> Can you declare those externs somewhere in opcode instead? Yes, taken care of. I have also moved the global declarations from opcodes/cr16-dis.c as externs into opcode/cr16.h. This was, both cr16-dis.c= and cr16-tdep.c can use these. >> But I would make sure that the type of the variables match the return ty= pe. OK, I have taken care of this. Please find below an updated patch for cr16 gdb. I have also attached the s= ame. Additionally I have also attached the bfd hunk which moves the globals into externs in the opcodes file. I will submit that to binutils once my gdb por= t=20 gets a go ahead. Thanks again for taking time to review this port. Regards, Kaushik 2012-10-26 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 --- ./gdb_src.orig/gdb/configure.tgt 2012-08-02 01:18:44.000000000 +0530 +++ ./gdb_src/gdb/configure.tgt 2012-10-23 15:09:24.000000000 +0530 @@ -116,6 +116,18 @@ bfin-*-*) gdb_sim=3D../sim/bfin/libsim.a ;; =20 +cr16*-*-*linux) + # Target: CR16 processor + gdb_target_obs=3D"cr16-tdep.o cr16-linux-tdep.o linux-tdep.o" + gdb_sim=3D../sim/cr16/libsim.a + ;; + +cr16*-*-*) + # Target: CR16 processor + gdb_target_obs=3D"cr16-tdep.o" + gdb_sim=3D../sim/cr16/libsim.a + ;; + cris*) # Target: CRIS gdb_target_obs=3D"cris-tdep.o solib-svr4.o" --- ./gdb_src.orig/gdb/cr16-linux-tdep.c 1970-01-01 05:30:00.000000000 +0530 +++ ./gdb_src/gdb/cr16-linux-tdep.c 2012-10-23 15:22:34.000000000 +0530 @@ -0,0 +1,103 @@ +/* Target-dependent code for GNU/Linux on the Sitel CR16 processors. + + Copyright 2012 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 "solib-svr4.h" +#include "symtab.h" +#include "cr16-tdep.h" + +/* Number of registers available for Linux targets */ +#define CR16_LINUX_NUM_REGS 21 + +/* The breakpoint instruction used by uClinux target */ +static const gdb_byte breakpoint_uclinux[] =3D { 0xC7, 0x00 }; + +/* Implement the "register_name" gdbarch method. */ + +static const char * +cr16_linux_register_name (struct gdbarch *gdbarch, int regnr) +{ + static const char *const reg_names[] =3D + { + "r0", + "r1", + "r2", + "r3", + "r4", + "r5", + "r6", + "r7", + "r8", + "r9", + "r10", + "r11", + "r12", + "r13", + "ra", + "psr", + "pc", + "r0r1_orig", + "intbase", + "usp", + "cfg" + }; + + return reg_names[regnr]; +} + +/* OS specific initialization of gdbarch. */ + +static void +cr16_uclinux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +{ + struct gdbarch_tdep *tdep =3D gdbarch_tdep (gdbarch); + + linux_init_abi (info, gdbarch); + + set_gdbarch_num_regs (gdbarch, CR16_LINUX_NUM_REGS); + set_gdbarch_register_name (gdbarch, cr16_linux_register_name); + + /* The opcode of excp bpt is 0x00C8, however for uclinux we will + use the excp flg (0x00C7) to insert a breakpoint. The excp bpt + requires external hardware support for breakpoints to work on + CR16 target. Software based breakpoints are implemented in the + kernel using excp flg and tested on the SC14452 target. Use + 0x00C7 with gdbserver/kernel and 0x00C8 for sim/ELF. We + represent the breakpoint in little endian format since CR16 + supports only little endian. */ + tdep->breakpoint =3D breakpoint_uclinux; + +} + +/* Provide a prototype to silence -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_cr16_linux_tdep; + +void +_initialize_cr16_linux_tdep (void) +{ + gdbarch_register_osabi (bfd_arch_cr16, 0, GDB_OSABI_LINUX, + cr16_uclinux_init_abi); +} --- ./gdb_src.orig/gdb/cr16-tdep.c 1970-01-01 05:30:00.000000000 +0530 +++ ./gdb_src/gdb/cr16-tdep.c 2012-10-25 10:44:15.000000000 +0530 @@ -0,0 +1,904 @@ +/* Target-dependent code for the Sitel CR16 for GDB, the GNU debugger. +=20 + Copyright (C) 2012 Free Software Foundation, Inc. +=20 + Contributed by Kaushik Phatak (kaushik.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]; +}; + +/* Implement the "register_name" gdbarch method. */ + +static const char * +cr16_register_name (struct gdbarch *gdbarch, int regnr) +{ + static const char *const reg_names[] =3D + { + "r0", + "r1", + "r2", + "r3", + "r4", + "r5", + "r6", + "r7", + "r8", + "r9", + "r10", + "r11", + "r12", + "r13", + "ra", + "sp", + "pc", + "isp", + "usp", + "intbase", + "psr", + "cfg" + }; + + return reg_names[regnr]; +} + + +/* Implement the "register_type" gdbarch method. */ + +static struct type * +cr16_register_type (struct gdbarch *gdbarch, int reg_nr) +{ + switch (reg_nr) + { + case CR16_PC_REGNUM: /* Note:PC in CR16 is of 24 bits. */ + return builtin_type (gdbarch)->builtin_func_ptr; + + case CR16_RA_REGNUM: /* Return address reg. */ + return builtin_type (gdbarch)->builtin_data_ptr; + break; + + case CR16_FP_REGNUM: /*Frame Pointer reg. */ + case CR16_SP_REGNUM: /*Stack Pointer reg. */ + return builtin_type (gdbarch)->builtin_data_ptr; + break; + + case SIM_CR16_ISP_REGNUM: + case SIM_CR16_USP_REGNUM: + case SIM_CR16_INTBASE_REGNUM: + return builtin_type (gdbarch)->builtin_int32; + break; + + case SIM_CR16_PSR_REGNUM: + case SIM_CR16_CFG_REGNUM: + return builtin_type (gdbarch)->builtin_uint32; + break; + + case SIM_CR16_R0_REGNUM: + case SIM_CR16_R1_REGNUM: + case SIM_CR16_R2_REGNUM: + case SIM_CR16_R3_REGNUM: + case SIM_CR16_R4_REGNUM: + case SIM_CR16_R5_REGNUM: + case SIM_CR16_R6_REGNUM: + case SIM_CR16_R7_REGNUM: + case SIM_CR16_R8_REGNUM: + case SIM_CR16_R9_REGNUM: + case SIM_CR16_R10_REGNUM: + case SIM_CR16_R11_REGNUM: + return builtin_type (gdbarch)->builtin_int16; + break; + + case SIM_CR16_R12_REGNUM: + return builtin_type (gdbarch)->builtin_int32; + break; + + default: + return builtin_type (gdbarch)->builtin_int32; + break; + } +} + +/* Function for finding saved registers in a 'struct pv_area'; this + function is passed to pv_area_scan. +=20 + If VALUE is a saved register, ADDR says it was saved at a constant + offset from the frame base, and SIZE indicates that the whole + register was saved, record its offset. */ + +static void +check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t val= ue) +{ + struct cr16_prologue *result =3D (struct cr16_prologue *) result_untyped; + + if (value.kind =3D=3D pvk_register + && value.k =3D=3D 0 + && pv_is_register (addr, CR16_SP_REGNUM) + && size =3D=3D register_size (target_gdbarch, value.reg)) + result->reg_offset[value.reg] =3D addr.k; +} + +/* Define a "handle" struct for fetching the next opcode. */ + +struct cr16_get_opcode_byte_handle +{ + CORE_ADDR pc; +}; + +/* Analyze a prologue starting at START_PC, going no further than + LIMIT_PC. Fill in RESULT as appropriate. */ + +static void +cr16_analyze_prologue (CORE_ADDR start_pc, + CORE_ADDR limit_pc, struct cr16_prologue *result) +{ + CORE_ADDR pc, next_pc; + gdb_byte 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); + words[0] =3D buf[1] << 8 | buf[0]; + words[1] =3D buf[3] << 8 | buf[2]; + words[2] =3D buf[5] << 8 | buf[4]; + allWords =3D + ((ULONGLONG) words[0] << 32) + ((unsigned long) words[1] << 16) + + words[2]; + + /* Find a matching opcode in table. + Nonzero means instruction has a match. */ + is_decoded =3D match_opcode (); + make_instruction (); + length =3D currInsn.size; + next_pc =3D pc + length; + insn_byte1 =3D (words[0] >> 8) & 0xFF; + + /* If PUSH, then save RA and other regs. */ + if (insn_byte1 =3D=3D 0x01) + { + int r1, r2; + int r; + + insn_byte2 =3D words[0]; + + if (insn_byte2 & 0x80) + { + reg[CR16_SP_REGNUM] =3D pv_add_constant (reg[CR16_SP_REGNUM], -4); + pv_area_store (stack, reg[CR16_SP_REGNUM], 4, + reg[CR16_RA_REGNUM]); + } + /* Start Register=3Dr1, 3 bit imm count=3Dr2. */ + r1 =3D insn_byte2 & 0x0F; + r2 =3D ((insn_byte2 & 0x70) >> 4); + r2 =3D r2 + r1 + 1; + + for (r =3D r1; r < r2; r++) + { + if (r >=3D CR16_R12_REGNUM) + { + reg[CR16_SP_REGNUM] =3D + pv_add_constant (reg[CR16_SP_REGNUM], -4); + pv_area_store (stack, reg[CR16_SP_REGNUM], 4, reg[r]); + r++; + } + else + { + reg[CR16_SP_REGNUM] =3D + pv_add_constant (reg[CR16_SP_REGNUM], -2); + pv_area_store (stack, reg[CR16_SP_REGNUM], 2, reg[r]); + } + } + after_last_frame_setup_insn =3D next_pc; + } + /* Add constant to SP. */ + else if (insn_byte1 =3D=3D 0x60) + { + int rdst; + signed short addend; + + insn_byte2 =3D words[0]; + rdst =3D insn_byte2 & 0x0F; + if (rdst =3D=3D CR16_SP_REGNUM) + { + if (length =3D=3D 2) + { + addend =3D (insn_byte2 & 0xF0) >> 4; + reg[rdst] =3D pv_add_constant (reg[rdst], addend); + } + if (length =3D=3D 4) + { + addend =3D words[1]; + reg[rdst] =3D pv_add_constant (reg[rdst], addend); + } + after_last_frame_setup_insn =3D next_pc; + } + } + /* Check for MOVD insn. */ + else if (insn_byte1 =3D=3D 0x55) + { + int rdst, rsrc; + + insn_byte2 =3D words[0]; + rsrc =3D (insn_byte2 & 0xF0) >> 4; + rdst =3D (insn_byte2 & 0x0F); + reg[rdst] =3D reg[rsrc]; + if (rsrc =3D=3D CR16_SP_REGNUM && rdst =3D=3D CR16_FP_REGNUM) + after_last_frame_setup_insn =3D next_pc; + } + else if (((insn_byte1 >> 4) & 0x0F) =3D=3D 0xd) + { + /* This moves an argument register to the stack. Don't + record it, but allow it to be a part of the prologue. */ + after_last_frame_setup_insn =3D next_pc; + } + else + { + break; /* Terminate the prologue scan. */ + } + + pc =3D next_pc; + } + + /* Is the frame size (offset, really) a known constant? */ + if (pv_is_register (reg[CR16_SP_REGNUM], CR16_SP_REGNUM)) + result->frame_size =3D reg[CR16_SP_REGNUM].k; + + /* Was the frame pointer initialized? */ + if (pv_is_register (reg[CR16_FP_REGNUM], CR16_SP_REGNUM)) + { + result->has_frame_ptr =3D 1; + result->frame_ptr_offset =3D reg[CR16_FP_REGNUM].k; + } + + /* Record where all the registers were saved. */ + pv_area_scan (stack, check_for_saved, (void *) result); + + result->prologue_end =3D after_last_frame_setup_insn; + do_cleanups (back_to); +} + + +/* Implement the "skip_prologue" gdbarch method. */ + +static CORE_ADDR +cr16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + const char *name; + CORE_ADDR func_addr, func_end; + struct cr16_prologue p; + + /* Try to find the extent of the function that contains PC. */ + if (!find_pc_partial_function (pc, &name, &func_addr, &func_end)) + return pc; + + cr16_analyze_prologue (pc, func_end, &p); + return p.prologue_end; +} + +/* Given a frame described by THIS_FRAME, decode the prologue of its + associated function if there is not cache entry as specified by + THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and + return that struct as the value of this function. */ + +static struct cr16_prologue * +cr16_analyze_frame_prologue (struct frame_info *this_frame, + void **this_prologue_cache) +{ + if (*this_prologue_cache) + 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); +=20 + return *this_prologue_cache; +} + +/* Given the next frame and a prologue cache, return this frame's + base. */ + +static CORE_ADDR +cr16_frame_base (struct frame_info *this_frame, void **this_prologue_cache) +{ + struct cr16_prologue *p + =3D cr16_analyze_frame_prologue (this_frame, this_prologue_cache); + + /* In functions that use alloca, the distance between the stack + pointer and the frame base varies dynamically, so we can't use + the SP plus static information like prologue analysis to find the + frame base. However, such functions must have a frame pointer, + to be able to restore the SP on exit. So whenever we do have a + frame pointer, use that to find the base. */ + if (p->has_frame_ptr) + { + CORE_ADDR fp =3D get_frame_register_unsigned (this_frame, CR16_FP_RE= GNUM); + return fp - p->frame_ptr_offset; + } + else + { + CORE_ADDR sp =3D get_frame_register_unsigned (this_frame, CR16_SP_RE= GNUM); + return sp - p->frame_size; + } +} + +/* Implement the "frame_this_id" method for unwinding frames. */ + +static void +cr16_frame_this_id (struct frame_info *this_frame, + void **this_prologue_cache, struct frame_id *this_id) +{ + *this_id =3D + frame_id_build (cr16_frame_base (this_frame, this_prologue_cache), + get_frame_func (this_frame)); +} + +/* Implement the "frame_prev_register" method for unwinding frames. */ + +static struct value * +cr16_frame_prev_register (struct frame_info *this_frame, + void **this_prologue_cache, int regnum) +{ + struct cr16_prologue *p =3D + cr16_analyze_frame_prologue (this_frame, this_prologue_cache); + CORE_ADDR frame_base =3D cr16_frame_base (this_frame, this_prologue_cach= e); + int reg_size =3D register_size (get_frame_arch (this_frame), regnum); + ULONGEST ra_prev; + + if (regnum =3D=3D CR16_SP_REGNUM) + return frame_unwind_got_constant (this_frame, regnum, frame_base); + + /* The call instruction has saved the return address on the RA + register, CR16_R13_REGNUM. So, we need not adjust anything + directly. We will analyze prologue as this RA register is + pushed onto stack for further leaf function calls to work. */ + else if (regnum =3D=3D CR16_PC_REGNUM) + { + ra_prev =3D frame_unwind_register_unsigned (this_frame, CR16_RA_REGN= UM); + ra_prev =3D ra_prev << 1; + return frame_unwind_got_constant (this_frame, CR16_PC_REGNUM, ra_pre= v); + } + + /* If prologue analysis says we saved this register somewhere, + return a description of the stack slot holding it. */ + else if (p->reg_offset[regnum] !=3D 1) + { + return frame_unwind_got_memory (this_frame, regnum, + frame_base + p->reg_offset[regnum]); + } + + /* Otherwise, presume we haven't changed the value of this + register, and get it from the next frame. */ + else + { + return frame_unwind_got_register (this_frame, regnum, regnum); + } +} + +static const struct frame_unwind cr16_frame_unwind =3D=20 +{ + NORMAL_FRAME, + default_frame_unwind_stop_reason, + cr16_frame_this_id, + cr16_frame_prev_register, + NULL, + default_frame_sniffer +}; + +/* Implement the "unwind_pc" gdbarch method. */ + +static CORE_ADDR +cr16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame) +{ + CORE_ADDR pc; +=20=20 + pc =3D frame_unwind_register_unsigned (this_frame, CR16_PC_REGNUM); + return pc; +} + +/* Implement the "unwind_sp" gdbarch method. */ + +static CORE_ADDR +cr16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame) +{ + CORE_ADDR sp; + + sp =3D frame_unwind_register_unsigned (this_frame, CR16_SP_REGNUM); + return sp; +} + +/* Implement the "dummy_id" gdbarch method. */ + +static struct frame_id +cr16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) +{ + return + frame_id_build (get_frame_register_unsigned (this_frame, CR16_SP_REGNU= M), + get_frame_pc (this_frame)); +} + +/* Implement the "push_dummy_call" gdbarch method. */ + +static CORE_ADDR +cr16_push_dummy_call (struct gdbarch *gdbarch, struct value *function, + struct regcache *regcache, CORE_ADDR bp_addr, int nargs, + struct value **args, CORE_ADDR sp, int struct_return, + CORE_ADDR struct_addr) +{ + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + int write_pass; + int sp_off =3D 0; + CORE_ADDR cfa; + int num_register_candidate_args; + + struct type *func_type =3D value_type (function); + + /* Dereference function pointer types. */ + while (TYPE_CODE (func_type) =3D=3D TYPE_CODE_PTR) + func_type =3D TYPE_TARGET_TYPE (func_type); + + /* The end result had better be a function or a method. */ + gdb_assert (TYPE_CODE (func_type) =3D=3D TYPE_CODE_FUNC + || TYPE_CODE (func_type) =3D=3D TYPE_CODE_METHOD); + + /* Functions with a variable number of arguments have all of their + variable arguments and the last non-variable argument passed + on the stack. + + Otherwise, we can pass up to four arguments on the stack. + + Once computed, we leave this value alone. I.e. we don't update + it in case of a struct return going in a register or an argument + requiring multiple registers, etc. We rely instead on the value + of the ``arg_reg'' variable to get these other details correct. */ + + if (TYPE_VARARGS (func_type)) + num_register_candidate_args =3D TYPE_NFIELDS (func_type) - 1; + else + num_register_candidate_args =3D 4; + + /* We make two passes; the first does the stack allocation, + the second actually stores the arguments. */ + for (write_pass =3D 0; write_pass <=3D 1; write_pass++) + { + int i; + int arg_reg =3D CR16_R0_REGNUM; + + if (write_pass) + sp =3D align_down (sp - sp_off, 4); + sp_off =3D 0; + + if (struct_return) + { + struct type *return_type =3D TYPE_TARGET_TYPE (func_type); + + gdb_assert (TYPE_CODE (return_type) =3D=3D TYPE_CODE_STRUCT + || TYPE_CODE (func_type) =3D=3D TYPE_CODE_UNION); + + if (TYPE_LENGTH (return_type) > 16 + || TYPE_LENGTH (return_type) % 4 !=3D 0) + { + if (write_pass) + regcache_cooked_write_unsigned (regcache, CR16_R12_REGNUM, + struct_addr); + } + } + + /* Push the arguments. */ + for (i =3D 0; i < nargs; i++) + { + struct value *arg =3D args[i]; + const gdb_byte *arg_bits =3D value_contents_all (arg); + struct type *arg_type =3D check_typedef (value_type (arg)); + ULONGEST arg_size =3D TYPE_LENGTH (arg_type); + + if (i =3D=3D 0 && struct_addr !=3D 0 && !struct_return + && TYPE_CODE (arg_type) =3D=3D TYPE_CODE_PTR + && extract_unsigned_integer (arg_bits, 4, + byte_order) =3D=3D struct_addr) + { + /* This argument represents the address at which C++ (and + possibly other languages) store their return value. + Put this value in R12. */ + if (write_pass) + regcache_cooked_write_unsigned (regcache, CR16_R12_REGNUM, + struct_addr); + } + else if (TYPE_CODE (arg_type) !=3D TYPE_CODE_STRUCT + && TYPE_CODE (arg_type) !=3D TYPE_CODE_UNION) + { + /* Argument is a scalar. */ + if (arg_size =3D=3D 8) + { + if (i < num_register_candidate_args + && arg_reg <=3D CR16_R7_REGNUM - 1) + { + /* If argument registers are going to be used to pass + an 8 byte scalar, the ABI specifies that two registers + must be available. */ + if (write_pass) + { + regcache_cooked_write_unsigned (regcache, arg_reg, + extract_unsigned_integer + (arg_bits, 4, + byte_order)); + regcache_cooked_write_unsigned (regcache, + arg_reg + 1, + extract_unsigned_integer + (arg_bits + 4, 4, + byte_order)); + } + arg_reg +=3D 2; + } + else + { + sp_off =3D align_up (sp_off, 4); + /* Otherwise, pass the 8 byte scalar on the stack. */ + if (write_pass) + write_memory (sp + sp_off, arg_bits, 8); + sp_off +=3D 8; + } + } + else + { + ULONGEST u; + + gdb_assert (arg_size <=3D 4); + + u =3D extract_unsigned_integer (arg_bits, arg_size, byte_order); + + if (i < num_register_candidate_args + && arg_reg <=3D CR16_R7_REGNUM) + { + if (write_pass) + regcache_cooked_write_unsigned (regcache, arg_reg, u); + arg_reg +=3D 1; + } + else + { + int p_arg_size =3D 4; + + if (TYPE_PROTOTYPED (func_type) + && i < TYPE_NFIELDS (func_type)) + { + struct type *p_arg_type =3D + TYPE_FIELD_TYPE (func_type, i); + p_arg_size =3D TYPE_LENGTH (p_arg_type); + } + + sp_off =3D align_up (sp_off, p_arg_size); + + if (write_pass) + write_memory_unsigned_integer (sp + sp_off, + p_arg_size, byte_order, + u); + sp_off +=3D p_arg_size; + } + } + } + else + { + /* Argument is a struct or union. Pass as much of the struct + in registers, as possible. Pass the rest on the stack. */ + while (arg_size > 0) + { + if (i < num_register_candidate_args + && arg_reg <=3D CR16_R7_REGNUM + && arg_size <=3D 4 * (CR16_R7_REGNUM - arg_reg + 1) + && arg_size % 4 =3D=3D 0) + { + int len =3D min (arg_size, 4); + + if (write_pass) + regcache_cooked_write_unsigned (regcache, arg_reg, + extract_unsigned_integer + (arg_bits, len, + byte_order)); + arg_bits +=3D len; + arg_size -=3D len; + arg_reg++; + } + else + { + sp_off =3D align_up (sp_off, 4); + if (write_pass) + write_memory (sp + sp_off, arg_bits, arg_size); + sp_off +=3D align_up (arg_size, 4); + arg_size =3D 0; + } + } + } + } + } + + /* Keep track of the stack address prior to pushing the return address. + This is the value that we'll return. */ + cfa =3D sp; + + /* Push the return address. */ + sp =3D sp - 4; + write_memory_unsigned_integer (sp, 4, byte_order, bp_addr); + + /* Update the stack pointer. */ + regcache_cooked_write_unsigned (regcache, CR16_SP_REGNUM, sp); + + return cfa; +} + +/* Implement the "return_value" gdbarch method. */ + +static enum return_value_convention +cr16_return_value (struct gdbarch *gdbarch, + struct type *func_type, + struct type *valtype, + struct regcache *regcache, + gdb_byte * readbuf, const gdb_byte * writebuf) +{ + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + ULONGEST valtype_len =3D TYPE_LENGTH (valtype); + + if (TYPE_LENGTH (valtype) > 16 + || ((TYPE_CODE (valtype) =3D=3D TYPE_CODE_STRUCT + || TYPE_CODE (valtype) =3D=3D TYPE_CODE_UNION) + && TYPE_LENGTH (valtype) % 4 !=3D 0)) + return RETURN_VALUE_STRUCT_CONVENTION; + + if (readbuf) + { + ULONGEST u; + int argreg =3D CR16_R0_REGNUM; + int offset =3D 0; + + while (valtype_len > 0) + { + int len =3D min (valtype_len, 4); + + regcache_cooked_read_unsigned (regcache, argreg, &u); + store_unsigned_integer (readbuf + offset, len, byte_order, u); + valtype_len -=3D len; + offset +=3D len; + argreg++; + } + } + + if (writebuf) + { + ULONGEST u; + int argreg =3D CR16_R0_REGNUM; + int offset =3D 0; + + while (valtype_len > 0) + { + int len =3D min (valtype_len, 4); + + u =3D extract_unsigned_integer (writebuf + offset, len, byte_order); + regcache_cooked_write_unsigned (regcache, argreg, u); + valtype_len -=3D len; + offset +=3D len; + argreg++; + } + } + + return RETURN_VALUE_REGISTER_CONVENTION; +} + +/* Implement the "breakpoint_from_pc" gdbarch method. */ + +static const gdb_byte * +cr16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, + int *lenptr) +{ + /* We use different breakpoint instructions for ELF and uClinux. + See cr16-linux-tdep.c for more details. */ + struct gdbarch_tdep *tdep =3D gdbarch_tdep (gdbarch); + + *lenptr =3D 2; + if (tdep =3D=3D NULL || tdep->breakpoint =3D=3D NULL) + { + return breakpoint_elf; + } + return tdep->breakpoint; +} + +/* Allocate and initialize a gdbarch object. */ + +static struct gdbarch * +cr16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) +{ + struct gdbarch *gdbarch; + struct gdbarch_tdep *tdep; + int elf_flags; + + /* Extract the elf_flags if available. */ + if (info.abfd !=3D NULL + && bfd_get_flavour (info.abfd) =3D=3D bfd_target_elf_flavour) + elf_flags =3D elf_elfheader (info.abfd)->e_flags; + else + elf_flags =3D 0; + + /* Try to find the architecture in the list of already defined + architectures. */ + for (arches =3D gdbarch_list_lookup_by_info (arches, &info); + arches !=3D NULL; + arches =3D gdbarch_list_lookup_by_info (arches->next, &info)) + { + if (gdbarch_tdep (arches->gdbarch)->elf_flags !=3D elf_flags) + continue; + + return arches->gdbarch; + } + /* None found, create a new architecture from the information + provided. */ + tdep =3D (struct gdbarch_tdep *) xcalloc (1, sizeof (struct gdbarch_tdep= )); + tdep->elf_flags =3D elf_flags; + gdbarch =3D gdbarch_alloc (&info, tdep); + + set_gdbarch_num_pseudo_regs (gdbarch, 0); + set_gdbarch_num_regs (gdbarch, CR16_NUM_REGS); + set_gdbarch_register_name (gdbarch, cr16_register_name); + set_gdbarch_register_type (gdbarch, cr16_register_type); + set_gdbarch_pc_regnum (gdbarch, CR16_PC_REGNUM); + set_gdbarch_sp_regnum (gdbarch, CR16_SP_REGNUM); + set_gdbarch_inner_than (gdbarch, core_addr_lessthan); + set_gdbarch_decr_pc_after_break (gdbarch, 2); + set_gdbarch_breakpoint_from_pc (gdbarch, cr16_breakpoint_from_pc); + set_gdbarch_skip_prologue (gdbarch, cr16_skip_prologue); + + /* Passing NULL values in the following two functions + for the time being, to fix later. */ + set_gdbarch_print_insn (gdbarch, print_insn_cr16); + set_gdbarch_unwind_pc (gdbarch, cr16_unwind_pc); + set_gdbarch_unwind_sp (gdbarch, cr16_unwind_sp); + + /* Methods for saving / extracting a dummy frame's ID. + The ID's stack address must match the SP value returned by + PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ + set_gdbarch_dummy_id (gdbarch, cr16_dummy_id); + set_gdbarch_push_dummy_call (gdbarch, cr16_push_dummy_call); + /* Target builtin data types. */ + set_gdbarch_char_signed (gdbarch, 8); + set_gdbarch_short_bit (gdbarch, 16); + set_gdbarch_int_bit (gdbarch, 16); + set_gdbarch_long_bit (gdbarch, 32); + set_gdbarch_long_long_bit (gdbarch, 64); + set_gdbarch_float_bit (gdbarch, 32); + + set_gdbarch_ptr_bit (gdbarch, 32); + set_gdbarch_float_format (gdbarch, floatformats_ieee_single); + set_gdbarch_double_bit (gdbarch, 64); + set_gdbarch_long_double_bit (gdbarch, 64); + set_gdbarch_double_format (gdbarch, floatformats_ieee_double); + set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double); + + frame_unwind_append_unwinder (gdbarch, &cr16_frame_unwind); + set_gdbarch_return_value (gdbarch, cr16_return_value); + + /* Hook in ABI-specific overrides, if they have been registered. */ + gdbarch_init_osabi (info, gdbarch); + + return gdbarch; + +} + +/* -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_cr16_tdep; + +/* Register the above initialization routine. */ + +void +_initialize_cr16_tdep (void) +{ + register_gdbarch_init (bfd_arch_cr16, cr16_gdbarch_init); +} --- ./gdb_src.orig/gdb/cr16-tdep.h 1970-01-01 05:30:00.000000000 +0530 +++ ./gdb_src/gdb/cr16-tdep.h 2012-10-23 15:22:53.000000000 +0530 @@ -0,0 +1,32 @@ +/* GNU/Linux on CR16 target support. + Copyright (C) 2012 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; +}; --_003_C6CA53A2A46BA7469348BDBD663AB65845B3EB9EKCHJEXMB02kpitc_ Content-Type: application/octet-stream; name="cr16_gdb.diff" Content-Description: cr16_gdb.diff Content-Disposition: attachment; filename="cr16_gdb.diff"; size=31806; creation-date="Thu, 25 Oct 2012 05:34:08 GMT"; modification-date="Fri, 26 Oct 2012 05:06:15 GMT" Content-Transfer-Encoding: base64 Content-length: 43115 LS0tIC4vZ2RiX3NyYy5vcmlnL2dkYi9jb25maWd1cmUudGd0CTIwMTItMDgt MDIgMDE6MTg6NDQuMDAwMDAwMDAwICswNTMwCisrKyAuL2dkYl9zcmMvZ2Ri L2NvbmZpZ3VyZS50Z3QJMjAxMi0xMC0yMyAxNTowOToyNC4wMDAwMDAwMDAg KzA1MzAKQEAgLTExNiw2ICsxMTYsMTggQEAgYmZpbi0qLSopCiAJZ2RiX3Np bT0uLi9zaW0vYmZpbi9saWJzaW0uYQogCTs7CiAKK2NyMTYqLSotKmxpbnV4 KQorCSMgVGFyZ2V0OiBDUjE2IHByb2Nlc3NvcgorCWdkYl90YXJnZXRfb2Jz PSJjcjE2LXRkZXAubyBjcjE2LWxpbnV4LXRkZXAubyBsaW51eC10ZGVwLm8i CisJZ2RiX3NpbT0uLi9zaW0vY3IxNi9saWJzaW0uYQorCTs7CisKK2NyMTYq LSotKikKKwkjIFRhcmdldDogQ1IxNiBwcm9jZXNzb3IKKwlnZGJfdGFyZ2V0 X29icz0iY3IxNi10ZGVwLm8iCisJZ2RiX3NpbT0uLi9zaW0vY3IxNi9saWJz aW0uYQorCTs7CisKIGNyaXMqKQogCSMgVGFyZ2V0OiBDUklTCiAJZ2RiX3Rh cmdldF9vYnM9ImNyaXMtdGRlcC5vIHNvbGliLXN2cjQubyIKLS0tIC4vZ2Ri X3NyYy5vcmlnL2dkYi9jcjE2LWxpbnV4LXRkZXAuYwkxOTcwLTAxLTAxIDA1 OjMwOjAwLjAwMDAwMDAwMCArMDUzMAorKysgLi9nZGJfc3JjL2dkYi9jcjE2 LWxpbnV4LXRkZXAuYwkyMDEyLTEwLTIzIDE1OjIyOjM0LjAwMDAwMDAwMCAr MDUzMApAQCAtMCwwICsxLDEwMyBAQAorLyogVGFyZ2V0LWRlcGVuZGVudCBj b2RlIGZvciBHTlUvTGludXggb24gdGhlIFNpdGVsIENSMTYgcHJvY2Vzc29y cy4KKworICAgQ29weXJpZ2h0IDIwMTIgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuCisKKyAgIENvbnRyaWJ1dGVkIGJ5IEthdXNoaWsgUGhhdGFr IChrYXVzaGlrLnBoYXRha0BrcGl0Y3VtbWlucy5jb20pCisgICBLUElUIEN1 bW1pbnMgSW5mb3N5c3RlbXMgTGltaXRlZCwgUHVuZSBJbmRpYS4KKworICAg VGhpcyBmaWxlIGlzIHBhcnQgb2YgR0RCLgorCisgICBUaGlzIHByb2dyYW0g aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yIG1vZGlmeQorICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMg b2YgdGhlIExpY2Vuc2UsIG9yCisgICAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorCisgICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgICBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisg ICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHBy b2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vu c2VzLz4uICAqLworCisjaW5jbHVkZSAiZGVmcy5oIgorI2luY2x1ZGUgIm9z YWJpLmgiCisjaW5jbHVkZSAiZWxmLWJmZC5oIgorI2luY2x1ZGUgImVsZi9j cjE2LmgiCisjaW5jbHVkZSAibGludXgtdGRlcC5oIgorI2luY2x1ZGUgInNv bGliLXN2cjQuaCIKKyNpbmNsdWRlICJzeW10YWIuaCIKKyNpbmNsdWRlICJj cjE2LXRkZXAuaCIKKworLyogTnVtYmVyIG9mIHJlZ2lzdGVycyBhdmFpbGFi bGUgZm9yIExpbnV4IHRhcmdldHMgICovCisjZGVmaW5lIENSMTZfTElOVVhf TlVNX1JFR1MgIDIxCisKKy8qIFRoZSBicmVha3BvaW50IGluc3RydWN0aW9u IHVzZWQgYnkgdUNsaW51eCB0YXJnZXQgICovCitzdGF0aWMgY29uc3QgZ2Ri X2J5dGUgYnJlYWtwb2ludF91Y2xpbnV4W10gPSB7IDB4QzcsIDB4MDAgfTsK KworLyogSW1wbGVtZW50IHRoZSAicmVnaXN0ZXJfbmFtZSIgZ2RiYXJjaCBt ZXRob2QuICAqLworCitzdGF0aWMgY29uc3QgY2hhciAqCitjcjE2X2xpbnV4 X3JlZ2lzdGVyX25hbWUgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBpbnQg cmVnbnIpCit7CisgIHN0YXRpYyBjb25zdCBjaGFyICpjb25zdCByZWdfbmFt ZXNbXSA9CisgIHsKKyAgICAicjAiLAorICAgICJyMSIsCisgICAgInIyIiwK KyAgICAicjMiLAorICAgICJyNCIsCisgICAgInI1IiwKKyAgICAicjYiLAor ICAgICJyNyIsCisgICAgInI4IiwKKyAgICAicjkiLAorICAgICJyMTAiLAor ICAgICJyMTEiLAorICAgICJyMTIiLAorICAgICJyMTMiLAorICAgICJyYSIs CisgICAgInBzciIsCisgICAgInBjIiwKKyAgICAicjByMV9vcmlnIiwKKyAg ICAiaW50YmFzZSIsCisgICAgInVzcCIsCisgICAgImNmZyIKKyAgfTsKKwor ICByZXR1cm4gcmVnX25hbWVzW3JlZ25yXTsKK30KKworLyogT1Mgc3BlY2lm aWMgaW5pdGlhbGl6YXRpb24gb2YgZ2RiYXJjaC4gICovCisKK3N0YXRpYyB2 b2lkCitjcjE2X3VjbGludXhfaW5pdF9hYmkgKHN0cnVjdCBnZGJhcmNoX2lu Zm8gaW5mbywgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gpCit7CisgIHN0cnVj dCBnZGJhcmNoX3RkZXAgKnRkZXAgPSBnZGJhcmNoX3RkZXAgKGdkYmFyY2gp OworCisgIGxpbnV4X2luaXRfYWJpIChpbmZvLCBnZGJhcmNoKTsKKworICBz ZXRfZ2RiYXJjaF9udW1fcmVncyAoZ2RiYXJjaCwgQ1IxNl9MSU5VWF9OVU1f UkVHUyk7CisgIHNldF9nZGJhcmNoX3JlZ2lzdGVyX25hbWUgKGdkYmFyY2gs IGNyMTZfbGludXhfcmVnaXN0ZXJfbmFtZSk7CisKKyAgLyogVGhlIG9wY29k ZSBvZiBleGNwIGJwdCBpcyAweDAwQzgsIGhvd2V2ZXIgZm9yIHVjbGludXgg d2Ugd2lsbAorICAgICB1c2UgdGhlIGV4Y3AgZmxnICgweDAwQzcpIHRvIGlu c2VydCBhIGJyZWFrcG9pbnQuICBUaGUgZXhjcCBicHQKKyAgICAgcmVxdWly ZXMgZXh0ZXJuYWwgaGFyZHdhcmUgc3VwcG9ydCBmb3IgYnJlYWtwb2ludHMg dG8gd29yayBvbgorICAgICBDUjE2IHRhcmdldC4gIFNvZnR3YXJlIGJhc2Vk IGJyZWFrcG9pbnRzIGFyZSBpbXBsZW1lbnRlZCBpbiB0aGUKKyAgICAga2Vy bmVsIHVzaW5nIGV4Y3AgZmxnIGFuZCB0ZXN0ZWQgb24gdGhlIFNDMTQ0NTIg dGFyZ2V0LiAgVXNlCisgICAgIDB4MDBDNyB3aXRoIGdkYnNlcnZlci9rZXJu ZWwgYW5kIDB4MDBDOCBmb3Igc2ltL0VMRi4gIFdlCisgICAgIHJlcHJlc2Vu dCB0aGUgYnJlYWtwb2ludCBpbiBsaXR0bGUgZW5kaWFuIGZvcm1hdCBzaW5j ZSBDUjE2CisgICAgIHN1cHBvcnRzIG9ubHkgbGl0dGxlIGVuZGlhbi4gICov CisgIHRkZXAtPmJyZWFrcG9pbnQgPSBicmVha3BvaW50X3VjbGludXg7CisK K30KKworLyogUHJvdmlkZSBhIHByb3RvdHlwZSB0byBzaWxlbmNlIC1XbWlz c2luZy1wcm90b3R5cGVzLiAgKi8KK2V4dGVybiBpbml0aWFsaXplX2ZpbGVf ZnR5cGUgX2luaXRpYWxpemVfY3IxNl9saW51eF90ZGVwOworCit2b2lkCitf aW5pdGlhbGl6ZV9jcjE2X2xpbnV4X3RkZXAgKHZvaWQpCit7CisgIGdkYmFy Y2hfcmVnaXN0ZXJfb3NhYmkgKGJmZF9hcmNoX2NyMTYsIDAsIEdEQl9PU0FC SV9MSU5VWCwKKwkJCSAgY3IxNl91Y2xpbnV4X2luaXRfYWJpKTsKK30KLS0t IC4vZ2RiX3NyYy5vcmlnL2dkYi9jcjE2LXRkZXAuYwkxOTcwLTAxLTAxIDA1 OjMwOjAwLjAwMDAwMDAwMCArMDUzMAorKysgLi9nZGJfc3JjL2dkYi9jcjE2 LXRkZXAuYwkyMDEyLTEwLTI1IDEwOjQ0OjE1LjAwMDAwMDAwMCArMDUzMApA QCAtMCwwICsxLDkwNCBAQAorLyogVGFyZ2V0LWRlcGVuZGVudCBjb2RlIGZv ciB0aGUgU2l0ZWwgQ1IxNiBmb3IgR0RCLCB0aGUgR05VIGRlYnVnZ2VyLgor IAorICAgQ29weXJpZ2h0IChDKSAyMDEyIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLgorIAorICAgQ29udHJpYnV0ZWQgYnkgS2F1c2hpayBQaGF0 YWsgKGthdXNoaWsucGhhdGFrQGtwaXRjdW1taW5zLmNvbSkKKyAgIEtQSVQg Q3VtbWlucyBJbmZvc3lzdGVtcyBMaW1pdGVkLCBQdW5lIEluZGlhLgorICAg VGhpcyBmaWxlIGlzIHBhcnQgb2YgR0RCLgorCisgIFRoaXMgcHJvZ3JhbSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQv b3IgbW9kaWZ5CisgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgIHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2Yg dGhlIExpY2Vuc2UsIG9yCisgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVy IHZlcnNpb24uCisgCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBp biB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgorICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgIEdOVSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgCisgIFlvdSBz aG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlCisgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAg SWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LiAg Ki8KKworI2luY2x1ZGUgImRlZnMuaCIKKyNpbmNsdWRlICJhcmNoLXV0aWxz LmgiCisjaW5jbHVkZSAicHJvbG9ndWUtdmFsdWUuaCIKKyNpbmNsdWRlICJ0 YXJnZXQuaCIKKyNpbmNsdWRlICJyZWdjYWNoZS5oIgorI2luY2x1ZGUgIm9w Y29kZS9jcjE2LmgiCisjaW5jbHVkZSAiZGlzLWFzbS5oIgorI2luY2x1ZGUg ImdkYnR5cGVzLmgiCisjaW5jbHVkZSAiZnJhbWUuaCIKKyNpbmNsdWRlICJm cmFtZS11bndpbmQuaCIKKyNpbmNsdWRlICJmcmFtZS1iYXNlLmgiCisjaW5j bHVkZSAidmFsdWUuaCIKKyNpbmNsdWRlICJnZGJjb3JlLmgiCisjaW5jbHVk ZSAiZHdhcmYyLWZyYW1lLmgiCisjaW5jbHVkZSAiZ2RiL3NpbS1jcjE2Lmgi CisjaW5jbHVkZSAiZWxmL2NyMTYuaCIKKyNpbmNsdWRlICJlbGYtYmZkLmgi CisjaW5jbHVkZSAib3NhYmkuaCIKKyNpbmNsdWRlICJjcjE2LXRkZXAuaCIK KworLyogTnVtYmVyIG9mIHJlZ2lzdGVycyBhdmFpbGFibGUgZm9yIEVMRiB0 YXJnZXRzLiAgKi8KKyNkZWZpbmUgQ1IxNl9OVU1fUkVHUyAgMjIKKworLyog VGhlIGJyZWFrcG9pbnQgaW5zdHJ1Y3Rpb24gdXNlZCB3aXRoIHNpbSBmb3Ig RUxGIHRhcmdldHMuICAqLworc3RhdGljIGNvbnN0IGdkYl9ieXRlIGJyZWFr cG9pbnRfZWxmW10gPSB7IDB4QzgsIDB4MDAgfTsKKworLyogQ2VydGFpbiBp bXBvcnRhbnQgcmVnaXN0ZXIgbnVtYmVycy4gICovCitlbnVtCit7CisgIENS MTZfUjBfUkVHTlVNID0gMCwKKyAgQ1IxNl9SN19SRUdOVU0gPSA3LAorICBD UjE2X1IxMl9SRUdOVU0gPSAxMiwKKyAgQ1IxNl9GUF9SRUdOVU0gPSAxMywK KyAgQ1IxNl9SQV9SRUdOVU0gPSAxNCwKKyAgQ1IxNl9TUF9SRUdOVU0gPSAx NSwKKyAgQ1IxNl9QQ19SRUdOVU0gPSAxNiwKK307CisKKy8qIFRoaXMgc3Ry dWN0dXJlIGhvbGRzIHRoZSByZXN1bHRzIG9mIGEgcHJvbG9ndWUgYW5hbHlz aXMuICAqLworc3RydWN0IGNyMTZfcHJvbG9ndWUKK3sKKyAgLyogVGhlIG9m ZnNldCBmcm9tIHRoZSBmcmFtZSBiYXNlIHRvIHRoZSBzdGFjayBwb2ludGVy IC0tLSBhbHdheXMKKyAgICAgemVybyBvciBuZWdhdGl2ZS4KKworICAgICBD YWxsaW5nIHRoaXMgYSAic2l6ZSIgaXMgYSBiaXQgbWlzbGVhZGluZywgYnV0 IGdpdmVuIHRoYXQgdGhlCisgICAgIHN0YWNrIGdyb3dzIGRvd253YXJkcywg dXNpbmcgb2Zmc2V0cyBmb3IgZXZlcnl0aGluZyBrZWVwcyBvbmUKKyAgICAg ZnJvbSBnb2luZyBjb21wbGV0ZWx5IHNpZ24tY3Jhenk6IHlvdSBuZXZlciBj aGFuZ2UgYW55dGhpbmcncworICAgICBzaWduIGZvciBhbiBBREQgaW5zdHJ1 Y3Rpb247IGFsd2F5cyBjaGFuZ2UgdGhlIHNlY29uZCBvcGVyYW5kJ3MKKyAg ICAgc2lnbiBmb3IgYSBTVUIgaW5zdHJ1Y3Rpb247IGFuZCBldmVyeXRoaW5n IHRha2VzIGNhcmUgb2YKKyAgICAgaXRzZWxmLiAgKi8KKyAgaW50IGZyYW1l X3NpemU7CisKKyAgLyogTm9uLXplcm8gaWYgdGhpcyBmdW5jdGlvbiBoYXMg aW5pdGlhbGl6ZWQgdGhlIGZyYW1lIHBvaW50ZXIgZnJvbQorICAgICB0aGUg c3RhY2sgcG9pbnRlciwgemVybyBvdGhlcndpc2UuICAqLworICBpbnQgaGFz X2ZyYW1lX3B0cjsKKworICAvKiBJZiBoYXNfZnJhbWVfcHRyIGlzIG5vbi16 ZXJvLCB0aGlzIGlzIHRoZSBvZmZzZXQgZnJvbSB0aGUgZnJhbWUKKyAgICAg YmFzZSB0byB3aGVyZSB0aGUgZnJhbWUgcG9pbnRlciBwb2ludHMuICBUaGlz IGlzIGFsd2F5cyB6ZXJvIG9yCisgICAgIG5lZ2F0aXZlLiAgKi8KKyAgaW50 IGZyYW1lX3B0cl9vZmZzZXQ7CisKKyAgLyogVGhlIGFkZHJlc3Mgb2YgdGhl IGZpcnN0IGluc3RydWN0aW9uIGF0IHdoaWNoIHRoZSBmcmFtZSBoYXMgYmVl bgorICAgICBzZXQgdXAgYW5kIHRoZSBhcmd1bWVudHMgYXJlIHdoZXJlIHRo ZSBkZWJ1ZyBpbmZvIHNheXMgdGhleSBhcmUKKyAgICAgLS0tIGFzIGJlc3Qg YXMgd2UgY2FuIHRlbGwuICAqLworICBDT1JFX0FERFIgcHJvbG9ndWVfZW5k OworCisgIC8qIHJlZ19vZmZzZXRbUl0gaXMgdGhlIG9mZnNldCBmcm9tIHRo ZSBDRkEgYXQgd2hpY2ggcmVnaXN0ZXIgUiBpcworICAgICBzYXZlZCwgb3Ig MSBpZiByZWdpc3RlciBSIGhhcyBub3QgYmVlbiBzYXZlZC4gIChSZWFsIHZh bHVlcyBhcmUKKyAgICAgYWx3YXlzIHplcm8gb3IgbmVnYXRpdmUuKSAgKi8K KyAgaW50IHJlZ19vZmZzZXRbQ1IxNl9OVU1fUkVHU107Cit9OworCisvKiBJ bXBsZW1lbnQgdGhlICJyZWdpc3Rlcl9uYW1lIiBnZGJhcmNoIG1ldGhvZC4g ICovCisKK3N0YXRpYyBjb25zdCBjaGFyICoKK2NyMTZfcmVnaXN0ZXJfbmFt ZSAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIGludCByZWducikKK3sKKyAg c3RhdGljIGNvbnN0IGNoYXIgKmNvbnN0IHJlZ19uYW1lc1tdID0KKyAgewor ICAgICJyMCIsCisgICAgInIxIiwKKyAgICAicjIiLAorICAgICJyMyIsCisg ICAgInI0IiwKKyAgICAicjUiLAorICAgICJyNiIsCisgICAgInI3IiwKKyAg ICAicjgiLAorICAgICJyOSIsCisgICAgInIxMCIsCisgICAgInIxMSIsCisg ICAgInIxMiIsCisgICAgInIxMyIsCisgICAgInJhIiwKKyAgICAic3AiLAor ICAgICJwYyIsCisgICAgImlzcCIsCisgICAgInVzcCIsCisgICAgImludGJh c2UiLAorICAgICJwc3IiLAorICAgICJjZmciCisgIH07CisKKyAgcmV0dXJu IHJlZ19uYW1lc1tyZWducl07Cit9CisKKworLyogSW1wbGVtZW50IHRoZSAi cmVnaXN0ZXJfdHlwZSIgZ2RiYXJjaCBtZXRob2QuICAqLworCitzdGF0aWMg c3RydWN0IHR5cGUgKgorY3IxNl9yZWdpc3Rlcl90eXBlIChzdHJ1Y3QgZ2Ri YXJjaCAqZ2RiYXJjaCwgaW50IHJlZ19ucikKK3sKKyAgc3dpdGNoIChyZWdf bnIpCisgICAgeworICAgIGNhc2UgQ1IxNl9QQ19SRUdOVU06CS8qIE5vdGU6 UEMgaW4gQ1IxNiBpcyBvZiAyNCBiaXRzLiAgKi8KKyAgICAgIHJldHVybiBi dWlsdGluX3R5cGUgKGdkYmFyY2gpLT5idWlsdGluX2Z1bmNfcHRyOworCisg ICAgY2FzZSBDUjE2X1JBX1JFR05VTToJLyogUmV0dXJuIGFkZHJlc3MgcmVn LiAgKi8KKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUgKGdkYmFyY2gpLT5i dWlsdGluX2RhdGFfcHRyOworICAgICAgYnJlYWs7CisKKyAgICBjYXNlIENS MTZfRlBfUkVHTlVNOgkvKkZyYW1lIFBvaW50ZXIgcmVnLiAgKi8KKyAgICBj YXNlIENSMTZfU1BfUkVHTlVNOgkvKlN0YWNrIFBvaW50ZXIgcmVnLiAgKi8K KyAgICAgIHJldHVybiBidWlsdGluX3R5cGUgKGdkYmFyY2gpLT5idWlsdGlu X2RhdGFfcHRyOworICAgICAgYnJlYWs7CisKKyAgICBjYXNlIFNJTV9DUjE2 X0lTUF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9VU1BfUkVHTlVNOgor ICAgIGNhc2UgU0lNX0NSMTZfSU5UQkFTRV9SRUdOVU06CisgICAgICByZXR1 cm4gYnVpbHRpbl90eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9pbnQzMjsKKyAg ICAgIGJyZWFrOworCisgICAgY2FzZSBTSU1fQ1IxNl9QU1JfUkVHTlVNOgor ICAgIGNhc2UgU0lNX0NSMTZfQ0ZHX1JFR05VTToKKyAgICAgIHJldHVybiBi dWlsdGluX3R5cGUgKGdkYmFyY2gpLT5idWlsdGluX3VpbnQzMjsKKyAgICAg IGJyZWFrOworCisgICAgY2FzZSBTSU1fQ1IxNl9SMF9SRUdOVU06CisgICAg Y2FzZSBTSU1fQ1IxNl9SMV9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9S Ml9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SM19SRUdOVU06CisgICAg Y2FzZSBTSU1fQ1IxNl9SNF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9S NV9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SNl9SRUdOVU06CisgICAg Y2FzZSBTSU1fQ1IxNl9SN19SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9S OF9SRUdOVU06CisgICAgY2FzZSBTSU1fQ1IxNl9SOV9SRUdOVU06CisgICAg Y2FzZSBTSU1fQ1IxNl9SMTBfUkVHTlVNOgorICAgIGNhc2UgU0lNX0NSMTZf UjExX1JFR05VTToKKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUgKGdkYmFy Y2gpLT5idWlsdGluX2ludDE2OworICAgICAgYnJlYWs7CisKKyAgICBjYXNl IFNJTV9DUjE2X1IxMl9SRUdOVU06CisgICAgICByZXR1cm4gYnVpbHRpbl90 eXBlIChnZGJhcmNoKS0+YnVpbHRpbl9pbnQzMjsKKyAgICAgIGJyZWFrOwor CisgICAgZGVmYXVsdDoKKyAgICAgIHJldHVybiBidWlsdGluX3R5cGUgKGdk YmFyY2gpLT5idWlsdGluX2ludDMyOworICAgICAgYnJlYWs7CisgICAgfQor fQorCisvKiBGdW5jdGlvbiBmb3IgZmluZGluZyBzYXZlZCByZWdpc3RlcnMg aW4gYSAnc3RydWN0IHB2X2FyZWEnOyB0aGlzCisgICBmdW5jdGlvbiBpcyBw YXNzZWQgdG8gcHZfYXJlYV9zY2FuLgorIAorICAgSWYgVkFMVUUgaXMgYSBz YXZlZCByZWdpc3RlciwgQUREUiBzYXlzIGl0IHdhcyBzYXZlZCBhdCBhIGNv bnN0YW50CisgICBvZmZzZXQgZnJvbSB0aGUgZnJhbWUgYmFzZSwgYW5kIFNJ WkUgaW5kaWNhdGVzIHRoYXQgdGhlIHdob2xlCisgICByZWdpc3RlciB3YXMg c2F2ZWQsIHJlY29yZCBpdHMgb2Zmc2V0LiAgKi8KKworc3RhdGljIHZvaWQK K2NoZWNrX2Zvcl9zYXZlZCAodm9pZCAqcmVzdWx0X3VudHlwZWQsIHB2X3Qg YWRkciwgQ09SRV9BRERSIHNpemUsIHB2X3QgdmFsdWUpCit7CisgIHN0cnVj dCBjcjE2X3Byb2xvZ3VlICpyZXN1bHQgPSAoc3RydWN0IGNyMTZfcHJvbG9n dWUgKikgcmVzdWx0X3VudHlwZWQ7CisKKyAgaWYgKHZhbHVlLmtpbmQgPT0g cHZrX3JlZ2lzdGVyCisgICAgICAmJiB2YWx1ZS5rID09IDAKKyAgICAgICYm IHB2X2lzX3JlZ2lzdGVyIChhZGRyLCBDUjE2X1NQX1JFR05VTSkKKyAgICAg ICYmIHNpemUgPT0gcmVnaXN0ZXJfc2l6ZSAodGFyZ2V0X2dkYmFyY2gsIHZh bHVlLnJlZykpCisgICAgcmVzdWx0LT5yZWdfb2Zmc2V0W3ZhbHVlLnJlZ10g PSBhZGRyLms7Cit9CisKKy8qIERlZmluZSBhICJoYW5kbGUiIHN0cnVjdCBm b3IgZmV0Y2hpbmcgdGhlIG5leHQgb3Bjb2RlLiAgKi8KKworc3RydWN0IGNy MTZfZ2V0X29wY29kZV9ieXRlX2hhbmRsZQoreworICBDT1JFX0FERFIgcGM7 Cit9OworCisvKiBBbmFseXplIGEgcHJvbG9ndWUgc3RhcnRpbmcgYXQgU1RB UlRfUEMsIGdvaW5nIG5vIGZ1cnRoZXIgdGhhbgorICAgTElNSVRfUEMuICBG aWxsIGluIFJFU1VMVCBhcyBhcHByb3ByaWF0ZS4gICovCisKK3N0YXRpYyB2 b2lkCitjcjE2X2FuYWx5emVfcHJvbG9ndWUgKENPUkVfQUREUiBzdGFydF9w YywKKwkJICAgICAgIENPUkVfQUREUiBsaW1pdF9wYywgc3RydWN0IGNyMTZf cHJvbG9ndWUgKnJlc3VsdCkKK3sKKyAgQ09SRV9BRERSIHBjLCBuZXh0X3Bj OworICBnZGJfYnl0ZSBpbnNuX2J5dGUxLCBpbnNuX2J5dGUyOworICBpbnQg cm47CisgIGludCBsZW5ndGg7CisgIHB2X3QgcmVnW0NSMTZfTlVNX1JFR1Nd OworICBzdHJ1Y3QgcHZfYXJlYSAqc3RhY2s7CisgIHN0cnVjdCBjbGVhbnVw ICpiYWNrX3RvOworICBDT1JFX0FERFIgYWZ0ZXJfbGFzdF9mcmFtZV9zZXR1 cF9pbnNuID0gc3RhcnRfcGM7CisgIGludCBpc19kZWNvZGVkOworCisgIG1l bXNldCAocmVzdWx0LCAwLCBzaXplb2YgKCpyZXN1bHQpKTsKKworICBmb3Ig KHJuID0gMDsgcm4gPCBDUjE2X05VTV9SRUdTOyBybisrKQorICAgIHsKKyAg ICAgIHJlZ1tybl0gPSBwdl9yZWdpc3RlciAocm4sIDApOworICAgICAgcmVz dWx0LT5yZWdfb2Zmc2V0W3JuXSA9IDE7CisgICAgfQorCisgIHN0YWNrID0g bWFrZV9wdl9hcmVhIChDUjE2X1NQX1JFR05VTSwgZ2RiYXJjaF9hZGRyX2Jp dCAodGFyZ2V0X2dkYmFyY2gpKTsKKyAgYmFja190byA9IG1ha2VfY2xlYW51 cF9mcmVlX3B2X2FyZWEgKHN0YWNrKTsKKworICBwYyA9IHN0YXJ0X3BjOwor ICB3aGlsZSAocGMgPCBsaW1pdF9wYykKKyAgICB7CisgICAgICBnZGJfYnl0 ZSBidWZbNl07CisKKyAgICAgIC8qIFJlYWQgNiBieXRlcywgbWF4IDQ4IGJp dCBvcGNvZGUuICAqLworICAgICAgdGFyZ2V0X3JlYWRfbWVtb3J5IChwYywg YnVmLCA2KTsKKyAgICAgIHdvcmRzWzBdID0gYnVmWzFdIDw8IDggfCBidWZb MF07CisgICAgICB3b3Jkc1sxXSA9IGJ1ZlszXSA8PCA4IHwgYnVmWzJdOwor ICAgICAgd29yZHNbMl0gPSBidWZbNV0gPDwgOCB8IGJ1Zls0XTsKKyAgICAg IGFsbFdvcmRzID0KKwkoKFVMT05HTE9ORykgd29yZHNbMF0gPDwgMzIpICsg KCh1bnNpZ25lZCBsb25nKSB3b3Jkc1sxXSA8PCAxNikgKworCXdvcmRzWzJd OworCisgICAgICAvKiBGaW5kIGEgbWF0Y2hpbmcgb3Bjb2RlIGluIHRhYmxl LgorICAgICAgICAgTm9uemVybyBtZWFucyBpbnN0cnVjdGlvbiBoYXMgYSBt YXRjaC4gICovCisgICAgICBpc19kZWNvZGVkID0gbWF0Y2hfb3Bjb2RlICgp OworICAgICAgbWFrZV9pbnN0cnVjdGlvbiAoKTsKKyAgICAgIGxlbmd0aCA9 IGN1cnJJbnNuLnNpemU7CisgICAgICBuZXh0X3BjID0gcGMgKyBsZW5ndGg7 CisgICAgICBpbnNuX2J5dGUxID0gKHdvcmRzWzBdID4+IDgpICYgMHhGRjsK KworICAgICAgLyogSWYgUFVTSCwgdGhlbiBzYXZlIFJBIGFuZCBvdGhlciBy ZWdzLiAgKi8KKyAgICAgIGlmIChpbnNuX2J5dGUxID09IDB4MDEpCisJewor CSAgaW50IHIxLCByMjsKKwkgIGludCByOworCisJICBpbnNuX2J5dGUyID0g d29yZHNbMF07CisKKwkgIGlmIChpbnNuX2J5dGUyICYgMHg4MCkKKwkgICAg eworCSAgICAgIHJlZ1tDUjE2X1NQX1JFR05VTV0gPSBwdl9hZGRfY29uc3Rh bnQgKHJlZ1tDUjE2X1NQX1JFR05VTV0sIC00KTsKKwkgICAgICBwdl9hcmVh X3N0b3JlIChzdGFjaywgcmVnW0NSMTZfU1BfUkVHTlVNXSwgNCwKKwkJCSAg ICAgcmVnW0NSMTZfUkFfUkVHTlVNXSk7CisJICAgIH0KKwkgIC8qIFN0YXJ0 IFJlZ2lzdGVyPXIxLCAzIGJpdCBpbW0gY291bnQ9cjIuICAqLworCSAgcjEg PSBpbnNuX2J5dGUyICYgMHgwRjsKKwkgIHIyID0gKChpbnNuX2J5dGUyICYg MHg3MCkgPj4gNCk7CisJICByMiA9IHIyICsgcjEgKyAxOworCisJICBmb3Ig KHIgPSByMTsgciA8IHIyOyByKyspCisJICAgIHsKKwkgICAgICBpZiAociA+ PSBDUjE2X1IxMl9SRUdOVU0pCisJCXsKKwkJICByZWdbQ1IxNl9TUF9SRUdO VU1dID0KKwkJICAgIHB2X2FkZF9jb25zdGFudCAocmVnW0NSMTZfU1BfUkVH TlVNXSwgLTQpOworCQkgIHB2X2FyZWFfc3RvcmUgKHN0YWNrLCByZWdbQ1Ix Nl9TUF9SRUdOVU1dLCA0LCByZWdbcl0pOworCQkgIHIrKzsKKwkJfQorCSAg ICAgIGVsc2UKKwkJeworCQkgIHJlZ1tDUjE2X1NQX1JFR05VTV0gPQorCQkg ICAgcHZfYWRkX2NvbnN0YW50IChyZWdbQ1IxNl9TUF9SRUdOVU1dLCAtMik7 CisJCSAgcHZfYXJlYV9zdG9yZSAoc3RhY2ssIHJlZ1tDUjE2X1NQX1JFR05V TV0sIDIsIHJlZ1tyXSk7CisJCX0KKwkgICAgfQorCSAgYWZ0ZXJfbGFzdF9m cmFtZV9zZXR1cF9pbnNuID0gbmV4dF9wYzsKKwl9CisgICAgICAvKiBBZGQg Y29uc3RhbnQgdG8gU1AuICAqLworICAgICAgZWxzZSBpZiAoaW5zbl9ieXRl MSA9PSAweDYwKQorCXsKKwkgIGludCByZHN0OworCSAgc2lnbmVkIHNob3J0 IGFkZGVuZDsKKworCSAgaW5zbl9ieXRlMiA9IHdvcmRzWzBdOworCSAgcmRz dCA9IGluc25fYnl0ZTIgJiAweDBGOworCSAgaWYgKHJkc3QgPT0gQ1IxNl9T UF9SRUdOVU0pCisJICAgIHsKKwkgICAgICBpZiAobGVuZ3RoID09IDIpCisJ CXsKKwkJICBhZGRlbmQgPSAoaW5zbl9ieXRlMiAmIDB4RjApID4+IDQ7CisJ CSAgcmVnW3Jkc3RdID0gcHZfYWRkX2NvbnN0YW50IChyZWdbcmRzdF0sIGFk ZGVuZCk7CisJCX0KKwkgICAgICBpZiAobGVuZ3RoID09IDQpCisJCXsKKwkJ ICBhZGRlbmQgPSB3b3Jkc1sxXTsKKwkJICByZWdbcmRzdF0gPSBwdl9hZGRf Y29uc3RhbnQgKHJlZ1tyZHN0XSwgYWRkZW5kKTsKKwkJfQorCSAgICAgIGFm dGVyX2xhc3RfZnJhbWVfc2V0dXBfaW5zbiA9IG5leHRfcGM7CisJICAgIH0K Kwl9CisgICAgICAvKiBDaGVjayBmb3IgTU9WRCBpbnNuLiAgKi8KKyAgICAg IGVsc2UgaWYgKGluc25fYnl0ZTEgPT0gMHg1NSkKKwl7CisJICBpbnQgcmRz dCwgcnNyYzsKKworCSAgaW5zbl9ieXRlMiA9IHdvcmRzWzBdOworCSAgcnNy YyA9IChpbnNuX2J5dGUyICYgMHhGMCkgPj4gNDsKKwkgIHJkc3QgPSAoaW5z bl9ieXRlMiAmIDB4MEYpOworCSAgcmVnW3Jkc3RdID0gcmVnW3JzcmNdOwor CSAgaWYgKHJzcmMgPT0gQ1IxNl9TUF9SRUdOVU0gJiYgcmRzdCA9PSBDUjE2 X0ZQX1JFR05VTSkKKwkgICAgYWZ0ZXJfbGFzdF9mcmFtZV9zZXR1cF9pbnNu ID0gbmV4dF9wYzsKKwl9CisgICAgICBlbHNlIGlmICgoKGluc25fYnl0ZTEg Pj4gNCkgJiAweDBGKSA9PSAweGQpCisJeworCSAgLyogVGhpcyBtb3ZlcyBh biBhcmd1bWVudCByZWdpc3RlciB0byB0aGUgc3RhY2suICBEb24ndAorCSAg ICAgcmVjb3JkIGl0LCBidXQgYWxsb3cgaXQgdG8gYmUgYSBwYXJ0IG9mIHRo ZSBwcm9sb2d1ZS4gICovCisJICBhZnRlcl9sYXN0X2ZyYW1lX3NldHVwX2lu c24gPSBuZXh0X3BjOworCX0KKyAgICAgIGVsc2UKKwl7CisJICBicmVhazsJ CS8qIFRlcm1pbmF0ZSB0aGUgcHJvbG9ndWUgc2Nhbi4gICovCisJfQorCisg ICAgICBwYyA9IG5leHRfcGM7CisgICAgfQorCisgIC8qIElzIHRoZSBmcmFt ZSBzaXplIChvZmZzZXQsIHJlYWxseSkgYSBrbm93biBjb25zdGFudD8gICov CisgIGlmIChwdl9pc19yZWdpc3RlciAocmVnW0NSMTZfU1BfUkVHTlVNXSwg Q1IxNl9TUF9SRUdOVU0pKQorICAgIHJlc3VsdC0+ZnJhbWVfc2l6ZSA9IHJl Z1tDUjE2X1NQX1JFR05VTV0uazsKKworICAvKiBXYXMgdGhlIGZyYW1lIHBv aW50ZXIgaW5pdGlhbGl6ZWQ/ICAqLworICBpZiAocHZfaXNfcmVnaXN0ZXIg KHJlZ1tDUjE2X0ZQX1JFR05VTV0sIENSMTZfU1BfUkVHTlVNKSkKKyAgICB7 CisgICAgICByZXN1bHQtPmhhc19mcmFtZV9wdHIgPSAxOworICAgICAgcmVz dWx0LT5mcmFtZV9wdHJfb2Zmc2V0ID0gcmVnW0NSMTZfRlBfUkVHTlVNXS5r OworICAgIH0KKworICAvKiBSZWNvcmQgd2hlcmUgYWxsIHRoZSByZWdpc3Rl cnMgd2VyZSBzYXZlZC4gICovCisgIHB2X2FyZWFfc2NhbiAoc3RhY2ssIGNo ZWNrX2Zvcl9zYXZlZCwgKHZvaWQgKikgcmVzdWx0KTsKKworICByZXN1bHQt PnByb2xvZ3VlX2VuZCA9IGFmdGVyX2xhc3RfZnJhbWVfc2V0dXBfaW5zbjsK KyAgZG9fY2xlYW51cHMgKGJhY2tfdG8pOworfQorCisKKy8qIEltcGxlbWVu dCB0aGUgInNraXBfcHJvbG9ndWUiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKwor c3RhdGljIENPUkVfQUREUgorY3IxNl9za2lwX3Byb2xvZ3VlIChzdHJ1Y3Qg Z2RiYXJjaCAqZ2RiYXJjaCwgQ09SRV9BRERSIHBjKQoreworICBjb25zdCBj aGFyICpuYW1lOworICBDT1JFX0FERFIgZnVuY19hZGRyLCBmdW5jX2VuZDsK KyAgc3RydWN0IGNyMTZfcHJvbG9ndWUgcDsKKworICAvKiBUcnkgdG8gZmlu ZCB0aGUgZXh0ZW50IG9mIHRoZSBmdW5jdGlvbiB0aGF0IGNvbnRhaW5zIFBD LiAgKi8KKyAgaWYgKCFmaW5kX3BjX3BhcnRpYWxfZnVuY3Rpb24gKHBjLCAm bmFtZSwgJmZ1bmNfYWRkciwgJmZ1bmNfZW5kKSkKKyAgICByZXR1cm4gcGM7 CisKKyAgY3IxNl9hbmFseXplX3Byb2xvZ3VlIChwYywgZnVuY19lbmQsICZw KTsKKyAgcmV0dXJuIHAucHJvbG9ndWVfZW5kOworfQorCisvKiBHaXZlbiBh IGZyYW1lIGRlc2NyaWJlZCBieSBUSElTX0ZSQU1FLCBkZWNvZGUgdGhlIHBy b2xvZ3VlIG9mIGl0cworICAgYXNzb2NpYXRlZCBmdW5jdGlvbiBpZiB0aGVy ZSBpcyBub3QgY2FjaGUgZW50cnkgYXMgc3BlY2lmaWVkIGJ5CisgICBUSElT X1BST0xPR1VFX0NBQ0hFLiAgU2F2ZSB0aGUgZGVjb2RlZCBwcm9sb2d1ZSBp biB0aGUgY2FjaGUgYW5kCisgICByZXR1cm4gdGhhdCBzdHJ1Y3QgYXMgdGhl IHZhbHVlIG9mIHRoaXMgZnVuY3Rpb24uICAqLworCitzdGF0aWMgc3RydWN0 IGNyMTZfcHJvbG9ndWUgKgorY3IxNl9hbmFseXplX2ZyYW1lX3Byb2xvZ3Vl IChzdHJ1Y3QgZnJhbWVfaW5mbyAqdGhpc19mcmFtZSwKKwkJCSAgICAgdm9p ZCAqKnRoaXNfcHJvbG9ndWVfY2FjaGUpCit7CisgIGlmICgqdGhpc19wcm9s b2d1ZV9jYWNoZSkKKyAgICByZXR1cm4gKnRoaXNfcHJvbG9ndWVfY2FjaGU7 CisKKyAgQ09SRV9BRERSIGZ1bmNfc3RhcnQsIHN0b3BfYWRkcjsKKworICAq dGhpc19wcm9sb2d1ZV9jYWNoZSA9IEZSQU1FX09CU1RBQ0tfWkFMTE9DIChz dHJ1Y3QgY3IxNl9wcm9sb2d1ZSk7CisgIGZ1bmNfc3RhcnQgPSBnZXRfZnJh bWVfZnVuYyAodGhpc19mcmFtZSk7CisgIHN0b3BfYWRkciA9IGdldF9mcmFt ZV9wYyAodGhpc19mcmFtZSk7CisKKyAvKiBJZiB3ZSBjb3VsZG4ndCBmaW5k IGFueSBmdW5jdGlvbiBjb250YWluaW5nIHRoZSBQQywgdGhlbgorICAgICBq dXN0IGluaXRpYWxpemUgdGhlIHByb2xvZ3VlIGNhY2hlLCBidXQgZG9uJ3Qg ZG8gYW55dGhpbmcuICAqLworICBpZiAoIWZ1bmNfc3RhcnQpCisgICAgc3Rv cF9hZGRyID0gZnVuY19zdGFydDsKKworICBjcjE2X2FuYWx5emVfcHJvbG9n dWUgKGZ1bmNfc3RhcnQsIHN0b3BfYWRkciwgKnRoaXNfcHJvbG9ndWVfY2Fj aGUpOworIAorICByZXR1cm4gKnRoaXNfcHJvbG9ndWVfY2FjaGU7Cit9CisK Ky8qIEdpdmVuIHRoZSBuZXh0IGZyYW1lIGFuZCBhIHByb2xvZ3VlIGNhY2hl LCByZXR1cm4gdGhpcyBmcmFtZSdzCisgICBiYXNlLiAgKi8KKworc3RhdGlj IENPUkVfQUREUgorY3IxNl9mcmFtZV9iYXNlIChzdHJ1Y3QgZnJhbWVfaW5m byAqdGhpc19mcmFtZSwgdm9pZCAqKnRoaXNfcHJvbG9ndWVfY2FjaGUpCit7 CisgIHN0cnVjdCBjcjE2X3Byb2xvZ3VlICpwCisgICAgPSBjcjE2X2FuYWx5 emVfZnJhbWVfcHJvbG9ndWUgKHRoaXNfZnJhbWUsIHRoaXNfcHJvbG9ndWVf Y2FjaGUpOworCisgIC8qIEluIGZ1bmN0aW9ucyB0aGF0IHVzZSBhbGxvY2Es IHRoZSBkaXN0YW5jZSBiZXR3ZWVuIHRoZSBzdGFjaworICAgICBwb2ludGVy IGFuZCB0aGUgZnJhbWUgYmFzZSB2YXJpZXMgZHluYW1pY2FsbHksIHNvIHdl IGNhbid0IHVzZQorICAgICB0aGUgU1AgcGx1cyBzdGF0aWMgaW5mb3JtYXRp b24gbGlrZSBwcm9sb2d1ZSBhbmFseXNpcyB0byBmaW5kIHRoZQorICAgICBm cmFtZSBiYXNlLiAgSG93ZXZlciwgc3VjaCBmdW5jdGlvbnMgbXVzdCBoYXZl IGEgZnJhbWUgcG9pbnRlciwKKyAgICAgdG8gYmUgYWJsZSB0byByZXN0b3Jl IHRoZSBTUCBvbiBleGl0LiAgU28gd2hlbmV2ZXIgd2UgZG8gaGF2ZSBhCisg ICAgIGZyYW1lIHBvaW50ZXIsIHVzZSB0aGF0IHRvIGZpbmQgdGhlIGJhc2Uu ICAqLworICBpZiAocC0+aGFzX2ZyYW1lX3B0cikKKyAgICB7CisgICAgICBD T1JFX0FERFIgZnAgPSBnZXRfZnJhbWVfcmVnaXN0ZXJfdW5zaWduZWQgKHRo aXNfZnJhbWUsIENSMTZfRlBfUkVHTlVNKTsKKyAgICAgIHJldHVybiBmcCAt IHAtPmZyYW1lX3B0cl9vZmZzZXQ7CisgICAgfQorICBlbHNlCisgICAgewor ICAgICAgQ09SRV9BRERSIHNwID0gZ2V0X2ZyYW1lX3JlZ2lzdGVyX3Vuc2ln bmVkICh0aGlzX2ZyYW1lLCBDUjE2X1NQX1JFR05VTSk7CisgICAgICByZXR1 cm4gc3AgLSBwLT5mcmFtZV9zaXplOworICAgIH0KK30KKworLyogSW1wbGVt ZW50IHRoZSAiZnJhbWVfdGhpc19pZCIgbWV0aG9kIGZvciB1bndpbmRpbmcg ZnJhbWVzLiAgKi8KKworc3RhdGljIHZvaWQKK2NyMTZfZnJhbWVfdGhpc19p ZCAoc3RydWN0IGZyYW1lX2luZm8gKnRoaXNfZnJhbWUsCisJCSAgICB2b2lk ICoqdGhpc19wcm9sb2d1ZV9jYWNoZSwgc3RydWN0IGZyYW1lX2lkICp0aGlz X2lkKQoreworICAqdGhpc19pZCA9CisgICAgZnJhbWVfaWRfYnVpbGQgKGNy MTZfZnJhbWVfYmFzZSAodGhpc19mcmFtZSwgdGhpc19wcm9sb2d1ZV9jYWNo ZSksCisJCSAgICBnZXRfZnJhbWVfZnVuYyAodGhpc19mcmFtZSkpOworfQor CisvKiBJbXBsZW1lbnQgdGhlICJmcmFtZV9wcmV2X3JlZ2lzdGVyIiBtZXRo b2QgZm9yIHVud2luZGluZyBmcmFtZXMuICAqLworCitzdGF0aWMgc3RydWN0 IHZhbHVlICoKK2NyMTZfZnJhbWVfcHJldl9yZWdpc3RlciAoc3RydWN0IGZy YW1lX2luZm8gKnRoaXNfZnJhbWUsCisJCQkgIHZvaWQgKip0aGlzX3Byb2xv Z3VlX2NhY2hlLCBpbnQgcmVnbnVtKQoreworICBzdHJ1Y3QgY3IxNl9wcm9s b2d1ZSAqcCA9CisgICAgY3IxNl9hbmFseXplX2ZyYW1lX3Byb2xvZ3VlICh0 aGlzX2ZyYW1lLCB0aGlzX3Byb2xvZ3VlX2NhY2hlKTsKKyAgQ09SRV9BRERS IGZyYW1lX2Jhc2UgPSBjcjE2X2ZyYW1lX2Jhc2UgKHRoaXNfZnJhbWUsIHRo aXNfcHJvbG9ndWVfY2FjaGUpOworICBpbnQgcmVnX3NpemUgPSByZWdpc3Rl cl9zaXplIChnZXRfZnJhbWVfYXJjaCAodGhpc19mcmFtZSksIHJlZ251bSk7 CisgIFVMT05HRVNUIHJhX3ByZXY7CisKKyAgaWYgKHJlZ251bSA9PSBDUjE2 X1NQX1JFR05VTSkKKyAgICByZXR1cm4gZnJhbWVfdW53aW5kX2dvdF9jb25z dGFudCAodGhpc19mcmFtZSwgcmVnbnVtLCBmcmFtZV9iYXNlKTsKKworICAv KiBUaGUgY2FsbCBpbnN0cnVjdGlvbiBoYXMgc2F2ZWQgdGhlIHJldHVybiBh ZGRyZXNzIG9uIHRoZSBSQQorICAgICByZWdpc3RlciwgQ1IxNl9SMTNfUkVH TlVNLiAgU28sIHdlIG5lZWQgbm90IGFkanVzdCBhbnl0aGluZworICAgICBk aXJlY3RseS4gIFdlIHdpbGwgYW5hbHl6ZSBwcm9sb2d1ZSBhcyB0aGlzIFJB IHJlZ2lzdGVyIGlzCisgICAgIHB1c2hlZCBvbnRvIHN0YWNrIGZvciBmdXJ0 aGVyIGxlYWYgZnVuY3Rpb24gY2FsbHMgdG8gd29yay4gICovCisgIGVsc2Ug aWYgKHJlZ251bSA9PSBDUjE2X1BDX1JFR05VTSkKKyAgICB7CisgICAgICBy YV9wcmV2ID0gZnJhbWVfdW53aW5kX3JlZ2lzdGVyX3Vuc2lnbmVkICh0aGlz X2ZyYW1lLCBDUjE2X1JBX1JFR05VTSk7CisgICAgICByYV9wcmV2ID0gcmFf cHJldiA8PCAxOworICAgICAgcmV0dXJuIGZyYW1lX3Vud2luZF9nb3RfY29u c3RhbnQgKHRoaXNfZnJhbWUsIENSMTZfUENfUkVHTlVNLCByYV9wcmV2KTsK KyAgICB9CisKKyAgLyogSWYgcHJvbG9ndWUgYW5hbHlzaXMgc2F5cyB3ZSBz YXZlZCB0aGlzIHJlZ2lzdGVyIHNvbWV3aGVyZSwKKyAgICAgcmV0dXJuIGEg ZGVzY3JpcHRpb24gb2YgdGhlIHN0YWNrIHNsb3QgaG9sZGluZyBpdC4gICov CisgIGVsc2UgaWYgKHAtPnJlZ19vZmZzZXRbcmVnbnVtXSAhPSAxKQorICAg IHsKKyAgICAgIHJldHVybiBmcmFtZV91bndpbmRfZ290X21lbW9yeSAodGhp c19mcmFtZSwgcmVnbnVtLAorCQkJCSAgICAgIGZyYW1lX2Jhc2UgKyBwLT5y ZWdfb2Zmc2V0W3JlZ251bV0pOworICAgIH0KKworICAvKiBPdGhlcndpc2Us IHByZXN1bWUgd2UgaGF2ZW4ndCBjaGFuZ2VkIHRoZSB2YWx1ZSBvZiB0aGlz CisgICAgIHJlZ2lzdGVyLCBhbmQgZ2V0IGl0IGZyb20gdGhlIG5leHQgZnJh bWUuICAqLworICBlbHNlCisgICAgeworICAgICAgcmV0dXJuIGZyYW1lX3Vu d2luZF9nb3RfcmVnaXN0ZXIgKHRoaXNfZnJhbWUsIHJlZ251bSwgcmVnbnVt KTsKKyAgICB9Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZnJhbWVfdW53 aW5kIGNyMTZfZnJhbWVfdW53aW5kID0gCit7CisgIE5PUk1BTF9GUkFNRSwK KyAgZGVmYXVsdF9mcmFtZV91bndpbmRfc3RvcF9yZWFzb24sCisgIGNyMTZf ZnJhbWVfdGhpc19pZCwKKyAgY3IxNl9mcmFtZV9wcmV2X3JlZ2lzdGVyLAor ICBOVUxMLAorICBkZWZhdWx0X2ZyYW1lX3NuaWZmZXIKK307CisKKy8qIElt cGxlbWVudCB0aGUgInVud2luZF9wYyIgZ2RiYXJjaCBtZXRob2QuICAqLwor CitzdGF0aWMgQ09SRV9BRERSCitjcjE2X3Vud2luZF9wYyAoc3RydWN0IGdk YmFyY2ggKmdkYmFyY2gsIHN0cnVjdCBmcmFtZV9pbmZvICp0aGlzX2ZyYW1l KQoreworICBDT1JFX0FERFIgcGM7CisgIAorICBwYyA9IGZyYW1lX3Vud2lu ZF9yZWdpc3Rlcl91bnNpZ25lZCAodGhpc19mcmFtZSwgQ1IxNl9QQ19SRUdO VU0pOworICByZXR1cm4gcGM7Cit9CisKKy8qIEltcGxlbWVudCB0aGUgInVu d2luZF9zcCIgZ2RiYXJjaCBtZXRob2QuICAqLworCitzdGF0aWMgQ09SRV9B RERSCitjcjE2X3Vud2luZF9zcCAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gs IHN0cnVjdCBmcmFtZV9pbmZvICp0aGlzX2ZyYW1lKQoreworICBDT1JFX0FE RFIgc3A7CisKKyAgc3AgPSBmcmFtZV91bndpbmRfcmVnaXN0ZXJfdW5zaWdu ZWQgKHRoaXNfZnJhbWUsIENSMTZfU1BfUkVHTlVNKTsKKyAgcmV0dXJuIHNw OworfQorCisvKiBJbXBsZW1lbnQgdGhlICJkdW1teV9pZCIgZ2RiYXJjaCBt ZXRob2QuICAqLworCitzdGF0aWMgc3RydWN0IGZyYW1lX2lkCitjcjE2X2R1 bW15X2lkIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgc3RydWN0IGZyYW1l X2luZm8gKnRoaXNfZnJhbWUpCit7CisgIHJldHVybgorICAgIGZyYW1lX2lk X2J1aWxkIChnZXRfZnJhbWVfcmVnaXN0ZXJfdW5zaWduZWQgKHRoaXNfZnJh bWUsIENSMTZfU1BfUkVHTlVNKSwKKwkJICAgIGdldF9mcmFtZV9wYyAodGhp c19mcmFtZSkpOworfQorCisvKiBJbXBsZW1lbnQgdGhlICJwdXNoX2R1bW15 X2NhbGwiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGljIENPUkVfQURE UgorY3IxNl9wdXNoX2R1bW15X2NhbGwgKHN0cnVjdCBnZGJhcmNoICpnZGJh cmNoLCBzdHJ1Y3QgdmFsdWUgKmZ1bmN0aW9uLAorCQkgICAgICBzdHJ1Y3Qg cmVnY2FjaGUgKnJlZ2NhY2hlLCBDT1JFX0FERFIgYnBfYWRkciwgaW50IG5h cmdzLAorCQkgICAgICBzdHJ1Y3QgdmFsdWUgKiphcmdzLCBDT1JFX0FERFIg c3AsIGludCBzdHJ1Y3RfcmV0dXJuLAorCQkgICAgICBDT1JFX0FERFIgc3Ry dWN0X2FkZHIpCit7CisgIGVudW0gYmZkX2VuZGlhbiBieXRlX29yZGVyID0g Z2RiYXJjaF9ieXRlX29yZGVyIChnZGJhcmNoKTsKKyAgaW50IHdyaXRlX3Bh c3M7CisgIGludCBzcF9vZmYgPSAwOworICBDT1JFX0FERFIgY2ZhOworICBp bnQgbnVtX3JlZ2lzdGVyX2NhbmRpZGF0ZV9hcmdzOworCisgIHN0cnVjdCB0 eXBlICpmdW5jX3R5cGUgPSB2YWx1ZV90eXBlIChmdW5jdGlvbik7CisKKyAg LyogRGVyZWZlcmVuY2UgZnVuY3Rpb24gcG9pbnRlciB0eXBlcy4gICovCisg IHdoaWxlIChUWVBFX0NPREUgKGZ1bmNfdHlwZSkgPT0gVFlQRV9DT0RFX1BU UikKKyAgICBmdW5jX3R5cGUgPSBUWVBFX1RBUkdFVF9UWVBFIChmdW5jX3R5 cGUpOworCisgIC8qIFRoZSBlbmQgcmVzdWx0IGhhZCBiZXR0ZXIgYmUgYSBm dW5jdGlvbiBvciBhIG1ldGhvZC4gICovCisgIGdkYl9hc3NlcnQgKFRZUEVf Q09ERSAoZnVuY190eXBlKSA9PSBUWVBFX0NPREVfRlVOQworCSAgICAgIHx8 IFRZUEVfQ09ERSAoZnVuY190eXBlKSA9PSBUWVBFX0NPREVfTUVUSE9EKTsK KworICAvKiBGdW5jdGlvbnMgd2l0aCBhIHZhcmlhYmxlIG51bWJlciBvZiBh cmd1bWVudHMgaGF2ZSBhbGwgb2YgdGhlaXIKKyAgICAgdmFyaWFibGUgYXJn dW1lbnRzIGFuZCB0aGUgbGFzdCBub24tdmFyaWFibGUgYXJndW1lbnQgcGFz c2VkCisgICAgIG9uIHRoZSBzdGFjay4KKworICAgICBPdGhlcndpc2UsIHdl IGNhbiBwYXNzIHVwIHRvIGZvdXIgYXJndW1lbnRzIG9uIHRoZSBzdGFjay4K KworICAgICBPbmNlIGNvbXB1dGVkLCB3ZSBsZWF2ZSB0aGlzIHZhbHVlIGFs b25lLiAgSS5lLiB3ZSBkb24ndCB1cGRhdGUKKyAgICAgaXQgaW4gY2FzZSBv ZiBhIHN0cnVjdCByZXR1cm4gZ29pbmcgaW4gYSByZWdpc3RlciBvciBhbiBh cmd1bWVudAorICAgICByZXF1aXJpbmcgbXVsdGlwbGUgcmVnaXN0ZXJzLCBl dGMuICBXZSByZWx5IGluc3RlYWQgb24gdGhlIHZhbHVlCisgICAgIG9mIHRo ZSBgYGFyZ19yZWcnJyB2YXJpYWJsZSB0byBnZXQgdGhlc2Ugb3RoZXIgZGV0 YWlscyBjb3JyZWN0LiAgKi8KKworICBpZiAoVFlQRV9WQVJBUkdTIChmdW5j X3R5cGUpKQorICAgIG51bV9yZWdpc3Rlcl9jYW5kaWRhdGVfYXJncyA9IFRZ UEVfTkZJRUxEUyAoZnVuY190eXBlKSAtIDE7CisgIGVsc2UKKyAgICBudW1f cmVnaXN0ZXJfY2FuZGlkYXRlX2FyZ3MgPSA0OworCisgIC8qIFdlIG1ha2Ug dHdvIHBhc3NlczsgdGhlIGZpcnN0IGRvZXMgdGhlIHN0YWNrIGFsbG9jYXRp b24sCisgICAgIHRoZSBzZWNvbmQgYWN0dWFsbHkgc3RvcmVzIHRoZSBhcmd1 bWVudHMuICAqLworICBmb3IgKHdyaXRlX3Bhc3MgPSAwOyB3cml0ZV9wYXNz IDw9IDE7IHdyaXRlX3Bhc3MrKykKKyAgICB7CisgICAgICBpbnQgaTsKKyAg ICAgIGludCBhcmdfcmVnID0gQ1IxNl9SMF9SRUdOVU07CisKKyAgICAgIGlm ICh3cml0ZV9wYXNzKQorCXNwID0gYWxpZ25fZG93biAoc3AgLSBzcF9vZmYs IDQpOworICAgICAgc3Bfb2ZmID0gMDsKKworICAgICAgaWYgKHN0cnVjdF9y ZXR1cm4pCisJeworCSAgc3RydWN0IHR5cGUgKnJldHVybl90eXBlID0gVFlQ RV9UQVJHRVRfVFlQRSAoZnVuY190eXBlKTsKKworCSAgZ2RiX2Fzc2VydCAo VFlQRV9DT0RFIChyZXR1cm5fdHlwZSkgPT0gVFlQRV9DT0RFX1NUUlVDVAor CQkgICAgICB8fCBUWVBFX0NPREUgKGZ1bmNfdHlwZSkgPT0gVFlQRV9DT0RF X1VOSU9OKTsKKworCSAgaWYgKFRZUEVfTEVOR1RIIChyZXR1cm5fdHlwZSkg PiAxNgorCSAgICAgIHx8IFRZUEVfTEVOR1RIIChyZXR1cm5fdHlwZSkgJSA0 ICE9IDApCisJICAgIHsKKwkgICAgICBpZiAod3JpdGVfcGFzcykKKwkJcmVn Y2FjaGVfY29va2VkX3dyaXRlX3Vuc2lnbmVkIChyZWdjYWNoZSwgQ1IxNl9S MTJfUkVHTlVNLAorCQkJCQkJc3RydWN0X2FkZHIpOworCSAgICB9CisJfQor CisgICAgICAvKiBQdXNoIHRoZSBhcmd1bWVudHMuICAqLworICAgICAgZm9y IChpID0gMDsgaSA8IG5hcmdzOyBpKyspCisJeworCSAgc3RydWN0IHZhbHVl ICphcmcgPSBhcmdzW2ldOworCSAgY29uc3QgZ2RiX2J5dGUgKmFyZ19iaXRz ID0gdmFsdWVfY29udGVudHNfYWxsIChhcmcpOworCSAgc3RydWN0IHR5cGUg KmFyZ190eXBlID0gY2hlY2tfdHlwZWRlZiAodmFsdWVfdHlwZSAoYXJnKSk7 CisJICBVTE9OR0VTVCBhcmdfc2l6ZSA9IFRZUEVfTEVOR1RIIChhcmdfdHlw ZSk7CisKKwkgIGlmIChpID09IDAgJiYgc3RydWN0X2FkZHIgIT0gMCAmJiAh c3RydWN0X3JldHVybgorCSAgICAgICYmIFRZUEVfQ09ERSAoYXJnX3R5cGUp ID09IFRZUEVfQ09ERV9QVFIKKwkgICAgICAmJiBleHRyYWN0X3Vuc2lnbmVk X2ludGVnZXIgKGFyZ19iaXRzLCA0LAorCQkJCQkgICBieXRlX29yZGVyKSA9 PSBzdHJ1Y3RfYWRkcikKKwkgICAgeworCSAgICAgIC8qIFRoaXMgYXJndW1l bnQgcmVwcmVzZW50cyB0aGUgYWRkcmVzcyBhdCB3aGljaCBDKysgKGFuZAor CSAgICAgICAgIHBvc3NpYmx5IG90aGVyIGxhbmd1YWdlcykgc3RvcmUgdGhl aXIgcmV0dXJuIHZhbHVlLgorCSAgICAgICAgIFB1dCB0aGlzIHZhbHVlIGlu IFIxMi4gICovCisJICAgICAgaWYgKHdyaXRlX3Bhc3MpCisJCXJlZ2NhY2hl X2Nvb2tlZF93cml0ZV91bnNpZ25lZCAocmVnY2FjaGUsIENSMTZfUjEyX1JF R05VTSwKKwkJCQkJCXN0cnVjdF9hZGRyKTsKKwkgICAgfQorCSAgZWxzZSBp ZiAoVFlQRV9DT0RFIChhcmdfdHlwZSkgIT0gVFlQRV9DT0RFX1NUUlVDVAor CQkgICAmJiBUWVBFX0NPREUgKGFyZ190eXBlKSAhPSBUWVBFX0NPREVfVU5J T04pCisJICAgIHsKKwkgICAgICAvKiBBcmd1bWVudCBpcyBhIHNjYWxhci4g ICovCisJICAgICAgaWYgKGFyZ19zaXplID09IDgpCisJCXsKKwkJICBpZiAo aSA8IG51bV9yZWdpc3Rlcl9jYW5kaWRhdGVfYXJncworCQkgICAgICAmJiBh cmdfcmVnIDw9IENSMTZfUjdfUkVHTlVNIC0gMSkKKwkJICAgIHsKKwkJICAg ICAgLyogSWYgYXJndW1lbnQgcmVnaXN0ZXJzIGFyZSBnb2luZyB0byBiZSB1 c2VkIHRvIHBhc3MKKwkJICAgICAgICAgYW4gOCBieXRlIHNjYWxhciwgdGhl IEFCSSBzcGVjaWZpZXMgdGhhdCB0d28gcmVnaXN0ZXJzCisJCSAgICAgICAg IG11c3QgYmUgYXZhaWxhYmxlLiAgKi8KKwkJICAgICAgaWYgKHdyaXRlX3Bh c3MpCisJCQl7CisJCQkgIHJlZ2NhY2hlX2Nvb2tlZF93cml0ZV91bnNpZ25l ZCAocmVnY2FjaGUsIGFyZ19yZWcsCisJCQkJCQkJICBleHRyYWN0X3Vuc2ln bmVkX2ludGVnZXIKKwkJCQkJCQkgIChhcmdfYml0cywgNCwKKwkJCQkJCQkg ICBieXRlX29yZGVyKSk7CisJCQkgIHJlZ2NhY2hlX2Nvb2tlZF93cml0ZV91 bnNpZ25lZCAocmVnY2FjaGUsCisJCQkJCQkJICBhcmdfcmVnICsgMSwKKwkJ CQkJCQkgIGV4dHJhY3RfdW5zaWduZWRfaW50ZWdlcgorCQkJCQkJCSAgKGFy Z19iaXRzICsgNCwgNCwKKwkJCQkJCQkgICBieXRlX29yZGVyKSk7CisJCQl9 CisJCSAgICAgIGFyZ19yZWcgKz0gMjsKKwkJICAgIH0KKwkJICBlbHNlCisJ CSAgICB7CisJCSAgICAgIHNwX29mZiA9IGFsaWduX3VwIChzcF9vZmYsIDQp OworCQkgICAgICAvKiBPdGhlcndpc2UsIHBhc3MgdGhlIDggYnl0ZSBzY2Fs YXIgb24gdGhlIHN0YWNrLiAgKi8KKwkJICAgICAgaWYgKHdyaXRlX3Bhc3Mp CisJCQl3cml0ZV9tZW1vcnkgKHNwICsgc3Bfb2ZmLCBhcmdfYml0cywgOCk7 CisJCSAgICAgIHNwX29mZiArPSA4OworCQkgICAgfQorCQl9CisJICAgICAg ZWxzZQorCQl7CisJCSAgVUxPTkdFU1QgdTsKKworCQkgIGdkYl9hc3NlcnQg KGFyZ19zaXplIDw9IDQpOworCisJCSAgdSA9IGV4dHJhY3RfdW5zaWduZWRf aW50ZWdlciAoYXJnX2JpdHMsIGFyZ19zaXplLCBieXRlX29yZGVyKTsKKwor CQkgIGlmIChpIDwgbnVtX3JlZ2lzdGVyX2NhbmRpZGF0ZV9hcmdzCisJCSAg ICAgICYmIGFyZ19yZWcgPD0gQ1IxNl9SN19SRUdOVU0pCisJCSAgICB7CisJ CSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJcmVnY2FjaGVfY29va2VkX3dy aXRlX3Vuc2lnbmVkIChyZWdjYWNoZSwgYXJnX3JlZywgdSk7CisJCSAgICAg IGFyZ19yZWcgKz0gMTsKKwkJICAgIH0KKwkJICBlbHNlCisJCSAgICB7CisJ CSAgICAgIGludCBwX2FyZ19zaXplID0gNDsKKworCQkgICAgICBpZiAoVFlQ RV9QUk9UT1RZUEVEIChmdW5jX3R5cGUpCisJCQkgICYmIGkgPCBUWVBFX05G SUVMRFMgKGZ1bmNfdHlwZSkpCisJCQl7CisJCQkgIHN0cnVjdCB0eXBlICpw X2FyZ190eXBlID0KKwkJCSAgICBUWVBFX0ZJRUxEX1RZUEUgKGZ1bmNfdHlw ZSwgaSk7CisJCQkgIHBfYXJnX3NpemUgPSBUWVBFX0xFTkdUSCAocF9hcmdf dHlwZSk7CisJCQl9CisKKwkJICAgICAgc3Bfb2ZmID0gYWxpZ25fdXAgKHNw X29mZiwgcF9hcmdfc2l6ZSk7CisKKwkJICAgICAgaWYgKHdyaXRlX3Bhc3Mp CisJCQl3cml0ZV9tZW1vcnlfdW5zaWduZWRfaW50ZWdlciAoc3AgKyBzcF9v ZmYsCisJCQkJCQkgICAgICAgcF9hcmdfc2l6ZSwgYnl0ZV9vcmRlciwKKwkJ CQkJCSAgICAgICB1KTsKKwkJICAgICAgc3Bfb2ZmICs9IHBfYXJnX3NpemU7 CisJCSAgICB9CisJCX0KKwkgICAgfQorCSAgZWxzZQorCSAgICB7CisJICAg ICAgLyogQXJndW1lbnQgaXMgYSBzdHJ1Y3Qgb3IgdW5pb24uICBQYXNzIGFz IG11Y2ggb2YgdGhlIHN0cnVjdAorCSAgICAgICAgIGluIHJlZ2lzdGVycywg YXMgcG9zc2libGUuICBQYXNzIHRoZSByZXN0IG9uIHRoZSBzdGFjay4gICov CisJICAgICAgd2hpbGUgKGFyZ19zaXplID4gMCkKKwkJeworCQkgIGlmIChp IDwgbnVtX3JlZ2lzdGVyX2NhbmRpZGF0ZV9hcmdzCisJCSAgICAgICYmIGFy Z19yZWcgPD0gQ1IxNl9SN19SRUdOVU0KKwkJICAgICAgJiYgYXJnX3NpemUg PD0gNCAqIChDUjE2X1I3X1JFR05VTSAtIGFyZ19yZWcgKyAxKQorCQkgICAg ICAmJiBhcmdfc2l6ZSAlIDQgPT0gMCkKKwkJICAgIHsKKwkJICAgICAgaW50 IGxlbiA9IG1pbiAoYXJnX3NpemUsIDQpOworCisJCSAgICAgIGlmICh3cml0 ZV9wYXNzKQorCQkJcmVnY2FjaGVfY29va2VkX3dyaXRlX3Vuc2lnbmVkIChy ZWdjYWNoZSwgYXJnX3JlZywKKwkJCQkJCQlleHRyYWN0X3Vuc2lnbmVkX2lu dGVnZXIKKwkJCQkJCQkoYXJnX2JpdHMsIGxlbiwKKwkJCQkJCQkgYnl0ZV9v cmRlcikpOworCQkgICAgICBhcmdfYml0cyArPSBsZW47CisJCSAgICAgIGFy Z19zaXplIC09IGxlbjsKKwkJICAgICAgYXJnX3JlZysrOworCQkgICAgfQor CQkgIGVsc2UKKwkJICAgIHsKKwkJICAgICAgc3Bfb2ZmID0gYWxpZ25fdXAg KHNwX29mZiwgNCk7CisJCSAgICAgIGlmICh3cml0ZV9wYXNzKQorCQkJd3Jp dGVfbWVtb3J5IChzcCArIHNwX29mZiwgYXJnX2JpdHMsIGFyZ19zaXplKTsK KwkJICAgICAgc3Bfb2ZmICs9IGFsaWduX3VwIChhcmdfc2l6ZSwgNCk7CisJ CSAgICAgIGFyZ19zaXplID0gMDsKKwkJICAgIH0KKwkJfQorCSAgICB9CisJ fQorICAgIH0KKworICAvKiBLZWVwIHRyYWNrIG9mIHRoZSBzdGFjayBhZGRy ZXNzIHByaW9yIHRvIHB1c2hpbmcgdGhlIHJldHVybiBhZGRyZXNzLgorICAg ICBUaGlzIGlzIHRoZSB2YWx1ZSB0aGF0IHdlJ2xsIHJldHVybi4gICovCisg IGNmYSA9IHNwOworCisgIC8qIFB1c2ggdGhlIHJldHVybiBhZGRyZXNzLiAg Ki8KKyAgc3AgPSBzcCAtIDQ7CisgIHdyaXRlX21lbW9yeV91bnNpZ25lZF9p bnRlZ2VyIChzcCwgNCwgYnl0ZV9vcmRlciwgYnBfYWRkcik7CisKKyAgLyog VXBkYXRlIHRoZSBzdGFjayBwb2ludGVyLiAgKi8KKyAgcmVnY2FjaGVfY29v a2VkX3dyaXRlX3Vuc2lnbmVkIChyZWdjYWNoZSwgQ1IxNl9TUF9SRUdOVU0s IHNwKTsKKworICByZXR1cm4gY2ZhOworfQorCisvKiBJbXBsZW1lbnQgdGhl ICJyZXR1cm5fdmFsdWUiIGdkYmFyY2ggbWV0aG9kLiAgKi8KKworc3RhdGlj IGVudW0gcmV0dXJuX3ZhbHVlX2NvbnZlbnRpb24KK2NyMTZfcmV0dXJuX3Zh bHVlIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwKKwkJICAgc3RydWN0IHR5 cGUgKmZ1bmNfdHlwZSwKKwkJICAgc3RydWN0IHR5cGUgKnZhbHR5cGUsCisJ CSAgIHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUsCisJCSAgIGdkYl9ieXRl ICogcmVhZGJ1ZiwgY29uc3QgZ2RiX2J5dGUgKiB3cml0ZWJ1ZikKK3sKKyAg ZW51bSBiZmRfZW5kaWFuIGJ5dGVfb3JkZXIgPSBnZGJhcmNoX2J5dGVfb3Jk ZXIgKGdkYmFyY2gpOworICBVTE9OR0VTVCB2YWx0eXBlX2xlbiA9IFRZUEVf TEVOR1RIICh2YWx0eXBlKTsKKworICBpZiAoVFlQRV9MRU5HVEggKHZhbHR5 cGUpID4gMTYKKyAgICAgIHx8ICgoVFlQRV9DT0RFICh2YWx0eXBlKSA9PSBU WVBFX0NPREVfU1RSVUNUCisJICAgfHwgVFlQRV9DT0RFICh2YWx0eXBlKSA9 PSBUWVBFX0NPREVfVU5JT04pCisJICAmJiBUWVBFX0xFTkdUSCAodmFsdHlw ZSkgJSA0ICE9IDApKQorICAgIHJldHVybiBSRVRVUk5fVkFMVUVfU1RSVUNU X0NPTlZFTlRJT047CisKKyAgaWYgKHJlYWRidWYpCisgICAgeworICAgICAg VUxPTkdFU1QgdTsKKyAgICAgIGludCBhcmdyZWcgPSBDUjE2X1IwX1JFR05V TTsKKyAgICAgIGludCBvZmZzZXQgPSAwOworCisgICAgICB3aGlsZSAodmFs dHlwZV9sZW4gPiAwKQorCXsKKwkgIGludCBsZW4gPSBtaW4gKHZhbHR5cGVf bGVuLCA0KTsKKworCSAgcmVnY2FjaGVfY29va2VkX3JlYWRfdW5zaWduZWQg KHJlZ2NhY2hlLCBhcmdyZWcsICZ1KTsKKwkgIHN0b3JlX3Vuc2lnbmVkX2lu dGVnZXIgKHJlYWRidWYgKyBvZmZzZXQsIGxlbiwgYnl0ZV9vcmRlciwgdSk7 CisJICB2YWx0eXBlX2xlbiAtPSBsZW47CisJICBvZmZzZXQgKz0gbGVuOwor CSAgYXJncmVnKys7CisJfQorICAgIH0KKworICBpZiAod3JpdGVidWYpCisg ICAgeworICAgICAgVUxPTkdFU1QgdTsKKyAgICAgIGludCBhcmdyZWcgPSBD UjE2X1IwX1JFR05VTTsKKyAgICAgIGludCBvZmZzZXQgPSAwOworCisgICAg ICB3aGlsZSAodmFsdHlwZV9sZW4gPiAwKQorCXsKKwkgIGludCBsZW4gPSBt aW4gKHZhbHR5cGVfbGVuLCA0KTsKKworCSAgdSA9IGV4dHJhY3RfdW5zaWdu ZWRfaW50ZWdlciAod3JpdGVidWYgKyBvZmZzZXQsIGxlbiwgYnl0ZV9vcmRl cik7CisJICByZWdjYWNoZV9jb29rZWRfd3JpdGVfdW5zaWduZWQgKHJlZ2Nh Y2hlLCBhcmdyZWcsIHUpOworCSAgdmFsdHlwZV9sZW4gLT0gbGVuOworCSAg b2Zmc2V0ICs9IGxlbjsKKwkgIGFyZ3JlZysrOworCX0KKyAgICB9CisKKyAg cmV0dXJuIFJFVFVSTl9WQUxVRV9SRUdJU1RFUl9DT05WRU5USU9OOworfQor CisvKiBJbXBsZW1lbnQgdGhlICJicmVha3BvaW50X2Zyb21fcGMiIGdkYmFy Y2ggbWV0aG9kLiAgKi8KKworc3RhdGljIGNvbnN0IGdkYl9ieXRlICoKK2Ny MTZfYnJlYWtwb2ludF9mcm9tX3BjIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJj aCwgQ09SRV9BRERSICogcGNwdHIsCisJCQkgaW50ICpsZW5wdHIpCit7Cisg IC8qIFdlIHVzZSBkaWZmZXJlbnQgYnJlYWtwb2ludCBpbnN0cnVjdGlvbnMg Zm9yIEVMRiBhbmQgdUNsaW51eC4KKyAgICAgU2VlIGNyMTYtbGludXgtdGRl cC5jIGZvciBtb3JlIGRldGFpbHMuICAqLworICBzdHJ1Y3QgZ2RiYXJjaF90 ZGVwICp0ZGVwID0gZ2RiYXJjaF90ZGVwIChnZGJhcmNoKTsKKworICAqbGVu cHRyID0gMjsKKyAgaWYgKHRkZXAgPT0gTlVMTCB8fCB0ZGVwLT5icmVha3Bv aW50ID09IE5VTEwpCisgICAgeworICAgICAgcmV0dXJuIGJyZWFrcG9pbnRf ZWxmOworICAgIH0KKyAgcmV0dXJuIHRkZXAtPmJyZWFrcG9pbnQ7Cit9CisK Ky8qIEFsbG9jYXRlIGFuZCBpbml0aWFsaXplIGEgZ2RiYXJjaCBvYmplY3Qu ICAqLworCitzdGF0aWMgc3RydWN0IGdkYmFyY2ggKgorY3IxNl9nZGJhcmNo X2luaXQgKHN0cnVjdCBnZGJhcmNoX2luZm8gaW5mbywgc3RydWN0IGdkYmFy Y2hfbGlzdCAqYXJjaGVzKQoreworICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJj aDsKKyAgc3RydWN0IGdkYmFyY2hfdGRlcCAqdGRlcDsKKyAgaW50IGVsZl9m bGFnczsKKworICAvKiBFeHRyYWN0IHRoZSBlbGZfZmxhZ3MgaWYgYXZhaWxh YmxlLiAgKi8KKyAgaWYgKGluZm8uYWJmZCAhPSBOVUxMCisgICAgICAmJiBi ZmRfZ2V0X2ZsYXZvdXIgKGluZm8uYWJmZCkgPT0gYmZkX3RhcmdldF9lbGZf Zmxhdm91cikKKyAgICBlbGZfZmxhZ3MgPSBlbGZfZWxmaGVhZGVyIChpbmZv LmFiZmQpLT5lX2ZsYWdzOworICBlbHNlCisgICAgZWxmX2ZsYWdzID0gMDsK KworICAvKiBUcnkgdG8gZmluZCB0aGUgYXJjaGl0ZWN0dXJlIGluIHRoZSBs aXN0IG9mIGFscmVhZHkgZGVmaW5lZAorICAgICBhcmNoaXRlY3R1cmVzLiAg Ki8KKyAgZm9yIChhcmNoZXMgPSBnZGJhcmNoX2xpc3RfbG9va3VwX2J5X2lu Zm8gKGFyY2hlcywgJmluZm8pOworICAgICAgIGFyY2hlcyAhPSBOVUxMOwor ICAgICAgIGFyY2hlcyA9IGdkYmFyY2hfbGlzdF9sb29rdXBfYnlfaW5mbyAo YXJjaGVzLT5uZXh0LCAmaW5mbykpCisgICAgeworICAgICAgaWYgKGdkYmFy Y2hfdGRlcCAoYXJjaGVzLT5nZGJhcmNoKS0+ZWxmX2ZsYWdzICE9IGVsZl9m bGFncykKKwljb250aW51ZTsKKworICAgICAgcmV0dXJuIGFyY2hlcy0+Z2Ri YXJjaDsKKyAgICB9CisgIC8qIE5vbmUgZm91bmQsIGNyZWF0ZSBhIG5ldyBh cmNoaXRlY3R1cmUgZnJvbSB0aGUgaW5mb3JtYXRpb24KKyAgICAgcHJvdmlk ZWQuICAqLworICB0ZGVwID0gKHN0cnVjdCBnZGJhcmNoX3RkZXAgKikgeGNh bGxvYyAoMSwgc2l6ZW9mIChzdHJ1Y3QgZ2RiYXJjaF90ZGVwKSk7CisgIHRk ZXAtPmVsZl9mbGFncyA9IGVsZl9mbGFnczsKKyAgZ2RiYXJjaCA9IGdkYmFy Y2hfYWxsb2MgKCZpbmZvLCB0ZGVwKTsKKworICBzZXRfZ2RiYXJjaF9udW1f cHNldWRvX3JlZ3MgKGdkYmFyY2gsIDApOworICBzZXRfZ2RiYXJjaF9udW1f cmVncyAoZ2RiYXJjaCwgQ1IxNl9OVU1fUkVHUyk7CisgIHNldF9nZGJhcmNo X3JlZ2lzdGVyX25hbWUgKGdkYmFyY2gsIGNyMTZfcmVnaXN0ZXJfbmFtZSk7 CisgIHNldF9nZGJhcmNoX3JlZ2lzdGVyX3R5cGUgKGdkYmFyY2gsIGNyMTZf cmVnaXN0ZXJfdHlwZSk7CisgIHNldF9nZGJhcmNoX3BjX3JlZ251bSAoZ2Ri YXJjaCwgQ1IxNl9QQ19SRUdOVU0pOworICBzZXRfZ2RiYXJjaF9zcF9yZWdu dW0gKGdkYmFyY2gsIENSMTZfU1BfUkVHTlVNKTsKKyAgc2V0X2dkYmFyY2hf aW5uZXJfdGhhbiAoZ2RiYXJjaCwgY29yZV9hZGRyX2xlc3N0aGFuKTsKKyAg c2V0X2dkYmFyY2hfZGVjcl9wY19hZnRlcl9icmVhayAoZ2RiYXJjaCwgMik7 CisgIHNldF9nZGJhcmNoX2JyZWFrcG9pbnRfZnJvbV9wYyAoZ2RiYXJjaCwg Y3IxNl9icmVha3BvaW50X2Zyb21fcGMpOworICBzZXRfZ2RiYXJjaF9za2lw X3Byb2xvZ3VlIChnZGJhcmNoLCBjcjE2X3NraXBfcHJvbG9ndWUpOworCisg IC8qIFBhc3NpbmcgTlVMTCAgdmFsdWVzIGluIHRoZSBmb2xsb3dpbmcgdHdv IGZ1bmN0aW9ucworICAgICBmb3IgdGhlIHRpbWUgYmVpbmcsIHRvIGZpeCBs YXRlci4gICovCisgIHNldF9nZGJhcmNoX3ByaW50X2luc24gKGdkYmFyY2gs IHByaW50X2luc25fY3IxNik7CisgIHNldF9nZGJhcmNoX3Vud2luZF9wYyAo Z2RiYXJjaCwgY3IxNl91bndpbmRfcGMpOworICBzZXRfZ2RiYXJjaF91bndp bmRfc3AgKGdkYmFyY2gsIGNyMTZfdW53aW5kX3NwKTsKKworICAvKiBNZXRo b2RzIGZvciBzYXZpbmcgLyBleHRyYWN0aW5nIGEgZHVtbXkgZnJhbWUncyBJ RC4KKyAgICAgVGhlIElEJ3Mgc3RhY2sgYWRkcmVzcyBtdXN0IG1hdGNoIHRo ZSBTUCB2YWx1ZSByZXR1cm5lZCBieQorICAgICBQVVNIX0RVTU1ZX0NBTEws IGFuZCBzYXZlZCBieSBnZW5lcmljX3NhdmVfZHVtbXlfZnJhbWVfdG9zLiAg Ki8KKyAgc2V0X2dkYmFyY2hfZHVtbXlfaWQgKGdkYmFyY2gsIGNyMTZfZHVt bXlfaWQpOworICBzZXRfZ2RiYXJjaF9wdXNoX2R1bW15X2NhbGwgKGdkYmFy Y2gsIGNyMTZfcHVzaF9kdW1teV9jYWxsKTsKKyAgLyogVGFyZ2V0IGJ1aWx0 aW4gZGF0YSB0eXBlcy4gICovCisgIHNldF9nZGJhcmNoX2NoYXJfc2lnbmVk IChnZGJhcmNoLCA4KTsKKyAgc2V0X2dkYmFyY2hfc2hvcnRfYml0IChnZGJh cmNoLCAxNik7CisgIHNldF9nZGJhcmNoX2ludF9iaXQgKGdkYmFyY2gsIDE2 KTsKKyAgc2V0X2dkYmFyY2hfbG9uZ19iaXQgKGdkYmFyY2gsIDMyKTsKKyAg c2V0X2dkYmFyY2hfbG9uZ19sb25nX2JpdCAoZ2RiYXJjaCwgNjQpOworICBz ZXRfZ2RiYXJjaF9mbG9hdF9iaXQgKGdkYmFyY2gsIDMyKTsKKworICBzZXRf Z2RiYXJjaF9wdHJfYml0IChnZGJhcmNoLCAzMik7CisgIHNldF9nZGJhcmNo X2Zsb2F0X2Zvcm1hdCAoZ2RiYXJjaCwgZmxvYXRmb3JtYXRzX2llZWVfc2lu Z2xlKTsKKyAgc2V0X2dkYmFyY2hfZG91YmxlX2JpdCAoZ2RiYXJjaCwgNjQp OworICBzZXRfZ2RiYXJjaF9sb25nX2RvdWJsZV9iaXQgKGdkYmFyY2gsIDY0 KTsKKyAgc2V0X2dkYmFyY2hfZG91YmxlX2Zvcm1hdCAoZ2RiYXJjaCwgZmxv YXRmb3JtYXRzX2llZWVfZG91YmxlKTsKKyAgc2V0X2dkYmFyY2hfbG9uZ19k b3VibGVfZm9ybWF0IChnZGJhcmNoLCBmbG9hdGZvcm1hdHNfaWVlZV9kb3Vi bGUpOworCisgIGZyYW1lX3Vud2luZF9hcHBlbmRfdW53aW5kZXIgKGdkYmFy Y2gsICZjcjE2X2ZyYW1lX3Vud2luZCk7CisgIHNldF9nZGJhcmNoX3JldHVy bl92YWx1ZSAoZ2RiYXJjaCwgY3IxNl9yZXR1cm5fdmFsdWUpOworCisgIC8q IEhvb2sgaW4gQUJJLXNwZWNpZmljIG92ZXJyaWRlcywgaWYgdGhleSBoYXZl IGJlZW4gcmVnaXN0ZXJlZC4gICovCisgIGdkYmFyY2hfaW5pdF9vc2FiaSAo aW5mbywgZ2RiYXJjaCk7CisKKyAgcmV0dXJuIGdkYmFyY2g7CisKK30KKwor LyogLVdtaXNzaW5nLXByb3RvdHlwZXMuICAqLworZXh0ZXJuIGluaXRpYWxp emVfZmlsZV9mdHlwZSBfaW5pdGlhbGl6ZV9jcjE2X3RkZXA7CisKKy8qIFJl Z2lzdGVyIHRoZSBhYm92ZSBpbml0aWFsaXphdGlvbiByb3V0aW5lLiAgKi8K Kwordm9pZAorX2luaXRpYWxpemVfY3IxNl90ZGVwICh2b2lkKQoreworICBy ZWdpc3Rlcl9nZGJhcmNoX2luaXQgKGJmZF9hcmNoX2NyMTYsIGNyMTZfZ2Ri YXJjaF9pbml0KTsKK30KLS0tIC4vZ2RiX3NyYy5vcmlnL2dkYi9jcjE2LXRk ZXAuaAkxOTcwLTAxLTAxIDA1OjMwOjAwLjAwMDAwMDAwMCArMDUzMAorKysg Li9nZGJfc3JjL2dkYi9jcjE2LXRkZXAuaAkyMDEyLTEwLTIzIDE1OjIyOjUz LjAwMDAwMDAwMCArMDUzMApAQCAtMCwwICsxLDMyIEBACisvKiBHTlUvTGlu dXggb24gIENSMTYgdGFyZ2V0IHN1cHBvcnQuCisgICBDb3B5cmlnaHQgKEMp IDIwMTIgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisKKyAgIENv bnRyaWJ1dGVkIGJ5IEthdXNoaWsgUGhhdGFrIChrYXVzaGlrLnBoYXRha0Br cGl0Y3VtbWlucy5jb20pCisgICBLUElUIEN1bW1pbnMgSW5mb3N5c3RlbXMg TGltaXRlZCwgUHVuZSBJbmRpYS4KKworICAgVGhpcyBmaWxlIGlzIHBhcnQg b2YgR0RCLgorCisgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICAgaXQg dW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRoZSBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9y CisgICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisg ICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJS QU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisg ICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlCisgICBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUg cmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNl ZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLworCisKKy8q IFRhcmdldC1kZXBlbmRlbnQgc3RydWN0dXJlIGluIGdkYmFyY2guICAqLwor CitzdHJ1Y3QgZ2RiYXJjaF90ZGVwCit7CisgIC8qIFRoZSBFTEYgaGVhZGVy IGZsYWdzIHNwZWNpZnkgdGhlIG11bHRpbGliIHVzZWQuICAqLworICBpbnQg ZWxmX2ZsYWdzOworCisgIC8qIEJyZWFrcG9pbnQgaW5zdHJ1Y3Rpb24uICAq LworICBjb25zdCBnZGJfYnl0ZSAqYnJlYWtwb2ludDsKK307 --_003_C6CA53A2A46BA7469348BDBD663AB65845B3EB9EKCHJEXMB02kpitc_ Content-Type: application/octet-stream; name="cr16_bfd.diff" Content-Description: cr16_bfd.diff Content-Disposition: attachment; filename="cr16_bfd.diff"; size=1841; creation-date="Thu, 25 Oct 2012 05:34:13 GMT"; modification-date="Thu, 25 Oct 2012 06:28:07 GMT" Content-Transfer-Encoding: base64 Content-length: 2497 ZGlmZiAtdXByTiAuL2dkYl9zcmMub3JpZy9vcGNvZGVzL2NyMTYtZGlzLmMg Li9nZGJfc3JjL29wY29kZXMvY3IxNi1kaXMuYwotLS0gLi9nZGJfc3JjLm9y aWcvb3Bjb2Rlcy9jcjE2LWRpcy5jCTIwMTItMDUtMTcgMjA6NDM6MjUuMDAw MDAwMDAwICswNTMwCisrKyAuL2dkYl9zcmMvb3Bjb2Rlcy9jcjE2LWRpcy5j CTIwMTItMTAtMjUgMDk6NDU6NTUuMDAwMDAwMDAwICswNTMwCkBAIC0zNiw5 ICszNiw2IEBACiAvKiBTZXQgQml0IE1hc2sgLSBhIG1hc2sgdG8gc2V0IGFs bCBiaXRzIHN0YXJ0aW5nIGZyb20gb2Zmc2V0ICdvZmZzJy4gICovCiAjZGVm aW5lIFNCTShvZmZzKSAgKCgoKDEgPDwgKDMyIC0gb2ZmcykpIC0xKSA8PCAo b2ZmcykpKQogCi10eXBlZGVmIHVuc2lnbmVkIGxvbmcgZHdvcmRVOwotdHlw ZWRlZiB1bnNpZ25lZCBzaG9ydCB3b3JkVTsKLQogdHlwZWRlZiBzdHJ1Y3QK IHsKICAgZHdvcmRVIHZhbDsKQEAgLTMxNyw3ICszMTQsNyBAQCBidWlsZF9t YXNrICh2b2lkKQogCiAvKiBTZWFyY2ggZm9yIGEgbWF0Y2hpbmcgb3Bjb2Rl LiBSZXR1cm4gMSBmb3Igc3VjY2VzcywgMCBmb3IgZmFpbHVyZS4gICovCiAK LXN0YXRpYyBpbnQKK2ludAogbWF0Y2hfb3Bjb2RlICh2b2lkKQogewogICB1 bnNpZ25lZCBsb25nIG1hc2s7CkBAIC03MzQsNyArNzMxLDcgQEAgcHJpbnRf YXJndW1lbnRzIChpbnMgKmN1cnJlbnRJbnNuLCBiZmRfdgogCiAvKiBCdWls ZCB0aGUgaW5zdHJ1Y3Rpb24ncyBhcmd1bWVudHMuICAqLwogCi1zdGF0aWMg dm9pZAordm9pZAogbWFrZV9pbnN0cnVjdGlvbiAodm9pZCkKIHsKICAgaW50 IGk7Ci0tLSAuL2dkYl9zcmMub3JpZy9iZmQvY29uZmlnLmJmZAkyMDEyLTA1 LTE1IDE4OjI1OjM0LjAwMDAwMDAwMCArMDUzMAorKysgLi9nZGJfc3JjL2Jm ZC9jb25maWcuYmZkCTIwMTItMTAtMjMgMTU6MDk6MDguMDAwMDAwMDAwICsw NTMwCkBAIC0zNDUsNiArMzQ1LDExIEBAIGNhc2UgIiR7dGFyZ30iIGluCiAg ICAgdGFyZ191bmRlcnNjb3JlPXllcwogICAgIDs7CiAKKyAgY3IxNiotKi11 Y2xpbnV4KikKKyAgICB0YXJnX2RlZnZlYz1iZmRfZWxmMzJfY3IxNl92ZWMK KyAgICB0YXJnX3VuZGVyc2NvcmU9eWVzCisgICAgOzsKKwogICBjcjE2Yy0q LWVsZiopCiAgICAgdGFyZ19kZWZ2ZWM9YmZkX2VsZjMyX2NyMTZjX3ZlYwog ICAgIHRhcmdfdW5kZXJzY29yZT15ZXMKLS0tIC4vZ2RiX3NyYy5vcmlnL2lu Y2x1ZGUvb3Bjb2RlL2NyMTYuaAkyMDEwLTA0LTE1IDE1OjU2OjA5LjAwMDAw MDAwMCArMDUzMAorKysgLi9nZGJfc3JjL2luY2x1ZGUvb3Bjb2RlL2NyMTYu aAkyMDEyLTEwLTI1IDEwOjE3OjAyLjAwMDAwMDAwMCArMDUzMApAQCAtNDM1 LDQgKzQzNSwxNyBAQCBleHRlcm4gY29uc3QgaW5zdCAqaW5zdHJ1Y3Rpb247 CiB0eXBlZGVmIGxvbmcgbG9uZyBpbnQgTE9OR0xPTkc7CiB0eXBlZGVmIHVu c2lnbmVkIGxvbmcgbG9uZyBVTE9OR0xPTkc7CiAKKy8qIERhdGEgdHlwZXMg Zm9yIG9wY29kZSBoYW5kbGluZy4gICovCit0eXBlZGVmIHVuc2lnbmVkIGxv bmcgZHdvcmRVOwordHlwZWRlZiB1bnNpZ25lZCBzaG9ydCB3b3JkVTsKKwor LyogR2xvYmFscyB0byBzdG9yZSBvcGNvZGUgZGF0YSBhbmQgYnVpbGQgdGhl IGludHJ1Y3Rpb24uICAqLworZXh0ZXJuIHdvcmRVIHdvcmRzWzNdOworZXh0 ZXJuIFVMT05HTE9ORyBhbGxXb3JkczsKK2V4dGVybiBpbnMgY3Vyckluc247 CisKKy8qIFByb3RvdHlwZXMgZm9yIGZ1bmN0aW9uIGluIGNyMTYtZGlzLmMg ICovCit2b2lkIG1ha2VfaW5zdHJ1Y3Rpb24gKHZvaWQpOworaW50IG1hdGNo X29wY29kZSAodm9pZCk7CisKICNlbmRpZiAvKiBfQ1IxNl9IXyAqLwo= --_003_C6CA53A2A46BA7469348BDBD663AB65845B3EB9EKCHJEXMB02kpitc_--