1215976Sjmallett; z_Windows_NT-586_asm.asm: - microtasking routines specifically 2232812Sjmallett; written for IA-32 architecture and Intel(R) 64 running Windows* OS 3215976Sjmallett 4215976Sjmallett; 5215976Sjmallett;//===----------------------------------------------------------------------===// 6215976Sjmallett;// 7215976Sjmallett;// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 8215976Sjmallett;// See https://llvm.org/LICENSE.txt for license information. 9215976Sjmallett;// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 10215976Sjmallett;// 11215976Sjmallett;//===----------------------------------------------------------------------===// 12215976Sjmallett; 13215976Sjmallett 14215976Sjmallett TITLE z_Windows_NT-586_asm.asm 15215976Sjmallett 16215976Sjmallett; ============================= IA-32 architecture ========================== 17215976Sjmallettifdef _M_IA32 18232812Sjmallett 19215976Sjmallett .586P 20215976Sjmallett 21215976Sjmallettif @Version gt 510 22215976Sjmallett .model HUGE 23215976Sjmallettelse 24215976Sjmallett_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' 25215976Sjmallett_TEXT ENDS 26215976Sjmallett_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' 27215976Sjmallett_DATA ENDS 28215976SjmallettCONST SEGMENT DWORD USE32 PUBLIC 'CONST' 29232812SjmallettCONST ENDS 30215976Sjmallett_BSS SEGMENT DWORD USE32 PUBLIC 'BSS' 31215976Sjmallett_BSS ENDS 32215976Sjmallett$$SYMBOLS SEGMENT BYTE USE32 'DEBSYM' 33215976Sjmallett$$SYMBOLS ENDS 34215976Sjmallett$$TYPES SEGMENT BYTE USE32 'DEBTYP' 35215976Sjmallett$$TYPES ENDS 36215976Sjmallett_TLS SEGMENT DWORD USE32 PUBLIC 'TLS' 37215976Sjmallett_TLS ENDS 38215976SjmallettFLAT GROUP _DATA, CONST, _BSS 39215976Sjmallett ASSUME CS: FLAT, DS: FLAT, SS: FLAT 40215976Sjmallettendif 41215976Sjmallett 42215976Sjmallett 43215976Sjmallett;------------------------------------------------------------------------ 44215976Sjmallett; FUNCTION ___kmp_x86_pause 45215976Sjmallett; 46215976Sjmallett; void 47215976Sjmallett; __kmp_x86_pause( void ) 48215976SjmallettPUBLIC ___kmp_x86_pause 49215976Sjmallett_p$ = 4 50215976Sjmallett_d$ = 8 51215976Sjmallett_TEXT SEGMENT 52232812Sjmallett ALIGN 16 53232812Sjmallett___kmp_x86_pause PROC NEAR 54215976Sjmallett 55215976Sjmallett db 0f3H 56215976Sjmallett db 090H ;; pause 57215976Sjmallett ret 58215976Sjmallett 59232812Sjmallett___kmp_x86_pause ENDP 60215976Sjmallett_TEXT ENDS 61215976Sjmallett 62215976Sjmallett;------------------------------------------------------------------------ 63215976Sjmallett; FUNCTION ___kmp_x86_cpuid 64215976Sjmallett; 65215976Sjmallett; void 66215976Sjmallett; __kmp_x86_cpuid( int mode, int mode2, struct kmp_cpuid *p ); 67215976SjmallettPUBLIC ___kmp_x86_cpuid 68215976Sjmallett_TEXT SEGMENT 69215976Sjmallett ALIGN 16 70232812Sjmallett_mode$ = 8 71215976Sjmallett_mode2$ = 12 72215976Sjmallett_p$ = 16 73215976Sjmallett_eax$ = 0 74215976Sjmallett_ebx$ = 4 75215976Sjmallett_ecx$ = 8 76215976Sjmallett_edx$ = 12 77215976Sjmallett 78215976Sjmallett___kmp_x86_cpuid PROC NEAR 79215976Sjmallett 80215976Sjmallett push ebp 81215976Sjmallett mov ebp, esp 82215976Sjmallett 83215976Sjmallett push edi 84215976Sjmallett push ebx 85215976Sjmallett push ecx 86215976Sjmallett push edx 87215976Sjmallett 88215976Sjmallett mov eax, DWORD PTR _mode$[ebp] 89215976Sjmallett mov ecx, DWORD PTR _mode2$[ebp] 90215976Sjmallett cpuid ; Query the CPUID for the current processor 91215976Sjmallett 92215976Sjmallett mov edi, DWORD PTR _p$[ebp] 93215976Sjmallett mov DWORD PTR _eax$[ edi ], eax 94215976Sjmallett mov DWORD PTR _ebx$[ edi ], ebx 95215976Sjmallett mov DWORD PTR _ecx$[ edi ], ecx 96215976Sjmallett mov DWORD PTR _edx$[ edi ], edx 97215976Sjmallett 98215976Sjmallett pop edx 99215976Sjmallett pop ecx 100215976Sjmallett pop ebx 101215976Sjmallett pop edi 102215976Sjmallett 103215976Sjmallett mov esp, ebp 104215976Sjmallett pop ebp 105232812Sjmallett ret 106232812Sjmallett 107232812Sjmallett___kmp_x86_cpuid ENDP 108232812Sjmallett_TEXT ENDS 109215976Sjmallett 110215976Sjmallett;------------------------------------------------------------------------ 111215976Sjmallett; FUNCTION ___kmp_test_then_add32 112215976Sjmallett; 113215976Sjmallett; kmp_int32 114215976Sjmallett; __kmp_test_then_add32( volatile kmp_int32 *p, kmp_int32 d ); 115215976SjmallettPUBLIC ___kmp_test_then_add32 116215976Sjmallett_p$ = 4 117215976Sjmallett_d$ = 8 118215976Sjmallett_TEXT SEGMENT 119215976Sjmallett ALIGN 16 120215976Sjmallett___kmp_test_then_add32 PROC NEAR 121232812Sjmallett 122232812Sjmallett mov eax, DWORD PTR _d$[esp] 123232812Sjmallett mov ecx, DWORD PTR _p$[esp] 124232812Sjmallettlock xadd DWORD PTR [ecx], eax 125215976Sjmallett ret 126215976Sjmallett 127215976Sjmallett___kmp_test_then_add32 ENDP 128215976Sjmallett_TEXT ENDS 129215976Sjmallett 130215976Sjmallett;------------------------------------------------------------------------ 131215976Sjmallett; FUNCTION ___kmp_compare_and_store8 132215976Sjmallett; 133215976Sjmallett; kmp_int8 134215976Sjmallett; __kmp_compare_and_store8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv ); 135215976SjmallettPUBLIC ___kmp_compare_and_store8 136215976Sjmallett_TEXT SEGMENT 137232812Sjmallett ALIGN 16 138232812Sjmallett_p$ = 4 139232812Sjmallett_cv$ = 8 140232812Sjmallett_sv$ = 12 141215976Sjmallett 142215976Sjmallett___kmp_compare_and_store8 PROC NEAR 143215976Sjmallett 144215976Sjmallett mov ecx, DWORD PTR _p$[esp] 145215976Sjmallett mov al, BYTE PTR _cv$[esp] 146215976Sjmallett mov dl, BYTE PTR _sv$[esp] 147215976Sjmallettlock cmpxchg BYTE PTR [ecx], dl 148215976Sjmallett sete al ; if al == [ecx] set al = 1 else set al = 0 149215976Sjmallett and eax, 1 ; sign extend previous instruction 150215976Sjmallett ret 151215976Sjmallett 152215976Sjmallett___kmp_compare_and_store8 ENDP 153232812Sjmallett_TEXT ENDS 154232812Sjmallett 155232812Sjmallett;------------------------------------------------------------------------ 156232812Sjmallett; FUNCTION ___kmp_compare_and_store16 157215976Sjmallett; 158215976Sjmallett; kmp_int16 159215976Sjmallett; __kmp_compare_and_store16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv ); 160215976SjmallettPUBLIC ___kmp_compare_and_store16 161215976Sjmallett_TEXT SEGMENT 162215976Sjmallett ALIGN 16 163215976Sjmallett_p$ = 4 164215976Sjmallett_cv$ = 8 165215976Sjmallett_sv$ = 12 166215976Sjmallett 167215976Sjmallett___kmp_compare_and_store16 PROC NEAR 168215976Sjmallett 169232812Sjmallett mov ecx, DWORD PTR _p$[esp] 170232812Sjmallett mov ax, WORD PTR _cv$[esp] 171232812Sjmallett mov dx, WORD PTR _sv$[esp] 172232812Sjmallettlock cmpxchg WORD PTR [ecx], dx 173215976Sjmallett sete al ; if ax == [ecx] set al = 1 else set al = 0 174215976Sjmallett and eax, 1 ; sign extend previous instruction 175215976Sjmallett ret 176215976Sjmallett 177215976Sjmallett___kmp_compare_and_store16 ENDP 178215976Sjmallett_TEXT ENDS 179215976Sjmallett 180215976Sjmallett;------------------------------------------------------------------------ 181215976Sjmallett; FUNCTION ___kmp_compare_and_store32 182215976Sjmallett; 183215976Sjmallett; kmp_int32 184215976Sjmallett; __kmp_compare_and_store32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv ); 185232812SjmallettPUBLIC ___kmp_compare_and_store32 186232812Sjmallett_TEXT SEGMENT 187232812Sjmallett ALIGN 16 188232812Sjmallett_p$ = 4 189215976Sjmallett_cv$ = 8 190215976Sjmallett_sv$ = 12 191215976Sjmallett 192215976Sjmallett___kmp_compare_and_store32 PROC NEAR 193215976Sjmallett 194215976Sjmallett mov ecx, DWORD PTR _p$[esp] 195215976Sjmallett mov eax, DWORD PTR _cv$[esp] 196215976Sjmallett mov edx, DWORD PTR _sv$[esp] 197215976Sjmallettlock cmpxchg DWORD PTR [ecx], edx 198215976Sjmallett sete al ; if eax == [ecx] set al = 1 else set al = 0 199215976Sjmallett and eax, 1 ; sign extend previous instruction 200215976Sjmallett ret 201232812Sjmallett 202232812Sjmallett___kmp_compare_and_store32 ENDP 203232812Sjmallett_TEXT ENDS 204232812Sjmallett 205215976Sjmallett;------------------------------------------------------------------------ 206215976Sjmallett; FUNCTION ___kmp_compare_and_store64 207215976Sjmallett; 208215976Sjmallett; kmp_int32 209215976Sjmallett; __kmp_compare_and_store64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv ); 210215976SjmallettPUBLIC ___kmp_compare_and_store64 211215976Sjmallett_TEXT SEGMENT 212215976Sjmallett ALIGN 16 213215976Sjmallett_p$ = 8 214215976Sjmallett_cv_low$ = 12 215215976Sjmallett_cv_high$ = 16 216215976Sjmallett_sv_low$ = 20 217232812Sjmallett_sv_high$ = 24 218232812Sjmallett 219232812Sjmallett___kmp_compare_and_store64 PROC NEAR 220232812Sjmallett 221215976Sjmallett push ebp 222215976Sjmallett mov ebp, esp 223215976Sjmallett push ebx 224215976Sjmallett push edi 225215976Sjmallett mov edi, DWORD PTR _p$[ebp] 226215976Sjmallett mov eax, DWORD PTR _cv_low$[ebp] 227215976Sjmallett mov edx, DWORD PTR _cv_high$[ebp] 228215976Sjmallett mov ebx, DWORD PTR _sv_low$[ebp] 229215976Sjmallett mov ecx, DWORD PTR _sv_high$[ebp] 230215976Sjmallettlock cmpxchg8b QWORD PTR [edi] 231215976Sjmallett sete al ; if edx:eax == [edi] set al = 1 else set al = 0 232215976Sjmallett and eax, 1 ; sign extend previous instruction 233232812Sjmallett pop edi 234232812Sjmallett pop ebx 235232812Sjmallett mov esp, ebp 236232812Sjmallett pop ebp 237215976Sjmallett ret 238215976Sjmallett 239215976Sjmallett___kmp_compare_and_store64 ENDP 240215976Sjmallett_TEXT ENDS 241215976Sjmallett 242215976Sjmallett;------------------------------------------------------------------------ 243215976Sjmallett; FUNCTION ___kmp_xchg_fixed8 244215976Sjmallett; 245215976Sjmallett; kmp_int8 246215976Sjmallett; __kmp_xchg_fixed8( volatile kmp_int8 *p, kmp_int8 d ); 247215976SjmallettPUBLIC ___kmp_xchg_fixed8 248215976Sjmallett_TEXT SEGMENT 249232812Sjmallett ALIGN 16 250232812Sjmallett_p$ = 4 251232812Sjmallett_d$ = 8 252232812Sjmallett 253215976Sjmallett___kmp_xchg_fixed8 PROC NEAR 254215976Sjmallett 255215976Sjmallett mov ecx, DWORD PTR _p$[esp] 256215976Sjmallett mov al, BYTE PTR _d$[esp] 257215976Sjmallettlock xchg BYTE PTR [ecx], al 258215976Sjmallett ret 259215976Sjmallett 260215976Sjmallett___kmp_xchg_fixed8 ENDP 261215976Sjmallett_TEXT ENDS 262215976Sjmallett 263215976Sjmallett;------------------------------------------------------------------------ 264215976Sjmallett; FUNCTION ___kmp_xchg_fixed16 265232812Sjmallett; 266232812Sjmallett; kmp_int16 267232812Sjmallett; __kmp_xchg_fixed16( volatile kmp_int16 *p, kmp_int16 d ); 268232812SjmallettPUBLIC ___kmp_xchg_fixed16 269215976Sjmallett_TEXT SEGMENT 270215976Sjmallett ALIGN 16 271215976Sjmallett_p$ = 4 272215976Sjmallett_d$ = 8 273215976Sjmallett 274215976Sjmallett___kmp_xchg_fixed16 PROC NEAR 275215976Sjmallett 276215976Sjmallett mov ecx, DWORD PTR _p$[esp] 277215976Sjmallett mov ax, WORD PTR _d$[esp] 278215976Sjmallettlock xchg WORD PTR [ecx], ax 279215976Sjmallett ret 280215976Sjmallett 281232812Sjmallett___kmp_xchg_fixed16 ENDP 282232812Sjmallett_TEXT ENDS 283232812Sjmallett 284232812Sjmallett;------------------------------------------------------------------------ 285215976Sjmallett; FUNCTION ___kmp_xchg_fixed32 286215976Sjmallett; 287215976Sjmallett; kmp_int32 288215976Sjmallett; __kmp_xchg_fixed32( volatile kmp_int32 *p, kmp_int32 d ); 289215976SjmallettPUBLIC ___kmp_xchg_fixed32 290215976Sjmallett_TEXT SEGMENT 291215976Sjmallett ALIGN 16 292215976Sjmallett_p$ = 4 293215976Sjmallett_d$ = 8 294215976Sjmallett 295215976Sjmallett___kmp_xchg_fixed32 PROC NEAR 296215976Sjmallett 297232812Sjmallett mov ecx, DWORD PTR _p$[esp] 298232812Sjmallett mov eax, DWORD PTR _d$[esp] 299232812Sjmallettlock xchg DWORD PTR [ecx], eax 300232812Sjmallett ret 301215976Sjmallett 302215976Sjmallett___kmp_xchg_fixed32 ENDP 303215976Sjmallett_TEXT ENDS 304215976Sjmallett 305215976Sjmallett 306215976Sjmallett;------------------------------------------------------------------------ 307215976Sjmallett; FUNCTION ___kmp_xchg_real32 308215976Sjmallett; 309215976Sjmallett; kmp_real32 310215976Sjmallett; __kmp_xchg_real32( volatile kmp_real32 *p, kmp_real32 d ); 311215976SjmallettPUBLIC ___kmp_xchg_real32 312215976Sjmallett_TEXT SEGMENT 313232812Sjmallett ALIGN 16 314232812Sjmallett_p$ = 8 315232812Sjmallett_d$ = 12 316232812Sjmallett_old_value$ = -4 317215976Sjmallett 318215976Sjmallett___kmp_xchg_real32 PROC NEAR 319215976Sjmallett 320215976Sjmallett push ebp 321215976Sjmallett mov ebp, esp 322215976Sjmallett sub esp, 4 323215976Sjmallett push esi 324215976Sjmallett mov esi, DWORD PTR _p$[ebp] 325215976Sjmallett 326215976Sjmallett fld DWORD PTR [esi] 327215976Sjmallett ;; load <addr> 328215976Sjmallett fst DWORD PTR _old_value$[ebp] 329232812Sjmallett ;; store into old_value 330232812Sjmallett 331232812Sjmallett mov eax, DWORD PTR _d$[ebp] 332232812Sjmallett 333215976Sjmallettlock xchg DWORD PTR [esi], eax 334215976Sjmallett 335215976Sjmallett fld DWORD PTR _old_value$[ebp] 336215976Sjmallett ;; return old_value 337215976Sjmallett pop esi 338215976Sjmallett mov esp, ebp 339215976Sjmallett pop ebp 340215976Sjmallett ret 341215976Sjmallett 342215976Sjmallett___kmp_xchg_real32 ENDP 343215976Sjmallett_TEXT ENDS 344215976Sjmallett 345232812Sjmallett 346232812Sjmallett;------------------------------------------------------------------------ 347232812Sjmallett; FUNCTION ___kmp_compare_and_store_ret8 348232812Sjmallett; 349215976Sjmallett; kmp_int8 350215976Sjmallett; __kmp_compare_and_store_ret8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv ); 351215976SjmallettPUBLIC ___kmp_compare_and_store_ret8 352215976Sjmallett_TEXT SEGMENT 353215976Sjmallett ALIGN 16 354215976Sjmallett_p$ = 4 355215976Sjmallett_cv$ = 8 356215976Sjmallett_sv$ = 12 357215976Sjmallett 358215976Sjmallett___kmp_compare_and_store_ret8 PROC NEAR 359215976Sjmallett 360215976Sjmallett mov ecx, DWORD PTR _p$[esp] 361232812Sjmallett mov al, BYTE PTR _cv$[esp] 362232812Sjmallett mov dl, BYTE PTR _sv$[esp] 363232812Sjmallettlock cmpxchg BYTE PTR [ecx], dl 364232812Sjmallett ret 365215976Sjmallett 366215976Sjmallett___kmp_compare_and_store_ret8 ENDP 367215976Sjmallett_TEXT ENDS 368215976Sjmallett 369215976Sjmallett;------------------------------------------------------------------------ 370215976Sjmallett; FUNCTION ___kmp_compare_and_store_ret16 371215976Sjmallett; 372215976Sjmallett; kmp_int16 373215976Sjmallett; __kmp_compare_and_store_ret16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv ); 374215976SjmallettPUBLIC ___kmp_compare_and_store_ret16 375215976Sjmallett_TEXT SEGMENT 376215976Sjmallett ALIGN 16 377232812Sjmallett_p$ = 4 378232812Sjmallett_cv$ = 8 379232812Sjmallett_sv$ = 12 380232812Sjmallett 381215976Sjmallett___kmp_compare_and_store_ret16 PROC NEAR 382215976Sjmallett 383215976Sjmallett mov ecx, DWORD PTR _p$[esp] 384215976Sjmallett mov ax, WORD PTR _cv$[esp] 385215976Sjmallett mov dx, WORD PTR _sv$[esp] 386215976Sjmallettlock cmpxchg WORD PTR [ecx], dx 387215976Sjmallett ret 388215976Sjmallett 389215976Sjmallett___kmp_compare_and_store_ret16 ENDP 390215976Sjmallett_TEXT ENDS 391215976Sjmallett 392215976Sjmallett;------------------------------------------------------------------------ 393232812Sjmallett; FUNCTION ___kmp_compare_and_store_ret32 394232812Sjmallett; 395232812Sjmallett; kmp_int32 396232812Sjmallett; __kmp_compare_and_store_ret32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv ); 397215976SjmallettPUBLIC ___kmp_compare_and_store_ret32 398215976Sjmallett_TEXT SEGMENT 399215976Sjmallett ALIGN 16 400215976Sjmallett_p$ = 4 401215976Sjmallett_cv$ = 8 402215976Sjmallett_sv$ = 12 403215976Sjmallett 404215976Sjmallett___kmp_compare_and_store_ret32 PROC NEAR 405215976Sjmallett 406215976Sjmallett mov ecx, DWORD PTR _p$[esp] 407232812Sjmallett mov eax, DWORD PTR _cv$[esp] 408232812Sjmallett mov edx, DWORD PTR _sv$[esp] 409232812Sjmallettlock cmpxchg DWORD PTR [ecx], edx 410232812Sjmallett ret 411215976Sjmallett 412215976Sjmallett___kmp_compare_and_store_ret32 ENDP 413215976Sjmallett_TEXT ENDS 414215976Sjmallett 415215976Sjmallett;------------------------------------------------------------------------ 416215976Sjmallett; FUNCTION ___kmp_compare_and_store_ret64 417215976Sjmallett; 418215976Sjmallett; kmp_int64 419215976Sjmallett; __kmp_compare_and_store_ret64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv ); 420215976SjmallettPUBLIC ___kmp_compare_and_store_ret64 421215976Sjmallett_TEXT SEGMENT 422215976Sjmallett ALIGN 16 423232812Sjmallett_p$ = 8 424232812Sjmallett_cv_low$ = 12 425232812Sjmallett_cv_high$ = 16 426232812Sjmallett_sv_low$ = 20 427215976Sjmallett_sv_high$ = 24 428215976Sjmallett 429215976Sjmallett___kmp_compare_and_store_ret64 PROC NEAR 430215976Sjmallett 431215976Sjmallett push ebp 432215976Sjmallett mov ebp, esp 433215976Sjmallett push ebx 434215976Sjmallett push edi 435215976Sjmallett mov edi, DWORD PTR _p$[ebp] 436215976Sjmallett mov eax, DWORD PTR _cv_low$[ebp] 437215976Sjmallett mov edx, DWORD PTR _cv_high$[ebp] 438215976Sjmallett mov ebx, DWORD PTR _sv_low$[ebp] 439232812Sjmallett mov ecx, DWORD PTR _sv_high$[ebp] 440232812Sjmallettlock cmpxchg8b QWORD PTR [edi] 441232812Sjmallett pop edi 442232812Sjmallett pop ebx 443215976Sjmallett mov esp, ebp 444215976Sjmallett pop ebp 445215976Sjmallett ret 446215976Sjmallett 447215976Sjmallett___kmp_compare_and_store_ret64 ENDP 448215976Sjmallett_TEXT ENDS 449215976Sjmallett 450215976Sjmallett;------------------------------------------------------------------------ 451215976Sjmallett; FUNCTION ___kmp_load_x87_fpu_control_word 452215976Sjmallett; 453215976Sjmallett; void 454215976Sjmallett; __kmp_load_x87_fpu_control_word( kmp_int16 *p ); 455232812Sjmallett; 456232812Sjmallett; parameters: 457232812Sjmallett; p: 4(%esp) 458232812SjmallettPUBLIC ___kmp_load_x87_fpu_control_word 459215976Sjmallett_TEXT SEGMENT 460215976Sjmallett ALIGN 16 461215976Sjmallett_p$ = 4 462215976Sjmallett 463215976Sjmallett___kmp_load_x87_fpu_control_word PROC NEAR 464215976Sjmallett 465215976Sjmallett mov eax, DWORD PTR _p$[esp] 466215976Sjmallett fldcw WORD PTR [eax] 467215976Sjmallett ret 468215976Sjmallett 469215976Sjmallett___kmp_load_x87_fpu_control_word ENDP 470215976Sjmallett_TEXT ENDS 471232812Sjmallett 472232812Sjmallett;------------------------------------------------------------------------ 473232812Sjmallett; FUNCTION ___kmp_store_x87_fpu_control_word 474232812Sjmallett; 475215976Sjmallett; void 476215976Sjmallett; __kmp_store_x87_fpu_control_word( kmp_int16 *p ); 477215976Sjmallett; 478215976Sjmallett; parameters: 479215976Sjmallett; p: 4(%esp) 480215976SjmallettPUBLIC ___kmp_store_x87_fpu_control_word 481215976Sjmallett_TEXT SEGMENT 482215976Sjmallett ALIGN 16 483215976Sjmallett_p$ = 4 484215976Sjmallett 485215976Sjmallett___kmp_store_x87_fpu_control_word PROC NEAR 486215976Sjmallett 487232812Sjmallett mov eax, DWORD PTR _p$[esp] 488232812Sjmallett fstcw WORD PTR [eax] 489232812Sjmallett ret 490232812Sjmallett 491215976Sjmallett___kmp_store_x87_fpu_control_word ENDP 492215976Sjmallett_TEXT ENDS 493215976Sjmallett 494215976Sjmallett;------------------------------------------------------------------------ 495215976Sjmallett; FUNCTION ___kmp_clear_x87_fpu_status_word 496215976Sjmallett; 497215976Sjmallett; void 498215976Sjmallett; __kmp_clear_x87_fpu_status_word(); 499215976SjmallettPUBLIC ___kmp_clear_x87_fpu_status_word 500215976Sjmallett_TEXT SEGMENT 501215976Sjmallett ALIGN 16 502215976Sjmallett 503232812Sjmallett___kmp_clear_x87_fpu_status_word PROC NEAR 504232812Sjmallett 505232812Sjmallett fnclex 506232812Sjmallett ret 507215976Sjmallett 508215976Sjmallett___kmp_clear_x87_fpu_status_word ENDP 509215976Sjmallett_TEXT ENDS 510215976Sjmallett 511215976Sjmallett 512215976Sjmallett;------------------------------------------------------------------------ 513215976Sjmallett; FUNCTION ___kmp_invoke_microtask 514215976Sjmallett; 515215976Sjmallett; typedef void (*microtask_t)( int *gtid, int *tid, ... ); 516215976Sjmallett; 517215976Sjmallett; int 518215976Sjmallett; __kmp_invoke_microtask( microtask_t pkfn, 519232812Sjmallett; int gtid, int tid, 520232812Sjmallett; int argc, void *p_argv[] ) 521232812SjmallettPUBLIC ___kmp_invoke_microtask 522232812Sjmallett_TEXT SEGMENT 523215976Sjmallett ALIGN 16 524215976Sjmallett_pkfn$ = 8 525215976Sjmallett_gtid$ = 12 526215976Sjmallett_tid$ = 16 527215976Sjmallett_argc$ = 20 528215976Sjmallett_argv$ = 24 529215976Sjmallettif OMPT_SUPPORT 530215976Sjmallett_exit_frame$ = 28 531215976Sjmallettendif 532215976Sjmallett_i$ = -8 533215976Sjmallett_stk_adj$ = -16 534215976Sjmallett_vptr$ = -12 535232812Sjmallett_qptr$ = -4 536232812Sjmallett 537232812Sjmallett___kmp_invoke_microtask PROC NEAR 538232812Sjmallett; Line 102 539215976Sjmallett push ebp 540215976Sjmallett mov ebp, esp 541215976Sjmallett sub esp, 16 ; 00000010H 542215976Sjmallett push ebx 543215976Sjmallett push esi 544215976Sjmallett push edi 545215976Sjmallettif OMPT_SUPPORT 546215976Sjmallett mov eax, DWORD PTR _exit_frame$[ebp] 547215976Sjmallett mov DWORD PTR [eax], ebp 548215976Sjmallettendif 549215976Sjmallett; Line 114 550215976Sjmallett mov eax, DWORD PTR _argc$[ebp] 551232812Sjmallett mov DWORD PTR _i$[ebp], eax 552232812Sjmallett 553232812Sjmallett;; ------------------------------------------------------------ 554232812Sjmallett lea edx, DWORD PTR [eax*4+8] 555215976Sjmallett mov ecx, esp ; Save current SP into ECX 556215976Sjmallett mov eax,edx ; Save the size of the args in eax 557215976Sjmallett sub ecx,edx ; esp-((#args+2)*4) -> ecx -- without mods, stack ptr would be this 558215976Sjmallett mov edx,ecx ; Save to edx 559215976Sjmallett and ecx,-128 ; Mask off 7 bits 560215976Sjmallett sub edx,ecx ; Amount to subtract from esp 561215976Sjmallett sub esp,edx ; Prepare stack ptr-- Now it will be aligned on 128-byte boundary at the call 562215976Sjmallett 563215976Sjmallett add edx,eax ; Calculate total size of the stack decrement. 564215976Sjmallett mov DWORD PTR _stk_adj$[ebp], edx 565215976Sjmallett;; ------------------------------------------------------------ 566215976Sjmallett 567232812Sjmallett jmp SHORT $L22237 568232812Sjmallett$L22238: 569232812Sjmallett mov ecx, DWORD PTR _i$[ebp] 570232812Sjmallett sub ecx, 1 571215976Sjmallett mov DWORD PTR _i$[ebp], ecx 572215976Sjmallett$L22237: 573215976Sjmallett cmp DWORD PTR _i$[ebp], 0 574215976Sjmallett jle SHORT $L22239 575215976Sjmallett; Line 116 576215976Sjmallett mov edx, DWORD PTR _i$[ebp] 577215976Sjmallett mov eax, DWORD PTR _argv$[ebp] 578215976Sjmallett mov ecx, DWORD PTR [eax+edx*4-4] 579215976Sjmallett mov DWORD PTR _vptr$[ebp], ecx 580215976Sjmallett; Line 123 581215976Sjmallett mov eax, DWORD PTR _vptr$[ebp] 582215976Sjmallett; Line 124 583232812Sjmallett push eax 584232812Sjmallett; Line 127 585232812Sjmallett jmp SHORT $L22238 586232812Sjmallett$L22239: 587215976Sjmallett; Line 129 588215976Sjmallett lea edx, DWORD PTR _tid$[ebp] 589215976Sjmallett mov DWORD PTR _vptr$[ebp], edx 590215976Sjmallett; Line 130 591215976Sjmallett lea eax, DWORD PTR _gtid$[ebp] 592215976Sjmallett mov DWORD PTR _qptr$[ebp], eax 593215976Sjmallett; Line 143 594215976Sjmallett mov eax, DWORD PTR _vptr$[ebp] 595215976Sjmallett; Line 144 596215976Sjmallett push eax 597215976Sjmallett; Line 145 598215976Sjmallett mov eax, DWORD PTR _qptr$[ebp] 599232812Sjmallett; Line 146 600232812Sjmallett push eax 601232812Sjmallett; Line 147 602232812Sjmallett call DWORD PTR _pkfn$[ebp] 603215976Sjmallett; Line 148 604215976Sjmallett add esp, DWORD PTR _stk_adj$[ebp] 605215976Sjmallett; Line 152 606215976Sjmallett mov eax, 1 607215976Sjmallett; Line 153 608215976Sjmallett pop edi 609215976Sjmallett pop esi 610215976Sjmallett pop ebx 611215976Sjmallett mov esp, ebp 612215976Sjmallett pop ebp 613215976Sjmallett ret 0 614215976Sjmallett___kmp_invoke_microtask ENDP 615232812Sjmallett_TEXT ENDS 616232812Sjmallett 617232812Sjmallettendif 618232812Sjmallett 619215976Sjmallett; ==================================== Intel(R) 64 =================================== 620215976Sjmallett 621215976Sjmallettifdef _M_AMD64 622215976Sjmallett 623215976Sjmallett;------------------------------------------------------------------------ 624215976Sjmallett; FUNCTION __kmp_x86_cpuid 625215976Sjmallett; 626215976Sjmallett; void 627215976Sjmallett; __kmp_x86_cpuid( int mode, int mode2, struct kmp_cpuid *p ); 628215976Sjmallett; 629215976Sjmallett; parameters: 630215976Sjmallett; mode: ecx 631232812Sjmallett; mode2: edx 632232812Sjmallett; cpuid_buffer: r8 633232812SjmallettPUBLIC __kmp_x86_cpuid 634232812Sjmallett_TEXT SEGMENT 635215976Sjmallett ALIGN 16 636215976Sjmallett 637215976Sjmallett__kmp_x86_cpuid PROC FRAME ;NEAR 638215976Sjmallett 639215976Sjmallett push rbp 640215976Sjmallett .pushreg rbp 641215976Sjmallett mov rbp, rsp 642215976Sjmallett .setframe rbp, 0 643215976Sjmallett push rbx ; callee-save register 644215976Sjmallett .pushreg rbx 645232812Sjmallett .ENDPROLOG 646215976Sjmallett 647215976Sjmallett mov r10, r8 ; p parameter 648215976Sjmallett mov eax, ecx ; mode parameter 649215976Sjmallett mov ecx, edx ; mode2 parameter 650215976Sjmallett cpuid ; Query the CPUID for the current processor 651215976Sjmallett 652215976Sjmallett mov DWORD PTR 0[ r10 ], eax ; store results into buffer 653215976Sjmallett mov DWORD PTR 4[ r10 ], ebx 654215976Sjmallett mov DWORD PTR 8[ r10 ], ecx 655215976Sjmallett mov DWORD PTR 12[ r10 ], edx 656232812Sjmallett 657215976Sjmallett pop rbx ; callee-save register 658215976Sjmallett mov rsp, rbp 659215976Sjmallett pop rbp 660215976Sjmallett ret 661215976Sjmallett 662215976Sjmallett__kmp_x86_cpuid ENDP 663215976Sjmallett_TEXT ENDS 664215976Sjmallett 665215976Sjmallett 666215976Sjmallett;------------------------------------------------------------------------ 667215976Sjmallett; FUNCTION __kmp_test_then_add32 668215976Sjmallett; 669232812Sjmallett; kmp_int32 670232812Sjmallett; __kmp_test_then_add32( volatile kmp_int32 *p, kmp_int32 d ); 671232812Sjmallett; 672232812Sjmallett; parameters: 673215976Sjmallett; p: rcx 674215976Sjmallett; d: edx 675215976Sjmallett; 676215976Sjmallett; return: eax 677215976SjmallettPUBLIC __kmp_test_then_add32 678215976Sjmallett_TEXT SEGMENT 679215976Sjmallett ALIGN 16 680215976Sjmallett__kmp_test_then_add32 PROC ;NEAR 681215976Sjmallett 682215976Sjmallett mov eax, edx 683232812Sjmallettlock xadd DWORD PTR [rcx], eax 684215976Sjmallett ret 685215976Sjmallett 686215976Sjmallett__kmp_test_then_add32 ENDP 687215976Sjmallett_TEXT ENDS 688215976Sjmallett 689215976Sjmallett 690215976Sjmallett;------------------------------------------------------------------------ 691215976Sjmallett; FUNCTION __kmp_test_then_add64 692215976Sjmallett; 693215976Sjmallett; kmp_int32 694215976Sjmallett; __kmp_test_then_add64( volatile kmp_int64 *p, kmp_int64 d ); 695215976Sjmallett; 696232812Sjmallett; parameters: 697232812Sjmallett; p: rcx 698232812Sjmallett; d: rdx 699232812Sjmallett; 700215976Sjmallett; return: rax 701215976SjmallettPUBLIC __kmp_test_then_add64 702215976Sjmallett_TEXT SEGMENT 703215976Sjmallett ALIGN 16 704215976Sjmallett__kmp_test_then_add64 PROC ;NEAR 705215976Sjmallett 706215976Sjmallett mov rax, rdx 707215976Sjmallettlock xadd QWORD PTR [rcx], rax 708215976Sjmallett ret 709215976Sjmallett 710232812Sjmallett__kmp_test_then_add64 ENDP 711232812Sjmallett_TEXT ENDS 712232812Sjmallett 713232812Sjmallett 714215976Sjmallett;------------------------------------------------------------------------ 715215976Sjmallett; FUNCTION __kmp_compare_and_store8 716215976Sjmallett; 717215976Sjmallett; kmp_int8 718215976Sjmallett; __kmp_compare_and_store8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv ); 719215976Sjmallett; parameters: 720215976Sjmallett; p: rcx 721215976Sjmallett; cv: edx 722215976Sjmallett; sv: r8d 723215976Sjmallett; 724215976Sjmallett; return: eax 725215976SjmallettPUBLIC __kmp_compare_and_store8 726232812Sjmallett_TEXT SEGMENT 727232812Sjmallett ALIGN 16 728232812Sjmallett 729232812Sjmallett__kmp_compare_and_store8 PROC ;NEAR 730215976Sjmallett 731215976Sjmallett mov al, dl ; "cv" 732215976Sjmallett mov edx, r8d ; "sv" 733215976Sjmallettlock cmpxchg BYTE PTR [rcx], dl 734215976Sjmallett sete al ; if al == [rcx] set al = 1 else set al = 0 735215976Sjmallett and rax, 1 ; sign extend previous instruction 736215976Sjmallett ret 737215976Sjmallett 738215976Sjmallett__kmp_compare_and_store8 ENDP 739215976Sjmallett_TEXT ENDS 740215976Sjmallett 741215976Sjmallett 742232812Sjmallett;------------------------------------------------------------------------ 743232812Sjmallett; FUNCTION __kmp_compare_and_store16 744232812Sjmallett; 745232812Sjmallett; kmp_int16 746215976Sjmallett; __kmp_compare_and_store16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv ); 747215976Sjmallett; parameters: 748215976Sjmallett; p: rcx 749215976Sjmallett; cv: edx 750215976Sjmallett; sv: r8d 751215976Sjmallett; 752215976Sjmallett; return: eax 753215976SjmallettPUBLIC __kmp_compare_and_store16 754215976Sjmallett_TEXT SEGMENT 755215976Sjmallett ALIGN 16 756215976Sjmallett 757215976Sjmallett__kmp_compare_and_store16 PROC ;NEAR 758232812Sjmallett 759232812Sjmallett mov ax, dx ; "cv" 760232812Sjmallett mov edx, r8d ; "sv" 761232812Sjmallettlock cmpxchg WORD PTR [rcx], dx 762215976Sjmallett sete al ; if ax == [rcx] set al = 1 else set al = 0 763215976Sjmallett and rax, 1 ; sign extend previous instruction 764215976Sjmallett ret 765215976Sjmallett 766215976Sjmallett__kmp_compare_and_store16 ENDP 767215976Sjmallett_TEXT ENDS 768215976Sjmallett 769215976Sjmallett 770215976Sjmallett;------------------------------------------------------------------------ 771215976Sjmallett; FUNCTION __kmp_compare_and_store32 772215976Sjmallett; 773215976Sjmallett; kmp_int32 774232812Sjmallett; __kmp_compare_and_store32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv ); 775232812Sjmallett; parameters: 776232812Sjmallett; p: rcx 777232812Sjmallett; cv: edx 778215976Sjmallett; sv: r8d 779215976Sjmallett; 780215976Sjmallett; return: eax 781215976SjmallettPUBLIC __kmp_compare_and_store32 782215976Sjmallett_TEXT SEGMENT 783215976Sjmallett ALIGN 16 784215976Sjmallett 785215976Sjmallett__kmp_compare_and_store32 PROC ;NEAR 786215976Sjmallett 787215976Sjmallett mov eax, edx ; "cv" 788215976Sjmallett mov edx, r8d ; "sv" 789215976Sjmallettlock cmpxchg DWORD PTR [rcx], edx 790232812Sjmallett sete al ; if eax == [rcx] set al = 1 else set al = 0 791232812Sjmallett and rax, 1 ; sign extend previous instruction 792232812Sjmallett ret 793232812Sjmallett 794215976Sjmallett__kmp_compare_and_store32 ENDP 795215976Sjmallett_TEXT ENDS 796215976Sjmallett 797215976Sjmallett 798215976Sjmallett;------------------------------------------------------------------------ 799215976Sjmallett; FUNCTION __kmp_compare_and_store64 800215976Sjmallett; 801215976Sjmallett; kmp_int32 802215976Sjmallett; __kmp_compare_and_store64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv ); 803215976Sjmallett; parameters: 804215976Sjmallett; p: rcx 805215976Sjmallett; cv: rdx 806232812Sjmallett; sv: r8 807232812Sjmallett; 808232812Sjmallett; return: eax 809232812SjmallettPUBLIC __kmp_compare_and_store64 810215976Sjmallett_TEXT SEGMENT 811215976Sjmallett ALIGN 16 812215976Sjmallett 813215976Sjmallett__kmp_compare_and_store64 PROC ;NEAR 814215976Sjmallett 815215976Sjmallett mov rax, rdx ; "cv" 816215976Sjmallett mov rdx, r8 ; "sv" 817215976Sjmallettlock cmpxchg QWORD PTR [rcx], rdx 818215976Sjmallett sete al ; if rax == [rcx] set al = 1 else set al = 0 819215976Sjmallett and rax, 1 ; sign extend previous instruction 820215976Sjmallett ret 821215976Sjmallett 822232812Sjmallett__kmp_compare_and_store64 ENDP 823232812Sjmallett_TEXT ENDS 824232812Sjmallett 825232812Sjmallett 826215976Sjmallett;------------------------------------------------------------------------ 827215976Sjmallett; FUNCTION ___kmp_xchg_fixed8 828215976Sjmallett; 829215976Sjmallett; kmp_int8 830215976Sjmallett; __kmp_xchg_fixed8( volatile kmp_int8 *p, kmp_int8 d ); 831215976Sjmallett; 832215976Sjmallett; parameters: 833215976Sjmallett; p: rcx 834215976Sjmallett; d: dl 835215976Sjmallett; 836215976Sjmallett; return: al 837215976SjmallettPUBLIC __kmp_xchg_fixed8 838232812Sjmallett_TEXT SEGMENT 839232812Sjmallett ALIGN 16 840232812Sjmallett 841232812Sjmallett__kmp_xchg_fixed8 PROC ;NEAR 842215976Sjmallett 843215976Sjmallett mov al, dl 844215976Sjmallettlock xchg BYTE PTR [rcx], al 845215976Sjmallett ret 846215976Sjmallett 847215976Sjmallett__kmp_xchg_fixed8 ENDP 848215976Sjmallett_TEXT ENDS 849215976Sjmallett 850215976Sjmallett 851215976Sjmallett;------------------------------------------------------------------------ 852215976Sjmallett; FUNCTION ___kmp_xchg_fixed16 853215976Sjmallett; 854232812Sjmallett; kmp_int16 855232812Sjmallett; __kmp_xchg_fixed16( volatile kmp_int16 *p, kmp_int16 d ); 856232812Sjmallett; 857232812Sjmallett; parameters: 858215976Sjmallett; p: rcx 859215976Sjmallett; d: dx 860215976Sjmallett; 861215976Sjmallett; return: ax 862215976SjmallettPUBLIC __kmp_xchg_fixed16 863215976Sjmallett_TEXT SEGMENT 864215976Sjmallett ALIGN 16 865215976Sjmallett 866215976Sjmallett__kmp_xchg_fixed16 PROC ;NEAR 867215976Sjmallett 868215976Sjmallett mov ax, dx 869215976Sjmallettlock xchg WORD PTR [rcx], ax 870232812Sjmallett ret 871232812Sjmallett 872232812Sjmallett__kmp_xchg_fixed16 ENDP 873232812Sjmallett_TEXT ENDS 874215976Sjmallett 875215976Sjmallett 876215976Sjmallett;------------------------------------------------------------------------ 877215976Sjmallett; FUNCTION ___kmp_xchg_fixed32 878215976Sjmallett; 879215976Sjmallett; kmp_int32 880215976Sjmallett; __kmp_xchg_fixed32( volatile kmp_int32 *p, kmp_int32 d ); 881215976Sjmallett; 882215976Sjmallett; parameters: 883215976Sjmallett; p: rcx 884215976Sjmallett; d: edx 885215976Sjmallett; 886232812Sjmallett; return: eax 887232812SjmallettPUBLIC __kmp_xchg_fixed32 888232812Sjmallett_TEXT SEGMENT 889232812Sjmallett ALIGN 16 890215976Sjmallett__kmp_xchg_fixed32 PROC ;NEAR 891215976Sjmallett 892215976Sjmallett mov eax, edx 893215976Sjmallettlock xchg DWORD PTR [rcx], eax 894215976Sjmallett ret 895215976Sjmallett 896215976Sjmallett__kmp_xchg_fixed32 ENDP 897215976Sjmallett_TEXT ENDS 898215976Sjmallett 899215976Sjmallett 900215976Sjmallett;------------------------------------------------------------------------ 901215976Sjmallett; FUNCTION ___kmp_xchg_fixed64 902232812Sjmallett; 903232812Sjmallett; kmp_int64 904232812Sjmallett; __kmp_xchg_fixed64( volatile kmp_int64 *p, kmp_int64 d ); 905232812Sjmallett; 906215976Sjmallett; parameters: 907215976Sjmallett; p: rcx 908215976Sjmallett; d: rdx 909215976Sjmallett; 910215976Sjmallett; return: rax 911215976SjmallettPUBLIC __kmp_xchg_fixed64 912215976Sjmallett_TEXT SEGMENT 913215976Sjmallett ALIGN 16 914215976Sjmallett__kmp_xchg_fixed64 PROC ;NEAR 915215976Sjmallett 916215976Sjmallett mov rax, rdx 917215976Sjmallettlock xchg QWORD PTR [rcx], rax 918232812Sjmallett ret 919232812Sjmallett 920232812Sjmallett__kmp_xchg_fixed64 ENDP 921232812Sjmallett_TEXT ENDS 922215976Sjmallett 923215976Sjmallett 924215976Sjmallett;------------------------------------------------------------------------ 925215976Sjmallett; FUNCTION __kmp_compare_and_store_ret8 926215976Sjmallett; 927215976Sjmallett; kmp_int8 928215976Sjmallett; __kmp_compare_and_store_ret8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv ); 929215976Sjmallett; parameters: 930215976Sjmallett; p: rcx 931215976Sjmallett; cv: edx 932215976Sjmallett; sv: r8d 933215976Sjmallett; 934232812Sjmallett; return: eax 935232812SjmallettPUBLIC __kmp_compare_and_store_ret8 936232812Sjmallett_TEXT SEGMENT 937232812Sjmallett ALIGN 16 938215976Sjmallett 939215976Sjmallett__kmp_compare_and_store_ret8 PROC ;NEAR 940215976Sjmallett mov al, dl ; "cv" 941215976Sjmallett mov edx, r8d ; "sv" 942215976Sjmallettlock cmpxchg BYTE PTR [rcx], dl 943215976Sjmallett ; Compare AL with [rcx]. If equal set 944215976Sjmallett ; ZF and exchange DL with [rcx]. Else, clear 945215976Sjmallett ; ZF and load [rcx] into AL. 946215976Sjmallett ret 947215976Sjmallett 948215976Sjmallett__kmp_compare_and_store_ret8 ENDP 949215976Sjmallett_TEXT ENDS 950232812Sjmallett 951232812Sjmallett 952232812Sjmallett;------------------------------------------------------------------------ 953232812Sjmallett; FUNCTION __kmp_compare_and_store_ret16 954215976Sjmallett; 955215976Sjmallett; kmp_int16 956215976Sjmallett; __kmp_compare_and_store_ret16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv ); 957215976Sjmallett; parameters: 958215976Sjmallett; p: rcx 959215976Sjmallett; cv: edx 960215976Sjmallett; sv: r8d 961215976Sjmallett; 962215976Sjmallett; return: eax 963215976SjmallettPUBLIC __kmp_compare_and_store_ret16 964215976Sjmallett_TEXT SEGMENT 965215976Sjmallett ALIGN 16 966232812Sjmallett 967232812Sjmallett__kmp_compare_and_store_ret16 PROC ;NEAR 968232812Sjmallett 969232812Sjmallett mov ax, dx ; "cv" 970215976Sjmallett mov edx, r8d ; "sv" 971215976Sjmallettlock cmpxchg WORD PTR [rcx], dx 972215976Sjmallett ret 973215976Sjmallett 974215976Sjmallett__kmp_compare_and_store_ret16 ENDP 975215976Sjmallett_TEXT ENDS 976215976Sjmallett 977215976Sjmallett 978215976Sjmallett;------------------------------------------------------------------------ 979215976Sjmallett; FUNCTION __kmp_compare_and_store_ret32 980215976Sjmallett; 981215976Sjmallett; kmp_int32 982232812Sjmallett; __kmp_compare_and_store_ret32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv ); 983232812Sjmallett; parameters: 984232812Sjmallett; p: rcx 985232812Sjmallett; cv: edx 986215976Sjmallett; sv: r8d 987215976Sjmallett; 988215976Sjmallett; return: eax 989215976SjmallettPUBLIC __kmp_compare_and_store_ret32 990215976Sjmallett_TEXT SEGMENT 991215976Sjmallett ALIGN 16 992215976Sjmallett 993215976Sjmallett__kmp_compare_and_store_ret32 PROC ;NEAR 994215976Sjmallett 995215976Sjmallett mov eax, edx ; "cv" 996215976Sjmallett mov edx, r8d ; "sv" 997215976Sjmallettlock cmpxchg DWORD PTR [rcx], edx 998232812Sjmallett ret 999232812Sjmallett 1000232812Sjmallett__kmp_compare_and_store_ret32 ENDP 1001232812Sjmallett_TEXT ENDS 1002215976Sjmallett 1003215976Sjmallett 1004215976Sjmallett;------------------------------------------------------------------------ 1005215976Sjmallett; FUNCTION __kmp_compare_and_store_ret64 1006215976Sjmallett; 1007215976Sjmallett; kmp_int64 1008215976Sjmallett; __kmp_compare_and_store_ret64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv ); 1009215976Sjmallett; parameters: 1010215976Sjmallett; p: rcx 1011215976Sjmallett; cv: rdx 1012215976Sjmallett; sv: r8 1013215976Sjmallett; 1014232812Sjmallett; return: rax 1015232812SjmallettPUBLIC __kmp_compare_and_store_ret64 1016232812Sjmallett_TEXT SEGMENT 1017232812Sjmallett ALIGN 16 1018215976Sjmallett 1019215976Sjmallett__kmp_compare_and_store_ret64 PROC ;NEAR 1020215976Sjmallett 1021215976Sjmallett mov rax, rdx ; "cv" 1022215976Sjmallett mov rdx, r8 ; "sv" 1023215976Sjmallettlock cmpxchg QWORD PTR [rcx], rdx 1024215976Sjmallett ret 1025215976Sjmallett 1026215976Sjmallett__kmp_compare_and_store_ret64 ENDP 1027215976Sjmallett_TEXT ENDS 1028232812Sjmallett 1029215976Sjmallett 1030215976Sjmallett;------------------------------------------------------------------------ 1031215976Sjmallett; FUNCTION __kmp_compare_and_store_loop8 1032215976Sjmallett; 1033215976Sjmallett; kmp_int8 1034215976Sjmallett; __kmp_compare_and_store_loop8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv ); 1035215976Sjmallett; parameters: 1036215976Sjmallett; p: rcx 1037215976Sjmallett; cv: edx 1038215976Sjmallett; sv: r8d 1039232812Sjmallett; 1040215976Sjmallett; return: al 1041215976SjmallettPUBLIC __kmp_compare_and_store_loop8 1042215976Sjmallett_TEXT SEGMENT 1043215976Sjmallett ALIGN 16 1044215976Sjmallett 1045215976Sjmallett__kmp_compare_and_store_loop8 PROC ;NEAR 1046215976Sjmallett$__kmp_loop: 1047215976Sjmallett mov al, dl ; "cv" 1048215976Sjmallett mov edx, r8d ; "sv" 1049215976Sjmallettlock cmpxchg BYTE PTR [rcx], dl 1050232812Sjmallett ; Compare AL with [rcx]. If equal set 1051215976Sjmallett ; ZF and exchange DL with [rcx]. Else, clear 1052215976Sjmallett ; ZF and load [rcx] into AL. 1053215976Sjmallett jz SHORT $__kmp_success 1054215976Sjmallett 1055215976Sjmallett db 0f3H 1056215976Sjmallett db 090H ; pause 1057215976Sjmallett 1058215976Sjmallett jmp SHORT $__kmp_loop 1059215976Sjmallett 1060215976Sjmallett$__kmp_success: 1061232812Sjmallett ret 1062215976Sjmallett 1063215976Sjmallett__kmp_compare_and_store_loop8 ENDP 1064215976Sjmallett_TEXT ENDS 1065215976Sjmallett 1066215976Sjmallett 1067215976Sjmallett;------------------------------------------------------------------------ 1068215976Sjmallett; FUNCTION __kmp_xchg_real32 1069215976Sjmallett; 1070215976Sjmallett; kmp_real32 1071215976Sjmallett; __kmp_xchg_real32( volatile kmp_real32 *p, kmp_real32 d ); 1072232812Sjmallett; 1073215976Sjmallett; parameters: 1074215976Sjmallett; p: rcx 1075215976Sjmallett; d: xmm1 (lower 4 bytes) 1076215976Sjmallett; 1077215976Sjmallett; return: xmm0 (lower 4 bytes) 1078215976SjmallettPUBLIC __kmp_xchg_real32 1079215976Sjmallett_TEXT SEGMENT 1080215976Sjmallett ALIGN 16 1081215976Sjmallett__kmp_xchg_real32 PROC ;NEAR 1082215976Sjmallett 1083232812Sjmallett movd eax, xmm1 ; load d 1084215976Sjmallett 1085215976Sjmallettlock xchg DWORD PTR [rcx], eax 1086215976Sjmallett 1087215976Sjmallett movd xmm0, eax ; load old value into return register 1088215976Sjmallett ret 1089215976Sjmallett 1090215976Sjmallett__kmp_xchg_real32 ENDP 1091215976Sjmallett_TEXT ENDS 1092215976Sjmallett 1093215976Sjmallett 1094232812Sjmallett;------------------------------------------------------------------------ 1095215976Sjmallett; FUNCTION __kmp_xchg_real64 1096215976Sjmallett; 1097215976Sjmallett; kmp_real64 1098215976Sjmallett; __kmp_xchg_real64( volatile kmp_real64 *p, kmp_real64 d ); 1099215976Sjmallett; 1100215976Sjmallett; parameters: 1101215976Sjmallett; p: rcx 1102215976Sjmallett; d: xmm1 (lower 8 bytes) 1103215976Sjmallett; 1104215976Sjmallett; return: xmm0 (lower 8 bytes) 1105232812SjmallettPUBLIC __kmp_xchg_real64 1106215976Sjmallett_TEXT SEGMENT 1107215976Sjmallett ALIGN 16 1108215976Sjmallett__kmp_xchg_real64 PROC ;NEAR 1109215976Sjmallett 1110215976Sjmallett movd rax, xmm1 ; load "d" 1111215976Sjmallett 1112215976Sjmallettlock xchg QWORD PTR [rcx], rax 1113215976Sjmallett 1114215976Sjmallett movd xmm0, rax ; load old value into return register 1115215976Sjmallett ret 1116232812Sjmallett 1117215976Sjmallett__kmp_xchg_real64 ENDP 1118215976Sjmallett_TEXT ENDS 1119215976Sjmallett 1120215976Sjmallett;------------------------------------------------------------------------ 1121215976Sjmallett; FUNCTION __kmp_load_x87_fpu_control_word 1122215976Sjmallett; 1123215976Sjmallett; void 1124215976Sjmallett; __kmp_load_x87_fpu_control_word( kmp_int16 *p ); 1125215976Sjmallett; 1126215976Sjmallett; parameters: 1127232812Sjmallett; p: rcx 1128215976SjmallettPUBLIC __kmp_load_x87_fpu_control_word 1129215976Sjmallett_TEXT SEGMENT 1130215976Sjmallett ALIGN 16 1131215976Sjmallett__kmp_load_x87_fpu_control_word PROC ;NEAR 1132215976Sjmallett 1133215976Sjmallett fldcw WORD PTR [rcx] 1134215976Sjmallett ret 1135215976Sjmallett 1136215976Sjmallett__kmp_load_x87_fpu_control_word ENDP 1137215976Sjmallett_TEXT ENDS 1138232812Sjmallett 1139232812Sjmallett 1140232812Sjmallett;------------------------------------------------------------------------ 1141232812Sjmallett; FUNCTION __kmp_store_x87_fpu_control_word 1142215976Sjmallett; 1143215976Sjmallett; void 1144215976Sjmallett; __kmp_store_x87_fpu_control_word( kmp_int16 *p ); 1145215976Sjmallett; 1146215976Sjmallett; parameters: 1147215976Sjmallett; p: rcx 1148215976SjmallettPUBLIC __kmp_store_x87_fpu_control_word 1149215976Sjmallett_TEXT SEGMENT 1150215976Sjmallett ALIGN 16 1151215976Sjmallett__kmp_store_x87_fpu_control_word PROC ;NEAR 1152215976Sjmallett 1153215976Sjmallett fstcw WORD PTR [rcx] 1154215976Sjmallett ret 1155215976Sjmallett 1156215976Sjmallett__kmp_store_x87_fpu_control_word ENDP 1157215976Sjmallett_TEXT ENDS 1158215976Sjmallett 1159215976Sjmallett 1160232812Sjmallett;------------------------------------------------------------------------ 1161215976Sjmallett; FUNCTION __kmp_clear_x87_fpu_status_word 1162232812Sjmallett; 1163232812Sjmallett; void 1164215976Sjmallett; __kmp_clear_x87_fpu_status_word() 1165215976SjmallettPUBLIC __kmp_clear_x87_fpu_status_word 1166215976Sjmallett_TEXT SEGMENT 1167215976Sjmallett ALIGN 16 1168215976Sjmallett__kmp_clear_x87_fpu_status_word PROC ;NEAR 1169215976Sjmallett 1170215976Sjmallett fnclex 1171215976Sjmallett ret 1172215976Sjmallett 1173215976Sjmallett__kmp_clear_x87_fpu_status_word ENDP 1174215976Sjmallett_TEXT ENDS 1175215976Sjmallett 1176215976Sjmallett 1177215976Sjmallett;------------------------------------------------------------------------ 1178215976Sjmallett; FUNCTION __kmp_invoke_microtask 1179215976Sjmallett; 1180215976Sjmallett; typedef void (*microtask_t)( int *gtid, int *tid, ... ); 1181215976Sjmallett; 1182215976Sjmallett; int 1183215976Sjmallett; __kmp_invoke_microtask( microtask_t pkfn, 1184215976Sjmallett; int gtid, int tid, 1185215976Sjmallett; int argc, void *p_argv[] ) { 1186215976Sjmallett; 1187215976Sjmallett; (*pkfn) ( >id, &tid, argv[0], ... ); 1188215976Sjmallett; return 1; 1189215976Sjmallett; } 1190215976Sjmallett; 1191215976Sjmallett; note: 1192215976Sjmallett; just before call to pkfn must have rsp 128-byte aligned for compiler 1193215976Sjmallett; 1194215976Sjmallett; parameters: 1195215976Sjmallett; rcx: pkfn 16[rbp] 1196215976Sjmallett; edx: gtid 24[rbp] 1197232812Sjmallett; r8d: tid 32[rbp] 1198232812Sjmallett; r9d: argc 40[rbp] 1199215976Sjmallett; [st]: p_argv 48[rbp] 1200215976Sjmallett; 1201215976Sjmallett; reg temps: 1202215976Sjmallett; rax: used all over the place 1203215976Sjmallett; rdx: used all over the place 1204215976Sjmallett; rcx: used as argument counter for push parms loop 1205215976Sjmallett; r10: used to hold pkfn function pointer argument 1206215976Sjmallett; 1207215976Sjmallett; return: eax (always 1/TRUE) 1208215976Sjmallett$_pkfn = 16 1209215976Sjmallett$_gtid = 24 1210215976Sjmallett$_tid = 32 1211215976Sjmallett$_argc = 40 1212215976Sjmallett$_p_argv = 48 1213215976Sjmallettif OMPT_SUPPORT 1214215976Sjmallett$_exit_frame = 56 1215215976Sjmallettendif 1216215976Sjmallett 1217215976SjmallettPUBLIC __kmp_invoke_microtask 1218215976Sjmallett_TEXT SEGMENT 1219215976Sjmallett ALIGN 16 1220215976Sjmallett 1221215976Sjmallett__kmp_invoke_microtask PROC FRAME ;NEAR 1222215976Sjmallett mov QWORD PTR 16[rsp], rdx ; home gtid parameter 1223215976Sjmallett mov QWORD PTR 24[rsp], r8 ; home tid parameter 1224215976Sjmallett push rbp ; save base pointer 1225215976Sjmallett .pushreg rbp 1226215976Sjmallett sub rsp, 0 ; no fixed allocation necessary - end prolog 1227215976Sjmallett 1228215976Sjmallett lea rbp, QWORD PTR [rsp] ; establish the base pointer 1229215976Sjmallett .setframe rbp, 0 1230215976Sjmallett .ENDPROLOG 1231215976Sjmallettif OMPT_SUPPORT 1232232812Sjmallett mov rax, QWORD PTR $_exit_frame[rbp] 1233232812Sjmallett mov QWORD PTR [rax], rbp 1234215976Sjmallettendif 1235215976Sjmallett mov r10, rcx ; save pkfn pointer for later 1236215976Sjmallett 1237215976Sjmallett;; ------------------------------------------------------------ 1238215976Sjmallett mov rax, r9 ; rax <= argc 1239215976Sjmallett cmp rax, 2 1240215976Sjmallett jge SHORT $_kmp_invoke_stack_align 1241215976Sjmallett mov rax, 2 ; set 4 homes if less than 2 parms 1242215976Sjmallett$_kmp_invoke_stack_align: 1243215976Sjmallett lea rdx, QWORD PTR [rax*8+16] ; rax <= (argc + 2) * 8 1244215976Sjmallett mov rax, rsp ; Save current SP into rax 1245215976Sjmallett sub rax, rdx ; rsp - ((argc+2)*8) -> rax 1246215976Sjmallett ; without align, rsp would be this 1247215976Sjmallett and rax, -128 ; Mask off 7 bits (128-byte align) 1248215976Sjmallett add rax, rdx ; add space for push's in a loop below 1249215976Sjmallett mov rsp, rax ; Prepare the stack ptr 1250215976Sjmallett ; Now it will align to 128-byte at the call 1251215976Sjmallett;; ------------------------------------------------------------ 1252215976Sjmallett ; setup pkfn parameter stack 1253215976Sjmallett mov rax, r9 ; rax <= argc 1254215976Sjmallett shl rax, 3 ; rax <= argc*8 1255215976Sjmallett mov rdx, QWORD PTR $_p_argv[rbp] ; rdx <= p_argv 1256215976Sjmallett add rdx, rax ; rdx <= &p_argv[argc] 1257215976Sjmallett mov rcx, r9 ; rcx <= argc 1258215976Sjmallett jecxz SHORT $_kmp_invoke_pass_parms ; nothing to push if argc=0 1259215976Sjmallett cmp ecx, 1 ; if argc=1 branch ahead 1260215976Sjmallett je SHORT $_kmp_invoke_one_parm 1261232812Sjmallett sub ecx, 2 ; if argc=2 branch ahead, subtract two from 1262215976Sjmallett je SHORT $_kmp_invoke_two_parms 1263215976Sjmallett 1264232812Sjmallett$_kmp_invoke_push_parms: ; push last - 5th parms to pkfn on stack 1265232812Sjmallett sub rdx, 8 ; decrement p_argv pointer to previous parm 1266232812Sjmallett mov r8, QWORD PTR [rdx] ; r8 <= p_argv[rcx-1] 1267215976Sjmallett push r8 ; push p_argv[rcx-1] onto stack (reverse order) 1268215976Sjmallett sub ecx, 1 1269215976Sjmallett jecxz SHORT $_kmp_invoke_two_parms 1270215976Sjmallett jmp SHORT $_kmp_invoke_push_parms 1271215976Sjmallett 1272215976Sjmallett$_kmp_invoke_two_parms: 1273215976Sjmallett sub rdx, 8 ; put 4th parm to pkfn in r9 1274215976Sjmallett mov r9, QWORD PTR [rdx] ; r9 <= p_argv[1] 1275215976Sjmallett 1276215976Sjmallett$_kmp_invoke_one_parm: 1277215976Sjmallett sub rdx, 8 ; put 3rd parm to pkfn in r8 1278215976Sjmallett mov r8, QWORD PTR [rdx] ; r8 <= p_argv[0] 1279215976Sjmallett 1280232812Sjmallett$_kmp_invoke_pass_parms: ; put 1st & 2nd parms to pkfn in registers 1281215976Sjmallett lea rdx, QWORD PTR $_tid[rbp] ; rdx <= &tid (2nd parm to pkfn) 1282232812Sjmallett lea rcx, QWORD PTR $_gtid[rbp] ; rcx <= >id (1st parm to pkfn) 1283232812Sjmallett sub rsp, 32 ; add stack space for first four parms 1284215976Sjmallett mov rax, r10 ; rax <= pkfn 1285215976Sjmallett call rax ; call (*pkfn)() 1286215976Sjmallett mov rax, 1 ; move 1 into return register; 1287215976Sjmallett 1288215976Sjmallett lea rsp, QWORD PTR [rbp] ; restore stack pointer 1289215976Sjmallett 1290215976Sjmallett; add rsp, 0 ; no fixed allocation necessary - start epilog 1291215976Sjmallett pop rbp ; restore frame pointer 1292215976Sjmallett ret 1293215976Sjmallett__kmp_invoke_microtask ENDP 1294215976Sjmallett_TEXT ENDS 1295215976Sjmallett 1296215976Sjmallettendif 1297215976Sjmallett 1298215976SjmallettEND 1299215976Sjmallett