From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Jacobowitz To: gdb-patches@sources.redhat.com Subject: [rfa] symbol hashing, part 2/n - ALL_BLOCK_SYMBOLS Date: Tue, 09 Oct 2001 09:35:00 -0000 Message-id: <20011009123457.A28534@nevyn.them.org> X-SW-Source: 2001-10/msg00100.html This patch changes no functionality; it replaces for loops with an ALL_BLOCK_SYMBOLS macro in places where it is entirely unambiguous to do so. I consider it fairly obvious, but I would greatly appreciate another set of eyes, since I touch a fair amount of code. The large printcmd changes are (should be?) just indentation updates. Is this OK? -- Daniel Jacobowitz Carnegie Mellon University MontaVista Software Debian GNU/Linux Developer 2001-10-01 Daniel Jacobowitz * symtab.h (struct block): (ALL_BLOCK_SYMBOLS): New macro. * symtab.c (find_pc_sect_symtab): Use ALL_BLOCK_SYMBOLS. (make_symbol_completion_list): Likewise. (make_symbol_overload_list): Likewise. * symmisc.c (dump_symtab): Likewise. * breakpoint.c (get_catch_sals): Likewise. * objfiles.c (objfile_relocate): Likewise. * stack.c (print_block_frame_locals): Likewise. (print_block_frame_labels): Likewise. (print_frame_arg_vars): Likewise. * tracepoint.c (add_local_symbols): Likewise. (scope_info): Likewise. * printcmd.c (print_frame_args): Likewise. Index: gdb/breakpoint.c =================================================================== RCS file: /cvs/src/src/gdb/breakpoint.c,v retrieving revision 1.53 diff -u -p -r1.53 breakpoint.c --- breakpoint.c 2001/09/18 05:00:48 1.53 +++ breakpoint.c 2001/10/01 22:20:38 @@ -5871,15 +5871,11 @@ get_catch_sals (int this_level_only) if (blocks_searched[index] == 0) { struct block *b = BLOCKVECTOR_BLOCK (bl, index); - int nsyms; register int i; register struct symbol *sym; - nsyms = BLOCK_NSYMS (b); - - for (i = 0; i < nsyms; i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); if (STREQ (SYMBOL_NAME (sym), "default")) { if (have_default) Index: gdb/objfiles.c =================================================================== RCS file: /cvs/src/src/gdb/objfiles.c,v retrieving revision 1.16 diff -u -p -r1.16 objfiles.c --- objfiles.c 2001/07/05 21:32:39 1.16 +++ objfiles.c 2001/10/01 22:20:53 @@ -557,16 +557,15 @@ objfile_relocate (struct objfile *objfil for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i) { struct block *b; + struct symbol *sym; int j; b = BLOCKVECTOR_BLOCK (bv, i); BLOCK_START (b) += ANOFFSET (delta, s->block_line_section); BLOCK_END (b) += ANOFFSET (delta, s->block_line_section); - for (j = 0; j < BLOCK_NSYMS (b); ++j) + ALL_BLOCK_SYMBOLS (b, j, sym) { - struct symbol *sym = BLOCK_SYM (b, j); - fixup_symbol_section (sym, objfile); /* The RS6000 code from which this was taken skipped Index: gdb/printcmd.c =================================================================== RCS file: /cvs/src/src/gdb/printcmd.c,v retrieving revision 1.27 diff -u -p -r1.27 printcmd.c --- printcmd.c 2001/09/12 04:18:08 1.27 +++ printcmd.c 2001/10/01 22:20:54 @@ -1806,168 +1806,168 @@ print_frame_args (struct symbol *func, s if (func) { b = SYMBOL_BLOCK_VALUE (func); nsyms = BLOCK_NSYMS (b); - } - for (i = 0; i < nsyms; i++) - { - QUIT; - sym = BLOCK_SYM (b, i); + ALL_BLOCK_SYMBOLS (b, i, sym) + { + QUIT; + sym = BLOCK_SYM (b, i); - /* Keep track of the highest stack argument offset seen, and - skip over any kinds of symbols we don't care about. */ + /* Keep track of the highest stack argument offset seen, and + skip over any kinds of symbols we don't care about. */ - switch (SYMBOL_CLASS (sym)) - { - case LOC_ARG: - case LOC_REF_ARG: - { - long current_offset = SYMBOL_VALUE (sym); - arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym)); + switch (SYMBOL_CLASS (sym)) + { + case LOC_ARG: + case LOC_REF_ARG: + { + long current_offset = SYMBOL_VALUE (sym); + arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym)); - /* Compute address of next argument by adding the size of - this argument and rounding to an int boundary. */ - current_offset = - ((current_offset + arg_size + sizeof (int) - 1) - & ~(sizeof (int) - 1)); - - /* If this is the highest offset seen yet, set highest_offset. */ - if (highest_offset == -1 - || (current_offset > highest_offset)) - highest_offset = current_offset; + /* Compute address of next argument by adding the size of + this argument and rounding to an int boundary. */ + current_offset = + ((current_offset + arg_size + sizeof (int) - 1) + & ~(sizeof (int) - 1)); + + /* If this is the highest offset seen yet, set highest_offset. */ + if (highest_offset == -1 + || (current_offset > highest_offset)) + highest_offset = current_offset; - /* Add the number of ints we're about to print to args_printed. */ - args_printed += (arg_size + sizeof (int) - 1) / sizeof (int); - } + /* Add the number of ints we're about to print to args_printed. */ + args_printed += (arg_size + sizeof (int) - 1) / sizeof (int); + } - /* We care about types of symbols, but don't need to keep track of - stack offsets in them. */ - case LOC_REGPARM: - case LOC_REGPARM_ADDR: - case LOC_LOCAL_ARG: - case LOC_BASEREG_ARG: - break; - - /* Other types of symbols we just skip over. */ - default: - continue; - } + /* We care about types of symbols, but don't need to keep track of + stack offsets in them. */ + case LOC_REGPARM: + case LOC_REGPARM_ADDR: + case LOC_LOCAL_ARG: + case LOC_BASEREG_ARG: + break; + + /* Other types of symbols we just skip over. */ + default: + continue; + } - /* We have to look up the symbol because arguments can have - two entries (one a parameter, one a local) and the one we - want is the local, which lookup_symbol will find for us. - This includes gcc1 (not gcc2) on the sparc when passing a - small structure and gcc2 when the argument type is float - and it is passed as a double and converted to float by - the prologue (in the latter case the type of the LOC_ARG - symbol is double and the type of the LOC_LOCAL symbol is - float). */ - /* But if the parameter name is null, don't try it. - Null parameter names occur on the RS/6000, for traceback tables. - FIXME, should we even print them? */ + /* We have to look up the symbol because arguments can have + two entries (one a parameter, one a local) and the one we + want is the local, which lookup_symbol will find for us. + This includes gcc1 (not gcc2) on the sparc when passing a + small structure and gcc2 when the argument type is float + and it is passed as a double and converted to float by + the prologue (in the latter case the type of the LOC_ARG + symbol is double and the type of the LOC_LOCAL symbol is + float). */ + /* But if the parameter name is null, don't try it. + Null parameter names occur on the RS/6000, for traceback tables. + FIXME, should we even print them? */ - if (*SYMBOL_NAME (sym)) - { - struct symbol *nsym; - nsym = lookup_symbol - (SYMBOL_NAME (sym), - b, VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL); - if (SYMBOL_CLASS (nsym) == LOC_REGISTER) + if (*SYMBOL_NAME (sym)) { - /* There is a LOC_ARG/LOC_REGISTER pair. This means that - it was passed on the stack and loaded into a register, - or passed in a register and stored in a stack slot. - GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER. - - Reasons for using the LOC_ARG: - (1) because find_saved_registers may be slow for remote - debugging, - (2) because registers are often re-used and stack slots - rarely (never?) are. Therefore using the stack slot is - much less likely to print garbage. - - Reasons why we might want to use the LOC_REGISTER: - (1) So that the backtrace prints the same value as - "print foo". I see no compelling reason why this needs - to be the case; having the backtrace print the value which - was passed in, and "print foo" print the value as modified - within the called function, makes perfect sense to me. - - Additional note: It might be nice if "info args" displayed - both values. - One more note: There is a case with sparc structure passing - where we need to use the LOC_REGISTER, but this is dealt with - by creating a single LOC_REGPARM in symbol reading. */ - - /* Leave sym (the LOC_ARG) alone. */ - ; + struct symbol *nsym; + nsym = lookup_symbol + (SYMBOL_NAME (sym), + b, VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL); + if (SYMBOL_CLASS (nsym) == LOC_REGISTER) + { + /* There is a LOC_ARG/LOC_REGISTER pair. This means that + it was passed on the stack and loaded into a register, + or passed in a register and stored in a stack slot. + GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER. + + Reasons for using the LOC_ARG: + (1) because find_saved_registers may be slow for remote + debugging, + (2) because registers are often re-used and stack slots + rarely (never?) are. Therefore using the stack slot is + much less likely to print garbage. + + Reasons why we might want to use the LOC_REGISTER: + (1) So that the backtrace prints the same value as + "print foo". I see no compelling reason why this needs + to be the case; having the backtrace print the value which + was passed in, and "print foo" print the value as modified + within the called function, makes perfect sense to me. + + Additional note: It might be nice if "info args" displayed + both values. + One more note: There is a case with sparc structure passing + where we need to use the LOC_REGISTER, but this is dealt with + by creating a single LOC_REGPARM in symbol reading. */ + + /* Leave sym (the LOC_ARG) alone. */ + ; + } + else + sym = nsym; } - else - sym = nsym; - } #ifdef UI_OUT - /* Print the current arg. */ - if (!first) - ui_out_text (uiout, ", "); - ui_out_wrap_hint (uiout, " "); - - annotate_arg_begin (); - - list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - fprintf_symbol_filtered (stb->stream, SYMBOL_SOURCE_NAME (sym), - SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI); - ui_out_field_stream (uiout, "name", stb); - annotate_arg_name_end (); - ui_out_text (uiout, "="); + /* Print the current arg. */ + if (!first) + ui_out_text (uiout, ", "); + ui_out_wrap_hint (uiout, " "); + + annotate_arg_begin (); + + list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); + fprintf_symbol_filtered (stb->stream, SYMBOL_SOURCE_NAME (sym), + SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI); + ui_out_field_stream (uiout, "name", stb); + annotate_arg_name_end (); + ui_out_text (uiout, "="); #else - /* Print the current arg. */ - if (!first) - fprintf_filtered (stream, ", "); - wrap_here (" "); - - annotate_arg_begin (); - - fprintf_symbol_filtered (stream, SYMBOL_SOURCE_NAME (sym), - SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI); - annotate_arg_name_end (); - fputs_filtered ("=", stream); + /* Print the current arg. */ + if (!first) + fprintf_filtered (stream, ", "); + wrap_here (" "); + + annotate_arg_begin (); + + fprintf_symbol_filtered (stream, SYMBOL_SOURCE_NAME (sym), + SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI); + annotate_arg_name_end (); + fputs_filtered ("=", stream); #endif - /* Avoid value_print because it will deref ref parameters. We just - want to print their addresses. Print ??? for args whose address - we do not know. We pass 2 as "recurse" to val_print because our - standard indentation here is 4 spaces, and val_print indents - 2 for each recurse. */ - val = read_var_value (sym, fi); + /* Avoid value_print because it will deref ref parameters. We just + want to print their addresses. Print ??? for args whose address + we do not know. We pass 2 as "recurse" to val_print because our + standard indentation here is 4 spaces, and val_print indents + 2 for each recurse. */ + val = read_var_value (sym, fi); - annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val)); + annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val)); - if (val) - { + if (val) + { #ifdef UI_OUT - val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0, - VALUE_ADDRESS (val), - stb->stream, 0, 0, 2, Val_no_prettyprint); - ui_out_field_stream (uiout, "value", stb); - } - else - ui_out_text (uiout, "???"); + val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0, + VALUE_ADDRESS (val), + stb->stream, 0, 0, 2, Val_no_prettyprint); + ui_out_field_stream (uiout, "value", stb); + } + else + ui_out_text (uiout, "???"); - /* Invoke ui_out_tuple_end. */ - do_cleanups (list_chain); + /* Invoke ui_out_tuple_end. */ + do_cleanups (list_chain); #else - val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0, - VALUE_ADDRESS (val), - stream, 0, 0, 2, Val_no_prettyprint); - } - else - fputs_filtered ("???", stream); + val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0, + VALUE_ADDRESS (val), + stream, 0, 0, 2, Val_no_prettyprint); + } + else + fputs_filtered ("???", stream); #endif - annotate_arg_end (); + annotate_arg_end (); - first = 0; + first = 0; + } } /* Don't print nameless args in situations where we don't know Index: gdb/stack.c =================================================================== RCS file: /cvs/src/src/gdb/stack.c,v retrieving revision 1.22 diff -u -p -r1.22 stack.c --- stack.c 2001/07/14 18:59:07 1.22 +++ stack.c 2001/10/01 22:20:55 @@ -1207,16 +1207,12 @@ static int print_block_frame_locals (struct block *b, register struct frame_info *fi, int num_tabs, register struct ui_file *stream) { - int nsyms; register int i, j; register struct symbol *sym; register int values_printed = 0; - nsyms = BLOCK_NSYMS (b); - - for (i = 0; i < nsyms; i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); switch (SYMBOL_CLASS (sym)) { case LOC_LOCAL: @@ -1246,16 +1242,12 @@ static int print_block_frame_labels (struct block *b, int *have_default, register struct ui_file *stream) { - int nsyms; register int i; register struct symbol *sym; register int values_printed = 0; - - nsyms = BLOCK_NSYMS (b); - for (i = 0; i < nsyms; i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); if (STREQ (SYMBOL_NAME (sym), "default")) { if (*have_default) @@ -1432,7 +1424,6 @@ print_frame_arg_vars (register struct fr { struct symbol *func = get_frame_function (fi); register struct block *b; - int nsyms; register int i; register struct symbol *sym, *sym2; register int values_printed = 0; @@ -1444,11 +1435,8 @@ print_frame_arg_vars (register struct fr } b = SYMBOL_BLOCK_VALUE (func); - nsyms = BLOCK_NSYMS (b); - - for (i = 0; i < nsyms; i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); switch (SYMBOL_CLASS (sym)) { case LOC_ARG: @@ -1483,7 +1471,6 @@ print_frame_arg_vars (register struct fr break; } } - if (!values_printed) { fprintf_filtered (stream, "No arguments.\n"); Index: gdb/symmisc.c =================================================================== RCS file: /cvs/src/src/gdb/symmisc.c,v retrieving revision 1.5 diff -u -p -r1.5 symmisc.c --- symmisc.c 2001/03/06 08:21:17 1.5 +++ symmisc.c 2001/10/01 22:20:56 @@ -410,6 +416,7 @@ dump_symtab (struct objfile *objfile, st int len, blen; register struct linetable *l; struct blockvector *bv; + struct symbol *sym; register struct block *b; int depth; @@ -471,11 +478,12 @@ dump_symtab (struct objfile *objfile, st if (BLOCK_GCC_COMPILED (b)) fprintf_filtered (outfile, ", compiled with gcc%d", BLOCK_GCC_COMPILED (b)); fprintf_filtered (outfile, "\n"); - /* Now print each symbol in this block */ - for (j = 0; j < blen; j++) + /* Now print each symbol in this block. */ + /* FIXMED: Sort? */ + ALL_BLOCK_SYMBOLS (b, j, sym) { struct print_symbol_args s; - s.symbol = BLOCK_SYM (b, j); + s.symbol = sym; s.depth = depth + 1; s.outfile = outfile; catch_errors (print_symbol, &s, "Error printing symbol:\n", Index: gdb/symtab.c =================================================================== RCS file: /cvs/src/src/gdb/symtab.c,v retrieving revision 1.42 diff -u -p -r1.42 symtab.c --- symtab.c 2001/07/07 17:19:50 1.42 +++ symtab.c 2001/10/01 22:20:57 @@ -3030,9 +3051,8 @@ make_symbol_completion_list (char *text, /* Also catch fields of types defined in this places which match our text string. Only complete on types visible from current context. */ - for (i = 0; i < BLOCK_NSYMS (b); i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); if (SYMBOL_CLASS (sym) == LOC_TYPEDEF) { @@ -3061,23 +3081,22 @@ make_symbol_completion_list (char *text, { QUIT; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - for (i = 0; i < BLOCK_NSYMS (b); i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } } ALL_SYMTABS (objfile, s) { + struct symbol *sym; QUIT; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); /* Don't do this block twice. */ if (b == surrounding_static_block) continue; - for (i = 0; i < BLOCK_NSYMS (b); i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } } @@ -3181,16 +3200,14 @@ make_file_symbol_completion_list (char * symbols which match. */ b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - for (i = 0; i < BLOCK_NSYMS (b); i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); - for (i = 0; i < BLOCK_NSYMS (b); i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } @@ -3568,9 +3585,8 @@ make_symbol_overload_list (struct symbol /* Also catch fields of types defined in this places which match our text string. Only complete on types visible from current context. */ - for (i = 0; i < BLOCK_NSYMS (b); i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); overload_list_add_symbol (sym, oload_name); } } @@ -3582,9 +3598,8 @@ make_symbol_overload_list (struct symbol { QUIT; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - for (i = 0; i < BLOCK_NSYMS (b); i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); overload_list_add_symbol (sym, oload_name); } } @@ -3596,9 +3611,8 @@ make_symbol_overload_list (struct symbol /* Don't do this block twice. */ if (b == surrounding_static_block) continue; - for (i = 0; i < BLOCK_NSYMS (b); i++) + ALL_BLOCK_SYMBOLS (b, i, sym) { - sym = BLOCK_SYM (b, i); overload_list_add_symbol (sym, oload_name); } } Index: gdb/symtab.h =================================================================== RCS file: /cvs/src/src/gdb/symtab.h,v retrieving revision 1.24 diff -u -p -r1.24 symtab.h --- symtab.h Tue Oct 9 11:21:41 2001 +++ symtab.h Tue Oct 9 11:23:14 2001 @@ -467,6 +467,14 @@ #define BLOCK_SUPERBLOCK(bl) (bl)->superblock #define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag +/* Macro to loop through all symbols in a block BL. + i counts which symbol we are looking at, and sym points to the current + symbol. */ +#define ALL_BLOCK_SYMBOLS(bl, i, sym) \ + for ((i) = 0, (sym) = BLOCK_SYM ((bl), (i)); \ + (i) < BLOCK_NSYMS ((bl)); \ + ++(i), (sym) = BLOCK_SYM ((bl), (i))) + /* Nonzero if symbols of block BL should be sorted alphabetically. Don't sort a block which corresponds to a function. If we did the sorting would have to preserve the order of the symbols for the Index: gdb/tracepoint.c =================================================================== RCS file: /cvs/src/src/gdb/tracepoint.c,v retrieving revision 1.26 diff -u -p -r1.26 tracepoint.c --- tracepoint.c 2001/08/23 20:31:36 1.26 +++ tracepoint.c 2001/10/01 22:20:59 @@ -1296,16 +1296,14 @@ add_local_symbols (struct collection_lis { struct symbol *sym; struct block *block; - int i, nsyms, count = 0; + int i, count = 0; block = block_for_pc (pc); while (block != 0) { QUIT; /* allow user to bail out with ^C */ - nsyms = BLOCK_NSYMS (block); - for (i = 0; i < nsyms; i++) + ALL_BLOCK_SYMBOLS (block, i, sym) { - sym = BLOCK_SYM (block, i); switch (SYMBOL_CLASS (sym)) { default: @@ -2335,7 +2333,7 @@ scope_info (char *args, int from_tty) struct minimal_symbol *msym; struct block *block; char **canonical, *symname, *save_args = args; - int i, j, nsyms, count = 0; + int i, j, count = 0; if (args == 0 || *args == 0) error ("requires an argument (function, line or *addr) to define a scope"); @@ -2351,14 +2349,13 @@ scope_info (char *args, int from_tty) while (block != 0) { QUIT; /* allow user to bail out with ^C */ - nsyms = BLOCK_NSYMS (block); - for (i = 0; i < nsyms; i++) + ALL_BLOCK_SYMBOLS (block, i, sym) { QUIT; /* allow user to bail out with ^C */ if (count == 0) printf_filtered ("Scope for %s:\n", save_args); count++; - sym = BLOCK_SYM (block, i); + symname = SYMBOL_NAME (sym); if (symname == NULL || *symname == '\0') continue; /* probably botched, certainly useless */