From patchwork Wed Aug 9 22:14:07 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lewis Hyatt X-Patchwork-Id: 1819643 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=cVlQdTLe; dkim-atps=neutral Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RLkrv0XLCz1yYl for ; Thu, 10 Aug 2023 08:15:27 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 120AC385C6E6 for ; Wed, 9 Aug 2023 22:15:25 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 120AC385C6E6 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691619325; bh=tcCb1x77Xrqu2bHoVqKiswvwFO1KVwjOcwDG0djUDCo=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=cVlQdTLe0b0dWabUIC35NNqDlkZapljFNV+Oicb8C0zXRPdCYXUu65O0xv44+DO0E G2UosMSuFsYJBk5oVn9Q5nQVUnXY/i3NZWfDBpeL+HNbo5ePfuh0DFlMNRIxsR172j LEAzrNNKHMci6jpqkRtw81Ww7JSggTuZodoVSPEw= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qk1-x730.google.com (mail-qk1-x730.google.com [IPv6:2607:f8b0:4864:20::730]) by sourceware.org (Postfix) with ESMTPS id DFAEA3857C66 for ; Wed, 9 Aug 2023 22:14:47 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org DFAEA3857C66 Received: by mail-qk1-x730.google.com with SMTP id af79cd13be357-76c845dc5beso22710685a.1 for ; Wed, 09 Aug 2023 15:14:47 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691619287; x=1692224087; 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=tcCb1x77Xrqu2bHoVqKiswvwFO1KVwjOcwDG0djUDCo=; b=SoB+v4OB1xUhxtvHQbASVf+rjgirkHVKZh3SDwkwtaJNaxdpvT9fWYSrv6JIU5/v6m jRVv/9dn8U/yePX8TVSiJXvNYt82cD5T0abyhWi6rT+4dzdyma7MsUZMVuyf7fowHrLh eEL5W+gtOMZfWvEaVYK30rPjogM4z4LN6Uj0ta+p110uXSSrWe3HGxFthQtzpnDERmTg sFGZ6FohouNu7T8fl6Zf9sy0pJq3ylcQLlxbPgWJQsP5/AWJO15rlODX2iLDnHhxM9do +AmxtKCqCv1XtvHGk5gSZnxmcoaXl8FMRAyJewanFplEIbU54Pw3fj4mYh/vQuaLuqfZ v+aA== X-Gm-Message-State: AOJu0YyHxq6WhdIjPm5I/iENzu65PXM/RyEO5G0bseVTacWVWE/++cUw +Mxq8LfqoM7AEF4FS7hUw73L2b0CSII= X-Google-Smtp-Source: AGHT+IHQ9bX14EKqks2pfskPK4x0ffamIvTPCKS90S3E6zZY3L+wXfmAHewzBBfH/BfcfUXU0LKxqQ== X-Received: by 2002:ae9:e10a:0:b0:768:4326:7b4d with SMTP id g10-20020ae9e10a000000b0076843267b4dmr356278qkm.65.1691619286688; Wed, 09 Aug 2023 15:14:46 -0700 (PDT) Received: from localhost.localdomain (96-67-140-173-static.hfc.comcastbusiness.net. [96.67.140.173]) by smtp.gmail.com with ESMTPSA id ce11-20020a05622a41cb00b0040fef71dc1esm46334qtb.10.2023.08.09.15.14.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Aug 2023 15:14:46 -0700 (PDT) To: gcc-patches@gcc.gnu.org Cc: David Malcolm , Lewis Hyatt Subject: [PATCH v4 1/8] libcpp: Add LC_GEN linemaps to support in-memory buffers Date: Wed, 9 Aug 2023 18:14:07 -0400 Message-Id: <20230809221414.2849878-2-lhyatt@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230809221414.2849878-1-lhyatt@gmail.com> References: <20230809221414.2849878-1-lhyatt@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3038.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lewis Hyatt via Gcc-patches From: Lewis Hyatt Reply-To: Lewis Hyatt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Add a new linemap reason LC_GEN which enables encoding the location of data that was generated during compilation and does not appear in any source file. There could be many use cases, such as, for instance, referring to the content of builtin macros (not yet implemented, but an easy lift after this one.) The first intended application is to create a place to store the input to a _Pragma directive, so that proper locations can be assigned to those tokens. This will be done in a subsequent commit. The TO_FILE member of struct line_map_ordinary has been changed to a union named SRC which can be either a file name, or a pointer to a line_map_data struct describing the data. There is no space overhead added to the line maps data structures. Outside libcpp, this patch includes only the minimal changes implied by the adjustment from TO_FILE to SRC in struct line_map_ordinary. Subsequent patches will implement the new functionality. libcpp/ChangeLog: * include/line-map.h (enum lc_reason): Add LC_GEN. (struct line_map_data): New struct. (struct line_map_ordinary): Change TO_FILE from a char* to a union, and rename to SRC. (class source_id): New class. (ORDINARY_MAP_GENERATED_DATA_P): New function. (ORDINARY_MAP_GENERATED_DATA): New function. (ORDINARY_MAP_GENERATED_DATA_LEN): New function. (ORDINARY_MAP_SOURCE_ID): New function. (ORDINARY_MAPS_SAME_FILE_P): New function. (ORDINARY_MAP_CONTAINING_FILE_NAME): Declare. (LINEMAP_FILE): Adapt to struct line_map_ordinary change. (linemap_get_file_highest_location): Likewise. * line-map.cc (source_id::operator==): New function. (ORDINARY_MAP_CONTAINING_FILE_NAME): New function. (linemap_add): Support creating LC_GEN maps. (linemap_line_start): Support LC_GEN maps. (linemap_check_files_exited): Likewise. (linemap_position_for_loc_and_offset): Likewise. (linemap_get_expansion_filename): Likewise. (linemap_dump): Likewise. (linemap_dump_location): Likewise. (linemap_get_file_highest_location): Likewise. * directives.cc (_cpp_do_file_change): Likewise. gcc/c-family/ChangeLog: * c-common.cc (try_to_locate_new_include_insertion_point): Recognize and ignore LC_GEN maps. gcc/cp/ChangeLog: * module.cc (module_state::write_ordinary_maps): Recognize and ignore LC_GEN maps, and adapt to interface change in struct line_map_ordinary. (module_state::read_ordinary_maps): Likewise. gcc/ChangeLog: * diagnostic-show-locus.cc (compatible_locations_p): Adapt to interface change in struct line_map_ordinary. * input.cc (special_fname_generated): New function. (dump_location_info): Support LC_GEN maps. (get_substring_ranges_for_loc): Adapt to interface change in struct line_map_ordinary. * input.h (special_fname_generated): Declare. gcc/go/ChangeLog: * go-linemap.cc (Gcc_linemap::to_string): Recognize and ignore LC_GEN maps. --- gcc/c-family/c-common.cc | 11 ++- gcc/cp/module.cc | 8 +- gcc/diagnostic-show-locus.cc | 2 +- gcc/go/go-linemap.cc | 3 +- gcc/input.cc | 27 +++++- gcc/input.h | 1 + libcpp/directives.cc | 4 +- libcpp/include/line-map.h | 144 ++++++++++++++++++++++++---- libcpp/line-map.cc | 181 +++++++++++++++++++++++++---------- 9 files changed, 299 insertions(+), 82 deletions(-) diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc index 9fbaeb437a1..ecfc2efc29f 100644 --- a/gcc/c-family/c-common.cc +++ b/gcc/c-family/c-common.cc @@ -9206,19 +9206,22 @@ try_to_locate_new_include_insertion_point (const char *file, location_t loc) const line_map_ordinary *ord_map = LINEMAPS_ORDINARY_MAP_AT (line_table, i); + if (ORDINARY_MAP_GENERATED_DATA_P (ord_map)) + continue; + if (const line_map_ordinary *from = linemap_included_from_linemap (line_table, ord_map)) /* We cannot use pointer equality, because with preprocessed input all filename strings are unique. */ - if (0 == strcmp (from->to_file, file)) + if (ORDINARY_MAP_SOURCE_ID (from) == file) { last_include_ord_map = from; last_ord_map_after_include = NULL; } - /* Likewise, use strcmp, and reject any line-zero introductory - map. */ - if (ord_map->to_line && 0 == strcmp (ord_map->to_file, file)) + /* Likewise, use strcmp (via the source_id comparison), and reject any + line-zero introductory map. */ + if (ord_map->to_line && ORDINARY_MAP_SOURCE_ID (ord_map) == file) { if (!first_ord_map_in_file) first_ord_map_in_file = ord_map; diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc index ea362bdffa4..ff17cd57016 100644 --- a/gcc/cp/module.cc +++ b/gcc/cp/module.cc @@ -16250,6 +16250,8 @@ module_state::write_ordinary_maps (elf_out *to, range_t &info, iter != end; ++iter) if (iter->src != current) { + if (ORDINARY_MAP_GENERATED_DATA_P (iter->src)) + continue; current = iter->src; const char *fname = ORDINARY_MAP_FILE_NAME (iter->src); @@ -16267,7 +16269,7 @@ module_state::write_ordinary_maps (elf_out *to, range_t &info, preprocessed input we could have multiple instances of the same name, and we'd rather not percolate that. */ - const_cast (iter->src)->to_file = name; + const_cast (iter->src)->src.file = name; fname = NULL; break; } @@ -16295,6 +16297,8 @@ module_state::write_ordinary_maps (elf_out *to, range_t &info, for (auto iter = ord_loc_remap->begin (), end = ord_loc_remap->end (); iter != end; ++iter) { + if (ORDINARY_MAP_GENERATED_DATA_P (iter->src)) + continue; dump (dumper::LOCATION) && dump ("Span:%u ordinary [%u+%u,+%u)->[%u,+%u)", iter - ord_loc_remap->begin (), @@ -16456,7 +16460,7 @@ module_state::read_ordinary_maps (unsigned num_ord_locs, unsigned range_bits) map->m_range_bits = sec.u (); map->m_column_and_range_bits = sec.u () + map->m_range_bits; unsigned fnum = sec.u (); - map->to_file = (fnum < filenames.length () ? filenames[fnum] : ""); + map->src.file = (fnum < filenames.length () ? filenames[fnum] : ""); map->to_line = sec.u (); base = map; } diff --git a/gcc/diagnostic-show-locus.cc b/gcc/diagnostic-show-locus.cc index 0514815b51f..a2aa6b4e0b5 100644 --- a/gcc/diagnostic-show-locus.cc +++ b/gcc/diagnostic-show-locus.cc @@ -998,7 +998,7 @@ compatible_locations_p (location_t loc_a, location_t loc_b) are in the same file. */ const line_map_ordinary *ord_map_a = linemap_check_ordinary (map_a); const line_map_ordinary *ord_map_b = linemap_check_ordinary (map_b); - return ord_map_a->to_file == ord_map_b->to_file; + return ORDINARY_MAPS_SAME_FILE_P (ord_map_a, ord_map_b); } } diff --git a/gcc/go/go-linemap.cc b/gcc/go/go-linemap.cc index 1d72e79647d..02d4ce04181 100644 --- a/gcc/go/go-linemap.cc +++ b/gcc/go/go-linemap.cc @@ -84,7 +84,8 @@ Gcc_linemap::to_string(Location location) resolved_location = linemap_resolve_location (line_table, location.gcc_location(), LRK_SPELLING_LOCATION, &lmo); - if (lmo == NULL || resolved_location < RESERVED_LOCATION_COUNT) + if (lmo == NULL || resolved_location < RESERVED_LOCATION_COUNT + || ORDINARY_MAP_GENERATED_DATA_P (lmo)) return ""; const char *path = LINEMAP_FILE (lmo); if (!path) diff --git a/gcc/input.cc b/gcc/input.cc index eaf301ec7c1..c1735215b29 100644 --- a/gcc/input.cc +++ b/gcc/input.cc @@ -35,6 +35,12 @@ special_fname_builtin () return _(""); } +const char * +special_fname_generated () +{ + return _(""); +} + /* Input charset configuration. */ static const char *default_charset_callback (const char *) { @@ -1391,7 +1397,19 @@ dump_location_info (FILE *stream) fprintf (stream, "ORDINARY MAP: %i\n", idx); dump_location_range (stream, MAP_START_LOCATION (map), end_location); - fprintf (stream, " file: %s\n", ORDINARY_MAP_FILE_NAME (map)); + + if (ORDINARY_MAP_GENERATED_DATA_P (map)) + { + fprintf (stream, " file: %s%s\n", + ORDINARY_MAP_CONTAINING_FILE_NAME (line_table, map), + special_fname_generated ()); + fprintf (stream, " data: %.*s\n", + (int) ORDINARY_MAP_GENERATED_DATA_LEN (map), + ORDINARY_MAP_GENERATED_DATA (map)); + } + else + fprintf (stream, " file: %s\n", LINEMAP_FILE (map)); + fprintf (stream, " starting at line: %i\n", ORDINARY_MAP_STARTING_LINE_NUMBER (map)); fprintf (stream, " column and range bits: %i\n", @@ -1417,6 +1435,9 @@ dump_location_info (FILE *stream) case LC_ENTER_MACRO: reason = "LC_RENAME_MACRO"; break; + case LC_GEN: + reason = "LC_GEN"; + break; default: reason = "Unknown"; } @@ -1814,11 +1835,11 @@ get_substring_ranges_for_loc (cpp_reader *pfile, /* Bulletproofing. We ought to only have different ordinary maps for start vs finish due to line-length jumps. */ if (start_ord_map != final_ord_map - && start_ord_map->to_file != final_ord_map->to_file) + && !ORDINARY_MAPS_SAME_FILE_P (start_ord_map, final_ord_map)) return "start and finish are spelled in different ordinary maps"; /* The file from linemap_resolve_location ought to match that from expand_location_to_spelling_point. */ - if (start_ord_map->to_file != start.file) + if (ORDINARY_MAP_SOURCE_ID (start_ord_map) != start.file) return "mismatching file after resolving linemap"; location_t start_loc diff --git a/gcc/input.h b/gcc/input.h index d1087b7a9e8..1b81a995f86 100644 --- a/gcc/input.h +++ b/gcc/input.h @@ -34,6 +34,7 @@ extern GTY(()) class line_maps *saved_line_table; /* Returns the translated string referring to the special location. */ const char *special_fname_builtin (); +const char *special_fname_generated (); /* line-map.cc reserves RESERVED_LOCATION_COUNT to the user. Ensure both UNKNOWN_LOCATION and BUILTINS_LOCATION fit into that. */ diff --git a/libcpp/directives.cc b/libcpp/directives.cc index ee5419d1f40..dfd782b3fca 100644 --- a/libcpp/directives.cc +++ b/libcpp/directives.cc @@ -1165,7 +1165,7 @@ _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason, const char *to_file, linenum_type to_line, unsigned int sysp) { - linemap_assert (reason != LC_ENTER_MACRO); + linemap_assert (reason != LC_ENTER_MACRO && reason != LC_GEN); const line_map_ordinary *ord_map = NULL; if (!to_line && reason == LC_RENAME_VERBATIM) @@ -1176,7 +1176,7 @@ _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason, preprocessed source. */ line_map_ordinary *last = LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table); if (!ORDINARY_MAP_STARTING_LINE_NUMBER (last) - && 0 == filename_cmp (to_file, ORDINARY_MAP_FILE_NAME (last)) + && ORDINARY_MAP_SOURCE_ID (last) == to_file && SOURCE_LINE (last, pfile->line_table->highest_line) == 2) { ord_map = last; diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h index 44fea0ea08e..e59123b18c5 100644 --- a/libcpp/include/line-map.h +++ b/libcpp/include/line-map.h @@ -75,6 +75,8 @@ enum lc_reason LC_RENAME_VERBATIM, /* Likewise, but "" != stdin. */ LC_ENTER_MACRO, /* Begin macro expansion. */ LC_MODULE, /* A (C++) Module. */ + LC_GEN, /* Internally generated source. */ + /* FIXME: add support for stringize and paste. */ LC_HWM /* High Water Mark. */ }; @@ -355,6 +357,16 @@ typedef void *(*line_map_realloc) (void *, size_t); for a given requested allocation. */ typedef size_t (*line_map_round_alloc_size_func) (size_t); +/* Struct to hold the data + size for in-memory data to be stored in a + line_map_ordinary. Because this is used rarely, it is better to + dynamically allocate this struct just when needed, rather than adding + overhead to every line_map to store the extra field. */ +struct GTY(()) line_map_data +{ + const char * GTY((string_length ("%h.len"))) data; + unsigned int len; +}; + /* A line_map encodes a sequence of locations. There are two kinds of maps. Ordinary maps and macro expansion maps, a.k.a macro maps. @@ -437,9 +449,15 @@ struct GTY((tag ("1"))) line_map_ordinary : public line_map { /* Pointer alignment boundary on both 32 and 64-bit systems. */ - const char *to_file; - linenum_type to_line; + /* SRC is either the file name, in the typical case, or a pointer to + a line_map_data which shows where to find the actual data, for the + case of an LC_GEN map. */ + union { + const char * GTY((tag ("false"))) file; + line_map_data * GTY((tag ("true"))) data; + } GTY((desc ("ORDINARY_MAP_GENERATED_DATA_P (&%1)"))) src; + linenum_type to_line; /* Location from whence this line map was included. For regular #includes, this location will be the last location of a map. For outermost file, this is 0. For modules it could be anywhere @@ -565,6 +583,42 @@ struct GTY((tag ("2"))) line_map_macro : public line_map { #define linemap_assert_fails(EXPR) (! (EXPR)) #endif +/* A source_id represents a location that contains source code, which is usually + the name of a file. But if the buffer length is non-zero, then it refers + instead to an in-memory buffer. This is used so that diagnostics can refer + to generated data as well as to normal source code. */ + +class source_id +{ +public: + /* This constructor is for the typical case, where the source code lives in + a file. It is not explicit, because this case is by far the most common + one, it is worthwhile to allow implicit construction from a string. */ + source_id (const char *filename = nullptr) + : m_filename_or_buffer (filename), + m_len (0) + {} + + /* This constructor is for the in-memory data case. */ + source_id (const char *buffer, unsigned buffer_len) + : m_filename_or_buffer (buffer), + m_len (buffer_len) + { + linemap_assert (buffer_len > 0); + } + + explicit operator bool () const { return m_filename_or_buffer; } + const char * get_filename_or_buffer () const { return m_filename_or_buffer; } + unsigned get_buffer_len () const { return m_len; } + bool is_buffer () const { return m_len; } + bool operator== (source_id src) const; + bool operator!= (source_id src) const { return !(*this == src); } + +private: + const char *m_filename_or_buffer; + unsigned m_len; +}; + /* Get whether location LOC is an ordinary location. */ inline bool @@ -662,6 +716,12 @@ ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map) return ord_map->sysp; } +/* TRUE if this line map contains generated data. */ +inline bool ORDINARY_MAP_GENERATED_DATA_P (const line_map_ordinary *ord_map) +{ + return ord_map->reason == LC_GEN; +} + /* TRUE if this line map is for a module (not a source file). */ inline bool @@ -671,14 +731,46 @@ MAP_MODULE_P (const line_map *map) && linemap_check_ordinary (map)->reason == LC_MODULE); } -/* Get the filename of ordinary map MAP. */ +/* Get the data contents of ordinary map MAP. */ inline const char * ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map) { - return ord_map->to_file; + linemap_assert (ord_map->reason != LC_GEN); + return ord_map->src.file; +} + +inline const char * +ORDINARY_MAP_GENERATED_DATA (const line_map_ordinary *ord_map) +{ + linemap_assert (ord_map->reason == LC_GEN); + return ord_map->src.data->data; +} + +inline unsigned int +ORDINARY_MAP_GENERATED_DATA_LEN (const line_map_ordinary *ord_map) +{ + linemap_assert (ord_map->reason == LC_GEN); + return ord_map->src.data->len; +} + +inline source_id ORDINARY_MAP_SOURCE_ID (const line_map_ordinary *ord_map) +{ + if (ORDINARY_MAP_GENERATED_DATA_P (ord_map)) + return source_id {ord_map->src.data->data, ord_map->src.data->len}; + return source_id {ord_map->src.file}; +} + +/* If we just want to know whether two maps point to the same + file/buffer or not. */ +inline bool +ORDINARY_MAPS_SAME_FILE_P (const line_map_ordinary *map1, + const line_map_ordinary *map2) +{ + return ORDINARY_MAP_SOURCE_ID (map1) == ORDINARY_MAP_SOURCE_ID (map2); } + /* Get the cpp macro whose expansion gave birth to macro map MAP. */ inline cpp_hashnode * @@ -1093,21 +1185,28 @@ extern location_t linemap_line_start extern line_map *line_map_new_raw (line_maps *, bool, unsigned); /* Add a mapping of logical source line to physical source file and - line number. This function creates an "ordinary map", which is a + line number. This function creates an "ordinary map", which is a map that records locations of tokens that are not part of macro replacement-lists present at a macro expansion point. - The text pointed to by TO_FILE must have a lifetime - at least as long as the lifetime of SET. An empty - TO_FILE means standard input. If reason is LC_LEAVE, and - TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their - natural values considering the file we are returning to. + The text pointed to by FILENAME_OR_BUFFER must have a lifetime at least as + long as the lifetime of SET. If reason is LC_LEAVE, and FILENAME_OR_BUFFER + is NULL, then FILENAME_OR_BUFFER, TO_LINE and SYSP are given their natural + values considering the file we are returning to. If reason is LC_GEN, then + FILENAME_OR_BUFFER is the actual content, and DATA_LEN>0 is the length of it. + Otherwise FILENAME_OR_BUFFER is a file name and DATA_LEN is ignored. + + If reason is LC_RENAME, and the map being renamed from is an LC_GEN map, + then FILENAME_OR_BUFFER may be NULL and will be copied from the source + map. + + A call to this function can relocate the previous set of maps, so any stored + line_map pointers should not be used. */ - A call to this function can relocate the previous set of - maps, so any stored line_map pointers should not be used. */ extern const line_map *linemap_add (class line_maps *, enum lc_reason, unsigned int sysp, - const char *to_file, linenum_type to_line); + const char *filename_or_buffer, linenum_type to_line, + unsigned int data_len = 0); /* Create a macro map. A macro map encodes source locations of tokens that are part of a macro replacement-list, at a macro expansion @@ -1257,7 +1356,7 @@ linemap_position_for_loc_and_offset (class line_maps *set, inline const char * LINEMAP_FILE (const line_map_ordinary *ord_map) { - return ord_map->to_file; + return ORDINARY_MAP_FILE_NAME (ord_map); } /* Return the line number this map started encoding location from. */ @@ -1277,6 +1376,13 @@ LINEMAP_SYSP (const line_map_ordinary *ord_map) return ord_map->sysp; } +/* For a normal ordinary map, this is the same as ORDINARY_MAP_FILE_NAME; + but for an LC_GEN map, it returns the file name from which the data + originated, instead of asserting. */ +const char * +ORDINARY_MAP_CONTAINING_FILE_NAME (line_maps *set, + const line_map_ordinary *ord_map); + const struct line_map *first_map_in_common (line_maps *set, location_t loc0, location_t loc1, @@ -2104,12 +2210,10 @@ struct linemap_stats long adhoc_table_entries_used; }; -/* Return the highest location emitted for a given file for which - there is a line map in SET. FILE_NAME is the file name to - consider. If the function returns TRUE, *LOC is set to the highest - location emitted for that file. */ -bool linemap_get_file_highest_location (class line_maps * set, - const char *file_name, +/* Return the highest location emitted for a given source ID for which there is + a line map in SET. If the function returns TRUE, *LOC is set to the highest + location emitted for that source. */ +bool linemap_get_file_highest_location (line_maps *set, source_id src, location_t *loc); /* Compute and return statistics about the memory consumption of some diff --git a/libcpp/line-map.cc b/libcpp/line-map.cc index e0f82e20571..e63916054e0 100644 --- a/libcpp/line-map.cc +++ b/libcpp/line-map.cc @@ -48,6 +48,31 @@ static location_t linemap_macro_loc_to_exp_point (line_maps *, extern unsigned num_expanded_macros_counter; extern unsigned num_macro_tokens_counter; +bool +source_id::operator== (source_id src) const +{ + return m_len == src.m_len + && (is_buffer () || !m_filename_or_buffer || !src.m_filename_or_buffer + ? m_filename_or_buffer == src.m_filename_or_buffer + : !filename_cmp (m_filename_or_buffer, src.m_filename_or_buffer)); +} + +/* For a normal ordinary map, this is the same as ORDINARY_MAP_FILE_NAME; + but for an LC_GEN map, it returns the file name from which the data + originated, instead of asserting. */ +const char * +ORDINARY_MAP_CONTAINING_FILE_NAME (line_maps *set, + const line_map_ordinary *ord_map) +{ + while (ORDINARY_MAP_GENERATED_DATA_P (ord_map)) + { + ord_map = linemap_included_from_linemap (set, ord_map); + if (!ord_map) + return "-"; + } + return ORDINARY_MAP_FILE_NAME (ord_map); +} + /* Destructor for class line_maps. Ensure non-GC-managed memory is released. */ @@ -411,8 +436,9 @@ linemap_check_files_exited (line_maps *set) for (const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set); ! MAIN_FILE_P (map); map = linemap_included_from_linemap (set, map)) - fprintf (stderr, "line-map.cc: file \"%s\" entered but not left\n", - ORDINARY_MAP_FILE_NAME (map)); + fprintf (stderr, "line-map.cc: file \"%s%s\" entered but not left\n", + ORDINARY_MAP_CONTAINING_FILE_NAME (set, map), + ORDINARY_MAP_GENERATED_DATA_P (map) ? "" : ""); } /* Create NUM zero-initialized maps of type MACRO_P. */ @@ -505,21 +531,28 @@ LAST_SOURCE_LINE_LOCATION (const line_map_ordinary *map) } /* Add a mapping of logical source line to physical source file and - line number. + line number. This function creates an "ordinary map", which is a + map that records locations of tokens that are not part of macro + replacement-lists present at a macro expansion point. + + The text pointed to by FILENAME_OR_BUFFER must have a lifetime at least as + long as the lifetime of SET. If reason is LC_LEAVE, and FILENAME_OR_BUFFER + is NULL, then FILENAME_OR_BUFFER, TO_LINE and SYSP are given their natural + values considering the file we are returning to. If reason is LC_GEN, then + FILENAME_OR_BUFFER is the actual content, and DATA_LEN>0 is the length of it. + Otherwise FILENAME_OR_BUFFER is a file name and DATA_LEN is ignored. - The text pointed to by TO_FILE must have a lifetime - at least as long as the final call to lookup_line (). An empty - TO_FILE means standard input. If reason is LC_LEAVE, and - TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their - natural values considering the file we are returning to. + If reason is LC_RENAME, and the map being renamed from is an LC_GEN map, + then FILENAME_OR_BUFFER may be NULL and will be copied from the source + map. - FROM_LINE should be monotonic increasing across calls to this - function. A call to this function can relocate the previous set of - maps, so any stored line_map pointers should not be used. */ + A call to this function can relocate the previous set of maps, so any stored + line_map pointers should not be used. */ const struct line_map * linemap_add (line_maps *set, enum lc_reason reason, - unsigned int sysp, const char *to_file, linenum_type to_line) + unsigned int sysp, const char *filename_or_buffer, + linenum_type to_line, unsigned int data_len) { /* Generate a start_location above the current highest_location. If possible, make the low range bits be zero. */ @@ -536,12 +569,24 @@ linemap_add (line_maps *set, enum lc_reason reason, /* When we enter the file for the first time reason cannot be LC_RENAME. */ - linemap_assert (!(set->depth == 0 && reason == LC_RENAME)); + line_map_data *data_to_reuse = nullptr; + bool is_data_map = (reason == LC_GEN); + if (reason == LC_RENAME || reason == LC_RENAME_VERBATIM) + { + linemap_assert (set->depth != 0); + const auto prev = LINEMAPS_LAST_ORDINARY_MAP (set); + linemap_assert (prev); + if (prev->reason == LC_GEN) + { + data_to_reuse = prev->src.data; + is_data_map = true; + } + } /* If we are leaving the main file, return a NULL map. */ if (reason == LC_LEAVE && MAIN_FILE_P (LINEMAPS_LAST_ORDINARY_MAP (set)) - && to_file == NULL) + && filename_or_buffer == NULL) { set->depth--; return NULL; @@ -557,8 +602,9 @@ linemap_add (line_maps *set, enum lc_reason reason, = linemap_check_ordinary (new_linemap (set, start_location)); map->reason = reason; - if (to_file && *to_file == '\0' && reason != LC_RENAME_VERBATIM) - to_file = ""; + if (filename_or_buffer && *filename_or_buffer == '\0' + && reason != LC_RENAME_VERBATIM && !is_data_map) + filename_or_buffer = ""; if (reason == LC_RENAME_VERBATIM) reason = LC_RENAME; @@ -577,21 +623,50 @@ linemap_add (line_maps *set, enum lc_reason reason, that comes right before MAP in the same file. */ from = linemap_included_from_linemap (set, map - 1); - /* A TO_FILE of NULL is special - we use the natural values. */ - if (to_file == NULL) + /* Not currently supporting a #include originating from an LC_GEN + map, since there is no clear use case for this and it would complicate + the logic here. */ + linemap_assert (!ORDINARY_MAP_GENERATED_DATA_P (from)); + + /* A null FILENAME_OR_BUFFER is special - we use the natural + values. */ + if (!filename_or_buffer) { - to_file = ORDINARY_MAP_FILE_NAME (from); + filename_or_buffer = from->src.file; to_line = SOURCE_LINE (from, from[1].start_location); sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (from); } else linemap_assert (filename_cmp (ORDINARY_MAP_FILE_NAME (from), - to_file) == 0); + filename_or_buffer) == 0); } map->sysp = sysp; - map->to_file = to_file; map->to_line = to_line; + + if (is_data_map) + { + /* All data maps should have reason == LC_GEN, even if they were + an LC_RENAME, to keep it simple to check which maps contain + data. */ + map->reason = LC_GEN; + + if (data_to_reuse) + map->src.data = data_to_reuse; + else + { + auto src_data + = (line_map_data *)set->reallocator (nullptr, + sizeof (line_map_data)); + src_data->data = filename_or_buffer; + src_data->len = data_len; + gcc_assert (data_len); + map->src.data = src_data; + } + } + else + map->src.file = filename_or_buffer; + LINEMAPS_ORDINARY_CACHE (set) = LINEMAPS_ORDINARY_USED (set) - 1; /* Do not store range_bits here. That's readjusted in linemap_line_start. */ @@ -606,7 +681,7 @@ linemap_add (line_maps *set, enum lc_reason reason, pure_location_p. */ linemap_assert (pure_location_p (set, start_location)); - if (reason == LC_ENTER) + if (reason == LC_ENTER || reason == LC_GEN) { if (set->depth == 0) map->included_from = 0; @@ -617,7 +692,7 @@ linemap_add (line_maps *set, enum lc_reason reason, & ~((1 << map[-1].m_column_and_range_bits) - 1)) + map[-1].start_location); set->depth++; - if (set->trace_includes) + if (set->trace_includes && reason == LC_ENTER) trace_include (set, map); } else if (reason == LC_RENAME) @@ -859,12 +934,16 @@ linemap_line_start (line_maps *set, linenum_type to_line, >= (((uint64_t) 1) << (CHAR_BIT * sizeof (linenum_type) - column_bits))) || range_bits < map->m_range_bits) - map = linemap_check_ordinary - (const_cast - (linemap_add (set, LC_RENAME, - ORDINARY_MAP_IN_SYSTEM_HEADER_P (map), - ORDINARY_MAP_FILE_NAME (map), - to_line))); + { + const auto maybe_filename = ORDINARY_MAP_GENERATED_DATA_P (map) + ? nullptr : map->src.file; + map = linemap_check_ordinary + (const_cast + (linemap_add (set, LC_RENAME, + ORDINARY_MAP_IN_SYSTEM_HEADER_P (map), + maybe_filename, + to_line))); + } map->m_column_and_range_bits = column_bits; map->m_range_bits = range_bits; r = (MAP_START_LOCATION (map) @@ -1023,9 +1102,9 @@ linemap_position_for_loc_and_offset (line_maps *set, >= MAP_START_LOCATION (map + 1)); map++) /* If the next map is a different file, or starts in a higher line, we cannot encode the location there. */ - if ((map + 1)->reason != LC_RENAME + if (((map + 1)->reason != LC_RENAME && (map + 1)->reason != LC_GEN) || line < ORDINARY_MAP_STARTING_LINE_NUMBER (map + 1) - || 0 != strcmp (LINEMAP_FILE (map + 1), LINEMAP_FILE (map))) + || !ORDINARY_MAPS_SAME_FILE_P (map, map + 1)) return loc; column += column_offset; @@ -1283,7 +1362,7 @@ linemap_get_expansion_filename (line_maps *set, linemap_macro_loc_to_exp_point (set, location, &map); - return LINEMAP_FILE (map); + return ORDINARY_MAP_CONTAINING_FILE_NAME (set, map); } /* Return the name of the macro associated to MACRO_MAP. */ @@ -1873,7 +1952,7 @@ linemap_dump (FILE *stream, class line_maps *set, unsigned ix, bool is_macro) { const char *const lc_reasons_v[LC_HWM] = { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM", - "LC_ENTER_MACRO", "LC_MODULE" }; + "LC_ENTER_MACRO", "LC_MODULE", "LC_GEN" }; const line_map *map; unsigned reason; @@ -1903,11 +1982,15 @@ linemap_dump (FILE *stream, class line_maps *set, unsigned ix, bool is_macro) const line_map_ordinary *includer_map = linemap_included_from_linemap (set, ord_map); - fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (ord_map), + fprintf (stream, "File: %s:%d\n", + ORDINARY_MAP_GENERATED_DATA_P (ord_map) ? "" + : ORDINARY_MAP_FILE_NAME (ord_map), ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map)); fprintf (stream, "Included from: [%d] %s\n", includer_map ? int (includer_map - set->info_ordinary.maps) : -1, - includer_map ? ORDINARY_MAP_FILE_NAME (includer_map) : "None"); + includer_map ? ORDINARY_MAP_CONTAINING_FILE_NAME (set, + includer_map) + : "None"); } else { @@ -1931,7 +2014,7 @@ linemap_dump_location (line_maps *set, { const line_map_ordinary *map; location_t location; - const char *path = "", *from = ""; + const char *path = "", *path_suffix = "", *from = ""; int l = -1, c = -1, s = -1, e = -1; if (IS_ADHOC_LOC (loc)) @@ -1948,7 +2031,9 @@ linemap_dump_location (line_maps *set, linemap_assert (location < RESERVED_LOCATION_COUNT); else { - path = LINEMAP_FILE (map); + path = ORDINARY_MAP_CONTAINING_FILE_NAME (set, map); + if (ORDINARY_MAP_GENERATED_DATA_P (map)) + path_suffix = ""; l = SOURCE_LINE (map, location); c = SOURCE_COLUMN (map, location); s = LINEMAP_SYSP (map) != 0; @@ -1959,24 +2044,23 @@ linemap_dump_location (line_maps *set, { const line_map_ordinary *from_map = linemap_included_from_linemap (set, map); - from = from_map ? LINEMAP_FILE (from_map) : ""; + from = from_map ? ORDINARY_MAP_CONTAINING_FILE_NAME (set, from_map) + : ""; } } /* P: path, L: line, C: column, S: in-system-header, M: map address, E: macro expansion?, LOC: original location, R: resolved location */ - fprintf (stream, "{P:%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}", - path, from, l, c, s, (void*)map, e, loc, location); + fprintf (stream, "{P:%s%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}", + path, path_suffix, from, l, c, s, (void*)map, e, loc, location); } -/* Return the highest location emitted for a given file for which - there is a line map in SET. FILE_NAME is the file name to - consider. If the function returns TRUE, *LOC is set to the highest - location emitted for that file. */ +/* Return the highest location emitted for a given source ID for which there is + a line map in SET. If the function returns TRUE, *LOC is set to the highest + location emitted for that source. */ bool -linemap_get_file_highest_location (line_maps *set, - const char *file_name, +linemap_get_file_highest_location (line_maps *set, source_id src, location_t *loc) { /* If the set is empty or no ordinary map has been created then @@ -1984,12 +2068,11 @@ linemap_get_file_highest_location (line_maps *set, if (set == NULL || set->info_ordinary.used == 0) return false; - /* Now look for the last ordinary map created for FILE_NAME. */ + /* Now look for the last ordinary map created for this file. */ int i; for (i = set->info_ordinary.used - 1; i >= 0; --i) { - const char *fname = set->info_ordinary.maps[i].to_file; - if (fname && !filename_cmp (fname, file_name)) + if (ORDINARY_MAP_SOURCE_ID (set->info_ordinary.maps + i) == src) break; } From patchwork Wed Aug 9 22:14:08 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lewis Hyatt X-Patchwork-Id: 1819642 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=wxZzGdke; dkim-atps=neutral Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RLkrg68GWz1yYl for ; Thu, 10 Aug 2023 08:15:15 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id CB386385734F for ; Wed, 9 Aug 2023 22:15:13 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org CB386385734F DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691619313; bh=2bqiaX8fGQCtU58i1/wgdRfXIIyLV0jx8UQ8dKb9s3I=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=wxZzGdkesdAgsh6vHtaAAWsaJbhOF9UcOOR+2Kjubh+PRTgs2PiSLG/9Bju/5svr7 VI5m7g4jpDVLE8FJagTZz5WXhe7imPy26QZjW/0HqE9AJn6pg0YhKDRlYaqwzlmKUO i9hIuFQGcYjUQ/quPDs4iu+G3cEowfQUCJLFsbNk= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qt1-x836.google.com (mail-qt1-x836.google.com [IPv6:2607:f8b0:4864:20::836]) by sourceware.org (Postfix) with ESMTPS id 901593857B9B for ; Wed, 9 Aug 2023 22:14:48 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 901593857B9B Received: by mail-qt1-x836.google.com with SMTP id d75a77b69052e-40fe9c38800so1455701cf.0 for ; Wed, 09 Aug 2023 15:14:48 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691619288; x=1692224088; 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=2bqiaX8fGQCtU58i1/wgdRfXIIyLV0jx8UQ8dKb9s3I=; b=X2HGC2eGSJ/EBgCw452G++NKrH7Rxxe1inIsZga65i/GMhfyrPNBRvLGmMX9GPvtMW hub7XADdxz97ATvj86X5/pVNWUXq4cmC2nA4jqdlt5lGnLmqXmKNJIq8tTXTBmwk5ft+ FIoPHbyS6w91kSL10beHkxANaXWnKxsSZsUzeOJp6Vgg5+rzyqjekHmyO9MMzKD5g4Y2 MDyjxrdIyp44BPRF93Lss1oBQerl/9qrH4RzhaxRnXysAXh1EWJVEzz5FhTubx6GzItV Og+bs7YkuxzE6/fUgRZTWDgBBGevbHuJI+xpXWUSCO9ItcU40fD61hQStZJXJuEiNRPD vb8w== X-Gm-Message-State: AOJu0Yzl1JW+N3G6oObvKgM6q1w4lBZZ7SNavEMfuGMz9dGv0wANPNqC v9NHRtzWNz8Y9QuyywIxjC/6vNsiYYs= X-Google-Smtp-Source: AGHT+IEwItVTBbdhxMXI9uo/p9cAiBTmkajDEtIXDNp3VosYr5D2/BIVcxHiT3VqiIjMgBBlyKnrDg== X-Received: by 2002:ac8:5981:0:b0:403:a91f:893d with SMTP id e1-20020ac85981000000b00403a91f893dmr992718qte.26.1691619287652; Wed, 09 Aug 2023 15:14:47 -0700 (PDT) Received: from localhost.localdomain (96-67-140-173-static.hfc.comcastbusiness.net. [96.67.140.173]) by smtp.gmail.com with ESMTPSA id ce11-20020a05622a41cb00b0040fef71dc1esm46334qtb.10.2023.08.09.15.14.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Aug 2023 15:14:47 -0700 (PDT) To: gcc-patches@gcc.gnu.org Cc: David Malcolm , Lewis Hyatt Subject: [PATCH v4 2/8] libcpp: diagnostics: Support generated data in expanded locations Date: Wed, 9 Aug 2023 18:14:08 -0400 Message-Id: <20230809221414.2849878-3-lhyatt@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230809221414.2849878-1-lhyatt@gmail.com> References: <20230809221414.2849878-1-lhyatt@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3038.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lewis Hyatt via Gcc-patches From: Lewis Hyatt Reply-To: Lewis Hyatt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" The previous patch in this series introduced the concept of LC_GEN line maps. This patch continues on the path to using them to improve _Pragma diagnostics, by adding a new source_id SRC member to struct expanded_location, which is populated by linemap_expand_location. This member allows call sites to detect and handle when a location refers to generated data rather than a plain file name. The previous FILE member of expanded_location is preserved (although redundant with SRC), so that call sites which do not and never will care about generated data do not need to be concerned about it. Call sites that will care are modified here, to use SRC rather than FILE for comparing locations. libcpp/ChangeLog: * include/line-map.h (struct expanded_location): Add SRC member. Add zero-initializers for all members, since source_id is not a POD type. (class fixit_hint): Adjust prototype. * line-map.cc (linemap_expand_location): Populate the new SRC member in the expanded_location. (rich_location::maybe_add_fixit): Compare explocs with the new SRC field instead of the FILE field. (fixit_hint::affects_line_p): Accept a source_id instead of a file name, and use it for the comparisons. gcc/c-family/ChangeLog: * c-format.cc (get_corrected_substring): Compare explocs with the new SRC field instead of the FILE field. * c-indentation.cc (should_warn_for_misleading_indentation): Likewise. (assert_get_visual_column_succeeds): Initialize the SRC field in the test expanded_location. (assert_get_visual_column_fails): Likewise. gcc/ChangeLog: * diagnostic-show-locus.cc (make_range): Adapt to the new constructor semantics for struct expanded_location. (layout::maybe_add_location_range): Compare explocs with the new SRC field instead of the FILE field. (layout::validate_fixit_hint_p): Likewise. (layout::print_leading_fixits): Use the SRC field in struct expanded_location to query fixit_hint::affects_line_p. (layout::print_trailing_fixits): Likewise. * diagnostic.cc (diagnostic_report_current_module): Use the new SRC field in expanded_location to detect LC_GEN locations and identify them as such. (assert_location_text): Adapt to the new constructor semantics for struct expanded_location. * input.cc (expand_location_1): Likewise. And when libcpp's linemap_expand_location returns a null FILE for generated data, replace it with special_fname_generated (). (total_lines_num): Handle a generic source_id argument rather than a file name only. (get_source_text_between): Compare explocs with the new SRC field instead of the FILE field. (get_substring_ranges_for_loc): Likewise. * edit-context.cc (edit_context::apply_fixit): Ignore locations in generated data. * input.h (LOCATION_SRC): New accessor macro. --- gcc/c-family/c-format.cc | 4 ++-- gcc/c-family/c-indentation.cc | 10 +++++----- gcc/diagnostic-show-locus.cc | 30 +++++++++++++++++------------- gcc/diagnostic.cc | 19 ++++++++++++------- gcc/edit-context.cc | 2 +- gcc/input.cc | 21 +++++++++++---------- gcc/input.h | 1 + libcpp/include/line-map.h | 24 ++++++++++++++---------- libcpp/line-map.cc | 15 +++++++-------- 9 files changed, 70 insertions(+), 56 deletions(-) diff --git a/gcc/c-family/c-format.cc b/gcc/c-family/c-format.cc index b4eeebcb30e..529b1408179 100644 --- a/gcc/c-family/c-format.cc +++ b/gcc/c-family/c-format.cc @@ -4522,9 +4522,9 @@ get_corrected_substring (const substring_loc &fmt_loc, = expand_location_to_spelling_point (fmt_substring_range.m_start); expanded_location finish = expand_location_to_spelling_point (fmt_substring_range.m_finish); - if (caret.file != start.file) + if (caret.src != start.src) return NULL; - if (start.file != finish.file) + if (start.src != finish.src) return NULL; if (caret.line != start.line) return NULL; diff --git a/gcc/c-family/c-indentation.cc b/gcc/c-family/c-indentation.cc index e8d3dece770..fce74991aae 100644 --- a/gcc/c-family/c-indentation.cc +++ b/gcc/c-family/c-indentation.cc @@ -334,7 +334,7 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo, const unsigned int tab_width = global_dc->tabstop; /* They must be in the same file. */ - if (next_stmt_exploc.file != body_exploc.file) + if (next_stmt_exploc.src != body_exploc.src) return false; /* If NEXT_STMT_LOC and BODY_LOC are on the same line, consider @@ -363,7 +363,7 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo, ^ DON'T WARN HERE. */ if (next_stmt_exploc.line == body_exploc.line) { - if (guard_exploc.file != body_exploc.file) + if (guard_exploc.src != body_exploc.src) return true; if (guard_exploc.line < body_exploc.line) /* The guard is on a line before a line that contains both @@ -372,7 +372,7 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo, else if (guard_exploc.line == body_exploc.line) { /* They're all on the same line. */ - gcc_assert (guard_exploc.file == next_stmt_exploc.file); + gcc_assert (guard_exploc.src == next_stmt_exploc.src); gcc_assert (guard_exploc.line == next_stmt_exploc.line); unsigned int guard_vis_column; unsigned int guard_line_first_nws; @@ -692,7 +692,7 @@ assert_get_visual_column_succeeds (const location &loc, unsigned int expected_first_nws) { expanded_location exploc; - exploc.file = file; + exploc.src = exploc.file = file; exploc.line = line; exploc.column = column; exploc.data = NULL; @@ -730,7 +730,7 @@ assert_get_visual_column_fails (const location &loc, const unsigned int tab_width) { expanded_location exploc; - exploc.file = file; + exploc.src = exploc.file = file; exploc.line = line; exploc.column = column; exploc.data = NULL; diff --git a/gcc/diagnostic-show-locus.cc b/gcc/diagnostic-show-locus.cc index a2aa6b4e0b5..bf969ab6d6a 100644 --- a/gcc/diagnostic-show-locus.cc +++ b/gcc/diagnostic-show-locus.cc @@ -697,9 +697,9 @@ static cpp_char_column_policy def_policy () } /* Create some expanded locations for testing layout_range. The filename - member of the explocs is set to the empty string. This member will only be + member of the explocs is set to NULL. This member will only be inspected by the calls to location_compute_display_column() made from the - layout_point constructors. That function will check for an empty filename + layout_point constructors. That function will check for a NULL filename argument and not attempt to open it, rather treating the non-existent data as if the display width were the same as the byte count. Tests exercising a real difference between byte count and display width are performed later, @@ -708,10 +708,14 @@ static cpp_char_column_policy def_policy () static layout_range make_range (int start_line, int start_col, int end_line, int end_col) { - const expanded_location start_exploc - = {"", start_line, start_col, NULL, false}; - const expanded_location finish_exploc - = {"", end_line, end_col, NULL, false}; + expanded_location start_exploc; + start_exploc.line = start_line; + start_exploc.column = start_col; + + expanded_location finish_exploc; + finish_exploc.line = end_line; + finish_exploc.column = end_col; + return layout_range (exploc_with_display_col (start_exploc, def_policy (), LOCATION_ASPECT_START), exploc_with_display_col (finish_exploc, def_policy (), @@ -1268,12 +1272,12 @@ layout::maybe_add_location_range (const location_range *loc_range, /* If any part of the range isn't in the same file as the primary location of this diagnostic, ignore the range. */ - if (start.file != m_exploc.file) + if (start.src != m_exploc.src) return false; - if (finish.file != m_exploc.file) + if (finish.src != m_exploc.src) return false; if (loc_range->m_range_display_kind == SHOW_RANGE_WITH_CARET) - if (caret.file != m_exploc.file) + if (caret.src != m_exploc.src) return false; /* Sanitize the caret location for non-primary ranges. */ @@ -1437,9 +1441,9 @@ layout::get_expanded_location (const line_span *line_span) const bool layout::validate_fixit_hint_p (const fixit_hint *hint) { - if (LOCATION_FILE (hint->get_start_loc ()) != m_exploc.file) + if (LOCATION_SRC (hint->get_start_loc ()) != m_exploc.src) return false; - if (LOCATION_FILE (hint->get_next_loc ()) != m_exploc.file) + if (LOCATION_SRC (hint->get_next_loc ()) != m_exploc.src) return false; return true; @@ -2102,7 +2106,7 @@ layout::print_leading_fixits (linenum_type row) gcc_assert (hint->insertion_p ()); - if (hint->affects_line_p (m_exploc.file, row)) + if (hint->affects_line_p (m_exploc.src, row)) { /* Printing the '+' with normal colorization and the inserted line with "insert" colorization @@ -2554,7 +2558,7 @@ layout::print_trailing_fixits (linenum_type row) if (hint->ends_with_newline_p ()) continue; - if (hint->affects_line_p (m_exploc.file, row)) + if (hint->affects_line_p (m_exploc.src, row)) corrections.add_hint (hint); } diff --git a/gcc/diagnostic.cc b/gcc/diagnostic.cc index c523f215bae..10a377ea209 100644 --- a/gcc/diagnostic.cc +++ b/gcc/diagnostic.cc @@ -798,13 +798,17 @@ diagnostic_report_current_module (diagnostic_context *context, location_t where) if (!includes_seen (context, map)) { bool first = true, need_inc = true, was_module = MAP_MODULE_P (map); - expanded_location s = {}; + const bool was_gen = ORDINARY_MAP_GENERATED_DATA_P (map); + expanded_location s; do { where = linemap_included_from (map); map = linemap_included_from_linemap (line_table, map); bool is_module = MAP_MODULE_P (map); - s.file = LINEMAP_FILE (map); + s.src = ORDINARY_MAP_SOURCE_ID (map); + s.file = (s.src.is_buffer () + ? special_fname_generated () + : s.src.get_filename_or_buffer ()); s.line = SOURCE_LINE (map, where); int col = -1; if (first && context->show_column) @@ -823,10 +827,13 @@ diagnostic_report_current_module (diagnostic_context *context, location_t where) N_("of module"), N_("In module imported at"), /* 6 */ N_("imported at"), + N_("In buffer generated from"), /* 8 */ }; - unsigned index = (was_module ? 6 : is_module ? 4 - : need_inc ? 2 : 0) + !first; + const unsigned index + = was_gen ? 8 + : ((was_module ? 6 : is_module ? 4 : need_inc ? 2 : 0) + + !first); pp_verbatim (context->printer, "%s%s %r%s%s%R", first ? "" : was_module ? ", " : ",\n", @@ -2691,11 +2698,9 @@ assert_location_text (const char *expected_loc_text, dc.column_origin = origin; expanded_location xloc; - xloc.file = filename; + xloc.src = xloc.file = filename; xloc.line = line; xloc.column = column; - xloc.data = NULL; - xloc.sysp = false; char *actual_loc_text = diagnostic_get_location_text (&dc, xloc); ASSERT_STREQ (expected_loc_text, actual_loc_text); diff --git a/gcc/edit-context.cc b/gcc/edit-context.cc index 6f5bc6b9d8f..15052aec417 100644 --- a/gcc/edit-context.cc +++ b/gcc/edit-context.cc @@ -295,7 +295,7 @@ edit_context::apply_fixit (const fixit_hint *hint) { expanded_location start = expand_location (hint->get_start_loc ()); expanded_location next_loc = expand_location (hint->get_next_loc ()); - if (start.file != next_loc.file) + if (start.src != next_loc.src || start.src.is_buffer ()) return false; if (start.line != next_loc.line) return false; diff --git a/gcc/input.cc b/gcc/input.cc index c1735215b29..c2559614a99 100644 --- a/gcc/input.cc +++ b/gcc/input.cc @@ -236,8 +236,6 @@ expand_location_1 (location_t loc, loc = LOCATION_LOCUS (loc); } - memset (&xloc, 0, sizeof (xloc)); - if (loc >= RESERVED_LOCATION_COUNT) { if (!expansion_point_p) @@ -288,7 +286,12 @@ expand_location_1 (location_t loc, xloc.data = block; if (loc <= BUILTINS_LOCATION) - xloc.file = loc == UNKNOWN_LOCATION ? NULL : special_fname_builtin (); + { + xloc.file = loc == UNKNOWN_LOCATION ? NULL : special_fname_builtin (); + xloc.src = xloc.file; + } + else if (xloc.src.is_buffer ()) + xloc.file = special_fname_generated (); return xloc; } @@ -323,11 +326,11 @@ diagnostic_file_cache_fini (void) equals the actual number of lines of the file. */ static size_t -total_lines_num (const char *file_path) +total_lines_num (source_id src) { size_t r = 0; location_t l = 0; - if (linemap_get_file_highest_location (line_table, file_path, &l)) + if (linemap_get_file_highest_location (line_table, src, &l)) { gcc_assert (l >= RESERVED_LOCATION_COUNT); expanded_location xloc = expand_location (l); @@ -990,9 +993,7 @@ get_source_text_between (location_t start, location_t end) /* If the locations are in different files or the end comes before the start, give up and return nothing. */ - if (!expstart.file || !expend.file) - return NULL; - if (strcmp (expstart.file, expend.file) != 0) + if (!expstart.src || expend.src != expstart.src) return NULL; if (expstart.line > expend.line) return NULL; @@ -1788,7 +1789,7 @@ get_substring_ranges_for_loc (cpp_reader *pfile, expanded_location finish = expand_location_to_spelling_point (src_range.m_finish, LOCATION_ASPECT_FINISH); - if (start.file != finish.file) + if (start.src != finish.src) return "range endpoints are in different files"; if (start.line != finish.line) return "range endpoints are on different lines"; @@ -1839,7 +1840,7 @@ get_substring_ranges_for_loc (cpp_reader *pfile, return "start and finish are spelled in different ordinary maps"; /* The file from linemap_resolve_location ought to match that from expand_location_to_spelling_point. */ - if (ORDINARY_MAP_SOURCE_ID (start_ord_map) != start.file) + if (ORDINARY_MAP_SOURCE_ID (start_ord_map) != start.src) return "mismatching file after resolving linemap"; location_t start_loc diff --git a/gcc/input.h b/gcc/input.h index 1b81a995f86..5c578f1a9de 100644 --- a/gcc/input.h +++ b/gcc/input.h @@ -175,6 +175,7 @@ extern location_t location_with_discriminator (location_t, int); extern bool has_discriminator (location_t); extern int get_discriminator_from_loc (location_t); +#define LOCATION_SRC(LOC) ((expand_location (LOC)).src) #define LOCATION_FILE(LOC) ((expand_location (LOC)).file) #define LOCATION_LINE(LOC) ((expand_location (LOC)).line) #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column) diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h index e59123b18c5..76617fe6129 100644 --- a/libcpp/include/line-map.h +++ b/libcpp/include/line-map.h @@ -1410,18 +1410,22 @@ linemap_location_before_p (class line_maps *set, typedef struct { - /* The name of the source file involved. */ - const char *file; + /* The file name of the location involved, or NULL if the location + is not in an external file. */ + const char *file = nullptr; - /* The line-location in the source file. */ - int line; - - int column; + /* A source_id recording the file name and/or the in-memory content, + as appropriate. Users that need to handle in-memory content need + to use this rather than FILE. */ + source_id src; - void *data; + /* The line-location in the source file. */ + int line = 0; + int column = 0; + void *data = nullptr; - /* In a system header?. */ - bool sysp; + /* In a system header? */ + bool sysp = false; } expanded_location; class range_label; @@ -2065,7 +2069,7 @@ class fixit_hint const char *new_content); ~fixit_hint () { free (m_bytes); } - bool affects_line_p (const char *file, int line) const; + bool affects_line_p (source_id src, int line) const; location_t get_start_loc () const { return m_start; } location_t get_next_loc () const { return m_next_loc; } bool maybe_append (location_t start, diff --git a/libcpp/line-map.cc b/libcpp/line-map.cc index e63916054e0..7704c60773b 100644 --- a/libcpp/line-map.cc +++ b/libcpp/line-map.cc @@ -1905,8 +1905,6 @@ linemap_expand_location (line_maps *set, { expanded_location xloc; - - memset (&xloc, 0, sizeof (xloc)); if (IS_ADHOC_LOC (loc)) { xloc.data = get_data_from_adhoc_loc (set, loc); @@ -1932,8 +1930,9 @@ linemap_expand_location (line_maps *set, abort (); const line_map_ordinary *ord_map = linemap_check_ordinary (map); - - xloc.file = LINEMAP_FILE (ord_map); + xloc.src = ORDINARY_MAP_SOURCE_ID (ord_map); + if (!xloc.src.is_buffer ()) + xloc.file = xloc.src.get_filename_or_buffer (); xloc.line = SOURCE_LINE (ord_map, loc); xloc.column = SOURCE_COLUMN (ord_map, loc); xloc.sysp = LINEMAP_SYSP (ord_map) != 0; @@ -2534,7 +2533,7 @@ rich_location::maybe_add_fixit (location_t start, = linemap_client_expand_location_to_spelling_point (next_loc, LOCATION_ASPECT_START); /* They must be within the same file... */ - if (exploc_start.file != exploc_next_loc.file) + if (exploc_start.src != exploc_next_loc.src) { stop_supporting_fixits (); return; @@ -2619,19 +2618,19 @@ fixit_hint::fixit_hint (location_t start, /* Does this fix-it hint affect the given line? */ bool -fixit_hint::affects_line_p (const char *file, int line) const +fixit_hint::affects_line_p (source_id src, int line) const { expanded_location exploc_start = linemap_client_expand_location_to_spelling_point (m_start, LOCATION_ASPECT_START); - if (file != exploc_start.file) + if (src != exploc_start.src) return false; if (line < exploc_start.line) return false; expanded_location exploc_next_loc = linemap_client_expand_location_to_spelling_point (m_next_loc, LOCATION_ASPECT_START); - if (file != exploc_next_loc.file) + if (src != exploc_next_loc.src) return false; if (line > exploc_next_loc.line) return false; From patchwork Wed Aug 9 22:14:09 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lewis Hyatt X-Patchwork-Id: 1819646 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=f0/HgQD2; dkim-atps=neutral Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RLkst0cfVz1yYl for ; Thu, 10 Aug 2023 08:16:17 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id BFE5D3853D3F for ; Wed, 9 Aug 2023 22:16:15 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org BFE5D3853D3F DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691619375; bh=E60u3LRKsghiRSqsI5YMOWLafr9q+EbJXGy7cEdZpaU=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=f0/HgQD2cAijZwhOISm5X9v7W+hbYlnVtox8wI+qbCGEwICPe/eeva/6aZUN/ChWA B5Z4M0TVGA2t5H1mnrmozLedKk2mzoAIcGxCbkRLsP1QzhlQy978/qWbnFbMreovUs pXKnA2xxyCWFRNjXNadEO0sWzJCLd3mZsMwBQMAk= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qk1-x72a.google.com (mail-qk1-x72a.google.com [IPv6:2607:f8b0:4864:20::72a]) by sourceware.org (Postfix) with ESMTPS id A4E4A3858D20 for ; Wed, 9 Aug 2023 22:14:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org A4E4A3858D20 Received: by mail-qk1-x72a.google.com with SMTP id af79cd13be357-7658430eb5dso26400085a.2 for ; Wed, 09 Aug 2023 15:14:50 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691619289; x=1692224089; 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=E60u3LRKsghiRSqsI5YMOWLafr9q+EbJXGy7cEdZpaU=; b=Uz+Q9sF7+5bHwzJjNhHSplMInpyS4xHL9YBRKD/+n/AUtAHyeCjbFVUVljudPo2klj ZJwJ2C7hR/2yN0E/EvO1MlAidpP9E3LCjnLdI/Jk19hcMzmQfaDHNiFgrFUDL2R+HeF6 I/1A7vlu2k5Egu+c/mbP+sQ1cq+Of5mGZb+26/JZjPokvn4tW4206vsuZ44Y+tPwzGUb KclgyXygI/fcWrJexbC/suzsAgT4ItsN9fBUWt3PsuuRCiRJgODd/AdId6ippqwvbI1y 4xxSwh38Nmc+5Ijpjwt5pMVNYQphfO73IkrcTHmumDrwPPAVYn1/SzoUvHWd0R8V+giR RjAQ== X-Gm-Message-State: AOJu0YzaUvMRHiazb/ahus0Guxlr32Hn5Zcnnyg6MlGOd61Qc/SzFPUr lvc+tvrdHiNrMlIaiaVELbb1oiXs2ak= X-Google-Smtp-Source: AGHT+IF3YD042ytwx6etbMiYJ7JsE79/FBoRT9SDqIjMhwUNEj2qxaXxFx7rstuXyg7zYPasdwg9qA== X-Received: by 2002:a05:620a:2942:b0:767:96e2:a9cb with SMTP id n2-20020a05620a294200b0076796e2a9cbmr424599qkp.38.1691619288501; Wed, 09 Aug 2023 15:14:48 -0700 (PDT) Received: from localhost.localdomain (96-67-140-173-static.hfc.comcastbusiness.net. [96.67.140.173]) by smtp.gmail.com with ESMTPSA id ce11-20020a05622a41cb00b0040fef71dc1esm46334qtb.10.2023.08.09.15.14.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Aug 2023 15:14:47 -0700 (PDT) To: gcc-patches@gcc.gnu.org Cc: David Malcolm , Lewis Hyatt Subject: [PATCH v4 3/8] diagnostics: Refactor class file_cache_slot Date: Wed, 9 Aug 2023 18:14:09 -0400 Message-Id: <20230809221414.2849878-4-lhyatt@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230809221414.2849878-1-lhyatt@gmail.com> References: <20230809221414.2849878-1-lhyatt@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3038.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lewis Hyatt via Gcc-patches From: Lewis Hyatt Reply-To: Lewis Hyatt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Class file_cache_slot in input.cc is used to query specific lines of source code from a file when needed by diagnostics infrastructure. This will be extended in a subsequent patch to support obtaining the source code from in-memory generated buffers rather than from a file. The present patch refactors class file_cache_slot, putting most of the logic into a new base class cache_data_source, in preparation for reusing that code in the next patch. There is no change in functionality yet. gcc/ChangeLog: * input.cc (class file_cache_slot): Refactor functionality into a new base class... (class cache_data_source): ...here. (file_cache::forcibly_evict_file): Adapt for refactoring. (file_cache_slot::evict): Renamed to... (file_cache_slot::reset): ...this, and partially refactored into base class... (cache_data_source::reset): ...here. (file_cache_slot::get_full_file_content): Moved into base class... (cache_data_source::get_full_file_content): ...here. (file_cache_slot::create): Adapt for refactoring. (file_cache_slot::file_cache_slot): Refactor partially into... (cache_data_source::cache_data_source): ...here. (file_cache_slot::~file_cache_slot): Refactor partially into... (cache_data_source::~cache_data_source): ...here. (file_cache_slot::needs_read_p): Remove. (file_cache_slot::needs_grow_p): Remove. (file_cache_slot::maybe_grow): Adapt for refactoring. (file_cache_slot::read_data): Refactored, along with... (file_cache_slot::maybe_read_data): this, into... (file_cache_slot::get_more_data): ...here. (find_end_of_line): Change interface to take a pair of pointers, rather than a pointer + length. (file_cache_slot::get_next_line): Refactored into... (cache_data_source::get_next_line): ...here. (file_cache_slot::goto_next_line): Refactored into... (cache_data_source::goto_next_line): ...here. (file_cache_slot::read_line_num): Refactored into... (cache_data_source::read_line_num): ...here. (location_get_source_line): Fix const-correctness as necessitated by new interface. --- gcc/input.cc | 513 +++++++++++++++++++++++---------------------------- 1 file changed, 235 insertions(+), 278 deletions(-) diff --git a/gcc/input.cc b/gcc/input.cc index c2559614a99..9377020b460 100644 --- a/gcc/input.cc +++ b/gcc/input.cc @@ -55,34 +55,88 @@ file_cache::initialize_input_context (diagnostic_input_charset_callback ccb, in_context.should_skip_bom = should_skip_bom; } -/* This is a cache used by get_next_line to store the content of a - file to be searched for file lines. */ -class file_cache_slot +/* This is an abstract interface for a class that provides data which we want to + look up by line number. Concrete implementations will follow, which handle + the cases of reading the data from the input source files, or of reading it + from in-memory generated data buffers. The design is driven with reading + from files in mind, in particular it is desirable to read only as much of a + file from disk as necessary. It works like a simplified std::istream, i.e. + virtual function calls are only needed when we need to retrieve more data + from the underlying source. */ + +class cache_data_source { -public: - file_cache_slot (); - ~file_cache_slot (); - bool read_line_num (size_t line_num, - char ** line, ssize_t *line_len); - - /* Accessors. */ - const char *get_file_path () const { return m_file_path; } +public: + bool read_line_num (size_t line_num, const char **line, ssize_t *line_len); unsigned get_use_count () const { return m_use_count; } + void inc_use_count () { m_use_count++; } + bool get_next_line (const char **line, ssize_t *line_len); + bool goto_next_line (); bool missing_trailing_newline_p () const { return m_missing_trailing_newline; } char_span get_full_file_content (); + bool unused () const { return !m_data_begin; } + virtual void reset (); + +protected: + cache_data_source (); + virtual ~cache_data_source (); + + /* These pointers delimit the data that we are processing. They are + maintained by the derived classes, we only ask for more by calling + get_more_data(). That function should return TRUE if more data was + obtained. Calling get_more_data () may invalidate these pointers + (i.e. reallocating them to a larger buffer). */ + const char *m_data_begin; + const char *m_data_end; + virtual bool get_more_data () = 0; + + /* This is to be called by the derived classes when this object is + being activated. */ + void on_create (unsigned int use_count, size_t total_lines) + { + m_use_count = use_count; + m_total_lines = total_lines; + } - void inc_use_count () { m_use_count++; } +private: + /* Non-copyable. */ + cache_data_source (const cache_data_source &) = delete; + cache_data_source& operator= (const cache_data_source &) = delete; - bool create (const file_cache::input_context &in_context, - const char *file_path, FILE *fp, unsigned highest_use_count); - void evict (); + /* The number of times this data has been accessed. This is used to designate + which entry to evict from the cache array when needed. */ + unsigned m_use_count; - private: - /* These are information used to store a line boundary. */ + /* Could this file be missing a trailing newline on its final line? + Initially true (to cope with empty files), set to true/false + as each line is read. */ + bool m_missing_trailing_newline; + + /* This is the total number of lines in the current data. At the + moment, we try to get this information from the line map + subsystem. Note that this is just a hint. When using the C++ + front-end, this hint is correct because the input file is then + completely tokenized before parsing starts; so the line map knows + the number of lines before compilation really starts. For e.g, + the C front-end, it can happen that we start emitting diagnostics + before the line map has seen the end of the file. */ + size_t m_total_lines; + + /* The number of the previous lines read. This starts at 1. Zero + means we've read no line so far. */ + size_t m_line_num; + + /* The index of the beginning of the current line. */ + size_t m_line_start_idx; + + /* These are information used to store a line boundary. Here and below, we + store always byte offsets, not pointers, since the underlying buffer may be + reallocated by the derived implementation unbeknownst to us after calling + get_more_data(). */ class line_info { public: @@ -90,13 +144,12 @@ public: size_t line_num; /* The position (byte count) of the beginning of the line, - relative to the file data pointer. This starts at zero. */ + relative to M_DATA_BEGIN. This starts at zero. */ size_t start_pos; - /* The position (byte count) of the last byte of the line. This - normally points to the '\n' character, or to one byte after the - last byte of the file, if the file doesn't contain a '\n' - character. */ + /* The position (byte count) of the last byte of the line. This normally + points to the '\n' character, or to M_DATA_END, if the data doesn't end + with a '\n' character. */ size_t end_pos; line_info (size_t l, size_t s, size_t e) @@ -104,91 +157,54 @@ public: {} line_info () - :line_num (0), start_pos (0), end_pos (0) + : line_num (0), start_pos (0), end_pos (0) {} }; - bool needs_read_p () const; - bool needs_grow_p () const; - void maybe_grow (); - bool read_data (); - bool maybe_read_data (); - bool get_next_line (char **line, ssize_t *line_len); - bool read_next_line (char ** line, ssize_t *line_len); - bool goto_next_line (); - - static const size_t buffer_size = 4 * 1024; - static const size_t line_record_size = 100; - - /* The number of time this file has been accessed. This is used - to designate which file cache to evict from the cache - array. */ - unsigned m_use_count; - - /* The file_path is the key for identifying a particular file in - the cache. - For libcpp-using code, the underlying buffer for this field is - owned by the corresponding _cpp_file within the cpp_reader. */ - const char *m_file_path; - - FILE *m_fp; - - /* This points to the content of the file that we've read so - far. */ - char *m_data; - - /* The allocated buffer to be freed may start a little earlier than DATA, - e.g. if a UTF8 BOM was skipped at the beginning. */ - int m_alloc_offset; - - /* The size of the DATA array above.*/ - size_t m_size; - - /* The number of bytes read from the underlying file so far. This - must be less (or equal) than SIZE above. */ - size_t m_nb_read; - - /* The index of the beginning of the current line. */ - size_t m_line_start_idx; - - /* The number of the previous line read. This starts at 1. Zero - means we've read no line so far. */ - size_t m_line_num; - - /* This is the total number of lines of the current file. At the - moment, we try to get this information from the line map - subsystem. Note that this is just a hint. When using the C++ - front-end, this hint is correct because the input file is then - completely tokenized before parsing starts; so the line map knows - the number of lines before compilation really starts. For e.g, - the C front-end, it can happen that we start emitting diagnostics - before the line map has seen the end of the file. */ - size_t m_total_lines; - - /* Could this file be missing a trailing newline on its final line? - Initially true (to cope with empty files), set to true/false - as each line is read. */ - bool m_missing_trailing_newline; - /* This is a record of the beginning and end of the lines we've seen while reading the file. This is useful to avoid walking the data from the beginning when we are asked to read a line that is - before LINE_START_IDX above. Note that the maximum size of this + before M_LINE_START_IDX. Note that the maximum size of this record is line_record_size, so that the memory consumption doesn't explode. We thus scale total_lines down to line_record_size. */ vec m_line_record; + static const size_t line_record_size = 100; +}; - void offset_buffer (int offset) - { - gcc_assert (offset < 0 ? m_alloc_offset + offset >= 0 - : (size_t) offset <= m_size); - gcc_assert (m_data); - m_alloc_offset += offset; - m_data += offset; - m_size -= offset; - } +/* This is the implementation of cache_data_source for ordinary + source files. */ +class file_cache_slot final : public cache_data_source +{ + +public: + file_cache_slot (); + ~file_cache_slot (); + + const char *get_file_path () const { return m_file_path; } + bool create (const file_cache::input_context &in_context, + const char *file_path, FILE *fp, unsigned highest_use_count); + void reset () override; + +protected: + bool get_more_data () override; +private: + /* The file_path is the key for identifying a particular file in the cache. + For libcpp-using code, the underlying buffer for this field is owned by the + corresponding _cpp_file within the cpp_reader. */ + const char *m_file_path; + + FILE *m_fp; + + /* The base class M_DATA_BEGIN and M_DATA_END delimit the bytes that are ready + to process. These two pointers here track a growable memory buffer, owned + by this object, where we store data as we read it from the file; we arrange + for the base class pointers to point to the right place within this + buffer. */ + char *m_buf_begin; + char *m_buf_end; + void maybe_grow (); }; /* Current position in real source file. */ @@ -391,26 +407,10 @@ file_cache::forcibly_evict_file (const char *file_path) /* Not found. */ return; - r->evict (); + r->reset (); } -void -file_cache_slot::evict () -{ - m_file_path = NULL; - if (m_fp) - fclose (m_fp); - m_fp = NULL; - m_nb_read = 0; - m_line_start_idx = 0; - m_line_num = 0; - m_line_record.truncate (0); - m_use_count = 0; - m_total_lines = 0; - m_missing_trailing_newline = true; -} - -/* Return the file cache that has been less used, recently, or the +/* Return the cache that has been less used, recently, or the first empty one. If HIGHEST_USE_COUNT is non-null, *HIGHEST_USE_COUNT is set to the highest use count of the entries in the cache table. */ @@ -473,14 +473,14 @@ file_cache::add_file (const char *file_path) as decoded according to the input charset, encoded as UTF-8. */ char_span -file_cache_slot::get_full_file_content () +cache_data_source::get_full_file_content () { - char *line; + const char *line; ssize_t line_len; while (get_next_line (&line, &line_len)) { } - return char_span (m_data, m_nb_read); + return char_span (m_data_begin, m_data_end - m_data_begin); } /* Populate this slot for use on FILE_PATH and FP, dropping any @@ -491,22 +491,12 @@ file_cache_slot::create (const file_cache::input_context &in_context, const char *file_path, FILE *fp, unsigned highest_use_count) { + reset (); + on_create (highest_use_count + 1, total_lines_num (source_id {file_path})); + m_data_begin = m_buf_begin; + m_data_end = m_buf_begin; m_file_path = file_path; - if (m_fp) - fclose (m_fp); m_fp = fp; - if (m_alloc_offset) - offset_buffer (-m_alloc_offset); - m_nb_read = 0; - m_line_start_idx = 0; - m_line_num = 0; - m_line_record.truncate (0); - /* Ensure that this cache entry doesn't get evicted next time - add_file_to_cache_tab is called. */ - m_use_count = ++highest_use_count; - m_total_lines = total_lines_num (file_path); - m_missing_trailing_newline = true; - /* Check the input configuration to determine if we need to do any transformations, such as charset conversion or BOM skipping. */ @@ -519,20 +509,17 @@ file_cache_slot::create (const file_cache::input_context &in_context, = cpp_get_converted_source (file_path, input_charset); if (!cs.data) return false; - if (m_data) - XDELETEVEC (m_data); - m_data = cs.data; - m_nb_read = m_size = cs.len; - m_alloc_offset = cs.data - cs.to_free; + XDELETEVEC (m_buf_begin); + m_buf_begin = cs.to_free; + m_buf_end = cs.data + cs.len; + m_data_begin = cs.data; + m_data_end = m_buf_end; } - else if (in_context.should_skip_bom) + else if (in_context.should_skip_bom && get_more_data ()) { - if (read_data ()) - { - const int offset = cpp_check_utf8_bom (m_data, m_nb_read); - offset_buffer (offset); - m_nb_read -= offset; - } + const int offset = cpp_check_utf8_bom (m_data_begin, + m_data_end - m_data_begin); + m_data_begin += offset; } return true; @@ -567,55 +554,60 @@ file_cache::lookup_or_add_file (const char *file_path) return r; } -/* Default constructor for a cache of file used by caret - diagnostic. */ - -file_cache_slot::file_cache_slot () -: m_use_count (0), m_file_path (NULL), m_fp (NULL), m_data (0), - m_alloc_offset (0), m_size (0), m_nb_read (0), m_line_start_idx (0), - m_line_num (0), m_total_lines (0), m_missing_trailing_newline (true) +cache_data_source::cache_data_source () +: m_data_begin (nullptr), m_data_end (nullptr), + m_use_count (0), + m_missing_trailing_newline (true), + m_total_lines (0), + m_line_num (0), + m_line_start_idx (0) { m_line_record.create (0); } -/* Destructor for a cache of file used by caret diagnostic. */ - -file_cache_slot::~file_cache_slot () +cache_data_source::~cache_data_source () { - if (m_fp) - { - fclose (m_fp); - m_fp = NULL; - } - if (m_data) - { - offset_buffer (-m_alloc_offset); - XDELETEVEC (m_data); - m_data = 0; - } m_line_record.release (); } -/* Returns TRUE iff the cache would need to be filled with data coming - from the file. That is, either the cache is empty or full or the - current line is empty. Note that if the cache is full, it would - need to be extended and filled again. */ - -bool -file_cache_slot::needs_read_p () const +void +cache_data_source::reset () { - return m_fp && (m_nb_read == 0 - || m_nb_read == m_size - || (m_line_start_idx >= m_nb_read - 1)); + m_data_begin = nullptr; + m_data_end = nullptr; + m_use_count = 0; + m_missing_trailing_newline = true; + m_total_lines = 0; + m_line_num = 0; + m_line_start_idx = 0; + m_line_record.truncate (0); } -/* Return TRUE iff the cache is full and thus needs to be - extended. */ +file_cache_slot::file_cache_slot () +: m_file_path (nullptr), m_fp (nullptr), + m_buf_begin (nullptr), m_buf_end (nullptr) +{} + +file_cache_slot::~file_cache_slot () +{ + if (m_fp) + fclose (m_fp); + XDELETEVEC (m_buf_begin); +} -bool -file_cache_slot::needs_grow_p () const +void +file_cache_slot::reset () { - return m_nb_read == m_size; + cache_data_source::reset (); + m_file_path = NULL; + if (m_fp) + { + fclose (m_fp); + m_fp = NULL; + } + + /* Do not free the buffer here, we intend to reuse it the next time this + slot is activated. */ } /* Grow the cache if it needs to be extended. */ @@ -623,22 +615,23 @@ file_cache_slot::needs_grow_p () const void file_cache_slot::maybe_grow () { - if (!needs_grow_p ()) - return; - - if (!m_data) + if (!m_buf_begin) { - gcc_assert (m_size == 0 && m_alloc_offset == 0); - m_size = buffer_size; - m_data = XNEWVEC (char, m_size); + const size_t buffer_size = 4 * 1024; + m_buf_begin = XNEWVEC (char, buffer_size); + m_buf_end = m_buf_begin + buffer_size; + m_data_begin = m_buf_begin; + m_data_end = m_data_begin; } - else + else if (m_data_end == m_buf_end) { - const int offset = m_alloc_offset; - offset_buffer (-offset); - m_size *= 2; - m_data = XRESIZEVEC (char, m_data, m_size); - offset_buffer (offset); + const auto new_size = 2 * (m_buf_end - m_buf_begin); + const auto data_offset = m_data_begin - m_buf_begin; + const auto data_size = m_data_end - m_data_begin; + m_buf_begin = XRESIZEVEC (char, m_buf_begin, new_size); + m_buf_end = m_buf_begin + new_size; + m_data_begin = m_buf_begin + data_offset; + m_data_end = m_data_begin + data_size; } } @@ -646,45 +639,28 @@ file_cache_slot::maybe_grow () Returns TRUE iff new data could be read. */ bool -file_cache_slot::read_data () +file_cache_slot::get_more_data () { - if (feof (m_fp) || ferror (m_fp)) + if (!m_fp || feof (m_fp) || ferror (m_fp)) return false; - maybe_grow (); - - char * from = m_data + m_nb_read; - size_t to_read = m_size - m_nb_read; - size_t nb_read = fread (from, 1, to_read, m_fp); - - if (ferror (m_fp)) - return false; - - m_nb_read += nb_read; - return !!nb_read; -} - -/* Read new data iff the cache needs to be filled with more data - coming from the file FP. Return TRUE iff the cache was filled with - mode data. */ - -bool -file_cache_slot::maybe_read_data () -{ - if (!needs_read_p ()) + char *const dest = m_buf_begin + (m_data_end - m_buf_begin); + const auto nb_read = fread (dest, 1, m_buf_end - dest, m_fp); + if (ferror (m_fp) || !nb_read) return false; - return read_data (); + m_data_end += nb_read; + return true; } -/* Helper function for file_cache_slot::get_next_line (), to find the end of +/* Helper function for cache_data_source::get_next_line (), to find the end of the next line. Returns with the memchr convention, i.e. nullptr if a line terminator was not found. We need to determine line endings in the same manner that libcpp does: any of \n, \r\n, or \r is a line ending. */ -static char * -find_end_of_line (char *s, size_t len) +static const char * +find_end_of_line (const char *s, const char *end) { - for (const auto end = s + len; s != end; ++s) + for (; s != end; ++s) { if (*s == '\n') return s; @@ -707,41 +683,38 @@ find_end_of_line (char *s, size_t len) return nullptr; } -/* Read a new line from file FP, using C as a cache for the data - coming from the file. Upon successful completion, *LINE is set to - the beginning of the line found. *LINE points directly in the - line cache and is only valid until the next call of get_next_line. - *LINE_LEN is set to the length of the line. Note that the line - does not contain any terminal delimiter. This function returns - true if some data was read or process from the cache, false - otherwise. Note that subsequent calls to get_next_line might - make the content of *LINE invalid. */ +/* Read a new line from the data source. Upon successful completion, *LINE is + set to the beginning of the line found. *LINE points directly in the line + cache and is only valid until the next call of get_next_line. *LINE_LEN is + set to the length of the line. Note that the line does not contain any + terminal delimiter. This function returns true if some data was read or + processed from the cache, false otherwise. Note that subsequent calls to + get_next_line might make the content of *LINE invalid. */ bool -file_cache_slot::get_next_line (char **line, ssize_t *line_len) +cache_data_source::get_next_line (const char **line, ssize_t *line_len) { - /* Fill the cache with data to process. */ - maybe_read_data (); + const char *line_start = m_data_begin + m_line_start_idx; - size_t remaining_size = m_nb_read - m_line_start_idx; - if (remaining_size == 0) - /* There is no more data to process. */ - return false; - - char *line_start = m_data + m_line_start_idx; + /* Check if we are all done reading the file. */ + if (line_start == m_data_end) + { + if (!get_more_data ()) + return false; + line_start = m_data_begin + m_line_start_idx; + } - char *next_line_start = NULL; - size_t len = 0; - char *line_end = find_end_of_line (line_start, remaining_size); + /* Find the end of the current line. */ + const char *next_line_start = NULL; + const char *line_end = find_end_of_line (line_start, m_data_end); if (line_end == NULL) { /* We haven't found an end-of-line delimiter in the cache. Fill the cache with more data from the file and look again. */ - while (maybe_read_data ()) + while (get_more_data ()) { - line_start = m_data + m_line_start_idx; - remaining_size = m_nb_read - m_line_start_idx; - line_end = find_end_of_line (line_start, remaining_size); + line_start = m_data_begin + m_line_start_idx; + line_end = find_end_of_line (line_start, m_data_end); if (line_end != NULL) { next_line_start = line_end + 1; @@ -758,8 +731,8 @@ file_cache_slot::get_next_line (char **line, ssize_t *line_len) If the file ends in a \r, we didn't identify it as a line terminator above, so do that now instead. */ - line_end = m_data + m_nb_read; - if (m_nb_read && line_end[-1] == '\r') + line_end = m_data_end; + if (line_end != m_data_begin && line_end[-1] == '\r') { --line_end; m_missing_trailing_newline = false; @@ -776,18 +749,11 @@ file_cache_slot::get_next_line (char **line, ssize_t *line_len) m_missing_trailing_newline = false; } - if (m_fp && ferror (m_fp)) - return false; - /* At this point, we've found the end of the of line. It either points to the line terminator or to one byte after the last byte of the file. */ - gcc_assert (line_end != NULL); - - len = line_end - line_start; - - if (m_line_start_idx < m_nb_read) - *line = line_start; - + const auto len = line_end - line_start; + *line = line_start; + *line_len = len; ++m_line_num; /* Before we update our line record, make sure the hint about the @@ -809,7 +775,7 @@ file_cache_slot::get_next_line (char **line, ssize_t *line_len) m_line_record.safe_push (file_cache_slot::line_info (m_line_num, m_line_start_idx, - line_end - m_data)); + line_end - m_data_begin)); else if (m_total_lines > line_record_size) { /* ... otherwise, we just scale total_lines down to @@ -820,23 +786,14 @@ file_cache_slot::get_next_line (char **line, ssize_t *line_len) m_line_record.safe_push (file_cache_slot::line_info (m_line_num, m_line_start_idx, - line_end - m_data)); + line_end - m_data_begin)); } } /* Update m_line_start_idx so that it points to the next line to be read. */ - if (next_line_start) - m_line_start_idx = next_line_start - m_data; - else - /* We didn't find any terminal '\n'. Let's consider that the end - of line is the end of the data in the cache. The next - invocation of get_next_line will either read more data from the - underlying file or return false early because we've reached the - end of the file. */ - m_line_start_idx = m_nb_read; - - *line_len = len; + m_line_start_idx + = (next_line_start ? next_line_start : m_data_end) - m_data_begin; return true; } @@ -848,15 +805,15 @@ file_cache_slot::get_next_line (char **line, ssize_t *line_len) completion. */ bool -file_cache_slot::goto_next_line () +cache_data_source::goto_next_line () { - char *l; + const char *l; ssize_t len; return get_next_line (&l, &len); } -/* Read an arbitrary line number LINE_NUM from the file cached in C. +/* Read an arbitrary line number LINE_NUM from the data cache. If the line was read successfully, *LINE points to the beginning of the line in the file cache and *LINE_LEN is the length of the line. *LINE is not nul-terminated, but may contain zero bytes. @@ -864,8 +821,8 @@ file_cache_slot::goto_next_line () This function returns bool if a line was read. */ bool -file_cache_slot::read_line_num (size_t line_num, - char ** line, ssize_t *line_len) +cache_data_source::read_line_num (size_t line_num, + const char ** line, ssize_t *line_len) { gcc_assert (line_num > 0); @@ -873,7 +830,7 @@ file_cache_slot::read_line_num (size_t line_num, { /* We've been asked to read lines that are before m_line_num. So lets use our line record (if it's not empty) to try to - avoid re-reading the file from the beginning again. */ + avoid re-scanning the data from the beginning again. */ if (m_line_record.is_empty ()) { @@ -882,7 +839,7 @@ file_cache_slot::read_line_num (size_t line_num, } else { - file_cache_slot::line_info *i = NULL; + line_info *i = NULL; if (m_total_lines <= line_record_size) { /* In languages where the input file is not totally @@ -918,7 +875,7 @@ file_cache_slot::read_line_num (size_t line_num, if (i && i->line_num == line_num) { /* We have the start/end of the line. */ - *line = m_data + i->start_pos; + *line = m_data_begin + i->start_pos; *line_len = i->end_pos - i->start_pos; return true; } @@ -957,7 +914,7 @@ file_cache_slot::read_line_num (size_t line_num, char_span location_get_source_line (const char *file_path, int line) { - char *buffer = NULL; + const char *buffer = NULL; ssize_t len; if (line == 0) From patchwork Wed Aug 9 22:14:10 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lewis Hyatt X-Patchwork-Id: 1819645 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=KWLZiXM0; dkim-atps=neutral Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RLksh2BXXz1yYl for ; Thu, 10 Aug 2023 08:16:08 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 3CC283854801 for ; Wed, 9 Aug 2023 22:16:06 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 3CC283854801 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691619366; bh=OuklhMdsl6Yx0ZdIcIAJtRoH4AC2hG9ic11rTVxcmdM=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=KWLZiXM0lgEdvWcCS38Vw4UoPKgX2YXYQvzInsytlpCziE8Wvdbwa7sMxKXvS/+rK ARxjN+0a+XTh3CQyTEjdpBYHKxOT1J5rDCQ+iBN2EDUpCB1ZgHffhBstu/OfUXH3go lHdxU53kn4SA6RIAnCGH21B3jgxXKRtwZyZ3dXPg= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qt1-x82d.google.com (mail-qt1-x82d.google.com [IPv6:2607:f8b0:4864:20::82d]) by sourceware.org (Postfix) with ESMTPS id 437003858291 for ; Wed, 9 Aug 2023 22:14:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 437003858291 Received: by mail-qt1-x82d.google.com with SMTP id d75a77b69052e-40e268fe7ddso1375241cf.3 for ; Wed, 09 Aug 2023 15:14:50 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691619289; x=1692224089; 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=OuklhMdsl6Yx0ZdIcIAJtRoH4AC2hG9ic11rTVxcmdM=; b=JgO+GPBtODcqp7+9sPa99QX0lGBoGci8h4xolXVC/7klcnEd8R9n/GJpR5yCH2rN9o 4ClosLNQwgbO7Iv+ZBZP0Db5gCEb1puOhpeDb/Le+zInSshPPIBNTT+AqJIxez2Unk0u L13Nz/VBrZf+isXWc9THKh3HhIw1a+EztZ1e0mFzjIO2HeQNKC4o/llU7vIO8s3NPnM4 Vyav+mL6fSrcWf7xFQlPK+iy2bd/XyHs7jaIWyvwdpCI4dKIHK12i+hw6mU7FNYv0zob wm09bGcZVgtl8uTvLtWetCs5UL3E2AbNB5azBxhZafKV7nFf8ECe2SzukaIBF55pnQP7 5Tpg== X-Gm-Message-State: AOJu0YyD3EYnV7YYLthnhNimEFE8YISrXhQLT5xGc6WhxKYaFRehqT09 qR8DsKNwGdnUfDR6QLYuEaFKM5Fnv3Q= X-Google-Smtp-Source: AGHT+IHyRTjNPbpfE5mxtvbM6+FPkMPjHblcwuQ2iWwB/7ln//b1XEITgdolJyd9+4VYOm+Abfk/kg== X-Received: by 2002:a05:622a:1116:b0:403:ef0f:2284 with SMTP id e22-20020a05622a111600b00403ef0f2284mr1029935qty.10.1691619289387; Wed, 09 Aug 2023 15:14:49 -0700 (PDT) Received: from localhost.localdomain (96-67-140-173-static.hfc.comcastbusiness.net. [96.67.140.173]) by smtp.gmail.com with ESMTPSA id ce11-20020a05622a41cb00b0040fef71dc1esm46334qtb.10.2023.08.09.15.14.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Aug 2023 15:14:48 -0700 (PDT) To: gcc-patches@gcc.gnu.org Cc: David Malcolm , Lewis Hyatt Subject: [PATCH v4 4/8] diagnostics: Support obtaining source code lines from generated data buffers Date: Wed, 9 Aug 2023 18:14:10 -0400 Message-Id: <20230809221414.2849878-5-lhyatt@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230809221414.2849878-1-lhyatt@gmail.com> References: <20230809221414.2849878-1-lhyatt@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3038.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lewis Hyatt via Gcc-patches From: Lewis Hyatt Reply-To: Lewis Hyatt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" This patch enhances location_get_source_line(), which is the primary interface provided by the diagnostics infrastructure to obtain the line of source code corresponding to a given location, so that it understands generated data locations in addition to normal file-based locations. This involves changing the argument to location_get_source_line() from a plain file name, to a source_id object that can represent either type of location. gcc/ChangeLog: * input.cc (class data_cache_slot): New class. (file_cache::lookup_data): New function. (diagnostics_file_cache_forcibly_evict_data): New function. (file_cache::forcibly_evict_data): New function. (file_cache::evicted_cache_tab_entry): Generalize (via a template) to work for both file_cache_slot and data_cache_slot. (file_cache::add_file): Adapt for new interface to evicted_cache_tab_entry. (file_cache::add_data): New function. (data_cache_slot::create): New function. (file_cache::file_cache): Support the new m_data_slots member. (file_cache::~file_cache): Likewise. (file_cache::lookup_or_add_data): New function. (file_cache::lookup_or_add): New function that calls either lookup_or_add_data or lookup_or_add_file as appropriate. (location_get_source_line): Change the FILE_PATH argument to a source_id SRC, and use it to support obtaining source lines from generated data as well as from files. (location_compute_display_column): Support generated data using the new features of location_get_source_line. (dump_location_info): Likewise. * input.h (location_get_source_line): Adjust prototype. Add a new convenience overload taking an expanded_location. (class cache_data_source): Declare. (class data_cache_slot): Declare. (class file_cache): Declare new members. (diagnostics_file_cache_forcibly_evict_data): Declare. --- gcc/input.cc | 171 ++++++++++++++++++++++++++++++++++++++++----------- gcc/input.h | 23 +++++-- 2 files changed, 153 insertions(+), 41 deletions(-) diff --git a/gcc/input.cc b/gcc/input.cc index 9377020b460..790279d4273 100644 --- a/gcc/input.cc +++ b/gcc/input.cc @@ -207,6 +207,28 @@ private: void maybe_grow (); }; +/* This is the implementation of cache_data_source for generated + data that is already in memory. */ +class data_cache_slot final : public cache_data_source +{ +public: + void create (const char *data, unsigned int data_len, + unsigned int highest_use_count); + bool represents_data (const char *data, unsigned int) const + { + /* We can just use pointer equality here since the generated data lives in + memory in one persistent place. It isn't anticipated there would be + several generated data buffers with the same content, so we don't mind + that in such a case we will store it twice. */ + return m_data_begin == data; + } + +protected: + /* In contrast to file_cache_slot, we do not own a buffer. The buffer + passed to create() needs to outlive this object. */ + bool get_more_data () override { return false; } +}; + /* Current position in real source file. */ location_t input_location = UNKNOWN_LOCATION; @@ -382,6 +404,21 @@ file_cache::lookup_file (const char *file_path) return r; } +data_cache_slot * +file_cache::lookup_data (const char *data, unsigned int data_len) +{ + for (unsigned int i = 0; i != num_file_slots; ++i) + { + const auto slot = m_data_slots + i; + if (slot->represents_data (data, data_len)) + { + slot->inc_use_count (); + return slot; + } + } + return nullptr; +} + /* Purge any mention of FILENAME from the cache of files used for printing source code. For use in selftests when working with tempfiles. */ @@ -397,6 +434,15 @@ diagnostics_file_cache_forcibly_evict_file (const char *file_path) global_dc->m_file_cache->forcibly_evict_file (file_path); } +void +diagnostics_file_cache_forcibly_evict_data (const char *data, + unsigned int data_len) +{ + if (!global_dc->m_file_cache) + return; + global_dc->m_file_cache->forcibly_evict_data (data, data_len); +} + void file_cache::forcibly_evict_file (const char *file_path) { @@ -410,36 +456,36 @@ file_cache::forcibly_evict_file (const char *file_path) r->reset (); } +void +file_cache::forcibly_evict_data (const char *data, unsigned int data_len) +{ + if (auto r = lookup_data (data, data_len)) + r->reset (); +} + /* Return the cache that has been less used, recently, or the first empty one. If HIGHEST_USE_COUNT is non-null, *HIGHEST_USE_COUNT is set to the highest use count of the entries in the cache table. */ -file_cache_slot* -file_cache::evicted_cache_tab_entry (unsigned *highest_use_count) +template +Slot * +file_cache::evicted_cache_tab_entry (Slot *slots, + unsigned int *highest_use_count) { - diagnostic_file_cache_init (); - - file_cache_slot *to_evict = &m_file_slots[0]; + auto to_evict = &slots[0]; unsigned huc = to_evict->get_use_count (); for (unsigned i = 1; i < num_file_slots; ++i) { - file_cache_slot *c = &m_file_slots[i]; - bool c_is_empty = (c->get_file_path () == NULL); - + auto c = &slots[i]; if (c->get_use_count () < to_evict->get_use_count () - || (to_evict->get_file_path () && c_is_empty)) + || (!to_evict->unused () && c->unused ())) /* We evict C because it's either an entry with a lower use count or one that is empty. */ to_evict = c; if (huc < c->get_use_count ()) huc = c->get_use_count (); - - if (c_is_empty) - /* We've reached the end of the cache; subsequent elements are - all empty. */ - break; } if (highest_use_count) @@ -463,12 +509,23 @@ file_cache::add_file (const char *file_path) return NULL; unsigned highest_use_count = 0; - file_cache_slot *r = evicted_cache_tab_entry (&highest_use_count); + file_cache_slot *r = evicted_cache_tab_entry (m_file_slots, + &highest_use_count); if (!r->create (in_context, file_path, fp, highest_use_count)) return NULL; return r; } +data_cache_slot * +file_cache::add_data (const char *data, unsigned int data_len) +{ + unsigned int highest_use_count = 0; + data_cache_slot *r = evicted_cache_tab_entry (m_data_slots, + &highest_use_count); + r->create (data, data_len, highest_use_count); + return r; +} + /* Get a borrowed char_span to the full content of this file as decoded according to the input charset, encoded as UTF-8. */ @@ -525,10 +582,22 @@ file_cache_slot::create (const file_cache::input_context &in_context, return true; } +void +data_cache_slot::create (const char *data, unsigned int data_len, + unsigned int highest_use_count) +{ + reset (); + on_create (highest_use_count + 1, + total_lines_num (source_id {data, data_len})); + m_data_begin = data; + m_data_end = data + data_len; +} + /* file_cache's ctor. */ file_cache::file_cache () -: m_file_slots (new file_cache_slot[num_file_slots]) + : m_file_slots (new file_cache_slot[num_file_slots]), + m_data_slots (new data_cache_slot[num_file_slots]) { initialize_input_context (nullptr, false); } @@ -537,6 +606,7 @@ file_cache::file_cache () file_cache::~file_cache () { + delete[] m_data_slots; delete[] m_file_slots; } @@ -554,6 +624,24 @@ file_cache::lookup_or_add_file (const char *file_path) return r; } +data_cache_slot * +file_cache::lookup_or_add_data (const char *data, unsigned int data_len) +{ + data_cache_slot *r = lookup_data (data, data_len); + if (!r) + r = add_data (data, data_len); + return r; +} + +cache_data_source * +file_cache::lookup_or_add (source_id src) +{ + if (src.is_buffer ()) + return lookup_or_add_data (src.get_filename_or_buffer (), + src.get_buffer_len ()); + return src ? lookup_or_add_file (src.get_filename_or_buffer ()) : nullptr; +} + cache_data_source::cache_data_source () : m_data_begin (nullptr), m_data_end (nullptr), m_use_count (0), @@ -912,26 +1000,22 @@ cache_data_source::read_line_num (size_t line_num, If the function fails, a NULL char_span is returned. */ char_span -location_get_source_line (const char *file_path, int line) +location_get_source_line (source_id src, int line) { - const char *buffer = NULL; - ssize_t len; - - if (line == 0) - return char_span (NULL, 0); - - if (file_path == NULL) - return char_span (NULL, 0); + const char_span fail (nullptr, 0); + if (!src || line <= 0) + return fail; diagnostic_file_cache_init (); + const auto c = global_dc->m_file_cache->lookup_or_add (src); + if (!c) + return fail; - file_cache_slot *c = global_dc->m_file_cache->lookup_or_add_file (file_path); - if (c == NULL) - return char_span (NULL, 0); - + const char *buffer = NULL; + ssize_t len; bool read = c->read_line_num (line, &buffer, &len); if (!read) - return char_span (NULL, 0); + return fail; return char_span (buffer, len); } @@ -1193,9 +1277,9 @@ int location_compute_display_column (expanded_location exploc, const cpp_char_column_policy &policy) { - if (!(exploc.file && *exploc.file && exploc.line && exploc.column)) + if (!(exploc.src && exploc.line && exploc.column)) return exploc.column; - char_span line = location_get_source_line (exploc.file, exploc.line); + char_span line = location_get_source_line (exploc); /* If line is NULL, this function returns exploc.column which is the desired fallback. */ return cpp_byte_column_to_display_column (line.get_buffer (), line.length (), @@ -1425,13 +1509,26 @@ dump_location_info (FILE *stream) { /* Beginning of a new source line: draw the line. */ - char_span line_text = location_get_source_line (exploc.file, - exploc.line); + char_span line_text = location_get_source_line (exploc); if (!line_text) break; + + const char *fn1, *fn2; + if (exploc.src.is_buffer ()) + { + fn1 = ORDINARY_MAP_CONTAINING_FILE_NAME (line_table, map); + fn2 = special_fname_generated (); + } + else + { + fn1 = exploc.file; + fn2 = ""; + } + fprintf (stream, - "%s:%3i|loc:%5i|%.*s\n", - exploc.file, exploc.line, + "%s%s:%3i|loc:%5i|%.*s\n", + fn1, fn2, + exploc.line, loc, (int)line_text.length (), line_text.get_buffer ()); @@ -1450,7 +1547,7 @@ dump_location_info (FILE *stream) if (len_loc < 5) len_loc = 5; - int indent = 6 + strlen (exploc.file) + len_lnum + len_loc; + int indent = 6 + strlen (fn1) + strlen (fn2) + len_lnum + len_loc; /* Thousands. */ if (end_location > 999) diff --git a/gcc/input.h b/gcc/input.h index 5c578f1a9de..d30673f1089 100644 --- a/gcc/input.h +++ b/gcc/input.h @@ -114,15 +114,21 @@ class char_span size_t m_n_elts; }; -extern char_span location_get_source_line (const char *file_path, int line); +extern char_span location_get_source_line (source_id src, int line); +inline char_span location_get_source_line (expanded_location exploc) +{ + return location_get_source_line (exploc.src, exploc.line); +} extern char *get_source_text_between (location_t, location_t); extern char_span get_source_file_content (const char *file_path); extern bool location_missing_trailing_newline (const char *file_path); -/* Forward decl of slot within file_cache, so that the definition doesn't +/* Forward decl of slots within file_cache, so that the definition doesn't need to be in this header. */ +class cache_data_source; class file_cache_slot; +class data_cache_slot; /* A cache of source files for use when emitting diagnostics (and in a few places in the C/C++ frontends). @@ -140,7 +146,10 @@ class file_cache ~file_cache (); file_cache_slot *lookup_or_add_file (const char *file_path); + data_cache_slot *lookup_or_add_data (const char *data, unsigned int data_len); + cache_data_source *lookup_or_add (source_id src); void forcibly_evict_file (const char *file_path); + void forcibly_evict_data (const char *data, unsigned int data_len); /* See comments in diagnostic.h about the input conversion context. */ struct input_context @@ -152,13 +161,17 @@ class file_cache bool should_skip_bom); private: - file_cache_slot *evicted_cache_tab_entry (unsigned *highest_use_count); + template + Slot *evicted_cache_tab_entry (Slot *slots, unsigned int *highest_use_count); + file_cache_slot *add_file (const char *file_path); + data_cache_slot *add_data (const char *data, unsigned int data_len); file_cache_slot *lookup_file (const char *file_path); + data_cache_slot *lookup_data (const char *data, unsigned int data_len); - private: static const size_t num_file_slots = 16; file_cache_slot *m_file_slots; + data_cache_slot *m_data_slots; input_context in_context; }; @@ -256,6 +269,8 @@ void dump_location_info (FILE *stream); void diagnostics_file_cache_fini (void); void diagnostics_file_cache_forcibly_evict_file (const char *file_path); +void diagnostics_file_cache_forcibly_evict_data (const char *data, + unsigned int data_len); class GTY(()) string_concat { From patchwork Wed Aug 9 22:14:11 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lewis Hyatt X-Patchwork-Id: 1819647 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=woPgJv92; dkim-atps=neutral Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RLkt42YCdz1yYl for ; Thu, 10 Aug 2023 08:16:28 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id ECAE0385E006 for ; Wed, 9 Aug 2023 22:16:25 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org ECAE0385E006 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691619386; bh=lMUe3/65p3quauYd9WJZITCAaH0G2x9jZGY7HT5soqI=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=woPgJv924zGO6iAspMUaMZutBsJ2jI6wmepr9g0iTfy+IWhyBFLF7LC8kZ8zn7VnX 7aEweZVeiIgIyV6wAiAlxmGzROzVNHmdbBoFY4R8Ul63jMzXqdXhUxlZQjZFlAiDvC myQdr9R2pgPjI7MihmuWJsTESTxOfifqf/heVMew= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qk1-x72c.google.com (mail-qk1-x72c.google.com [IPv6:2607:f8b0:4864:20::72c]) by sourceware.org (Postfix) with ESMTPS id 0A9F03857BA4 for ; Wed, 9 Aug 2023 22:14:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 0A9F03857BA4 Received: by mail-qk1-x72c.google.com with SMTP id af79cd13be357-765ae938b1bso23389485a.0 for ; Wed, 09 Aug 2023 15:14:51 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691619290; x=1692224090; 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=lMUe3/65p3quauYd9WJZITCAaH0G2x9jZGY7HT5soqI=; b=KeMyHvmCzXEONd+4g4riO5WXtFUyWixL6JRtovSTf0v2TELz3/PykT0OFej0HAm4vj bbgNEz3GVicJm4QHO/auqqP1XOsNZJUxiGe0Hu+fezAmL9rtAEYG6AjefvnxSwWGf2AE Xa1qiwmJYMXHhWBM8PArMYbEBL9ZTJhM5E0TwZURi9xQ1Rw94Wd7oJeSpIq28MeoukIY rGaIfcok5LhH2CkZuBiWfIUMLu84CTiXBSDMhe7joj3xvE/MYCJZH3F1f/2cthBp5Rmk yOR0O1jQISa+b9a6yZaq1FJfrDlt29VOsDygD8VDMYRMOBGEQJAKtlqkRPFGL9nNiPgh 63nA== X-Gm-Message-State: AOJu0Yxhjy/OJoF2zir62QaPsN4FhF1UM2Z5x8hULIv5xPwVcMvRxYKi rpR05U/m/ptTAkCVPICUAZ+OVvItu1E= X-Google-Smtp-Source: AGHT+IGd7R1/81+ZfaWe652ECM7S+dMMkbvAntBmiMl2Dviuv+Yxi4rB7gJ0S9IpZRbIUV3dAmGzgw== X-Received: by 2002:a05:622a:134e:b0:405:433f:5e5c with SMTP id w14-20020a05622a134e00b00405433f5e5cmr796099qtk.36.1691619290194; Wed, 09 Aug 2023 15:14:50 -0700 (PDT) Received: from localhost.localdomain (96-67-140-173-static.hfc.comcastbusiness.net. [96.67.140.173]) by smtp.gmail.com with ESMTPSA id ce11-20020a05622a41cb00b0040fef71dc1esm46334qtb.10.2023.08.09.15.14.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Aug 2023 15:14:49 -0700 (PDT) To: gcc-patches@gcc.gnu.org Cc: David Malcolm , Lewis Hyatt Subject: [PATCH v4 5/8] diagnostics: Support testing generated data in input.cc selftests Date: Wed, 9 Aug 2023 18:14:11 -0400 Message-Id: <20230809221414.2849878-6-lhyatt@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230809221414.2849878-1-lhyatt@gmail.com> References: <20230809221414.2849878-1-lhyatt@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3038.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lewis Hyatt via Gcc-patches From: Lewis Hyatt Reply-To: Lewis Hyatt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Add selftests for the new capabilities in input.cc related to source code locations that are stored in memory rather than ordinary files. gcc/ChangeLog: * input.cc (temp_source_file::do_linemap_add): New function. (line_table_case::line_table_case): Add GENERATED_DATA argument. (line_table_test::line_table_test): Implement new M_GENERATED_DATA argument. (for_each_line_table_case): Optionally include generated data locations in the set of cases. (test_accessing_ordinary_linemaps): Test generated data locations. (test_make_location_nonpure_range_endpoints): Likewise. (test_line_offset_overflow): Likewise. (input_cc_tests): Likewise. * selftest.cc (named_temp_file::named_temp_file): Interpret a null SUFFIX argument as a request to use in-memory data. (named_temp_file::~named_temp_file): Support in-memory data. (temp_source_file::temp_source_file): Likewise. (temp_source_file::~temp_source_file): Likewise. * selftest.h (struct line_map_ordinary): Foward declare. (class named_temp_file): Add missing explicit to the constructor. (class temp_source_file): Add new members to support in-memory data. (class line_table_test): Likewise. (for_each_line_table_case): Adjust prototype. --- gcc/input.cc | 81 +++++++++++++++++++++++++++++++++---------------- gcc/selftest.cc | 53 +++++++++++++++++++++++++------- gcc/selftest.h | 19 ++++++++++-- 3 files changed, 113 insertions(+), 40 deletions(-) diff --git a/gcc/input.cc b/gcc/input.cc index 790279d4273..8c4e40aaf23 100644 --- a/gcc/input.cc +++ b/gcc/input.cc @@ -2066,6 +2066,20 @@ get_num_source_ranges_for_substring (cpp_reader *pfile, /* Selftests of location handling. */ +/* Wrapper around linemap_add to handle transparently adding either a tmp file, + or in-memory generated content. */ +const line_map_ordinary * +temp_source_file::do_linemap_add (int line) +{ + const line_map *map; + if (content_buf) + map = linemap_add (line_table, LC_GEN, false, content_buf, + line, content_len); + else + map = linemap_add (line_table, LC_ENTER, false, get_filename (), line); + return linemap_check_ordinary (map); +} + /* Verify that compare() on linenum_type handles comparisons over the full range of the type. */ @@ -2144,13 +2158,16 @@ assert_loceq (const char *exp_filename, int exp_linenum, int exp_colnum, class line_table_case { public: - line_table_case (int default_range_bits, int base_location) + line_table_case (int default_range_bits, int base_location, + bool generated_data) : m_default_range_bits (default_range_bits), - m_base_location (base_location) + m_base_location (base_location), + m_generated_data (generated_data) {} int m_default_range_bits; int m_base_location; + bool m_generated_data; }; /* Constructor. Store the old value of line_table, and create a new @@ -2167,6 +2184,7 @@ line_table_test::line_table_test () gcc_assert (saved_line_table->round_alloc_size); line_table->round_alloc_size = saved_line_table->round_alloc_size; line_table->default_range_bits = 0; + m_generated_data = false; } /* Constructor. Store the old value of line_table, and create a new @@ -2188,6 +2206,7 @@ line_table_test::line_table_test (const line_table_case &case_) line_table->highest_location = case_.m_base_location; line_table->highest_line = case_.m_base_location; } + m_generated_data = case_.m_generated_data; } /* Destructor. Restore the old value of line_table. */ @@ -2207,7 +2226,10 @@ test_accessing_ordinary_linemaps (const line_table_case &case_) line_table_test ltt (case_); /* Build a simple linemap describing some locations. */ - linemap_add (line_table, LC_ENTER, false, "foo.c", 0); + if (ltt.m_generated_data) + linemap_add (line_table, LC_GEN, false, "some data", 0, 10); + else + linemap_add (line_table, LC_ENTER, false, "foo.c", 0); linemap_line_start (line_table, 1, 100); location_t loc_a = linemap_position_for_column (line_table, 1); @@ -2257,21 +2279,23 @@ test_accessing_ordinary_linemaps (const line_table_case &case_) linemap_add (line_table, LC_LEAVE, false, NULL, 0); /* Verify that we can recover the location info. */ - assert_loceq ("foo.c", 1, 1, loc_a); - assert_loceq ("foo.c", 1, 23, loc_b); - assert_loceq ("foo.c", 2, 1, loc_c); - assert_loceq ("foo.c", 2, 17, loc_d); - assert_loceq ("foo.c", 3, 700, loc_e); - assert_loceq ("foo.c", 4, 100, loc_back_to_short); + const auto fname + = (ltt.m_generated_data ? special_fname_generated () : "foo.c"); + assert_loceq (fname, 1, 1, loc_a); + assert_loceq (fname, 1, 23, loc_b); + assert_loceq (fname, 2, 1, loc_c); + assert_loceq (fname, 2, 17, loc_d); + assert_loceq (fname, 3, 700, loc_e); + assert_loceq (fname, 4, 100, loc_back_to_short); /* In the very wide line, the initial location should be fully tracked. */ - assert_loceq ("foo.c", 5, 2000, loc_start_of_very_long_line); + assert_loceq (fname, 5, 2000, loc_start_of_very_long_line); /* ...but once we exceed LINE_MAP_MAX_COLUMN_NUMBER column-tracking should be disabled. */ - assert_loceq ("foo.c", 5, 0, loc_too_wide); - assert_loceq ("foo.c", 5, 0, loc_too_wide_2); + assert_loceq (fname, 5, 0, loc_too_wide); + assert_loceq (fname, 5, 0, loc_too_wide_2); /*...and column-tracking should be re-enabled for subsequent lines. */ - assert_loceq ("foo.c", 6, 10, loc_sane_again); + assert_loceq (fname, 6, 10, loc_sane_again); assert_loceq ("bar.c", 1, 150, loc_f); @@ -2318,10 +2342,11 @@ test_make_location_nonpure_range_endpoints (const line_table_case &case_) with C++ frontend. ....................0000000001111111111222. ....................1234567890123456789012. */ - const char *content = " r += !aaa == bbb;\n"; - temp_source_file tmp (SELFTEST_LOCATION, ".C", content); line_table_test ltt (case_); - linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1); + const char *content = " r += !aaa == bbb;\n"; + temp_source_file tmp (SELFTEST_LOCATION, ".C", content, strlen (content), + ltt.m_generated_data); + tmp.do_linemap_add (1); const location_t c11 = linemap_position_for_column (line_table, 11); const location_t c12 = linemap_position_for_column (line_table, 12); @@ -3978,7 +4003,8 @@ static const location_t boundary_locations[] = { /* Run TESTCASE multiple times, once for each case in our test matrix. */ void -for_each_line_table_case (void (*testcase) (const line_table_case &)) +for_each_line_table_case (void (*testcase) (const line_table_case &), + bool test_generated_data) { /* As noted above in the description of struct line_table_case, we want to explore a test matrix of interesting line_table @@ -3997,16 +4023,19 @@ for_each_line_table_case (void (*testcase) (const line_table_case &)) const int num_boundary_locations = ARRAY_SIZE (boundary_locations); for (int loc_idx = 0; loc_idx < num_boundary_locations; loc_idx++) { - line_table_case c (default_range_bits, boundary_locations[loc_idx]); - - testcase (c); - - num_cases_tested++; + /* ...and try both normal files, and internally generated data. */ + for (int gen = 0; gen != 1+test_generated_data; ++gen) + { + line_table_case c (default_range_bits, + boundary_locations[loc_idx], gen); + testcase (c); + num_cases_tested++; + } } } /* Verify that we fully covered the test matrix. */ - ASSERT_EQ (num_cases_tested, 2 * 12); + ASSERT_EQ (num_cases_tested, 2 * 12 * (1+test_generated_data)); } /* Verify that when presented with a consecutive pair of locations with @@ -4017,7 +4046,7 @@ for_each_line_table_case (void (*testcase) (const line_table_case &)) static void test_line_offset_overflow () { - line_table_test ltt (line_table_case (5, 0)); + line_table_test ltt (line_table_case (5, 0, false)); linemap_add (line_table, LC_ENTER, false, "foo.c", 0); linemap_line_start (line_table, 1, 100); @@ -4257,9 +4286,9 @@ input_cc_tests () test_should_have_column_data_p (); test_unknown_location (); test_builtins (); - for_each_line_table_case (test_make_location_nonpure_range_endpoints); + for_each_line_table_case (test_make_location_nonpure_range_endpoints, true); - for_each_line_table_case (test_accessing_ordinary_linemaps); + for_each_line_table_case (test_accessing_ordinary_linemaps, true); for_each_line_table_case (test_lexer); for_each_line_table_case (test_lexer_string_locations_simple); for_each_line_table_case (test_lexer_string_locations_ebcdic); diff --git a/gcc/selftest.cc b/gcc/selftest.cc index 20c10bbd055..7126b9901dd 100644 --- a/gcc/selftest.cc +++ b/gcc/selftest.cc @@ -163,14 +163,21 @@ assert_str_startswith (const location &loc, named_temp_file::named_temp_file (const char *suffix) { - m_filename = make_temp_file (suffix); - ASSERT_NE (m_filename, NULL); + if (suffix) + { + m_filename = make_temp_file (suffix); + ASSERT_NE (m_filename, NULL); + } + else + m_filename = nullptr; } /* Destructor. Delete the tempfile. */ named_temp_file::~named_temp_file () { + if (!m_filename) + return; unlink (m_filename); diagnostics_file_cache_forcibly_evict_file (m_filename); free (m_filename); @@ -183,7 +190,9 @@ named_temp_file::~named_temp_file () temp_source_file::temp_source_file (const location &loc, const char *suffix, const char *content) -: named_temp_file (suffix) +: named_temp_file (suffix), + content_buf (nullptr), + content_len (0) { FILE *out = fopen (get_filename (), "w"); if (!out) @@ -192,19 +201,41 @@ temp_source_file::temp_source_file (const location &loc, fclose (out); } -/* As above, but with a size, to allow for NUL bytes in CONTENT. */ +/* As above, but with a size, to allow for NUL bytes in CONTENT. When + IS_GENERATED==true, the data is kept in memory instead, for testing LC_GEN + maps. */ temp_source_file::temp_source_file (const location &loc, const char *suffix, const char *content, - size_t sz) -: named_temp_file (suffix) + size_t sz, + bool is_generated) +: named_temp_file (is_generated ? nullptr : suffix), + content_buf (is_generated ? XNEWVEC (char, sz) : nullptr), + content_len (is_generated ? sz : 0) { - FILE *out = fopen (get_filename (), "w"); - if (!out) - fail_formatted (loc, "unable to open tempfile: %s", get_filename ()); - fwrite (content, sz, 1, out); - fclose (out); + if (is_generated) + { + gcc_assert (sz); /* Empty generated content is not supported. */ + memcpy (content_buf, content, sz); + } + else + { + FILE *out = fopen (get_filename (), "w"); + if (!out) + fail_formatted (loc, "unable to open tempfile: %s", get_filename ()); + fwrite (content, sz, 1, out); + fclose (out); + } +} + +temp_source_file::~temp_source_file () +{ + if (content_buf) + { + diagnostics_file_cache_forcibly_evict_data (content_buf, content_len); + XDELETEVEC (content_buf); + } } /* Avoid introducing locale-specific differences in the results diff --git a/gcc/selftest.h b/gcc/selftest.h index 20d522afda4..ede3b008145 100644 --- a/gcc/selftest.h +++ b/gcc/selftest.h @@ -25,6 +25,8 @@ along with GCC; see the file COPYING3. If not see #if CHECKING_P +struct line_map_ordinary; + namespace selftest { /* A struct describing the source-location of a selftest, to make it @@ -96,7 +98,7 @@ extern void assert_str_startswith (const location &loc, class named_temp_file { public: - named_temp_file (const char *suffix); + explicit named_temp_file (const char *suffix); ~named_temp_file (); const char *get_filename () const { return m_filename; } @@ -113,7 +115,13 @@ class temp_source_file : public named_temp_file temp_source_file (const location &loc, const char *suffix, const char *content); temp_source_file (const location &loc, const char *suffix, - const char *content, size_t sz); + const char *content, size_t sz, + bool is_generated = false); + ~temp_source_file (); + + char *const content_buf; + const size_t content_len; + const line_map_ordinary *do_linemap_add (int line); /* In input.cc */ }; /* RAII-style class for avoiding introducing locale-specific differences @@ -171,6 +179,10 @@ class line_table_test /* Destructor. Restore the saved line_table. */ ~line_table_test (); + + /* When this is enabled in the line_table_case, test storing all the data + in memory rather than a file. */ + bool m_generated_data; }; /* Helper function for selftests that need a function decl. */ @@ -183,7 +195,8 @@ extern tree make_fndecl (tree return_type, /* Run TESTCASE multiple times, once for each case in our test matrix. */ extern void -for_each_line_table_case (void (*testcase) (const line_table_case &)); +for_each_line_table_case (void (*testcase) (const line_table_case &), + bool test_generated_data = false); /* Read the contents of PATH into memory, returning a 0-terminated buffer that must be freed by the caller. From patchwork Wed Aug 9 22:14:12 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lewis Hyatt X-Patchwork-Id: 1819648 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=ncYlcoNk; dkim-atps=neutral Received: from server2.sourceware.org (ip-8-43-85-97.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 (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RLktx35P0z1yYl for ; Thu, 10 Aug 2023 08:17:13 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5336F382DC67 for ; Wed, 9 Aug 2023 22:17:11 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5336F382DC67 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691619431; bh=0QNIxYvewQUfv0/Z/Yf49TEtMDdRWk6OsGg89QORLkg=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=ncYlcoNkZAYlc/ocByre81DerfkrDEbBOtAxXNlDqEa2lliiKLPSxdg+tI95D077F bNjaZvedXmVVBGK3CDiO0fJaMoOC4Xk1QgQ/xi0kaiqTVktTYvPIVUrtInmuc0SR7T JRn85XrOj7AIzyZtKnSEzO7NIos0VnRJ46ip3+dM= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by sourceware.org (Postfix) with ESMTPS id 0873B3857702 for ; Wed, 9 Aug 2023 22:14:52 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 0873B3857702 Received: by mail-qt1-x832.google.com with SMTP id d75a77b69052e-40f0b412b78so1442391cf.3 for ; Wed, 09 Aug 2023 15:14:52 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691619291; x=1692224091; 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=0QNIxYvewQUfv0/Z/Yf49TEtMDdRWk6OsGg89QORLkg=; b=Yfwrn1A7H5lt/fWe4GvXKobJ34N6nSryPRuWrCBYjgJcUVSS3R6QkGprDO77GWj23+ ISC68Z3CjhAWGGqzmboozLHR+DKYB8yRyM6f1LoHy6LpBozkcf7juri0j4BRTntVd9SM I5piE5+wH07Os9BBzqwMdkMXmLFgwmWkHdcdBkaF2V5Ei6XTp9TyA0WpkqdMSW4WRvHw nucg7M9YAMY3xKfb+GvDV6AIIbsrM6k1ZauPU+O9N/4D/J37Jbg83nm+/Rx6UtW9Rqvl KFU7e2sLNm1BLq3ibF1hQz20r+sI6Pfme+4re99+BV/2RFidKfvF5cPldVFfAINajrF0 ghYA== X-Gm-Message-State: AOJu0YwxihCLlamHLhrc9cV5RNZPf8hrm6At/yY3+DaY7hhBP0ux+5nL wLPs/LoD8D/aO09oQHPiij0IBwW3ZuE= X-Google-Smtp-Source: AGHT+IGFYSk3ZiG93h9mHbrbGR163s072SvbW99rucTTUFM8n/U4oi1JXXzPa+P7vpE4zYzyciM68Q== X-Received: by 2002:a05:622a:14cf:b0:400:97c6:b40b with SMTP id u15-20020a05622a14cf00b0040097c6b40bmr860409qtx.48.1691619291141; Wed, 09 Aug 2023 15:14:51 -0700 (PDT) Received: from localhost.localdomain (96-67-140-173-static.hfc.comcastbusiness.net. [96.67.140.173]) by smtp.gmail.com with ESMTPSA id ce11-20020a05622a41cb00b0040fef71dc1esm46334qtb.10.2023.08.09.15.14.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Aug 2023 15:14:50 -0700 (PDT) To: gcc-patches@gcc.gnu.org Cc: David Malcolm , Lewis Hyatt Subject: [PATCH v4 6/8] diagnostics: Full support for generated data locations Date: Wed, 9 Aug 2023 18:14:12 -0400 Message-Id: <20230809221414.2849878-7-lhyatt@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230809221414.2849878-1-lhyatt@gmail.com> References: <20230809221414.2849878-1-lhyatt@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3038.7 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_LOTSOFHASH, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lewis Hyatt via Gcc-patches From: Lewis Hyatt Reply-To: Lewis Hyatt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Previous patches in this series have laid the groundwork for supporting source code locations in memory ("generated data") rather than ordinary files. This patch completes the support by adding awareness of such locations to all places that need to support them. The main changes are to diagnostic-show-locus.cc; the others are primarily small tweaks such as changing from the FILE to the SRC member when inspecting an expanded_location. gcc/c-family/ChangeLog: * c-format.cc (get_corrected_substring): Use the new overload of location_get_source_line() to support generated data. * c-indentation.cc (get_visual_column): Likewise. (get_first_nws_vis_column): Change argument from a plain file name to a source_id. (detect_intervening_unindent): Likewise. (should_warn_for_misleading_indentation): Pass detect_intervening_unindent() the SRC field rather than the FILE field from the expanded_location. gcc/ChangeLog: * gcc-rich-location.cc (blank_line_before_p): Use the new overload of location_get_source_line() to support generated data. * input.cc (get_source_text_between): Likewise. (get_substring_ranges_for_loc): Likewise. (get_source_file_content): Change the argument from a plain filename to a source_id. (location_missing_trailing_newline): Likewise. * input.h (get_source_file_content): Adjust prototype. (location_missing_trailing_newline): Likewise. * diagnostic-show-locus.cc (layout::calculate_x_offset_display): Use the new overload of location_get_source_line() to support generated data. (layout::print_line): Likewise. (class line_corrections): Change m_filename from a plain filename to a source_id. (source_line::source_line): Change argument from a plain filename to a source_id. (line_corrections::add_hint): Adapt to source_line change. (layout::print_trailing_fixits): Adapt to line_corrections change. (test_layout_x_offset_display_utf8): Test generated data too. (test_layout_x_offset_display_tab): Likewise. (test_diagnostic_show_locus_one_liner): Likewise. (test_diagnostic_show_locus_one_liner_utf8): Likewise. (test_add_location_if_nearby): Likewise. (test_diagnostic_show_locus_fixit_lines): Likewise. (test_fixit_consolidation): Likewise. (test_overlapped_fixit_printing): Likewise. (test_overlapped_fixit_printing_utf8): Likewise. (test_overlapped_fixit_printing_2): Likewise. (test_fixit_insert_containing_newline): Likewise. (test_fixit_insert_containing_newline_2): Likewise. (test_fixit_replace_containing_newline): Likewise. (test_fixit_deletion_affecting_newline): Likewise. (test_tab_expansion): Likewise. (test_escaping_bytes_1): Likewise. (test_escaping_bytes_2): Likewise. (test_line_numbers_multiline_range): Likewise. (diagnostic_show_locus_cc_tests): Likewise. --- gcc/c-family/c-format.cc | 2 +- gcc/c-family/c-indentation.cc | 8 +- gcc/diagnostic-show-locus.cc | 227 ++++++++++++++++++---------------- gcc/gcc-rich-location.cc | 2 +- gcc/input.cc | 21 ++-- gcc/input.h | 6 +- 6 files changed, 136 insertions(+), 130 deletions(-) diff --git a/gcc/c-family/c-format.cc b/gcc/c-family/c-format.cc index 529b1408179..929ec24622c 100644 --- a/gcc/c-family/c-format.cc +++ b/gcc/c-family/c-format.cc @@ -4537,7 +4537,7 @@ get_corrected_substring (const substring_loc &fmt_loc, if (caret.column > finish.column) return NULL; - char_span line = location_get_source_line (start.file, start.line); + char_span line = location_get_source_line (start); if (!line) return NULL; diff --git a/gcc/c-family/c-indentation.cc b/gcc/c-family/c-indentation.cc index fce74991aae..27a90d9cc15 100644 --- a/gcc/c-family/c-indentation.cc +++ b/gcc/c-family/c-indentation.cc @@ -50,7 +50,7 @@ get_visual_column (expanded_location exploc, unsigned int *first_nws, unsigned int tab_width) { - char_span line = location_get_source_line (exploc.file, exploc.line); + char_span line = location_get_source_line (exploc); if (!line) return false; if ((size_t)exploc.column > line.length ()) @@ -87,7 +87,7 @@ get_visual_column (expanded_location exploc, Otherwise, return false, leaving *FIRST_NWS untouched. */ static bool -get_first_nws_vis_column (const char *file, int line_num, +get_first_nws_vis_column (source_id file, int line_num, unsigned int *first_nws, unsigned int tab_width) { @@ -158,7 +158,7 @@ get_first_nws_vis_column (const char *file, int line_num, Return true if such an unindent/outdent is detected. */ static bool -detect_intervening_unindent (const char *file, +detect_intervening_unindent (source_id file, int body_line, int next_stmt_line, unsigned int vis_column, @@ -528,7 +528,7 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo, /* Don't warn if there is an unindent between the two statements. */ int vis_column = MIN (next_stmt_vis_column, body_vis_column); - if (detect_intervening_unindent (body_exploc.file, body_exploc.line, + if (detect_intervening_unindent (body_exploc.src, body_exploc.line, next_stmt_exploc.line, vis_column, tab_width)) return false; diff --git a/gcc/diagnostic-show-locus.cc b/gcc/diagnostic-show-locus.cc index bf969ab6d6a..b75c272caae 100644 --- a/gcc/diagnostic-show-locus.cc +++ b/gcc/diagnostic-show-locus.cc @@ -1618,8 +1618,7 @@ layout::calculate_x_offset_display () return; } - const char_span line = location_get_source_line (m_exploc.file, - m_exploc.line); + const char_span line = location_get_source_line (m_exploc); if (!line) { /* Nothing to do, we couldn't find the source line. */ @@ -2407,16 +2406,15 @@ class line_corrections { public: line_corrections (const char_display_policy &policy, - const char *filename, - linenum_type row) - : m_policy (policy), m_filename (filename), m_row (row) + source_id src, linenum_type row) + : m_policy (policy), m_src (src), m_row (row) {} ~line_corrections (); void add_hint (const fixit_hint *hint); const char_display_policy &m_policy; - const char *m_filename; + source_id m_src; linenum_type m_row; auto_vec m_corrections; }; @@ -2437,7 +2435,7 @@ line_corrections::~line_corrections () class source_line { public: - source_line (const char *filename, int line); + source_line (source_id src, int line); char_span as_span () { return char_span (chars, width); } @@ -2447,9 +2445,9 @@ public: /* source_line's ctor. */ -source_line::source_line (const char *filename, int line) +source_line::source_line (source_id src, int line) { - char_span span = location_get_source_line (filename, line); + char_span span = location_get_source_line (src, line); chars = span.get_buffer (); width = span.length (); } @@ -2493,7 +2491,7 @@ line_corrections::add_hint (const fixit_hint *hint) affected_bytes.start - 1); /* Try to read the source. */ - source_line line (m_filename, m_row); + source_line line (m_src, m_row); if (line.chars && between.finish < line.width) { /* Consolidate into the last correction: @@ -2549,7 +2547,7 @@ layout::print_trailing_fixits (linenum_type row) { /* Build a list of correction instances for the line, potentially consolidating hints (for the sake of readability). */ - line_corrections corrections (m_policy, m_exploc.file, row); + line_corrections corrections (m_policy, m_exploc.src, row); for (unsigned int i = 0; i < m_fixit_hints.length (); i++) { const fixit_hint *hint = m_fixit_hints[i]; @@ -2787,7 +2785,7 @@ layout::show_ruler (int max_column) const void layout::print_line (linenum_type row) { - char_span line = location_get_source_line (m_exploc.file, row); + char_span line = location_get_source_line (m_exploc.src, row); if (!line) return; @@ -2996,10 +2994,10 @@ test_layout_x_offset_display_utf8 (const line_table_case &case_) no multibyte characters earlier on the line. */ const int emoji_col = 102; - temp_source_file tmp (SELFTEST_LOCATION, ".c", content); line_table_test ltt (case_); - - linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, 1 + line_bytes, + ltt.m_generated_data); + tmp.do_linemap_add (1); location_t line_end = linemap_position_for_column (line_table, line_bytes); @@ -3007,17 +3005,23 @@ test_layout_x_offset_display_utf8 (const line_table_case &case_) if (line_end > LINE_MAP_MAX_LOCATION_WITH_COLS) return; - ASSERT_STREQ (tmp.get_filename (), LOCATION_FILE (line_end)); + if (ltt.m_generated_data) + { + ASSERT_EQ (nullptr, tmp.get_filename ()); + ASSERT_STREQ (special_fname_generated (), LOCATION_FILE (line_end)); + } + else + ASSERT_STREQ (tmp.get_filename (), LOCATION_FILE (line_end)); ASSERT_EQ (1, LOCATION_LINE (line_end)); ASSERT_EQ (line_bytes, LOCATION_COLUMN (line_end)); - char_span lspan = location_get_source_line (tmp.get_filename (), 1); + const expanded_location xloc = expand_location (line_end); + char_span lspan = location_get_source_line (xloc); ASSERT_EQ (line_display_cols, cpp_display_width (lspan.get_buffer (), lspan.length (), def_policy ())); ASSERT_EQ (line_display_cols, - location_compute_display_column (expand_location (line_end), - def_policy ())); + location_compute_display_column (xloc, def_policy ())); ASSERT_EQ (0, memcmp (lspan.get_buffer () + (emoji_col - 1), "\xf0\x9f\x98\x82\xf0\x9f\x98\x82", 8)); @@ -3149,10 +3153,10 @@ test_layout_x_offset_display_tab (const line_table_case &case_) a space would have taken up. */ ASSERT_EQ (7, extra_width[10]); - temp_source_file tmp (SELFTEST_LOCATION, ".c", content); line_table_test ltt (case_); - - linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, line_bytes + 1, + ltt.m_generated_data); + tmp.do_linemap_add (1); location_t line_end = linemap_position_for_column (line_table, line_bytes); @@ -3161,7 +3165,8 @@ test_layout_x_offset_display_tab (const line_table_case &case_) return; /* Check that cpp_display_width handles the tabs as expected. */ - char_span lspan = location_get_source_line (tmp.get_filename (), 1); + const expanded_location xloc = expand_location (line_end); + char_span lspan = location_get_source_line (xloc); ASSERT_EQ ('\t', *(lspan.get_buffer () + (tab_col - 1))); for (int tabstop = 1; tabstop != num_tabstops; ++tabstop) { @@ -3170,8 +3175,7 @@ test_layout_x_offset_display_tab (const line_table_case &case_) cpp_display_width (lspan.get_buffer (), lspan.length (), policy)); ASSERT_EQ (line_bytes + extra_width[tabstop], - location_compute_display_column (expand_location (line_end), - policy)); + location_compute_display_column (xloc, policy)); } /* Check that the tab is expanded to the expected number of spaces. */ @@ -3795,10 +3799,10 @@ test_diagnostic_show_locus_one_liner (const line_table_case &case_) ....................0000000001111111. ....................1234567890123456. */ const char *content = "foo = bar.field;\n"; - temp_source_file tmp (SELFTEST_LOCATION, ".c", content); line_table_test ltt (case_); - - linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, strlen (content), + ltt.m_generated_data); + tmp.do_linemap_add (1); location_t line_end = linemap_position_for_column (line_table, 16); @@ -3806,7 +3810,14 @@ test_diagnostic_show_locus_one_liner (const line_table_case &case_) if (line_end > LINE_MAP_MAX_LOCATION_WITH_COLS) return; - ASSERT_STREQ (tmp.get_filename (), LOCATION_FILE (line_end)); + if (ltt.m_generated_data) + { + ASSERT_EQ (nullptr, tmp.get_filename ()); + ASSERT_STREQ (special_fname_generated (), LOCATION_FILE (line_end)); + } + else + ASSERT_STREQ (tmp.get_filename (), LOCATION_FILE (line_end)); + ASSERT_EQ (1, LOCATION_LINE (line_end)); ASSERT_EQ (16, LOCATION_COLUMN (line_end)); @@ -4377,10 +4388,10 @@ test_diagnostic_show_locus_one_liner_utf8 (const line_table_case &case_) /* 0000000000000000000001111111111111111111222222222222222222222233333 1111222233334444567890122223333456789999000011112222345678999900001 Byte columns. */ - temp_source_file tmp (SELFTEST_LOCATION, ".c", content); line_table_test ltt (case_); - - linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, strlen (content), + ltt.m_generated_data); + tmp.do_linemap_add (1); location_t line_end = linemap_position_for_column (line_table, 31); @@ -4388,11 +4399,18 @@ test_diagnostic_show_locus_one_liner_utf8 (const line_table_case &case_) if (line_end > LINE_MAP_MAX_LOCATION_WITH_COLS) return; - ASSERT_STREQ (tmp.get_filename (), LOCATION_FILE (line_end)); + if (ltt.m_generated_data) + { + ASSERT_EQ (nullptr, tmp.get_filename ()); + ASSERT_STREQ (special_fname_generated (), LOCATION_FILE (line_end)); + } + else + ASSERT_STREQ (tmp.get_filename (), LOCATION_FILE (line_end)); + ASSERT_EQ (1, LOCATION_LINE (line_end)); ASSERT_EQ (31, LOCATION_COLUMN (line_end)); - char_span lspan = location_get_source_line (tmp.get_filename (), 1); + char_span lspan = location_get_source_line (expand_location (line_end)); ASSERT_EQ (25, cpp_display_width (lspan.get_buffer (), lspan.length (), def_policy ())); ASSERT_EQ (25, location_compute_display_column (expand_location (line_end), @@ -4429,12 +4447,10 @@ test_add_location_if_nearby (const line_table_case &case_) " double x;\n" /* line 4. */ " double y;\n" /* line 5. */ ";\n"); /* line 6. */ - temp_source_file tmp (SELFTEST_LOCATION, ".c", content); line_table_test ltt (case_); - - const line_map_ordinary *ord_map - = linemap_check_ordinary (linemap_add (line_table, LC_ENTER, false, - tmp.get_filename (), 0)); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, strlen (content), + ltt.m_generated_data); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); @@ -4493,12 +4509,10 @@ test_diagnostic_show_locus_fixit_lines (const line_table_case &case_) "\n" /* line 4. */ "\n" /* line 5. */ " : 0.0};\n"); /* line 6. */ - temp_source_file tmp (SELFTEST_LOCATION, ".c", content); line_table_test ltt (case_); - - const line_map_ordinary *ord_map - = linemap_check_ordinary (linemap_add (line_table, LC_ENTER, false, - tmp.get_filename (), 0)); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, strlen (content), + ltt.m_generated_data); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); @@ -4589,8 +4603,10 @@ static void test_fixit_consolidation (const line_table_case &case_) { line_table_test ltt (case_); - - linemap_add (line_table, LC_ENTER, false, "test.c", 1); + if (ltt.m_generated_data) + linemap_add (line_table, LC_GEN, false, "some content", 1, 13); + else + linemap_add (line_table, LC_ENTER, false, "test.c", 1); const location_t c10 = linemap_position_for_column (line_table, 10); const location_t c15 = linemap_position_for_column (line_table, 15); @@ -4736,13 +4752,11 @@ test_overlapped_fixit_printing (const line_table_case &case_) ...123456789012345678901234567890123456789. */ const char *content = (" foo *f = (foo *)ptr->field;\n"); - temp_source_file tmp (SELFTEST_LOCATION, ".C", content); line_table_test ltt (case_); + temp_source_file tmp (SELFTEST_LOCATION, ".C", content, strlen (content), + ltt.m_generated_data); - const line_map_ordinary *ord_map - = linemap_check_ordinary (linemap_add (line_table, LC_ENTER, false, - tmp.get_filename (), 0)); - + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); const location_t final_line_end @@ -4763,6 +4777,8 @@ test_overlapped_fixit_printing (const line_table_case &case_) = linemap_position_for_line_and_column (line_table, ord_map, 1, 28); const location_t expr = make_location (expr_start, expr_start, expr_finish); + const expanded_location xloc = expand_location (expr); + /* Various examples of fix-it hints that aren't themselves consolidated, but for which the *printing* may need consolidation. */ @@ -4806,7 +4822,7 @@ test_overlapped_fixit_printing (const line_table_case &case_) /* Add each hint in turn to a line_corrections instance, and verify that they are consolidated into one correction instance as expected. */ - line_corrections lc (policy, tmp.get_filename (), 1); + line_corrections lc (policy, xloc.src, xloc.line); /* The first replace hint by itself. */ lc.add_hint (hint_0); @@ -4947,13 +4963,10 @@ test_overlapped_fixit_printing_utf8 (const line_table_case &case_) 12344445555666677778901234566667777888899990123456789012333344445 Byte columns. */ - temp_source_file tmp (SELFTEST_LOCATION, ".C", content); line_table_test ltt (case_); - - const line_map_ordinary *ord_map - = linemap_check_ordinary (linemap_add (line_table, LC_ENTER, false, - tmp.get_filename (), 0)); - + temp_source_file tmp (SELFTEST_LOCATION, ".C", content, strlen (content), + ltt.m_generated_data); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); const location_t final_line_end @@ -4974,6 +4987,8 @@ test_overlapped_fixit_printing_utf8 (const line_table_case &case_) = linemap_position_for_line_and_column (line_table, ord_map, 1, 34); const location_t expr = make_location (expr_start, expr_start, expr_finish); + const expanded_location xloc = expand_location (expr); + /* Various examples of fix-it hints that aren't themselves consolidated, but for which the *printing* may need consolidation. */ @@ -5022,7 +5037,7 @@ test_overlapped_fixit_printing_utf8 (const line_table_case &case_) /* Add each hint in turn to a line_corrections instance, and verify that they are consolidated into one correction instance as expected. */ - line_corrections lc (policy, tmp.get_filename (), 1); + line_corrections lc (policy, xloc.src, xloc.line); /* The first replace hint by itself. */ lc.add_hint (hint_0); @@ -5180,13 +5195,11 @@ test_overlapped_fixit_printing_2 (const line_table_case &case_) ...123456789012345678901234567890123456789. */ const char *content = ("int a5[][0][0] = { 1, 2 };\n"); - temp_source_file tmp (SELFTEST_LOCATION, ".c", content); - line_table_test ltt (case_); - - const line_map_ordinary *ord_map - = linemap_check_ordinary (linemap_add (line_table, LC_ENTER, false, - tmp.get_filename (), 0)); + line_table_test ltt (case_); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, strlen (content), + ltt.m_generated_data); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); const location_t final_line_end @@ -5271,10 +5284,10 @@ test_fixit_insert_containing_newline (const line_table_case &case_) " x = a;\n" /* line 2. */ " case 'b':\n" /* line 3. */ " x = b;\n");/* line 4. */ - - temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content); line_table_test ltt (case_); - linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 3); + temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content, + strlen (old_content), false); + tmp.do_linemap_add (3); location_t case_start = linemap_position_for_column (line_table, 5); location_t case_finish = linemap_position_for_column (line_table, 13); @@ -5342,12 +5355,11 @@ test_fixit_insert_containing_newline_2 (const line_table_case &case_) "{\n" /* line 2. */ " putchar (ch);\n" /* line 3. */ "}\n"); /* line 4. */ - - temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content); line_table_test ltt (case_); + temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content, + strlen (old_content), ltt.m_generated_data); - const line_map_ordinary *ord_map = linemap_check_ordinary - (linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 0)); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); /* The primary range is the "putchar" token. */ @@ -5406,9 +5418,10 @@ test_fixit_replace_containing_newline (const line_table_case &case_) .........................1234567890123. */ const char *old_content = "foo = bar ();\n"; - temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content); line_table_test ltt (case_); - linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1); + temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content, + strlen (old_content), ltt.m_generated_data); + tmp.do_linemap_add (1); /* Replace the " = " with "\n = ", as if we were reformatting an overly long line. */ @@ -5446,10 +5459,10 @@ test_fixit_deletion_affecting_newline (const line_table_case &case_) const char *old_content = ("foo = bar (\n" " );\n"); - temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content); line_table_test ltt (case_); - const line_map_ordinary *ord_map = linemap_check_ordinary - (linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 0)); + temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content, + strlen (old_content), ltt.m_generated_data); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); /* Attempt to delete the " (\n...)". */ @@ -5498,9 +5511,10 @@ test_tab_expansion (const line_table_case &case_) const int last_byte_col = 25; ASSERT_EQ (35, cpp_display_width (content, last_byte_col, policy)); - temp_source_file tmp (SELFTEST_LOCATION, ".c", content); line_table_test ltt (case_); - linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, strlen (content), + ltt.m_generated_data); + tmp.do_linemap_add (1); /* Don't attempt to run the tests if column data might be unavailable. */ location_t line_end = linemap_position_for_column (line_table, last_byte_col); @@ -5547,15 +5561,14 @@ test_escaping_bytes_1 (const line_table_case &case_) { const char content[] = "before\0\1\2\3\v\x80\xff""after\n"; const size_t sz = sizeof (content); - temp_source_file tmp (SELFTEST_LOCATION, ".c", content, sz); line_table_test ltt (case_); - const line_map_ordinary *ord_map = linemap_check_ordinary - (linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 0)); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, sz, + ltt.m_generated_data); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); location_t finish - = linemap_position_for_line_and_column (line_table, ord_map, 1, - strlen (content)); + = linemap_position_for_line_and_column (line_table, ord_map, 1, sz); if (finish > LINE_MAP_MAX_LOCATION_WITH_COLS) return; @@ -5603,15 +5616,14 @@ test_escaping_bytes_2 (const line_table_case &case_) { const char content[] = "\0after\n"; const size_t sz = sizeof (content); - temp_source_file tmp (SELFTEST_LOCATION, ".c", content, sz); line_table_test ltt (case_); - const line_map_ordinary *ord_map = linemap_check_ordinary - (linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 0)); + temp_source_file tmp (SELFTEST_LOCATION, ".c", content, sz, + ltt.m_generated_data); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); location_t finish - = linemap_position_for_line_and_column (line_table, ord_map, 1, - strlen (content)); + = linemap_position_for_line_and_column (line_table, ord_map, 1, sz); if (finish > LINE_MAP_MAX_LOCATION_WITH_COLS) return; @@ -5663,8 +5675,7 @@ test_line_numbers_multiline_range () temp_source_file tmp (SELFTEST_LOCATION, ".txt", pp_formatted_text (&pp)); line_table_test ltt; - const line_map_ordinary *ord_map = linemap_check_ordinary - (linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 0)); + const line_map_ordinary *ord_map = tmp.do_linemap_add (0); linemap_line_start (line_table, 1, 100); /* Create a multi-line location, starting at the "line" of line 9, with @@ -5705,28 +5716,28 @@ diagnostic_show_locus_cc_tests () test_display_widths (); - for_each_line_table_case (test_layout_x_offset_display_utf8); - for_each_line_table_case (test_layout_x_offset_display_tab); + for_each_line_table_case (test_layout_x_offset_display_utf8, true); + for_each_line_table_case (test_layout_x_offset_display_tab, true); test_get_line_bytes_without_trailing_whitespace (); test_diagnostic_show_locus_unknown_location (); - for_each_line_table_case (test_diagnostic_show_locus_one_liner); - for_each_line_table_case (test_diagnostic_show_locus_one_liner_utf8); - for_each_line_table_case (test_add_location_if_nearby); - for_each_line_table_case (test_diagnostic_show_locus_fixit_lines); - for_each_line_table_case (test_fixit_consolidation); - for_each_line_table_case (test_overlapped_fixit_printing); - for_each_line_table_case (test_overlapped_fixit_printing_utf8); - for_each_line_table_case (test_overlapped_fixit_printing_2); - for_each_line_table_case (test_fixit_insert_containing_newline); - for_each_line_table_case (test_fixit_insert_containing_newline_2); - for_each_line_table_case (test_fixit_replace_containing_newline); - for_each_line_table_case (test_fixit_deletion_affecting_newline); - for_each_line_table_case (test_tab_expansion); - for_each_line_table_case (test_escaping_bytes_1); - for_each_line_table_case (test_escaping_bytes_2); + for_each_line_table_case (test_diagnostic_show_locus_one_liner, true); + for_each_line_table_case (test_diagnostic_show_locus_one_liner_utf8, true); + for_each_line_table_case (test_add_location_if_nearby, true); + for_each_line_table_case (test_diagnostic_show_locus_fixit_lines, true); + for_each_line_table_case (test_fixit_consolidation, true); + for_each_line_table_case (test_overlapped_fixit_printing, true); + for_each_line_table_case (test_overlapped_fixit_printing_utf8, true); + for_each_line_table_case (test_overlapped_fixit_printing_2, true); + for_each_line_table_case (test_fixit_insert_containing_newline, true); + for_each_line_table_case (test_fixit_insert_containing_newline_2, true); + for_each_line_table_case (test_fixit_replace_containing_newline, true); + for_each_line_table_case (test_fixit_deletion_affecting_newline, true); + for_each_line_table_case (test_tab_expansion, true); + for_each_line_table_case (test_escaping_bytes_1, true); + for_each_line_table_case (test_escaping_bytes_2, true); test_line_numbers_multiline_range (); } diff --git a/gcc/gcc-rich-location.cc b/gcc/gcc-rich-location.cc index edecf07f81e..5a118925f77 100644 --- a/gcc/gcc-rich-location.cc +++ b/gcc/gcc-rich-location.cc @@ -78,7 +78,7 @@ static bool blank_line_before_p (location_t loc) { expanded_location exploc = expand_location (loc); - char_span line = location_get_source_line (exploc.file, exploc.line); + char_span line = location_get_source_line (exploc); if (!line) return false; if (line.length () < (size_t)exploc.column) diff --git a/gcc/input.cc b/gcc/input.cc index 8c4e40aaf23..a987435c733 100644 --- a/gcc/input.cc +++ b/gcc/input.cc @@ -1048,7 +1048,7 @@ get_source_text_between (location_t start, location_t end) /* For a single line we need to trim both edges. */ if (expstart.line == expend.line) { - char_span line = location_get_source_line (expstart.file, expstart.line); + char_span line = location_get_source_line (expstart); if (line.length () < 1) return NULL; int s = expstart.column - 1; @@ -1065,7 +1065,7 @@ get_source_text_between (location_t start, location_t end) parts of the start and end lines off depending on column values. */ for (int lnum = expstart.line; lnum <= expend.line; ++lnum) { - char_span line = location_get_source_line (expstart.file, lnum); + char_span line = location_get_source_line (expstart.src, lnum); if (line.length () < 1 && (lnum != expstart.line && lnum != expend.line)) continue; @@ -1114,11 +1114,10 @@ get_source_text_between (location_t start, location_t end) as decoded according to the input charset, encoded as UTF-8. */ char_span -get_source_file_content (const char *file_path) +get_source_file_content (source_id src) { diagnostic_file_cache_init (); - - file_cache_slot *c = global_dc->m_file_cache->lookup_or_add_file (file_path); + const auto c = global_dc->m_file_cache->lookup_or_add (src); return c->get_full_file_content (); } @@ -1127,15 +1126,11 @@ get_source_file_content (const char *file_path) requesting a line number beyond the end of the file. */ bool -location_missing_trailing_newline (const char *file_path) +location_missing_trailing_newline (source_id src) { diagnostic_file_cache_init (); - - file_cache_slot *c = global_dc->m_file_cache->lookup_or_add_file (file_path); - if (c == NULL) - return false; - - return c->missing_trailing_newline_p (); + const auto c = global_dc->m_file_cache->lookup_or_add (src); + return c && c->missing_trailing_newline_p (); } /* Test if the location originates from the spelling location of a @@ -1850,7 +1845,7 @@ get_substring_ranges_for_loc (cpp_reader *pfile, if (start.column > finish.column) return "range endpoints are reversed"; - char_span line = location_get_source_line (start.file, start.line); + char_span line = location_get_source_line (start); if (!line) return "unable to read source line"; diff --git a/gcc/input.h b/gcc/input.h index d30673f1089..a784f101ce7 100644 --- a/gcc/input.h +++ b/gcc/input.h @@ -119,10 +119,10 @@ inline char_span location_get_source_line (expanded_location exploc) { return location_get_source_line (exploc.src, exploc.line); } -extern char *get_source_text_between (location_t, location_t); -extern char_span get_source_file_content (const char *file_path); -extern bool location_missing_trailing_newline (const char *file_path); +extern char *get_source_text_between (location_t, location_t); +extern char_span get_source_file_content (source_id src); +extern bool location_missing_trailing_newline (source_id src); /* Forward decl of slots within file_cache, so that the definition doesn't need to be in this header. */ From patchwork Wed Aug 9 22:14:13 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lewis Hyatt X-Patchwork-Id: 1819649 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=MoB6NE1G; dkim-atps=neutral Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RLkw46sjtz1yYl for ; Thu, 10 Aug 2023 08:18:12 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id CB5463830B42 for ; Wed, 9 Aug 2023 22:18:10 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org CB5463830B42 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691619490; bh=bEkNGogw2XTZuv7q7QmNEv1OGxrxaXQ4yvVqLv9WS50=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=MoB6NE1G9zec1FpD5qfj5bzSxyR4oBpmwezC2wOEFoNWqH8lw5NWIxW+d3NjwP/HY uQJ3l+DAyCEYFk8m2xYx/+ASLZk78ZMXi/FP7KAymIw8Ka+yg5wJfr2xcKgBmd8c6n 0e5/3X0zEE+hCp72gLnTLe9EP80aoXggKPdowdB4= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qt1-x82a.google.com (mail-qt1-x82a.google.com [IPv6:2607:f8b0:4864:20::82a]) by sourceware.org (Postfix) with ESMTPS id 443CD3857C41 for ; Wed, 9 Aug 2023 22:14:53 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 443CD3857C41 Received: by mail-qt1-x82a.google.com with SMTP id d75a77b69052e-4039f7e1d3aso1541841cf.0 for ; Wed, 09 Aug 2023 15:14:53 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691619292; x=1692224092; 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=bEkNGogw2XTZuv7q7QmNEv1OGxrxaXQ4yvVqLv9WS50=; b=X4GSxyrFXbXUzaK6Ra+sTSx2hjkneqegoDaXTw+L0ZMwiNBQisAcT6/027camTGAKk s7s1rx0PMujVU8FRBvIZ/DrsaTmr1zY4zjlcoYFYM9BCG9mUJDn+F/GLk3B+G3k0CLe6 +1m+fV1hjJ2Yaj+mLklulId80Oasw8H5av5IRMsmXffvYNSes3H9QfmjdYm3dsof1qbi dfOYJbQ6ZlIyopf1e2VVWz0E64gVwQm4fret7+ODi3oMoJBKgzH75UVM7XkKGENeX2EK 4g0aBmyybofmuzKbGt/jgO6AHANk6JU6gZPMwCsRJYFS63mb6yHUsHggDqGpwbn1z8sy m9Vw== X-Gm-Message-State: AOJu0YyMGckk5bz5VZQmBk5Zho0sVWi+U6ot+DlaIp6fprpLk0jKVYzG HKGpksaAfxT4u0fXQo8EZmg/X3QbJVA= X-Google-Smtp-Source: AGHT+IFBVA5pFdDY29Y41+moejj49qQR3UvADJ5H5VbcMXOrXltiXoUBpzhCxbwjHDkB8zbnehT40g== X-Received: by 2002:ac8:59c3:0:b0:403:a9aa:56d6 with SMTP id f3-20020ac859c3000000b00403a9aa56d6mr768237qtf.58.1691619291946; Wed, 09 Aug 2023 15:14:51 -0700 (PDT) Received: from localhost.localdomain (96-67-140-173-static.hfc.comcastbusiness.net. [96.67.140.173]) by smtp.gmail.com with ESMTPSA id ce11-20020a05622a41cb00b0040fef71dc1esm46334qtb.10.2023.08.09.15.14.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Aug 2023 15:14:51 -0700 (PDT) To: gcc-patches@gcc.gnu.org Cc: David Malcolm , Lewis Hyatt Subject: [PATCH v4 7/8] diagnostics: libcpp: Assign real locations to the tokens inside _Pragma strings Date: Wed, 9 Aug 2023 18:14:13 -0400 Message-Id: <20230809221414.2849878-8-lhyatt@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230809221414.2849878-1-lhyatt@gmail.com> References: <20230809221414.2849878-1-lhyatt@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3038.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lewis Hyatt via Gcc-patches From: Lewis Hyatt Reply-To: Lewis Hyatt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Currently, the tokens obtained from a destringified _Pragma string do not get assigned proper locations while they are being lexed. After the tokens have been obtained, they are reassigned the same location as the _Pragma token, which is sufficient to make things like _Pragma("GCC diagnostic ignored...") operate correctly, but this still results in inferior diagnostics, since the diagnostics do not point to the problematic tokens. Further, if a diagnostic is issued by libcpp during the lexing of the tokens, as opposed to being issued by the frontend during the processing of the pragma, then the patched-up location is not yet in place, and the user rather sees an invalid location that is near to the location of the _Pragma string in some cases, or potentially very far away, depending on the macro expansion history. For example: ===== _Pragma("GCC diagnostic ignored \"oops") ===== produces the diagnostic: file.cpp:1:24: warning: missing terminating " character 1 | _Pragma("GCC diagnostic ignored \"oops") | ^ with the caret in a nonsensical location, while this one: ===== #define S "GCC diagnostic ignored \"oops" _Pragma(S) ===== produces: file.cpp:2:24: warning: missing terminating " character 2 | _Pragma(S) | ^ with both the caret in a nonsensical location, and the actual relevant context completely absent. Fix this by assigning proper locations using the new LC_GEN type of linemap. Now the tokens are given locations inside a generated content buffer, and the macro expansion stack is modified to be aware that these tokens logically belong to the "expansion" of the _Pragma directive. For the above examples we now output: ====== In buffer generated from file.cpp:1: :1:24: warning: missing terminating " character 1 | GCC diagnostic ignored "oops | ^ file.cpp:1:1: note: in <_Pragma directive> 1 | _Pragma("GCC diagnostic ignored \"oops") | ^~~~~~~ ====== and ====== :1:24: warning: missing terminating " character 1 | GCC diagnostic ignored "oops | ^ file.cpp:2:1: note: in <_Pragma directive> 2 | _Pragma(S) | ^~~~~~~ ====== So that carets are pointing to something meaningful and all relevant context appears in the diagnostic. For the second example, it would be nice if the macro expansion also output "in expansion of macro S", however doing that for a general case of macro expansions makes the logic very complicated, since it has to be done after the fact when the macro maps have already been constructed. It doesn't seem worth it for this case, given that the _Pragma string has already been output once on the first line. gcc/ChangeLog: * tree-diagnostic.cc (maybe_unwind_expanded_macro_loc): Add awareness of _Pragma directive to the macro expansion trace. libcpp/ChangeLog: * directives.cc (get_token_no_padding): Add argument to receive the virtual location of the token. (get__Pragma_string): Likewise. (do_pragma): Set pfile->directive_result->src_loc properly, it should not be a virtual location. (destringize_and_run): Update to provide proper locations for the _Pragma string tokens. Support raw strings. (_cpp_do__Pragma): Adapt to changes to the helper functions. * errors.cc (cpp_diagnostic_at): Support cpp_reader::diagnostic_rebase_loc. (cpp_diagnostic_with_line): Likewise. * include/line-map.h (class rich_location): Add new member forget_cached_expanded_locations(). * internal.h (struct _cpp__Pragma_state): Define new struct. (_cpp_rebase_diagnostic_location): Declare new function. (struct cpp_reader): Add diagnostic_rebase_loc member. (_cpp_push__Pragma_token_context): Declare new function. (_cpp_do__Pragma): Adjust prototype. * macro.cc (pragma_str): New static var. (builtin_macro): Adapt to new implementation of _Pragma processing. (_cpp_pop_context): Fix the logic for resetting pfile->top_most_macro_node, which previously was never triggered, although the error seems to have been harmless. (_cpp_push__Pragma_token_context): New function. (_cpp_rebase_diagnostic_location): New function. gcc/c-family/ChangeLog: * c-ppoutput.cc (token_streamer::stream): Pass the virtual location of the _Pragma token to maybe_print_line(), not the spelling location. libgomp/ChangeLog: * testsuite/libgomp.oacc-c-c++-common/reduction-5.c: Adjust for new macro tracking output for _Pragma directives. * testsuite/libgomp.oacc-c-c++-common/vred2d-128.c: Likewise. gcc/testsuite/ChangeLog: * c-c++-common/cpp/diagnostic-pragma-1.c: Adjust for new macro tracking output for _Pragma directives. * c-c++-common/cpp/pr57580.c: Likewise. * c-c++-common/gomp/pragma-3.c: Likewise. * c-c++-common/gomp/pragma-5.c: Likewise. * g++.dg/pch/operator-1.C: Likewise. * gcc.dg/cpp/pr28165.c: Likewise. * gcc.dg/cpp/pr35322.c: Likewise. * gcc.dg/dfp/pragma-float-const-decimal64-4.c: Likewise. * gcc.dg/dfp/pragma-float-const-decimal64-5.c: Likewise. * gcc.dg/dfp/pragma-float-const-decimal64-6.c: Likewise. * gcc.dg/gomp/macro-4.c: Likewise. * gcc.dg/pragma-message.c: Likewise. * c-c++-common/pragma-diag-17.c: New test. * c-c++-common/pragma-diag-18.c: New test. * g++.dg/cpp/pragma-raw-string.C: New test. * g++.dg/pch/LC_GEN-maps.C: New test. * g++.dg/pch/LC_GEN-maps.Hs: New test. * lib/prune.exp: Support pruning new _Pragma include trace. --- gcc/c-family/c-ppoutput.cc | 2 +- .../c-c++-common/cpp/diagnostic-pragma-1.c | 1 + gcc/testsuite/c-c++-common/cpp/pr57580.c | 2 +- gcc/testsuite/c-c++-common/gomp/pragma-3.c | 3 +- gcc/testsuite/c-c++-common/gomp/pragma-5.c | 3 +- gcc/testsuite/c-c++-common/pragma-diag-17.c | 35 +++ gcc/testsuite/c-c++-common/pragma-diag-18.c | 18 ++ gcc/testsuite/g++.dg/cpp/pragma-raw-string.C | 16 + gcc/testsuite/g++.dg/pch/LC_GEN-maps.C | 20 ++ gcc/testsuite/g++.dg/pch/LC_GEN-maps.Hs | 5 + gcc/testsuite/g++.dg/pch/operator-1.C | 1 + gcc/testsuite/gcc.dg/cpp/pr28165.c | 1 + gcc/testsuite/gcc.dg/cpp/pr35322.c | 1 + .../dfp/pragma-float-const-decimal64-4.c | 1 + .../dfp/pragma-float-const-decimal64-5.c | 2 +- .../dfp/pragma-float-const-decimal64-6.c | 2 +- gcc/testsuite/gcc.dg/gomp/macro-4.c | 2 +- gcc/testsuite/gcc.dg/pragma-message.c | 3 +- gcc/testsuite/lib/prune.exp | 1 + gcc/tree-diagnostic.cc | 18 +- libcpp/directives.cc | 278 ++++++++++++------ libcpp/errors.cc | 16 +- libcpp/include/line-map.h | 1 + libcpp/internal.h | 32 +- libcpp/macro.cc | 126 +++++++- .../libgomp.oacc-c-c++-common/reduction-5.c | 3 +- .../libgomp.oacc-c-c++-common/vred2d-128.c | 40 ++- 27 files changed, 491 insertions(+), 142 deletions(-) create mode 100644 gcc/testsuite/c-c++-common/pragma-diag-17.c create mode 100644 gcc/testsuite/c-c++-common/pragma-diag-18.c create mode 100644 gcc/testsuite/g++.dg/cpp/pragma-raw-string.C create mode 100644 gcc/testsuite/g++.dg/pch/LC_GEN-maps.C create mode 100644 gcc/testsuite/g++.dg/pch/LC_GEN-maps.Hs diff --git a/gcc/c-family/c-ppoutput.cc b/gcc/c-family/c-ppoutput.cc index 4aa2bef2c0f..364bfe5ad43 100644 --- a/gcc/c-family/c-ppoutput.cc +++ b/gcc/c-family/c-ppoutput.cc @@ -280,7 +280,7 @@ token_streamer::stream (cpp_reader *pfile, const cpp_token *token, const char *space; const char *name; - line_marker_emitted = maybe_print_line (token->src_loc); + line_marker_emitted = maybe_print_line (loc); fputs ("#pragma ", print.outf); c_pp_lookup_pragma (token->val.pragma, &space, &name); if (space) diff --git a/gcc/testsuite/c-c++-common/cpp/diagnostic-pragma-1.c b/gcc/testsuite/c-c++-common/cpp/diagnostic-pragma-1.c index 9867c94a8dd..801c93935b8 100644 --- a/gcc/testsuite/c-c++-common/cpp/diagnostic-pragma-1.c +++ b/gcc/testsuite/c-c++-common/cpp/diagnostic-pragma-1.c @@ -1,4 +1,5 @@ // { dg-do compile } +// { dg-additional-options "-ftrack-macro-expansion=0" } #pragma GCC warning "warn-a" // { dg-warning warn-a } #pragma GCC error "err-b" // { dg-error err-b } diff --git a/gcc/testsuite/c-c++-common/cpp/pr57580.c b/gcc/testsuite/c-c++-common/cpp/pr57580.c index e77462b20de..b0e54d876d6 100644 --- a/gcc/testsuite/c-c++-common/cpp/pr57580.c +++ b/gcc/testsuite/c-c++-common/cpp/pr57580.c @@ -1,6 +1,6 @@ /* PR preprocessor/57580 */ /* { dg-do compile } */ -/* { dg-options "-save-temps" } */ +/* { dg-options "-save-temps -ftrack-macro-expansion=0" } */ #define MSG \ _Pragma("message(\"message0\")") \ diff --git a/gcc/testsuite/c-c++-common/gomp/pragma-3.c b/gcc/testsuite/c-c++-common/gomp/pragma-3.c index 3e1b2111c3d..e0cffb8aeea 100644 --- a/gcc/testsuite/c-c++-common/gomp/pragma-3.c +++ b/gcc/testsuite/c-c++-common/gomp/pragma-3.c @@ -8,7 +8,8 @@ void f (void) { const char *str = outer(inner(1,2)); /* { dg-line str_location } */ - /* { dg-warning "35:'pragma omp error' encountered: Test" "" { target *-*-* } inner_location } + /* { dg-warning "1:'pragma omp error' encountered: Test" "" { target *-*-* } 1 } + { dg-note "35: in <_Pragma directive>" "" { target *-*-* } inner_location } { dg-note "20:in expansion of macro 'inner'" "" { target *-*-* } outer_location } { dg-note "21:in expansion of macro 'outer'" "" { target *-*-* } str_location } */ } diff --git a/gcc/testsuite/c-c++-common/gomp/pragma-5.c b/gcc/testsuite/c-c++-common/gomp/pragma-5.c index 173c25e803a..787a334882d 100644 --- a/gcc/testsuite/c-c++-common/gomp/pragma-5.c +++ b/gcc/testsuite/c-c++-common/gomp/pragma-5.c @@ -8,7 +8,8 @@ void f (void) { const char *str = outer(inner(1,2)); /* { dg-line str_location } */ - /* { dg-warning "35:'pragma omp error' encountered: Test" "" { target *-*-* } inner_location } + /* { dg-warning "4:'pragma omp error' encountered: Test" "" { target *-*-* } 1 } + { dg-note "35:in <_Pragma directive>" "" { target *-*-*} inner_location } { dg-note "20:in expansion of macro 'inner'" "" { target *-*-* } outer_location } { dg-note "21:in expansion of macro 'outer'" "" { target *-*-* } str_location } */ } diff --git a/gcc/testsuite/c-c++-common/pragma-diag-17.c b/gcc/testsuite/c-c++-common/pragma-diag-17.c new file mode 100644 index 00000000000..b9539c9598b --- /dev/null +++ b/gcc/testsuite/c-c++-common/pragma-diag-17.c @@ -0,0 +1,35 @@ +/* Test virtual location aspects of _Pragmas, when an error is reported after + lexing the tokens from the _Pragma string. */ +/* { dg-additional-options "-Wpragmas -Wunknown-pragmas" } */ + +_Pragma("GCC diagnostic ignored \"oops1\"") /* { dg-note {1:in <_Pragma directive>} } */ +/* { dg-warning {24:'oops1' is not an option} "" { target *-*-* } 1 } */ + +#define S2 "GCC diagnostic ignored \"oops2\"" +_Pragma(S2) /* { dg-note {1:in <_Pragma directive>} } */ +/* { dg-warning {24:'oops2' is not an option} "" { target *-*-* } 1 } */ + +#define PP(x) _Pragma(x) /* { dg-note {15:in <_Pragma directive>} } */ +PP("GCC diagnostic ignored \"oops3\"") /* { dg-note {1:in expansion of macro 'PP'} } */ +/* { dg-warning {24:'oops3' is not an option} "" { target *-*-* } 1 } */ + +#define X4 _Pragma("GCC diagnostic ignored \"oops4\"") /* { dg-note {12:in <_Pragma directive>} } */ +#define Y4 X4 /* { dg-note {12:in expansion of macro 'X4'} } */ +Y4 /* { dg-note {1:in expansion of macro 'Y4'} } */ +/* { dg-warning {24:'oops4' is not an option} "" { target *-*-* } 1 } */ + +#define P5 _Pragma /* { dg-note {12:in <_Pragma directive>} } */ +#define S5 "GCC diagnostic ignored \"oops5\"" +#define Y5 P5(S5) /* { dg-note {12:in expansion of macro 'P5'} } */ +Y5 /* { dg-note {1:in expansion of macro 'Y5'} } */ +/* { dg-warning {24:'oops5' is not an option} "" { target *-*-* } 1 } */ + +#define P6 _Pragma /* { dg-note {12:in <_Pragma directive>} } */ +#define X6 P6("GCC diagnostic ignored \"oops6\"") /* { dg-note {12:in expansion of macro 'P6'} } */ +X6 /* { dg-note {1:in expansion of macro 'X6'} } */ +/* { dg-warning {24:'oops6' is not an option} "" { target *-*-* } 1 } */ + +_Pragma(__DATE__) /* { dg-warning {-:[-Wunknown-pragmas]} } */ + +_Pragma("once") /* { dg-note {1:in <_Pragma directive>} } */ +/* { dg-warning {#pragma once in main file} "" { target *-*-*} 1 } */ diff --git a/gcc/testsuite/c-c++-common/pragma-diag-18.c b/gcc/testsuite/c-c++-common/pragma-diag-18.c new file mode 100644 index 00000000000..5de0fbcb8f1 --- /dev/null +++ b/gcc/testsuite/c-c++-common/pragma-diag-18.c @@ -0,0 +1,18 @@ +/* Test virtual location aspects of _Pragmas, when an error is reported during + lexing of the _Pragma string itself or of the tokens within it. */ +/* { dg-additional-options "-Wpragmas" } */ + +#define X1 "\"" +_Pragma(X1) /* { dg-note {1:in <_Pragma directive>} } */ +/* { dg-warning {1:missing terminating " character} "" { target *-*-* } 1 } */ + +#define X2a _Pragma("GCC warning \"hello\"") ( /* { dg-note {13:in <_Pragma directive>} } */ +#define X2b "GCC warning \"goodbye\"" ) +_Pragma X2a X2b /* { dg-note {9:in expansion of macro 'X2a'} } */ +/* { dg-note {1:in <_Pragma directive>} "" { target *-*-* } .-1 } */ +/* { dg-warning {13:hello} "" { target *-*-* } 1 } */ +/* { dg-warning {13:goodbye} "" { target *-*-* } 1 } */ + +_Pragma() /* { dg-error {9:_Pragma takes a parenthesized string literal} } */ +/* { dg-note {1:in <_Pragma directive>} "" { target *-*-* } .-1 } */ +/* { dg-error {at end of input|'_Pragma' does not name a type} "" { target *-*-* } .-2 } */ diff --git a/gcc/testsuite/g++.dg/cpp/pragma-raw-string.C b/gcc/testsuite/g++.dg/cpp/pragma-raw-string.C new file mode 100644 index 00000000000..5a495aadeec --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp/pragma-raw-string.C @@ -0,0 +1,16 @@ +/* Test that _Pragma with a raw string works correctly. */ +/* { dg-do compile { target c++11 } } */ +/* { dg-additional-options "-Wunused-variable -Wpragmas" } */ + +_Pragma(R"delim(GCC diagnostic push)delim") +_Pragma(R"(GCC diagnostic ignored "-Wunused-variable")") +void f1 () { int i; } +_Pragma(R"(GCC diagnostic pop)") +void f2 () { int i; } /* { dg-warning {18:-Wunused-variable} } */ + +/* Make sure lines stay in sync if there is an embedded newline too. */ +_Pragma(R"xyz(GCC diagnostic ignored R"(two +line option?)")xyz") +/* { dg-note {1:in <_Pragma directive>} "" { target *-*-* } .-2 } */ +/* { dg-warning {24:unknown option} "" { target *-*-* } 1 } */ +void f3 () { int i; } /* { dg-warning {18:-Wunused-variable} } */ diff --git a/gcc/testsuite/g++.dg/pch/LC_GEN-maps.C b/gcc/testsuite/g++.dg/pch/LC_GEN-maps.C new file mode 100644 index 00000000000..4ce241579fe --- /dev/null +++ b/gcc/testsuite/g++.dg/pch/LC_GEN-maps.C @@ -0,0 +1,20 @@ +#include "LC_GEN-maps.H" + +/* The LC_GEN map was written to the PCH, but there is not currently a way to + observe that fact in normal user code. Let's try to test it anyway, using + -fdump-internal-locations to inspect the line_maps object we received from + the PCH. */ + +/* { dg-additional-options -fdump-internal-locations } */ +/* { dg-allow-blank-lines-in-output "" } */ + +/* These regexps themselves will also appear in the output of + -fdump-internal-locations, so we need to make sure they contain at least + some regexp special characters, even if not strictly necessary, so they + match the intended text only, and not themselves. Also, we make the second + one intentionally match the whole output if it maches anything. We could + use dg-excess-errors instead, but that outputs XFAILS which are not really + helpful for this test. */ + +/* { dg-regexp {reason: . \(LC_GEN\)} } */ +/* { dg-regexp {(.|[\n\r])*[d]ata: this string should end up in the "PCH"(.|[\n\r])*} } */ diff --git a/gcc/testsuite/g++.dg/pch/LC_GEN-maps.Hs b/gcc/testsuite/g++.dg/pch/LC_GEN-maps.Hs new file mode 100644 index 00000000000..76eefa7d1ae --- /dev/null +++ b/gcc/testsuite/g++.dg/pch/LC_GEN-maps.Hs @@ -0,0 +1,5 @@ +/* Evaluating the _Pragma directive here creates an LC_GEN map in the + line_maps object that will be stored in the PCH. The test will make sure + that the buffer holding the de-stringified _Pragma string contents makes + its way there. */ +_Pragma("this string should end up in the \"PCH\"") diff --git a/gcc/testsuite/g++.dg/pch/operator-1.C b/gcc/testsuite/g++.dg/pch/operator-1.C index 290b5f7ab21..bf1c8b07bdb 100644 --- a/gcc/testsuite/g++.dg/pch/operator-1.C +++ b/gcc/testsuite/g++.dg/pch/operator-1.C @@ -1,2 +1,3 @@ +/* { dg-additional-options "-ftrack-macro-expansion=0" } */ #include "operator-1.H" int main(void){ major(0);} /* { dg-warning "Did not Work" } */ diff --git a/gcc/testsuite/gcc.dg/cpp/pr28165.c b/gcc/testsuite/gcc.dg/cpp/pr28165.c index 71c7c1dba46..3e5e49ffa01 100644 --- a/gcc/testsuite/gcc.dg/cpp/pr28165.c +++ b/gcc/testsuite/gcc.dg/cpp/pr28165.c @@ -2,5 +2,6 @@ /* PR preprocessor/28165 */ /* { dg-do preprocess } */ +/* { dg-additional-options "-ftrack-macro-expansion=0" } */ #pragma GCC system_header /* { dg-warning "system_header" "ignored" } */ _Pragma ("GCC system_header") /* { dg-warning "system_header" "ignored" } */ diff --git a/gcc/testsuite/gcc.dg/cpp/pr35322.c b/gcc/testsuite/gcc.dg/cpp/pr35322.c index 1af9605eac6..5bd5f69b73d 100644 --- a/gcc/testsuite/gcc.dg/cpp/pr35322.c +++ b/gcc/testsuite/gcc.dg/cpp/pr35322.c @@ -1,4 +1,5 @@ /* Test case for PR 35322 -- _Pragma ICE. */ /* { dg-do preprocess } */ +/* { dg-additional-options "-ftrack-macro-expansion=0" } */ _Pragma("GCC dependency") /* { dg-error "#pragma dependency expects" } */ diff --git a/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-4.c b/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-4.c index af0398daf79..42fc28a4384 100644 --- a/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-4.c +++ b/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-4.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-additional-options -ftrack-macro-expansion=0 } */ /* N1312 7.1.1: The FLOAT_CONST_DECIMAL64 pragma. C99 6.4.4.2a (New). diff --git a/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-5.c b/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-5.c index 75e9525dda0..3aefede7b5d 100644 --- a/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-5.c +++ b/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-5.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-std=c99 -pedantic" } */ +/* { dg-options "-std=c99 -pedantic -ftrack-macro-expansion=0" } */ /* N1312 7.1.1: The FLOAT_CONST_DECIMAL64 pragma. C99 6.4.4.2a (New). diff --git a/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-6.c b/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-6.c index 03c1715bee6..6d70ce2bb8d 100644 --- a/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-6.c +++ b/gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-6.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-std=c99 -pedantic-errors" } */ +/* { dg-options "-std=c99 -pedantic-errors -ftrack-macro-expansion=0" } */ /* N1312 7.1.1: The FLOAT_CONST_DECIMAL64 pragma. C99 6.4.4.2a (New). diff --git a/gcc/testsuite/gcc.dg/gomp/macro-4.c b/gcc/testsuite/gcc.dg/gomp/macro-4.c index a4ed9a3980a..c6817d40125 100644 --- a/gcc/testsuite/gcc.dg/gomp/macro-4.c +++ b/gcc/testsuite/gcc.dg/gomp/macro-4.c @@ -1,6 +1,6 @@ /* PR preprocessor/27746 */ /* { dg-do compile } */ -/* { dg-options "-fopenmp -Wunknown-pragmas" } */ +/* { dg-options "-fopenmp -Wunknown-pragmas -ftrack-macro-expansion=0" } */ #define p _Pragma ("omp parallel") #define omp_p _Pragma ("omp p") diff --git a/gcc/testsuite/gcc.dg/pragma-message.c b/gcc/testsuite/gcc.dg/pragma-message.c index 1b7cf09de0a..72fb0da6f44 100644 --- a/gcc/testsuite/gcc.dg/pragma-message.c +++ b/gcc/testsuite/gcc.dg/pragma-message.c @@ -45,8 +45,9 @@ #define DO_PRAGMA(x) _Pragma (#x) /* { dg-line pragma_loc1 } */ #define TODO(x) DO_PRAGMA(message ("TODO - " #x)) /* { dg-line pragma_loc2 } */ TODO(Okay 4) /* { dg-message "in expansion of macro 'TODO'" } */ -/* { dg-message "TODO - Okay 4" "test4.1" { target *-*-* } pragma_loc1 } */ +/* { dg-message "1:TODO - Okay 4" "test4.1" { target *-*-* } 1 } */ /* { dg-message "in expansion of macro 'DO_PRAGMA'" "test4.2" { target *-*-* } pragma_loc2 } */ +/* { dg-note {in <_Pragma directive>} "test4.3" { target *-*-* } pragma_loc1 } */ #if 0 #pragma message ("Not printed") diff --git a/gcc/testsuite/lib/prune.exp b/gcc/testsuite/lib/prune.exp index 8d37b24e59b..02ebf8b30d9 100644 --- a/gcc/testsuite/lib/prune.exp +++ b/gcc/testsuite/lib/prune.exp @@ -54,6 +54,7 @@ proc prune_gcc_output { text } { # Diagnostic inclusion stack regsub -all "(^|\n)(In file)?\[ \]+included from \[^\n\]*" $text "" text + regsub -all "(^|\n)In buffer generated from \[^\n\]*" $text "" text regsub -all "(^|\n)\[ \]+from \[^\n\]*" $text "" text regsub -all "(^|\n)(In|of) module( \[^\n \]*,)? imported at \[^\n\]*" $text "" text diff --git a/gcc/tree-diagnostic.cc b/gcc/tree-diagnostic.cc index 731e3559cd8..fd2773f3d8a 100644 --- a/gcc/tree-diagnostic.cc +++ b/gcc/tree-diagnostic.cc @@ -203,9 +203,12 @@ maybe_unwind_expanded_macro_loc (diagnostic_context *context, const int resolved_def_loc_line = SOURCE_LINE (m, l0); if (ix == 0 && saved_location_line != resolved_def_loc_line) { - diagnostic_append_note (context, resolved_def_loc, - "in definition of macro %qs", - linemap_map_get_macro_name (iter->map)); + const char *name = linemap_map_get_macro_name (iter->map); + if (*name == '<') + diagnostic_append_note (context, resolved_def_loc, "in %s", name); + else + diagnostic_append_note (context, resolved_def_loc, + "in definition of macro %qs", name); /* At this step, as we've printed the context of the macro definition, we don't want to print the context of its expansion, otherwise, it'd be redundant. */ @@ -220,9 +223,12 @@ maybe_unwind_expanded_macro_loc (diagnostic_context *context, MACRO_MAP_EXPANSION_POINT_LOCATION (iter->map), LRK_MACRO_DEFINITION_LOCATION, NULL); - diagnostic_append_note (context, resolved_exp_loc, - "in expansion of macro %qs", - linemap_map_get_macro_name (iter->map)); + const char *name = linemap_map_get_macro_name (iter->map); + if (*name == '<') + diagnostic_append_note (context, resolved_exp_loc, "in %s", name); + else + diagnostic_append_note (context, resolved_exp_loc, + "in expansion of macro %qs", name); } } diff --git a/libcpp/directives.cc b/libcpp/directives.cc index dfd782b3fca..d2d83e6dc83 100644 --- a/libcpp/directives.cc +++ b/libcpp/directives.cc @@ -127,10 +127,10 @@ static void do_pragma_warning_or_error (cpp_reader *, bool error); static void do_pragma_warning (cpp_reader *); static void do_pragma_error (cpp_reader *); static void do_linemarker (cpp_reader *); -static const cpp_token *get_token_no_padding (cpp_reader *); -static const cpp_token *get__Pragma_string (cpp_reader *); -static void destringize_and_run (cpp_reader *, const cpp_string *, - location_t); +static const cpp_token *get_token_no_padding (cpp_reader *, + location_t * = nullptr); +static const cpp_token *get__Pragma_string (cpp_reader *, + location_t * = nullptr); static bool parse_answer (cpp_reader *, int, location_t, cpp_macro **); static cpp_hashnode *parse_assertion (cpp_reader *, int, cpp_macro **); static cpp_macro **find_answer (cpp_hashnode *, const cpp_macro *); @@ -1504,14 +1504,12 @@ do_pragma (cpp_reader *pfile) { const struct pragma_entry *p = NULL; const cpp_token *token, *pragma_token; - location_t pragma_token_virt_loc = 0; cpp_token ns_token; unsigned int count = 1; pfile->state.prevent_expansion++; - pragma_token = token = cpp_get_token_with_location (pfile, - &pragma_token_virt_loc); + pragma_token = token = cpp_get_token (pfile); ns_token = *token; if (token->type == CPP_NAME) { @@ -1537,7 +1535,7 @@ do_pragma (cpp_reader *pfile) { if (p->is_deferred) { - pfile->directive_result.src_loc = pragma_token_virt_loc; + pfile->directive_result.src_loc = pragma_token->src_loc; pfile->directive_result.type = CPP_PRAGMA; pfile->directive_result.flags = pragma_token->flags; pfile->directive_result.val.pragma = p->u.ident; @@ -1830,11 +1828,11 @@ do_pragma_error (cpp_reader *pfile) /* Get a token but skip padding. */ static const cpp_token * -get_token_no_padding (cpp_reader *pfile) +get_token_no_padding (cpp_reader *pfile, location_t *virt_loc) { for (;;) { - const cpp_token *result = cpp_get_token (pfile); + const cpp_token *result = cpp_get_token_with_location (pfile, virt_loc); if (result->type != CPP_PADDING) return result; } @@ -1843,7 +1841,7 @@ get_token_no_padding (cpp_reader *pfile) /* Check syntax is "(string-literal)". Returns the string on success, or NULL on failure. */ static const cpp_token * -get__Pragma_string (cpp_reader *pfile) +get__Pragma_string (cpp_reader *pfile, location_t *string_virt_loc) { const cpp_token *string; const cpp_token *paren; @@ -1854,7 +1852,7 @@ get__Pragma_string (cpp_reader *pfile) if (paren->type != CPP_OPEN_PAREN) return NULL; - string = get_token_no_padding (pfile); + string = get_token_no_padding (pfile, string_virt_loc); if (string->type == CPP_EOF) _cpp_backup_tokens (pfile, 1); if (string->type != CPP_STRING && string->type != CPP_WSTRING @@ -1874,55 +1872,105 @@ get__Pragma_string (cpp_reader *pfile) /* Destringize IN into a temporary buffer, by removing the first \ of \" and \\ sequences, and process the result as a #pragma directive. */ static void -destringize_and_run (cpp_reader *pfile, const cpp_string *in, - location_t expansion_loc) -{ - const unsigned char *src, *limit; - char *dest, *result; - cpp_context *saved_context; - cpp_token *saved_cur_token; - tokenrun *saved_cur_run; - cpp_token *toks; - int count; - const struct directive *save_directive; - - dest = result = (char *) alloca (in->len - 1); - src = in->text + 1 + (in->text[0] == 'L'); - limit = in->text + in->len - 1; - while (src < limit) +destringize_and_run (cpp_reader *pfile, _cpp__Pragma_state *pstate) +{ + uchar *dest, *result; + + /* Determine where the data starts, and what kind of string it is. */ + const cpp_string *const in = &pstate->string_tok->val.str; + const uchar *src = in->text; + bool is_raw_string = false; + for (;;) { - /* We know there is a character following the backslash. */ - if (*src == '\\' && (src[1] == '\\' || src[1] == '"')) - src++; - *dest++ = *src++; + switch (*src++) + { + case '\"': break; + case 'R': is_raw_string = true; continue; + case '\0': gcc_assert (false); + default: continue; + } + break; } - *dest = '\n'; - /* Ugh; an awful kludge. We are really not set up to be lexing - tokens when in the middle of a macro expansion. Use a new - context to force cpp_get_token to lex, and so skip_rest_of_line - doesn't go beyond the end of the text. Also, remember the - current lexing position so we can return to it later. + /* If we were given a raw string literal, we don't need to destringize it, + but we do need to strip off the prefix and the suffix. */ + if (is_raw_string) + { + cpp_string buf; + const bool ok + = cpp_interpret_string_notranslate (pfile, in, 1, &buf, CPP_STRING); + gcc_assert (ok); - Something like line-at-a-time lexing should remove the need for - this. */ - saved_context = pfile->context; - saved_cur_token = pfile->cur_token; - saved_cur_run = pfile->cur_run; + /* BUF.TEXT ends with a terminating null (which is counted in BUF.LEN). + We want to end with a newline as required by cpp_push_buffer. While it + is not strictly necessary to null terminate our buffer, it is useful to + do so for safety, so we reserve one extra byte. The \n\0 sequence is + appended after the else block. */ + result = _cpp_unaligned_alloc (pfile, buf.len + 1); + memcpy (result, buf.text, buf.len - 1); + dest = result + (buf.len - 1); + XDELETEVEC (buf.text); + } + else + { + const auto last_ptr = in->text + in->len - 1; + /* +2 for the trailing \n\0 as above. */ + dest = result = _cpp_unaligned_alloc (pfile, last_ptr - src + 1 + 2); + while (src < last_ptr) + { + /* We know there is a character following the backslash. */ + if (*src == '\\' && (src[1] == '\\' || src[1] == '"')) + src++; + *dest++ = *src++; + } + } + *dest++ = '\n'; + *dest++ = '\0'; - pfile->context = XCNEW (cpp_context); + /* We will now ask PFILE to interrupt what it was doing (obtaining tokens + either from the main context via lexing, or from a macro context), and get + tokens from the string argument instead. We create a new isolated + cpp_context so that cpp_get_token will think it is working on the main + buffer and call cpp_lex_token accordingly. Save all the relevant state so + we can return to the previous task once that is completed. - /* Inline run_directive, since we need to delay the _cpp_pop_buffer - until we've read all of the tokens that we want. */ - cpp_push_buffer (pfile, (const uchar *) result, dest - result, - /* from_stage3 */ true); - /* ??? Antique Disgusting Hack. What does this do? */ - if (pfile->buffer->prev) - pfile->buffer->file = pfile->buffer->prev->file; + Doing things this way is a bit of a kludge, but the alternative would be + to create a new context type to support lexing from a string, and that + would add overhead to every token parse, while _Pragma is relatively rarely + needed. */ + const auto saved_context = pfile->context; + const auto saved_cur_token = pfile->cur_token; + const auto saved_cur_run = pfile->cur_run; + pfile->context = XCNEW (cpp_context); start_directive (pfile); + + /* Set up an LC_GEN line map to get valid locations for the tokens we are + about to lex. We need to do this after calling start_directive, because + historically pfile->directive_line is what's been passed to + pfile->cb.def_pragma, and we are not proposing to change that now. To + decide if we are in a system header or not, look at the location of the + _Pragma token. So for instance if we have _Pragma(S) in the main file, + where S is a macro defined in a system header, we will decide we are not in + a system location. */ + const unsigned int buf_len = dest - result; + const int sysp = linemap_location_in_system_header_p (pfile->line_table, + pstate->pragma_loc); + linemap_add (pfile->line_table, LC_GEN, sysp, (const char *)result, 1, + buf_len); + const auto col_hint = (uchar *) memchr (result, '\n', buf_len) - result; + linemap_line_start (pfile->line_table, 1, col_hint); + + /* Push the buffer. */ + cpp_push_buffer (pfile, result, buf_len - 2, true); + + /* This is needed to make _Pragma("once") work correctly, as it needs + pfile->buffer->file to be set to the current source file. */ + pfile->buffer->file = pfile->buffer->prev->file; + + /* We are ready to start handling the directive as normal. */ _cpp_clean_line (pfile); - save_directive = pfile->directive; + const auto save_directive = pfile->directive; pfile->directive = &dtable[T_PRAGMA]; do_pragma (pfile); if (pfile->directive_result.type == CPP_PRAGMA) @@ -1931,85 +1979,127 @@ destringize_and_run (cpp_reader *pfile, const cpp_string *in, pfile->directive = save_directive; /* We always insert at least one token, the directive result. It'll - either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we + either be a CPP_PADDING or a CPP_PRAGMA. In the latter case, we need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */ /* If we're not handling the pragma internally, read all of the tokens from - the string buffer now, while the string buffer is still installed. */ - /* ??? Note that the token buffer allocated here is leaked. It's not clear - to me what the true lifespan of the tokens are. It would appear that - the lifespan is the entire parse of the main input stream, in which case - this may not be wrong. */ - if (pfile->directive_result.type == CPP_PRAGMA) - { - int maxcount; - - count = 1; - maxcount = 50; - toks = XNEWVEC (cpp_token, maxcount); - toks[0] = pfile->directive_result; - toks[0].src_loc = expansion_loc; - - do + the string buffer now, while the string buffer is still installed, and then + push them as a new token context after. This way, we can clean up the + temporarily modified state of the lexer now. */ + + const bool is_deferred = (pfile->directive_result.type == CPP_PRAGMA); + if (is_deferred) + { + /* Using _cpp_buff allows us to arrange for this buffer to be freed when + the new token context is popped, without adding any additional space + overhead to the cpp_context structure. In order to support + track_macro_expansion==0, we need to store the cpp_token objects + contiguously, and the virt locs separately. (Note that these tokens + may acquire a virtual loc here, in case the pragma allows macro + expansion. But they will not yet have virtual locs representing them + as part of the expansion of the _Pragma directive; this will be handled + later in _cpp_push__Pragma_token_context. */ + const size_t init_count = 50; + _cpp_buff *tok_buff + = _cpp_get_buff (pfile, init_count * sizeof (cpp_token)); + _cpp_buff *loc_buff + = _cpp_get_buff (pfile, init_count * sizeof (location_t)); + + /* Remember the base buffs so we can chain the final loc buff after it + once we are done collecting tokens. */ + const auto tok_buff0 = tok_buff; + pstate->buff_chain = &loc_buff->next; + + /* DIRECTIVE_RESULT is the first token we return (a CPP_PRAGMA). This + location cannot result from macro expansion, so there is no virtual + location to worry about. */ + auto tok_out = (cpp_token *) tok_buff->base; + *tok_out++ = pfile->directive_result; + auto loc_out = (location_t *) loc_buff->base; + *loc_out++ = pfile->directive_result.src_loc; + unsigned int ntoks = 1; + + /* Finally get all the tokens. */ + for (;;) { - if (count == maxcount) + if (tok_buff->limit - (uchar *)tok_out < (int)sizeof (cpp_token)) { - maxcount = maxcount * 3 / 2; - toks = XRESIZEVEC (cpp_token, toks, maxcount); + _cpp_extend_buff (pfile, &tok_buff, + tok_buff->limit - tok_buff->base); + tok_out = ((cpp_token *)tok_buff->base) + ntoks; } - toks[count] = *cpp_get_token (pfile); - /* _Pragma is a builtin, so we're not within a macro-map, and so - the token locations are set to bogus ordinary locations - near to, but after that of the "_Pragma". - Paper over this by setting them equal to the location of the - _Pragma itself (PR preprocessor/69126). */ - toks[count].src_loc = expansion_loc; + + if (loc_buff->limit - (uchar *)loc_out < (int)sizeof (location_t)) + { + _cpp_extend_buff (pfile, &loc_buff, + loc_buff->limit - loc_buff->base); + loc_out = ((location_t *)loc_buff->base) + ntoks; + } + + const auto this_tok = tok_out; + *tok_out++ = *cpp_get_token_with_location (pfile, loc_out++); + ++ntoks; + /* Macros have been already expanded by cpp_get_token if the pragma allowed expansion. */ - toks[count++].flags |= NO_EXPAND; + this_tok->flags |= NO_EXPAND; + if (this_tok->type == CPP_PRAGMA_EOL) + break; } - while (toks[count-1].type != CPP_PRAGMA_EOL); + + /* Finalize the buffers so they can be stored as one chain in a + cpp_context and freed when that context is popped. */ + tok_buff0->next = loc_buff; + pstate->ntoks = ntoks; + pstate->tok_buff = tok_buff; + pstate->loc_buff = loc_buff; } else { - count = 1; - toks = &pfile->avoid_paste; - /* If we handled the entire pragma internally, make sure we get the line number correct for the next token. */ if (pfile->cb.line_change) pfile->cb.line_change (pfile, pfile->cur_token, false); } - /* Finish inlining run_directive. */ + /* Reset the old state before... */ + const auto map = linemap_add (pfile->line_table, LC_LEAVE, 0, nullptr, 0); + linemap_line_start + (pfile->line_table, + ORDINARY_MAP_STARTING_LINE_NUMBER (linemap_check_ordinary (map)), + 127); pfile->buffer->file = NULL; _cpp_pop_buffer (pfile); - - /* Reset the old macro state before ... */ XDELETE (pfile->context); pfile->context = saved_context; pfile->cur_token = saved_cur_token; pfile->cur_run = saved_cur_run; - /* ... inserting the new tokens we collected. */ - _cpp_push_token_context (pfile, NULL, toks, count); + /* ...inserting the new tokens we collected. This is not a simple call to + _cpp_push_token_context, because we need to create virtual locations + for the tokens and push an extended token context to return them. */ + if (is_deferred) + _cpp_push__Pragma_token_context (pfile, pstate); + else + _cpp_push_token_context (pfile, nullptr, &pfile->avoid_paste, 1); } + /* Handle the _Pragma operator. Return 0 on error, 1 if ok. */ + int -_cpp_do__Pragma (cpp_reader *pfile, location_t expansion_loc) +_cpp_do__Pragma (cpp_reader *pfile, _cpp__Pragma_state *pstate) { /* Make sure we don't invalidate the string token, if the closing parenthesis ended up on a different line. */ ++pfile->keep_tokens; - const cpp_token *string = get__Pragma_string (pfile); + pstate->string_tok = get__Pragma_string (pfile, &pstate->string_loc); --pfile->keep_tokens; pfile->directive_result.type = CPP_PADDING; - - if (string) + if (pstate->string_tok) { - destringize_and_run (pfile, &string->val.str, expansion_loc); + destringize_and_run (pfile, pstate); return 1; } cpp_error (pfile, CPP_DL_ERROR, diff --git a/libcpp/errors.cc b/libcpp/errors.cc index 3269d076af2..54c1c282540 100644 --- a/libcpp/errors.cc +++ b/libcpp/errors.cc @@ -60,13 +60,11 @@ cpp_diagnostic_at (cpp_reader * pfile, enum cpp_diagnostic_level level, enum cpp_warning_reason reason, rich_location *richloc, const char *msgid, va_list *ap) { - bool ret; - if (!pfile->cb.diagnostic) abort (); - ret = pfile->cb.diagnostic (pfile, level, reason, richloc, _(msgid), ap); - - return ret; + if (pfile->diagnostic_rebase_loc) + _cpp_rebase_diagnostic_location (pfile, richloc); + return pfile->cb.diagnostic (pfile, level, reason, richloc, _(msgid), ap); } /* Print a diagnostic at the location of the previously lexed token. */ @@ -197,16 +195,14 @@ cpp_diagnostic_with_line (cpp_reader * pfile, enum cpp_diagnostic_level level, location_t src_loc, unsigned int column, const char *msgid, va_list *ap) { - bool ret; - if (!pfile->cb.diagnostic) abort (); rich_location richloc (pfile->line_table, src_loc); if (column) richloc.override_column (column); - ret = pfile->cb.diagnostic (pfile, level, reason, &richloc, _(msgid), ap); - - return ret; + if (pfile->diagnostic_rebase_loc) + _cpp_rebase_diagnostic_location (pfile, &richloc); + return pfile->cb.diagnostic (pfile, level, reason, &richloc, _(msgid), ap); } /* Print a warning or error, depending on the value of LEVEL. */ diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h index 76617fe6129..ae32584c264 100644 --- a/libcpp/include/line-map.h +++ b/libcpp/include/line-map.h @@ -1812,6 +1812,7 @@ class rich_location location_range *get_range (unsigned int idx); expanded_location get_expanded_location (unsigned int idx); + void forget_cached_expanded_location () { m_have_expanded_location = false; } void override_column (int column); diff --git a/libcpp/internal.h b/libcpp/internal.h index 8b74d10c1a3..b6118d7128b 100644 --- a/libcpp/internal.h +++ b/libcpp/internal.h @@ -292,6 +292,28 @@ struct lexer_state unsigned char ignore__Pragma; }; +/* Because handling of _Pragma bounces back and forth between macro.cc and + directives.cc, it is useful to keep the needed state in one place. */ +struct _cpp__Pragma_state +{ + const cpp_token *string_tok; /* The token for the argument string. */ + + /* These locations are the virtual locations returned by + cpp_get_token_with_location, if the relevant tokens came from macro + expansions. */ + location_t pragma_loc; /* Location of the _Pragma token. */ + location_t string_loc; /* Location of the string arg. */ + + /* The tokens lexed from the _Pragma string. */ + unsigned int ntoks; + _cpp_buff *tok_buff; + _cpp_buff *loc_buff; + _cpp_buff **buff_chain; +}; + +/* In macro.cc, implements pstate->diagnostic_rebase_loc handling. */ +void _cpp_rebase_diagnostic_location (cpp_reader *, rich_location *); + /* Special nodes - identifiers with predefined significance. */ struct spec_nodes { @@ -601,6 +623,12 @@ struct cpp_reader zero of said file. */ location_t main_loc; + /* Location from which we would like to pretend a given token was + macro-expanded, if a diagnostic is issued. Useful for improving + _Pragma diagnostics. */ + location_t diagnostic_rebase_loc; + cpp_hashnode *diagnostic_rebase_node; + /* Returns true iff we should warn about UTF-8 bidirectional control characters. */ bool warn_bidi_p () const @@ -701,6 +729,8 @@ extern const unsigned char *_cpp_builtin_macro_text (cpp_reader *, extern int _cpp_warn_if_unused_macro (cpp_reader *, cpp_hashnode *, void *); extern void _cpp_push_token_context (cpp_reader *, cpp_hashnode *, const cpp_token *, unsigned int); +extern void _cpp_push__Pragma_token_context (cpp_reader *, + _cpp__Pragma_state *); extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int); /* In identifiers.cc */ @@ -772,7 +802,7 @@ extern int _cpp_handle_directive (cpp_reader *, bool); extern void _cpp_define_builtin (cpp_reader *, const char *); extern char ** _cpp_save_pragma_names (cpp_reader *); extern void _cpp_restore_pragma_names (cpp_reader *, char **); -extern int _cpp_do__Pragma (cpp_reader *, location_t); +extern int _cpp_do__Pragma (cpp_reader *, _cpp__Pragma_state *); extern void _cpp_init_directives (cpp_reader *); extern void _cpp_init_internal_pragmas (cpp_reader *); extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *, diff --git a/libcpp/macro.cc b/libcpp/macro.cc index dada8fea835..864e7dabc38 100644 --- a/libcpp/macro.cc +++ b/libcpp/macro.cc @@ -93,6 +93,8 @@ struct macro_arg_saved_data { static const char *vaopt_paste_error = N_("'##' cannot appear at either end of __VA_OPT__"); +static const uchar pragma_str[] = N_("<_Pragma directive>"); + static void expand_arg (cpp_reader *, macro_arg *); /* A class for tracking __VA_OPT__ state while iterating over a @@ -756,7 +758,31 @@ builtin_macro (cpp_reader *pfile, cpp_hashnode *node, if (pfile->state.in_directive || pfile->state.ignore__Pragma) return 0; - return _cpp_do__Pragma (pfile, loc); + _cpp__Pragma_state pstate = {}; + pstate.pragma_loc = loc; + + /* The diagnostic_rebase stuff arranges that any diagnostics issued during + lexing will point the user back to the _Pragma location. */ + const auto prev_rloc = pfile->diagnostic_rebase_loc; + const auto prev_rnode = pfile->diagnostic_rebase_node; + pfile->diagnostic_rebase_loc = loc; + pfile->diagnostic_rebase_node + = cpp_lookup (pfile, pragma_str, (sizeof pragma_str) - 1); + + /* While lexing tokens, if we end up expanding some macros, we would + like not to override top_most_macro_node; preserving it pointing + to the _Pragma helps out the case of -ftrack-macro-expansion=0. + Setting this flag causes in_macro_expansion_p to return TRUE, + even though we are not technically in a macro context. */ + const bool prev_expand = pfile->about_to_expand_macro_p; + pfile->about_to_expand_macro_p = true; + + /* Get the tokens, then reset everything back how it was. */ + const int res = _cpp_do__Pragma (pfile, &pstate); + pfile->about_to_expand_macro_p = prev_expand; + pfile->diagnostic_rebase_loc = prev_rloc; + pfile->diagnostic_rebase_node = prev_rnode; + return res; } buf = _cpp_builtin_macro_text (pfile, node, expand_loc); @@ -2802,7 +2828,8 @@ _cpp_pop_context (cpp_reader *pfile) && macro_of_context (context->prev) != macro) macro->flags &= ~NODE_DISABLED; - if (macro == pfile->top_most_macro_node && context->prev == NULL) + if (!pfile->about_to_expand_macro_p + && context->prev == &pfile->base_context) /* We are popping the context of the top-most macro node. */ pfile->top_most_macro_node = NULL; } @@ -2836,10 +2863,10 @@ reached_end_of_context (cpp_context *context) /* Consume the next token contained in the current context of PFILE, and return it in *TOKEN. It's "full location" is returned in - *LOCATION. If -ftrack-macro-location is in effeect, fFull location" - means the location encoding the locus of the token across macro - expansion; otherwise it's just is the "normal" location of the - token which (*TOKEN)->src_loc. */ + *LOCATION. If -ftrack-macro-location is in effect, "full location" + means the virtual location encoding the locus of the token across macro + expansion; otherwise it's just the "normal" (spelling) location of the + token, which is (*TOKEN)->src_loc. */ static inline void consume_next_token_from_context (cpp_reader *pfile, const cpp_token ** token, @@ -4137,3 +4164,90 @@ cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node, *buffer = '\0'; return pfile->macro_buffer; } + +/* Handle the list of tokens lexed from a _Pragma string. We need to create + virtual locations (reflecting the fact that these tokens are logically + within the expansion of the _Pragma string), and push an extended token + context. */ + +void +_cpp_push__Pragma_token_context (cpp_reader *pfile, + _cpp__Pragma_state *pstate) +{ + const auto node = cpp_lookup (pfile, pragma_str, (sizeof pragma_str) - 1); + const auto toks = (const cpp_token *) pstate->tok_buff->base; + + /* If not tracking macro expansions, then just push a normal token context. + cpp_get_token () will return the user the location of the _Pragma + directive, so they will have a valid location for the _Pragma which is + outside the LC_GEN map. */ + if (!CPP_OPTION (pfile, track_macro_expansion)) + { + _cpp_push_token_context (pfile, node, toks, pstate->ntoks); + /* Arrange to free the buffers when the context is popped. */ + pfile->context->buff = pstate->tok_buff; + return; + } + + location_t *virt_locs = nullptr; + _cpp_buff *const macro_tokens = tokens_buff_new (pfile, pstate->ntoks, + &virt_locs); + const auto map = linemap_enter_macro (pfile->line_table, node, + pstate->pragma_loc, pstate->ntoks); + const auto locs = (location_t *)pstate->loc_buff->base; + for (unsigned int i = 0; i != pstate->ntoks; ++i) + { + tokens_buff_add_token (macro_tokens, virt_locs, toks + i, + locs[i], locs[i], map, i); + } + + /* Chain tok_buff ahead of macro_tokens so both are freed together + when the context is popped. pstate->buff_chain is the NEXT pointer + of the last buffer in the LOC_BUFF chain, so it looks like: + TOK_BUFF_1 -> ... -> TOK_BUFF_N -> ... -> LOC_BUFF_1 -> ... -> + LOC_BUFF_N -> MACRO_TOKENS_1 -> ... -> MACRO_TOKENS_N. */ + *pstate->buff_chain = macro_tokens; + push_extended_tokens_context (pfile, node, pstate->tok_buff, virt_locs, + (const cpp_token **) macro_tokens->base, + pstate->ntoks); +} + +void +_cpp_rebase_diagnostic_location (cpp_reader *pfile, rich_location *richloc) +{ + /* If we are here, it means a diagnostic is being generated while lexing + tokens outside a macro context, but pfile->diagnostic_rebase_loc indicates + a location from which we would like to pretend we are actually expanding a + macro. This works around the fact that a macro map can only be generated + once we know how many tokens it will contain, but the number of tokens to + be lexed from, say, a _Pragma string, is not known ahead of time. In the + case of _Pragma, _cpp_push__Pragma_token_context above handles creating the + proper macro map once all the tokens are available. This function runs + earlier than that, while in the middle of lexing tokens, so it creates a + temporary macro map which serves only to improve the information content of + the diagnostic that's about to be generated. */ + + const int nlocs = richloc->get_num_locations (); + + if (CPP_OPTION (pfile, track_macro_expansion)) + { + const auto map + = linemap_enter_macro (pfile->line_table, pfile->diagnostic_rebase_node, + pfile->diagnostic_rebase_loc, nlocs); + for (int i = 0; i != nlocs; ++i) + { + location_range &r = *richloc->get_range (i); + r.m_loc = linemap_add_macro_token (map, i, r.m_loc, r.m_loc); + } + } + else + { + /* When not tracking macro expansion, then set the location to the + expansion point for all tokens, which is what would be returned + by cpp_get_token in the normal case. */ + for (int i = 0; i != nlocs; ++i) + richloc->get_range (i)->m_loc = pfile->invocation_location; + } + + richloc->forget_cached_expanded_location (); +} diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/reduction-5.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/reduction-5.c index ddccfe89e73..f518915492d 100644 --- a/libgomp/testsuite/libgomp.oacc-c-c++-common/reduction-5.c +++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/reduction-5.c @@ -46,7 +46,8 @@ main (void) /* Nvptx targets require a vector_length or 32 in to allow spinlocks with gangs. */ check_reduction (num_workers (nw) vector_length (vl), worker); /* { dg-line check_reduction_loc } */ - /* { dg-warning "22:region is vector partitioned but does not contain vector partitioned code" "" { target *-*-* } pragma_loc } + /* { dg-warning "1:region is vector partitioned but does not contain vector partitioned code" "" { target *-*-* } 1 } + { dg-note "22:in <_Pragma directive>" "" { target *-*-* xfail offloading_enabled} pragma_loc } { dg-note "1:in expansion of macro 'DO_PRAGMA'" "" { target *-*-* xfail offloading_enabled } DO_PRAGMA_loc } { dg-note "3:in expansion of macro 'check_reduction'" "" { target *-*-* xfail offloading_enabled } check_reduction_loc } TODO See PR101551 for 'offloading_enabled' XFAILs. */ diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/vred2d-128.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/vred2d-128.c index 84e6d51670b..bd2567d96f8 100644 --- a/libgomp/testsuite/libgomp.oacc-c-c++-common/vred2d-128.c +++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/vred2d-128.c @@ -40,46 +40,54 @@ int a1[n], a2[n]; gentest (test1, "acc parallel loop gang vector_length (128) firstprivate (t1, t2)", "acc loop vector reduction(+:t1) reduction(-:t2)") -/* { dg-warning {'t1' is used uninitialized} {} { target *-*-* } outer } +/* { dg-warning {'t1' is used uninitialized} {} { target *-*-* } 1 } + { dg-note {in <_Pragma directive>} {} { target { ! offloading_enabled } } outer } { dg-note {'t1' was declared here} {} { target *-*-* } vars } - { dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-4 } + { dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-5 } TODO See PR101551 for 'offloading_enabled' differences. */ -/* { dg-warning {'t2' is used uninitialized} {} { target *-*-* } outer } +/* { dg-warning {'t2' is used uninitialized} {} { target *-*-* } 1 } + { DUPdg-note {in <_Pragma directive>} {} { target { ! offloading_enabled } } outer } { dg-note {'t2' was declared here} {} { target *-*-* } vars } - { DUP_dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-8 } + { DUP_dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-10 } TODO See PR101551 for 'offloading_enabled' differences. */ gentest (test2, "acc parallel loop gang vector_length (128) firstprivate (t1, t2)", "acc loop worker vector reduction(+:t1) reduction(-:t2)") -/* { DUPdg-warning {'t1' is used uninitialized} {} { target *-*-* } outer } +/* { DUPdg-warning {'t1' is used uninitialized} {} { target *-*-* } 1 } + { DUPdg-note {in <_Pragma directive>} {} { target { ! offloading_enabled } } outer } { DUP_dg-note {'t1' was declared here} {} { target *-*-* } vars } - { dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-4 } + { dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-5 } TODO See PR101551 for 'offloading_enabled' differences. */ -/* { DUPdg-warning {'t2' is used uninitialized} {} { target *-*-* } outer } +/* { DUPdg-warning {'t2' is used uninitialized} {} { target *-*-* } 1 } + { DUPdg-note {in <_Pragma directive>} {} { target { ! offloading_enabled } } outer } { DUP_dg-note {'t2' was declared here} {} { target *-*-* } vars } - { DUP_dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-8 } + { DUP_dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-10 } TODO See PR101551 for 'offloading_enabled' differences. */ gentest (test3, "acc parallel loop gang worker vector_length (128) firstprivate (t1, t2)", "acc loop vector reduction(+:t1) reduction(-:t2)") -/* { DUPdg-warning {'t1' is used uninitialized} {} { target *-*-* } outer } +/* { DUPdg-warning {'t1' is used uninitialized} {} { target *-*-* } 1 } + { DUPdg-note {in <_Pragma directive>} {} { target { ! offloading_enabled } } outer } { DUP_dg-note {'t1' was declared here} {} { target *-*-* } vars } - { dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-4 } + { dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-5 } TODO See PR101551 for 'offloading_enabled' differences. */ -/* { DUPdg-warning {'t2' is used uninitialized} {} { target *-*-* } outer } +/* { DUPdg-warning {'t2' is used uninitialized} {} { target *-*-* } 1 } + { DUPdg-note {in <_Pragma directive>} {} { target { ! offloading_enabled } } outer } { DUP_dg-note {'t2' was declared here} {} { target *-*-* } vars } - { DUP_dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-8 } + { DUP_dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-10 } TODO See PR101551 for 'offloading_enabled' differences. */ gentest (test4, "acc parallel loop firstprivate (t1, t2)", "acc loop reduction(+:t1) reduction(-:t2)") -/* { DUPdg-warning {'t1' is used uninitialized} {} { target *-*-* } outer } +/* { DUPdg-warning {'t1' is used uninitialized} {} { target *-*-* } 1 } + { DUPdg-note {in <_Pragma directive>} {} { target { ! offloading_enabled } } outer } { DUP_dg-note {'t1' was declared here} {} { target *-*-* } vars } - { dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-4 } + { dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-5 } TODO See PR101551 for 'offloading_enabled' differences. */ -/* { DUPdg-warning {'t2' is used uninitialized} {} { target *-*-* } outer } +/* { DUPdg-warning {'t2' is used uninitialized} {} { target *-*-* } 1 } + { DUPdg-note {in <_Pragma directive>} {} { target { ! offloading_enabled } } outer } { DUP_dg-note {'t2' was declared here} {} { target *-*-* } vars } - { DUP_dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-8 } + { DUP_dg-note {in expansion of macro 'gentest'} {} { target { ! offloading_enabled } } .-10 } TODO See PR101551 for 'offloading_enabled' differences. */ From patchwork Wed Aug 9 22:14:14 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lewis Hyatt X-Patchwork-Id: 1819644 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=LPx6a0sB; dkim-atps=neutral Received: from server2.sourceware.org (ip-8-43-85-97.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 (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RLks41v2Pz1yYl for ; Thu, 10 Aug 2023 08:15:36 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 2AFDA3856DF8 for ; Wed, 9 Aug 2023 22:15:34 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 2AFDA3856DF8 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691619334; bh=r3pPrWqQYQ7C8r1NsXpqvjXME+banAHcGjkccqn77Lg=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=LPx6a0sBfgiVkvVWDNlQ/xa2yYhnjNFabE/rCIxKTjL4QqKXXOaWk+J0A1OyNAoq7 BlcycS9wrnmSQJ6BjC8eYLZXV2JVgQyS/1GFDBGM7cUP9ARyJzsZzg3cU+JjKitFls vKHptGiwsyC4/0MtOSZjswAOctZGukMZ5YmxXLcE= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-qt1-x82e.google.com (mail-qt1-x82e.google.com [IPv6:2607:f8b0:4864:20::82e]) by sourceware.org (Postfix) with ESMTPS id 86C64385770F for ; Wed, 9 Aug 2023 22:14:53 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 86C64385770F Received: by mail-qt1-x82e.google.com with SMTP id d75a77b69052e-40fc670197aso6961461cf.1 for ; Wed, 09 Aug 2023 15:14:53 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691619293; x=1692224093; 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=r3pPrWqQYQ7C8r1NsXpqvjXME+banAHcGjkccqn77Lg=; b=lBHNMLsHtr3DVrVoKrsT1RP6CuO3LJtI/orHDD1UCmY7XUnBhJSc3mOsv3bq0orfeI om6vR4pVyvR/wzT2QpcYlRlzrmfSAQz9FlX6C6ky9Vf6ukDkoPUQvL2Ldo7jFef3ozrz 2IWUkE3yWO+au6MewP3O5PxprTpnpIe4rgfBb3IKfCIj2wcUZILIJGHaubo71EmGmEby NCjtemHzO9m522eCPBNvAlc0kBn6c4/i302aa4sSSEYmbD+neWdEqBV50EdJ0SLRlX7k nEuJ014n4emxwJIJVHvD9Rf2oFlG4gH2Pkqg+d0WpgiRSeM2+5KOcQk9Ow3JfvbF9TUd kIvA== X-Gm-Message-State: AOJu0Yylp+QfkSpHRqcVkuicC3YKt0UWzWfdhkGc5sNOk2kXe3Qchsob eTnTJROOKUyxYXYCSvFEExvPdEQpLok= X-Google-Smtp-Source: AGHT+IH+Js0S4cNwmd5hBb2lg0DMYd27tTLM77hniLO0pDFS2BEefgBfzTkc6N/ZiVSVl24rtFEzDQ== X-Received: by 2002:ac8:5b08:0:b0:40c:21b2:40ab with SMTP id m8-20020ac85b08000000b0040c21b240abmr244849qtw.22.1691619292690; Wed, 09 Aug 2023 15:14:52 -0700 (PDT) Received: from localhost.localdomain (96-67-140-173-static.hfc.comcastbusiness.net. [96.67.140.173]) by smtp.gmail.com with ESMTPSA id ce11-20020a05622a41cb00b0040fef71dc1esm46334qtb.10.2023.08.09.15.14.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Aug 2023 15:14:52 -0700 (PDT) To: gcc-patches@gcc.gnu.org Cc: David Malcolm , Lewis Hyatt Subject: [PATCH v4 8/8] diagnostics: Support generated data locations in SARIF output Date: Wed, 9 Aug 2023 18:14:14 -0400 Message-Id: <20230809221414.2849878-9-lhyatt@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230809221414.2849878-1-lhyatt@gmail.com> References: <20230809221414.2849878-1-lhyatt@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3038.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lewis Hyatt via Gcc-patches From: Lewis Hyatt Reply-To: Lewis Hyatt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" The diagnostics routines for SARIF output need to read the source code back in, so that they can generate "snippet" and "content" records, so they need to be able to cope with generated data locations. Add support for that in diagnostic-format-sarif.cc. gcc/ChangeLog: * diagnostic-format-sarif.cc (class sarif_builder): Adapt interface to support generated data locations. (sarif_builder::maybe_make_physical_location_object): Change the m_filenames hash_set to support generated data. (sarif_builder::make_artifact_location_object): Use a source_id rather than a plain file name. (sarif_builder::maybe_make_region_object): Adapt to expanded_location interface changes. (sarif_builder::maybe_make_region_object_for_context): Likewise. (sarif_builder::make_artifact_object): Likewise. (sarif_builder::make_run_object): Handle generated data. (sarif_builder::maybe_make_artifact_content_object): Likewise. (get_source_lines): Likewise. gcc/testsuite/ChangeLog: * c-c++-common/diagnostic-format-sarif-file-5.c: New test. --- gcc/diagnostic-format-sarif.cc | 88 +++++++++++-------- .../diagnostic-format-sarif-file-5.c | 31 +++++++ 2 files changed, 82 insertions(+), 37 deletions(-) create mode 100644 gcc/testsuite/c-c++-common/diagnostic-format-sarif-file-5.c diff --git a/gcc/diagnostic-format-sarif.cc b/gcc/diagnostic-format-sarif.cc index 1eff71962d7..c7c0e5d4b0a 100644 --- a/gcc/diagnostic-format-sarif.cc +++ b/gcc/diagnostic-format-sarif.cc @@ -174,7 +174,7 @@ private: json::array *maybe_make_kinds_array (diagnostic_event::meaning m) const; json::object *maybe_make_physical_location_object (location_t loc); json::object *make_artifact_location_object (location_t loc); - json::object *make_artifact_location_object (const char *filename); + json::object *make_artifact_location_object (source_id src); json::object *make_artifact_location_object_for_pwd () const; json::object *maybe_make_region_object (location_t loc) const; json::object *maybe_make_region_object_for_context (location_t loc) const; @@ -197,9 +197,9 @@ private: json::object *make_reporting_descriptor_object_for_cwe_id (int cwe_id) const; json::object * make_reporting_descriptor_reference_object_for_cwe_id (int cwe_id); - json::object *make_artifact_object (const char *filename); - json::object *maybe_make_artifact_content_object (const char *filename) const; - json::object *maybe_make_artifact_content_object (const char *filename, + json::object *make_artifact_object (source_id src); + json::object *maybe_make_artifact_content_object (source_id src) const; + json::object *maybe_make_artifact_content_object (source_id src, int start_line, int end_line) const; json::object *make_fix_object (const rich_location &rich_loc); @@ -220,7 +220,11 @@ private: diagnostic group. */ sarif_result *m_cur_group_result; - hash_set m_filenames; + /* If the second member is >0, then this is a buffer of generated content, + with that length, not a filename. */ + hash_set , + int_hash > + > m_filenames; bool m_seen_any_relative_paths; hash_set m_rule_id_set; json::array *m_rules_arr; @@ -787,7 +791,8 @@ sarif_builder::maybe_make_physical_location_object (location_t loc) /* "artifactLocation" property (SARIF v2.1.0 section 3.29.3). */ json::object *artifact_loc_obj = make_artifact_location_object (loc); phys_loc_obj->set ("artifactLocation", artifact_loc_obj); - m_filenames.add (LOCATION_FILE (loc)); + const auto src = LOCATION_SRC (loc); + m_filenames.add ({src.get_filename_or_buffer (), src.get_buffer_len ()}); /* "region" property (SARIF v2.1.0 section 3.29.4). */ if (json::object *region_obj = maybe_make_region_object (loc)) @@ -811,7 +816,7 @@ sarif_builder::maybe_make_physical_location_object (location_t loc) json::object * sarif_builder::make_artifact_location_object (location_t loc) { - return make_artifact_location_object (LOCATION_FILE (loc)); + return make_artifact_location_object (LOCATION_SRC (loc)); } /* The ID value for use in "uriBaseId" properties (SARIF v2.1.0 section 3.4.4) @@ -823,10 +828,13 @@ sarif_builder::make_artifact_location_object (location_t loc) or return NULL. */ json::object * -sarif_builder::make_artifact_location_object (const char *filename) +sarif_builder::make_artifact_location_object (source_id src) { json::object *artifact_loc_obj = new json::object (); + const auto filename = src.is_buffer () + ? special_fname_generated () : src.get_filename_or_buffer (); + /* "uri" property (SARIF v2.1.0 section 3.4.3). */ artifact_loc_obj->set ("uri", new json::string (filename)); @@ -912,9 +920,9 @@ sarif_builder::maybe_make_region_object (location_t loc) const expanded_location exploc_start = expand_location (start_loc); expanded_location exploc_finish = expand_location (finish_loc); - if (exploc_start.file !=exploc_caret.file) + if (exploc_start.src != exploc_caret.src) return NULL; - if (exploc_finish.file !=exploc_caret.file) + if (exploc_finish.src != exploc_caret.src) return NULL; json::object *region_obj = new json::object (); @@ -963,9 +971,9 @@ sarif_builder::maybe_make_region_object_for_context (location_t loc) const expanded_location exploc_start = expand_location (start_loc); expanded_location exploc_finish = expand_location (finish_loc); - if (exploc_start.file !=exploc_caret.file) + if (exploc_start.src != exploc_caret.src) return NULL; - if (exploc_finish.file !=exploc_caret.file) + if (exploc_finish.src != exploc_caret.src) return NULL; json::object *region_obj = new json::object (); @@ -979,9 +987,9 @@ sarif_builder::maybe_make_region_object_for_context (location_t loc) const /* "snippet" property (SARIF v2.1.0 section 3.30.13). */ if (json::object *artifact_content_obj - = maybe_make_artifact_content_object (exploc_start.file, - exploc_start.line, - exploc_finish.line)) + = maybe_make_artifact_content_object (exploc_start.src, + exploc_start.line, + exploc_finish.line)) region_obj->set ("snippet", artifact_content_obj); return region_obj; @@ -1298,7 +1306,10 @@ sarif_builder::make_run_object (sarif_invocation *invocation_obj, json::array *artifacts_arr = new json::array (); for (auto iter : m_filenames) { - json::object *artifact_obj = make_artifact_object (iter); + const auto src = iter.second + ? source_id {iter.first, iter.second} /* Memory buffer. */ + : source_id {iter.first}; /* Filename. */ + json::object *artifact_obj = make_artifact_object (src); artifacts_arr->append (artifact_obj); } run_obj->set ("artifacts", artifacts_arr); @@ -1472,37 +1483,37 @@ sarif_builder::maybe_make_cwe_taxonomy_object () const /* Make an artifact object (SARIF v2.1.0 section 3.24). */ json::object * -sarif_builder::make_artifact_object (const char *filename) +sarif_builder::make_artifact_object (source_id src) { json::object *artifact_obj = new json::object (); /* "location" property (SARIF v2.1.0 section 3.24.2). */ - json::object *artifact_loc_obj = make_artifact_location_object (filename); + json::object *artifact_loc_obj = make_artifact_location_object (src); artifact_obj->set ("location", artifact_loc_obj); /* "contents" property (SARIF v2.1.0 section 3.24.8). */ if (json::object *artifact_content_obj - = maybe_make_artifact_content_object (filename)) + = maybe_make_artifact_content_object (src)) artifact_obj->set ("contents", artifact_content_obj); /* "sourceLanguage" property (SARIF v2.1.0 section 3.24.10). */ if (m_context->m_client_data_hooks) if (const char *source_lang = m_context->m_client_data_hooks->maybe_get_sarif_source_language - (filename)) + (src.get_filename_or_buffer ())) artifact_obj->set ("sourceLanguage", new json::string (source_lang)); return artifact_obj; } /* Make an artifactContent object (SARIF v2.1.0 section 3.3) for the - full contents of FILENAME. */ + full contents of SRC. */ json::object * -sarif_builder::maybe_make_artifact_content_object (const char *filename) const +sarif_builder::maybe_make_artifact_content_object (source_id src) const { /* Let input.cc handle any charset conversion. */ - char_span utf8_content = get_source_file_content (filename); + char_span utf8_content = get_source_file_content (src); if (!utf8_content) return NULL; @@ -1518,10 +1529,12 @@ sarif_builder::maybe_make_artifact_content_object (const char *filename) const } /* Attempt to read the given range of lines from FILENAME; return - a freshly-allocated 0-terminated buffer containing them, or NULL. */ + a freshly-allocated buffer containing them, or NULL. + The buffer is null-terminated, but could also contain embedded null + bytes, so the char_span's length() accessor should be used. */ -static char * -get_source_lines (const char *filename, +static char_span +get_source_lines (source_id src, int start_line, int end_line) { @@ -1529,9 +1542,9 @@ get_source_lines (const char *filename, for (int line = start_line; line <= end_line; line++) { - char_span line_content = location_get_source_line (filename, line); + char_span line_content = location_get_source_line (src, line); if (!line_content.get_buffer ()) - return NULL; + return char_span (nullptr, 0); result.reserve (line_content.length () + 1); for (size_t i = 0; i < line_content.length (); i++) result.quick_push (line_content[i]); @@ -1539,33 +1552,34 @@ get_source_lines (const char *filename, } result.safe_push ('\0'); - return xstrdup (result.address ()); + return char_span (xstrdup (result.address ()), result.length () - 1); } /* Make an artifactContent object (SARIF v2.1.0 section 3.3) for the given - run of lines within FILENAME (including the endpoints). */ + run of lines in the source code identified by SRC (including the + endpoints). */ json::object * -sarif_builder::maybe_make_artifact_content_object (const char *filename, +sarif_builder::maybe_make_artifact_content_object (source_id src, int start_line, int end_line) const { - char *text_utf8 = get_source_lines (filename, start_line, end_line); + const char_span text_utf8 = get_source_lines (src, start_line, end_line); if (!text_utf8) return NULL; /* Don't add it if it's not valid UTF-8. */ - if (!cpp_valid_utf8_p(text_utf8, strlen(text_utf8))) + if (!cpp_valid_utf8_p (text_utf8.get_buffer (), text_utf8.length ())) { - free (text_utf8); + free (const_cast (text_utf8.get_buffer ())); return NULL; } json::object *artifact_content_obj = new json::object (); - artifact_content_obj->set ("text", new json::string (text_utf8)); - free (text_utf8); - + artifact_content_obj->set ("text", new json::string (text_utf8.get_buffer (), + text_utf8.length ())); + free (const_cast (text_utf8.get_buffer ())); return artifact_content_obj; } diff --git a/gcc/testsuite/c-c++-common/diagnostic-format-sarif-file-5.c b/gcc/testsuite/c-c++-common/diagnostic-format-sarif-file-5.c new file mode 100644 index 00000000000..2ca6a069d3f --- /dev/null +++ b/gcc/testsuite/c-c++-common/diagnostic-format-sarif-file-5.c @@ -0,0 +1,31 @@ +/* The goal is to test SARIF output of generated data, such as a _Pragma string. + But SARIF output as of yet does not output macro definitions, so such + generated data buffers never end up in the typical SARIF output. One way we + can achieve it is to use -fdump-internal-locations, which outputs top-level + diagnostic notes inside macro definitions, that SARIF will end up processing. + It also outputs a lot of other stuff to stderr (not to the SARIF file) that + is not relevant to this test, so we use a blanket dg-regexp to filter all of + that away. */ + +/* { dg-do compile } */ +/* { dg-options "-fdiagnostics-format=sarif-file -fdump-internal-locations" } */ +/* { dg-allow-blank-lines-in-output "" } */ + +_Pragma("GCC diagnostic push") + +/* { dg-regexp {(.|[\n\r])*} } */ + +/* Because of the way -fdump-internal-locations works, these regexes themselves + will end up in the sarif output also. But due to the escaping, they don't + match themselves, so they still test what we need. */ + +/* Four of this pair are output for the tokens inside the + _Pragma string (3 plus a PRAGMA_EOL). */ + +/* { dg-final { scan-sarif-file "\"artifactLocation\": \{\"uri\": \"\"," } } */ +/* { dg-final { scan-sarif-file "\"snippet\": \{\"text\": \"GCC diagnostic push\\\\n\"" } } */ + +/* One of this pair is output for the overall internal location. */ + +/* { dg-final { scan-sarif-file "\{\"location\": \{\"uri\": \"\"," } } */ +/* { dg-final { scan-sarif-file "\"contents\": \{\"text\": \"GCC diagnostic push\\\\n\\\\0" } } */