From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id 6JpCF/2q0WczVw0AWB0awg (envelope-from ) for ; Wed, 12 Mar 2025 11:40:45 -0400 Authentication-Results: simark.ca; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=hKzyOlsU; dkim-atps=neutral Received: by simark.ca (Postfix, from userid 112) id 5B44D1E105; Wed, 12 Mar 2025 11:40:45 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.0 (2022-12-13) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-5.4 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED autolearn=ham autolearn_force=no version=4.0.0 Received: from server2.sourceware.org (server2.sourceware.org [8.43.85.97]) (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 54D091E08E for ; Wed, 12 Mar 2025 11:40:44 -0400 (EDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 03B4A385840D for ; Wed, 12 Mar 2025 15:40:44 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 03B4A385840D Authentication-Results: sourceware.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=hKzyOlsU Received: from mail-ed1-x530.google.com (mail-ed1-x530.google.com [IPv6:2a00:1450:4864:20::530]) by sourceware.org (Postfix) with ESMTPS id 7ED833858401 for ; Wed, 12 Mar 2025 15:37:18 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 7ED833858401 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 7ED833858401 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::530 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1741793838; cv=none; b=fRz9s1aTtkxOlD8uRC/Hhxe6y3ZgAlO8AS1bvEDNuKiwiRdKjAkVnYEY1QfIshQrWRtbXKwFobd5CBs3nqHpKRlrhwzcpHT+Fh6SqEiTYxjdwol+clDqtB6g5dBcX0yJ7Fri7nChMOv7AKet4js/gmuo+oXWrRbdoLQ4/rcVVvg= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1741793838; c=relaxed/simple; bh=dnqrLnu/21LOgLyDUd+2yrFIFUre7aG4WRIEoG8LLAc=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=oJwjUJ77PRPYvxgIDA7vYOO43OjA3yENM3cV4PDNowsRXVNN5gUhpa0V4f4Sd51POPJ6kqUFdFEVKFZ3gcGrmaGxuqPwR0fkPWoiHEaICHRUfWYvBavtbt2Q9Rw3aFOO14coLZlfkb760vw/+FdEIW/9I3MvV0LMygmiz1vRjns= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 7ED833858401 Received: by mail-ed1-x530.google.com with SMTP id 4fb4d7f45d1cf-5e56b229d60so2034817a12.0 for ; Wed, 12 Mar 2025 08:37:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1741793836; x=1742398636; darn=sourceware.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=uyS1MkzXOJ3u6HS3U8wX4MP1Qc/JSFAuGfC8X/8g/pI=; b=hKzyOlsUuy6OON1043x0p2Loqt/XNv62v69Z1M3wOKyXOI/a1+FjnoSWUpaTtLkPI4 jJz9PssXWf34PrU4Mfp60CldhlLcTQ+UiAWW2h9zY6Kz3CiODCx97rDHo/zHG57zVWoI G1FjchCBgxJF4mnYXPJ+8d5UJA5g1a7bgGy3WpDbdsK9uS1Bznq+vBgwwxpPOo143RD7 VoVz7l1GPI+nufFBz3LkQIN+54vhS/eMdtmDZhkgThpOoUXFDS5jzbgR4m9Cpw+oMtl6 DZAt9H6b3pIjl4J/VhqU4v6CUOTN8bKjmgAGjYRBQ7mEgencGs5y5sz5Rh9ZA2VWC/yb +Vig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1741793836; x=1742398636; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=uyS1MkzXOJ3u6HS3U8wX4MP1Qc/JSFAuGfC8X/8g/pI=; b=Eia62bmXS7GsUX0vL1CG3AQcpEz44R/JOzioIXsWu4MAIkEHJIi0aZSvtPEhFYa06p FYaEK9+zOCDO+HFdVoFP4Rtq+6t+5+NYnCWx349elQMqDyGlBSrbi4vH3V27oCzsmsGS cNNLdkEFoaQ4tAZDzf7oqvQRheaoyhs/3K75h8tSobad8aJNub+OKHt4PU8DXupDgWGW /X3sLNeoJums5lB6WhbvCemu75I+mrZI7j/HoldhjoraIKRa23KKARKQNM9I0pneGLK1 Z4jjGyZbv/WT9MSQVsvLo18DrzmERIwrCzowm6+e/DVaxF1Y9r9uAJ2OobmIltlExqSk RDQA== X-Gm-Message-State: AOJu0YwR23ncIAXe+9qY2fOivDd5GTiBkSQDEX2HPGmyYpUYjxv5Pio2 kfSyDyqYt69eAVyT1dKmW4594JI7sabYSylpsR5rE+2V2cY2uFtvT/4y9NeEQ2k= X-Gm-Gg: ASbGncs/cG1edZ/r0nJ0vAeeGESea9ILgpxOBCWeHuA1t8UfD5SN9MgF9B8UsKTuLbG logV2jnXJFUxVsssfJ+TYQsHnWkROJSkdEdRyCjBS7+BBhqFJv4uB+TZt3KsRoSuyDFkadB1A7D 8i1Y8LFeFpWSEw3NAyJ3hGyI3rn7CctMV6sFQSP+PNoy3vkq5yrRB+CtY2JYFonEUVu+g+vEMY6 lLyQ5n60xmQZC8rPNOktT7g/PCK75OGMOoMsf/HUr0+se0iPJnQO3Pt4wHitmXjQfIpMbhFu+sj Y6a89v45QwTt/2MBtDjNOOLCJMC4Vb7ZQIVkmy0nS/e35u5xsj2RCZWy63s/w0JsQEGc X-Google-Smtp-Source: AGHT+IGvjEcD3lHgPBhq/Si14qH6tXe/yUDkNIlTSHkIAJi5/HxA6tXTeeJY5MAt7zmc1OkoGebh9w== X-Received: by 2002:a05:6402:348e:b0:5e4:d27a:d868 with SMTP id 4fb4d7f45d1cf-5e7f6e65d3dmr253122a12.0.1741793835955; Wed, 12 Mar 2025 08:37:15 -0700 (PDT) Received: from pop-os.ssw.jku.at ([140.78.145.202]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5e5c74a6af7sm9888800a12.33.2025.03.12.08.37.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Mar 2025 08:37:15 -0700 (PDT) From: dominikmascherbauer X-Google-Original-From: dominikmascherbauer To: gdb-patches@sourceware.org Cc: dominikmascherbauer Subject: [PATCH v2 2/3] Add type signature fallback and JIT objfile restriction. Date: Wed, 12 Mar 2025 16:37:07 +0100 Message-Id: X-Mailer: git-send-email 2.34.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit 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 To support type signature fallback, the lookup_signatured_type method is extended. If no type signature was found in the current objfile or in a dwo file, the dwraf-type-signature-fallback option is checked: 'off': return nullptr 'main': only check the current main objfile for the type signature. This reduces the additional load for a fallback as only one additional objfile is checked. The main objfile often contains major parts of the debug info, thus it is also likely that the requested type signature is found there. If the main objfile is linked to dwo/dwp files, those are also checked for the type signature. This should be the same behavior as if the type signature is lookup up without fallback. 'full': check all objfiles in the current prospace. Requires potentially more time than just checking the main objfile, but it will also find a type signature in a loaded shared library. If a type signature was found in a fallback objfile, the per_objfile after lookup_signatured_type is the fallback per_objfile. This ensures that if the type unit still needs to be read, it is read from the correct objfile. Additionally, a flag is added to objfiles that marks an objfile as a JIT objfile. With this information the type signature fallback can be restricted to only work for JIT objfiles. This is a separate option because JIT objfile are self-contained but usually share debug info (especially type information) with some other already loaded objfile. So this leaves loading other objfiles as is to avoid unexpected behavior if needed. --- gdb/dwarf2/read.c | 184 +++++++++++++++++++++++++++++++++++++------- gdb/jit.c | 6 +- gdb/objfile-flags.h | 3 + 3 files changed, 162 insertions(+), 31 deletions(-) diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index 3fdaf003fb7..4b86acec772 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -2669,12 +2669,12 @@ fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile *per_objfile, to read all the DWOs to build the type unit groups. */ static struct signatured_type * -lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) +lookup_dwo_signatured_type (struct dwo_unit *dwo_unit, ULONGEST sig, + struct dwarf2_per_objfile *per_objfile) { - dwarf2_per_objfile *per_objfile = cu->per_objfile; dwarf2_per_bfd *per_bfd = per_objfile->per_bfd; - gdb_assert (cu->dwo_unit); + gdb_assert (dwo_unit); /* We only ever need to read in one copy of a signatured type. Use the global signatured_types array to do our own comdat-folding @@ -2697,14 +2697,14 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) && (*sig_type_it)->tu_read) return *sig_type_it; - /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the + /* Note: dwo_unit is the dwo_unit that references this TU, not the dwo_unit of the TU itself. */ - dwo_file *dwo_file = cu->dwo_unit->dwo_file; + dwo_file *dwo_file = dwo_unit->dwo_file; auto it = dwo_file->tus.find (sig); if (it == dwo_file->tus.end ()) return nullptr; - dwo_unit *dwo_entry = *it; + struct dwo_unit *dwo_entry = *it; /* If the global table doesn't have an entry for this TU, add one. */ if (sig_type_it == per_bfd->signatured_types.end ()) @@ -2724,13 +2724,12 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) it won't be in .gdb_index. */ static struct signatured_type * -lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) +lookup_dwp_signatured_type (ULONGEST sig, + struct dwarf2_per_objfile *per_objfile) { - dwarf2_per_objfile *per_objfile = cu->per_objfile; dwarf2_per_bfd *per_bfd = per_objfile->per_bfd; struct dwp_file *dwp_file = get_dwp_file (per_objfile); - gdb_assert (cu->dwo_unit); gdb_assert (dwp_file != NULL); auto sig_type_it = per_bfd->signatured_types.find (sig); @@ -2756,34 +2755,133 @@ lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) return *sig_type_it; } +/* Subroutine of lookup_signatured_type. + Look up the type for signature SIG, from a fallback objfile. + If we don't have a DWO/DWP file or can't find the signature there, check the + fallback object file. + If a signatured type was found, PER_OBJFILE will contain its per_objfile. */ + +static struct signatured_type * +lookup_fallback_signatured_type (struct objfile *fallback_objfile, ULONGEST sig, + struct dwarf2_per_objfile **per_objfile) +{ + struct signatured_type *sig_type = nullptr; + + /* If we have a separate debug objfile, use it for the fallback. */ + if (fallback_objfile->separate_debug_objfile != nullptr) + fallback_objfile = fallback_objfile->separate_debug_objfile; + + struct dwarf2_per_objfile *fallback_per_objfile = get_dwarf2_per_objfile + (fallback_objfile); + + /* The fallback objfile must be different to the current objfile. Otherwise, + this is no fallback so all necessary checks were already performed in + lookup_signatured_type. */ + if (fallback_per_objfile == *per_objfile) + return nullptr; + + /* Do we have a dwp file? */ + if (get_dwp_file (fallback_per_objfile) != nullptr) + { + sig_type = lookup_dwp_signatured_type (sig, fallback_per_objfile); + } + /* Do we have dwo files? */ + else + { + /* Look for dwo_entry that contains the signatured type. */ + for (const dwo_file_up &file : fallback_per_objfile->per_bfd->dwo_files) + { + auto it = file->tus.find (sig); + if (it != file->tus.end ()) + { + /* We found the dwo entry. Check for the signatured type. */ + sig_type = lookup_dwo_signatured_type (*it, sig, + fallback_per_objfile); + break; + } + } + } + + /* Do we still need to check the fallback per_objfile or was the signatured + type found in a DWO/DWP file? */ + if (sig_type == nullptr) + { + auto sig_type_it + = fallback_per_objfile->per_bfd->signatured_types.find (sig); + + if (sig_type_it != fallback_per_objfile->per_bfd->signatured_types.end ()) + sig_type = *sig_type_it; + } + + if (sig_type != nullptr) + /* Ensure we will know where the signature type came from. */ + *per_objfile = fallback_per_objfile; + return sig_type; +} + /* Lookup a signature based type for DW_FORM_ref_sig8. Returns NULL if signature SIG is not present in the table. - It is up to the caller to complain about this. */ + It is up to the caller to complain about this. + If type_signature_fallback is enabled and the signatured type is found, + per_objfile is the objfile where the signatured type was found in. */ static struct signatured_type * -lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) +lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig, + struct dwarf2_per_objfile **per_objfile) { - dwarf2_per_objfile *per_objfile = cu->per_objfile; - dwarf2_per_bfd *per_bfd = per_objfile->per_bfd; + struct signatured_type *sig_type = nullptr; + dwarf2_per_bfd *per_bfd = (*per_objfile)->per_bfd; if (cu->dwo_unit) { /* We're in a DWO/DWP file, and we're using .gdb_index. - These cases require special processing. */ - if (get_dwp_file (per_objfile) == NULL) - return lookup_dwo_signatured_type (cu, sig); + These cases require special processing. */ + if (get_dwp_file (*per_objfile) == nullptr) + sig_type = lookup_dwo_signatured_type (cu->dwo_unit, sig, *per_objfile); else - return lookup_dwp_signatured_type (cu, sig); + sig_type = lookup_dwp_signatured_type (sig, *per_objfile); + + /* If we already found the signatured type, return it. */ + if (sig_type != nullptr) + return sig_type; } else { + /* Lookup type signature in the current objfile. */ auto sig_type_it = per_bfd->signatured_types.find (sig); + /* If we already found the signatured type, return it. */ if (sig_type_it != per_bfd->signatured_types.end ()) return *sig_type_it; + } - return nullptr; + /* Handle fallback if type signature lookup fallback is enabled for this + objfile. */ + if (use_type_signature_fallback ((*per_objfile)->objfile)) + { + /* Do a full fallback through all objfiles in the progspace. */ + if (type_signature_fallback == type_signature_fallback_full) + { + for (objfile *objfile: (*per_objfile)->objfile->pspace ()->objfiles ()) + { + sig_type = lookup_fallback_signatured_type (objfile, sig, + per_objfile); + /* If we already found the signatured type, return it. */ + if (sig_type != nullptr) + return sig_type; + } + } + else + { + /* fallback to main symfile objfile. */ + struct objfile *objfile + = (*per_objfile)->objfile->pspace ()->symfile_object_file; + return lookup_fallback_signatured_type (objfile, sig, per_objfile); + } } + + /* We could not find the signatured type. */ + return nullptr; } /* Low level DIE reading support. */ @@ -4333,8 +4431,19 @@ maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu, dwarf2_per_cu *per_cu, bool queued = false; if (!per_objfile->symtab_set_p (per_cu)) { - /* Add it to the queue. */ - queue_comp_unit (per_cu, per_objfile, pretend_language); + if (dependent_cu != nullptr && !per_objfile->queue.has_value () && + type_signature_fallback != type_signature_fallback_off) + { + /* If the signatured type in the fallback objfile references another + signatured type we might end up here with no queue in the fallback + objfile. */ + dw2_instantiate_symtab (per_cu, per_objfile, false); + } + else + { + /* Add it to the queue. */ + queue_comp_unit (per_cu, per_objfile, pretend_language); + } queued = true; dwarf_read_debug_printf ("Queuing CU for expansion: " @@ -8383,7 +8492,7 @@ static int queue_and_load_dwo_tu (dwo_unit *dwo_unit, dwarf2_cu *cu) { ULONGEST signature = dwo_unit->signature; - signatured_type *sig_type = lookup_dwo_signatured_type (cu, signature); + signatured_type *sig_type = lookup_dwo_signatured_type (cu->dwo_unit, signature, cu->per_objfile); if (sig_type != NULL) { @@ -18985,6 +19094,7 @@ dwarf2_get_die_type (cu_offset die_offset, dwarf2_per_cu *per_cu, static struct die_info * follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type, + struct dwarf2_per_objfile *sig_type_per_objfile, struct dwarf2_cu **ref_cu) { struct dwarf2_cu *sig_cu; @@ -19000,12 +19110,14 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type, Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs, it doesn't mean they are currently loaded. Since we require them to be loaded, we must check for ourselves. */ - if (maybe_queue_comp_unit (*ref_cu, sig_type, per_objfile, + if (maybe_queue_comp_unit (*ref_cu, sig_type, sig_type_per_objfile, language_minimal) - || per_objfile->get_cu (sig_type) == nullptr) - read_signatured_type (sig_type, per_objfile); + || sig_type_per_objfile->get_cu (sig_type) == nullptr) + { + read_signatured_type (sig_type, sig_type_per_objfile); + } - sig_cu = per_objfile->get_cu (sig_type); + sig_cu = sig_type_per_objfile->get_cu (sig_type); gdb_assert (sig_cu != NULL); gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0); @@ -19041,7 +19153,8 @@ follow_die_sig (struct die_info *src_die, const struct attribute *attr, gdb_assert (attr->form == DW_FORM_ref_sig8); - sig_type = lookup_signatured_type (*ref_cu, signature); + dwarf2_per_objfile *sig_type_per_objfile = (*ref_cu)->per_objfile; + sig_type = lookup_signatured_type (*ref_cu, signature, &sig_type_per_objfile); /* sig_type will be NULL if the signatured type is missing from the debug info. */ if (sig_type == NULL) @@ -19053,7 +19166,7 @@ follow_die_sig (struct die_info *src_die, const struct attribute *attr, objfile_name ((*ref_cu)->per_objfile->objfile)); } - die = follow_die_sig_1 (src_die, sig_type, ref_cu); + die = follow_die_sig_1 (src_die, sig_type, sig_type_per_objfile, ref_cu); if (die == NULL) { src_die->error_dump (); @@ -19080,7 +19193,8 @@ get_signatured_type (struct die_info *die, ULONGEST signature, struct die_info *type_die; struct type *type; - sig_type = lookup_signatured_type (cu, signature); + dwarf2_per_objfile *sig_type_per_objfile = per_objfile; + sig_type = lookup_signatured_type (cu, signature, &sig_type_per_objfile); /* sig_type will be NULL if the signatured type is missing from the debug info. */ if (sig_type == NULL) @@ -19099,7 +19213,7 @@ get_signatured_type (struct die_info *die, ULONGEST signature, return type; type_cu = cu; - type_die = follow_die_sig_1 (die, sig_type, &type_cu); + type_die = follow_die_sig_1 (die, sig_type, sig_type_per_objfile, &type_cu); if (type_die != NULL) { /* N.B. We need to call get_die_type to ensure only one type for this DIE @@ -19126,6 +19240,18 @@ get_signatured_type (struct die_info *die, ULONGEST signature, type = build_error_marker_type (cu, die); } + if (type_signature_fallback != type_signature_fallback_off) + { + /* We might already have read the required signatured type + after looking for it in a fallback objfile */ + struct type *existing_type = per_objfile->get_type_for_signatured_type + (sig_type); + if (existing_type != nullptr) + { + gdb_assert (type == existing_type); + return type; + } + } per_objfile->set_type_for_signatured_type (sig_type, type); return type; diff --git a/gdb/jit.c b/gdb/jit.c index d55e371b02a..ce19591c378 100644 --- a/gdb/jit.c +++ b/gdb/jit.c @@ -664,7 +664,8 @@ jit_object_close_impl (struct gdb_symbol_callbacks *cb, priv_data->entry.symfile_addr)); objfile *objfile = objfile::make (nullptr, current_program_space, - objfile_name.c_str (), OBJF_NOT_FILENAME); + objfile_name.c_str (), + OBJF_NOT_FILENAME | OBJF_JIT); objfile->section_offsets.push_back (0); objfile->sect_index_text = 0; objfile->per_bfd->gdbarch = priv_data->gdbarch; @@ -801,7 +802,8 @@ JITed symbol file is not an object file, ignoring it.\n")); objfile = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd.get ()), 0, &sai, - OBJF_SHARED | OBJF_NOT_FILENAME, NULL); + OBJF_SHARED | OBJF_NOT_FILENAME | + OBJF_JIT, NULL); add_objfile_entry (objfile, entry_addr, code_entry->symfile_addr, code_entry->symfile_size); diff --git a/gdb/objfile-flags.h b/gdb/objfile-flags.h index e0a84bcdc2e..0ad6e4037dd 100644 --- a/gdb/objfile-flags.h +++ b/gdb/objfile-flags.h @@ -56,6 +56,9 @@ enum objfile_flag : unsigned /* User requested that we do not read this objfile's symbolic information. */ OBJF_READNEVER = 1 << 6, + + /* Set if this objfile originates from a JIT compilation */ + OBJF_JIT = 1 << 7, }; DEF_ENUM_FLAGS_TYPE (enum objfile_flag, objfile_flags); -- 2.34.1