From 0e2a21335b6fc4a5b6bed19d9623916c52918b72 Mon Sep 17 00:00:00 2001 From: Andrew Burgess Date: Mon, 7 Jan 2019 07:26:35 +0000 Subject: gdb: Avoid signed integer overflow when printing source lines When printing source lines with calls to print_source_lines we need to pass a start line number and an end line number. The end line number is calculated by calling get_lines_to_list and adding this value to the start line number. For example this code from list_command: print_source_lines (cursal.symtab, first, first + get_lines_to_list (), 0); The problem is that get_lines_to_list returns a value based on the GDB setting `set listsize LISTSIZE`. By default LISTSIZE is 10, however, its also possible to set LISTSIZE to unlimited, in which case get_lines_to_list will return INT_MAX. As the parameter signature for print_source_lines is: void print_source_lines (struct symtab *, int, int, print_source_lines_flags); and `first` in the above code is an `int`, then when LISTSIZE is `unlimited` the above code will result in signed integer overflow, which is undefined. The solution in this patch is a new class source_lines_range that can be constructed from a single line number and a direction (forward or backward). The range is then constructed from the line number and the value of get_lines_to_list. gdb/ChangeLog: * cli/cli-cmds.c (list_command): Pass a source_lines_range to print_source_lines. * source.c (print_source_lines_base): Update line number check. (print_source_lines): New function. (source_lines_range::source_lines_range): New function. * source.h (class source_lines_range): New class. (print_source_lines): New declaration. --- gdb/source.h | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) (limited to 'gdb/source.h') diff --git a/gdb/source.h b/gdb/source.h index fcd83da..f1b5f6e 100644 --- a/gdb/source.h +++ b/gdb/source.h @@ -157,6 +157,54 @@ DEF_ENUM_FLAGS_TYPE (enum print_source_lines_flag, print_source_lines_flags); extern void print_source_lines (struct symtab *s, int line, int stopline, print_source_lines_flags flags); +/* Wrap up the logic to build a line number range for passing to + print_source_lines when using get_lines_to_list. An instance of this + class can be built from a single line number and a direction (forward or + backward) the range is then computed using get_lines_to_list. */ +class source_lines_range +{ +public: + /* When constructing the range from a single line number, does the line + range extend forward, or backward. */ + enum direction + { + FORWARD, + BACKWARD + }; + + /* Construct a SOURCE_LINES_RANGE starting at STARTLINE and extending in + direction DIR. The number of lines is from GET_LINES_TO_LIST. If the + direction is backward then the start is actually (STARTLINE - + GET_LINES_TO_LIST). There is also logic in place to ensure the start + is always 1 or more, and the end will be at most INT_MAX. */ + explicit source_lines_range (int startline, direction dir = FORWARD); + + /* Construct a SOURCE_LINES_RANGE from STARTLINE to STOPLINE. */ + explicit source_lines_range (int startline, int stopline) + : m_startline (startline), + m_stopline (stopline) + { /* Nothing. */ } + + /* Return the line to start listing from. */ + int startline () const + { return m_startline; } + + /* Return the line after the last line that should be listed. */ + int stopline () const + { return m_stopline; } + +private: + + /* The start and end of the range. */ + int m_startline; + int m_stopline; +}; + +/* Variation of previous print_source_lines that takes a range instead of a + start and end line number. */ +extern void print_source_lines (struct symtab *s, source_lines_range r, + print_source_lines_flags flags); + /* Forget line positions and file names for the symtabs in a particular objfile. */ extern void forget_cached_source_info_for_objfile (struct objfile *); -- cgit v1.1