dyld-551.3.tar.gz
[apple/dyld.git] / src / dyldNew.cpp
1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
2 *
3 * Copyright (c) 2004-2008 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
26 #include <stdlib.h>
27 #include <stdint.h>
28 #include <string.h>
29 #include <mach/mach.h>
30 #include <sys/mman.h>
31
32 extern "C" void* __dso_handle;
33
34 #include "dyld.h"
35 #include "dyldLibSystemInterface.h"
36
37 //
38 // dyld initially allocates all memory from a pool inside dyld.
39 // Once libSystem.dylib is initialized, dyld uses libSystem's malloc/free.
40 //
41
42 #if __LP64__
43 // room for about ~1000 initial dylibs
44 #define DYLD_POOL_CHUNK_SIZE 200*1024
45 #else
46 // room for about ~900 initial dylibs
47 #define DYLD_POOL_CHUNK_SIZE 150*1024
48 #endif
49
50 struct dyld_static_pool {
51 dyld_static_pool* previousPool;
52 uint8_t* current;
53 uint8_t* end;
54 uint8_t pool[1];
55 };
56
57 // allocate initial pool independently of pool header to take less space on disk
58 static uint8_t initialPoolContent[DYLD_POOL_CHUNK_SIZE] __attribute__((__aligned__(16)));
59 static dyld_static_pool initialPool = { NULL, initialPoolContent, &initialPoolContent[DYLD_POOL_CHUNK_SIZE] };
60 static dyld_static_pool* currentPool = &initialPool;
61
62
63 void* malloc(size_t size)
64 {
65 if ( (dyld::gLibSystemHelpers != NULL) && dyld::gProcessInfo->libSystemInitialized ) {
66 void* p = dyld::gLibSystemHelpers->malloc(size);
67 //dyld::log("malloc(%lu) => %p from libSystem\n", size, p);
68 return p;
69 }
70 else {
71 if ( size > DYLD_POOL_CHUNK_SIZE ) {
72 dyld::log("dyld malloc overflow: size=%zu\n", size);
73 exit(1);
74 }
75 size = (size+sizeof(void*)-1) & (-sizeof(void*)); // pointer align
76 uint8_t* result = currentPool->current;
77 currentPool->current += size;
78 if ( currentPool->current > currentPool->end ) {
79 vm_address_t addr = 0;
80 kern_return_t r = vm_allocate(mach_task_self(), &addr, DYLD_POOL_CHUNK_SIZE, VM_FLAGS_ANYWHERE);
81 if ( r != KERN_SUCCESS ) {
82 dyld::log("out of address space for dyld memory pool\n");
83 exit(1);
84 }
85 dyld_static_pool* newPool = (dyld_static_pool*)addr;
86 newPool->previousPool = NULL;
87 newPool->current = newPool->pool;
88 newPool->end = (uint8_t*)(addr + DYLD_POOL_CHUNK_SIZE);
89 newPool->previousPool = currentPool;
90 currentPool = newPool;
91 if ( (currentPool->current + size) > currentPool->end ) {
92 dyld::log("dyld memory pool exhausted: size=%lu\n", size);
93 exit(1);
94 }
95 result = currentPool->current;
96 currentPool->current += size;
97 }
98 //dyld::log("%p = malloc(%3lu) from pool %p, free space = %lu\n", result, size, currentPool, (long)(currentPool->end - currentPool->current));
99 return result;
100 }
101 }
102
103
104 void free(void* ptr)
105 {
106 // ignore any pointer within dyld (i.e. stuff from pool or static strings)
107 if ( (dyld::gLibSystemHelpers != NULL) && ((ptr < &__dso_handle) || (ptr >= &initialPoolContent[DYLD_POOL_CHUNK_SIZE])) ) {
108 // ignore stuff in any dynamically alloated dyld pools
109 for (dyld_static_pool* p = currentPool; p != NULL; p = p->previousPool) {
110 if ( (p->pool <= ptr) && (ptr < p->end) ) {
111 // do nothing, pool entries can't be reclaimed
112 //dyld::log("free(%p) from dynamic pool\n", ptr);
113 return;
114 }
115 }
116
117 //dyld::log("free(%p) from libSystem\n", ptr);
118 return dyld::gLibSystemHelpers->free(ptr);
119 }
120 else {
121 // do nothing, pool entries can't be reclaimed
122 //dyld::log("free(%p) from static pool\n", ptr);
123 }
124 }
125
126
127 void* calloc(size_t count, size_t size)
128 {
129 // Check for overflow of integer multiplication
130 size_t total = count * size;
131 if ( total/count != size ) {
132 dyld::log("dyld calloc overflow: count=%zu, size=%zu\n", count, size);
133 dyld::halt("dyld calloc overflow");
134 }
135 if ( dyld::gLibSystemHelpers != NULL ) {
136 void* result = dyld::gLibSystemHelpers->malloc(total);
137 if ( result != NULL )
138 bzero(result, total);
139 return result;
140 }
141 else {
142 // this allocates out of static buffer which is already zero filled
143 return malloc(total);
144 }
145 }
146
147
148 void* realloc(void *ptr, size_t size)
149 {
150 void* result = malloc(size);
151 memcpy(result, ptr, size);
152 return result;
153 }
154
155 // void* reallocf(void *ptr, size_t size);
156 // void* valloc(size_t size);
157
158 // needed __libc_init()
159 extern "C" int _malloc_lock;
160 int _malloc_lock = 0;
161
162
163 // <rdar://problem/12857033> dyld calls this which uses libSystem.dylib's vm_allocate if available
164 int vm_alloc(vm_address_t* addr, vm_size_t size, uint32_t flags)
165 {
166 if ( (dyld::gLibSystemHelpers != NULL) && (dyld::gLibSystemHelpers->version >= 12) ) {
167 return dyld::gLibSystemHelpers->vm_alloc(mach_task_self(), addr, size, flags);
168 }
169 else {
170 return ::vm_allocate(mach_task_self(), addr, size, flags);
171 }
172 }
173
174 void* xmmap(void* addr, size_t len, int prot, int flags, int fd, off_t offset)
175 {
176 if ( (dyld::gLibSystemHelpers != NULL) && (dyld::gLibSystemHelpers->version >= 12) ) {
177 return dyld::gLibSystemHelpers->mmap(addr, len, prot, flags, fd, offset);
178 }
179 else {
180 return ::mmap(addr, len, prot, flags, fd, offset);
181 }
182 }
183
184
185