Context Navigation

source: dev/trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp@ 228

Last change on this file since 228 was 225, checked in by dai_9181, 17 years ago
CodeGeneratorクラスのベースを実装
File size: 31.8 KB

Rev	Line
[206]	1	#include "stdafx.h"
	2
[225]	3	#include <Compiler.h>
	4
[3]	5	#include "../BasicCompiler_Common/common.h"
	6	#include "Opcode.h"
	7
	8	void GetStackData_ToRegister(int *type,int sp){
	9	/*NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を
	10	レジスタedx:eax、ecx:ebxに取得する*/
	11
	12	if(type[sp-1]==DEF_DOUBLE){
	13	//fld qword ptr[esp]
[225]	14	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	15
	16	//fistp qword ptr[esp]
[225]	17	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
[3]	18
	19	//pop ebx
[225]	20	compiler.codeGenerator.op_pop(REG_EBX);
[3]	21
	22	//pop ecx
[225]	23	compiler.codeGenerator.op_pop(REG_ECX);
[3]	24	}
	25	else if(type[sp-1]==DEF_SINGLE){
	26	//fld dword ptr[esp]
[225]	27	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	28
	29	//sub esp,4
[225]	30	compiler.codeGenerator.op_sub_esp(4);
[3]	31
	32	//fistp qword ptr[esp]
[225]	33	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
[3]	34
	35	//pop ebx
[225]	36	compiler.codeGenerator.op_pop(REG_EBX);
[3]	37
	38	//pop ecx
[225]	39	compiler.codeGenerator.op_pop(REG_ECX);
[3]	40	}
	41	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	42	//pop ebx
[225]	43	compiler.codeGenerator.op_pop(REG_EBX);
[3]	44
	45	//pop ecx
[225]	46	compiler.codeGenerator.op_pop(REG_ECX);
[3]	47	}
	48	else{
	49	//pop eax
[225]	50	compiler.codeGenerator.op_pop(REG_EAX);
[3]	51
	52	if(IsSignedType(type[sp-1])){
	53	//符号拡張
	54	//edx:eax ← eax
	55
	56	//cdq
[225]	57	compiler.codeGenerator.op_cdq();
[3]	58	}
	59	else{
	60	//ビット拡張
	61	//edx:eax ← eax
	62
	63	//xor edx,edx
[225]	64	compiler.codeGenerator.op_zero_reg(REG_EDX);
[3]	65	}
	66
	67	//mov ebx,eax
[225]	68	compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
[3]	69
	70	//mov ecx,edx
[225]	71	compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
[3]	72	}
	73
	74	//第1項を64ビットに対応させる
	75	if(type[sp-2]==DEF_DOUBLE){
	76	//fld qword ptr[esp]
[225]	77	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	78
	79	//fistp qword ptr[esp]
[225]	80	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
[3]	81
	82	//pop eax
[225]	83	compiler.codeGenerator.op_pop(REG_EAX);
[3]	84
	85	//pop edx
[225]	86	compiler.codeGenerator.op_pop(REG_EDX);
[3]	87	}
	88	else if(type[sp-2]==DEF_SINGLE){
	89	//fld dword ptr[esp]
[225]	90	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	91
	92	//sub esp,4
[225]	93	compiler.codeGenerator.op_sub_esp(4);
[3]	94
	95	//fistp qword ptr[esp]
[225]	96	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
[3]	97
	98	//pop eax
[225]	99	compiler.codeGenerator.op_pop(REG_EAX);
[3]	100
	101	//pop edx
[225]	102	compiler.codeGenerator.op_pop(REG_EDX);
[3]	103	}
	104	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	105	//pop eax
[225]	106	compiler.codeGenerator.op_pop(REG_EAX);
[3]	107
	108	//pop edx
[225]	109	compiler.codeGenerator.op_pop(REG_EDX);
[3]	110	}
	111	else{
	112	//pop eax
[225]	113	compiler.codeGenerator.op_pop(REG_EAX);
[3]	114
	115	if(IsSignedType(type[sp-2])){
	116	//符号拡張
	117	//edx:eax ← eax
	118
	119	//cdq
[225]	120	compiler.codeGenerator.op_cdq();
[3]	121	}
	122	else{
	123	//ビット拡張
	124	//edx:eax ← eax
	125
	126	//xor edx,edx
[225]	127	compiler.codeGenerator.op_zero_reg(REG_EDX);
[3]	128	}
	129	}
	130	}
	131
	132	void FormatStackData_To64bit(int *type,int sp){
	133	//NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を64ビット整数型にする
	134
	135	GetStackData_ToRegister(type,sp);
	136
	137	//push ecx
[225]	138	compiler.codeGenerator.op_push(REG_ECX);
[3]	139
	140	//push ebx
[225]	141	compiler.codeGenerator.op_push(REG_EBX);
[3]	142
	143	//push edx
[225]	144	compiler.codeGenerator.op_push(REG_EDX);
[3]	145
	146	//push eax
[225]	147	compiler.codeGenerator.op_push(REG_EAX);
[3]	148	}
	149
	150	BOOL CalcTwoTerm_Arithmetic(int idCalc,int type,LONG_PTR index_stack,int *pStackPointer){
	151	/* value[sp-2] = value[sp-2] + value[sp-1]
	152	value[sp-2] = value[sp-2] - value[sp-1]
	153	value[sp-2] = value[sp-2] * value[sp-1] */
	154
	155	int sp;
	156	sp=*pStackPointer;
	157
	158	int AnswerType;
	159	AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]);
	160
	161	if(type[sp-2]==DEF_DOUBLE\|\|type[sp-2]==DEF_SINGLE\|\|
	162	type[sp-1]==DEF_DOUBLE\|\|type[sp-1]==DEF_SINGLE){
	163	/////////////
	164	// 実数演算
	165	/////////////
	166
	167	if(type[sp-1]==DEF_DOUBLE){
	168	//fld qword ptr[esp]
[225]	169	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	170
	171	//add esp,8
[225]	172	compiler.codeGenerator.op_add_esp(8);
[3]	173	}
	174	else if(type[sp-1]==DEF_SINGLE){
	175	//fld dword ptr[esp]
[225]	176	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	177
	178	//add esp,4
[225]	179	compiler.codeGenerator.op_add_esp(4);
[3]	180	}
	181	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	182	//64ビット整数値
	183
	184	//fild qword ptr[esp]
[225]	185	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	186
	187	//add esp,8
[225]	188	compiler.codeGenerator.op_add_esp(8);
[3]	189	}
	190	else{
	191	//その他整数型
	192
	193	//fild dword ptr[esp]
[225]	194	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	195
	196	//add esp,4
[225]	197	compiler.codeGenerator.op_add_esp(4);
[3]	198	}
	199
	200	if(type[sp-2]==DEF_DOUBLE){
	201	//fld qword ptr[esp]
[225]	202	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	203	}
	204	else if(type[sp-2]==DEF_SINGLE){
	205	//fld dword ptr[esp]
[225]	206	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	207	}
	208	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	209	//64ビット整数値
[225]	210	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	211	}
	212	else{
	213	//その他整数型
	214
	215	//fild dword ptr[esp]
[225]	216	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	217	}
	218
	219	if(GetTypeSize(type[sp-2],-1)==sizeof(_int64)){
	220	if(AnswerType==DEF_SINGLE){
	221	//add esp,4
[225]	222	compiler.codeGenerator.op_add_esp(4);
[3]	223	}
	224	}
	225	else{
	226	if(AnswerType==DEF_DOUBLE){
	227	//sub esp,4
[225]	228	compiler.codeGenerator.op_sub_esp(4);
[3]	229	}
	230	}
	231
	232	if(idCalc==CALC_ADDITION){
	233	//faddp st(1),st
[225]	234	compiler.codeGenerator.PutOld(
	235	(char)0xDE,
	236	(char)0xC1
	237	);
[3]	238	}
	239	else if(idCalc==CALC_SUBTRACTION){
	240	//fsubrp st(1),st
[225]	241	compiler.codeGenerator.PutOld(
	242	(char)0xDE,
	243	(char)0xE1
	244	);
[3]	245	}
	246	else if(idCalc==CALC_PRODUCT){
	247	//fmulp st(1),st
[225]	248	compiler.codeGenerator.PutOld(
	249	(char)0xDE,
	250	(char)0xC9
	251	);
[3]	252	}
	253
	254	if(AnswerType==DEF_DOUBLE){
	255	//fstp qword ptr[esp]
[225]	256	compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
[3]	257	}
	258	else{
	259	//fstp dword ptr[esp]
[225]	260	compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
[3]	261	}
	262	}
	263	else if(Is64Type(type[sp-2])\|\|Is64Type(type[sp-1])){
	264	//////////////////////
	265	// 64ビット整数演算
	266	//////////////////////
	267
	268	if(idCalc==CALC_PRODUCT){
	269	if(!((type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD)&&
	270	(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD))){
	271	//2つの項のどちらかが64ビット整数でないとき
	272	FormatStackData_To64bit(type,sp);
	273	}
	274
	275	//call _allmul
[206]	276	extern const UserProc *pSub_allmul;
[225]	277	compiler.codeGenerator.op_call(pSub_allmul);
[3]	278
	279	//push edx
[225]	280	compiler.codeGenerator.op_push(REG_EDX);
[3]	281
	282	//push eax
[225]	283	compiler.codeGenerator.op_push(REG_EAX);
[3]	284	}
	285	else{
	286	if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	287	//第2項が64ビット整数値のとき
	288
	289	//pop ebx
[225]	290	compiler.codeGenerator.op_pop(REG_EBX);
[3]	291
	292	//pop ecx
[225]	293	compiler.codeGenerator.op_pop(REG_ECX);
[3]	294	}
	295	else{
	296	//第2項がその他整数値のとき
	297
	298	//pop eax
[225]	299	compiler.codeGenerator.op_pop(REG_EAX);
[3]	300
	301	if(IsSignedType(type[sp-1])){
	302	//符号拡張
	303	//edx:eax ← eax
	304
	305	//cdq
[225]	306	compiler.codeGenerator.op_cdq();
[3]	307	}
	308	else{
	309	//ビット拡張
	310	//edx:eax ← eax
	311
	312	//xor edx,edx
[225]	313	compiler.codeGenerator.op_zero_reg(REG_EDX);
[3]	314	}
	315
	316	//mov ebx,eax
[225]	317	compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
[3]	318
	319	//mov ecx,edx
[225]	320	compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
[3]	321	}
	322
	323	if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	324	//第1項が64ビット整数値のとき
	325
	326	if(idCalc==CALC_ADDITION){
	327	//add dword ptr[esp],ebx
[225]	328	compiler.codeGenerator.PutOld(
	329	(char)0x01,
	330	(char)0x1C,
	331	(char)0x24
	332	);
[3]	333
	334	//adc dword ptr[esp+sizeof(long)],ecx
[225]	335	compiler.codeGenerator.PutOld(
	336	(char)0x11,
	337	(char)0x4C,
	338	(char)0x24,
	339	(char)0x04
	340	);
[3]	341	}
	342	else if(idCalc==CALC_SUBTRACTION){
	343	//sub dword ptr[esp],ebx
[225]	344	compiler.codeGenerator.PutOld(
	345	(char)0x29,
	346	(char)0x1C,
	347	(char)0x24
	348	);
[3]	349
	350	//sbb dword ptr[esp+sizeof(long)],ecx
[225]	351	compiler.codeGenerator.PutOld(
	352	(char)0x19,
	353	(char)0x4C,
	354	(char)0x24,
	355	(char)0x04
	356	);
[3]	357	}
	358	}
	359	else{
	360	//第1項がその他整数値のとき
	361
	362	//pop eax
[225]	363	compiler.codeGenerator.op_pop(REG_EAX);
[3]	364
	365	if(IsSignedType(type[sp-2])){
	366	//符号拡張
	367	//edx:eax ← eax
	368
	369	//cdq
[225]	370	compiler.codeGenerator.op_cdq();
[3]	371	}
	372	else{
	373	//ビット拡張
	374	//edx:eax ← eax
	375
	376	//xor edx,edx
[225]	377	compiler.codeGenerator.op_zero_reg(REG_EDX);
[3]	378	}
	379
	380	if(idCalc==CALC_ADDITION){
	381	//add ebx,eax
[225]	382	compiler.codeGenerator.op_add_RR( REG_EBX, REG_EAX );
[3]	383
	384	//adc ecx,edx
[225]	385	compiler.codeGenerator.op_adc_RR( REG_ECX, REG_EDX );
[3]	386	}
	387	else if(idCalc==CALC_SUBTRACTION){
	388	//sub ebx,eax
[225]	389	compiler.codeGenerator.op_sub_RR( REG_EBX, REG_EAX );
[3]	390
	391	//sbb ecx,edx
[225]	392	compiler.codeGenerator.op_sub_RR( REG_ECX, REG_EDX );
[3]	393	}
	394
	395	//push ecx
[225]	396	compiler.codeGenerator.op_push(REG_ECX);
[3]	397
	398	//push ebx
[225]	399	compiler.codeGenerator.op_push(REG_EBX);
[3]	400	}
	401	}
	402	}
	403	else{
	404	//////////////////////////
	405	//32ビット以下の整数演算
	406	//////////////////////////
	407
	408	//pop ebx
[225]	409	compiler.codeGenerator.op_pop(REG_EBX);
[3]	410
	411	//pop eax
[225]	412	compiler.codeGenerator.op_pop(REG_EAX);
[3]	413
	414	//sub esp,4
[225]	415	compiler.codeGenerator.op_sub_esp(4);
[3]	416
	417	if(idCalc==CALC_ADDITION){
	418	//add eax,ebx
[225]	419	compiler.codeGenerator.op_add_RR( REG_EAX, REG_EBX );
[3]	420	}
	421	else if(idCalc==CALC_SUBTRACTION){
	422	//sub eax,ebx
[225]	423	compiler.codeGenerator.op_sub_RR( REG_EAX, REG_EBX );
[3]	424	}
	425	else if(idCalc==CALC_PRODUCT){
	426	//imul eax,ebx（64ビット演算ではないので、符号を考慮しない）
[225]	427	compiler.codeGenerator.op_imul_RR( REG_EAX, REG_EBX );
[3]	428	}
	429
	430	//mov dword ptr[esp],eax
[225]	431	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]	432	}
	433
	434	sp--;
	435	type[sp-1]=AnswerType;
	436
	437	*pStackPointer=sp;
	438
	439	return 1;
	440	}
	441
	442	BOOL Calc_Mod(int type,int pStackPointer){
	443	//value[sp-2]%=value[sp-1]
	444	//剰余演算
	445
	446	int sp;
	447	sp=*pStackPointer;
	448
	449	if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD\|\|
	450	type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	451	////////////////
	452	// 64ビット演算
	453	////////////////
	454
	455	//第2項を64ビットに対応させる
	456	FormatStackData_To64bit(type,sp);
	457
	458	if(IsSignedType(type[sp-2])==0&&IsSignedType(type[sp-1])==0){
	459	//符号なし演算
	460
	461	//call _aullrem
[206]	462	extern const UserProc *pSub_aullrem;
[225]	463	compiler.codeGenerator.op_call(pSub_aullrem);
[3]	464	}
	465	else{
	466	//符号あり演算
	467
	468	//call _allrem
[206]	469	extern const UserProc *pSub_allrem;
[225]	470	compiler.codeGenerator.op_call(pSub_allrem);
[3]	471	}
	472
	473	//push edx
[225]	474	compiler.codeGenerator.op_push(REG_EDX);
[3]	475
	476	//push eax
[225]	477	compiler.codeGenerator.op_push(REG_EAX);
[3]	478
	479	sp--;
	480	if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
	481	else type[sp-1]=DEF_INT64;
	482	}
	483	else{
	484	////////////////
	485	// 32ビット演算
	486	////////////////
	487
	488	if(type[sp-1]==DEF_DOUBLE){
	489	//fld qword ptr[esp]
[225]	490	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	491
	492	//add esp,4
[225]	493	compiler.codeGenerator.op_add_esp(4);
[3]	494
	495	//fistp dword ptr[esp]
[225]	496	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	497	}
	498	else if(type[sp-1]==DEF_SINGLE){
	499	//fld dword ptr[esp]
[225]	500	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	501
	502	//fistp dword ptr[esp]
[225]	503	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	504	}
	505
	506	//pop ebx
[225]	507	compiler.codeGenerator.op_pop(REG_EBX);
[3]	508
	509	if(type[sp-2]==DEF_DOUBLE){
	510	//fld qword ptr[esp]
[225]	511	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	512
	513	//add esp,4
[225]	514	compiler.codeGenerator.op_add_esp(4);
[3]	515
	516	//fistp dword ptr[esp]
[225]	517	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	518	}
	519	else if(type[sp-2]==DEF_SINGLE){
	520	//fld dword ptr[esp]
[225]	521	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	522
	523	//fistp dword ptr[esp]
[225]	524	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	525	}
	526
	527	//pop eax
[225]	528	compiler.codeGenerator.op_pop(REG_EAX);
[3]	529
	530	//sub esp,4
[225]	531	compiler.codeGenerator.op_sub_esp(4);
[3]	532
	533	if(type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD){
	534	//xor edx,edx
[225]	535	compiler.codeGenerator.op_zero_reg(REG_EDX);
[3]	536
	537	//div ebx (eax=eax/ebx...edx)
[225]	538	compiler.codeGenerator.op_div_R( REG_EBX );
[3]	539	}
	540	else{
	541	//cdq
[225]	542	compiler.codeGenerator.op_cdq();
[3]	543
	544	//idiv ebx (eax=eax/ebx...edx)
[225]	545	compiler.codeGenerator.op_idiv_R( REG_EBX );
[3]	546	}
	547
	548	//mov dword ptr[esp],edx
[225]	549	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EDX, REG_ESP, 0, MOD_BASE );
[3]	550
	551	sp--;
	552	type[sp-1]=DEF_LONG;
	553	}
	554
	555	*pStackPointer=sp;
	556
	557	return 1;
	558	}
	559
	560	BOOL Calc_Divide(int type,int pStackPointer,int BaseType){
	561	//value[sp-2]/=value[sp-1];
	562	//除算
	563
	564	int sp;
	565	sp=*pStackPointer;
	566
	567	///////////////////////
	568	// 浮動小数点演算のみ
	569	///////////////////////
	570
	571	int AnswerType;
	572	if(type[sp-2]==DEF_DOUBLE\|\|type[sp-1]==DEF_DOUBLE\|\|BaseType==DEF_DOUBLE) AnswerType=DEF_DOUBLE;
	573	else AnswerType=DEF_SINGLE;
	574
	575	if(type[sp-1]==DEF_DOUBLE){
	576	//fld qword ptr[esp]
[225]	577	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	578
	579	//add esp,8
[225]	580	compiler.codeGenerator.op_add_esp(8);
[3]	581	}
	582	else if(type[sp-1]==DEF_SINGLE){
	583	//fld dword ptr[esp]
[225]	584	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	585
	586	//add esp,4
[225]	587	compiler.codeGenerator.op_add_esp(4);
[3]	588	}
	589	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	590	//64ビット整数値
	591
	592	//fild qword ptr[esp]
[225]	593	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	594
	595	//add esp,8
[225]	596	compiler.codeGenerator.op_add_esp(8);
[3]	597	}
	598	else if(type[sp-1]==DEF_DWORD){
	599	//pop eax
[225]	600	compiler.codeGenerator.op_pop(REG_EAX);
[3]	601
	602	//push 0
[225]	603	compiler.codeGenerator.op_push_V(0);
[3]	604
	605	//push eax
[225]	606	compiler.codeGenerator.op_push(REG_EAX);
[3]	607
	608	//fild qword ptr[esp]
[225]	609	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	610
	611	//add esp,8
[225]	612	compiler.codeGenerator.op_add_esp(8);
[3]	613	}
	614	else{
	615	//fild dword ptr[esp]
[225]	616	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	617
	618	//add esp,4
[225]	619	compiler.codeGenerator.op_add_esp(4);
[3]	620	}
	621
	622	if(type[sp-2]==DEF_DOUBLE){
	623	//fld qword ptr[esp]
[225]	624	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	625	}
	626	else if(type[sp-2]==DEF_SINGLE){
	627	//fld dword ptr[esp]
[225]	628	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	629	}
	630	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	631	//64ビット整数値
	632
	633	//fild qword ptr[esp]
[225]	634	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	635	}
	636	else if(type[sp-2]==DEF_DWORD){
	637	//pop eax
[225]	638	compiler.codeGenerator.op_pop(REG_EAX);
[3]	639
	640	//push 0
[225]	641	compiler.codeGenerator.op_push_V(0);
[3]	642
	643	//push eax
[225]	644	compiler.codeGenerator.op_push(REG_EAX);
[3]	645
	646	//fild qword ptr[esp]
[225]	647	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	648	}
	649	else{ //Long
	650	//fild dword ptr[esp]
[225]	651	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	652	}
	653	//↓ここだけ例外DWord
	654	if(GetTypeSize(type[sp-2],-1)==sizeof(_int64)\|\|type[sp-2]==DEF_DWORD){
	655	if(AnswerType==DEF_SINGLE){
	656	//add esp,4
[225]	657	compiler.codeGenerator.op_add_esp(4);
[3]	658	}
	659	}
	660	else{
	661	if(AnswerType==DEF_DOUBLE){
	662	//sub esp,4
[225]	663	compiler.codeGenerator.op_sub_esp(4);
[3]	664	}
	665	}
	666
	667	//fdivrp st(1),st
[225]	668	compiler.codeGenerator.PutOld(
	669	(char)0xDE,
	670	(char)0xF1
	671	);
[3]	672
	673	sp--;
	674	if(AnswerType==DEF_DOUBLE){
	675	//fstp qword ptr[esp]
[225]	676	compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
[3]	677
	678	type[sp-1]=DEF_DOUBLE;
	679	}
	680	else{
	681	//fstp dword ptr[esp]
[225]	682	compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
[3]	683
	684	type[sp-1]=DEF_SINGLE;
	685	}
	686
	687	*pStackPointer=sp;
	688
	689	return 1;
	690	}
	691
	692	BOOL Calc_IntDivide(int type,LONG_PTR index_stack,int *pStackPointer){
	693	//value[sp-2]/=value[sp-1]
	694	//除算（整数）
	695
	696	int sp;
	697	sp=*pStackPointer;
	698
	699	if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD\|\|
	700	type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	701	////////////////
	702	// 64ビット演算
	703	////////////////
	704
	705	//2つの項を64ビットに対応させる
	706	FormatStackData_To64bit(type,sp);
	707
	708	if(IsSignedType(type[sp-2])==0&&IsSignedType(type[sp-1])==0){
	709	//符号なし演算
	710
	711	//call _aulldiv
[206]	712	extern const UserProc *pSub_aulldiv;
[225]	713	compiler.codeGenerator.op_call(pSub_aulldiv);
[3]	714	}
	715	else{
	716	//符号あり演算
	717
	718	//call _alldiv
[206]	719	extern const UserProc *pSub_alldiv;
[225]	720	compiler.codeGenerator.op_call(pSub_alldiv);
[3]	721	}
	722
	723	//push edx
[225]	724	compiler.codeGenerator.op_push(REG_EDX);
[3]	725
	726	//push eax
[225]	727	compiler.codeGenerator.op_push(REG_EAX);
[3]	728
	729	sp--;
	730	if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
	731	else type[sp-1]=DEF_INT64;
	732	}
	733	else{
	734	////////////////
	735	// 32ビット演算
	736	////////////////
	737
	738	if(type[sp-1]==DEF_DOUBLE){
	739	//fld qword ptr[esp]
[225]	740	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	741
	742	//add esp,4
[225]	743	compiler.codeGenerator.op_add_esp(4);
[3]	744
	745	//fistp dword ptr[esp]
[225]	746	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	747	}
	748	else if(type[sp-1]==DEF_SINGLE){
	749	//fld dword ptr[esp]
[225]	750	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	751
	752	//fistp dword ptr[esp]
[225]	753	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	754	}
	755
	756	//pop ebx
[225]	757	compiler.codeGenerator.op_pop(REG_EBX);
[3]	758
	759	if(type[sp-2]==DEF_DOUBLE){
	760	//fld qword ptr[esp]
[225]	761	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	762
	763	//add esp,4
[225]	764	compiler.codeGenerator.op_add_esp(4);
[3]	765
	766	//fistp dword ptr[esp]
[225]	767	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	768	}
	769	else if(type[sp-2]==DEF_SINGLE){
	770	//fld dword ptr[esp]
[225]	771	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	772
	773	//fistp dword ptr[esp]
[225]	774	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	775	}
	776
	777	//pop eax
[225]	778	compiler.codeGenerator.op_pop(REG_EAX);
[3]	779
	780	//sub esp,4
[225]	781	compiler.codeGenerator.op_sub_esp(4);
[3]	782
	783	if((type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD)\|\|
	784	(IS_POSITIVE_LITERAL(index_stack[sp-2])&&type[sp-1]==DEF_DWORD)\|\|
	785	(type[sp-2]==DEF_DWORD&&IS_POSITIVE_LITERAL(index_stack[sp-1]))){
	786	//xor edx,edx
[225]	787	compiler.codeGenerator.op_zero_reg(REG_EDX);
[3]	788
	789	//div ebx (eax=eax/ebx...edx)
[225]	790	compiler.codeGenerator.op_div_R( REG_EBX );
[3]	791	}
	792	else{
	793	//cdq
[225]	794	compiler.codeGenerator.op_cdq();
[3]	795
	796	//idiv ebx (eax=eax/ebx...edx)
[225]	797	compiler.codeGenerator.op_idiv_R( REG_EBX );
[3]	798	}
	799
	800	//mov dword ptr[esp],eax
[225]	801	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]	802
	803	sp--;
	804
	805	//整数以外の型だったときはLong型にする
	806	if(!IsWholeNumberType(type[sp-1])) type[sp-1]=DEF_LONG;
	807	}
	808
	809	*pStackPointer=sp;
	810	return 1;
	811	}
	812
	813	BOOL Calc_MinusMark(int *type,int sp){
	814	//value[sp-1]=-value[sp-1]
	815	//符号反転
	816
	817	if(type[sp-1]==DEF_DOUBLE){
	818	//fld qword ptr[esp]
[225]	819	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	820
	821	//push -1
[225]	822	compiler.codeGenerator.op_push_V(-1);
[3]	823
	824	//fild dword ptr[esp]
[225]	825	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	826
	827	//add esp,4
[225]	828	compiler.codeGenerator.op_add_esp(4);
[3]	829
	830	//fmulp st(1),st
[225]	831	compiler.codeGenerator.PutOld(
	832	(char)0xDE,
	833	(char)0xC9
	834	);
[3]	835
	836	//fstp qword ptr[esp]
[225]	837	compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
[3]	838	}
	839	else if(type[sp-1]==DEF_SINGLE){
	840	//fld dword ptr[esp]
[225]	841	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	842
	843	//push -1
[225]	844	compiler.codeGenerator.op_push_V(-1);
[3]	845
	846	//fild dword ptr[esp]
[225]	847	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	848
	849	//add esp,4
[225]	850	compiler.codeGenerator.op_add_esp(4);
[3]	851
	852	//fmulp st(1),st
[225]	853	compiler.codeGenerator.PutOld(
	854	(char)0xDE,
	855	(char)0xC9
	856	);
[3]	857
	858	//fstp dword ptr[esp]
[225]	859	compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
[3]	860	}
	861	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	862	//pop eax
[225]	863	compiler.codeGenerator.op_pop(REG_EAX);
[3]	864
	865	//neg eax
[225]	866	compiler.codeGenerator.op_neg( REG_EAX );
[3]	867
	868	//pop edx
[225]	869	compiler.codeGenerator.op_pop(REG_EDX);
[3]	870
	871	//adc edx,0
[225]	872	compiler.codeGenerator.op_adc_RV8(REG_EDX,0);
[3]	873
	874	//neg edx
[225]	875	compiler.codeGenerator.op_neg( REG_EDX );
[3]	876
	877	//push edx
[225]	878	compiler.codeGenerator.op_push(REG_EDX);
[3]	879
	880	//push eax
[225]	881	compiler.codeGenerator.op_push(REG_EAX);
[3]	882
	883	type[sp-1]=DEF_INT64; //QWordはInt64へ
	884	}
	885	else if(IsWholeNumberType(type[sp-1])){
	886	//pop eax
[225]	887	compiler.codeGenerator.op_pop(REG_EAX);
[3]	888
	889	//imul eax,-1
[225]	890	compiler.codeGenerator.op_imul_RV8( REG_EAX, -1 );
[3]	891
	892	//push eax
[225]	893	compiler.codeGenerator.op_push(REG_EAX);
[3]	894
	895	type[sp-1]=GetSignedType(type[sp-1]);
	896	}
	897
	898	return 1;
	899	}
	900
	901	BOOL Calc_Power(int type,int pStackPointer){
	902	//べき乗（実数演算のみ）
	903
	904	int sp;
	905	sp=*pStackPointer;
	906
	907	if(type[sp-1]==DEF_DOUBLE){
	908	//fld qword ptr[esp]
[225]	909	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	910
	911	//add esp,8
[225]	912	compiler.codeGenerator.op_add_esp(8);
[3]	913	}
	914	else if(type[sp-1]==DEF_SINGLE){
	915	//fld dword ptr[esp]
[225]	916	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	917
	918	//add esp,4
[225]	919	compiler.codeGenerator.op_add_esp(4);
[3]	920	}
	921	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	922	//64ビット整数値
	923
	924	//fild qword ptr[esp]
[225]	925	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	926
	927	//add esp,8
[225]	928	compiler.codeGenerator.op_add_esp(8);
[3]	929	}
	930	else{
	931	//32ビット整数値
	932
	933	//fild dword ptr[esp]
[225]	934	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	935
	936	//add esp,4
[225]	937	compiler.codeGenerator.op_add_esp(4);
[3]	938	}
	939
	940	if(type[sp-2]==DEF_DOUBLE){
	941	//fld qword ptr[esp]
[225]	942	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	943	}
	944	else if(type[sp-2]==DEF_SINGLE){
	945	//fld dword ptr[esp]
[225]	946	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	947
	948	//sub esp,4
[225]	949	compiler.codeGenerator.op_sub_esp(4);
[3]	950	}
	951	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	952	//64ビット整数値
	953
	954	//fild qword ptr[esp]
[225]	955	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	956	}
	957	else{
	958	//32ビット整数値
	959
	960	//fild dword ptr[esp]
[225]	961	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	962
	963	//sub esp,4
[225]	964	compiler.codeGenerator.op_sub_esp(4);
[3]	965	}
	966
	967	//sub esp,8
[225]	968	compiler.codeGenerator.op_sub_esp(8);
[3]	969
	970	//fstp qword ptr[esp]
[225]	971	compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
[3]	972
	973	//fstp qword ptr[esp+8]
[225]	974	compiler.codeGenerator.op_fstp_base_offset(DEF_DOUBLE,REG_ESP,8);
[3]	975
	976	//call pow
[206]	977	extern const UserProc *pSub_pow;
[225]	978	compiler.codeGenerator.op_call(pSub_pow);
[3]	979
	980	//sub esp,8
[225]	981	compiler.codeGenerator.op_sub_esp(8);
[3]	982
	983	//fstp qword ptr[esp]
[225]	984	compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
[3]	985
	986	sp--;
	987	type[sp-1]=DEF_DOUBLE;
	988
	989	*pStackPointer=sp;
	990	return 1;
	991	}
	992
	993	BOOL Calc_Cast(int type,LONG_PTR index_stack,int *pStackPointer){
	994	//キャスト
	995
	996	int sp;
	997	sp=*pStackPointer;
	998
	999	int CastType;
	1000	CastType=type[sp-1];
	1001	if((CastType&FLAG_CAST)==0){
	1002	SetError(47,NULL,cp);
	1003	return 0;
	1004	}
	1005	CastType=CastType&(~FLAG_CAST);
	1006
	1007	if(IsPtrType(CastType)){
	1008	ChangeTypeToLong(type[sp-2]);
	1009	}
	1010	else if(IsRealNumberType(CastType)){
	1011	if(CastType==DEF_DOUBLE) ChangeTypeToDouble(type[sp-2]);
	1012	else if(CastType==DEF_SINGLE) ChangeTypeToSingle(type[sp-2]);
	1013	}
	1014	else ChangeTypeToWhole(type[sp-2],CastType);
	1015
	1016	type[sp-2]=CastType;
	1017	index_stack[sp-2]=index_stack[sp-1];
	1018
	1019	sp--;
	1020
	1021	*pStackPointer=sp;
	1022	return 1;
	1023	}
	1024
	1025	BOOL Calc_SHL(int type,int pStackPointer){
	1026	//左ビットシフト
	1027	//value[sp-2]=value[sp-2]<<value[sp-1]
	1028
	1029	int sp;
	1030	sp=*pStackPointer;
	1031
	1032	if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	1033	////////////////
	1034	// 64ビット演算
	1035	////////////////
	1036
	1037	//2項目は32ビット整数として利用
	1038	if(type[sp-1]==DEF_DOUBLE){
	1039	//fld qword ptr[esp]
[225]	1040	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1041
	1042	//add esp,4
[225]	1043	compiler.codeGenerator.op_add_esp(4);
[3]	1044
	1045	//fistp dword ptr[esp]
[225]	1046	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1047
	1048	//pop ecx
[225]	1049	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1050	}
	1051	else if(type[sp-1]==DEF_SINGLE){
	1052	//fld dword ptr[esp]
[225]	1053	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1054
	1055	//fistp dword ptr[esp]
[225]	1056	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1057
	1058	//pop ecx
[225]	1059	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1060	}
	1061	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	1062	//pop ecx
[225]	1063	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1064
	1065	//add esp,4
[225]	1066	compiler.codeGenerator.op_add_esp(4);
[3]	1067	}
	1068	else{
	1069	//pop ecx
[225]	1070	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1071	}
	1072
	1073	//第1項を64ビットに対応させる
	1074	if(type[sp-2]==DEF_DOUBLE){
	1075	//fld qword ptr[esp]
[225]	1076	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1077
	1078	//fistp qword ptr[esp]
[225]	1079	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
[3]	1080
	1081	//pop eax
[225]	1082	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1083
	1084	//pop edx
[225]	1085	compiler.codeGenerator.op_pop(REG_EDX);
[3]	1086	}
	1087	else if(type[sp-2]==DEF_SINGLE){
	1088	//fld dword ptr[esp]
[225]	1089	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1090
	1091	//sub esp,4
[225]	1092	compiler.codeGenerator.op_sub_esp(4);
[3]	1093
	1094	//fistp qword ptr[esp]
[225]	1095	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
[3]	1096
	1097	//pop eax
[225]	1098	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1099
	1100	//pop edx
[225]	1101	compiler.codeGenerator.op_pop(REG_EDX);
[3]	1102	}
	1103	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	1104	//pop eax
[225]	1105	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1106
	1107	//pop edx
[225]	1108	compiler.codeGenerator.op_pop(REG_EDX);
[3]	1109	}
	1110	else{
	1111	//pop eax
[225]	1112	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1113
	1114	if(IsSignedType(type[sp-2])){
	1115	//符号拡張
	1116	//edx:eax ← eax
	1117
	1118	//cdq
[225]	1119	compiler.codeGenerator.op_cdq();
[3]	1120	}
	1121	else{
	1122	//ビット拡張
	1123	//edx:eax ← eax
	1124
	1125	//xor edx,edx
[225]	1126	compiler.codeGenerator.op_zero_reg(REG_EDX);
[3]	1127	}
	1128	}
	1129
	1130	//call _allshl
[206]	1131	extern const UserProc *pSub_allshl;
[225]	1132	compiler.codeGenerator.op_call(pSub_allshl);
[3]	1133
	1134	//push edx
[225]	1135	compiler.codeGenerator.op_push(REG_EDX);
[3]	1136
	1137	//push eax
[225]	1138	compiler.codeGenerator.op_push(REG_EAX);
[3]	1139
	1140	sp--;
	1141	}
	1142	else{
	1143	////////////////
	1144	// 32ビット演算
	1145	////////////////
	1146
	1147	//2項目は32ビット整数として利用
	1148	if(type[sp-1]==DEF_DOUBLE){
	1149	//fld qword ptr[esp]
[225]	1150	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1151
	1152	//add esp,4
[225]	1153	compiler.codeGenerator.op_add_esp(4);
[3]	1154
	1155	//fistp dword ptr[esp]
[225]	1156	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1157
	1158	//pop ecx
[225]	1159	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1160	}
	1161	else if(type[sp-1]==DEF_SINGLE){
	1162	//fld dword ptr[esp]
[225]	1163	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1164
	1165	//fistp dword ptr[esp]
[225]	1166	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1167
	1168	//pop ecx
[225]	1169	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1170	}
	1171	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	1172	//pop ecx
[225]	1173	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1174
	1175	//add esp,4
[225]	1176	compiler.codeGenerator.op_add_esp(4);
[3]	1177	}
	1178	else{
	1179	//pop ecx
[225]	1180	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1181	}
	1182
	1183	if(type[sp-2]==DEF_DOUBLE){
	1184	//fld qword ptr[esp]
[225]	1185	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1186
	1187	//add esp,4
[225]	1188	compiler.codeGenerator.op_add_esp(4);
[3]	1189
	1190	//fistp dword ptr[esp]
[225]	1191	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1192	}
	1193	else if(type[sp-2]==DEF_SINGLE){
	1194	//fld dword ptr[esp]
[225]	1195	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1196
	1197	//fistp dword ptr[esp]
[225]	1198	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1199	}
	1200
	1201	//pop eax
[225]	1202	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1203
	1204	//sub esp,4
[225]	1205	compiler.codeGenerator.op_sub_esp(4);
[3]	1206
	1207	//shl eax,cl
[225]	1208	compiler.codeGenerator.PutOld(
	1209	(char)0xD3,
	1210	(char)0xE0
	1211	);
[3]	1212
	1213	//mov dword ptr[esp],eax
[225]	1214	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]	1215
	1216	sp--;
	1217
	1218	//32ビット型にする
	1219	if(IsSignedType(type[sp-1])) type[sp-1]=DEF_LONG;
	1220	else type[sp-1]=DEF_DWORD;
	1221	}
	1222
	1223	*pStackPointer=sp;
	1224	return 1;
	1225	}
	1226
	1227	BOOL Calc_SHR(int type,int pStackPointer){
	1228	//右ビットシフト
	1229	//value[sp-2]=value[sp-2]>>value[sp-1]
	1230
	1231	int sp;
	1232	sp=*pStackPointer;
	1233
	1234	if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	1235	////////////////
	1236	// 64ビット演算
	1237	////////////////
	1238
	1239	//2項目は32ビット整数として利用
	1240	if(type[sp-1]==DEF_DOUBLE){
	1241	//fld qword ptr[esp]
[225]	1242	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1243
	1244	//add esp,4
[225]	1245	compiler.codeGenerator.op_add_esp(4);
[3]	1246
	1247	//fistp dword ptr[esp]
[225]	1248	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1249
	1250	//pop ecx
[225]	1251	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1252	}
	1253	else if(type[sp-1]==DEF_SINGLE){
	1254	//fld dword ptr[esp]
[225]	1255	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1256
	1257	//fistp dword ptr[esp]
[225]	1258	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1259
	1260	//pop ecx
[225]	1261	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1262	}
	1263	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	1264	//pop ecx
[225]	1265	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1266
	1267	//add esp,4
[225]	1268	compiler.codeGenerator.op_add_esp(4);
[3]	1269	}
	1270	else{
	1271	//pop ecx
[225]	1272	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1273	}
	1274
	1275	//第1項を64ビットに対応させる
	1276	if(type[sp-2]==DEF_DOUBLE){
	1277	//fld qword ptr[esp]
[225]	1278	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1279
	1280	//fistp qword ptr[esp]
[225]	1281	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
[3]	1282
	1283	//pop eax
[225]	1284	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1285
	1286	//pop edx
[225]	1287	compiler.codeGenerator.op_pop(REG_EDX);
[3]	1288	}
	1289	else if(type[sp-2]==DEF_SINGLE){
	1290	//fld dword ptr[esp]
[225]	1291	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1292
	1293	//sub esp,4
[225]	1294	compiler.codeGenerator.op_sub_esp(4);
[3]	1295
	1296	//fistp qword ptr[esp]
[225]	1297	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
[3]	1298
	1299	//pop eax
[225]	1300	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1301
	1302	//pop edx
[225]	1303	compiler.codeGenerator.op_pop(REG_EDX);
[3]	1304	}
	1305	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	1306	//pop eax
[225]	1307	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1308
	1309	//pop edx
[225]	1310	compiler.codeGenerator.op_pop(REG_EDX);
[3]	1311	}
	1312	else{
	1313	//pop eax
[225]	1314	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1315
	1316	if(IsSignedType(type[sp-2])){
	1317	//符号拡張
	1318	//edx:eax ← eax
	1319
	1320	//cdq
[225]	1321	compiler.codeGenerator.op_cdq();
[3]	1322	}
	1323	else{
	1324	//ビット拡張
	1325	//edx:eax ← eax
	1326
	1327	//xor edx,edx
[225]	1328	compiler.codeGenerator.op_zero_reg(REG_EDX);
[3]	1329	}
	1330	}
	1331
	1332	if(type[sp-2]==DEF_QWORD){
	1333	//符号なし演算
	1334
	1335	//call _aullshr
[206]	1336	extern const UserProc *pSub_aullshr;
[225]	1337	compiler.codeGenerator.op_call(pSub_aullshr);
[3]	1338	}
	1339	else{
	1340	//符号あり演算
	1341
	1342	//call _allshr
[206]	1343	extern const UserProc *pSub_allshr;
[225]	1344	compiler.codeGenerator.op_call(pSub_allshr);
[3]	1345	}
	1346
	1347	//push edx
[225]	1348	compiler.codeGenerator.op_push(REG_EDX);
[3]	1349
	1350	//push eax
[225]	1351	compiler.codeGenerator.op_push(REG_EAX);
[3]	1352
	1353	sp--;
	1354	}
	1355	else{
	1356	////////////////
	1357	// 32ビット演算
	1358	////////////////
	1359
	1360	//2項目は32ビット整数として利用
	1361	if(type[sp-1]==DEF_DOUBLE){
	1362	//fld qword ptr[esp]
[225]	1363	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1364
	1365	//add esp,4
[225]	1366	compiler.codeGenerator.op_add_esp(4);
[3]	1367
	1368	//fistp dword ptr[esp]
[225]	1369	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1370
	1371	//pop ecx
[225]	1372	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1373	}
	1374	else if(type[sp-1]==DEF_SINGLE){
	1375	//fld dword ptr[esp]
[225]	1376	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1377
	1378	//fistp dword ptr[esp]
[225]	1379	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1380
	1381	//pop ecx
[225]	1382	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1383	}
	1384	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	1385	//pop ecx
[225]	1386	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1387
	1388	//add esp,4
[225]	1389	compiler.codeGenerator.op_add_esp(4);
[3]	1390	}
	1391	else{
	1392	//pop ecx
[225]	1393	compiler.codeGenerator.op_pop(REG_ECX);
[3]	1394	}
	1395
	1396	if(type[sp-2]==DEF_DOUBLE){
	1397	//fld qword ptr[esp]
[225]	1398	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1399
	1400	//add esp,4
[225]	1401	compiler.codeGenerator.op_add_esp(4);
[3]	1402
	1403	//fistp dword ptr[esp]
[225]	1404	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1405	}
	1406	else if(type[sp-2]==DEF_SINGLE){
	1407	//fld dword ptr[esp]
[225]	1408	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1409
	1410	//fistp dword ptr[esp]
[225]	1411	compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
[3]	1412	}
	1413
	1414	//pop eax
[225]	1415	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1416
	1417	//sub esp,4
[225]	1418	compiler.codeGenerator.op_sub_esp(4);
[3]	1419
	1420	if(type[sp-2]==DEF_DWORD){
	1421	//shr eax,cl
[225]	1422	compiler.codeGenerator.PutOld(
	1423	(char)0xD3,
	1424	(char)0xE8
	1425	);
[3]	1426	}
	1427	else{
	1428	//sar eax,cl
[225]	1429	compiler.codeGenerator.PutOld(
	1430	(char)0xD3,
	1431	(char)0xF8
	1432	);
[3]	1433	}
	1434
	1435	//mov dword ptr[esp],eax
[225]	1436	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]	1437
	1438	sp--;
	1439
	1440	//整数以外の型だったときはLong型にする
	1441	if(!IsWholeNumberType(type[sp-1])) type[sp-1]=DEF_LONG;
	1442	}
	1443
	1444	*pStackPointer=sp;
	1445	return 1;
	1446	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: