From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mark Mitchell To: kettenis@wins.uva.nl Cc: Peter.Schauer@Regent.E-Technik.TU-Muenchen.DE, kingdon@redhat.com, donnte@microsoft.com, gdb@sourceware.cygnus.com Subject: Re: Regressions problem (200 failures) Date: Sat, 01 Apr 2000 00:00:00 -0000 Message-id: <20000302090701N.mitchell@codesourcery.com> References: <200003021010.LAA13693@reisser.regent.e-technik.tu-muenchen.de> <20000302023420H.mitchell@codesourcery.com> <200003021246.e22CkWL00549@delius.kettenis.local> X-SW-Source: 2000-q1/msg00512.html >>>>> "Mark" == Mark Kettenis writes: Mark> some bit rot since then. Are the prologue's generated by Mark> GCC any different from those generated back in 1994? I dunno, but my guess is that's not the bug. Right now, the problem is: o We put line notes in the prologue o We weren't putting line notes before the first real code, so GCC was skipping over that too. o I promoted the last line note in the prologue to appear before the first real code, bringing GCC back to seme-sensible behavior. We could try to: o Not emit line notes in the prologue that correspond to the '{' line. o Try to find the first line note in the real code, instead of the last line note in the prologue. The latter is probably easiest, but is still harder that what I did. -- Mark Mitchell mark@codesourcery.com CodeSourcery, LLC http://www.codesourcery.com >From eliz@delorie.com Sat Apr 01 00:00:00 2000 From: Eli Zaretskii To: ezannoni@cygnus.com Cc: gdb@sourceware.cygnus.com Subject: Re: Buffering problems with "gdb < foo" Date: Sat, 01 Apr 2000 00:00:00 -0000 Message-id: <200003070817.DAA14441@indy.delorie.com> References: <200003050850.DAA10185@indy.delorie.com> <14531.61750.823726.628635@kwikemart.cygnus.com> X-SW-Source: 2000-q1/msg00555.html Content-length: 676 > > Does this work on Unix? If so, it would make this a DJGPP-specific > > problem. > > I haven't tried, but probably it won't. Can you send me your command file? It is simply "gdb < foo > bar". The input file `foo' looks like this: shell gcc -g -o t.exe t.c file t.exe dir y dir . break main run q y (If needed, I can send the exact file used for the input.) Try this, and you will see that GDB exits immediately after it processes the first "dir" command. > > If this is not DJGPP-specific, then I think _initialize_event_loop > > should turn editing off if input_fd is not a tty. > > I think so, can you submit a patch to do this? Will do. >From eliz@delorie.com Sat Apr 01 00:00:00 2000 From: Eli Zaretskii To: cgf@cygnus.com Cc: toddpw@windriver.com, gdb@sourceware.cygnus.com Subject: Re: Readline and -DMINIMAL Date: Sat, 01 Apr 2000 00:00:00 -0000 Message-id: <200003312329.SAA07193@indy.delorie.com> References: <200003281230.EAA15638@alabama.wrs.com> <20000328105123.G27306@cygnus.com> X-SW-Source: 2000-q1/msg00851.html Content-length: 397 > The readline directory in CVS is version > 4.0 with changes from Eli Zaretskii (I hope he also notified the readline > maintainer about these) to get things working on DJGPP. I checked my patches against the recent beta version of Readline, and all the changes are already taken care of there (the person who ported Bash to DJGPP submitted almost identical patches to the Readline maintainer). >From kingdon@redhat.com Sat Apr 01 00:00:00 2000 From: Jim Kingdon To: akale@veritas.com Cc: gdb-patches@sourceware.cygnus.com Subject: Re: Regression caused by elfread.c patch Date: Sat, 01 Apr 2000 00:00:00 -0000 Message-id: <200002150453.XAA11268@devserv.devel.redhat.com> References: <200002142206.e1EM6a310093@delius.kettenis.local> <00021509472500.20543@fermat.vxindia.veritas.com> X-SW-Source: 2000-q1/msg00286.html Content-length: 405 > That was because Jim didn't checkin my patch correctly. > He has fixed it now. No, this is a different problem. I don't see how your patch could work at all - sym->section->index is a very different number than a SECT_OFF_* code. The SECT_OFF_* code (which gets fed to ANOFFSET) isn't computed until later in the function (via the call to record_minimal_symbol_and_info). I have reverted the patch. >From fnasser@cygnus.com Sat Apr 01 00:00:00 2000 From: Fernando Nasser To: gdb@sourceware.cygnus.com Subject: Variable objects code now available in gdb Date: Sat, 01 Apr 2000 00:00:00 -0000 Message-id: <38A30E4E.B757E57E@cygnus.com> X-SW-Source: 2000-q1/msg00203.html Content-length: 830 The Insight GUI had a neat code, written by Keith Seitz, which allows for the tracking of variables and expressions. This is used by Insight to implement its Local Variables and Watch Expression windows. As this is can be really useful to script languages and most of the code was written in C, we decided to extract it and make it available on the gdb library. I have created a C API, fixed a few things and added the files varobj.c and varobj.h to gdb. There is also a wrapper.c file which provides longjump free calls to some gdb utility routines. P.S.: Insight was modified to use this new code as well. -- Fernando Nasser Red Hat - Toronto E-Mail: fnasser@cygnus.com 2323 Yonge Street, Suite #300 Tel: 416-482-2661 ext. 311 Toronto, Ontario M4P 2C9 Fax: 416-482-6299 >From echristo@cygnus.com Sat Apr 01 00:00:00 2000 From: Eric Christopher To: Jim Kingdon , gdb@sourceware.cygnus.com Subject: Re: Has anyone compiled gdb from CVS on Linux? Date: Sat, 01 Apr 2000 00:00:00 -0000 Message-id: <38A20644.99DEB7A6@cygnus.com> References: <20000208190825.A17306@lucon.org> X-SW-Source: 2000-q1/msg00195.html Content-length: 1366 The define is in the config.h file that gdb_wait.h needs to include . It doesn't seem to be included either in linux-thread.c or gdb_wait.h. I'm guessing it should be? from gdb/config.h: /* Define if you have the header file. */ #define HAVE_SYS_WAIT_H 1 and gdb/gdb_wait.h /#ifdef HAVE_SYS_WAIT_H #include /* POSIX */ #else #ifdef HAVE_WAIT_H #include /* legacy */ #endif #endif -eric > > > I cannot compile gdb from CVS on Linux since the merge. For one thing, > > include/wait.h doesn't have > > I got around this by the enclosed patch (all that HAVE_WAIT_H looks > like pre-POSIX cruft to me). I haven't tried to turn this into an > official submission (yet, at least). > > With this patch, it compiles and runs for me. > > Index: lin-thread.c > =================================================================== > RCS file: /cvs/src/src/gdb/lin-thread.c,v > retrieving revision 1.1.1.1 > diff -u -r1.1.1.1 lin-thread.c > --- lin-thread.c 1999/12/22 21:45:07 1.1.1.1 > +++ lin-thread.c 2000/02/09 04:45:14 > @@ -102,13 +102,7 @@ > #include "inferior.h" > #include "gdbcmd.h" > > -#ifdef HAVE_WAIT_H > -#include > -#else > -#ifdef HAVE_SYS_WAIT_H > #include > -#endif > -#endif > > /* "wait.h" fills in the gaps left by */ > #include "wait.h" >From jimb@zwingli.cygnus.com Sat Apr 01 00:00:00 2000 From: Jim Blandy To: gdb@sourceware.cygnus.com Subject: unloading shared objects Date: Sat, 01 Apr 2000 00:00:00 -0000 Message-id: <200003102115.QAA15516@zwingli.cygnus.com> X-SW-Source: 2000-q1/msg00672.html Content-length: 28044 I think I've got some code mostly working for this, but free_objfile is tangled up with CLEAR_SOLIB in a way that is causing problems. It'll take a little more work, but I think I'll have something ready soon. Unfortunately, it's not done right now, and I'll be gone for the entire weekend, so the earliest I could possibly have anything working would be Monday. I don't know how that interacts with our hopes for GDB 5.0. In case some enterprising soul wants to take it the rest of the way while I'm gone, I've enclosed my patches below. I think the basic logic is okay; known issues are: - free_objfile calls CLEAR_SOLIB, which isn't what we want, I think. - Selecting a core file and attaching to a process both add the shared libraries' sections to the target_ops structure. When we unload a shared library, we close the BFD those sections refer to. We need to remove those sections from the target_ops structure. And finally: - Should solib.c be maintaining its own list of shared objects at all, or should it always retrieve the full link map from the inferior, and use the objfile list itself as our record of what we know about? In other words, what does so_list_head offer that object_files doesn't do better? Anyway, I'll finish these when I get back, if nobody else does. I'd love comments on the changes. Index: solib.c =================================================================== RCS file: /cvs/src/src/gdb/solib.c,v retrieving revision 1.2 diff -c -r1.2 solib.c *** solib.c 2000/03/06 18:04:56 1.2 --- solib.c 2000/03/10 21:09:51 *************** *** 136,153 **** struct so_list { struct so_list *next; /* next structure in linked list */ struct link_map lm; /* copy of link map from inferior */ struct link_map *lmaddr; /* addr in inferior lm was read from */ CORE_ADDR lmend; /* upper addr bound of mapped object */ - char so_name[MAX_PATH_SIZE]; /* shared object lib name (FIXME) */ char symbols_loaded; /* flag: symbols read in yet? */ char from_tty; /* flag: print msgs? */ struct objfile *objfile; /* objfile for loaded lib */ struct section_table *sections; struct section_table *sections_end; struct section_table *textsection; - bfd *abfd; }; static struct so_list *so_list_head; /* List of known shared objects */ --- 136,171 ---- struct so_list { + /* The following fields of the structure come directly from the + dynamic linker's tables in the inferior, and are initialized by + current_sos. */ + struct so_list *next; /* next structure in linked list */ struct link_map lm; /* copy of link map from inferior */ struct link_map *lmaddr; /* addr in inferior lm was read from */ + + /* Shared object file name, exactly as it appears in the + inferior's link map. This may be a relative path, or something + which needs to be looked up in LD_LIBRARY_PATH, etc. We use it + to tell which entries in the inferior's dynamic linker's link + map we've already loaded. */ + char so_original_name[MAX_PATH_SIZE]; + + /* shared object file name, expanded to something GDB can open */ + char so_name[MAX_PATH_SIZE]; + + /* The following fields of the structure are built from + information gathered from the shared object file itself, and + are initialized when we actually add it to our symbol tables. */ + + bfd *abfd; CORE_ADDR lmend; /* upper addr bound of mapped object */ char symbols_loaded; /* flag: symbols read in yet? */ char from_tty; /* flag: print msgs? */ struct objfile *objfile; /* objfile for loaded lib */ struct section_table *sections; struct section_table *sections_end; struct section_table *textsection; }; static struct so_list *so_list_head; /* List of known shared objects */ *************** *** 168,174 **** match_main PARAMS ((char *)); static void ! special_symbol_handling PARAMS ((struct so_list *)); static void sharedlibrary_command PARAMS ((char *, int)); --- 186,192 ---- match_main PARAMS ((char *)); static void ! special_symbol_handling PARAMS ((void)); static void sharedlibrary_command PARAMS ((char *, int)); *************** *** 181,189 **** static int symbol_add_stub PARAMS ((PTR)); - static struct so_list * - find_solib PARAMS ((struct so_list *)); - static struct link_map * first_link_map_member PARAMS ((void)); --- 199,204 ---- *************** *** 199,204 **** --- 214,223 ---- #else + static struct so_list *current_sos (void); + static void free_so (struct so_list *node); + static void sync_solibs (struct target_ops *target); + static int disable_break PARAMS ((void)); *************** *** 854,860 **** Find the first element in the inferior's dynamic link map, and return its address in the inferior. This function doesn't copy the ! link map entry itself into our address space; find_solib actually does the reading. */ static struct link_map * --- 873,879 ---- Find the first element in the inferior's dynamic link map, and return its address in the inferior. This function doesn't copy the ! link map entry itself into our address space; current_sos actually does the reading. */ static struct link_map * *************** *** 951,1091 **** } #endif /* SVR4_SHARED_LIBS */ - /* ! LOCAL FUNCTION ! find_solib -- step through list of shared objects SYNOPSIS ! struct so_list *find_solib (struct so_list *so_list_ptr) DESCRIPTION ! This module contains the routine which finds the names of any ! loaded "images" in the current process. The argument in must be ! NULL on the first call, and then the returned value must be passed ! in on subsequent calls. This provides the capability to "step" down ! the list of loaded objects. On the last object, a NULL value is ! returned. ! The arg and return value are "struct link_map" pointers, as defined ! in . ! */ ! ! static struct so_list * ! find_solib (so_list_ptr) ! struct so_list *so_list_ptr; /* Last lm or NULL for first one */ { ! struct so_list *so_list_next = NULL; ! struct link_map *lm = NULL; ! struct so_list *new; ! if (so_list_ptr == NULL) { ! /* We are setting up for a new scan through the loaded images. */ ! if ((so_list_next = so_list_head) == NULL) ! { ! /* We have not already read in the dynamic linking structures ! from the inferior, lookup the address of the base structure. */ ! debug_base = locate_base (); ! if (debug_base != 0) ! { ! /* Read the base structure in and find the address of the first ! link map list member. */ ! lm = first_link_map_member (); ! } ! } } ! else { ! /* We have been called before, and are in the process of walking ! the shared library list. Advance to the next shared object. */ ! if ((lm = LM_NEXT (so_list_ptr)) == NULL) ! { ! /* We have hit the end of the list, so check to see if any were ! added, but be quiet if we can't read from the target any more. */ ! int status = target_read_memory ((CORE_ADDR) so_list_ptr->lmaddr, ! (char *) &(so_list_ptr->lm), ! sizeof (struct link_map)); ! if (status == 0) ! { ! lm = LM_NEXT (so_list_ptr); ! } ! else ! { ! lm = NULL; ! } ! } ! so_list_next = so_list_ptr->next; } ! if ((so_list_next == NULL) && (lm != NULL)) { ! /* Get next link map structure from inferior image and build a local ! abbreviated load_map structure */ ! new = (struct so_list *) xmalloc (sizeof (struct so_list)); ! memset ((char *) new, 0, sizeof (struct so_list)); ! new->lmaddr = lm; ! /* Add the new node as the next node in the list, or as the root ! node if this is the first one. */ ! if (so_list_ptr != NULL) ! { ! so_list_ptr->next = new; ! } ! else ! { ! so_list_head = new; ! if (!solib_cleanup_queued) ! { ! make_run_cleanup (do_clear_solib, NULL); ! solib_cleanup_queued = 1; ! } ! } ! so_list_next = new; read_memory ((CORE_ADDR) lm, (char *) &(new->lm), sizeof (struct link_map)); /* For SVR4 versions, the first entry in the link map is for the inferior executable, so we must ignore it. For some versions of SVR4, it has no name. For others (Solaris 2.3 for example), it does have a name, so we can no longer use a missing name to decide when to ignore it. */ ! if (!IGNORE_FIRST_LINK_MAP_ENTRY (new->lm)) { int errcode; char *buffer; target_read_string ((CORE_ADDR) LM_NAME (new), &buffer, MAX_PATH_SIZE - 1, &errcode); if (errcode != 0) { ! warning ("find_solib: Can't read pathname for load map: %s\n", safe_strerror (errcode)); - return (so_list_next); } ! strncpy (new->so_name, buffer, MAX_PATH_SIZE - 1); ! new->so_name[MAX_PATH_SIZE - 1] = '\0'; ! free (buffer); ! catch_errors (solib_map_sections, new, ! "Error while mapping shared library sections:\n", ! RETURN_MASK_ALL); } } ! return (so_list_next); } /* A small stub to get us past the arg-passing pinhole of catch_errors. */ static int symbol_add_stub (arg) PTR arg; { ! register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */ CORE_ADDR text_addr = 0; - struct section_addr_info section_addrs; ! memset (§ion_addrs, 0, sizeof (section_addrs)); if (so->textsection) text_addr = so->textsection->addr; else if (so->abfd != NULL) --- 970,1160 ---- } #endif /* SVR4_SHARED_LIBS */ ! /* LOCAL FUNCTION ! free_so --- free a `struct so_list' object SYNOPSIS ! void free_so (struct so_list *so) DESCRIPTION ! Free the storage associated with the `struct so_list' object *SO, ! and remove it from GDB's symbol tables, if it was there. Don't ! worry about unlinking it from the shared object list; the caller ! must handle that. ! ! This can be applied to both shared objects in GDB's list, or ! objects just obtained from current_sos, which don't have BFD's or ! objfiles created for them. */ ! static void ! free_so (struct so_list *so) { ! char *bfd_filename = 0; ! ! if (so->objfile) ! free_objfile (so->objfile); ! if (so->sections) ! free (so->sections); ! ! if (so->abfd) { ! bfd_filename = bfd_get_filename (so->abfd); ! if (! bfd_close (so->abfd)) ! warning ("cannot close \"%s\": %s", ! bfd_filename, bfd_errmsg (bfd_get_error ())); } ! ! if (bfd_filename) ! free (bfd_filename); ! ! free (so); ! } ! ! ! /* On some systems, the only way to recognize the link map entry for ! the main executable file is by looking at its name. Return ! non-zero iff SONAME matches one of the known main executable names. */ ! ! static int ! match_main (soname) ! char *soname; ! { ! char **mainp; ! ! for (mainp = main_name_list; *mainp != NULL; mainp++) { ! if (strcmp (soname, *mainp) == 0) ! return (1); } ! ! return (0); ! } ! ! ! /* LOCAL FUNCTION ! ! current_sos -- build a list of currently loaded shared objects ! ! SYNOPSIS ! ! struct so_list *current_sos () ! ! DESCRIPTION ! ! Build a list of `struct so_list' objects describing the shared ! objects currently loaded in the inferior. This list does not ! include an entry for the main executable file. ! ! Note that we only gather information directly available from the ! inferior --- we don't examine any of the shared library files ! themselves. The declaration of `struct so_list' says which fields ! we provide values for. */ ! ! static struct so_list * ! current_sos () ! { ! struct link_map *lm; ! struct so_list *head = 0; ! struct so_list **link_ptr = &head; ! ! /* Make sure we've looked up the inferior's dynamic linker's base ! structure. */ ! if (! debug_base) { ! debug_base = locate_base (); ! /* If we can't find the dynamic linker's base structure, this ! must not be a dynamically linked executable. Hmm. */ ! if (! debug_base) ! return 0; ! } ! /* Walk the inferior's link map list, and build our list of ! `struct so_list' nodes. */ ! lm = first_link_map_member (); ! while (lm) ! { ! struct so_list *new ! = (struct so_list *) xmalloc (sizeof (struct so_list)); ! memset (new, 0, sizeof (*new)); ! ! new->lmaddr = lm; read_memory ((CORE_ADDR) lm, (char *) &(new->lm), sizeof (struct link_map)); + + lm = LM_NEXT (new); + /* For SVR4 versions, the first entry in the link map is for the inferior executable, so we must ignore it. For some versions of SVR4, it has no name. For others (Solaris 2.3 for example), it does have a name, so we can no longer use a missing name to decide when to ignore it. */ ! if (IGNORE_FIRST_LINK_MAP_ENTRY (new->lm)) { + free_so (new); + } + else + { int errcode; char *buffer; + + /* Extract this shared object's name. */ target_read_string ((CORE_ADDR) LM_NAME (new), &buffer, MAX_PATH_SIZE - 1, &errcode); if (errcode != 0) { ! warning ("current_sos: Can't read pathname for load map: %s\n", safe_strerror (errcode)); } ! else ! { ! strncpy (new->so_name, buffer, MAX_PATH_SIZE - 1); ! new->so_name[MAX_PATH_SIZE - 1] = '\0'; ! free (buffer); ! strcpy (new->so_original_name, new->so_name); ! } ! ! /* If this entry has no name, or its name matches the name ! for the main executable, don't include it in the list. */ ! if (! new->so_name[0] ! || match_main (new->so_name)) ! free_so (new); ! else ! { ! new->next = 0; ! *link_ptr = new; ! link_ptr = &new->next; ! } } } ! ! return head; } + /* A small stub to get us past the arg-passing pinhole of catch_errors. */ static int symbol_add_stub (arg) PTR arg; { ! /* catch_errs bogon */ ! register struct so_list *so = (struct so_list *) arg; CORE_ADDR text_addr = 0; ! /* Have we already loaded this shared object? */ ! ALL_OBJFILES (so->objfile) ! { ! if (strcmp (so->objfile->name, so->so_name) == 0) ! return 1; ! } ! ! /* Find the shared object's text segment. */ if (so->textsection) text_addr = so->textsection->addr; else if (so->abfd != NULL) *************** *** 1094,1100 **** /* If we didn't find a mapped non zero sized .text section, set up text_addr so that the relocation in symbol_file_add does no harm. */ - lowest_sect = bfd_get_section_by_name (so->abfd, ".text"); if (lowest_sect == NULL) bfd_map_over_sections (so->abfd, find_lowest_section, --- 1163,1168 ---- *************** *** 1104,1168 **** + (CORE_ADDR) LM_ADDR (so); } - ALL_OBJFILES (so->objfile) { ! if (strcmp (so->objfile->name, so->so_name) == 0) ! return 1; ! } ! section_addrs.text_addr = text_addr; ! so->objfile = ! symbol_file_add (so->so_name, so->from_tty, ! §ion_addrs, 0, OBJF_SHARED); ! return (1); ! } ! /* This function will check the so name to see if matches the main list. ! In some system the main object is in the list, which we want to exclude */ ! ! static int ! match_main (soname) ! char *soname; ! { ! char **mainp; ! for (mainp = main_name_list; *mainp != NULL; mainp++) ! { ! if (strcmp (soname, *mainp) == 0) ! return (1); ! } ! return (0); } - /* ! GLOBAL FUNCTION ! solib_add -- add a shared library file to the symtab and section list SYNOPSIS ! void solib_add (char *arg_string, int from_tty, ! struct target_ops *target) DESCRIPTION ! */ void ! solib_add (arg_string, from_tty, target) ! char *arg_string; ! int from_tty; ! struct target_ops *target; { ! register struct so_list *so = NULL; /* link map state variable */ ! ! /* Last shared library that we read. */ ! struct so_list *so_last = NULL; ! char *re_err; ! int count; ! int old; #ifdef SVR4_SHARED_LIBS /* If we are attaching to a running process for which we --- 1172,1235 ---- + (CORE_ADDR) LM_ADDR (so); } { ! struct section_addr_info section_addrs; ! memset (§ion_addrs, 0, sizeof (section_addrs)); ! section_addrs.text_addr = text_addr; ! so->objfile = symbol_file_add (so->so_name, so->from_tty, ! §ion_addrs, 0, OBJF_SHARED); ! } ! return (1); } ! /* LOCAL FUNCTION ! solib_add -- synchronize GDB's shared object list with the inferior's SYNOPSIS ! void solib_add (char *pattern, int from_tty, struct target_ops *TARGET) DESCRIPTION ! Extract the list of currently loaded shared objects from the ! inferior, and compare it with the list of shared objects for which ! GDB has currently loaded symbolic information. If new shared ! objects have been loaded, or old shared objects have disappeared, ! make the appropriate changes to GDB's tables. ! ! If PATTERN is non-null, read symbols only for shared objects ! whose names match PATTERN. ! ! If FROM_TTY is non-null, feel free to print messages about what ! we're doing. ! ! If TARGET is non-null, add the sections of all new shared objects ! to TARGET's section table. Note that this doesn't remove any ! sections for shared objects that have been unloaded, and it ! doesn't check to see if the new shared objects are already present in ! the section table. But we only use this for core files and ! processes we've just attached to, so that's okay. */ void ! solib_add (char *pattern, int from_tty, struct target_ops *target) { ! struct so_list *inferior = current_sos (); ! struct so_list *gdb, **gdb_link; ! #define JIMB_DEBUG ! #ifdef JIMB_DEBUG ! printf ("GDB's shared library list:\n"); ! for (gdb = so_list_head; gdb; gdb = gdb->next) ! printf (" %s\n", gdb->so_original_name); ! printf ("inferior's shared library list:\n"); ! for (gdb = inferior; gdb; gdb = gdb->next) ! printf (" %s\n", gdb->so_original_name); ! #endif #ifdef SVR4_SHARED_LIBS /* If we are attaching to a running process for which we *************** *** 1176,1254 **** #endif SVR4_SHARED_LIBS ! if ((re_err = re_comp (arg_string? arg_string : ".")) != NULL) { ! error ("Invalid regexp: %s", re_err); } ! /* Add the shared library sections to the section table of the ! specified target, if any. */ ! if (target) { ! /* Count how many new section_table entries there are. */ ! so = NULL; ! count = 0; ! while ((so = find_solib (so)) != NULL) { ! if (so->so_name[0] && !match_main (so->so_name)) ! { ! count += so->sections_end - so->sections; ! } } ! if (count) { ! ! /* Add these section table entries to the target's table. */ ! old = target_resize_to_sections (target, count); ! while ((so = find_solib (so)) != NULL) ! { ! if (so->so_name[0]) ! { ! count = so->sections_end - so->sections; ! memcpy ((char *) (target->to_sections + old), ! so->sections, ! (sizeof (struct section_table)) * count); ! old += count; ! } ! } } } ! /* Now add the symbol files. */ ! while ((so = find_solib (so)) != NULL) { ! if (so->so_name[0] && re_exec (so->so_name) && ! !match_main (so->so_name)) { ! so->from_tty = from_tty; ! if (so->symbols_loaded) { ! if (from_tty) { ! printf_unfiltered ("Symbols already loaded for %s\n", so->so_name); } } ! else if (catch_errors ! (symbol_add_stub, so, ! "Error while reading shared library symbols:\n", ! RETURN_MASK_ALL)) { ! so_last = so; ! so->symbols_loaded = 1; } } - } ! /* Getting new symbols may change our opinion about what is ! frameless. */ ! if (so_last) ! reinit_frame_cache (); ! if (so_last) ! special_symbol_handling (so_last); } /* LOCAL FUNCTION --- 1243,1417 ---- #endif SVR4_SHARED_LIBS ! if (pattern) { ! char *re_err = re_comp (pattern); ! ! if (re_err) ! error ("Invalid regexp: %s", re_err); } ! /* Since this function might actually add some elements to the ! so_list_head list, arrange for it to be cleaned up when ! appropriate. */ ! if (!solib_cleanup_queued) { ! make_run_cleanup (do_clear_solib, NULL); ! solib_cleanup_queued = 1; ! } ! ! /* GDB and the inferior's dynamic linker each maintain their own ! list of currently loaded shared objects; we want to bring the ! former in sync with the latter. Scan both lists, seeing which ! shared objects appear where. There are three cases: ! ! - A shared object appears on both lists. This means that GDB ! knows about it already, and it's still loaded in the inferior. ! Nothing needs to happen. ! ! - A shared object appears only on GDB's list. This means that ! the inferior has unloaded it. We should remove the shared ! object from GDB's tables. ! ! - A shared object appears only on the inferior's list. This ! means that it's just been loaded. We should add it to GDB's ! tables. ! ! So we walk GDB's list, checking each entry to see if it appears ! in the inferior's list too. If it does, no action is needed, and ! we remove it from the inferior's list. If it doesn't, the ! inferior has unloaded it, and we remove it from GDB's list. By ! the time we're done walking GDB's list, the inferior's list ! contains only the new shared objects, which we then add. */ ! ! gdb = so_list_head; ! gdb_link = &so_list_head; ! while (gdb) ! { ! struct so_list *i = inferior; ! struct so_list **i_link = &inferior; ! ! /* Check to see whether the shared object *gdb also appears in ! the inferior's current list. */ ! while (i) { ! if (! strcmp (gdb->so_original_name, i->so_original_name)) ! break; ! ! i_link = &i->next; ! i = *i_link; ! } ! ! /* If the shared object appears on the inferior's list too, then ! it's still loaded, so we don't need to do anything. Delete ! it from the inferior's list, and leave it on GDB's list. */ ! if (i) ! { ! *i_link = i->next; ! #ifdef JIMB_DEBUG ! printf ("unchanged: %s\n", i->so_name); ! #endif ! free_so (i); ! gdb_link = &gdb->next; ! gdb = *gdb_link; } ! /* If it's not on the inferior's list, remove it from GDB's tables. */ ! else { ! *gdb_link = gdb->next; ! #ifdef JIMB_DEBUG ! printf ("unloaded: %s\n", gdb->so_name); ! #endif ! free_so (gdb); ! gdb = *gdb_link; } } ! /* Now the inferior's list contains only shared objects that don't ! appear in GDB's list --- those that are newly loaded. Add them ! to GDB's shared object list, and read in their symbols, if ! appropriate. */ ! if (inferior) { ! struct so_list *i; ! ! /* Add the new shared objects to GDB's list. */ ! *gdb_link = inferior; ! ! /* Fill in the rest of each of the `struct so_list' nodes, and ! read symbols for those files whose names match PATTERN. */ ! for (i = inferior; i; i = i->next) { ! i->from_tty = from_tty; ! ! /* Fill in the rest of the `struct so_list' node. */ ! catch_errors (solib_map_sections, i, ! "Error while mapping shared library sections:\n", ! RETURN_MASK_ALL); ! ! if (! pattern || re_exec (i->so_name)) { ! if (i->symbols_loaded) ! { ! if (from_tty) ! printf_unfiltered ("Symbols already loaded for %s\n", ! i->so_name); ! } ! else { ! #ifdef JIMB_DEBUG ! printf ("loaded: %s\n", i->so_name); ! #endif ! if (catch_errors ! (symbol_add_stub, i, ! "Error while reading shared library symbols:\n", ! RETURN_MASK_ALL)) ! { ! if (from_tty) ! printf_unfiltered ("Loaded symbols for %s\n", ! i->so_name); ! i->symbols_loaded = 1; ! } } } ! } ! ! /* If requested, add the shared objects' sections to the the ! TARGET's section table. */ ! if (target) ! { ! int new_sections; ! ! /* Figure out how many sections we'll need to add in total. */ ! new_sections = 0; ! for (i = inferior; i; i = i->next) ! new_sections += (i->sections_end - i->sections); ! ! if (new_sections > 0) { ! int space = target_resize_to_sections (target, new_sections); ! ! for (i = inferior; i; i = i->next) ! { ! int count = (i->sections_end - i->sections); ! memcpy (target->to_sections + space, ! i->sections, ! count * sizeof (i->sections[0])); ! space += count; ! } } } ! /* Getting new symbols may change our opinion about what is ! frameless. */ ! reinit_frame_cache (); ! special_symbol_handling (); ! } } + /* LOCAL FUNCTION *************** *** 1289,1295 **** addr_fmt = "016l"; #endif ! while ((so = find_solib (so)) != NULL) { if (so->so_name[0]) { --- 1452,1460 ---- addr_fmt = "016l"; #endif ! solib_add (0, 0, 0); ! ! for (so = so_list_head; so; so = so->next) { if (so->so_name[0]) { *************** *** 1347,1361 **** { register struct so_list *so = 0; /* link map state variable */ ! while ((so = find_solib (so)) != NULL) { ! if (so->so_name[0]) ! { ! if ((address >= (CORE_ADDR) LM_ADDR (so)) && ! (address < (CORE_ADDR) so->lmend)) ! return (so->so_name); ! } } return (0); } --- 1512,1524 ---- { register struct so_list *so = 0; /* link map state variable */ ! for (so = so_list_head; so; so = so->next) { ! if ((address >= (CORE_ADDR) LM_ADDR (so)) && ! (address < (CORE_ADDR) so->lmend)) ! return (so->so_name); } + return (0); } *************** *** 1775,1781 **** { /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base yet. In fact, in the case of a SunOS4 executable being run on ! Solaris, we can't get it yet. find_solib will get it when it needs it. */ #if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL)) if ((debug_base = locate_base ()) == 0) --- 1938,1944 ---- { /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base yet. In fact, in the case of a SunOS4 executable being run on ! Solaris, we can't get it yet. current_sos will get it when it needs it. */ #if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL)) if ((debug_base = locate_base ()) == 0) *************** *** 1843,1849 **** SYNOPSIS ! void special_symbol_handling (struct so_list *so) DESCRIPTION --- 2006,2012 ---- SYNOPSIS ! void special_symbol_handling () DESCRIPTION *************** *** 1859,1866 **** */ static void ! special_symbol_handling (so) ! struct so_list *so; { #ifndef SVR4_SHARED_LIBS int j; --- 2022,2028 ---- */ static void ! special_symbol_handling () { #ifndef SVR4_SHARED_LIBS int j; >From guo@cup.hp.com Sat Apr 01 00:00:00 2000 From: Jimmy Guo To: "Daniel Berlin+mail.gdb" Cc: gdb@sourceware.cygnus.com Subject: Re: RTTI working for G++ Date: Sat, 01 Apr 2000 00:00:00 -0000 Message-id: References: X-SW-Source: 2000-q1/msg00727.html Content-length: 610 A general question about the repositories on sourceware: Can we use cvsup client tool to maintain a local repository? Instead of getting 'snapshots' via the CVS interfaces, I'd like to use the cvsup tool to get updates to the repositories. It requires sourceware to run a cvsupd daemon. Otherwise, what is the easiest way to maintain local repository? I want to create a local repository containing gdb, dejagnu, and binutils products, and be able to automatically 'synchronize' with sourceware's every night or on demand (turn-key solution here). Thanks for any suggestion! - Jimmy Guo, guo@cup.hp.com