Changeset 225 in dev
- Timestamp:
- Jul 21, 2007, 11:47:40 PM (17 years ago)
- Location:
- trunk/abdev
- Files:
-
- 1 added
- 27 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/abdev/BasicCompiler32/BasicCompiler.vcproj
r215 r225 1117 1117 > 1118 1118 <File 1119 RelativePath=".\CodeGenerator.cpp" 1120 > 1121 <FileConfiguration 1122 Name="Debug|Win32" 1123 > 1124 <Tool 1125 Name="VCCLCompilerTool" 1126 ObjectFile="$(IntDir)\$(InputName)1.obj" 1127 XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc" 1128 /> 1129 </FileConfiguration> 1130 <FileConfiguration 1131 Name="Release|Win32" 1132 > 1133 <Tool 1134 Name="VCCLCompilerTool" 1135 ObjectFile="$(IntDir)\$(InputName)1.obj" 1136 XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc" 1137 /> 1138 </FileConfiguration> 1139 </File> 1140 <File 1119 1141 RelativePath="op32_main.cpp" 1120 1142 > … … 1340 1362 </File> 1341 1363 <File 1364 RelativePath=".\MachineFixed.h" 1365 > 1366 </File> 1367 <File 1342 1368 RelativePath="Opcode.h" 1343 1369 > … … 1420 1446 <File 1421 1447 RelativePath="..\BasicCompiler_Common\include\NamespaceSupporter.h" 1448 > 1449 </File> 1450 <File 1451 RelativePath="..\BasicCompiler_Common\include\NativeCode.h" 1422 1452 > 1423 1453 </File> -
trunk/abdev/BasicCompiler32/CParameter.cpp
r206 r225 1 1 #include "stdafx.h" 2 3 #include <Compiler.h> 2 4 3 5 #include "../BasicCompiler_Common/common.h" … … 72 74 73 75 //push esp 74 op_push( REG_ESP );76 compiler.codeGenerator.op_push( REG_ESP ); 75 77 76 78 nCountOfTempObjects++; … … 111 113 //call free 112 114 extern const UserProc *pSub_free; 113 op_call(pSub_free);115 compiler.codeGenerator.op_call(pSub_free); 114 116 } 115 117 else{ … … 118 120 //pop ... 上位32ビット 119 121 //pop ... 下位32ビット 120 op_add_esp( PTR_SIZE * 3 );122 compiler.codeGenerator.op_add_esp( PTR_SIZE * 3 ); 121 123 } 122 124 else{ 123 125 //pop ... 参照を消す 124 126 //pop ... 値を消す 125 op_add_esp( PTR_SIZE * 2 );127 compiler.codeGenerator.op_add_esp( PTR_SIZE * 2 ); 126 128 } 127 129 } … … 134 136 135 137 //push object_size 136 op_push_V(object_size);138 compiler.codeGenerator.op_push_V(object_size); 137 139 138 140 //call calloc 139 141 extern const UserProc *pSub_calloc; 140 op_call(pSub_calloc);142 compiler.codeGenerator.op_call(pSub_calloc); 141 143 142 144 //push eax(ここでプッシュされた値が実際にパラメータとして引き渡される) 143 op_push(REG_EAX);145 compiler.codeGenerator.op_push(REG_EAX); 144 146 145 147 //push eax 146 op_push(REG_EAX);148 compiler.codeGenerator.op_push(REG_EAX); 147 149 148 150 Type calcType; … … 332 334 333 335 //mov eax, dword ptr[esp+offset] 334 op_mov_RM(336 compiler.codeGenerator.op_mov_RM( 335 337 sizeof(long), 336 338 REG_EAX, … … 340 342 341 343 //push eax 342 op_push(REG_EAX);344 compiler.codeGenerator.op_push(REG_EAX); 343 345 } 344 346 else{ … … 378 380 379 381 //push eax 380 op_push(REG_EAX);382 compiler.codeGenerator.op_push(REG_EAX); 381 383 } 382 384 } -
trunk/abdev/BasicCompiler32/Compile_Calc.cpp
r206 r225 14 14 if(OldType==DEF_DOUBLE){ 15 15 //fld qword ptr[esp] 16 op_fld_ptr_esp(DEF_DOUBLE);16 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 17 17 18 18 //add esp,8 19 op_add_esp(8);19 compiler.codeGenerator.op_add_esp(8); 20 20 } 21 21 else if(OldType==DEF_SINGLE){ 22 22 //fld dword ptr[esp] 23 op_fld_ptr_esp(DEF_SINGLE);23 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 24 24 25 25 //add esp,4 26 op_add_esp(4);26 compiler.codeGenerator.op_add_esp(4); 27 27 } 28 28 else if(OldType==DEF_LONG){ 29 29 //fild dword ptr[esp] 30 op_fld_ptr_esp(DEF_LONG);30 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 31 31 32 32 //add esp,4 33 op_add_esp(4);33 compiler.codeGenerator.op_add_esp(4); 34 34 } 35 35 else if(OldType==DEF_DWORD){ 36 36 //pop eax 37 op_pop(REG_EAX);37 compiler.codeGenerator.op_pop(REG_EAX); 38 38 39 39 //push 0 40 op_push_V(0);40 compiler.codeGenerator.op_push_V(0); 41 41 42 42 //push eax 43 op_push(REG_EAX);43 compiler.codeGenerator.op_push(REG_EAX); 44 44 45 45 //fild qword ptr[esp] 46 OpBuffer[obp++]=(char)0xDF; 47 OpBuffer[obp++]=(char)0x2C; 48 OpBuffer[obp++]=(char)0x24; 46 compiler.codeGenerator.PutOld( 47 (char)0xDF, 48 (char)0x2C, 49 (char)0x24 50 ); 49 51 50 52 //add esp,8 51 op_add_esp(8);53 compiler.codeGenerator.op_add_esp(8); 52 54 } 53 55 } … … 58 60 else if(OldType==DEF_SINGLE){ 59 61 //fld dword ptr[esp] 60 op_fld_ptr_esp(DEF_SINGLE);62 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 61 63 62 64 //sub esp,4 63 op_sub_esp(4);65 compiler.codeGenerator.op_sub_esp(4); 64 66 65 67 //fstp qword ptr[esp] 66 OpBuffer[obp++]=(char)0xDD; 67 OpBuffer[obp++]=(char)0x1C; 68 OpBuffer[obp++]=(char)0x24; 68 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 69 69 } 70 70 else if(OldType==DEF_INT64||OldType==DEF_QWORD){ … … 72 72 73 73 //fild qword ptr[esp] 74 op_fld_ptr_esp(DEF_INT64);74 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 75 75 76 76 //fstp qword ptr[esp] 77 OpBuffer[obp++]=(char)0xDD; 78 OpBuffer[obp++]=(char)0x1C; 79 OpBuffer[obp++]=(char)0x24; 77 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 80 78 } 81 79 else if(IsWholeNumberType(OldType)){ … … 87 85 if(OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)){ 88 86 //pop eax 89 op_pop(REG_EAX);87 compiler.codeGenerator.op_pop(REG_EAX); 90 88 91 89 //movsx eax,ax 92 OpBuffer[obp++]=(char)0x0F; 93 OpBuffer[obp++]=(char)0xBF; 94 OpBuffer[obp++]=(char)0xC0; 90 compiler.codeGenerator.op_movsx_R32R16( REG_EAX ); 95 91 96 92 //push eax 97 op_push(REG_EAX);93 compiler.codeGenerator.op_push(REG_EAX); 98 94 } 99 95 else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){ 100 96 //pop eax 101 op_pop(REG_EAX);97 compiler.codeGenerator.op_pop(REG_EAX); 102 98 103 99 //movsx eax,al 104 OpBuffer[obp++]=(char)0x0F; 105 OpBuffer[obp++]=(char)0xBE; 106 OpBuffer[obp++]=(char)0xC0; 100 compiler.codeGenerator.op_movsx_R32R8( REG_EAX ); 107 101 108 102 //push eax 109 op_push(REG_EAX);103 compiler.codeGenerator.op_push(REG_EAX); 110 104 } 111 105 112 106 //fild dword ptr[esp] 113 op_fld_ptr_esp(DEF_LONG);107 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 114 108 115 109 //sub esp,4 116 op_sub_esp(4);110 compiler.codeGenerator.op_sub_esp(4); 117 111 } 118 112 else{ … … 120 114 121 115 //pop eax 122 op_pop(REG_EAX);116 compiler.codeGenerator.op_pop(REG_EAX); 123 117 124 118 //push 0 125 op_push_V(0);119 compiler.codeGenerator.op_push_V(0); 126 120 127 121 //push eax 128 op_push(REG_EAX);122 compiler.codeGenerator.op_push(REG_EAX); 129 123 130 124 //fild qword ptr[esp] 131 OpBuffer[obp++]=(char)0xDF; 132 OpBuffer[obp++]=(char)0x2C; 133 OpBuffer[obp++]=(char)0x24; 125 compiler.codeGenerator.PutOld( 126 (char)0xDF, 127 (char)0x2C, 128 (char)0x24 129 ); 134 130 } 135 131 136 132 //fstp qword ptr[esp] 137 OpBuffer[obp++]=(char)0xDD; 138 OpBuffer[obp++]=(char)0x1C; 139 OpBuffer[obp++]=(char)0x24; 133 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 140 134 } 141 135 else SetError(9,NULL,cp); … … 147 141 else if(OldType==DEF_DOUBLE){ 148 142 //fld qword ptr[esp] 149 op_fld_ptr_esp(DEF_DOUBLE);143 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 150 144 151 145 //add esp,4 152 op_add_esp(4);146 compiler.codeGenerator.op_add_esp(4); 153 147 154 148 //fstp dword ptr[esp] 155 OpBuffer[obp++]=(char)0xD9; 156 OpBuffer[obp++]=(char)0x1C; 157 OpBuffer[obp++]=(char)0x24; 149 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP ); 158 150 } 159 151 else if(OldType==DEF_INT64||OldType==DEF_QWORD){ … … 161 153 162 154 //fild qword ptr[esp] 163 op_fld_ptr_esp(DEF_INT64);155 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 164 156 165 157 //add esp,4 166 op_add_esp(4);158 compiler.codeGenerator.op_add_esp(4); 167 159 168 160 //fstp dword ptr[esp] 169 OpBuffer[obp++]=(char)0xD9; 170 OpBuffer[obp++]=(char)0x1C; 171 OpBuffer[obp++]=(char)0x24; 161 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP ); 172 162 } 173 163 else if(IsWholeNumberType(OldType)){ … … 179 169 if(OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)){ 180 170 //pop eax 181 op_pop(REG_EAX);171 compiler.codeGenerator.op_pop(REG_EAX); 182 172 183 173 //movsx eax,ax 184 OpBuffer[obp++]=(char)0x0F; 185 OpBuffer[obp++]=(char)0xBF; 186 OpBuffer[obp++]=(char)0xC0; 174 compiler.codeGenerator.op_movsx_R32R16( REG_EAX ); 187 175 188 176 //push eax 189 op_push(REG_EAX);177 compiler.codeGenerator.op_push(REG_EAX); 190 178 } 191 179 else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){ 192 180 //pop eax 193 op_pop(REG_EAX);181 compiler.codeGenerator.op_pop(REG_EAX); 194 182 195 183 //movsx eax,al 196 OpBuffer[obp++]=(char)0x0F; 197 OpBuffer[obp++]=(char)0xBE; 198 OpBuffer[obp++]=(char)0xC0; 184 compiler.codeGenerator.op_movsx_R32R8( REG_EAX ); 199 185 200 186 //push eax 201 op_push(REG_EAX);187 compiler.codeGenerator.op_push(REG_EAX); 202 188 } 203 189 204 190 //fild dword ptr[esp] 205 op_fld_ptr_esp(DEF_LONG);191 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 206 192 } 207 193 else{ … … 209 195 210 196 //fild dword ptr[esp] 211 op_fld_ptr_esp(DEF_LONG);197 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 212 198 } 213 199 214 200 //fstp dword ptr[esp] 215 OpBuffer[obp++]=(char)0xD9; 216 OpBuffer[obp++]=(char)0x1C; 217 OpBuffer[obp++]=(char)0x24; 201 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP ); 218 202 } 219 203 else SetError(9,NULL,cp); … … 227 211 else if(OldType==DEF_DOUBLE){ 228 212 //fld qword ptr[esp] 229 op_fld_ptr_esp(DEF_DOUBLE);213 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 230 214 231 215 //fistp qword ptr[esp] 232 op_fistp_ptr_esp( sizeof(_int64) );216 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 233 217 } 234 218 else if(OldType==DEF_SINGLE){ 235 219 //fld dword ptr[esp] 236 op_fld_ptr_esp(DEF_SINGLE);220 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 237 221 238 222 //sub esp,4 239 op_sub_esp(4);223 compiler.codeGenerator.op_sub_esp(4); 240 224 241 225 //fistp qword ptr[esp] 242 op_fistp_ptr_esp( sizeof(_int64) );226 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 243 227 } 244 228 else if(IsWholeNumberType(OldType)){ … … 249 233 250 234 //pop eax 251 op_pop(REG_EAX);235 compiler.codeGenerator.op_pop(REG_EAX); 252 236 253 237 //cdq 254 op_cdq();238 compiler.codeGenerator.op_cdq(); 255 239 256 240 //push edx 257 op_push(REG_EDX);241 compiler.codeGenerator.op_push(REG_EDX); 258 242 259 243 //push eax 260 op_push(REG_EAX);244 compiler.codeGenerator.op_push(REG_EAX); 261 245 } 262 246 else{ … … 264 248 265 249 //pop eax 266 op_pop(REG_EAX);250 compiler.codeGenerator.op_pop(REG_EAX); 267 251 268 252 //push 0 269 op_push_V(0);253 compiler.codeGenerator.op_push_V(0); 270 254 271 255 //push eax 272 op_push(REG_EAX);256 compiler.codeGenerator.op_push(REG_EAX); 273 257 } 274 258 } … … 281 265 282 266 //fld qword ptr[esp] 283 op_fld_ptr_esp(DEF_DOUBLE);267 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 284 268 285 269 //add esp,4 286 op_add_esp(4);270 compiler.codeGenerator.op_add_esp(4); 287 271 288 272 //fistp dword ptr[esp] 289 op_fistp_ptr_esp( sizeof(long) );273 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 290 274 } 291 275 else if(OldType==DEF_SINGLE){ 292 276 //fld dword ptr[esp] 293 op_fld_ptr_esp(DEF_SINGLE);277 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 294 278 295 279 //fistp dword ptr[esp] 296 op_fistp_ptr_esp( sizeof(long) );280 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 297 281 } 298 282 else if(OldType==DEF_INT64||OldType==DEF_QWORD){ 299 283 //pop eax 300 op_pop(REG_EAX);284 compiler.codeGenerator.op_pop(REG_EAX); 301 285 302 286 //add esp,4 303 op_add_esp(4);287 compiler.codeGenerator.op_add_esp(4); 304 288 305 289 //push eax 306 op_push(REG_EAX);290 compiler.codeGenerator.op_push(REG_EAX); 307 291 } 308 292 } … … 314 298 else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){ 315 299 //pop eax 316 op_pop(REG_EAX);300 compiler.codeGenerator.op_pop(REG_EAX); 317 301 318 302 //movsx eax,al 319 OpBuffer[obp++]=(char)0x0F; 320 OpBuffer[obp++]=(char)0xBE; 321 OpBuffer[obp++]=(char)0xC0; 303 compiler.codeGenerator.op_movsx_R32R8( REG_EAX ); 322 304 323 305 //push eax 324 op_push(REG_EAX);306 compiler.codeGenerator.op_push(REG_EAX); 325 307 } 326 308 else{ … … 328 310 329 311 //pop eax 330 op_pop(REG_EAX);312 compiler.codeGenerator.op_pop(REG_EAX); 331 313 332 314 //and eax,0000FFFFh 333 OpBuffer[obp++]=(char)0x25; 334 *((long *)(OpBuffer+obp))=0x0000FFFF; 335 obp+=sizeof(long); 315 compiler.codeGenerator.op_and_RV( REG_EAX, 0x0000FFFF ); 336 316 337 317 //push eax 338 op_push(REG_EAX);318 compiler.codeGenerator.op_push(REG_EAX); 339 319 } 340 320 } … … 346 326 347 327 //pop eax 348 op_pop(REG_EAX);328 compiler.codeGenerator.op_pop(REG_EAX); 349 329 350 330 //and eax,000000FFh 351 OpBuffer[obp++]=(char)0x25; 352 *((long *)(OpBuffer+obp))=0x000000FF; 353 obp+=sizeof(long); 331 compiler.codeGenerator.op_and_RV( REG_EAX, 0x000000FF ); 354 332 355 333 //push eax 356 op_push(REG_EAX);334 compiler.codeGenerator.op_push(REG_EAX); 357 335 } 358 336 … … 370 348 if(type==DEF_DOUBLE){ 371 349 //fld qword ptr[esp] 372 op_fld_ptr_esp(DEF_DOUBLE);350 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 373 351 374 352 //add esp,8 375 op_add_esp(8);353 compiler.codeGenerator.op_add_esp(8); 376 354 } 377 355 else if(type==DEF_SINGLE){ 378 356 //fld dword ptr[esp] 379 op_fld_ptr_esp(DEF_SINGLE);357 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 380 358 381 359 //add esp,4 382 op_add_esp(4);360 compiler.codeGenerator.op_add_esp(4); 383 361 } 384 362 else if( Is64Type( type ) ){ 385 363 //pop eax 386 op_pop(REG_EAX);364 compiler.codeGenerator.op_pop(REG_EAX); 387 365 388 366 //pop edx 389 op_pop(REG_EDX);367 compiler.codeGenerator.op_pop(REG_EDX); 390 368 } 391 369 else{ 392 370 //pop eax 393 op_pop(REG_EAX);371 compiler.codeGenerator.op_pop(REG_EAX); 394 372 } 395 373 } … … 586 564 587 565 //push eax 588 op_push(REG_EAX);566 compiler.codeGenerator.op_push(REG_EAX); 589 567 } 590 568 … … 639 617 640 618 // call System.[TypeClass]._Create 641 op_call( pUserProc );619 compiler.codeGenerator.op_call( pUserProc ); 642 620 643 621 // push eax 644 op_push( REG_EAX );622 compiler.codeGenerator.op_push( REG_EAX ); 645 623 646 624 calcType = pUserProc->ReturnType(); -
trunk/abdev/BasicCompiler32/Compile_Calc_PushVar.cpp
r206 r225 1 1 #include "stdafx.h" 2 3 #include <Compiler.h> 2 4 3 5 #include "../BasicCompiler_Common/common.h" … … 8 10 if(pRelativeVar->bOffsetOffset){ 9 11 //fld ptr[ecx+offset] 10 op_fld_base_offset(type,REG_ECX,(int)pRelativeVar->offset);12 compiler.codeGenerator.op_fld_base_offset(type,REG_ECX,(int)pRelativeVar->offset); 11 13 obp-=sizeof(long); 12 14 pobj_GlobalVarSchedule->add(); … … 15 17 else{ 16 18 //mov ecx,offset 17 op_mov_RV(REG_ECX,(int)pRelativeVar->offset);19 compiler.codeGenerator.op_mov_RV(REG_ECX,(int)pRelativeVar->offset); 18 20 obp-=sizeof(long); 19 21 pobj_GlobalVarSchedule->add(); … … 21 23 22 24 //fld ptr[ecx] 23 op_fld_basereg(type,REG_ECX);25 compiler.codeGenerator.op_fld_basereg(type,REG_ECX); 24 26 } 25 27 } … … 30 32 if(pRelativeVar->bOffsetOffset){ 31 33 //fld ptr[ebp+ecx+offset] 32 op_fld_base_offset_ex(type,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);34 compiler.codeGenerator.op_fld_base_offset_ex(type,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET); 33 35 obp-=sizeof(long); 34 36 AddLocalVarAddrSchedule(); … … 37 39 else{ 38 40 //fld ptr[ebp+offset] 39 op_fld_base_offset(type,REG_EBP,(int)pRelativeVar->offset);41 compiler.codeGenerator.op_fld_base_offset(type,REG_EBP,(int)pRelativeVar->offset); 40 42 obp-=sizeof(long); 41 43 AddLocalVarAddrSchedule(); … … 46 48 if(pRelativeVar->bOffsetOffset){ 47 49 //add ecx,qword ptr[ebp+offset] 48 op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);50 compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32); 49 51 obp-=sizeof(long); 50 52 AddLocalVarAddrSchedule(); … … 53 55 else{ 54 56 //mov ecx,qword ptr[ebp+offset] 55 op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);57 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32); 56 58 obp-=sizeof(long); 57 59 AddLocalVarAddrSchedule(); … … 64 66 directmem: 65 67 //fld ptr[ecx] 66 op_fld_basereg(type,REG_ECX);68 compiler.codeGenerator.op_fld_basereg(type,REG_ECX); 67 69 } 68 70 } … … 96 98 if(pRelativeVar->bOffsetOffset){ 97 99 //mov reg, ptr[ecx+offset] 98 op_mov_RM(varSize,reg,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32);100 compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32); 99 101 } 100 102 else{ 101 103 //mov reg, ptr[offset] 102 op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset + offsetOf64Head,MOD_DISP32);104 compiler.codeGenerator.op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset + offsetOf64Head,MOD_DISP32); 103 105 } 104 106 obp-=sizeof(long); … … 109 111 if(pRelativeVar->bOffsetOffset){ 110 112 //add ecx,qword ptr[offset] 111 op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);113 compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32); 112 114 } 113 115 else{ 114 116 //mov ecx,qword ptr[offset] 115 op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);117 compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32); 116 118 } 117 119 obp-=sizeof(long); … … 124 126 if(pRelativeVar->bOffsetOffset){ 125 127 //mov reg, ptr[ebp+ecx+offset] 126 op_mov_RM_ex(varSize,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,USE_OFFSET);128 compiler.codeGenerator.op_mov_RM_ex(varSize,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,USE_OFFSET); 127 129 } 128 130 else{ 129 131 //mov reg, ptr[ebp+offset] 130 op_mov_RM(varSize,reg,REG_EBP,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32);132 compiler.codeGenerator.op_mov_RM(varSize,reg,REG_EBP,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32); 131 133 } 132 134 obp-=sizeof(long); … … 137 139 if(pRelativeVar->bOffsetOffset){ 138 140 //add ecx,qword ptr[ebp+offset] 139 op_add_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);141 compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32); 140 142 } 141 143 else{ 142 144 //mov ecx,qword ptr[ebp+offset] 143 op_mov_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);145 compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32); 144 146 } 145 147 obp-=sizeof(long); … … 153 155 if( is64Head ){ 154 156 //mov reg, ptr[ecx] 155 op_mov_RM(varSize,reg,REG_ECX,offsetOf64Head,MOD_BASE_DISP8);157 compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,offsetOf64Head,MOD_BASE_DISP8); 156 158 } 157 159 else{ 158 160 //mov reg, ptr[ecx] 159 op_mov_RM(varSize,reg,REG_ECX,0,MOD_BASE);161 compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,0,MOD_BASE); 160 162 } 161 163 } … … 164 166 165 167 166 167 168 void PushDoubleVariable(RELATIVE_VAR *pRelativeVar){ 168 void PushLongVariable(RELATIVE_VAR *pRelativeVar){ 169 169 if(pRelativeVar->dwKind==VAR_GLOBAL){ 170 170 if(pRelativeVar->bOffsetOffset){ 171 //push dword ptr[ecx+offset+sizeof(long)]172 OpBuffer[obp++]=(char)0xFF;173 OpBuffer[obp++]=(char)0xB1;174 *((long *)(OpBuffer+obp))=pRelativeVar->offset+sizeof(long);175 pobj_GlobalVarSchedule->add();176 obp+=sizeof(long);177 178 171 //push dword ptr[ecx+offset] 179 172 OpBuffer[obp++]=(char)0xFF; … … 184 177 } 185 178 else{ 186 //push dword ptr[offset+sizeof(long)]187 OpBuffer[obp++]=(char)0xFF;188 OpBuffer[obp++]=(char)0x35;189 *((long *)(OpBuffer+obp))=pRelativeVar->offset+sizeof(long);190 pobj_GlobalVarSchedule->add();191 obp+=sizeof(long);192 193 179 //push dword ptr[offset] 194 180 OpBuffer[obp++]=(char)0xFF; … … 200 186 } 201 187 else if(pRelativeVar->dwKind==VAR_REFGLOBAL){ 202 SetError(300,NULL,cp); 188 //mov eax,dword ptr[offset] 189 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 ); 190 obp-=sizeof(long); 191 pobj_GlobalVarSchedule->add(); 192 obp+=sizeof(long); 193 194 if(pRelativeVar->bOffsetOffset){ 195 //add eax,ecx 196 compiler.codeGenerator.op_add_RR( REG_EAX, REG_ECX ); 197 } 198 199 //push dword ptr[eax] 200 compiler.codeGenerator.op_push_M( REG_EAX ); 203 201 } 204 202 else if(pRelativeVar->dwKind==VAR_LOCAL){ 205 203 if(pRelativeVar->bOffsetOffset){ 206 //add ecx,offset +sizeof(long)204 //add ecx,offset 207 205 OpBuffer[obp++]=(char)0x81; 208 206 OpBuffer[obp++]=(char)0xC1; 209 *((long *)(OpBuffer+obp))=pRelativeVar->offset +sizeof(long);207 *((long *)(OpBuffer+obp))=pRelativeVar->offset; 210 208 AddLocalVarAddrSchedule(); 211 209 obp+=sizeof(long); 212 210 213 211 //push dword ptr[ebp+ecx] 214 OpBuffer[obp++]=(char)0xFF; 215 OpBuffer[obp++]=(char)0x74; 216 OpBuffer[obp++]=(char)0x0D; 217 OpBuffer[obp++]=(char)0x00; 218 219 //sub ecx,sizeof(long) 220 OpBuffer[obp++]=(char)0x83; 221 OpBuffer[obp++]=(char)0xE9; 222 OpBuffer[obp++]=(char)0x04; 223 224 //push dword ptr[ebp+ecx] 225 OpBuffer[obp++]=(char)0xFF; 226 OpBuffer[obp++]=(char)0x74; 227 OpBuffer[obp++]=(char)0x0D; 228 OpBuffer[obp++]=(char)0x00; 229 } 230 else{ 231 //push dword ptr[ebp+offset+sizeof(long)] 232 OpBuffer[obp++]=(char)0xFF; 233 OpBuffer[obp++]=(char)0xB5; 234 *((long *)(OpBuffer+obp))=pRelativeVar->offset+sizeof(long); 235 AddLocalVarAddrSchedule(); 236 obp+=sizeof(long); 237 212 compiler.codeGenerator.PutOld( 213 (char)0xFF, 214 (char)0x74, 215 (char)0x0D, 216 (char)0x00 217 ); 218 } 219 else{ 238 220 //push dword ptr[ebp+offset] 239 221 OpBuffer[obp++]=(char)0xFF; … … 254 236 if(pRelativeVar->bOffsetOffset){ 255 237 //add eax,ecx 256 OpBuffer[obp++]=(char)0x03; 257 OpBuffer[obp++]=(char)0xC1; 258 } 259 260 //push dword ptr[eax+sizeof(long)] 261 OpBuffer[obp++]=(char)0xFF; 262 OpBuffer[obp++]=(char)0x70; 263 OpBuffer[obp++]=(char)0x04; 238 compiler.codeGenerator.op_add_RR( REG_EAX, REG_ECX ); 239 } 264 240 265 241 //push dword ptr[eax] 266 OpBuffer[obp++]=(char)0xFF; 267 OpBuffer[obp++]=(char)0x30; 268 } 269 else if(pRelativeVar->dwKind==VAR_DIRECTMEM){ 270 //push dword ptr[ecx+sizeof(long)] 271 OpBuffer[obp++]=(char)0xFF; 272 OpBuffer[obp++]=(char)0xB1; 273 *((long *)(OpBuffer+obp))=sizeof(long); 274 obp+=sizeof(long); 275 276 //push dword ptr[ecx] 277 OpBuffer[obp++]=(char)0xFF; 278 OpBuffer[obp++]=(char)0x31; 279 } 280 } 281 void PushLongVariable(RELATIVE_VAR *pRelativeVar){ 282 if(pRelativeVar->dwKind==VAR_GLOBAL){ 283 if(pRelativeVar->bOffsetOffset){ 284 //push dword ptr[ecx+offset] 285 OpBuffer[obp++]=(char)0xFF; 286 OpBuffer[obp++]=(char)0xB1; 287 *((long *)(OpBuffer+obp))=pRelativeVar->offset; 288 pobj_GlobalVarSchedule->add(); 289 obp+=sizeof(long); 290 } 291 else{ 292 //push dword ptr[offset] 293 OpBuffer[obp++]=(char)0xFF; 294 OpBuffer[obp++]=(char)0x35; 295 *((long *)(OpBuffer+obp))=pRelativeVar->offset; 296 pobj_GlobalVarSchedule->add(); 297 obp+=sizeof(long); 298 } 299 } 300 else if(pRelativeVar->dwKind==VAR_REFGLOBAL){ 301 //mov eax,dword ptr[offset] 302 op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 ); 303 obp-=sizeof(long); 304 pobj_GlobalVarSchedule->add(); 305 obp+=sizeof(long); 306 307 if(pRelativeVar->bOffsetOffset){ 308 //add eax,ecx 309 OpBuffer[obp++]=(char)0x03; 310 OpBuffer[obp++]=(char)0xC1; 311 } 312 313 //push dword ptr[eax] 314 OpBuffer[obp++]=(char)0xFF; 315 OpBuffer[obp++]=(char)0x30; 316 } 317 else if(pRelativeVar->dwKind==VAR_LOCAL){ 318 if(pRelativeVar->bOffsetOffset){ 319 //add ecx,offset 320 OpBuffer[obp++]=(char)0x81; 321 OpBuffer[obp++]=(char)0xC1; 322 *((long *)(OpBuffer+obp))=pRelativeVar->offset; 323 AddLocalVarAddrSchedule(); 324 obp+=sizeof(long); 325 326 //push dword ptr[ebp+ecx] 327 OpBuffer[obp++]=(char)0xFF; 328 OpBuffer[obp++]=(char)0x74; 329 OpBuffer[obp++]=(char)0x0D; 330 OpBuffer[obp++]=(char)0x00; 331 } 332 else{ 333 //push dword ptr[ebp+offset] 334 OpBuffer[obp++]=(char)0xFF; 335 OpBuffer[obp++]=(char)0xB5; 336 *((long *)(OpBuffer+obp))=pRelativeVar->offset; 337 AddLocalVarAddrSchedule(); 338 obp+=sizeof(long); 339 } 340 } 341 else if(pRelativeVar->dwKind==VAR_REFLOCAL){ 342 //mov eax,dword ptr[ebp+offset] 343 OpBuffer[obp++]=(char)0x8B; 344 OpBuffer[obp++]=(char)0x85; 345 *((long *)(OpBuffer+obp))=pRelativeVar->offset; 346 AddLocalVarAddrSchedule(); 347 obp+=sizeof(long); 348 349 if(pRelativeVar->bOffsetOffset){ 350 //add eax,ecx 351 OpBuffer[obp++]=(char)0x03; 352 OpBuffer[obp++]=(char)0xC1; 353 } 354 355 //push dword ptr[eax] 356 OpBuffer[obp++]=(char)0xFF; 357 OpBuffer[obp++]=(char)0x30; 242 compiler.codeGenerator.op_push_M( REG_EAX ); 358 243 } 359 244 else if(pRelativeVar->dwKind==VAR_DIRECTMEM){ 360 245 //push dword ptr[ecx] 361 OpBuffer[obp++]=(char)0xFF; 362 OpBuffer[obp++]=(char)0x31; 246 compiler.codeGenerator.op_push_M( REG_ECX ); 363 247 } 364 248 } 365 void PushIntegerVariable(RELATIVE_VAR *pRelativeVar){366 if(pRelativeVar->dwKind==VAR_GLOBAL){367 if(pRelativeVar->bOffsetOffset){368 //movsx eax,word ptr[ecx+offset]369 OpBuffer[obp++]=(char)0x0F;370 OpBuffer[obp++]=(char)0xBF;371 OpBuffer[obp++]=(char)0x81;372 *((long *)(OpBuffer+obp))=pRelativeVar->offset;373 pobj_GlobalVarSchedule->add();374 obp+=sizeof(long);375 }376 else{377 //movsx eax,word ptr[offset]378 OpBuffer[obp++]=(char)0x0F;379 OpBuffer[obp++]=(char)0xBF;380 OpBuffer[obp++]=(char)0x05;381 *((long *)(OpBuffer+obp))=pRelativeVar->offset;382 pobj_GlobalVarSchedule->add();383 obp+=sizeof(long);384 }385 }386 else if(pRelativeVar->dwKind==VAR_REFGLOBAL){387 //mov ebx,dword ptr[offset]388 op_mov_RM( sizeof(long), REG_EBX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );389 obp-=sizeof(long);390 pobj_GlobalVarSchedule->add();391 obp+=sizeof(long);392 393 if(pRelativeVar->bOffsetOffset){394 //add ebx,ecx395 OpBuffer[obp++]=(char)0x03;396 OpBuffer[obp++]=(char)0xD9;397 }398 399 //movsx eax,word ptr[ebx]400 OpBuffer[obp++]=(char)0x0F;401 OpBuffer[obp++]=(char)0xBF;402 OpBuffer[obp++]=(char)0x03;403 }404 else if(pRelativeVar->dwKind==VAR_LOCAL){405 if(pRelativeVar->bOffsetOffset){406 //add ecx,offset407 OpBuffer[obp++]=(char)0x81;408 OpBuffer[obp++]=(char)0xC1;409 *((long *)(OpBuffer+obp))=pRelativeVar->offset;410 AddLocalVarAddrSchedule();411 obp+=sizeof(long);412 413 //movsx eax,word ptr[ebp+ecx]414 OpBuffer[obp++]=(char)0x0F;415 OpBuffer[obp++]=(char)0xBF;416 OpBuffer[obp++]=(char)0x44;417 OpBuffer[obp++]=(char)0x0D;418 OpBuffer[obp++]=(char)0x00;419 }420 else{421 //movsx eax,word ptr[ebp+offset]422 OpBuffer[obp++]=(char)0x0F;423 OpBuffer[obp++]=(char)0xBF;424 OpBuffer[obp++]=(char)0x85;425 *((long *)(OpBuffer+obp))=pRelativeVar->offset;426 AddLocalVarAddrSchedule();427 obp+=sizeof(long);428 }429 }430 else if(pRelativeVar->dwKind==VAR_REFLOCAL){431 //mov ebx,dword ptr[ebp+offset]432 OpBuffer[obp++]=(char)0x8B;433 OpBuffer[obp++]=(char)0x9D;434 *((long *)(OpBuffer+obp))=pRelativeVar->offset;435 AddLocalVarAddrSchedule();436 obp+=sizeof(long);437 438 if(pRelativeVar->bOffsetOffset){439 //add ebx,ecx440 OpBuffer[obp++]=(char)0x03;441 OpBuffer[obp++]=(char)0xD9;442 }443 444 //movsx eax,word ptr[ebx]445 OpBuffer[obp++]=(char)0x0F;446 OpBuffer[obp++]=(char)0xBF;447 OpBuffer[obp++]=(char)0x03;448 }449 else if(pRelativeVar->dwKind==VAR_DIRECTMEM){450 //movsx eax,word ptr[ecx]451 OpBuffer[obp++]=(char)0x0F;452 OpBuffer[obp++]=(char)0xBF;453 OpBuffer[obp++]=(char)0x01;454 }455 456 //push eax457 op_push(REG_EAX);458 }459 void PushWordVariable(RELATIVE_VAR *pRelativeVar){460 //xor eax,eax(eaxを0に初期化する)461 op_zero_reg(REG_EAX);462 463 if(pRelativeVar->dwKind==VAR_GLOBAL){464 if(pRelativeVar->bOffsetOffset){465 //mov ax,word ptr[ecx+offset]466 OpBuffer[obp++]=(char)0x66;467 OpBuffer[obp++]=(char)0x8B;468 OpBuffer[obp++]=(char)0x81;469 *((long *)(OpBuffer+obp))=pRelativeVar->offset;470 pobj_GlobalVarSchedule->add();471 obp+=sizeof(long);472 }473 else{474 //mov ax,word ptr[offset]475 OpBuffer[obp++]=(char)0x66;476 OpBuffer[obp++]=(char)0xA1;477 *((long *)(OpBuffer+obp))=pRelativeVar->offset;478 pobj_GlobalVarSchedule->add();479 obp+=sizeof(long);480 }481 }482 else if(pRelativeVar->dwKind==VAR_REFGLOBAL){483 //mov ebx,dword ptr[offset]484 op_mov_RM( sizeof(long), REG_EBX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );485 obp-=sizeof(long);486 pobj_GlobalVarSchedule->add();487 obp+=sizeof(long);488 489 if(pRelativeVar->bOffsetOffset){490 //add ebx,ecx491 OpBuffer[obp++]=(char)0x03;492 OpBuffer[obp++]=(char)0xD9;493 }494 495 //mov ax,word ptr[ebx]496 OpBuffer[obp++]=(char)0x66;497 OpBuffer[obp++]=(char)0x8B;498 OpBuffer[obp++]=(char)0x03;499 }500 else if(pRelativeVar->dwKind==VAR_LOCAL){501 if(pRelativeVar->bOffsetOffset){502 //add ecx,offset503 OpBuffer[obp++]=(char)0x81;504 OpBuffer[obp++]=(char)0xC1;505 *((long *)(OpBuffer+obp))=pRelativeVar->offset;506 AddLocalVarAddrSchedule();507 obp+=sizeof(long);508 509 //mov ax,word ptr[ebp+ecx]510 OpBuffer[obp++]=(char)0x66;511 OpBuffer[obp++]=(char)0x8B;512 OpBuffer[obp++]=(char)0x44;513 OpBuffer[obp++]=(char)0x0D;514 OpBuffer[obp++]=(char)0x00;515 }516 else{517 //mov ax,word ptr[ebp+offset]518 OpBuffer[obp++]=(char)0x66;519 OpBuffer[obp++]=(char)0x8B;520 OpBuffer[obp++]=(char)0x85;521 *((long *)(OpBuffer+obp))=pRelativeVar->offset;522 AddLocalVarAddrSchedule();523 obp+=sizeof(long);524 }525 }526 else if(pRelativeVar->dwKind==VAR_REFLOCAL){527 //mov ebx,dword ptr[ebp+offset]528 OpBuffer[obp++]=(char)0x8B;529 OpBuffer[obp++]=(char)0x9D;530 *((long *)(OpBuffer+obp))=pRelativeVar->offset;531 AddLocalVarAddrSchedule();532 obp+=sizeof(long);533 534 if(pRelativeVar->bOffsetOffset){535 //add ebx,ecx536 OpBuffer[obp++]=(char)0x03;537 OpBuffer[obp++]=(char)0xD9;538 }539 540 //mov ax,word ptr[ebx]541 OpBuffer[obp++]=(char)0x66;542 OpBuffer[obp++]=(char)0x8B;543 OpBuffer[obp++]=(char)0x03;544 }545 else if(pRelativeVar->dwKind==VAR_DIRECTMEM){546 //mov ax,word ptr[ecx]547 OpBuffer[obp++]=(char)0x66;548 OpBuffer[obp++]=(char)0x8B;549 OpBuffer[obp++]=(char)0x01;550 }551 552 //push eax553 op_push(REG_EAX);554 }555 void PushCharVariable(RELATIVE_VAR *pRelativeVar){556 if(pRelativeVar->dwKind==VAR_GLOBAL){557 if(pRelativeVar->bOffsetOffset){558 //movsx eax,byte ptr[ecx+offset]559 OpBuffer[obp++]=(char)0x0F;560 OpBuffer[obp++]=(char)0xBE;561 OpBuffer[obp++]=(char)0x81;562 *((long *)(OpBuffer+obp))=pRelativeVar->offset;563 pobj_GlobalVarSchedule->add();564 obp+=sizeof(long);565 }566 else{567 //movsx eax,byte ptr[offset]568 OpBuffer[obp++]=(char)0x0F;569 OpBuffer[obp++]=(char)0xBE;570 OpBuffer[obp++]=(char)0x05;571 *((long *)(OpBuffer+obp))=pRelativeVar->offset;572 pobj_GlobalVarSchedule->add();573 obp+=sizeof(long);574 }575 }576 else if(pRelativeVar->dwKind==VAR_REFGLOBAL){577 //mov ebx,dword ptr[offset]578 op_mov_RM( sizeof(long), REG_EBX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );579 obp-=sizeof(long);580 pobj_GlobalVarSchedule->add();581 obp+=sizeof(long);582 583 if(pRelativeVar->bOffsetOffset){584 //add ebx,ecx585 OpBuffer[obp++]=(char)0x03;586 OpBuffer[obp++]=(char)0xD9;587 }588 589 //movsx eax,byte ptr[ebx]590 OpBuffer[obp++]=(char)0x0F;591 OpBuffer[obp++]=(char)0xBE;592 OpBuffer[obp++]=(char)0x03;593 }594 else if(pRelativeVar->dwKind==VAR_LOCAL){595 if(pRelativeVar->bOffsetOffset){596 //add ecx,offset597 OpBuffer[obp++]=(char)0x81;598 OpBuffer[obp++]=(char)0xC1;599 *((long *)(OpBuffer+obp))=pRelativeVar->offset;600 AddLocalVarAddrSchedule();601 obp+=sizeof(long);602 603 //movsx eax,byte ptr[ebp+ecx]604 OpBuffer[obp++]=(char)0x0F;605 OpBuffer[obp++]=(char)0xBE;606 OpBuffer[obp++]=(char)0x44;607 OpBuffer[obp++]=(char)0x0D;608 OpBuffer[obp++]=(char)0x00;609 }610 else{611 //movsx eax,byte ptr[ebp+offset]612 OpBuffer[obp++]=(char)0x0F;613 OpBuffer[obp++]=(char)0xBE;614 OpBuffer[obp++]=(char)0x85;615 *((long *)(OpBuffer+obp))=pRelativeVar->offset;616 AddLocalVarAddrSchedule();617 obp+=sizeof(long);618 }619 }620 else if(pRelativeVar->dwKind==VAR_REFLOCAL){621 //mov ebx,dword ptr[ebp+offset]622 OpBuffer[obp++]=(char)0x8B;623 OpBuffer[obp++]=(char)0x9D;624 *((long *)(OpBuffer+obp))=pRelativeVar->offset;625 AddLocalVarAddrSchedule();626 obp+=sizeof(long);627 628 if(pRelativeVar->bOffsetOffset){629 //add ebx,ecx630 OpBuffer[obp++]=(char)0x03;631 OpBuffer[obp++]=(char)0xD9;632 }633 634 //movsx eax,byte ptr[ebx]635 OpBuffer[obp++]=(char)0x0F;636 OpBuffer[obp++]=(char)0xBE;637 OpBuffer[obp++]=(char)0x03;638 }639 else if(pRelativeVar->dwKind==VAR_DIRECTMEM){640 //movsx eax,byte ptr[ecx]641 OpBuffer[obp++]=(char)0x0F;642 OpBuffer[obp++]=(char)0xBE;643 OpBuffer[obp++]=(char)0x01;644 }645 646 //push eax647 op_push(REG_EAX);648 }649 void PushByteVariable(RELATIVE_VAR *pRelativeVar){650 //xor eax,eax(eaxを0に初期化する)651 op_zero_reg(REG_EAX);652 653 if(pRelativeVar->dwKind==VAR_GLOBAL){654 if(pRelativeVar->bOffsetOffset){655 //mov al,byte ptr[ecx+offset]656 OpBuffer[obp++]=(char)0x8A;657 OpBuffer[obp++]=(char)0x81;658 *((long *)(OpBuffer+obp))=pRelativeVar->offset;659 pobj_GlobalVarSchedule->add();660 obp+=sizeof(long);661 }662 else{663 //mov al,byte ptr[offset]664 OpBuffer[obp++]=(char)0xA0;665 *((long *)(OpBuffer+obp))=pRelativeVar->offset;666 pobj_GlobalVarSchedule->add();667 obp+=sizeof(long);668 }669 }670 else if(pRelativeVar->dwKind==VAR_REFGLOBAL){671 //mov ebx,dword ptr[offset]672 op_mov_RM( sizeof(long), REG_EBX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );673 obp-=sizeof(long);674 pobj_GlobalVarSchedule->add();675 obp+=sizeof(long);676 677 if(pRelativeVar->bOffsetOffset){678 //add ebx,ecx679 OpBuffer[obp++]=(char)0x03;680 OpBuffer[obp++]=(char)0xD9;681 }682 683 //mov al,byte ptr[ebx]684 OpBuffer[obp++]=(char)0x8A;685 OpBuffer[obp++]=(char)0x03;686 }687 else if(pRelativeVar->dwKind==VAR_LOCAL){688 if(pRelativeVar->bOffsetOffset){689 //add ecx,offset690 OpBuffer[obp++]=(char)0x81;691 OpBuffer[obp++]=(char)0xC1;692 *((long *)(OpBuffer+obp))=pRelativeVar->offset;693 AddLocalVarAddrSchedule();694 obp+=sizeof(long);695 696 //mov al,byte ptr[ebp+ecx]697 OpBuffer[obp++]=(char)0x8A;698 OpBuffer[obp++]=(char)0x44;699 OpBuffer[obp++]=(char)0x0D;700 OpBuffer[obp++]=(char)0x00;701 }702 else{703 //mov al,byte ptr[ebp+offset]704 OpBuffer[obp++]=(char)0x8A;705 OpBuffer[obp++]=(char)0x85;706 *((long *)(OpBuffer+obp))=pRelativeVar->offset;707 AddLocalVarAddrSchedule();708 obp+=sizeof(long);709 }710 }711 else if(pRelativeVar->dwKind==VAR_REFLOCAL){712 //mov ebx,dword ptr[ebp+offset]713 OpBuffer[obp++]=(char)0x8B;714 OpBuffer[obp++]=(char)0x9D;715 *((long *)(OpBuffer+obp))=pRelativeVar->offset;716 AddLocalVarAddrSchedule();717 obp+=sizeof(long);718 719 if(pRelativeVar->bOffsetOffset){720 //add ebx,ecx721 OpBuffer[obp++]=(char)0x03;722 OpBuffer[obp++]=(char)0xD9;723 }724 725 //mov al,byte ptr[ebx]726 OpBuffer[obp++]=(char)0x8A;727 OpBuffer[obp++]=(char)0x03;728 }729 else if(pRelativeVar->dwKind==VAR_DIRECTMEM){730 //mov al,byte ptr[ecx]731 OpBuffer[obp++]=(char)0x8A;732 OpBuffer[obp++]=(char)0x01;733 }734 735 //push eax736 op_push(REG_EAX);737 } -
trunk/abdev/BasicCompiler32/Compile_CallProc.cpp
r206 r225 15 15 //call _System_GetEip 16 16 extern const UserProc *pSub_System_GetEip; 17 op_call(pSub_System_GetEip);17 compiler.codeGenerator.op_call(pSub_System_GetEip); 18 18 19 19 //push eax 20 op_push(REG_EAX);20 compiler.codeGenerator.op_push(REG_EAX); 21 21 22 22 //push ebp 23 op_push(REG_EBP);23 compiler.codeGenerator.op_push(REG_EBP); 24 24 25 25 //call _DebugSys_SaveContext 26 26 extern const UserProc *pSub_DebugSys_SaveContext; 27 op_call(pSub_DebugSys_SaveContext);27 compiler.codeGenerator.op_call(pSub_DebugSys_SaveContext); 28 28 } 29 29 … … 260 260 261 261 //push object_size 262 op_push_V(object_size);262 compiler.codeGenerator.op_push_V(object_size); 263 263 264 264 //call calloc 265 265 extern const UserProc *pSub_calloc; 266 op_call(pSub_calloc);266 compiler.codeGenerator.op_call(pSub_calloc); 267 267 268 268 //push eax 269 op_push(REG_EAX);269 compiler.codeGenerator.op_push(REG_EAX); 270 270 } 271 271 … … 297 297 298 298 // 参照を実体ポインタにする 299 op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );299 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE ); 300 300 } 301 301 } … … 306 306 307 307 //mov ecx,dword ptr[esp+ParmSize] 308 op_mov_RM( sizeof(long), REG_ECX, REG_ESP, ParmSize + tempSize, MOD_BASE_DISP32 );308 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ESP, ParmSize + tempSize, MOD_BASE_DISP32 ); 309 309 } 310 310 else{ … … 315 315 316 316 //push ecx 317 op_push(REG_ECX);317 compiler.codeGenerator.op_push(REG_ECX); 318 318 } 319 319 … … 347 347 348 348 //call ProcAddr 349 op_call(pUserProc);349 compiler.codeGenerator.op_call(pUserProc); 350 350 } 351 351 352 352 if(pUserProc->IsCdecl()){ 353 353 //add esp,ParmSize 354 op_add_esp(ParmSize);354 compiler.codeGenerator.op_add_esp(ParmSize); 355 355 } 356 356 … … 408 408 if(pDllProc->IsCdecl()){ 409 409 //add esp,ParmSize 410 op_add_esp(ParmSize);410 compiler.codeGenerator.op_add_esp(ParmSize); 411 411 } 412 412 -
trunk/abdev/BasicCompiler32/Compile_Func.cpp
r206 r225 33 33 if( resultType.IsDouble() ){ 34 34 //fld qword ptr[esp] 35 op_fld_ptr_esp(DEF_DOUBLE);35 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 36 36 37 37 //fnstcw word ptr[esp] … … 76 76 77 77 //add esp,4 78 op_add_esp(4);78 compiler.codeGenerator.op_add_esp(4); 79 79 } 80 80 else if( resultType.IsSingle() ){ 81 81 //fld dword ptr[esp] 82 op_fld_ptr_esp(DEF_SINGLE);82 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 83 83 84 84 //sub esp,4 85 op_sub_esp(4);85 compiler.codeGenerator.op_sub_esp(4); 86 86 87 87 //fnstcw word ptr[esp] … … 126 126 127 127 //add esp,4 128 op_add_esp(4);128 compiler.codeGenerator.op_add_esp(4); 129 129 } 130 130 else if( resultType.Is64() ){ 131 131 //pop eax 132 op_pop(REG_EAX);132 compiler.codeGenerator.op_pop(REG_EAX); 133 133 134 134 //add esp,4 135 op_add_esp(4);135 compiler.codeGenerator.op_add_esp(4); 136 136 137 137 //push eax 138 op_push(REG_EAX);138 compiler.codeGenerator.op_push(REG_EAX); 139 139 } 140 140 141 141 //pop eax 142 op_pop(REG_EAX);142 compiler.codeGenerator.op_pop(REG_EAX); 143 143 } 144 144 … … 151 151 152 152 //pop eax 153 op_pop(REG_EAX);153 compiler.codeGenerator.op_pop(REG_EAX); 154 154 155 155 //push 0 … … 158 158 159 159 //push eax 160 op_push(REG_EAX);160 compiler.codeGenerator.op_push(REG_EAX); 161 161 162 162 //fild qword ptr[esp] … … 166 166 167 167 //add esp,8 168 op_add_esp(8);168 compiler.codeGenerator.op_add_esp(8); 169 169 } 170 170 void Opcode_Func_Len(const char *Parameter){ … … 193 193 194 194 //pop eax 195 op_pop(REG_EAX);195 compiler.codeGenerator.op_pop(REG_EAX); 196 196 197 197 return; … … 270 270 271 271 //mov ecx,eax 272 op_mov_RR(REG_ECX,REG_EAX);272 compiler.codeGenerator.op_mov_RR(REG_ECX,REG_EAX); 273 273 274 274 //参照タイプが整合しているかをチェック … … 277 277 if(type.IsObjectPtr()){ 278 278 //mov ecx,dword ptr[ecx] 279 op_mov_RM(sizeof(long),REG_ECX,REG_ECX,0,MOD_BASE);279 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ECX,0,MOD_BASE); 280 280 } 281 281 } … … 303 303 //mov eax,dword ptr[edx+func_index] 304 304 if(i2*PTR_SIZE<=0x7F){ 305 op_mov_RM(sizeof(long),REG_EAX,REG_EDX,i2*PTR_SIZE,MOD_BASE_DISP8);305 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,i2*PTR_SIZE,MOD_BASE_DISP8); 306 306 } 307 307 else{ 308 op_mov_RM(sizeof(long),REG_EAX,REG_EDX,i2*PTR_SIZE,MOD_BASE_DISP32);308 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,i2*PTR_SIZE,MOD_BASE_DISP32); 309 309 } 310 310 } … … 331 331 332 332 //mov eax,size 333 op_mov_RV( REG_EAX, typeSize );333 compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize ); 334 334 } 335 335 void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){ … … 362 362 363 363 //mov eax,dword ptr[eax] 364 op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );364 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE ); 365 365 366 366 SetError(-120,NULL,cp); … … 397 397 398 398 //mov eax,dword ptr[eax] 399 op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );399 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE ); 400 400 } 401 401 else{ … … 416 416 if(type==DEF_DOUBLE){ 417 417 //pop eax 418 op_pop(REG_EAX);418 compiler.codeGenerator.op_pop(REG_EAX); 419 419 420 420 //fld qword ptr[eax] … … 424 424 else if(type==DEF_SINGLE||type==DEF_DWORD){ 425 425 //pop eax 426 op_pop(REG_EAX);426 compiler.codeGenerator.op_pop(REG_EAX); 427 427 428 428 //mov eax,dword ptr[eax] … … 432 432 else if(type==DEF_QWORD){ 433 433 //pop ecx 434 op_pop(REG_ECX);434 compiler.codeGenerator.op_pop(REG_ECX); 435 435 436 436 //mov eax,dword ptr[ecx] 437 op_mov_RM(sizeof(long),REG_EAX,REG_ECX,0,MOD_BASE);437 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_ECX,0,MOD_BASE); 438 438 439 439 //mov edx,dword ptr[ecx+sizeof(long)] 440 op_mov_RM(sizeof(long),REG_EDX,REG_ECX,sizeof(long),MOD_BASE_DISP8);440 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EDX,REG_ECX,sizeof(long),MOD_BASE_DISP8); 441 441 } 442 442 else if(type==DEF_WORD){ 443 443 //pop ebx 444 op_pop(REG_EBX);444 compiler.codeGenerator.op_pop(REG_EBX); 445 445 446 446 //xor eax,eax … … 455 455 else if(type==DEF_BYTE){ 456 456 //pop ebx 457 op_pop(REG_EBX);457 compiler.codeGenerator.op_pop(REG_EBX); 458 458 459 459 //xor eax,eax -
trunk/abdev/BasicCompiler32/Compile_Object.cpp
r206 r225 1 1 #include "stdafx.h" 2 3 #include <Compiler.h> 2 4 3 5 #include "../BasicCompiler_Common/common.h" … … 24 26 25 27 //push ebx 26 op_push(REG_EBX);28 compiler.codeGenerator.op_push(REG_EBX); 27 29 } 28 30 29 31 // ※ここでプッシュされた値はコンストラクタのthisポインタとなる 30 32 //push eax 31 op_push(REG_EAX);33 compiler.codeGenerator.op_push(REG_EAX); 32 34 33 35 … … 75 77 76 78 //pop eax 77 op_pop(REG_EAX);79 compiler.codeGenerator.op_pop(REG_EAX); 78 80 79 81 if(bSomeObjects){ 80 82 //pop ebx 81 op_pop(REG_EBX);83 compiler.codeGenerator.op_pop(REG_EBX); 82 84 83 85 //add eax,TypeSize … … 87 89 88 90 //sub ebx,1 89 OpBuffer[obp++]=(char)0x83; 90 OpBuffer[obp++]=(char)0xEB; 91 OpBuffer[obp++]=(char)0x01; 91 compiler.codeGenerator.op_sub_RV8(REG_EBX,1); 92 92 93 93 //jnz ↑ … … 116 116 117 117 //pop eax 118 op_pop(REG_EAX);118 compiler.codeGenerator.op_pop(REG_EAX); 119 119 120 120 //※添え字上限値であることを考慮 … … 142 142 143 143 //push eax 144 op_push(REG_EAX);144 compiler.codeGenerator.op_push(REG_EAX); 145 145 } 146 146 else{ … … 164 164 //call _System_GC_malloc_ForObject 165 165 extern const UserProc *pSub_System_GC_malloc_ForObject; 166 op_call(pSub_System_GC_malloc_ForObject);166 compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObject); 167 167 } 168 168 else{ … … 172 172 //call _System_GC_malloc_ForObjectPtr 173 173 extern const UserProc *pSub_System_GC_malloc_ForObjectPtr; 174 op_call(pSub_System_GC_malloc_ForObjectPtr);174 compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObjectPtr); 175 175 } 176 176 … … 186 186 187 187 //mov dword ptr[eax],ebx(オブジェクトの個数) 188 OpBuffer[obp++]=(char)0x89; 189 OpBuffer[obp++]=(char)0x18; 188 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE ); 190 189 191 190 //add eax,sizeof(DWORD) … … 201 200 202 201 //mov dword ptr[eax],ecx(オブジェクトのサイズ) 203 OpBuffer[obp++]=(char)0x89; 204 OpBuffer[obp++]=(char)0x08; 202 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE ); 205 203 206 204 //add eax,sizeof(DWORD) … … 220 218 221 219 //mov dword ptr[eax],ecx(デストラクタの関数ポインタ) 222 OpBuffer[obp++]=(char)0x89; 223 OpBuffer[obp++]=(char)0x08; 220 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE ); 224 221 225 222 //add eax,sizeof(DWORD) … … 238 235 // ※ここでプッシュされた値はNew演算子の戻り値となる 239 236 //push eax 240 op_push(REG_EAX);237 compiler.codeGenerator.op_push(REG_EAX); 241 238 242 239 … … 257 254 258 255 //pop eax 259 op_pop(REG_EAX);256 compiler.codeGenerator.op_pop(REG_EAX); 260 257 261 258 //sub eax,sizeof(DWORD)*3 262 op_sub_RV8( REG_EAX, OBJECT_HEAD_SIZE );259 compiler.codeGenerator.op_sub_RV8( REG_EAX, OBJECT_HEAD_SIZE ); 263 260 264 261 //push eax 265 op_push(REG_EAX);262 compiler.codeGenerator.op_push(REG_EAX); 266 263 267 264 … … 313 310 314 311 //push ecx 315 op_push(REG_ECX);312 compiler.codeGenerator.op_push(REG_ECX); 316 313 317 314 //push edx 318 op_push(REG_EDX);315 compiler.codeGenerator.op_push(REG_EDX); 319 316 320 317 //push ecx(Thisポインタ ※隠れた第一パラメータ) 321 op_push(REG_ECX);318 compiler.codeGenerator.op_push(REG_ECX); 322 319 323 320 //call edx … … 326 323 327 324 //pop edx 328 op_pop(REG_EDX);325 compiler.codeGenerator.op_pop(REG_EDX); 329 326 330 327 //pop ecx 331 op_pop(REG_ECX);328 compiler.codeGenerator.op_pop(REG_ECX); 332 329 333 330 //add ecx,esi 334 OpBuffer[obp++]=(char)0x03; 335 OpBuffer[obp++]=(char)0xCE; 331 compiler.codeGenerator.op_add_RR( REG_ECX, REG_ESI ); 336 332 337 333 //sub ebx,1 338 OpBuffer[obp++]=(char)0x83; 339 OpBuffer[obp++]=(char)0xEB; 340 OpBuffer[obp++]=(char)0x01; 334 compiler.codeGenerator.op_sub_RV8(REG_EBX,1); 341 335 342 336 //jnz ↑ … … 354 348 //call _System_GC_free_for_SweepingDelete 355 349 extern const UserProc *pSub_System_GC_free_for_SweepingDelete; 356 op_call(pSub_System_GC_free_for_SweepingDelete);350 compiler.codeGenerator.op_call(pSub_System_GC_free_for_SweepingDelete); 357 351 } 358 352 else{ 359 353 //call free 360 354 extern const UserProc *pSub_free; 361 op_call(pSub_free);355 compiler.codeGenerator.op_call(pSub_free); 362 356 } 363 357 } -
trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp
r206 r225 23 23 24 24 //ret 25 op_ret();25 compiler.codeGenerator.op_ret(); 26 26 } 27 27 else if( userProc.GetName() == "_System_InitDllGlobalVariables" ){ … … 33 33 if(!bDll){ 34 34 //ret 35 op_ret();35 compiler.codeGenerator.op_ret(); 36 36 37 37 return; … … 57 57 //_System_StartupProgramの呼び出し 58 58 extern const UserProc *pSub_System_StartupProgram; 59 op_call(pSub_System_StartupProgram);59 compiler.codeGenerator.op_call(pSub_System_StartupProgram); 60 60 61 61 //クラスに属する静的メンバを定義 … … 68 68 69 69 //ret 70 op_ret();70 compiler.codeGenerator.op_ret(); 71 71 } 72 72 else if( userProc.GetName() == "_System_InitStaticLocalVariables" ){ … … 91 91 92 92 //ret 93 op_ret();93 compiler.codeGenerator.op_ret(); 94 94 } 95 95 else if( userProc.GetName() == "_System_Call_Destructor_of_GlobalObject" ){ … … 105 105 106 106 //ret 107 op_ret();107 compiler.codeGenerator.op_ret(); 108 108 } 109 109 else if( userProc.GetName() == "_System_GetSp" ){ 110 110 //mov eax,esp 111 op_mov_RR(REG_EAX,REG_ESP);111 compiler.codeGenerator.op_mov_RR(REG_EAX,REG_ESP); 112 112 113 113 //add eax,PTR_SIZE 114 op_add_RV8(REG_EAX,PTR_SIZE);114 compiler.codeGenerator.op_add_RV8(REG_EAX,PTR_SIZE); 115 115 116 116 //ret 117 op_ret();117 compiler.codeGenerator.op_ret(); 118 118 } 119 119 else if( userProc.GetName() == "_allrem" ){ … … 290 290 compiler.GetNamespaceSupporter().SetImportedNamespaces( pUserProc->GetImportedNamespaces() ); 291 291 292 // コード生成対象を選択 293 compiler.codeGenerator.Select( (const_cast<UserProc *>(pUserProc))->GetNativeCode() ); 294 292 295 if(pUserProc->IsSystem()){ 293 296 //////////////////// … … 369 372 370 373 //sub esp,AllLocalVarSize(スケジュール) 371 op_sub_esp(0xFFFFFFFF);374 compiler.codeGenerator.op_sub_esp(0xFFFFFFFF); 372 375 LocalVarSchedule=obp-sizeof(long); 373 376 374 377 //push ebp 375 op_push(REG_EBP);378 compiler.codeGenerator.op_push(REG_EBP); 376 379 377 380 //mov ebp,esp … … 380 383 381 384 //push ebx 382 op_push(REG_EBX);385 compiler.codeGenerator.op_push(REG_EBX); 383 386 384 387 //push esi … … 460 463 //call _DebugSys_StartProc 461 464 extern const UserProc *pSub_DebugSys_StartProc; 462 op_call(pSub_DebugSys_StartProc);465 compiler.codeGenerator.op_call(pSub_DebugSys_StartProc); 463 466 } 464 467 … … 543 546 544 547 //mov dword ptr[ecx],eax 545 OpBuffer[obp++]=(char)0x89; 546 OpBuffer[obp++]=(char)0x01; 548 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ECX, 0, MOD_BASE ); 547 549 } 548 550 } … … 653 655 //call _DebugSys_EndProc 654 656 extern const UserProc *pSub_DebugSys_EndProc; 655 op_call(pSub_DebugSys_EndProc);657 compiler.codeGenerator.op_call(pSub_DebugSys_EndProc); 656 658 } 657 659 … … 672 674 if( i3==DEF_OBJECT ){ 673 675 //mov eax,dword ptr[eax] 674 op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );676 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE ); 675 677 } 676 678 } … … 717 719 else if(i3==DEF_INTEGER||i3==DEF_WORD || (Smoothie::IsUnicode()&&i3==DEF_CHAR)){ 718 720 //xor eax,eax(eaxを0に初期化する) 719 op_zero_reg(REG_EAX);721 compiler.codeGenerator.op_zero_reg(REG_EAX); 720 722 721 723 //mov ax,word ptr[ebp+offset] … … 729 731 else if(i3==DEF_SBYTE||i3==DEF_BYTE||i3==DEF_BOOLEAN || (Smoothie::IsUnicode()==false&&i3==DEF_CHAR)){ 730 732 //xor eax,eax(eaxを0に初期化する) 731 op_zero_reg(REG_EAX);733 compiler.codeGenerator.op_zero_reg(REG_EAX); 732 734 733 735 //mov al,byte ptr[ebp+offset] … … 763 765 764 766 //pop ebx 765 op_pop(REG_EBX);767 compiler.codeGenerator.op_pop(REG_EBX); 766 768 767 769 if(bDebugCompile){ 768 770 //cmp esp,ebp 769 op_cmp_RR( REG_ESP, REG_EBP );771 compiler.codeGenerator.op_cmp_RR( REG_ESP, REG_EBP ); 770 772 771 773 //jz 6(次のcallとbreakpointを飛び越す) … … 775 777 //call _esp_error 776 778 extern const UserProc *pSub_esp_error; 777 op_call( pSub_esp_error );779 compiler.codeGenerator.op_call( pSub_esp_error ); 778 780 779 781 breakpoint; … … 785 787 786 788 //pop ebp 787 op_pop(REG_EBP);789 compiler.codeGenerator.op_pop(REG_EBP); 788 790 789 791 //add esp AllLocalVarSize 790 op_add_esp(AllLocalVarSize-BaseOffset);792 compiler.codeGenerator.op_add_esp(AllLocalVarSize-BaseOffset); 791 793 792 794 if( BaseOffset==0 || pUserProc->IsCdecl() ){ 793 795 //ret 794 op_ret();796 compiler.codeGenerator.op_ret(); 795 797 } 796 798 else{ -
trunk/abdev/BasicCompiler32/Compile_Set_Var.cpp
r206 r225 2 2 3 3 #include <jenga/include/smoothie/Smoothie.h> 4 5 #include <Compiler.h> 4 6 5 7 #include "../BasicCompiler_Common/common.h" … … 21 23 22 24 //mov ecx,object_size 23 op_mov_RV(REG_ECX,object_size);25 compiler.codeGenerator.op_mov_RV(REG_ECX,object_size); 24 26 25 27 //pop esi 26 op_pop(REG_ESI);28 compiler.codeGenerator.op_pop(REG_ESI); 27 29 28 30 //pop edi 29 op_pop(REG_EDI);31 compiler.codeGenerator.op_pop(REG_EDI); 30 32 31 33 if(bUseHeap){ 32 34 //mov eax,esi 33 op_mov_RR(REG_EAX,REG_ESI);35 compiler.codeGenerator.op_mov_RR(REG_EAX,REG_ESI); 34 36 } 35 37 36 38 //rep movs byte ptr[edi],byte ptr[esi] 37 op_rep_movs(sizeof(BYTE));39 compiler.codeGenerator.op_rep_movs(sizeof(BYTE)); 38 40 39 41 if(bUseHeap){ 40 42 //push eax 41 op_push(REG_EAX);43 compiler.codeGenerator.op_push(REG_EAX); 42 44 43 45 //call free 44 46 extern const UserProc *pSub_free; 45 op_call(pSub_free);47 compiler.codeGenerator.op_call(pSub_free); 46 48 } 47 49 … … 64 66 65 67 //push edx 66 op_push( REG_EDX );68 compiler.codeGenerator.op_push( REG_EDX ); 67 69 68 70 //push eax 69 op_push( REG_EAX );71 compiler.codeGenerator.op_push( REG_EAX ); 70 72 71 73 //fild qword ptr[esp] 72 op_fld_ptr_esp(DEF_INT64);74 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 73 75 74 76 //pop 75 op_pop( REG_NON );77 compiler.codeGenerator.op_pop( REG_NON ); 76 78 77 79 //pop 78 op_pop( REG_NON );80 compiler.codeGenerator.op_pop( REG_NON ); 79 81 } 80 82 else{ 81 83 //push eax 82 op_push( REG_EAX );84 compiler.codeGenerator.op_push( REG_EAX ); 83 85 84 86 //fild qword ptr[esp] 85 op_fld_ptr_esp(DEF_LONG);87 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 86 88 87 89 //pop 88 op_pop( REG_NON );90 compiler.codeGenerator.op_pop( REG_NON ); 89 91 } 90 92 } … … 93 95 if(pRelativeVar->bOffsetOffset){ 94 96 //fstp ptr[ecx+offset] 95 op_fstp_base_offset(VarType,REG_ECX,(int)pRelativeVar->offset);97 compiler.codeGenerator.op_fstp_base_offset(VarType,REG_ECX,(int)pRelativeVar->offset); 96 98 obp-=sizeof(long); 97 99 pobj_GlobalVarSchedule->add(); … … 100 102 else{ 101 103 //mov ecx,offset 102 op_mov_RV(REG_ECX,(int)pRelativeVar->offset);104 compiler.codeGenerator.op_mov_RV(REG_ECX,(int)pRelativeVar->offset); 103 105 obp-=sizeof(long); 104 106 pobj_GlobalVarSchedule->add(); … … 106 108 107 109 //fstp ptr[ecx] 108 op_fstp_basereg(VarType,REG_ECX);110 compiler.codeGenerator.op_fstp_basereg(VarType,REG_ECX); 109 111 } 110 112 } … … 112 114 if(pRelativeVar->bOffsetOffset){ 113 115 //add ecx,qword ptr[offset] 114 op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);116 compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32); 115 117 } 116 118 else{ 117 119 //mov ecx,qword ptr[offset] 118 op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);120 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32); 119 121 } 120 122 obp-=sizeof(long); … … 127 129 if(pRelativeVar->bOffsetOffset){ 128 130 //fstp ptr[ebp+ecx+offset] 129 op_fstp_base_offset_ex(VarType,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);131 compiler.codeGenerator.op_fstp_base_offset_ex(VarType,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET); 130 132 } 131 133 else{ 132 134 //fstp ptr[ebp+offset] 133 op_fstp_base_offset(VarType,REG_EBP,(int)pRelativeVar->offset);135 compiler.codeGenerator.op_fstp_base_offset(VarType,REG_EBP,(int)pRelativeVar->offset); 134 136 } 135 137 obp-=sizeof(long); … … 140 142 if(pRelativeVar->bOffsetOffset){ 141 143 //add ecx,qword ptr[ebp+offset] 142 op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);144 compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32); 143 145 } 144 146 else{ 145 147 //mov ecx,qword ptr[ebp+offset] 146 op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);148 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32); 147 149 } 148 150 obp-=sizeof(long); … … 155 157 directmem: 156 158 //fstp ptr[ecx] 157 op_fstp_basereg(VarType,REG_ECX);159 compiler.codeGenerator.op_fstp_basereg(VarType,REG_ECX); 158 160 } 159 161 } … … 170 172 else if(type==DEF_INT64||type==DEF_QWORD){ 171 173 //cmp eax,0 172 op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);174 compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_EAX,0); 173 175 174 176 //setne al 175 op_setne( REG_EAX );177 compiler.codeGenerator.op_setne( REG_EAX ); 176 178 177 179 //cmp edx,0 178 op_cmp_value(GetTypeSize(type,-1),REG_EDX,0);180 compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_EDX,0); 179 181 180 182 //setne cl 181 op_setne( REG_ECX );183 compiler.codeGenerator.op_setne( REG_ECX ); 182 184 183 185 //or al,cl 184 op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );186 compiler.codeGenerator.op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX ); 185 187 } 186 188 else{ … … 193 195 194 196 //cmp eax,0 195 op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);197 compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_EAX,0); 196 198 197 199 //setne al 198 op_setne( REG_EAX );200 compiler.codeGenerator.op_setne( REG_EAX ); 199 201 200 202 SetWholeVariable( sizeof(char), DEF_BYTE, pRelative ); … … 209 211 if(IsSignedType(type)){ 210 212 //cdq 211 op_cdq();213 compiler.codeGenerator.op_cdq(); 212 214 } 213 215 else{ 214 216 //xor edx,edx 215 op_zero_reg(REG_EDX);217 compiler.codeGenerator.op_zero_reg(REG_EDX); 216 218 } 217 219 } … … 219 221 if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){ 220 222 //movsx reg32,reg16 221 op_movsx_R32R16(reg,reg);223 compiler.codeGenerator.op_movsx_R32R16(reg,reg); 222 224 } 223 225 else if(type==DEF_WORD){ 224 226 //and reg,0000FFFFh 225 op_and_RV(reg,(int)0x0000FFFF);227 compiler.codeGenerator.op_and_RV(reg,(int)0x0000FFFF); 226 228 } 227 229 else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){ 228 230 //movsx reg32,reg8 229 op_movsx_R32R8(reg,reg);231 compiler.codeGenerator.op_movsx_R32R8(reg,reg); 230 232 } 231 233 else if(type==DEF_BYTE||type==DEF_BOOLEAN){ 232 234 //and reg,000000FFh 233 op_and_RV(reg,(int)0xFF);235 compiler.codeGenerator.op_and_RV(reg,(int)0xFF); 234 236 } 235 237 } … … 237 239 if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){ 238 240 //movsx reg16,reg8 239 op_movsx_R16R8(reg,reg);241 compiler.codeGenerator.op_movsx_R16R8(reg,reg); 240 242 } 241 243 else if(type==DEF_BYTE||type==DEF_BOOLEAN){ 242 244 //and reg,000000FFh 243 op_and_RV(reg,(int)0xFF);245 compiler.codeGenerator.op_and_RV(reg,(int)0xFF); 244 246 } 245 247 } … … 256 258 //push 257 259 //push 258 op_sub_esp( PTR_SIZE * 2 );260 compiler.codeGenerator.op_sub_esp( PTR_SIZE * 2 ); 259 261 260 262 //fistp qword ptr[esp] 261 op_fistp_ptr_esp( sizeof(_int64) );263 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 262 264 263 265 //pop eax 264 op_pop( REG_EAX );266 compiler.codeGenerator.op_pop( REG_EAX ); 265 267 266 268 //pop edx 267 op_pop( REG_EDX );269 compiler.codeGenerator.op_pop( REG_EDX ); 268 270 } 269 271 else{ … … 272 274 273 275 //push 274 op_push( REG_NON );276 compiler.codeGenerator.op_push( REG_NON ); 275 277 276 278 //fistp dword ptr[esp] 277 op_fistp_ptr_esp( sizeof(long) );279 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 278 280 279 281 //pop eax 280 op_pop( REG_EAX );282 compiler.codeGenerator.op_pop( REG_EAX ); 281 283 } 282 284 } … … 310 312 311 313 //mov ecx,eax 312 op_mov_RR( REG_ECX, REG_EAX );314 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EAX ); 313 315 314 316 //add ecx,sizeof(long) 315 op_add_RV8( REG_ECX, sizeof(long) );317 compiler.codeGenerator.op_add_RV8( REG_ECX, sizeof(long) ); 316 318 317 319 //mov eax,edx 318 op_mov_RR( REG_EAX, REG_EDX );320 compiler.codeGenerator.op_mov_RR( REG_EAX, REG_EDX ); 319 321 320 322 SetWholeVariable(sizeof(long),DEF_LONG,pRelative); … … 326 328 if(pRelative->bOffsetOffset){ 327 329 //mov ptr[ecx+offset],eax/ax/al 328 op_mov_MR(varSize,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);330 compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32); 329 331 } 330 332 else{ 331 333 //mov ptr[offset],eax/ax/al 332 op_mov_MR(varSize,REG_EAX,0,(int)pRelative->offset,MOD_DISP32);334 compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,0,(int)pRelative->offset,MOD_DISP32); 333 335 } 334 336 obp-=sizeof(long); … … 342 344 if(pRelative->bOffsetOffset){ 343 345 //add ecx,qword ptr[offset] 344 op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);346 compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32); 345 347 } 346 348 else{ 347 349 //mov ecx,qword ptr[offset] 348 op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);350 compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32); 349 351 } 350 352 obp-=sizeof(long); … … 357 359 if(pRelative->bOffsetOffset){ 358 360 //mov ptr[ebp+ecx+offset],eax/ax/al 359 op_mov_MR_ex(varSize,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);361 compiler.codeGenerator.op_mov_MR_ex(varSize,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET); 360 362 } 361 363 else{ 362 364 //mov ptr[ebp+offset],eax/ax/al 363 op_mov_MR(varSize,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);365 compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32); 364 366 } 365 367 obp-=sizeof(long); … … 370 372 if(pRelative->bOffsetOffset){ 371 373 //add ecx,ptr[ebp+offset] 372 op_add_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);374 compiler.codeGenerator.op_add_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32); 373 375 } 374 376 else{ 375 377 //mov ecx,ptr[ebp+offset] 376 op_mov_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);378 compiler.codeGenerator.op_mov_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32); 377 379 } 378 380 obp-=sizeof(long); … … 386 388 387 389 //mov ptr[ecx],eax/ax/al 388 op_mov_MR(varSize,REG_EAX,REG_ECX,0,MOD_BASE);389 } 390 } 390 compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_ECX,0,MOD_BASE); 391 } 392 } -
trunk/abdev/BasicCompiler32/Compile_Statement.cpp
r206 r225 110 110 else if( resultType.IsStruct() ){ 111 111 //mov ebx,eax 112 op_mov_RR(REG_EBX,REG_EAX);112 compiler.codeGenerator.op_mov_RR(REG_EBX,REG_EAX); 113 113 114 114 FreeTempObject(REG_EBX,&resultType.GetClass()); … … 144 144 else if( tempType.IsDouble() ){ 145 145 //fld qword ptr[esp] 146 op_fld_ptr_esp(DEF_DOUBLE);146 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 147 147 148 148 //push 0 149 op_push_V(0);149 compiler.codeGenerator.op_push_V(0); 150 150 151 151 //fild dword ptr[esp] 152 op_fld_ptr_esp(DEF_LONG);152 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 153 153 154 154 //add esp,sizeof(double)+sizeof(long) 155 op_add_esp(sizeof(double)+sizeof(long));155 compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long)); 156 156 157 157 //fcompp 158 OpBuffer[obp++]=(char)0xDE; 159 OpBuffer[obp++]=(char)0xD9; 158 compiler.codeGenerator.op_fcompp(); 160 159 161 160 //fnstsw ax 162 OpBuffer[obp++]=(char)0xDF; 163 OpBuffer[obp++]=(char)0xE0; 161 compiler.codeGenerator.op_fnstsw_ax(); 164 162 165 163 //test ah,40 166 OpBuffer[obp++]=(char)0xF6; 167 OpBuffer[obp++]=(char)0xC4; 168 OpBuffer[obp++]=(char)0x40; 164 compiler.codeGenerator.op_test_ah( (char)0x40 ); 169 165 170 166 //jne (endif、または else まで) … … 178 174 else if( tempType.IsSingle() ){ 179 175 //fld dword ptr[esp] 180 op_fld_ptr_esp(DEF_SINGLE);176 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 181 177 182 178 //push 0 183 op_push_V(0);179 compiler.codeGenerator.op_push_V(0); 184 180 185 181 //fild dword ptr[esp] 186 op_fld_ptr_esp(DEF_LONG);182 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 187 183 188 184 //add esp,sizeof(float)+sizeof(long) 189 op_add_esp(sizeof(float)+sizeof(long));185 compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long)); 190 186 191 187 //fcompp 192 OpBuffer[obp++]=(char)0xDE; 193 OpBuffer[obp++]=(char)0xD9; 188 compiler.codeGenerator.op_fcompp(); 194 189 195 190 //fnstsw ax 196 OpBuffer[obp++]=(char)0xDF; 197 OpBuffer[obp++]=(char)0xE0; 191 compiler.codeGenerator.op_fnstsw_ax(); 198 192 199 193 //test ah,40 200 OpBuffer[obp++]=(char)0xF6; 201 OpBuffer[obp++]=(char)0xC4; 202 OpBuffer[obp++]=(char)0x40; 194 compiler.codeGenerator.op_test_ah( (char)0x40 ); 203 195 204 196 //jne (endif、または else まで) … … 214 206 215 207 //pop eax 216 op_pop(REG_EAX);208 compiler.codeGenerator.op_pop(REG_EAX); 217 209 218 210 //pop ebx 219 op_pop(REG_EBX);211 compiler.codeGenerator.op_pop(REG_EBX); 220 212 221 213 //cmp eax,0 … … 258 250 259 251 //pop eax 260 op_pop(REG_EAX);252 compiler.codeGenerator.op_pop(REG_EAX); 261 253 262 254 //cmp eax,0 … … 401 393 else if( tempType.IsDouble() ){ 402 394 //fld qword ptr[esp] 403 op_fld_ptr_esp(DEF_DOUBLE);395 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 404 396 405 397 //push 0 406 op_push_V(0);398 compiler.codeGenerator.op_push_V(0); 407 399 408 400 //fild dword ptr[esp] 409 op_fld_ptr_esp(DEF_LONG);401 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 410 402 411 403 //add esp,sizeof(double)+sizeof(long) 412 op_add_esp(sizeof(double)+sizeof(long));404 compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long)); 413 405 414 406 //fcompp 415 OpBuffer[obp++]=(char)0xDE; 416 OpBuffer[obp++]=(char)0xD9; 407 compiler.codeGenerator.op_fcompp(); 417 408 418 409 //fnstsw ax 419 OpBuffer[obp++]=(char)0xDF; 420 OpBuffer[obp++]=(char)0xE0; 410 compiler.codeGenerator.op_fnstsw_ax(); 421 411 422 412 //test ah,40 423 OpBuffer[obp++]=(char)0xF6; 424 OpBuffer[obp++]=(char)0xC4; 425 OpBuffer[obp++]=(char)0x40; 413 compiler.codeGenerator.op_test_ah( (char)0x40 ); 426 414 427 415 //jne (Wend まで) … … 435 423 else if( tempType.IsSingle() ){ 436 424 //fld dword ptr[esp] 437 op_fld_ptr_esp(DEF_SINGLE);425 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 438 426 439 427 //push 0 440 op_push_V(0);428 compiler.codeGenerator.op_push_V(0); 441 429 442 430 //fild dword ptr[esp] 443 op_fld_ptr_esp(DEF_LONG);431 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 444 432 445 433 //add esp,sizeof(float)+sizeof(long) 446 op_add_esp(sizeof(float)+sizeof(long));434 compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long)); 447 435 448 436 //fcompp 449 OpBuffer[obp++]=(char)0xDE; 450 OpBuffer[obp++]=(char)0xD9; 437 compiler.codeGenerator.op_fcompp(); 451 438 452 439 //fnstsw ax 453 OpBuffer[obp++]=(char)0xDF; 454 OpBuffer[obp++]=(char)0xE0; 440 compiler.codeGenerator.op_fnstsw_ax(); 455 441 456 442 //test ah,40 457 OpBuffer[obp++]=(char)0xF6; 458 OpBuffer[obp++]=(char)0xC4; 459 OpBuffer[obp++]=(char)0x40; 443 compiler.codeGenerator.op_test_ah( (char)0x40 ); 460 444 461 445 //jne (Wend まで) … … 471 455 472 456 //pop eax 473 op_pop(REG_EAX);457 compiler.codeGenerator.op_pop(REG_EAX); 474 458 475 459 //pop ebx 476 op_pop(REG_EBX);460 compiler.codeGenerator.op_pop(REG_EBX); 477 461 478 462 //cmp eax,0 … … 514 498 515 499 //pop eax 516 op_pop(REG_EAX);500 compiler.codeGenerator.op_pop(REG_EAX); 517 501 518 502 //cmp eax,0 … … 616 600 617 601 //pop eax 618 op_pop(REG_EAX);602 compiler.codeGenerator.op_pop(REG_EAX); 619 603 620 604 //cmp eax,0 … … 634 618 635 619 //pop eax 636 op_pop(REG_EAX);620 compiler.codeGenerator.op_pop(REG_EAX); 637 621 638 622 //jmp [カウンタ減少の場合の判定を飛び越す] … … 648 632 649 633 //pop eax 650 op_pop(REG_EAX);634 compiler.codeGenerator.op_pop(REG_EAX); 651 635 652 636 *((long *)(OpBuffer+i3))=obp-(i3+sizeof(long)); //jmpジャンプ先のオフセット値 … … 737 721 if( tempType.IsDouble() ){ 738 722 //fld qword ptr[esp] 739 op_fld_ptr_esp(DEF_DOUBLE);723 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 740 724 741 725 //push 0 742 op_push_V(0);726 compiler.codeGenerator.op_push_V(0); 743 727 744 728 //fild dword ptr[esp] 745 op_fld_ptr_esp(DEF_LONG);729 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 746 730 747 731 //add esp,sizeof(double)+sizeof(long) 748 op_add_esp(sizeof(double)+sizeof(long));732 compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long)); 749 733 750 734 //fcompp 751 OpBuffer[obp++]=(char)0xDE; 752 OpBuffer[obp++]=(char)0xD9; 735 compiler.codeGenerator.op_fcompp(); 753 736 754 737 //fnstsw ax 755 OpBuffer[obp++]=(char)0xDF; 756 OpBuffer[obp++]=(char)0xE0; 738 compiler.codeGenerator.op_fnstsw_ax(); 757 739 758 740 //test ah,40 759 OpBuffer[obp++]=(char)0xF6; 760 OpBuffer[obp++]=(char)0xC4; 761 OpBuffer[obp++]=(char)0x40; 741 compiler.codeGenerator.op_test_ah( (char)0x40 ); 762 742 763 743 if(basbuf[i3]=='0'){ … … 778 758 else if( tempType.IsSingle() ){ 779 759 //fld dword ptr[esp] 780 op_fld_ptr_esp(DEF_SINGLE);760 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 781 761 782 762 //push 0 783 op_push_V(0);763 compiler.codeGenerator.op_push_V(0); 784 764 785 765 //fild dword ptr[esp] 786 op_fld_ptr_esp(DEF_LONG);766 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 787 767 788 768 //add esp,sizeof(float)+sizeof(long) 789 op_add_esp(sizeof(float)+sizeof(long));769 compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long)); 790 770 791 771 //fcompp 792 OpBuffer[obp++]=(char)0xDE; 793 OpBuffer[obp++]=(char)0xD9; 772 compiler.codeGenerator.op_fcompp(); 794 773 795 774 //fnstsw ax 796 OpBuffer[obp++]=(char)0xDF; 797 OpBuffer[obp++]=(char)0xE0; 775 compiler.codeGenerator.op_fnstsw_ax(); 798 776 799 777 //test ah,40 800 OpBuffer[obp++]=(char)0xF6; 801 OpBuffer[obp++]=(char)0xC4; 802 OpBuffer[obp++]=(char)0x40; 778 compiler.codeGenerator.op_test_ah( (char)0x40 ); 803 779 804 780 if(basbuf[i3]=='0'){ … … 821 797 822 798 //pop eax 823 op_pop(REG_EAX);799 compiler.codeGenerator.op_pop(REG_EAX); 824 800 825 801 //pop ebx 826 op_pop(REG_EBX);802 compiler.codeGenerator.op_pop(REG_EBX); 827 803 828 804 //cmp eax,0 … … 877 853 else{ 878 854 //pop eax 879 op_pop(REG_EAX);855 compiler.codeGenerator.op_pop(REG_EAX); 880 856 881 857 //cmp eax,0 … … 1027 1003 if(sw==0){ 1028 1004 //add esp,CaseTypeSize 1029 op_add_esp(CaseTypeSize);1005 compiler.codeGenerator.op_add_esp(CaseTypeSize); 1030 1006 } 1031 1007 break; … … 1101 1077 1102 1078 //pop edx 1103 op_pop(REG_EDX);1079 compiler.codeGenerator.op_pop(REG_EDX); 1104 1080 1105 1081 //mov ecx,dword ptr[esp] 1106 op_mov_RM(sizeof(long),REG_ECX,REG_ESP,0,MOD_BASE);1082 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ESP,0,MOD_BASE); 1107 1083 1108 1084 //push edx 1109 op_push(REG_EDX);1085 compiler.codeGenerator.op_push(REG_EDX); 1110 1086 1111 1087 //push ecx 1112 op_push(REG_ECX);1088 compiler.codeGenerator.op_push(REG_ECX); 1113 1089 1114 1090 //call operator_proc ※ ==演算子 1115 op_call(pUserProc);1091 compiler.codeGenerator.op_call(pUserProc); 1116 1092 1117 1093 //test eax,eax 1118 op_test(REG_EAX,REG_EAX);1094 compiler.codeGenerator.op_test(REG_EAX,REG_EAX); 1119 1095 1120 1096 //jne ... … … 1128 1104 1129 1105 //fld qword ptr[esp] 1130 op_fld_ptr_esp(DEF_DOUBLE);1106 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1131 1107 1132 1108 //add esp,CaseTypeSize 1133 op_add_esp(CaseTypeSize);1109 compiler.codeGenerator.op_add_esp(CaseTypeSize); 1134 1110 1135 1111 //fld qword ptr[esp] 1136 op_fld_ptr_esp(DEF_DOUBLE);1112 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1137 1113 1138 1114 //fcompp 1139 OpBuffer[obp++]=(char)0xDE; 1140 OpBuffer[obp++]=(char)0xD9; 1115 compiler.codeGenerator.op_fcompp(); 1141 1116 1142 1117 //fnstsw ax 1143 OpBuffer[obp++]=(char)0xDF; 1144 OpBuffer[obp++]=(char)0xE0; 1118 compiler.codeGenerator.op_fnstsw_ax(); 1145 1119 1146 1120 //test ah,40 1147 OpBuffer[obp++]=(char)0xF6; 1148 OpBuffer[obp++]=(char)0xC4; 1149 OpBuffer[obp++]=(char)0x40; 1121 compiler.codeGenerator.op_test_ah( (char)0x40 ); 1150 1122 1151 1123 //jne ... … … 1159 1131 1160 1132 //fld dword ptr[esp] 1161 op_fld_ptr_esp(DEF_SINGLE);1133 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1162 1134 1163 1135 //add esp,CaseTypeSize 1164 op_add_esp(CaseTypeSize);1136 compiler.codeGenerator.op_add_esp(CaseTypeSize); 1165 1137 1166 1138 //fld dword ptr[esp] 1167 op_fld_ptr_esp(DEF_SINGLE);1139 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1168 1140 1169 1141 //fcompp 1170 OpBuffer[obp++]=(char)0xDE; 1171 OpBuffer[obp++]=(char)0xD9; 1142 compiler.codeGenerator.op_fcompp(); 1172 1143 1173 1144 //fnstsw ax 1174 OpBuffer[obp++]=(char)0xDF; 1175 OpBuffer[obp++]=(char)0xE0; 1145 compiler.codeGenerator.op_fnstsw_ax(); 1176 1146 1177 1147 //test ah,40 1178 OpBuffer[obp++]=(char)0xF6; 1179 OpBuffer[obp++]=(char)0xC4; 1180 OpBuffer[obp++]=(char)0x40; 1148 compiler.codeGenerator.op_test_ah( (char)0x40 ); 1181 1149 1182 1150 //jne ... … … 1190 1158 1191 1159 //pop ebx 1192 op_pop(REG_EBX);1160 compiler.codeGenerator.op_pop(REG_EBX); 1193 1161 1194 1162 //mov eax,dword ptr[esp] … … 1273 1241 1274 1242 //add esp,CaseTypeSize 1275 op_add_esp(CaseTypeSize);1243 compiler.codeGenerator.op_add_esp(CaseTypeSize); 1276 1244 } 1277 1245 … … 1321 1289 1322 1290 //ret 1323 op_ret();1291 compiler.codeGenerator.op_ret(); 1324 1292 } 1325 1293 else{ … … 1398 1366 1399 1367 //pop eax 1400 op_pop(REG_EAX);1368 compiler.codeGenerator.op_pop(REG_EAX); 1401 1369 1402 1370 //fstp qword ptr[eax] … … 1408 1376 1409 1377 //pop ebx 1410 op_pop(REG_EBX);1378 compiler.codeGenerator.op_pop(REG_EBX); 1411 1379 1412 1380 //pop eax 1413 op_pop(REG_EAX);1381 compiler.codeGenerator.op_pop(REG_EAX); 1414 1382 1415 1383 //mov dword ptr[eax],ebx 1416 OpBuffer[obp++]=(char)0x89; 1417 OpBuffer[obp++]=(char)0x18; 1384 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE ); 1418 1385 } 1419 1386 else if(type==DEF_QWORD){ … … 1421 1388 1422 1389 //pop ecx 1423 op_pop(REG_ECX);1390 compiler.codeGenerator.op_pop(REG_ECX); 1424 1391 1425 1392 //pop ebx 1426 op_pop(REG_EBX);1393 compiler.codeGenerator.op_pop(REG_EBX); 1427 1394 1428 1395 //pop eax 1429 op_pop(REG_EAX);1396 compiler.codeGenerator.op_pop(REG_EAX); 1430 1397 1431 1398 //mov dword ptr[eax],ecx 1432 OpBuffer[obp++]=(char)0x89; 1433 OpBuffer[obp++]=(char)0x08; 1399 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE ); 1434 1400 1435 1401 //mov dword ptr[eax+sizeof(long)],ebx 1436 OpBuffer[obp++]=(char)0x89; 1437 OpBuffer[obp++]=(char)0x58; 1438 OpBuffer[obp++]=(char)0x04; 1402 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0x04, MOD_BASE_DISP8 ); 1439 1403 } 1440 1404 else if(type==DEF_DWORD){ … … 1442 1406 1443 1407 //pop ebx 1444 op_pop(REG_EBX);1408 compiler.codeGenerator.op_pop(REG_EBX); 1445 1409 1446 1410 //pop eax 1447 op_pop(REG_EAX);1411 compiler.codeGenerator.op_pop(REG_EAX); 1448 1412 1449 1413 //mov dword ptr[eax],ebx 1450 OpBuffer[obp++]=(char)0x89; 1451 OpBuffer[obp++]=(char)0x18; 1414 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE ); 1452 1415 } 1453 1416 else if(type==DEF_WORD){ … … 1455 1418 1456 1419 //pop ebx 1457 op_pop(REG_EBX);1420 compiler.codeGenerator.op_pop(REG_EBX); 1458 1421 1459 1422 //pop eax 1460 op_pop(REG_EAX);1423 compiler.codeGenerator.op_pop(REG_EAX); 1461 1424 1462 1425 //mov word ptr[eax],bx … … 1469 1432 1470 1433 //pop ebx 1471 op_pop(REG_EBX);1434 compiler.codeGenerator.op_pop(REG_EBX); 1472 1435 1473 1436 //pop eax 1474 op_pop(REG_EAX);1437 compiler.codeGenerator.op_pop(REG_EAX); 1475 1438 1476 1439 //mov byte ptr[eax],bl -
trunk/abdev/BasicCompiler32/Compile_Var.cpp
r224 r225 28 28 29 29 //pop ebx 30 op_pop(REG_EBX);30 compiler.codeGenerator.op_pop(REG_EBX); 31 31 32 32 if( resultType.PtrLevel() ){ … … 36 36 if(typeSize>=2){ 37 37 //imul ebx,i2 38 op_imul_RV( REG_EBX, typeSize );38 compiler.codeGenerator.op_imul_RV( REG_EBX, typeSize ); 39 39 } 40 40 } … … 46 46 47 47 //pop ecx 48 op_pop(REG_ECX);48 compiler.codeGenerator.op_pop(REG_ECX); 49 49 50 50 //add ecx,ebx 51 OpBuffer[obp++]=(char)0x03; 52 OpBuffer[obp++]=(char)0xCB; 51 compiler.codeGenerator.op_add_RR( REG_ECX, REG_EBX ); 53 52 } 54 53 void SetRelativeOffset( RELATIVE_VAR &relativeVar ){ 55 54 if(relativeVar.dwKind==VAR_DIRECTMEM){ 56 55 //mov ecx,dword ptr[ecx] 57 op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE );56 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE ); 58 57 } 59 58 else{ … … 63 62 64 63 //mov ecx,dword ptr[eax] 65 op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );64 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE ); 66 65 } 67 66 } … … 114 113 115 114 //push ecx 116 op_push(REG_ECX);115 compiler.codeGenerator.op_push(REG_ECX); 117 116 118 117 //push 0 119 op_push_V(0);118 compiler.codeGenerator.op_push_V(0); 120 119 121 120 for(i=i3-1;i>=0;i--){ … … 133 132 134 133 //pop eax 135 op_pop(REG_EAX);134 compiler.codeGenerator.op_pop(REG_EAX); 136 135 137 136 for(i2=i+1,i4=1;i2<i3;i2++) i4*=subscripts[i2]+1; … … 152 151 153 152 //pop eax 154 op_pop(REG_EAX);153 compiler.codeGenerator.op_pop(REG_EAX); 155 154 156 155 //imul eax,TypeSize … … 161 160 162 161 //pop ecx 163 op_pop(REG_ECX);162 compiler.codeGenerator.op_pop(REG_ECX); 164 163 165 164 //add ecx,eax 166 OpBuffer[obp++]=(char)0x03; 167 OpBuffer[obp++]=(char)0xC8; 165 compiler.codeGenerator.op_add_RR( REG_ECX, REG_EAX ); 168 166 169 167 return 1; … … 628 626 //xor ecx,ecx(ecxを0に初期化する) 629 627 //※ecxは変数ベースアドレスからの相対オフセットを示す 630 op_zero_reg(REG_ECX);628 compiler.codeGenerator.op_zero_reg(REG_ECX); 631 629 632 630 pRelativeVar->bOffsetOffset=1; … … 1194 1192 else{ 1195 1193 //push 0 1196 op_push_V(0);1194 compiler.codeGenerator.op_push_V(0); 1197 1195 1198 1196 //push VarSize 1199 op_push_V( pVar->GetMemorySize() );1197 compiler.codeGenerator.op_push_V( pVar->GetMemorySize() ); 1200 1198 1201 1199 //mov eax,ebp … … 1210 1208 1211 1209 //push eax 1212 op_push(REG_EAX);1210 compiler.codeGenerator.op_push(REG_EAX); 1213 1211 1214 1212 //call FillMemory … … 1237 1235 1238 1236 //pop eax 1239 op_pop( REG_EAX );1237 compiler.codeGenerator.op_pop( REG_EAX ); 1240 1238 1241 1239 RELATIVE_VAR RelativeVar; … … 1273 1271 1274 1272 //add eax,dword ptr[offset] 1275 op_add_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );1273 compiler.codeGenerator.op_add_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 ); 1276 1274 } 1277 1275 else{ 1278 1276 //mov eax,dword ptr[offset] 1279 op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );1277 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 ); 1280 1278 } 1281 1279 obp-=sizeof(long); … … 1356 1354 1357 1355 // 変数領域に要するLONG_PTR単位の個数を引き渡す 1358 op_push_V( pVar->GetMemorySize()/PTR_SIZE );1356 compiler.codeGenerator.op_push_V( pVar->GetMemorySize()/PTR_SIZE ); 1359 1357 1360 1358 … … 1363 1361 1364 1362 //mov eax,offset 1365 op_mov_RV(REG_EAX,(int)pVar->GetOffsetAddress());1363 compiler.codeGenerator.op_mov_RV(REG_EAX,(int)pVar->GetOffsetAddress()); 1366 1364 obp-=sizeof(long); 1367 1365 pobj_GlobalVarSchedule->add(); … … 1369 1367 1370 1368 //push eax 1371 op_push( REG_EAX );1369 compiler.codeGenerator.op_push( REG_EAX ); 1372 1370 1373 1371 // … … 1381 1379 1382 1380 //push eax 1383 op_push( REG_EAX );1381 compiler.codeGenerator.op_push( REG_EAX ); 1384 1382 1385 1383 // … … 1388 1386 1389 1387 // call AddGlobalRootPtr 1390 op_call( pUserProc_AddGlobalRootPtr );1388 compiler.codeGenerator.op_call( pUserProc_AddGlobalRootPtr ); 1391 1389 1392 1390 ReallocNativeCodeBuffer(); -
trunk/abdev/BasicCompiler32/MakePeHdr.cpp
r224 r225 437 437 dwContinueAddress=-1; 438 438 439 // コード生成対象を選択 440 compiler.codeGenerator.Select( compiler.globalNativeCode ); 441 439 442 trace_for_sourcecodestep( "★★★ グローバル領域のコンパイルを開始" ); 440 443 … … 443 446 //OpBuffer[obp++]=(char)0xCC; 444 447 448 445 449 //push ebp 446 op_push(REG_EBP);450 compiler.codeGenerator.op_push(REG_EBP); 447 451 448 452 if(bDebugCompile){ … … 455 459 456 460 //_System_StartupProgramの呼び出し 457 op_call(pSub_System_StartupProgram);461 compiler.codeGenerator.op_call(pSub_System_StartupProgram); 458 462 459 463 //クラスに属する静的メンバを定義 … … 489 493 //call _System_End 490 494 extern const UserProc *pSub_System_End; 491 op_call(pSub_System_End);495 compiler.codeGenerator.op_call(pSub_System_End); 492 496 493 497 494 498 //xor eax,eax(eaxを0に初期化する) 495 op_zero_reg(REG_EAX);499 compiler.codeGenerator.op_zero_reg(REG_EAX); 496 500 497 501 //pop ebp 498 op_pop(REG_EBP);502 compiler.codeGenerator.op_pop(REG_EBP); 499 503 500 504 //ret 501 op_ret();505 compiler.codeGenerator.op_ret(); 502 506 503 507 //グローバル実行領域のコードサイズ -
trunk/abdev/BasicCompiler32/NumOpe.cpp
r224 r225 15 15 if(type==DEF_OBJECT || type==DEF_STRUCT){ 16 16 //push eax 17 op_push(REG_EAX);17 compiler.codeGenerator.op_push(REG_EAX); 18 18 } 19 19 else if(type==DEF_DOUBLE){ 20 20 //sub esp,8 21 op_sub_esp(8);21 compiler.codeGenerator.op_sub_esp(8); 22 22 23 23 //fstp qword ptr[esp] 24 OpBuffer[obp++]=(char)0xDD; 25 OpBuffer[obp++]=(char)0x1C; 26 OpBuffer[obp++]=(char)0x24; 24 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 27 25 } 28 26 else if(type==DEF_SINGLE){ 29 27 //sub esp,4 30 op_sub_esp(4);28 compiler.codeGenerator.op_sub_esp(4); 31 29 32 30 //fstp dword ptr[esp] 33 OpBuffer[obp++]=(char)0xD9; 34 OpBuffer[obp++]=(char)0x1C; 35 OpBuffer[obp++]=(char)0x24; 31 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP ); 36 32 } 37 33 else if(type==DEF_INT64||type==DEF_QWORD){ 38 34 //push edx 39 op_push(REG_EDX);35 compiler.codeGenerator.op_push(REG_EDX); 40 36 41 37 //push eax 42 op_push(REG_EAX);38 compiler.codeGenerator.op_push(REG_EAX); 43 39 } 44 40 else if(type==DEF_LONG){ 45 41 //push eax 46 op_push(REG_EAX);42 compiler.codeGenerator.op_push(REG_EAX); 47 43 } 48 44 else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){ 49 45 //movsx ebx,ax 50 OpBuffer[obp++]=(char)0x0F; 51 OpBuffer[obp++]=(char)0xBF; 52 OpBuffer[obp++]=(char)0xD8; 46 compiler.codeGenerator.op_movsx_R32R16( REG_EBX, REG_EAX ); 53 47 54 48 //push ebx 55 op_push(REG_EBX);49 compiler.codeGenerator.op_push(REG_EBX); 56 50 } 57 51 else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){ 58 52 //movsx ebx,al 59 OpBuffer[obp++]=(char)0x0F; 60 OpBuffer[obp++]=(char)0xBE; 61 OpBuffer[obp++]=(char)0xD8; 53 compiler.codeGenerator.op_movsx_R32R8( REG_EBX, REG_EAX ); 62 54 63 55 //push ebx 64 op_push(REG_EBX);56 compiler.codeGenerator.op_push(REG_EBX); 65 57 } 66 58 else if(type==DEF_DWORD||type==DEF_WORD||type==DEF_BYTE||type==DEF_BOOLEAN|| 67 59 IsPtrType(type)){ 68 60 //push eax 69 op_push(REG_EAX);61 compiler.codeGenerator.op_push(REG_EAX); 70 62 } 71 63 else{ … … 157 149 158 150 //オブジェクトポインタをecxにコピー 159 op_mov_RR( REG_ECX, useReg );151 compiler.codeGenerator.op_mov_RR( REG_ECX, useReg ); 160 152 161 153 RELATIVE_VAR relativeVar; … … 200 192 //オブジェクトポインタをスタックに入れておく 201 193 //push reg 202 op_push( useReg );194 compiler.codeGenerator.op_push( useReg ); 203 195 204 196 if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){ … … 207 199 } 208 200 209 op_pop();201 compiler.codeGenerator.op_pop(); 210 202 211 203 ///////////////////// … … 521 513 if( resultType.IsReal() ){ 522 514 //fld ptr[esp] 523 op_fld_ptr_esp( resultType.GetBasicType() );515 compiler.codeGenerator.op_fld_ptr_esp( resultType.GetBasicType() ); 524 516 525 517 //add esp,size 526 op_add_esp( resultType.GetBasicSize() );518 compiler.codeGenerator.op_add_esp( resultType.GetBasicSize() ); 527 519 } 528 520 else{ 529 521 //pop eax 530 op_pop(REG_EAX);522 compiler.codeGenerator.op_pop(REG_EAX); 531 523 532 524 if( resultType.Is64() ){ 533 525 //pop edx 534 op_pop(REG_EDX);526 compiler.codeGenerator.op_pop(REG_EDX); 535 527 } 536 528 } … … 603 595 604 596 //mov eax,i2 605 op_mov_RV(REG_EAX,i2);597 compiler.codeGenerator.op_mov_RV(REG_EAX,i2); 606 598 obp-=sizeof(long); 607 599 pobj_DataTableSchedule->add(); … … 613 605 614 606 //push eax 615 op_push( REG_EAX );607 compiler.codeGenerator.op_push( REG_EAX ); 616 608 617 609 return true; … … 815 807 //sub esp,size 816 808 //fstp ptr[esp] 817 op_fstp_push( resultType );809 compiler.codeGenerator.op_fstp_push( resultType ); 818 810 } 819 811 else{ 820 812 if( resultType.Is64() ){ 821 813 //push edx 822 op_push( REG_EDX );814 compiler.codeGenerator.op_push( REG_EDX ); 823 815 } 824 816 else{ … … 827 819 828 820 //push eax 829 op_push( REG_EAX );821 compiler.codeGenerator.op_push( REG_EAX ); 830 822 } 831 823 } … … 851 843 852 844 //push 0 853 op_push_V( 0 );845 compiler.codeGenerator.op_push_V( 0 ); 854 846 855 847 sp++; … … 912 904 913 905 //push HILONG(dbl) 914 op_push_V((long)*(long *)(((char *)(&i64data))+4));906 compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4)); 915 907 916 908 //push LOLONG(dbl) 917 op_push_V(*(long *)(&i64data));909 compiler.codeGenerator.op_push_V(*(long *)(&i64data)); 918 910 } 919 911 else if(type_stack[sp]==DEF_SINGLE){ … … 926 918 927 919 //push term 928 op_push_V(i3);920 compiler.codeGenerator.op_push_V(i3); 929 921 } 930 922 else{ … … 932 924 933 925 //push term 934 op_push_V((long)i64data);926 compiler.codeGenerator.op_push_V((long)i64data); 935 927 936 928 if((long)i64data==0) index_stack[sp]=LITERAL_NULL; … … 1082 1074 1083 1075 //push HILONG(i64data) 1084 op_push_V((long)*(long *)(((char *)(&i64data))+4));1076 compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4)); 1085 1077 1086 1078 //push LOLONG(i64data) 1087 op_push_V(*(long *)(&i64data));1079 compiler.codeGenerator.op_push_V(*(long *)(&i64data)); 1088 1080 } 1089 1081 else if( resultType.IsSingle() ){ … … 1097 1089 1098 1090 //push flt 1099 op_push_V(i3);1091 compiler.codeGenerator.op_push_V(i3); 1100 1092 } 1101 1093 else{ … … 1108 1100 1109 1101 //push term 1110 op_push_V(i3);1102 compiler.codeGenerator.op_push_V(i3); 1111 1103 } 1112 1104 -
trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp
r206 r225 1 1 #include "stdafx.h" 2 3 #include <Compiler.h> 2 4 3 5 #include "../BasicCompiler_Common/common.h" … … 10 12 if(type[sp-1]==DEF_DOUBLE){ 11 13 //fld qword ptr[esp] 12 op_fld_ptr_esp(DEF_DOUBLE);14 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 13 15 14 16 //fistp qword ptr[esp] 15 op_fistp_ptr_esp( sizeof(_int64) );17 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 16 18 17 19 //pop ebx 18 op_pop(REG_EBX);20 compiler.codeGenerator.op_pop(REG_EBX); 19 21 20 22 //pop ecx 21 op_pop(REG_ECX);23 compiler.codeGenerator.op_pop(REG_ECX); 22 24 } 23 25 else if(type[sp-1]==DEF_SINGLE){ 24 26 //fld dword ptr[esp] 25 op_fld_ptr_esp(DEF_SINGLE);27 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 26 28 27 29 //sub esp,4 28 op_sub_esp(4);30 compiler.codeGenerator.op_sub_esp(4); 29 31 30 32 //fistp qword ptr[esp] 31 op_fistp_ptr_esp( sizeof(_int64) );33 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 32 34 33 35 //pop ebx 34 op_pop(REG_EBX);36 compiler.codeGenerator.op_pop(REG_EBX); 35 37 36 38 //pop ecx 37 op_pop(REG_ECX);39 compiler.codeGenerator.op_pop(REG_ECX); 38 40 } 39 41 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ 40 42 //pop ebx 41 op_pop(REG_EBX);43 compiler.codeGenerator.op_pop(REG_EBX); 42 44 43 45 //pop ecx 44 op_pop(REG_ECX);46 compiler.codeGenerator.op_pop(REG_ECX); 45 47 } 46 48 else{ 47 49 //pop eax 48 op_pop(REG_EAX);50 compiler.codeGenerator.op_pop(REG_EAX); 49 51 50 52 if(IsSignedType(type[sp-1])){ … … 53 55 54 56 //cdq 55 op_cdq();57 compiler.codeGenerator.op_cdq(); 56 58 } 57 59 else{ … … 60 62 61 63 //xor edx,edx 62 op_zero_reg(REG_EDX);64 compiler.codeGenerator.op_zero_reg(REG_EDX); 63 65 } 64 66 65 67 //mov ebx,eax 66 OpBuffer[obp++]=(char)0x8B; 67 OpBuffer[obp++]=(char)0xD8; 68 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX ); 68 69 69 70 //mov ecx,edx 70 OpBuffer[obp++]=(char)0x8B; 71 OpBuffer[obp++]=(char)0xCA; 71 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX ); 72 72 } 73 73 … … 75 75 if(type[sp-2]==DEF_DOUBLE){ 76 76 //fld qword ptr[esp] 77 op_fld_ptr_esp(DEF_DOUBLE);77 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 78 78 79 79 //fistp qword ptr[esp] 80 op_fistp_ptr_esp( sizeof(_int64) );80 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 81 81 82 82 //pop eax 83 op_pop(REG_EAX);83 compiler.codeGenerator.op_pop(REG_EAX); 84 84 85 85 //pop edx 86 op_pop(REG_EDX);86 compiler.codeGenerator.op_pop(REG_EDX); 87 87 } 88 88 else if(type[sp-2]==DEF_SINGLE){ 89 89 //fld dword ptr[esp] 90 op_fld_ptr_esp(DEF_SINGLE);90 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 91 91 92 92 //sub esp,4 93 op_sub_esp(4);93 compiler.codeGenerator.op_sub_esp(4); 94 94 95 95 //fistp qword ptr[esp] 96 op_fistp_ptr_esp( sizeof(_int64) );96 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 97 97 98 98 //pop eax 99 op_pop(REG_EAX);99 compiler.codeGenerator.op_pop(REG_EAX); 100 100 101 101 //pop edx 102 op_pop(REG_EDX);102 compiler.codeGenerator.op_pop(REG_EDX); 103 103 } 104 104 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){ 105 105 //pop eax 106 op_pop(REG_EAX);106 compiler.codeGenerator.op_pop(REG_EAX); 107 107 108 108 //pop edx 109 op_pop(REG_EDX);109 compiler.codeGenerator.op_pop(REG_EDX); 110 110 } 111 111 else{ 112 112 //pop eax 113 op_pop(REG_EAX);113 compiler.codeGenerator.op_pop(REG_EAX); 114 114 115 115 if(IsSignedType(type[sp-2])){ … … 118 118 119 119 //cdq 120 op_cdq();120 compiler.codeGenerator.op_cdq(); 121 121 } 122 122 else{ … … 125 125 126 126 //xor edx,edx 127 op_zero_reg(REG_EDX);127 compiler.codeGenerator.op_zero_reg(REG_EDX); 128 128 } 129 129 } … … 136 136 137 137 //push ecx 138 op_push(REG_ECX);138 compiler.codeGenerator.op_push(REG_ECX); 139 139 140 140 //push ebx 141 op_push(REG_EBX);141 compiler.codeGenerator.op_push(REG_EBX); 142 142 143 143 //push edx 144 op_push(REG_EDX);144 compiler.codeGenerator.op_push(REG_EDX); 145 145 146 146 //push eax 147 op_push(REG_EAX);147 compiler.codeGenerator.op_push(REG_EAX); 148 148 } 149 149 … … 167 167 if(type[sp-1]==DEF_DOUBLE){ 168 168 //fld qword ptr[esp] 169 op_fld_ptr_esp(DEF_DOUBLE);169 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 170 170 171 171 //add esp,8 172 op_add_esp(8);172 compiler.codeGenerator.op_add_esp(8); 173 173 } 174 174 else if(type[sp-1]==DEF_SINGLE){ 175 175 //fld dword ptr[esp] 176 op_fld_ptr_esp(DEF_SINGLE);177 178 //add esp,4 179 op_add_esp(4);176 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 177 178 //add esp,4 179 compiler.codeGenerator.op_add_esp(4); 180 180 } 181 181 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ … … 183 183 184 184 //fild qword ptr[esp] 185 op_fld_ptr_esp(DEF_INT64);185 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 186 186 187 187 //add esp,8 188 op_add_esp(8);188 compiler.codeGenerator.op_add_esp(8); 189 189 } 190 190 else{ … … 192 192 193 193 //fild dword ptr[esp] 194 op_fld_ptr_esp(DEF_LONG);195 196 //add esp,4 197 op_add_esp(4);194 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 195 196 //add esp,4 197 compiler.codeGenerator.op_add_esp(4); 198 198 } 199 199 200 200 if(type[sp-2]==DEF_DOUBLE){ 201 201 //fld qword ptr[esp] 202 op_fld_ptr_esp(DEF_DOUBLE);202 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 203 203 } 204 204 else if(type[sp-2]==DEF_SINGLE){ 205 205 //fld dword ptr[esp] 206 op_fld_ptr_esp(DEF_SINGLE);206 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 207 207 } 208 208 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){ 209 209 //64ビット整数値 210 op_fld_ptr_esp(DEF_INT64);210 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 211 211 } 212 212 else{ … … 214 214 215 215 //fild dword ptr[esp] 216 op_fld_ptr_esp(DEF_LONG);216 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 217 217 } 218 218 … … 220 220 if(AnswerType==DEF_SINGLE){ 221 221 //add esp,4 222 op_add_esp(4);222 compiler.codeGenerator.op_add_esp(4); 223 223 } 224 224 } … … 226 226 if(AnswerType==DEF_DOUBLE){ 227 227 //sub esp,4 228 op_sub_esp(4);228 compiler.codeGenerator.op_sub_esp(4); 229 229 } 230 230 } … … 232 232 if(idCalc==CALC_ADDITION){ 233 233 //faddp st(1),st 234 OpBuffer[obp++]=(char)0xDE; 235 OpBuffer[obp++]=(char)0xC1; 234 compiler.codeGenerator.PutOld( 235 (char)0xDE, 236 (char)0xC1 237 ); 236 238 } 237 239 else if(idCalc==CALC_SUBTRACTION){ 238 240 //fsubrp st(1),st 239 OpBuffer[obp++]=(char)0xDE; 240 OpBuffer[obp++]=(char)0xE1; 241 compiler.codeGenerator.PutOld( 242 (char)0xDE, 243 (char)0xE1 244 ); 241 245 } 242 246 else if(idCalc==CALC_PRODUCT){ 243 247 //fmulp st(1),st 244 OpBuffer[obp++]=(char)0xDE; 245 OpBuffer[obp++]=(char)0xC9; 248 compiler.codeGenerator.PutOld( 249 (char)0xDE, 250 (char)0xC9 251 ); 246 252 } 247 253 248 254 if(AnswerType==DEF_DOUBLE){ 249 255 //fstp qword ptr[esp] 250 OpBuffer[obp++]=(char)0xDD; 251 OpBuffer[obp++]=(char)0x1C; 252 OpBuffer[obp++]=(char)0x24; 256 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 253 257 } 254 258 else{ 255 259 //fstp dword ptr[esp] 256 OpBuffer[obp++]=(char)0xD9; 257 OpBuffer[obp++]=(char)0x1C; 258 OpBuffer[obp++]=(char)0x24; 260 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP ); 259 261 } 260 262 } … … 273 275 //call _allmul 274 276 extern const UserProc *pSub_allmul; 275 op_call(pSub_allmul);277 compiler.codeGenerator.op_call(pSub_allmul); 276 278 277 279 //push edx 278 op_push(REG_EDX);280 compiler.codeGenerator.op_push(REG_EDX); 279 281 280 282 //push eax 281 op_push(REG_EAX);283 compiler.codeGenerator.op_push(REG_EAX); 282 284 } 283 285 else{ … … 286 288 287 289 //pop ebx 288 op_pop(REG_EBX);290 compiler.codeGenerator.op_pop(REG_EBX); 289 291 290 292 //pop ecx 291 op_pop(REG_ECX);293 compiler.codeGenerator.op_pop(REG_ECX); 292 294 } 293 295 else{ … … 295 297 296 298 //pop eax 297 op_pop(REG_EAX);299 compiler.codeGenerator.op_pop(REG_EAX); 298 300 299 301 if(IsSignedType(type[sp-1])){ … … 302 304 303 305 //cdq 304 op_cdq();306 compiler.codeGenerator.op_cdq(); 305 307 } 306 308 else{ … … 309 311 310 312 //xor edx,edx 311 op_zero_reg(REG_EDX);313 compiler.codeGenerator.op_zero_reg(REG_EDX); 312 314 } 313 315 314 316 //mov ebx,eax 315 OpBuffer[obp++]=(char)0x8B; 316 OpBuffer[obp++]=(char)0xD8; 317 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX ); 317 318 318 319 //mov ecx,edx 319 OpBuffer[obp++]=(char)0x8B; 320 OpBuffer[obp++]=(char)0xCA; 320 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX ); 321 321 } 322 322 … … 326 326 if(idCalc==CALC_ADDITION){ 327 327 //add dword ptr[esp],ebx 328 OpBuffer[obp++]=(char)0x01; 329 OpBuffer[obp++]=(char)0x1C; 330 OpBuffer[obp++]=(char)0x24; 328 compiler.codeGenerator.PutOld( 329 (char)0x01, 330 (char)0x1C, 331 (char)0x24 332 ); 331 333 332 334 //adc dword ptr[esp+sizeof(long)],ecx 333 OpBuffer[obp++]=(char)0x11; 334 OpBuffer[obp++]=(char)0x4C; 335 OpBuffer[obp++]=(char)0x24; 336 OpBuffer[obp++]=(char)0x04; 335 compiler.codeGenerator.PutOld( 336 (char)0x11, 337 (char)0x4C, 338 (char)0x24, 339 (char)0x04 340 ); 337 341 } 338 342 else if(idCalc==CALC_SUBTRACTION){ 339 343 //sub dword ptr[esp],ebx 340 OpBuffer[obp++]=(char)0x29; 341 OpBuffer[obp++]=(char)0x1C; 342 OpBuffer[obp++]=(char)0x24; 344 compiler.codeGenerator.PutOld( 345 (char)0x29, 346 (char)0x1C, 347 (char)0x24 348 ); 343 349 344 350 //sbb dword ptr[esp+sizeof(long)],ecx 345 OpBuffer[obp++]=(char)0x19; 346 OpBuffer[obp++]=(char)0x4C; 347 OpBuffer[obp++]=(char)0x24; 348 OpBuffer[obp++]=(char)0x04; 351 compiler.codeGenerator.PutOld( 352 (char)0x19, 353 (char)0x4C, 354 (char)0x24, 355 (char)0x04 356 ); 349 357 } 350 358 } … … 353 361 354 362 //pop eax 355 op_pop(REG_EAX);363 compiler.codeGenerator.op_pop(REG_EAX); 356 364 357 365 if(IsSignedType(type[sp-2])){ … … 360 368 361 369 //cdq 362 op_cdq();370 compiler.codeGenerator.op_cdq(); 363 371 } 364 372 else{ … … 367 375 368 376 //xor edx,edx 369 op_zero_reg(REG_EDX);377 compiler.codeGenerator.op_zero_reg(REG_EDX); 370 378 } 371 379 372 380 if(idCalc==CALC_ADDITION){ 373 381 //add ebx,eax 374 OpBuffer[obp++]=(char)0x03; 375 OpBuffer[obp++]=(char)0xD8; 382 compiler.codeGenerator.op_add_RR( REG_EBX, REG_EAX ); 376 383 377 384 //adc ecx,edx 378 OpBuffer[obp++]=(char)0x13; 379 OpBuffer[obp++]=(char)0xCA; 385 compiler.codeGenerator.op_adc_RR( REG_ECX, REG_EDX ); 380 386 } 381 387 else if(idCalc==CALC_SUBTRACTION){ 382 388 //sub ebx,eax 383 OpBuffer[obp++]=(char)0x2B; 384 OpBuffer[obp++]=(char)0xC3; 389 compiler.codeGenerator.op_sub_RR( REG_EBX, REG_EAX ); 385 390 386 391 //sbb ecx,edx 387 OpBuffer[obp++]=(char)0x1B; 388 OpBuffer[obp++]=(char)0xD1; 392 compiler.codeGenerator.op_sub_RR( REG_ECX, REG_EDX ); 389 393 } 390 394 391 395 //push ecx 392 op_push(REG_ECX);396 compiler.codeGenerator.op_push(REG_ECX); 393 397 394 398 //push ebx 395 op_push(REG_EBX);399 compiler.codeGenerator.op_push(REG_EBX); 396 400 } 397 401 } … … 403 407 404 408 //pop ebx 405 op_pop(REG_EBX);409 compiler.codeGenerator.op_pop(REG_EBX); 406 410 407 411 //pop eax 408 op_pop(REG_EAX);412 compiler.codeGenerator.op_pop(REG_EAX); 409 413 410 414 //sub esp,4 411 op_sub_esp(4);415 compiler.codeGenerator.op_sub_esp(4); 412 416 413 417 if(idCalc==CALC_ADDITION){ 414 418 //add eax,ebx 415 OpBuffer[obp++]=(char)0x03; 416 OpBuffer[obp++]=(char)0xC3; 419 compiler.codeGenerator.op_add_RR( REG_EAX, REG_EBX ); 417 420 } 418 421 else if(idCalc==CALC_SUBTRACTION){ 419 422 //sub eax,ebx 420 OpBuffer[obp++]=(char)0x2B; 421 OpBuffer[obp++]=(char)0xC3; 423 compiler.codeGenerator.op_sub_RR( REG_EAX, REG_EBX ); 422 424 } 423 425 else if(idCalc==CALC_PRODUCT){ 424 426 //imul eax,ebx(64ビット演算ではないので、符号を考慮しない) 425 OpBuffer[obp++]=(char)0x0F; 426 OpBuffer[obp++]=(char)0xAF; 427 OpBuffer[obp++]=(char)0xC3; 427 compiler.codeGenerator.op_imul_RR( REG_EAX, REG_EBX ); 428 428 } 429 429 430 430 //mov dword ptr[esp],eax 431 OpBuffer[obp++]=(char)0x89; 432 OpBuffer[obp++]=(char)0x04; 433 OpBuffer[obp++]=(char)0x24; 431 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 434 432 } 435 433 … … 463 461 //call _aullrem 464 462 extern const UserProc *pSub_aullrem; 465 op_call(pSub_aullrem);463 compiler.codeGenerator.op_call(pSub_aullrem); 466 464 } 467 465 else{ … … 470 468 //call _allrem 471 469 extern const UserProc *pSub_allrem; 472 op_call(pSub_allrem);470 compiler.codeGenerator.op_call(pSub_allrem); 473 471 } 474 472 475 473 //push edx 476 op_push(REG_EDX);474 compiler.codeGenerator.op_push(REG_EDX); 477 475 478 476 //push eax 479 op_push(REG_EAX);477 compiler.codeGenerator.op_push(REG_EAX); 480 478 481 479 sp--; … … 490 488 if(type[sp-1]==DEF_DOUBLE){ 491 489 //fld qword ptr[esp] 492 op_fld_ptr_esp(DEF_DOUBLE);493 494 //add esp,4 495 op_add_esp(4);496 497 //fistp dword ptr[esp] 498 op_fistp_ptr_esp( sizeof(long) );490 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 491 492 //add esp,4 493 compiler.codeGenerator.op_add_esp(4); 494 495 //fistp dword ptr[esp] 496 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 499 497 } 500 498 else if(type[sp-1]==DEF_SINGLE){ 501 499 //fld dword ptr[esp] 502 op_fld_ptr_esp(DEF_SINGLE);503 504 //fistp dword ptr[esp] 505 op_fistp_ptr_esp( sizeof(long) );500 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 501 502 //fistp dword ptr[esp] 503 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 506 504 } 507 505 508 506 //pop ebx 509 op_pop(REG_EBX);507 compiler.codeGenerator.op_pop(REG_EBX); 510 508 511 509 if(type[sp-2]==DEF_DOUBLE){ 512 510 //fld qword ptr[esp] 513 op_fld_ptr_esp(DEF_DOUBLE);514 515 //add esp,4 516 op_add_esp(4);517 518 //fistp dword ptr[esp] 519 op_fistp_ptr_esp( sizeof(long) );511 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 512 513 //add esp,4 514 compiler.codeGenerator.op_add_esp(4); 515 516 //fistp dword ptr[esp] 517 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 520 518 } 521 519 else if(type[sp-2]==DEF_SINGLE){ 522 520 //fld dword ptr[esp] 523 op_fld_ptr_esp(DEF_SINGLE);524 525 //fistp dword ptr[esp] 526 op_fistp_ptr_esp( sizeof(long) );521 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 522 523 //fistp dword ptr[esp] 524 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 527 525 } 528 526 529 527 //pop eax 530 op_pop(REG_EAX);528 compiler.codeGenerator.op_pop(REG_EAX); 531 529 532 530 //sub esp,4 533 op_sub_esp(4);531 compiler.codeGenerator.op_sub_esp(4); 534 532 535 533 if(type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD){ 536 534 //xor edx,edx 537 op_zero_reg(REG_EDX);535 compiler.codeGenerator.op_zero_reg(REG_EDX); 538 536 539 537 //div ebx (eax=eax/ebx...edx) 540 OpBuffer[obp++]=(char)0xF7; 541 OpBuffer[obp++]=(char)0xF3; 538 compiler.codeGenerator.op_div_R( REG_EBX ); 542 539 } 543 540 else{ 544 541 //cdq 545 op_cdq();542 compiler.codeGenerator.op_cdq(); 546 543 547 544 //idiv ebx (eax=eax/ebx...edx) 548 OpBuffer[obp++]=(char)0xF7; 549 OpBuffer[obp++]=(char)0xFB; 545 compiler.codeGenerator.op_idiv_R( REG_EBX ); 550 546 } 551 547 552 548 //mov dword ptr[esp],edx 553 OpBuffer[obp++]=(char)0x89; 554 OpBuffer[obp++]=(char)0x14; 555 OpBuffer[obp++]=(char)0x24; 549 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EDX, REG_ESP, 0, MOD_BASE ); 556 550 557 551 sp--; … … 581 575 if(type[sp-1]==DEF_DOUBLE){ 582 576 //fld qword ptr[esp] 583 op_fld_ptr_esp(DEF_DOUBLE);577 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 584 578 585 579 //add esp,8 586 op_add_esp(8);580 compiler.codeGenerator.op_add_esp(8); 587 581 } 588 582 else if(type[sp-1]==DEF_SINGLE){ 589 583 //fld dword ptr[esp] 590 op_fld_ptr_esp(DEF_SINGLE);584 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 591 585 592 586 //add esp,4 593 op_add_esp(4);587 compiler.codeGenerator.op_add_esp(4); 594 588 } 595 589 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ … … 597 591 598 592 //fild qword ptr[esp] 599 op_fld_ptr_esp(DEF_INT64);593 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 600 594 601 595 //add esp,8 602 op_add_esp(8);596 compiler.codeGenerator.op_add_esp(8); 603 597 } 604 598 else if(type[sp-1]==DEF_DWORD){ 605 599 //pop eax 606 op_pop(REG_EAX);600 compiler.codeGenerator.op_pop(REG_EAX); 607 601 608 602 //push 0 609 op_push_V(0);603 compiler.codeGenerator.op_push_V(0); 610 604 611 605 //push eax 612 op_push(REG_EAX);606 compiler.codeGenerator.op_push(REG_EAX); 613 607 614 608 //fild qword ptr[esp] 615 OpBuffer[obp++]=(char)0xDF; 616 OpBuffer[obp++]=(char)0x2C; 617 OpBuffer[obp++]=(char)0x24; 609 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 618 610 619 611 //add esp,8 620 op_add_esp(8);612 compiler.codeGenerator.op_add_esp(8); 621 613 } 622 614 else{ 623 615 //fild dword ptr[esp] 624 op_fld_ptr_esp(DEF_LONG);616 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 625 617 626 618 //add esp,4 627 op_add_esp(4);619 compiler.codeGenerator.op_add_esp(4); 628 620 } 629 621 630 622 if(type[sp-2]==DEF_DOUBLE){ 631 623 //fld qword ptr[esp] 632 op_fld_ptr_esp(DEF_DOUBLE);624 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 633 625 } 634 626 else if(type[sp-2]==DEF_SINGLE){ 635 627 //fld dword ptr[esp] 636 op_fld_ptr_esp(DEF_SINGLE);628 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 637 629 } 638 630 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){ … … 640 632 641 633 //fild qword ptr[esp] 642 op_fld_ptr_esp(DEF_INT64);634 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 643 635 } 644 636 else if(type[sp-2]==DEF_DWORD){ 645 637 //pop eax 646 op_pop(REG_EAX);638 compiler.codeGenerator.op_pop(REG_EAX); 647 639 648 640 //push 0 649 op_push_V(0);641 compiler.codeGenerator.op_push_V(0); 650 642 651 643 //push eax 652 op_push(REG_EAX);644 compiler.codeGenerator.op_push(REG_EAX); 653 645 654 646 //fild qword ptr[esp] 655 OpBuffer[obp++]=(char)0xDF; 656 OpBuffer[obp++]=(char)0x2C; 657 OpBuffer[obp++]=(char)0x24; 647 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 658 648 } 659 649 else{ //Long 660 650 //fild dword ptr[esp] 661 op_fld_ptr_esp(DEF_LONG);651 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 662 652 } 663 653 //↓ここだけ例外DWord … … 665 655 if(AnswerType==DEF_SINGLE){ 666 656 //add esp,4 667 op_add_esp(4);657 compiler.codeGenerator.op_add_esp(4); 668 658 } 669 659 } … … 671 661 if(AnswerType==DEF_DOUBLE){ 672 662 //sub esp,4 673 op_sub_esp(4);663 compiler.codeGenerator.op_sub_esp(4); 674 664 } 675 665 } 676 666 677 667 //fdivrp st(1),st 678 OpBuffer[obp++]=(char)0xDE; 679 OpBuffer[obp++]=(char)0xF1; 668 compiler.codeGenerator.PutOld( 669 (char)0xDE, 670 (char)0xF1 671 ); 680 672 681 673 sp--; 682 674 if(AnswerType==DEF_DOUBLE){ 683 675 //fstp qword ptr[esp] 684 OpBuffer[obp++]=(char)0xDD; 685 OpBuffer[obp++]=(char)0x1C; 686 OpBuffer[obp++]=(char)0x24; 676 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 687 677 688 678 type[sp-1]=DEF_DOUBLE; … … 690 680 else{ 691 681 //fstp dword ptr[esp] 692 OpBuffer[obp++]=(char)0xD9; 693 OpBuffer[obp++]=(char)0x1C; 694 OpBuffer[obp++]=(char)0x24; 682 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP ); 695 683 696 684 type[sp-1]=DEF_SINGLE; … … 723 711 //call _aulldiv 724 712 extern const UserProc *pSub_aulldiv; 725 op_call(pSub_aulldiv);713 compiler.codeGenerator.op_call(pSub_aulldiv); 726 714 } 727 715 else{ … … 730 718 //call _alldiv 731 719 extern const UserProc *pSub_alldiv; 732 op_call(pSub_alldiv);720 compiler.codeGenerator.op_call(pSub_alldiv); 733 721 } 734 722 735 723 //push edx 736 op_push(REG_EDX);724 compiler.codeGenerator.op_push(REG_EDX); 737 725 738 726 //push eax 739 op_push(REG_EAX);727 compiler.codeGenerator.op_push(REG_EAX); 740 728 741 729 sp--; … … 750 738 if(type[sp-1]==DEF_DOUBLE){ 751 739 //fld qword ptr[esp] 752 op_fld_ptr_esp(DEF_DOUBLE);753 754 //add esp,4 755 op_add_esp(4);756 757 //fistp dword ptr[esp] 758 op_fistp_ptr_esp( sizeof(long) );740 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 741 742 //add esp,4 743 compiler.codeGenerator.op_add_esp(4); 744 745 //fistp dword ptr[esp] 746 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 759 747 } 760 748 else if(type[sp-1]==DEF_SINGLE){ 761 749 //fld dword ptr[esp] 762 op_fld_ptr_esp(DEF_SINGLE);763 764 //fistp dword ptr[esp] 765 op_fistp_ptr_esp( sizeof(long) );750 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 751 752 //fistp dword ptr[esp] 753 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 766 754 } 767 755 768 756 //pop ebx 769 op_pop(REG_EBX);757 compiler.codeGenerator.op_pop(REG_EBX); 770 758 771 759 if(type[sp-2]==DEF_DOUBLE){ 772 760 //fld qword ptr[esp] 773 op_fld_ptr_esp(DEF_DOUBLE);774 775 //add esp,4 776 op_add_esp(4);777 778 //fistp dword ptr[esp] 779 op_fistp_ptr_esp( sizeof(long) );761 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 762 763 //add esp,4 764 compiler.codeGenerator.op_add_esp(4); 765 766 //fistp dword ptr[esp] 767 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 780 768 } 781 769 else if(type[sp-2]==DEF_SINGLE){ 782 770 //fld dword ptr[esp] 783 op_fld_ptr_esp(DEF_SINGLE);784 785 //fistp dword ptr[esp] 786 op_fistp_ptr_esp( sizeof(long) );771 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 772 773 //fistp dword ptr[esp] 774 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 787 775 } 788 776 789 777 //pop eax 790 op_pop(REG_EAX);778 compiler.codeGenerator.op_pop(REG_EAX); 791 779 792 780 //sub esp,4 793 op_sub_esp(4);781 compiler.codeGenerator.op_sub_esp(4); 794 782 795 783 if((type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD)|| … … 797 785 (type[sp-2]==DEF_DWORD&&IS_POSITIVE_LITERAL(index_stack[sp-1]))){ 798 786 //xor edx,edx 799 op_zero_reg(REG_EDX);787 compiler.codeGenerator.op_zero_reg(REG_EDX); 800 788 801 789 //div ebx (eax=eax/ebx...edx) 802 OpBuffer[obp++]=(char)0xF7; 803 OpBuffer[obp++]=(char)0xF3; 790 compiler.codeGenerator.op_div_R( REG_EBX ); 804 791 } 805 792 else{ 806 793 //cdq 807 op_cdq();794 compiler.codeGenerator.op_cdq(); 808 795 809 796 //idiv ebx (eax=eax/ebx...edx) 810 OpBuffer[obp++]=(char)0xF7; 811 OpBuffer[obp++]=(char)0xFB; 797 compiler.codeGenerator.op_idiv_R( REG_EBX ); 812 798 } 813 799 814 800 //mov dword ptr[esp],eax 815 OpBuffer[obp++]=(char)0x89; 816 OpBuffer[obp++]=(char)0x04; 817 OpBuffer[obp++]=(char)0x24; 801 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 818 802 819 803 sp--; … … 833 817 if(type[sp-1]==DEF_DOUBLE){ 834 818 //fld qword ptr[esp] 835 op_fld_ptr_esp(DEF_DOUBLE);819 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 836 820 837 821 //push -1 838 op_push_V(-1);822 compiler.codeGenerator.op_push_V(-1); 839 823 840 824 //fild dword ptr[esp] 841 op_fld_ptr_esp(DEF_LONG);825 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 842 826 843 827 //add esp,4 844 op_add_esp(4);828 compiler.codeGenerator.op_add_esp(4); 845 829 846 830 //fmulp st(1),st 847 OpBuffer[obp++]=(char)0xDE; 848 OpBuffer[obp++]=(char)0xC9; 831 compiler.codeGenerator.PutOld( 832 (char)0xDE, 833 (char)0xC9 834 ); 849 835 850 836 //fstp qword ptr[esp] 851 OpBuffer[obp++]=(char)0xDD; 852 OpBuffer[obp++]=(char)0x1C; 853 OpBuffer[obp++]=(char)0x24; 837 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 854 838 } 855 839 else if(type[sp-1]==DEF_SINGLE){ 856 840 //fld dword ptr[esp] 857 op_fld_ptr_esp(DEF_SINGLE);841 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 858 842 859 843 //push -1 860 op_push_V(-1);844 compiler.codeGenerator.op_push_V(-1); 861 845 862 846 //fild dword ptr[esp] 863 op_fld_ptr_esp(DEF_LONG);847 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 864 848 865 849 //add esp,4 866 op_add_esp(4);850 compiler.codeGenerator.op_add_esp(4); 867 851 868 852 //fmulp st(1),st 869 OpBuffer[obp++]=(char)0xDE; 870 OpBuffer[obp++]=(char)0xC9; 853 compiler.codeGenerator.PutOld( 854 (char)0xDE, 855 (char)0xC9 856 ); 871 857 872 858 //fstp dword ptr[esp] 873 OpBuffer[obp++]=(char)0xD9; 874 OpBuffer[obp++]=(char)0x1C; 875 OpBuffer[obp++]=(char)0x24; 859 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP ); 876 860 } 877 861 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ 878 862 //pop eax 879 op_pop(REG_EAX);863 compiler.codeGenerator.op_pop(REG_EAX); 880 864 881 865 //neg eax 882 OpBuffer[obp++]=(char)0xF7; 883 OpBuffer[obp++]=(char)0xD8; 866 compiler.codeGenerator.op_neg( REG_EAX ); 884 867 885 868 //pop edx 886 op_pop(REG_EDX);869 compiler.codeGenerator.op_pop(REG_EDX); 887 870 888 871 //adc edx,0 889 OpBuffer[obp++]=(char)0x83; 890 OpBuffer[obp++]=(char)0xD2; 891 OpBuffer[obp++]=(char)0x00; 872 compiler.codeGenerator.op_adc_RV8(REG_EDX,0); 892 873 893 874 //neg edx 894 OpBuffer[obp++]=(char)0xF7; 895 OpBuffer[obp++]=(char)0xDA; 875 compiler.codeGenerator.op_neg( REG_EDX ); 896 876 897 877 //push edx 898 op_push(REG_EDX);878 compiler.codeGenerator.op_push(REG_EDX); 899 879 900 880 //push eax 901 op_push(REG_EAX);881 compiler.codeGenerator.op_push(REG_EAX); 902 882 903 883 type[sp-1]=DEF_INT64; //QWordはInt64へ … … 905 885 else if(IsWholeNumberType(type[sp-1])){ 906 886 //pop eax 907 op_pop(REG_EAX);887 compiler.codeGenerator.op_pop(REG_EAX); 908 888 909 889 //imul eax,-1 910 OpBuffer[obp++]=(char)0x6B; 911 OpBuffer[obp++]=(char)0xC0; 912 OpBuffer[obp++]=(char)0xFF; 890 compiler.codeGenerator.op_imul_RV8( REG_EAX, -1 ); 913 891 914 892 //push eax 915 op_push(REG_EAX);893 compiler.codeGenerator.op_push(REG_EAX); 916 894 917 895 type[sp-1]=GetSignedType(type[sp-1]); … … 929 907 if(type[sp-1]==DEF_DOUBLE){ 930 908 //fld qword ptr[esp] 931 op_fld_ptr_esp(DEF_DOUBLE);909 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 932 910 933 911 //add esp,8 934 op_add_esp(8);912 compiler.codeGenerator.op_add_esp(8); 935 913 } 936 914 else if(type[sp-1]==DEF_SINGLE){ 937 915 //fld dword ptr[esp] 938 op_fld_ptr_esp(DEF_SINGLE);916 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 939 917 940 918 //add esp,4 941 op_add_esp(4);919 compiler.codeGenerator.op_add_esp(4); 942 920 } 943 921 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ … … 945 923 946 924 //fild qword ptr[esp] 947 op_fld_ptr_esp(DEF_INT64);925 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 948 926 949 927 //add esp,8 950 op_add_esp(8);928 compiler.codeGenerator.op_add_esp(8); 951 929 } 952 930 else{ … … 954 932 955 933 //fild dword ptr[esp] 956 op_fld_ptr_esp(DEF_LONG);934 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 957 935 958 936 //add esp,4 959 op_add_esp(4);937 compiler.codeGenerator.op_add_esp(4); 960 938 } 961 939 962 940 if(type[sp-2]==DEF_DOUBLE){ 963 941 //fld qword ptr[esp] 964 op_fld_ptr_esp(DEF_DOUBLE);942 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 965 943 } 966 944 else if(type[sp-2]==DEF_SINGLE){ 967 945 //fld dword ptr[esp] 968 op_fld_ptr_esp(DEF_SINGLE);946 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 969 947 970 948 //sub esp,4 971 op_sub_esp(4);949 compiler.codeGenerator.op_sub_esp(4); 972 950 } 973 951 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){ … … 975 953 976 954 //fild qword ptr[esp] 977 op_fld_ptr_esp(DEF_INT64);955 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 978 956 } 979 957 else{ … … 981 959 982 960 //fild dword ptr[esp] 983 op_fld_ptr_esp(DEF_LONG);961 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 984 962 985 963 //sub esp,4 986 op_sub_esp(4);964 compiler.codeGenerator.op_sub_esp(4); 987 965 } 988 966 989 967 //sub esp,8 990 op_sub_esp(8);968 compiler.codeGenerator.op_sub_esp(8); 991 969 992 970 //fstp qword ptr[esp] 993 OpBuffer[obp++]=(char)0xDD; 994 OpBuffer[obp++]=(char)0x1C; 995 OpBuffer[obp++]=(char)0x24; 971 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 996 972 997 973 //fstp qword ptr[esp+8] 998 OpBuffer[obp++]=(char)0xDD; 999 OpBuffer[obp++]=(char)0x5C; 1000 OpBuffer[obp++]=(char)0x24; 1001 OpBuffer[obp++]=(char)0x08; 974 compiler.codeGenerator.op_fstp_base_offset(DEF_DOUBLE,REG_ESP,8); 1002 975 1003 976 //call pow 1004 977 extern const UserProc *pSub_pow; 1005 op_call(pSub_pow);978 compiler.codeGenerator.op_call(pSub_pow); 1006 979 1007 980 //sub esp,8 1008 op_sub_esp(8);981 compiler.codeGenerator.op_sub_esp(8); 1009 982 1010 983 //fstp qword ptr[esp] 1011 OpBuffer[obp++]=(char)0xDD; 1012 OpBuffer[obp++]=(char)0x1C; 1013 OpBuffer[obp++]=(char)0x24; 984 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP ); 1014 985 1015 986 sp--; … … 1067 1038 if(type[sp-1]==DEF_DOUBLE){ 1068 1039 //fld qword ptr[esp] 1069 op_fld_ptr_esp(DEF_DOUBLE);1070 1071 //add esp,4 1072 op_add_esp(4);1073 1074 //fistp dword ptr[esp] 1075 op_fistp_ptr_esp( sizeof(long) );1076 1077 //pop ecx 1078 op_pop(REG_ECX);1040 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1041 1042 //add esp,4 1043 compiler.codeGenerator.op_add_esp(4); 1044 1045 //fistp dword ptr[esp] 1046 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1047 1048 //pop ecx 1049 compiler.codeGenerator.op_pop(REG_ECX); 1079 1050 } 1080 1051 else if(type[sp-1]==DEF_SINGLE){ 1081 1052 //fld dword ptr[esp] 1082 op_fld_ptr_esp(DEF_SINGLE);1083 1084 //fistp dword ptr[esp] 1085 op_fistp_ptr_esp( sizeof(long) );1086 1087 //pop ecx 1088 op_pop(REG_ECX);1053 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1054 1055 //fistp dword ptr[esp] 1056 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1057 1058 //pop ecx 1059 compiler.codeGenerator.op_pop(REG_ECX); 1089 1060 } 1090 1061 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ 1091 1062 //pop ecx 1092 op_pop(REG_ECX);1093 1094 //add esp,4 1095 op_add_esp(4);1096 } 1097 else{ 1098 //pop ecx 1099 op_pop(REG_ECX);1063 compiler.codeGenerator.op_pop(REG_ECX); 1064 1065 //add esp,4 1066 compiler.codeGenerator.op_add_esp(4); 1067 } 1068 else{ 1069 //pop ecx 1070 compiler.codeGenerator.op_pop(REG_ECX); 1100 1071 } 1101 1072 … … 1103 1074 if(type[sp-2]==DEF_DOUBLE){ 1104 1075 //fld qword ptr[esp] 1105 op_fld_ptr_esp(DEF_DOUBLE);1076 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1106 1077 1107 1078 //fistp qword ptr[esp] 1108 op_fistp_ptr_esp( sizeof(_int64) );1079 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 1109 1080 1110 1081 //pop eax 1111 op_pop(REG_EAX);1082 compiler.codeGenerator.op_pop(REG_EAX); 1112 1083 1113 1084 //pop edx 1114 op_pop(REG_EDX);1085 compiler.codeGenerator.op_pop(REG_EDX); 1115 1086 } 1116 1087 else if(type[sp-2]==DEF_SINGLE){ 1117 1088 //fld dword ptr[esp] 1118 op_fld_ptr_esp(DEF_SINGLE);1089 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1119 1090 1120 1091 //sub esp,4 1121 op_sub_esp(4);1092 compiler.codeGenerator.op_sub_esp(4); 1122 1093 1123 1094 //fistp qword ptr[esp] 1124 op_fistp_ptr_esp( sizeof(_int64) );1095 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 1125 1096 1126 1097 //pop eax 1127 op_pop(REG_EAX);1098 compiler.codeGenerator.op_pop(REG_EAX); 1128 1099 1129 1100 //pop edx 1130 op_pop(REG_EDX);1101 compiler.codeGenerator.op_pop(REG_EDX); 1131 1102 } 1132 1103 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){ 1133 1104 //pop eax 1134 op_pop(REG_EAX);1105 compiler.codeGenerator.op_pop(REG_EAX); 1135 1106 1136 1107 //pop edx 1137 op_pop(REG_EDX);1108 compiler.codeGenerator.op_pop(REG_EDX); 1138 1109 } 1139 1110 else{ 1140 1111 //pop eax 1141 op_pop(REG_EAX);1112 compiler.codeGenerator.op_pop(REG_EAX); 1142 1113 1143 1114 if(IsSignedType(type[sp-2])){ … … 1146 1117 1147 1118 //cdq 1148 op_cdq();1119 compiler.codeGenerator.op_cdq(); 1149 1120 } 1150 1121 else{ … … 1153 1124 1154 1125 //xor edx,edx 1155 op_zero_reg(REG_EDX);1126 compiler.codeGenerator.op_zero_reg(REG_EDX); 1156 1127 } 1157 1128 } … … 1159 1130 //call _allshl 1160 1131 extern const UserProc *pSub_allshl; 1161 op_call(pSub_allshl);1132 compiler.codeGenerator.op_call(pSub_allshl); 1162 1133 1163 1134 //push edx 1164 op_push(REG_EDX);1135 compiler.codeGenerator.op_push(REG_EDX); 1165 1136 1166 1137 //push eax 1167 op_push(REG_EAX);1138 compiler.codeGenerator.op_push(REG_EAX); 1168 1139 1169 1140 sp--; … … 1177 1148 if(type[sp-1]==DEF_DOUBLE){ 1178 1149 //fld qword ptr[esp] 1179 op_fld_ptr_esp(DEF_DOUBLE);1180 1181 //add esp,4 1182 op_add_esp(4);1183 1184 //fistp dword ptr[esp] 1185 op_fistp_ptr_esp( sizeof(long) );1186 1187 //pop ecx 1188 op_pop(REG_ECX);1150 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1151 1152 //add esp,4 1153 compiler.codeGenerator.op_add_esp(4); 1154 1155 //fistp dword ptr[esp] 1156 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1157 1158 //pop ecx 1159 compiler.codeGenerator.op_pop(REG_ECX); 1189 1160 } 1190 1161 else if(type[sp-1]==DEF_SINGLE){ 1191 1162 //fld dword ptr[esp] 1192 op_fld_ptr_esp(DEF_SINGLE);1193 1194 //fistp dword ptr[esp] 1195 op_fistp_ptr_esp( sizeof(long) );1196 1197 //pop ecx 1198 op_pop(REG_ECX);1163 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1164 1165 //fistp dword ptr[esp] 1166 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1167 1168 //pop ecx 1169 compiler.codeGenerator.op_pop(REG_ECX); 1199 1170 } 1200 1171 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ 1201 1172 //pop ecx 1202 op_pop(REG_ECX);1203 1204 //add esp,4 1205 op_add_esp(4);1206 } 1207 else{ 1208 //pop ecx 1209 op_pop(REG_ECX);1173 compiler.codeGenerator.op_pop(REG_ECX); 1174 1175 //add esp,4 1176 compiler.codeGenerator.op_add_esp(4); 1177 } 1178 else{ 1179 //pop ecx 1180 compiler.codeGenerator.op_pop(REG_ECX); 1210 1181 } 1211 1182 1212 1183 if(type[sp-2]==DEF_DOUBLE){ 1213 1184 //fld qword ptr[esp] 1214 op_fld_ptr_esp(DEF_DOUBLE);1215 1216 //add esp,4 1217 op_add_esp(4);1218 1219 //fistp dword ptr[esp] 1220 op_fistp_ptr_esp( sizeof(long) );1185 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1186 1187 //add esp,4 1188 compiler.codeGenerator.op_add_esp(4); 1189 1190 //fistp dword ptr[esp] 1191 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1221 1192 } 1222 1193 else if(type[sp-2]==DEF_SINGLE){ 1223 1194 //fld dword ptr[esp] 1224 op_fld_ptr_esp(DEF_SINGLE);1225 1226 //fistp dword ptr[esp] 1227 op_fistp_ptr_esp( sizeof(long) );1195 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1196 1197 //fistp dword ptr[esp] 1198 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1228 1199 } 1229 1200 1230 1201 //pop eax 1231 op_pop(REG_EAX);1202 compiler.codeGenerator.op_pop(REG_EAX); 1232 1203 1233 1204 //sub esp,4 1234 op_sub_esp(4);1205 compiler.codeGenerator.op_sub_esp(4); 1235 1206 1236 1207 //shl eax,cl 1237 OpBuffer[obp++]=(char)0xD3; 1238 OpBuffer[obp++]=(char)0xE0; 1208 compiler.codeGenerator.PutOld( 1209 (char)0xD3, 1210 (char)0xE0 1211 ); 1239 1212 1240 1213 //mov dword ptr[esp],eax 1241 OpBuffer[obp++]=(char)0x89; 1242 OpBuffer[obp++]=(char)0x04; 1243 OpBuffer[obp++]=(char)0x24; 1214 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 1244 1215 1245 1216 sp--; … … 1269 1240 if(type[sp-1]==DEF_DOUBLE){ 1270 1241 //fld qword ptr[esp] 1271 op_fld_ptr_esp(DEF_DOUBLE);1272 1273 //add esp,4 1274 op_add_esp(4);1275 1276 //fistp dword ptr[esp] 1277 op_fistp_ptr_esp( sizeof(long) );1278 1279 //pop ecx 1280 op_pop(REG_ECX);1242 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1243 1244 //add esp,4 1245 compiler.codeGenerator.op_add_esp(4); 1246 1247 //fistp dword ptr[esp] 1248 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1249 1250 //pop ecx 1251 compiler.codeGenerator.op_pop(REG_ECX); 1281 1252 } 1282 1253 else if(type[sp-1]==DEF_SINGLE){ 1283 1254 //fld dword ptr[esp] 1284 op_fld_ptr_esp(DEF_SINGLE);1285 1286 //fistp dword ptr[esp] 1287 op_fistp_ptr_esp( sizeof(long) );1288 1289 //pop ecx 1290 op_pop(REG_ECX);1255 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1256 1257 //fistp dword ptr[esp] 1258 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1259 1260 //pop ecx 1261 compiler.codeGenerator.op_pop(REG_ECX); 1291 1262 } 1292 1263 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ 1293 1264 //pop ecx 1294 op_pop(REG_ECX);1295 1296 //add esp,4 1297 op_add_esp(4);1298 } 1299 else{ 1300 //pop ecx 1301 op_pop(REG_ECX);1265 compiler.codeGenerator.op_pop(REG_ECX); 1266 1267 //add esp,4 1268 compiler.codeGenerator.op_add_esp(4); 1269 } 1270 else{ 1271 //pop ecx 1272 compiler.codeGenerator.op_pop(REG_ECX); 1302 1273 } 1303 1274 … … 1305 1276 if(type[sp-2]==DEF_DOUBLE){ 1306 1277 //fld qword ptr[esp] 1307 op_fld_ptr_esp(DEF_DOUBLE);1278 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1308 1279 1309 1280 //fistp qword ptr[esp] 1310 op_fistp_ptr_esp( sizeof(_int64) );1281 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 1311 1282 1312 1283 //pop eax 1313 op_pop(REG_EAX);1284 compiler.codeGenerator.op_pop(REG_EAX); 1314 1285 1315 1286 //pop edx 1316 op_pop(REG_EDX);1287 compiler.codeGenerator.op_pop(REG_EDX); 1317 1288 } 1318 1289 else if(type[sp-2]==DEF_SINGLE){ 1319 1290 //fld dword ptr[esp] 1320 op_fld_ptr_esp(DEF_SINGLE);1291 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1321 1292 1322 1293 //sub esp,4 1323 op_sub_esp(4);1294 compiler.codeGenerator.op_sub_esp(4); 1324 1295 1325 1296 //fistp qword ptr[esp] 1326 op_fistp_ptr_esp( sizeof(_int64) );1297 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 1327 1298 1328 1299 //pop eax 1329 op_pop(REG_EAX);1300 compiler.codeGenerator.op_pop(REG_EAX); 1330 1301 1331 1302 //pop edx 1332 op_pop(REG_EDX);1303 compiler.codeGenerator.op_pop(REG_EDX); 1333 1304 } 1334 1305 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){ 1335 1306 //pop eax 1336 op_pop(REG_EAX);1307 compiler.codeGenerator.op_pop(REG_EAX); 1337 1308 1338 1309 //pop edx 1339 op_pop(REG_EDX);1310 compiler.codeGenerator.op_pop(REG_EDX); 1340 1311 } 1341 1312 else{ 1342 1313 //pop eax 1343 op_pop(REG_EAX);1314 compiler.codeGenerator.op_pop(REG_EAX); 1344 1315 1345 1316 if(IsSignedType(type[sp-2])){ … … 1348 1319 1349 1320 //cdq 1350 op_cdq();1321 compiler.codeGenerator.op_cdq(); 1351 1322 } 1352 1323 else{ … … 1355 1326 1356 1327 //xor edx,edx 1357 op_zero_reg(REG_EDX);1328 compiler.codeGenerator.op_zero_reg(REG_EDX); 1358 1329 } 1359 1330 } … … 1364 1335 //call _aullshr 1365 1336 extern const UserProc *pSub_aullshr; 1366 op_call(pSub_aullshr);1337 compiler.codeGenerator.op_call(pSub_aullshr); 1367 1338 } 1368 1339 else{ … … 1371 1342 //call _allshr 1372 1343 extern const UserProc *pSub_allshr; 1373 op_call(pSub_allshr);1344 compiler.codeGenerator.op_call(pSub_allshr); 1374 1345 } 1375 1346 1376 1347 //push edx 1377 op_push(REG_EDX);1348 compiler.codeGenerator.op_push(REG_EDX); 1378 1349 1379 1350 //push eax 1380 op_push(REG_EAX);1351 compiler.codeGenerator.op_push(REG_EAX); 1381 1352 1382 1353 sp--; … … 1390 1361 if(type[sp-1]==DEF_DOUBLE){ 1391 1362 //fld qword ptr[esp] 1392 op_fld_ptr_esp(DEF_DOUBLE);1393 1394 //add esp,4 1395 op_add_esp(4);1396 1397 //fistp dword ptr[esp] 1398 op_fistp_ptr_esp( sizeof(long) );1399 1400 //pop ecx 1401 op_pop(REG_ECX);1363 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1364 1365 //add esp,4 1366 compiler.codeGenerator.op_add_esp(4); 1367 1368 //fistp dword ptr[esp] 1369 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1370 1371 //pop ecx 1372 compiler.codeGenerator.op_pop(REG_ECX); 1402 1373 } 1403 1374 else if(type[sp-1]==DEF_SINGLE){ 1404 1375 //fld dword ptr[esp] 1405 op_fld_ptr_esp(DEF_SINGLE);1406 1407 //fistp dword ptr[esp] 1408 op_fistp_ptr_esp( sizeof(long) );1409 1410 //pop ecx 1411 op_pop(REG_ECX);1376 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1377 1378 //fistp dword ptr[esp] 1379 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1380 1381 //pop ecx 1382 compiler.codeGenerator.op_pop(REG_ECX); 1412 1383 } 1413 1384 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ 1414 1385 //pop ecx 1415 op_pop(REG_ECX);1416 1417 //add esp,4 1418 op_add_esp(4);1419 } 1420 else{ 1421 //pop ecx 1422 op_pop(REG_ECX);1386 compiler.codeGenerator.op_pop(REG_ECX); 1387 1388 //add esp,4 1389 compiler.codeGenerator.op_add_esp(4); 1390 } 1391 else{ 1392 //pop ecx 1393 compiler.codeGenerator.op_pop(REG_ECX); 1423 1394 } 1424 1395 1425 1396 if(type[sp-2]==DEF_DOUBLE){ 1426 1397 //fld qword ptr[esp] 1427 op_fld_ptr_esp(DEF_DOUBLE);1428 1429 //add esp,4 1430 op_add_esp(4);1431 1432 //fistp dword ptr[esp] 1433 op_fistp_ptr_esp( sizeof(long) );1398 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1399 1400 //add esp,4 1401 compiler.codeGenerator.op_add_esp(4); 1402 1403 //fistp dword ptr[esp] 1404 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1434 1405 } 1435 1406 else if(type[sp-2]==DEF_SINGLE){ 1436 1407 //fld dword ptr[esp] 1437 op_fld_ptr_esp(DEF_SINGLE);1438 1439 //fistp dword ptr[esp] 1440 op_fistp_ptr_esp( sizeof(long) );1408 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1409 1410 //fistp dword ptr[esp] 1411 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 1441 1412 } 1442 1413 1443 1414 //pop eax 1444 op_pop(REG_EAX);1415 compiler.codeGenerator.op_pop(REG_EAX); 1445 1416 1446 1417 //sub esp,4 1447 op_sub_esp(4);1418 compiler.codeGenerator.op_sub_esp(4); 1448 1419 1449 1420 if(type[sp-2]==DEF_DWORD){ 1450 1421 //shr eax,cl 1451 OpBuffer[obp++]=(char)0xD3; 1452 OpBuffer[obp++]=(char)0xE8; 1422 compiler.codeGenerator.PutOld( 1423 (char)0xD3, 1424 (char)0xE8 1425 ); 1453 1426 } 1454 1427 else{ 1455 1428 //sar eax,cl 1456 OpBuffer[obp++]=(char)0xD3; 1457 OpBuffer[obp++]=(char)0xF8; 1429 compiler.codeGenerator.PutOld( 1430 (char)0xD3, 1431 (char)0xF8 1432 ); 1458 1433 } 1459 1434 1460 1435 //mov dword ptr[esp],eax 1461 OpBuffer[obp++]=(char)0x89; 1462 OpBuffer[obp++]=(char)0x04; 1463 OpBuffer[obp++]=(char)0x24; 1436 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 1464 1437 1465 1438 sp--; -
trunk/abdev/BasicCompiler32/NumOpe_Logical.cpp
r206 r225 1 1 #include "stdafx.h" 2 3 #include <Compiler.h> 2 4 3 5 #include "../BasicCompiler_Common/common.h" … … 28 30 29 31 //pop ebx 30 op_pop(REG_EBX);32 compiler.codeGenerator.op_pop(REG_EBX); 31 33 32 34 //pop ecx 33 op_pop(REG_ECX);35 compiler.codeGenerator.op_pop(REG_ECX); 34 36 } 35 37 else{ … … 37 39 38 40 //pop eax 39 op_pop(REG_EAX);41 compiler.codeGenerator.op_pop(REG_EAX); 40 42 41 43 if(IsSignedType(type[sp-1])){ … … 44 46 45 47 //cdq 46 op_cdq();48 compiler.codeGenerator.op_cdq(); 47 49 } 48 50 else{ … … 51 53 52 54 //xor edx,edx 53 op_zero_reg(REG_EDX);55 compiler.codeGenerator.op_zero_reg(REG_EDX); 54 56 } 55 57 56 58 //mov ebx,eax 57 OpBuffer[obp++]=(char)0x8B; 58 OpBuffer[obp++]=(char)0xD8; 59 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX ); 59 60 60 61 //mov ecx,edx 61 OpBuffer[obp++]=(char)0x8B; 62 OpBuffer[obp++]=(char)0xCA; 62 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX ); 63 63 } 64 64 … … 67 67 68 68 //xor dword ptr[esp],ebx 69 OpBuffer[obp++]=(char)0x31; 70 OpBuffer[obp++]=(char)0x1C; 71 OpBuffer[obp++]=(char)0x24; 69 compiler.codeGenerator.PutOld( 70 (char)0x31, 71 (char)0x1C, 72 (char)0x24 73 ); 72 74 73 75 //xor dword ptr[esp+sizeof(long)],ecx 74 OpBuffer[obp++]=(char)0x31; 75 OpBuffer[obp++]=(char)0x4C; 76 OpBuffer[obp++]=(char)0x24; 77 OpBuffer[obp++]=(char)0x04; 76 compiler.codeGenerator.PutOld( 77 (char)0x31, 78 (char)0x4C, 79 (char)0x24, 80 (char)0x04 81 ); 78 82 } 79 83 else{ … … 81 85 if(IsSignedType(type[sp-2])){ 82 86 //pop eax 83 op_pop(REG_EAX);87 compiler.codeGenerator.op_pop(REG_EAX); 84 88 85 89 //符号拡張 … … 87 91 88 92 //cdq 89 op_cdq();93 compiler.codeGenerator.op_cdq(); 90 94 } 91 95 else{ 92 96 //pop eax 93 op_pop(REG_EAX);97 compiler.codeGenerator.op_pop(REG_EAX); 94 98 95 99 //ビット拡張 … … 97 101 98 102 //xor edx,edx 99 op_zero_reg(REG_EDX);103 compiler.codeGenerator.op_zero_reg(REG_EDX); 100 104 } 101 105 102 106 //xor ebx,eax 103 OpBuffer[obp++]=(char)0x33; 104 OpBuffer[obp++]=(char)0xD8; 107 compiler.codeGenerator.op_xor_RR( REG_EBX, REG_EAX ); 105 108 106 109 //xor ecx,edx 107 OpBuffer[obp++]=(char)0x33; 108 OpBuffer[obp++]=(char)0xCA; 110 compiler.codeGenerator.op_xor_RR( REG_ECX, REG_EDX ); 109 111 110 112 //push ecx 111 op_push(REG_ECX);113 compiler.codeGenerator.op_push(REG_ECX); 112 114 113 115 //push ebx 114 op_push(REG_EBX);116 compiler.codeGenerator.op_push(REG_EBX); 115 117 } 116 118 … … 125 127 126 128 //pop ebx 127 op_pop(REG_EBX);129 compiler.codeGenerator.op_pop(REG_EBX); 128 130 129 131 //pop eax 130 op_pop(REG_EAX);132 compiler.codeGenerator.op_pop(REG_EAX); 131 133 132 134 //sub esp,4 133 op_sub_esp(4);135 compiler.codeGenerator.op_sub_esp(4); 134 136 135 137 //xor eax,ebx 136 OpBuffer[obp++]=(char)0x33; 137 OpBuffer[obp++]=(char)0xC3; 138 compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX ); 138 139 139 140 //mov dword ptr[esp],eax 140 OpBuffer[obp++]=(char)0x89; 141 OpBuffer[obp++]=(char)0x04; 142 OpBuffer[obp++]=(char)0x24; 141 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 143 142 144 143 sp--; … … 174 173 175 174 //pop ebx 176 op_pop(REG_EBX);175 compiler.codeGenerator.op_pop(REG_EBX); 177 176 178 177 //pop ecx 179 op_pop(REG_ECX);178 compiler.codeGenerator.op_pop(REG_ECX); 180 179 } 181 180 else{ … … 183 182 184 183 //pop eax 185 op_pop(REG_EAX);184 compiler.codeGenerator.op_pop(REG_EAX); 186 185 187 186 if(IsSignedType(type[sp-1])){ … … 190 189 191 190 //cdq 192 op_cdq();191 compiler.codeGenerator.op_cdq(); 193 192 } 194 193 else{ … … 197 196 198 197 //xor edx,edx 199 op_zero_reg(REG_EDX);198 compiler.codeGenerator.op_zero_reg(REG_EDX); 200 199 } 201 200 202 201 //mov ebx,eax 203 OpBuffer[obp++]=(char)0x8B; 204 OpBuffer[obp++]=(char)0xD8; 202 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX ); 205 203 206 204 //mov ecx,edx 207 OpBuffer[obp++]=(char)0x8B; 208 OpBuffer[obp++]=(char)0xCA; 205 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX ); 209 206 } 210 207 … … 213 210 214 211 //or dword ptr[esp],ebx 215 OpBuffer[obp++]=(char)0x09; 216 OpBuffer[obp++]=(char)0x1C; 217 OpBuffer[obp++]=(char)0x24; 212 compiler.codeGenerator.PutOld( 213 (char)0x09, 214 (char)0x1C, 215 (char)0x24 216 ); 218 217 219 218 //or dword ptr[esp+sizeof(long)],ecx 220 OpBuffer[obp++]=(char)0x09; 221 OpBuffer[obp++]=(char)0x4C; 222 OpBuffer[obp++]=(char)0x24; 223 OpBuffer[obp++]=(char)0x04; 219 compiler.codeGenerator.PutOld( 220 (char)0x09, 221 (char)0x4C, 222 (char)0x24, 223 (char)0x04 224 ); 224 225 } 225 226 else{ … … 227 228 if(IsSignedType(type[sp-2])){ 228 229 //pop eax 229 op_pop(REG_EAX);230 compiler.codeGenerator.op_pop(REG_EAX); 230 231 231 232 //符号拡張 … … 233 234 234 235 //cdq 235 op_cdq();236 compiler.codeGenerator.op_cdq(); 236 237 } 237 238 else{ 238 239 //pop eax 239 op_pop(REG_EAX);240 compiler.codeGenerator.op_pop(REG_EAX); 240 241 241 242 //ビット拡張 … … 243 244 244 245 //xor edx,edx 245 op_zero_reg(REG_EDX);246 compiler.codeGenerator.op_zero_reg(REG_EDX); 246 247 } 247 248 248 249 //or ebx,eax 249 OpBuffer[obp++]=(char)0x0B; 250 OpBuffer[obp++]=(char)0xD8; 250 compiler.codeGenerator.op_or_RR( sizeof(long), REG_EBX, REG_EAX ); 251 251 252 252 //or ecx,edx 253 OpBuffer[obp++]=(char)0x0B; 254 OpBuffer[obp++]=(char)0xCA; 253 compiler.codeGenerator.op_or_RR( sizeof(long), REG_ECX, REG_EDX ); 255 254 256 255 //push ecx 257 op_push(REG_ECX);256 compiler.codeGenerator.op_push(REG_ECX); 258 257 259 258 //push ebx 260 op_push(REG_EBX);259 compiler.codeGenerator.op_push(REG_EBX); 261 260 } 262 261 … … 271 270 272 271 //pop ebx 273 op_pop(REG_EBX);272 compiler.codeGenerator.op_pop(REG_EBX); 274 273 275 274 //pop eax 276 op_pop(REG_EAX);275 compiler.codeGenerator.op_pop(REG_EAX); 277 276 278 277 //sub esp,4 279 op_sub_esp(4);278 compiler.codeGenerator.op_sub_esp(4); 280 279 281 280 //or eax,ebx 282 OpBuffer[obp++]=(char)0x0B; 283 OpBuffer[obp++]=(char)0xC3; 281 compiler.codeGenerator.op_or_RR( sizeof(long), REG_EAX, REG_EBX ); 284 282 285 283 //mov dword ptr[esp],eax 286 OpBuffer[obp++]=(char)0x89; 287 OpBuffer[obp++]=(char)0x04; 288 OpBuffer[obp++]=(char)0x24; 284 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 289 285 290 286 sp--; … … 320 316 321 317 //pop ebx 322 op_pop(REG_EBX);318 compiler.codeGenerator.op_pop(REG_EBX); 323 319 324 320 //pop ecx 325 op_pop(REG_ECX);321 compiler.codeGenerator.op_pop(REG_ECX); 326 322 } 327 323 else{ … … 329 325 330 326 //pop eax 331 op_pop(REG_EAX);327 compiler.codeGenerator.op_pop(REG_EAX); 332 328 333 329 if(IsSignedType(type[sp-1])){ … … 336 332 337 333 //cdq 338 op_cdq();334 compiler.codeGenerator.op_cdq(); 339 335 } 340 336 else{ … … 343 339 344 340 //xor edx,edx 345 op_zero_reg(REG_EDX);341 compiler.codeGenerator.op_zero_reg(REG_EDX); 346 342 } 347 343 348 344 //mov ebx,eax 349 OpBuffer[obp++]=(char)0x8B; 350 OpBuffer[obp++]=(char)0xD8; 345 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX ); 351 346 352 347 //mov ecx,edx 353 OpBuffer[obp++]=(char)0x8B; 354 OpBuffer[obp++]=(char)0xCA; 348 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX ); 355 349 } 356 350 … … 359 353 360 354 //and dword ptr[esp],ebx 361 OpBuffer[obp++]=(char)0x21; 362 OpBuffer[obp++]=(char)0x1C; 363 OpBuffer[obp++]=(char)0x24; 355 compiler.codeGenerator.PutOld( 356 (char)0x21, 357 (char)0x1C, 358 (char)0x24 359 ); 364 360 365 361 //and dword ptr[esp+sizeof(long)],ecx 366 OpBuffer[obp++]=(char)0x21; 367 OpBuffer[obp++]=(char)0x4C; 368 OpBuffer[obp++]=(char)0x24; 369 OpBuffer[obp++]=(char)0x04; 362 compiler.codeGenerator.PutOld( 363 (char)0x21, 364 (char)0x4C, 365 (char)0x24, 366 (char)0x04 367 ); 370 368 } 371 369 else{ … … 373 371 if(IsSignedType(type[sp-2])){ 374 372 //pop eax 375 op_pop(REG_EAX);373 compiler.codeGenerator.op_pop(REG_EAX); 376 374 377 375 //符号拡張 … … 379 377 380 378 //cdq 381 op_cdq();379 compiler.codeGenerator.op_cdq(); 382 380 } 383 381 else{ 384 382 //pop eax 385 op_pop(REG_EAX);383 compiler.codeGenerator.op_pop(REG_EAX); 386 384 387 385 //ビット拡張 … … 389 387 390 388 //xor edx,edx 391 op_zero_reg(REG_EDX);389 compiler.codeGenerator.op_zero_reg(REG_EDX); 392 390 } 393 391 394 392 //and ebx,eax 395 OpBuffer[obp++]=(char)0x23; 396 OpBuffer[obp++]=(char)0xD8; 393 compiler.codeGenerator.op_and_RR( REG_EBX, REG_EAX ); 397 394 398 395 //and ecx,edx 399 OpBuffer[obp++]=(char)0x23; 400 OpBuffer[obp++]=(char)0xCA; 396 compiler.codeGenerator.op_and_RR( REG_ECX, REG_EDX ); 401 397 402 398 //push ecx 403 op_push(REG_ECX);399 compiler.codeGenerator.op_push(REG_ECX); 404 400 405 401 //push ebx 406 op_push(REG_EBX);402 compiler.codeGenerator.op_push(REG_EBX); 407 403 } 408 404 … … 417 413 418 414 //pop ebx 419 op_pop(REG_EBX);415 compiler.codeGenerator.op_pop(REG_EBX); 420 416 421 417 //pop eax 422 op_pop(REG_EAX);418 compiler.codeGenerator.op_pop(REG_EAX); 423 419 424 420 //sub esp,4 425 op_sub_esp(4);421 compiler.codeGenerator.op_sub_esp(4); 426 422 427 423 //and eax,ebx 428 OpBuffer[obp++]=(char)0x23; 429 OpBuffer[obp++]=(char)0xC3; 424 compiler.codeGenerator.op_and_RR( REG_EAX, REG_EBX ); 430 425 431 426 //mov dword ptr[esp],eax 432 OpBuffer[obp++]=(char)0x89; 433 OpBuffer[obp++]=(char)0x04; 434 OpBuffer[obp++]=(char)0x24; 427 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 435 428 436 429 sp--; … … 454 447 if( type[sp - 1] == DEF_BOOLEAN ){ 455 448 //pop eax 456 op_pop( REG_EAX );449 compiler.codeGenerator.op_pop( REG_EAX ); 457 450 458 451 //cmp eax,0 459 op_cmp_value(GetTypeSize(type[sp-1],-1),REG_EAX,0);452 compiler.codeGenerator.op_cmp_value(GetTypeSize(type[sp-1],-1),REG_EAX,0); 460 453 461 454 //setne al 462 op_setne( REG_EAX );455 compiler.codeGenerator.op_setne( REG_EAX ); 463 456 464 457 //and eax,000000FFh 465 op_and_RV(REG_EAX,(int)0xFF);458 compiler.codeGenerator.op_and_RV(REG_EAX,(int)0xFF); 466 459 467 460 //neg 468 op_neg( REG_EAX );461 compiler.codeGenerator.op_neg( REG_EAX ); 469 462 470 463 //sbb eax, eax 471 op_sbb_RR( REG_EAX, REG_EAX );464 compiler.codeGenerator.op_sbb_RR( REG_EAX, REG_EAX ); 472 465 473 466 //add eax, 1 474 op_add_RV8( REG_EAX, 1 );467 compiler.codeGenerator.op_add_RV8( REG_EAX, 1 ); 475 468 476 469 //push eax 477 op_push( REG_EAX );470 compiler.codeGenerator.op_push( REG_EAX ); 478 471 } 479 472 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ … … 483 476 484 477 //not dword ptr[esp] 485 OpBuffer[obp++]=(char)0xF7; 486 OpBuffer[obp++]=(char)0x14; 487 OpBuffer[obp++]=(char)0x24; 478 compiler.codeGenerator.PutOld( 479 (char)0xF7, 480 (char)0x14, 481 (char)0x24 482 ); 488 483 489 484 //not dword ptr[esp+4] 490 OpBuffer[obp++]=(char)0xF7; 491 OpBuffer[obp++]=(char)0x54; 492 OpBuffer[obp++]=(char)0x24; 493 OpBuffer[obp++]=(char)0x04; 485 compiler.codeGenerator.PutOld( 486 (char)0xF7, 487 (char)0x54, 488 (char)0x24, 489 (char)0x04 490 ); 494 491 } 495 492 else{ … … 499 496 500 497 //not dword ptr[esp] 501 OpBuffer[obp++]=(char)0xF7; 502 OpBuffer[obp++]=(char)0x14; 503 OpBuffer[obp++]=(char)0x24; 498 compiler.codeGenerator.PutOld( 499 (char)0xF7, 500 (char)0x14, 501 (char)0x24 502 ); 504 503 } 505 504 -
trunk/abdev/BasicCompiler32/NumOpe_Relation.cpp
r206 r225 1 1 #include "stdafx.h" 2 3 #include <Compiler.h> 2 4 3 5 #include "../BasicCompiler_Common/common.h" … … 44 46 if(type_stack[sp-1]==DEF_DOUBLE){ 45 47 //fld qword ptr[esp] 46 op_fld_ptr_esp(DEF_DOUBLE);48 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 47 49 48 50 //add esp,8 49 op_add_esp(8);51 compiler.codeGenerator.op_add_esp(8); 50 52 } 51 53 else if(type_stack[sp-1]==DEF_SINGLE){ 52 54 //fld dword ptr[esp] 53 op_fld_ptr_esp(DEF_SINGLE);54 55 //add esp,4 56 op_add_esp(4);55 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 56 57 //add esp,4 58 compiler.codeGenerator.op_add_esp(4); 57 59 } 58 60 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){ … … 60 62 61 63 //fild qword ptr[esp] 62 op_fld_ptr_esp(DEF_INT64);64 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 63 65 64 66 //add esp,8 65 op_add_esp(8);67 compiler.codeGenerator.op_add_esp(8); 66 68 } 67 69 else{ … … 69 71 70 72 //fild dword ptr[esp] 71 op_fld_ptr_esp(DEF_LONG);72 73 //add esp,4 74 op_add_esp(4);73 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 74 75 //add esp,4 76 compiler.codeGenerator.op_add_esp(4); 75 77 } 76 78 77 79 if(type_stack[sp-2]==DEF_DOUBLE){ 78 80 //fld qword ptr[esp] 79 op_fld_ptr_esp(DEF_DOUBLE);80 81 //add esp,4 82 op_add_esp(4);81 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 82 83 //add esp,4 84 compiler.codeGenerator.op_add_esp(4); 83 85 } 84 86 else if(type_stack[sp-2]==DEF_SINGLE){ 85 87 //fld dword ptr[esp] 86 op_fld_ptr_esp(DEF_SINGLE);88 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 87 89 } 88 90 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){ … … 90 92 91 93 //fild qword ptr[esp] 92 op_fld_ptr_esp(DEF_INT64);93 94 //add esp,4 95 op_add_esp(4);94 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 95 96 //add esp,4 97 compiler.codeGenerator.op_add_esp(4); 96 98 } 97 99 else{ … … 99 101 100 102 //fild dword ptr[esp] 101 op_fld_ptr_esp(DEF_LONG);103 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 102 104 } 103 105 104 106 //fcompp 105 OpBuffer[obp++]=(char)0xDE; 106 OpBuffer[obp++]=(char)0xD9; 107 compiler.codeGenerator.op_fcompp(); 107 108 108 109 //fnstsw ax 109 OpBuffer[obp++]=(char)0xDF; 110 OpBuffer[obp++]=(char)0xE0; 110 compiler.codeGenerator.op_fnstsw_ax(); 111 111 112 112 //mov ecx,1 113 OpBuffer[obp++]=(char)0xB9; 114 *((long *)(OpBuffer+obp))=1; 115 obp+=sizeof(long); 113 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 ); 116 114 117 115 //test ah,41h 118 OpBuffer[obp++]=(char)0xF6; 119 OpBuffer[obp++]=(char)0xC4; 120 OpBuffer[obp++]=(char)0x41; 116 compiler.codeGenerator.op_test_ah( (char)0x41 ); 121 117 122 118 //jne 5 123 OpBuffer[obp++]=(char)0x75; 124 OpBuffer[obp++]=(char)0x02; 119 compiler.codeGenerator.PutOld( 120 (char)0x75, 121 (char)0x02 122 ); 125 123 126 124 //xor ecx,ecx(ecxを0にする) 127 op_zero_reg(REG_ECX);125 compiler.codeGenerator.op_zero_reg(REG_ECX); 128 126 129 127 //mov dword ptr[esp],ecx 130 OpBuffer[obp++]=(char)0x89; 131 OpBuffer[obp++]=(char)0x0C; 132 OpBuffer[obp++]=(char)0x24; 128 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 133 129 } 134 130 else if(Is64Type(AnswerType)){ … … 147 143 148 144 //cmp edx,ecx 149 OpBuffer[obp++]=(char)0x3B; 150 OpBuffer[obp++]=(char)0xD1; 145 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX ); 151 146 152 147 if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){ … … 206 201 207 202 //xor eax,eax(eaxを0にする) 208 op_zero_reg(REG_EAX);203 compiler.codeGenerator.op_zero_reg(REG_EAX); 209 204 210 205 //push eax 211 op_push(REG_EAX);206 compiler.codeGenerator.op_push(REG_EAX); 212 207 } 213 208 else{ … … 217 212 218 213 //pop ebx 219 op_pop(REG_EBX);214 compiler.codeGenerator.op_pop(REG_EBX); 220 215 221 216 //pop eax 222 op_pop(REG_EAX);217 compiler.codeGenerator.op_pop(REG_EAX); 223 218 224 219 // どちらかのサイズが足りない場合は自動拡張する … … 226 221 227 222 //sub esp,4 228 op_sub_esp(4);223 compiler.codeGenerator.op_sub_esp(4); 229 224 230 225 //mov ecx,1 … … 258 253 259 254 //mov dword ptr[esp],ecx 260 OpBuffer[obp++]=(char)0x89; 261 OpBuffer[obp++]=(char)0x0C; 262 OpBuffer[obp++]=(char)0x24; 255 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 263 256 } 264 257 … … 283 276 if(type_stack[sp-1]==DEF_DOUBLE){ 284 277 //fld qword ptr[esp] 285 op_fld_ptr_esp(DEF_DOUBLE);278 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 286 279 287 280 //add esp,8 288 op_add_esp(8);281 compiler.codeGenerator.op_add_esp(8); 289 282 } 290 283 else if(type_stack[sp-1]==DEF_SINGLE){ 291 284 //fld dword ptr[esp] 292 op_fld_ptr_esp(DEF_SINGLE);293 294 //add esp,4 295 op_add_esp(4);285 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 286 287 //add esp,4 288 compiler.codeGenerator.op_add_esp(4); 296 289 } 297 290 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){ … … 299 292 300 293 //fild qword ptr[esp] 301 op_fld_ptr_esp(DEF_INT64);294 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 302 295 303 296 //add esp,8 304 op_add_esp(8);297 compiler.codeGenerator.op_add_esp(8); 305 298 } 306 299 else{ … … 308 301 309 302 //fild dword ptr[esp] 310 op_fld_ptr_esp(DEF_LONG);311 312 //add esp,4 313 op_add_esp(4);303 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 304 305 //add esp,4 306 compiler.codeGenerator.op_add_esp(4); 314 307 } 315 308 316 309 if(type_stack[sp-2]==DEF_DOUBLE){ 317 310 //fld qword ptr[esp] 318 op_fld_ptr_esp(DEF_DOUBLE);319 320 //add esp,4 321 op_add_esp(4);311 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 312 313 //add esp,4 314 compiler.codeGenerator.op_add_esp(4); 322 315 } 323 316 else if(type_stack[sp-2]==DEF_SINGLE){ 324 317 //fld dword ptr[esp] 325 op_fld_ptr_esp(DEF_SINGLE);318 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 326 319 } 327 320 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){ … … 329 322 330 323 //fild qword ptr[esp] 331 op_fld_ptr_esp(DEF_INT64);332 333 //add esp,4 334 op_add_esp(4);324 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 325 326 //add esp,4 327 compiler.codeGenerator.op_add_esp(4); 335 328 } 336 329 else{ … … 338 331 339 332 //fild dword ptr[esp] 340 op_fld_ptr_esp(DEF_LONG);333 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 341 334 } 342 335 … … 346 339 347 340 //fnstsw ax 348 OpBuffer[obp++]=(char)0xDF; 349 OpBuffer[obp++]=(char)0xE0; 341 compiler.codeGenerator.op_fnstsw_ax(); 350 342 351 343 //mov ecx,1 … … 355 347 356 348 //test ah,1 357 OpBuffer[obp++]=(char)0xF6; 358 OpBuffer[obp++]=(char)0xC4; 359 OpBuffer[obp++]=(char)0x01; 349 compiler.codeGenerator.op_test_ah( (char)0x01 ); 360 350 361 351 //je 5 … … 369 359 370 360 //mov dword ptr[esp],ecx 371 OpBuffer[obp++]=(char)0x89; 372 OpBuffer[obp++]=(char)0x0C; 373 OpBuffer[obp++]=(char)0x24; 361 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 374 362 } 375 363 else if(Is64Type(AnswerType)){ … … 447 435 448 436 //xor eax,eax(eaxを0にする) 449 op_zero_reg(REG_EAX);437 compiler.codeGenerator.op_zero_reg(REG_EAX); 450 438 451 439 //push eax 452 op_push(REG_EAX);440 compiler.codeGenerator.op_push(REG_EAX); 453 441 } 454 442 else{ … … 458 446 459 447 //pop ebx 460 op_pop(REG_EBX);448 compiler.codeGenerator.op_pop(REG_EBX); 461 449 462 450 //pop eax 463 op_pop(REG_EAX);451 compiler.codeGenerator.op_pop(REG_EAX); 464 452 465 453 // どちらかのサイズが足りない場合は自動拡張する … … 467 455 468 456 //sub esp,4 469 op_sub_esp(4);457 compiler.codeGenerator.op_sub_esp(4); 470 458 471 459 //mov ecx,1 … … 499 487 500 488 //mov dword ptr[esp],ecx 501 OpBuffer[obp++]=(char)0x89; 502 OpBuffer[obp++]=(char)0x0C; 503 OpBuffer[obp++]=(char)0x24; 489 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 504 490 } 505 491 … … 527 513 if(type_stack[sp-1]==DEF_DOUBLE){ 528 514 //fld qword ptr[esp] 529 op_fld_ptr_esp(DEF_DOUBLE);515 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 530 516 531 517 //add esp,8 532 op_add_esp(8);518 compiler.codeGenerator.op_add_esp(8); 533 519 } 534 520 else if(type_stack[sp-1]==DEF_SINGLE){ 535 521 //fld dword ptr[esp] 536 op_fld_ptr_esp(DEF_SINGLE);537 538 //add esp,4 539 op_add_esp(4);522 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 523 524 //add esp,4 525 compiler.codeGenerator.op_add_esp(4); 540 526 } 541 527 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){ … … 543 529 544 530 //fild qword ptr[esp] 545 op_fld_ptr_esp(DEF_INT64);531 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 546 532 547 533 //add esp,8 548 op_add_esp(8);534 compiler.codeGenerator.op_add_esp(8); 549 535 } 550 536 else{ … … 552 538 553 539 //fild dword ptr[esp] 554 op_fld_ptr_esp(DEF_LONG);555 556 //add esp,4 557 op_add_esp(4);540 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 541 542 //add esp,4 543 compiler.codeGenerator.op_add_esp(4); 558 544 } 559 545 560 546 if(type_stack[sp-2]==DEF_DOUBLE){ 561 547 //fld qword ptr[esp] 562 op_fld_ptr_esp(DEF_DOUBLE);563 564 //add esp,4 565 op_add_esp(4);548 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 549 550 //add esp,4 551 compiler.codeGenerator.op_add_esp(4); 566 552 } 567 553 else if(type_stack[sp-2]==DEF_SINGLE){ 568 554 //fld dword ptr[esp] 569 op_fld_ptr_esp(DEF_SINGLE);555 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 570 556 } 571 557 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){ … … 573 559 574 560 //fild qword ptr[esp] 575 op_fld_ptr_esp(DEF_INT64);576 577 //add esp,4 578 op_add_esp(4);561 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 562 563 //add esp,4 564 compiler.codeGenerator.op_add_esp(4); 579 565 } 580 566 else{ … … 582 568 583 569 //fild dword ptr[esp] 584 op_fld_ptr_esp(DEF_LONG);570 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 585 571 } 586 572 587 573 //fcompp 588 OpBuffer[obp++]=(char)0xDE; 589 OpBuffer[obp++]=(char)0xD9; 574 compiler.codeGenerator.op_fcompp(); 590 575 591 576 //fnstsw ax 592 OpBuffer[obp++]=(char)0xDF; 593 OpBuffer[obp++]=(char)0xE0; 577 compiler.codeGenerator.op_fnstsw_ax(); 594 578 595 579 //mov ecx,1 … … 599 583 600 584 //test ah,01h 601 OpBuffer[obp++]=(char)0xF6; 602 OpBuffer[obp++]=(char)0xC4; 603 OpBuffer[obp++]=(char)0x01; 585 compiler.codeGenerator.op_test_ah( (char)0x41 ); 604 586 605 587 //jne 5 … … 613 595 614 596 //mov dword ptr[esp],ecx 615 OpBuffer[obp++]=(char)0x89; 616 OpBuffer[obp++]=(char)0x0C; 617 OpBuffer[obp++]=(char)0x24; 597 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 618 598 } 619 599 else if(Is64Type(AnswerType)){ … … 678 658 679 659 //xor eax,eax(eaxを0にする) 680 op_zero_reg(REG_EAX);660 compiler.codeGenerator.op_zero_reg(REG_EAX); 681 661 682 662 //jmp 5(演算終了位置へジャンプ) … … 694 674 695 675 //push eax 696 op_push(REG_EAX);676 compiler.codeGenerator.op_push(REG_EAX); 697 677 } 698 678 else{ … … 702 682 703 683 //pop ebx 704 op_pop(REG_EBX);684 compiler.codeGenerator.op_pop(REG_EBX); 705 685 706 686 //pop eax 707 op_pop(REG_EAX);687 compiler.codeGenerator.op_pop(REG_EAX); 708 688 709 689 // どちらかのサイズが足りない場合は自動拡張する … … 711 691 712 692 //sub esp,4 713 op_sub_esp(4);693 compiler.codeGenerator.op_sub_esp(4); 714 694 715 695 //mov ecx,1 … … 743 723 744 724 //mov dword ptr[esp],ecx 745 OpBuffer[obp++]=(char)0x89; 746 OpBuffer[obp++]=(char)0x0C; 747 OpBuffer[obp++]=(char)0x24; 725 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 748 726 } 749 727 … … 771 749 if(type_stack[sp-1]==DEF_DOUBLE){ 772 750 //fld qword ptr[esp] 773 op_fld_ptr_esp(DEF_DOUBLE);751 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 774 752 775 753 //add esp,8 776 op_add_esp(8);754 compiler.codeGenerator.op_add_esp(8); 777 755 } 778 756 else if(type_stack[sp-1]==DEF_SINGLE){ 779 757 //fld dword ptr[esp] 780 op_fld_ptr_esp(DEF_SINGLE);781 782 //add esp,4 783 op_add_esp(4);758 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 759 760 //add esp,4 761 compiler.codeGenerator.op_add_esp(4); 784 762 } 785 763 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){ … … 787 765 788 766 //fild qword ptr[esp] 789 op_fld_ptr_esp(DEF_INT64);767 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 790 768 791 769 //add esp,8 792 op_add_esp(8);770 compiler.codeGenerator.op_add_esp(8); 793 771 } 794 772 else{ //Long、DWord 795 773 //fild dword ptr[esp] 796 op_fld_ptr_esp(DEF_LONG);797 798 //add esp,4 799 op_add_esp(4);774 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 775 776 //add esp,4 777 compiler.codeGenerator.op_add_esp(4); 800 778 } 801 779 802 780 if(type_stack[sp-2]==DEF_DOUBLE){ 803 781 //fld qword ptr[esp] 804 op_fld_ptr_esp(DEF_DOUBLE);805 806 //add esp,4 807 op_add_esp(4);782 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 783 784 //add esp,4 785 compiler.codeGenerator.op_add_esp(4); 808 786 } 809 787 else if(type_stack[sp-2]==DEF_SINGLE){ 810 788 //fld dword ptr[esp] 811 op_fld_ptr_esp(DEF_SINGLE);789 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 812 790 } 813 791 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){ … … 815 793 816 794 //fild qword ptr[esp] 817 op_fld_ptr_esp(DEF_INT64);818 819 //add esp,4 820 op_add_esp(4);795 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 796 797 //add esp,4 798 compiler.codeGenerator.op_add_esp(4); 821 799 } 822 800 else{ //Long、DWord 823 801 //fild dword ptr[esp] 824 op_fld_ptr_esp(DEF_LONG);802 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 825 803 } 826 804 827 805 //fcompp 828 OpBuffer[obp++]=(char)0xDE; 829 OpBuffer[obp++]=(char)0xD9; 806 compiler.codeGenerator.op_fcompp(); 830 807 831 808 //fnstsw ax 832 OpBuffer[obp++]=(char)0xDF; 833 OpBuffer[obp++]=(char)0xE0; 809 compiler.codeGenerator.op_fnstsw_ax(); 834 810 835 811 //mov ecx,1 … … 839 815 840 816 //test ah,41 841 OpBuffer[obp++]=(char)0xF6; 842 OpBuffer[obp++]=(char)0xC4; 843 OpBuffer[obp++]=(char)0x41; 817 compiler.codeGenerator.op_test_ah( (char)0x41 ); 844 818 845 819 //je 5 … … 853 827 854 828 //mov dword ptr[esp],ecx 855 OpBuffer[obp++]=(char)0x89; 856 OpBuffer[obp++]=(char)0x0C; 857 OpBuffer[obp++]=(char)0x24; 829 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 858 830 } 859 831 else if(Is64Type(AnswerType)){ … … 918 890 919 891 //xor eax,eax(eaxを0にする) 920 op_zero_reg(REG_EAX);892 compiler.codeGenerator.op_zero_reg(REG_EAX); 921 893 922 894 //jmp 5(演算終了位置へジャンプ) … … 934 906 935 907 //push eax 936 op_push(REG_EAX);908 compiler.codeGenerator.op_push(REG_EAX); 937 909 } 938 910 else{ … … 942 914 943 915 //pop ebx 944 op_pop(REG_EBX);916 compiler.codeGenerator.op_pop(REG_EBX); 945 917 946 918 //pop eax 947 op_pop(REG_EAX);919 compiler.codeGenerator.op_pop(REG_EAX); 948 920 949 921 // どちらかのサイズが足りない場合は自動拡張する … … 951 923 952 924 //sub esp,4 953 op_sub_esp(4);925 compiler.codeGenerator.op_sub_esp(4); 954 926 955 927 //mov ecx,1 … … 979 951 980 952 //mov dword ptr[esp],ecx 981 OpBuffer[obp++]=(char)0x89; 982 OpBuffer[obp++]=(char)0x0C; 983 OpBuffer[obp++]=(char)0x24; 953 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 984 954 } 985 955 … … 1005 975 if(type[sp-1]==DEF_DOUBLE){ 1006 976 //fld qword ptr[esp] 1007 op_fld_ptr_esp(DEF_DOUBLE);977 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1008 978 1009 979 //add esp,8 1010 op_add_esp(8);980 compiler.codeGenerator.op_add_esp(8); 1011 981 } 1012 982 else if(type[sp-1]==DEF_SINGLE){ 1013 983 //fld dword ptr[esp] 1014 op_fld_ptr_esp(DEF_SINGLE);1015 1016 //add esp,4 1017 op_add_esp(4);984 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 985 986 //add esp,4 987 compiler.codeGenerator.op_add_esp(4); 1018 988 } 1019 989 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ … … 1021 991 1022 992 //fild qword ptr[esp] 1023 op_fld_ptr_esp(DEF_INT64);993 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 1024 994 1025 995 //add esp,8 1026 op_add_esp(8);996 compiler.codeGenerator.op_add_esp(8); 1027 997 } 1028 998 else{ //Long、DWord 1029 999 //fild dword ptr[esp] 1030 op_fld_ptr_esp(DEF_LONG);1031 1032 //add esp,4 1033 op_add_esp(4);1000 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 1001 1002 //add esp,4 1003 compiler.codeGenerator.op_add_esp(4); 1034 1004 } 1035 1005 1036 1006 if(type[sp-2]==DEF_DOUBLE){ 1037 1007 //fld qword ptr[esp] 1038 op_fld_ptr_esp(DEF_DOUBLE);1039 1040 //add esp,4 1041 op_add_esp(4);1008 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1009 1010 //add esp,4 1011 compiler.codeGenerator.op_add_esp(4); 1042 1012 } 1043 1013 else if(type[sp-2]==DEF_SINGLE){ 1044 1014 //fld dword ptr[esp] 1045 op_fld_ptr_esp(DEF_SINGLE);1015 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1046 1016 } 1047 1017 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){ … … 1049 1019 1050 1020 //fild qword ptr[esp] 1051 op_fld_ptr_esp(DEF_INT64);1052 1053 //add esp,4 1054 op_add_esp(4);1021 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 1022 1023 //add esp,4 1024 compiler.codeGenerator.op_add_esp(4); 1055 1025 } 1056 1026 else{ //Long、DWord 1057 1027 //fild dword ptr[esp] 1058 op_fld_ptr_esp(DEF_LONG);1028 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 1059 1029 } 1060 1030 1061 1031 //fcompp 1062 OpBuffer[obp++]=(char)0xDE; 1063 OpBuffer[obp++]=(char)0xD9; 1032 compiler.codeGenerator.op_fcompp(); 1064 1033 1065 1034 //fnstsw ax 1066 OpBuffer[obp++]=(char)0xDF; 1067 OpBuffer[obp++]=(char)0xE0; 1035 compiler.codeGenerator.op_fnstsw_ax(); 1068 1036 1069 1037 //mov ecx,1 … … 1073 1041 1074 1042 //test ah,40 1075 OpBuffer[obp++]=(char)0xF6; 1076 OpBuffer[obp++]=(char)0xC4; 1077 OpBuffer[obp++]=(char)0x40; 1043 compiler.codeGenerator.op_test_ah( (char)0x40 ); 1078 1044 1079 1045 //je 5 … … 1087 1053 1088 1054 //mov dword ptr[esp],ecx 1089 OpBuffer[obp++]=(char)0x89; 1090 OpBuffer[obp++]=(char)0x0C; 1091 OpBuffer[obp++]=(char)0x24; 1055 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 1092 1056 } 1093 1057 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD|| … … 1124 1088 1125 1089 //xor eax,eax(eaxを0にする) 1126 op_zero_reg(REG_EAX);1090 compiler.codeGenerator.op_zero_reg(REG_EAX); 1127 1091 1128 1092 //jmp 5(演算終了位置へジャンプ) … … 1140 1104 1141 1105 //push eax 1142 op_push(REG_EAX);1106 compiler.codeGenerator.op_push(REG_EAX); 1143 1107 } 1144 1108 else{ … … 1148 1112 1149 1113 //pop eax 1150 op_pop(REG_EAX);1114 compiler.codeGenerator.op_pop(REG_EAX); 1151 1115 1152 1116 //pop ebx 1153 op_pop(REG_EBX);1117 compiler.codeGenerator.op_pop(REG_EBX); 1154 1118 1155 1119 // どちらかのサイズが足りない場合は自動拡張する … … 1157 1121 1158 1122 //sub esp,4 1159 op_sub_esp(4);1123 compiler.codeGenerator.op_sub_esp(4); 1160 1124 1161 1125 //xor eax,ebx … … 1173 1137 1174 1138 //mov dword ptr[esp],eax 1175 OpBuffer[obp++]=(char)0x89; 1176 OpBuffer[obp++]=(char)0x04; 1177 OpBuffer[obp++]=(char)0x24; 1139 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 1178 1140 } 1179 1141 … … 1199 1161 if(type[sp-1]==DEF_DOUBLE){ 1200 1162 //fld qword ptr[esp] 1201 op_fld_ptr_esp(DEF_DOUBLE);1163 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1202 1164 1203 1165 //add esp,8 1204 op_add_esp(8);1166 compiler.codeGenerator.op_add_esp(8); 1205 1167 } 1206 1168 else if(type[sp-1]==DEF_SINGLE){ 1207 1169 //fld dword ptr[esp] 1208 op_fld_ptr_esp(DEF_SINGLE);1209 1210 //add esp,4 1211 op_add_esp(4);1170 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1171 1172 //add esp,4 1173 compiler.codeGenerator.op_add_esp(4); 1212 1174 } 1213 1175 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ … … 1215 1177 1216 1178 //fild qword ptr[esp] 1217 op_fld_ptr_esp(DEF_INT64);1179 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 1218 1180 1219 1181 //add esp,8 1220 op_add_esp(8);1182 compiler.codeGenerator.op_add_esp(8); 1221 1183 } 1222 1184 else{ //Long、DWord 1223 1185 //fild dword ptr[esp] 1224 op_fld_ptr_esp(DEF_LONG);1225 1226 //add esp,4 1227 op_add_esp(4);1186 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 1187 1188 //add esp,4 1189 compiler.codeGenerator.op_add_esp(4); 1228 1190 } 1229 1191 1230 1192 if(type[sp-2]==DEF_DOUBLE){ 1231 1193 //fld qword ptr[esp] 1232 op_fld_ptr_esp(DEF_DOUBLE);1233 1234 //add esp,4 1235 op_add_esp(4);1194 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 1195 1196 //add esp,4 1197 compiler.codeGenerator.op_add_esp(4); 1236 1198 } 1237 1199 else if(type[sp-2]==DEF_SINGLE){ 1238 1200 //fld dword ptr[esp] 1239 op_fld_ptr_esp(DEF_SINGLE);1201 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 1240 1202 } 1241 1203 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){ … … 1243 1205 1244 1206 //fild qword ptr[esp] 1245 op_fld_ptr_esp(DEF_INT64);1246 1247 //add esp,4 1248 op_add_esp(4);1207 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64); 1208 1209 //add esp,4 1210 compiler.codeGenerator.op_add_esp(4); 1249 1211 } 1250 1212 else{ //Long、DWord 1251 1213 //fild dword ptr[esp] 1252 op_fld_ptr_esp(DEF_LONG);1214 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG); 1253 1215 } 1254 1216 1255 1217 //fcompp 1256 OpBuffer[obp++]=(char)0xDE; 1257 OpBuffer[obp++]=(char)0xD9; 1218 compiler.codeGenerator.op_fcompp(); 1258 1219 1259 1220 //fnstsw ax 1260 OpBuffer[obp++]=(char)0xDF; 1261 OpBuffer[obp++]=(char)0xE0; 1221 compiler.codeGenerator.op_fnstsw_ax(); 1262 1222 1263 1223 //mov ecx,1 … … 1267 1227 1268 1228 //test ah,40 1269 OpBuffer[obp++]=(char)0xF6; 1270 OpBuffer[obp++]=(char)0xC4; 1271 OpBuffer[obp++]=(char)0x40; 1229 compiler.codeGenerator.op_test_ah( (char)0x40 ); 1272 1230 1273 1231 //jne 5 … … 1281 1239 1282 1240 //mov dword ptr[esp],ecx 1283 OpBuffer[obp++]=(char)0x89; 1284 OpBuffer[obp++]=(char)0x0C; 1285 OpBuffer[obp++]=(char)0x24; 1241 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE ); 1286 1242 } 1287 1243 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD|| … … 1331 1287 1332 1288 //xor eax,eax(eaxを0にする) 1333 op_zero_reg(REG_EAX);1289 compiler.codeGenerator.op_zero_reg(REG_EAX); 1334 1290 1335 1291 //push eax 1336 op_push(REG_EAX);1292 compiler.codeGenerator.op_push(REG_EAX); 1337 1293 } 1338 1294 else{ … … 1342 1298 1343 1299 //pop eax 1344 op_pop(REG_EAX);1300 compiler.codeGenerator.op_pop(REG_EAX); 1345 1301 1346 1302 //pop ebx 1347 op_pop(REG_EBX);1303 compiler.codeGenerator.op_pop(REG_EBX); 1348 1304 1349 1305 // どちらかのサイズが足りない場合は自動拡張する … … 1351 1307 1352 1308 //sub esp,4 1353 op_sub_esp(4);1309 compiler.codeGenerator.op_sub_esp(4); 1354 1310 1355 1311 //xor eax,ebx … … 1375 1331 1376 1332 //mov dword ptr[esp],eax 1377 OpBuffer[obp++]=(char)0x89; 1378 OpBuffer[obp++]=(char)0x04; 1379 OpBuffer[obp++]=(char)0x24; 1333 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE ); 1380 1334 } 1381 1335 -
trunk/abdev/BasicCompiler32/NumOpe_TypeOperation.cpp
r206 r225 20 20 21 21 //pop eax 22 op_pop(REG_EAX);22 compiler.codeGenerator.op_pop(REG_EAX); 23 23 24 24 //cdq 25 op_cdq();25 compiler.codeGenerator.op_cdq(); 26 26 27 27 //push edx 28 op_push(REG_EDX);28 compiler.codeGenerator.op_push(REG_EDX); 29 29 30 30 //push eax 31 op_push(REG_EAX);31 compiler.codeGenerator.op_push(REG_EAX); 32 32 } 33 33 else{ … … 35 35 36 36 //pop eax 37 op_pop(REG_EAX);37 compiler.codeGenerator.op_pop(REG_EAX); 38 38 39 39 //push 0 40 op_push_V(0);40 compiler.codeGenerator.op_push_V(0); 41 41 42 42 //push eax 43 op_push(REG_EAX);43 compiler.codeGenerator.op_push(REG_EAX); 44 44 } 45 45 } … … 49 49 if(Is64Type(type)){ 50 50 //pop eax 51 op_pop(REG_EAX);51 compiler.codeGenerator.op_pop(REG_EAX); 52 52 53 53 //pop edx 54 op_pop(REG_EDX);54 compiler.codeGenerator.op_pop(REG_EDX); 55 55 56 56 //push eax 57 op_push(REG_EAX);57 compiler.codeGenerator.op_push(REG_EAX); 58 58 } 59 59 else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){ 60 60 //pop eax 61 op_pop(REG_EAX);61 compiler.codeGenerator.op_pop(REG_EAX); 62 62 63 63 //movsx eax,ax 64 OpBuffer[obp++]=(char)0x0F; 65 OpBuffer[obp++]=(char)0xBF; 66 OpBuffer[obp++]=(char)0xC0; 64 compiler.codeGenerator.op_movsx_R32R16( REG_EAX ); 67 65 68 66 //push eax 69 op_push(REG_EAX);67 compiler.codeGenerator.op_push(REG_EAX); 70 68 } 71 69 else if(type==DEF_WORD){ 72 70 //pop eax 73 op_pop(REG_EAX);71 compiler.codeGenerator.op_pop(REG_EAX); 74 72 75 73 //and eax,0000FFFFh … … 79 77 80 78 //push eax 81 op_push(REG_EAX);79 compiler.codeGenerator.op_push(REG_EAX); 82 80 } 83 81 else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){ 84 82 //pop eax 85 op_pop(REG_EAX);83 compiler.codeGenerator.op_pop(REG_EAX); 86 84 87 85 //movsx eax,al 88 OpBuffer[obp++]=(char)0x0F; 89 OpBuffer[obp++]=(char)0xBE; 90 OpBuffer[obp++]=(char)0xC0; 86 compiler.codeGenerator.op_movsx_R32R8( REG_EAX ); 91 87 92 88 //push eax 93 op_push(REG_EAX);89 compiler.codeGenerator.op_push(REG_EAX); 94 90 } 95 91 else if(type==DEF_BYTE||type==DEF_BOOLEAN){ 96 92 //pop eax 97 op_pop(REG_EAX);93 compiler.codeGenerator.op_pop(REG_EAX); 98 94 99 95 //and eax,000000FFh … … 103 99 104 100 //push eax 105 op_push(REG_EAX);101 compiler.codeGenerator.op_push(REG_EAX); 106 102 } 107 103 } … … 109 105 if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){ 110 106 //pop eax 111 op_pop(REG_EAX);107 compiler.codeGenerator.op_pop(REG_EAX); 112 108 113 109 //movsx eax,al 114 OpBuffer[obp++]=(char)0x0F; 115 OpBuffer[obp++]=(char)0xBE; 116 OpBuffer[obp++]=(char)0xC0; 110 compiler.codeGenerator.op_movsx_R32R8( REG_EAX ); 117 111 118 112 //push eax 119 op_push(REG_EAX);113 compiler.codeGenerator.op_push(REG_EAX); 120 114 } 121 115 else if(type==DEF_BYTE){ 122 116 //pop eax 123 op_pop(REG_EAX);117 compiler.codeGenerator.op_pop(REG_EAX); 124 118 125 119 //and eax,000000FFh … … 129 123 130 124 //push eax 131 op_push(REG_EAX);125 compiler.codeGenerator.op_push(REG_EAX); 132 126 } 133 127 } … … 135 129 if(Is64Type(type)){ 136 130 //pop eax 137 op_pop(REG_EAX);131 compiler.codeGenerator.op_pop(REG_EAX); 138 132 139 133 //pop edx 140 op_pop(REG_EDX);134 compiler.codeGenerator.op_pop(REG_EDX); 141 135 142 136 //push eax 143 op_push(REG_EAX);137 compiler.codeGenerator.op_push(REG_EAX); 144 138 } 145 139 } … … 150 144 if(Is64Type(NewType)){ 151 145 //fld qword ptr[esp] 152 op_fld_ptr_esp(DEF_DOUBLE);146 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 153 147 154 148 //fistp qword ptr[esp] 155 op_fistp_ptr_esp( sizeof(_int64) );149 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 156 150 } 157 151 else{ 158 152 //fld qword ptr[esp] 159 op_fld_ptr_esp(DEF_DOUBLE);153 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE); 160 154 161 155 //add esp,4 162 op_add_esp(4);156 compiler.codeGenerator.op_add_esp(4); 163 157 164 158 //fistp dword ptr[esp] 165 op_fistp_ptr_esp( sizeof(long) );159 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 166 160 } 167 161 } … … 169 163 if(Is64Type(NewType)){ 170 164 //fld dword ptr[esp] 171 op_fld_ptr_esp(DEF_SINGLE);165 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 172 166 173 167 //sub esp,4 174 op_sub_esp(4);168 compiler.codeGenerator.op_sub_esp(4); 175 169 176 170 //fistp qword ptr[esp] 177 op_fistp_ptr_esp( sizeof(_int64) );171 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) ); 178 172 } 179 173 else{ 180 174 //fld dword ptr[esp] 181 op_fld_ptr_esp(DEF_SINGLE);175 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE); 182 176 183 177 //fistp dword ptr[esp] 184 op_fistp_ptr_esp( sizeof(long) );178 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) ); 185 179 } 186 180 } -
trunk/abdev/BasicCompiler32/Opcode.h
r206 r225 3 3 #include <Type.h> 4 4 #include <Procedure.h> 5 6 7 //未定義の定数情報 8 #define IMAGE_FILE_MACHINE_AMD64 0x8664 9 10 11 //レジスタを示す定数 12 #define REG_NON -1 13 #define REG_EAX 0x00 //reg:000 14 #define REG_ECX 0x01 //reg:001 15 #define REG_EDX 0x02 //reg:010 16 #define REG_EBX 0x03 //reg:011 17 #define REG_ESP 0x04 //reg:100 18 #define REG_EBP 0x05 //reg:101 19 #define REG_ESI 0x06 //reg:110 20 #define REG_EDI 0x07 //reg:111 21 22 #define REG_RAX REG_EAX 23 #define REG_RCX REG_ECX 24 #define REG_RDX REG_EDX 25 #define REG_RBX REG_EBX 26 #define REG_RSP REG_ESP 27 #define REG_RBP REG_EBP 28 #define REG_RSI REG_ESI 29 #define REG_RDI REG_EDI 30 31 #define REGISTER_OPERAND(reg) (reg&0x07) 5 #include "MachineFixed.h" 6 32 7 33 8 //変数の種類 … … 190 165 void SetReg_RealVariable(int type,RELATIVE_VAR *pRelativeVar); 191 166 void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg, bool is64Head = false); 192 void PushDoubleVariable(RELATIVE_VAR *pRelativeVar);193 167 void PushLongVariable(RELATIVE_VAR *pRelativeVar); 194 void PushIntegerVariable(RELATIVE_VAR *pRelativeVar);195 void PushWordVariable(RELATIVE_VAR *pRelativeVar);196 void PushCharVariable(RELATIVE_VAR *pRelativeVar);197 void PushByteVariable(RELATIVE_VAR *pRelativeVar);198 168 199 169 //Compile_Object.cpp … … 294 264 //////////////////////////////// 295 265 296 //Mod(モード)297 #define MOD_BASE (char)0x00298 #define MOD_DISP32 (char)0xFF299 #define MOD_BASE_DISP8 (char)0x40300 #define MOD_BASE_DISP32 (char)0x80301 #define MOD_REG (char)0xC0302 303 #define USE_OFFSET 1304 #define NON_OFFSET 0305 306 266 //op32_main.cpp 307 267 BOOL IsSafeReg(int reg); 268 /* 308 269 void op_mov_RV (int reg,int offset); 309 270 void op_mov_RV (int op_size,int reg,int offset); … … 357 318 void op_call(const UserProc *pUserProc); 358 319 void op_ret(); 320 */ -
trunk/abdev/BasicCompiler32/OperatorProc.cpp
r206 r225 2 2 3 3 #include <jenga/include/smoothie/LexicalAnalysis.h> 4 5 #include <Compiler.h> 4 6 5 7 #include "../BasicCompiler_Common/common.h" … … 12 14 if( method ){ 13 15 //push reg 14 op_push(reg);16 compiler.codeGenerator.op_push(reg); 15 17 16 18 //call DestructorProcAddr 17 op_call( &method->GetUserProc() );19 compiler.codeGenerator.op_call( &method->GetUserProc() ); 18 20 } 19 21 20 22 //push reg 21 op_push(reg);23 compiler.codeGenerator.op_push(reg); 22 24 23 25 //call free 24 26 extern const UserProc *pSub_free; 25 op_call(pSub_free);27 compiler.codeGenerator.op_call(pSub_free); 26 28 } 27 29 … … 108 110 109 111 //push object_size 110 op_push_V(object_size);112 compiler.codeGenerator.op_push_V(object_size); 111 113 112 114 //call calloc 113 115 extern const UserProc *pSub_calloc; 114 op_call(pSub_calloc);116 compiler.codeGenerator.op_call(pSub_calloc); 115 117 116 118 //mov ebx,eax 117 op_mov_RR(REG_EBX,REG_EAX);119 compiler.codeGenerator.op_mov_RR(REG_EBX,REG_EAX); 118 120 } 119 121 … … 123 125 if(right_side_size==sizeof(_int64)){ 124 126 //pop eax 125 op_pop(REG_EAX);127 compiler.codeGenerator.op_pop(REG_EAX); 126 128 127 129 //pop edx 128 op_pop(REG_EDX);130 compiler.codeGenerator.op_pop(REG_EDX); 129 131 } 130 132 else{ 131 133 //pop eax 132 op_pop(REG_EAX);134 compiler.codeGenerator.op_pop(REG_EAX); 133 135 } 134 136 } 135 137 136 138 //pop ecx 137 op_pop(REG_ECX);139 compiler.codeGenerator.op_pop(REG_ECX); 138 140 139 141 … … 141 143 if(bUseHeap[sp-1]){ 142 144 //mov esi,eax 143 op_mov_RR(REG_ESI,REG_EAX);145 compiler.codeGenerator.op_mov_RR(REG_ESI,REG_EAX); 144 146 } 145 147 if(bUseHeap[sp-2]){ 146 148 //mov edi,ecx 147 op_mov_RR(REG_EDI,REG_ECX);149 compiler.codeGenerator.op_mov_RR(REG_EDI,REG_ECX); 148 150 } 149 151 … … 153 155 if(right_side_size==sizeof(_int64)){ 154 156 //push edx 155 op_push(REG_EDX);157 compiler.codeGenerator.op_push(REG_EDX); 156 158 157 159 //push eax 158 op_push(REG_EAX);160 compiler.codeGenerator.op_push(REG_EAX); 159 161 } 160 162 else{ 161 163 //push eax 162 op_push(REG_EAX);164 compiler.codeGenerator.op_push(REG_EAX); 163 165 } 164 166 … … 167 169 168 170 //mov eax,esp 169 op_mov_RR( REG_EAX, REG_ESP );171 compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ESP ); 170 172 171 173 //push eax 172 op_push( REG_EAX );174 compiler.codeGenerator.op_push( REG_EAX ); 173 175 } 174 176 } … … 176 178 if( pUserProc->ReturnType().IsStruct() ){ 177 179 //push ebx 178 op_push(REG_EBX);180 compiler.codeGenerator.op_push(REG_EBX); 179 181 } 180 182 181 183 //push ecx 182 op_push(REG_ECX);184 compiler.codeGenerator.op_push(REG_ECX); 183 185 184 186 //call operator_proc 185 op_call(pUserProc);187 compiler.codeGenerator.op_call(pUserProc); 186 188 187 189 if(bTwoTerm){ 188 190 if( pUserProc->RealParams()[1]->IsRef() ){ 189 191 //一時参照を破棄 190 op_pop( REG_NON );192 compiler.codeGenerator.op_pop( REG_NON ); 191 193 } 192 194 } -
trunk/abdev/BasicCompiler32/increment.cpp
r206 r225 1 1 #include "stdafx.h" 2 3 #include <Compiler.h> 2 4 3 5 #include "../BasicCompiler_Common/common.h" … … 19 21 if(IsUse_ecx(&VarRelativeVar)){ 20 22 //push ecx 21 op_push(REG_ECX);23 compiler.codeGenerator.op_push(REG_ECX); 22 24 } 23 25 … … 48 50 49 51 //add eax,1 50 op_add_RV8(REG_EAX,1);52 compiler.codeGenerator.op_add_RV8(REG_EAX,1); 51 53 52 54 //adc edx,0 53 op_adc_RV8(REG_EDX,0);55 compiler.codeGenerator.op_adc_RV8(REG_EDX,0); 54 56 } 55 57 else if(idCalc==CALC_SUBTRACTION){ … … 57 59 58 60 //sub eax,1 59 op_sub_RV8(REG_EAX,1);61 compiler.codeGenerator.op_sub_RV8(REG_EAX,1); 60 62 61 63 //sbb edx,0 62 op_sbb_RV8(REG_EDX,0);64 compiler.codeGenerator.op_sbb_RV8(REG_EDX,0); 63 65 } 64 66 } … … 66 68 if(idCalc==CALC_ADDITION){ 67 69 //インクリメント 68 op_inc(REG_EAX);70 compiler.codeGenerator.op_inc(REG_EAX); 69 71 } 70 72 else if(idCalc==CALC_SUBTRACTION){ 71 73 //デクリメント 72 op_dec(REG_EAX);74 compiler.codeGenerator.op_dec(REG_EAX); 73 75 } 74 76 } … … 77 79 //変数オフセットを一時退避 78 80 //push ecx 79 op_push(REG_ECX);81 compiler.codeGenerator.op_push(REG_ECX); 80 82 81 83 if( varType.IsDouble() ){ 82 84 //sub esp,8 83 op_sub_esp(8);85 compiler.codeGenerator.op_sub_esp(8); 84 86 85 87 //fstp qword ptr[esp] 86 op_fstp_basereg(varType.GetBasicType(),REG_ESP);88 compiler.codeGenerator.op_fstp_basereg(varType.GetBasicType(),REG_ESP); 87 89 } 88 90 else if( varType.IsSingle() ){ 89 91 //sub esp,4 90 op_sub_esp(4);92 compiler.codeGenerator.op_sub_esp(4); 91 93 92 94 //fstp dword ptr[esp] 93 op_fstp_basereg(varType.GetBasicType(),REG_ESP);95 compiler.codeGenerator.op_fstp_basereg(varType.GetBasicType(),REG_ESP); 94 96 } 95 97 else if( varType.Is64() ){ 96 98 //push edx 97 op_push(REG_EDX);99 compiler.codeGenerator.op_push(REG_EDX); 98 100 99 101 //push eax 100 op_push(REG_EAX);102 compiler.codeGenerator.op_push(REG_EAX); 101 103 } 102 104 else{ 103 105 //push eax 104 op_push(REG_EAX);106 compiler.codeGenerator.op_push(REG_EAX); 105 107 } 106 108 … … 160 162 if( varType.IsDouble() ){ 161 163 //fld qword ptr[esp] 162 op_fld_basereg(varType.GetBasicType(),REG_ESP);164 compiler.codeGenerator.op_fld_basereg(varType.GetBasicType(),REG_ESP); 163 165 164 166 //add esp,8 165 op_add_esp(8);167 compiler.codeGenerator.op_add_esp(8); 166 168 } 167 169 else if( varType.IsSingle() ){ 168 170 //fld dword ptr[esp] 169 op_fld_basereg(varType.GetBasicType(),REG_ESP);171 compiler.codeGenerator.op_fld_basereg(varType.GetBasicType(),REG_ESP); 170 172 171 173 //add esp,4 172 op_add_esp(4);174 compiler.codeGenerator.op_add_esp(4); 173 175 } 174 176 else if( varType.Is64() ){ 175 177 //pop eax 176 op_pop(REG_EAX);178 compiler.codeGenerator.op_pop(REG_EAX); 177 179 178 180 //pop edx 179 op_pop(REG_EDX);181 compiler.codeGenerator.op_pop(REG_EDX); 180 182 } 181 183 else{ 182 184 //pop eax 183 op_pop(REG_EAX);185 compiler.codeGenerator.op_pop(REG_EAX); 184 186 } 185 187 … … 187 189 //変数オフセットを復元 188 190 //pop ecx 189 op_pop(REG_ECX);191 compiler.codeGenerator.op_pop(REG_ECX); 190 192 } 191 193 … … 197 199 if(IsUse_ecx(&VarRelativeVar)){ 198 200 //pop ecx 199 op_pop(REG_ECX);201 compiler.codeGenerator.op_pop(REG_ECX); 200 202 } 201 203 -
trunk/abdev/BasicCompiler32/op32_main.cpp
r206 r225 10 10 return 0; 11 11 } 12 13 14 15 /////////////////////////////////////////////////16 // ModR/Mバイト、SIBバイト、ディスプレースメント17 /////////////////////////////////////////////////18 19 //スケール20 #define SCALE_NON (char)0x0021 #define SCALE_2 (char)0x4022 #define SCALE_4 (char)0x8023 #define SCALE_8 (char)0xC024 25 //インデックスなし26 #define INDEX_NON 0x0427 28 void set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,int disp){29 if(mod==MOD_DISP32){30 //ModR/Mバイト31 OpBuffer[obp++]=(char)( REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(0x04));32 33 base_reg=0x05;34 index_reg=INDEX_NON;35 }36 else{37 //ModR/Mバイト38 OpBuffer[obp++]=(char)(mod | REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(base_reg));39 }40 41 42 //レジスタモードの場合は、ここで終了43 if(mod==MOD_REG) return;44 45 46 if(REGISTER_OPERAND(base_reg)==0x04||mod==MOD_DISP32){47 //////////////////////48 // SIBバイトを使う49 //////////////////////50 51 OpBuffer[obp++]=(char)(scale| REGISTER_OPERAND(index_reg)<<3 | REGISTER_OPERAND(base_reg));52 }53 54 //ディスプレースメントを必要としない場合は、ここで終了55 if(mod==MOD_BASE) return;56 57 58 //////////////////////////59 // ディスプレースメント60 //////////////////////////61 62 if(mod==MOD_BASE_DISP8) OpBuffer[obp++]=(char)disp;63 else{64 *((long *)(OpBuffer+obp))=disp;65 obp+=sizeof(long);66 }67 }68 69 70 71 void __op_format(char op_prefix,char opcode,int reg){72 //命令プリフィックス73 if(op_prefix) OpBuffer[obp++]=op_prefix;74 75 //オペコード、レジスタ76 OpBuffer[obp++]=(char)(opcode|REGISTER_OPERAND(reg));77 }78 void __op_format(char op_prefix,char opcode1,char opcode2,int reg,int base_reg,int offset,char mod){79 //命令プリフィックス80 if(op_prefix) OpBuffer[obp++]=op_prefix;81 82 //オペコード83 OpBuffer[obp++]=opcode1;84 if(opcode2) OpBuffer[obp++]=opcode2;85 86 //ModR/M, SIB, disp87 set_mod_rm_sib_disp(mod,reg,SCALE_NON,INDEX_NON,base_reg,offset);88 }89 90 91 92 ///////////////////93 // mov関連94 ///////////////////95 96 void op_mov_RV(int reg,int offset){97 //mov reg,value98 99 //オペコード、レジスタ100 OpBuffer[obp++]=(char)(0xB8|REGISTER_OPERAND(reg));101 102 //DISP32103 *((long *)(OpBuffer+obp))=offset;104 obp+=sizeof(long);105 }106 void op_mov_RV(int op_size,int reg,int offset){107 if(op_size==PTR_SIZE) op_mov_RV(reg,offset);108 else SetError(300,NULL,cp);109 }110 void op_mov_RR(int reg1,int reg2){111 //mov reg1,reg2112 113 if(reg1==reg2) return;114 115 //1000 1011 11xx xbbb116 OpBuffer[obp++]=(char)0x8B;117 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));118 }119 void op_mov_RM(int op_size,int reg,int base_reg,int offset,char mod){120 //mov reg32,dword ptr[base_reg+offset]121 //mov reg16,word ptr[base_reg+offset]122 //mov reg8,byte ptr[base_reg+offset]123 124 //16ビット演算の命令プリフィックス125 char op_prefix=0;126 if(op_size==sizeof(short)) op_prefix=(char)0x66;127 128 //オペコード129 char opcode;130 if(op_size==sizeof(char)) opcode=(char)0x8A;131 else opcode=(char)0x8B;132 133 __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);134 }135 void op_mov_RM_ex(int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){136 //mov reg32,dword ptr[base_reg1+base_reg2+offset]137 //mov reg16,word ptr[base_reg1+base_reg2+offset]138 //mov reg8,byte ptr[base_reg1+base_reg2+offset]139 140 if(base_reg1==REG_ESP){141 //SIBバイトのindex部にespは指定できない142 base_reg1=base_reg2;143 base_reg2=REG_ESP;144 }145 146 //16ビット演算のプリフィックス147 if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;148 149 //オペコード150 if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x8A;151 else OpBuffer[obp++]=(char)0x8B;152 153 if(bUseOffset){154 ///////////////////////////155 // オフセット値を使う156 ///////////////////////////157 158 //レジスタ159 OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);160 161 //ベースレジスタ162 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));163 164 //オフセット値165 *((long *)(OpBuffer+obp))=offset;166 obp+=sizeof(long);167 }168 else{169 ///////////////////////////170 // オフセット値を使わない171 ///////////////////////////172 173 //レジスタ174 OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);175 176 //ベースレジスタ177 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));178 }179 }180 void op_mov_MR(int op_size,int reg,int base_reg,int offset,char mod){181 //mov dword ptr[base_reg+offset],reg32182 //mov word ptr[base_reg+offset],reg16183 //mov byte ptr[base_reg+offset],reg8184 185 //16ビット演算の命令プリフィックス186 char op_prefix=0;187 if(op_size==sizeof(short)) op_prefix=(char)0x66;188 189 //オペコード190 char opcode;191 if(op_size==sizeof(char)) opcode=(char)0x88;192 else opcode=(char)0x89;193 194 __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);195 }196 void op_mov_MR_ex(int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){197 //mov dword ptr[base_reg1+base_reg2+offset],reg32198 //mov word ptr[base_reg1+base_reg2+offset],reg16199 //mov byte ptr[base_reg1+base_reg2+offset],reg8200 201 if(base_reg1==REG_ESP){202 //SIBバイトのindex部にrspは指定できない203 base_reg1=base_reg2;204 base_reg2=REG_ESP;205 }206 207 //16ビット演算のプリフィックス208 if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;209 210 //オペコード211 if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x88;212 else OpBuffer[obp++]=(char)0x89;213 214 if(bUseOffset==USE_OFFSET){215 //////////////////////////216 //オフセット値を使う217 //////////////////////////218 219 //レジスタ220 OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);221 222 //ベースレジスタ223 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));224 225 //オフセット値226 *((long *)(OpBuffer+obp))=offset;227 obp+=sizeof(long);228 }229 else{230 //////////////////////////231 //オフセット値を使わない232 //////////////////////////233 234 //レジスタ235 OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);236 237 //ベースレジスタ238 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));239 }240 }241 242 243 244 245 ////////////////////////////////246 // movsx関連247 ////////////////////////////////248 249 void op_movsx_R32R16(int reg32,int reg16){250 //movsx reg32,reg16251 252 //16ビット演算の命令プリフィックス253 char op_prefix=0;254 255 //オペコード256 char opcode=(char)0x0F;257 char opcode2=(char)0xBF;258 259 __op_format(op_prefix,opcode,opcode2,reg32,reg16,0,MOD_REG);260 }261 void op_movsx_R32R8(int reg32,int reg8){262 //movsx reg32,reg8263 264 //16ビット演算の命令プリフィックス265 char op_prefix=0;266 267 //オペコード268 char opcode=(char)0x0F;269 char opcode2=(char)0xBE;270 271 __op_format(op_prefix,opcode,opcode2,reg32,reg8,0,MOD_REG);272 }273 void op_movsx_R16R8(int reg16,int reg8){274 //movsx reg16,reg8275 276 //16ビット演算の命令プリフィックス277 char op_prefix=(char)0x66;278 279 //オペコード280 char opcode=(char)0x0F;281 char opcode2=(char)0xBE;282 283 __op_format(op_prefix,opcode,opcode2,reg16,reg8,0,MOD_REG);284 }285 286 287 288 //////////////////////////////////289 // インクリメント・デクリメント290 //////////////////////////////////291 292 void op_inc(int reg){293 //inc reg294 295 //16ビット演算の命令プリフィックス296 char op_prefix=0;297 298 //オペコード299 char opcode=(char)0xFF;300 301 __op_format(op_prefix,opcode,0,0,reg,0,MOD_REG);302 }303 void op_dec(int reg){304 op_inc(reg);305 OpBuffer[obp-1]=OpBuffer[obp-1]|0x08;306 }307 308 309 310 /////////////////////311 // add関連312 /////////////////////313 314 void op_add_RV8(int reg,char cValue){315 //add reg,value8316 317 OpBuffer[obp++]=(char)0x83;318 OpBuffer[obp++]=(char)(0xC0|REGISTER_OPERAND(reg));319 OpBuffer[obp++]=cValue;320 }321 void op_add_RM(int op_size,int reg,int base_reg,int offset,char mod){322 //add reg32,dword ptr[base_reg+offset]323 //add reg16,word ptr[base_reg+offset]324 //add reg8,byte ptr[base_reg+offset]325 326 //16ビット演算の命令プリフィックス327 char op_prefix=0;328 if(op_size==sizeof(short)) op_prefix=(char)0x66;329 330 //オペコード331 char opcode;332 if(op_size==sizeof(char)) opcode=(char)0x02;333 else opcode=(char)0x03;334 335 __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);336 }337 void op_adc_RV8(int reg,char cValue){338 //adc reg,value8339 340 OpBuffer[obp++]=(char)0x83;341 OpBuffer[obp++]=(char)(0xD0|REGISTER_OPERAND(reg));342 OpBuffer[obp++]=cValue;343 }344 345 346 /////////////////////347 // sub関連348 /////////////////////349 350 void op_sub_RV8(int reg,char cValue){351 //sub reg,value8352 353 OpBuffer[obp++]=(char)0x83;354 OpBuffer[obp++]=(char)(0xE8|REGISTER_OPERAND(reg));355 OpBuffer[obp++]=cValue;356 }357 void op_sbb_RV8(int reg,char cValue){358 //sbb reg,value8359 360 OpBuffer[obp++]=(char)0x83;361 OpBuffer[obp++]=(char)(0xD8|REGISTER_OPERAND(reg));362 OpBuffer[obp++]=cValue;363 }364 void op_sbb_RR( int reg1, int reg2 ){365 //sbb reg1,reg2366 367 //オペコード368 OpBuffer[obp++]=(char)0x1B;369 370 //レジスタ371 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));372 }373 374 375 376 ////////////////////////377 // imul関連378 ////////////////////////379 380 void op_imul_RR(int reg1,int reg2){381 //imul reg1,reg2382 383 //オペコード384 OpBuffer[obp++]=(char)0x0F;385 OpBuffer[obp++]=(char)0xAF;386 387 //レジスタ388 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));389 }390 391 void op_imul_RV(int reg,int i32data){392 //imul reg,i32data393 394 if(-128<=i32data&&i32data<=127){395 //オペコード396 OpBuffer[obp++]=(char)0x6B;397 398 //レジスタ399 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg));400 401 //値402 OpBuffer[obp++]=(char)i32data;403 }404 else{405 //オペコード406 OpBuffer[obp++]=(char)0x69;407 408 //レジスタ409 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg));410 411 //値412 *((long *)(OpBuffer+obp))=i32data;413 obp+=sizeof(long);414 }415 }416 417 418 419 //////////////////////420 // and関連421 //////////////////////422 423 void op_and_RV(int reg,int value){424 //and reg,value425 426 if(reg==REG_RAX){427 //eaxのみ特殊428 429 // [8bit rex] 0010 0101 [32bit offset]430 OpBuffer[obp++]=(char)0x25;431 *((long *)(OpBuffer+obp))=value;432 obp+=sizeof(long);433 }434 else{435 //16ビット演算の命令プリフィックス436 char op_prefix=0;437 438 //オペコード439 char opcode=(char)0x81;440 441 __op_format(op_prefix,opcode,0,0,reg,value,MOD_REG);442 }443 }444 445 void op_or_RR( int op_size, int reg1, int reg2 ){446 //16ビット演算のプリフィックス447 if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;448 449 //オペコード450 if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x0A;451 else OpBuffer[obp++]=(char)0x0B;452 453 //レジスタ454 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));455 }456 457 458 459 void op_neg( int reg ){460 //neg reg461 462 //オペコード463 OpBuffer[obp++]=(char)0xF7;464 465 //レジスタ466 OpBuffer[obp++]=(char)(0xD8| REGISTER_OPERAND(reg));467 }468 469 470 471 ///////////////////////472 // 64ビット関連473 ///////////////////////474 475 void op_cdq(){476 //cdq477 OpBuffer[obp++]=(char)0x99;478 }479 480 481 482 /////////////////////483 // ストリング関係484 /////////////////////485 486 void op_rep_movs(int op_size){487 if(op_size==sizeof(BYTE)){488 //rep movs byte ptr[edi],byte ptr[esi]489 OpBuffer[obp++]=(char)0xF3;490 OpBuffer[obp++]=(char)0xA4;491 }492 else if(op_size==sizeof(short)){493 //rep movs word ptr[edi],word ptr[esi]494 OpBuffer[obp++]=(char)0xF3;495 OpBuffer[obp++]=(char)0x66;496 OpBuffer[obp++]=(char)0xA5;497 }498 else if(op_size==sizeof(long)){499 //rep movs dword ptr[edi],dword ptr[esi]500 OpBuffer[obp++]=(char)0xF3;501 OpBuffer[obp++]=(char)0xA5;502 }503 }504 505 506 507 508 //////////////////////////509 // スタック関連510 //////////////////////////511 512 void op_push(int reg){513 //push reg514 515 if( reg == REG_NON ){516 op_sub_esp( PTR_SIZE );517 return;518 }519 520 //オペコード、レジスタ521 __op_format(0,(char)0x50,reg);522 }523 void op_push_V(long data){524 //スタックにリテラル値をプッシュ525 if(-128<=data&&data<=127){526 //push 8ビット値527 OpBuffer[obp++]=(char)0x6A;528 OpBuffer[obp++]=(char)data;529 }530 else{531 //push 32ビット値532 OpBuffer[obp++]=(char)0x68;533 *((long *)(OpBuffer+obp))=data;534 obp+=sizeof(long);535 }536 }537 void op_pop(int reg){538 //pop reg539 540 if( reg == REG_NON ){541 op_add_esp( PTR_SIZE );542 return;543 }544 545 //オペコード、レジスタ546 __op_format(0,(char)0x58,reg);547 }548 void op_add_esp(int num){549 //スタックポインタの加算(pop方向)550 551 //add esp,num552 if(0xFFFFFF80&num){553 OpBuffer[obp++]=(char)0x81;554 OpBuffer[obp++]=(char)0xC4;555 *((long *)(OpBuffer+obp))=num;556 obp+=sizeof(long);557 }558 else{559 //「128 > num > -127」の場合560 OpBuffer[obp++]=(char)0x83;561 OpBuffer[obp++]=(char)0xC4;562 OpBuffer[obp++]=(char)num;563 }564 }565 void op_sub_esp(int num){566 //スタックポインタの減算(push方向)567 568 //sub esp,num569 if(0xFFFFFF80&num){570 OpBuffer[obp++]=(char)0x81;571 OpBuffer[obp++]=(char)0xEC;572 *((long *)(OpBuffer+obp))=num;573 obp+=sizeof(long);574 }575 else{576 //「128 > num > -127」の場合577 OpBuffer[obp++]=(char)0x83;578 OpBuffer[obp++]=(char)0xEC;579 OpBuffer[obp++]=(char)num;580 }581 }582 583 584 585 /////////////////////586 // cmp関連587 /////////////////////588 void op_cmp_RR( int reg1, int reg2 ){589 //オペコード590 OpBuffer[obp++]=(char)0x3B;591 592 //レジスタ593 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));594 }595 void op_cmp_value(int op_size,int reg,char byte_data){596 //cmp reg,byte_data597 598 if(op_size==sizeof(char)&®==REG_EAX){599 //alレジスタの場合は特殊600 OpBuffer[obp++]=(char)0x3C;601 602 //8ビット値603 OpBuffer[obp++]=byte_data;604 605 return;606 }607 608 //16ビット演算のプリフィックス609 if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;610 611 //オペコード612 if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x80;613 else OpBuffer[obp++]=(char)0x83;614 615 //レジスタ616 OpBuffer[obp++]=(char)(0xF8| REGISTER_OPERAND(reg));617 618 //8ビット値619 OpBuffer[obp++]=byte_data;620 }621 void op_setne( int reg ){622 //オペコード623 OpBuffer[obp++]=(char)0x0F;624 OpBuffer[obp++]=(char)0x95;625 626 //レジスタ627 OpBuffer[obp++]=(char)( 0xC0 | REGISTER_OPERAND(reg) );628 }629 630 631 632 ////////////////////633 // test関連634 ////////////////////635 636 void op_test(int reg1,int reg2){637 //test reg1,reg2638 639 //1000 0101 11rr rbbb640 OpBuffer[obp++]=(char)0x85;641 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));642 }643 644 645 646 //////////////////////////////647 // 浮動小数点関連648 //////////////////////////////649 650 void op_fld_ptr_esp(int type){651 //スタックポインタが示すバッファのデータを浮動小数点レジスタへロード652 653 if(type==DEF_DOUBLE){654 //fld qword ptr[esp]655 OpBuffer[obp++]=(char)0xDD;656 OpBuffer[obp++]=(char)0x04;657 OpBuffer[obp++]=(char)0x24;658 }659 else if(type==DEF_SINGLE){660 //fld dword ptr[esp]661 OpBuffer[obp++]=(char)0xD9;662 OpBuffer[obp++]=(char)0x04;663 OpBuffer[obp++]=(char)0x24;664 }665 else if(type==DEF_INT64){666 //fild qword ptr[esp]667 OpBuffer[obp++]=(char)0xDF;668 OpBuffer[obp++]=(char)0x2C;669 OpBuffer[obp++]=(char)0x24;670 }671 else if(type==DEF_LONG){672 //fild dword ptr[esp]673 OpBuffer[obp++]=(char)0xDB;674 OpBuffer[obp++]=(char)0x04;675 OpBuffer[obp++]=(char)0x24;676 }677 }678 void op_fld_basereg(int type,int base_reg){679 //fld ptr[reg]680 681 //オペコード682 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;683 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;684 else SetError(300,NULL,cp);685 686 if(base_reg==REG_ESP){687 OpBuffer[obp++]=(char)0x04;688 OpBuffer[obp++]=(char)0x24;689 }690 else if(base_reg==REG_EBP){691 OpBuffer[obp++]=(char)0x45;692 OpBuffer[obp++]=(char)0x00;693 }694 else{695 OpBuffer[obp++]=(char)REGISTER_OPERAND(base_reg);696 }697 }698 void op_fld_base_offset(int type,int base_reg,int offset){699 //fld ptr[reg+offset]700 701 //オペコード702 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;703 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;704 else SetError(300,NULL,cp);705 706 //オペコード、レジスタ707 if(base_reg==REG_ESP){708 OpBuffer[obp++]=(char)0x84;709 OpBuffer[obp++]=(char)0x24;710 }711 else{712 OpBuffer[obp++]=(char)(0x80|REGISTER_OPERAND(base_reg));713 }714 715 //オフセット値716 *((long *)(OpBuffer+obp))=offset;717 obp+=sizeof(long);718 }719 void op_fld_base_offset_ex(int type,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){720 //fld ptr[base_reg1+base_reg2+offset]721 722 if(base_reg1==REG_ESP){723 //SIBバイトのindex部にespは指定できない724 base_reg1=base_reg2;725 base_reg2=REG_ESP;726 }727 728 //オペコード729 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;730 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;731 else SetError(300,NULL,cp);732 733 int reg=0;734 if(bUseOffset){735 ///////////////////////////736 // オフセット値を使う737 ///////////////////////////738 739 //レジスタ740 OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);741 742 //ベースレジスタ743 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));744 745 //オフセット値746 *((long *)(OpBuffer+obp))=offset;747 obp+=sizeof(long);748 }749 else{750 ///////////////////////////751 // オフセット値を使わない752 ///////////////////////////753 754 //レジスタ755 OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);756 757 //ベースレジスタ758 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));759 }760 }761 void op_fstp_basereg(int type,int base_reg){762 //fstp ptr[reg]763 764 //オペコード765 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;766 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;767 else SetError(300,NULL,cp);768 769 if(base_reg==REG_ESP){770 OpBuffer[obp++]=(char)0x1C;771 OpBuffer[obp++]=(char)0x24;772 }773 else if(base_reg==REG_EBP){774 OpBuffer[obp++]=(char)0x5D;775 OpBuffer[obp++]=(char)0x00;776 }777 else{778 OpBuffer[obp++]=(char)(0x18|REGISTER_OPERAND(base_reg));779 }780 }781 void op_fstp_base_offset(int type,int base_reg,int offset){782 //fstp ptr[reg+offset]783 784 //オペコード785 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;786 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;787 else SetError(300,NULL,cp);788 789 //オペコード、レジスタ790 if(base_reg==REG_ESP){791 OpBuffer[obp++]=(char)0x9C;792 OpBuffer[obp++]=(char)0x24;793 }794 else{795 OpBuffer[obp++]=(char)(0x98|REGISTER_OPERAND(base_reg));796 }797 798 //オフセット値799 *((long *)(OpBuffer+obp))=offset;800 obp+=sizeof(long);801 }802 void op_fstp_base_offset_ex(int type,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){803 //fstp ptr[base_reg1+base_reg2+offset]804 805 if(base_reg1==REG_ESP){806 //SIBバイトのindex部にespは指定できない807 base_reg1=base_reg2;808 base_reg2=REG_ESP;809 }810 811 //オペコード812 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;813 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;814 else SetError(300,NULL,cp);815 816 int reg=0;817 if(bUseOffset){818 ///////////////////////////819 // オフセット値を使う820 ///////////////////////////821 822 //レジスタ823 OpBuffer[obp++]=(char)(0x9C| REGISTER_OPERAND(reg)<<3);824 825 //ベースレジスタ826 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));827 828 //オフセット値829 *((long *)(OpBuffer+obp))=offset;830 obp+=sizeof(long);831 }832 else{833 ///////////////////////////834 // オフセット値を使わない835 ///////////////////////////836 837 //レジスタ838 OpBuffer[obp++]=(char)(0x1C| REGISTER_OPERAND(reg)<<3);839 840 //ベースレジスタ841 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));842 }843 }844 void op_fistp_ptr_esp( int typeSize ){845 if( typeSize == sizeof(_int64) ){846 //64bit847 848 //fistp qword ptr[esp]849 fpu_cast();850 OpBuffer[obp++]=(char)0xDF;851 OpBuffer[obp++]=(char)0x3C;852 OpBuffer[obp++]=(char)0x24;853 fpu_cast_end();854 }855 else if( typeSize == sizeof(long) ){856 //32bit857 858 //fistp dword ptr[esp]859 fpu_cast();860 OpBuffer[obp++]=(char)0xDB;861 OpBuffer[obp++]=(char)0x1C;862 OpBuffer[obp++]=(char)0x24;863 fpu_cast_end();864 }865 else{866 SetError();867 }868 }869 void op_fstp_push( Type &type ){870 //sub esp,size871 op_sub_esp( type.GetBasicSize() );872 873 op_fstp_basereg( type.GetBasicType(), REG_ESP );874 }875 876 877 878 //////////////////////////////879 // レジスタ関連880 //////////////////////////////881 882 void op_zero_reg(int reg){883 //レジスタに0をセット884 885 switch(reg){886 case REG_EAX:887 //xor eax,eax888 OpBuffer[obp++]=(char)0x33;889 OpBuffer[obp++]=(char)0xC0;890 break;891 case REG_EBX:892 //xor ebx,ebx893 OpBuffer[obp++]=(char)0x33;894 OpBuffer[obp++]=(char)0xDB;895 break;896 case REG_ECX:897 //xor ecx,ecx898 OpBuffer[obp++]=(char)0x33;899 OpBuffer[obp++]=(char)0xC9;900 break;901 case REG_EDX:902 //xor edx,edx903 OpBuffer[obp++]=(char)0x33;904 OpBuffer[obp++]=(char)0xD2;905 break;906 case REG_EBP:907 //xor ebp,ebp908 OpBuffer[obp++]=(char)0x33;909 OpBuffer[obp++]=(char)0xED;910 break;911 }912 }913 914 void fpu_cast(){915 ///////////////////////916 // FPUの切り捨て設定917 ///////////////////////918 919 //sub esp,16920 op_sub_esp(16);921 922 //mov dword ptr[esp+4],eax923 OpBuffer[obp++]=(char)0x89;924 OpBuffer[obp++]=(char)0x44;925 OpBuffer[obp++]=(char)0x24;926 OpBuffer[obp++]=(char)0x04;927 928 //fnstcw word ptr[esp]929 OpBuffer[obp++]=(char)0xD9;930 OpBuffer[obp++]=(char)0x3C;931 OpBuffer[obp++]=(char)0x24;932 933 //mov ax,word ptr[esp]934 OpBuffer[obp++]=(char)0x66;935 OpBuffer[obp++]=(char)0x8B;936 OpBuffer[obp++]=(char)0x04;937 OpBuffer[obp++]=(char)0x24;938 939 //or ah,0Ch940 OpBuffer[obp++]=(char)0x80;941 OpBuffer[obp++]=(char)0xCC;942 OpBuffer[obp++]=(char)0x0C;943 944 //mov word ptr[esp+2],ax945 OpBuffer[obp++]=(char)0x66;946 OpBuffer[obp++]=(char)0x89;947 OpBuffer[obp++]=(char)0x44;948 OpBuffer[obp++]=(char)0x24;949 OpBuffer[obp++]=(char)0x02;950 951 //fldcw word ptr[esp+2]952 OpBuffer[obp++]=(char)0xD9;953 OpBuffer[obp++]=(char)0x6C;954 OpBuffer[obp++]=(char)0x24;955 OpBuffer[obp++]=(char)0x02;956 957 //mov eax,dword ptr[esp+4]958 OpBuffer[obp++]=(char)0x8B;959 OpBuffer[obp++]=(char)0x44;960 OpBuffer[obp++]=(char)0x24;961 OpBuffer[obp++]=(char)0x04;962 963 //add esp,16964 op_add_esp(16);965 }966 void fpu_cast_end(){967 //sub esp,16968 op_sub_esp(16);969 970 //fldcw word ptr[esp]971 OpBuffer[obp++]=(char)0xD9;972 OpBuffer[obp++]=(char)0x2C;973 OpBuffer[obp++]=(char)0x24;974 975 //add esp,16976 op_add_esp(16);977 }978 979 980 /////////////////////////////981 // 関数呼び出し982 /////////////////////////////983 984 void op_call(const UserProc *pUserProc){985 OpBuffer[obp++]=(char)0xE8;986 pobj_SubAddrSchedule->add(pUserProc,1);987 pUserProc->Using();988 obp+=sizeof(long);989 }990 void op_ret(){991 OpBuffer[obp++]=(char)0xC3;992 } -
trunk/abdev/BasicCompiler_Common/gc.cpp
r223 r225 1 1 #include "stdafx.h" 2 2 3 #include "common.h"3 #include <Compiler.h> 4 4 5 5 #ifdef _AMD64_ … … 25 25 26 26 //mov rax,rsp 27 op_mov_RR(REG_RAX,REG_RSP);27 compiler.codeGenerator.op_mov_RR(REG_RAX,REG_RSP); 28 28 29 29 //mov ptr[offset],rax/eax 30 op_mov_MR(PTR_SIZE,REG_RAX,0,(int)RelativeVar.offset,MOD_DISP32);30 compiler.codeGenerator.op_mov_MR(PTR_SIZE,REG_RAX,0,(int)RelativeVar.offset,MOD_DISP32); 31 31 obp-=sizeof(long); 32 32 pobj_GlobalVarSchedule->add(); -
trunk/abdev/BasicCompiler_Common/include/CodeGenerator.h
r224 r225 1 1 #pragma once 2 2 3 #include <NativeCode.h> 4 5 #ifdef _AMD64_ 6 #include "../../BasicCompiler64/MachineFixed.h" 7 #else 8 #include "../../BasicCompiler32/MachineFixed.h" 9 #endif 10 11 3 12 void ReallocNativeCodeBuffer(); 13 14 class CodeGenerator 15 { 16 NativeCode *pNativeCode; 17 18 // XMLシリアライズ用 19 private: 20 friend class boost::serialization::access; 21 template<class Archive> void serialize(Archive& ar, const unsigned int version) 22 { 23 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( NativeCode ); 24 } 25 26 public: 27 28 void Select( NativeCode &nativeCode ) 29 { 30 pNativeCode = &nativeCode; 31 } 32 33 #ifdef _AMD64_ 34 #else 35 private: 36 void set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,long disp); 37 void __op_format(char op_prefix,char opcode,int reg); 38 void __op_format(char op_prefix,char opcode1,char opcode2,int reg,int base_reg,int offset,char mod); 39 public: 40 void op_mov_RV (int reg,long offset); 41 void op_mov_RV (int op_size,int reg,int offset); 42 void op_mov_RR (int reg1,int reg2); 43 void op_mov_RM (int op_size,int reg,int base_reg,int offset,char mod); 44 void op_mov_RM_ex (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset); 45 void op_mov_MR (int op_size,int reg,int base_reg,int offset,char mod); 46 void op_mov_MR_ex (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset); 47 void op_movsx_R32R16 (int reg32,int reg16 = REG_NON); 48 void op_movsx_R32R8 (int reg32,int reg8 = REG_NON); 49 void op_movsx_R16R8 (int reg16,int reg8 = REG_NON); 50 void op_inc (int reg); 51 void op_dec (int reg); 52 void op_add_RV8 (int reg,char cValue); 53 void op_add_RR ( int reg1, int reg2 ); 54 void op_add_RM (int op_size,int reg,int base_reg,int offset,char mod); 55 void op_adc_RV8 (int reg,char cValue); 56 void op_adc_RR ( int reg1, int reg2 ); 57 void op_sub_RV8 (int reg,char cValue); 58 void op_sub_RR ( int reg1, int reg2 ); 59 void op_sbb_RV8 (int reg,char cValue); 60 void op_sbb_RR ( int reg1, int reg2 ); 61 void op_imul_RR (int reg1,int reg2); 62 void op_imul_RV (int reg,long i32data); 63 void op_imul_RV8 (int reg,char cValue); 64 void op_div_R ( int reg ); 65 void op_idiv_R ( int reg ); 66 void op_and_RV (int reg,long value); 67 void op_and_RR ( int reg1, int reg2 ); 68 void op_or_RR ( int op_size, int reg1, int reg2 ); 69 void op_xor_RR ( int reg1, int reg2 = REG_NON ); 70 void op_neg ( int reg ); 71 void op_cdq (); 72 73 void op_rep_movs (int op_size); 74 75 void op_push(int reg); 76 void op_push_V(long data); 77 void op_push_M( int base_reg ); 78 void op_pop(int reg = REG_NON); 79 void op_add_esp(long num); 80 void op_sub_esp(long num); 81 void op_cmp_RR( int reg1, int reg2 ); 82 void op_cmp_value(int op_size,int reg,char byte_data); 83 void op_setne( int reg ); 84 void op_test(int reg1,int reg2); 85 void op_test_ah( char cValue ); 86 void op_fld_ptr_esp(int type); 87 void op_fld_basereg (int type,int base_reg); 88 void op_fld_base_offset (int type,int base_reg,long offset); 89 void op_fld_base_offset_ex (int type,int base_reg1,int base_reg2,long offset,BOOL bUseOffset); 90 void op_fstp_basereg (int type,int base_reg); 91 void op_fstp_base_offset (int type,int base_reg,long offset); 92 void op_fstp_base_offset_ex (int type,int base_reg1,int base_reg2,long offset,BOOL bUseOffset); 93 void op_fistp_ptr_esp ( int typeSize ); 94 void op_fstp_push ( Type &type ); 95 void op_fcompp(); 96 void op_fnstsw_ax(); 97 void op_zero_reg(int reg); 98 void fpu_cast(); 99 void fpu_cast_end(); 100 101 void op_call(const UserProc *pUserProc); 102 void op_ret(); 103 #endif 104 105 106 107 108 void PutOld( char c1, char c2 ) 109 { 110 pNativeCode->Put( c1 ); 111 pNativeCode->Put( c2 ); 112 } 113 void PutOld( char c1, char c2, char c3 ) 114 { 115 pNativeCode->Put( c1 ); 116 pNativeCode->Put( c2 ); 117 pNativeCode->Put( c3 ); 118 } 119 void PutOld( char c1, char c2, char c3, char c4 ) 120 { 121 pNativeCode->Put( c1 ); 122 pNativeCode->Put( c2 ); 123 pNativeCode->Put( c3 ); 124 pNativeCode->Put( c4 ); 125 } 126 void PutOld( char c1, char c2, char c3, char c4, char c5 ) 127 { 128 pNativeCode->Put( c1 ); 129 pNativeCode->Put( c2 ); 130 pNativeCode->Put( c3 ); 131 pNativeCode->Put( c4 ); 132 pNativeCode->Put( c5 ); 133 } 134 void PutOld( char c1, char c2, char c3, char c4, char c5, char c6 ) 135 { 136 pNativeCode->Put( c1 ); 137 pNativeCode->Put( c2 ); 138 pNativeCode->Put( c3 ); 139 pNativeCode->Put( c4 ); 140 pNativeCode->Put( c5 ); 141 pNativeCode->Put( c6 ); 142 } 143 }; -
trunk/abdev/BasicCompiler_Common/include/Compiler.h
r224 r225 5 5 #include <MetaImpl.h> 6 6 #include <DataTable.h> 7 #include <CodeGenerator.h> 7 8 8 9 class Compiler … … 34 35 } 35 36 37 // グローバル領域のネイティブコード 38 NativeCode globalNativeCode; 39 40 // コード生成機構 41 CodeGenerator codeGenerator; 42 36 43 static bool StringToType( const std::string &typeName, Type &type ); 37 44 static const std::string TypeToString( const Type &type ); -
trunk/abdev/BasicCompiler_Common/include/NativeCode.h
r224 r225 2 2 3 3 #include <vector> 4 5 #include <BoostSerializationSupport.h> 4 6 5 7 class Schedule … … 9 11 { 10 12 None, 13 GlobalVar, // グローバル変数スケジュール 14 LocalVar, // ローカル変数スケジュール 15 Relocation, // リロケーション情報スケジュール 11 16 }; 12 17 … … 123 128 memcpy( this->codeBuffer + this->size, codeBuffer, size ); 124 129 this->size += size; 130 131 // 未完成 132 extern char *OpBuffer; 133 extern int obp; 134 memcpy( OpBuffer, codeBuffer, size ); 135 obp += size; 125 136 } 126 137 void Put( const NativeCode &nativeCode ) … … 132 143 codeBuffer[size++] = c; 133 144 Realloc(); 145 146 147 148 // 未完成 149 extern char *OpBuffer; 150 extern int obp; 151 OpBuffer[obp++]=c; 134 152 } 135 153 void Put( long l, Schedule::Type scheduleType = Schedule::None ) … … 142 160 *((long *)(codeBuffer+size))=l; 143 161 size += sizeof(long); 162 163 164 165 // 未完成 166 extern char *OpBuffer; 167 extern int obp; 168 *((long *)(OpBuffer+obp))=l; 169 obp+=sizeof(long); 144 170 } 145 171 }; -
trunk/abdev/BasicCompiler_Common/include/Procedure.h
r224 r225 11 11 #include <Parameter.h> 12 12 #include <Variable.h> 13 #include < NativeCode.h>13 #include <CodeGenerator.h> 14 14 15 15 class CClass; … … 314 314 } 315 315 316 NativeCode &GetNativeCode() 317 { 318 return nativeCode; 319 } 320 316 321 std::string GetFullName() const; 317 322 -
trunk/abdev/BasicCompiler_Common/src/LexicalScopingImpl.cpp
r206 r225 108 108 109 109 //mov ecx,dword ptr[ebp+offset] 110 op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar->GetOffsetAddress(),MOD_BASE_DISP32);110 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar->GetOffsetAddress(),MOD_BASE_DISP32); 111 111 obp-=sizeof(long); 112 112 AddLocalVarAddrSchedule(); … … 114 114 115 115 //push ecx 116 op_push(REG_ECX);116 compiler.codeGenerator.op_push(REG_ECX); 117 117 #endif 118 118 119 119 //call free 120 120 extern const UserProc *pSub_free; 121 op_call(pSub_free);121 compiler.codeGenerator.op_call(pSub_free); 122 122 123 123
Note:
See TracChangeset
for help on using the changeset viewer.