Return to rld_state.h CVS log

Up to [Apple XNU] / GNUtools / cctools / include / mach-o

Annotation of GNUtools/cctools/include/mach-o/rld_state.h, revision 1.1.1.1

1.1       root        1: /*
                      2:  * To allow the debugger to debug programs that used rld on themselves without
                      3:  * having the having the programs create a debug file information is maintained
                      4:  * in the rld package for the debugger.  This information is two static data
                      5:  * items and a static routine.  The information that is maintained is the state
                      6:  * of the loaded sets are currently loaded into the program.  The number of
                      7:  * object files and their names that make up each set and the resulting address
                      8:  * they were loaded at is maintained for each set.  The static data symbol
                      9:  * rld_loaded_state points to an array of rld_loaded_state structures that
                     10:  * contains the above information.  The static data symbol rld_nloaded_states
                     11:  * contains the count of these structures.  When the loaded state is changed
                     12:  * the static routine rld_loaded_state_changed() is called.
                     13:  *
                     14:  * This is the only information in the rld package the debugger is allowed to
                     15:  * use.  The debugger sets a break point on the routine rld_loaded_state_changed
                     16:  * when it is triped on then it can inspect the rld_loaded_state.  Then using
                     17:  * the rld package and the program it is debugging as a base file then it can
                     18:  * create the symbols for the loaded sets by doing rld_loads for each set.
                     19:  * The debugger uses an undocumented feature of rld_load (intended only for it's
                     20:  * use) which is to used the interger value of 1 (RLD_DEBUG_OUTPUT_FILENAME)
                     21:  * for the output_filename which causes the symbols to be created and left in
                     22:  * memory and not written to a file.
                     23:  *
                     24:  * When the debugger attaches to a running process there is a window of time
                     25:  * where the process could be doing an rld operation and the state in not
                     26:  * correct.  The window is shorted to it's minimal time by changing the value
                     27:  * of rld_nloaded_states so that that number of states can be safely accessed.
                     28:  * There are still small windows where problems can occur.
                     29:  */
                     30: 
                     31: struct rld_loaded_state {
                     32:     char **object_filenames;   /* pointer to an array of file names loaded */
                     33:     unsigned long              /*  in this set */
                     34:        nobject_filenames;      /* number of file names loaded in this set */
                     35:     struct mach_header         /* The address the set was link edited at */
                     36:        *header_addr;
                     37: };
                     38: 
                     39: /* 
                     40:  * static unsigned long rld_nloaded_states = 0;
                     41:  * static struct rld_loaded_state *rld_loaded_state = NULL;
                     42:  *
                     43:  * static void rld_loaded_state_changed(void);
                     44:  */
                     45: #define RLD_NLOADED_STATES     "rld_nloaded_states"
                     46: #define RLD_LOADED_STATE       "rld_loaded_state"
                     47: #define RLD_LOADED_STATE_CHANGED "rld_loaded_state_changed"
                     48: 
                     49: #define RLD_DEBUG_OUTPUT_FILENAME ((char *)1)
                     50: 
                     51: /*
                     52:  * moninitrld() can be defined in the librld.o library module if it is used or
                     53:  * defined as a common in gcrt0.o if the librld.o library module is not used.
                     54:  * The library module is passed monaddition() to call when a rld_load() is done
                     55:  * and returns a pointer to the routine to get the rld loaded state so it can
                     56:  * be written in to the gmon.out file.
                     57:  */
                     58: extern void (*moninitrld(
                     59:     void (* monaddition)(char *lowpc, char *highpc)))
                     60:            (struct rld_loaded_state **rld_loaded_state,
                     61:             unsigned long *rld_nloaded_states);

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.