#2038: 64Bit.19.patch - tango - D Programming Language - Trac

build/script/unittest.sh

old	new
9	9	EXE=runUnittests_$DC
10	10	DL="-L-ldl"
11	11	UNAME=`uname`
12		OPTIONS="-debug -~~debug=UnitTest~~"
	12	OPTIONS="-debug -L-L/32bit/usr/lib -debug=utf -debug=UnitTest" # :w -debug=PRINTF"
13	13
14	14	error () {
15	15	echo "Example : DC=dmd PLATFORM=linux ARCH=32 build/script/unittest.sh"
…	…
33	33	OPTIONS="-oq -d-debug -d-debug=UnitTest"
34	34	fi
35	35
36		build/bin/$PLATFORM$ARCH/bob -v -r=$DC -c=$DC -p=$PLATFORM -l=libtango-$DC-tst -o="-g -unittest $OPTIONS" .
	36	echo build/bin/${PLATFORM}32/bob -r=$DC -v -c=$DC -p=$PLATFORM -l=libtango-$DC-tst -o=\"-m$ARCH -gc -unittest $OPTIONS\" .
	37	build/bin/${PLATFORM}32/bob -r=$DC -v -c=$DC -p=$PLATFORM -l=libtango-$DC-tst -o="-m$ARCH -gc -unittest $OPTIONS" .
37	38
	39
	40	echo "Compiled"
	41
38	42	if ! which $DC >& /dev/null
39	43	then
40	44	echo "$DC not found on your \$PATH!"
…	…
99	103	DL=""
100	104	fi
101	105
102		echo "$DC $EXE.d $DFILES -g ~~$OPTIONS~~ -unittest -L-L. -L-ltango-$DC-tst $DL -L-lz -L-lbz2"
103		$DC $EXE.d $DFILES -g ~~$OPTIONS -unittest -L-L. -L-ltango-$DC-tst $DL -L-lz -L-lbz2~~ && rm $EXE.d && rm libtango-$DC-tst.a
	106	echo "$DC $EXE.d $DFILES -gc $OPTIONS -m$ARCH -unittest -L-L. -L-ltango-$DC-tst $DL -L-lz -L-lbz2"
	107	$DC $EXE.d $DFILES -gc $OPTIONS -m$ARCH -unittest -L-L. -L-ltango-$DC-tst $DL -L-lz -L-lbz2 #&& rm $EXE.d && rm libtango-$DC-tst.a
104	108
105	109	./runUnittests_$DC
106	110

build/src/bob.d

old	new
38	38	new FreeBSD (args);
39	39	new Solaris (args);
40	40	new Windows (args);
41		stdout.formatln ("{} files", FileFilter.builder(args.os, args.compiler)());
	41	Stdout.formatln ("{} files", FileFilter.builder(args.os, args.compiler)());
42	42	}
43	43	}
44	44
…	…
170	170
171	171	if (args.core) {
172	172	foreach (file; scan(".c")) {
173		auto obj = compile (file, gcc32);
	173	auto obj = compile (file, gcc);
174	174	addToLib(obj);
175	175	}
176	176
177	177	foreach (file; scan(".S")) {
178		auto obj = compile (file, gcc32);
	178	auto obj = compile (file, gcc);
179	179	addToLib(obj);
180	180	}
181	181	}
…	…
780	780	if (args.verbose)
781	781	{
782	782	foreach (str; cmd)
783		stdout (str)(' ');
784		stdout.newline;
	783	Stdout (str)(' ');
	784	Stdout.newline;
785	785	}
786	786
787	787	if (! args.inhibit)
…	…
794	794	proc.copyEnv (true);
795	795
796	796	proc.execute();
797		stdout.stream.copy (proc.stderr);
798		stdout.stream.copy (proc.stdout);
	797	Stdout.stream.copy (proc.stderr);
	798	Stdout.stream.copy (proc.stdout);
799	799	auto result = proc.wait;
800	800	if (result.status != 0 \|\| result.reason != Process.Result.Exit)
801	801	throw new Exception (result.toString);

object.di

old	new
119	119	equals_t equals(void p1, void p2);
120	120	/// compares the types of this TypeInfo stored at p1 and p2
121	121	int compare(void p1, void p2);
	122	/// Return alignment of type
	123	size_t talign() { return tsize(); }
122	124	/// returns the size of a type with the current TypeInfo
123	125	size_t tsize();
124	126	/// swaps the two types stored at p1 and p2
…	…
131	133	PointerMap pointermap();
132	134	/// offsets of the various elements
133	135	OffsetTypeInfo[] offTi();
	136
	137	/** Return internal info on arguments fitting into 8byte.
	138	* See X86-64 ABI 3.2.3
	139	*/
	140	version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2);
134	141	}
135	142
136	143	class TypeInfo_Typedef : TypeInfo

tango/text/convert/Layout.d

old	new
66	66	alias void* Arg;
67	67	alias va_list ArgList;
68	68	}
	69	else version(DigitalMars)
	70	{
	71	private import tango.core.Vararg;
	72	alias void* Arg;
	73	alias va_list ArgList;
	74	}
69	75	else
70	76	{
71	77	alias void* Arg;
…	…
111	117
112	118	public final T[] sprint (T[] result, T[] formatStr, ...)
113	119	{
	120	version (X86_64)
	121	{
	122	va_list ap;
	123
	124	va_start(ap, __va_argsave);
	125
	126	scope(exit) va_end(ap);
	127
	128	return vprint (result, formatStr, _arguments, ap);
	129	}
	130	else
114	131	return vprint (result, formatStr, _arguments, _argptr);
115	132	}
116	133
…	…
175	192
176	193	public final T[] convert (T[] formatStr, ...)
177	194	{
	195	version (X86_64)
	196	{
	197	va_list ap;
	198
	199	va_start(ap, __va_argsave);
	200
	201	scope(exit) va_end(ap);
	202
	203	return convert (_arguments, ap, formatStr);
	204	}
	205	else
178	206	return convert (_arguments, _argptr, formatStr);
179	207	}
180	208
…	…
184	212
185	213	public final uint convert (Sink sink, T[] formatStr, ...)
186	214	{
	215	version (X86_64)
	216	{
	217	va_list ap;
	218
	219	va_start(ap, __va_argsave);
	220
	221	scope(exit) va_end(ap);
	222
	223	return convert (sink, _arguments, ap, formatStr);
	224	}
	225	else
187	226	return convert (sink, _arguments, _argptr, formatStr);
188	227	}
189	228
…	…
203	242	return output.write(s);
204	243	}
205	244
	245
	246	version (X86_64)
	247	{
	248	va_list ap;
	249
	250	va_start(ap, __va_argsave);
	251
	252	scope(exit) va_end(ap);
	253
	254	return convert (&sink, _arguments, ap, formatStr);
	255	}
	256	else
206	257	return convert (&sink, _arguments, _argptr, formatStr);
207	258	}
208	259
…	…
224	275	return output;
225	276	}
226	277
227		~~version (old)~~
228		{
229	278	/**********************************************************************
230	279
231	280	**********************************************************************/
232	281
233		public final T[] convertOne (T[] result, TypeInfo ti, Arg arg)
	282	version (old) public final T[] convertOne (T[] result, TypeInfo ti, Arg arg)
234	283	{
235	284	return dispatch (result, null, ti, arg);
236	285	}
237		}
	286
238	287	/**********************************************************************
239	288
240	289	**********************************************************************/
…	…
336	385	}
337	386	}
338	387	}
339		~~else~~
	388	else version(X86)
340	389	{
341	390	Arg[64] arglist = void;
342	391	foreach (i, arg; arguments)
…	…
345	394	args += (arg.tsize + size_t.sizeof - 1) & ~ (size_t.sizeof - 1);
346	395	}
347	396	}
	397	else version(X86_64)
	398	{
	399	Arg[64] arglist = void;
	400	void[] buffer;
	401	uint len = 0;
	402
	403	foreach(i, argType; arguments)
	404	len += (argType.tsize + size_t.sizeof - 1) & ~ (size_t.sizeof - 1);
	405
	406	buffer.length = len;
	407	len = 0;
	408	foreach(i, argType; arguments)
	409	{
	410	//printf("type: %s\n", argType.classinfo.name.ptr);
	411
	412	va_arg(args, argType, buffer.ptr+len);
	413
	414	if(argType.classinfo.name.length != 25 && argType.classinfo.name[9] == TypeCode.ARRAY &&
	415	(argType.classinfo.name[10] == TypeCode.USHORT \|\|
	416	argType.classinfo.name[10] == TypeCode.SHORT))
	417	{
	418	printf("Warning: (u)short[] is broken for varargs in x86_64");
	419	// simply disable the array for now
	420	(cast(short[]*) (buffer.ptr+len)).length = 0;
	421	}
	422
	423	arglist[i] = &buffer[len];
	424
	425	len+= (argType.tsize + size_t.sizeof - 1) & ~ (size_t.sizeof - 1);
	426	}
	427
	428	scope (exit) delete buffer;
	429	}
348	430	return parse (formatStr, arguments, arglist, sink);
349	431	}
350	432
…	…
530	612	auto tiAsso = cast(TypeInfo_AssociativeArray)_ti;
531	613	auto tiKey = tiAsso.key;
532	614	auto tiVal = tiAsso.next();
	615
533	616	// the knowledge of the internal k/v storage is used
534	617	// so this might break if, that internal storage changes
535	618	alias ubyte AV; // any type for key, value might be ok, the sizes are corrected later
…	…
539	622	length += sink ("{");
540	623	bool first = true;
541	624
542		size_t roundUp (size_t sz)
	625	size_t roundUp (size_t tsize)
543	626	{
544		return (sz + (void).sizeof -1) & ~((void).sizeof - 1);
	627	//return (sz + (void).sizeof -1) & ~((void).sizeof - 1);
	628
	629	version (X86_64)
	630	// Size of key needed to align value on 16 bytes
	631	return (tsize + 15) & ~(15);
	632	else
	633	return (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
545	634	}
546	635
547	636	foreach (ref v; aa)
…	…
943	1032	/*******************************************************************************
944	1033
945	1034	*******************************************************************************/
946
	1035	import tango.stdc.stdio : printf;
947	1036	debug (UnitTest)
948	1037	{
949	1038	unittest
…	…
1096	1185	int[][] b = [ [ 51, 52 ], [ 53, 54, 55 ] ];
1097	1186	assert( Formatter( "{}", b ) == "[[51, 52], [53, 54, 55]]" );
1098	1187
	1188	char[1024] static_buffer;
	1189	static_buffer[0..10] = "1234567890";
	1190
	1191	assert (Formatter( "{}", static_buffer[0..10]) == "1234567890");
	1192
	1193	version(X86)
	1194	{
1099	1195	ushort[3] c = [ cast(ushort)51, 52, 53 ];
1100	1196	assert( Formatter( "{}", c ) == "[51, 52, 53]" );
	1197	}
1101	1198
1102	1199	// integer AA
1103	1200	ushort[long] d;
1104	1201	d[234] = 2;
1105	1202	d[345] = 3;
	1203
1106	1204	assert( Formatter( "{}", d ) == "{234 => 2, 345 => 3}" \|\|
1107	1205	Formatter( "{}", d ) == "{345 => 3, 234 => 2}");
1108	1206

tango/text/Text.d

old	new
213	213
214	214	private import tango.stdc.string : memmove;
215	215
	216	version(DigitalMars)
	217	{
	218	private import tango.core.Vararg;
	219	}
216	220
217	221	/*******************************************************************************
218	222

tango/text/Regex.d

old	new
3498	3498	// are somewhat weak (empirical testing), but sofar no new
3499	3499	// regressions have been discovered. larsivi 20090827
3500	3500	TNFATransition!(char_t) highestPriTrans;
3501		foreach ( trans; sorted_elms[$-1].nfa_state.transitions ) {
	3501
	3502	assert(sorted_elms[$-1] && sorted_elms[$-1].nfa_state && sorted_elms[$-1].nfa_state, "Something is null that is assumed non-null. ");
	3503
	3504	foreach ( trans; sorted_elms[$-1].nfa_state.transitions )
	3505	{
3502	3506	if (trans.canFinish()) {
3503	3507	r.dfa_state.reluctant = true;
3504	3508	break;
…	…
3888	3892	if ( c < *cmp ) {
3889	3893	++cmp;
3890	3894	continue;
3891		}
	3895	}
3892	3896	++cmp;
3893	3897	if ( c <= *cmp )
3894	3898	goto Lconsume;

tango/net/device/Berkeley.d

old	new
2028	2028	ih.getHostByName(Berkeley.hostName());
2029	2029	assert(ih.addrList.length > 0);
2030	2030	IPv4Address ia = new IPv4Address(ih.addrList[0], IPv4Address.PORT_ANY);
	2031	printf("addrses: %x %x\n", ia.toAddrString.ptr, ih.name.ptr);
2031	2032	printf("IP address = %.s\nname = %.s\n", ia.toAddrString(), ih.name);
2032	2033	foreach(int i, char[] s; ih.aliases)
2033	2034	{

tango/io/device/Device.d

old	new
291	291
292	292	override size_t read (void[] dst)
293	293	{
294		int read = posix.read (handle, dst.ptr, dst.length);
	294	auto read = posix.read (handle, dst.ptr, dst.length);
	295
295	296	if (read is -1)
296	297	error;
297	298	else

tango/io/Console.d

old	new
638	638	Cerr = new Console.Output (conduit, conduit.redirected);
639	639	}
640	640
641
642	641	/******************************************************************************
643	642
644	643	Flush outputs before we exit.

tango/io/stream/Snoop.d

old	new
17	17
18	18	private import tango.text.convert.Format;
19	19
	20	version(DigitalMars)
	21	{
	22	private import tango.core.Vararg;
	23	}
	24
20	25	private alias void delegate(char[]) Snoop;
21	26
22	27	/*******************************************************************************

tango/io/stream/Format.d

old	new
16	16
17	17	private import tango.text.convert.Layout;
18	18
	19	version(DigitalMars)
	20	{
	21	private import tango.core.Vararg;
	22	}
	23
19	24	/*******************************************************************************
20	25
21	26	A bridge between a Layout instance and a stream. This is used for
…	…
136	141
137	142	final FormatOutput format (T[] fmt, ...)
138	143	{
	144	version (X86_64)
	145	{
	146	va_list ap;
	147
	148	va_start(ap, __va_argsave);
	149
	150	scope(exit) va_end(ap);
	151
	152	convert (&emit, _arguments, ap, fmt);
	153	}
	154	else
139	155	convert (&emit, _arguments, _argptr, fmt);
	156
140	157	return this;
141	158	}
142	159
…	…
148	165
149	166	final FormatOutput formatln (T[] fmt, ...)
150	167	{
	168	version (X86_64)
	169	{
	170	va_list ap;
	171
	172	va_start(ap, __va_argsave);
	173
	174	scope(exit) va_end(ap);
	175
	176	convert (&emit, _arguments, ap, fmt);
	177	}
	178	else
151	179	convert (&emit, _arguments, _argptr, fmt);
	180
152	181	return newline;
153	182	}
154	183
…	…
167	196
168	197	assert (_arguments.length <= slice.length/4, "FormatOutput :: too many arguments");
169	198
170		if (_arguments.length is 0)
	199	if (_arguments.length == 0)
171	200	sink.flush;
172	201	else
	202	{
	203
	204	version (X86_64)
	205	{
	206	va_list ap;
	207
	208	va_start(ap, __va_argsave);
	209
	210	scope(exit) va_end(ap);
	211
	212	convert (&emit, _arguments, ap, slice[0 .. _arguments.length * 4 - 2]);
	213	}
	214	else
173	215	convert (&emit, _arguments, _argptr, slice[0 .. _arguments.length * 4 - 2]);
174
	216	}
175	217	return this;
176	218	}
177	219

tango/io/Path.d

old	new
184	184
185	185	/***********************************************************************
186	186
	187	Return an adjusted path such that non-empty instances always
	188	have a leading separator.
	189
	190	Note: Allocates memory where path is not already terminated.
	191
	192	***********************************************************************/
	193
	194	static char[] paddedLeading (char[] path, char c = '/')
	195	{
	196	if (path.length && path[0] != c)
	197	path = c ~ path;
	198	return path;
	199	}
	200
	201	/***********************************************************************
	202
187	203	Return an adjusted path such that non-empty instances do not
188	204	have a trailing separator.
189	205
…	…
211	227
212	228	if (paths.length)
213	229	{
214		foreach (path; paths[0 .. $-1])
215		result ~= padded (path);
216		result ~= paths [$-1];
	230	result ~= paths[0];
	231
	232	foreach (path; paths[1 .. $-1])
	233	result ~= paddedLeading (stripped(path));
	234
	235	result ~= paddedLeading(paths[$-1]);
	236
217	237	return result;
218	238	}
219	239	return "";

tango/core/rt/gc/basic/gcx.d

old	new
64	64	private import gcc.builtins; // for __builtin_unwind_init
65	65	}
66	66
	67	extern (C) uint sleep(uint seconds);
67	68
68	69	struct BlkInfo
69	70	{
…	…
1666	1667	*/
1667	1668	void addRange(void pbot, void ptop)
1668	1669	{
1669		debug(PRINTF) printf("Thread %x ", pthread_self());
	1670	debug(PRINTF) debug(THREADINVARIANT) printf("Thread %x ", pthread_self());
1670	1671	debug(PRINTF) printf("%x.Gcx::addRange(%x, %x), nranges = %d\n", this, pbot, ptop, nranges);
1671	1672	if (nranges == rangedim)
1672	1673	{
…	…
1694	1695	*/
1695	1696	void removeRange(void *pbot)
1696	1697	{
1697		debug(PRINTF) printf("Thread %x ", pthread_self());
	1698	debug(PRINTF) debug(THREADINVARIANT) printf("Thread %x ", pthread_self());
1698	1699	debug(PRINTF) printf("%x.Gcx.removeRange(%x), nranges = %d\n", this, pbot, nranges);
1699	1700	for (size_t i = nranges; i--;)
1700	1701	{
…	…
2098	2099	size_t newnpools;
2099	2100	size_t i;
2100	2101
2101		~~//debug(PRINTF) printf("**********Gcx::newPool(npages = %d)**************\n", npages);~~
2102	2102
	2103	debug(PRINTF) printf("**********Gcx::newPool(npages = %x)**************\n", npages);
	2104	if ( npages > 0xc5e00010 )
	2105	sleep ( 5);
	2106
2103	2107	// Round up to COMMITSIZE pages
2104	2108	npages = (npages + (COMMITSIZE/PAGESIZE) - 1) & ~(COMMITSIZE/PAGESIZE - 1);
2105	2109
…	…
2344	2348	}
2345	2349	else
2346	2350	{
	2351	version (D_InlineAsm_X86)
	2352	{
2347	2353	asm
2348	2354	{
2349	2355	pushad ;
2350	2356	mov sp[EBP],ESP ;
2351	2357	}
2352	2358	}
	2359	else version (D_InlineAsm_X86_64)
	2360	{
	2361	asm
	2362	{
	2363	push RAX ;
	2364	push RBX ;
	2365	push RCX ;
	2366	push RDX ;
	2367	push RSI ;
	2368	push RDI ;
	2369	push RBP ;
	2370	push R8 ;
	2371	push R9 ;
	2372	push R10 ;
	2373	push R11 ;
	2374	push R12 ;
	2375	push R13 ;
	2376	push R14 ;
	2377	push R15 ;
	2378	push EAX ; // 16 byte align the stack
	2379	}
	2380	}
	2381	else
	2382	{
	2383	static assert( false, "Architecture not supported." );
	2384	}
	2385	}
2353	2386	result = fullcollect(sp);
2354	2387	version (GNU)
2355	2388	{
…	…
2359	2392	{
2360	2393	// nothing to do
2361	2394	}
2362		else
	2395	else version (D_InlineAsm_X86)
2363	2396	{
2364	2397	asm
2365	2398	{
2366	2399	popad ;
2367	2400	}
2368	2401	}
	2402	else version (D_InlineAsm_X86_64)
	2403	{
	2404	asm
	2405	{
	2406	pop EAX ; // 16 byte align the stack
	2407	pop R15 ;
	2408	pop R14 ;
	2409	pop R13 ;
	2410	pop R12 ;
	2411	pop R11 ;
	2412	pop R10 ;
	2413	pop R9 ;
	2414	pop R8 ;
	2415	pop RBP ;
	2416	pop RDI ;
	2417	pop RSI ;
	2418	pop RDX ;
	2419	pop RCX ;
	2420	pop RBX ;
	2421	pop RAX ;
	2422	}
	2423	}
	2424	else
	2425	{
	2426	static assert( false, "Architecture not supported." );
	2427	}
2369	2428	return result;
2370	2429	}
2371	2430
…	…
2471	2530	}
2472	2531	*b = 0;
2473	2532
2474		auto o = pool.baseAddr + (b - bbase) * 32 * 16;
	2533	auto o = pool.baseAddr + (b - bbase) * (typeof(bitm).sizeof8) 16;
2475	2534	if (!(bitm & 0xFFFF))
2476	2535	{
2477	2536	bitm >>= 16;
…	…
2519	2578	for (n = 0; n < npools; n++)
2520	2579	{ size_t pn;
2521	2580	size_t ncommitted;
2522		~~uint* bbase;~~
2523	2581
2524	2582	pool = pooltable[n];
2525		bbase = pool.mark.base();
	2583	auto bbase = pool.mark.base();
2526	2584	ncommitted = pool.ncommitted;
2527	2585	for (pn = 0; pn < ncommitted; pn++, bbase += PAGESIZE / (32 * 16))
2528	2586	{
…	…
2571	2629	sentinel_Invariant(sentinel_add(p));
2572	2630
2573	2631	pool.freebits.set(biti);
	2632
2574	2633	if (pool.finals.nbits && pool.finals.testClear(biti))
2575	2634	rt_finalize(cast(List )sentinel_add(p), false/noStack > 0*/);
2576	2635	clrBits(pool, biti, BlkAttr.ALL_BITS);
…	…
2909	2968	//debug(PRINTF) printf("Pool::Pool(%u)\n", npages);
2910	2969	poolsize = npages * PAGESIZE;
2911	2970	assert(poolsize >= POOLSIZE);
	2971
	2972	debug(PRINTF) printf("alloc of pool: %p bytes\n", poolsize);
	2973
2912	2974	baseAddr = cast(byte *)os_mem_map(poolsize);
2913	2975
2914	2976	// Some of the code depends on page alignment of memory pools

tango/core/rt/gc/basic/gcalloc.d

old	new
115	115	}
116	116	else static if (is(typeof(mmap))) // else version (GC_Use_Alloc_MMap)
117	117	{
	118	debug(PRINTF) import tango.stdc.stdio: printf;
	119
	120
118	121	void *os_mem_map(size_t nbytes)
119	122	{ void *p;
120	123
	124	debug(PRINTF) printf("mmap alloc of %p bytes\n", nbytes);
121	125	p = mmap(null, nbytes, PROT_READ \| PROT_WRITE, MAP_PRIVATE \| MAP_ANON, -1, 0);
122	126	return (p == MAP_FAILED) ? null : p;
123	127	}

tango/core/rt/gc/basic/gcbits.d

old	new
50	50
51	51	struct GCBits
52	52	{
53		const int BITS_PER_WORD = 32;
54		const int BITS_SHIFT = 5;
55		const int BITS_MASK = 31;
	53	alias size_t wordtype;
56	54
57		uint* data = null;
	55	const BITS_PER_WORD = (wordtype.sizeof * 8);
	56	const BITS_SHIFT = (wordtype.sizeof == 8 ? 6 : 5);
	57	const BITS_MASK = (BITS_PER_WORD - 1);
	58	const BITS_1 = cast(wordtype)1;
	59
	60	wordtype* data = null;
58	61	size_t nwords = 0; // allocated words in data[] excluding sentinals
59	62	size_t nbits = 0; // number of bits in data[] excluding sentinals
60	63
…	…
79	82	{
80	83	this.nbits = nbits;
81	84	nwords = (nbits + (BITS_PER_WORD - 1)) >> BITS_SHIFT;
82		data = cast(~~uint*)calloc(nwords + 2, uint~~.sizeof);
	85	data = cast(wordtype*)calloc(nwords + 2, wordtype.sizeof);
83	86	if (!data)
84	87	onOutOfMemoryError();
85	88	}
86	89
87		~~uint~~ test(size_t i)
	90	wordtype test(size_t i)
88	91	in
89	92	{
90	93	assert(i < nbits);
…	…
92	95	body
93	96	{
94	97	//return (cast(bit *)(data + 1))[i];
95		return data[1 + (i >> BITS_SHIFT)] & (1 << (i & BITS_MASK));
	98	return data[1 + (i >> BITS_SHIFT)] & (BITS_1 << (i & BITS_MASK));
96	99	}
97	100
98	101	void set(size_t i)
…	…
103	106	body
104	107	{
105	108	//(cast(bit *)(data + 1))[i] = 1;
106		data[1 + (i >> BITS_SHIFT)] \|= (1 << (i & BITS_MASK));
	109	data[1 + (i >> BITS_SHIFT)] \|= (BITS_1 << (i & BITS_MASK));
107	110	}
108	111
109	112	void clear(size_t i)
…	…
114	117	body
115	118	{
116	119	//(cast(bit *)(data + 1))[i] = 0;
117		data[1 + (i >> BITS_SHIFT)] &= ~(1 << (i & BITS_MASK));
	120	data[1 + (i >> BITS_SHIFT)] &= ~(BITS_1 << (i & BITS_MASK));
118	121	}
119	122
120		~~uint~~ testClear(size_t i)
	123	wordtype testClear(size_t i)
121	124	{
122	125	version (bitops)
123	126	{
…	…
136	139	}
137	140	}
138	141	else
139		{ ~~uint~~ result;
	142	{ wordtype result;
140	143
141	144	//result = (cast(bit *)(data + 1))[i];
142	145	//(cast(bit *)(data + 1))[i] = 0;
143	146
144		~~uint~~* p = &data[1 + (i >> BITS_SHIFT)];
145		~~uint mask = (~~1 << (i & BITS_MASK));
	147	wordtype* p = &data[1 + (i >> BITS_SHIFT)];
	148	wordtype mask = (BITS_1 << (i & BITS_MASK));
146	149	result = *p & mask;
147	150	*p &= ~mask;
148	151	return result;
…	…
188	191	for (;d1!=dEnd;++d1)
189	192	*d1=0u;
190	193	} else {
191		memset(data + 1, 0, nwords * ~~uint~~.sizeof);
	194	memset(data + 1, 0, nwords * wordtype.sizeof);
192	195	}
193	196	}
194	197
…	…
200	203	body
201	204	{
202	205	version(MEMCPY_NON_SIG_SAFE) {
203		~~uint~~ * d1=data+1,d2=f.data+1,dEnd=d1+nwords;
	206	wordtype * d1=data+1,d2=f.data+1,dEnd=d1+nwords;
204	207	for (;d1!=dEnd;++d1,++d2)
205	208	d1=d2;
206	209	} else {
207		memcpy(data + 1, f.data + 1, nwords * ~~uint~~.sizeof);
	210	memcpy(data + 1, f.data + 1, nwords * wordtype.sizeof);
208	211	}
209	212	}
210	213
211		~~uint~~* base()
	214	wordtype* base()
212	215	in
213	216	{
214	217	assert(data);

tango/core/rt/compiler/ldc/object_.d

old	new
412	412	/// Compares two instances for <, ==, or >.
413	413	int compare(in void* p1, in void* p2) { return 0; } //throw new Exception("non comparable",__FILE__,__LINE__);
414	414
	415	/// Return alignment of type
	416	size_t talign() { return tsize(); }
	417
415	418	/// Returns size of the type.
416	419	size_t tsize() { return 0; }
417	420

tango/core/rt/compiler/ldc/typeinfo/ti_void.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return void.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return void.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_wchar.d

old	new
21	21	return cast(wchar )p1 - cast(wchar )p2;
22	22	}
23	23
	24	override size_t talign()
	25	{
	26	return wchar.alignof;
	27	}
	28
24	29	override size_t tsize()
25	30	{
26	31	return wchar.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_ptr.d

old	new
25	25	return 0;
26	26	}
27	27
	28	override size_t talign()
	29	{
	30	return (void*).alignof;
	31	}
	32
28	33	override size_t tsize()
29	34	{
30	35	return (void*).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Afloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (float[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (float[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_double.d

old	new
43	43	return _compare(cast(double )p1, cast(double )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return double.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return double.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_delegate.d

old	new
18	18	return cast(dg )p1 == cast(dg )p2;
19	19	}
20	20
	21	override size_t talign()
	22	{
	23	return dg.alignof;
	24	}
	25
21	26	override size_t tsize()
22	27	{
23	28	return dg.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Adouble.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (double[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (double[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_char.d

old	new
20	20	return cast(char )p1 - cast(char )p2;
21	21	}
22	22
	23	override size_t talign()
	24	{
	25	return char.alignof;
	26	}
	27
23	28	override size_t tsize()
24	29	{
25	30	return char.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Acdouble.d

old	new
75	75	return 0;
76	76	}
77	77
	78	override size_t talign()
	79	{
	80	return (cdouble[]).alignof;
	81	}
	82
78	83	override size_t tsize()
79	84	{
80	85	return (cdouble[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_uint.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return uint.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return uint.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_AC.d

old	new
82	82	return 0;
83	83	}
84	84
	85	override size_t talign()
	86	{
	87	return (Object[]).alignof;
	88	}
	89
85	90	override size_t tsize()
86	91	{
87	92	return (Object[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_ulong.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return ulong.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return ulong.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_creal.d

old	new
44	44	return _compare(cast(creal )p1, cast(creal )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return creal.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return creal.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_ubyte.d

old	new
22	22	return cast(ubyte )p1 - cast(ubyte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ubyte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ubyte.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Aint.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (int[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (int[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_short.d

old	new
22	22	return cast(short )p1 - cast(short )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return short.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return short.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_long.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return long.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return long.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Along.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (long[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (long[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_byte.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return byte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return byte.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_float.d

old	new
42	42	return _compare(cast(float )p1, cast(float )p2);
43	43	}
44	44
	45	override size_t talign()
	46	{
	47	return float.alignof;
	48	}
	49
45	50	override size_t tsize()
46	51	{
47	52	return float.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_cfloat.d

old	new
44	44	return _compare(cast(cfloat )p1, cast(cfloat )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cfloat.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cfloat.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Acfloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (cfloat[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (cfloat[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_cdouble.d

old	new
44	44	return _compare(cast(cdouble )p1, cast(cdouble )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cdouble.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cdouble.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_dchar.d

old	new
22	22	return cast(dchar )p1 - cast(dchar )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return dchar.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return dchar.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_C.d

old	new
62	62	return c;
63	63	}
64	64
	65	override size_t talign()
	66	{
	67	return Object.alignof;
	68	}
	69
65	70	override size_t tsize()
66	71	{
67	72	return Object.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_real.d

old	new
43	43	return _compare(cast(real )p1, cast(real )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return real.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return real.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Areal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (real[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (real[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_ushort.d

old	new
22	22	return cast(ushort )p1 - cast(ushort )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ushort.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ushort.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Acreal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (creal[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (creal[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Ag.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (byte[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (byte[]).sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_int.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return int.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return int.sizeof;

tango/core/rt/compiler/ldc/typeinfo/ti_Ashort.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (short[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (short[]).sizeof;

tango/core/rt/compiler/dmd/rt/adi.d

old	new
68	68	* reversed.
69	69	*/
70	70
71		extern (C) ~~long~~ _adReverseChar(char[] a)
	71	extern (C) char[] _adReverseChar(char[] a)
72	72	{
73	73	bool hadErrors=false;
74	74	if (a.length > 1)
…	…
100	100	}
101	101
102	102	uint stridehi = 1;
103		while ((chi & 0xC0) == 0x80 ~~&& hi >= lo~~)
	103	while ((chi & 0xC0) == 0x80)
104	104	{
105	105	chi = *--hi;
106	106	stridehi++;
107	107	}
108		if (lo >= hi){
	108	if (lo == hi)
	109	{
109	110	if (lo>hi){
110	111	hadErrors=true;
111	112	}
…	…
131	132	*/
132	133	memcpy(tmp.ptr, hi, stridehi);
133	134	memcpy(tmplo.ptr, lo, stridelo);
134		memmove(lo + stridehi, lo + stridelo , ~~(hi - lo) - stridelo~~);
	135	memmove(lo + stridehi, lo + stridelo , cast(size_t)((hi - lo) - stridelo));
135	136	memcpy(lo, tmp.ptr, stridehi);
136	137	memcpy(hi + stridehi - stridelo, tmplo.ptr, stridelo);
137	138
138	139	lo += stridehi;
139		hi = hi - 1 + (stridehi - stridelo);
	140	hi = hi - 1 + cast(int)(stridehi - stridelo);
140	141	}
141	142	}
142	143	if (hadErrors)
143	144	throw new Exception("invalid UTF-8 sequence",__FILE__,__LINE__);
144		return cast(long)(&a);
	145	return a;
145	146	}
146	147
147	148	unittest
148	149	{
149		auto a = "abcd"~~c[]~~;
	150	auto a = "abcd";
150	151
151	152	auto r = a.dup.reverse;
152	153	//writefln(r);

tango/core/rt/compiler/dmd/rt/trace.d

old	new
787	787	* dw length
788	788	* ascii string
789	789	*/
790
791		version (OSX) { // 16 byte align stack
792		asm {
793		naked ;
	790	version (OSX)
	791	{ // 16 byte align stack
	792	version (D_InlineAsm_X86)
	793	asm
	794	{ naked ;
794	795	pushad ;
795	796	mov ECX,8*4[ESP] ;
796	797	xor EAX,EAX ;
…	…
814	815	popad ;
815	816	ret ;
816	817	}
817		} else {
818		asm {
819		naked ;
	818	else version (D_InlineAsm_X86_64)
	819	static assert(0);
	820	else
	821	static assert(0);
	822	}
	823	else
	824	{
	825	version (D_InlineAsm_X86)
	826	asm
	827	{ naked ;
820	828	pushad ;
821	829	mov ECX,8*4[ESP] ;
822	830	xor EAX,EAX ;
…	…
839	847	popad ;
840	848	ret ;
841	849	}
	850	else version (D_InlineAsm_X86_64)
	851	asm
	852	{ naked ;
	853	push RAX ;
	854	push RCX ;
	855	push RDX ;
	856	push RSI ;
	857	push RDI ;
	858	push R8 ;
	859	push R9 ;
	860	push R10 ;
	861	push R11 ;
	862	mov RCX,9*8[RSP] ;
	863	xor RAX,RAX ;
	864	mov AL,[RCX] ;
	865	cmp AL,0xFF ;
	866	jne L1 ;
	867	cmp byte ptr 1[RCX],0 ;
	868	jne L1 ;
	869	mov AX,2[RCX] ;
	870	add 9*8[RSP],3 ;
	871	add RCX,3 ;
	872	L1: inc RAX ;
	873	inc RCX ;
	874	add 9*8[RSP],RAX ;
	875	dec RAX ;
	876	push RCX ;
	877	push RAX ;
	878	call trace_pro ;
	879	add RSP,16 ;
	880	pop R11 ;
	881	pop R10 ;
	882	pop R8 ;
	883	pop R9 ;
	884	pop RDI ;
	885	pop RSI ;
	886	pop RDX ;
	887	pop RCX ;
	888	pop RAX ;
	889	ret ;
842	890	}
	891	else
	892	static assert(0);
843	893	}
	894	}
844	895
845	896	/////////////////////////////////////////////
846	897	// Function called by trace code in function epilog.
…	…
906	957	}
907	958	}
908	959	}
	960	else version (D_InlineAsm_X86_64)
	961	{
	962	extern (D)
	963	{
	964	void QueryPerformanceCounter(timer_t* ctr)
	965	{
	966	asm
	967	{
	968	naked ;
	969	rdtsc ;
	970	mov [RDI],EAX ;
	971	mov 4[RDI],EDX ;
	972	ret ;
	973	}
	974	}
	975
	976	void QueryPerformanceFrequency(timer_t* freq)
	977	{
	978	*freq = 3579545;
	979	}
	980	}
	981	}
909	982	else
910	983	{
911	984	static assert(0);

tango/core/rt/compiler/dmd/rt/lifetime.d

old	new
33	33	import tango.stdc.string : memcpy, memset, memcmp;
34	34	import tango.stdc.stdarg;
35	35	debug(PRINTF) import tango.stdc.stdio : printf;
	36
	37	alias void[] array_t;
36	38	}
37	39
38	40
…	…
192	194	* ti is the type of the resulting array, or pointer to element.
193	195	* (For when the array is initialized to 0)
194	196	*/
195		extern ~~(C) ulong~~ _d_newarrayT(TypeInfo ti, size_t length)
	197	extern(C) array_t _d_newarrayT(TypeInfo ti, size_t length)
196	198	{
197	199	void* p;
198		~~ulong~~ result;
	200	array_t result;
199	201	auto size = ti.next.tsize(); // array element size
200	202
201	203	debug(PRINTF) printf("_d_newarrayT(length = x%x, size = %d)\n", length, size);
202	204	if (length == 0 \|\| size == 0)
203		result = 0;
	205	result = array_t.init;
204	206	else
205	207	{
206	208	version (D_InlineAsm_X86)
…	…
213	215	jc Loverflow ;
214	216	}
215	217	}
	218	else version (D_InlineAsm_X86_64)
	219	asm
	220	{
	221	mov RAX,size ;
	222	mul RAX,length ;
	223	mov size,RAX ;
	224	jc Loverflow ;
	225	}
216	226	else
217	227	size *= length;
	228
218	229	PointerMap pm;
219		version (D_HavePointerMap) {
220		pm = ti.next.pointermap();
221		}
	230	version (D_HavePointerMap) pm = ti.next.pointermap();
	231
222	232	p = gc_malloc(size + 1, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm);
223	233	debug(PRINTF) printf(" p = %p\n", p);
224	234	memset(p, 0, size);
225		result = cast(~~ulong)length + (cast(ulong)cast(uint)p << 32)~~;
	235	result = cast(array_t)p[0..length];
226	236	}
227	237	return result;
228	238
…	…
233	243	/**
234	244	* For when the array has a non-zero initializer.
235	245	*/
236		extern ~~(C) ulong~~ _d_newarrayiT(TypeInfo ti, size_t length)
	246	extern(C) array_t _d_newarrayiT(TypeInfo ti, size_t length)
237	247	{
238		~~ulong~~ result;
	248	array_t result;
239	249	auto size = ti.next.tsize(); // array element size
240	250
241	251	debug(PRINTF) printf("_d_newarrayiT(length = %d, size = %d)\n", length, size);
242	252
243	253	if (length == 0 \|\| size == 0)
244		result = 0;
	254	result = array_t.init;
245	255	else
246	256	{
247	257	auto initializer = ti.next.init();
…	…
257	267	jc Loverflow ;
258	268	}
259	269	}
	270	else version (D_InlineAsm_X86_64)
	271	asm
	272	{
	273	mov RAX,size ;
	274	mul RAX,length ;
	275	mov size,RAX ;
	276	jc Loverflow ;
	277	}
260	278	else
261	279	size *= length;
	280
262	281	PointerMap pm;
263	282	version (D_HavePointerMap) {
264	283	pm = ti.next.pointermap();
…	…
284	303	}
285	304	}
286	305	va_end(q);
287		result = cast(~~ulong)length + (cast(ulong)cast(uint)p << 32)~~;
	306	result = cast(array_t)p[0..length];
288	307	}
289	308	return result;
290	309
…	…
295	314	/**
296	315	*
297	316	*/
298		extern ~~(C) ulong~~ _d_newarraymT(TypeInfo ti, int ndims, ...)
	317	extern(C) array_t _d_newarraymT(TypeInfo ti, int ndims, ...)
299	318	{
300		~~ulong~~ result;
	319	array_t result;
301	320
302	321	debug(PRINTF) printf("_d_newarraymT(ndims = %d)\n", ndims);
303	322	if (ndims == 0)
304		result = 0;
	323	result = array_t.init;
305	324	else
306		{ ~~va_list q;~~
307		va_~~start!(int)(q, ndims)~~;
	325	{
	326	va_list q;
308	327
309		void[] foo(TypeInfo ti, size_t* pdim, int ndims)
	328	version(X86)
	329	va_start(q, ndims);
	330	else version(X86_64)
	331	va_start(q, __va_argsave);
	332	else
	333	static assert(false, "platform not supported");
	334
	335	void[] foo(TypeInfo ti, va_list ap, int ndims)
310	336	{
311		size_t dim = *pdim;
	337	size_t dim;
	338	va_arg(ap, dim);
312	339	void[] p;
313	340
314	341	debug(PRINTF) printf("foo(ti = %p, ti.next = %p, dim = %d, ndims = %d\n", ti, ti.next, dim, ndims);
…	…
320	347	else
321	348	{
322	349	p = gc_malloc(dim * (void[]).sizeof + 1)[0 .. dim];
323		for (int i = 0; i < dim; i++)
	350
	351	version (X86)
324	352	{
325		(cast(void[]*)p.ptr)[i] = foo(ti.next, pdim + 1, ndims - 1);
	353	va_list ap2;
	354	va_copy(ap2, ap);
326	355	}
	356
	357	for (size_t i = 0; i < dim; i++)
	358	{
	359	version (X86_64)
	360	{
	361	__va_list argsave = cast(__va_list)ap;
	362	va_list ap2 = &argsave;
327	363	}
	364	(cast(void[]*)p.ptr)[i] = foo(ti.next, ap2, ndims - 1);
	365	}
	366	}
328	367	return p;
329	368	}
330	369
331		size_t* pdim = cast(size_t *)q;
332		result = cast(ulong)foo(ti, pdim, ndims);
	370	result = cast(typeof(result))foo(ti, q, ndims);
333	371	debug(PRINTF) printf("result = %llx\n", result);
334	372
335	373	version (none)
…	…
348	386	/**
349	387	*
350	388	*/
351		extern ~~(C) ulong _d_newarraymiT(TypeInfo ti, in~~t ndims, ...)
	389	extern(C) array_t _d_newarraymiT(TypeInfo ti, size_t ndims, ...)
352	390	{
353		~~ulong~~ result;
	391	array_t result;
354	392
355	393	debug(PRINTF) printf("_d_newarraymiT(ndims = %d)\n", ndims);
356	394	if (ndims == 0)
357		result = 0;
	395	result = array_t.init;
358	396	else
359	397	{
360	398	va_list q;
361		~~va_start!(int)(q, ndims);~~
362	399
363		void[] foo(TypeInfo ti, size_t* pdim, int ndims)
	400	version(X86)
	401	va_start(q, ndims);
	402	else version(X86_64)
	403	va_start(q, __va_argsave);
	404	else
	405	static assert(false, "platform not supported");
	406
	407	void[] foo(TypeInfo ti, va_list ap, size_t ndims)
364	408	{
365		size_t dim = *pdim;
	409	size_t dim;
	410	va_arg(ap, dim);
366	411	void[] p;
367	412
368	413	if (ndims == 1)
…	…
373	418	else
374	419	{
375	420	p = gc_malloc(dim * (void[]).sizeof + 1)[0 .. dim];
376		for (int i = 0; i < dim; i++)
	421
	422	version (X86)
377	423	{
378		(cast(void[]*)p.ptr)[i] = foo(ti.next, pdim + 1, ndims - 1);
	424	va_list ap2;
	425	va_copy(ap2, ap);
379	426	}
	427
	428	for (size_t i = 0; i < dim; i++)
	429	{
	430	version (X86_64)
	431	{
	432	__va_list argsave = cast(__va_list)ap;
	433	va_list ap2 = &argsave;
380	434	}
	435	(cast(void[]*)p.ptr)[i] = foo(ti.next, ap2, ndims - 1);
	436	}
	437	}
	438
381	439	return p;
382	440	}
383	441
384		size_t* pdim = cast(size_t *)q;
385		result = cast(ulong)foo(ti, pdim, ndims);
	442	result = cast(typeof(result))foo(ti, q, ndims);
386	443	debug(PRINTF) printf("result = %llx\n", result);
387	444
388	445	version (none)
…	…
457	514	{
458	515	Interface pi = cast(Interface **)p;
459	516	Object o = cast(Object)(p - pi.offset);
	517	debug(PRINTF) printf("finalizing...");
460	518	rt_finalize(cast(void*)o);
461	519	}
462	520	}
…	…
467	525	*/
468	526	extern (C) void _d_callfinalizer(void* p)
469	527	{
	528	debug(PRINTF) printf("dcall finalizing...");
470	529	rt_finalize( p );
471	530	}
472	531
…	…
490	549	if (p) // not necessary if called from gc
491	550	{
492	551	if (det)
	552	{
	553	debug(PRINTF) printf("\t det=true, calling dispose\n");
493	554	(cast(Object)p).dispose();
	555	}
	556	debug(PRINTF) printf("\tcasting to class info\n");
494	557
495	558	ClassInfo pc = cast(ClassInfo)p;
496	559
	560	debug(PRINTF) printf("\tdereferencing pc: %lu\n", *pc);
	561
497	562	if (*pc)
498	563	{
499	564	ClassInfo c = **pc;
500	565
501	566	try
502	567	{
	568	debug(PRINTF) printf("\tdoing tests.. collecthandler is %lu\n", cast(void*)collectHandler);
503	569	if (det \|\| collectHandler is null \|\| collectHandler(cast(Object)p))
504	570	{
505	571	do
…	…
509	575	void delegate() dg;
510	576	dg.ptr = p;
511	577	dg.funcptr = cast(void function()) c.destructor;
	578	debug(PRINTF) printf("\tcalling dtor of %s\n", c.name.ptr);
512	579	dg(); // call destructor
	580	debug(PRINTF) printf("\tdtor done.\n");
513	581	}
514	582	c = c.base;
515	583	} while (c);
…	…
519	587	}
520	588	catch (Exception e)
521	589	{
	590	debug(PRINTF) printf("\tException while finalizing\n");
522	591	onFinalizeError(**pc, e);
523	592	}
524	593	finally
…	…
527	596	}
528	597	}
529	598	}
	599	debug(PRINTF) printf("\tLeaving.\n");
530	600	}
531	601
532	602
…	…
753	823	onOutOfMemoryError();
754	824	}
755	825
	826	/**************************************
	827	* Extend an array by n elements.
	828	* Caller must initialize that element.
	829	*/
	830	version(X86_64) extern (C) byte[] _d_arrayappendcTX(TypeInfo ti, inout byte[] x, size_t n)
	831	{
	832	auto sizeelem = ti.next.tsize(); // array element size
	833	auto info = gc_query(x.ptr);
	834	auto length = x.length;
	835	auto newlength = length + n;
	836	auto newsize = newlength * sizeelem;
756	837
	838	assert(info.size == 0 \|\| length * sizeelem <= info.size);
	839
	840	//printf("_d_arrayappendcTX(sizeelem = %d, ptr = %p, length = %d, cap = %d)\n", sizeelem, x.ptr, x.length, cap);
	841
	842	if (newsize >= info.size)
	843	{ byte* newdata;
	844
	845	if (info.size >= PAGESIZE)
	846	{ // Try to extend in-place
	847	auto u = gc_extend(x.ptr, (newsize + 1) - info.size, (newsize + 1) - info.size);
	848	if (u)
	849	{
	850	goto L1;
	851	}
	852	}
	853
	854	PointerMap pm;
	855	version (D_HavePointerMap) {
	856	pm = ti.next.pointermap();
	857	}
	858
	859	uint attr = !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0;
	860	newdata = cast(byte *) gc_malloc(newCapacity(newlength, sizeelem) + 1, attr, pm);
	861
	862	memcpy(newdata, x.ptr, length * sizeelem);
	863
	864	(cast(void **)(&x))[1] = newdata;
	865	}
	866
	867	L1:
	868	cast(size_t )&x = newlength;
	869	assert((cast(size_t)x.ptr & 15) == 0);
	870	assert(gc_query(x.ptr).size > x.length * sizeelem);
	871	return x;
	872	}
	873
	874
757	875	/**
758	876	* Append y[] to array x[].
759	877	* size is size of each array element.
…	…
902	1020	return x;
903	1021	}
904	1022
	1023	import tango.io.Stdout;
905	1024
906	1025	/**
907	1026	* Append dchar to char[]
…	…
1113	1232	byte[] b;
1114	1233	auto size = ti.next.tsize(); // array element size
1115	1234
	1235	version (X86)
	1236	{
1116	1237	p = cast(byte[]*)(&n + 1);
1117
1118	1238	for (i = 0; i < n; i++)
1119	1239	{
1120	1240	b = *p++;
1121	1241	length += b.length;
1122	1242	}
	1243	}
	1244	else version (X86_64)
	1245	{
	1246	__va_list argsave = __va_argsave.va;
	1247	va_list ap;
	1248	va_start(ap, __va_argsave);
	1249	for (i = 0; i < n; i++)
	1250	{
	1251	b.length = 0;
	1252	va_arg(ap, b);
	1253	length += b.length;
	1254	}
	1255	va_end(ap);
	1256	}
	1257
1123	1258	if (!length)
1124	1259	return null;
1125	1260
…	…
1128	1263	pm = ti.next.pointermap();
1129	1264	}
1130	1265	a = gc_malloc(length * size, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm);
	1266
	1267	version (X86)
	1268	{
1131	1269	p = cast(byte[]*)(&n + 1);
1132
1133		uint j = 0;
	1270	size_t j = 0;
1134	1271	for (i = 0; i < n; i++)
1135	1272	{
1136	1273	b = *p++;
…	…
1140	1277	j += b.length * size;
1141	1278	}
1142	1279	}
	1280	}
	1281	else version (X86_64)
	1282	{
	1283	va_list ap2 = &argsave;
	1284	size_t j = 0;
	1285	for (i = 0; i < n; i++)
	1286	{
	1287	b.length = 0;
	1288	va_arg(ap2, b);
	1289	if (b.length)
	1290	{
	1291	memcpy(a + j, b.ptr, b.length * size);
	1292	j += b.length * size;
	1293	}
	1294	}
	1295	va_end(ap2);
	1296	}
1143	1297
1144	1298	byte[] result;
1145	1299	cast(size_t )&result = length; // jam length
…	…
1147	1301	return result;
1148	1302	}
1149	1303
	1304	extern (C) void* _d_arrayliteralTX(TypeInfo ti, size_t length)
	1305	{
	1306	auto sizeelem = ti.next.tsize(); // array element size
	1307	void* result;
1150	1308
	1309	//printf("_d_arrayliteralTX(sizeelem = %d, length = %d)\n", sizeelem, length);
	1310	if (length == 0 \|\| sizeelem == 0)
	1311	result = null;
	1312	else
	1313	{
	1314	PointerMap pm;
	1315	version (D_HavePointerMap) {
	1316	pm = ti.next.pointermap();
	1317	}
	1318	result = gc_malloc(length * sizeelem, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm);
	1319	}
	1320	return result;
	1321	}
	1322
1151	1323	/**
1152	1324	*
1153	1325	*/
1154		extern (C) void* _d_arrayliteralT(TypeInfo ti, size_t length, ...)
	1326	version (X86) extern (C) void* _d_arrayliteralT(TypeInfo ti, size_t length, ...)
1155	1327	{
1156	1328	auto sizeelem = ti.next.tsize(); // array element size
1157	1329	void* result;
…	…
1167	1339	}
1168	1340	result = gc_malloc(length * sizeelem, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm);
1169	1341
	1342	version(X86)
	1343	{
1170	1344	va_list q;
1171	1345	va_start!(size_t)(q, length);
1172	1346
…	…
1187	1361
1188	1362	va_end(q);
1189	1363	}
	1364	else version(X86_64)
	1365	{
	1366	va_list q;
	1367	va_start(q, __va_argsave);
	1368	for (size_t i = 0; i < length; i++)
	1369	{
	1370	va_arg(q, ti.next, result + i * sizeelem);
	1371	}
	1372	va_end(q);
	1373	}
	1374	}
1190	1375	return result;
1191	1376	}
1192	1377
…	…
1204	1389	/**
1205	1390	*
1206	1391	*/
1207		extern (C) ~~long~~ _adDupT(TypeInfo ti, Array2 a)
	1392	extern (C) array_t _adDupT(TypeInfo ti, Array2 a)
1208	1393	out (result)
1209	1394	{
1210	1395	auto sizeelem = ti.next.tsize(); // array element size
…	…
1226	1411	r.length = a.length;
1227	1412	memcpy(r.ptr, a.ptr, size);
1228	1413	}
1229		return cast(~~long~~)(&r);
	1414	return cast(array_t)(&r);
1230	1415	}
1231	1416
1232	1417

tango/core/rt/compiler/dmd/rt/memory.d

old	new
109	109	ret;
110	110	}
111	111	}
	112	else version( D_InlineAsm_X86_64 )
	113	{
	114	asm
	115	{
	116	naked;
	117	mov RAX, RSP;
	118	ret;
	119	}
	120	}
112	121	else
113	122	{
114	123	static assert( false, "Architecture not supported." );

tango/core/rt/compiler/dmd/rt/dmain2.d

old	new
16	16
17	17	import tango.stdc.stdlib : malloc, free, exit, EXIT_FAILURE;
18	18	import tango.stdc.string : strlen;
19		~~import tango.stdc.stdio : printf;~~
20	19	}
21	20
22	21	version( Win32 )
…	…
314	313	}
315	314	catch (Object o)
316	315	{
317		~~//fprintf(stderr, "%.*s\n", o.toString());~~
318	316	console (o.toString)("\n");
319	317	result = EXIT_FAILURE;
320	318	}
…	…
343	341	{
344	342	rt_init();
345	343	if (runModuleUnitTests())
	344	{
346	345	tryExec(&runMain);
	346	}
	347
347	348	rt_term();
348	349	}
349	350

tango/core/rt/compiler/dmd/rt/cover.d

old	new
34	34	struct BitArray
35	35	{
36	36	size_t len;
37		uint* ptr;
	37	size_t* ptr;
38	38
39	39	bool opIndex( size_t i )
40	40	in

tango/core/rt/compiler/dmd/rt/aaA.d

old	new
69	69	* Although DMD will return types of Array in registers,
70	70	* gcc will not, so we instead use a 'long'.
71	71	*/
72		alias ~~long~~ ArrayRet_t;
	72	alias void[] ArrayRet_t;
73	73
74	74	struct Array
75	75	{
…	…
110	110
111	111	size_t aligntsize(size_t tsize)
112	112	{
113		// Is pointer alignment on the x64 4 bytes or 8?
	113	version (X86_64)
	114	// Size of key needed to align value on 16 bytes
	115	return (tsize + 15) & ~(15);
	116	else
114	117	return (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
115	118	}
116	119
…	…
238	241	*/
239	242
240	243	void* _aaGet(AA* aa, TypeInfo keyti, size_t valuesize, ...)
	244	{
	245	return _aaGetX(aa, keyti, valuesize, cast(void *)(&valuesize + 1));
	246	}
	247
	248	void* _aaGetX(AA* aa, TypeInfo keyti, size_t valuesize, void* pkey)
241	249	in
242	250	{
243	251	assert(aa);
…	…
251	259	}
252	260	body
253	261	{
254		~~auto pkey = cast(void *)(&valuesize + 1);~~
255	262	size_t i;
256	263	aaA *e;
257	264	auto keysize = aligntsize(keyti.tsize());
258	265
259	266	if (!aa.a)
260	267	aa.a = new BB();
	268
261	269	aa.a.keyti = keyti;
262	270
263	271	if (!aa.a.b.length)
…	…
269	277	}
270	278
271	279	auto key_hash = keyti.getHash(pkey);
	280
272	281	//printf("hash = %d\n", key_hash);
	282
273	283	i = key_hash % aa.a.b.length;
274	284	auto pe = &aa.a.b[i];
	285
275	286	while ((e = *pe) !is null)
276	287	{
277	288	if (key_hash == e.hash)
…	…
312	323
313	324	void* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, ...)
314	325	{
	326	return _aaGetRvalueX(aa, keyti, valuesize, cast(void *)(&valuesize + 1));
	327	}
	328
	329	void* _aaGetRvalueX(AA aa, TypeInfo keyti, size_t valuesize, void* pkey)
	330	{
315	331	//printf("_aaGetRvalue(valuesize = %u)\n", valuesize);
316	332	if (!aa.a)
317	333	return null;
318	334
319		~~auto pkey = cast(void *)(&valuesize + 1);~~
320	335	auto keysize = aligntsize(keyti.tsize());
321	336	auto len = aa.a.b.length;
322	337
…	…
351	366	*/
352	367
353	368	void* _aaIn(AA aa, TypeInfo keyti, ...)
	369	{
	370	return _aaInX(aa, keyti, cast(void *)(&keyti + 1));
	371	}
	372
	373	void* _aaInX(AA aa, TypeInfo keyti, void* pkey)
354	374	in
355	375	{
356	376	}
…	…
362	382	{
363	383	if (aa.a)
364	384	{
365		~~auto pkey = cast(void *)(&keyti + 1);~~
366
367	385	//printf("_aaIn(), .length = %d, .ptr = %x\n", aa.a.length, cast(uint)aa.a.ptr);
368	386	auto len = aa.a.b.length;
369	387
…	…
399	417
400	418	void _aaDel(AA aa, TypeInfo keyti, ...)
401	419	{
402		auto pkey = cast(void *)(&keyti + 1);
	420	return _aaDelX(aa, keyti, cast(void *)(&keyti + 1));
	421	}
	422
	423	void _aaDelX(AA aa, TypeInfo keyti, void* pkey)
	424	{
403	425	aaA *e;
404	426
405	427	if (aa.a && aa.a.b.length)
…	…
673	695
674	696	auto len = _aaLen(aa);
675	697	if (!len)
676		return 0;
	698	return null;
677	699	res = (cast(byte) gc_malloc(len keysize,
678	700	!(aa.a.keyti.flags() & 1) ? BlkAttr.NO_SCAN : 0))[0 .. len * keysize];
679	701	resi = 0;
…	…
801	823	return result;
802	824	}
803	825
	826	extern (C) BB* _d_assocarrayliteralTX(TypeInfo_AssociativeArray ti, void[] keys, void[] values)
	827	{
	828	auto valueti = ti.next;
	829	auto valuesize = valueti.tsize(); // value size
	830	auto keyti = ti.key;
	831	auto keysize = keyti.tsize(); // key size
	832	auto length = keys.length;
	833	BB* result;
804	834
	835	//printf("_d_assocarrayliteralT(keysize = %d, valuesize = %d, length = %d)\n", keysize, valuesize, length);
	836	//printf("tivalue = %.*s\n", ti.next.classinfo.name);
	837	assert(length == values.length);
	838	if (length == 0 \|\| valuesize == 0 \|\| keysize == 0)
	839	{
	840	;
	841	}
	842	else
	843	{
	844	result = new BB();
	845
	846	size_t i;
	847	for (i = 0; i < prime_list.length - 1; i++)
	848	{
	849	if (length <= prime_list[i])
	850	break;
	851	}
	852	auto len = prime_list[i];
	853	result.b = new aaA*[len];
	854
	855	size_t keytsize = aligntsize(keysize);
	856
	857	for (size_t j = 0; j < length; j++)
	858	{ auto pkey = keys.ptr + j * keysize;
	859	auto pvalue = values.ptr + j * valuesize;
	860	aaA* e;
	861
	862	auto key_hash = keyti.getHash(pkey);
	863	//printf("hash = %d\n", key_hash);
	864	i = key_hash % len;
	865	auto pe = &result.b[i];
	866	while (1)
	867	{
	868	e = *pe;
	869	if (!e)
	870	{
	871	// Not found, create new elem
	872	//printf("create new one\n");
	873	e = cast(aaA ) cast(void) new void[aaA.sizeof + keytsize + valuesize];
	874	memcpy(e + 1, pkey, keysize);
	875	e.hash = key_hash;
	876	*pe = e;
	877	result.nodes++;
	878	break;
	879	}
	880	if (key_hash == e.hash)
	881	{
	882	auto c = keyti.compare(pkey, e + 1);
	883	if (c == 0)
	884	break;
	885	pe = (c < 0) ? &e.left : &e.right;
	886	}
	887	else
	888	pe = (key_hash < e.hash) ? &e.left : &e.right;
	889	}
	890	memcpy(cast(void *)(e + 1) + keytsize, pvalue, valuesize);
	891	}
	892	}
	893	return result;
	894	}
	895
805	896	/***********************************
806	897	* Construct an associative array of type ti from
807	898	* length pairs of key/value pairs.
808	899	*/
809	900
810		extern (C)
811		BB* _d_assocarrayliteralT(TypeInfo_AssociativeArray ti, size_t length, ...)
	901	extern (C) BB* _d_assocarrayliteralT(TypeInfo_AssociativeArray ti, size_t length, ...)
812	902	{
813	903	auto valuesize = ti.next.tsize(); // value size
814	904	auto keyti = ti.key;
…	…
824	914	else
825	915	{
826	916	va_list q;
827		va_start!(size_t)(q, length);
	917	version(X86_64) va_start(q, __va_argsave); else va_start!(size_t)(q, length);
828	918
829	919	result = new BB();
830	920	result.keyti = keyti;

tango/core/rt/compiler/dmd/rt/cast_.d

old	new
82	82
83	83	Object _d_dynamic_cast(Object o, ClassInfo c)
84	84	{ ClassInfo oc;
85		~~size_~~t offset = 0;
	85	uint offset = 0;
86	86
87	87	//printf("_d_dynamic_cast(o = %p, c = '%.*s')\n", o, c.name);
88	88
…	…
101	101	return o;
102	102	}
103	103
104		int _d_isbaseof2(ClassInfo oc, ClassInfo c, ref ~~size_~~t offset)
	104	int _d_isbaseof2(ClassInfo oc, ClassInfo c, ref uint offset)
105	105	{ int i;
106	106
107	107	if (oc is c)

tango/core/rt/compiler/dmd/rt/memset.d

old	new
41	41	return pstart;
42	42	}
43	43
	44
44	45	int _memset32(int p, int value, size_t count)
45	46	{
46		version (X86)
	47	version (D_InlineAsm_X86)
47	48	{
48	49	asm
49	50	{
…	…
118	119	}
119	120	return pstart;
120	121	}
	122
	123	float _memsetFloat(float p, float value, size_t count)
	124	{
	125	float *pstart = p;
	126	float *ptop;
	127
	128	for (ptop = &p[count]; p < ptop; p++)
	129	*p = value;
	130	return pstart;
	131	}
	132
	133	double _memsetDouble(double p, double value, size_t count)
	134	{
	135	double *pstart = p;
	136	double *ptop;
	137
	138	for (ptop = &p[count]; p < ptop; p++)
	139	*p = value;
	140	return pstart;
	141	}

tango/core/rt/compiler/dmd/rt/alloca.d

old	new
27	27	* EAX allocated data, null if stack overflows
28	28	*/
29	29
	30
30	31	extern (C) void* __alloca(int nbytes)
31	32	{
	33	version (D_InlineAsm_X86)
	34	{
32	35	asm
33	36	{
34	37	naked ;
…	…
37	40	push EBX ;
38	41	push EDI ;
39	42	push ESI ;
	43	}
	44
	45	version (OSX)
	46	{
	47	asm
	48	{
	49	add EAX,15 ;
	50	and EAX,0xFFFFFFF0 ; // round up to 16 byte boundary
	51	}
	52	}
	53	else
	54	{
	55	asm
	56	{
40	57	add EAX,3 ;
41	58	and EAX,0xFFFFFFFC ; // round up to dword
	59	}
	60	}
	61
	62	asm
	63	{
42	64	jnz Abegin ;
43	65	mov EAX,4 ; // allow zero bytes allocation, 0 rounded to dword is 4..
44	66	Abegin:
…	…
108	130	ret ;
109	131	}
110	132	}
	133	else version (D_InlineAsm_X86_64)
	134	{
	135	asm
	136	{
	137	naked ;
	138	mov RDX,RCX ;
	139	mov RAX,RDI ; // get nbytes
	140	add RAX,15 ;
	141	and AL,0xF0 ; // round up to 16 byte boundary
	142	test RAX,RAX ;
	143	jnz Abegin ;
	144	mov RAX,16 ; // allow zero bytes allocation
	145	Abegin:
	146	mov RSI,RAX ; // RSI = nbytes
	147	neg RAX ;
	148	add RAX,RSP ; // RAX is now what the new RSP will be.
	149	jae Aoverflow ;
	150	}
	151	version (Win64)
	152	{
	153	asm
	154	{
	155	// We need to be careful about the guard page
	156	// Thus, for every 4k page, touch it to cause the OS to load it in.
	157	mov RCX,RAX ; // RCX is new location for stack
	158	mov RBX,RSI ; // RBX is size to "grow" stack
	159	L1:
	160	test [RCX+RBX],RBX ; // bring in page
	161	sub RBX,0x1000 ; // next 4K page down
	162	jae L1 ; // if more pages
	163	test [RCX],RBX ; // bring in last page
	164	}
	165	}
	166	version (Unix)
	167	{
	168	asm
	169	{
	170	cmp RAX,_pastdata ;
	171	jbe Aoverflow ; // Unlikely - ~2 Gbytes under UNIX
	172	}
	173	}
	174	asm
	175	{
	176	// Copy down to [RSP] the temps on the stack.
	177	// The number of temps is (RBP - RSP - locals).
	178	mov RCX,RBP ;
	179	sub RCX,RSP ;
	180	sub RCX,[RDX] ; // RCX = number of temps (bytes) to move.
	181	add [RDX],RSI ; // adjust locals by nbytes for next call to alloca()
	182	mov RSP,RAX ; // Set up new stack pointer.
	183	add RAX,RCX ; // Return value = RSP + temps.
	184	mov RDI,RSP ; // Destination of copy of temps.
	185	add RSI,RSP ; // Source of copy.
	186	shr RCX,3 ; // RCX to count of qwords in temps
	187	rep ;
	188	movsq ;
	189	jmp done ;
	190
	191	Aoverflow:
	192	// Overflowed the stack. Return null
	193	xor RAX,RAX ;
	194
	195	done:
	196	ret ;
	197	}
	198	}
	199	else
	200	static assert(0);
	201	}

tango/core/rt/compiler/dmd/object_.d

old	new
331	331	{
332	332	foreach (m; ModuleInfo)
333	333	{
	334	if (!m)
	335	continue;
	336
334	337	//writefln("module %s, %d", m.name, m.localClasses.length);
335	338	foreach (c; m.localClasses)
336	339	{
…	…
416	419
417	420	/// Compares two instances for <, ==, or >.
418	421	int compare(in void* p1, in void* p2) { return 0; } // throw new Exception("non comparable",__FILE__,__LINE__);
419
	422	/// Return alignment of type
	423	size_t talign() { return tsize(); }
420	424	/// Returns size of the type.
421	425	size_t tsize() { return 0; }
422	426
…	…
473	477
474	478	/// Get type information on the contents of the type; null if not available
475	479	OffsetTypeInfo[] offTi() { return null; }
	480
	481
	482	/** Return internal info on arguments fitting into 8byte.
	483	* See X86-64 ABI 3.2.3
	484	*/
	485	version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	486	{
	487	arg1 = this;
	488	return 0;
476	489	}
	490	}
477	491
478	492	class TypeInfo_Typedef : TypeInfo
479	493	{
…	…
499	513	override PointerMap pointermap() { return base.pointermap(); }
500	514	override void[] init() { return m_init.length ? m_init : base.init(); }
501	515
	516	size_t talign() { return base.talign(); }
	517
	518	version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	519	{
	520	return base.argTypes(arg1, arg2);
	521	}
	522
502	523	TypeInfo base;
503	524	char[] name;
504	525	void[] m_init;
…	…
636	657
637	658	override uint flags() { return 1; }
638	659
	660	size_t talign()
	661	{
	662	return (void[]).alignof;
	663	}
	664
	665	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	666	{ //arg1 = typeid(size_t);
	667	//arg2 = typeid(void*);
	668	return 0;
	669	}
	670
639	671	override PointerMap pointermap()
640	672	{
641	673	//return static mask for arrays
…	…
750	782
751	783	TypeInfo value;
752	784	size_t len;
	785
	786	size_t talign()
	787	{
	788	return value.talign();
753	789	}
754	790
	791	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	792	{
	793	arg1 = typeid(void*);
	794	return 0;
	795	}
	796
	797	}
	798
755	799	class TypeInfo_AssociativeArray : TypeInfo
756	800	{
757	801	override char[] toString()
…	…
818	862
819	863	TypeInfo value;
820	864	TypeInfo key;
	865
	866	size_t talign()
	867	{
	868	return (char[int]).alignof;
821	869	}
822	870
	871	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	872	{
	873	arg1 = typeid(void*);
	874	return 0;
	875	}
	876	}
	877
823	878	class TypeInfo_Function : TypeInfo
824	879	{
825	880	override char[] toString()
…	…
902	957	}
903	958
904	959	TypeInfo next;
	960
	961	size_t talign()
	962	{
	963	alias int delegate() dg;
	964	return dg.alignof;
905	965	}
906	966
	967	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	968	{ //arg1 = typeid(void*);
	969	//arg2 = typeid(void*);
	970	return 0;
	971	}
	972
	973	}
	974
907	975	class TypeInfo_Class : TypeInfo
908	976	{
909	977	override char[] toString() { return info.name; }
…	…
1114	1182
1115	1183	override uint flags() { return m_flags; }
1116	1184
	1185	size_t talign() { return m_align; }
	1186
	1187
1117	1188	char[] name;
1118	1189	void[] m_init; // initializer; init.ptr == null if 0 initialize
1119	1190
…	…
1124	1195	char[] function() xtoString;
1125	1196
1126	1197	uint m_flags;
	1198	uint m_align;
1127	1199
1128	1200	version (D_HavePointerMap) {
1129	1201	PointerMap m_pointermap;
1130	1202
1131	1203	override PointerMap pointermap() { return m_pointermap; }
1132	1204	}
	1205
	1206	version (X86_64)
	1207	{
	1208	int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	1209	{
	1210	arg1 = m_arg1;
	1211	arg2 = m_arg2;
	1212	return 0;
1133	1213	}
	1214	TypeInfo m_arg1;
	1215	TypeInfo m_arg2;
	1216	}
	1217	}
1134	1218
1135	1219	class TypeInfo_Tuple : TypeInfo
1136	1220	{
…	…
1197	1281	{
1198	1282	assert(0);
1199	1283	}
	1284
	1285	version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	1286	{
	1287	assert(0);
1200	1288	}
	1289	}
1201	1290
1202	1291
1203	1292	////////////////////////////////////////////////////////////////////////////////
…	…
1476	1565	{ _moduleinfo_array[len] = mr.mod;
1477	1566	len++;
1478	1567	}
	1568
	1569	debug(PRINTF) foreach (m; _moduleinfo_array)
	1570	{
	1571	//printf("\t%p\n", m);
	1572	printf("\t%.*s\n", m.name.length,m.name.ptr);
1479	1573	}
1480	1574
	1575	}
	1576
1481	1577	version( freebsd )
1482	1578	{
1483	1579	int len = 0;
…	…
1552	1648	debug(PRINTF) printf("\tmodule[%d] = '%p'\n", i, m);
1553	1649	if (!m)
1554	1650	continue;
1555		debug(PRINTF) printf("\tmodule[%d] = '%.*s'\n", i, m.name);
	1651	debug(PRINTF) printf("\tmodule[%d].name = '%s'\n", i, m.name);
1556	1652	if (m.flags & MIctordone)
1557	1653	continue;
1558	1654	debug(PRINTF) printf("\tmodule[%d] = '%.*s', m = x%x\n", i, m.name, m);

tango/core/rt/compiler/dmd/std/intrinsic.d

old	new
25	25	* The bit number of the first bit set.
26	26	* The return value is undefined if v is zero.
27	27	*/
28		int bsf( ~~uin~~t v );
	28	int bsf( size_t v );
29	29
30	30
31	31	/**
…	…
133	133	array = [0]:x2, [1]:x100
134	134	</pre>
135	135	*/
	136
136	137	int bts( size_t* p, size_t bitnum );
137	138
138
139	139	/**
140	140	* Swaps bytes in a 4 byte uint end-to-end, i.e. byte 0 becomes
141	141	* byte 3, byte 1 becomes byte 2, byte 2 becomes byte 1, byte 3

tango/core/rt/compiler/dmd/typeinfo/ti_void.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return void.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return void.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_wchar.d

old	new
21	21	return cast(wchar )p1 - cast(wchar )p2;
22	22	}
23	23
	24	override size_t talign()
	25	{
	26	return wchar.alignof;
	27	}
	28
24	29	override size_t tsize()
25	30	{
26	31	return wchar.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_ptr.d

old	new
25	25	return 0;
26	26	}
27	27
	28	override size_t talign()
	29	{
	30	return (void*).alignof;
	31	}
	32
28	33	override size_t tsize()
29	34	{
30	35	return (void*).sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Afloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (float[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (float[]).sizeof;
…	…
90	95	{
91	96	return typeid(float);
92	97	}
	98
	99	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	100	{
	101	return 0;
93	102	}
	103	}
94	104
95	105	// ifloat[]
96	106

tango/core/rt/compiler/dmd/typeinfo/ti_double.d

old	new
43	43	return _compare(cast(double )p1, cast(double )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return double.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return double.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_delegate.d

old	new
18	18	return cast(dg )p1 == cast(dg )p2;
19	19	}
20	20
	21	override size_t talign()
	22	{
	23	return dg.alignof;
	24	}
	25
21	26	override size_t tsize()
22	27	{
23	28	return dg.sizeof;
…	…
36	41	{
37	42	return 1;
38	43	}
	44
	45	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	46	{
	47	arg1 = typeid(void*);
	48	arg2 = typeid(void*);
	49	return 0;
39	50	}
	51	}

tango/core/rt/compiler/dmd/typeinfo/ti_Adouble.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (double[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (double[]).sizeof;
…	…
90	95	{
91	96	return typeid(double);
92	97	}
	98
	99	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	100	{
	101	return 0;
93	102	}
	103	}
94	104
95	105	// idouble[]
96	106

tango/core/rt/compiler/dmd/typeinfo/ti_char.d

old	new
20	20	return cast(char )p1 - cast(char )p2;
21	21	}
22	22
	23	override size_t talign()
	24	{
	25	return char.alignof;
	26	}
	27
23	28	override size_t tsize()
24	29	{
25	30	return char.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Acdouble.d

old	new
75	75	return 0;
76	76	}
77	77
	78	override size_t talign()
	79	{
	80	return (cdouble[]).alignof;
	81	}
	82
78	83	override size_t tsize()
79	84	{
80	85	return (cdouble[]).sizeof;
…	…
89	94	{
90	95	return typeid(cdouble);
91	96	}
	97
	98	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	99	{
	100	return 0;
92	101	}
	102	}

tango/core/rt/compiler/dmd/typeinfo/ti_uint.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return uint.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return uint.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_AC.d

old	new
82	82	return 0;
83	83	}
84	84
	85	override size_t talign()
	86	{
	87	return (Object[]).alignof;
	88	}
	89
85	90	override size_t tsize()
86	91	{
87	92	return (Object[]).sizeof;
…	…
96	101	{
97	102	return typeid(Object);
98	103	}
	104
	105	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	106	{
	107	return 0;
99	108	}
	109	}

tango/core/rt/compiler/dmd/typeinfo/ti_ulong.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return ulong.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return ulong.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_creal.d

old	new
44	44	return _compare(cast(creal )p1, cast(creal )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return creal.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return creal.sizeof;
…	…
63	68
64	69	return (cast(creal *)&r)[0 .. 1];
65	70	}
	71
	72	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	73	{
	74	arg1 = typeid(real);
	75	arg2 = typeid(real);
	76	return 0;
66	77	}
	78	}

tango/core/rt/compiler/dmd/typeinfo/ti_ubyte.d

old	new
22	22	return cast(ubyte )p1 - cast(ubyte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ubyte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ubyte.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Aint.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (int[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (int[]).sizeof;
…	…
61	66	{
62	67	return typeid(int);
63	68	}
	69
	70	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	71	{
	72	return 0;
64	73	}
	74	}
65	75
66	76	unittest
67	77	{

tango/core/rt/compiler/dmd/typeinfo/ti_short.d

old	new
22	22	return cast(short )p1 - cast(short )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return short.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return short.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_long.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return long.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return long.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Along.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (long[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (long[]).sizeof;
…	…
62	67	{
63	68	return typeid(long);
64	69	}
	70
	71	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	72	{
	73	return 0;
65	74	}
	75	}
66	76
67	77
68	78	// ulong[]

tango/core/rt/compiler/dmd/typeinfo/ti_byte.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return byte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return byte.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_float.d

old	new
42	42	return _compare(cast(float )p1, cast(float )p2);
43	43	}
44	44
	45	override size_t talign()
	46	{
	47	return float.alignof;
	48	}
	49
45	50	override size_t tsize()
46	51	{
47	52	return float.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_cfloat.d

old	new
44	44	return _compare(cast(cfloat )p1, cast(cfloat )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cfloat.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cfloat.sizeof;
…	…
63	68
64	69	return (cast(cfloat *)&r)[0 .. 1];
65	70	}
	71
	72	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	73	{
	74	arg1 = typeid(double);
	75	return 0;
66	76	}
	77	}

tango/core/rt/compiler/dmd/typeinfo/ti_Acfloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (cfloat[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (cfloat[]).sizeof;
…	…
90	95	{
91	96	return typeid(cfloat);
92	97	}
	98
	99	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	100	{
	101	return 0;
93	102	}
	103	}

tango/core/rt/compiler/dmd/typeinfo/ti_cdouble.d

old	new
44	44	return _compare(cast(cdouble )p1, cast(cdouble )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cdouble.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cdouble.sizeof;
…	…
63	68
64	69	return (cast(cdouble *)&r)[0 .. 1];
65	70	}
	71
	72	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	73	{
	74	return 0;
66	75	}
	76	}

tango/core/rt/compiler/dmd/typeinfo/ti_dchar.d

old	new
22	22	return cast(dchar )p1 - cast(dchar )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return dchar.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return dchar.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_C.d

old	new
62	62	return c;
63	63	}
64	64
	65	override size_t talign()
	66	{
	67	return Object.alignof;
	68	}
	69
65	70	override size_t tsize()
66	71	{
67	72	return Object.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_real.d

old	new
43	43	return _compare(cast(real )p1, cast(real )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return real.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return real.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Areal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (real[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (real[]).sizeof;
…	…
90	95	{
91	96	return typeid(real);
92	97	}
	98
	99	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	100	{
	101	return 0;
93	102	}
	103	}
94	104
95	105	// ireal[]
96	106

tango/core/rt/compiler/dmd/typeinfo/ti_ushort.d

old	new
22	22	return cast(ushort )p1 - cast(ushort )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ushort.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ushort.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Acreal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (creal[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (creal[]).sizeof;
…	…
90	95	{
91	96	return typeid(creal);
92	97	}
	98
	99	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	100	{
	101	return 0;
93	102	}
	103	}

tango/core/rt/compiler/dmd/typeinfo/ti_Ag.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (byte[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (byte[]).sizeof;
…	…
117	122
118	123	override hash_t getHash(in void* p){
119	124	char[] s = cast(char[])p;
	125
120	126	version (OldHash)
121	127	{
122	128	hash_t hash = 0;
…	…
133	139	{
134	140	return typeid(char);
135	141	}
	142
	143	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	144	{
	145	return 0;
136	146	}
	147	}

tango/core/rt/compiler/dmd/typeinfo/ti_int.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return int.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return int.sizeof;

tango/core/rt/compiler/dmd/typeinfo/ti_Ashort.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (short[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (short[]).sizeof;
…	…
61	66	{
62	67	return typeid(short);
63	68	}
	69
	70	version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
	71	{
	72	arg1 = typeid(size_t);
	73	arg2 = typeid(void*);
	74	return 0;
64	75	}
	76	}
65	77
66	78
67	79	// ushort[]

tango/core/rt/compiler/dmd/posix/deh.d

old	new
64	64	void *fptr; // pointer to start of function
65	65	uint espoffset; // offset of ESP from EBP
66	66	uint retoffset; // offset from start of function to return code
67		~~uin~~t nhandlers; // dimension of handler_info[]
	67	size_t nhandlers; // dimension of handler_info[]
68	68	DHandlerInfo handler_info[1];
69	69	}
70	70
71	71	struct DCatchBlock
72	72	{
73	73	ClassInfo type; // catch type
74		~~uin~~t bpoffset; // EBP offset of catch var
	74	size_t bpoffset; // EBP offset of catch var
75	75	void *code; // catch handler code
76	76	}
77	77
78	78	// Create one of these for each try-catch
79	79	struct DCatchInfo
80	80	{
81		~~uin~~t ncatches; // number of catch blocks
	81	size_t ncatches; // number of catch blocks
82	82	DCatchBlock catch_block[1]; // data for each catch block
83	83	}
84	84
…	…
126	126
127	127	return null;
128	128	}
129
130	129	else
131	130	{
132	131	FuncTable *ft;
…	…
164	163	* caller's EBP
165	164	*/
166	165
167		~~uint __eh_find_caller(uint regbp, uin~~t *pretaddr)
	166	size_t __eh_find_caller(size_t regbp, size_t *pretaddr)
168	167	{
169		~~uint bp = cast(uin~~t )regbp;
	168	size_t bp = cast(size_t )regbp;
170	169
171	170	if (bp) // if not end of call chain
172	171	{
…	…
176	175	// stack should grow to smaller values
177	176	terminate();
178	177
179		pretaddr = cast(~~uint *)(regbp + in~~t.sizeof);
	178	pretaddr = cast(size_t *)(regbp + size_t.sizeof);
180	179	}
181	180	return bp;
182	181	}
…	…
195	194	* Throw a D object.
196	195	*/
197	196
198		extern(C) void _d_throwc(Object *h){
199		uint regebp;
	197	extern(C) void _d_throwc(Object *h)
	198	{
	199	size_t regebp;
200	200
201	201	debug(deh)
202	202	{
…	…
204	204	printf("\tvptr = %p\n", cast(void *)h);
205	205	}
206	206
	207	version (D_InlineAsm_X86)
207	208	asm
208	209	{
209	210	mov regebp,EBP ;
210	211	}
	212	else version (D_InlineAsm_X86_64)
	213	asm
	214	{
	215	mov regebp,RBP ;
	216	}
	217	else
	218	static assert(0);
211	219
212	220	//static uint abc;
213	221	//if (++abc == 2) (char )0=0;
…	…
218	226	DHandlerTable *handler_table;
219	227	FuncTable *pfunc;
220	228	DHandlerInfo *phi;
221		~~uin~~t retaddr;
222		~~uin~~t funcoffset;
	229	size_t retaddr;
	230	size_t funcoffset;
223	231	uint spoff;
224	232	uint retoffset;
225	233	int index;
226		int dim;
	234	size_t dim;
227	235	int ndx;
228	236	int prev_ndx;
229	237
…	…
244	252	debug(deh) printf("no handler table\n");
245	253	continue;
246	254	}
247		funcoffset = cast(~~uin~~t)handler_table.fptr;
	255	funcoffset = cast(size_t)handler_table.fptr;
248	256	spoff = handler_table.espoffset;
249	257	retoffset = handler_table.retoffset;
250	258
…	…
261	269	debug(deh)
262	270	{
263	271	printf("handler_info[]:\n");
264		for (int i = 0; i < dim; i++)
	272	for (size_t i = 0; i < dim; i++)
265	273	{
266	274	phi = handler_table.handler_info.ptr + i;
267	275	printf("\t[%d]: offset = x%04x, endoffset = x%04x, prev_index = %d, cioffset = x%04x, finally_code = %x\n",
…	…
270	278	}
271	279
272	280	index = -1;
273		for (int i = 0; i < dim; i++)
	281	for (size_t i = 0; i < dim; i++)
274	282	{
275	283	phi = handler_table.handler_info.ptr + i;
276	284
277	285	debug(deh) printf("i = %d, phi.offset = %04x\n", i, funcoffset + phi.offset);
278		if (~~cast(uint)~~retaddr > funcoffset + phi.offset &&
279		~~cast(uint)~~retaddr <= funcoffset + phi.endoffset)
	286	if (retaddr > funcoffset + phi.offset &&
	287	retaddr <= funcoffset + phi.endoffset)
280	288	index = i;
281	289	}
282	290	debug(deh) printf("index = %d\n", index);
…	…
287	295	{
288	296	phi = handler_table.handler_info.ptr + ndx;
289	297	prev_ndx = phi.prev_index;
	298
290	299	if (phi.cioffset)
291	300	{
292	301	// this is a catch handler (no finally)
293	302	DCatchInfo *pci;
294		int ncatches;
295		int i;
	303	size_t ncatches;
	304	size_t i;
296	305
297	306	pci = cast(DCatchInfo )(cast(char )handler_table + phi.cioffset);
298	307	ncatches = pci.ncatches;
	308
299	309	for (i = 0; i < ncatches; i++)
300	310	{
301	311	DCatchBlock *pcb;
…	…
311	321
312	322	// Jump to catch block. Does not return.
313	323	{
314		~~uin~~t catch_esp;
	324	size_t catch_esp;
315	325	fp_t catch_addr;
316	326
317	327	catch_addr = cast(fp_t)(pcb.code);
318	328	catch_esp = regebp - handler_table.espoffset - fp_t.sizeof;
	329
	330	version (D_InlineAsm_X86)
319	331	asm
320	332	{
321	333	mov EAX,catch_esp ;
…	…
325	337	mov ESP,EAX ; // reset stack
326	338	ret ; // jump to catch block
327	339	}
	340	else version (D_InlineAsm_X86_64)
	341	asm
	342	{
	343	mov RAX,catch_esp ;
	344	mov RCX,catch_esp ;
	345	mov RCX,catch_addr ;
	346	mov [RAX],RCX ;
	347	mov RBP,regebp ;
	348	mov RSP,RAX ; // reset stack
	349	ret ; // jump to catch block
328	350	}
	351	else
	352	static assert(0);
	353
329	354	}
330	355	}
331	356	}
	357	}
332	358	else if (phi.finally_code)
333	359	{ // Call finally block
334	360	// Note that it is unnecessary to adjust the ESP, as the finally block
…	…
338	364
339	365	version (OSX)
340	366	{
341		asm {
	367	version (D_InlineAsm_X86)
	368	asm
	369	{
342	370	sub ESP,4 ;
343	371	push EBX ;
344	372	mov EBX,blockaddr ;
…	…
349	377	pop EBX ;
350	378	add ESP,4 ;
351	379	}
352		} else {
353		asm {
	380	else version (D_InlineAsm_X86_64)
	381	asm
	382	{
	383	sub RSP,8 ;
	384	push RBX ;
	385	mov RBX,blockaddr ;
	386	push RBP ;
	387	mov RBP,regebp ;
	388	call RBX ;
	389	pop RBP ;
	390	pop RBX ;
	391	add RSP,8 ;
	392	}
	393	else
	394	static assert(0);
	395	}
	396	else
	397	{
	398	version (D_InlineAsm_X86)
	399	asm
	400	{
354	401	push EBX ;
355	402	mov EBX,blockaddr ;
356	403	push EBP ;
…	…
359	406	pop EBP ;
360	407	pop EBX ;
361	408	}
	409	else version (D_InlineAsm_X86_64)
	410	asm
	411	{
	412	sub RSP,8 ;
	413	push RBX ;
	414	mov RBX,blockaddr ;
	415	push RBP ;
	416	mov RBP,regebp ;
	417	call RBX ;
	418	pop RBP ;
	419	pop RBX ;
	420	add RSP,8 ;
362	421	}
	422	else
	423	static assert(0);
363	424	}
364	425	}
365	426	}
366	427	}
	428	}

tango/core/rt/compiler/dmd/posix/llmath.d

old	new
19	19	* [ECX,EBX] = [EDX,EAX] % [ECX,EBX]
20	20	*/
21	21
	22
22	23	void __ULDIV__()
23	24	{
	25	version (D_InlineAsm_X86)
24	26	asm
25	27	{
26	28	naked ;
…	…
178	180	xor EDX,EDX ;
179	181	ret ;
180	182	}
	183	else version (D_InlineAsm_X86_64)
	184	assert(0);
	185	else
	186	static assert(0);
181	187	}
182	188
183	189
…	…
193	199
194	200	void __LDIV__()
195	201	{
	202	version (D_InlineAsm_X86)
196	203	asm
197	204	{
198	205	naked ;
…	…
241	248
242	249	L12: jmp __ULDIV__ ;
243	250	}
	251	else version (D_InlineAsm_X86_64)
	252	assert(0);
	253	else
	254	static assert(0);
244	255	}
245	256
246
247	257	/***************************************
248	258	* Compare [EDX,EAX] with [ECX,EBX]
249	259	* Signed
…	…
252	262
253	263	void __LCMP__()
254	264	{
	265	version (D_InlineAsm_X86)
255	266	asm
256	267	{
257	268	naked ;
…	…
270	281	C2: pop EDX ;
271	282	C1: ret ;
272	283	}
	284	else version (D_InlineAsm_X86_64)
	285	assert(0);
	286	else
	287	static assert(0);
273	288	}
274	289
275
276
277
278	290	// Convert ulong to real
279	291
280	292	private real adjust = cast(real)0x800_0000_0000_0000 * 0x10;
281	293
282	294	real __U64_LDBL()
283	295	{
284		version (OSX) {
	296	version (OSX)
	297	{
	298	version (D_InlineAsm_X86)
285	299	asm
286	300	{ naked ;
287	301	push EDX ;
…	…
300	314	add ESP, 8 ;
301	315	ret ;
302	316	}
303		} else {
	317	else version (D_InlineAsm_X86_64)
	318	static assert(0);
	319	else
	320	static assert(0);
	321	}
	322	else
	323	{
	324	version (D_InlineAsm_X86)
304	325	asm
305	326	{ naked ;
306	327	push EDX ;
…	…
315	336	add ESP, 8 ;
316	337	ret ;
317	338	}
	339	else version (D_InlineAsm_X86_64)
	340	asm
	341	{ naked ;
	342	push RAX ;
	343	and dword ptr 4[RSP], 0x7FFFFFFF ;
	344	fild qword ptr [RSP] ;
	345	test RAX,RAX ;
	346	jns L1 ;
	347	fld real ptr adjust ;
	348	faddp ST(1), ST ;
	349	L1: ;
	350	add RSP, 8 ;
	351	ret ;
318	352	}
	353	else
	354	static assert(0);
319	355	}
	356	}
320	357
321	358	// Same as __U64_LDBL, but return result as double in [EDX,EAX]
322	359	ulong __ULLNGDBL()
323	360	{
	361	version (D_InlineAsm_X86)
324	362	asm
325	363	{ naked ;
326	364	call __U64_LDBL ;
…	…
330	368	pop EDX ;
331	369	ret ;
332	370	}
	371	else version (D_InlineAsm_X86_64)
	372	asm
	373	{ naked ;
	374	call __U64_LDBL ;
	375	sub RSP,8 ;
	376	fstp double ptr [RSP] ;
	377	pop RAX ;
	378	ret ;
333	379	}
	380	else
	381	static assert(0);
	382	}
334	383
	384
335	385	// Convert double to ulong
336	386
337	387	private short roundTo0 = 0xFBF;
…	…
339	389	ulong __DBLULLNG()
340	390	{
341	391	// BUG: should handle NAN's and overflows
342		version (OSX) {
343		asm {
344		naked ;
	392	version (OSX)
	393	{
	394	version (D_InlineAsm_X86)
	395	asm
	396	{ naked ;
345	397	push 0xFBF ; // roundTo0
346	398	push 0x0000403e ;
347	399	push 0x80000000 ;
…	…
374	426	add ESP,24 ;
375	427	ret ;
376	428	}
377		} else {
	429	else version (D_InlineAsm_X86_64)
	430	static assert(0);
	431	else
	432	static assert(0);
	433	}
	434	else
	435	{
	436	version (D_InlineAsm_X86)
378	437	asm
379	438	{ naked ;
380	439	push EDX ;
…	…
405	464	add ESP,8 ;
406	465	ret ;
407	466	}
	467	else version (D_InlineAsm_X86_64)
	468	asm
	469	{ naked ;
	470	push RAX ;
	471	fld double ptr [RSP] ;
	472	sub RSP,8 ;
	473	fld real ptr adjust ;
	474	fcomp ;
	475	fstsw AX ;
	476	fstcw 8[RSP] ;
	477	fldcw roundTo0 ;
	478	sahf ;
	479	jae L1 ;
	480	fld real ptr adjust ;
	481	fsubp ST(1), ST ;
	482	fistp qword ptr [RSP] ;
	483	pop RAX ;
	484	fldcw [RSP] ;
	485	add RSP,8 ;
	486	mov EDX,0x8000_0000 ;
	487	shl RDX,32 ;
	488	add RAX,RDX ;
	489	ret ;
	490	L1: ;
	491	fistp qword ptr [RSP] ;
	492	pop RAX ;
	493	fldcw [RSP] ;
	494	add RSP,8 ;
	495	ret ;
408	496	}
	497	else
	498	static assert(0);
409	499	}
	500	}
410	501
411	502	// Convert double in ST0 to uint
412	503
413	504	uint __DBLULNG()
414	505	{
415	506	// BUG: should handle NAN's and overflows
416		version (OSX) {
417		asm {
418		naked ;
	507	version (OSX)
	508	{
	509	version (D_InlineAsm_X86)
	510	asm
	511	{ naked ;
419	512	push 0xFBF ; // roundTo0
420	513	sub ESP,12 ;
421	514	fstcw 8[ESP] ;
…	…
426	519	add ESP,12 ;
427	520	ret ;
428	521	}
429		} else {
430		asm {
431		naked ;
	522	else version (D_InlineAsm_X86_64)
	523	assert(0);
	524	else
	525	static assert(0);
	526	}
	527	else
	528	{
	529	version (D_InlineAsm_X86)
	530	asm
	531	{ naked ;
432	532	sub ESP,16 ;
433	533	fstcw 8[ESP] ;
434	534	fldcw roundTo0 ;
…	…
438	538	add ESP,12 ;
439	539	ret ;
440	540	}
	541	else version (D_InlineAsm_X86_64)
	542	asm
	543	{ naked ;
	544	sub RSP,16 ;
	545	fstcw 8[RSP] ;
	546	fldcw roundTo0 ;
	547	fistp qword ptr [RSP] ;
	548	fldcw 8[RSP] ;
	549	pop RAX ;
	550	add RSP,8 ;
	551	ret ;
441	552	}
	553	else
	554	static assert(0);
442	555	}
	556	}
443	557
444
445	558	// Convert real in ST0 to ulong
446	559
447	560	ulong __LDBLULLNG()
448	561	{
449	562	version (OSX)
450	563	{
	564	version (D_InlineAsm_X86)
451	565	asm
452	566	{ naked ;
453	567	push 0xFBF ; // roundTo0
…	…
479	593	add ESP,24 ;
480	594	ret ;
481	595	}
	596	else version (D_InlineAsm_X86_64)
	597	static assert(0);
	598	else
	599	static assert(0);
482	600	}
483	601	else
484	602	{
	603	version (D_InlineAsm_X86)
485	604	asm
486	605	{ naked ;
487	606	sub ESP,16 ;
…	…
509	628	add ESP,8 ;
510	629	ret ;
511	630	}
	631	else version (D_InlineAsm_X86_64)
	632	asm
	633	{ naked ;
	634	sub RSP,16 ;
	635	fld real ptr adjust ;
	636	fcomp ;
	637	fstsw AX ;
	638	fstcw 8[RSP] ;
	639	fldcw roundTo0 ;
	640	sahf ;
	641	jae L1 ;
	642	fld real ptr adjust ;
	643	fsubp ST(1), ST ;
	644	fistp qword ptr [RSP] ;
	645	pop RAX ;
	646	fldcw [RSP] ;
	647	add RSP,8 ;
	648	mov RCX,0x8000_0000 ;
	649	shl RCX,32 ;
	650	add RAX,RCX ;
	651	ret ;
	652	L1: ;
	653	fistp qword ptr [RSP] ;
	654	pop RAX ;
	655	fldcw [RSP] ;
	656	add RSP,8 ;
	657	ret ;
512	658	}
	659	else
	660	static assert(0);
513	661	}
514
	662	}

tango/core/rt/compiler/gdc/object_.d

old	new
413	413	/// Compares two instances for <, ==, or >.
414	414	int compare(in void* p1, in void* p2) { return 0; } // throw new Exception("non comparable",__FILE__,__LINE__);
415	415
	416	/// Return alignment of type
	417	size_t talign() { return tsize(); }
	418
416	419	/// Returns size of the type.
417	420	size_t tsize() { return 0; }
418	421

tango/core/rt/compiler/gdc/typeinfo/ti_void.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return void.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return void.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_wchar.d

old	new
21	21	return cast(wchar )p1 - cast(wchar )p2;
22	22	}
23	23
	24	override size_t talign()
	25	{
	26	return wchar.alignof;
	27	}
	28
24	29	override size_t tsize()
25	30	{
26	31	return wchar.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_ptr.d

old	new
25	25	return 0;
26	26	}
27	27
	28	override size_t talign()
	29	{
	30	return (void*).alignof;
	31	}
	32
28	33	override size_t tsize()
29	34	{
30	35	return (void*).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Afloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (float[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (float[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_double.d

old	new
43	43	return _compare(cast(double )p1, cast(double )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return double.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return double.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_delegate.d

old	new
18	18	return cast(dg )p1 == cast(dg )p2;
19	19	}
20	20
	21	override size_t talign()
	22	{
	23	return dg.alignof;
	24	}
	25
21	26	override size_t tsize()
22	27	{
23	28	return dg.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Adouble.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (double[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (double[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_char.d

old	new
20	20	return cast(char )p1 - cast(char )p2;
21	21	}
22	22
	23	override size_t talign()
	24	{
	25	return char.alignof;
	26	}
	27
23	28	override size_t tsize()
24	29	{
25	30	return char.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Acdouble.d

old	new
75	75	return 0;
76	76	}
77	77
	78	override size_t talign()
	79	{
	80	return (cdouble[]).alignof;
	81	}
	82
78	83	override size_t tsize()
79	84	{
80	85	return (cdouble[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_uint.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return uint.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return uint.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_AC.d

old	new
82	82	return 0;
83	83	}
84	84
	85	override size_t talign()
	86	{
	87	return (Object[]).alignof;
	88	}
	89
85	90	override size_t tsize()
86	91	{
87	92	return (Object[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_ulong.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return ulong.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return ulong.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_creal.d

old	new
44	44	return _compare(cast(creal )p1, cast(creal )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return creal.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return creal.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_ubyte.d

old	new
22	22	return cast(ubyte )p1 - cast(ubyte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ubyte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ubyte.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Aint.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (int[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (int[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_short.d

old	new
22	22	return cast(short )p1 - cast(short )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return short.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return short.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_long.d

old	new
31	31	return 0;
32	32	}
33	33
	34	override size_t talign()
	35	{
	36	return long.alignof;
	37	}
	38
34	39	override size_t tsize()
35	40	{
36	41	return long.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Along.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (long[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (long[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_byte.d

old	new
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return byte.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return byte.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_float.d

old	new
42	42	return _compare(cast(float )p1, cast(float )p2);
43	43	}
44	44
	45	override size_t talign()
	46	{
	47	return float.alignof;
	48	}
	49
45	50	override size_t tsize()
46	51	{
47	52	return float.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_cfloat.d

old	new
44	44	return _compare(cast(cfloat )p1, cast(cfloat )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cfloat.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cfloat.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Acfloat.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (cfloat[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (cfloat[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_cdouble.d

old	new
44	44	return _compare(cast(cdouble )p1, cast(cdouble )p2);
45	45	}
46	46
	47	override size_t talign()
	48	{
	49	return cdouble.alignof;
	50	}
	51
47	52	override size_t tsize()
48	53	{
49	54	return cdouble.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_dchar.d

old	new
22	22	return cast(dchar )p1 - cast(dchar )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return dchar.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return dchar.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_C.d

old	new
62	62	return c;
63	63	}
64	64
	65	override size_t talign()
	66	{
	67	return Object.alignof;
	68	}
	69
65	70	override size_t tsize()
66	71	{
67	72	return Object.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_real.d

old	new
43	43	return _compare(cast(real )p1, cast(real )p2);
44	44	}
45	45
	46	override size_t talign()
	47	{
	48	return real.alignof;
	49	}
	50
46	51	override size_t tsize()
47	52	{
48	53	return real.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Areal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (real[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (real[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_ushort.d

old	new
22	22	return cast(ushort )p1 - cast(ushort )p2;
23	23	}
24	24
	25	override size_t talign()
	26	{
	27	return ushort.alignof;
	28	}
	29
25	30	override size_t tsize()
26	31	{
27	32	return ushort.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Acreal.d

old	new
76	76	return 0;
77	77	}
78	78
	79	override size_t talign()
	80	{
	81	return (creal[]).alignof;
	82	}
	83
79	84	override size_t tsize()
80	85	{
81	86	return (creal[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Ag.d

old	new
48	48	return 0;
49	49	}
50	50
	51	override size_t talign()
	52	{
	53	return (byte[]).alignof;
	54	}
	55
51	56	override size_t tsize()
52	57	{
53	58	return (byte[]).sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_int.d

old	new
26	26	return 0;
27	27	}
28	28
	29	override size_t talign()
	30	{
	31	return int.alignof;
	32	}
	33
29	34	override size_t tsize()
30	35	{
31	36	return int.sizeof;

tango/core/rt/compiler/gdc/typeinfo/ti_Ashort.d

old	new
47	47	return 0;
48	48	}
49	49
	50	override size_t talign()
	51	{
	52	return (short[]).alignof;
	53	}
	54
50	55	override size_t tsize()
51	56	{
52	57	return (short[]).sizeof;

tango/core/rt/compiler/util/utf.d

old	new
884	884	w = toUTF16(d);
885	885	assert(w == "hello");
886	886
	887	debug(utf) printf("utf.toUTF.unittest\n");
887	888
888	889	c = "hel\u1234o";
889	890	w = toUTF16(c);
…	…
901	902	w = toUTF16(d);
902	903	assert(w == "hel\u1234o");
903	904
	905	debug(utf) printf("utf.toUTF.unittest\n");
904	906
905	907	c = "he\U0010AAAAllo";
906	908	w = toUTF16(c);

tango/core/Variant.d

old	new
8	8	module tango.core.Variant;
9	9
10	10	private import tango.core.Memory : GC;
11		private import tango.core.Vararg ~~: va_list~~;
	11	private import tango.core.Vararg;
12	12	private import tango.core.Traits;
13	13	private import tango.core.Tuple;
14	14
…	…
37	37	version=EnableVararg;
38	38	}
39	39	}
	40	version( X86_64 )
	41	{
	42	version( Windows )
	43	{
	44	version=EnableVararg;
40	45	}
	46	else version( Posix )
	47	{
	48	version=EnableVararg;
	49	}
	50
	51	import tango.math.Math : max;
	52
	53	}
	54	}
41	55	else version( LDC )
42	56	{
43	57	version( X86 )
…	…
750	764	auto vs = new Variant[](types.length);
751	765
752	766	foreach( i, ref v ; vs )
	767	{
	768	version(X86_64)
	769	{
	770	scope void[] buffer;
	771	uint len = 0;
	772
	773	foreach(argType; types)
	774	len = max(len,(argType.tsize + size_t.sizeof - 1) & ~ (size_t.sizeof - 1));
	775
	776	buffer.length = len;
	777
	778	va_arg(args, types[i], buffer.ptr);
	779
	780	Variant.fromPtr(types[i], buffer.ptr, v);
	781	}
	782	else
753	783	args = Variant.fromPtr(types[i], args, v);
	784	}
754	785
755	786	return vs;
756	787	}
…	…
758	789	/// ditto
759	790	static Variant[] fromVararg(...)
760	791	{
	792	version(X86_64)
	793	{
	794	va_list ap;
	795	va_start(ap, __va_argsave);
	796
	797	scope (exit) va_end(ap);
	798
	799	return Variant.fromVararg(_arguments, ap);
	800	}
	801	else
761	802	return Variant.fromVararg(_arguments, _argptr);
762	803	}
763	804
…	…
767	808	* This will allocate memory to store the arguments in; you may destroy
768	809	* this memory when you are done with it if you feel so inclined.
769	810	*/
770		static void toVararg(Variant[] vars, out TypeInfo[] types, out va_list args)
	811	deprecated static void toVararg(Variant[] vars, out TypeInfo[] types, out va_list args)
771	812	{
772	813	// First up, compute the total amount of space we'll need. While
773	814	// we're at it, work out if any of the values we're storing have
…	…
1239	1280
1240	1281	Variant[] scoop(...)
1241	1282	{
	1283	version(X86_64)
	1284	{
	1285	va_list ap;
	1286	va_start(ap, __va_argsave);
	1287
	1288	scope (exit) va_end(ap);
	1289
	1290	return Variant.fromVararg(_arguments, ap);
	1291	}
	1292
1242	1293	return Variant.fromVararg(_arguments, _argptr);
1243	1294	}
1244	1295
…	…
1281	1332	assert( vs[0xb].get!(typeof(va_b)).name == "phil" );
1282	1333	assert( vs[0xc].get!(typeof(va_c)).name == "phil" );
1283	1334
	1335	version (none) version(X86) // TODO toVararg won't work in x86_64 as it is now
1284	1336	{
1285	1337	TypeInfo[] types;
1286	1338	void* args;

tango/core/Thread.d

old	new
348	348	{
349	349	__builtin_unwind_init();
350	350	}
	351	else version ( D_InlineAsm_X86_64 )
	352	{
	353	asm
	354	{
	355	// Not sure what goes here, pushad is invalid in 64 bit code
	356	push RAX ;
	357	push RBX ;
	358	push RCX ;
	359	push RDX ;
	360	push RSI ;
	361	push RDI ;
	362	push RBP ;
	363	push R8 ;
	364	push R9 ;
	365	push R10 ;
	366	push R11 ;
	367	push R12 ;
	368	push R13 ;
	369	push R14 ;
	370	push R15 ;
	371	push EAX ; // 16 byte align the stack
	372	}
	373	}
351	374	else
352	375	{
353	376	static assert( false, "Architecture not supported." );
…	…
411	434	{
412	435	// registers will be popped automatically
413	436	}
	437	else version ( D_InlineAsm_X86_64 )
	438	{
	439	asm
	440	{
	441	// Not sure what goes here, popad is invalid in 64 bit code
	442	pop EAX ; // 16 byte align the stack
	443	pop R15 ;
	444	pop R14 ;
	445	pop R13 ;
	446	pop R12 ;
	447	pop R11 ;
	448	pop R10 ;
	449	pop R9 ;
	450	pop R8 ;
	451	pop RBP ;
	452	pop RDI ;
	453	pop RSI ;
	454	pop RDX ;
	455	pop RCX ;
	456	pop RBX ;
	457	pop RAX ;
	458	}
	459	}
414	460	else
415	461	{
416	462	static assert( false, "Architecture not supported." );
…	…
2670	2716	}
2671	2717	else version( AsmX86_64_Posix )
2672	2718	{
2673		asm
	2719	version( DigitalMars ) asm
2674	2720	{
2675	2721	naked;
2676	2722
2677	2723	// save current stack state
	2724	push RBP;
	2725	mov RBP, RSP;
	2726	push RBX;
	2727	push R12;
	2728	push R13;
	2729	push R14;
	2730	push R15;
	2731	sub RSP, 4;
	2732	stmxcsr [RSP];
	2733	sub RSP, 4;
	2734	//version(SynchroFloatExcept){
	2735	fstcw [RSP];
	2736	fwait;
	2737	//} else {
	2738	// fnstcw [RSP];
	2739	// fnclex;
	2740	//}
	2741
	2742	// store oldp again with more accurate address
	2743	mov [RDI], RSP;
	2744	// load newp to begin context switch
	2745	mov RSP, RSI;
	2746
	2747	// load saved state from new stack
	2748	fldcw [RSP];
	2749	add RSP, 4;
	2750	ldmxcsr [RSP];
	2751	add RSP, 4;
	2752	pop R15;
	2753	pop R14;
	2754	pop R13;
	2755	pop R12;
	2756
	2757	pop RBX;
	2758	pop RBP;
	2759
	2760	// 'return' to complete switch
	2761	ret;
	2762
	2763	}
	2764	else asm
	2765	{
	2766	naked;
	2767
	2768	// save current stack state
2678	2769	pushq RBP;
2679	2770	mov RBP, RSP;
2680	2771	pushq RBX;

tango/core/vendor/std/intrinsic.di

old	new
25	25	* The bit number of the first bit set.
26	26	* The return value is undefined if v is zero.
27	27	*/
28		int bsf( ~~uin~~t v );
	28	int bsf( size_t v );
29	29
30	30
31	31	/**

tango/core/tools/StackTrace.d

old	new
72	72	/// Builds a backtrace of addresses, the addresses are addresses of the next instruction,
73	73	/// return addresses, the most likely the calling instruction is the one before them
74	74	/// (stack top excluded.)
75		extern(C) size_t rt_addrBacktrace(TraceContext* context, TraceContext contextOut,size_ttraceBuf,size_t bufLength,int *flags){
76		if (addrBacktraceFnc !is null){
	75	extern(C) size_t rt_addrBacktrace(TraceContext* context, TraceContext contextOut,size_ttraceBuf,size_t bufLength,int *flags)
	76	{
	77	if (addrBacktraceFnc !is null)
77	78	return addrBacktraceFnc(context,contextOut,traceBuf,bufLength,flags);
78		~~} else {~~
	79	else
79	80	return 0;
80	81	}
81		}
82	82
83	83	/// Tries to sybolize a frame information, this should try to build the best
84	84	/// backtrace information, if possible finding the calling context, thus
…	…
141	141	}
142	142
143	143	/// Basic class that represents a stacktrace.
144		class BasicTraceInfo: Exception.TraceInfo{
	144	class BasicTraceInfo: Exception.TraceInfo
	145	{
145	146	size_t[] traceAddresses;
146	147	size_t[128] traceBuf;
147	148	AddrPrecision addrPrecision;
…	…
159	160	this.addrPrecision=addrPrecision;
160	161	}
161	162	/// Takes a stacktrace.
162		void trace(TraceContext *contextIn=null,int skipFrames=0){
	163	void trace(TraceContext *contextIn=null,int skipFrames=0)
	164	{
163	165	int flags;
164	166	size_t nFrames=rt_addrBacktrace(contextIn,&context,traceBuf.ptr,traceBuf.length,&flags);
165	167	traceAddresses=traceBuf[skipFrames..nFrames];
…	…
211	213	extern(C)int backtrace(void**,int);
212	214	}
213	215
	216
	217
214	218	/// Default (tango given) backtrace function.
215	219	size_t defaultAddrBacktrace(TraceContext* context,TraceContext*contextOut,
216		size_ttraceBuf,size_t length,intflags){
217		version(LibCBacktrace){
	220	size_ttraceBuf,size_t length,intflags)
	221	{
	222	version(LibCBacktrace)
	223	{
218	224	//if (context!is null) return 0; // now it just gives a local trace, uncomment & skip?
219	225	*flags=AddrPrecision.TopExact;
220	226	return cast(size_t)backtrace(cast(void**)traceBuf,length);
221		} else version (Windows){
	227	}
	228	else version (Windows)
	229	{
222	230	return winAddrBacktrace(context,contextOut,traceBuf,length,flags);
223		} else {
	231	}
	232	else
	233	{
224	234	return 0;
225	235	}
226	236	}
…	…
308	318	}
309	319
310	320	/// Function that generates a trace (handler compatible with old TraceInfo.)
311		Exception.TraceInfo basicTracer( void* ptr = null ){
	321	Exception.TraceInfo basicTracer( void* ptr = null )
	322	{
312	323	BasicTraceInfo res;
313		try{
314		version(CatchRecursiveTracing){
	324	try
	325	{
	326	version(CatchRecursiveTracing)
	327	{
315	328	recursiveStackTraces.val=recursiveStackTraces.val+1;
316	329	scope(exit) recursiveStackTraces.val=recursiveStackTraces.val-1;
317	330	// printf("tracer %d\n",recursiveStackTraces.val);
318		if (recursiveStackTraces.val>10) {
	331	if (recursiveStackTraces.val>10)
	332	{
319	333	Runtime.console.stderr("hit maximum recursive tracing (tracer asserting...?)\n");
320	334	abort();
321	335	return null;
…	…
323	337	}
324	338	res=new BasicTraceInfo();
325	339	res.trace(cast(TraceContext*)ptr);
326		} catch (Exception e){
	340	}
	341	catch (Exception e)
	342	{
327	343	Runtime.console.stderr("tracer got exception:\n");
328	344	Runtime.console.stderr(e.msg);
329	345	e.writeOut((char[]s){ Runtime.console.stderr(s); });
330	346	Runtime.console.stderr("\n");
331		} catch (Object o){
	347	}
	348	catch (Object o)
	349	{
332	350	Runtime.console.stderr("tracer got object exception:\n");
333	351	Runtime.console.stderr(o.toString());
334	352	Runtime.console.stderr("\n");

tango/core/Vararg.d

old	new
21	21	}
22	22	else
23	23	{
24		/**
25		* The base vararg list type.
26		*/
	24	version (X86)
	25	{
27	26	alias void* va_list;
28	27
29
30		/**
31		* This function initializes the supplied argument pointer for subsequent
32		* use by va_arg and va_end.
33		*
34		* Params:
35		* ap = The argument pointer to initialize.
36		* paramn = The identifier of the rightmost parameter in the function
37		* parameter list.
38		*/
39		void va_start(T) ( out va_list ap, ref T parmn )
	28	template va_arg(T)
40	29	{
41		ap = cast(va_list) ( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
42		}
43
44		/**
45		* This function returns the next argument in the sequence referenced by
46		* the supplied argument pointer. The argument pointer will be adjusted
47		* to point to the next arggument in the sequence.
48		*
49		* Params:
50		* ap = The argument pointer.
51		*
52		* Returns:
53		* The next argument in the sequence. The result is undefined if ap
54		* does not point to a valid argument.
55		*/
56		T va_arg(T) ( ref va_list ap )
	30	T va_arg(ref va_list _argptr)
57	31	{
58		~~T arg = cast(T) ap~~;
59		~~ap = cast(va_list) ( cast(void*) ap + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) )~~ );
	32	T arg = cast(T)_argptr;
	33	_argptr = _argptr + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1));
60	34	return arg;
61	35	}
62
63		/**
64		* This function cleans up any resources allocated by va_start. It is
65		* currently a no-op and exists mostly for syntax compatibility with
66		* the variadric argument functions for C.
67		*
68		* Params:
69		* ap = The argument pointer.
70		*/
71		~~void va_end( va_list ap )~~
72		{
73
74	36	}
75
76
77		/**
78		* This function copied the argument pointer src to dst.
79		*
80		* Params:
81		* src = The source pointer.
82		* dst = The destination pointer.
83		*/
84		void va_copy( out va_list dst, va_list src )
	37	}
	38	else
85	39	{
86		~~dst = src~~;
	40	public import tango.stdc.stdarg;
87	41	}
88	42	}

tango/core/sync/Atomic.d

old	new
245	245	return oldval;
246	246	}
247	247	} else version(D_InlineAsm_X86) {
248		T atomicSwap( T )( ~~inout~~ T val, T newval )
	248	T atomicSwap( T )( ref T val, T newval )
249	249	in {
250	250	// NOTE: 32 bit x86 systems support 8 byte CAS, which only requires
251	251	// 4 byte alignment, so use size_t as the align type here.
…	…
289	289	}
290	290	}
291	291	} else version (D_InlineAsm_X86_64){
292		T atomicSwap( T )( ~~inout~~ T val, T newval )
	292	T atomicSwap( T )( ref T val, T newval )
293	293	in {
294	294	assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) );
295	295	} body {
…	…
332	332	}
333	333	}
334	334	} else {
335		T atomicSwap( T )( ~~inout~~ T val, T newval )
	335	T atomicSwap( T )( ref T val, T newval )
336	336	in {
337	337	assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) );
338	338	} body {

tango/stdc/posix/netinet/in_.d

old	new
410	410	extern (D) int IN6_IS_ADDR_MULTICAST( in6_addr* addr )
411	411	{
412	412	version(BigEndian)
413		return ~~addr.s6_addr32[0] & 0xff000000~~ == 0xff000000;
	413	return (addr.s6_addr32[0] & 0xff000000) == 0xff000000;
414	414	else
415		return ~~addr.s6_addr32[0] & 0x000000ff~~ == 0x000000ff;
	415	return (addr.s6_addr32[0] & 0x000000ff) == 0x000000ff;
416	416	}
417	417
418	418	extern (D) int IN6_IS_ADDR_LINKLOCAL( in6_addr* addr )
419	419	{
420	420	version(BigEndian)
421		return ~~addr.s6_addr32[0] & 0xffc00000~~ == 0xfe800000;
	421	return (addr.s6_addr32[0] & 0xffc00000) == 0xfe800000;
422	422	else
423		return ~~addr.s6_addr32[0] & 0x0000c0ff~~ == 0x000080fe;
	423	return (addr.s6_addr32[0] & 0x0000c0ff) == 0x000080fe;
424	424	}
425	425
426	426	extern (D) int IN6_IS_ADDR_SITELOCAL( in6_addr* addr )
427	427	{
428	428	version(BigEndian)
429		return ~~addr.s6_addr32[0] & 0xffc00000~~ == 0xfec00000;
	429	return (addr.s6_addr32[0] & 0xffc00000) == 0xfec00000;
430	430	else
431		return ~~addr.s6_addr32[0] & 0x0000c0ff~~ == 0x0000c0fe;
	431	return (addr.s6_addr32[0] & 0x0000c0ff) == 0x0000c0fe;
432	432	}
433	433
434	434	extern (D) int IN6_IS_ADDR_V4MAPPED( in6_addr* addr )
…	…
456	456	extern (D) int IN6_IS_ADDR_MC_NODELOCAL( in6_addr* addr )
457	457	{
458	458	version(BigEndian)
459		return ~~addr.s6_addr32[0] & 0xff0f0000~~ == 0xff010000;
	459	return (addr.s6_addr32[0] & 0xff0f0000) == 0xff010000;
460	460	else
461		return ~~addr.s6_addr32[0] & 0x00000fff~~ == 0x000001ff;
	461	return (addr.s6_addr32[0] & 0x00000fff) == 0x000001ff;
462	462	}
463	463
464	464	extern (D) int IN6_IS_ADDR_MC_LINKLOCAL( in6_addr* addr )
465	465	{
466	466	version(BigEndian)
467		return ~~addr.s6_addr32[0] & 0xff0f0000~~ == 0xff020000;
	467	return (addr.s6_addr32[0] & 0xff0f0000) == 0xff020000;
468	468	else
469		return ~~addr.s6_addr32[0] & 0x00000fff~~ == 0x000002ff;
	469	return (addr.s6_addr32[0] & 0x00000fff) == 0x000002ff;
470	470	}
471	471
472	472	extern (D) int IN6_IS_ADDR_MC_SITELOCAL( in6_addr* addr )
473	473	{
474	474	version(BigEndian)
475		return ~~addr.s6_addr32[0] & 0xff0f0000~~ == 0xff050000;
	475	return (addr.s6_addr32[0] & 0xff0f0000) == 0xff050000;
476	476	else
477		return ~~addr.s6_addr32[0] & 0x00000fff~~ == 0x000005ff;
	477	return (addr.s6_addr32[0] & 0x00000fff) == 0x000005ff;
478	478	}
479	479
480	480	extern (D) int IN6_IS_ADDR_MC_ORGLOCAL( in6_addr* addr )
481	481	{
482	482	version(BigEndian)
483		return ~~addr.s6_addr32[0] & 0xff0f0000~~ == 0xff080000;
	483	return (addr.s6_addr32[0] & 0xff0f0000) == 0xff080000;
484	484	else
485		return ~~addr.s6_addr32[0] & 0x00000fff~~ == 0x000008ff;
	485	return (addr.s6_addr32[0] & 0x00000fff) == 0x000008ff;
486	486	}
487	487
488	488	extern (D) int IN6_IS_ADDR_MC_GLOBAL( in6_addr* addr )
489	489	{
490	490	version(BigEndian)
491		return ~~addr.s6_addr32[0] & 0xff0f0000~~ == 0xff0e0000;
	491	return (addr.s6_addr32[0] & 0xff0f0000) == 0xff0e0000;
492	492	else
493		return ~~addr.s6_addr32[0] & 0x00000fff~~ == 0x00000eff;
	493	return (addr.s6_addr32[0] & 0x00000fff) == 0x00000eff;
494	494	}
495	495	}
496	496

tango/stdc/stdarg.d

old	new
9	9	module tango.stdc.stdarg;
10	10
11	11
	12	debug(PRINTF) import tango.stdc.stdio: printf;
	13
	14
12	15	version( GNU )
13	16	{
14	17	public import std.c.stdarg;
…	…
19	22	}
20	23	else
21	24	{
	25	version (X86)
	26	{
	27	/*********************
	28	* The argument pointer type.
	29	*/
22	30	alias void* va_list;
23	31
24		template va_start( T )
	32	/**********
	33	* Initialize ap.
	34	* For 32 bit code, parmn should be the last named parameter.
	35	* For 64 bit code, parmn should be __va_argsave.
	36	*/
	37	void va_start(T)(out va_list ap, ref T parmn)
25	38	{
26		~~void va_start( out va_list ap, ref T parmn )~~
27		{
28	39	ap = cast(va_list) ( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
29	40	}
30		}
31	41
32		template va_arg( T )
	42	/************
	43	* Retrieve and return the next value that is type T.
	44	* Should use the other va_arg instead, as this won't work for 64 bit code.
	45	*/
	46	T va_arg(T)(ref va_list ap)
33	47	{
34		~~T va_arg( ref va_list ap )~~
35		{
36	48	T arg = cast(T) ap;
37	49	ap = cast(va_list) ( cast(void*) ap + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
38	50	return arg;
39	51	}
	52
	53	/************
	54	* Retrieve and return the next value that is type T.
	55	* This is the preferred version.
	56	*/
	57	void va_arg(T)(ref va_list ap, ref T parmn)
	58	{
	59	parmn = cast(T)ap;
	60	ap = cast(va_list)(cast(void*)ap + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1)));
40	61	}
41	62
	63	/*************
	64	* Retrieve and store through parmn the next value that is of TypeInfo ti.
	65	* Used when the static type is not known.
	66	*/
	67	void va_arg()(ref va_list ap, TypeInfo ti, void* parmn)
	68	{
	69	// Wait until everyone updates to get TypeInfo.talign()
	70	//auto talign = ti.talign();
	71	//auto p = cast(void*)(cast(size_t)ap + talign - 1) & ~(talign - 1);
	72	auto p = ap;
	73	auto tsize = ti.tsize();
	74	ap = cast(void*)(cast(size_t)p + ((tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
	75	parmn[0..tsize] = p[0..tsize];
	76	}
	77
	78	/***********************
	79	* End use of ap.
	80	*/
42	81	void va_end( va_list ap )
43	82	{
	83	}
44	84
	85	void va_copy(out va_list dest, va_list src)
	86	{
	87	dest = src;
45	88	}
	89	}
	90	else version (X86_64)
	91	{
	92	// Layout of this struct must match __gnuc_va_list for C ABI compatibility
	93	struct __va_list
	94	{
	95	uint offset_regs = 6 * 8; // no regs
	96	uint offset_fpregs = 6 * 8 + 8 * 16; // no fp regs
	97	void* stack_args;
	98	void* reg_args;
	99	}
46	100
	101	struct __va_argsave_t
	102	{
	103	size_t[6] regs; // RDI,RSI,RDX,RCX,R8,R9
	104	real[8] fpregs; // XMM0..XMM7
	105	__va_list va;
	106	}
	107
	108	/*
	109	* Making it an array of 1 causes va_list to be passed as a pointer in
	110	* function argument lists
	111	*/
	112	alias void* va_list;
	113
	114	void va_start(T)(out va_list ap, ref T parmn)
	115	{
	116	ap = &parmn.va;
	117	}
	118
	119	T va_arg(T)(va_list ap)
	120	{ T a;
	121	va_arg(ap, a);
	122	return a;
	123	}
	124
	125	void va_arg(T)(va_list apx, ref T parmn)
	126	{
	127	debug(PRINTF) printf("va_arg(T) called\n");
	128	__va_list* ap = cast(__va_list*)apx;
	129	static if (is(T U == __argTypes))
	130	{
	131	static if (U.length == 0 \|\| T.sizeof > 16 \|\| U[0].sizeof > 8)
	132	{ // Always passed in memory
	133	// The arg may have more strict alignment than the stack
	134	auto p = (cast(size_t)ap.stack_args + T.alignof - 1) & ~(T.alignof - 1);
	135	ap.stack_args = cast(void*)(p + ((T.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
	136	parmn = cast(T)p;
	137	}
	138	else static if (U.length == 1)
	139	{ // Arg is passed in one register
	140	alias U[0] T1;
	141	static if (is(T1 == double) \|\| is(T1 == float))
	142	{ // Passed in XMM register
	143	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	144	{
	145	parmn = cast(T)(ap.reg_args + ap.offset_fpregs);
	146	ap.offset_fpregs += 16;
	147	}
	148	else
	149	{
	150	parmn = cast(T)ap.stack_args;
	151	ap.stack_args += (T1.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	152	}
	153	}
	154	else
	155	{ // Passed in regular register
	156	if (ap.offset_regs < 6 * 8 && T.sizeof <= 8)
	157	{
	158	parmn = cast(T)(ap.reg_args + ap.offset_regs);
	159	ap.offset_regs += 8;
	160	}
	161	else
	162	{
	163	auto p = (cast(size_t)ap.stack_args + T.alignof - 1) & ~(T.alignof - 1);
	164	ap.stack_args = cast(void*)(p + ((T.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
	165	parmn = cast(T)p;
	166	}
	167	}
	168	}
	169	else static if (U.length == 2)
	170	{ // Arg is passed in two registers
	171	alias U[0] T1;
	172	alias U[1] T2;
	173
	174	static if (is(T1 == double) \|\| is(T1 == float))
	175	{
	176	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	177	{
	178	cast(T1)&parmn = cast(T1)(ap.reg_args + ap.offset_fpregs);
	179	ap.offset_fpregs += 16;
	180	}
	181	else
	182	{
	183	cast(T1)&parmn = cast(T1)ap.stack_args;
	184	ap.stack_args += (T1.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	185	}
	186	}
	187	else
	188	{
	189	if (ap.offset_regs < 6 * 8 && T1.sizeof <= 8)
	190	{
	191	cast(T1)&parmn = cast(T1)(ap.reg_args + ap.offset_regs);
	192	ap.offset_regs += 8;
	193	}
	194	else
	195	{
	196	cast(T1)&parmn = cast(T1)ap.stack_args;
	197	ap.stack_args += 8;
	198	}
	199	}
	200
	201	auto p = cast(void*)&parmn + 8;
	202	static if (is(T2 == double) \|\| is(T2 == float))
	203	{
	204	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	205	{
	206	cast(T2)p = cast(T2)(ap.reg_args + ap.offset_fpregs);
	207	ap.offset_fpregs += 16;
	208	}
	209	else
	210	{
	211	cast(T2)p = cast(T2)ap.stack_args;
	212	ap.stack_args += (T2.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	213	}
	214	}
	215	else
	216	{
	217	void* a = void;
	218	if (ap.offset_regs < 6 * 8 && T2.sizeof <= 8)
	219	{
	220	a = ap.reg_args + ap.offset_regs;
	221	ap.offset_regs += 8;
	222	}
	223	else
	224	{
	225	a = ap.stack_args;
	226	ap.stack_args += 8;
	227	}
	228	// Be careful not to go past the size of the actual argument
	229	const sz2 = T.sizeof - 8;
	230	p[0..sz2] = a[0..sz2];
	231	}
	232	}
	233	else
	234	{
	235	static assert(0);
	236	}
	237	}
	238	else
	239	{
	240	static assert(0, "not a valid argument type for va_arg");
	241	}
	242	}
	243
	244	void va_arg()(va_list apx, TypeInfo ti, void* parmn)
	245	{
	246	__va_list* ap = cast(__va_list*)apx;
	247	TypeInfo arg1, arg2;
	248	if (!ti.argTypes(arg1, arg2))
	249	{
	250	if (arg1 && arg1.tsize() <= 8)
	251	{
	252	// Arg is passed in one register
	253	auto tsize = arg1.tsize();
	254	void* p;
	255	auto s = arg1.toString();
	256	if (s == "double" \|\| s == "float" \|\| s == "idouble" \|\| s == "ifloat")
	257	{ // Passed in XMM register
	258	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	259	{
	260	p = ap.reg_args + ap.offset_fpregs;
	261	ap.offset_fpregs += 16;
	262	}
	263	else
	264	{
	265	p = ap.stack_args;
	266	ap.stack_args += (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	267	}
	268	}
	269	else
	270	{ // Passed in regular register
	271	if (ap.offset_regs < 6 * 8)
	272	{
	273	p = ap.reg_args + ap.offset_regs;
	274	ap.offset_regs += 8;
	275	}
	276	else
	277	{
	278	p = ap.stack_args;
	279	ap.stack_args += 8;
	280	}
	281	}
	282	parmn[0..tsize] = p[0..tsize];
	283
	284	if (arg2)
	285	{
	286	parmn += 8;
	287	tsize = arg2.tsize();
	288	s = arg2.toString();
	289	if (s == "double" \|\| s == "float" \|\| s == "idouble" \|\| s == "ifloat")
	290	{ // Passed in XMM register
	291	if (ap.offset_fpregs < (6 * 8 + 16 * 8))
	292	{
	293	p = ap.reg_args + ap.offset_fpregs;
	294	ap.offset_fpregs += 16;
	295	}
	296	else
	297	{
	298	p = ap.stack_args;
	299	ap.stack_args += (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
	300	}
	301	}
	302	else
	303	{ // Passed in regular register
	304	if (ap.offset_regs < 6 * 8)
	305	{
	306	p = ap.reg_args + ap.offset_regs;
	307	ap.offset_regs += 8;
	308	}
	309	else
	310	{
	311	p = ap.stack_args;
	312	ap.stack_args += 8;
	313	}
	314	}
	315	tsize = ti.tsize() - 8;
	316	parmn[0..tsize] = p[0..tsize];
	317	}
	318	}
	319	else
	320	{
	321	// Always passed in memory
	322	// The arg may have more strict alignment than the stack
	323	auto talign = ti.talign();
	324	auto tsize = ti.tsize();
	325
	326
	327	auto p = cast(void*)((cast(size_t)ap.stack_args + talign - 1) & ~(talign - 1));
	328	ap.stack_args = cast(void*)(cast(size_t)p + ((tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
	329	parmn[0..tsize] = p[0..tsize];
	330	}
	331	}
	332	else
	333	{
	334	assert(0, "not a valid argument type for va_arg");
	335	}
	336	}
	337
	338	void va_end(va_list ap)
	339	{
	340	}
	341
47	342	void va_copy( out va_list dest, va_list src )
48	343	{
49	344	dest = src;
50	345	}
51	346	}
	347	else
	348	{
	349	static assert(0);
	350	}
	351	}

tango/util/log/Log.d

old	new
103	103	alias void* Arg;
104	104	alias va_list ArgList;
105	105	}
	106	version (DigitalMars)
	107	{
	108	private import tango.core.Vararg;
	109	alias void* Arg;
	110	alias va_list ArgList;
	111	}
106	112	else
107	113	{
108	114	alias void* Arg;
…	…
327	333
328	334	static void formatln (char[] fmt, ...)
329	335	{
	336	version (X86_64)
	337	{
	338	va_list ap;
	339
	340	va_start(ap, __va_argsave);
	341
	342	scope(exit) va_end(ap);
	343
	344	root.format (Level.Info, fmt, _arguments, ap);
	345	}
	346	else
330	347	root.format (Level.Info, fmt, _arguments, _argptr);
331	348	}
332	349
…	…
498	515
499	516	final void trace (char[] fmt, ...)
500	517	{
	518	version (X86_64)
	519	{
	520	va_list ap;
	521
	522	va_start(ap, __va_argsave);
	523
	524	scope(exit) va_end(ap);
	525
	526	format (Level.Trace, fmt, _arguments, ap);
	527	}
	528	else
501	529	format (Level.Trace, fmt, _arguments, _argptr);
502	530	}
503	531
…	…
520	548
521	549	final void info (char[] fmt, ...)
522	550	{
	551	version (X86_64)
	552	{
	553	va_list ap;
	554
	555	va_start(ap, __va_argsave);
	556
	557	scope(exit) va_end(ap);
	558
	559	format (Level.Info, fmt, _arguments, ap);
	560	}
	561	else
523	562	format (Level.Info, fmt, _arguments, _argptr);
524	563	}
525	564
…	…
542	581
543	582	final void warn (char[] fmt, ...)
544	583	{
	584	version (X86_64)
	585	{
	586	va_list ap;
	587
	588	va_start(ap, __va_argsave);
	589
	590	scope(exit) va_end(ap);
	591
	592	format (Level.Warn, fmt, _arguments, ap);
	593	}
	594	else
545	595	format (Level.Warn, fmt, _arguments, _argptr);
546	596	}
547	597
…	…
564	614
565	615	final void error (char[] fmt, ...)
566	616	{
	617	version (X86_64)
	618	{
	619	va_list ap;
	620
	621	va_start(ap, __va_argsave);
	622
	623	scope(exit) va_end(ap);
	624
	625	format (Level.Error, fmt, _arguments, ap);
	626	}
	627	else
567	628	format (Level.Error, fmt, _arguments, _argptr);
568	629	}
569	630
…	…
586	647
587	648	final void fatal (char[] fmt, ...)
588	649	{
	650	version (X86_64)
	651	{
	652	va_list ap;
	653
	654	va_start(ap, __va_argsave);
	655
	656	scope(exit) va_end(ap);
	657
	658	format (Level.Fatal, fmt, _arguments, ap);
	659	}
	660	else
589	661	format (Level.Fatal, fmt, _arguments, _argptr);
590	662	}
591	663
…	…
767	839
768	840	final char[] format (char[] buffer, char[] formatStr, ...)
769	841	{
	842	version (X86_64)
	843	{
	844	va_list ap;
	845
	846	va_start(ap, __va_argsave);
	847
	848	scope(exit) va_end(ap);
	849
	850	return Format.vprint (buffer, formatStr, _arguments, ap);
	851	}
	852	else
770	853	return Format.vprint (buffer, formatStr, _arguments, _argptr);
	854
771	855	}
772	856
773	857	/***********************************************************************

tango/sys/Process.d

old	new
1267	1267	// Replace stdin with the "read" pipe
1268	1268	if(pin !is null)
1269	1269	{
1270		dup2(pin.source.fileHandle(), STDIN_FILENO);
	1270	if (dup2(pin.source.fileHandle(), STDIN_FILENO) < 0)
	1271	throw new Exception("dup2 < 0");
1271	1272	pin.sink().close();
1272	1273	pin.source.close();
1273	1274	}
…	…
1275	1276	// Replace stdout with the "write" pipe
1276	1277	if(pout !is null)
1277	1278	{
1278		dup2(pout.sink.fileHandle(), STDOUT_FILENO);
	1279	if (dup2(pout.sink.fileHandle(), STDOUT_FILENO) < 0)
	1280	throw new Exception("dup2 < 0");
1279	1281	pout.source.close();
1280	1282	pout.sink.close();
1281	1283	}
…	…
1283	1285	// Replace stderr with the "write" pipe
1284	1286	if(perr !is null)
1285	1287	{
1286		dup2(perr.sink.fileHandle(), STDERR_FILENO);
	1288	if (dup2(perr.sink.fileHandle(), STDERR_FILENO) < 0)
	1289	throw new Exception("dup2 < 0");
1287	1290	perr.source.close();
1288	1291	perr.sink.close();
1289	1292	}
…	…
1292	1295	// versa
1293	1296	if(_redirect & Redirect.OutputToError)
1294	1297	{
1295		dup2(STDERR_FILENO, STDOUT_FILENO);
	1298	if(dup2(STDERR_FILENO, STDOUT_FILENO) < 0)
	1299	throw new Exception("dup2 < 0");
1296	1300	}
1297	1301
1298	1302	if(_redirect & Redirect.ErrorToOutput)
1299	1303	{
1300		dup2(STDOUT_FILENO, STDERR_FILENO);
	1304	if(dup2(STDOUT_FILENO, STDERR_FILENO) < 0)
	1305	throw new Exception("dup2 < 0");
1301	1306	}
1302	1307
1303	1308	// We close the unneeded part of the execv*() notification pipe
…	…
1339	1344	}
1340	1345	exit(errno);
1341	1346	}
	1347	exit(errno);
1342	1348	}
1343	1349	else
1344	1350	{
…	…
1926	1932	{
1927	1933	char[][] pathList = delimit(str[0 .. strlen(str)], ":");
1928	1934
	1935	char[] path_buf;
	1936
1929	1937	foreach (path; pathList)
1930	1938	{
1931		if (path[~~path.length -~~ 1] != FileConst.PathSeparatorChar)
	1939	if (path[$-1] != FileConst.PathSeparatorChar)
1932	1940	{
1933		path ~= FileConst.PathSeparatorChar;
	1941	path_buf.length = path.length + 1 + filename.length + 1;
	1942	path_buf[] = path ~ FileConst.PathSeparatorChar ~ filename ~ '\0';
1934	1943	}
	1944	else
	1945	{
	1946	path_buf.length = path.length +filename.length + 1;
	1947	path_buf[] = path ~ filename ~ '\0';
	1948	}
1935	1949
1936		debug (Process)
1937		Stdout.formatln("Trying execution of '{0}' in directory '{1}'",
1938		filename, path);
	1950	rc = execve(path_buf.ptr, argv.ptr, (envp.length == 0 ? environ : envp.ptr));
1939	1951
1940		~~path ~= filename;~~
1941		~~path ~= '\0';~~
1942
1943		~~rc = execve(path.ptr, argv.ptr, (envp.length == 0 ? environ : envp.ptr));~~
1944	1952	// If the process execution failed because of an error
1945	1953	// other than ENOENT (No such file or directory) we
1946	1954	// abort the loop.
1947		if (rc == -1 && ~~errno !=~~ ENOENT)
	1955	if (rc == -1 && SysError.lastCode !is ENOENT)
1948	1956	{
1949	1957	break;
1950	1958	}
…	…
2030	2038	return msg ~ Integer.format (tmp, value);
2031	2039	}
2032	2040
2033
	2041	extern (C) uint sleep (uint s);
2034	2042	debug (UnitTest)
2035	2043	{
	2044	import tango.io.Stdout;
	2045	import tango.stdc.stdio : printf, fflush, stdout;
	2046
2036	2047	unittest
2037	2048	{
2038	2049	char[] message = "hello world";
…	…
2047	2058	try
2048	2059	{
2049	2060	auto p = new Process(command, null);
	2061	Stdout.flush;
	2062	p.execute();
	2063	char[255] buffer;
2050	2064
2051		~~p.execute();~~
2052		~~char[1024] buffer;~~
2053	2065	auto nread = p.stdout.read(buffer);
	2066
2054	2067	assert(nread != p.stdout.Eof);
	2068
2055	2069	version(Windows)
2056	2070	assert(buffer[0..nread] == message ~ "\r\n");
2057	2071	else
2058	2072	assert(buffer[0..nread] == message ~ "\n");
	2073
2059	2074	nread = p.stdout.read(buffer);
2060	2075	assert(nread == p.stdout.Eof);
2061	2076

tango/sys/HomeFolder.d

old	new
124	124	******************************************************************************/
125	125
126	126	private char[] expandFromEnvironment(char[] path)
	127	in
127	128	{
128	129	assert(path.length >= 1);
129	130	assert(path[0] == '~');
130
	131	}
	132	body
	133	{
131	134	// Get HOME and use that to replace the tilde.
132	135	char[] home = homeFolder;
133	136	if (home is null)
134	137	return path;
135	138
	139	if (home[$-1] == '/')
	140	home = home[0..$-1];
	141
136	142	return Path.join(home, path[1..$]);
	143
137	144	}
138	145
139	146	/*******************************************************************************
…	…
168	175	int extra_memory_size = 5 * 1024;
169	176	void* extra_memory;
170	177
	178	scope (exit) if(extra_memory) tango.stdc.stdlib.free(extra_memory);
	179
171	180	while (1)
172	181	{
173	182	extra_memory = tango.stdc.stdlib.malloc(extra_memory_size);
174	183	if (extra_memory is null)
175		~~goto Lerror~~;
	184	throw new OutOfMemoryException("Not enough memory for user lookup in tilde expansion.", __LINE__);
176	185
177	186	// Obtain info from database.
178	187	passwd *verify;
…	…
181	190	&verify) == 0)
182	191	{
183	192	// Failure if verify doesn't point at result.
184		if (verify != &result)
185		// username is not found, so return path[]
186		goto Lnotfound;
187		break;
	193	if (verify == &result)
	194	{
	195	auto pwdirlen = strlen(result.pw_dir);
	196
	197	path = Path.join(result.pw_dir[0..pwdirlen].dup, path[last_char..$]);
188	198	}
189	199
	200	return path;
	201	}
	202
190	203	if (tango.stdc.errno.errno() != ERANGE)
191		~~goto Lerror~~;
	204	throw new OutOfMemoryException("Not enough memory for user lookup in tilde expansion.", __LINE__);
192	205
193	206	// extra_memory isn't large enough
194	207	tango.stdc.stdlib.free(extra_memory);
195	208	extra_memory_size *= 2;
196	209	}
197
198		~~auto pwdirlen = strlen(result.pw_dir);~~
199		~~path = Path.join(result.pw_dir[0..pwdirlen].dup, path[last_char..$]);~~
200
201		~~Lnotfound:~~
202		~~tango.stdc.stdlib.free(extra_memory);~~
203		~~return path;~~
204
205		~~Lerror:~~
206		~~// Errors are going to be caused by running out of memory~~
207		~~if (extra_memory)~~
208		~~tango.stdc.stdlib.free(extra_memory);~~
209		~~throw new OutOfMemoryException("Not enough memory for user lookup in tilde expansion.", __LINE__);~~
210	210	}
211	211
212	212	}
…	…
308	308	*******************************************************************************/
309	309
310	310	debug(UnitTest) {
	311
311	312	unittest
312	313	{
313	314	version (Posix)
…	…
322	323
323	324	// Testing when an environment variable is set.
324	325	Environment.set("HOME", "tango/test");
	326	assert (Environment.get("HOME") == "tango/test");
	327
325	328	assert(expandTilde("~/") == "tango/test/");
326	329	assert(expandTilde("~") == "tango/test");
327	330

Ticket #2038: 64Bit.19.patch

build/script/unittest.sh

build/src/bob.d

object.di

tango/text/convert/Layout.d

tango/text/Text.d

tango/text/Regex.d

tango/net/device/Berkeley.d

tango/io/device/Device.d

tango/io/Console.d

tango/io/stream/Snoop.d

tango/io/stream/Format.d

tango/io/Path.d

tango/core/rt/gc/basic/gcx.d

tango/core/rt/gc/basic/gcalloc.d

tango/core/rt/gc/basic/gcbits.d

tango/core/rt/compiler/ldc/object_.d

tango/core/rt/compiler/ldc/typeinfo/ti_void.d

tango/core/rt/compiler/ldc/typeinfo/ti_wchar.d

tango/core/rt/compiler/ldc/typeinfo/ti_ptr.d

tango/core/rt/compiler/ldc/typeinfo/ti_Afloat.d

tango/core/rt/compiler/ldc/typeinfo/ti_double.d

tango/core/rt/compiler/ldc/typeinfo/ti_delegate.d

tango/core/rt/compiler/ldc/typeinfo/ti_Adouble.d

tango/core/rt/compiler/ldc/typeinfo/ti_char.d

tango/core/rt/compiler/ldc/typeinfo/ti_Acdouble.d

tango/core/rt/compiler/ldc/typeinfo/ti_uint.d

tango/core/rt/compiler/ldc/typeinfo/ti_AC.d

tango/core/rt/compiler/ldc/typeinfo/ti_ulong.d

tango/core/rt/compiler/ldc/typeinfo/ti_creal.d

tango/core/rt/compiler/ldc/typeinfo/ti_ubyte.d

tango/core/rt/compiler/ldc/typeinfo/ti_Aint.d

tango/core/rt/compiler/ldc/typeinfo/ti_short.d

tango/core/rt/compiler/ldc/typeinfo/ti_long.d

tango/core/rt/compiler/ldc/typeinfo/ti_Along.d

tango/core/rt/compiler/ldc/typeinfo/ti_byte.d

tango/core/rt/compiler/ldc/typeinfo/ti_float.d

tango/core/rt/compiler/ldc/typeinfo/ti_cfloat.d

tango/core/rt/compiler/ldc/typeinfo/ti_Acfloat.d

tango/core/rt/compiler/ldc/typeinfo/ti_cdouble.d

tango/core/rt/compiler/ldc/typeinfo/ti_dchar.d

tango/core/rt/compiler/ldc/typeinfo/ti_C.d

tango/core/rt/compiler/ldc/typeinfo/ti_real.d

tango/core/rt/compiler/ldc/typeinfo/ti_Areal.d

tango/core/rt/compiler/ldc/typeinfo/ti_ushort.d

tango/core/rt/compiler/ldc/typeinfo/ti_Acreal.d

tango/core/rt/compiler/ldc/typeinfo/ti_Ag.d

tango/core/rt/compiler/ldc/typeinfo/ti_int.d

tango/core/rt/compiler/ldc/typeinfo/ti_Ashort.d

tango/core/rt/compiler/dmd/rt/adi.d

tango/core/rt/compiler/dmd/rt/trace.d

tango/core/rt/compiler/dmd/rt/lifetime.d

tango/core/rt/compiler/dmd/rt/memory.d

tango/core/rt/compiler/dmd/rt/dmain2.d

tango/core/rt/compiler/dmd/rt/cover.d

tango/core/rt/compiler/dmd/rt/aaA.d

tango/core/rt/compiler/dmd/rt/cast_.d

tango/core/rt/compiler/dmd/rt/memset.d

tango/core/rt/compiler/dmd/rt/alloca.d

tango/core/rt/compiler/dmd/object_.d

tango/core/rt/compiler/dmd/std/intrinsic.d

tango/core/rt/compiler/dmd/typeinfo/ti_void.d

tango/core/rt/compiler/dmd/typeinfo/ti_wchar.d

tango/core/rt/compiler/dmd/typeinfo/ti_ptr.d

tango/core/rt/compiler/dmd/typeinfo/ti_Afloat.d

tango/core/rt/compiler/dmd/typeinfo/ti_double.d

tango/core/rt/compiler/dmd/typeinfo/ti_delegate.d

tango/core/rt/compiler/dmd/typeinfo/ti_Adouble.d

tango/core/rt/compiler/dmd/typeinfo/ti_char.d

tango/core/rt/compiler/dmd/typeinfo/ti_Acdouble.d

tango/core/rt/compiler/dmd/typeinfo/ti_uint.d

tango/core/rt/compiler/dmd/typeinfo/ti_AC.d

tango/core/rt/compiler/dmd/typeinfo/ti_ulong.d

tango/core/rt/compiler/dmd/typeinfo/ti_creal.d

tango/core/rt/compiler/dmd/typeinfo/ti_ubyte.d

tango/core/rt/compiler/dmd/typeinfo/ti_Aint.d

tango/core/rt/compiler/dmd/typeinfo/ti_short.d

tango/core/rt/compiler/dmd/typeinfo/ti_long.d

tango/core/rt/compiler/dmd/typeinfo/ti_Along.d

tango/core/rt/compiler/dmd/typeinfo/ti_byte.d