This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

Re: [rfa] symbol hashing, part 2/n - ALL_BLOCK_SYMBOLS



Daniel,
Thanks so much for doing this. It makes it so much easier.

Yes, I looked ths over and it seems to work, except that I would really
prefer the change to printcmd.c split in two. The first bit to
rationalize that "if (func)..."  code. This would have with it all
the indentation changes as well. The code as it is now doesn't really
make much sense. So, that looks a good change to me. But it has nothing
to do with the new macro.  After that change is in, you can introduce
the macro in printcmd.c w/o having all the indent changes.
It also makes it easier to distinguish a no-op change (the macro) from
the other one.

The cahnge is printcmd.c needs to delete also the 
	  sym = BLOCK_SYM (b, i);
line.

[Note that I don't maintain printcmd.c, so, I should just shut up :-)]

I applied your patch as is to my sources, and did a grep for BLOCK_SYM,
and found a few more for loops that could be converted:


This one in buildsym.c:
line ~280:

	  struct symbol *sym;
	  for (i = 0; i < BLOCK_NSYMS (block); i++)
	    {
	      sym = BLOCK_SYM (block, i);

And this one in symtab.c:
line ~1500:

	top = BLOCK_NSYMS (block);
	for (bot = 0; bot < top; bot++)
	  {
	    sym = BLOCK_SYM (block, bot);

Another one is in mi/mi-stack-cmd.c.
There are some also in gdbtk/generic/gdbtk-cmds.c and gdbtk-stack.c.

Some tricky ones are left, for a second pass. In mdebugread.c: it is
actually a while loop, in mylookup_symbol, similarly in coffread.c:
patch_opaque_types(), the for loop is reversed.
(Were these in your original patch? I don't remember).

I cannot spot any others, can you?

Elena

Daniel Jacobowitz writes:
 > 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  <drow@mvista.com>
 > 
 > 	* 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 */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]