git.saurik.com Git - apple/dyld.git/blob

1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-

2 *

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 */

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>

33 #include <vector>

35 #include "Tracing.h"

36 #include "ImageLoader.h"

37 #include "dyld2.h"

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

41 #if TARGET_OS_OSX

42 #define INITIAL_UUID_IMAGE_COUNT 32

43 #else

44 #define INITIAL_UUID_IMAGE_COUNT 4

45 #endif

47 VECTOR_NEVER_DESTRUCTED(dyld_image_info);

48 VECTOR_NEVER_DESTRUCTED(dyld_uuid_info);

 static std::vector<dyld_image_info> sImageInfos;

 static std::vector<dyld_uuid_info>  sImageUUIDs;

53 #if __x86_64__

 static std::vector<dyld_aot_image_info> sAotImageInfos;

55 #endif

57 size_t allImagesCount()

58 {

59 return sImageInfos.size();

60 }

 const mach_header* allImagesIndexedMachHeader(uint32_t index)

63 {

         if ( index < sImageInfos.size() )

65 return sImageInfos[index].imageLoadAddress;

66 else

67 return NULL;

68 }

 const char* allImagesIndexedPath(uint32_t index)

71 {

         if ( index < sImageInfos.size() )

73 return sImageInfos[index].imageFilePath;

74 else

75 return NULL;

76 }

 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

         if ( sImageInfos.size() == 0 )

83 sImageInfos.reserve(INITIAL_IMAGE_COUNT);

         if ( sImageUUIDs.capacity() == 0 )

                 sImageUUIDs.reserve(4);

86 // set infoArray to NULL to denote it is in-use

         dyld::gProcessInfo->infoArray = NULL;

89 // 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();

95 // set infoArray back to base address of vector (other process can now read)

         dyld::gProcessInfo->infoArray = &sImageInfos[0];

97 }

99 #if __x86_64__

 void addAotImagesToAllAotImages(uint32_t aotInfoCount, const dyld_aot_image_info aotInfo[])

101 {

     if (sAotImageInfos.size() == 0) {

103 sAotImageInfos.reserve(INITIAL_IMAGE_COUNT);

104 }

105 // set aotInfoArray to NULL to denote it is in-use

     dyld::gProcessInfo->aotInfoArray = NULL;

107

     for (uint32_t i = 0; i < aotInfoCount; ++i) {

         sAotImageInfos.push_back(aotInfo[i]);

110 }

     dyld::gProcessInfo->aotInfoCount = (uint32_t)sAotImageInfos.size();

     dyld::gProcessInfo->aotInfoArrayChangeTimestamp = mach_absolute_time();

113

114 // set aotInfoArray back to base address of vector (other process can now read)

     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

         if ( sImageInfos.size() == 0 ) {

125 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]);

129 }

                         dyld::gProcessInfo->infoArray = &sImageInfos[0];

                         dyld::gProcessInfo->infoArrayCount = (uint32_t)sImageInfos.size();

132 }

133 }

         dyld::gProcessInfo->notification(dyld_image_info_change, 0, NULL);

135 }

136 #endif

137

 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();

         dyld::gProcessInfo->notification(dyld_image_adding, infoCount, info);

143 uint64_t t1 = mach_absolute_time();

         ImageLoader::fgTotalDebuggerPausedTime += (t1-t0);

145

146 // <rdar://problem/7739489> record initial count of images

147 // so CrashReporter can note which images were dynamically loaded

         if ( dyld::gProcessInfo->initialImageCount == 0 )

                 dyld::gProcessInfo->initialImageCount = dyld::gProcessInfo->infoArrayCount;

150 return NULL;

151 }

152

153

154

 void addNonSharedCacheImageUUID(const dyld_uuid_info& info)

156 {

157 // set uuidArray to NULL to denote it is in-use

         dyld::gProcessInfo->uuidArray = NULL;

159

160 // append all new images

161 sImageUUIDs.push_back(info);

         dyld::gProcessInfo->uuidArrayCount = sImageUUIDs.size();

163

164 // set uuidArray back to base address of vector (other process can now read)

         dyld::gProcessInfo->uuidArray = &sImageUUIDs[0];

166 }

167

 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

         dyld::gProcessInfo->infoArray = NULL;

174

175 // remove image from infoArray

         for (std::vector<dyld_image_info>::iterator it=sImageInfos.begin(); it != sImageInfos.end(); it++) {

                 if ( it->imageLoadAddress == loadAddress ) {

178 goingAway = *it;

179 sImageInfos.erase(it);

180 break;

181 }

182 }

         dyld::gProcessInfo->infoArrayCount = (uint32_t)sImageInfos.size();

184

185 // set infoArray back to base address of vector

         dyld::gProcessInfo->infoArray = &sImageInfos[0];

187

188

189 // set uuidArrayCount to NULL to denote it is in-use

         dyld::gProcessInfo->uuidArray = NULL;

191

192 // remove image from infoArray

         for (std::vector<dyld_uuid_info>::iterator it=sImageUUIDs.begin(); it != sImageUUIDs.end(); it++) {

                 if ( it->imageLoadAddress == loadAddress ) {

195 sImageUUIDs.erase(it);

196 break;

197 }

198 }

         dyld::gProcessInfo->uuidArrayCount = sImageUUIDs.size();

         dyld::gProcessInfo->infoArrayChangeTimestamp = mach_absolute_time();

201

202 // set infoArray back to base address of vector

         dyld::gProcessInfo->uuidArray = &sImageUUIDs[0];

204

205 // tell gdb that about the new images

         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

         static void gdb_image_notifier(enum dyld_image_mode mode, uint32_t infoCount, const dyld_image_info info[])

217 {

                 dyld3::ScopedTimer(DBG_DYLD_GDB_IMAGE_NOTIFIER, 0, 0, 0);

219 uint64_t machHeaders[infoCount];

                 for (uint32_t i=0; i < infoCount; ++i) {

                         machHeaders[i] = (uintptr_t)(info[i].imageLoadAddress);

222 }

223 switch ( mode ) {

224 case dyld_image_adding:

                                 _dyld_debugger_notification(dyld_notify_adding, infoCount, machHeaders);

226 break;

227 case dyld_image_removing:

                                 _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();

                 _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

         struct dyld_all_image_infos  dyld_all_image_infos __attribute__ ((section ("__DATA,__all_image_info"))) 

255 = {

                                                                         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

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