Mercurial > projects > ldc
annotate tango/lib/compiler/llvmdc/lifetime.d @ 271:1e6e2b5d5bfe trunk
[svn r292] Fixed: string switch was broken in several ways.
Fixed: TypeInfo_Typedef.next was incorrect (return base of base instead of just base).
Fixed: ClassInfo offset type info (offTi) had invalid offsets.
| author | lindquist |
|---|---|
| date | Wed, 18 Jun 2008 21:31:05 +0200 |
| parents | 23d0d9855cad |
| children | a3b7c19c866c |
| rev | line source |
|---|---|
| 132 | 1 /** |
| 2 * This module contains all functions related to an object's lifetime: | |
| 3 * allocation, resizing, deallocation, and finalization. | |
| 4 * | |
| 5 * Copyright: Copyright (C) 2004-2007 Digital Mars, www.digitalmars.com. | |
| 6 * All rights reserved. | |
| 7 * License: | |
| 8 * This software is provided 'as-is', without any express or implied | |
| 9 * warranty. In no event will the authors be held liable for any damages | |
| 10 * arising from the use of this software. | |
| 11 * | |
| 12 * Permission is granted to anyone to use this software for any purpose, | |
| 13 * including commercial applications, and to alter it and redistribute it | |
| 14 * freely, in both source and binary form, subject to the following | |
| 15 * restrictions: | |
| 16 * | |
| 17 * o The origin of this software must not be misrepresented; you must not | |
| 18 * claim that you wrote the original software. If you use this software | |
| 19 * in a product, an acknowledgment in the product documentation would be | |
| 20 * appreciated but is not required. | |
| 21 * o Altered source versions must be plainly marked as such, and must not | |
| 22 * be misrepresented as being the original software. | |
| 23 * o This notice may not be removed or altered from any source | |
| 24 * distribution. | |
| 25 * Authors: Walter Bright, Sean Kelly, Tomas Lindquist Olsen | |
| 26 */ | |
| 27 module lifetime; | |
| 28 | |
|
133
44a95ac7368a
[svn r137] Many fixes towards tango.io.Console working, but not quite there yet...
lindquist
parents:
132
diff
changeset
|
29 //debug=PRINTF; |
| 137 | 30 //debug=PRINTF2; |
| 132 | 31 |
|
237
a168a2c3ea48
[svn r253] Removed -inlineasm option. inline asm is now enabled by default unless the new -noasm option is passed.
lindquist
parents:
212
diff
changeset
|
32 // we're not allowed to jump out of asm blocks |
|
a168a2c3ea48
[svn r253] Removed -inlineasm option. inline asm is now enabled by default unless the new -noasm option is passed.
lindquist
parents:
212
diff
changeset
|
33 //version(D_InlineAsm_X86) version = Asm86; |
|
a168a2c3ea48
[svn r253] Removed -inlineasm option. inline asm is now enabled by default unless the new -noasm option is passed.
lindquist
parents:
212
diff
changeset
|
34 |
| 132 | 35 private |
| 36 { | |
| 37 import tango.stdc.stdlib; | |
| 38 import tango.stdc.string; | |
| 39 import tango.stdc.stdarg; | |
| 40 debug(PRINTF) import tango.stdc.stdio; | |
|
133
44a95ac7368a
[svn r137] Many fixes towards tango.io.Console working, but not quite there yet...
lindquist
parents:
132
diff
changeset
|
41 else debug(PRINTF2) import tango.stdc.stdio; |
| 132 | 42 } |
| 43 | |
| 44 | |
| 45 private | |
| 46 { | |
| 47 enum BlkAttr : uint | |
| 48 { | |
| 49 FINALIZE = 0b0000_0001, | |
| 50 NO_SCAN = 0b0000_0010, | |
| 51 NO_MOVE = 0b0000_0100, | |
| 52 ALL_BITS = 0b1111_1111 | |
| 53 } | |
| 54 | |
| 55 struct BlkInfo | |
| 56 { | |
| 57 void* base; | |
| 58 size_t size; | |
| 59 uint attr; | |
| 60 } | |
| 61 | |
| 62 extern (C) uint gc_getAttr( void* p ); | |
| 63 extern (C) uint gc_setAttr( void* p, uint a ); | |
| 64 extern (C) uint gc_clrAttr( void* p, uint a ); | |
| 65 | |
| 66 extern (C) void* gc_malloc( size_t sz, uint ba = 0 ); | |
| 67 extern (C) void* gc_calloc( size_t sz, uint ba = 0 ); | |
| 68 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz ); | |
| 69 extern (C) void gc_free( void* p ); | |
| 70 | |
| 71 extern (C) void* gc_addrOf( void* p ); | |
| 72 extern (C) size_t gc_sizeOf( void* p ); | |
| 73 extern (C) BlkInfo gc_query( void* p ); | |
| 74 | |
| 75 extern (C) bool onCollectResource( Object o ); | |
| 76 extern (C) void onFinalizeError( ClassInfo c, Exception e ); | |
| 77 extern (C) void onOutOfMemoryError(); | |
| 78 | |
| 79 extern (C) void _d_monitordelete(Object h, bool det = true); | |
| 80 | |
| 81 enum | |
| 82 { | |
| 83 PAGESIZE = 4096 | |
| 84 } | |
| 85 } | |
| 86 | |
| 87 | |
| 88 /** | |
| 89 * | |
| 90 */ | |
| 91 extern (C) Object _d_newclass(ClassInfo ci) | |
| 92 { | |
| 93 void* p; | |
| 94 | |
| 137 | 95 debug(PRINTF2) printf("_d_newclass(ci = %p, %s)\n", ci, cast(char *)ci.name.ptr); |
|
133
44a95ac7368a
[svn r137] Many fixes towards tango.io.Console working, but not quite there yet...
lindquist
parents:
132
diff
changeset
|
96 /+ |
| 132 | 97 if (ci.flags & 1) // if COM object |
| 98 { /* COM objects are not garbage collected, they are reference counted | |
| 99 * using AddRef() and Release(). They get free'd by C's free() | |
| 100 * function called by Release() when Release()'s reference count goes | |
| 101 * to zero. | |
| 102 */ | |
| 103 p = tango.stdc.stdlib.malloc(ci.init.length); | |
| 104 if (!p) | |
| 105 onOutOfMemoryError(); | |
| 106 } | |
| 107 else | |
|
133
44a95ac7368a
[svn r137] Many fixes towards tango.io.Console working, but not quite there yet...
lindquist
parents:
132
diff
changeset
|
108 +/ |
| 132 | 109 { |
| 110 p = gc_malloc(ci.init.length, | |
| 111 BlkAttr.FINALIZE | (ci.flags & 2 ? BlkAttr.NO_SCAN : 0)); | |
|
133
44a95ac7368a
[svn r137] Many fixes towards tango.io.Console working, but not quite there yet...
lindquist
parents:
132
diff
changeset
|
112 debug(PRINTF2) printf(" p = %p\n", p); |
| 132 | 113 } |
| 114 | |
| 137 | 115 debug(PRINTF2) |
| 132 | 116 { |
| 117 printf("p = %p\n", p); | |
| 137 | 118 printf("ci = %p, ci.init = %p, len = %d\n", ci, ci.init.ptr, ci.init.length); |
| 119 printf("vptr = %p\n", *cast(void**) ci.init.ptr); | |
| 120 printf("vtbl[0] = %p\n", (*cast(void***) ci.init.ptr)[0]); | |
| 121 printf("vtbl[1] = %p\n", (*cast(void***) ci.init.ptr)[1]); | |
| 122 printf("init[0] = %p\n", (cast(uint**) ci.init.ptr)[0]); | |
| 123 printf("init[1] = %p\n", (cast(uint**) ci.init.ptr)[1]); | |
| 124 printf("init[2] = %p\n", (cast(uint**) ci.init.ptr)[2]); | |
| 125 printf("init[3] = %p\n", (cast(uint**) ci.init.ptr)[3]); | |
| 126 printf("init[4] = %p\n", (cast(uint**) ci.init.ptr)[4]); | |
| 132 | 127 } |
| 128 | |
| 129 // initialize it | |
|
133
44a95ac7368a
[svn r137] Many fixes towards tango.io.Console working, but not quite there yet...
lindquist
parents:
132
diff
changeset
|
130 // llvmdc does this inline |
|
44a95ac7368a
[svn r137] Many fixes towards tango.io.Console working, but not quite there yet...
lindquist
parents:
132
diff
changeset
|
131 //(cast(byte*) p)[0 .. ci.init.length] = ci.init[]; |
| 132 | 132 |
| 133 debug(PRINTF) printf("initialization done\n"); | |
| 134 return cast(Object) p; | |
| 135 } | |
| 136 | |
| 137 /** | |
| 138 * | |
| 139 */ | |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
140 extern (C) void _d_delinterface(void* p) |
| 132 | 141 { |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
142 if (p) |
| 132 | 143 { |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
144 Interface* pi = **cast(Interface ***)p; |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
145 Object o = cast(Object)(p - pi.offset); |
| 132 | 146 |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
147 _d_delclass(o); |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
148 //*p = null; |
| 132 | 149 } |
| 150 } | |
| 151 | |
| 152 // used for deletion | |
| 153 private extern (D) alias void function(Object) fp_t; | |
| 154 | |
| 155 | |
| 156 /** | |
| 157 * | |
| 158 */ | |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
159 extern (C) void _d_delclass(Object p) |
| 132 | 160 { |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
161 if (p) |
| 132 | 162 { |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
163 debug(PRINTF) printf("_d_delclass(%p)\n", p); |
| 132 | 164 |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
165 ClassInfo **pc = cast(ClassInfo **)p; |
| 132 | 166 if (*pc) |
| 167 { | |
| 168 ClassInfo c = **pc; | |
| 169 | |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
170 rt_finalize(cast(void*) p); |
| 132 | 171 |
| 172 if (c.deallocator) | |
| 173 { | |
| 174 fp_t fp = cast(fp_t)c.deallocator; | |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
175 (*fp)(p); // call deallocator |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
176 //*p = null; |
| 132 | 177 return; |
| 178 } | |
| 179 } | |
| 180 else | |
| 181 { | |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
182 rt_finalize(cast(void*) p); |
| 132 | 183 } |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
184 gc_free(cast(void*) p); |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
185 //*p = null; |
| 132 | 186 } |
| 187 } | |
| 188 | |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
189 /+ |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
190 |
| 132 | 191 /** |
| 192 * | |
| 193 */ | |
| 194 struct Array | |
| 195 { | |
| 196 size_t length; | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
197 void* data; |
| 132 | 198 } |
| 199 | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
200 +/ |
| 132 | 201 |
| 202 /** | |
| 203 * Allocate a new array of length elements. | |
| 204 * ti is the type of the resulting array, or pointer to element. | |
| 205 * (For when the array is initialized to 0) | |
| 206 */ | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
207 extern (C) void* _d_newarrayT(TypeInfo ti, size_t length) |
| 132 | 208 { |
| 209 void* p; | |
| 210 auto size = ti.next.tsize(); // array element size | |
| 211 | |
|
212
4c2689d57ba4
[svn r228] Fixed: when new'ing basic types, the storage was not default initialized.
lindquist
parents:
211
diff
changeset
|
212 debug(PRINTF) printf("_d_newarrayT(length = %u, size = %d)\n", length, size); |
| 132 | 213 if (length == 0 || size == 0) |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
214 return null; |
| 132 | 215 |
|
237
a168a2c3ea48
[svn r253] Removed -inlineasm option. inline asm is now enabled by default unless the new -noasm option is passed.
lindquist
parents:
212
diff
changeset
|
216 version (Asm86) |
| 132 | 217 { |
| 218 asm | |
| 219 { | |
| 220 mov EAX,size ; | |
| 221 mul EAX,length ; | |
| 222 mov size,EAX ; | |
| 223 jc Loverflow ; | |
| 224 } | |
| 225 } | |
| 226 else | |
| 227 size *= length; | |
| 228 p = gc_malloc(size + 1, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0); | |
| 229 debug(PRINTF) printf(" p = %p\n", p); | |
| 230 memset(p, 0, size); | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
231 return p; |
| 132 | 232 |
| 233 Loverflow: | |
| 234 onOutOfMemoryError(); | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
235 return null; |
| 132 | 236 } |
| 237 | |
| 238 /** | |
| 239 * For when the array has a non-zero initializer. | |
| 240 */ | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
241 extern (C) void* _d_newarrayiT(TypeInfo ti, size_t length) |
| 132 | 242 { |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
243 void* result; |
| 132 | 244 auto size = ti.next.tsize(); // array element size |
| 245 | |
| 246 debug(PRINTF) printf("_d_newarrayiT(length = %d, size = %d)\n", length, size); | |
| 247 | |
| 248 if (length == 0 || size == 0) | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
249 result = null; |
| 132 | 250 else |
| 251 { | |
| 252 auto initializer = ti.next.init(); | |
| 253 auto isize = initializer.length; | |
| 254 auto q = initializer.ptr; | |
|
237
a168a2c3ea48
[svn r253] Removed -inlineasm option. inline asm is now enabled by default unless the new -noasm option is passed.
lindquist
parents:
212
diff
changeset
|
255 version (Asm86) |
| 132 | 256 { |
| 257 asm | |
| 258 { | |
| 259 mov EAX,size ; | |
| 260 mul EAX,length ; | |
| 261 mov size,EAX ; | |
| 262 jc Loverflow ; | |
| 263 } | |
| 264 } | |
| 265 else | |
| 266 size *= length; | |
| 267 auto p = gc_malloc(size + 1, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0); | |
| 268 debug(PRINTF) printf(" p = %p\n", p); | |
| 269 if (isize == 1) | |
| 270 memset(p, *cast(ubyte*)q, size); | |
| 271 else if (isize == int.sizeof) | |
| 272 { | |
| 273 int init = *cast(int*)q; | |
| 274 size /= int.sizeof; | |
| 275 for (size_t u = 0; u < size; u++) | |
| 276 { | |
| 277 (cast(int*)p)[u] = init; | |
| 278 } | |
| 279 } | |
| 280 else | |
| 281 { | |
| 282 for (size_t u = 0; u < size; u += isize) | |
| 283 { | |
| 284 memcpy(p + u, q, isize); | |
| 285 } | |
| 286 } | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
287 result = p; |
| 132 | 288 } |
| 289 return result; | |
| 290 | |
| 291 Loverflow: | |
| 292 onOutOfMemoryError(); | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
293 return null; |
| 132 | 294 } |
| 295 | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
296 /+ |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
297 |
| 132 | 298 /** |
| 299 * | |
| 300 */ | |
| 301 extern (C) Array _d_newarraymT(TypeInfo ti, int ndims, ...) | |
| 302 { | |
| 303 Array result; | |
| 304 | |
| 305 debug(PRINTF) printf("_d_newarraymT(ndims = %d)\n", ndims); | |
| 306 if (ndims == 0) | |
| 307 result = Array(); | |
| 308 else | |
| 309 { va_list q; | |
| 310 va_start!(int)(q, ndims); | |
| 311 | |
| 312 void[] foo(TypeInfo ti, size_t* pdim, int ndims) | |
| 313 { | |
| 314 size_t dim = *pdim; | |
| 315 void[] p; | |
| 316 | |
| 317 debug(PRINTF) printf("foo(ti = %p, ti.next = %p, dim = %d, ndims = %d\n", ti, ti.next, dim, ndims); | |
| 318 if (ndims == 1) | |
| 319 { | |
| 320 return _d_newarrayT(ti, dim); | |
| 321 } | |
| 322 else | |
| 323 { | |
| 324 p = gc_malloc(dim * (void[]).sizeof + 1)[0 .. dim]; | |
| 325 for (int i = 0; i < dim; i++) | |
| 326 { | |
| 327 (cast(void[]*)p.ptr)[i] = foo(ti.next, pdim + 1, ndims - 1); | |
| 328 } | |
| 329 } | |
| 330 return p; | |
| 331 } | |
| 332 | |
| 333 size_t* pdim = cast(size_t *)q; | |
| 334 void[] arr = foo(ti, pdim, ndims); | |
| 335 result = Arra | |
| 336 debug(PRINTF) printf("result = %llx\n", result); | |
| 337 | |
| 338 version (none) | |
| 339 { | |
| 340 for (int i = 0; i < ndims; i++) | |
| 341 { | |
| 342 printf("index %d: %d\n", i, va_arg!(int)(q)); | |
| 343 } | |
| 344 } | |
| 345 va_end(q); | |
| 346 } | |
| 347 return result; | |
| 348 } | |
| 349 | |
| 350 | |
| 351 /** | |
| 352 * | |
| 353 */ | |
| 354 extern (C) Array _d_newarraymiT(TypeInfo ti, int ndims, ...) | |
| 355 { | |
| 356 Array result; | |
| 357 | |
| 358 debug(PRINTF) printf("_d_newarraymiT(ndims = %d)\n", ndims); | |
| 359 if (ndims == 0) | |
| 360 result = 0; | |
| 361 else | |
| 362 { | |
| 363 va_list q; | |
| 364 va_start!(int)(q, ndims); | |
| 365 | |
| 366 void[] foo(TypeInfo ti, size_t* pdim, int ndims) | |
| 367 { | |
| 368 size_t dim = *pdim; | |
| 369 void[] p; | |
| 370 | |
| 371 if (ndims == 1) | |
| 372 { | |
| 373 auto r = _d_newarrayiT(ti, dim); | |
| 374 p = *cast(void[]*)(&r); | |
| 375 } | |
| 376 else | |
| 377 { | |
| 378 p = gc_malloc(dim * (void[]).sizeof + 1)[0 .. dim]; | |
| 379 for (int i = 0; i < dim; i++) | |
| 380 { | |
| 381 (cast(void[]*)p.ptr)[i] = foo(ti.next, pdim + 1, ndims - 1); | |
| 382 } | |
| 383 } | |
| 384 return p; | |
| 385 } | |
| 386 | |
| 387 size_t* pdim = cast(size_t *)q; | |
| 388 result = cast(ulong)foo(ti, pdim, ndims); | |
| 389 debug(PRINTF) printf("result = %llx\n", result); | |
| 390 | |
| 391 version (none) | |
| 392 { | |
| 393 for (int i = 0; i < ndims; i++) | |
| 394 { | |
| 395 printf("index %d: %d\n", i, va_arg!(int)(q)); | |
| 396 printf("init = %d\n", va_arg!(int)(q)); | |
| 397 } | |
| 398 } | |
| 399 va_end(q); | |
| 400 } | |
| 401 return result; | |
| 402 } | |
| 403 | |
| 404 /** | |
| 405 * | |
| 406 */ | |
| 407 void* _d_allocmemory(size_t nbytes) | |
| 408 { | |
| 409 return gc_malloc(nbytes); | |
| 410 } | |
| 411 | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
412 +/ |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
413 |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
414 /** |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
415 * for allocating a single POD value |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
416 */ |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
417 extern (C) void* _d_allocmemoryT(TypeInfo ti) |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
418 { |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
419 return gc_malloc(ti.tsize(), (ti.flags() & 1) ? BlkAttr.NO_SCAN : 0); |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
420 } |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
421 |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
422 /** |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
423 * |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
424 */ |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
425 extern (C) void _d_delarray(size_t plength, void* pdata) |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
426 { |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
427 // if (p) |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
428 // { |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
429 assert(!plength || pdata); |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
430 |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
431 if (pdata) |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
432 gc_free(pdata); |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
433 // p.data = null; |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
434 // p.length = 0; |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
435 // } |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
436 } |
| 132 | 437 |
| 438 /** | |
| 439 * | |
| 440 */ | |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
441 extern (C) void _d_delmemory(void* p) |
| 132 | 442 { |
| 443 if (p) | |
| 444 { | |
|
209
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
445 gc_free(p); |
|
c4c9b4ac021b
[svn r225] Fixed: delete expressions no longer use llvm's free instruction, which crashes on a GC provided pointer.
lindquist
parents:
203
diff
changeset
|
446 //*p = null; |
| 132 | 447 } |
| 448 } | |
| 449 | |
| 450 | |
| 451 /** | |
| 452 * | |
| 453 */ | |
| 454 extern (C) void _d_callfinalizer(void* p) | |
| 455 { | |
| 456 rt_finalize( p ); | |
| 457 } | |
| 458 | |
| 459 | |
| 460 /** | |
| 461 * | |
| 462 */ | |
| 463 extern (C) void rt_finalize(void* p, bool det = true) | |
| 464 { | |
| 465 debug(PRINTF) printf("rt_finalize(p = %p)\n", p); | |
| 466 | |
| 467 if (p) // not necessary if called from gc | |
| 468 { | |
| 469 ClassInfo** pc = cast(ClassInfo**)p; | |
| 470 | |
| 471 if (*pc) | |
| 472 { | |
| 473 ClassInfo c = **pc; | |
| 474 | |
| 475 try | |
| 476 { | |
| 477 if (det || onCollectResource(cast(Object)p)) | |
| 478 { | |
| 479 do | |
| 480 { | |
| 481 if (c.destructor) | |
| 482 { | |
|
268
23d0d9855cad
[svn r289] Fixed: right shift >> was broken for unsigned types.
lindquist
parents:
237
diff
changeset
|
483 debug(PRINTF) printf("calling dtor of %.*s\n", c.name.length, c.name.ptr); |
| 132 | 484 fp_t fp = cast(fp_t)c.destructor; |
| 485 (*fp)(cast(Object)p); // call destructor | |
| 486 } | |
| 487 c = c.base; | |
| 488 } while (c); | |
| 489 } | |
| 490 if ((cast(void**)p)[1]) // if monitor is not null | |
| 491 _d_monitordelete(cast(Object)p, det); | |
| 492 } | |
| 493 catch (Exception e) | |
| 494 { | |
| 495 onFinalizeError(**pc, e); | |
| 496 } | |
| 497 finally | |
| 498 { | |
| 499 *pc = null; // zero vptr | |
| 500 } | |
| 501 } | |
| 502 } | |
| 503 } | |
| 504 | |
| 505 /** | |
| 506 * Resize dynamic arrays with 0 initializers. | |
| 507 */ | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
508 extern (C) byte* _d_arraysetlengthT(TypeInfo ti, size_t newlength, size_t plength, byte* pdata) |
| 132 | 509 in |
| 510 { | |
| 511 assert(ti); | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
512 assert(!plength || pdata); |
| 132 | 513 } |
| 514 body | |
| 515 { | |
| 516 byte* newdata; | |
| 517 size_t sizeelem = ti.next.tsize(); | |
| 518 | |
| 519 debug(PRINTF) | |
| 520 { | |
|
211
f66219e0d530
[svn r227] Fixed: crash in lifetime.d when resizing array of AAs by .length assignment.
lindquist
parents:
209
diff
changeset
|
521 printf("_d_arraysetlengthT(sizeelem = %d, newlength = %d)\n", sizeelem, newlength); |
|
f66219e0d530
[svn r227] Fixed: crash in lifetime.d when resizing array of AAs by .length assignment.
lindquist
parents:
209
diff
changeset
|
522 printf("\tp.data = %p, p.length = %d\n", pdata, plength); |
| 132 | 523 } |
| 524 | |
| 525 if (newlength) | |
| 526 { | |
|
237
a168a2c3ea48
[svn r253] Removed -inlineasm option. inline asm is now enabled by default unless the new -noasm option is passed.
lindquist
parents:
212
diff
changeset
|
527 version (Asm86) |
| 132 | 528 { |
| 529 size_t newsize = void; | |
| 530 | |
| 531 asm | |
| 532 { | |
| 533 mov EAX, newlength; | |
| 534 mul EAX, sizeelem; | |
| 535 mov newsize, EAX; | |
| 536 jc Loverflow; | |
| 537 } | |
| 538 } | |
| 539 else | |
| 540 { | |
| 541 size_t newsize = sizeelem * newlength; | |
| 542 | |
| 543 if (newsize / newlength != sizeelem) | |
| 544 goto Loverflow; | |
| 545 } | |
| 546 | |
| 547 debug(PRINTF) printf("newsize = %x, newlength = %x\n", newsize, newlength); | |
| 548 | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
549 if (pdata) |
| 132 | 550 { |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
551 newdata = pdata; |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
552 if (newlength > plength) |
| 132 | 553 { |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
554 size_t size = plength * sizeelem; |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
555 auto info = gc_query(pdata); |
| 132 | 556 |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
557 if (info.size <= newsize || info.base != pdata) |
| 132 | 558 { |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
559 if (info.size >= PAGESIZE && info.base == pdata) |
| 132 | 560 { // Try to extend in-place |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
561 auto u = gc_extend(pdata, (newsize + 1) - info.size, (newsize + 1) - info.size); |
| 132 | 562 if (u) |
| 563 { | |
| 564 goto L1; | |
| 565 } | |
| 566 } | |
| 567 newdata = cast(byte *)gc_malloc(newsize + 1, info.attr); | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
568 newdata[0 .. size] = pdata[0 .. size]; |
| 132 | 569 } |
| 570 L1: | |
| 571 newdata[size .. newsize] = 0; | |
| 572 } | |
| 573 } | |
| 574 else | |
| 575 { | |
| 576 newdata = cast(byte *)gc_calloc(newsize + 1, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0); | |
| 577 } | |
| 578 } | |
| 579 else | |
| 580 { | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
581 newdata = pdata; |
| 132 | 582 } |
| 583 | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
584 return newdata; |
| 132 | 585 |
| 586 Loverflow: | |
| 587 onOutOfMemoryError(); | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
588 return null; |
| 132 | 589 } |
| 590 | |
| 591 | |
| 592 /** | |
| 593 * Resize arrays for non-zero initializers. | |
| 594 * p pointer to array lvalue to be updated | |
| 595 * newlength new .length property of array | |
| 596 * sizeelem size of each element of array | |
| 597 * initsize size of initializer | |
| 598 * ... initializer | |
| 599 */ | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
600 extern (C) byte* _d_arraysetlengthiT(TypeInfo ti, size_t newlength, size_t plength, byte* pdata) |
| 132 | 601 in |
| 602 { | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
603 assert(!plength || pdata); |
| 132 | 604 } |
| 605 body | |
| 606 { | |
| 607 byte* newdata; | |
|
211
f66219e0d530
[svn r227] Fixed: crash in lifetime.d when resizing array of AAs by .length assignment.
lindquist
parents:
209
diff
changeset
|
608 TypeInfo tinext = ti.next; |
|
f66219e0d530
[svn r227] Fixed: crash in lifetime.d when resizing array of AAs by .length assignment.
lindquist
parents:
209
diff
changeset
|
609 size_t sizeelem = tinext.tsize(); |
|
f66219e0d530
[svn r227] Fixed: crash in lifetime.d when resizing array of AAs by .length assignment.
lindquist
parents:
209
diff
changeset
|
610 void[] initializer = tinext.init(); |
| 132 | 611 size_t initsize = initializer.length; |
| 612 | |
| 613 assert(sizeelem); | |
| 614 assert(initsize); | |
| 615 assert(initsize <= sizeelem); | |
| 616 assert((sizeelem / initsize) * initsize == sizeelem); | |
| 617 | |
| 618 debug(PRINTF) | |
| 619 { | |
|
211
f66219e0d530
[svn r227] Fixed: crash in lifetime.d when resizing array of AAs by .length assignment.
lindquist
parents:
209
diff
changeset
|
620 printf("_d_arraysetlengthiT(sizeelem = %d, newlength = %d, initsize = %d)\n", sizeelem, newlength, initsize); |
|
f66219e0d530
[svn r227] Fixed: crash in lifetime.d when resizing array of AAs by .length assignment.
lindquist
parents:
209
diff
changeset
|
621 printf("\tp.data = %p, p.length = %d\n", pdata, plength); |
| 132 | 622 } |
| 623 | |
| 624 if (newlength) | |
| 625 { | |
|
237
a168a2c3ea48
[svn r253] Removed -inlineasm option. inline asm is now enabled by default unless the new -noasm option is passed.
lindquist
parents:
212
diff
changeset
|
626 version (Asm86) |
| 132 | 627 { |
| 628 size_t newsize = void; | |
| 629 | |
| 630 asm | |
| 631 { | |
| 632 mov EAX,newlength ; | |
| 633 mul EAX,sizeelem ; | |
| 634 mov newsize,EAX ; | |
| 635 jc Loverflow ; | |
| 636 } | |
| 637 } | |
| 638 else | |
| 639 { | |
| 640 size_t newsize = sizeelem * newlength; | |
| 641 | |
| 642 if (newsize / newlength != sizeelem) | |
| 643 goto Loverflow; | |
| 644 } | |
| 645 debug(PRINTF) printf("newsize = %x, newlength = %x\n", newsize, newlength); | |
| 646 | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
647 size_t size = plength * sizeelem; |
| 132 | 648 |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
649 if (pdata) |
| 132 | 650 { |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
651 newdata = pdata; |
|
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
652 if (newlength > plength) |
| 132 | 653 { |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
654 auto info = gc_query(pdata); |
| 132 | 655 |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
656 if (info.size <= newsize || info.base != pdata) |
| 132 | 657 { |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
658 if (info.size >= PAGESIZE && info.base == pdata) |
| 132 | 659 { // Try to extend in-place |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
660 auto u = gc_extend(pdata, (newsize + 1) - info.size, (newsize + 1) - info.size); |
| 132 | 661 if (u) |
| 662 { | |
| 663 goto L1; | |
| 664 } | |
| 665 } | |
| 666 newdata = cast(byte *)gc_malloc(newsize + 1, info.attr); | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
667 newdata[0 .. size] = pdata[0 .. size]; |
| 132 | 668 L1: ; |
| 669 } | |
| 670 } | |
| 671 } | |
| 672 else | |
| 673 { | |
|
211
f66219e0d530
[svn r227] Fixed: crash in lifetime.d when resizing array of AAs by .length assignment.
lindquist
parents:
209
diff
changeset
|
674 newdata = cast(byte *)gc_malloc(newsize + 1, !(tinext.flags() & 1) ? BlkAttr.NO_SCAN : 0); |
| 132 | 675 } |
| 676 | |
| 677 auto q = initializer.ptr; // pointer to initializer | |
| 678 | |
| 679 if (newsize > size) | |
| 680 { | |
| 681 if (initsize == 1) | |
| 682 { | |
| 683 debug(PRINTF) printf("newdata = %p, size = %d, newsize = %d, *q = %d\n", newdata, size, newsize, *cast(byte*)q); | |
| 684 newdata[size .. newsize] = *(cast(byte*)q); | |
| 685 } | |
| 686 else | |
| 687 { | |
| 688 for (size_t u = size; u < newsize; u += initsize) | |
| 689 { | |
| 690 memcpy(newdata + u, q, initsize); | |
| 691 } | |
| 692 } | |
| 693 } | |
| 694 } | |
| 695 else | |
| 696 { | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
697 newdata = pdata; |
| 132 | 698 } |
| 699 | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
700 return newdata; |
| 132 | 701 |
| 702 Loverflow: | |
| 703 onOutOfMemoryError(); | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
704 return null; |
| 132 | 705 } |
| 706 | |
|
203
e881c9b1c738
[svn r219] Fixed: the tango/lib/gc/basic garbage collector now compiles and links into an executable (change in tango/lib/llvmdc-posix.mak), closes #5 .
lindquist
parents:
137
diff
changeset
|
707 /+ |
| 132 | 708 |
| 709 /** | |
| 710 * Append y[] to array x[]. | |
| 711 * size is size of each array element. | |
| 712 */ | |
| 713 extern (C) long _d_arrayappendT(TypeInfo ti, Array *px, byte[] y) | |
| 714 { | |
| 715 auto sizeelem = ti.next.tsize(); // array element size | |
| 716 auto info = gc_query(px.data); | |
| 717 auto length = px.length; | |
| 718 auto newlength = length + y.length; | |
| 719 auto newsize = newlength * sizeelem; | |
| 720 | |
| 721 if (info.size < newsize || info.base != px.data) | |
| 722 { byte* newdata; | |
| 723 | |
| 724 if (info.size >= PAGESIZE && info.base == px.data) | |
| 725 { // Try to extend in-place | |
| 726 auto u = gc_extend(px.data, (newsize + 1) - info.size, (newsize + 1) - info.size); | |
| 727 if (u) | |
| 728 { | |
| 729 goto L1; | |
| 730 } | |
| 731 } | |
| 732 newdata = cast(byte *)gc_malloc(newCapacity(newlength, sizeelem) + 1, info.attr); | |
| 733 memcpy(newdata, px.data, length * sizeelem); | |
| 734 px.data = newdata; | |
| 735 } | |
| 736 L1: | |
| 737 px.length = newlength; | |
| 738 memcpy(px.data + length * sizeelem, y.ptr, y.length * sizeelem); | |
| 739 return *cast(long*)px; | |
| 740 } | |
| 741 | |
| 742 | |
| 743 /** | |
| 744 * | |
| 745 */ | |
| 746 size_t newCapacity(size_t newlength, size_t size) | |
| 747 { | |
| 748 version(none) | |
| 749 { | |
| 750 size_t newcap = newlength * size; | |
| 751 } | |
| 752 else | |
| 753 { | |
| 754 /* | |
| 755 * Better version by Dave Fladebo: | |
| 756 * This uses an inverse logorithmic algorithm to pre-allocate a bit more | |
| 757 * space for larger arrays. | |
| 758 * - Arrays smaller than PAGESIZE bytes are left as-is, so for the most | |
| 759 * common cases, memory allocation is 1 to 1. The small overhead added | |
| 760 * doesn't affect small array perf. (it's virtually the same as | |
| 761 * current). | |
| 762 * - Larger arrays have some space pre-allocated. | |
| 763 * - As the arrays grow, the relative pre-allocated space shrinks. | |
| 764 * - The logorithmic algorithm allocates relatively more space for | |
| 765 * mid-size arrays, making it very fast for medium arrays (for | |
| 766 * mid-to-large arrays, this turns out to be quite a bit faster than the | |
| 767 * equivalent realloc() code in C, on Linux at least. Small arrays are | |
| 768 * just as fast as GCC). | |
| 769 * - Perhaps most importantly, overall memory usage and stress on the GC | |
| 770 * is decreased significantly for demanding environments. | |
| 771 */ | |
| 772 size_t newcap = newlength * size; | |
| 773 size_t newext = 0; | |
| 774 | |
| 775 if (newcap > PAGESIZE) | |
| 776 { | |
| 777 //double mult2 = 1.0 + (size / log10(pow(newcap * 2.0,2.0))); | |
| 778 | |
| 779 // redo above line using only integer math | |
| 780 | |
| 781 static int log2plus1(size_t c) | |
| 782 { int i; | |
| 783 | |
| 784 if (c == 0) | |
| 785 i = -1; | |
| 786 else | |
| 787 for (i = 1; c >>= 1; i++) | |
| 788 { | |
| 789 } | |
| 790 return i; | |
| 791 } | |
| 792 | |
| 793 /* The following setting for mult sets how much bigger | |
| 794 * the new size will be over what is actually needed. | |
| 795 * 100 means the same size, more means proportionally more. | |
| 796 * More means faster but more memory consumption. | |
| 797 */ | |
| 798 //long mult = 100 + (1000L * size) / (6 * log2plus1(newcap)); | |
| 799 long mult = 100 + (1000L * size) / log2plus1(newcap); | |
| 800 | |
| 801 // testing shows 1.02 for large arrays is about the point of diminishing return | |
| 802 if (mult < 102) | |
| 803 mult = 102; | |
| 804 newext = cast(size_t)((newcap * mult) / 100); | |
| 805 newext -= newext % size; | |
| 806 debug(PRINTF) printf("mult: %2.2f, alloc: %2.2f\n",mult/100.0,newext / cast(double)size); | |
| 807 } | |
| 808 newcap = newext > newcap ? newext : newcap; | |
| 809 debug(PRINTF) printf("newcap = %d, newlength = %d, size = %d\n", newcap, newlength, size); | |
| 810 } | |
| 811 return newcap; | |
| 812 } | |
| 813 | |
| 814 | |
| 815 /** | |
| 816 * | |
| 817 */ | |
| 818 extern (C) byte[] _d_arrayappendcT(TypeInfo ti, inout byte[] x, ...) | |
| 819 { | |
| 820 auto sizeelem = ti.next.tsize(); // array element size | |
| 821 auto info = gc_query(x.ptr); | |
| 822 auto length = x.length; | |
| 823 auto newlength = length + 1; | |
| 824 auto newsize = newlength * sizeelem; | |
| 825 | |
| 826 assert(info.size == 0 || length * sizeelem <= info.size); | |
| 827 | |
| 828 debug(PRINTF) printf("_d_arrayappendcT(sizeelem = %d, ptr = %p, length = %d, cap = %d)\n", sizeelem, x.ptr, x.length, info.size); | |
| 829 | |
| 830 if (info.size <= newsize || info.base != x.ptr) | |
| 831 { byte* newdata; | |
| 832 | |
| 833 if (info.size >= PAGESIZE && info.base == x.ptr) | |
| 834 { // Try to extend in-place | |
| 835 auto u = gc_extend(x.ptr, (newsize + 1) - info.size, (newsize + 1) - info.size); | |
| 836 if (u) | |
| 837 { | |
| 838 goto L1; | |
| 839 } | |
| 840 } | |
| 841 debug(PRINTF) printf("_d_arrayappendcT(length = %d, newlength = %d, cap = %d)\n", length, newlength, info.size); | |
| 842 auto newcap = newCapacity(newlength, sizeelem); | |
| 843 assert(newcap >= newlength * sizeelem); | |
| 844 newdata = cast(byte *)gc_malloc(newcap + 1, info.attr); | |
| 845 memcpy(newdata, x.ptr, length * sizeelem); | |
| 846 (cast(void**)(&x))[1] = newdata; | |
| 847 } | |
| 848 L1: | |
| 849 byte *argp = cast(byte *)(&ti + 2); | |
| 850 | |
| 851 *cast(size_t *)&x = newlength; | |
| 852 x.ptr[length * sizeelem .. newsize] = argp[0 .. sizeelem]; | |
| 853 assert((cast(size_t)x.ptr & 15) == 0); | |
| 854 assert(gc_sizeOf(x.ptr) > x.length * sizeelem); | |
| 855 return x; | |
| 856 } | |
| 857 | |
| 858 | |
| 859 /** | |
| 860 * | |
| 861 */ | |
| 862 extern (C) byte[] _d_arraycatT(TypeInfo ti, byte[] x, byte[] y) | |
| 863 out (result) | |
| 864 { | |
| 865 auto sizeelem = ti.next.tsize(); // array element size | |
| 866 debug(PRINTF) printf("_d_arraycatT(%d,%p ~ %d,%p sizeelem = %d => %d,%p)\n", x.length, x.ptr, y.length, y.ptr, sizeelem, result.length, result.ptr); | |
| 867 assert(result.length == x.length + y.length); | |
| 868 for (size_t i = 0; i < x.length * sizeelem; i++) | |
| 869 assert((cast(byte*)result)[i] == (cast(byte*)x)[i]); | |
| 870 for (size_t i = 0; i < y.length * sizeelem; i++) | |
| 871 assert((cast(byte*)result)[x.length * sizeelem + i] == (cast(byte*)y)[i]); | |
| 872 | |
| 873 size_t cap = gc_sizeOf(result.ptr); | |
| 874 assert(!cap || cap > result.length * sizeelem); | |
| 875 } | |
| 876 body | |
| 877 { | |
| 878 version (none) | |
| 879 { | |
| 880 /* Cannot use this optimization because: | |
| 881 * char[] a, b; | |
| 882 * char c = 'a'; | |
| 883 * b = a ~ c; | |
| 884 * c = 'b'; | |
| 885 * will change the contents of b. | |
| 886 */ | |
| 887 if (!y.length) | |
| 888 return x; | |
| 889 if (!x.length) | |
| 890 return y; | |
| 891 } | |
| 892 | |
| 893 debug(PRINTF) printf("_d_arraycatT(%d,%p ~ %d,%p)\n", x.length, x.ptr, y.length, y.ptr); | |
| 894 auto sizeelem = ti.next.tsize(); // array element size | |
| 895 debug(PRINTF) printf("_d_arraycatT(%d,%p ~ %d,%p sizeelem = %d)\n", x.length, x.ptr, y.length, y.ptr, sizeelem); | |
| 896 size_t xlen = x.length * sizeelem; | |
| 897 size_t ylen = y.length * sizeelem; | |
| 898 size_t len = xlen + ylen; | |
| 899 | |
| 900 if (!len) | |
| 901 return null; | |
| 902 | |
| 903 byte* p = cast(byte*)gc_malloc(len + 1, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0); | |
| 904 memcpy(p, x.ptr, xlen); | |
| 905 memcpy(p + xlen, y.ptr, ylen); | |
| 906 p[len] = 0; | |
| 907 return p[0 .. x.length + y.length]; | |
| 908 } | |
| 909 | |
| 910 | |
| 911 /** | |
| 912 * | |
| 913 */ | |
| 914 extern (C) byte[] _d_arraycatnT(TypeInfo ti, uint n, ...) | |
| 915 { void* a; | |
| 916 size_t length; | |
| 917 byte[]* p; | |
| 918 uint i; | |
| 919 byte[] b; | |
| 920 auto size = ti.next.tsize(); // array element size | |
| 921 | |
| 922 p = cast(byte[]*)(&n + 1); | |
| 923 | |
| 924 for (i = 0; i < n; i++) | |
| 925 { | |
| 926 b = *p++; | |
| 927 length += b.length; | |
| 928 } | |
| 929 if (!length) | |
| 930 return null; | |
| 931 | |
| 932 a = gc_malloc(length * size, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0); | |
| 933 p = cast(byte[]*)(&n + 1); | |
| 934 | |
| 935 uint j = 0; | |
| 936 for (i = 0; i < n; i++) | |
| 937 { | |
| 938 b = *p++; | |
| 939 if (b.length) | |
| 940 { | |
| 941 memcpy(a + j, b.ptr, b.length * size); | |
| 942 j += b.length * size; | |
| 943 } | |
| 944 } | |
| 945 | |
| 946 byte[] result; | |
| 947 *cast(int *)&result = length; // jam length | |
| 948 (cast(void **)&result)[1] = a; // jam ptr | |
| 949 return result; | |
| 950 } | |
| 951 | |
| 952 | |
| 953 /** | |
| 954 * | |
| 955 */ | |
| 956 extern (C) void* _d_arrayliteralT(TypeInfo ti, size_t length, ...) | |
| 957 { | |
| 958 auto sizeelem = ti.next.tsize(); // array element size | |
| 959 void* result; | |
| 960 | |
| 961 debug(PRINTF) printf("_d_arrayliteralT(sizeelem = %d, length = %d)\n", sizeelem, length); | |
| 962 if (length == 0 || sizeelem == 0) | |
| 963 result = null; | |
| 964 else | |
| 965 { | |
| 966 result = gc_malloc(length * sizeelem, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0); | |
| 967 | |
| 968 va_list q; | |
| 969 va_start!(size_t)(q, length); | |
| 970 | |
| 971 size_t stacksize = (sizeelem + int.sizeof - 1) & ~(int.sizeof - 1); | |
| 972 | |
| 973 if (stacksize == sizeelem) | |
| 974 { | |
| 975 memcpy(result, q, length * sizeelem); | |
| 976 } | |
| 977 else | |
| 978 { | |
| 979 for (size_t i = 0; i < length; i++) | |
| 980 { | |
| 981 memcpy(result + i * sizeelem, q, sizeelem); | |
| 982 q += stacksize; | |
| 983 } | |
| 984 } | |
| 985 | |
| 986 va_end(q); | |
| 987 } | |
| 988 return result; | |
| 989 } | |
| 990 | |
| 991 +/ | |
| 992 | |
| 993 | |
| 994 /** | |
| 995 * Support for array.dup property. | |
| 996 */ | |
| 997 struct Array2 | |
| 998 { | |
| 999 size_t length; | |
| 1000 void* ptr; | |
| 1001 } | |
| 1002 | |
| 1003 | |
| 1004 /** | |
| 1005 * | |
| 1006 */ | |
| 1007 extern (C) Array2 _adDupT(TypeInfo ti, Array2 a) | |
| 1008 out (result) | |
| 1009 { | |
| 1010 auto sizeelem = ti.next.tsize(); // array element size | |
| 1011 assert(memcmp(result.ptr, a.ptr, a.length * sizeelem) == 0); | |
| 1012 } | |
| 1013 body | |
| 1014 { | |
| 1015 Array2 r; | |
| 1016 | |
| 1017 if (a.length) | |
| 1018 { | |
| 1019 auto sizeelem = ti.next.tsize(); // array element size | |
| 1020 auto size = a.length * sizeelem; | |
| 1021 r.ptr = gc_malloc(size, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0); | |
| 1022 r.length = a.length; | |
| 1023 memcpy(r.ptr, a.ptr, size); | |
| 1024 } | |
| 1025 return r; | |
| 1026 } | |
| 1027 | |
| 1028 | |
| 1029 unittest | |
| 1030 { | |
| 1031 int[] a; | |
| 1032 int[] b; | |
| 1033 int i; | |
| 1034 | |
| 1035 a = new int[3]; | |
| 1036 a[0] = 1; a[1] = 2; a[2] = 3; | |
| 1037 b = a.dup; | |
| 1038 assert(b.length == 3); | |
| 1039 for (i = 0; i < 3; i++) | |
| 1040 assert(b[i] == i + 1); | |
| 1041 } |