From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 103607 invoked by alias); 23 Mar 2017 14:51:03 -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 100204 invoked by uid 89); 23 Mar 2017 14:51:01 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-23.7 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= X-HELO: mail-wr0-f181.google.com Received: from mail-wr0-f181.google.com (HELO mail-wr0-f181.google.com) (209.85.128.181) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 23 Mar 2017 14:50:49 +0000 Received: by mail-wr0-f181.google.com with SMTP id u1so15060056wra.2 for ; Thu, 23 Mar 2017 07:50:49 -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:in-reply-to:references:from:date :message-id:subject:to:cc; bh=V00WDOqdyl8lz0vsRFQaAPVNpE6Azh03ffzoaY5RrWI=; b=syLnkxWAwGh+UKqBIIns1dt+vXQSnZ9x0RQpUV490oO8ERqFK2XE1rF93dmm5jUd8r CQ9FKHevtDtEiTW9TcwMClWs73t24/nFXLyNZWWX18V+kDHGQgYea1Saz0W/BaP/vACm Vu8IKwn8I0UGWOzSw8facOLouLNPZhf1UxjDpj14G0BM3NUS8wcwTyhUSPHSSILV4bTp Uws8jr5VW9YygD3tef5Sh8CnUQnXGzskKMzFj5kvVAK6t2DGYQgDVd7Wr670HS68FxmL YQ79OTukzBcYknhypZVDtgMgQ6BVzY2chUa1dy+PvDPZkHzUVd9+E8ZXEaN4AwhiofdR EvHA== X-Gm-Message-State: AFeK/H1J1QCe/5IeLYH4AwqyegsANW6YhFnhZJG/dhxFxo6MsYsRqQMakXP0HmC+W9/lcKpRle9o0yzvLXW5+Q== X-Received: by 10.223.150.123 with SMTP id c56mr2919934wra.202.1490280645324; Thu, 23 Mar 2017 07:50:45 -0700 (PDT) MIME-Version: 1.0 Received: by 10.80.195.15 with HTTP; Thu, 23 Mar 2017 07:50:04 -0700 (PDT) In-Reply-To: References: <6ba7849d-2475-587d-d4a9-6e67c7df550b@redhat.com> From: Pip Cet Date: Thu, 23 Mar 2017 14:51:00 -0000 Message-ID: Subject: Re: [PATCH] [WebAssembly] Skeleton support To: Nick Clifton Cc: binutils@sourceware.org Content-Type: multipart/mixed; boundary=001a1146370a7c2950054b6700fc X-IsSubscribed: yes X-SW-Source: 2017-03/txt/msg00321.txt.bz2 --001a1146370a7c2950054b6700fc Content-Type: text/plain; charset=UTF-8 Content-length: 47968 Here is the second part of the patch, relative to the first part, adding wasm-module.c and wasm-module.h. I hope I have addressed all of your comments so far. Again, any further comments would be appreciated. I have not been able to completely remove the LEB128 code; reading an LEB128 integer from a file stream without knowing the length of either the integer or the stream, while advancing the file position properly and handling errors and EOF, is quite different from reading the same integer from a buffer with a known endpoint (also, _bfd_safe_read_leb128 provides no way of knowing whether the end of the buffer was reached after a complete LEB128 integer rather than in the middle of one; I'm still trying to figure out whether that's a bug). Thanks, Pip ----------- Suggested change log entry: 2017-03-23 Pip Cet * wasm-module.c: New file to support WebAssembly modules. * wasm-module.h: New file to support WebAssembly modules. * doc/webassembly.texi: Start documenting wasm-module.c. * config.bfd: Add wasm_vec. * targets.c: Likewise. * configure.ac: Likewise. * Makefile.am: Add entries for wasm-module.c. diff --git a/bfd/Makefile.am b/bfd/Makefile.am index 6fa8302020..49ab092fc3 100644 --- a/bfd/Makefile.am +++ b/bfd/Makefile.am @@ -459,6 +459,7 @@ BFD32_BACKENDS = \ versados.lo \ vms-lib.lo \ vms-misc.lo \ + wasm-module.lo \ xcofflink.lo \ xsym.lo \ xtensa-isa.lo \ @@ -652,6 +653,7 @@ BFD32_BACKENDS_CFILES = \ versados.c \ vms-lib.c \ vms-misc.c \ + wasm-module.c \ xcofflink.c \ xsym.c \ xtensa-isa.c \ diff --git a/bfd/config.bfd b/bfd/config.bfd index abcb7ae210..1235c2cb86 100644 --- a/bfd/config.bfd +++ b/bfd/config.bfd @@ -1796,6 +1796,7 @@ case "${targ}" in wasm32-*-*) targ_defvec=wasm32_elf32_vec + targ_selvecs="wasm_vec" ;; we32k-*-*) diff --git a/bfd/configure.ac b/bfd/configure.ac index 77961945d1..feb1231c91 100644 --- a/bfd/configure.ac +++ b/bfd/configure.ac @@ -700,6 +700,7 @@ 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 ;; diff --git a/bfd/doc/webassembly.texi b/bfd/doc/webassembly.texi new file mode 100644 index 0000000000..ad650943a1 --- /dev/null +++ b/bfd/doc/webassembly.texi @@ -0,0 +1,33 @@ +@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. + +There are slight differences in the LEB128 integer implementations +between the WebAssembly specification and the BFD code; these result +in some malformed WebAssembly modules being treated as valid. + +@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/targets.c b/bfd/targets.c index 74559ac4c6..5841e8d6e5 100644 --- a/bfd/targets.c +++ b/bfd/targets.c @@ -893,6 +893,7 @@ 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; @@ -1422,6 +1423,7 @@ static const bfd_target * const _bfd_target_vector[] = &w65_coff_vec, + &wasm_vec, &wasm32_elf32_vec, &we32k_coff_vec, diff --git a/bfd/wasm-module.c b/bfd/wasm-module.c new file mode 100644 index 0000000000..7941745894 --- /dev/null +++ b/bfd/wasm-module.c @@ -0,0 +1,845 @@ +/* BFD back-end for WebAssembly modules. + Copyright (C) 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" +#include "wasm-module.h" + +typedef struct +{ + asymbol *symbols; + bfd_size_type symcount; +} tdata_type; + +static const char * const wasm_numbered_sections[] = { + NULL, /* custom section, different layout */ + WASM_SECTION( 1, "type"), + WASM_SECTION( 2, "import"), + WASM_SECTION( 3, "function"), + WASM_SECTION( 4, "table"), + WASM_SECTION( 5, "memory"), + WASM_SECTION( 6, "global"), + WASM_SECTION( 7, "export"), + WASM_SECTION( 8, "start"), + WASM_SECTION( 9, "element"), + WASM_SECTION(10, "code"), + WASM_SECTION(11, "data"), +}; + +#define WASM_NUMBERED_SECTIONS (sizeof (wasm_numbered_sections) / sizeof (wasm_numbered_sections[0])) + +/* Resolve SECTION_CODE to a section name if there is one, NULL + otherwise. */ +static const char * +wasm_section_code_to_name (bfd_byte section_code) +{ + if (section_code < WASM_NUMBERED_SECTIONS) + { + return wasm_numbered_sections[section_code]; + } + + return NULL; +} + +/* Translate section name NAME to a section code, or 0 if it's a + custom name. */ +static int +wasm_section_name_to_code (const char *name) +{ + unsigned i; + for (i = 1; i < WASM_NUMBERED_SECTIONS; i++) + { + if (strcmp (name, wasm_numbered_sections[i]) == 0) + return i; + } + + return 0; +} + +/* WebAssembly LEB128 integers are sufficiently like DWARF LEB128 + integers that we use _bfd_safe_read_leb128, but there are two + points of difference: + + - WebAssembly requires a 32-bit value to be encoded in at most 5 + bytes, etc. + - _bfd_safe_read_leb128 accepts incomplete LEB128 encodings at the + end of the buffer, while these are invalid in WebAssembly. + + Those differences mean that we will accept some files that are + invalid WebAssembly. */ + +/* Read an LEB128-encoded integer from ABFD's I/O stream, reading one + byte at a time. Set ERROR_RETURN if no complete integer could be + read, LENGTH_RETURN to the number of bytes read (including bytes in + incomplete numbers). SIGN means interpret the number as SLEB128. */ +static bfd_vma +wasm_read_leb128 (bfd *abfd, + bfd_boolean *error_return, + unsigned int *length_return, + bfd_boolean sign) +{ + bfd_vma result = 0; + unsigned int num_read = 0; + unsigned int shift = 0; + unsigned char byte = 0; + bfd_boolean success = FALSE; + + while (bfd_bread (&byte, 1, abfd) == 1) + { + num_read++; + + result |= ((bfd_vma) (byte & 0x7f)) << shift; + + shift += 7; + if ((byte & 0x80) == 0) + { + success = TRUE; + break; + } + } + + if (length_return != NULL) + *length_return = num_read; + if (error_return != NULL) + *error_return = ! success; + + if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40)) + result |= -((bfd_vma) 1 << shift); + + return result; +} + +/* Encode an integer V as LEB128 and write it to ABFD, return TRUE on + success. */ +static bfd_boolean +wasm_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; +} + +/* Read COUNT bytes from ABFD into BUF, jumping to error_return on + failure. */ +#define READ_ALL(buf, count, abfd) \ + do \ + { \ + if (bfd_bread(buf, count, abfd) != count) \ + goto error_return; \ + } \ + while (0) + +/* Read the LEB128 integer at P, saving it to X; at end of buffer, + jump to error_return. */ +#define READ_LEB128(x, p, end) \ + do \ + { \ + unsigned int length_read; \ + (x) = _bfd_safe_read_leb128 (abfd, (p), &length_read, \ + FALSE, (end)); \ + (p) += length_read; \ + if (length_read == 0) \ + goto error_return; \ + } \ + while (0) + +/* Verify the magic number at the beginning of a WebAssembly module + ABFD, setting ERRORPTR if there's a mismatch. */ +static bfd_boolean +wasm_read_magic (bfd *abfd, bfd_boolean *errorptr) +{ + bfd_byte magic_const[] = WASM_MAGIC; + bfd_byte magic[4]; + + READ_ALL (magic, 4, abfd); + + if (memcmp (magic, magic_const, 4) != 0) + goto error_return; + + return TRUE; + + error_return: + *errorptr = TRUE; + return FALSE; +} + +/* Read the version number from ABFD, returning TRUE if it's a supported + version. Set ERRORPTR otherwise. */ +static bfd_boolean +wasm_read_version (bfd *abfd, bfd_boolean *errorptr) +{ + bfd_byte vers[4]; + bfd_byte vers_const[] = WASM_VERSION; + + READ_ALL (vers, (bfd_size_type) 4, abfd); + + /* Don't attempt to parse newer versions, which are likely to + require code changes. */ + if (memcmp (vers, vers_const, 4) != 0) + goto error_return; + + return TRUE; + + error_return: + *errorptr = TRUE; + return FALSE; +} + +/* Read the WebAssembly header (magic number plus version number) from + ABFD, setting ERRORPTR to TRUE if there is a mismatch. */ +static bfd_boolean +wasm_read_header (bfd *abfd, bfd_boolean *errorptr) +{ + if (! wasm_read_magic (abfd, errorptr)) + return FALSE; + + if (! wasm_read_version (abfd, errorptr)) + return FALSE; + + return TRUE; +} + +/* Scan the "function" subsection of the "name" section ASECT in the + wasm module ABFD. Create symbols. Return TRUE on success. */ +static bfd_boolean +wasm_scan_name_function_section (bfd *abfd, sec_ptr asect) +{ + bfd_byte *p; + bfd_byte *end; + bfd_vma payload_size; + bfd_vma symcount = 0; + tdata_type *tdata = abfd->tdata.any; + asymbol *symbols = NULL; + sec_ptr space_function_index; + + if (! asect) + return FALSE; + + if (strcmp (asect->name, WASM_NAME_SECTION) != 0) + return FALSE; + + p = asect->contents; + end = asect->contents + asect->size; + + if (! p) + return FALSE; + + while (p < end) + { + bfd_byte subsection_code = *p++; + if (subsection_code == WASM_FUNCTION_SUBSECTION) + break; + + /* subsection_code is documented to be a varuint7, meaning that + it has to be a single byte in the 0 - 127 range. If it isn't, + the spec must have changed underneath us, so give up. */ + if (subsection_code & 0x80) + return FALSE; + + READ_LEB128 (payload_size, p, end); + + if (p > p + payload_size) + return FALSE; + + p += payload_size; + } + + if (p >= end) + return FALSE; + + READ_LEB128 (payload_size, p, end); + + if (p > p + payload_size) + return FALSE; + + if (p + payload_size > end) + return FALSE; + + end = p + payload_size; + + READ_LEB128 (symcount, p, end); + + /* sanity check: each symbol has at least two bytes. */ + if (symcount > payload_size/2) + return FALSE; + + tdata->symcount = symcount; + + space_function_index = bfd_make_section_with_flags (abfd, WASM_SECTION_FUNCTION_INDEX, SEC_READONLY | SEC_CODE); + if (! space_function_index) + space_function_index = bfd_get_section_by_name (abfd, WASM_SECTION_FUNCTION_INDEX); + + if (! space_function_index) + return FALSE; + + symbols = bfd_zalloc (abfd, tdata->symcount * sizeof (asymbol)); + if (! symbols) + return FALSE; + + for (symcount = 0; p < end && symcount < tdata->symcount; symcount++) + { + bfd_vma index; + bfd_vma len; + char *name; + asymbol *sym; + + READ_LEB128 (index, p, end); + READ_LEB128 (len, p, end); + + if (p + len < p || p + len > end) + goto error_return; + + name = bfd_zalloc (abfd, len + 1); + if (! name) + goto error_return; + + memcpy (name, p, len); + p += len; + + 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; + } + + if (symcount < tdata->symcount) + goto error_return; + + tdata->symbols = symbols; + abfd->symcount = symcount; + + return TRUE; + + error_return: + while (symcount) + bfd_release (abfd, (void *)symbols[--symcount].name); + bfd_release (abfd, symbols); + return FALSE; +} + +/* Read a byte from ABFD and return it, or EOF for EOF or error. Set + ERRORPTR on non-EOF error. + + This differs from READ_ALL because we don't know whether there is + another section to be read at EOF. */ +static int +wasm_read_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; +} + +/* Scan the wasm module ABFD, creating sections and symbols. Return + TRUE on success. */ +static bfd_boolean +wasm_scan (bfd *abfd) +{ + bfd_boolean error = FALSE; + /* fake VMAs for now. Choose 0x80000000 as base to avoid clashes + with actual data addresses. */ + bfd_vma vma = 0x80000000; + int section_code; + unsigned int bytes_read; + char *name = NULL; + + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) + goto error_return; + + if (! wasm_read_header (abfd, &error)) + goto error_return; + + while ((section_code = wasm_read_byte (abfd, &error)) != EOF) + { + asection *bfdsec; + + if (section_code != 0) + { + const char *sname = wasm_section_code_to_name (section_code); + + if (! sname) + goto error_return; + + name = strdup (sname); + bfdsec = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); + if (bfdsec == NULL) + goto error_return; + name = NULL; + + bfdsec->vma = vma; + bfdsec->lma = vma; + bfdsec->size = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE); + if (error) + goto error_return; + bfdsec->filepos = bfd_tell (abfd); + bfdsec->alignment_power = 0; + } + else + { + bfd_vma payload_len; + file_ptr section_start; + bfd_vma namelen; + char *prefix = WASM_SECTION_PREFIX; + char *p; + int ret; + + payload_len = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE); + if (error) + goto error_return; + section_start = bfd_tell (abfd); + namelen = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE); + if (error || namelen > payload_len) + goto error_return; + name = bfd_zmalloc (namelen + strlen (prefix) + 1); + if (! name) + goto error_return; + p = name; + ret = sprintf (p, "%s", prefix); + if (ret < 0 || (bfd_vma) ret != strlen (prefix)) + goto error_return; + p += ret; + READ_ALL (p, namelen, abfd); + + bfdsec = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); + if (bfdsec == NULL) + goto error_return; + name = NULL; + + bfdsec->vma = vma; + bfdsec->lma = vma; + bfdsec->filepos = bfd_tell (abfd); + bfdsec->size = section_start + payload_len - bfdsec->filepos; + bfdsec->alignment_power = 0; + } + + if (bfdsec->size != 0) + { + bfdsec->contents = bfd_zalloc (abfd, bfdsec->size); + if (! bfdsec->contents) + goto error_return; + + READ_ALL (bfdsec->contents, bfdsec->size, abfd); + } + + 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; + + return TRUE; + + error_return: + if (name) + free (name); + + for (asection *bfdsec = abfd->sections; bfdsec; bfdsec = bfdsec->next) + free ((void *) bfdsec->name); + + return FALSE; +} + +/* Put a numbered section ASECT of ABFD into the table of numbered + sections pointed to by FSARG. */ +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 == 0) + return; + + numbered_sections[index] = asect; +} + +struct compute_section_arg +{ + bfd_vma pos; + bfd_boolean failed; +}; + +/* Compute the file position of ABFD's section ASECT. FSARG is a + pointer to the current file position. + + We allow section names of the form .wasm.id to encode the numbered + section with ID id, if it exists; otherwise, a custom section with + ID "id" is produced. Arbitrary section names are for sections that + are assumed already to contain a section header; those are appended + to the WebAssembly module verbatim. */ +static void +wasm_compute_custom_section_file_position (bfd *abfd, sec_ptr asect, + void *fsarg) +{ + struct compute_section_arg *fs = fsarg; + int index; + + if (fs->failed) + return; + + index = wasm_section_name_to_code (asect->name); + + if (index != 0) + return; + + if (CONST_STRNEQ (asect->name, WASM_SECTION_PREFIX)) + { + const char *name = asect->name + strlen (WASM_SECTION_PREFIX); + 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 (! wasm_write_uleb128 (abfd, 0) + || ! wasm_write_uleb128 (abfd, payload_len) + || ! wasm_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; +} + +/* Compute the file positions for the sections of ABFD. Currently, + this writes all numbered sections first, in order, then all custom + sections, in section order. + + The spec says that the numbered sections must appear in order of + their ids, but custom sections can appear in any position and any + order, and more than once. FIXME: support that. */ +static bfd_boolean +wasm_compute_section_file_positions (bfd *abfd) +{ + bfd_byte magic[] = WASM_MAGIC; + bfd_byte vers[] = WASM_VERSION; + sec_ptr numbered_sections[WASM_NUMBERED_SECTIONS]; + struct compute_section_arg fs; + unsigned int i; + + bfd_seek (abfd, (bfd_vma) 0, SEEK_SET); + + if (bfd_bwrite (magic, sizeof (magic), abfd) != (sizeof magic) + || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers)) + return FALSE; + + for (i = 0; i < WASM_NUMBERED_SECTIONS; i++) + numbered_sections[i] = NULL; + + bfd_map_over_sections (abfd, wasm_register_section, numbered_sections); + + fs.pos = bfd_tell (abfd); + for (i = 0; i < WASM_NUMBERED_SECTIONS; i++) + { + sec_ptr sec = numbered_sections[i]; + bfd_size_type size; + + if (! sec) + continue; + size = sec->size; + if (bfd_seek (abfd, fs.pos, SEEK_SET) != 0) + return FALSE; + if (! wasm_write_uleb128 (abfd, i) + || ! wasm_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; + + abfd->output_has_begun = TRUE; + + 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 +wasm_write_object_contents (bfd* abfd) +{ + bfd_byte magic[] = WASM_MAGIC; + bfd_byte vers[] = WASM_VERSION; + + if (bfd_seek (abfd, 0, SEEK_SET) != 0) + return FALSE; + + if (bfd_bwrite (magic, sizeof (magic), abfd) != sizeof (magic) + || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers)) + 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 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); +} + +/* Check whether ABFD is a WebAssembly module; if so, scan it. */ +static const bfd_target * +wasm_object_p (bfd *abfd) +{ + bfd_boolean error; + + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) + return NULL; + + if (! wasm_read_header (abfd, &error)) + { + 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 (wasm_scan_name_function_section (abfd, bfd_get_section_by_name (abfd, WASM_NAME_SECTION))) + { + 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 + +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, + 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 (_bfd_nolink), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + + NULL, + + NULL, +}; diff --git a/bfd/wasm-module.h b/bfd/wasm-module.h new file mode 100644 index 0000000000..b6cb7d565f --- /dev/null +++ b/bfd/wasm-module.h @@ -0,0 +1,52 @@ +/* BFD back-end for WebAssembly modules. + Copyright (C) 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. */ + +#ifndef _WASM_MODULE_H +#define _WASM_MODULE_H + +/* WebAssembly module file header. Note that WASM_VERSION is a 32-bit + little-endian integer, not an LEB128-encoded integer. */ +#define WASM_MAGIC { 0x00, 'a', 's', 'm' } +#define WASM_VERSION { 0x01, 0x00, 0x00, 0x00} + +/* Prefix to use to form section names. */ +#define WASM_SECTION_PREFIX ".wasm." + +/* NUMBER is currently unused, but is included for error checking + purposes. */ +#define WASM_SECTION(number, name) (WASM_SECTION_PREFIX name) + +/* section names. WASM_NAME_SECTION is the name of the named section + named "name". */ +#define WASM_NAME_SECTION WASM_SECTION(0, "name") +#define WASM_RELOC_SECTION_PREFIX WASM_SECTION(0, "reloc.") +#define WASM_LINKING_SECTION WASM_SECTION(0, "linking") +#define WASM_DYLINK_SECTION WASM_SECTION(0, "dylink") + +/* subsection indices. Right now, that's subsections of the "name" + section only. */ +#define WASM_FUNCTION_SUBSECTION 1 /* function names */ +#define WASM_LOCALS_SUBSECTION 2 /* names of locals by function */ + + +/* The section to report wasm symbols in. */ +#define WASM_SECTION_FUNCTION_INDEX ".space.function_index" + +#endif /* _WASM_MODULE_H */ On Thu, Mar 23, 2017 at 2:55 AM, Pip Cet wrote: > Okay, here's the first part of the changes, adding a new architecture, > wasm32, and minimal ELF support. I've left the date range in the > copyright notice for elf32-wasm32.c because future patches will add > substantial parts from other architectures' ELF support files; if that > needs changing, please let me know. > > Any comments would be appreciated. > Thanks, > Pip > > Suggested change log entries: > include/: > 2017-03-22 Pip Cet > > * elf/wasm32.h: New file to support wasm32 architecture. > > bfd/: > 2017-03-22 Pip Cet > * cpu-wasm32.c: New file to support wasm32 architecture. > * elf32-wasm32.c: New file to support wasm32 architecture. > * Makefile.am: Add wasm32 architecture. > * archures.c: Likewise. > * config.bfd: Likewise. > * configure.ac: Likewise. > * targets.c: Likewise. > ----- > > diff --git a/bfd/Makefile.am b/bfd/Makefile.am > index 0b0226306f..6fa8302020 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 \ > @@ -383,6 +385,7 @@ BFD32_BACKENDS = \ > elf32-v850.lo \ > elf32-vax.lo \ > elf32-visium.lo \ > + elf32-wasm32.lo \ > elf32-xc16x.lo \ > elf32-xgate.lo \ > elf32-xstormy16.lo \ > @@ -576,6 +579,7 @@ BFD32_BACKENDS_CFILES = \ > elf32-v850.c \ > elf32-vax.c \ > elf32-visium.c \ > + elf32-wasm32.c \ > elf32-xc16x.c \ > elf32-xgate.c \ > elf32-xstormy16.c \ > diff --git a/bfd/archures.c b/bfd/archures.c > index c909db012d..c6e7152057 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, {* WebAssembly *} > +.#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/config.bfd b/bfd/config.bfd > index 52db9a47f1..abcb7ae210 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,10 @@ case "${targ}" in > targ_defvec=visium_elf32_vec > ;; > > + wasm32-*-*) > + targ_defvec=wasm32_elf32_vec > + ;; > + > we32k-*-*) > targ_defvec=we32k_coff_vec > ;; > diff --git a/bfd/configure.ac b/bfd/configure.ac > index ee0c537ea2..77961945d1 100644 > --- a/bfd/configure.ac > +++ b/bfd/configure.ac > @@ -700,6 +700,7 @@ 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" ;; > + 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..19d4cb9270 > --- /dev/null > +++ b/bfd/cpu-wasm32.c > @@ -0,0 +1,36 @@ > +/* BFD support for the WebAssembly target > + Copyright (C) 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/elf32-wasm32.c b/bfd/elf32-wasm32.c > new file mode 100644 > index 0000000000..2088146cc4 > --- /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 EM_WEBASSEMBLY > +#define ELF_MACHINE_CODE EM_WEBASSEMBLY > +/* 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/targets.c b/bfd/targets.c > index 1a7c6b87d6..74559ac4c6 100644 > --- a/bfd/targets.c > +++ b/bfd/targets.c > @@ -893,6 +893,7 @@ 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 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; > @@ -1421,6 +1422,8 @@ static const bfd_target * const _bfd_target_vector[] = > > &w65_coff_vec, > > + &wasm32_elf32_vec, > + > &we32k_coff_vec, > > #ifdef BFD64 > diff --git a/include/elf/wasm32.h b/include/elf/wasm32.h > new file mode 100644 > index 0000000000..38e6c2e950 > --- /dev/null > +++ b/include/elf/wasm32.h > @@ -0,0 +1,28 @@ > +/* ELF support for BFD for the WebAssembly target > + Copyright (C) 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 */ > > On Wed, Mar 22, 2017 at 4:11 PM, Pip Cet wrote: >> Hi Nick, >> thank you very much for your comments. If it's okay, I shall split the >> patch into two parts (one for the skeleton code, one for wasm-module.c >> plus the new header file), address your comments, and try again. >> >> On Wed, Mar 22, 2017 at 12:55 PM, Nick Clifton wrote: >>> It is often easier (for us) if changelog entries are not included in >>> the patch, but instead are just part of the accompanying email. This >>> is because they almost never apply when patching the sources, and so >>> they always have to be added by hand. >> >> Thanks, noted. >> >>>> 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. >>> >>> Given that this file is brand new, it is hard to see how the FSF can claim >>> copyright from 1994... >> >> You're right; it is based on an older file, but has been replaced entirely. >> >>>> +#define ELF_TARGET_ID 0x4157 /* 'WA' */ >>>> +#define ELF_MACHINE_CODE 0x4157 /* 'WA' */ >>> >>> You could use the value EM_WEBASSEMBLY here. It is defined in include/elf/common.h. >>> >>>> +++ 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; >>> >>> You missed out a required patch to this file. The _bfd_target_vector >>> array (starting at line 940) needs to have the new wasm vectors added to it. >>> To see why, try building a set of the binutils sources configured as: >>> >>> --enable-64-bit-bfd --enable-targets=all >> >> Thanks! >> >>>> diff --git a/bfd/wasm-module.c b/bfd/wasm-module.c >>> >>>> +/* 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) >>> >>> Given that you are duplicating code that is already in another source file, >>> it might be better to just change those functions to non-static and use them >>> directly. This avoids unnecessary code duplication... >> >> Yeah, the situation for the LEB128 code in particular is a bit diffuse >> at the moment: by my count, there are eleven files (including gdb and >> gold in the count) defining at least one LEB128 function, with >> different calling conventions, return types, and error behaviour. I'd >> like to remedy that in a future patch, but for now the risk of >> namespace collisions convinced me not to export the ELF functions. >> >>>> +static bfd_vma >>>> +wasm_get_uleb128 (bfd* abfd, bfd_boolean* error) >>> >>> It is *very* helpful to have a comment before the start of a function, >>> explaining what it does. (Well if it is a non-trivial function). >> >> Thanks, I shall add those. >> >>> In >>> particular I wondered why you need a webasm specific ULEB128 reading >>> function. Does webasm use non-standard ULEB128 values, or is there >>> something else going on ? >> >> The problem is that WebAssembly doesn't consider it necessary to tell >> you in advance how much data there is to be read, so EOF needs to be >> handled carefully. (The other deviation is that WebAssembly allows >> overlong LEB128 representations, but only if the number of bytes >> doesn't exceed the maximum for the integer size (5 bytes for 32 bits, >> usually)). Now that I write it down this should definitely go into >> separate functions... >> >>> Given that there are already LEB128 reading functions in libbfd.c, maybe >>> they could be used instead ? >> >> I'll give that another try. >> >>>> + { >>>> + if (bfd_get_error () != bfd_error_file_truncated) >>>> + *errorptr = TRUE; >>>> + return FALSE; >>>> + } >>> >>> Why is it not an error if the read failed for some reason other than file >>> truncation ? >> >> I may be misreading the code; the intention is that *errorptr is set >> to TRUE, indicating an error, for all reasons except for file >> truncation, which indicates EOF, which is not an error if we're done >> with the last section. >> >>>> +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; >>>> + } >>> >>> This particular piece of code is repeated several times in the wasm-module.c >>> source file. Perhaps this is a suitable case for a macro or inline function ? >> >> Yes, I'll make it one. >> >>>> +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; >>> >>> Please move variable declarations to the start of the block. (So >>> that the sources can be built with any ISO-C compliant C compiler, >>> not just gcc). >> >> I'll add -Wdeclaration-after-statement to my C flags. Perhaps this >> should be added to warning.m4? >> >> (I tried that, and there are a number of places that trigger the >> warning; I fixed them, mostly to check that there were no actual bugs, >> and things build cleanly with the warning now. Should I submit a patch >> for that?) >> >>>> + while (p && p < end) >>>> + { >>>> + if (*p++ == 1) >>>> + break; >>>> + bfd_vma payload_size; >>>> + if (!read_uleb128 (&p, end, &payload_size)) >>>> + return FALSE; >>>> + >>>> + p += payload_size; >>>> + } >>> >>> A very large value for payload_size could result in p wrapping round >>> to before asect->contents. Is there a maximum known payload size ? >> >> Thanks for spotting that! >> >>> If so then you ought to check for it here. Otherwise check that: >>> p < p + payload_size < end >> >> Will do. >> >>>> + bfd_vma payload_size; >>> >>> You are declaring payload_size twice in this function! >> >> Oops, sorry about that. >> >>> Phew - well that is it for a first pass. I hope that these comments were helpful. >> >> They are, absolutely. Thanks again, and sorry for causing you so much work, >> Pip --001a1146370a7c2950054b6700fc Content-Type: text/plain; charset=US-ASCII; name="binutils-wasm-004.diff" Content-Disposition: attachment; filename="binutils-wasm-004.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_j0mijk980 Content-length: 39890 ZGlmZiAtLWdpdCBhL2JmZC9NYWtlZmlsZS5hbSBiL2JmZC9NYWtlZmlsZS5h bQppbmRleCA2ZmE4MzAyMDIwLi40OWFiMDkyZmMzIDEwMDY0NAotLS0gYS9i ZmQvTWFrZWZpbGUuYW0KKysrIGIvYmZkL01ha2VmaWxlLmFtCkBAIC00NTks NiArNDU5LDcgQEAgQkZEMzJfQkFDS0VORFMgPSBcCiAJdmVyc2Fkb3MubG8g XAogCXZtcy1saWIubG8gXAogCXZtcy1taXNjLmxvIFwKKwl3YXNtLW1vZHVs ZS5sbyBcCiAJeGNvZmZsaW5rLmxvIFwKIAl4c3ltLmxvIFwKIAl4dGVuc2Et aXNhLmxvIFwKQEAgLTY1Miw2ICs2NTMsNyBAQCBCRkQzMl9CQUNLRU5EU19D RklMRVMgPSBcCiAJdmVyc2Fkb3MuYyBcCiAJdm1zLWxpYi5jIFwKIAl2bXMt bWlzYy5jIFwKKwl3YXNtLW1vZHVsZS5jIFwKIAl4Y29mZmxpbmsuYyBcCiAJ eHN5bS5jIFwKIAl4dGVuc2EtaXNhLmMgXApkaWZmIC0tZ2l0IGEvYmZkL2Nv bmZpZy5iZmQgYi9iZmQvY29uZmlnLmJmZAppbmRleCBhYmNiN2FlMjEwLi4x MjM1YzJjYjg2IDEwMDY0NAotLS0gYS9iZmQvY29uZmlnLmJmZAorKysgYi9i ZmQvY29uZmlnLmJmZApAQCAtMTc5Niw2ICsxNzk2LDcgQEAgY2FzZSAiJHt0 YXJnfSIgaW4KIAogICB3YXNtMzItKi0qKQogICAgIHRhcmdfZGVmdmVjPXdh c20zMl9lbGYzMl92ZWMKKyAgICB0YXJnX3NlbHZlY3M9Indhc21fdmVjIgog ICAgIDs7CiAKICAgd2UzMmstKi0qKQpkaWZmIC0tZ2l0IGEvYmZkL2NvbmZp Z3VyZS5hYyBiL2JmZC9jb25maWd1cmUuYWMKaW5kZXggNzc5NjE5NDVkMS4u ZmViMTIzMWM5MSAxMDA2NDQKLS0tIGEvYmZkL2NvbmZpZ3VyZS5hYworKysg Yi9iZmQvY29uZmlndXJlLmFjCkBAIC03MDAsNiArNzAwLDcgQEAgZG8KICAg ICBmdDMyX2VsZjMyX3ZlYykJCSB0Yj0iJHRiIGVsZjMyLWZ0MzIubG8gZWxm MzIubG8gJGVsZiIgOzsKICAgICB2aXNpdW1fZWxmMzJfdmVjKQkJIHRiPSIk dGIgZWxmMzItdmlzaXVtLmxvIGVsZjMyLmxvICRlbGYiIDs7CiAgICAgdzY1 X2NvZmZfdmVjKQkJIHRiPSIkdGIgY29mZi13NjUubG8gcmVsb2MxNi5sbyAk Y29mZmdlbiIgOzsKKyAgICB3YXNtX3ZlYykgICAgICAgICAgICAgICAgICAg IHRiPSIkdGIgd2FzbS1tb2R1bGUubG8iIDs7CiAgICAgd2FzbTMyX2VsZjMy X3ZlYykgICAgICAgICAgICB0Yj0iJHRiIGVsZjMyLXdhc20zMi5sbyBlbGYz Mi5sbyAkZWxmIiA7OwogICAgIHdlMzJrX2NvZmZfdmVjKQkJIHRiPSIkdGIg Y29mZi13ZTMyay5sbyAkY29mZmdlbiIgOzsKICAgICB4ODZfNjRfY29mZl92 ZWMpCQkgdGI9IiR0YiBjb2ZmLXg4Nl82NC5sbyAkY29mZiI7IHRhcmdldF9z aXplPTY0IDs7CmRpZmYgLS1naXQgYS9iZmQvZG9jL3dlYmFzc2VtYmx5LnRl eGkgYi9iZmQvZG9jL3dlYmFzc2VtYmx5LnRleGkKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uYWQ2NTA5NDNhMQotLS0gL2Rldi9u dWxsCisrKyBiL2JmZC9kb2Mvd2ViYXNzZW1ibHkudGV4aQpAQCAtMCwwICsx LDMzIEBACitAc2VjdGlvbiBXZWJBc3NlbWJseSBiYWNrZW5kCitUaGUgV2Vi QXNzZW1ibHkgbW9kdWxlIGZpbGUgZm9ybWF0LCBhdCBwcmVzZW50LCBpcyBh IHZlcnkgc2ltcGxlCitvYmplY3QgZmlsZSBmb3JtYXQgd2l0aCB1cCB0byAx MSBudW1iZXJlZCBzZWN0aW9ucyBwbHVzIG5hbWVkCitgYGN1c3RvbScnIHNl Y3Rpb25zLiBBdCBwcmVzZW50LCB0aGVyZSBpcyBubyBzdGFuZGFyZCBmb3Ig cmVsb2NhdGlvbnMKK29yIHN5bWJvbHMsIHRob3VnaCBhIEBjb2RleyJuYW1l In0gc3Vic2VjdGlvbiBjYW4gYXNzaWduIG5hbWVzIHRvCitmdW5jdGlvbiBp bmRpY2VzIGFuZCBsb2NhbCB2YXJpYWJsZXMuCisKK0FzIHN1Y2gsIGl0IG9m ZmVycyBubyByZWFsIGFkdmFudGFnZXMgb3ZlciBFTEYsIGFuZCBpbnRlcm1l ZGlhdGUgRUxGCitmaWxlcyBjYW4gYmUgdXNlZCB0byBwcm9kdWNlIFdlYkFz c2VtYmx5IG1vZHVsZXMuIFRoZSBXZWJBc3NlbWJseQorYmFja2VuZCBhaW1z IHRvIGVuYWJsZSB0aGUgb3Bwb3NpdGU6IHJlYWRpbmcgYSBXZWJBc3NlbWJs eSBtb2R1bGUgYW5kCitwcm9kdWNpbmcgYW4gRUxGIGZpbGUgY29udGFpbmlu ZyB0aGUgc2FtZSBpbmZvcm1hdGlvbiwgd2hpY2ggY2FuIHRoZW4KK2JlIG1h bmlwdWxhdGVkIGFuZCBpbnNwZWN0ZWQgd2l0aCBzdGFuZGFyZCB0b29scy4K KworV2hlbiB3cml0aW5nIFdlYkFzc2VtYmx5IG1vZHVsZXMsIHRoZSBXZWJB c3NlbWJseSBiYWNrZW5kIGF0dGVtcHRzIHRvCitkZXRlcm1pbmUgYmFzZWQg b24gdGhlIHNlY3Rpb24gbmFtZSB3aGV0aGVyIHRvIHVzZSBhIG51bWVyaWMg c2VjdGlvbgoraWQsIGEgbmFtZWQgc2VjdGlvbiBoZWFkZXIsIG9yIHRvIGlu Y2x1ZGUgdGhlIHNlY3Rpb24gdmVyYmF0aW0sCithc3N1bWluZyBpdCBhbHJl YWR5IGNvbnRhaW5zIGFueSBuZWNlc3NhcnkgaGVhZGVyLgorCitGdW5jdGlv biBuYW1lcyBhcmUgc3VwcG9ydGVkIGFzIHN5bWJvbHM7IGxvY2FsIG5hbWVz IGFuZCBXZWJBc3NlbWJseQorcmVsb2NhdGlvbiBzZWN0aW9ucyBhcmUgY3Vy cmVudGx5IHVuc3VwcG9ydGVkLgorCitUaGVyZSBhcmUgc2xpZ2h0IGRpZmZl cmVuY2VzIGluIHRoZSBMRUIxMjggaW50ZWdlciBpbXBsZW1lbnRhdGlvbnMK K2JldHdlZW4gdGhlIFdlYkFzc2VtYmx5IHNwZWNpZmljYXRpb24gYW5kIHRo ZSBCRkQgY29kZTsgdGhlc2UgcmVzdWx0CitpbiBzb21lIG1hbGZvcm1lZCBX ZWJBc3NlbWJseSBtb2R1bGVzIGJlaW5nIHRyZWF0ZWQgYXMgdmFsaWQuCisK K0BtZW51CisqIEZpbGUgbGF5b3V0OjoKK0BlbmQgbWVudQorCitAbm9kZSBG aWxlIGxheW91dCwgV2ViQXNzZW1ibHkKK0BzdWJzZWN0aW9uIEZpbGUgbGF5 b3V0CitGb3IgYSBkZXNjcmlwdGlvbiBvZiB0aGUgV2ViQXNzZW1ibHkgZmls ZSBmb3JtYXQsIHNlZQorQHVybHtodHRwczovL2dpdGh1Yi5jb20vV2ViQXNz ZW1ibHkvZGVzaWduL2Jsb2IvbWFzdGVyL0JpbmFyeUVuY29kaW5nLm1kfS4K ZGlmZiAtLWdpdCBhL2JmZC90YXJnZXRzLmMgYi9iZmQvdGFyZ2V0cy5jCmlu ZGV4IDc0NTU5YWM0YzYuLjU4NDFlOGQ2ZTUgMTAwNjQ0Ci0tLSBhL2JmZC90 YXJnZXRzLmMKKysrIGIvYmZkL3RhcmdldHMuYwpAQCAtODkzLDYgKzg5Myw3 IEBAIGV4dGVybiBjb25zdCBiZmRfdGFyZ2V0IHZheF9hb3V0X25ic2RfdmVj OwogZXh0ZXJuIGNvbnN0IGJmZF90YXJnZXQgdmF4X2VsZjMyX3ZlYzsKIGV4 dGVybiBjb25zdCBiZmRfdGFyZ2V0IHZpc2l1bV9lbGYzMl92ZWM7CiBleHRl cm4gY29uc3QgYmZkX3RhcmdldCB3NjVfY29mZl92ZWM7CitleHRlcm4gY29u c3QgYmZkX3RhcmdldCB3YXNtX3ZlYzsKIGV4dGVybiBjb25zdCBiZmRfdGFy Z2V0IHdhc20zMl9lbGYzMl92ZWM7CiBleHRlcm4gY29uc3QgYmZkX3Rhcmdl dCB3ZTMya19jb2ZmX3ZlYzsKIGV4dGVybiBjb25zdCBiZmRfdGFyZ2V0IHg4 Nl82NF9jb2ZmX3ZlYzsKQEAgLTE0MjIsNiArMTQyMyw3IEBAIHN0YXRpYyBj b25zdCBiZmRfdGFyZ2V0ICogY29uc3QgX2JmZF90YXJnZXRfdmVjdG9yW10g PQogCiAJJnc2NV9jb2ZmX3ZlYywKIAorICAgICAgICAmd2FzbV92ZWMsCiAg ICAgICAgICZ3YXNtMzJfZWxmMzJfdmVjLAogCiAJJndlMzJrX2NvZmZfdmVj LApkaWZmIC0tZ2l0IGEvYmZkL3dhc20tbW9kdWxlLmMgYi9iZmQvd2FzbS1t b2R1bGUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw Li43OTQxNzQ1ODk0Ci0tLSAvZGV2L251bGwKKysrIGIvYmZkL3dhc20tbW9k dWxlLmMKQEAgLTAsMCArMSw4NDUgQEAKKy8qIEJGRCBiYWNrLWVuZCBmb3Ig V2ViQXNzZW1ibHkgbW9kdWxlcy4KKyAgIENvcHlyaWdodCAoQykgMjAxNyBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKworICAgQmFzZWQgb24g c3JlYy5jLCBtbW8uYywgYW5kIGJpbmFyeS5jCisKKyAgIFRoaXMgZmlsZSBp cyBwYXJ0IG9mIEJGRCwgdGhlIEJpbmFyeSBGaWxlIERlc2NyaXB0b3IgbGli cmFyeS4KKworICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgor ICAgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAg VGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQg aXQgd2lsbCBiZSB1c2VmdWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAg TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UKKyAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRl IHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgICBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQgLSBGaWZ0aCBGbG9vciwgQm9zdG9uLAorICAg TUEgMDIxMTAtMTMwMSwgVVNBLiAgKi8KKworLyogVGhlIFdlYkFzc2VtYmx5 IG1vZHVsZSBmb3JtYXQgaXMgYSBzaW1wbGUgb2JqZWN0IGZpbGUgZm9ybWF0 CisgICBpbmNsdWRpbmcgdXAgdG8gMTEgbnVtYmVyZWQgc2VjdGlvbnMsIHBs dXMgYW55IG51bWJlciBvZiBuYW1lZAorICAgImN1c3RvbSIgc2VjdGlvbnMu IEl0IGlzIGRlc2NyaWJlZCBhdAorICAgaHR0cHM6Ly9naXRodWIuY29tL1dl YkFzc2VtYmx5L2Rlc2lnbi9ibG9iL21hc3Rlci9CaW5hcnlFbmNvZGluZy5t ZC4gKi8KKworI2luY2x1ZGUgInN5c2RlcC5oIgorI2luY2x1ZGUgImFsbG9j YS1jb25mLmgiCisjaW5jbHVkZSAiYmZkLmgiCisjaW5jbHVkZSAic3lzZGVw LmgiCisjaW5jbHVkZSA8bGltaXRzLmg+CisjaW5jbHVkZSAiYmZkX3N0ZGlu dC5oIgorI2luY2x1ZGUgImxpYmliZXJ0eS5oIgorI2luY2x1ZGUgImxpYmJm ZC5oIgorI2luY2x1ZGUgIndhc20tbW9kdWxlLmgiCisKK3R5cGVkZWYgc3Ry dWN0Cit7CisgIGFzeW1ib2wgKnN5bWJvbHM7CisgIGJmZF9zaXplX3R5cGUg c3ltY291bnQ7Cit9IHRkYXRhX3R5cGU7CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3Qgd2FzbV9udW1iZXJlZF9zZWN0aW9uc1tdID0geworICBOVUxM LCAvKiBjdXN0b20gc2VjdGlvbiwgZGlmZmVyZW50IGxheW91dCAqLworICBX QVNNX1NFQ1RJT04oIDEsICJ0eXBlIiksCisgIFdBU01fU0VDVElPTiggMiwg ImltcG9ydCIpLAorICBXQVNNX1NFQ1RJT04oIDMsICJmdW5jdGlvbiIpLAor ICBXQVNNX1NFQ1RJT04oIDQsICJ0YWJsZSIpLAorICBXQVNNX1NFQ1RJT04o IDUsICJtZW1vcnkiKSwKKyAgV0FTTV9TRUNUSU9OKCA2LCAiZ2xvYmFsIiks CisgIFdBU01fU0VDVElPTiggNywgImV4cG9ydCIpLAorICBXQVNNX1NFQ1RJ T04oIDgsICJzdGFydCIpLAorICBXQVNNX1NFQ1RJT04oIDksICJlbGVtZW50 IiksCisgIFdBU01fU0VDVElPTigxMCwgImNvZGUiKSwKKyAgV0FTTV9TRUNU SU9OKDExLCAiZGF0YSIpLAorfTsKKworI2RlZmluZSBXQVNNX05VTUJFUkVE X1NFQ1RJT05TIChzaXplb2YgKHdhc21fbnVtYmVyZWRfc2VjdGlvbnMpIC8g c2l6ZW9mICh3YXNtX251bWJlcmVkX3NlY3Rpb25zWzBdKSkKKworLyogUmVz b2x2ZSBTRUNUSU9OX0NPREUgdG8gYSBzZWN0aW9uIG5hbWUgaWYgdGhlcmUg aXMgb25lLCBOVUxMCisgICBvdGhlcndpc2UuICovCitzdGF0aWMgY29uc3Qg Y2hhciAqCit3YXNtX3NlY3Rpb25fY29kZV90b19uYW1lIChiZmRfYnl0ZSBz ZWN0aW9uX2NvZGUpCit7CisgIGlmIChzZWN0aW9uX2NvZGUgPCBXQVNNX05V TUJFUkVEX1NFQ1RJT05TKQorICAgIHsKKyAgICAgIHJldHVybiB3YXNtX251 bWJlcmVkX3NlY3Rpb25zW3NlY3Rpb25fY29kZV07CisgICAgfQorCisgIHJl dHVybiBOVUxMOworfQorCisvKiBUcmFuc2xhdGUgc2VjdGlvbiBuYW1lIE5B TUUgdG8gYSBzZWN0aW9uIGNvZGUsIG9yIDAgaWYgaXQncyBhCisgICBjdXN0 b20gbmFtZS4gKi8KK3N0YXRpYyBpbnQKK3dhc21fc2VjdGlvbl9uYW1lX3Rv X2NvZGUgKGNvbnN0IGNoYXIgKm5hbWUpCit7CisgIHVuc2lnbmVkIGk7Cisg IGZvciAoaSA9IDE7IGkgPCBXQVNNX05VTUJFUkVEX1NFQ1RJT05TOyBpKysp CisgICAgeworICAgICAgaWYgKHN0cmNtcCAobmFtZSwgd2FzbV9udW1iZXJl ZF9zZWN0aW9uc1tpXSkgPT0gMCkKKyAgICAgICAgcmV0dXJuIGk7CisgICAg fQorCisgIHJldHVybiAwOworfQorCisvKiBXZWJBc3NlbWJseSBMRUIxMjgg aW50ZWdlcnMgYXJlIHN1ZmZpY2llbnRseSBsaWtlIERXQVJGIExFQjEyOAor ICAgaW50ZWdlcnMgdGhhdCB3ZSB1c2UgX2JmZF9zYWZlX3JlYWRfbGViMTI4 LCBidXQgdGhlcmUgYXJlIHR3bworICAgcG9pbnRzIG9mIGRpZmZlcmVuY2U6 CisKKyAgIC0gV2ViQXNzZW1ibHkgcmVxdWlyZXMgYSAzMi1iaXQgdmFsdWUg dG8gYmUgZW5jb2RlZCBpbiBhdCBtb3N0IDUKKyAgICAgYnl0ZXMsIGV0Yy4K KyAgIC0gX2JmZF9zYWZlX3JlYWRfbGViMTI4IGFjY2VwdHMgaW5jb21wbGV0 ZSBMRUIxMjggZW5jb2RpbmdzIGF0IHRoZQorICAgICBlbmQgb2YgdGhlIGJ1 ZmZlciwgd2hpbGUgdGhlc2UgYXJlIGludmFsaWQgaW4gV2ViQXNzZW1ibHku CisKKyAgIFRob3NlIGRpZmZlcmVuY2VzIG1lYW4gdGhhdCB3ZSB3aWxsIGFj Y2VwdCBzb21lIGZpbGVzIHRoYXQgYXJlCisgICBpbnZhbGlkIFdlYkFzc2Vt Ymx5LiAqLworCisvKiBSZWFkIGFuIExFQjEyOC1lbmNvZGVkIGludGVnZXIg ZnJvbSBBQkZEJ3MgSS9PIHN0cmVhbSwgcmVhZGluZyBvbmUKKyAgIGJ5dGUg YXQgYSB0aW1lLiBTZXQgRVJST1JfUkVUVVJOIGlmIG5vIGNvbXBsZXRlIGlu dGVnZXIgY291bGQgYmUKKyAgIHJlYWQsIExFTkdUSF9SRVRVUk4gdG8gdGhl IG51bWJlciBvZiBieXRlcyByZWFkIChpbmNsdWRpbmcgYnl0ZXMgaW4KKyAg IGluY29tcGxldGUgbnVtYmVycykuIFNJR04gbWVhbnMgaW50ZXJwcmV0IHRo ZSBudW1iZXIgYXMgU0xFQjEyOC4gKi8KK3N0YXRpYyBiZmRfdm1hCit3YXNt X3JlYWRfbGViMTI4IChiZmQgKmFiZmQsCisgICAgICAgICAgICAgICAgICBi ZmRfYm9vbGVhbiAqZXJyb3JfcmV0dXJuLAorICAgICAgICAgICAgICAgICAg dW5zaWduZWQgaW50ICpsZW5ndGhfcmV0dXJuLAorICAgICAgICAgICAgICAg ICAgYmZkX2Jvb2xlYW4gc2lnbikKK3sKKyAgYmZkX3ZtYSByZXN1bHQgPSAw OworICB1bnNpZ25lZCBpbnQgbnVtX3JlYWQgPSAwOworICB1bnNpZ25lZCBp bnQgc2hpZnQgPSAwOworICB1bnNpZ25lZCBjaGFyIGJ5dGUgPSAwOworICBi ZmRfYm9vbGVhbiBzdWNjZXNzID0gRkFMU0U7CisKKyAgd2hpbGUgKGJmZF9i cmVhZCAoJmJ5dGUsIDEsIGFiZmQpID09IDEpCisgICAgeworICAgICAgbnVt X3JlYWQrKzsKKworICAgICAgcmVzdWx0IHw9ICgoYmZkX3ZtYSkgKGJ5dGUg JiAweDdmKSkgPDwgc2hpZnQ7CisKKyAgICAgIHNoaWZ0ICs9IDc7CisgICAg ICBpZiAoKGJ5dGUgJiAweDgwKSA9PSAwKQorICAgICAgICB7CisgICAgICAg ICAgc3VjY2VzcyA9IFRSVUU7CisgICAgICAgICAgYnJlYWs7CisgICAgICAg IH0KKyAgICB9CisKKyAgaWYgKGxlbmd0aF9yZXR1cm4gIT0gTlVMTCkKKyAg ICAqbGVuZ3RoX3JldHVybiA9IG51bV9yZWFkOworICBpZiAoZXJyb3JfcmV0 dXJuICE9IE5VTEwpCisgICAgKmVycm9yX3JldHVybiA9ICEgc3VjY2VzczsK KworICBpZiAoc2lnbiAmJiAoc2hpZnQgPCA4ICogc2l6ZW9mIChyZXN1bHQp KSAmJiAoYnl0ZSAmIDB4NDApKQorICAgIHJlc3VsdCB8PSAtKChiZmRfdm1h KSAxIDw8IHNoaWZ0KTsKKworICByZXR1cm4gcmVzdWx0OworfQorCisvKiBF bmNvZGUgYW4gaW50ZWdlciBWIGFzIExFQjEyOCBhbmQgd3JpdGUgaXQgdG8g QUJGRCwgcmV0dXJuIFRSVUUgb24KKyAgIHN1Y2Nlc3MuICovCitzdGF0aWMg YmZkX2Jvb2xlYW4KK3dhc21fd3JpdGVfdWxlYjEyOCAoYmZkICphYmZkLCBi ZmRfdm1hIHYpCit7CisgIGRvCisgICAgeworICAgICAgYmZkX2J5dGUgYyA9 IHYgJiAweDdmOworICAgICAgdiA+Pj0gNzsKKworICAgICAgaWYgKHYpCisg ICAgICAgIGMgfD0gMHg4MDsKKworICAgICAgaWYgKGJmZF9id3JpdGUgKCZj LCAxLCBhYmZkKSAhPSAxKQorICAgICAgICByZXR1cm4gRkFMU0U7CisgICAg fQorICB3aGlsZSAodik7CisKKyAgcmV0dXJuIFRSVUU7Cit9CisKKy8qIFJl YWQgQ09VTlQgYnl0ZXMgZnJvbSBBQkZEIGludG8gQlVGLCBqdW1waW5nIHRv IGVycm9yX3JldHVybiBvbgorICAgZmFpbHVyZS4gKi8KKyNkZWZpbmUgUkVB RF9BTEwoYnVmLCBjb3VudCwgYWJmZCkgICAgICAgICAgICAgIFwKKyAgZG8g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwK KyAgICB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFwKKyAgICAgIGlmIChiZmRfYnJlYWQoYnVmLCBjb3VudCwgYWJmZCkg IT0gY291bnQpIFwKKyAgICAgICAgZ290byBlcnJvcl9yZXR1cm47ICAgICAg ICAgICAgICAgICAgICAgIFwKKyAgICB9ICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFwKKyAgd2hpbGUgKDApCisKKy8qIFJl YWQgdGhlIExFQjEyOCBpbnRlZ2VyIGF0IFAsIHNhdmluZyBpdCB0byBYOyBh dCBlbmQgb2YgYnVmZmVyLAorICAganVtcCB0byBlcnJvcl9yZXR1cm4uICov CisjZGVmaW5lIFJFQURfTEVCMTI4KHgsIHAsIGVuZCkgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgIGRvICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBcCisgICAgeyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgICB1bnNpZ25lZCBpbnQgbGVuZ3RoX3JlYWQ7ICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAoeCkgPSBf YmZkX3NhZmVfcmVhZF9sZWIxMjggKGFiZmQsIChwKSwgJmxlbmd0aF9yZWFk LCAgICAgICAgICAgICBcCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIEZBTFNFLCAoZW5kKSk7ICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgICAocCkgKz0gbGVuZ3RoX3JlYWQ7ICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICBpZiAobGVu Z3RoX3JlYWQgPT0gMCkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBcCisgICAgICAgIGdvdG8gZXJyb3JfcmV0dXJuOyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgIHdoaWxlICgwKQor CisvKiBWZXJpZnkgdGhlIG1hZ2ljIG51bWJlciBhdCB0aGUgYmVnaW5uaW5n IG9mIGEgV2ViQXNzZW1ibHkgbW9kdWxlCisgICBBQkZELCBzZXR0aW5nIEVS Uk9SUFRSIGlmIHRoZXJlJ3MgYSBtaXNtYXRjaC4gKi8KK3N0YXRpYyBiZmRf Ym9vbGVhbgord2FzbV9yZWFkX21hZ2ljIChiZmQgKmFiZmQsIGJmZF9ib29s ZWFuICplcnJvcnB0cikKK3sKKyAgYmZkX2J5dGUgbWFnaWNfY29uc3RbXSA9 IFdBU01fTUFHSUM7CisgIGJmZF9ieXRlIG1hZ2ljWzRdOworCisgIFJFQURf QUxMIChtYWdpYywgNCwgYWJmZCk7CisKKyAgaWYgKG1lbWNtcCAobWFnaWMs IG1hZ2ljX2NvbnN0LCA0KSAhPSAwKQorICAgIGdvdG8gZXJyb3JfcmV0dXJu OworCisgIHJldHVybiBUUlVFOworCisgZXJyb3JfcmV0dXJuOgorICAqZXJy b3JwdHIgPSBUUlVFOworICByZXR1cm4gRkFMU0U7Cit9CisKKy8qIFJlYWQg dGhlIHZlcnNpb24gbnVtYmVyIGZyb20gQUJGRCwgcmV0dXJuaW5nIFRSVUUg aWYgaXQncyBhIHN1cHBvcnRlZAorICAgdmVyc2lvbi4gU2V0IEVSUk9SUFRS IG90aGVyd2lzZS4gKi8KK3N0YXRpYyBiZmRfYm9vbGVhbgord2FzbV9yZWFk X3ZlcnNpb24gKGJmZCAqYWJmZCwgYmZkX2Jvb2xlYW4gKmVycm9ycHRyKQor eworICBiZmRfYnl0ZSB2ZXJzWzRdOworICBiZmRfYnl0ZSB2ZXJzX2NvbnN0 W10gPSBXQVNNX1ZFUlNJT047CisKKyAgUkVBRF9BTEwgKHZlcnMsIChiZmRf c2l6ZV90eXBlKSA0LCBhYmZkKTsKKworICAvKiBEb24ndCBhdHRlbXB0IHRv IHBhcnNlIG5ld2VyIHZlcnNpb25zLCB3aGljaCBhcmUgbGlrZWx5IHRvCisg ICAgIHJlcXVpcmUgY29kZSBjaGFuZ2VzLiAqLworICBpZiAobWVtY21wICh2 ZXJzLCB2ZXJzX2NvbnN0LCA0KSAhPSAwKQorICAgIGdvdG8gZXJyb3JfcmV0 dXJuOworCisgIHJldHVybiBUUlVFOworCisgZXJyb3JfcmV0dXJuOgorICAq ZXJyb3JwdHIgPSBUUlVFOworICByZXR1cm4gRkFMU0U7Cit9CisKKy8qIFJl YWQgdGhlIFdlYkFzc2VtYmx5IGhlYWRlciAobWFnaWMgbnVtYmVyIHBsdXMg dmVyc2lvbiBudW1iZXIpIGZyb20KKyAgIEFCRkQsIHNldHRpbmcgRVJST1JQ VFIgdG8gVFJVRSBpZiB0aGVyZSBpcyBhIG1pc21hdGNoLiAqLworc3RhdGlj IGJmZF9ib29sZWFuCit3YXNtX3JlYWRfaGVhZGVyIChiZmQgKmFiZmQsIGJm ZF9ib29sZWFuICplcnJvcnB0cikKK3sKKyAgaWYgKCEgd2FzbV9yZWFkX21h Z2ljIChhYmZkLCBlcnJvcnB0cikpCisgICAgcmV0dXJuIEZBTFNFOworCisg IGlmICghIHdhc21fcmVhZF92ZXJzaW9uIChhYmZkLCBlcnJvcnB0cikpCisg ICAgcmV0dXJuIEZBTFNFOworCisgIHJldHVybiBUUlVFOworfQorCisvKiBT Y2FuIHRoZSAiZnVuY3Rpb24iIHN1YnNlY3Rpb24gb2YgdGhlICJuYW1lIiBz ZWN0aW9uIEFTRUNUIGluIHRoZQorICAgd2FzbSBtb2R1bGUgQUJGRC4gQ3Jl YXRlIHN5bWJvbHMuIFJldHVybiBUUlVFIG9uIHN1Y2Nlc3MuICovCitzdGF0 aWMgYmZkX2Jvb2xlYW4KK3dhc21fc2Nhbl9uYW1lX2Z1bmN0aW9uX3NlY3Rp b24gKGJmZCAqYWJmZCwgc2VjX3B0ciBhc2VjdCkKK3sKKyAgYmZkX2J5dGUg KnA7CisgIGJmZF9ieXRlICplbmQ7CisgIGJmZF92bWEgcGF5bG9hZF9zaXpl OworICBiZmRfdm1hIHN5bWNvdW50ID0gMDsKKyAgdGRhdGFfdHlwZSAqdGRh dGEgPSBhYmZkLT50ZGF0YS5hbnk7CisgIGFzeW1ib2wgKnN5bWJvbHMgPSBO VUxMOworICBzZWNfcHRyIHNwYWNlX2Z1bmN0aW9uX2luZGV4OworCisgIGlm ICghIGFzZWN0KQorICAgIHJldHVybiBGQUxTRTsKKworICBpZiAoc3RyY21w IChhc2VjdC0+bmFtZSwgV0FTTV9OQU1FX1NFQ1RJT04pICE9IDApCisgICAg cmV0dXJuIEZBTFNFOworCisgIHAgPSBhc2VjdC0+Y29udGVudHM7CisgIGVu ZCA9IGFzZWN0LT5jb250ZW50cyArIGFzZWN0LT5zaXplOworCisgIGlmICgh IHApCisgICAgcmV0dXJuIEZBTFNFOworCisgIHdoaWxlIChwIDwgZW5kKQor ICAgIHsKKyAgICAgIGJmZF9ieXRlIHN1YnNlY3Rpb25fY29kZSA9ICpwKys7 CisgICAgICBpZiAoc3Vic2VjdGlvbl9jb2RlID09IFdBU01fRlVOQ1RJT05f U1VCU0VDVElPTikKKyAgICAgICAgYnJlYWs7CisKKyAgICAgIC8qIHN1YnNl Y3Rpb25fY29kZSBpcyBkb2N1bWVudGVkIHRvIGJlIGEgdmFydWludDcsIG1l YW5pbmcgdGhhdAorICAgICAgICAgaXQgaGFzIHRvIGJlIGEgc2luZ2xlIGJ5 dGUgaW4gdGhlIDAgLSAxMjcgcmFuZ2UuIElmIGl0IGlzbid0LAorICAgICAg ICAgdGhlIHNwZWMgbXVzdCBoYXZlIGNoYW5nZWQgdW5kZXJuZWF0aCB1cywg c28gZ2l2ZSB1cC4gKi8KKyAgICAgIGlmIChzdWJzZWN0aW9uX2NvZGUgJiAw eDgwKQorICAgICAgICByZXR1cm4gRkFMU0U7CisKKyAgICAgIFJFQURfTEVC MTI4IChwYXlsb2FkX3NpemUsIHAsIGVuZCk7CisKKyAgICAgIGlmIChwID4g cCArIHBheWxvYWRfc2l6ZSkKKyAgICAgICAgcmV0dXJuIEZBTFNFOworCisg ICAgICBwICs9IHBheWxvYWRfc2l6ZTsKKyAgICB9CisKKyAgaWYgKHAgPj0g ZW5kKQorICAgIHJldHVybiBGQUxTRTsKKworICBSRUFEX0xFQjEyOCAocGF5 bG9hZF9zaXplLCBwLCBlbmQpOworCisgIGlmIChwID4gcCArIHBheWxvYWRf c2l6ZSkKKyAgICByZXR1cm4gRkFMU0U7CisKKyAgaWYgKHAgKyBwYXlsb2Fk X3NpemUgPiBlbmQpCisgICAgcmV0dXJuIEZBTFNFOworCisgIGVuZCA9IHAg KyBwYXlsb2FkX3NpemU7CisKKyAgUkVBRF9MRUIxMjggKHN5bWNvdW50LCBw LCBlbmQpOworCisgIC8qIHNhbml0eSBjaGVjazogZWFjaCBzeW1ib2wgaGFz IGF0IGxlYXN0IHR3byBieXRlcy4gKi8KKyAgaWYgKHN5bWNvdW50ID4gcGF5 bG9hZF9zaXplLzIpCisgICAgcmV0dXJuIEZBTFNFOworCisgIHRkYXRhLT5z eW1jb3VudCA9IHN5bWNvdW50OworCisgIHNwYWNlX2Z1bmN0aW9uX2luZGV4 ID0gYmZkX21ha2Vfc2VjdGlvbl93aXRoX2ZsYWdzIChhYmZkLCBXQVNNX1NF Q1RJT05fRlVOQ1RJT05fSU5ERVgsIFNFQ19SRUFET05MWSB8IFNFQ19DT0RF KTsKKyAgaWYgKCEgc3BhY2VfZnVuY3Rpb25faW5kZXgpCisgICAgc3BhY2Vf ZnVuY3Rpb25faW5kZXggPSBiZmRfZ2V0X3NlY3Rpb25fYnlfbmFtZSAoYWJm ZCwgV0FTTV9TRUNUSU9OX0ZVTkNUSU9OX0lOREVYKTsKKworICBpZiAoISBz cGFjZV9mdW5jdGlvbl9pbmRleCkKKyAgICByZXR1cm4gRkFMU0U7CisKKyAg c3ltYm9scyA9IGJmZF96YWxsb2MgKGFiZmQsIHRkYXRhLT5zeW1jb3VudCAq IHNpemVvZiAoYXN5bWJvbCkpOworICBpZiAoISBzeW1ib2xzKQorICAgIHJl dHVybiBGQUxTRTsKKworICBmb3IgKHN5bWNvdW50ID0gMDsgcCA8IGVuZCAm JiBzeW1jb3VudCA8IHRkYXRhLT5zeW1jb3VudDsgc3ltY291bnQrKykKKyAg ICB7CisgICAgICBiZmRfdm1hIGluZGV4OworICAgICAgYmZkX3ZtYSBsZW47 CisgICAgICBjaGFyICpuYW1lOworICAgICAgYXN5bWJvbCAqc3ltOworCisg ICAgICBSRUFEX0xFQjEyOCAoaW5kZXgsIHAsIGVuZCk7CisgICAgICBSRUFE X0xFQjEyOCAobGVuLCBwLCBlbmQpOworCisgICAgICBpZiAocCArIGxlbiA8 IHAgfHwgcCArIGxlbiA+IGVuZCkKKyAgICAgICAgZ290byBlcnJvcl9yZXR1 cm47CisKKyAgICAgIG5hbWUgPSBiZmRfemFsbG9jIChhYmZkLCBsZW4gKyAx KTsKKyAgICAgIGlmICghIG5hbWUpCisgICAgICAgIGdvdG8gZXJyb3JfcmV0 dXJuOworCisgICAgICBtZW1jcHkgKG5hbWUsIHAsIGxlbik7CisgICAgICBw ICs9IGxlbjsKKworICAgICAgc3ltID0gJnN5bWJvbHNbc3ltY291bnRdOwor ICAgICAgc3ltLT50aGVfYmZkID0gYWJmZDsKKyAgICAgIHN5bS0+bmFtZSA9 IG5hbWU7CisgICAgICBzeW0tPnZhbHVlID0gaW5kZXg7CisgICAgICBzeW0t PmZsYWdzID0gQlNGX0dMT0JBTCB8IEJTRl9GVU5DVElPTjsKKyAgICAgIHN5 bS0+c2VjdGlvbiA9IHNwYWNlX2Z1bmN0aW9uX2luZGV4OworICAgICAgc3lt LT51ZGF0YS5wID0gTlVMTDsKKyAgICB9CisKKyAgaWYgKHN5bWNvdW50IDwg dGRhdGEtPnN5bWNvdW50KQorICAgIGdvdG8gZXJyb3JfcmV0dXJuOworCisg IHRkYXRhLT5zeW1ib2xzID0gc3ltYm9sczsKKyAgYWJmZC0+c3ltY291bnQg PSBzeW1jb3VudDsKKworICByZXR1cm4gVFJVRTsKKworIGVycm9yX3JldHVy bjoKKyAgd2hpbGUgKHN5bWNvdW50KQorICAgIGJmZF9yZWxlYXNlIChhYmZk LCAodm9pZCAqKXN5bWJvbHNbLS1zeW1jb3VudF0ubmFtZSk7CisgIGJmZF9y ZWxlYXNlIChhYmZkLCBzeW1ib2xzKTsKKyAgcmV0dXJuIEZBTFNFOworfQor CisvKiBSZWFkIGEgYnl0ZSBmcm9tIEFCRkQgYW5kIHJldHVybiBpdCwgb3Ig RU9GIGZvciBFT0Ygb3IgZXJyb3IuIFNldAorICAgRVJST1JQVFIgb24gbm9u LUVPRiBlcnJvci4KKworICAgVGhpcyBkaWZmZXJzIGZyb20gUkVBRF9BTEwg YmVjYXVzZSB3ZSBkb24ndCBrbm93IHdoZXRoZXIgdGhlcmUgaXMKKyAgIGFu b3RoZXIgc2VjdGlvbiB0byBiZSByZWFkIGF0IEVPRi4gKi8KK3N0YXRpYyBp bnQKK3dhc21fcmVhZF9ieXRlIChiZmQgKmFiZmQsIGJmZF9ib29sZWFuICpl cnJvcnB0cikKK3sKKyAgYmZkX2J5dGUgYnl0ZTsKKyAgaWYgKGJmZF9icmVh ZCAoJmJ5dGUsIChiZmRfc2l6ZV90eXBlKSAxLCBhYmZkKSAhPSAxKQorICAg IHsKKyAgICAgIGlmIChiZmRfZ2V0X2Vycm9yICgpICE9IGJmZF9lcnJvcl9m aWxlX3RydW5jYXRlZCkKKyAgICAgICAgKmVycm9ycHRyID0gVFJVRTsKKyAg ICAgIHJldHVybiBFT0Y7CisgICAgfQorCisgIHJldHVybiBieXRlOworfQor CisvKiBTY2FuIHRoZSB3YXNtIG1vZHVsZSBBQkZELCBjcmVhdGluZyBzZWN0 aW9ucyBhbmQgc3ltYm9scy4gUmV0dXJuCisgICBUUlVFIG9uIHN1Y2Nlc3Mu ICovCitzdGF0aWMgYmZkX2Jvb2xlYW4KK3dhc21fc2NhbiAoYmZkICphYmZk KQoreworICBiZmRfYm9vbGVhbiBlcnJvciA9IEZBTFNFOworICAvKiBmYWtl IFZNQXMgZm9yIG5vdy4gQ2hvb3NlIDB4ODAwMDAwMDAgYXMgYmFzZSB0byBh dm9pZCBjbGFzaGVzCisgICAgIHdpdGggYWN0dWFsIGRhdGEgYWRkcmVzc2Vz LiAqLworICBiZmRfdm1hIHZtYSA9IDB4ODAwMDAwMDA7CisgIGludCBzZWN0 aW9uX2NvZGU7CisgIHVuc2lnbmVkIGludCBieXRlc19yZWFkOworICBjaGFy ICpuYW1lID0gTlVMTDsKKworICBpZiAoYmZkX3NlZWsgKGFiZmQsIChmaWxl X3B0cikgMCwgU0VFS19TRVQpICE9IDApCisgICAgZ290byBlcnJvcl9yZXR1 cm47CisKKyAgaWYgKCEgd2FzbV9yZWFkX2hlYWRlciAoYWJmZCwgJmVycm9y KSkKKyAgICBnb3RvIGVycm9yX3JldHVybjsKKworICB3aGlsZSAoKHNlY3Rp b25fY29kZSA9IHdhc21fcmVhZF9ieXRlIChhYmZkLCAmZXJyb3IpKSAhPSBF T0YpCisgICAgeworICAgICAgYXNlY3Rpb24gKmJmZHNlYzsKKworICAgICAg aWYgKHNlY3Rpb25fY29kZSAhPSAwKQorICAgICAgICB7CisgICAgICAgICAg Y29uc3QgY2hhciAqc25hbWUgPSB3YXNtX3NlY3Rpb25fY29kZV90b19uYW1l IChzZWN0aW9uX2NvZGUpOworCisgICAgICAgICAgaWYgKCEgc25hbWUpCisg ICAgICAgICAgICBnb3RvIGVycm9yX3JldHVybjsKKworICAgICAgICAgIG5h bWUgPSBzdHJkdXAgKHNuYW1lKTsKKyAgICAgICAgICBiZmRzZWMgPSBiZmRf bWFrZV9zZWN0aW9uX2FueXdheV93aXRoX2ZsYWdzIChhYmZkLCBuYW1lLCBT RUNfSEFTX0NPTlRFTlRTKTsKKyAgICAgICAgICBpZiAoYmZkc2VjID09IE5V TEwpCisgICAgICAgICAgICBnb3RvIGVycm9yX3JldHVybjsKKyAgICAgICAg ICBuYW1lID0gTlVMTDsKKworICAgICAgICAgIGJmZHNlYy0+dm1hID0gdm1h OworICAgICAgICAgIGJmZHNlYy0+bG1hID0gdm1hOworICAgICAgICAgIGJm ZHNlYy0+c2l6ZSA9IHdhc21fcmVhZF9sZWIxMjggKGFiZmQsICZlcnJvciwg JmJ5dGVzX3JlYWQsIEZBTFNFKTsKKyAgICAgICAgICBpZiAoZXJyb3IpCisg ICAgICAgICAgICBnb3RvIGVycm9yX3JldHVybjsKKyAgICAgICAgICBiZmRz ZWMtPmZpbGVwb3MgPSBiZmRfdGVsbCAoYWJmZCk7CisgICAgICAgICAgYmZk c2VjLT5hbGlnbm1lbnRfcG93ZXIgPSAwOworICAgICAgICB9CisgICAgICBl bHNlCisgICAgICAgIHsKKyAgICAgICAgICBiZmRfdm1hIHBheWxvYWRfbGVu OworICAgICAgICAgIGZpbGVfcHRyIHNlY3Rpb25fc3RhcnQ7CisgICAgICAg ICAgYmZkX3ZtYSBuYW1lbGVuOworICAgICAgICAgIGNoYXIgKnByZWZpeCA9 IFdBU01fU0VDVElPTl9QUkVGSVg7CisgICAgICAgICAgY2hhciAqcDsKKyAg ICAgICAgICBpbnQgcmV0OworCisgICAgICAgICAgcGF5bG9hZF9sZW4gPSB3 YXNtX3JlYWRfbGViMTI4IChhYmZkLCAmZXJyb3IsICZieXRlc19yZWFkLCBG QUxTRSk7CisgICAgICAgICAgaWYgKGVycm9yKQorICAgICAgICAgICAgZ290 byBlcnJvcl9yZXR1cm47CisgICAgICAgICAgc2VjdGlvbl9zdGFydCA9IGJm ZF90ZWxsIChhYmZkKTsKKyAgICAgICAgICBuYW1lbGVuID0gd2FzbV9yZWFk X2xlYjEyOCAoYWJmZCwgJmVycm9yLCAmYnl0ZXNfcmVhZCwgRkFMU0UpOwor ICAgICAgICAgIGlmIChlcnJvciB8fCBuYW1lbGVuID4gcGF5bG9hZF9sZW4p CisgICAgICAgICAgICBnb3RvIGVycm9yX3JldHVybjsKKyAgICAgICAgICBu YW1lID0gYmZkX3ptYWxsb2MgKG5hbWVsZW4gKyBzdHJsZW4gKHByZWZpeCkg KyAxKTsKKyAgICAgICAgICBpZiAoISBuYW1lKQorICAgICAgICAgICAgZ290 byBlcnJvcl9yZXR1cm47CisgICAgICAgICAgcCA9IG5hbWU7CisgICAgICAg ICAgcmV0ID0gc3ByaW50ZiAocCwgIiVzIiwgcHJlZml4KTsKKyAgICAgICAg ICBpZiAocmV0IDwgMCB8fCAoYmZkX3ZtYSkgcmV0ICE9IHN0cmxlbiAocHJl Zml4KSkKKyAgICAgICAgICAgIGdvdG8gZXJyb3JfcmV0dXJuOworICAgICAg ICAgIHAgKz0gcmV0OworICAgICAgICAgIFJFQURfQUxMIChwLCBuYW1lbGVu LCBhYmZkKTsKKworICAgICAgICAgIGJmZHNlYyA9IGJmZF9tYWtlX3NlY3Rp b25fYW55d2F5X3dpdGhfZmxhZ3MgKGFiZmQsIG5hbWUsIFNFQ19IQVNfQ09O VEVOVFMpOworICAgICAgICAgIGlmIChiZmRzZWMgPT0gTlVMTCkKKyAgICAg ICAgICAgIGdvdG8gZXJyb3JfcmV0dXJuOworICAgICAgICAgIG5hbWUgPSBO VUxMOworCisgICAgICAgICAgYmZkc2VjLT52bWEgPSB2bWE7CisgICAgICAg ICAgYmZkc2VjLT5sbWEgPSB2bWE7CisgICAgICAgICAgYmZkc2VjLT5maWxl cG9zID0gYmZkX3RlbGwgKGFiZmQpOworICAgICAgICAgIGJmZHNlYy0+c2l6 ZSA9IHNlY3Rpb25fc3RhcnQgKyBwYXlsb2FkX2xlbiAtIGJmZHNlYy0+Zmls ZXBvczsKKyAgICAgICAgICBiZmRzZWMtPmFsaWdubWVudF9wb3dlciA9IDA7 CisgICAgICAgIH0KKworICAgICAgaWYgKGJmZHNlYy0+c2l6ZSAhPSAwKQor ICAgICAgICB7CisgICAgICAgICAgYmZkc2VjLT5jb250ZW50cyA9IGJmZF96 YWxsb2MgKGFiZmQsIGJmZHNlYy0+c2l6ZSk7CisgICAgICAgICAgaWYgKCEg YmZkc2VjLT5jb250ZW50cykKKyAgICAgICAgICAgIGdvdG8gZXJyb3JfcmV0 dXJuOworCisgICAgICAgICAgUkVBRF9BTEwgKGJmZHNlYy0+Y29udGVudHMs IGJmZHNlYy0+c2l6ZSwgYWJmZCk7CisgICAgICAgIH0KKworICAgICAgdm1h ICs9IGJmZHNlYy0+c2l6ZTsKKyAgICB9CisKKyAgLyogTWFrZSBzdXJlIHdl J3JlIGF0IGFjdHVhbCBFT0YuIFRoZXJlJ3Mgbm8gaW5kaWNhdGlvbiBpbiB0 aGUKKyAgICAgV2ViQXNzZW1ibHkgZm9ybWF0IG9mIGhvdyBsb25nIHRoZSBm aWxlIGlzIHN1cHBvc2VkIHRvIGJlLiAqLworICBpZiAoZXJyb3IpCisgICAg Z290byBlcnJvcl9yZXR1cm47CisKKyAgcmV0dXJuIFRSVUU7CisKKyBlcnJv cl9yZXR1cm46CisgIGlmIChuYW1lKQorICAgIGZyZWUgKG5hbWUpOworCisg IGZvciAoYXNlY3Rpb24gKmJmZHNlYyA9IGFiZmQtPnNlY3Rpb25zOyBiZmRz ZWM7IGJmZHNlYyA9IGJmZHNlYy0+bmV4dCkKKyAgICBmcmVlICgodm9pZCAq KSBiZmRzZWMtPm5hbWUpOworCisgIHJldHVybiBGQUxTRTsKK30KKworLyog UHV0IGEgbnVtYmVyZWQgc2VjdGlvbiBBU0VDVCBvZiBBQkZEIGludG8gdGhl IHRhYmxlIG9mIG51bWJlcmVkCisgICBzZWN0aW9ucyBwb2ludGVkIHRvIGJ5 IEZTQVJHLiAqLworc3RhdGljIHZvaWQKK3dhc21fcmVnaXN0ZXJfc2VjdGlv biAoYmZkICphYmZkIEFUVFJJQlVURV9VTlVTRUQsCisgICAgICAgICAgICAg ICAgICAgICAgIGFzZWN0aW9uICphc2VjdCwgdm9pZCAqZnNhcmcpCit7Cisg IHNlY19wdHIgKm51bWJlcmVkX3NlY3Rpb25zID0gZnNhcmc7CisgIGludCBp bmRleCA9IHdhc21fc2VjdGlvbl9uYW1lX3RvX2NvZGUgKGFzZWN0LT5uYW1l KTsKKworICBpZiAoaW5kZXggPT0gMCkKKyAgICByZXR1cm47CisKKyAgbnVt YmVyZWRfc2VjdGlvbnNbaW5kZXhdID0gYXNlY3Q7Cit9CisKK3N0cnVjdCBj b21wdXRlX3NlY3Rpb25fYXJnCit7CisgIGJmZF92bWEgcG9zOworICBiZmRf Ym9vbGVhbiBmYWlsZWQ7Cit9OworCisvKiBDb21wdXRlIHRoZSBmaWxlIHBv c2l0aW9uIG9mIEFCRkQncyBzZWN0aW9uIEFTRUNULiBGU0FSRyBpcyBhCisg ICBwb2ludGVyIHRvIHRoZSBjdXJyZW50IGZpbGUgcG9zaXRpb24uCisKKyAg IFdlIGFsbG93IHNlY3Rpb24gbmFtZXMgb2YgdGhlIGZvcm0gLndhc20uaWQg dG8gZW5jb2RlIHRoZSBudW1iZXJlZAorICAgc2VjdGlvbiB3aXRoIElEIGlk LCBpZiBpdCBleGlzdHM7IG90aGVyd2lzZSwgYSBjdXN0b20gc2VjdGlvbiB3 aXRoCisgICBJRCAiaWQiIGlzIHByb2R1Y2VkLiBBcmJpdHJhcnkgc2VjdGlv biBuYW1lcyBhcmUgZm9yIHNlY3Rpb25zIHRoYXQKKyAgIGFyZSBhc3N1bWVk IGFscmVhZHkgdG8gY29udGFpbiBhIHNlY3Rpb24gaGVhZGVyOyB0aG9zZSBh cmUgYXBwZW5kZWQKKyAgIHRvIHRoZSBXZWJBc3NlbWJseSBtb2R1bGUgdmVy YmF0aW0uICovCitzdGF0aWMgdm9pZAord2FzbV9jb21wdXRlX2N1c3RvbV9z ZWN0aW9uX2ZpbGVfcG9zaXRpb24gKGJmZCAqYWJmZCwgc2VjX3B0ciBhc2Vj dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB2b2lkICpmc2FyZykKK3sKKyAgc3RydWN0IGNvbXB1dGVfc2VjdGlvbl9h cmcgKmZzID0gZnNhcmc7CisgIGludCBpbmRleDsKKworICBpZiAoZnMtPmZh aWxlZCkKKyAgICByZXR1cm47CisKKyAgaW5kZXggPSB3YXNtX3NlY3Rpb25f bmFtZV90b19jb2RlIChhc2VjdC0+bmFtZSk7CisKKyAgaWYgKGluZGV4ICE9 IDApCisgICAgcmV0dXJuOworCisgIGlmIChDT05TVF9TVFJORVEgKGFzZWN0 LT5uYW1lLCBXQVNNX1NFQ1RJT05fUFJFRklYKSkKKyAgICB7CisgICAgICBj b25zdCBjaGFyICpuYW1lID0gYXNlY3QtPm5hbWUgKyBzdHJsZW4gKFdBU01f U0VDVElPTl9QUkVGSVgpOworICAgICAgYmZkX3NpemVfdHlwZSBwYXlsb2Fk X2xlbiA9IGFzZWN0LT5zaXplOworICAgICAgYmZkX3NpemVfdHlwZSBuYW1l X2xlbiA9IHN0cmxlbiAobmFtZSk7CisgICAgICBiZmRfc2l6ZV90eXBlIG5s ID0gbmFtZV9sZW47CisKKyAgICAgIHBheWxvYWRfbGVuICs9IG5hbWVfbGVu OworCisgICAgICBkbworICAgICAgICB7CisgICAgICAgICAgcGF5bG9hZF9s ZW4rKzsKKyAgICAgICAgICBubCA+Pj0gNzsKKyAgICAgICAgfQorICAgICAg d2hpbGUgKG5sKTsKKworICAgICAgYmZkX3NlZWsgKGFiZmQsIGZzLT5wb3Ms IFNFRUtfU0VUKTsKKyAgICAgIGlmICghIHdhc21fd3JpdGVfdWxlYjEyOCAo YWJmZCwgMCkKKyAgICAgICAgICB8fCAhIHdhc21fd3JpdGVfdWxlYjEyOCAo YWJmZCwgcGF5bG9hZF9sZW4pCisgICAgICAgICAgfHwgISB3YXNtX3dyaXRl X3VsZWIxMjggKGFiZmQsIG5hbWVfbGVuKQorICAgICAgICAgIHx8IGJmZF9i d3JpdGUgKG5hbWUsIG5hbWVfbGVuLCBhYmZkKSAhPSBuYW1lX2xlbikKKyAg ICAgICAgZ290byBlcnJvcl9yZXR1cm47CisgICAgICBmcy0+cG9zID0gYXNl Y3QtPmZpbGVwb3MgPSBiZmRfdGVsbCAoYWJmZCk7CisgICAgfQorICBlbHNl CisgICAgeworICAgICAgYXNlY3QtPmZpbGVwb3MgPSBmcy0+cG9zOworICAg IH0KKworCisgIGZzLT5wb3MgKz0gYXNlY3QtPnNpemU7CisKKyAgcmV0dXJu OworCisgZXJyb3JfcmV0dXJuOgorICBmcy0+ZmFpbGVkID0gVFJVRTsKK30K KworLyogQ29tcHV0ZSB0aGUgZmlsZSBwb3NpdGlvbnMgZm9yIHRoZSBzZWN0 aW9ucyBvZiBBQkZELiBDdXJyZW50bHksCisgICB0aGlzIHdyaXRlcyBhbGwg bnVtYmVyZWQgc2VjdGlvbnMgZmlyc3QsIGluIG9yZGVyLCB0aGVuIGFsbCBj dXN0b20KKyAgIHNlY3Rpb25zLCBpbiBzZWN0aW9uIG9yZGVyLgorCisgICBU aGUgc3BlYyBzYXlzIHRoYXQgdGhlIG51bWJlcmVkIHNlY3Rpb25zIG11c3Qg YXBwZWFyIGluIG9yZGVyIG9mCisgICB0aGVpciBpZHMsIGJ1dCBjdXN0b20g c2VjdGlvbnMgY2FuIGFwcGVhciBpbiBhbnkgcG9zaXRpb24gYW5kIGFueQor ICAgb3JkZXIsIGFuZCBtb3JlIHRoYW4gb25jZS4gRklYTUU6IHN1cHBvcnQg dGhhdC4gKi8KK3N0YXRpYyBiZmRfYm9vbGVhbgord2FzbV9jb21wdXRlX3Nl Y3Rpb25fZmlsZV9wb3NpdGlvbnMgKGJmZCAqYWJmZCkKK3sKKyAgYmZkX2J5 dGUgbWFnaWNbXSA9IFdBU01fTUFHSUM7CisgIGJmZF9ieXRlIHZlcnNbXSA9 IFdBU01fVkVSU0lPTjsKKyAgc2VjX3B0ciBudW1iZXJlZF9zZWN0aW9uc1tX QVNNX05VTUJFUkVEX1NFQ1RJT05TXTsKKyAgc3RydWN0IGNvbXB1dGVfc2Vj dGlvbl9hcmcgZnM7CisgIHVuc2lnbmVkIGludCBpOworCisgIGJmZF9zZWVr IChhYmZkLCAoYmZkX3ZtYSkgMCwgU0VFS19TRVQpOworCisgIGlmIChiZmRf YndyaXRlIChtYWdpYywgc2l6ZW9mIChtYWdpYyksIGFiZmQpICE9IChzaXpl b2YgbWFnaWMpCisgICAgICB8fCBiZmRfYndyaXRlICh2ZXJzLCBzaXplb2Yg KHZlcnMpLCBhYmZkKSAhPSBzaXplb2YgKHZlcnMpKQorICAgIHJldHVybiBG QUxTRTsKKworICBmb3IgKGkgPSAwOyBpIDwgV0FTTV9OVU1CRVJFRF9TRUNU SU9OUzsgaSsrKQorICAgIG51bWJlcmVkX3NlY3Rpb25zW2ldID0gTlVMTDsK KworICBiZmRfbWFwX292ZXJfc2VjdGlvbnMgKGFiZmQsIHdhc21fcmVnaXN0 ZXJfc2VjdGlvbiwgbnVtYmVyZWRfc2VjdGlvbnMpOworCisgIGZzLnBvcyA9 IGJmZF90ZWxsIChhYmZkKTsKKyAgZm9yIChpID0gMDsgaSA8IFdBU01fTlVN QkVSRURfU0VDVElPTlM7IGkrKykKKyAgICB7CisgICAgICBzZWNfcHRyIHNl YyA9IG51bWJlcmVkX3NlY3Rpb25zW2ldOworICAgICAgYmZkX3NpemVfdHlw ZSBzaXplOworCisgICAgICBpZiAoISBzZWMpCisgICAgICAgIGNvbnRpbnVl OworICAgICAgc2l6ZSA9IHNlYy0+c2l6ZTsKKyAgICAgIGlmIChiZmRfc2Vl ayAoYWJmZCwgZnMucG9zLCBTRUVLX1NFVCkgIT0gMCkKKyAgICAgICAgcmV0 dXJuIEZBTFNFOworICAgICAgaWYgKCEgd2FzbV93cml0ZV91bGViMTI4IChh YmZkLCBpKQorICAgICAgICAgIHx8ICEgd2FzbV93cml0ZV91bGViMTI4IChh YmZkLCBzaXplKSkKKyAgICAgICAgcmV0dXJuIEZBTFNFOworICAgICAgZnMu cG9zID0gc2VjLT5maWxlcG9zID0gYmZkX3RlbGwgKGFiZmQpOworICAgICAg ZnMucG9zICs9IHNpemU7CisgICAgfQorCisgIGZzLmZhaWxlZCA9IEZBTFNF OworCisgIGJmZF9tYXBfb3Zlcl9zZWN0aW9ucyAoYWJmZCwgd2FzbV9jb21w dXRlX2N1c3RvbV9zZWN0aW9uX2ZpbGVfcG9zaXRpb24sICZmcyk7CisKKyAg aWYgKGZzLmZhaWxlZCkKKyAgICByZXR1cm4gRkFMU0U7CisKKyAgYWJmZC0+ b3V0cHV0X2hhc19iZWd1biA9IFRSVUU7CisKKyAgcmV0dXJuIFRSVUU7Cit9 CisKK3N0YXRpYyBiZmRfYm9vbGVhbgord2FzbV9zZXRfc2VjdGlvbl9jb250 ZW50cyAoYmZkICphYmZkLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg c2VjX3B0ciBzZWN0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg Y29uc3Qgdm9pZCAqbG9jYXRpb24sCisgICAgICAgICAgICAgICAgICAgICAg ICAgICBmaWxlX3B0ciBvZmZzZXQsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICBiZmRfc2l6ZV90eXBlIGNvdW50KQoreworICBpZiAoY291bnQgPT0g MCkKKyAgICByZXR1cm4gVFJVRTsKKworICBpZiAoISBhYmZkLT5vdXRwdXRf aGFzX2JlZ3VuCisgICAgICAmJiAhIHdhc21fY29tcHV0ZV9zZWN0aW9uX2Zp bGVfcG9zaXRpb25zIChhYmZkKSkKKyAgICByZXR1cm4gRkFMU0U7CisKKyAg aWYgKGJmZF9zZWVrIChhYmZkLCBzZWN0aW9uLT5maWxlcG9zICsgb2Zmc2V0 LCBTRUVLX1NFVCkgIT0gMAorICAgICAgfHwgYmZkX2J3cml0ZSAobG9jYXRp b24sIGNvdW50LCBhYmZkKSAhPSBjb3VudCkKKyAgICByZXR1cm4gRkFMU0U7 CisKKyAgcmV0dXJuIFRSVUU7Cit9CisKK3N0YXRpYyBiZmRfYm9vbGVhbgor d2FzbV93cml0ZV9vYmplY3RfY29udGVudHMgKGJmZCogYWJmZCkKK3sKKyAg YmZkX2J5dGUgbWFnaWNbXSA9IFdBU01fTUFHSUM7CisgIGJmZF9ieXRlIHZl cnNbXSA9IFdBU01fVkVSU0lPTjsKKworICBpZiAoYmZkX3NlZWsgKGFiZmQs IDAsIFNFRUtfU0VUKSAhPSAwKQorICAgIHJldHVybiBGQUxTRTsKKworICBp ZiAoYmZkX2J3cml0ZSAobWFnaWMsIHNpemVvZiAobWFnaWMpLCBhYmZkKSAh PSBzaXplb2YgKG1hZ2ljKQorICAgICAgfHwgYmZkX2J3cml0ZSAodmVycywg c2l6ZW9mICh2ZXJzKSwgYWJmZCkgIT0gc2l6ZW9mICh2ZXJzKSkKKyAgICBy ZXR1cm4gRkFMU0U7CisKKyAgcmV0dXJuIFRSVUU7Cit9CisKK3N0YXRpYyBi ZmRfYm9vbGVhbgord2FzbV9ta29iamVjdCAoYmZkICphYmZkKQoreworICB0 ZGF0YV90eXBlICp0ZGF0YSA9ICh0ZGF0YV90eXBlICopIGJmZF9hbGxvYyAo YWJmZCwgc2l6ZW9mICh0ZGF0YV90eXBlKSk7CisKKyAgaWYgKCEgdGRhdGEp CisgICAgcmV0dXJuIEZBTFNFOworCisgIHRkYXRhLT5zeW1ib2xzID0gTlVM TDsKKyAgdGRhdGEtPnN5bWNvdW50ID0gMDsKKworICBhYmZkLT50ZGF0YS5h bnkgPSB0ZGF0YTsKKworICByZXR1cm4gVFJVRTsKK30KKworc3RhdGljIGxv bmcKK3dhc21fZ2V0X3N5bXRhYl91cHBlcl9ib3VuZCAoYmZkICphYmZkKQor eworICB0ZGF0YV90eXBlICp0ZGF0YSA9IGFiZmQtPnRkYXRhLmFueTsKKwor ICByZXR1cm4gKHRkYXRhLT5zeW1jb3VudCArIDEpICogKHNpemVvZiAoYXN5 bWJvbCAqKSk7Cit9CisKK3N0YXRpYyBsb25nCit3YXNtX2Nhbm9uaWNhbGl6 ZV9zeW10YWIgKGJmZCAqYWJmZCwgYXN5bWJvbCAqKmFsb2NhdGlvbikKK3sK KyAgdGRhdGFfdHlwZSAqdGRhdGEgPSBhYmZkLT50ZGF0YS5hbnk7CisgIHNp emVfdCBpOworCisgIGZvciAoaSA9IDA7IGkgPCB0ZGF0YS0+c3ltY291bnQ7 IGkrKykKKyAgICBhbG9jYXRpb25baV0gPSAmdGRhdGEtPnN5bWJvbHNbaV07 CisgIGFsb2NhdGlvbltpXSA9IE5VTEw7CisKKyAgcmV0dXJuIHRkYXRhLT5z eW1jb3VudDsKK30KKworc3RhdGljIGFzeW1ib2wgKgord2FzbV9tYWtlX2Vt cHR5X3N5bWJvbCAoYmZkICphYmZkKQoreworICBiZmRfc2l6ZV90eXBlIGFt dCA9IHNpemVvZiAoYXN5bWJvbCk7CisgIGFzeW1ib2wgKm5ld19zeW1ib2wg PSAoYXN5bWJvbCAqKSBiZmRfemFsbG9jIChhYmZkLCBhbXQpOworCisgIGlm ICghIG5ld19zeW1ib2wpCisgICAgcmV0dXJuIE5VTEw7CisgIG5ld19zeW1i b2wtPnRoZV9iZmQgPSBhYmZkOworICByZXR1cm4gbmV3X3N5bWJvbDsKK30K Kworc3RhdGljIHZvaWQKK3dhc21fcHJpbnRfc3ltYm9sIChiZmQgKmFiZmQs CisgICAgICAgICAgICAgICAgICAgdm9pZCAqIGZpbGVwLAorICAgICAgICAg ICAgICAgICAgIGFzeW1ib2wgKnN5bWJvbCwKKyAgICAgICAgICAgICAgICAg ICBiZmRfcHJpbnRfc3ltYm9sX3R5cGUgaG93KQoreworICBGSUxFICpmaWxl ID0gKEZJTEUgKikgZmlsZXA7CisKKyAgc3dpdGNoIChob3cpCisgICAgewor ICAgIGNhc2UgYmZkX3ByaW50X3N5bWJvbF9uYW1lOgorICAgICAgZnByaW50 ZiAoZmlsZSwgIiVzIiwgc3ltYm9sLT5uYW1lKTsKKyAgICAgIGJyZWFrOwor CisgICAgZGVmYXVsdDoKKyAgICAgIGJmZF9wcmludF9zeW1ib2xfdmFuZGYg KGFiZmQsIGZpbGVwLCBzeW1ib2wpOworICAgICAgZnByaW50ZiAoZmlsZSwg IiAlLTVzICVzIiwgc3ltYm9sLT5zZWN0aW9uLT5uYW1lLCBzeW1ib2wtPm5h bWUpOworICAgIH0KK30KKworc3RhdGljIHZvaWQKK3dhc21fZ2V0X3N5bWJv bF9pbmZvIChiZmQgKmFiZmQgQVRUUklCVVRFX1VOVVNFRCwKKyAgICAgICAg ICAgICAgICAgICAgICBhc3ltYm9sICpzeW1ib2wsCisgICAgICAgICAgICAg ICAgICAgICAgc3ltYm9sX2luZm8gKnJldCkKK3sKKyAgYmZkX3N5bWJvbF9p bmZvIChzeW1ib2wsIHJldCk7Cit9CisKKy8qIENoZWNrIHdoZXRoZXIgQUJG RCBpcyBhIFdlYkFzc2VtYmx5IG1vZHVsZTsgaWYgc28sIHNjYW4gaXQuICov CitzdGF0aWMgY29uc3QgYmZkX3RhcmdldCAqCit3YXNtX29iamVjdF9wIChi ZmQgKmFiZmQpCit7CisgIGJmZF9ib29sZWFuIGVycm9yOworCisgIGlmIChi ZmRfc2VlayAoYWJmZCwgKGZpbGVfcHRyKSAwLCBTRUVLX1NFVCkgIT0gMCkK KyAgICByZXR1cm4gTlVMTDsKKworICBpZiAoISB3YXNtX3JlYWRfaGVhZGVy IChhYmZkLCAmZXJyb3IpKQorICAgIHsKKyAgICAgIGJmZF9zZXRfZXJyb3Ig KGJmZF9lcnJvcl93cm9uZ19mb3JtYXQpOworICAgICAgcmV0dXJuIE5VTEw7 CisgICAgfQorCisgIGlmICghIHdhc21fbWtvYmplY3QgKGFiZmQpIHx8ICEg d2FzbV9zY2FuIChhYmZkKSkKKyAgICByZXR1cm4gTlVMTDsKKworICBpZiAo ISBiZmRfZGVmYXVsdF9zZXRfYXJjaF9tYWNoIChhYmZkLCBiZmRfYXJjaF93 YXNtMzIsIDApKQorICAgIHJldHVybiBOVUxMOworCisgIGlmICh3YXNtX3Nj YW5fbmFtZV9mdW5jdGlvbl9zZWN0aW9uIChhYmZkLCBiZmRfZ2V0X3NlY3Rp b25fYnlfbmFtZSAoYWJmZCwgV0FTTV9OQU1FX1NFQ1RJT04pKSkKKyAgICB7 CisgICAgICBhYmZkLT5mbGFncyB8PSBIQVNfU1lNUzsKKyAgICB9CisKKyAg cmV0dXJuIGFiZmQtPnh2ZWM7Cit9CisKKy8qIEJGRF9KVU1QX1RBQkxFX1dS SVRFICovCisjZGVmaW5lIHdhc21fc2V0X2FyY2hfbWFjaCAgICAgICAgICAg ICAgICBfYmZkX2dlbmVyaWNfc2V0X2FyY2hfbWFjaAorCisvKiBCRkRfSlVN UF9UQUJMRV9TWU1CT0xTICovCisjZGVmaW5lIHdhc21fZ2V0X3N5bWJvbF92 ZXJzaW9uX3N0cmluZyAgICBfYmZkX25vc3ltYm9sc19nZXRfc3ltYm9sX3Zl cnNpb25fc3RyaW5nCisjZGVmaW5lIHdhc21fYmZkX2lzX2xvY2FsX2xhYmVs X25hbWUgICAgICAgYmZkX2dlbmVyaWNfaXNfbG9jYWxfbGFiZWxfbmFtZQor I2RlZmluZSB3YXNtX2JmZF9pc190YXJnZXRfc3BlY2lhbF9zeW1ib2wgKChi ZmRfYm9vbGVhbiAoKikgKGJmZCAqLCBhc3ltYm9sICopKSBiZmRfZmFsc2Up CisjZGVmaW5lIHdhc21fZ2V0X2xpbmVubyAgICAgICAgICAgICAgICAgICBf YmZkX25vc3ltYm9sc19nZXRfbGluZW5vCisjZGVmaW5lIHdhc21fZmluZF9u ZWFyZXN0X2xpbmUgICAgICAgICAgICBfYmZkX25vc3ltYm9sc19maW5kX25l YXJlc3RfbGluZQorI2RlZmluZSB3YXNtX2ZpbmRfbGluZSAgICAgICAgICAg ICAgICAgICAgX2JmZF9ub3N5bWJvbHNfZmluZF9saW5lCisjZGVmaW5lIHdh c21fZmluZF9pbmxpbmVyX2luZm8gICAgICAgICAgICBfYmZkX25vc3ltYm9s c19maW5kX2lubGluZXJfaW5mbworI2RlZmluZSB3YXNtX2JmZF9tYWtlX2Rl YnVnX3N5bWJvbCAgICAgICAgX2JmZF9ub3N5bWJvbHNfYmZkX21ha2VfZGVi dWdfc3ltYm9sCisjZGVmaW5lIHdhc21fcmVhZF9taW5pc3ltYm9scyAgICAg ICAgICAgICBfYmZkX2dlbmVyaWNfcmVhZF9taW5pc3ltYm9scworI2RlZmlu ZSB3YXNtX21pbmlzeW1ib2xfdG9fc3ltYm9sICAgICAgICAgX2JmZF9nZW5l cmljX21pbmlzeW1ib2xfdG9fc3ltYm9sCisKK2NvbnN0IGJmZF90YXJnZXQg d2FzbV92ZWMgPQoreworICAid2FzbSIsICAgICAgICAgICAgICAgLyogTmFt ZSAqLworICBiZmRfdGFyZ2V0X3Vua25vd25fZmxhdm91ciwKKyAgQkZEX0VO RElBTl9MSVRUTEUsCisgIEJGRF9FTkRJQU5fTElUVExFLAorICAoSEFTX1NZ TVMgfCBXUF9URVhUKSwgICAgICAgICAgICAgLyogT2JqZWN0IGZsYWdzLiAq LworICAoU0VDX0NPREUgfCBTRUNfREFUQSB8IFNFQ19IQVNfQ09OVEVOVFMp LCAvKiBTZWN0aW9uIGZsYWdzICovCisgIDAsICAgICAgICAgICAgICAgICAg ICAvKiBMZWFkaW5nIHVuZGVyc2NvcmUgKi8KKyAgJyAnLCAgICAgICAgICAg ICAgICAgIC8qIEFSX3BhZF9jaGFyICovCisgIDI1NSwgICAgICAgICAgICAg ICAgICAvKiBBUl9tYXhfbmFtZWxlbiAqLworICAwLAkJCQkvKiBtYXRjaCBw cmlvcml0eS4gICovCisgIC8qIFJvdXRpbmVzIHRvIGJ5dGUtc3dhcCB2YXJp b3VzIHNpemVkIGludGVnZXJzIGZyb20gdGhlIGRhdGEgc2VjdGlvbnMgKi8K KyAgYmZkX2dldGw2NCwgYmZkX2dldGxfc2lnbmVkXzY0LCBiZmRfcHV0bDY0 LAorICBiZmRfZ2V0bDMyLCBiZmRfZ2V0bF9zaWduZWRfMzIsIGJmZF9wdXRs MzIsCisgIGJmZF9nZXRsMTYsIGJmZF9nZXRsX3NpZ25lZF8xNiwgYmZkX3B1 dGwxNiwKKworICAvKiBSb3V0aW5lcyB0byBieXRlLXN3YXAgdmFyaW91cyBz aXplZCBpbnRlZ2VycyBmcm9tIHRoZSBmaWxlIGhlYWRlcnMgKi8KKyAgYmZk X2dldGw2NCwgYmZkX2dldGxfc2lnbmVkXzY0LCBiZmRfcHV0bDY0LAorICBi ZmRfZ2V0bDMyLCBiZmRfZ2V0bF9zaWduZWRfMzIsIGJmZF9wdXRsMzIsCisg IGJmZF9nZXRsMTYsIGJmZF9nZXRsX3NpZ25lZF8xNiwgYmZkX3B1dGwxNiwK KworICB7CisgICAgX2JmZF9kdW1teV90YXJnZXQsCisgICAgd2FzbV9vYmpl Y3RfcCwJLyogYmZkX2NoZWNrX2Zvcm1hdC4gICovCisgICAgX2JmZF9kdW1t eV90YXJnZXQsCisgICAgX2JmZF9kdW1teV90YXJnZXQsCisgIH0sCisgIHsK KyAgICBiZmRfZmFsc2UsCisgICAgd2FzbV9ta29iamVjdCwKKyAgICBfYmZk X2dlbmVyaWNfbWthcmNoaXZlLAorICAgIGJmZF9mYWxzZSwKKyAgfSwKKyAg ewkJCQkvKiBiZmRfd3JpdGVfY29udGVudHMuICAqLworICAgIGJmZF9mYWxz ZSwKKyAgICB3YXNtX3dyaXRlX29iamVjdF9jb250ZW50cywKKyAgICBfYmZk X3dyaXRlX2FyY2hpdmVfY29udGVudHMsCisgICAgYmZkX2ZhbHNlLAorICB9 LAorCisgIEJGRF9KVU1QX1RBQkxFX0dFTkVSSUMgKF9iZmRfZ2VuZXJpYyks CisgIEJGRF9KVU1QX1RBQkxFX0NPUFkgKF9iZmRfZ2VuZXJpYyksCisgIEJG RF9KVU1QX1RBQkxFX0NPUkUgKF9iZmRfbm9jb3JlKSwKKyAgQkZEX0pVTVBf VEFCTEVfQVJDSElWRSAoX2JmZF9ub2FyY2hpdmUpLAorICBCRkRfSlVNUF9U QUJMRV9TWU1CT0xTICh3YXNtKSwKKyAgQkZEX0pVTVBfVEFCTEVfUkVMT0NT IChfYmZkX25vcmVsb2NzKSwKKyAgQkZEX0pVTVBfVEFCTEVfV1JJVEUgKHdh c20pLAorICBCRkRfSlVNUF9UQUJMRV9MSU5LIChfYmZkX25vbGluayksCisg IEJGRF9KVU1QX1RBQkxFX0RZTkFNSUMgKF9iZmRfbm9keW5hbWljKSwKKwor ICBOVUxMLAorCisgIE5VTEwsCit9OwpkaWZmIC0tZ2l0IGEvYmZkL3dhc20t bW9kdWxlLmggYi9iZmQvd2FzbS1tb2R1bGUuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwLi5iNmNiN2Q1NjVmCi0tLSAvZGV2L251 bGwKKysrIGIvYmZkL3dhc20tbW9kdWxlLmgKQEAgLTAsMCArMSw1MiBAQAor LyogQkZEIGJhY2stZW5kIGZvciBXZWJBc3NlbWJseSBtb2R1bGVzLgorICAg Q29weXJpZ2h0IChDKSAyMDE3IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLgorCisgICBUaGlzIGZpbGUgaXMgcGFydCBvZiBCRkQsIHRoZSBCaW5h cnkgRmlsZSBEZXNjcmlwdG9yIGxpYnJhcnkuCisKKyAgIFRoaXMgcHJvZ3Jh bSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBh bmQvb3IgbW9kaWZ5CisgICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICAg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24g MyBvZiB0aGUgTGljZW5zZSwgb3IKKyAgIChhdCB5b3VyIG9wdGlvbikgYW55 IGxhdGVyIHZlcnNpb24uCisKKyAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAg YnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAgIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisK KyAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgICBhbG9uZyB3aXRoIHRoaXMg cHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQor ICAgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0IC0gRmlm dGggRmxvb3IsIEJvc3RvbiwKKyAgIE1BIDAyMTEwLTEzMDEsIFVTQS4gICov CisKKyNpZm5kZWYgX1dBU01fTU9EVUxFX0gKKyNkZWZpbmUgX1dBU01fTU9E VUxFX0gKKworLyogV2ViQXNzZW1ibHkgbW9kdWxlIGZpbGUgaGVhZGVyLiBO b3RlIHRoYXQgV0FTTV9WRVJTSU9OIGlzIGEgMzItYml0CisgICBsaXR0bGUt ZW5kaWFuIGludGVnZXIsIG5vdCBhbiBMRUIxMjgtZW5jb2RlZCBpbnRlZ2Vy LiAqLworI2RlZmluZSBXQVNNX01BR0lDICAgIHsgMHgwMCwgJ2EnLCAncycs ICdtJyB9CisjZGVmaW5lIFdBU01fVkVSU0lPTiAgeyAweDAxLCAweDAwLCAw eDAwLCAweDAwfQorCisvKiBQcmVmaXggdG8gdXNlIHRvIGZvcm0gc2VjdGlv biBuYW1lcy4gKi8KKyNkZWZpbmUgV0FTTV9TRUNUSU9OX1BSRUZJWCAiLndh c20uIgorCisvKiBOVU1CRVIgaXMgY3VycmVudGx5IHVudXNlZCwgYnV0IGlz IGluY2x1ZGVkIGZvciBlcnJvciBjaGVja2luZworICAgcHVycG9zZXMuICov CisjZGVmaW5lIFdBU01fU0VDVElPTihudW1iZXIsIG5hbWUpIChXQVNNX1NF Q1RJT05fUFJFRklYIG5hbWUpCisKKy8qIHNlY3Rpb24gbmFtZXMuIFdBU01f TkFNRV9TRUNUSU9OIGlzIHRoZSBuYW1lIG9mIHRoZSBuYW1lZCBzZWN0aW9u CisgICBuYW1lZCAibmFtZSIuICovCisjZGVmaW5lIFdBU01fTkFNRV9TRUNU SU9OICAgICAgICAgV0FTTV9TRUNUSU9OKDAsICJuYW1lIikKKyNkZWZpbmUg V0FTTV9SRUxPQ19TRUNUSU9OX1BSRUZJWCBXQVNNX1NFQ1RJT04oMCwgInJl bG9jLiIpCisjZGVmaW5lIFdBU01fTElOS0lOR19TRUNUSU9OICAgICAgV0FT TV9TRUNUSU9OKDAsICJsaW5raW5nIikKKyNkZWZpbmUgV0FTTV9EWUxJTktf U0VDVElPTiAgICAgICBXQVNNX1NFQ1RJT04oMCwgImR5bGluayIpCisKKy8q IHN1YnNlY3Rpb24gaW5kaWNlcy4gUmlnaHQgbm93LCB0aGF0J3Mgc3Vic2Vj dGlvbnMgb2YgdGhlICJuYW1lIgorICAgc2VjdGlvbiBvbmx5LiAqLworI2Rl ZmluZSBXQVNNX0ZVTkNUSU9OX1NVQlNFQ1RJT04gMSAvKiBmdW5jdGlvbiBu YW1lcyAqLworI2RlZmluZSBXQVNNX0xPQ0FMU19TVUJTRUNUSU9OICAgMiAv KiBuYW1lcyBvZiBsb2NhbHMgYnkgZnVuY3Rpb24gKi8KKworCisvKiBUaGUg c2VjdGlvbiB0byByZXBvcnQgd2FzbSBzeW1ib2xzIGluLiAqLworI2RlZmlu ZSBXQVNNX1NFQ1RJT05fRlVOQ1RJT05fSU5ERVggIi5zcGFjZS5mdW5jdGlv bl9pbmRleCIKKworI2VuZGlmIC8qIF9XQVNNX01PRFVMRV9IICovCg== --001a1146370a7c2950054b6700fc--