/*
* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/*
* To allow the debugger to debug programs that used rld on themselves without
* having the having the programs create a debug file information is maintained
* in the rld package for the debugger. This information is two static data
* items and a static routine. The information that is maintained is the state
* of the loaded sets are currently loaded into the program. The number of
* object files and their names that make up each set and the resulting address
* they were loaded at is maintained for each set. The static data symbol
* rld_loaded_state points to an array of rld_loaded_state structures that
* contains the above information. The static data symbol rld_nloaded_states
* contains the count of these structures. When the loaded state is changed
* the static routine rld_loaded_state_changed() is called.
*
* This is the only information in the rld package the debugger is allowed to
* use. The debugger sets a break point on the routine rld_loaded_state_changed
* when it is triped on then it can inspect the rld_loaded_state. Then using
* the rld package and the program it is debugging as a base file then it can
* create the symbols for the loaded sets by doing rld_loads for each set.
* The debugger uses an undocumented feature of rld_load (intended only for it's
* use) which is to used the interger value of 1 (RLD_DEBUG_OUTPUT_FILENAME)
* for the output_filename which causes the symbols to be created and left in
* memory and not written to a file.
*
* When the debugger attaches to a running process there is a window of time
* where the process could be doing an rld operation and the state in not
* correct. The window is shorted to it's minimal time by changing the value
* of rld_nloaded_states so that that number of states can be safely accessed.
* There are still small windows where problems can occur.
*/
struct rld_loaded_state {
char **object_filenames; /* pointer to an array of file names loaded */
unsigned long /* in this set */
nobject_filenames; /* number of file names loaded in this set */
struct mach_header /* The address the set was link edited at */
*header_addr;
};
/*
* static unsigned long rld_nloaded_states = 0;
* static struct rld_loaded_state *rld_loaded_state = NULL;
*
* static void rld_loaded_state_changed(void);
*/
#define RLD_NLOADED_STATES "rld_nloaded_states"
#define RLD_LOADED_STATE "rld_loaded_state"
#define RLD_LOADED_STATE_CHANGED "rld_loaded_state_changed"
#define RLD_DEBUG_OUTPUT_FILENAME ((char *)1)
/*
* moninitrld() can be defined in the librld.o library module if it is used or
* defined as a common in gcrt0.o if the librld.o library module is not used.
* The library module is passed monaddition() to call when a rld_load() is done
* and returns a pointer to the routine to get the rld loaded state so it can
* be written in to the gmon.out file.
*/
extern void (*moninitrld(
void (* monaddition)(char *lowpc, char *highpc)))
(struct rld_loaded_state **rld_loaded_state,
unsigned long *rld_nloaded_states);