From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 67907 invoked by alias); 20 Mar 2017 23:21:39 -0000 Mailing-List: contact binutils-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: binutils-owner@sourceware.org Received: (qmail 67892 invoked by uid 89); 20 Mar 2017 23:21:37 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-22.6 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,RCVD_IN_DNSWL_NONE,SPF_PASS,UNSUBSCRIBE_BODY autolearn=ham version=3.3.2 spammy=UD:global, executables, Cet, UD:p X-HELO: mail-wr0-f175.google.com Received: from mail-wr0-f175.google.com (HELO mail-wr0-f175.google.com) (209.85.128.175) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 20 Mar 2017 23:21:29 +0000 Received: by mail-wr0-f175.google.com with SMTP id g10so102036385wrg.2 for ; Mon, 20 Mar 2017 16:21:29 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:from:date:message-id:subject:to; bh=eUjr2lJsyzVLZg06iYHhnzDPLN8hcqjqXwsubgomMNc=; b=XaiuUfSoN5GJ36aKqlC00lVd7PoFBgDV39GCHlt/upoFA93B2TuQ3fYc6DuJRfI6CG k+HVEqiJfQdG8vrDgKpxGY0IkO6gevCAtv3zD0URBcAipz/YkHoz7yHHOsC812YDlHdu 7S/bHMew/WUFTrge6ARkCFWobPWQP8NWyh97bJeSAi+0Ox7TkiKLqdhadL+ug5H8reCl pWGq7ghLoG6aa4CNpkyE1xWwzonJSoB5iPy1JjBRr+hSR1zb1HejGzfnOXV33iyemFXp 2SqtVy+KvBTanI9WOVXmIKJOyXdx/bpcRrtpHtTcUrAvO1xDV9bLqFeDERxHeVwm6dGb lH5A== X-Gm-Message-State: AFeK/H0h4SifOSrVv/UsxSRcM2y+sYCZPY0vSK3cDPd5MdyZEKgCTMJpOb9kjulSlWB6W7OxmlV0SWhZbnJm3w== X-Received: by 10.223.170.73 with SMTP id q9mr27400285wrd.13.1490052086381; Mon, 20 Mar 2017 16:21:26 -0700 (PDT) MIME-Version: 1.0 Received: by 10.80.195.15 with HTTP; Mon, 20 Mar 2017 16:20:45 -0700 (PDT) From: Pip Cet Date: Mon, 20 Mar 2017 23:21:00 -0000 Message-ID: Subject: [PATCH] [WebAssembly] Skeleton support To: binutils@sourceware.org Content-Type: multipart/mixed; boundary=94eb2c1cc6024eb3d0054b31c948 X-IsSubscribed: yes X-SW-Source: 2017-03/txt/msg00286.txt.bz2 --94eb2c1cc6024eb3d0054b31c948 Content-Type: text/plain; charset=UTF-8 Content-length: 35861 This patch adds skeleton support for the WebAssembly architecture; BFD constants, new (mostly empty) files, and a single substantial file, bfd/wasm-module.c, which is a first attempt at a backend for WebAssembly modules (files beginning with "\0asm"). If config.sub is updated to today's GNU version, "./configure --target=wasm32-unknown-none --disable-gdb --enable-maintainer-mode --disable-gas --disable-ld --disable-opcodes && make" succeeds and the produced "nm" binary can read names/symbols from WebAssembly modules. Obviously this isn't yet very useful, but I figured I had to start somewhere. This is my first patch, so any advice or criticism that may help me when it comes to future patches would be most welcome. Thanks Pip Cet ------ bfd/ChangeLog | 15 + bfd/Makefile.am | 2 + bfd/Makefile.in | 3 + bfd/archures.c | 4 + bfd/bfd-in2.h | 2 + bfd/config.bfd | 6 + bfd/configure | 2 + bfd/configure.ac | 2 + bfd/cpu-wasm32.c | 36 ++ bfd/doc/webassembly.texi | 29 ++ bfd/elf32-wasm32.c | 52 ++ bfd/po/SRC-POTFILES.in | 1 + bfd/targets.c | 2 + bfd/wasm-module.c | 814 +++++++++++++++++++++++++++++++ include/ChangeLog | 4 + include/elf/wasm32.h | 28 ++ diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 50e76c2dea..8ba59fe27e 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,18 @@ +2017-03-20 Pip Cet + + * Makefile.am: Add WebAssembly architecture. + * configure.ac: Likewise. + * targets.c: Likewise. + * config.bfd (targ_cpu): Likewise. + * archures.c: Likewise. + * cpu-wasm32.c: New file to support WebAssembly architecture. + * elf32-wasm32.c: Likewise. + * wasm-module.c: Initial backend for WebAssembly modules. + * doc/webassembly.texi: Start documentation for wasm-module.c. + * bfd-in2.h: Regenerate. + * Makefile.in: Regenerate. + * configure: Regenerate. + 2017-03-20 Alan Modra PR 21266 diff --git a/bfd/Makefile.am b/bfd/Makefile.am index 0b0226306f..e3b536460e 100644 --- a/bfd/Makefile.am +++ b/bfd/Makefile.am @@ -169,6 +169,7 @@ ALL_MACHINES = \ cpu-vax.lo \ cpu-visium.lo \ cpu-w65.lo \ + cpu-wasm32.lo \ cpu-we32k.lo \ cpu-xc16x.lo \ cpu-xgate.lo \ @@ -257,6 +258,7 @@ ALL_MACHINES_CFILES = \ cpu-v850_rh850.c \ cpu-vax.c \ cpu-visium.c \ + cpu-wasm32.c \ cpu-w65.c \ cpu-we32k.c \ cpu-xc16x.c \ diff --git a/bfd/Makefile.in b/bfd/Makefile.in index 096c7ef043..76446ce7c0 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -502,6 +502,7 @@ ALL_MACHINES = \ cpu-vax.lo \ cpu-visium.lo \ cpu-w65.lo \ + cpu-wasm32.lo \ cpu-we32k.lo \ cpu-xc16x.lo \ cpu-xgate.lo \ @@ -590,6 +591,7 @@ ALL_MACHINES_CFILES = \ cpu-v850_rh850.c \ cpu-vax.c \ cpu-visium.c \ + cpu-wasm32.c \ cpu-w65.c \ cpu-we32k.c \ cpu-xc16x.c \ @@ -1446,6 +1448,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-vax.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-visium.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-w65.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-wasm32.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-we32k.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-xc16x.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-xgate.Plo@am__quote@ diff --git a/bfd/archures.c b/bfd/archures.c index c909db012d..dcf9be30b1 100644 --- a/bfd/archures.c +++ b/bfd/archures.c @@ -528,6 +528,8 @@ DESCRIPTION .#define bfd_mach_nios2r2 2 . bfd_arch_visium, {* Visium *} .#define bfd_mach_visium 1 +. bfd_arch_wasm32, +.#define bfd_mach_wasm32 1 . bfd_arch_pru, {* PRU *} .#define bfd_mach_pru 0 . bfd_arch_last @@ -654,6 +656,7 @@ extern const bfd_arch_info_type bfd_v850_arch; extern const bfd_arch_info_type bfd_v850_rh850_arch; extern const bfd_arch_info_type bfd_vax_arch; extern const bfd_arch_info_type bfd_visium_arch; +extern const bfd_arch_info_type bfd_wasm32_arch; extern const bfd_arch_info_type bfd_w65_arch; extern const bfd_arch_info_type bfd_we32k_arch; extern const bfd_arch_info_type bfd_xstormy16_arch; @@ -746,6 +749,7 @@ static const bfd_arch_info_type * const bfd_archures_list[] = &bfd_vax_arch, &bfd_visium_arch, &bfd_w65_arch, + &bfd_wasm32_arch, &bfd_we32k_arch, &bfd_xstormy16_arch, &bfd_xtensa_arch, diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h index 59403af698..432caafd32 100644 --- a/bfd/bfd-in2.h +++ b/bfd/bfd-in2.h @@ -2372,6 +2372,8 @@ enum bfd_architecture #define bfd_mach_nios2r2 2 bfd_arch_visium, /* Visium */ #define bfd_mach_visium 1 + bfd_arch_wasm32, +#define bfd_mach_wasm32 1 bfd_arch_pru, /* PRU */ #define bfd_mach_pru 0 bfd_arch_last diff --git a/bfd/config.bfd b/bfd/config.bfd index 52db9a47f1..1235c2cb86 100644 --- a/bfd/config.bfd +++ b/bfd/config.bfd @@ -197,6 +197,7 @@ tilegx*) targ_archs=bfd_tilegx_arch ;; tilepro*) targ_archs=bfd_tilepro_arch ;; v850*) targ_archs="bfd_v850_arch bfd_v850_rh850_arch" ;; visium*) targ_archs=bfd_visium_arch ;; +wasm32) targ_archs=bfd_wasm32_arch ;; x86_64*) targ_archs=bfd_i386_arch ;; xtensa*) targ_archs=bfd_xtensa_arch ;; xgate) targ_archs=bfd_xgate_arch ;; @@ -1793,6 +1794,11 @@ case "${targ}" in targ_defvec=visium_elf32_vec ;; + wasm32-*-*) + targ_defvec=wasm32_elf32_vec + targ_selvecs="wasm_vec" + ;; + we32k-*-*) targ_defvec=we32k_coff_vec ;; diff --git a/bfd/configure b/bfd/configure index 83256d25df..7cae4ae3d8 100755 --- a/bfd/configure +++ b/bfd/configure @@ -14569,6 +14569,8 @@ do ft32_elf32_vec) tb="$tb elf32-ft32.lo elf32.lo $elf" ;; visium_elf32_vec) tb="$tb elf32-visium.lo elf32.lo $elf" ;; w65_coff_vec) tb="$tb coff-w65.lo reloc16.lo $coffgen" ;; + wasm_vec) tb="$tb wasm-module.lo" ;; + wasm32_elf32_vec) tb="$tb elf32-wasm32.lo elf32.lo $elf" ;; we32k_coff_vec) tb="$tb coff-we32k.lo $coffgen" ;; x86_64_coff_vec) tb="$tb coff-x86_64.lo $coff"; target_size=64 ;; x86_64_elf32_vec) tb="$tb elf64-x86-64.lo elf-ifunc.lo elf-nacl.lo elf64.lo elf32.lo $elf"; target_size=64 ;; diff --git a/bfd/configure.ac b/bfd/configure.ac index ee0c537ea2..feb1231c91 100644 --- a/bfd/configure.ac +++ b/bfd/configure.ac @@ -700,6 +700,8 @@ do ft32_elf32_vec) tb="$tb elf32-ft32.lo elf32.lo $elf" ;; visium_elf32_vec) tb="$tb elf32-visium.lo elf32.lo $elf" ;; w65_coff_vec) tb="$tb coff-w65.lo reloc16.lo $coffgen" ;; + wasm_vec) tb="$tb wasm-module.lo" ;; + wasm32_elf32_vec) tb="$tb elf32-wasm32.lo elf32.lo $elf" ;; we32k_coff_vec) tb="$tb coff-we32k.lo $coffgen" ;; x86_64_coff_vec) tb="$tb coff-x86_64.lo $coff"; target_size=64 ;; x86_64_elf32_vec) tb="$tb elf64-x86-64.lo elf-ifunc.lo elf-nacl.lo elf64.lo elf32.lo $elf"; target_size=64 ;; diff --git a/bfd/cpu-wasm32.c b/bfd/cpu-wasm32.c new file mode 100644 index 0000000000..929778d531 --- /dev/null +++ b/bfd/cpu-wasm32.c @@ -0,0 +1,36 @@ +/* BFD support for the WebAssembly target + Copyright (C) 1994-2017 Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + 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, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +#include "sysdep.h" +#include "bfd.h" +#include "libbfd.h" +#include "libiberty.h" + +#define N(number, print, default, next) \ +{ 32, 32, 8, bfd_arch_wasm32, number, "wasm32", "wasm32", 4, default, bfd_default_compatible, \ + bfd_default_scan, bfd_arch_default_fill, next } + +static const bfd_arch_info_type arch_info_struct[] = +{ + N (bfd_mach_wasm32, "wasm32", TRUE, NULL) +}; + +const bfd_arch_info_type bfd_wasm32_arch = + N (bfd_mach_wasm32, "wasm32", TRUE, & arch_info_struct[0]); diff --git a/bfd/doc/webassembly.texi b/bfd/doc/webassembly.texi new file mode 100644 index 0000000000..25aeb5d614 --- /dev/null +++ b/bfd/doc/webassembly.texi @@ -0,0 +1,29 @@ +@section WebAssembly backend +The WebAssembly module file format, at present, is a very simple +object file format with up to 11 numbered sections plus named +``custom'' sections. At present, there is no standard for +relocations or symbols, though a @code{"name"} subsection can assign +names to function indices and local variables. + +As such, it offers no real advantages over ELF, and intermediate ELF +files can be used to produce WebAssembly modules. The WebAssembly +backend aims to enable the opposite: reading a WebAssembly module and +producing an ELF file containing the same information, which can then +be manipulated and inspected with standard tools. + +When writing WebAssembly modules, the WebAssembly backend attempts to +determine based on the section name whether to use a numeric section +id, a named section header, or to include the section verbatim, +assuming it already contains any necessary header. + +Function names are supported as symbols; local names and WebAssembly +relocation sections are currently unsupported. + +@menu +* File layout:: +@end menu + +@node File layout, WebAssembly +@subsection File layout +For a description of the WebAssembly file format, see +@url{https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md}. diff --git a/bfd/elf32-wasm32.c b/bfd/elf32-wasm32.c new file mode 100644 index 0000000000..cb56acab00 --- /dev/null +++ b/bfd/elf32-wasm32.c @@ -0,0 +1,52 @@ +/* 32-bit ELF for the WebAssembly target + Copyright (C) 1999-2017 Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + 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, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, + Boston, MA 02110-1301, USA. */ + +#include "sysdep.h" +#include "bfd.h" +#include "libbfd.h" +#include "elf-bfd.h" +#include "bfd_stdint.h" +#include "elf/wasm32.h" + +#define ELF_ARCH bfd_arch_wasm32 +#define ELF_TARGET_ID 0x4157 /* 'WA' */ +#define ELF_MACHINE_CODE 0x4157 /* 'WA' */ +/* FIXME we don't have paged executables, see + * https://github.com/pipcet/binutils-gdb/issues/4 */ +#define ELF_MAXPAGESIZE 4096 + +#define TARGET_LITTLE_SYM wasm32_elf32_vec +#define TARGET_LITTLE_NAME "elf32-wasm32" + +#define elf_backend_can_gc_sections 1 +#define elf_backend_rela_normal 1 +/* For testing. */ +#define elf_backend_want_dynrelro 1 + +#define bfd_elf32_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup +#define bfd_elf32_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup + +#define ELF_DYNAMIC_INTERPRETER "/sbin/elf-dynamic-interpreter.so" + +#define elf_backend_want_got_plt 1 +#define elf_backend_plt_readonly 1 +#define elf_backend_got_header_size 0 + +#include "elf32-target.h" diff --git a/bfd/po/SRC-POTFILES.in b/bfd/po/SRC-POTFILES.in index 7ecdb0a11f..bf45ca8e1a 100644 --- a/bfd/po/SRC-POTFILES.in +++ b/bfd/po/SRC-POTFILES.in @@ -141,6 +141,7 @@ cpu-v850_rh850.c cpu-vax.c cpu-visium.c cpu-w65.c +cpu-wasm32.c cpu-we32k.c cpu-xc16x.c cpu-xgate.c diff --git a/bfd/targets.c b/bfd/targets.c index 1a7c6b87d6..f9074b6ae5 100644 --- a/bfd/targets.c +++ b/bfd/targets.c @@ -893,6 +893,8 @@ extern const bfd_target vax_aout_nbsd_vec; extern const bfd_target vax_elf32_vec; extern const bfd_target visium_elf32_vec; extern const bfd_target w65_coff_vec; +extern const bfd_target wasm_vec; +extern const bfd_target wasm32_elf32_vec; extern const bfd_target we32k_coff_vec; extern const bfd_target x86_64_coff_vec; extern const bfd_target x86_64_elf32_vec; diff --git a/bfd/wasm-module.c b/bfd/wasm-module.c new file mode 100644 index 0000000000..f8d78b1d73 --- /dev/null +++ b/bfd/wasm-module.c @@ -0,0 +1,814 @@ +/* BFD back-end for WebAssembly modules. + Copyright (C) 1990-2017 Free Software Foundation, Inc. + + Based on srec.c, mmo.c, and binary.c + + This file is part of BFD, the Binary File Descriptor library. + + 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, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +/* The WebAssembly module format is a simple object file format + * including up to 11 numbered sections, plus any number of named + * "custom" sections. It is described at + * https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md. */ + +#include "sysdep.h" +#include "alloca-conf.h" +#include "bfd.h" +#include "sysdep.h" +#include +#include "bfd_stdint.h" +#include "libiberty.h" +#include "libbfd.h" + +/* From elf-eh-frame.c: */ +/* If *ITER hasn't reached END yet, read the next byte into *RESULT and + move onto the next byte. Return true on success. */ + +static inline bfd_boolean +read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result) +{ + if (*iter >= end) + return FALSE; + *result = *((*iter)++); + return TRUE; +} + +/* Move *ITER over LENGTH bytes, or up to END, whichever is closer. + Return true it was possible to move LENGTH bytes. */ + +static inline bfd_boolean +skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length) +{ + if ((bfd_size_type) (end - *iter) < length) + { + *iter = end; + return FALSE; + } + *iter += length; + return TRUE; +} + +/* Move *ITER over an leb128, stopping at END. Return true if the end + of the leb128 was found. */ + +static bfd_boolean +skip_leb128 (bfd_byte **iter, bfd_byte *end) +{ + unsigned char byte; + do + if (!read_byte (iter, end, &byte)) + return FALSE; + while (byte & 0x80); + return TRUE; +} + +/* Like skip_leb128, but treat the leb128 as an unsigned value and + store it in *VALUE. */ + +static bfd_boolean +read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value) +{ + bfd_byte *start, *p; + + start = *iter; + if (!skip_leb128 (iter, end)) + return FALSE; + + p = *iter; + *value = *--p; + while (p > start) + *value = (*value << 7) | (*--p & 0x7f); + + return TRUE; +} + +static bfd_vma +wasm_get_uleb128 (bfd* abfd, bfd_boolean* error) +{ + bfd_byte byte; + bfd_vma value = 0; + int shift = 0; + + do + { + if (bfd_bread (&byte, 1, abfd) != 1) + goto error_return; + + value += (byte & 0x7f) << shift; + + shift += 7; + } + while (byte & 0x80); + + return value; + + error_return: + *error = TRUE; + return (bfd_vma)-1; +} + +static bfd_boolean +bfd_write_uleb128 (bfd *abfd, bfd_vma v) +{ + do + { + bfd_byte c = v & 0x7f; + v >>= 7; + + if (v) + c |= 0x80; + + if (bfd_bwrite (&c, 1, abfd) != 1) + return FALSE; + } + while (v); + + return TRUE; +} + +typedef struct +{ + asymbol *symbols; + bfd_size_type symcount; +} tdata_type; + +static bfd_boolean +wasm_get_magic (bfd *abfd, bfd_boolean *errorptr) +{ + bfd_byte magic[4]; + if (bfd_bread (magic, (bfd_size_type) 4, abfd) != 4) + { + if (bfd_get_error () != bfd_error_file_truncated) + *errorptr = TRUE; + return FALSE; + } + + if (magic[0] != 0 || + magic[1] != 'a' || + magic[2] != 's' || + magic[3] != 'm') + { + *errorptr = TRUE; + return FALSE; + } + + return TRUE; +} + +static int +wasm_get_byte (bfd *abfd, bfd_boolean *errorptr) +{ + bfd_byte byte; + if (bfd_bread (&byte, (bfd_size_type) 1, abfd) != 1) + { + if (bfd_get_error () != bfd_error_file_truncated) + *errorptr = TRUE; + return EOF; + } + + return byte; +} + +static bfd_boolean +wasm_get_version (bfd *abfd, bfd_boolean *errorptr) +{ + bfd_byte vers[4]; + if (bfd_bread (vers, (bfd_size_type) 4, abfd) != 4) + { + *errorptr = TRUE; + return FALSE; + } + + /* Don't attempt to parse newer versions, which are likely to + * require code changes. */ + if (vers[0] != 1 || vers[1] || vers[2] || vers[3]) + return FALSE; + + return TRUE; +} + +#define WASM_NUMBERED_SECTIONS 11 + +static const char * +wasm_section_code_to_name (bfd_byte section_code) +{ + switch (section_code) { + case 1: + return ".wasm.type"; + case 2: + return ".wasm.import"; + case 3: + return ".wasm.function"; + case 4: + return ".wasm.table"; + case 5: + return ".wasm.memory"; + case 6: + return ".wasm.global"; + case 7: + return ".wasm.export"; + case 8: + return ".wasm.start"; + case 9: + return ".wasm.element"; + case 10: + return ".wasm.code"; + case 11: + return ".wasm.data"; + } + + return NULL; +} + +static int +wasm_section_name_to_code (const char *name) +{ + if (strcmp (name, ".wasm.type") == 0) + return 1; + if (strcmp (name, ".wasm.import") == 0) + return 2; + if (strcmp (name, ".wasm.function") == 0) + return 3; + if (strcmp (name, ".wasm.table") == 0) + return 4; + if (strcmp (name, ".wasm.memory") == 0) + return 5; + if (strcmp (name, ".wasm.global") == 0) + return 6; + if (strcmp (name, ".wasm.export") == 0) + return 7; + if (strcmp (name, ".wasm.start") == 0) + return 8; + if (strcmp (name, ".wasm.element") == 0) + return 9; + if (strcmp (name, ".wasm.code") == 0) + return 10; + if (strcmp (name, ".wasm.data") == 0) + return 11; + + return -1; +} + +static bfd_boolean +bfd_wasm_read_header (bfd *abfd, bfd_boolean *error) +{ + if (!wasm_get_magic (abfd, error)) + goto error_return; + + if (!wasm_get_version (abfd, error)) + goto error_return; + + return TRUE; + + error_return: + return FALSE; +} + +static bfd_boolean +wasm_scan_name_function_section (bfd *abfd, sec_ptr asect, + void *data ATTRIBUTE_UNUSED) +{ + if (!asect) + return FALSE; + + if (strcmp (asect->name, ".wasm.name") != 0) + return FALSE; + + bfd_byte *p = asect->contents; + bfd_byte *end = asect->contents + asect->size; + + while (p && p < end) + { + if (*p++ == 1) + break; + bfd_vma payload_size; + if (!read_uleb128 (&p, end, &payload_size)) + return FALSE; + + p += payload_size; + } + + if (!p || p >= end) + return FALSE; + + bfd_vma payload_size; + if (!read_uleb128 (&p, end, &payload_size)) + return FALSE; + + if (p + payload_size > end) + return FALSE; + + end = p + payload_size; + + bfd_vma symcount = 0; + if (!read_uleb128 (&p, end, &symcount)) + return FALSE; + + tdata_type *tdata = abfd->tdata.any; + tdata->symcount = symcount; + symcount = 0; + + bfd_size_type sym_allocated = 0; + asymbol *symbols = NULL; + sec_ptr space_function_index = bfd_make_section_with_flags (abfd, ".space.function_index", SEC_READONLY | SEC_CODE); + if (!space_function_index) + space_function_index = bfd_get_section_by_name (abfd, ".space.function_index"); + + for (bfd_vma i = 0; p < end && i < tdata->symcount; i++) + { + bfd_vma index; + bfd_vma len; + char *name; + + if (!read_uleb128 (&p, end, &index) || + !read_uleb128 (&p, end, &len)) + return FALSE; + + name = bfd_alloc (abfd, len + 1); + + name[len] = 0; + + memcpy (name, p, len); + + p += len; + + if (symcount == sym_allocated) + { + sym_allocated *= 2; + if (sym_allocated == 0) + sym_allocated = 512; + + symbols = bfd_realloc (symbols, sym_allocated * sizeof (asymbol)); + } + + asymbol *sym = &symbols[symcount++]; + sym->the_bfd = abfd; + sym->name = name; + sym->value = index; + sym->flags = BSF_GLOBAL | BSF_FUNCTION; + sym->section = space_function_index; + sym->udata.p = NULL; + } + + tdata->symbols = symbols; + tdata->symcount = symcount; + abfd->symcount = symcount; + + return TRUE; +} + +static bfd_boolean +wasm_scan (bfd *abfd) +{ + bfd_boolean error = FALSE; + bfd_vma vma = 0x80000000; + int section_code; + + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) + goto error_return; + + if (!bfd_wasm_read_header (abfd, &error)) + goto error_return; + + while ((section_code = wasm_get_byte (abfd, &error)) != EOF) + { + asection *bfdsec; + if (section_code) + { + const char *name = wasm_section_code_to_name (section_code); + char *secname; + + if (!name) + goto error_return; + + secname = strdup (name); + + bfdsec = bfd_make_section_anyway_with_flags (abfd, secname, SEC_HAS_CONTENTS); + if (bfdsec == NULL) + goto error_return; + + bfdsec->vma = vma; + bfdsec->lma = vma; + bfdsec->size = wasm_get_uleb128 (abfd, &error); + bfdsec->filepos = bfd_tell (abfd); + bfdsec->alignment_power = 0; + } + else + { + bfd_vma payload_len = wasm_get_uleb128 (abfd, &error); + file_ptr section_start = bfd_tell (abfd); + bfd_vma namelen = wasm_get_uleb128 (abfd, &error); + if (namelen == (bfd_vma)-1) + goto error_return; + char *name = bfd_zalloc (abfd, namelen+1); + name[namelen] = 0; + if (bfd_bread (name, namelen, abfd) != namelen) + goto error_return; + + char *secname; + asprintf (&secname, ".wasm.%s", name); + + bfdsec = bfd_make_section_anyway_with_flags (abfd, secname, SEC_HAS_CONTENTS); + if (bfdsec == NULL) + goto error_return; + + bfdsec->vma = vma; + bfdsec->lma = vma; + bfdsec->size = payload_len - bfd_tell (abfd) + section_start; + bfdsec->filepos = bfd_tell (abfd); + bfdsec->alignment_power = 0; + } + + bfdsec->contents = bfd_zalloc (abfd, bfdsec->size); + if (bfdsec->size && !bfdsec->contents) + goto error_return; + + if (bfd_bread (bfdsec->contents, bfdsec->size, abfd) != bfdsec->size) + goto error_return; + + vma += bfdsec->size; + } + + /* Make sure we're at actual EOF. There's no indication in the + * WebAssembly format of how long the file is supposed to be. */ + if (error) + goto error_return; + + if (!wasm_scan_name_function_section (abfd, bfd_get_section_by_name (abfd, ".wasm.name"), NULL)) + return TRUE; + + return TRUE; + + error_return: + return FALSE; +} + +static void +wasm_register_section (bfd *abfd ATTRIBUTE_UNUSED, + asection *asect, void *fsarg) +{ + sec_ptr *numbered_sections = fsarg; + int index = wasm_section_name_to_code (asect->name); + + if (index == -1) + return; + + numbered_sections[index] = asect; +} + +struct compute_section_arg +{ + bfd_vma pos; + bfd_boolean failed; +}; + +static void +wasm_compute_custom_section_file_position (bfd *abfd, sec_ptr asect, + void *fsarg) +{ + struct compute_section_arg *fs = fsarg; + + if (fs->failed) + return; + + int index = wasm_section_name_to_code (asect->name); + + if (index != -1) + return; + + if (CONST_STRNEQ (asect->name, ".wasm.")) + { + const char *name = asect->name + strlen (".wasm."); + bfd_size_type payload_len = asect->size; + bfd_size_type name_len = strlen (name); + bfd_size_type nl = name_len; + + payload_len += name_len; + + do + { + payload_len++; + nl >>= 7; + } + while (nl); + + bfd_seek (abfd, fs->pos, SEEK_SET); + if (!bfd_write_uleb128 (abfd, 0) || + !bfd_write_uleb128 (abfd, payload_len) || + !bfd_write_uleb128 (abfd, name_len) || + bfd_bwrite (name, name_len, abfd) != name_len) + goto error_return; + fs->pos = asect->filepos = bfd_tell (abfd); + } + else + { + asect->filepos = fs->pos; + } + + + fs->pos += asect->size; + + return; + + error_return: + fs->failed = TRUE; + return; +} + +static bfd_boolean +wasm_compute_section_file_positions (bfd *abfd) +{ + bfd_byte magic[] = { 0x00, 'a', 's', 'm' }; + bfd_byte vers[] = { 0x01, 0x00, 0x00, 0x00 }; + + bfd_seek (abfd, (bfd_vma)0, SEEK_SET); + + if (bfd_bwrite (magic, 4, abfd) != 4 || + bfd_bwrite (vers, 4, abfd) != 4) + return FALSE; + + sec_ptr numbered_sections[WASM_NUMBERED_SECTIONS+1]; + + for (int i = 0; i <= WASM_NUMBERED_SECTIONS; i++) + numbered_sections[i] = 0; + + bfd_map_over_sections (abfd, wasm_register_section, numbered_sections); + + struct compute_section_arg fs; + fs.pos = 8; + for (int i = 0; i <= WASM_NUMBERED_SECTIONS; i++) + { + sec_ptr sec = numbered_sections[i]; + if (!sec) + continue; + bfd_seek (abfd, fs.pos, SEEK_SET); + bfd_size_type size = sec->size; + if (!bfd_write_uleb128 (abfd, i) || + !bfd_write_uleb128 (abfd, size)) + return FALSE; + fs.pos = sec->filepos = bfd_tell (abfd); + fs.pos += size; + } + + fs.failed = FALSE; + + bfd_map_over_sections (abfd, wasm_compute_custom_section_file_position, &fs); + + if (fs.failed) + return FALSE; + + return TRUE; +} + + +static bfd_boolean +wasm_set_section_contents (bfd *abfd, + sec_ptr section, + const void *location, + file_ptr offset, + bfd_size_type count) +{ + if (count == 0) + return TRUE; + + if (!abfd->output_has_begun && + !wasm_compute_section_file_positions (abfd)) + return FALSE; + + if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 + || bfd_bwrite (location, count, abfd) != count) + return FALSE; + + return TRUE; +} + +static bfd_boolean +_bfd_wasm_write_object_contents (bfd* abfd) +{ + bfd_byte magic[] = { 0x00, 'a', 's', 'm' }; + bfd_byte vers[] = { 0x01, 0x00, 0x00, 0x00 }; + + if (bfd_seek (abfd, 0, SEEK_SET) != 0) + return FALSE; + + if (bfd_bwrite (magic, 4, abfd) != 4 || + bfd_bwrite (vers, 4, abfd) != 4) + return FALSE; + + return TRUE; +} + +static bfd_boolean +wasm_mkobject (bfd *abfd) +{ + tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type)); + + if (!tdata) + return FALSE; + + tdata->symbols = NULL; + tdata->symcount = 0; + + abfd->tdata.any = tdata; + + return TRUE; +} + +static int +wasm_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info ATTRIBUTE_UNUSED) +{ + return 8; +} + +static long +wasm_get_symtab_upper_bound (bfd *abfd) +{ + tdata_type *tdata = abfd->tdata.any; + + return (tdata->symcount + 1) * (sizeof (asymbol)); +} + +static long +wasm_canonicalize_symtab (bfd *abfd, asymbol **alocation) +{ + tdata_type *tdata = abfd->tdata.any; + size_t i; + + for (i = 0; i < tdata->symcount; i++) + alocation[i] = &tdata->symbols[i]; + alocation[i] = NULL; + + return tdata->symcount; +} + +static asymbol * +wasm_make_empty_symbol (bfd *abfd) +{ + bfd_size_type amt = sizeof (asymbol); + asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt); + + if (!new_symbol) + return NULL; + new_symbol->the_bfd = abfd; + return new_symbol; +} + +static void +wasm_print_symbol (bfd *abfd, + void * filep, + asymbol *symbol, + bfd_print_symbol_type how) +{ + FILE *file = (FILE *) filep; + + switch (how) + { + case bfd_print_symbol_name: + fprintf (file, "%s", symbol->name); + break; + + default: + bfd_print_symbol_vandf (abfd, filep, symbol); + fprintf (file, " %-5s %s", symbol->section->name, symbol->name); + } +} + +static void +wasm_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, + asymbol *symbol, + symbol_info *ret) +{ + bfd_symbol_info (symbol, ret); +} + +static const bfd_target * +wasm_object_p (bfd *abfd) +{ + bfd_byte b[8]; + + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 + || bfd_bread (b, (bfd_size_type) 8, abfd) != 8) + return NULL; + + if (b[0] != 0 || b[1] != 'a' || b[2] != 's' || b[3] != 'm' || + b[4] != 1 || b[5] != 0 || b[6] != 0 || b[7] != 0) + { + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + if (! wasm_mkobject (abfd) || ! wasm_scan (abfd)) + return NULL; + + if (! bfd_default_set_arch_mach (abfd, bfd_arch_wasm32, 0)) + return NULL; + + if (abfd->symcount > 0) + abfd->flags |= HAS_SYMS; + + return abfd->xvec; +} + +/* BFD_JUMP_TABLE_WRITE */ +#define wasm_set_arch_mach _bfd_generic_set_arch_mach + +/* BFD_JUMP_TABLE_SYMBOLS */ +#define wasm_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string +#define wasm_bfd_is_local_label_name bfd_generic_is_local_label_name +#define wasm_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) +#define wasm_get_lineno _bfd_nosymbols_get_lineno +#define wasm_find_nearest_line _bfd_nosymbols_find_nearest_line +#define wasm_find_line _bfd_nosymbols_find_line +#define wasm_find_inliner_info _bfd_nosymbols_find_inliner_info +#define wasm_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol +#define wasm_read_minisymbols _bfd_generic_read_minisymbols +#define wasm_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol + +/* BFD_JUMP_TABLE_LINK */ +#define wasm_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents +#define wasm_bfd_relax_section bfd_generic_relax_section +#define wasm_bfd_gc_sections bfd_generic_gc_sections +#define wasm_bfd_lookup_section_flags bfd_generic_lookup_section_flags +#define wasm_bfd_merge_sections bfd_generic_merge_sections +#define wasm_bfd_is_group_section bfd_generic_is_group_section +#define wasm_bfd_discard_group bfd_generic_discard_group +#define wasm_bfd_link_hash_table_create _bfd_generic_link_hash_table_create +#define wasm_bfd_link_add_symbols _bfd_generic_link_add_symbols +#define wasm_bfd_link_just_syms _bfd_generic_link_just_syms +#define wasm_bfd_copy_link_hash_symbol_type _bfd_generic_copy_link_hash_symbol_type +#define wasm_bfd_final_link _bfd_generic_final_link +#define wasm_bfd_link_split_section _bfd_generic_link_split_section +#define wasm_section_already_linked _bfd_generic_section_already_linked +#define wasm_bfd_define_common_symbol bfd_generic_define_common_symbol +#define wasm_bfd_link_check_relocs _bfd_generic_link_check_relocs + +const bfd_target wasm_vec = +{ + "wasm", /* Name */ + bfd_target_unknown_flavour, + BFD_ENDIAN_LITTLE, + BFD_ENDIAN_LITTLE, + (HAS_SYMS | WP_TEXT), /* Object flags. */ + (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS), /* Section flags */ + 0, /* Leading underscore */ + ' ', /* AR_pad_char */ + 255, /* AR_max_namelen */ + 0, /* match priority. */ + /* Routines to byte-swap various sized integers from the data sections */ + bfd_getl64, bfd_getl_signed_64, bfd_putl64, + bfd_getl32, bfd_getl_signed_32, bfd_putl32, + bfd_getl16, bfd_getl_signed_16, bfd_putl16, + + /* Routines to byte-swap various sized integers from the file headers */ + bfd_getl64, bfd_getl_signed_64, bfd_putl64, + bfd_getl32, bfd_getl_signed_32, bfd_putl32, + bfd_getl16, bfd_getl_signed_16, bfd_putl16, + + { + _bfd_dummy_target, + wasm_object_p, /* bfd_check_format. */ + _bfd_dummy_target, + _bfd_dummy_target, + }, + { + bfd_false, + wasm_mkobject, + _bfd_generic_mkarchive, + bfd_false, + }, + { /* bfd_write_contents. */ + bfd_false, + _bfd_wasm_write_object_contents, + _bfd_write_archive_contents, + bfd_false, + }, + + BFD_JUMP_TABLE_GENERIC (_bfd_generic), + BFD_JUMP_TABLE_COPY (_bfd_generic), + BFD_JUMP_TABLE_CORE (_bfd_nocore), + BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), + BFD_JUMP_TABLE_SYMBOLS (wasm), + BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), + BFD_JUMP_TABLE_WRITE (wasm), + BFD_JUMP_TABLE_LINK (wasm), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + + NULL, + + NULL, +}; diff --git a/include/ChangeLog b/include/ChangeLog index eacfeb9ac9..dc467fd384 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,7 @@ +2017-03-20 Pip Cet + + * elf/wasm32.h: New file to support WebAssembly architecture. + 2017-03-16 Nick Clifton * elf/common.h (GNU_BUILD_ATTRIBUTE_SHORT_ENUM): New GNU BUILD diff --git a/include/elf/wasm32.h b/include/elf/wasm32.h new file mode 100644 index 0000000000..4edd66fa8c --- /dev/null +++ b/include/elf/wasm32.h @@ -0,0 +1,28 @@ +/* ELF support for BFD for the WebAssembly target + Copyright (C) 1998-2017 Free Software Foundation, Inc. + + 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, write to the Free Software Foundation, + Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + +#ifndef _ELF_WASM32_H +#define _ELF_WASM32_H + +#include "elf/reloc-macros.h" + +/* Relocation types. */ + +START_RELOC_NUMBERS (elf_wasm32_reloc_type) +END_RELOC_NUMBERS (R_WASM32_max = 1) + +#endif /* _ELF_WASM32_H */ --94eb2c1cc6024eb3d0054b31c948 Content-Type: text/plain; charset=US-ASCII; name="binutils-wasm-001.diff" Content-Disposition: attachment; filename="binutils-wasm-001.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_j0iqhrt50 Content-length: 47198 IGJmZC9DaGFuZ2VMb2cgICAgICAgICAgICAgICB8ICAxNSArCiBiZmQvTWFr ZWZpbGUuYW0gICAgICAgICAgICAgfCAgIDIgKwogYmZkL01ha2VmaWxlLmlu ICAgICAgICAgICAgIHwgICAzICsKIGJmZC9hcmNodXJlcy5jICAgICAgICAg ICAgICB8ICAgNCArCiBiZmQvYmZkLWluMi5oICAgICAgICAgICAgICAgfCAg IDIgKwogYmZkL2NvbmZpZy5iZmQgICAgICAgICAgICAgIHwgICA2ICsKIGJm ZC9jb25maWd1cmUgICAgICAgICAgICAgICB8ICAgMiArCiBiZmQvY29uZmln dXJlLmFjICAgICAgICAgICAgfCAgIDIgKwogYmZkL2NwdS13YXNtMzIuYyAg ICAgICAgICAgIHwgIDM2ICsrCiBiZmQvZG9jL3dlYmFzc2VtYmx5LnRleGkg ICAgfCAgMjkgKysKIGJmZC9lbGYzMi13YXNtMzIuYyAgICAgICAgICB8ICA1 MiArKwogYmZkL3BvL1NSQy1QT1RGSUxFUy5pbiAgICAgIHwgICAxICsKIGJm ZC90YXJnZXRzLmMgICAgICAgICAgICAgICB8ICAgMiArCiBiZmQvd2FzbS1t b2R1bGUuYyAgICAgICAgICAgfCA4MTQgKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKwogaW5jbHVkZS9DaGFuZ2VMb2cgICAgICAgICAgIHwgICA0 ICsKIGluY2x1ZGUvZWxmL3dhc20zMi5oICAgICAgICB8ICAyOCArKwoKZGlm ZiAtLWdpdCBhL2JmZC9DaGFuZ2VMb2cgYi9iZmQvQ2hhbmdlTG9nCmluZGV4 IDUwZTc2YzJkZWEuLjhiYTU5ZmUyN2UgMTAwNjQ0Ci0tLSBhL2JmZC9DaGFu Z2VMb2cKKysrIGIvYmZkL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisy MDE3LTAzLTIwICBQaXAgQ2V0ICA8cGlwY2V0QGdtYWlsLmNvbT4KKworCSog TWFrZWZpbGUuYW06IEFkZCBXZWJBc3NlbWJseSBhcmNoaXRlY3R1cmUuCisJ KiBjb25maWd1cmUuYWM6IExpa2V3aXNlLgorCSogdGFyZ2V0cy5jOiBMaWtl d2lzZS4KKwkqIGNvbmZpZy5iZmQgKHRhcmdfY3B1KTogTGlrZXdpc2UuCisJ KiBhcmNodXJlcy5jOiBMaWtld2lzZS4KKwkqIGNwdS13YXNtMzIuYzogTmV3 IGZpbGUgdG8gc3VwcG9ydCBXZWJBc3NlbWJseSBhcmNoaXRlY3R1cmUuCisJ KiBlbGYzMi13YXNtMzIuYzogTGlrZXdpc2UuCisJKiB3YXNtLW1vZHVsZS5j OiBJbml0aWFsIGJhY2tlbmQgZm9yIFdlYkFzc2VtYmx5IG1vZHVsZXMuCisJ KiBkb2Mvd2ViYXNzZW1ibHkudGV4aTogU3RhcnQgZG9jdW1lbnRhdGlvbiBm b3Igd2FzbS1tb2R1bGUuYy4KKwkqIGJmZC1pbjIuaDogUmVnZW5lcmF0ZS4K KwkqIE1ha2VmaWxlLmluOiBSZWdlbmVyYXRlLgorCSogY29uZmlndXJlOiBS ZWdlbmVyYXRlLgorCiAyMDE3LTAzLTIwICBBbGFuIE1vZHJhICA8YW1vZHJh QGdtYWlsLmNvbT4KIAogCVBSIDIxMjY2CmRpZmYgLS1naXQgYS9iZmQvTWFr ZWZpbGUuYW0gYi9iZmQvTWFrZWZpbGUuYW0KaW5kZXggMGIwMjI2MzA2Zi4u ZTNiNTM2NDYwZSAxMDA2NDQKLS0tIGEvYmZkL01ha2VmaWxlLmFtCisrKyBi L2JmZC9NYWtlZmlsZS5hbQpAQCAtMTY5LDYgKzE2OSw3IEBAIEFMTF9NQUNI SU5FUyA9IFwKIAljcHUtdmF4LmxvIFwKIAljcHUtdmlzaXVtLmxvIFwKIAlj cHUtdzY1LmxvIFwKKwljcHUtd2FzbTMyLmxvIFwKIAljcHUtd2UzMmsubG8g XAogCWNwdS14YzE2eC5sbyBcCiAJY3B1LXhnYXRlLmxvIFwKQEAgLTI1Nyw2 ICsyNTgsNyBAQCBBTExfTUFDSElORVNfQ0ZJTEVTID0gXAogCWNwdS12ODUw X3JoODUwLmMgXAogCWNwdS12YXguYyBcCiAJY3B1LXZpc2l1bS5jIFwKKwlj cHUtd2FzbTMyLmMgXAogCWNwdS13NjUuYyBcCiAJY3B1LXdlMzJrLmMgXAog CWNwdS14YzE2eC5jIFwKZGlmZiAtLWdpdCBhL2JmZC9NYWtlZmlsZS5pbiBi L2JmZC9NYWtlZmlsZS5pbgppbmRleCAwOTZjN2VmMDQzLi43NjQ0NmNlN2Mw IDEwMDY0NAotLS0gYS9iZmQvTWFrZWZpbGUuaW4KKysrIGIvYmZkL01ha2Vm aWxlLmluCkBAIC01MDIsNiArNTAyLDcgQEAgQUxMX01BQ0hJTkVTID0gXAog CWNwdS12YXgubG8gXAogCWNwdS12aXNpdW0ubG8gXAogCWNwdS13NjUubG8g XAorCWNwdS13YXNtMzIubG8gXAogCWNwdS13ZTMyay5sbyBcCiAJY3B1LXhj MTZ4LmxvIFwKIAljcHUteGdhdGUubG8gXApAQCAtNTkwLDYgKzU5MSw3IEBA IEFMTF9NQUNISU5FU19DRklMRVMgPSBcCiAJY3B1LXY4NTBfcmg4NTAuYyBc CiAJY3B1LXZheC5jIFwKIAljcHUtdmlzaXVtLmMgXAorCWNwdS13YXNtMzIu YyBcCiAJY3B1LXc2NS5jIFwKIAljcHUtd2UzMmsuYyBcCiAJY3B1LXhjMTZ4 LmMgXApAQCAtMTQ0Niw2ICsxNDQ4LDcgQEAgZGlzdGNsZWFuLWNvbXBpbGU6 CiBAQU1ERVBfVFJVRUBAYW1fX2luY2x1ZGVAIEBhbV9fcXVvdGVALi8kKERF UERJUikvY3B1LXZheC5QbG9AYW1fX3F1b3RlQAogQEFNREVQX1RSVUVAQGFt X19pbmNsdWRlQCBAYW1fX3F1b3RlQC4vJChERVBESVIpL2NwdS12aXNpdW0u UGxvQGFtX19xdW90ZUAKIEBBTURFUF9UUlVFQEBhbV9faW5jbHVkZUAgQGFt X19xdW90ZUAuLyQoREVQRElSKS9jcHUtdzY1LlBsb0BhbV9fcXVvdGVACitA QU1ERVBfVFJVRUBAYW1fX2luY2x1ZGVAIEBhbV9fcXVvdGVALi8kKERFUERJ UikvY3B1LXdhc20zMi5QbG9AYW1fX3F1b3RlQAogQEFNREVQX1RSVUVAQGFt X19pbmNsdWRlQCBAYW1fX3F1b3RlQC4vJChERVBESVIpL2NwdS13ZTMyay5Q bG9AYW1fX3F1b3RlQAogQEFNREVQX1RSVUVAQGFtX19pbmNsdWRlQCBAYW1f X3F1b3RlQC4vJChERVBESVIpL2NwdS14YzE2eC5QbG9AYW1fX3F1b3RlQAog QEFNREVQX1RSVUVAQGFtX19pbmNsdWRlQCBAYW1fX3F1b3RlQC4vJChERVBE SVIpL2NwdS14Z2F0ZS5QbG9AYW1fX3F1b3RlQApkaWZmIC0tZ2l0IGEvYmZk L2FyY2h1cmVzLmMgYi9iZmQvYXJjaHVyZXMuYwppbmRleCBjOTA5ZGIwMTJk Li5kY2Y5YmUzMGIxIDEwMDY0NAotLS0gYS9iZmQvYXJjaHVyZXMuYworKysg Yi9iZmQvYXJjaHVyZXMuYwpAQCAtNTI4LDYgKzUyOCw4IEBAIERFU0NSSVBU SU9OCiAuI2RlZmluZSBiZmRfbWFjaF9uaW9zMnIyCTIKIC4gIGJmZF9hcmNo X3Zpc2l1bSwJeyogVmlzaXVtICp9CiAuI2RlZmluZSBiZmRfbWFjaF92aXNp dW0JMQorLiAgYmZkX2FyY2hfd2FzbTMyLAorLiNkZWZpbmUgYmZkX21hY2hf d2FzbTMyICAgICAgICAxCiAuICBiZmRfYXJjaF9wcnUsCXsqIFBSVSAqfQog LiNkZWZpbmUgYmZkX21hY2hfcHJ1CTAKIC4gIGJmZF9hcmNoX2xhc3QKQEAg LTY1NCw2ICs2NTYsNyBAQCBleHRlcm4gY29uc3QgYmZkX2FyY2hfaW5mb190 eXBlIGJmZF92ODUwX2FyY2g7CiBleHRlcm4gY29uc3QgYmZkX2FyY2hfaW5m b190eXBlIGJmZF92ODUwX3JoODUwX2FyY2g7CiBleHRlcm4gY29uc3QgYmZk X2FyY2hfaW5mb190eXBlIGJmZF92YXhfYXJjaDsKIGV4dGVybiBjb25zdCBi ZmRfYXJjaF9pbmZvX3R5cGUgYmZkX3Zpc2l1bV9hcmNoOworZXh0ZXJuIGNv bnN0IGJmZF9hcmNoX2luZm9fdHlwZSBiZmRfd2FzbTMyX2FyY2g7CiBleHRl cm4gY29uc3QgYmZkX2FyY2hfaW5mb190eXBlIGJmZF93NjVfYXJjaDsKIGV4 dGVybiBjb25zdCBiZmRfYXJjaF9pbmZvX3R5cGUgYmZkX3dlMzJrX2FyY2g7 CiBleHRlcm4gY29uc3QgYmZkX2FyY2hfaW5mb190eXBlIGJmZF94c3Rvcm15 MTZfYXJjaDsKQEAgLTc0Niw2ICs3NDksNyBAQCBzdGF0aWMgY29uc3QgYmZk X2FyY2hfaW5mb190eXBlICogY29uc3QgYmZkX2FyY2h1cmVzX2xpc3RbXSA9 CiAgICAgJmJmZF92YXhfYXJjaCwKICAgICAmYmZkX3Zpc2l1bV9hcmNoLAog ICAgICZiZmRfdzY1X2FyY2gsCisgICAgJmJmZF93YXNtMzJfYXJjaCwKICAg ICAmYmZkX3dlMzJrX2FyY2gsCiAgICAgJmJmZF94c3Rvcm15MTZfYXJjaCwK ICAgICAmYmZkX3h0ZW5zYV9hcmNoLApkaWZmIC0tZ2l0IGEvYmZkL2JmZC1p bjIuaCBiL2JmZC9iZmQtaW4yLmgKaW5kZXggNTk0MDNhZjY5OC4uNDMyY2Fh ZmQzMiAxMDA2NDQKLS0tIGEvYmZkL2JmZC1pbjIuaAorKysgYi9iZmQvYmZk LWluMi5oCkBAIC0yMzcyLDYgKzIzNzIsOCBAQCBlbnVtIGJmZF9hcmNoaXRl Y3R1cmUKICNkZWZpbmUgYmZkX21hY2hfbmlvczJyMiAgICAgICAyCiAgIGJm ZF9hcmNoX3Zpc2l1bSwgICAgIC8qIFZpc2l1bSAqLwogI2RlZmluZSBiZmRf bWFjaF92aXNpdW0gICAgICAgIDEKKyAgYmZkX2FyY2hfd2FzbTMyLAorI2Rl ZmluZSBiZmRfbWFjaF93YXNtMzIgICAgICAgIDEKICAgYmZkX2FyY2hfcHJ1 LCAgICAgICAgLyogUFJVICovCiAjZGVmaW5lIGJmZF9tYWNoX3BydSAgIDAK ICAgYmZkX2FyY2hfbGFzdApkaWZmIC0tZ2l0IGEvYmZkL2NvbmZpZy5iZmQg Yi9iZmQvY29uZmlnLmJmZAppbmRleCA1MmRiOWE0N2YxLi4xMjM1YzJjYjg2 IDEwMDY0NAotLS0gYS9iZmQvY29uZmlnLmJmZAorKysgYi9iZmQvY29uZmln LmJmZApAQCAtMTk3LDYgKzE5Nyw3IEBAIHRpbGVneCopCSB0YXJnX2FyY2hz PWJmZF90aWxlZ3hfYXJjaCA7OwogdGlsZXBybyopCSB0YXJnX2FyY2hzPWJm ZF90aWxlcHJvX2FyY2ggOzsKIHY4NTAqKQkJIHRhcmdfYXJjaHM9ImJmZF92 ODUwX2FyY2ggYmZkX3Y4NTBfcmg4NTBfYXJjaCIgOzsKIHZpc2l1bSopCSB0 YXJnX2FyY2hzPWJmZF92aXNpdW1fYXJjaCA7Oword2FzbTMyKQkJIHRhcmdf YXJjaHM9YmZkX3dhc20zMl9hcmNoIDs7CiB4ODZfNjQqKQkgdGFyZ19hcmNo cz1iZmRfaTM4Nl9hcmNoIDs7CiB4dGVuc2EqKQkgdGFyZ19hcmNocz1iZmRf eHRlbnNhX2FyY2ggOzsKIHhnYXRlKQkJIHRhcmdfYXJjaHM9YmZkX3hnYXRl X2FyY2ggOzsKQEAgLTE3OTMsNiArMTc5NCwxMSBAQCBjYXNlICIke3Rhcmd9 IiBpbgogICAgIHRhcmdfZGVmdmVjPXZpc2l1bV9lbGYzMl92ZWMKICAgICA7 OwogCisgIHdhc20zMi0qLSopCisgICAgdGFyZ19kZWZ2ZWM9d2FzbTMyX2Vs ZjMyX3ZlYworICAgIHRhcmdfc2VsdmVjcz0id2FzbV92ZWMiCisgICAgOzsK KwogICB3ZTMyay0qLSopCiAgICAgdGFyZ19kZWZ2ZWM9d2UzMmtfY29mZl92 ZWMKICAgICA7OwpkaWZmIC0tZ2l0IGEvYmZkL2NvbmZpZ3VyZSBiL2JmZC9j b25maWd1cmUKaW5kZXggODMyNTZkMjVkZi4uN2NhZTRhZTNkOCAxMDA3NTUK LS0tIGEvYmZkL2NvbmZpZ3VyZQorKysgYi9iZmQvY29uZmlndXJlCkBAIC0x NDU2OSw2ICsxNDU2OSw4IEBAIGRvCiAgICAgZnQzMl9lbGYzMl92ZWMpCQkg dGI9IiR0YiBlbGYzMi1mdDMyLmxvIGVsZjMyLmxvICRlbGYiIDs7CiAgICAg dmlzaXVtX2VsZjMyX3ZlYykJCSB0Yj0iJHRiIGVsZjMyLXZpc2l1bS5sbyBl bGYzMi5sbyAkZWxmIiA7OwogICAgIHc2NV9jb2ZmX3ZlYykJCSB0Yj0iJHRi IGNvZmYtdzY1LmxvIHJlbG9jMTYubG8gJGNvZmZnZW4iIDs7CisgICAgd2Fz bV92ZWMpICAgICAgICAgICAgICAgICAgICB0Yj0iJHRiIHdhc20tbW9kdWxl LmxvIiA7OworICAgIHdhc20zMl9lbGYzMl92ZWMpICAgICAgICAgICAgdGI9 IiR0YiBlbGYzMi13YXNtMzIubG8gZWxmMzIubG8gJGVsZiIgOzsKICAgICB3 ZTMya19jb2ZmX3ZlYykJCSB0Yj0iJHRiIGNvZmYtd2UzMmsubG8gJGNvZmZn ZW4iIDs7CiAgICAgeDg2XzY0X2NvZmZfdmVjKQkJIHRiPSIkdGIgY29mZi14 ODZfNjQubG8gJGNvZmYiOyB0YXJnZXRfc2l6ZT02NCA7OwogICAgIHg4Nl82 NF9lbGYzMl92ZWMpCQkgdGI9IiR0YiBlbGY2NC14ODYtNjQubG8gZWxmLWlm dW5jLmxvIGVsZi1uYWNsLmxvIGVsZjY0LmxvIGVsZjMyLmxvICRlbGYiOyB0 YXJnZXRfc2l6ZT02NCA7OwpkaWZmIC0tZ2l0IGEvYmZkL2NvbmZpZ3VyZS5h YyBiL2JmZC9jb25maWd1cmUuYWMKaW5kZXggZWUwYzUzN2VhMi4uZmViMTIz MWM5MSAxMDA2NDQKLS0tIGEvYmZkL2NvbmZpZ3VyZS5hYworKysgYi9iZmQv Y29uZmlndXJlLmFjCkBAIC03MDAsNiArNzAwLDggQEAgZG8KICAgICBmdDMy X2VsZjMyX3ZlYykJCSB0Yj0iJHRiIGVsZjMyLWZ0MzIubG8gZWxmMzIubG8g JGVsZiIgOzsKICAgICB2aXNpdW1fZWxmMzJfdmVjKQkJIHRiPSIkdGIgZWxm MzItdmlzaXVtLmxvIGVsZjMyLmxvICRlbGYiIDs7CiAgICAgdzY1X2NvZmZf dmVjKQkJIHRiPSIkdGIgY29mZi13NjUubG8gcmVsb2MxNi5sbyAkY29mZmdl biIgOzsKKyAgICB3YXNtX3ZlYykgICAgICAgICAgICAgICAgICAgIHRiPSIk dGIgd2FzbS1tb2R1bGUubG8iIDs7CisgICAgd2FzbTMyX2VsZjMyX3ZlYykg ICAgICAgICAgICB0Yj0iJHRiIGVsZjMyLXdhc20zMi5sbyBlbGYzMi5sbyAk ZWxmIiA7OwogICAgIHdlMzJrX2NvZmZfdmVjKQkJIHRiPSIkdGIgY29mZi13 ZTMyay5sbyAkY29mZmdlbiIgOzsKICAgICB4ODZfNjRfY29mZl92ZWMpCQkg dGI9IiR0YiBjb2ZmLXg4Nl82NC5sbyAkY29mZiI7IHRhcmdldF9zaXplPTY0 IDs7CiAgICAgeDg2XzY0X2VsZjMyX3ZlYykJCSB0Yj0iJHRiIGVsZjY0LXg4 Ni02NC5sbyBlbGYtaWZ1bmMubG8gZWxmLW5hY2wubG8gZWxmNjQubG8gZWxm MzIubG8gJGVsZiI7IHRhcmdldF9zaXplPTY0IDs7CmRpZmYgLS1naXQgYS9i ZmQvY3B1LXdhc20zMi5jIGIvYmZkL2NwdS13YXNtMzIuYwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi45Mjk3NzhkNTMxCi0tLSAv ZGV2L251bGwKKysrIGIvYmZkL2NwdS13YXNtMzIuYwpAQCAtMCwwICsxLDM2 IEBACisvKiBCRkQgc3VwcG9ydCBmb3IgdGhlIFdlYkFzc2VtYmx5IHRhcmdl dAorICAgQ29weXJpZ2h0IChDKSAxOTk0LTIwMTcgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uLCBJbmMuCisKKyAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIEJG RCwgdGhlIEJpbmFyeSBGaWxlIERlc2NyaXB0b3IgbGlicmFyeS4KKworICAg VGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRo ZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICAgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhpcyBwcm9ncmFt IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgIGFsb25n IHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVl IFNvZnR3YXJlCisgICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBT dHJlZXQgLSBGaWZ0aCBGbG9vciwgQm9zdG9uLAorICAgTUEgMDIxMTAtMTMw MSwgVVNBLiAgKi8KKworI2luY2x1ZGUgInN5c2RlcC5oIgorI2luY2x1ZGUg ImJmZC5oIgorI2luY2x1ZGUgImxpYmJmZC5oIgorI2luY2x1ZGUgImxpYmli ZXJ0eS5oIgorCisjZGVmaW5lIE4obnVtYmVyLCBwcmludCwgZGVmYXVsdCwg bmV4dCkgIFwKK3sgIDMyLCAzMiwgOCwgYmZkX2FyY2hfd2FzbTMyLCBudW1i ZXIsICJ3YXNtMzIiLCAid2FzbTMyIiwgNCwgZGVmYXVsdCwgYmZkX2RlZmF1 bHRfY29tcGF0aWJsZSwgXAorICAgYmZkX2RlZmF1bHRfc2NhbiwgYmZkX2Fy Y2hfZGVmYXVsdF9maWxsLCBuZXh0IH0KKworc3RhdGljIGNvbnN0IGJmZF9h cmNoX2luZm9fdHlwZSBhcmNoX2luZm9fc3RydWN0W10gPQoreworICBOIChi ZmRfbWFjaF93YXNtMzIsICAgICAgIndhc20zMiIsICAgVFJVRSwgTlVMTCkK K307CisKK2NvbnN0IGJmZF9hcmNoX2luZm9fdHlwZSBiZmRfd2FzbTMyX2Fy Y2ggPQorICBOIChiZmRfbWFjaF93YXNtMzIsICJ3YXNtMzIiLCBUUlVFLCAm IGFyY2hfaW5mb19zdHJ1Y3RbMF0pOwpkaWZmIC0tZ2l0IGEvYmZkL2RvYy93 ZWJhc3NlbWJseS50ZXhpIGIvYmZkL2RvYy93ZWJhc3NlbWJseS50ZXhpCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLjI1YWViNWQ2 MTQKLS0tIC9kZXYvbnVsbAorKysgYi9iZmQvZG9jL3dlYmFzc2VtYmx5LnRl eGkKQEAgLTAsMCArMSwyOSBAQAorQHNlY3Rpb24gV2ViQXNzZW1ibHkgYmFj a2VuZAorVGhlIFdlYkFzc2VtYmx5IG1vZHVsZSBmaWxlIGZvcm1hdCwgYXQg cHJlc2VudCwgaXMgYSB2ZXJ5IHNpbXBsZQorb2JqZWN0IGZpbGUgZm9ybWF0 IHdpdGggdXAgdG8gMTEgbnVtYmVyZWQgc2VjdGlvbnMgcGx1cyBuYW1lZAor YGBjdXN0b20nJyBzZWN0aW9ucy4gQXQgcHJlc2VudCwgdGhlcmUgaXMgbm8g c3RhbmRhcmQgZm9yCityZWxvY2F0aW9ucyBvciBzeW1ib2xzLCB0aG91Z2gg YSBAY29kZXsibmFtZSJ9IHN1YnNlY3Rpb24gY2FuIGFzc2lnbgorbmFtZXMg dG8gZnVuY3Rpb24gaW5kaWNlcyBhbmQgbG9jYWwgdmFyaWFibGVzLgorCitB cyBzdWNoLCBpdCBvZmZlcnMgbm8gcmVhbCBhZHZhbnRhZ2VzIG92ZXIgRUxG LCBhbmQgaW50ZXJtZWRpYXRlIEVMRgorZmlsZXMgY2FuIGJlIHVzZWQgdG8g cHJvZHVjZSBXZWJBc3NlbWJseSBtb2R1bGVzLiBUaGUgV2ViQXNzZW1ibHkK K2JhY2tlbmQgYWltcyB0byBlbmFibGUgdGhlIG9wcG9zaXRlOiByZWFkaW5n IGEgV2ViQXNzZW1ibHkgbW9kdWxlIGFuZAorcHJvZHVjaW5nIGFuIEVMRiBm aWxlIGNvbnRhaW5pbmcgdGhlIHNhbWUgaW5mb3JtYXRpb24sIHdoaWNoIGNh biB0aGVuCitiZSBtYW5pcHVsYXRlZCBhbmQgaW5zcGVjdGVkIHdpdGggc3Rh bmRhcmQgdG9vbHMuCisKK1doZW4gd3JpdGluZyBXZWJBc3NlbWJseSBtb2R1 bGVzLCB0aGUgV2ViQXNzZW1ibHkgYmFja2VuZCBhdHRlbXB0cyB0bworZGV0 ZXJtaW5lIGJhc2VkIG9uIHRoZSBzZWN0aW9uIG5hbWUgd2hldGhlciB0byB1 c2UgYSBudW1lcmljIHNlY3Rpb24KK2lkLCBhIG5hbWVkIHNlY3Rpb24gaGVh ZGVyLCBvciB0byBpbmNsdWRlIHRoZSBzZWN0aW9uIHZlcmJhdGltLAorYXNz dW1pbmcgaXQgYWxyZWFkeSBjb250YWlucyBhbnkgbmVjZXNzYXJ5IGhlYWRl ci4KKworRnVuY3Rpb24gbmFtZXMgYXJlIHN1cHBvcnRlZCBhcyBzeW1ib2xz OyBsb2NhbCBuYW1lcyBhbmQgV2ViQXNzZW1ibHkKK3JlbG9jYXRpb24gc2Vj dGlvbnMgYXJlIGN1cnJlbnRseSB1bnN1cHBvcnRlZC4KKworQG1lbnUKKyog RmlsZSBsYXlvdXQ6OgorQGVuZCBtZW51CisKK0Bub2RlIEZpbGUgbGF5b3V0 LCBXZWJBc3NlbWJseQorQHN1YnNlY3Rpb24gRmlsZSBsYXlvdXQKK0ZvciBh IGRlc2NyaXB0aW9uIG9mIHRoZSBXZWJBc3NlbWJseSBmaWxlIGZvcm1hdCwg c2VlCitAdXJse2h0dHBzOi8vZ2l0aHViLmNvbS9XZWJBc3NlbWJseS9kZXNp Z24vYmxvYi9tYXN0ZXIvQmluYXJ5RW5jb2RpbmcubWR9LgpkaWZmIC0tZ2l0 IGEvYmZkL2VsZjMyLXdhc20zMi5jIGIvYmZkL2VsZjMyLXdhc20zMi5jCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLmNiNTZhY2Fi MDAKLS0tIC9kZXYvbnVsbAorKysgYi9iZmQvZWxmMzItd2FzbTMyLmMKQEAg LTAsMCArMSw1MiBAQAorLyogMzItYml0IEVMRiBmb3IgdGhlIFdlYkFzc2Vt Ymx5IHRhcmdldAorICAgQ29weXJpZ2h0IChDKSAxOTk5LTIwMTcgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisKKyAgIFRoaXMgZmlsZSBpcyBw YXJ0IG9mIEJGRCwgdGhlIEJpbmFyeSBGaWxlIERlc2NyaXB0b3IgbGlicmFy eS4KKworICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICAg KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQg d2lsbCBiZSB1c2VmdWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7 IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UK KyAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRv IHRoZSBGcmVlIFNvZnR3YXJlCisgICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBG cmFua2xpbiBTdHJlZXQgLSBGaWZ0aCBGbG9vciwKKyAgIEJvc3RvbiwgTUEg MDIxMTAtMTMwMSwgVVNBLiAgKi8KKworI2luY2x1ZGUgInN5c2RlcC5oIgor I2luY2x1ZGUgImJmZC5oIgorI2luY2x1ZGUgImxpYmJmZC5oIgorI2luY2x1 ZGUgImVsZi1iZmQuaCIKKyNpbmNsdWRlICJiZmRfc3RkaW50LmgiCisjaW5j bHVkZSAiZWxmL3dhc20zMi5oIgorCisjZGVmaW5lIEVMRl9BUkNICQliZmRf YXJjaF93YXNtMzIKKyNkZWZpbmUgRUxGX1RBUkdFVF9JRAkJMHg0MTU3IC8q ICdXQScgKi8KKyNkZWZpbmUgRUxGX01BQ0hJTkVfQ09ERQkweDQxNTcgLyog J1dBJyAqLworLyogRklYTUUgd2UgZG9uJ3QgaGF2ZSBwYWdlZCBleGVjdXRh Ymxlcywgc2VlCisgKiBodHRwczovL2dpdGh1Yi5jb20vcGlwY2V0L2JpbnV0 aWxzLWdkYi9pc3N1ZXMvNCAqLworI2RlZmluZSBFTEZfTUFYUEFHRVNJWkUJ CTQwOTYKKworI2RlZmluZSBUQVJHRVRfTElUVExFX1NZTSAgICAgICB3YXNt MzJfZWxmMzJfdmVjCisjZGVmaW5lIFRBUkdFVF9MSVRUTEVfTkFNRQkiZWxm MzItd2FzbTMyIgorCisjZGVmaW5lIGVsZl9iYWNrZW5kX2Nhbl9nY19zZWN0 aW9ucyAgICAgICAgICAxCisjZGVmaW5lIGVsZl9iYWNrZW5kX3JlbGFfbm9y bWFsICAgICAgICAgICAgICAxCisvKiBGb3IgdGVzdGluZy4gKi8KKyNkZWZp bmUgZWxmX2JhY2tlbmRfd2FudF9keW5yZWxybyAgICAgICAgICAgIDEKKwor I2RlZmluZSBiZmRfZWxmMzJfYmZkX3JlbG9jX3R5cGVfbG9va3VwIF9iZmRf bm9yZWxvY3NfYmZkX3JlbG9jX3R5cGVfbG9va3VwCisjZGVmaW5lIGJmZF9l bGYzMl9iZmRfcmVsb2NfbmFtZV9sb29rdXAgX2JmZF9ub3JlbG9jc19iZmRf cmVsb2NfbmFtZV9sb29rdXAKKworI2RlZmluZSBFTEZfRFlOQU1JQ19JTlRF UlBSRVRFUiAgIi9zYmluL2VsZi1keW5hbWljLWludGVycHJldGVyLnNvIgor CisjZGVmaW5lIGVsZl9iYWNrZW5kX3dhbnRfZ290X3BsdCAxCisjZGVmaW5l IGVsZl9iYWNrZW5kX3BsdF9yZWFkb25seSAxCisjZGVmaW5lIGVsZl9iYWNr ZW5kX2dvdF9oZWFkZXJfc2l6ZSAwCisKKyNpbmNsdWRlICJlbGYzMi10YXJn ZXQuaCIKZGlmZiAtLWdpdCBhL2JmZC9wby9TUkMtUE9URklMRVMuaW4gYi9i ZmQvcG8vU1JDLVBPVEZJTEVTLmluCmluZGV4IDdlY2RiMGExMWYuLmJmNDVj YThlMWEgMTAwNjQ0Ci0tLSBhL2JmZC9wby9TUkMtUE9URklMRVMuaW4KKysr IGIvYmZkL3BvL1NSQy1QT1RGSUxFUy5pbgpAQCAtMTQxLDYgKzE0MSw3IEBA IGNwdS12ODUwX3JoODUwLmMKIGNwdS12YXguYwogY3B1LXZpc2l1bS5jCiBj cHUtdzY1LmMKK2NwdS13YXNtMzIuYwogY3B1LXdlMzJrLmMKIGNwdS14YzE2 eC5jCiBjcHUteGdhdGUuYwpkaWZmIC0tZ2l0IGEvYmZkL3RhcmdldHMuYyBi L2JmZC90YXJnZXRzLmMKaW5kZXggMWE3YzZiODdkNi4uZjkwNzRiNmFlNSAx MDA2NDQKLS0tIGEvYmZkL3RhcmdldHMuYworKysgYi9iZmQvdGFyZ2V0cy5j CkBAIC04OTMsNiArODkzLDggQEAgZXh0ZXJuIGNvbnN0IGJmZF90YXJnZXQg dmF4X2FvdXRfbmJzZF92ZWM7CiBleHRlcm4gY29uc3QgYmZkX3RhcmdldCB2 YXhfZWxmMzJfdmVjOwogZXh0ZXJuIGNvbnN0IGJmZF90YXJnZXQgdmlzaXVt X2VsZjMyX3ZlYzsKIGV4dGVybiBjb25zdCBiZmRfdGFyZ2V0IHc2NV9jb2Zm X3ZlYzsKK2V4dGVybiBjb25zdCBiZmRfdGFyZ2V0IHdhc21fdmVjOworZXh0 ZXJuIGNvbnN0IGJmZF90YXJnZXQgd2FzbTMyX2VsZjMyX3ZlYzsKIGV4dGVy biBjb25zdCBiZmRfdGFyZ2V0IHdlMzJrX2NvZmZfdmVjOwogZXh0ZXJuIGNv bnN0IGJmZF90YXJnZXQgeDg2XzY0X2NvZmZfdmVjOwogZXh0ZXJuIGNvbnN0 IGJmZF90YXJnZXQgeDg2XzY0X2VsZjMyX3ZlYzsKZGlmZiAtLWdpdCBhL2Jm ZC93YXNtLW1vZHVsZS5jIGIvYmZkL3dhc20tbW9kdWxlLmMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uZjhkNzhiMWQ3MwotLS0g L2Rldi9udWxsCisrKyBiL2JmZC93YXNtLW1vZHVsZS5jCkBAIC0wLDAgKzEs ODE0IEBACisvKiBCRkQgYmFjay1lbmQgZm9yIFdlYkFzc2VtYmx5IG1vZHVs ZXMuCisgICBDb3B5cmlnaHQgKEMpIDE5OTAtMjAxNyBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4KKworICAgQmFzZWQgb24gc3JlYy5jLCBtbW8u YywgYW5kIGJpbmFyeS5jCisKKyAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIEJG RCwgdGhlIEJpbmFyeSBGaWxlIERlc2NyaXB0b3IgbGlicmFyeS4KKworICAg VGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRo ZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICAgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhpcyBwcm9ncmFt IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgIGFsb25n IHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVl IFNvZnR3YXJlCisgICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBT dHJlZXQgLSBGaWZ0aCBGbG9vciwgQm9zdG9uLAorICAgTUEgMDIxMTAtMTMw MSwgVVNBLiAgKi8KKworLyogVGhlIFdlYkFzc2VtYmx5IG1vZHVsZSBmb3Jt YXQgaXMgYSBzaW1wbGUgb2JqZWN0IGZpbGUgZm9ybWF0CisgKiBpbmNsdWRp bmcgdXAgdG8gMTEgbnVtYmVyZWQgc2VjdGlvbnMsIHBsdXMgYW55IG51bWJl ciBvZiBuYW1lZAorICogImN1c3RvbSIgc2VjdGlvbnMuIEl0IGlzIGRlc2Ny aWJlZCBhdAorICogaHR0cHM6Ly9naXRodWIuY29tL1dlYkFzc2VtYmx5L2Rl c2lnbi9ibG9iL21hc3Rlci9CaW5hcnlFbmNvZGluZy5tZC4gKi8KKworI2lu Y2x1ZGUgInN5c2RlcC5oIgorI2luY2x1ZGUgImFsbG9jYS1jb25mLmgiCisj aW5jbHVkZSAiYmZkLmgiCisjaW5jbHVkZSAic3lzZGVwLmgiCisjaW5jbHVk ZSA8bGltaXRzLmg+CisjaW5jbHVkZSAiYmZkX3N0ZGludC5oIgorI2luY2x1 ZGUgImxpYmliZXJ0eS5oIgorI2luY2x1ZGUgImxpYmJmZC5oIgorCisvKiBG cm9tIGVsZi1laC1mcmFtZS5jOiAqLworLyogSWYgKklURVIgaGFzbid0IHJl YWNoZWQgRU5EIHlldCwgcmVhZCB0aGUgbmV4dCBieXRlIGludG8gKlJFU1VM VCBhbmQKKyAgIG1vdmUgb250byB0aGUgbmV4dCBieXRlLiAgUmV0dXJuIHRy dWUgb24gc3VjY2Vzcy4gICovCisKK3N0YXRpYyBpbmxpbmUgYmZkX2Jvb2xl YW4KK3JlYWRfYnl0ZSAoYmZkX2J5dGUgKippdGVyLCBiZmRfYnl0ZSAqZW5k LCB1bnNpZ25lZCBjaGFyICpyZXN1bHQpCit7CisgIGlmICgqaXRlciA+PSBl bmQpCisgICAgcmV0dXJuIEZBTFNFOworICAqcmVzdWx0ID0gKigoKml0ZXIp KyspOworICByZXR1cm4gVFJVRTsKK30KKworLyogTW92ZSAqSVRFUiBvdmVy IExFTkdUSCBieXRlcywgb3IgdXAgdG8gRU5ELCB3aGljaGV2ZXIgaXMgY2xv c2VyLgorICAgUmV0dXJuIHRydWUgaXQgd2FzIHBvc3NpYmxlIHRvIG1vdmUg TEVOR1RIIGJ5dGVzLiAgKi8KKworc3RhdGljIGlubGluZSBiZmRfYm9vbGVh bgorc2tpcF9ieXRlcyAoYmZkX2J5dGUgKippdGVyLCBiZmRfYnl0ZSAqZW5k LCBiZmRfc2l6ZV90eXBlIGxlbmd0aCkKK3sKKyAgaWYgKChiZmRfc2l6ZV90 eXBlKSAoZW5kIC0gKml0ZXIpIDwgbGVuZ3RoKQorICAgIHsKKyAgICAgICpp dGVyID0gZW5kOworICAgICAgcmV0dXJuIEZBTFNFOworICAgIH0KKyAgKml0 ZXIgKz0gbGVuZ3RoOworICByZXR1cm4gVFJVRTsKK30KKworLyogTW92ZSAq SVRFUiBvdmVyIGFuIGxlYjEyOCwgc3RvcHBpbmcgYXQgRU5ELiAgUmV0dXJu IHRydWUgaWYgdGhlIGVuZAorICAgb2YgdGhlIGxlYjEyOCB3YXMgZm91bmQu ICAqLworCitzdGF0aWMgYmZkX2Jvb2xlYW4KK3NraXBfbGViMTI4IChiZmRf Ynl0ZSAqKml0ZXIsIGJmZF9ieXRlICplbmQpCit7CisgIHVuc2lnbmVkIGNo YXIgYnl0ZTsKKyAgZG8KKyAgICBpZiAoIXJlYWRfYnl0ZSAoaXRlciwgZW5k LCAmYnl0ZSkpCisgICAgICByZXR1cm4gRkFMU0U7CisgIHdoaWxlIChieXRl ICYgMHg4MCk7CisgIHJldHVybiBUUlVFOworfQorCisvKiBMaWtlIHNraXBf bGViMTI4LCBidXQgdHJlYXQgdGhlIGxlYjEyOCBhcyBhbiB1bnNpZ25lZCB2 YWx1ZSBhbmQKKyAgIHN0b3JlIGl0IGluICpWQUxVRS4gICovCisKK3N0YXRp YyBiZmRfYm9vbGVhbgorcmVhZF91bGViMTI4IChiZmRfYnl0ZSAqKml0ZXIs IGJmZF9ieXRlICplbmQsIGJmZF92bWEgKnZhbHVlKQoreworICBiZmRfYnl0 ZSAqc3RhcnQsICpwOworCisgIHN0YXJ0ID0gKml0ZXI7CisgIGlmICghc2tp cF9sZWIxMjggKGl0ZXIsIGVuZCkpCisgICAgcmV0dXJuIEZBTFNFOworCisg IHAgPSAqaXRlcjsKKyAgKnZhbHVlID0gKi0tcDsKKyAgd2hpbGUgKHAgPiBz dGFydCkKKyAgICAqdmFsdWUgPSAoKnZhbHVlIDw8IDcpIHwgKCotLXAgJiAw eDdmKTsKKworICByZXR1cm4gVFJVRTsKK30KKworc3RhdGljIGJmZF92bWEK K3dhc21fZ2V0X3VsZWIxMjggKGJmZCogYWJmZCwgYmZkX2Jvb2xlYW4qIGVy cm9yKQoreworICBiZmRfYnl0ZSBieXRlOworICBiZmRfdm1hIHZhbHVlID0g MDsKKyAgaW50IHNoaWZ0ID0gMDsKKworICBkbworICAgIHsKKyAgICAgIGlm IChiZmRfYnJlYWQgKCZieXRlLCAxLCBhYmZkKSAhPSAxKQorICAgICAgICBn b3RvIGVycm9yX3JldHVybjsKKworICAgICAgdmFsdWUgKz0gKGJ5dGUgJiAw eDdmKSA8PCBzaGlmdDsKKworICAgICAgc2hpZnQgKz0gNzsKKyAgICB9Cisg IHdoaWxlIChieXRlICYgMHg4MCk7CisKKyAgcmV0dXJuIHZhbHVlOworCisg ZXJyb3JfcmV0dXJuOgorICAqZXJyb3IgPSBUUlVFOworICByZXR1cm4gKGJm ZF92bWEpLTE7Cit9CisKK3N0YXRpYyBiZmRfYm9vbGVhbgorYmZkX3dyaXRl X3VsZWIxMjggKGJmZCAqYWJmZCwgYmZkX3ZtYSB2KQoreworICBkbworICAg IHsKKyAgICAgIGJmZF9ieXRlIGMgPSB2ICYgMHg3ZjsKKyAgICAgIHYgPj49 IDc7CisKKyAgICAgIGlmICh2KQorICAgICAgICBjIHw9IDB4ODA7CisKKyAg ICAgIGlmIChiZmRfYndyaXRlICgmYywgMSwgYWJmZCkgIT0gMSkKKyAgICAg ICAgcmV0dXJuIEZBTFNFOworICAgIH0KKyAgd2hpbGUgKHYpOworCisgIHJl dHVybiBUUlVFOworfQorCit0eXBlZGVmIHN0cnVjdAoreworICBhc3ltYm9s ICpzeW1ib2xzOworICBiZmRfc2l6ZV90eXBlIHN5bWNvdW50OworfSB0ZGF0 YV90eXBlOworCitzdGF0aWMgYmZkX2Jvb2xlYW4KK3dhc21fZ2V0X21hZ2lj IChiZmQgKmFiZmQsIGJmZF9ib29sZWFuICplcnJvcnB0cikKK3sKKyAgYmZk X2J5dGUgbWFnaWNbNF07CisgIGlmIChiZmRfYnJlYWQgKG1hZ2ljLCAoYmZk X3NpemVfdHlwZSkgNCwgYWJmZCkgIT0gNCkKKyAgICB7CisgICAgICBpZiAo YmZkX2dldF9lcnJvciAoKSAhPSBiZmRfZXJyb3JfZmlsZV90cnVuY2F0ZWQp CisgICAgICAgICplcnJvcnB0ciA9IFRSVUU7CisgICAgICByZXR1cm4gRkFM U0U7CisgICAgfQorCisgIGlmIChtYWdpY1swXSAhPSAwIHx8CisgICAgICBt YWdpY1sxXSAhPSAnYScgfHwKKyAgICAgIG1hZ2ljWzJdICE9ICdzJyB8fAor ICAgICAgbWFnaWNbM10gIT0gJ20nKQorICAgIHsKKyAgICAgICplcnJvcnB0 ciA9IFRSVUU7CisgICAgICByZXR1cm4gRkFMU0U7CisgICAgfQorCisgIHJl dHVybiBUUlVFOworfQorCitzdGF0aWMgaW50Cit3YXNtX2dldF9ieXRlIChi ZmQgKmFiZmQsIGJmZF9ib29sZWFuICplcnJvcnB0cikKK3sKKyAgYmZkX2J5 dGUgYnl0ZTsKKyAgaWYgKGJmZF9icmVhZCAoJmJ5dGUsIChiZmRfc2l6ZV90 eXBlKSAxLCBhYmZkKSAhPSAxKQorICAgIHsKKyAgICAgIGlmIChiZmRfZ2V0 X2Vycm9yICgpICE9IGJmZF9lcnJvcl9maWxlX3RydW5jYXRlZCkKKyAgICAg ICAgKmVycm9ycHRyID0gVFJVRTsKKyAgICAgIHJldHVybiBFT0Y7CisgICAg fQorCisgIHJldHVybiBieXRlOworfQorCitzdGF0aWMgYmZkX2Jvb2xlYW4K K3dhc21fZ2V0X3ZlcnNpb24gKGJmZCAqYWJmZCwgYmZkX2Jvb2xlYW4gKmVy cm9ycHRyKQoreworICBiZmRfYnl0ZSB2ZXJzWzRdOworICBpZiAoYmZkX2Jy ZWFkICh2ZXJzLCAoYmZkX3NpemVfdHlwZSkgNCwgYWJmZCkgIT0gNCkKKyAg ICB7CisgICAgICAqZXJyb3JwdHIgPSBUUlVFOworICAgICAgcmV0dXJuIEZB TFNFOworICAgIH0KKworICAvKiBEb24ndCBhdHRlbXB0IHRvIHBhcnNlIG5l d2VyIHZlcnNpb25zLCB3aGljaCBhcmUgbGlrZWx5IHRvCisgICAqIHJlcXVp cmUgY29kZSBjaGFuZ2VzLiAqLworICBpZiAodmVyc1swXSAhPSAxIHx8IHZl cnNbMV0gfHwgdmVyc1syXSB8fCB2ZXJzWzNdKQorICAgIHJldHVybiBGQUxT RTsKKworICByZXR1cm4gVFJVRTsKK30KKworI2RlZmluZSBXQVNNX05VTUJF UkVEX1NFQ1RJT05TIDExCisKK3N0YXRpYyBjb25zdCBjaGFyICoKK3dhc21f c2VjdGlvbl9jb2RlX3RvX25hbWUgKGJmZF9ieXRlIHNlY3Rpb25fY29kZSkK K3sKKyAgc3dpdGNoIChzZWN0aW9uX2NvZGUpIHsKKyAgY2FzZSAxOgorICAg IHJldHVybiAiLndhc20udHlwZSI7CisgIGNhc2UgMjoKKyAgICByZXR1cm4g Ii53YXNtLmltcG9ydCI7CisgIGNhc2UgMzoKKyAgICByZXR1cm4gIi53YXNt LmZ1bmN0aW9uIjsKKyAgY2FzZSA0OgorICAgIHJldHVybiAiLndhc20udGFi bGUiOworICBjYXNlIDU6CisgICAgcmV0dXJuICIud2FzbS5tZW1vcnkiOwor ICBjYXNlIDY6CisgICAgcmV0dXJuICIud2FzbS5nbG9iYWwiOworICBjYXNl IDc6CisgICAgcmV0dXJuICIud2FzbS5leHBvcnQiOworICBjYXNlIDg6Cisg ICAgcmV0dXJuICIud2FzbS5zdGFydCI7CisgIGNhc2UgOToKKyAgICByZXR1 cm4gIi53YXNtLmVsZW1lbnQiOworICBjYXNlIDEwOgorICAgIHJldHVybiAi Lndhc20uY29kZSI7CisgIGNhc2UgMTE6CisgICAgcmV0dXJuICIud2FzbS5k YXRhIjsKKyAgfQorCisgIHJldHVybiBOVUxMOworfQorCitzdGF0aWMgaW50 Cit3YXNtX3NlY3Rpb25fbmFtZV90b19jb2RlIChjb25zdCBjaGFyICpuYW1l KQoreworICBpZiAoc3RyY21wIChuYW1lLCAiLndhc20udHlwZSIpID09IDAp CisgICAgcmV0dXJuIDE7CisgIGlmIChzdHJjbXAgKG5hbWUsICIud2FzbS5p bXBvcnQiKSA9PSAwKQorICAgIHJldHVybiAyOworICBpZiAoc3RyY21wIChu YW1lLCAiLndhc20uZnVuY3Rpb24iKSA9PSAwKQorICAgIHJldHVybiAzOwor ICBpZiAoc3RyY21wIChuYW1lLCAiLndhc20udGFibGUiKSA9PSAwKQorICAg IHJldHVybiA0OworICBpZiAoc3RyY21wIChuYW1lLCAiLndhc20ubWVtb3J5 IikgPT0gMCkKKyAgICByZXR1cm4gNTsKKyAgaWYgKHN0cmNtcCAobmFtZSwg Ii53YXNtLmdsb2JhbCIpID09IDApCisgICAgcmV0dXJuIDY7CisgIGlmIChz dHJjbXAgKG5hbWUsICIud2FzbS5leHBvcnQiKSA9PSAwKQorICAgIHJldHVy biA3OworICBpZiAoc3RyY21wIChuYW1lLCAiLndhc20uc3RhcnQiKSA9PSAw KQorICAgIHJldHVybiA4OworICBpZiAoc3RyY21wIChuYW1lLCAiLndhc20u ZWxlbWVudCIpID09IDApCisgICAgcmV0dXJuIDk7CisgIGlmIChzdHJjbXAg KG5hbWUsICIud2FzbS5jb2RlIikgPT0gMCkKKyAgICByZXR1cm4gMTA7Cisg IGlmIChzdHJjbXAgKG5hbWUsICIud2FzbS5kYXRhIikgPT0gMCkKKyAgICBy ZXR1cm4gMTE7CisKKyAgcmV0dXJuIC0xOworfQorCitzdGF0aWMgYmZkX2Jv b2xlYW4KK2JmZF93YXNtX3JlYWRfaGVhZGVyIChiZmQgKmFiZmQsIGJmZF9i b29sZWFuICplcnJvcikKK3sKKyAgaWYgKCF3YXNtX2dldF9tYWdpYyAoYWJm ZCwgZXJyb3IpKQorICAgIGdvdG8gZXJyb3JfcmV0dXJuOworCisgIGlmICgh d2FzbV9nZXRfdmVyc2lvbiAoYWJmZCwgZXJyb3IpKQorICAgIGdvdG8gZXJy b3JfcmV0dXJuOworCisgIHJldHVybiBUUlVFOworCisgZXJyb3JfcmV0dXJu OgorICByZXR1cm4gRkFMU0U7Cit9CisKK3N0YXRpYyBiZmRfYm9vbGVhbgor d2FzbV9zY2FuX25hbWVfZnVuY3Rpb25fc2VjdGlvbiAoYmZkICphYmZkLCBz ZWNfcHRyIGFzZWN0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgdm9pZCAqZGF0YSBBVFRSSUJVVEVfVU5VU0VEKQoreworICBpZiAoIWFz ZWN0KQorICAgIHJldHVybiBGQUxTRTsKKworICBpZiAoc3RyY21wIChhc2Vj dC0+bmFtZSwgIi53YXNtLm5hbWUiKSAhPSAwKQorICAgIHJldHVybiBGQUxT RTsKKworICBiZmRfYnl0ZSAqcCA9IGFzZWN0LT5jb250ZW50czsKKyAgYmZk X2J5dGUgKmVuZCA9IGFzZWN0LT5jb250ZW50cyArIGFzZWN0LT5zaXplOwor CisgIHdoaWxlIChwICYmIHAgPCBlbmQpCisgICAgeworICAgICAgaWYgKCpw KysgPT0gMSkKKyAgICAgICAgYnJlYWs7CisgICAgICBiZmRfdm1hIHBheWxv YWRfc2l6ZTsKKyAgICAgIGlmICghcmVhZF91bGViMTI4ICgmcCwgZW5kLCAm cGF5bG9hZF9zaXplKSkKKyAgICAgICAgcmV0dXJuIEZBTFNFOworCisgICAg ICBwICs9IHBheWxvYWRfc2l6ZTsKKyAgICB9CisKKyAgaWYgKCFwIHx8IHAg Pj0gZW5kKQorICAgIHJldHVybiBGQUxTRTsKKworICBiZmRfdm1hIHBheWxv YWRfc2l6ZTsKKyAgaWYgKCFyZWFkX3VsZWIxMjggKCZwLCBlbmQsICZwYXls b2FkX3NpemUpKQorICAgIHJldHVybiBGQUxTRTsKKworICBpZiAocCArIHBh eWxvYWRfc2l6ZSA+IGVuZCkKKyAgICByZXR1cm4gRkFMU0U7CisKKyAgZW5k ID0gcCArIHBheWxvYWRfc2l6ZTsKKworICBiZmRfdm1hIHN5bWNvdW50ID0g MDsKKyAgaWYgKCFyZWFkX3VsZWIxMjggKCZwLCBlbmQsICZzeW1jb3VudCkp CisgICAgcmV0dXJuIEZBTFNFOworCisgIHRkYXRhX3R5cGUgKnRkYXRhID0g YWJmZC0+dGRhdGEuYW55OworICB0ZGF0YS0+c3ltY291bnQgPSBzeW1jb3Vu dDsKKyAgc3ltY291bnQgPSAwOworCisgIGJmZF9zaXplX3R5cGUgc3ltX2Fs bG9jYXRlZCA9IDA7CisgIGFzeW1ib2wgKnN5bWJvbHMgPSBOVUxMOworICBz ZWNfcHRyIHNwYWNlX2Z1bmN0aW9uX2luZGV4ID0gYmZkX21ha2Vfc2VjdGlv bl93aXRoX2ZsYWdzIChhYmZkLCAiLnNwYWNlLmZ1bmN0aW9uX2luZGV4Iiwg U0VDX1JFQURPTkxZIHwgU0VDX0NPREUpOworICBpZiAoIXNwYWNlX2Z1bmN0 aW9uX2luZGV4KQorICAgIHNwYWNlX2Z1bmN0aW9uX2luZGV4ID0gYmZkX2dl dF9zZWN0aW9uX2J5X25hbWUgKGFiZmQsICIuc3BhY2UuZnVuY3Rpb25faW5k ZXgiKTsKKworICBmb3IgKGJmZF92bWEgaSA9IDA7IHAgPCBlbmQgJiYgaSA8 IHRkYXRhLT5zeW1jb3VudDsgaSsrKQorICAgIHsKKyAgICAgIGJmZF92bWEg aW5kZXg7CisgICAgICBiZmRfdm1hIGxlbjsKKyAgICAgIGNoYXIgKm5hbWU7 CisKKyAgICAgIGlmICghcmVhZF91bGViMTI4ICgmcCwgZW5kLCAmaW5kZXgp IHx8CisgICAgICAgICAgIXJlYWRfdWxlYjEyOCAoJnAsIGVuZCwgJmxlbikp CisgICAgICAgIHJldHVybiBGQUxTRTsKKworICAgICAgbmFtZSA9IGJmZF9h bGxvYyAoYWJmZCwgbGVuICsgMSk7CisKKyAgICAgIG5hbWVbbGVuXSA9IDA7 CisKKyAgICAgIG1lbWNweSAobmFtZSwgcCwgbGVuKTsKKworICAgICAgcCAr PSBsZW47CisKKyAgICAgIGlmIChzeW1jb3VudCA9PSBzeW1fYWxsb2NhdGVk KQorICAgICAgICB7CisgICAgICAgICAgc3ltX2FsbG9jYXRlZCAqPSAyOwor ICAgICAgICAgIGlmIChzeW1fYWxsb2NhdGVkID09IDApCisgICAgICAgICAg ICBzeW1fYWxsb2NhdGVkID0gNTEyOworCisgICAgICAgICAgc3ltYm9scyA9 IGJmZF9yZWFsbG9jIChzeW1ib2xzLCBzeW1fYWxsb2NhdGVkICogc2l6ZW9m IChhc3ltYm9sKSk7CisgICAgICAgIH0KKworICAgICAgYXN5bWJvbCAqc3lt ID0gJnN5bWJvbHNbc3ltY291bnQrK107CisgICAgICBzeW0tPnRoZV9iZmQg PSBhYmZkOworICAgICAgc3ltLT5uYW1lID0gbmFtZTsKKyAgICAgIHN5bS0+ dmFsdWUgPSBpbmRleDsKKyAgICAgIHN5bS0+ZmxhZ3MgPSBCU0ZfR0xPQkFM IHwgQlNGX0ZVTkNUSU9OOworICAgICAgc3ltLT5zZWN0aW9uID0gc3BhY2Vf ZnVuY3Rpb25faW5kZXg7CisgICAgICBzeW0tPnVkYXRhLnAgPSBOVUxMOwor ICAgIH0KKworICB0ZGF0YS0+c3ltYm9scyA9IHN5bWJvbHM7CisgIHRkYXRh LT5zeW1jb3VudCA9IHN5bWNvdW50OworICBhYmZkLT5zeW1jb3VudCA9IHN5 bWNvdW50OworCisgIHJldHVybiBUUlVFOworfQorCitzdGF0aWMgYmZkX2Jv b2xlYW4KK3dhc21fc2NhbiAoYmZkICphYmZkKQoreworICBiZmRfYm9vbGVh biBlcnJvciA9IEZBTFNFOworICBiZmRfdm1hIHZtYSA9IDB4ODAwMDAwMDA7 CisgIGludCBzZWN0aW9uX2NvZGU7CisKKyAgaWYgKGJmZF9zZWVrIChhYmZk LCAoZmlsZV9wdHIpIDAsIFNFRUtfU0VUKSAhPSAwKQorICAgIGdvdG8gZXJy b3JfcmV0dXJuOworCisgIGlmICghYmZkX3dhc21fcmVhZF9oZWFkZXIgKGFi ZmQsICZlcnJvcikpCisgICAgZ290byBlcnJvcl9yZXR1cm47CisKKyAgd2hp bGUgKChzZWN0aW9uX2NvZGUgPSB3YXNtX2dldF9ieXRlIChhYmZkLCAmZXJy b3IpKSAhPSBFT0YpCisgICAgeworICAgICAgYXNlY3Rpb24gKmJmZHNlYzsK KyAgICAgIGlmIChzZWN0aW9uX2NvZGUpCisgICAgICAgIHsKKyAgICAgICAg ICBjb25zdCBjaGFyICpuYW1lID0gd2FzbV9zZWN0aW9uX2NvZGVfdG9fbmFt ZSAoc2VjdGlvbl9jb2RlKTsKKyAgICAgICAgICBjaGFyICpzZWNuYW1lOwor CisgICAgICAgICAgaWYgKCFuYW1lKQorICAgICAgICAgICAgZ290byBlcnJv cl9yZXR1cm47CisKKyAgICAgICAgICBzZWNuYW1lID0gc3RyZHVwIChuYW1l KTsKKworICAgICAgICAgIGJmZHNlYyA9IGJmZF9tYWtlX3NlY3Rpb25fYW55 d2F5X3dpdGhfZmxhZ3MgKGFiZmQsIHNlY25hbWUsIFNFQ19IQVNfQ09OVEVO VFMpOworICAgICAgICAgIGlmIChiZmRzZWMgPT0gTlVMTCkKKyAgICAgICAg ICAgIGdvdG8gZXJyb3JfcmV0dXJuOworCisgICAgICAgICAgYmZkc2VjLT52 bWEgPSB2bWE7CisgICAgICAgICAgYmZkc2VjLT5sbWEgPSB2bWE7CisgICAg ICAgICAgYmZkc2VjLT5zaXplID0gd2FzbV9nZXRfdWxlYjEyOCAoYWJmZCwg JmVycm9yKTsKKyAgICAgICAgICBiZmRzZWMtPmZpbGVwb3MgPSBiZmRfdGVs bCAoYWJmZCk7CisgICAgICAgICAgYmZkc2VjLT5hbGlnbm1lbnRfcG93ZXIg PSAwOworICAgICAgICB9CisgICAgICBlbHNlCisgICAgICAgIHsKKyAgICAg ICAgICBiZmRfdm1hIHBheWxvYWRfbGVuID0gd2FzbV9nZXRfdWxlYjEyOCAo YWJmZCwgJmVycm9yKTsKKyAgICAgICAgICBmaWxlX3B0ciBzZWN0aW9uX3N0 YXJ0ID0gYmZkX3RlbGwgKGFiZmQpOworICAgICAgICAgIGJmZF92bWEgbmFt ZWxlbiA9IHdhc21fZ2V0X3VsZWIxMjggKGFiZmQsICZlcnJvcik7CisgICAg ICAgICAgaWYgKG5hbWVsZW4gPT0gKGJmZF92bWEpLTEpCisgICAgICAgICAg ICBnb3RvIGVycm9yX3JldHVybjsKKyAgICAgICAgICBjaGFyICpuYW1lID0g YmZkX3phbGxvYyAoYWJmZCwgbmFtZWxlbisxKTsKKyAgICAgICAgICBuYW1l W25hbWVsZW5dID0gMDsKKyAgICAgICAgICBpZiAoYmZkX2JyZWFkIChuYW1l LCBuYW1lbGVuLCBhYmZkKSAhPSBuYW1lbGVuKQorICAgICAgICAgICAgZ290 byBlcnJvcl9yZXR1cm47CisKKyAgICAgICAgICBjaGFyICpzZWNuYW1lOwor ICAgICAgICAgIGFzcHJpbnRmICgmc2VjbmFtZSwgIi53YXNtLiVzIiwgbmFt ZSk7CisKKyAgICAgICAgICBiZmRzZWMgPSBiZmRfbWFrZV9zZWN0aW9uX2Fu eXdheV93aXRoX2ZsYWdzIChhYmZkLCBzZWNuYW1lLCBTRUNfSEFTX0NPTlRF TlRTKTsKKyAgICAgICAgICBpZiAoYmZkc2VjID09IE5VTEwpCisgICAgICAg ICAgICBnb3RvIGVycm9yX3JldHVybjsKKworICAgICAgICAgIGJmZHNlYy0+ dm1hID0gdm1hOworICAgICAgICAgIGJmZHNlYy0+bG1hID0gdm1hOworICAg ICAgICAgIGJmZHNlYy0+c2l6ZSA9IHBheWxvYWRfbGVuIC0gYmZkX3RlbGwg KGFiZmQpICsgc2VjdGlvbl9zdGFydDsKKyAgICAgICAgICBiZmRzZWMtPmZp bGVwb3MgPSBiZmRfdGVsbCAoYWJmZCk7CisgICAgICAgICAgYmZkc2VjLT5h bGlnbm1lbnRfcG93ZXIgPSAwOworICAgICAgICB9CisKKyAgICAgIGJmZHNl Yy0+Y29udGVudHMgPSBiZmRfemFsbG9jIChhYmZkLCBiZmRzZWMtPnNpemUp OworICAgICAgaWYgKGJmZHNlYy0+c2l6ZSAmJiAhYmZkc2VjLT5jb250ZW50 cykKKyAgICAgICAgZ290byBlcnJvcl9yZXR1cm47CisKKyAgICAgIGlmIChi ZmRfYnJlYWQgKGJmZHNlYy0+Y29udGVudHMsIGJmZHNlYy0+c2l6ZSwgYWJm ZCkgIT0gYmZkc2VjLT5zaXplKQorICAgICAgICBnb3RvIGVycm9yX3JldHVy bjsKKworICAgICAgdm1hICs9IGJmZHNlYy0+c2l6ZTsKKyAgICB9CisKKyAg LyogTWFrZSBzdXJlIHdlJ3JlIGF0IGFjdHVhbCBFT0YuIFRoZXJlJ3Mgbm8g aW5kaWNhdGlvbiBpbiB0aGUKKyAgICogV2ViQXNzZW1ibHkgZm9ybWF0IG9m IGhvdyBsb25nIHRoZSBmaWxlIGlzIHN1cHBvc2VkIHRvIGJlLiAqLworICBp ZiAoZXJyb3IpCisgICAgZ290byBlcnJvcl9yZXR1cm47CisKKyAgaWYgKCF3 YXNtX3NjYW5fbmFtZV9mdW5jdGlvbl9zZWN0aW9uIChhYmZkLCBiZmRfZ2V0 X3NlY3Rpb25fYnlfbmFtZSAoYWJmZCwgIi53YXNtLm5hbWUiKSwgTlVMTCkp CisgICAgcmV0dXJuIFRSVUU7CisKKyAgcmV0dXJuIFRSVUU7CisKKyBlcnJv cl9yZXR1cm46CisgIHJldHVybiBGQUxTRTsKK30KKworc3RhdGljIHZvaWQK K3dhc21fcmVnaXN0ZXJfc2VjdGlvbiAoYmZkICphYmZkIEFUVFJJQlVURV9V TlVTRUQsCisgICAgICAgICAgICAgICAgICAgICAgIGFzZWN0aW9uICphc2Vj dCwgdm9pZCAqZnNhcmcpCit7CisgIHNlY19wdHIgKm51bWJlcmVkX3NlY3Rp b25zID0gZnNhcmc7CisgIGludCBpbmRleCA9IHdhc21fc2VjdGlvbl9uYW1l X3RvX2NvZGUgKGFzZWN0LT5uYW1lKTsKKworICBpZiAoaW5kZXggPT0gLTEp CisgICAgcmV0dXJuOworCisgIG51bWJlcmVkX3NlY3Rpb25zW2luZGV4XSA9 IGFzZWN0OworfQorCitzdHJ1Y3QgY29tcHV0ZV9zZWN0aW9uX2FyZworewor ICBiZmRfdm1hIHBvczsKKyAgYmZkX2Jvb2xlYW4gZmFpbGVkOworfTsKKwor c3RhdGljIHZvaWQKK3dhc21fY29tcHV0ZV9jdXN0b21fc2VjdGlvbl9maWxl X3Bvc2l0aW9uIChiZmQgKmFiZmQsIHNlY19wdHIgYXNlY3QsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdm9pZCAqZnNh cmcpCit7CisgIHN0cnVjdCBjb21wdXRlX3NlY3Rpb25fYXJnICpmcyA9IGZz YXJnOworCisgIGlmIChmcy0+ZmFpbGVkKQorICAgIHJldHVybjsKKworICBp bnQgaW5kZXggPSB3YXNtX3NlY3Rpb25fbmFtZV90b19jb2RlIChhc2VjdC0+ bmFtZSk7CisKKyAgaWYgKGluZGV4ICE9IC0xKQorICAgIHJldHVybjsKKwor ICBpZiAoQ09OU1RfU1RSTkVRIChhc2VjdC0+bmFtZSwgIi53YXNtLiIpKQor ICAgIHsKKyAgICAgIGNvbnN0IGNoYXIgKm5hbWUgPSBhc2VjdC0+bmFtZSAr IHN0cmxlbiAoIi53YXNtLiIpOworICAgICAgYmZkX3NpemVfdHlwZSBwYXls b2FkX2xlbiA9IGFzZWN0LT5zaXplOworICAgICAgYmZkX3NpemVfdHlwZSBu YW1lX2xlbiA9IHN0cmxlbiAobmFtZSk7CisgICAgICBiZmRfc2l6ZV90eXBl IG5sID0gbmFtZV9sZW47CisKKyAgICAgIHBheWxvYWRfbGVuICs9IG5hbWVf bGVuOworCisgICAgICBkbworICAgICAgICB7CisgICAgICAgICAgcGF5bG9h ZF9sZW4rKzsKKyAgICAgICAgICBubCA+Pj0gNzsKKyAgICAgICAgfQorICAg ICAgd2hpbGUgKG5sKTsKKworICAgICAgYmZkX3NlZWsgKGFiZmQsIGZzLT5w b3MsIFNFRUtfU0VUKTsKKyAgICAgIGlmICghYmZkX3dyaXRlX3VsZWIxMjgg KGFiZmQsIDApIHx8CisgICAgICAgICAgIWJmZF93cml0ZV91bGViMTI4IChh YmZkLCBwYXlsb2FkX2xlbikgfHwKKyAgICAgICAgICAhYmZkX3dyaXRlX3Vs ZWIxMjggKGFiZmQsIG5hbWVfbGVuKSB8fAorICAgICAgICAgIGJmZF9id3Jp dGUgKG5hbWUsIG5hbWVfbGVuLCBhYmZkKSAhPSBuYW1lX2xlbikKKyAgICAg ICAgZ290byBlcnJvcl9yZXR1cm47CisgICAgICBmcy0+cG9zID0gYXNlY3Qt PmZpbGVwb3MgPSBiZmRfdGVsbCAoYWJmZCk7CisgICAgfQorICBlbHNlCisg ICAgeworICAgICAgYXNlY3QtPmZpbGVwb3MgPSBmcy0+cG9zOworICAgIH0K KworCisgIGZzLT5wb3MgKz0gYXNlY3QtPnNpemU7CisKKyAgcmV0dXJuOwor CisgZXJyb3JfcmV0dXJuOgorICBmcy0+ZmFpbGVkID0gVFJVRTsKKyAgcmV0 dXJuOworfQorCitzdGF0aWMgYmZkX2Jvb2xlYW4KK3dhc21fY29tcHV0ZV9z ZWN0aW9uX2ZpbGVfcG9zaXRpb25zIChiZmQgKmFiZmQpCit7CisgIGJmZF9i eXRlIG1hZ2ljW10gPSB7IDB4MDAsICdhJywgJ3MnLCAnbScgfTsKKyAgYmZk X2J5dGUgdmVyc1tdID0geyAweDAxLCAweDAwLCAweDAwLCAweDAwIH07CisK KyAgYmZkX3NlZWsgKGFiZmQsIChiZmRfdm1hKTAsIFNFRUtfU0VUKTsKKwor ICBpZiAoYmZkX2J3cml0ZSAobWFnaWMsIDQsIGFiZmQpICE9IDQgfHwKKyAg ICAgIGJmZF9id3JpdGUgKHZlcnMsIDQsIGFiZmQpICE9IDQpCisgICAgcmV0 dXJuIEZBTFNFOworCisgIHNlY19wdHIgbnVtYmVyZWRfc2VjdGlvbnNbV0FT TV9OVU1CRVJFRF9TRUNUSU9OUysxXTsKKworICBmb3IgKGludCBpID0gMDsg aSA8PSBXQVNNX05VTUJFUkVEX1NFQ1RJT05TOyBpKyspCisgICAgbnVtYmVy ZWRfc2VjdGlvbnNbaV0gPSAwOworCisgIGJmZF9tYXBfb3Zlcl9zZWN0aW9u cyAoYWJmZCwgd2FzbV9yZWdpc3Rlcl9zZWN0aW9uLCBudW1iZXJlZF9zZWN0 aW9ucyk7CisKKyAgc3RydWN0IGNvbXB1dGVfc2VjdGlvbl9hcmcgZnM7Cisg IGZzLnBvcyA9IDg7CisgIGZvciAoaW50IGkgPSAwOyBpIDw9IFdBU01fTlVN QkVSRURfU0VDVElPTlM7IGkrKykKKyAgICB7CisgICAgICBzZWNfcHRyIHNl YyA9IG51bWJlcmVkX3NlY3Rpb25zW2ldOworICAgICAgaWYgKCFzZWMpCisg ICAgICAgIGNvbnRpbnVlOworICAgICAgYmZkX3NlZWsgKGFiZmQsIGZzLnBv cywgU0VFS19TRVQpOworICAgICAgYmZkX3NpemVfdHlwZSBzaXplID0gc2Vj LT5zaXplOworICAgICAgaWYgKCFiZmRfd3JpdGVfdWxlYjEyOCAoYWJmZCwg aSkgfHwKKyAgICAgICAgICAhYmZkX3dyaXRlX3VsZWIxMjggKGFiZmQsIHNp emUpKQorICAgICAgICByZXR1cm4gRkFMU0U7CisgICAgICBmcy5wb3MgPSBz ZWMtPmZpbGVwb3MgPSBiZmRfdGVsbCAoYWJmZCk7CisgICAgICBmcy5wb3Mg Kz0gc2l6ZTsKKyAgICB9CisKKyAgZnMuZmFpbGVkID0gRkFMU0U7CisKKyAg YmZkX21hcF9vdmVyX3NlY3Rpb25zIChhYmZkLCB3YXNtX2NvbXB1dGVfY3Vz dG9tX3NlY3Rpb25fZmlsZV9wb3NpdGlvbiwgJmZzKTsKKworICBpZiAoZnMu ZmFpbGVkKQorICAgIHJldHVybiBGQUxTRTsKKworICByZXR1cm4gVFJVRTsK K30KKworCitzdGF0aWMgYmZkX2Jvb2xlYW4KK3dhc21fc2V0X3NlY3Rpb25f Y29udGVudHMgKGJmZCAqYWJmZCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgIHNlY19wdHIgc2VjdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgIGNvbnN0IHZvaWQgKmxvY2F0aW9uLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgZmlsZV9wdHIgb2Zmc2V0LAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgYmZkX3NpemVfdHlwZSBjb3VudCkKK3sKKyAgaWYgKGNvdW50 ID09IDApCisgICAgcmV0dXJuIFRSVUU7CisKKyAgaWYgKCFhYmZkLT5vdXRw dXRfaGFzX2JlZ3VuICYmCisgICAgICAhd2FzbV9jb21wdXRlX3NlY3Rpb25f ZmlsZV9wb3NpdGlvbnMgKGFiZmQpKQorICAgIHJldHVybiBGQUxTRTsKKwor ICBpZiAoYmZkX3NlZWsgKGFiZmQsIHNlY3Rpb24tPmZpbGVwb3MgKyBvZmZz ZXQsIFNFRUtfU0VUKSAhPSAwCisgICAgICB8fCBiZmRfYndyaXRlIChsb2Nh dGlvbiwgY291bnQsIGFiZmQpICE9IGNvdW50KQorICAgIHJldHVybiBGQUxT RTsKKworICByZXR1cm4gVFJVRTsKK30KKworc3RhdGljIGJmZF9ib29sZWFu CitfYmZkX3dhc21fd3JpdGVfb2JqZWN0X2NvbnRlbnRzIChiZmQqIGFiZmQp Cit7CisgIGJmZF9ieXRlIG1hZ2ljW10gPSB7IDB4MDAsICdhJywgJ3MnLCAn bScgfTsKKyAgYmZkX2J5dGUgdmVyc1tdID0geyAweDAxLCAweDAwLCAweDAw LCAweDAwIH07CisKKyAgaWYgKGJmZF9zZWVrIChhYmZkLCAwLCBTRUVLX1NF VCkgIT0gMCkKKyAgICByZXR1cm4gRkFMU0U7CisKKyAgaWYgKGJmZF9id3Jp dGUgKG1hZ2ljLCA0LCBhYmZkKSAhPSA0IHx8CisgICAgICBiZmRfYndyaXRl ICh2ZXJzLCA0LCBhYmZkKSAhPSA0KQorICAgIHJldHVybiBGQUxTRTsKKwor ICByZXR1cm4gVFJVRTsKK30KKworc3RhdGljIGJmZF9ib29sZWFuCit3YXNt X21rb2JqZWN0IChiZmQgKmFiZmQpCit7CisgIHRkYXRhX3R5cGUgKnRkYXRh ID0gKHRkYXRhX3R5cGUgKikgYmZkX2FsbG9jIChhYmZkLCBzaXplb2YgKHRk YXRhX3R5cGUpKTsKKworICBpZiAoIXRkYXRhKQorICAgIHJldHVybiBGQUxT RTsKKworICB0ZGF0YS0+c3ltYm9scyA9IE5VTEw7CisgIHRkYXRhLT5zeW1j b3VudCA9IDA7CisKKyAgYWJmZC0+dGRhdGEuYW55ID0gdGRhdGE7CisKKyAg cmV0dXJuIFRSVUU7Cit9CisKK3N0YXRpYyBpbnQKK3dhc21fc2l6ZW9mX2hl YWRlcnMgKGJmZCAqYWJmZCBBVFRSSUJVVEVfVU5VU0VELAorICAgICAgICAg ICAgICAgICAgICAgc3RydWN0IGJmZF9saW5rX2luZm8gKmluZm8gQVRUUklC VVRFX1VOVVNFRCkKK3sKKyAgcmV0dXJuIDg7Cit9CisKK3N0YXRpYyBsb25n Cit3YXNtX2dldF9zeW10YWJfdXBwZXJfYm91bmQgKGJmZCAqYWJmZCkKK3sK KyAgdGRhdGFfdHlwZSAqdGRhdGEgPSBhYmZkLT50ZGF0YS5hbnk7CisKKyAg cmV0dXJuICh0ZGF0YS0+c3ltY291bnQgKyAxKSAqIChzaXplb2YgKGFzeW1i b2wpKTsKK30KKworc3RhdGljIGxvbmcKK3dhc21fY2Fub25pY2FsaXplX3N5 bXRhYiAoYmZkICphYmZkLCBhc3ltYm9sICoqYWxvY2F0aW9uKQoreworICB0 ZGF0YV90eXBlICp0ZGF0YSA9IGFiZmQtPnRkYXRhLmFueTsKKyAgc2l6ZV90 IGk7CisKKyAgZm9yIChpID0gMDsgaSA8IHRkYXRhLT5zeW1jb3VudDsgaSsr KQorICAgIGFsb2NhdGlvbltpXSA9ICZ0ZGF0YS0+c3ltYm9sc1tpXTsKKyAg YWxvY2F0aW9uW2ldID0gTlVMTDsKKworICByZXR1cm4gdGRhdGEtPnN5bWNv dW50OworfQorCitzdGF0aWMgYXN5bWJvbCAqCit3YXNtX21ha2VfZW1wdHlf c3ltYm9sIChiZmQgKmFiZmQpCit7CisgIGJmZF9zaXplX3R5cGUgYW10ID0g c2l6ZW9mIChhc3ltYm9sKTsKKyAgYXN5bWJvbCAqbmV3X3N5bWJvbCA9IChh c3ltYm9sICopIGJmZF96YWxsb2MgKGFiZmQsIGFtdCk7CisKKyAgaWYgKCFu ZXdfc3ltYm9sKQorICAgIHJldHVybiBOVUxMOworICBuZXdfc3ltYm9sLT50 aGVfYmZkID0gYWJmZDsKKyAgcmV0dXJuIG5ld19zeW1ib2w7Cit9CisKK3N0 YXRpYyB2b2lkCit3YXNtX3ByaW50X3N5bWJvbCAoYmZkICphYmZkLAorICAg ICAgICAgICAgICAgICAgIHZvaWQgKiBmaWxlcCwKKyAgICAgICAgICAgICAg ICAgICBhc3ltYm9sICpzeW1ib2wsCisgICAgICAgICAgICAgICAgICAgYmZk X3ByaW50X3N5bWJvbF90eXBlIGhvdykKK3sKKyAgRklMRSAqZmlsZSA9IChG SUxFICopIGZpbGVwOworCisgIHN3aXRjaCAoaG93KQorICAgIHsKKyAgICBj YXNlIGJmZF9wcmludF9zeW1ib2xfbmFtZToKKyAgICAgIGZwcmludGYgKGZp bGUsICIlcyIsIHN5bWJvbC0+bmFtZSk7CisgICAgICBicmVhazsKKworICAg IGRlZmF1bHQ6CisgICAgICBiZmRfcHJpbnRfc3ltYm9sX3ZhbmRmIChhYmZk LCBmaWxlcCwgc3ltYm9sKTsKKyAgICAgIGZwcmludGYgKGZpbGUsICIgJS01 cyAlcyIsIHN5bWJvbC0+c2VjdGlvbi0+bmFtZSwgc3ltYm9sLT5uYW1lKTsK KyAgICB9Cit9CisKK3N0YXRpYyB2b2lkCit3YXNtX2dldF9zeW1ib2xfaW5m byAoYmZkICphYmZkIEFUVFJJQlVURV9VTlVTRUQsCisgICAgICAgICAgICAg ICAgICAgICAgYXN5bWJvbCAqc3ltYm9sLAorICAgICAgICAgICAgICAgICAg ICAgIHN5bWJvbF9pbmZvICpyZXQpCit7CisgIGJmZF9zeW1ib2xfaW5mbyAo c3ltYm9sLCByZXQpOworfQorCitzdGF0aWMgY29uc3QgYmZkX3RhcmdldCAq Cit3YXNtX29iamVjdF9wIChiZmQgKmFiZmQpCit7CisgIGJmZF9ieXRlIGJb OF07CisKKyAgaWYgKGJmZF9zZWVrIChhYmZkLCAoZmlsZV9wdHIpIDAsIFNF RUtfU0VUKSAhPSAwCisgICAgICB8fCBiZmRfYnJlYWQgKGIsIChiZmRfc2l6 ZV90eXBlKSA4LCBhYmZkKSAhPSA4KQorICAgIHJldHVybiBOVUxMOworCisg IGlmIChiWzBdICE9IDAgfHwgYlsxXSAhPSAnYScgfHwgYlsyXSAhPSAncycg fHwgYlszXSAhPSAnbScgfHwKKyAgICAgIGJbNF0gIT0gMSB8fCBiWzVdICE9 IDAgfHwgYls2XSAhPSAwIHx8IGJbN10gIT0gMCkKKyAgICB7CisgICAgICBi ZmRfc2V0X2Vycm9yIChiZmRfZXJyb3Jfd3JvbmdfZm9ybWF0KTsKKyAgICAg IHJldHVybiBOVUxMOworICAgIH0KKworICBpZiAoISB3YXNtX21rb2JqZWN0 IChhYmZkKSB8fCAhIHdhc21fc2NhbiAoYWJmZCkpCisgICAgcmV0dXJuIE5V TEw7CisKKyAgaWYgKCEgYmZkX2RlZmF1bHRfc2V0X2FyY2hfbWFjaCAoYWJm ZCwgYmZkX2FyY2hfd2FzbTMyLCAwKSkKKyAgICByZXR1cm4gTlVMTDsKKwor ICBpZiAoYWJmZC0+c3ltY291bnQgPiAwKQorICAgIGFiZmQtPmZsYWdzIHw9 IEhBU19TWU1TOworCisgIHJldHVybiBhYmZkLT54dmVjOworfQorCisvKiBC RkRfSlVNUF9UQUJMRV9XUklURSAqLworI2RlZmluZSB3YXNtX3NldF9hcmNo X21hY2ggICAgICAgICAgICAgICAgICAgICAgIF9iZmRfZ2VuZXJpY19zZXRf YXJjaF9tYWNoCisKKy8qIEJGRF9KVU1QX1RBQkxFX1NZTUJPTFMgKi8KKyNk ZWZpbmUgd2FzbV9nZXRfc3ltYm9sX3ZlcnNpb25fc3RyaW5nICAgIF9iZmRf bm9zeW1ib2xzX2dldF9zeW1ib2xfdmVyc2lvbl9zdHJpbmcKKyNkZWZpbmUg d2FzbV9iZmRfaXNfbG9jYWxfbGFiZWxfbmFtZSAgICAgICBiZmRfZ2VuZXJp Y19pc19sb2NhbF9sYWJlbF9uYW1lCisjZGVmaW5lIHdhc21fYmZkX2lzX3Rh cmdldF9zcGVjaWFsX3N5bWJvbCAoKGJmZF9ib29sZWFuICgqKSAoYmZkICos IGFzeW1ib2wgKikpIGJmZF9mYWxzZSkKKyNkZWZpbmUgd2FzbV9nZXRfbGlu ZW5vICAgICAgICAgICAgICAgICAgIF9iZmRfbm9zeW1ib2xzX2dldF9saW5l bm8KKyNkZWZpbmUgd2FzbV9maW5kX25lYXJlc3RfbGluZSAgICAgICAgICAg IF9iZmRfbm9zeW1ib2xzX2ZpbmRfbmVhcmVzdF9saW5lCisjZGVmaW5lIHdh c21fZmluZF9saW5lICAgICAgICAgICAgICAgICAgICBfYmZkX25vc3ltYm9s c19maW5kX2xpbmUKKyNkZWZpbmUgd2FzbV9maW5kX2lubGluZXJfaW5mbyAg ICAgICAgICAgIF9iZmRfbm9zeW1ib2xzX2ZpbmRfaW5saW5lcl9pbmZvCisj ZGVmaW5lIHdhc21fYmZkX21ha2VfZGVidWdfc3ltYm9sICAgICAgICBfYmZk X25vc3ltYm9sc19iZmRfbWFrZV9kZWJ1Z19zeW1ib2wKKyNkZWZpbmUgd2Fz bV9yZWFkX21pbmlzeW1ib2xzICAgICAgICAgICAgIF9iZmRfZ2VuZXJpY19y ZWFkX21pbmlzeW1ib2xzCisjZGVmaW5lIHdhc21fbWluaXN5bWJvbF90b19z eW1ib2wgICAgICAgICBfYmZkX2dlbmVyaWNfbWluaXN5bWJvbF90b19zeW1i b2wKKworLyogQkZEX0pVTVBfVEFCTEVfTElOSyAqLworI2RlZmluZSB3YXNt X2JmZF9nZXRfcmVsb2NhdGVkX3NlY3Rpb25fY29udGVudHMgICBiZmRfZ2Vu ZXJpY19nZXRfcmVsb2NhdGVkX3NlY3Rpb25fY29udGVudHMKKyNkZWZpbmUg d2FzbV9iZmRfcmVsYXhfc2VjdGlvbiAgICAgICAgICAgIGJmZF9nZW5lcmlj X3JlbGF4X3NlY3Rpb24KKyNkZWZpbmUgd2FzbV9iZmRfZ2Nfc2VjdGlvbnMg ICAgICAgICAgICAgIGJmZF9nZW5lcmljX2djX3NlY3Rpb25zCisjZGVmaW5l IHdhc21fYmZkX2xvb2t1cF9zZWN0aW9uX2ZsYWdzICAgICBiZmRfZ2VuZXJp Y19sb29rdXBfc2VjdGlvbl9mbGFncworI2RlZmluZSB3YXNtX2JmZF9tZXJn ZV9zZWN0aW9ucyAgICAgICAgICAgYmZkX2dlbmVyaWNfbWVyZ2Vfc2VjdGlv bnMKKyNkZWZpbmUgd2FzbV9iZmRfaXNfZ3JvdXBfc2VjdGlvbiAgICAgICAg IGJmZF9nZW5lcmljX2lzX2dyb3VwX3NlY3Rpb24KKyNkZWZpbmUgd2FzbV9i ZmRfZGlzY2FyZF9ncm91cCAgICAgICAgICAgIGJmZF9nZW5lcmljX2Rpc2Nh cmRfZ3JvdXAKKyNkZWZpbmUgd2FzbV9iZmRfbGlua19oYXNoX3RhYmxlX2Ny ZWF0ZSAgX2JmZF9nZW5lcmljX2xpbmtfaGFzaF90YWJsZV9jcmVhdGUKKyNk ZWZpbmUgd2FzbV9iZmRfbGlua19hZGRfc3ltYm9scyAgICAgICAgX2JmZF9n ZW5lcmljX2xpbmtfYWRkX3N5bWJvbHMKKyNkZWZpbmUgd2FzbV9iZmRfbGlu a19qdXN0X3N5bXMgICAgICAgICAgX2JmZF9nZW5lcmljX2xpbmtfanVzdF9z eW1zCisjZGVmaW5lIHdhc21fYmZkX2NvcHlfbGlua19oYXNoX3N5bWJvbF90 eXBlIF9iZmRfZ2VuZXJpY19jb3B5X2xpbmtfaGFzaF9zeW1ib2xfdHlwZQor I2RlZmluZSB3YXNtX2JmZF9maW5hbF9saW5rICAgICAgICAgICAgICBfYmZk X2dlbmVyaWNfZmluYWxfbGluaworI2RlZmluZSB3YXNtX2JmZF9saW5rX3Nw bGl0X3NlY3Rpb24gICAgICBfYmZkX2dlbmVyaWNfbGlua19zcGxpdF9zZWN0 aW9uCisjZGVmaW5lIHdhc21fc2VjdGlvbl9hbHJlYWR5X2xpbmtlZCAgICAg IF9iZmRfZ2VuZXJpY19zZWN0aW9uX2FscmVhZHlfbGlua2VkCisjZGVmaW5l IHdhc21fYmZkX2RlZmluZV9jb21tb25fc3ltYm9sICAgICBiZmRfZ2VuZXJp Y19kZWZpbmVfY29tbW9uX3N5bWJvbAorI2RlZmluZSB3YXNtX2JmZF9saW5r X2NoZWNrX3JlbG9jcyAgICAgICBfYmZkX2dlbmVyaWNfbGlua19jaGVja19y ZWxvY3MKKworY29uc3QgYmZkX3RhcmdldCB3YXNtX3ZlYyA9Cit7CisgICJ3 YXNtIiwgICAgICAgICAgICAgICAvKiBOYW1lICovCisgIGJmZF90YXJnZXRf dW5rbm93bl9mbGF2b3VyLAorICBCRkRfRU5ESUFOX0xJVFRMRSwKKyAgQkZE X0VORElBTl9MSVRUTEUsCisgIChIQVNfU1lNUyB8IFdQX1RFWFQpLCAgICAg ICAgICAgICAvKiBPYmplY3QgZmxhZ3MuICovCisgIChTRUNfQ09ERSB8IFNF Q19EQVRBIHwgU0VDX0hBU19DT05URU5UUyksIC8qIFNlY3Rpb24gZmxhZ3Mg Ki8KKyAgMCwgICAgICAgICAgICAgICAgICAgIC8qIExlYWRpbmcgdW5kZXJz Y29yZSAqLworICAnICcsICAgICAgICAgICAgICAgICAgLyogQVJfcGFkX2No YXIgKi8KKyAgMjU1LCAgICAgICAgICAgICAgICAgIC8qIEFSX21heF9uYW1l bGVuICovCisgIDAsCQkJCS8qIG1hdGNoIHByaW9yaXR5LiAgKi8KKyAgLyog Um91dGluZXMgdG8gYnl0ZS1zd2FwIHZhcmlvdXMgc2l6ZWQgaW50ZWdlcnMg ZnJvbSB0aGUgZGF0YSBzZWN0aW9ucyAqLworICBiZmRfZ2V0bDY0LCBiZmRf Z2V0bF9zaWduZWRfNjQsIGJmZF9wdXRsNjQsCisgIGJmZF9nZXRsMzIsIGJm ZF9nZXRsX3NpZ25lZF8zMiwgYmZkX3B1dGwzMiwKKyAgYmZkX2dldGwxNiwg YmZkX2dldGxfc2lnbmVkXzE2LCBiZmRfcHV0bDE2LAorCisgIC8qIFJvdXRp bmVzIHRvIGJ5dGUtc3dhcCB2YXJpb3VzIHNpemVkIGludGVnZXJzIGZyb20g dGhlIGZpbGUgaGVhZGVycyAqLworICBiZmRfZ2V0bDY0LCBiZmRfZ2V0bF9z aWduZWRfNjQsIGJmZF9wdXRsNjQsCisgIGJmZF9nZXRsMzIsIGJmZF9nZXRs X3NpZ25lZF8zMiwgYmZkX3B1dGwzMiwKKyAgYmZkX2dldGwxNiwgYmZkX2dl dGxfc2lnbmVkXzE2LCBiZmRfcHV0bDE2LAorCisgIHsKKyAgICBfYmZkX2R1 bW15X3RhcmdldCwKKyAgICB3YXNtX29iamVjdF9wLAkvKiBiZmRfY2hlY2tf Zm9ybWF0LiAgKi8KKyAgICBfYmZkX2R1bW15X3RhcmdldCwKKyAgICBfYmZk X2R1bW15X3RhcmdldCwKKyAgfSwKKyAgeworICAgIGJmZF9mYWxzZSwKKyAg ICB3YXNtX21rb2JqZWN0LAorICAgIF9iZmRfZ2VuZXJpY19ta2FyY2hpdmUs CisgICAgYmZkX2ZhbHNlLAorICB9LAorICB7CQkJCS8qIGJmZF93cml0ZV9j b250ZW50cy4gICovCisgICAgYmZkX2ZhbHNlLAorICAgIF9iZmRfd2FzbV93 cml0ZV9vYmplY3RfY29udGVudHMsCisgICAgX2JmZF93cml0ZV9hcmNoaXZl X2NvbnRlbnRzLAorICAgIGJmZF9mYWxzZSwKKyAgfSwKKworICBCRkRfSlVN UF9UQUJMRV9HRU5FUklDIChfYmZkX2dlbmVyaWMpLAorICBCRkRfSlVNUF9U QUJMRV9DT1BZIChfYmZkX2dlbmVyaWMpLAorICBCRkRfSlVNUF9UQUJMRV9D T1JFIChfYmZkX25vY29yZSksCisgIEJGRF9KVU1QX1RBQkxFX0FSQ0hJVkUg KF9iZmRfbm9hcmNoaXZlKSwKKyAgQkZEX0pVTVBfVEFCTEVfU1lNQk9MUyAo d2FzbSksCisgIEJGRF9KVU1QX1RBQkxFX1JFTE9DUyAoX2JmZF9ub3JlbG9j cyksCisgIEJGRF9KVU1QX1RBQkxFX1dSSVRFICh3YXNtKSwKKyAgQkZEX0pV TVBfVEFCTEVfTElOSyAod2FzbSksCisgIEJGRF9KVU1QX1RBQkxFX0RZTkFN SUMgKF9iZmRfbm9keW5hbWljKSwKKworICBOVUxMLAorCisgIE5VTEwsCit9 OwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9DaGFuZ2VMb2cgYi9pbmNsdWRlL0No YW5nZUxvZwppbmRleCBlYWNmZWI5YWM5Li5kYzQ2N2ZkMzg0IDEwMDY0NAot LS0gYS9pbmNsdWRlL0NoYW5nZUxvZworKysgYi9pbmNsdWRlL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDcgQEAKKzIwMTctMDMtMjAgIFBpcCBDZXQgIDxwaXBj ZXRAZ21haWwuY29tPgorCisJKiBlbGYvd2FzbTMyLmg6IE5ldyBmaWxlIHRv IHN1cHBvcnQgV2ViQXNzZW1ibHkgYXJjaGl0ZWN0dXJlLgorCiAyMDE3LTAz LTE2ICBOaWNrIENsaWZ0b24gIDxuaWNrY0ByZWRoYXQuY29tPgogCiAJKiBl bGYvY29tbW9uLmggKEdOVV9CVUlMRF9BVFRSSUJVVEVfU0hPUlRfRU5VTSk6 IE5ldyBHTlUgQlVJTEQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZWxmL3dhc20z Mi5oIGIvaW5jbHVkZS9lbGYvd2FzbTMyLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMC4uNGVkZDY2ZmE4YwotLS0gL2Rldi9udWxs CisrKyBiL2luY2x1ZGUvZWxmL3dhc20zMi5oCkBAIC0wLDAgKzEsMjggQEAK Ky8qIEVMRiBzdXBwb3J0IGZvciBCRkQgZm9yIHRoZSBXZWJBc3NlbWJseSB0 YXJnZXQKKyAgIENvcHlyaWdodCAoQykgMTk5OC0yMDE3IEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLgorCisgICBUaGlzIHByb2dyYW0gaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1v ZGlmeQorICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhl IExpY2Vuc2UsIG9yCisgICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorCisgICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1dCBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgICBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07 IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv biwKKyAgIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCAtIEZpZnRoIEZsb29y LCBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4gICovCisKKyNpZm5kZWYg X0VMRl9XQVNNMzJfSAorI2RlZmluZSBfRUxGX1dBU00zMl9ICisKKyNpbmNs dWRlICJlbGYvcmVsb2MtbWFjcm9zLmgiCisKKy8qIFJlbG9jYXRpb24gdHlw ZXMuICAqLworCitTVEFSVF9SRUxPQ19OVU1CRVJTIChlbGZfd2FzbTMyX3Jl bG9jX3R5cGUpCitFTkRfUkVMT0NfTlVNQkVSUyAoUl9XQVNNMzJfbWF4ID0g MSkKKworI2VuZGlmIC8qIF9FTEZfV0FTTTMyX0ggKi8K --94eb2c1cc6024eb3d0054b31c948--