From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id cZpAClK9DGr/bwgAWB0awg (envelope-from ) for ; Tue, 19 May 2026 15:43:14 -0400 Authentication-Results: simark.ca; dkim=pass (1024-bit key; unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=Hch8q2ee; dkim-atps=neutral Received: by simark.ca (Postfix, from userid 112) id 24E1F1E024; Tue, 19 May 2026 15:43:14 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-25) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-3.4 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED,RCVD_IN_VALIDITY_CERTIFIED_BLOCKED, RCVD_IN_VALIDITY_RPBL_BLOCKED,RCVD_IN_VALIDITY_SAFE_BLOCKED autolearn=ham autolearn_force=no version=4.0.1 Received: from vm01.sourceware.org (vm01.sourceware.org [38.145.34.32]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange x25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id 471A51E024 for ; Tue, 19 May 2026 15:43:11 -0400 (EDT) Received: from vm01.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 559D54BB588C for ; Tue, 19 May 2026 19:43:10 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 559D54BB588C Authentication-Results: sourceware.org; dkim=pass (1024-bit key, unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=Hch8q2ee Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTP id 4FD074BB3BF1 for ; Tue, 19 May 2026 19:42:36 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 4FD074BB3BF1 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 4FD074BB3BF1 Authentication-Results: sourceware.org; arc=none smtp.remote-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1779219756; cv=none; b=hFp9p7oh664NiCz+fVQsy8Liap1mAKPoC3FAo88Gxpukw+T4N/GocnKRy1oqhccZ1+D35d2pxodrJ01ZaSpLZIWmU2/FaUV87Mwpun+e0WrM6uoCmKQXGNAX616dUw5iR7vleqrYPS2XxtDu404UU0QaFD/wHEWDEmLmabNesek= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1779219756; c=relaxed/simple; bh=Fac2Xa3ylJyJMsM9j7j23DPlPWENQxyThhcmOSHiS34=; h=DKIM-Signature:Message-ID:Date:MIME-Version:Subject:To:From; b=NkMevSb4nYoY8DSqaORPrfAegWZv3vy7VEmn9JhGbM2uR4e99aQToRzdYes28n3AfFIB3s1ThphMgXi21tRaG/1Tli6CpHX1TVkow+qIWwRA3Gs7h3Jj7ig7ebPyWQYMR9wE+JsxcgBMiAPiDHtDkhsP0WNymcC6aIbplqj8O4E= ARC-Authentication-Results: i=1; sourceware.org; dkim=pass (1024-bit key, unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=Hch8q2ee DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 4FD074BB3BF1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1779219756; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=Xr+eK3j2Hz1RGuRKvhNC+vYMFpcVZOrRyPaae820LEo=; b=Hch8q2eehgiUJT8TulRLtnLUsPLxrSSBr0kqRBIs3akNPsCZlwYlFN1vTyhE2CSu7VIUek NYO0pTOLiOjqmITWBTr+YKbA+FsJsWi2nLKGWF6XiZrniQjBbDEhRqby6D0lhxBFYi2urE 9HSizlo+C4J1FfpBjktvkEJ3SPEj1TE= Received: from mail-vk1-f197.google.com (mail-vk1-f197.google.com [209.85.221.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-520-7j3yN_FNPG2e28JZeXZ-vA-1; Tue, 19 May 2026 15:42:31 -0400 X-MC-Unique: 7j3yN_FNPG2e28JZeXZ-vA-1 X-Mimecast-MFC-AGG-ID: 7j3yN_FNPG2e28JZeXZ-vA_1779219751 Received: by mail-vk1-f197.google.com with SMTP id 71dfb90a1353d-57539ff73cbso9422123e0c.0 for ; Tue, 19 May 2026 12:42:31 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779219750; x=1779824550; h=in-reply-to:from:content-language:references:cc:to:subject :user-agent:mime-version:date:message-id:x-gm-gg:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=8pQCP7ESNNIA9XtmQWkApCcMJUqDQkiFZHiKhD0SGhg=; b=E1kItQhKVqGOoK6HXPPIlHzLNXhCLU7FU4WsqxbSOiOI+kIfsKlx1I/XRLN8sxSB2f M9gXJVVP1/WaOme3s/UUxa+cDRKG0T0IidCP1ImkoftImXMCj8+nW74fK9kd97VK6X2u 3lr68Z8rSQawrCjcopmDmUzCNdAYdbgnqRmDTb0EySX33XO+3OaubJ59iI7p2jVZ48T7 OIoFyUT+uFyO+Cyl9nPn7msAp3eo9m1PrWKYvt6Sg+MF21CKQlSuCyoch8oT21DW7gaW WHInZ0CQW9qaSWpLUgk3qSV8HiMDk1lvFioqubCRNQiVD7Clc6AO6VUzkFMDiMsoc5oI /1sQ== X-Forwarded-Encrypted: i=1; AFNElJ9wLyP9Pl+NOqGIr1lOoLhTxaqpheqiEVxJzIZQq0iLBwX5GWwFBGHQNjZpTXZ9125EYBsmpblbIeryuw==@sourceware.org X-Gm-Message-State: AOJu0YwqoRaODSnVjHd/y6Bzt8GAwUL0YmQ58Hwh2DAgtsHM+OuBCRPl Ods7kq2Pndy3ALsiAGNRaJ5zv5MZ7sHPFaWtva3iBPVcmwaU6ah5u4Scdd0YaaSuVZNWlsEQ3nz BzOxGmsFYzNoZ1fIKlH8KZ6On5iBKDlLAoF0IoYxRC2zIOfYhQdFub2l7KNUlTw3V6SzgB3E= X-Gm-Gg: Acq92OF94/UPxBU1lkCmgiEMD2wLpr4fZhzjZGGWfRHSDMIbQroydwZpu+sZhF6Qbe3 0Dc7aeef2O9mDZWIzMXsZVOT2sWAnvyrIxi7WDgl7yYa9e7Pd/gOf1WJOdtCinPSMUIf9SP7Yyq 9QtD3/sFJleKGf6ivYFqLbY+FjMwOQxfnMuHAx5nJ7+PhS5fFJaV/aYBFLOISeYo4zOS1k82ECB zW5eqXqjIhi6pqQ+XmnczdC2BUW0Q2Ro0MlDxhnLJsc8R+JE0K3OQNjVZv2NEVrnieP6Vn3A05O PeZDvHL4pZsALeW5X6iFU+aeJhAWrRXl3Nc+xr/H0cwfjHGbwKXTUSXY168S6Hc5/4F9puNoP7Q xGkeuqqZfjqt+47flKRAjGIinAt/kxlQZtAGUnpVtPmIF/rWnai/hXBLBgnkZ1Uj9WkCY X-Received: by 2002:a05:6122:a07:b0:575:f155:8cd4 with SMTP id 71dfb90a1353d-5760b5a5c01mr3037551e0c.0.1779219750037; Tue, 19 May 2026 12:42:30 -0700 (PDT) X-Received: by 2002:a05:6122:a07:b0:575:f155:8cd4 with SMTP id 71dfb90a1353d-5760b5a5c01mr3037538e0c.0.1779219749179; Tue, 19 May 2026 12:42:29 -0700 (PDT) Received: from ?IPV6:2804:14d:8084:993e:2d5d:7adb:2b6:a50e? ([2804:14d:8084:993e:2d5d:7adb:2b6:a50e]) by smtp.gmail.com with ESMTPSA id 71dfb90a1353d-5760f58feacsm9134105e0c.1.2026.05.19.12.42.26 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 19 May 2026 12:42:28 -0700 (PDT) Message-ID: <88ae1a52-4417-47d9-a01e-57365e436454@redhat.com> Date: Tue, 19 May 2026 16:42:24 -0300 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v3 7/7] gdb/dwarf: read foreign type units To: Simon Marchi , gdb-patches@sourceware.org Cc: Tom Tromey References: <20260511154053.142576-1-simon.marchi@efficios.com> <20260511154053.142576-8-simon.marchi@efficios.com> From: Guinevere Larsen In-Reply-To: <20260511154053.142576-8-simon.marchi@efficios.com> X-Mimecast-Spam-Score: 0 X-Mimecast-MFC-PROC-ID: Y8YXJxKZDBafgX4yj8QErMB7p5Xb8vMNZf5S_sRoamw_1779219751 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="------------vuZd0N8a40ZHqMlP4y5pC3WP" Content-Language: en-US X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~public-inbox=simark.ca@sourceware.org This is a multi-part message in MIME format. --------------vuZd0N8a40ZHqMlP4y5pC3WP Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Hi Simon! This commit seems to have made the gdb.dwarf2/debug-names-bad-cu-index.exp have some racy cases. I've attached a log of the failed run in this email to help you figure out what could be going on. On 5/11/26 12:40 PM, Simon Marchi wrote: > In DWARF 5, foreign type units are type units present in .dwo files. > Type units in .dwo files don't have a matching skeleton in the main > file. When an .debug_names index is present, it can't include those > type units in the regular type unit list, since that list specifies > offsets in the main file. They are instead listed in the foreign TU > list, which is basically just a list of type signatures. > > In order to help the debugger locate these units (i.e. find the .dwo > file containing them), individual index entries referencing foreign type > units may also include a reference to a compile unit that the debugger > can follow to find the appropriate .dwo file. > > This patch implements reading the .debug_names foreign TU list and using > these "hint" CUs to locate foreign type units. I use the term "hint" > throughout the code, but I don't mind another name if someone has a > better idea. > > The first part is to read the actual foreign TU list from the > .debug_names index and create signatured_type objects out of them. This > is done in the new function create_foreign_type_units_from_debug_names. > Append the newly created signatured_type to the > mapped_debug_names_reader::foreign_type_units vector, which will be used > later to resolve DW_IDX_type_unit indices. Populate the > dwarf2_per_bfd::signatured_types set, which contains signatured_types > indexed by signature. And finally, transfer ownership of the object to > the dwarf2_per_bfd::all_units vector. > > Previously, all dwarf2_per_cu (including signatured_type) objects were > created with a non-nullptr section. With foreign type units, we don't > know the section at creation time. We also don't know the offset into > section nor the size of the unit. Therefore, add a > dwarf2_per_bfd::allocate_signatured_type overload that takes just the > signature. Remove the "section != nullptr" assert from the > dwarf2_per_cu constructor, but add it to the other allocate_* methods. > > Since the new create_foreign_type_units_from_debug_names function adds > items to the dwarf2_per_bfd::all_units vector, the vector needs to be > sorted after create_foreign_type_units_from_debug_names runs. Remove > the finalize_all_units call from create_all_units, making the callers > responsible to call it. > > The next step is to read the hint CU attributes when scanning the index > entries. Rework mapped_debug_names_reader::scan_one_entry to remember > which kind of unit references it saw for the entry (comp, type and/or > foreign type) and then figure out what this means. The logic is: > > - Did the entry reference a foreign type unit? If so, it's a foreign > type unit. Does it also reference a hint CU? If not, drop the > entry, there's nothing useful we can do with it. > > - Otherwise, did the entry reference a (non-foreign) type unit? Then > it's a regular type unit. If so, it shouldn't also have a > DW_IDX_compile_unit. > > - Otherwise, did the entry reference a comp unit? If so, it's a comp > unit. > > - Otherwise, we don't know what unit the entry references, it's an > error. > > Since the .debug_name index attaches hint CU attributes to individual > index entries, my initial implementation added the hint CU information > to the cooked_index_entry structure. I am not sure why DWARF 5 chose to > do it this way, as opposed to attaching one hint per foreign TU. Does > this mean that two type units with the same signature could be different > and, for a specific index entry, it would be important to find one > specific instance of the type unit over the others? I have no idea. > > However, I know that the current GDB DWARF reader is not able to load > multiple type units with the same signature but different content. Once > it loads one type unit with a given signature, all subsequent references > to that signature will use that loaded type unit. I therefore chose to > have the .debug_names reader record just one hint CU per foreign TU. > This avoids growing the cooked_index_entry structure for nothing, and > having to pass through this information through multiple layers. > > The next step is to locate the .dwo file containing the foreign TUs when > we need them. This sometimes makes use of the hint CU, but not always. > I identified these 3 code paths: > > 1. When the type unit gets expanded directly, for instance if you use > "ptype" and there is a direct match into the type unit. This case > is handled in load_full_type_unit, calling a new function > fill_in_sig_entry_from_per_cu_hint. This one uses the hint recorded > by the .debug_names reader. When a cooked index entry exists and > refers to a foreign TU for which the section is not yet known, we > know that there exists a hint, otherwise we wouldn't have created > the entry in the first place. > > 2. The second one is when the type unit is referenced by some other > unit. This case is handled in follow_die_sig_1, calling another new > function fill_in_sig_entry_from_dwo_file. In this case, we know > which unit is referring to the TU, so we use that unit's dwo file to > fill in the details. As explained in the comment, this is sometimes > just an optimization, but sometimes also necessary, if the TU > does not have a hint, due to it not containing any indexed name. > > 3. Similarly, in dwarf2_base_index_functions::expand_all_symtabs, we > might have to handle foreign type units for which we don't have a > hint. I initially implemented something in two passes, to go dig in > the dwo_file structures to find those TUs, but ended up choosing to > just skip them, for the reasons explained in the comment there. > > Setting a dwarf2_per_cu's section a posteriori breaks the assumed > ordering of the dwarf2_per_bfd::all_units vector. After setting the > section, re-sort the vector. > > Add a target board to exercise this new code. This board builds with: > > - type units (-fdebug-types-section) > - split DWARF (-gsplit-dwarf) > - .debug_names index (created by GDB) > > I ran the whole testsuite with this board file and it's not perfect, but > the results are comparable to the dwarf5-fission-debug-types board, for > instance. > > There is one known failure that I am unable to get to the bottom of. It > seems orthogonal to my change though, more like an indexer or symbol > reader issue. There are maybe more of this kind, but this is one > example: > > FAIL: gdb.ada/tick_length_array_enum_idx.exp: ptype variable_table'length (GDB internal error) > > /home/smarchi/src/binutils-gdb/gdb/dwarf2/read.c:1839: internal-error: search_one: Assertion `symtab != nullptr' failed. > > The problem appears to be that a cooked index lookup for symbol > variable_table says that a given TU should contain a match. But then > trying to expand the TU makes dw2_instantiate_symtab yield a nullptr > compunit_symtab, I think because the symbol reader found nothing > interesting symbol-wise. And then the assert in search_one triggers. > > The issue seems sensitive to some aspects of the environment (gnat > version?). I am able to reproduce the issue on Arch Linux (gnat 15) > with: > > $ make check TESTS="gdb.ada/tick_length_array_enum_idx.exp" RUNTESTFLAGS="--target_board=dwarf5-fission-debug-types-debug-names" > > But it doesn't reproduce on Debian 13 (gnat 14), Ubuntu 24.04 (gnat > 13) or Fedora Rawhide (gnat 16). > > Change-Id: I0d4ccc1cbbce3a337794341744d24091e8549d7f > Approved-By: Tom Tromey > --- > gdb/dwarf2/read-debug-names.c | 212 ++++++++++++++---- > gdb/dwarf2/read.c | 167 +++++++++++++- > gdb/dwarf2/read.h | 37 ++- > gdb/dwarf2/types.h | 2 + > ...dwarf5-fission-debug-types-debug-names.exp | 29 +++ > 5 files changed, 392 insertions(+), 55 deletions(-) > create mode 100644 gdb/testsuite/boards/dwarf5-fission-debug-types-debug-names.exp > > diff --git a/gdb/dwarf2/read-debug-names.c b/gdb/dwarf2/read-debug-names.c > index 487e2ea87edb..a062c1ad2562 100644 > --- a/gdb/dwarf2/read-debug-names.c > +++ b/gdb/dwarf2/read-debug-names.c > @@ -88,9 +88,13 @@ struct mapped_debug_names_reader > > uint8_t offset_size = 0; > uint32_t cu_count = 0; > - uint32_t tu_count = 0, bucket_count = 0, name_count = 0; > + uint32_t tu_count = 0; > + uint32_t foreign_tu_count = 0; > + uint32_t bucket_count = 0; > + uint32_t name_count = 0; > const gdb_byte *cu_table_reordered = nullptr; > const gdb_byte *tu_table_reordered = nullptr; > + const gdb_byte *foreign_tu_table_reordered = nullptr; > const uint32_t *bucket_table_reordered = nullptr; > const uint32_t *hash_table_reordered = nullptr; > const gdb_byte *name_table_string_offs_reordered = nullptr; > @@ -122,7 +126,11 @@ struct mapped_debug_names_reader > > /* List of local TUs in the same order as found in the index (DWARF 5 section > 6.1.1.4.3). */ > - std::vector type_units; > + std::vector type_units; > + > + /* List of foreign TUs in the same order as found in the index (DWARF 5 > + section 6.1.1.4.4). */ > + std::vector foreign_type_units; > > /* Even though the scanning of .debug_names and creation of the > cooked index entries is done serially, we create multiple shards > @@ -217,7 +225,10 @@ mapped_debug_names_reader::scan_one_entry (const char *name, > cooked_index_flag flags = 0; > sect_offset die_offset {}; > enum language lang = language_unknown; > - dwarf2_per_cu *per_cu = nullptr; > + dwarf2_per_cu *comp_unit = nullptr; > + signatured_type *type_unit = nullptr; > + signatured_type *foreign_type_unit = nullptr; > + > for (const auto &attr : indexval.attr_vec) > { > ULONGEST ull; > @@ -282,7 +293,6 @@ mapped_debug_names_reader::scan_one_entry (const char *name, > { > case DW_IDX_compile_unit: > { > - /* Don't crash on bad data. */ > if (ull >= this->comp_units.size ()) > { > complain_about_index_entry > @@ -292,13 +302,17 @@ mapped_debug_names_reader::scan_one_entry (const char *name, > continue; > } > > - per_cu = this->comp_units[ull]; > + comp_unit = this->comp_units[ull]; > break; > } > case DW_IDX_type_unit: > { > - /* Don't crash on bad data. */ > - if (ull >= this->type_units.size ()) > + if (ull < this->type_units.size ()) > + type_unit = this->type_units[ull]; > + else if (auto foreign_idx = ull - this->type_units.size (); > + foreign_idx < this->foreign_type_units.size ()) > + foreign_type_unit = this->foreign_type_units[foreign_idx]; > + else > { > complain_about_index_entry > (abfd, name, offset_in_entry_pool, > @@ -307,15 +321,10 @@ mapped_debug_names_reader::scan_one_entry (const char *name, > continue; > } > > - per_cu = this->type_units[ull]; > break; > } > case DW_IDX_die_offset: > die_offset = sect_offset (ull); > - /* In a per-CU index (as opposed to a per-module index), index > - entries without CU attribute implicitly refer to the single CU. */ > - if (per_cu == nullptr) > - per_cu = this->comp_units[0]; > break; > case DW_IDX_parent: > parent = ull; > @@ -339,27 +348,117 @@ mapped_debug_names_reader::scan_one_entry (const char *name, > } > } > > - /* Skip if we couldn't find a valid CU/TU index. */ > - if (per_cu != nullptr) > + /* From DWARF 5 section 6.1.1.3 ("Per-CU versus Per-Module Indexes"): > + > + In a per-CU index, the CU list may have only a single entry, and index > + entries may omit the CU attribute. */ > + if (comp_unit == nullptr > + && type_unit == nullptr > + && foreign_type_unit == nullptr) > { > - dwarf_read_debug_printf_v > - (" -> die_offset %s, per_cu offset %s", > - sect_offset_str (die_offset), > - sect_offset_str (per_cu->sect_off ())); > + if (this->comp_units.size () != 1) > + { > + complain_about_index_entry > + (abfd, name, offset_in_entry_pool, > + _(".debug_names entry is missing CU index, but index has %zu CUs " > + "(expecting 1)"), > + this->comp_units.size ()); > + return entry; > + } > > - *result > - = indices[next_shard].add (die_offset, (dwarf_tag) indexval.dwarf_tag, > - flags, lang, name, nullptr, per_cu); > - > - ++next_shard; > - if (next_shard == indices.size ()) > - next_shard = 0; > - > - entry_pool_offsets_to_entries.emplace (offset_in_entry_pool, *result); > + comp_unit = this->comp_units[0]; > } > - else > - dwarf_read_debug_printf_v (" -> no valid CU/TU, skipping"); > > + /* Figure out which unit this entry refers to. */ > + dwarf2_per_cu *actual_unit; > + > + if (foreign_type_unit != nullptr) > + { > + if (type_unit != nullptr) > + { > + complain_about_index_entry > + (abfd, name, offset_in_entry_pool, > + _(".debug_names entry refers to two TUs")); > + return entry; > + } > + > + /* Implement this part of DWARF 5 section 6.1.1.2 ("Structure of the Name > + Index"): > + > + When an index entry refers to a foreign type unit, it may have > + attributes for both CU and (foreign) TU. For such entries, the CU > + attribute gives the consumer a reference to the CU that may be used > + to locate a split DWARF object file that contains the type unit. */ > + if (comp_unit == nullptr) > + { > + /* If a foreign type unit does not say which compile unit to follow > + to find it, it's pretty much useless. */ > + complain_about_index_entry > + (abfd, name, offset_in_entry_pool, > + _(".debug_names entry refers to foreign type unit but " > + "no compile unit")); > + return entry; > + } > + > + actual_unit = foreign_type_unit; > + > + /* .debug_names attaches one "hint" CU per index entry, insinuating that > + for some names / index entries, it is important which .dwo we choose to > + locate the TU. Even if it's important, the DWARF reader is not > + currently able to load multiple versions of the same TU. So just > + record one hint CU for each foreign TU. */ > + if (foreign_type_unit->hint_per_cu == nullptr) > + { > + foreign_type_unit->hint_per_cu = comp_unit; > + dwarf_read_debug_printf_v > + (" hint CU for foreign type unit with signature %s: " > + "unit offset %s", > + hex_string (foreign_type_unit->signature), > + sect_offset_str (comp_unit->sect_off ())); > + } > + } > + else if (type_unit != nullptr) > + { > + if (comp_unit != nullptr) > + { > + complain_about_index_entry > + (abfd, name, offset_in_entry_pool, > + _(".debug_names entry refers to both a CU and a TU")); > + return entry; > + } > + > + actual_unit = type_unit; > + } > + else if (comp_unit != nullptr) > + actual_unit = comp_unit; > + else > + { > + complain_about_index_entry > + (abfd, name, offset_in_entry_pool, > + _(".debug_names entry is missing a CU or TU reference")); > + return entry; > + } > + > + gdb_assert (actual_unit != nullptr); > + > + if (foreign_type_unit != nullptr) > + dwarf_read_debug_printf_v (" -> signature %s, DIE offset: %s", > + hex_string (foreign_type_unit->signature), > + sect_offset_str (die_offset)); > + else > + dwarf_read_debug_printf_v (" -> unit offset %s, DIE offset %s", > + sect_offset_str (actual_unit->sect_off ()), > + sect_offset_str (die_offset)); > + > + *result = indices[next_shard].add (die_offset, > + (dwarf_tag) indexval.dwarf_tag, flags, > + lang, name, nullptr, actual_unit); > + > + ++next_shard; > + if (next_shard == indices.size ()) > + next_shard = 0; > + > + entry_pool_offsets_to_entries.emplace (offset_in_entry_pool, *result); > return entry; > } > > @@ -553,7 +652,7 @@ build_and_check_tu_list_from_debug_names (dwarf2_per_objfile *per_objfile, > return false; > } > > - map.type_units.emplace_back (per_cu); > + map.type_units.emplace_back (per_cu->as_signatured_type ()); > } > > return true; > @@ -665,22 +764,12 @@ read_debug_names_from_section (dwarf2_per_objfile *per_objfile, > > /* foreign_type_unit_count - The number of TUs in the foreign TU > list. */ > - uint32_t foreign_tu_count = read_4_bytes (abfd, addr); > + map.foreign_tu_count = read_4_bytes (abfd, addr); > addr += 4; > > dwarf_read_debug_printf ("cu_count: %u, tu_count: %u, " > "foreign_tu_count: %u", > - map.cu_count, map.tu_count, foreign_tu_count); > - > - if (foreign_tu_count != 0) > - { > - warning (_("Section .debug_names in %ps has unsupported %lu foreign TUs, " > - "ignoring .debug_names."), > - styled_string (file_name_style.style (), > - filename), > - static_cast (foreign_tu_count)); > - return false; > - } > + map.cu_count, map.tu_count, map.foreign_tu_count); > > /* bucket_count - The number of hash buckets in the hash lookup > table. */ > @@ -761,6 +850,10 @@ read_debug_names_from_section (dwarf2_per_objfile *per_objfile, > map.tu_table_reordered = addr; > addr += map.tu_count * map.offset_size; > > + /* List of foreign TUs */ > + map.foreign_tu_table_reordered = addr; > + addr += map.foreign_tu_count * sizeof (std::uint64_t); > + > /* Hash Lookup Table */ > map.bucket_table_reordered = reinterpret_cast (addr); > addr += map.bucket_count * 4; > @@ -918,6 +1011,35 @@ build_and_check_cu_lists_from_debug_names (dwarf2_per_bfd *per_bfd, > return build_and_check_cu_list_from_debug_names (per_bfd, dwz_map, dwz->info); > } > > +/* Create signatured_type objects for the foreign TU list in MAP. */ > + > +static void > +create_foreign_type_units_from_debug_names (dwarf2_per_bfd *per_bfd, > + mapped_debug_names_reader &map) > +{ > + for (uint32_t i = 0; i < map.foreign_tu_count; ++i) > + { > + /* The list of foreign TUs is a list of 64-bit (DW_FORM_ref_sig8) type > + signatures representing type units placed in .dwo files. All we know > + about them for now is the signature. */ > + const gdb_byte *ptr > + = map.foreign_tu_table_reordered + i * sizeof (std::uint64_t); > + std::uint64_t sig > + = extract_unsigned_integer (ptr, sizeof (std::uint64_t), > + map.dwarf5_byte_order); > + > + dwarf_read_debug_printf_v (" Foreign TU %u (%u): signature %s", i, > + i + map.tu_count, hex_string (sig)); > + > + signatured_type_up sig_type > + = per_bfd->allocate_signatured_type (sig); > + > + map.foreign_type_units.emplace_back (sig_type.get ()); > + per_bfd->signatured_types.emplace (sig_type.get ()); > + per_bfd->all_units.emplace_back (sig_type.release ()); > + } > +} > + > /* See read-debug-names.h. */ > > bool > @@ -975,6 +1097,12 @@ dwarf2_read_debug_names (dwarf2_per_objfile *per_objfile) > return false; > } > > + create_foreign_type_units_from_debug_names (per_objfile->per_bfd, map); > + > + /* create_foreign_type_units_from_debug_names may add more entries to the > + ALL_UNITS vector, so it must be called before finalize_all_units. */ > + finalize_all_units (per_objfile->per_bfd); > + > per_bfd->debug_aranges.read (per_objfile->objfile); > > /* There is a single address map for the whole index (coming from > diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c > index d061bc22b12d..4d8923d3ca7a 100644 > --- a/gdb/dwarf2/read.c > +++ b/gdb/dwarf2/read.c > @@ -695,6 +695,13 @@ static struct die_info *follow_die_ref (struct die_info *, > const struct attribute *, > struct dwarf2_cu **); > > +static void fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile *per_objfile, > + signatured_type *sig_entry, > + dwo_unit *dwo_entry); > + > +static void fill_in_sig_entry_from_per_cu_hint > + (dwarf2_per_objfile &per_objfile, signatured_type &sig_type); > + > static struct die_info *follow_die_sig (struct die_info *, > const struct attribute *, > struct dwarf2_cu **); > @@ -1415,6 +1422,7 @@ dwarf2_per_bfd::allocate_per_cu (dwarf2_section_info *section, > sect_offset sect_off, unsigned int length, > bool is_dwz) > { > + gdb_assert (section != nullptr); > dwarf2_per_cu_up result (new dwarf2_per_cu (this, section, sect_off, > length, is_dwz)); > result->index = all_units.size (); > @@ -1431,6 +1439,7 @@ dwarf2_per_bfd::allocate_signatured_type (dwarf2_section_info *section, > bool is_dwz, > ULONGEST signature) > { > + gdb_assert (section != nullptr); > auto result > = std::make_unique (this, section, sect_off, length, > is_dwz, signature); > @@ -1439,6 +1448,20 @@ dwarf2_per_bfd::allocate_signatured_type (dwarf2_section_info *section, > return result; > } > > +/* See read.h. */ > + > +signatured_type_up > +dwarf2_per_bfd::allocate_signatured_type (ULONGEST signature) > +{ > + auto result > + = std::make_unique (this, nullptr, > + invalid_sect_offset, > + 0, false, signature); > + result->index = all_units.size (); > + this->num_type_units++; > + return result; > +} > + > /* Subroutine of dw2_get_file_names_reader to simplify it. > Return the file name for the given file_entry. > CU_INFO describes the CU's DW_AT_name and DW_AT_comp_dir. > @@ -1722,6 +1745,20 @@ dwarf2_base_index_functions::expand_all_symtabs (struct objfile *objfile) > > for (dwarf2_per_cu *per_cu : all_units_range (per_objfile->per_bfd)) > { > + /* If a .debug_names index contains a foreign TU but no index entry > + references it, the TU won't have a hint CU. This is a problem, because > + we won't be able to locate it. Skip them, for the following reasons: > + > + - If they don't contain anything worthy of a named index entry, they > + are unlikely to contain anything interesting, symbol-wise. > + - They are likely to be referred to by some other unit (otherwise, > + why does it exist?), so will get expanded anyway. */ > + if (signatured_type *sig_type = per_cu->as_signatured_type (); > + (sig_type != nullptr > + && sig_type->section () == nullptr > + && sig_type->hint_per_cu == nullptr)) > + continue; > + > /* We don't want to directly expand a partial CU, because if we > read it with the wrong language, then assertion failures can > be triggered later on. See PR symtab/23010. So, tell > @@ -2223,8 +2260,7 @@ add_type_unit (dwarf2_per_bfd *per_bfd, dwarf2_section_info *section, > return emplace_ret.first; > } > > -/* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type. > - Fill in SIG_ENTRY with DWO_ENTRY. */ > +/* Fill in the missing details in SIG_ENTRY from DWO_ENTRY. */ > > static void > fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile *per_objfile, > @@ -2680,6 +2716,10 @@ cutu_reader::cutu_reader (dwarf2_per_cu &this_cu, > { > struct objfile *objfile = per_objfile.objfile; > struct dwarf2_section_info *section = this_cu.section (); > + > + /* Any foreign TU must have been located before getting here. */ > + gdb_assert (section != nullptr); > + > bfd *abfd = section->get_bfd_owner (); > const gdb_byte *begin_info_ptr; > struct dwarf2_section_info *abbrev_section; > @@ -3278,6 +3318,7 @@ cooked_index_worker_debug_info::do_reading () > dwarf2_per_bfd *per_bfd = m_per_objfile->per_bfd; > > create_all_units (m_per_objfile); > + finalize_all_units (m_per_objfile->per_bfd); > process_type_units (m_per_objfile, &m_index_storage); > > if (!per_bfd->debug_aranges.empty ()) > @@ -3358,6 +3399,19 @@ read_comp_units_from_section (dwarf2_per_objfile *per_objfile, > > /* See read.h. */ > > +void > +dwarf2_per_bfd::sort_all_units () > +{ > + std::sort (this->all_units.begin (), this->all_units.end (), > + [] (const dwarf2_per_cu_up &a, const dwarf2_per_cu_up &b) > + { > + return all_units_less_than (*a, { b->section (), > + b->sect_off () }); > + }); > +} > + > +/* See read.h. */ > + > void > finalize_all_units (dwarf2_per_bfd *per_bfd) > { > @@ -3365,14 +3419,7 @@ finalize_all_units (dwarf2_per_bfd *per_bfd) > gdb_assert (per_bfd->all_units.size () > == per_bfd->num_comp_units + per_bfd->num_type_units); > > - /* Ensure that the all_units vector is in the expected order for > - dwarf2_find_containing_unit to be able to perform a binary search. */ > - std::sort (per_bfd->all_units.begin (), per_bfd->all_units.end (), > - [] (const dwarf2_per_cu_up &a, const dwarf2_per_cu_up &b) > - { > - return all_units_less_than (*a, { b->section (), > - b->sect_off () }); > - }); > + per_bfd->sort_all_units (); > } > > /* See read.h. */ > @@ -3410,7 +3457,6 @@ create_all_units (dwarf2_per_objfile *per_objfile) > > per_objfile->per_bfd->signatured_types = std::move (sig_types); > > - finalize_all_units (per_objfile->per_bfd); > remove_all_units.disable (); > } > > @@ -17104,6 +17150,77 @@ dwarf2_get_die_type (cu_offset die_offset, dwarf2_per_cu *per_cu, > return get_die_type_at_offset (die_offset_sect, per_cu, per_objfile); > } > > +/* Fill in the missing details in SIG_TYPE from DWO_FILE. > + > + Error out if there isn't a type unit with the appropriate signature in > + DWO_FILE. */ > + > +static void > +fill_in_sig_entry_from_dwo_file (dwarf2_per_objfile &per_objfile, > + signatured_type &sig_type, dwo_file &dwo_file) > +{ > + gdb_assert (sig_type.section () == nullptr); > + > + dwo_unit *dwo_tu = dwo_file.find_tu (sig_type.signature); > + if (dwo_tu == nullptr) > + error (_(DWARF_ERROR_PREFIX > + "Unable to locate type unit with signature %s in DWO file %s " > + "[in module %s]"), > + hex_string (sig_type.signature), dwo_file.dwo_name.c_str (), > + objfile_name (per_objfile.objfile)); > + > + fill_in_sig_entry_from_dwo_entry (&per_objfile, &sig_type, dwo_tu); > + sig_type.set_section (dwo_tu->section); > + sig_type.set_sect_off (dwo_tu->sect_off); > + sig_type.set_length (dwo_tu->length); > + > + /* Setting SIG_TYPE's section invalidates the ALL_UNITS vector order, > + re-sort it. */ > + per_objfile.per_bfd->sort_all_units (); > +} > + > +/* Fill in the missing details in SIG_TYPE from its hint CU. > + > + Error out if we're unable to locate the .dwo file using the hint CU. */ > + > +static void > +fill_in_sig_entry_from_per_cu_hint (dwarf2_per_objfile &per_objfile, > + signatured_type &sig_type) > +{ > + gdb_assert (sig_type.section () == nullptr); > + gdb_assert (sig_type.hint_per_cu != nullptr); > + > + dwarf2_per_cu *hint_per_cu = sig_type.hint_per_cu; > + dwo_unit *dwo_unit; > + > + /* If a dwarf2_cu already exists for HINT_PER_CU, no need to build another > + one. */ > + if (dwarf2_cu *hint_cu = per_objfile.get_cu (hint_per_cu); > + hint_cu != nullptr) > + dwo_unit = hint_cu->dwo_unit; > + else > + { > + /* Constructing this cutu_reader will look for the .dwo file, creating > + the dwo_file if necessary. */ > + abbrev_table_cache abbrev_table_cache; > + cutu_reader reader (*hint_per_cu, per_objfile, nullptr, true, > + std::nullopt, abbrev_table_cache); > + > + /* dwo_unit is owned by the per_bfd, which outlives the reader. */ > + dwo_unit = reader.cu ()->dwo_unit; > + } > + > + if (dwo_unit == nullptr) > + error (_(DWARF_ERROR_PREFIX > + "Hint compilation unit for foreign type unit with signature %s is " > + "not in a DWO file [in module %s]"), > + hex_string (sig_type.signature), > + objfile_name (per_objfile.objfile)); > + > + fill_in_sig_entry_from_dwo_file (per_objfile, sig_type, > + *dwo_unit->dwo_file); > +} > + > /* Follow type unit SIG_TYPE referenced by SRC_DIE. > On entry *REF_CU is the CU of SRC_DIE. > On exit *REF_CU is the CU of the result. > @@ -17119,6 +17236,28 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type, > we can get here for DW_AT_imported_declaration where we need > the DIE not the type. */ > > + /* If SIG_TYPE's section is not set, it means it's a .debug_names foreign > + type unit for which we don't know the containing file or section yet. > + Use the referencing CU as the hint: we know there must exist a TU with > + the correct signature in its .dwo file, and that .dwo is already open, > + might as well use it. > + > + But this is not only an optimization. If a .debug_names foreign unit > + does not have any index entry referencing it, then we don't have any > + "hint CU" for it. The only hint we have is the referencing CU. */ > + if (sig_type->section () == nullptr) > + { > + if ((*ref_cu)->dwo_unit == nullptr) > + error (_(DWARF_ERROR_PREFIX > + "Unit referencing foreign type unit with signature %s is " > + "not from a DWO file [in module %s]"), > + hex_string (sig_type->signature), > + objfile_name (per_objfile->objfile)); > + > + fill_in_sig_entry_from_dwo_file (*per_objfile, *sig_type, > + *(*ref_cu)->dwo_unit->dwo_file); > + } > + > dwarf2_cu *sig_cu = ensure_loaded_type_unit (sig_type, per_objfile); > > if (sig_cu == nullptr) > @@ -17299,6 +17438,12 @@ load_full_type_unit (signatured_type *sig_type, > gdb_assert (sig_type->is_debug_types ()); > gdb_assert (per_objfile->get_cu (sig_type) == nullptr); > > + /* If the section is not set, this is a .debug_names foreign type unit for > + which we don't know the containing file nor section yet. For these, we > + must have a "hint" CU to follow to find the file and section. */ > + if (sig_type->section () == nullptr) > + fill_in_sig_entry_from_per_cu_hint (*per_objfile, *sig_type); > + > abbrev_table_cache abbrev_table_cache; > cutu_reader reader (*sig_type, *per_objfile, nullptr, false, > std::nullopt, abbrev_table_cache); > diff --git a/gdb/dwarf2/read.h b/gdb/dwarf2/read.h > index a0811fe0d377..12dc6224d8c0 100644 > --- a/gdb/dwarf2/read.h > +++ b/gdb/dwarf2/read.h > @@ -110,7 +110,6 @@ struct dwarf2_per_cu > m_per_bfd (per_bfd) > { > gdb_assert (per_bfd != nullptr); > - gdb_assert (section != nullptr); > } > > private: > @@ -285,9 +284,24 @@ struct dwarf2_per_cu > dwarf2_section_info *section () const > { return m_section; } > > + /* Set the section of this unit. */ > + void set_section (dwarf2_section_info *section) > + { > + gdb_assert (section != nullptr); > + gdb_assert (m_section == nullptr); > + m_section = section; > + } > + > sect_offset sect_off () const > { return m_sect_off; } > > + /* Set the section offset of this unit. */ > + void set_sect_off (sect_offset sect_off) > + { > + gdb_assert (m_sect_off == invalid_sect_offset); > + m_sect_off = sect_off; > + } > + > bool is_dwz () const > { return m_is_dwz; } > > @@ -482,6 +496,12 @@ struct signatured_type : public dwarf2_per_cu > /* Containing DWO unit. > This field is valid iff per_cu.reading_dwo_directly. */ > struct dwo_unit *dwo_unit = nullptr; > + > + /* When using a .debug_names index, the section is not initially known for > + foreign type units (aka skeletonless type units). This is a reference to > + a CU that can be used to locate the .dwo file and section containing the > + type unit. */ > + dwarf2_per_cu *hint_per_cu = nullptr; > }; > > using signatured_type_up = std::unique_ptr; > @@ -576,6 +596,10 @@ struct dwarf2_per_bfd > return this->all_units[index].get (); > } > > + /* Ensure that the all_units vector is in the expected order for > + dwarf2_find_containing_unit to be able to perform a binary search. */ > + void sort_all_units (); > + > /* Return the separate '.dwz' debug file. If there is no > .gnu_debugaltlink or .debug_sup section in the file, then the > result depends on REQUIRE: if REQUIRE is true, error out; if > @@ -610,6 +634,12 @@ struct dwarf2_per_bfd > bool is_dwz, > ULONGEST signature); > > + /* A convenience function to allocate a signatured_type. The > + returned object has its "index" field set properly. > + > + This one is used when only the signature is known at creation time. */ > + signatured_type_up allocate_signatured_type (ULONGEST signature); > + > /* Map all the DWARF section data needed when scanning > .debug_info. */ > void map_info_sections (struct objfile *objfile); > @@ -1334,7 +1364,10 @@ extern const char *read_indirect_string_at_offset > > extern void finalize_all_units (dwarf2_per_bfd *per_bfd); > > -/* Create a list of all compilation units in OBJFILE. */ > +/* Create a list of all compilation units in OBJFILE. > + > + After it is done creating all units, the caller is responsible for calling > + finalize_all_units. */ > > extern void create_all_units (dwarf2_per_objfile *per_objfile); > > diff --git a/gdb/dwarf2/types.h b/gdb/dwarf2/types.h > index 169b0fd08678..cb8ce33940ca 100644 > --- a/gdb/dwarf2/types.h > +++ b/gdb/dwarf2/types.h > @@ -31,6 +31,8 @@ DEFINE_OFFSET_TYPE (cu_offset, unsigned int); > section. */ > DEFINE_OFFSET_TYPE (sect_offset, uint64_t); > > +constexpr auto invalid_sect_offset = static_cast (-1); > + > static inline const char * > sect_offset_str (sect_offset offset) > { > diff --git a/gdb/testsuite/boards/dwarf5-fission-debug-types-debug-names.exp b/gdb/testsuite/boards/dwarf5-fission-debug-types-debug-names.exp > new file mode 100644 > index 000000000000..be8bebed1a43 > --- /dev/null > +++ b/gdb/testsuite/boards/dwarf5-fission-debug-types-debug-names.exp > @@ -0,0 +1,29 @@ > +# Copyright 2026 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, see . > + > +# A board that compiles with DWARF 5, split DWARF (fission) and type units, > +# and generates a .debug_names index using GDB. > +# > +# Example usage: > +# bash$ make check \ > +# RUNTESTFLAGS='--target_board=dwarf5-fission-debug-types-debug-names' > + > +set CC_WITH_TWEAKS_FLAGS "-n" > +load_board_description "cc-with-tweaks" > + > +set_board_info debug_flags \ > + [join { "-gdwarf-5" \ > + "-gsplit-dwarf" \ > + "-fdebug-types-section" }] -- Cheers, Guinevere Larsen It/she --------------vuZd0N8a40ZHqMlP4y5pC3WP Content-Type: text/x-log; charset=UTF-8; name="gdb.log" Content-Disposition: attachment; filename="gdb.log" Content-Transfer-Encoding: base64 VGVzdCBydW4gYnkgZ3dlbnRoZWt3ZWVuIG9uIFR1ZSBNYXkgMTkgMTY6MjU6MTQgMjAyNgpOYXRp dmUgY29uZmlndXJhdGlvbiBpcyB4ODZfNjQtcGMtbGludXgtZ251CgoJCT09PSBnZGIgdGVzdHMg PT09CgpTY2hlZHVsZSBvZiB2YXJpYXRpb25zOgogICAgdW5peAoKUnVubmluZyB0YXJnZXQgdW5p eApVc2luZyAvdXNyL3NoYXJlL2RlamFnbnUvYmFzZWJvYXJkcy91bml4LmV4cCBhcyBib2FyZCBk ZXNjcmlwdGlvbiBmaWxlIGZvciB0YXJnZXQuClVzaW5nIC91c3Ivc2hhcmUvZGVqYWdudS9jb25m aWcvdW5peC5leHAgYXMgZ2VuZXJpYyBpbnRlcmZhY2UgZmlsZSBmb3IgdGFyZ2V0LgpVc2luZyAv aG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0 ZS8uLi8uLi8uLi9kb3duc3RyZWFtLWdkYi9nZGIvdGVzdHN1aXRlL2NvbmZpZy91bml4LmV4cCBh cyB0b29sLWFuZC10YXJnZXQtc3BlY2lmaWMgaW50ZXJmYWNlIGZpbGUuClJ1bm5pbmcgL2hvbWUv Z3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvLi4v Li4vLi4vZG93bnN0cmVhbS1nZGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2RlYnVnLW5hbWVz LWJhZC1jdS1pbmRleC5leHAgLi4uCkV4ZWN1dGluZyBvbiBidWlsZDogcm0gLXJmIC9ob21lL2d3 ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1idWlsZC9nZGIvdGVzdHN1aXRlL291dHB1 dHMvZ2RiLmR3YXJmMi9kZWJ1Zy1uYW1lcy1iYWQtY3UtaW5kZXggICAgKHRpbWVvdXQgPSAzMDAp CmJ1aWx0aW5fc3Bhd24gLWlnbm9yZSBTSUdIVVAgcm0gLXJmIC9ob21lL2d3ZW50aGVrd2Vlbi9E b2N1bWVudHMvZG93bnN0cmVhbS1idWlsZC9nZGIvdGVzdHN1aXRlL291dHB1dHMvZ2RiLmR3YXJm Mi9kZWJ1Zy1uYW1lcy1iYWQtY3UtaW5kZXgNCmdkYl9kb19jYWNoZTogdW5pdmVyc2FsX2NvbXBp bGVfb3B0aW9uc19jICggICkKRXhlY3V0aW5nIG9uIGhvc3Q6IGdjYyAgICAtZmRpYWdub3N0aWNz LWNvbG9yPW5ldmVyIC1jIC1vIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVh bS1idWlsZC9nZGIvdGVzdHN1aXRlL3RlbXAvMjUxNTE1Ny9jY29wdHMubyAvaG9tZS9nd2VudGhl a3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS90ZW1wLzI1MTUx NTcvY2NvcHRzLmMgICAgKHRpbWVvdXQgPSAzMDApCmJ1aWx0aW5fc3Bhd24gLWlnbm9yZSBTSUdI VVAgZ2NjIC1mZGlhZ25vc3RpY3MtY29sb3I9bmV2ZXIgLWMgLW8gL2hvbWUvZ3dlbnRoZWt3ZWVu L0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvdGVtcC8yNTE1MTU3L2Nj b3B0cy5vIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1idWlsZC9nZGIv dGVzdHN1aXRlL3RlbXAvMjUxNTE1Ny9jY29wdHMuYw0KZ2RiX2RvX2NhY2hlOiBnZXRfY29tcGls ZXJfaW5mb18xICggYyApCmdldF9jb21waWxlcl9pbmZvOiBnY2MtMTUtMi0xCmdkYl9kb19jYWNo ZTogZ2V0X2NvbXBpbGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9p bmZvXzEgKCBjICkKZ2RiX2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9k b19jYWNoZTogZ2V0X2NvbXBpbGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21w aWxlcl9pbmZvXzEgKCBjICkKZ2RiX2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyAp CmdkYl9kb19jYWNoZTogZ2V0X2NvbXBpbGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdl dF9jb21waWxlcl9pbmZvXzEgKCBjICkKRXhlY3V0aW5nIG9uIGhvc3Q6IGdjYyAgLWZuby1zdGFj ay1wcm90ZWN0b3IgL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxk L2dkYi90ZXN0c3VpdGUvLi4vLi4vLi4vZG93bnN0cmVhbS1nZGIvZ2RiL3Rlc3RzdWl0ZS9nZGIu ZHdhcmYyL19zdGFydC5jICAtZmRpYWdub3N0aWNzLWNvbG9yPW5ldmVyIC1nICAtbm9zdGFydGZp bGVzIC1sbSAgIC1vIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1idWls ZC9nZGIvdGVzdHN1aXRlL3RlbXAvMjUxNTE1Ny9mdW5jX2FkZHIueCAgICAodGltZW91dCA9IDMw MCkKYnVpbHRpbl9zcGF3biAtaWdub3JlIFNJR0hVUCBnY2MgLWZuby1zdGFjay1wcm90ZWN0b3Ig L2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3Vp dGUvLi4vLi4vLi4vZG93bnN0cmVhbS1nZGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL19zdGFy dC5jIC1mZGlhZ25vc3RpY3MtY29sb3I9bmV2ZXIgLWcgLW5vc3RhcnRmaWxlcyAtbG0gLW8gL2hv bWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUv dGVtcC8yNTE1MTU3L2Z1bmNfYWRkci54DQoKU3RhcnRpbmcgbG9nZmlsZTogL2hvbWUvZ3dlbnRo ZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9n ZGIuZHdhcmYyL2RlYnVnLW5hbWVzLWJhZC1jdS1pbmRleC9nZGIuaW4uMQoKYnVpbHRpbl9zcGF3 biAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3Rz dWl0ZS8uLi8uLi9nZGIvZ2RiIC1udyAtbnggLXEgLWlleCBzZXQgaGVpZ2h0IDAgLWlleCBzZXQg d2lkdGggMCAtZGF0YS1kaXJlY3RvcnkgL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3du c3RyZWFtLWJ1aWxkL2dkYi9kYXRhLWRpcmVjdG9yeSAtaWV4IHNldCBpbnRlcmFjdGl2ZS1tb2Rl IG9uDQooZ2RiKSBzZXQgaGVpZ2h0IDANCihnZGIpIHNldCB3aWR0aCAwDQooZ2RiKSBraWxsDQpU aGUgcHJvZ3JhbSBpcyBub3QgYmVpbmcgcnVuLg0KKGdkYikgZmlsZSAvaG9tZS9nd2VudGhla3dl ZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS90ZW1wLzI1MTUxNTcv ZnVuY19hZGRyLngNClJlYWRpbmcgc3ltYm9scyBmcm9tIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1 bWVudHMvZG93bnN0cmVhbS1idWlsZC9nZGIvdGVzdHN1aXRlL3RlbXAvMjUxNTE1Ny9mdW5jX2Fk ZHIueC4uLg0KKGdkYikgcCBfc3RhcnRfbGFiZWwgLSBfc3RhcnQNCiQxID0gNA0KKGdkYikgZGlz YXNzZW1ibGUgX3N0YXJ0DQpEdW1wIG9mIGFzc2VtYmxlciBjb2RlIGZvciBmdW5jdGlvbiBfc3Rh cnQ6DQogICAweDAwMDAwMDAwMDA0MDAzMzAgPCswPjoJcHVzaCAgICVyYnANCiAgIDB4MDAwMDAw MDAwMDQwMDMzMSA8KzE+Ogltb3YgICAgJXJzcCwlcmJwDQogICAweDAwMDAwMDAwMDA0MDAzMzQg PCs0PjoJbW92ICAgICQweDAsJWVkaQ0KICAgMHgwMDAwMDAwMDAwNDAwMzM5IDwrOT46CWNhbGwg ICAweDQwMDMyMCA8ZXhpdEBwbHQ+DQpFbmQgb2YgYXNzZW1ibGVyIGR1bXAuDQooZ2RiKSB3aXRo IHByaW50IGFzbS1kZW1hbmdsZSBvbiAtLSB4LzJpIF9zdGFydCs5DQogICAweDQwMDMzOSA8X3N0 YXJ0Kzk+OgljYWxsICAgMHg0MDAzMjAgPGV4aXRAcGx0Pg0KICAgMHg0MDAzM2U6CUNhbm5vdCBh Y2Nlc3MgbWVtb3J5IGF0IGFkZHJlc3MgMHg0MDAzM2UNCihnZGIpIGdkYl9kb19jYWNoZTogaXNf NjRfdGFyZ2V0ICggICkKZ2RiX2RvX2NhY2hlOiB1bml2ZXJzYWxfY29tcGlsZV9vcHRpb25zX2Mg KCAgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBjICkKZ2RiX2RvX2NhY2hl OiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19jYWNoZTogZ2V0X2NvbXBpbGVyX2lu Zm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBjICkKZ2RiX2Rv X2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19jYWNoZTogZ2V0X2NvbXBp bGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBjICkK Z2RiX2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19jYWNoZTogZ2V0 X2NvbXBpbGVyX2luZm9fMSAoIGMgKQpFeGVjdXRpbmcgb24gaG9zdDogZ2NjICAtZm5vLXN0YWNr LXByb3RlY3RvciAgLWZkaWFnbm9zdGljcy1jb2xvcj1uZXZlciAtYyAgLW8gL2hvbWUvZ3dlbnRo ZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvdGVtcC8yNTE1 MTU3L2lzXzY0X3RhcmdldC5vIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVh bS1idWlsZC9nZGIvdGVzdHN1aXRlL3RlbXAvMjUxNTE1Ny9pc182NF90YXJnZXQuYyAgICAodGlt ZW91dCA9IDMwMCkKYnVpbHRpbl9zcGF3biAtaWdub3JlIFNJR0hVUCBnY2MgLWZuby1zdGFjay1w cm90ZWN0b3IgLWZkaWFnbm9zdGljcy1jb2xvcj1uZXZlciAtYyAtbyAvaG9tZS9nd2VudGhla3dl ZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS90ZW1wLzI1MTUxNTcv aXNfNjRfdGFyZ2V0Lm8gL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1 aWxkL2dkYi90ZXN0c3VpdGUvdGVtcC8yNTE1MTU3L2lzXzY0X3RhcmdldC5jDQpnZGJfZG9fY2Fj aGU6IGlzXzY0X3RhcmdldCAoICApCmdkYl9kb19jYWNoZTogaXNfNjRfdGFyZ2V0ICggICkKZ2Ri X2RvX2NhY2hlOiBpc182NF90YXJnZXQgKCAgKQpnZGJfZG9fY2FjaGU6IHVuaXZlcnNhbF9jb21w aWxlX29wdGlvbnNfYyAoICApCmdkYl9kb19jYWNoZTogZ2V0X2NvbXBpbGVyX2luZm9fMSAoIGMg KQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBjICkKZ2RiX2RvX2NhY2hlOiBn ZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19jYWNoZTogZ2V0X2NvbXBpbGVyX2luZm9f MSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBjICkKZ2RiX2RvX2Nh Y2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19jYWNoZTogZ2V0X2NvbXBpbGVy X2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBjICkKZ2Ri X2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCkV4ZWN1dGluZyBvbiBob3N0OiBn Y2MgIC1mbm8tc3RhY2stcHJvdGVjdG9yICAtZmRpYWdub3N0aWNzLWNvbG9yPW5ldmVyIC1jICAt byAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3Rz dWl0ZS9vdXRwdXRzL2dkYi5kd2FyZjIvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4L2RlYnVnLW5h bWVzLWJhZC1jdS1pbmRleDAubyAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJl YW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS9vdXRwdXRzL2dkYi5kd2FyZjIvZGVidWctbmFtZXMtYmFk LWN1LWluZGV4L2RlYnVnLW5hbWVzLlMgICAgKHRpbWVvdXQgPSAzMDApCmJ1aWx0aW5fc3Bhd24g LWlnbm9yZSBTSUdIVVAgZ2NjIC1mbm8tc3RhY2stcHJvdGVjdG9yIC1mZGlhZ25vc3RpY3MtY29s b3I9bmV2ZXIgLWMgLW8gL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1 aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIuZHdhcmYyL2RlYnVnLW5hbWVzLWJhZC1jdS1p bmRleC9kZWJ1Zy1uYW1lcy1iYWQtY3UtaW5kZXgwLm8gL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3Vt ZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIuZHdhcmYyL2Rl YnVnLW5hbWVzLWJhZC1jdS1pbmRleC9kZWJ1Zy1uYW1lcy5TDQpnZGJfZG9fY2FjaGU6IHVuaXZl cnNhbF9jb21waWxlX29wdGlvbnNfYyAoICApCmdkYl9kb19jYWNoZTogZ2V0X2NvbXBpbGVyX2lu Zm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBjICkKZ2RiX2Rv X2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19jYWNoZTogZ2V0X2NvbXBp bGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBjICkK Z2RiX2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19jYWNoZTogZ2V0 X2NvbXBpbGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEg KCBjICkKZ2RiX2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCkV4ZWN1dGluZyBv biBob3N0OiBnY2MgIC1mbm8tc3RhY2stcHJvdGVjdG9yICAtZmRpYWdub3N0aWNzLWNvbG9yPW5l dmVyIC1jICAtbyAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQv Z2RiL3Rlc3RzdWl0ZS9vdXRwdXRzL2dkYi5kd2FyZjIvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4 L2RlYnVnLW5hbWVzLWJhZC1jdS1pbmRleDEubyAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRz L2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS8uLi8uLi8uLi9kb3duc3RyZWFtLWdkYi9n ZGIvdGVzdHN1aXRlL2dkYi5kd2FyZjIvX3N0YXJ0LmMgICAgKHRpbWVvdXQgPSAzMDApCmJ1aWx0 aW5fc3Bhd24gLWlnbm9yZSBTSUdIVVAgZ2NjIC1mbm8tc3RhY2stcHJvdGVjdG9yIC1mZGlhZ25v c3RpY3MtY29sb3I9bmV2ZXIgLWMgLW8gL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3du c3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIuZHdhcmYyL2RlYnVnLW5hbWVz LWJhZC1jdS1pbmRleC9kZWJ1Zy1uYW1lcy1iYWQtY3UtaW5kZXgxLm8gL2hvbWUvZ3dlbnRoZWt3 ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvLi4vLi4vLi4vZG93 bnN0cmVhbS1nZGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL19zdGFydC5jDQpnZGJfZG9fY2Fj aGU6IHVuaXZlcnNhbF9jb21waWxlX29wdGlvbnNfYyAoICApCmdkYl9kb19jYWNoZTogZ2V0X2Nv bXBpbGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZvXzEgKCBj ICkKZ2RiX2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19jYWNoZTog Z2V0X2NvbXBpbGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxlcl9pbmZv XzEgKCBjICkKZ2RiX2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCmdkYl9kb19j YWNoZTogZ2V0X2NvbXBpbGVyX2luZm9fMSAoIGMgKQpnZGJfZG9fY2FjaGU6IGdldF9jb21waWxl cl9pbmZvXzEgKCBjICkKZ2RiX2RvX2NhY2hlOiBnZXRfY29tcGlsZXJfaW5mb18xICggYyApCkV4 ZWN1dGluZyBvbiBob3N0OiBnY2MgIC1mbm8tc3RhY2stcHJvdGVjdG9yIC9ob21lL2d3ZW50aGVr d2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1idWlsZC9nZGIvdGVzdHN1aXRlL291dHB1dHMvZ2Ri LmR3YXJmMi9kZWJ1Zy1uYW1lcy1iYWQtY3UtaW5kZXgvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4 MC5vIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1idWlsZC9nZGIvdGVz dHN1aXRlL291dHB1dHMvZ2RiLmR3YXJmMi9kZWJ1Zy1uYW1lcy1iYWQtY3UtaW5kZXgvZGVidWct bmFtZXMtYmFkLWN1LWluZGV4MS5vICAtZmRpYWdub3N0aWNzLWNvbG9yPW5ldmVyICAtbm9zdGFy dGZpbGVzIC1sbSAgIC1vIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1i dWlsZC9nZGIvdGVzdHN1aXRlL291dHB1dHMvZ2RiLmR3YXJmMi9kZWJ1Zy1uYW1lcy1iYWQtY3Ut aW5kZXgvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4ICAgICh0aW1lb3V0ID0gMzAwKQpidWlsdGlu X3NwYXduIC1pZ25vcmUgU0lHSFVQIGdjYyAtZm5vLXN0YWNrLXByb3RlY3RvciAvaG9tZS9nd2Vu dGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS9vdXRwdXRz L2dkYi5kd2FyZjIvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4L2RlYnVnLW5hbWVzLWJhZC1jdS1p bmRleDAubyAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2Ri L3Rlc3RzdWl0ZS9vdXRwdXRzL2dkYi5kd2FyZjIvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4L2Rl YnVnLW5hbWVzLWJhZC1jdS1pbmRleDEubyAtZmRpYWdub3N0aWNzLWNvbG9yPW5ldmVyIC1ub3N0 YXJ0ZmlsZXMgLWxtIC1vIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1i dWlsZC9nZGIvdGVzdHN1aXRlL291dHB1dHMvZ2RiLmR3YXJmMi9kZWJ1Zy1uYW1lcy1iYWQtY3Ut aW5kZXgvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4DQoKU3RhcnRpbmcgbG9nZmlsZTogL2hvbWUv Z3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvb3V0 cHV0cy9nZGIuZHdhcmYyL2RlYnVnLW5hbWVzLWJhZC1jdS1pbmRleC9nZGIuaW4uMgoKYnVpbHRp bl9zcGF3biAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2Ri L3Rlc3RzdWl0ZS8uLi8uLi9nZGIvZ2RiIC1udyAtbnggLXEgLWlleCBzZXQgaGVpZ2h0IDAgLWll eCBzZXQgd2lkdGggMCAtZGF0YS1kaXJlY3RvcnkgL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50 cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi9kYXRhLWRpcmVjdG9yeSAtaWV4IHNldCBpbnRlcmFjdGl2 ZS1tb2RlIG9uDQooZ2RiKSBzZXQgaGVpZ2h0IDANCihnZGIpIHNldCB3aWR0aCAwDQooZ2RiKSBk aXINClJlaW5pdGlhbGl6ZSBzb3VyY2UgcGF0aCB0byBlbXB0eT8gKHkgb3IgbikgeQ0KU291cmNl IGRpcmVjdG9yaWVzIHNlYXJjaGVkOiAkY2RpcjokY3dkDQooZ2RiKSBkaXIgL2hvbWUvZ3dlbnRo ZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWdkYi9nZGIvdGVzdHN1aXRlL2dkYi5kd2FyZjIN ClNvdXJjZSBkaXJlY3RvcmllcyBzZWFyY2hlZDogL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50 cy9kb3duc3RyZWFtLWdkYi9nZGIvdGVzdHN1aXRlL2dkYi5kd2FyZjI6JGNkaXI6JGN3ZA0KKGdk Yikgc2hvdyBjb21wbGFpbnRzDQpNYXggbnVtYmVyIG9mIGNvbXBsYWludHMgYWJvdXQgaW5jb3Jy ZWN0IHN5bWJvbHMgaXMgMC4NCihnZGIpIHNldCBjb21wbGFpbnRzIDENCihnZGIpIG1haW50IHNl dCBkd2FyZiBzeW5jaHJvbm91cyBvbg0KKGdkYikgUEFTUzogZ2RiLmR3YXJmMi9kZWJ1Zy1uYW1l cy1iYWQtY3UtaW5kZXguZXhwOiBtYWludCBzZXQgZHdhcmYgc3luY2hyb25vdXMgb24Ka2lsbA0K VGhlIHByb2dyYW0gaXMgbm90IGJlaW5nIHJ1bi4NCihnZGIpIGZpbGUgL2hvbWUvZ3dlbnRoZWt3 ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIu ZHdhcmYyL2RlYnVnLW5hbWVzLWJhZC1jdS1pbmRleC9kZWJ1Zy1uYW1lcy1iYWQtY3UtaW5kZXgN ClJlYWRpbmcgc3ltYm9scyBmcm9tIC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0 cmVhbS1idWlsZC9nZGIvdGVzdHN1aXRlL291dHB1dHMvZ2RiLmR3YXJmMi9kZWJ1Zy1uYW1lcy1i YWQtY3UtaW5kZXgvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4Li4uDQp3YXJuaW5nOiBTZWN0aW9u IC5kZWJ1Z19uYW1lcyBoYXMgaW5jb3JyZWN0IGVudHJ5IGluIENVIHRhYmxlLCBpZ25vcmluZyAu ZGVidWdfbmFtZXMuDQooZ2RiKSBtYWludCBwcmludCBvYmpmaWxlcyBkZWJ1Zy1uYW1lcy1iYWQt Y3UtaW5kZXgNCg0KT2JqZWN0IGZpbGUgL2hvbWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3du c3RyZWFtLWJ1aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIuZHdhcmYyL2RlYnVnLW5hbWVz LWJhZC1jdS1pbmRleC9kZWJ1Zy1uYW1lcy1iYWQtY3UtaW5kZXg6ICBPYmpmaWxlIGF0IDB4MzZh ZmI5ZTAsIGJmZCBhdCAweDM2OTNhY2UwLCAxMSBtaW5zeW1zDQoNCkNvb2tlZCBpbmRleCBpbiB1 c2U6DQoNCiAgZW50cmllczoNCg0KICAgIFswXSAoKGNvb2tlZF9pbmRleF9lbnRyeSAqKSAweDdm YWFmODAwNDQwMCkNCiAgICBuYW1lOiAgICAgICBfc3RhcnQNCiAgICBjYW5vbmljYWw6ICBfc3Rh cnQNCiAgICBxdWFsaWZpZWQ6ICBfc3RhcnQNCiAgICBEV0FSRiB0YWc6ICBEV19UQUdfc3VicHJv Z3JhbQ0KICAgIGZsYWdzOiAgICAgIDB4MCBbXQ0KICAgIERJRSBvZmZzZXQ6IDB4ZA0KICAgIENV IGluZGV4OiAgIDANCiAgICBwYXJlbnQ6ICAgICAoKGNvb2tlZF9pbmRleF9lbnRyeSAqKSAwKQ0K DQogICAgWzFdICgoY29va2VkX2luZGV4X2VudHJ5ICopIDB4N2ZhYWY0MDA2ODIwKQ0KICAgIG5h bWU6ICAgICAgIGludA0KICAgIGNhbm9uaWNhbDogIGludA0KICAgIHF1YWxpZmllZDogIGludA0K ICAgIERXQVJGIHRhZzogIERXX1RBR19iYXNlX3R5cGUNCiAgICBmbGFnczogICAgICAweDIgW0lT X1NUQVRJQ10NCiAgICBESUUgb2Zmc2V0OiAweDNlDQogICAgQ1UgaW5kZXg6ICAgMQ0KICAgIHBh cmVudDogICAgICgoY29va2VkX2luZGV4X2VudHJ5ICopIDApDQoNCiAgICBbMl0gKChjb29rZWRf aW5kZXhfZW50cnkgKikgMHg3ZmFhZjQwMDY3ZjApDQogICAgbmFtZTogICAgICAgc3RydWN0X3dp dGhfaW50X21lbWJlcg0KICAgIGNhbm9uaWNhbDogIHN0cnVjdF93aXRoX2ludF9tZW1iZXINCiAg ICBxdWFsaWZpZWQ6ICBzdHJ1Y3Rfd2l0aF9pbnRfbWVtYmVyDQogICAgRFdBUkYgdGFnOiAgRFdf VEFHX3N0cnVjdHVyZV90eXBlDQogICAgZmxhZ3M6ICAgICAgMHgyIFtJU19TVEFUSUNdDQogICAg RElFIG9mZnNldDogMHgxOA0KICAgIENVIGluZGV4OiAgIDENCiAgICBwYXJlbnQ6ICAgICAoKGNv b2tlZF9pbmRleF9lbnRyeSAqKSAwKQ0KDQogICAgWzNdICgoY29va2VkX2luZGV4X2VudHJ5ICop IDB4MzZmYzUyNTApDQogICAgbmFtZTogICAgICAgaW50DQogICAgY2Fub25pY2FsOiAgaW50DQog ICAgcXVhbGlmaWVkOiAgaW50DQogICAgRFdBUkYgdGFnOiAgRFdfVEFHX2Jhc2VfdHlwZQ0KICAg IGZsYWdzOiAgICAgIDB4MiBbSVNfU1RBVElDXQ0KICAgIERJRSBvZmZzZXQ6IDB4M2UNCiAgICBD VSBpbmRleDogICAxDQogICAgcGFyZW50OiAgICAgKChjb29rZWRfaW5kZXhfZW50cnkgKikgMCkN Cg0KICAgIFs0XSAoKGNvb2tlZF9pbmRleF9lbnRyeSAqKSAweDM2ZmM1MjIwKQ0KICAgIG5hbWU6 ICAgICAgIHN0cnVjdF93aXRoX2ludF9tZW1iZXINCiAgICBjYW5vbmljYWw6ICBzdHJ1Y3Rfd2l0 aF9pbnRfbWVtYmVyDQogICAgcXVhbGlmaWVkOiAgc3RydWN0X3dpdGhfaW50X21lbWJlcg0KICAg IERXQVJGIHRhZzogIERXX1RBR19zdHJ1Y3R1cmVfdHlwZQ0KICAgIGZsYWdzOiAgICAgIDB4MiBb SVNfU1RBVElDXQ0KICAgIERJRSBvZmZzZXQ6IDB4MTgNCiAgICBDVSBpbmRleDogICAxDQogICAg cGFyZW50OiAgICAgKChjb29rZWRfaW5kZXhfZW50cnkgKikgMCkNCg0KICBtYWluOiAoKGNvb2tl ZF9pbmRleF9lbnRyeSAqKSAwKQ0KDQogIGFkZHJlc3MgbWFwczoNCg0KICAgIFswXSAoKGFkZHJt YXAgKikgMHg3ZmFhZTQwMDQyMjApDQoNCiAgICAgIFsweDBdICgoZHdhcmYyX3Blcl9jdSAqKSAw KQ0KDQogICAgWzFdICgoYWRkcm1hcCAqKSAweDdmYWFkYzAwNDIyMCkNCg0KICAgICAgWzB4MF0g KChkd2FyZjJfcGVyX2N1ICopIDApDQoNCiAgICBbMl0gKChhZGRybWFwICopIDB4N2ZhYjA4MDA0 MjIwKQ0KDQogICAgICBbMHgwXSAoKGR3YXJmMl9wZXJfY3UgKikgMCkNCg0KICAgIFszXSAoKGFk ZHJtYXAgKikgMHg3ZmFhZWMwMDQyMjApDQoNCiAgICAgIFsweDBdICgoZHdhcmYyX3Blcl9jdSAq KSAwKQ0KDQogICAgWzRdICgoYWRkcm1hcCAqKSAweDdmYWIwMDAwNDIyMCkNCg0KICAgICAgWzB4 MF0gKChkd2FyZjJfcGVyX2N1ICopIDApDQoNCiAgICBbNV0gKChhZGRybWFwICopIDB4N2ZhYWU4 MDA0MjIwKQ0KDQogICAgICBbMHgwXSAoKGR3YXJmMl9wZXJfY3UgKikgMCkNCg0KICAgIFs2XSAo KGFkZHJtYXAgKikgMHg3ZmFhZjgwMDQ0MzApDQoNCiAgICAgIFsweDBdICgoZHdhcmYyX3Blcl9j dSAqKSAwKQ0KDQogICAgWzddICgoYWRkcm1hcCAqKSAweDdmYWFmNDAwNjg1MCkNCg0KICAgICAg WzB4MF0gKChkd2FyZjJfcGVyX2N1ICopIDApDQoNCiAgICBbOF0gKChhZGRybWFwICopIDB4MzZm YzUyODApDQoNCiAgICAgIFsweDBdICgoZHdhcmYyX3Blcl9jdSAqKSAwKQ0KICAgICAgWzB4NDAw MzMwXSAoKGR3YXJmMl9wZXJfY3UgKikgMHg3ZmFhZjQwMDQwZTApDQogICAgICBbMHg0MDAzM2Vd ICgoZHdhcmYyX3Blcl9jdSAqKSAwKQ0KDQooZ2RiKSBQQVNTOiBnZGIuZHdhcmYyL2RlYnVnLW5h bWVzLWJhZC1jdS1pbmRleC5leHA6IGZpbmQgaW5kZXggdHlwZQpQQVNTOiBnZGIuZHdhcmYyL2Rl YnVnLW5hbWVzLWJhZC1jdS1pbmRleC5leHA6IGZpbmQgaW5kZXggdHlwZSwgY2hlY2sgdHlwZSBp cyB2YWxpZApGQUlMOiBnZGIuZHdhcmYyL2RlYnVnLW5hbWVzLWJhZC1jdS1pbmRleC5leHA6IC5k ZWJ1Z19uYW1lcyB1c2VkCkZBSUw6IGdkYi5kd2FyZjIvZGVidWctbmFtZXMtYmFkLWN1LWluZGV4 LmV4cDogc2F3IGNvbXBsYWludApzZXQgY29tcGxhaW50cyAwDQooZ2RiKSB0ZXN0Y2FzZSAvaG9t ZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS8u Li8uLi8uLi9kb3duc3RyZWFtLWdkYi9nZGIvdGVzdHN1aXRlL2dkYi5kd2FyZjIvZGVidWctbmFt ZXMtYmFkLWN1LWluZGV4LmV4cCBjb21wbGV0ZWQgaW4gMCBzZWNvbmRzCgoJCT09PSBnZGIgU3Vt bWFyeSA9PT0KCiMgb2YgZXhwZWN0ZWQgcGFzc2VzCQkzCiMgb2YgdW5leHBlY3RlZCBmYWlsdXJl cwkyCkV4ZWN1dGluZyBvbiBob3N0OiAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1lbnRzL2Rvd25z dHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS8uLi8uLi9nZGIvZ2RiIC1udyAtbnggLXEgLWlleCAi c2V0IGhlaWdodCAwIiAtaWV4ICJzZXQgd2lkdGggMCIgLWRhdGEtZGlyZWN0b3J5IC9ob21lL2d3 ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1idWlsZC9nZGIvZGF0YS1kaXJlY3Rvcnkg LWlleCAic2V0IGludGVyYWN0aXZlLW1vZGUgb24iIC0tdmVyc2lvbiAgICAodGltZW91dCA9IDMw MCkKYnVpbHRpbl9zcGF3biAtaWdub3JlIFNJR0hVUCAvaG9tZS9nd2VudGhla3dlZW4vRG9jdW1l bnRzL2Rvd25zdHJlYW0tYnVpbGQvZ2RiL3Rlc3RzdWl0ZS8uLi8uLi9nZGIvZ2RiIC1udyAtbngg LXEgLWlleCBzZXQgaGVpZ2h0IDAgLWlleCBzZXQgd2lkdGggMCAtZGF0YS1kaXJlY3RvcnkgL2hv bWUvZ3dlbnRoZWt3ZWVuL0RvY3VtZW50cy9kb3duc3RyZWFtLWJ1aWxkL2dkYi9kYXRhLWRpcmVj dG9yeSAtaWV4IHNldCBpbnRlcmFjdGl2ZS1tb2RlIG9uIC0tdmVyc2lvbg0KR05VIGdkYiAoR0RC KSAxOC4wLjUwLjIwMjYwNTEzLWdpdA0KQ29weXJpZ2h0IChDKSAyMDI2IEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLg0KTGljZW5zZSBHUEx2Mys6IEdOVSBHUEwgdmVyc2lvbiAzIG9yIGxh dGVyIDxodHRwOi8vZ251Lm9yZy9saWNlbnNlcy9ncGwuaHRtbD4NClRoaXMgaXMgZnJlZSBzb2Z0 d2FyZTogeW91IGFyZSBmcmVlIHRvIGNoYW5nZSBhbmQgcmVkaXN0cmlidXRlIGl0Lg0KVGhlcmUg aXMgTk8gV0FSUkFOVFksIHRvIHRoZSBleHRlbnQgcGVybWl0dGVkIGJ5IGxhdy4NCi9ob21lL2d3 ZW50aGVrd2Vlbi9Eb2N1bWVudHMvZG93bnN0cmVhbS1idWlsZC9nZGIvZ2RiIHZlcnNpb24gIDE4 LjAuNTAuMjAyNjA1MTMtZ2l0IC1udyAtbnggLXEgLWlleCAic2V0IGhlaWdodCAwIiAtaWV4ICJz ZXQgd2lkdGggMCIgLWRhdGEtZGlyZWN0b3J5IC9ob21lL2d3ZW50aGVrd2Vlbi9Eb2N1bWVudHMv ZG93bnN0cmVhbS1idWlsZC9nZGIvZGF0YS1kaXJlY3RvcnkgLWlleCAic2V0IGludGVyYWN0aXZl LW1vZGUgb24iIAoKcnVudGVzdCBjb21wbGV0ZWQgYXQgVHVlIE1heSAxOSAxNjoyNToxNCAyMDI2 Cg== --------------vuZd0N8a40ZHqMlP4y5pC3WP--