src/dyld_debugger.cpp

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2004-2009 Apple 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@
 */

#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <mach-o/loader.h>
#include <mach-o/dyld_images.h>
#include <mach-o/dyld_process_info.h>

#include <vector>

#include "Tracing.h"
#include "ImageLoader.h"
#include "dyld2.h"

extern "C" 	void _dyld_debugger_notification(enum dyld_notify_mode mode, unsigned long count, uint64_t machHeaders[]);

#if TARGET_OS_OSX
	#define INITIAL_UUID_IMAGE_COUNT 32
#else
	#define INITIAL_UUID_IMAGE_COUNT 4
#endif

VECTOR_NEVER_DESTRUCTED(dyld_image_info);
VECTOR_NEVER_DESTRUCTED(dyld_uuid_info);

static std::vector<dyld_image_info> sImageInfos;
static std::vector<dyld_uuid_info>  sImageUUIDs;

#if __x86_64__
static std::vector<dyld_aot_image_info> sAotImageInfos;
#endif

size_t allImagesCount()
{
	return sImageInfos.size();
}

const mach_header* allImagesIndexedMachHeader(uint32_t index)
{
	if ( index < sImageInfos.size() )
		return sImageInfos[index].imageLoadAddress;
	else
		return NULL;
}

const char* allImagesIndexedPath(uint32_t index)
{
	if ( index < sImageInfos.size() )
		return sImageInfos[index].imageFilePath;
	else
		return NULL;
}


void addImagesToAllImages(uint32_t infoCount, const dyld_image_info info[])
{
	// make initial size large enough that we probably won't need to re-alloc it
	if ( sImageInfos.size() == 0 )
		sImageInfos.reserve(INITIAL_IMAGE_COUNT);
	if ( sImageUUIDs.capacity() == 0 )
		sImageUUIDs.reserve(4);
	// set infoArray to NULL to denote it is in-use
	dyld::gProcessInfo->infoArray = NULL;

	// append all new images
	for (uint32_t i=0; i < infoCount; ++i)
		sImageInfos.push_back(info[i]);
	dyld::gProcessInfo->infoArrayCount = (uint32_t)sImageInfos.size();
	dyld::gProcessInfo->infoArrayChangeTimestamp = mach_absolute_time();

	// set infoArray back to base address of vector (other process can now read)
	dyld::gProcessInfo->infoArray = &sImageInfos[0];
}

#if __x86_64__
void addAotImagesToAllAotImages(uint32_t aotInfoCount, const dyld_aot_image_info aotInfo[])
{
    if (sAotImageInfos.size() == 0) {
        sAotImageInfos.reserve(INITIAL_IMAGE_COUNT);
    }
    // set aotInfoArray to NULL to denote it is in-use
    dyld::gProcessInfo->aotInfoArray = NULL;

    for (uint32_t i = 0; i < aotInfoCount; ++i) {
        sAotImageInfos.push_back(aotInfo[i]);
    }
    dyld::gProcessInfo->aotInfoCount = (uint32_t)sAotImageInfos.size();
    dyld::gProcessInfo->aotInfoArrayChangeTimestamp = mach_absolute_time();

    // set aotInfoArray back to base address of vector (other process can now read)
    dyld::gProcessInfo->aotInfoArray = &sAotImageInfos[0];
}
#endif

#if TARGET_OS_SIMULATOR
// called once in dyld_sim start up to copy image list from host dyld to sImageInfos
void syncProcessInfo()
{
	// may want to set version field of gProcessInfo if it might be different than host
	if ( sImageInfos.size() == 0 ) {
		sImageInfos.reserve(INITIAL_IMAGE_COUNT);
		if ( dyld::gProcessInfo->infoArray != NULL ) {
			for (uint32_t i=0; i < dyld::gProcessInfo->infoArrayCount; ++i) {
				sImageInfos.push_back(dyld::gProcessInfo->infoArray[i]);
			}
			dyld::gProcessInfo->infoArray = &sImageInfos[0];
			dyld::gProcessInfo->infoArrayCount = (uint32_t)sImageInfos.size();
		}
	}
	dyld::gProcessInfo->notification(dyld_image_info_change, 0, NULL);
}
#endif

const char* notifyGDB(enum dyld_image_states state, uint32_t infoCount, const dyld_image_info info[])
{
	// tell gdb that about the new images
	uint64_t t0 = mach_absolute_time();
	dyld::gProcessInfo->notification(dyld_image_adding, infoCount, info);
	uint64_t t1 = mach_absolute_time();
	ImageLoader::fgTotalDebuggerPausedTime += (t1-t0);

	// <rdar://problem/7739489> record initial count of images
	// so CrashReporter can note which images were dynamically loaded
	if ( dyld::gProcessInfo->initialImageCount == 0 )
		dyld::gProcessInfo->initialImageCount = dyld::gProcessInfo->infoArrayCount;
	return NULL;
}


void addNonSharedCacheImageUUID(const dyld_uuid_info& info)
{
	// set uuidArray to NULL to denote it is in-use
	dyld::gProcessInfo->uuidArray = NULL;

	// append all new images
	sImageUUIDs.push_back(info);
	dyld::gProcessInfo->uuidArrayCount = sImageUUIDs.size();

	// set uuidArray back to base address of vector (other process can now read)
	dyld::gProcessInfo->uuidArray = &sImageUUIDs[0];
}

void removeImageFromAllImages(const struct mach_header* loadAddress)
{
	dyld_image_info goingAway;

	// set infoArray to NULL to denote it is in-use
	dyld::gProcessInfo->infoArray = NULL;

	// remove image from infoArray
	for (std::vector<dyld_image_info>::iterator it=sImageInfos.begin(); it != sImageInfos.end(); it++) {
		if ( it->imageLoadAddress == loadAddress ) {
			goingAway = *it;
			sImageInfos.erase(it);
			break;
		}
	}
	dyld::gProcessInfo->infoArrayCount = (uint32_t)sImageInfos.size();

	// set infoArray back to base address of vector
	dyld::gProcessInfo->infoArray = &sImageInfos[0];


	// set uuidArrayCount to NULL to denote it is in-use
	dyld::gProcessInfo->uuidArray = NULL;

	// remove image from infoArray
	for (std::vector<dyld_uuid_info>::iterator it=sImageUUIDs.begin(); it != sImageUUIDs.end(); it++) {
		if ( it->imageLoadAddress == loadAddress ) {
			sImageUUIDs.erase(it);
			break;
		}
	}
	dyld::gProcessInfo->uuidArrayCount = sImageUUIDs.size();
	dyld::gProcessInfo->infoArrayChangeTimestamp = mach_absolute_time();

	// set infoArray back to base address of vector
	dyld::gProcessInfo->uuidArray = &sImageUUIDs[0];

	// tell gdb that about the new images
	dyld::gProcessInfo->notification(dyld_image_removing, 1, &goingAway);
}


#if TARGET_OS_SIMULATOR
	namespace dyld {
		struct dyld_all_image_infos* gProcessInfo = NULL;
	}
#else

	static void gdb_image_notifier(enum dyld_image_mode mode, uint32_t infoCount, const dyld_image_info info[])
	{
		dyld3::ScopedTimer(DBG_DYLD_GDB_IMAGE_NOTIFIER, 0, 0, 0);
		uint64_t machHeaders[infoCount];
		for (uint32_t i=0; i < infoCount; ++i) {
			machHeaders[i] = (uintptr_t)(info[i].imageLoadAddress);
		}
		switch ( mode ) {
			 case dyld_image_adding:
				_dyld_debugger_notification(dyld_notify_adding, infoCount, machHeaders);
				break;
			 case dyld_image_removing:
				_dyld_debugger_notification(dyld_notify_removing, infoCount, machHeaders);
				break;
			default:
				break;
		}
		// do nothing
		// gdb sets a break point here to catch notifications
		//dyld::log("dyld: gdb_image_notifier(%s, %d, ...)\n", mode ? "dyld_image_removing" : "dyld_image_adding", infoCount);
		//for (uint32_t i=0; i < infoCount; ++i)
		//	dyld::log("dyld: %d loading at %p %s\n", i, info[i].imageLoadAddress, info[i].imageFilePath);
		//for (uint32_t i=0; i < dyld::gProcessInfo->infoArrayCount; ++i)
		//	dyld::log("dyld: %d loading at %p %s\n", i, dyld::gProcessInfo->infoArray[i].imageLoadAddress, dyld::gProcessInfo->infoArray[i].imageFilePath);
	}

	// only used with accelerator tables and ASan which images need to be re-loaded
	void resetAllImages()
	{
		sImageInfos.clear();
		sImageUUIDs.clear();
		_dyld_debugger_notification(dyld_notify_remove_all, 0, NULL);
	}

	extern void* __dso_handle;
	#define STR(s) # s
	#define XSTR(s) STR(s)

	struct dyld_all_image_infos  dyld_all_image_infos __attribute__ ((section ("__DATA,__all_image_info")))
								= {
									17, 0, {NULL}, &gdb_image_notifier, false, false, (const mach_header*)&__dso_handle, NULL,
									XSTR(DYLD_VERSION), NULL, 0, NULL, 0, 0, NULL, &dyld_all_image_infos,
									0, 0, NULL, NULL, NULL, 0, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
									0, {0}, "/usr/lib/dyld", {0}, {0}, 0, 0, NULL, 0
									};

	struct dyld_shared_cache_ranges dyld_shared_cache_ranges;

	namespace dyld {
		struct dyld_all_image_infos* gProcessInfo = &dyld_all_image_infos;
	}
#endif
Commit	Line	Data
	1	/* -- mode: C++; c-basic-offset: 4; tab-width: 4 --
	2	*
	3	* Copyright (c) 2004-2009 Apple Inc. All rights reserved.
	4	*
	5	* @APPLE_LICENSE_HEADER_START@
	6	*
	7	* This file contains Original Code and/or Modifications of Original Code
	8	* as defined in and that are subject to the Apple Public Source License
	9	* Version 2.0 (the 'License'). You may not use this file except in
	10	* compliance with the License. Please obtain a copy of the License at
	11	* http://www.opensource.apple.com/apsl/ and read it before using this
	12	* file.
	13	*
	14	* The Original Code and all software distributed under the License are
	15	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	16	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	17	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	19	* Please see the License for the specific language governing rights and
	20	* limitations under the License.
	21	*
	22	* @APPLE_LICENSE_HEADER_END@
	23	*/
	24
	25	#include <stddef.h>
	26	#include <stdint.h>
	27	#include <stdlib.h>
	28	#include <string.h>
	29	#include <mach-o/loader.h>
	30	#include <mach-o/dyld_images.h>
	31	#include <mach-o/dyld_process_info.h>
	32
	33	#include <vector>
	34
	35	#include "Tracing.h"
	36	#include "ImageLoader.h"
	37	#include "dyld2.h"
	38
	39	extern "C" void _dyld_debugger_notification(enum dyld_notify_mode mode, unsigned long count, uint64_t machHeaders[]);
	40
	41	#if TARGET_OS_OSX
	42	#define INITIAL_UUID_IMAGE_COUNT 32
	43	#else
	44	#define INITIAL_UUID_IMAGE_COUNT 4
	45	#endif
	46
	47	VECTOR_NEVER_DESTRUCTED(dyld_image_info);
	48	VECTOR_NEVER_DESTRUCTED(dyld_uuid_info);
	49
	50	static std::vector<dyld_image_info> sImageInfos;
	51	static std::vector<dyld_uuid_info> sImageUUIDs;
	52
	53	#if __x86_64__
	54	static std::vector<dyld_aot_image_info> sAotImageInfos;
	55	#endif
	56
	57	size_t allImagesCount()
	58	{
	59	return sImageInfos.size();
	60	}
	61
	62	const mach_header* allImagesIndexedMachHeader(uint32_t index)
	63	{
	64	if ( index < sImageInfos.size() )
	65	return sImageInfos[index].imageLoadAddress;
	66	else
	67	return NULL;
	68	}
	69
	70	const char* allImagesIndexedPath(uint32_t index)
	71	{
	72	if ( index < sImageInfos.size() )
	73	return sImageInfos[index].imageFilePath;
	74	else
	75	return NULL;
	76	}
	77
	78
	79	void addImagesToAllImages(uint32_t infoCount, const dyld_image_info info[])
	80	{
	81	// make initial size large enough that we probably won't need to re-alloc it
	82	if ( sImageInfos.size() == 0 )
	83	sImageInfos.reserve(INITIAL_IMAGE_COUNT);
	84	if ( sImageUUIDs.capacity() == 0 )
	85	sImageUUIDs.reserve(4);
	86	// set infoArray to NULL to denote it is in-use
	87	dyld::gProcessInfo->infoArray = NULL;
	88
	89	// append all new images
	90	for (uint32_t i=0; i < infoCount; ++i)
	91	sImageInfos.push_back(info[i]);
	92	dyld::gProcessInfo->infoArrayCount = (uint32_t)sImageInfos.size();
	93	dyld::gProcessInfo->infoArrayChangeTimestamp = mach_absolute_time();
	94
	95	// set infoArray back to base address of vector (other process can now read)
	96	dyld::gProcessInfo->infoArray = &sImageInfos[0];
	97	}
	98
	99	#if __x86_64__
	100	void addAotImagesToAllAotImages(uint32_t aotInfoCount, const dyld_aot_image_info aotInfo[])
	101	{
	102	if (sAotImageInfos.size() == 0) {
	103	sAotImageInfos.reserve(INITIAL_IMAGE_COUNT);
	104	}
	105	// set aotInfoArray to NULL to denote it is in-use
	106	dyld::gProcessInfo->aotInfoArray = NULL;
	107
	108	for (uint32_t i = 0; i < aotInfoCount; ++i) {
	109	sAotImageInfos.push_back(aotInfo[i]);
	110	}
	111	dyld::gProcessInfo->aotInfoCount = (uint32_t)sAotImageInfos.size();
	112	dyld::gProcessInfo->aotInfoArrayChangeTimestamp = mach_absolute_time();
	113
	114	// set aotInfoArray back to base address of vector (other process can now read)
	115	dyld::gProcessInfo->aotInfoArray = &sAotImageInfos[0];
	116	}
	117	#endif
	118
	119	#if TARGET_OS_SIMULATOR
	120	// called once in dyld_sim start up to copy image list from host dyld to sImageInfos
	121	void syncProcessInfo()
	122	{
	123	// may want to set version field of gProcessInfo if it might be different than host
	124	if ( sImageInfos.size() == 0 ) {
	125	sImageInfos.reserve(INITIAL_IMAGE_COUNT);
	126	if ( dyld::gProcessInfo->infoArray != NULL ) {
	127	for (uint32_t i=0; i < dyld::gProcessInfo->infoArrayCount; ++i) {
	128	sImageInfos.push_back(dyld::gProcessInfo->infoArray[i]);
	129	}
	130	dyld::gProcessInfo->infoArray = &sImageInfos[0];
	131	dyld::gProcessInfo->infoArrayCount = (uint32_t)sImageInfos.size();
	132	}
	133	}
	134	dyld::gProcessInfo->notification(dyld_image_info_change, 0, NULL);
	135	}
	136	#endif
	137
	138	const char* notifyGDB(enum dyld_image_states state, uint32_t infoCount, const dyld_image_info info[])
	139	{
	140	// tell gdb that about the new images
	141	uint64_t t0 = mach_absolute_time();
	142	dyld::gProcessInfo->notification(dyld_image_adding, infoCount, info);
	143	uint64_t t1 = mach_absolute_time();
	144	ImageLoader::fgTotalDebuggerPausedTime += (t1-t0);
	145
	146	// <rdar://problem/7739489> record initial count of images
	147	// so CrashReporter can note which images were dynamically loaded
	148	if ( dyld::gProcessInfo->initialImageCount == 0 )
	149	dyld::gProcessInfo->initialImageCount = dyld::gProcessInfo->infoArrayCount;
	150	return NULL;
	151	}
	152
	153
	154
	155	void addNonSharedCacheImageUUID(const dyld_uuid_info& info)
	156	{
	157	// set uuidArray to NULL to denote it is in-use
	158	dyld::gProcessInfo->uuidArray = NULL;
	159
	160	// append all new images
	161	sImageUUIDs.push_back(info);
	162	dyld::gProcessInfo->uuidArrayCount = sImageUUIDs.size();
	163
	164	// set uuidArray back to base address of vector (other process can now read)
	165	dyld::gProcessInfo->uuidArray = &sImageUUIDs[0];
	166	}
	167
	168	void removeImageFromAllImages(const struct mach_header* loadAddress)
	169	{
	170	dyld_image_info goingAway;
	171
	172	// set infoArray to NULL to denote it is in-use
	173	dyld::gProcessInfo->infoArray = NULL;
	174
	175	// remove image from infoArray
	176	for (std::vector<dyld_image_info>::iterator it=sImageInfos.begin(); it != sImageInfos.end(); it++) {
	177	if ( it->imageLoadAddress == loadAddress ) {
	178	goingAway = *it;
	179	sImageInfos.erase(it);
	180	break;
	181	}
	182	}
	183	dyld::gProcessInfo->infoArrayCount = (uint32_t)sImageInfos.size();
	184
	185	// set infoArray back to base address of vector
	186	dyld::gProcessInfo->infoArray = &sImageInfos[0];
	187
	188
	189	// set uuidArrayCount to NULL to denote it is in-use
	190	dyld::gProcessInfo->uuidArray = NULL;
	191
	192	// remove image from infoArray
	193	for (std::vector<dyld_uuid_info>::iterator it=sImageUUIDs.begin(); it != sImageUUIDs.end(); it++) {
	194	if ( it->imageLoadAddress == loadAddress ) {
	195	sImageUUIDs.erase(it);
	196	break;
	197	}
	198	}
	199	dyld::gProcessInfo->uuidArrayCount = sImageUUIDs.size();
	200	dyld::gProcessInfo->infoArrayChangeTimestamp = mach_absolute_time();
	201
	202	// set infoArray back to base address of vector
	203	dyld::gProcessInfo->uuidArray = &sImageUUIDs[0];
	204
	205	// tell gdb that about the new images
	206	dyld::gProcessInfo->notification(dyld_image_removing, 1, &goingAway);
	207	}
	208
	209
	210	#if TARGET_OS_SIMULATOR
	211	namespace dyld {
	212	struct dyld_all_image_infos* gProcessInfo = NULL;
	213	}
	214	#else
	215
	216	static void gdb_image_notifier(enum dyld_image_mode mode, uint32_t infoCount, const dyld_image_info info[])
	217	{
	218	dyld3::ScopedTimer(DBG_DYLD_GDB_IMAGE_NOTIFIER, 0, 0, 0);
	219	uint64_t machHeaders[infoCount];
	220	for (uint32_t i=0; i < infoCount; ++i) {
	221	machHeaders[i] = (uintptr_t)(info[i].imageLoadAddress);
	222	}
	223	switch ( mode ) {
	224	case dyld_image_adding:
	225	_dyld_debugger_notification(dyld_notify_adding, infoCount, machHeaders);
	226	break;
	227	case dyld_image_removing:
	228	_dyld_debugger_notification(dyld_notify_removing, infoCount, machHeaders);
	229	break;
	230	default:
	231	break;
	232	}
	233	// do nothing
	234	// gdb sets a break point here to catch notifications
	235	//dyld::log("dyld: gdb_image_notifier(%s, %d, ...)\n", mode ? "dyld_image_removing" : "dyld_image_adding", infoCount);
	236	//for (uint32_t i=0; i < infoCount; ++i)
	237	// dyld::log("dyld: %d loading at %p %s\n", i, info[i].imageLoadAddress, info[i].imageFilePath);
	238	//for (uint32_t i=0; i < dyld::gProcessInfo->infoArrayCount; ++i)
	239	// dyld::log("dyld: %d loading at %p %s\n", i, dyld::gProcessInfo->infoArray[i].imageLoadAddress, dyld::gProcessInfo->infoArray[i].imageFilePath);
	240	}
	241
	242	// only used with accelerator tables and ASan which images need to be re-loaded
	243	void resetAllImages()
	244	{
	245	sImageInfos.clear();
	246	sImageUUIDs.clear();
	247	_dyld_debugger_notification(dyld_notify_remove_all, 0, NULL);
	248	}
	249
	250	extern void* __dso_handle;
	251	#define STR(s) # s
	252	#define XSTR(s) STR(s)
	253
	254	struct dyld_all_image_infos dyld_all_image_infos __attribute__ ((section ("__DATA,__all_image_info")))
	255	= {
	256	17, 0, {NULL}, &gdb_image_notifier, false, false, (const mach_header*)&__dso_handle, NULL,
	257	XSTR(DYLD_VERSION), NULL, 0, NULL, 0, 0, NULL, &dyld_all_image_infos,
	258	0, 0, NULL, NULL, NULL, 0, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
	259	0, {0}, "/usr/lib/dyld", {0}, {0}, 0, 0, NULL, 0
	260	};
	261
	262	struct dyld_shared_cache_ranges dyld_shared_cache_ranges;
	263
	264	namespace dyld {
	265	struct dyld_all_image_infos* gProcessInfo = &dyld_all_image_infos;
	266	}
	267	#endif
	268