| /* Caching input files for use by diagnostics. | |
| Copyright (C) 2004-2026 Free Software Foundation, Inc. | |
| This file is part of GCC. | |
| GCC is free software; you can redistribute it and/or modify it under | |
| the terms of the GNU General Public License as published by the Free | |
| Software Foundation; either version 3, or (at your option) any later | |
| version. | |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with GCC; see the file COPYING3. If not see | |
| <http://www.gnu.org/licenses/>. */ | |
| #include "config.h" | |
| #include "system.h" | |
| #include "coretypes.h" | |
| #include "cpplib.h" | |
| #include "diagnostics/file-cache.h" | |
| #include "diagnostics/dumping.h" | |
| #include "selftest.h" | |
| #ifndef HAVE_ICONV | |
| #define HAVE_ICONV 0 | |
| #endif | |
| namespace diagnostics { | |
| /* Input charset configuration. */ | |
| static const char *default_charset_callback (const char *) | |
| { | |
| return nullptr; | |
| } | |
| void | |
| file_cache::initialize_input_context (diagnostic_input_charset_callback ccb, | |
| bool should_skip_bom) | |
| { | |
| m_input_context.ccb = (ccb ? ccb : default_charset_callback); | |
| m_input_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 | |
| { | |
| public: | |
| file_cache_slot (); | |
| ~file_cache_slot (); | |
| void dump (FILE *out, int indent) const; | |
| void DEBUG_FUNCTION dump () const { dump (stderr, 0); } | |
| 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; } | |
| unsigned get_use_count () const { return m_use_count; } | |
| bool missing_trailing_newline_p () const | |
| { | |
| return m_missing_trailing_newline; | |
| } | |
| char_span get_full_file_content (); | |
| void inc_use_count () { m_use_count++; } | |
| bool create (const file_cache::input_context &in_context, | |
| const char *file_path, FILE *fp, unsigned highest_use_count); | |
| void evict (); | |
| void set_content (const char *buf, size_t sz); | |
| static size_t tune (size_t line_record_size_) | |
| { | |
| size_t ret = line_record_size; | |
| line_record_size = line_record_size_; | |
| return ret; | |
| } | |
| private: | |
| /* These are information used to store a line boundary. */ | |
| class line_info | |
| { | |
| public: | |
| /* The line number. It starts from 1. */ | |
| size_t line_num; | |
| /* The position (byte count) of the beginning of the line, | |
| relative to the file data pointer. 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. */ | |
| size_t end_pos; | |
| line_info (size_t l, size_t s, size_t e) | |
| : line_num (l), start_pos (s), end_pos (e) | |
| {} | |
| line_info () | |
| :line_num (0), start_pos (0), end_pos (0) | |
| {} | |
| static bool less_than(const line_info &a, const line_info &b) | |
| { | |
| return a.line_num < b.line_num; | |
| } | |
| }; | |
| 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 size_t line_record_size; | |
| static size_t recent_cached_lines_shift; | |
| /* 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. This copy is owned by the slot. */ | |
| char *m_file_path; | |
| FILE *m_fp; | |
| /* True when an read error happened. */ | |
| bool m_error; | |
| /* 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; | |
| /* 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. When the lines exceed line_record_size | |
| this is scaled down dynamically, with the line_info becoming anchors. */ | |
| vec<line_info, va_heap> m_line_record; | |
| /* A cache of the recently seen lines. This is maintained as a ring | |
| buffer. */ | |
| vec<line_info, va_heap> m_line_recent; | |
| /* First and last valid entry in m_line_recent. */ | |
| size_t m_line_recent_last, m_line_recent_first; | |
| 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; | |
| } | |
| }; | |
| size_t file_cache_slot::line_record_size = 0; | |
| size_t file_cache_slot::recent_cached_lines_shift = 8; | |
| /* Tune file_cache. */ | |
| void | |
| file_cache::tune (size_t num_file_slots, size_t lines) | |
| { | |
| if (file_cache_slot::tune (lines) != lines | |
| || m_num_file_slots != num_file_slots) | |
| { | |
| delete[] m_file_slots; | |
| m_file_slots = new file_cache_slot[num_file_slots]; | |
| } | |
| m_num_file_slots = num_file_slots; | |
| } | |
| static const char * | |
| find_end_of_line (const char *s, size_t len); | |
| /* Lookup the cache used for the content of a given file accessed by | |
| caret diagnostic. Return the found cached file, or NULL if no | |
| cached file was found. */ | |
| file_cache_slot * | |
| file_cache::lookup_file (const char *file_path) | |
| { | |
| gcc_assert (file_path); | |
| /* This will contain the found cached file. */ | |
| file_cache_slot *r = NULL; | |
| for (unsigned i = 0; i < m_num_file_slots; ++i) | |
| { | |
| file_cache_slot *c = &m_file_slots[i]; | |
| if (c->get_file_path () && !strcmp (c->get_file_path (), file_path)) | |
| { | |
| c->inc_use_count (); | |
| r = c; | |
| } | |
| } | |
| if (r) | |
| r->inc_use_count (); | |
| return r; | |
| } | |
| /* Purge any mention of FILENAME from the cache of files used for | |
| printing source code. For use in selftests when working | |
| with tempfiles. */ | |
| void | |
| file_cache::forcibly_evict_file (const char *file_path) | |
| { | |
| gcc_assert (file_path); | |
| file_cache_slot *r = lookup_file (file_path); | |
| if (!r) | |
| /* Not found. */ | |
| return; | |
| r->evict (); | |
| } | |
| /* Determine if FILE_PATH missing a trailing newline on its final line. | |
| Only valid to call once all of the file has been loaded, by | |
| requesting a line number beyond the end of the file. */ | |
| bool | |
| file_cache::missing_trailing_newline_p (const char *file_path) | |
| { | |
| gcc_assert (file_path); | |
| file_cache_slot *r = lookup_or_add_file (file_path); | |
| return r->missing_trailing_newline_p (); | |
| } | |
| void | |
| file_cache::add_buffered_content (const char *file_path, | |
| const char *buffer, | |
| size_t sz) | |
| { | |
| gcc_assert (file_path); | |
| file_cache_slot *r = lookup_file (file_path); | |
| if (!r) | |
| { | |
| unsigned highest_use_count = 0; | |
| r = evicted_cache_tab_entry (&highest_use_count); | |
| if (!r->create (m_input_context, file_path, nullptr, highest_use_count)) | |
| return; | |
| } | |
| r->set_content (buffer, sz); | |
| } | |
| void | |
| file_cache_slot::evict () | |
| { | |
| free (m_file_path); | |
| m_file_path = NULL; | |
| if (m_fp) | |
| fclose (m_fp); | |
| m_error = false; | |
| m_fp = NULL; | |
| m_nb_read = 0; | |
| m_line_start_idx = 0; | |
| m_line_num = 0; | |
| m_line_record.truncate (0); | |
| m_line_recent_first = 0; | |
| m_line_recent_last = 0; | |
| m_use_count = 0; | |
| m_missing_trailing_newline = true; | |
| } | |
| /* Return the file 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) | |
| { | |
| file_cache_slot *to_evict = &m_file_slots[0]; | |
| unsigned huc = to_evict->get_use_count (); | |
| for (unsigned i = 1; i < m_num_file_slots; ++i) | |
| { | |
| file_cache_slot *c = &m_file_slots[i]; | |
| bool c_is_empty = (c->get_file_path () == NULL); | |
| if (c->get_use_count () < to_evict->get_use_count () | |
| || (to_evict->get_file_path () && c_is_empty)) | |
| /* 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) | |
| *highest_use_count = huc; | |
| return to_evict; | |
| } | |
| /* Create the cache used for the content of a given file to be | |
| accessed by caret diagnostic. This cache is added to an array of | |
| cache and can be retrieved by lookup_file_in_cache_tab. This | |
| function returns the created cache. Note that only the last | |
| m_num_file_slots files are cached. | |
| This can return nullptr if the FILE_PATH can't be opened for | |
| reading, or if the content can't be converted to the input_charset. */ | |
| file_cache_slot* | |
| file_cache::add_file (const char *file_path) | |
| { | |
| FILE *fp = fopen (file_path, "r"); | |
| if (fp == NULL) | |
| return NULL; | |
| unsigned highest_use_count = 0; | |
| file_cache_slot *r = evicted_cache_tab_entry (&highest_use_count); | |
| if (!r->create (m_input_context, file_path, fp, highest_use_count)) | |
| return NULL; | |
| 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. */ | |
| char_span | |
| file_cache_slot::get_full_file_content () | |
| { | |
| char *line; | |
| ssize_t line_len; | |
| while (get_next_line (&line, &line_len)) | |
| { | |
| } | |
| return char_span (m_data, m_nb_read); | |
| } | |
| /* Populate this slot for use on FILE_PATH and FP, dropping any | |
| existing cached content within it. */ | |
| bool | |
| file_cache_slot::create (const file_cache::input_context &in_context, | |
| const char *file_path, FILE *fp, | |
| unsigned highest_use_count) | |
| { | |
| m_file_path = file_path ? xstrdup (file_path) : nullptr; | |
| if (m_fp) | |
| fclose (m_fp); | |
| m_error = false; | |
| 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_recent_first = 0; | |
| m_line_recent_last = 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_missing_trailing_newline = true; | |
| /* Check the input configuration to determine if we need to do any | |
| transformations, such as charset conversion or BOM skipping. */ | |
| if (const char *input_charset = in_context.ccb (file_path)) | |
| { | |
| /* Need a full-blown conversion of the input charset. */ | |
| fclose (m_fp); | |
| m_fp = NULL; | |
| const cpp_converted_source cs | |
| = 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; | |
| } | |
| else if (in_context.should_skip_bom) | |
| { | |
| if (read_data ()) | |
| { | |
| const int offset = cpp_check_utf8_bom (m_data, m_nb_read); | |
| offset_buffer (offset); | |
| m_nb_read -= offset; | |
| } | |
| } | |
| return true; | |
| } | |
| void | |
| file_cache_slot::set_content (const char *buf, size_t sz) | |
| { | |
| m_data = (char *)xmalloc (sz); | |
| memcpy (m_data, buf, sz); | |
| m_nb_read = m_size = sz; | |
| m_alloc_offset = 0; | |
| if (m_fp) | |
| { | |
| fclose (m_fp); | |
| m_fp = nullptr; | |
| } | |
| } | |
| /* file_cache's ctor. */ | |
| file_cache::file_cache () | |
| : m_num_file_slots (16), m_file_slots (new file_cache_slot[m_num_file_slots]) | |
| { | |
| initialize_input_context (nullptr, false); | |
| } | |
| /* file_cache's dtor. */ | |
| file_cache::~file_cache () | |
| { | |
| delete[] m_file_slots; | |
| } | |
| void | |
| file_cache::dump (FILE *out, int indent) const | |
| { | |
| for (size_t i = 0; i < m_num_file_slots; ++i) | |
| { | |
| dumping::emit_indent (out, indent); | |
| fprintf (out, "slot[%i]:\n", (int)i); | |
| m_file_slots[i].dump (out, indent + 2); | |
| } | |
| } | |
| void | |
| file_cache::dump () const | |
| { | |
| dump (stderr, 0); | |
| } | |
| /* Lookup the cache used for the content of a given file accessed by | |
| caret diagnostic. If no cached file was found, create a new cache | |
| for this file, add it to the array of cached file and return | |
| it. | |
| This can return nullptr on a cache miss if FILE_PATH can't be opened for | |
| reading, or if the content can't be converted to the input_charset. */ | |
| file_cache_slot* | |
| file_cache::lookup_or_add_file (const char *file_path) | |
| { | |
| file_cache_slot *r = lookup_file (file_path); | |
| if (r == NULL) | |
| r = add_file (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_error (false), m_data (0), | |
| m_alloc_offset (0), m_size (0), m_nb_read (0), m_line_start_idx (0), | |
| m_line_num (0), m_missing_trailing_newline (true), | |
| m_line_recent_last (0), m_line_recent_first (0) | |
| { | |
| m_line_record.create (0); | |
| m_line_recent.create (1U << recent_cached_lines_shift); | |
| for (int i = 0; i < 1 << recent_cached_lines_shift; i++) | |
| m_line_recent.quick_push (file_cache_slot::line_info (0, 0, 0)); | |
| } | |
| /* Destructor for a cache of file used by caret diagnostic. */ | |
| file_cache_slot::~file_cache_slot () | |
| { | |
| free (m_file_path); | |
| 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 (); | |
| m_line_recent.release (); | |
| } | |
| void | |
| file_cache_slot::dump (FILE *out, int indent) const | |
| { | |
| if (!m_file_path) | |
| { | |
| dumping::emit_indent (out, indent); | |
| fprintf (out, "(unused)\n"); | |
| return; | |
| } | |
| dumping::emit_string_field (out, indent, "file_path", m_file_path); | |
| { | |
| dumping::emit_indent (out, indent); | |
| fprintf (out, "fp: %p\n", (void *)m_fp); | |
| } | |
| dumping::emit_bool_field (out, indent, "needs_read_p", needs_read_p ()); | |
| dumping::emit_bool_field (out, indent, "needs_grow_p", needs_grow_p ()); | |
| dumping::emit_unsigned_field (out, indent, "use_count", m_use_count); | |
| dumping::emit_size_t_field (out, indent, "size", m_size); | |
| dumping::emit_size_t_field (out, indent, "nb_read", m_nb_read); | |
| dumping::emit_size_t_field (out, indent, "start_line_idx", m_line_start_idx); | |
| dumping::emit_size_t_field (out, indent, "line_num", m_line_num); | |
| dumping::emit_bool_field (out, indent, "missing_trailing_newline", | |
| m_missing_trailing_newline); | |
| { | |
| dumping::emit_indent (out, indent); | |
| fprintf (out, "line records (%i):\n", m_line_record.length ()); | |
| } | |
| int idx = 0; | |
| for (auto &line : m_line_record) | |
| { | |
| dumping::emit_indent (out, indent); | |
| fprintf (out, ("[%i]:" | |
| " line " HOST_SIZE_T_PRINT_DEC ":" | |
| " byte offsets: " HOST_SIZE_T_PRINT_DEC | |
| "-" HOST_SIZE_T_PRINT_DEC "\n"), | |
| idx++, line.line_num, line.start_pos, line.end_pos); | |
| } | |
| } | |
| /* 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 | |
| { | |
| return m_fp && (m_nb_read == 0 | |
| || m_nb_read == m_size | |
| || (m_line_start_idx >= m_nb_read - 1)); | |
| } | |
| /* Return TRUE iff the cache is full and thus needs to be | |
| extended. */ | |
| bool | |
| file_cache_slot::needs_grow_p () const | |
| { | |
| return m_nb_read == m_size; | |
| } | |
| /* Grow the cache if it needs to be extended. */ | |
| void | |
| file_cache_slot::maybe_grow () | |
| { | |
| if (!needs_grow_p ()) | |
| return; | |
| if (!m_data) | |
| { | |
| gcc_assert (m_size == 0 && m_alloc_offset == 0); | |
| m_size = buffer_size; | |
| m_data = XNEWVEC (char, m_size); | |
| } | |
| else | |
| { | |
| const int offset = m_alloc_offset; | |
| offset_buffer (-offset); | |
| m_size *= 2; | |
| m_data = XRESIZEVEC (char, m_data, m_size); | |
| offset_buffer (offset); | |
| } | |
| } | |
| /* Read more data into the cache. Extends the cache if need be. | |
| Returns TRUE iff new data could be read. */ | |
| bool | |
| file_cache_slot::read_data () | |
| { | |
| if (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)) | |
| { | |
| m_error = true; | |
| 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 ()) | |
| return false; | |
| return read_data (); | |
| } | |
| /* Helper function for file_cache_slot::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 const char * | |
| find_end_of_line (const char *s, size_t len) | |
| { | |
| for (const auto end = s + len; s != end; ++s) | |
| { | |
| if (*s == '\n') | |
| return s; | |
| if (*s == '\r') | |
| { | |
| const auto next = s + 1; | |
| if (next == end) | |
| { | |
| /* Don't find the line ending if \r is the very last character | |
| in the buffer; we do not know if it's the end of the file or | |
| just the end of what has been read so far, and we wouldn't | |
| want to break in the middle of what's actually a \r\n | |
| sequence. Instead, we will handle the case of a file ending | |
| in a \r later. */ | |
| break; | |
| } | |
| return (*next == '\n' ? next : s); | |
| } | |
| } | |
| 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. */ | |
| bool | |
| file_cache_slot::get_next_line (char **line, ssize_t *line_len) | |
| { | |
| /* Fill the cache with data to process. */ | |
| maybe_read_data (); | |
| size_t remaining_size = m_nb_read - m_line_start_idx; | |
| if (remaining_size == 0) | |
| /* There is no more data to process. */ | |
| return false; | |
| const char *line_start = m_data + m_line_start_idx; | |
| const char *next_line_start = NULL; | |
| size_t len = 0; | |
| const char *line_end = find_end_of_line (line_start, remaining_size); | |
| 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 ()) | |
| { | |
| 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); | |
| if (line_end != NULL) | |
| { | |
| next_line_start = line_end + 1; | |
| break; | |
| } | |
| } | |
| if (line_end == NULL) | |
| { | |
| /* We've loaded all the file into the cache and still no | |
| terminator. Let's say the line ends up at one byte past the | |
| end of the file. This is to stay consistent with the case | |
| of when the line ends up with a terminator and line_end points to | |
| that. That consistency is useful below in the len calculation. | |
| 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_missing_trailing_newline = false; | |
| } | |
| else | |
| m_missing_trailing_newline = true; | |
| } | |
| else | |
| m_missing_trailing_newline = false; | |
| } | |
| else | |
| { | |
| next_line_start = line_end + 1; | |
| m_missing_trailing_newline = false; | |
| } | |
| if (m_error) | |
| 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 = const_cast<char *> (line_start); | |
| ++m_line_num; | |
| /* Now update our line record so that re-reading lines from the | |
| before m_line_start_idx is faster. */ | |
| size_t rlen = m_line_record.length (); | |
| /* Only update when beyond the previously cached region. */ | |
| if (rlen == 0 || m_line_record[rlen - 1].line_num < m_line_num) | |
| { | |
| size_t spacing | |
| = (rlen >= 2 | |
| ? (m_line_record[rlen - 1].line_num | |
| - m_line_record[rlen - 2].line_num) : 1); | |
| size_t delta | |
| = rlen >= 1 ? m_line_num - m_line_record[rlen - 1].line_num : 1; | |
| size_t max_size = line_record_size; | |
| /* One anchor per hundred input lines. */ | |
| if (max_size == 0) | |
| max_size = m_line_num / 100; | |
| /* If we're too far beyond drop half of the lines to rebalance. */ | |
| if (rlen == max_size && delta >= spacing * 2) | |
| { | |
| size_t j = 0; | |
| for (size_t i = 1; i < rlen; i += 2) | |
| m_line_record[j++] = m_line_record[i]; | |
| m_line_record.truncate (j); | |
| rlen = j; | |
| spacing *= 2; | |
| } | |
| if (rlen < max_size && delta >= spacing) | |
| { | |
| file_cache_slot::line_info li (m_line_num, m_line_start_idx, | |
| line_end - m_data); | |
| m_line_record.safe_push (li); | |
| } | |
| } | |
| /* Cache recent tail lines separately for fast access. This assumes | |
| most accesses do not skip backwards. */ | |
| if (m_line_recent_last == m_line_recent_first | |
| || m_line_recent[m_line_recent_last].line_num == m_line_num - 1) | |
| { | |
| size_t mask = ((size_t) 1 << recent_cached_lines_shift) - 1; | |
| m_line_recent_last = (m_line_recent_last + 1) & mask; | |
| if (m_line_recent_last == m_line_recent_first) | |
| m_line_recent_first = (m_line_recent_first + 1) & mask; | |
| m_line_recent[m_line_recent_last] | |
| = file_cache_slot::line_info (m_line_num, m_line_start_idx, | |
| line_end - m_data); | |
| } | |
| /* 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; | |
| return true; | |
| } | |
| /* Consume the next bytes coming from the cache (or from its | |
| underlying file if there are remaining unread bytes in the file) | |
| until we reach the next end-of-line (or end-of-file). There is no | |
| copying from the cache involved. Return TRUE upon successful | |
| completion. */ | |
| bool | |
| file_cache_slot::goto_next_line () | |
| { | |
| char *l; | |
| ssize_t len; | |
| return get_next_line (&l, &len); | |
| } | |
| /* Read an arbitrary line number LINE_NUM from the file cached in C. | |
| 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. | |
| *LINE is only valid until the next call of read_line_num. | |
| 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) | |
| { | |
| gcc_assert (line_num > 0); | |
| /* Is the line in the recent line cache? | |
| This assumes the main file processing is only using | |
| a single contiguous cursor with only temporary excursions. */ | |
| if (m_line_recent_first != m_line_recent_last | |
| && m_line_recent[m_line_recent_first].line_num <= line_num | |
| && m_line_recent[m_line_recent_last].line_num >= line_num) | |
| { | |
| line_info &last = m_line_recent[m_line_recent_last]; | |
| size_t mask = (1U << recent_cached_lines_shift) - 1; | |
| size_t idx = (m_line_recent_last - (last.line_num - line_num)) & mask; | |
| line_info &recent = m_line_recent[idx]; | |
| gcc_assert (recent.line_num == line_num); | |
| *line = m_data + recent.start_pos; | |
| *line_len = recent.end_pos - recent.start_pos; | |
| return true; | |
| } | |
| if (line_num <= m_line_num) | |
| { | |
| line_info l (line_num, 0, 0); | |
| int i = m_line_record.lower_bound (l, line_info::less_than); | |
| if (i == 0) | |
| { | |
| m_line_start_idx = 0; | |
| m_line_num = 0; | |
| } | |
| else if (m_line_record[i - 1].line_num == line_num) | |
| { | |
| /* We have the start/end of the line. */ | |
| *line = m_data + m_line_record[i - 1].start_pos; | |
| *line_len = m_line_record[i - 1].end_pos - m_line_record[i - 1].start_pos; | |
| return true; | |
| } | |
| else | |
| { | |
| gcc_assert (m_line_record[i - 1].line_num < m_line_num); | |
| m_line_start_idx = m_line_record[i - 1].start_pos; | |
| m_line_num = m_line_record[i - 1].line_num - 1; | |
| } | |
| } | |
| /* Let's walk from line m_line_num up to line_num - 1, without | |
| copying any line. */ | |
| while (m_line_num < line_num - 1) | |
| if (!goto_next_line ()) | |
| return false; | |
| /* The line we want is the next one. Let's read it. */ | |
| return get_next_line (line, line_len); | |
| } | |
| /* Return the physical source line that corresponds to FILE_PATH/LINE. | |
| The line is not nul-terminated. The returned pointer is only | |
| valid until the next call of location_get_source_line. | |
| Note that the line can contain several null characters, | |
| so the returned value's length has the actual length of the line. | |
| If the function fails, a NULL char_span is returned. */ | |
| char_span | |
| file_cache::get_source_line (const char *file_path, int line) | |
| { | |
| char *buffer = NULL; | |
| ssize_t len; | |
| if (line == 0) | |
| return char_span (NULL, 0); | |
| if (file_path == NULL) | |
| return char_span (NULL, 0); | |
| file_cache_slot *c = lookup_or_add_file (file_path); | |
| if (c == NULL) | |
| return char_span (NULL, 0); | |
| bool read = c->read_line_num (line, &buffer, &len); | |
| if (!read) | |
| return char_span (NULL, 0); | |
| return char_span (buffer, len); | |
| } | |
| char_span | |
| file_cache::get_source_file_content (const char *file_path) | |
| { | |
| file_cache_slot *c = lookup_or_add_file (file_path); | |
| if (c == nullptr) | |
| return char_span (nullptr, 0); | |
| return c->get_full_file_content (); | |
| } | |
| #if CHECKING_P | |
| namespace selftest { | |
| using temp_source_file = ::selftest::temp_source_file; | |
| /* Verify reading of a specific line LINENUM in TMP, FC. */ | |
| static void | |
| check_line (temp_source_file &tmp, file_cache &fc, int linenum) | |
| { | |
| char_span line = fc.get_source_line (tmp.get_filename (), linenum); | |
| int n; | |
| const char *b = line.get_buffer (); | |
| size_t l = line.length (); | |
| char buf[5]; | |
| ASSERT_LT (l, 5); | |
| memcpy (buf, b, l); | |
| buf[l] = '\0'; | |
| ASSERT_TRUE (sscanf (buf, "%d", &n) == 1); | |
| ASSERT_EQ (n, linenum); | |
| } | |
| /* Test file cache replacement. */ | |
| static void | |
| test_replacement () | |
| { | |
| const int maxline = 1000; | |
| char *vec = XNEWVEC (char, maxline * 5); | |
| char *p = vec; | |
| int i; | |
| for (i = 1; i <= maxline; i++) | |
| p += sprintf (p, "%d\n", i); | |
| temp_source_file tmp (SELFTEST_LOCATION, ".txt", vec); | |
| free (vec); | |
| file_cache fc; | |
| for (i = 2; i <= maxline; i++) | |
| { | |
| check_line (tmp, fc, i); | |
| check_line (tmp, fc, i - 1); | |
| if (i >= 10) | |
| check_line (tmp, fc, i - 9); | |
| if (i >= 350) /* Exceed the look behind cache. */ | |
| check_line (tmp, fc, i - 300); | |
| } | |
| for (i = 5; i <= maxline; i += 100) | |
| check_line (tmp, fc, i); | |
| for (i = 1; i <= maxline; i++) | |
| check_line (tmp, fc, i); | |
| } | |
| /* Verify reading of input files (e.g. for caret-based diagnostics). */ | |
| static void | |
| test_reading_source_line () | |
| { | |
| /* Create a tempfile and write some text to it. */ | |
| temp_source_file tmp (SELFTEST_LOCATION, ".txt", | |
| "01234567890123456789\n" | |
| "This is the test text\n" | |
| "This is the 3rd line"); | |
| file_cache fc; | |
| /* Read back a specific line from the tempfile. */ | |
| char_span source_line = fc.get_source_line (tmp.get_filename (), 3); | |
| ASSERT_TRUE (source_line); | |
| ASSERT_TRUE (source_line.get_buffer () != NULL); | |
| ASSERT_EQ (20, source_line.length ()); | |
| ASSERT_TRUE (!strncmp ("This is the 3rd line", | |
| source_line.get_buffer (), source_line.length ())); | |
| source_line = fc.get_source_line (tmp.get_filename (), 2); | |
| ASSERT_TRUE (source_line); | |
| ASSERT_TRUE (source_line.get_buffer () != NULL); | |
| ASSERT_EQ (21, source_line.length ()); | |
| ASSERT_TRUE (!strncmp ("This is the test text", | |
| source_line.get_buffer (), source_line.length ())); | |
| source_line = fc.get_source_line (tmp.get_filename (), 4); | |
| ASSERT_FALSE (source_line); | |
| ASSERT_TRUE (source_line.get_buffer () == NULL); | |
| } | |
| /* Verify reading from buffers (e.g. for sarif-replay). */ | |
| static void | |
| test_reading_source_buffer () | |
| { | |
| const char *text = ("01234567890123456789\n" | |
| "This is the test text\n" | |
| "This is the 3rd line"); | |
| const char *filename = "foo.txt"; | |
| file_cache fc; | |
| fc.add_buffered_content (filename, text, strlen (text)); | |
| /* Read back a specific line from the tempfile. */ | |
| char_span source_line = fc.get_source_line (filename, 3); | |
| ASSERT_TRUE (source_line); | |
| ASSERT_TRUE (source_line.get_buffer () != NULL); | |
| ASSERT_EQ (20, source_line.length ()); | |
| ASSERT_TRUE (!strncmp ("This is the 3rd line", | |
| source_line.get_buffer (), source_line.length ())); | |
| source_line = fc.get_source_line (filename, 2); | |
| ASSERT_TRUE (source_line); | |
| ASSERT_TRUE (source_line.get_buffer () != NULL); | |
| ASSERT_EQ (21, source_line.length ()); | |
| ASSERT_TRUE (!strncmp ("This is the test text", | |
| source_line.get_buffer (), source_line.length ())); | |
| source_line = fc.get_source_line (filename, 4); | |
| ASSERT_FALSE (source_line); | |
| ASSERT_TRUE (source_line.get_buffer () == NULL); | |
| } | |
| /* Run all of the selftests within this file. */ | |
| void | |
| file_cache_cc_tests () | |
| { | |
| test_reading_source_line (); | |
| test_reading_source_buffer (); | |
| test_replacement (); | |
| } | |
| } // namespace selftest | |
| #endif /* CHECKING_P */ | |
| } // namespace diagnostics |