gdb/tid-parse.c

   1 /* TID parsing for GDB, the GNU debugger.
   2
   3    Copyright (C) 2015-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "tid-parse.h"
  21 #include "inferior.h"
  22 #include "gdbthread.h"
  23 #include <ctype.h>
  24
  25 /* See tid-parse.h.  */
  26
  27 void ATTRIBUTE_NORETURN
  28 invalid_thread_id_error (const char *string)
  29 {
  30   error (_("Invalid thread ID: %s"), string);
  31 }
  32
  33 /* Wrapper for get_number_trailer that throws an error if we get back
  34    a negative number.  We'll see a negative value if the number is
  35    stored in a negative convenience variable (e.g., $minus_one = -1).
  36    STRING is the parser string to be used in the error message if we
  37    do get back a negative number.  */
  38
  39 static int
  40 get_positive_number_trailer (const char **pp, int trailer, const char *string)
  41 {
  42   int num;
  43
  44   num = get_number_trailer (pp, trailer);
  45   if (num < 0)
  46     error (_("negative value: %s"), string);
  47   return num;
  48 }
  49
  50 /* See tid-parse.h.  */
  51
  52 struct thread_info *
  53 parse_thread_id (const char *tidstr, const char **end)
  54 {
  55   const char *number = tidstr;
  56   const char *dot, *p1;
  57   struct inferior *inf;
  58   int thr_num;
  59   int explicit_inf_id = 0;
  60
  61   dot = strchr (number, '.');
  62
  63   if (dot != NULL)
  64     {
  65       /* Parse number to the left of the dot.  */
  66       int inf_num;
  67
  68       p1 = number;
  69       inf_num = get_positive_number_trailer (&p1, '.', number);
  70       if (inf_num == 0)
  71         invalid_thread_id_error (number);
  72
  73       inf = find_inferior_id (inf_num);
  74       if (inf == NULL)
  75         error (_("No inferior number '%d'"), inf_num);
  76
  77       explicit_inf_id = 1;
  78       p1 = dot + 1;
  79     }
  80   else
  81     {
  82       inf = current_inferior ();
  83
  84       p1 = number;
  85     }
  86
  87   thr_num = get_positive_number_trailer (&p1, 0, number);
  88   if (thr_num == 0)
  89     invalid_thread_id_error (number);
  90
  91   thread_info *tp = nullptr;
  92   for (thread_info *it : inf->threads ())
  93     if (it->per_inf_num == thr_num)
  94       {
  95         tp = it;
  96         break;
  97       }
  98
  99   if (tp == NULL)
 100     {
 101       if (show_inferior_qualified_tids () || explicit_inf_id)
 102         error (_("Unknown thread %d.%d."), inf->num, thr_num);
 103       else
 104         error (_("Unknown thread %d."), thr_num);
 105     }
 106
 107   if (end != NULL)
 108     *end = p1;
 109
 110   return tp;
 111 }
 112
 113 /* See tid-parse.h.  */
 114
 115 tid_range_parser::tid_range_parser (const char *tidlist,
 116                                     int default_inferior)
 117 {
 118   init (tidlist, default_inferior);
 119 }
 120
 121 /* See tid-parse.h.  */
 122
 123 void
 124 tid_range_parser::init (const char *tidlist, int default_inferior)
 125 {
 126   m_state = STATE_INFERIOR;
 127   m_cur_tok = tidlist;
 128   m_inf_num = 0;
 129   m_qualified = false;
 130   m_default_inferior = default_inferior;
 131 }
 132
 133 /* See tid-parse.h.  */
 134
 135 bool
 136 tid_range_parser::finished () const
 137 {
 138   switch (m_state)
 139     {
 140     case STATE_INFERIOR:
 141       /* Parsing is finished when at end of string or null string,
 142          or we are not in a range and not in front of an integer, negative
 143          integer, convenience var or negative convenience var.  */
 144       return (*m_cur_tok == '\0'
 145               || !(isdigit (*m_cur_tok)
 146                    || *m_cur_tok == '$'
 147                    || *m_cur_tok == '*'));
 148     case STATE_THREAD_RANGE:
 149     case STATE_STAR_RANGE:
 150       return m_range_parser.finished ();
 151     }
 152
 153   gdb_assert_not_reached ("unhandled state");
 154 }
 155
 156 /* See tid-parse.h.  */
 157
 158 const char *
 159 tid_range_parser::cur_tok () const
 160 {
 161   switch (m_state)
 162     {
 163     case STATE_INFERIOR:
 164       return m_cur_tok;
 165     case STATE_THREAD_RANGE:
 166     case STATE_STAR_RANGE:
 167       return m_range_parser.cur_tok ();
 168     }
 169
 170   gdb_assert_not_reached ("unhandled state");
 171 }
 172
 173 void
 174 tid_range_parser::skip_range ()
 175 {
 176   gdb_assert (m_state == STATE_THREAD_RANGE
 177               || m_state == STATE_STAR_RANGE);
 178
 179   m_range_parser.skip_range ();
 180   init (m_range_parser.cur_tok (), m_default_inferior);
 181 }
 182
 183 /* See tid-parse.h.  */
 184
 185 bool
 186 tid_range_parser::tid_is_qualified () const
 187 {
 188   return m_qualified;
 189 }
 190
 191 /* Helper for tid_range_parser::get_tid and
 192    tid_range_parser::get_tid_range.  Return the next range if THR_END
 193    is non-NULL, return a single thread ID otherwise.  */
 194
 195 bool
 196 tid_range_parser::get_tid_or_range (int *inf_num,
 197                                     int *thr_start, int *thr_end)
 198 {
 199   if (m_state == STATE_INFERIOR)
 200     {
 201       const char *p;
 202       const char *space;
 203
 204       space = skip_to_space (m_cur_tok);
 205
 206       p = m_cur_tok;
 207       while (p < space && *p != '.')
 208         p++;
 209       if (p < space)
 210         {
 211           const char *dot = p;
 212
 213           /* Parse number to the left of the dot.  */
 214           p = m_cur_tok;
 215           m_inf_num = get_positive_number_trailer (&p, '.', m_cur_tok);
 216           if (m_inf_num == 0)
 217             return 0;
 218
 219           m_qualified = true;
 220           p = dot + 1;
 221
 222           if (isspace (*p))
 223             return false;
 224         }
 225       else
 226         {
 227           m_inf_num = m_default_inferior;
 228           m_qualified = false;
 229           p = m_cur_tok;
 230         }
 231
 232       m_range_parser.init (p);
 233       if (p[0] == '*' && (p[1] == '\0' || isspace (p[1])))
 234         {
 235           /* Setup the number range parser to return numbers in the
 236              whole [1,INT_MAX] range.  */
 237           m_range_parser.setup_range (1, INT_MAX, skip_spaces (p + 1));
 238           m_state = STATE_STAR_RANGE;
 239         }
 240       else
 241         m_state = STATE_THREAD_RANGE;
 242     }
 243
 244   *inf_num = m_inf_num;
 245   *thr_start = m_range_parser.get_number ();
 246   if (*thr_start < 0)
 247     error (_("negative value: %s"), m_cur_tok);
 248   if (*thr_start == 0)
 249     {
 250       m_state = STATE_INFERIOR;
 251       return false;
 252     }
 253
 254   /* If we successfully parsed a thread number or finished parsing a
 255      thread range, switch back to assuming the next TID is
 256      inferior-qualified.  */
 257   if (!m_range_parser.in_range ())
 258     {
 259       m_state = STATE_INFERIOR;
 260       m_cur_tok = m_range_parser.cur_tok ();
 261
 262       if (thr_end != NULL)
 263         *thr_end = *thr_start;
 264     }
 265
 266   /* If we're midway through a range, and the caller wants the end
 267      value, return it and skip to the end of the range.  */
 268   if (thr_end != NULL
 269       && (m_state == STATE_THREAD_RANGE
 270           || m_state == STATE_STAR_RANGE))
 271     {
 272       *thr_end = m_range_parser.end_value ();
 273
 274       skip_range ();
 275     }
 276
 277   return (*inf_num != 0 && *thr_start != 0);
 278 }
 279
 280 /* See tid-parse.h.  */
 281
 282 bool
 283 tid_range_parser::get_tid_range (int *inf_num,
 284                                  int *thr_start, int *thr_end)
 285 {
 286   gdb_assert (inf_num != NULL && thr_start != NULL && thr_end != NULL);
 287
 288   return get_tid_or_range (inf_num, thr_start, thr_end);
 289 }
 290
 291 /* See tid-parse.h.  */
 292
 293 bool
 294 tid_range_parser::get_tid (int *inf_num, int *thr_num)
 295 {
 296   gdb_assert (inf_num != NULL && thr_num != NULL);
 297
 298   return get_tid_or_range (inf_num, thr_num, NULL);
 299 }
 300
 301 /* See tid-parse.h.  */
 302
 303 bool
 304 tid_range_parser::in_star_range () const
 305 {
 306   return m_state == STATE_STAR_RANGE;
 307 }
 308
 309 bool
 310 tid_range_parser::in_thread_range () const
 311 {
 312   return m_state == STATE_THREAD_RANGE;
 313 }
 314
 315 /* See tid-parse.h.  */
 316
 317 int
 318 tid_is_in_list (const char *list, int default_inferior,
 319                 int inf_num, int thr_num)
 320 {
 321   if (list == NULL || *list == '\0')
 322     return 1;
 323
 324   tid_range_parser parser (list, default_inferior);
 325   if (parser.finished ())
 326     invalid_thread_id_error (parser.cur_tok ());
 327   while (!parser.finished ())
 328     {
 329       int tmp_inf, tmp_thr_start, tmp_thr_end;
 330
 331       if (!parser.get_tid_range (&tmp_inf, &tmp_thr_start, &tmp_thr_end))
 332         invalid_thread_id_error (parser.cur_tok ());
 333       if (tmp_inf == inf_num
 334           && tmp_thr_start <= thr_num && thr_num <= tmp_thr_end)
 335         return 1;
 336     }
 337   return 0;
 338 }