gcc/input.h

   1 /* Declarations for variables relating to reading the source file.
   2    Used by parsers, lexical analyzers, and error message routines.
   3    Copyright (C) 1993-2023 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_INPUT_H
  22 #define GCC_INPUT_H
  23
  24 #include "line-map.h"
  25
  26 extern GTY(()) class line_maps *line_table;
  27 extern GTY(()) class line_maps *saved_line_table;
  28
  29 /* A value which will never be used to represent a real location.  */
  30 #define UNKNOWN_LOCATION ((location_t) 0)
  31
  32 /* The location for declarations in "<built-in>" */
  33 #define BUILTINS_LOCATION ((location_t) 1)
  34
  35 /* Returns the translated string referring to the special location.  */
  36 const char *special_fname_builtin ();
  37
  38 /* line-map.cc reserves RESERVED_LOCATION_COUNT to the user.  Ensure
  39    both UNKNOWN_LOCATION and BUILTINS_LOCATION fit into that.  */
  40 STATIC_ASSERT (BUILTINS_LOCATION < RESERVED_LOCATION_COUNT);
  41
  42 /* Hasher for 'location_t' values satisfying '!RESERVED_LOCATION_P', thus able
  43    to use 'UNKNOWN_LOCATION'/'BUILTINS_LOCATION' as spare values for
  44    'Empty'/'Deleted'.  */
  45 /* Per PR103157 "'gengtype': 'typedef' causing infinite-recursion code to be
  46    generated", don't use
  47        typedef int_hash<location_t, UNKNOWN_LOCATION, BUILTINS_LOCATION>
  48          location_hash;
  49    here.
  50
  51    It works for a single-use case, but when using a 'struct'-based variant
  52        struct location_hash
  53          : int_hash<location_t, UNKNOWN_LOCATION, BUILTINS_LOCATION> {};
  54    in more than one place, 'gengtype' generates duplicate functions (thus:
  55    "error: redefinition of 'void gt_ggc_mx(location_hash&)'" etc.).
  56    Attempting to mark that one up with GTY options, we run into a 'gengtype'
  57    "parse error: expected '{', have '<'", which probably falls into category
  58    "understanding of C++ is limited", as documented in 'gcc/doc/gty.texi'.
  59
  60    Thus, use a plain ol' '#define':
  61 */
  62 #define location_hash int_hash<location_t, UNKNOWN_LOCATION, BUILTINS_LOCATION>
  63
  64 extern bool is_location_from_builtin_token (location_t);
  65 extern expanded_location expand_location (location_t);
  66
  67 class cpp_char_column_policy;
  68
  69 extern int
  70 location_compute_display_column (expanded_location exploc,
  71                                  const cpp_char_column_policy &policy);
  72
  73 /* A class capturing the bounds of a buffer, to allow for run-time
  74    bounds-checking in a checked build.  */
  75
  76 class char_span
  77 {
  78  public:
  79   char_span (const char *ptr, size_t n_elts) : m_ptr (ptr), m_n_elts (n_elts) {}
  80
  81   /* Test for a non-NULL pointer.  */
  82   operator bool() const { return m_ptr; }
  83
  84   /* Get length, not including any 0-terminator (which may not be,
  85      in fact, present).  */
  86   size_t length () const { return m_n_elts; }
  87
  88   const char *get_buffer () const { return m_ptr; }
  89
  90   char operator[] (int idx) const
  91   {
  92     gcc_assert (idx >= 0);
  93     gcc_assert ((size_t)idx < m_n_elts);
  94     return m_ptr[idx];
  95   }
  96
  97   char_span subspan (int offset, int n_elts) const
  98   {
  99     gcc_assert (offset >= 0);
 100     gcc_assert (offset < (int)m_n_elts);
 101     gcc_assert (n_elts >= 0);
 102     gcc_assert (offset + n_elts <= (int)m_n_elts);
 103     return char_span (m_ptr + offset, n_elts);
 104   }
 105
 106   char *xstrdup () const
 107   {
 108     return ::xstrndup (m_ptr, m_n_elts);
 109   }
 110
 111  private:
 112   const char *m_ptr;
 113   size_t m_n_elts;
 114 };
 115
 116 extern char_span location_get_source_line (const char *file_path, int line);
 117 extern char *get_source_text_between (location_t, location_t);
 118
 119 extern bool location_missing_trailing_newline (const char *file_path);
 120
 121 /* Forward decl of slot within file_cache, so that the definition doesn't
 122    need to be in this header.  */
 123 class file_cache_slot;
 124
 125 /* A cache of source files for use when emitting diagnostics
 126    (and in a few places in the C/C++ frontends).
 127
 128    Results are only valid until the next call to the cache, as
 129    slots can be evicted.
 130
 131    Filenames are stored by pointer, and so must outlive the cache
 132    instance.  */
 133
 134 class file_cache
 135 {
 136  public:
 137   file_cache ();
 138   ~file_cache ();
 139
 140   file_cache_slot *lookup_or_add_file (const char *file_path);
 141   void forcibly_evict_file (const char *file_path);
 142
 143   /* See comments in diagnostic.h about the input conversion context.  */
 144   struct input_context
 145   {
 146     diagnostic_input_charset_callback ccb;
 147     bool should_skip_bom;
 148   };
 149   void initialize_input_context (diagnostic_input_charset_callback ccb,
 150                                  bool should_skip_bom);
 151
 152  private:
 153   file_cache_slot *evicted_cache_tab_entry (unsigned *highest_use_count);
 154   file_cache_slot *add_file (const char *file_path);
 155   file_cache_slot *lookup_file (const char *file_path);
 156
 157  private:
 158   static const size_t num_file_slots = 16;
 159   file_cache_slot *m_file_slots;
 160   input_context in_context;
 161 };
 162
 163 extern expanded_location
 164 expand_location_to_spelling_point (location_t,
 165                                    enum location_aspect aspect
 166                                      = LOCATION_ASPECT_CARET);
 167 extern location_t expansion_point_location_if_in_system_header (location_t);
 168 extern location_t expansion_point_location (location_t);
 169
 170 extern location_t input_location;
 171
 172 extern location_t location_with_discriminator (location_t, int);
 173 extern bool has_discriminator (location_t);
 174 extern int get_discriminator_from_loc (location_t);
 175
 176 #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
 177 #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
 178 #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
 179 #define LOCATION_LOCUS(LOC) \
 180   ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \
 181    : (LOC))
 182 #define LOCATION_BLOCK(LOC) \
 183   ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
 184    : NULL))
 185 #define RESERVED_LOCATION_P(LOC) \
 186   (LOCATION_LOCUS (LOC) < RESERVED_LOCATION_COUNT)
 187
 188 /* Return a positive value if LOCATION is the locus of a token that is
 189    located in a system header, O otherwise. It returns 1 if LOCATION
 190    is the locus of a token that is located in a system header, and 2
 191    if LOCATION is the locus of a token located in a C system header
 192    that therefore needs to be extern "C" protected in C++.
 193
 194    Note that this function returns 1 if LOCATION belongs to a token
 195    that is part of a macro replacement-list defined in a system
 196    header, but expanded in a non-system file.  */
 197
 198 static inline int
 199 in_system_header_at (location_t loc)
 200 {
 201   return linemap_location_in_system_header_p (line_table, loc);
 202 }
 203
 204 /* Return true if LOCATION is the locus of a token that
 205    comes from a macro expansion, false otherwise.  */
 206
 207 static inline bool
 208 from_macro_expansion_at (location_t loc)
 209 {
 210   return linemap_location_from_macro_expansion_p (line_table, loc);
 211 }
 212
 213 /* Return true if LOCATION is the locus of a token that comes from
 214    a macro definition, false otherwise.  This differs from from_macro_expansion_at
 215    in its treatment of macro arguments, for which this returns false.  */
 216
 217 static inline bool
 218 from_macro_definition_at (location_t loc)
 219 {
 220   return linemap_location_from_macro_definition_p (line_table, loc);
 221 }
 222
 223 static inline location_t
 224 get_pure_location (location_t loc)
 225 {
 226   return get_pure_location (line_table, loc);
 227 }
 228
 229 /* Get the start of any range encoded within location LOC.  */
 230
 231 static inline location_t
 232 get_start (location_t loc)
 233 {
 234   return get_range_from_loc (line_table, loc).m_start;
 235 }
 236
 237 /* Get the endpoint of any range encoded within location LOC.  */
 238
 239 static inline location_t
 240 get_finish (location_t loc)
 241 {
 242   return get_range_from_loc (line_table, loc).m_finish;
 243 }
 244
 245 extern location_t make_location (location_t caret,
 246                                  location_t start, location_t finish);
 247 extern location_t make_location (location_t caret, source_range src_range);
 248
 249 void dump_line_table_statistics (void);
 250
 251 void dump_location_info (FILE *stream);
 252
 253 void diagnostics_file_cache_fini (void);
 254
 255 void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
 256
 257 class GTY(()) string_concat
 258 {
 259 public:
 260   string_concat (int num, location_t *locs);
 261
 262   int m_num;
 263   location_t * GTY ((atomic)) m_locs;
 264 };
 265
 266 class GTY(()) string_concat_db
 267 {
 268  public:
 269   string_concat_db ();
 270   void record_string_concatenation (int num, location_t *locs);
 271
 272   bool get_string_concatenation (location_t loc,
 273                                  int *out_num,
 274                                  location_t **out_locs);
 275
 276  private:
 277   static location_t get_key_loc (location_t loc);
 278
 279   /* For the fields to be private, we must grant access to the
 280      generated code in gtype-desc.cc.  */
 281
 282   friend void ::gt_ggc_mx_string_concat_db (void *x_p);
 283   friend void ::gt_pch_nx_string_concat_db (void *x_p);
 284   friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
 285                                              gt_pointer_operator op,
 286                                              void *cookie);
 287
 288   hash_map <location_hash, string_concat *> *m_table;
 289 };
 290
 291 #endif