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-2021 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 /* line-map.c reserves RESERVED_LOCATION_COUNT to the user.  Ensure
  36    both UNKNOWN_LOCATION and BUILTINS_LOCATION fit into that.  */
  37 STATIC_ASSERT (BUILTINS_LOCATION < RESERVED_LOCATION_COUNT);
  38
  39 extern bool is_location_from_builtin_token (location_t);
  40 extern expanded_location expand_location (location_t);
  41
  42 extern int location_compute_display_column (expanded_location exploc,
  43                                             int tabstop);
  44
  45 /* A class capturing the bounds of a buffer, to allow for run-time
  46    bounds-checking in a checked build.  */
  47
  48 class char_span
  49 {
  50  public:
  51   char_span (const char *ptr, size_t n_elts) : m_ptr (ptr), m_n_elts (n_elts) {}
  52
  53   /* Test for a non-NULL pointer.  */
  54   operator bool() const { return m_ptr; }
  55
  56   /* Get length, not including any 0-terminator (which may not be,
  57      in fact, present).  */
  58   size_t length () const { return m_n_elts; }
  59
  60   const char *get_buffer () const { return m_ptr; }
  61
  62   char operator[] (int idx) const
  63   {
  64     gcc_assert (idx >= 0);
  65     gcc_assert ((size_t)idx < m_n_elts);
  66     return m_ptr[idx];
  67   }
  68
  69   char_span subspan (int offset, int n_elts) const
  70   {
  71     gcc_assert (offset >= 0);
  72     gcc_assert (offset < (int)m_n_elts);
  73     gcc_assert (n_elts >= 0);
  74     gcc_assert (offset + n_elts <= (int)m_n_elts);
  75     return char_span (m_ptr + offset, n_elts);
  76   }
  77
  78   char *xstrdup () const
  79   {
  80     return ::xstrndup (m_ptr, m_n_elts);
  81   }
  82
  83  private:
  84   const char *m_ptr;
  85   size_t m_n_elts;
  86 };
  87
  88 extern char_span location_get_source_line (const char *file_path, int line);
  89
  90 extern bool location_missing_trailing_newline (const char *file_path);
  91
  92 /* Forward decl of slot within file_cache, so that the definition doesn't
  93    need to be in this header.  */
  94 class file_cache_slot;
  95
  96 /* A cache of source files for use when emitting diagnostics
  97    (and in a few places in the C/C++ frontends).
  98
  99    Results are only valid until the next call to the cache, as
 100    slots can be evicted.
 101
 102    Filenames are stored by pointer, and so must outlive the cache
 103    instance.  */
 104
 105 class file_cache
 106 {
 107  public:
 108   file_cache ();
 109   ~file_cache ();
 110
 111   file_cache_slot *lookup_or_add_file (const char *file_path);
 112   void forcibly_evict_file (const char *file_path);
 113
 114   /* See comments in diagnostic.h about the input conversion context.  */
 115   struct input_context
 116   {
 117     diagnostic_input_charset_callback ccb;
 118     bool should_skip_bom;
 119   };
 120   void initialize_input_context (diagnostic_input_charset_callback ccb,
 121                                  bool should_skip_bom);
 122
 123  private:
 124   file_cache_slot *evicted_cache_tab_entry (unsigned *highest_use_count);
 125   file_cache_slot *add_file (const char *file_path);
 126   file_cache_slot *lookup_file (const char *file_path);
 127
 128  private:
 129   static const size_t num_file_slots = 16;
 130   file_cache_slot *m_file_slots;
 131   input_context in_context;
 132 };
 133
 134 extern expanded_location
 135 expand_location_to_spelling_point (location_t,
 136                                    enum location_aspect aspect
 137                                      = LOCATION_ASPECT_CARET);
 138 extern location_t expansion_point_location_if_in_system_header (location_t);
 139 extern location_t expansion_point_location (location_t);
 140
 141 extern location_t input_location;
 142
 143 #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
 144 #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
 145 #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
 146 #define LOCATION_LOCUS(LOC) \
 147   ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \
 148    : (LOC))
 149 #define LOCATION_BLOCK(LOC) \
 150   ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
 151    : NULL))
 152 #define RESERVED_LOCATION_P(LOC) \
 153   (LOCATION_LOCUS (LOC) < RESERVED_LOCATION_COUNT)
 154
 155 /* Return a positive value if LOCATION is the locus of a token that is
 156    located in a system header, O otherwise. It returns 1 if LOCATION
 157    is the locus of a token that is located in a system header, and 2
 158    if LOCATION is the locus of a token located in a C system header
 159    that therefore needs to be extern "C" protected in C++.
 160
 161    Note that this function returns 1 if LOCATION belongs to a token
 162    that is part of a macro replacement-list defined in a system
 163    header, but expanded in a non-system file.  */
 164
 165 static inline int
 166 in_system_header_at (location_t loc)
 167 {
 168   return linemap_location_in_system_header_p (line_table, loc);
 169 }
 170
 171 /* Return true if LOCATION is the locus of a token that
 172    comes from a macro expansion, false otherwise.  */
 173
 174 static inline bool
 175 from_macro_expansion_at (location_t loc)
 176 {
 177   return linemap_location_from_macro_expansion_p (line_table, loc);
 178 }
 179
 180 /* Return true if LOCATION is the locus of a token that comes from
 181    a macro definition, false otherwise.  This differs from from_macro_expansion_at
 182    in its treatment of macro arguments, for which this returns false.  */
 183
 184 static inline bool
 185 from_macro_definition_at (location_t loc)
 186 {
 187   return linemap_location_from_macro_definition_p (line_table, loc);
 188 }
 189
 190 static inline location_t
 191 get_pure_location (location_t loc)
 192 {
 193   return get_pure_location (line_table, loc);
 194 }
 195
 196 /* Get the start of any range encoded within location LOC.  */
 197
 198 static inline location_t
 199 get_start (location_t loc)
 200 {
 201   return get_range_from_loc (line_table, loc).m_start;
 202 }
 203
 204 /* Get the endpoint of any range encoded within location LOC.  */
 205
 206 static inline location_t
 207 get_finish (location_t loc)
 208 {
 209   return get_range_from_loc (line_table, loc).m_finish;
 210 }
 211
 212 extern location_t make_location (location_t caret,
 213                                  location_t start, location_t finish);
 214 extern location_t make_location (location_t caret, source_range src_range);
 215
 216 void dump_line_table_statistics (void);
 217
 218 void dump_location_info (FILE *stream);
 219
 220 void diagnostics_file_cache_fini (void);
 221
 222 void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
 223
 224 class GTY(()) string_concat
 225 {
 226 public:
 227   string_concat (int num, location_t *locs);
 228
 229   int m_num;
 230   location_t * GTY ((atomic)) m_locs;
 231 };
 232
 233 struct location_hash : int_hash <location_t, UNKNOWN_LOCATION> { };
 234
 235 class GTY(()) string_concat_db
 236 {
 237  public:
 238   string_concat_db ();
 239   void record_string_concatenation (int num, location_t *locs);
 240
 241   bool get_string_concatenation (location_t loc,
 242                                  int *out_num,
 243                                  location_t **out_locs);
 244
 245  private:
 246   static location_t get_key_loc (location_t loc);
 247
 248   /* For the fields to be private, we must grant access to the
 249      generated code in gtype-desc.c.  */
 250
 251   friend void ::gt_ggc_mx_string_concat_db (void *x_p);
 252   friend void ::gt_pch_nx_string_concat_db (void *x_p);
 253   friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
 254                                              gt_pointer_operator op,
 255                                              void *cookie);
 256
 257   hash_map <location_hash, string_concat *> *m_table;
 258 };
 259
 260 #endif