hexsha stringlengths 40 40 | size int64 6 1.05M | ext stringclasses 3 values | lang stringclasses 1 value | max_stars_repo_path stringlengths 4 232 | max_stars_repo_name stringlengths 7 106 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 7 | max_stars_count int64 1 33.5k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 232 | max_issues_repo_name stringlengths 7 106 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 7 | max_issues_count int64 1 37.5k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 232 | max_forks_repo_name stringlengths 7 106 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 7 | max_forks_count int64 1 12.6k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 6 1.05M | avg_line_length float64 1.16 19.7k | max_line_length int64 2 938k | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
fae78a565ab5daac5796acd923820058b24a47d4 | 4,983 | asm | Assembly | dino/lcs/enemy/44.asm | zengfr/arcade_game_romhacking_sourcecode_top_secret_data | a4a0c86c200241494b3f1834cd0aef8dc02f7683 | [
"Apache-2.0"
] | 6 | 2020-10-14T15:29:10.000Z | 2022-02-12T18:58:54.000Z | dino/lcs/enemy/44.asm | zengfr/arcade_game_romhacking_sourcecode_top_secret_data | a4a0c86c200241494b3f1834cd0aef8dc02f7683 | [
"Apache-2.0"
] | null | null | null | dino/lcs/enemy/44.asm | zengfr/arcade_game_romhacking_sourcecode_top_secret_data | a4a0c86c200241494b3f1834cd0aef8dc02f7683 | [
"Apache-2.0"
] | 1 | 2020-12-17T08:59:10.000Z | 2020-12-17T08:59:10.000Z | copyright zengfr site:http://github.com/zengfr/romhack
00042A move.l D1, (A0)+
00042C dbra D0, $42a
004D3A move.l D0, (A4)+
004D3C move.l D0, (A4)+
01291A movea.l ($44,A2), A4
01291E adda.w D0, A4 [123p+ 44, 123p+ 46, enemy+44, enemy+46, item+44, item+46]
012928 movea.l ($44,A3), A6
01292C adda.w D1, A6 [123p+ 44, 123p+ 46, enemy+44, enemy+46, item+44, item+46]
0129B8 movea.l ($44,A3), A6
0129BC move.w (A6,D1.w), D1 [enemy+44, enemy+46]
012A5C movea.l ($44,A2), A4
012A60 add.w D0, D0 [enemy+44, enemy+46]
012A6E movea.l ($44,A3), A6
012A72 adda.w D1, A6 [123p+ 44, 123p+ 46, enemy+44, enemy+46]
0338A6 move.l #$103000, ($44,A6)
0338AE clr.b ($4a,A6) [enemy+44, enemy+46]
0338DA move.l #$103000, ($44,A6)
0338E2 clr.b ($4a,A6) [enemy+44, enemy+46]
03390E move.l #$103000, ($44,A6)
033916 clr.b ($4a,A6) [enemy+44, enemy+46]
0359C0 move.l #$103c00, ($44,A6)
0359C8 clr.b ($4a,A6) [enemy+44, enemy+46]
03B2F0 move.l #$103c00, ($44,A6)
03B2F8 clr.b ($4a,A6) [enemy+44, enemy+46]
03B86A move.l #$103000, ($44,A6)
03B872 clr.b ($4a,A6) [enemy+44, enemy+46]
03DE6C move.l #$103c00, ($44,A6)
03DE74 clr.b ($4a,A6) [enemy+44, enemy+46]
040332 move.l #$103c00, ($44,A6)
04033A clr.b ($4a,A6) [enemy+44, enemy+46]
04212C move.l #$103000, ($44,A6) [enemy+40, enemy+42]
042134 clr.b ($4a,A6) [enemy+44, enemy+46]
042626 move.l #$103000, ($44,A6)
04262E clr.b ($4a,A6) [enemy+44, enemy+46]
045824 move.l #$103000, ($44,A6)
04582C clr.b ($4a,A6) [enemy+44, enemy+46]
0483C0 move.l #$106000, ($44,A6)
0483C8 move.b #$1, ($4a,A6) [enemy+44, enemy+46]
04D920 move.l #$103000, ($44,A6)
04D928 clr.b ($4a,A6) [enemy+44, enemy+46]
04DD3A move.l #$106000, ($44,A6)
04DD42 move.b #$1, ($4a,A6) [enemy+44, enemy+46]
04FD7A move.l #$103000, ($44,A6)
04FD82 clr.b ($4a,A6) [enemy+44, enemy+46]
0512CA move.l #$103c00, ($44,A6)
0512D2 clr.b ($4a,A6) [enemy+44, enemy+46]
053450 move.l #$103c00, ($44,A6)
053458 clr.b ($4a,A6) [enemy+44, enemy+46]
0558AA move.l #$103c00, ($44,A6) [enemy+63]
0558B2 clr.b ($4a,A6) [enemy+44, enemy+46]
055B40 move.l #$103000, ($44,A6)
055B48 clr.b ($4a,A6) [enemy+44, enemy+46]
0572AC move.l #$103c00, ($44,A6)
0572B4 clr.b ($4a,A6) [enemy+44, enemy+46]
0578B8 move.l #$103c00, ($44,A6)
0578C0 clr.b ($4a,A6) [enemy+44, enemy+46]
057FC8 move.l #$103c00, ($44,A6)
057FD0 clr.b ($4a,A6) [enemy+44, enemy+46]
0580DA move.l #$103c00, ($44,A6)
0580E2 clr.b ($4a,A6) [enemy+44, enemy+46]
0584D4 move.l #$103c00, ($44,A6)
0584DC clr.b ($4a,A6) [enemy+44, enemy+46]
05A4C2 move.l #$103c00, ($44,A6)
05A4CA clr.b ($4a,A6) [enemy+44, enemy+46]
05AAD2 move.l #$103c00, ($44,A6)
05AADA clr.b ($4a,A6) [enemy+44, enemy+46]
05B0AC move.l #$103000, ($44,A6) [enemy+6E]
05B0B4 clr.b ($4a,A6) [enemy+44, enemy+46]
05B930 move.l #$c0100000, ($44,A6) [enemy+ 6]
05B938 clr.b ($4a,A6) [enemy+44, enemy+46]
05C3D8 move.l #$103000, ($44,A6) [enemy+ 6]
05C3E0 clr.b ($4a,A6) [enemy+44, enemy+46]
05EE4C move.l #$103000, ($44,A6) [enemy+ 4]
05EE54 clr.b ($4a,A6) [enemy+44, enemy+46]
05F61A move.l #$103000, ($44,A6)
05F622 clr.b ($4a,A6) [enemy+44, enemy+46]
06A21E move.l #$103c00, ($44,A6)
06A226 clr.b ($4a,A6) [enemy+44, enemy+46]
0AAACA move.l (A0), D2
0AAACC move.w D0, (A0) [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAACE move.w D0, ($2,A0)
0AAAD2 cmp.l (A0), D0
0AAAD4 bne $aaafc
0AAAD8 move.l D2, (A0)+
0AAADA cmpa.l A0, A1 [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAAE6 move.l (A0), D2
0AAAE8 move.w D0, (A0) [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAAF4 move.l D2, (A0)+
0AAAF6 cmpa.l A0, A1 [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
copyright zengfr site:http://github.com/zengfr/romhack
| 53.010638 | 350 | 0.627534 |
5f24b7420b984748b6f396c11b77da60af493cd6 | 30,038 | asm | Assembly | src/kernel/pkernel.asm | tishion/PiscisOS | 0ff2bb30265749e9ea42a11e04e44e301e848506 | [
"MIT"
] | 86 | 2015-01-16T05:53:36.000Z | 2022-03-01T19:26:49.000Z | src/kernel/pkernel.asm | tishion/PiscisOS | 0ff2bb30265749e9ea42a11e04e44e301e848506 | [
"MIT"
] | null | null | null | src/kernel/pkernel.asm | tishion/PiscisOS | 0ff2bb30265749e9ea42a11e04e44e301e848506 | [
"MIT"
] | 23 | 2015-07-24T13:46:59.000Z | 2022-02-28T07:43:51.000Z | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Kernel of the PiscisOS
;; The only one main source file to be assembled
;;
;; 23/01/2012
;; Copyright (C) tishion
;; E-Mail:tishion@163.com
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include ".\include\sys32.h"
include ".\include\process.h"
include ".\include\ascii.h"
include ".\include\drivers\console.h"
include ".\include\drivers\i8259A.h"
include ".\include\drivers\keyboard.h"
include ".\include\drivers\ramdiskfs.h"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Kernel base an offset
KERNEL_BASE equ 1000h
KERNEL_OFFSET equ 0000h
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Address of some CONST
MEMORY_SIZE equ 0f000h ;address of memory size of system[4Byte]
sys_tic equ 0f010h
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
LOW_MEMORY_SAVE_BASE equ 0290000h
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Diskette bases
DISKIMG_BASE equ 100000h
RAW_FAT_BASE equ 100200h
NEW_FAT_BASE equ 280000h
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Cursor
row_start equ 08000h ;address of number of current screen row
x_cursor equ 08002h ;address of number of current column
y_cursor equ 08004h ;address of number of current row
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; 16 BIT CODE ENTRY AFTER BOOTSECTOR
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
use16
org 00h
kernel_start:
jmp start_of_code16
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; 16 BIT DATAS
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
macro title_ver_row
{
times 33 db 32
db 'Piscis OS v1.0'
times 33 db 32
}
macro title_sep_row
{
times 80 db 205
}
initscreen:
title_ver_row
title_sep_row
str_debug db 0dh, 0ah, 'Piscis_Debug_String', 0
str_not386 db 0dh, 0ah, 'CPU is unsupported. 386+ is requried.', 0
str_loaddisk db 0dh, 0ah, 'Loading floppy cache: 00 %', 8, 8, 8, 8, 0
str_memmovefailed db 0dh, 0ah, 'Fatal - Floppy image move failed.', 0
str_badsect db 0dh, 0ah, 'Fatal - Floppy damaged.', 0
str_memsizeunknow db 0dh, 0ah, 'Fatal - Memory size unknown.', 0
str_notenoughmem db 0dh, 0ah, 'Fatal - Memory not enough. At least 16M', 0
str_pros db '00', 8, 8, 0
str_okt db ' ... OK', 0
char_backspace db 8, 0
char_newline db 0dh, 0ah, 0
mem_range_count dw 0
mem_range_buffer db 20 dup 0
mem_size dd 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; 16 BIT PROCS
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintStr:
push ax
push bx
cld
.next_char:
lodsb
cmp al, 0
je .exit_p
mov ah, 0eh
xor bh, bh
int 10h
jmp .next_char
.exit_p:
pop bx
pop ax
ret
PrintByte: ;use al
push bx
mov ah, 0eh
push ax
xor bh, bh
shr al, 4
add al, 30h
cmp al, 3ah
jb .notalpha_h
add al, 7
.notalpha_h:
int 10h
pop ax
xor bh, bh
and al, 0fh
add al, 30h
cmp al, 3ah
jb .notalpha_l
add al, 7
.notalpha_l:
int 10h
pop bx
ret
PrintWord: ;use ax
push ax
shr ax, 8
call PrintByte
pop ax
and ax, 00ffh
call PrintByte
ret
PrintDWord: ;use eax
push eax
shr eax, 16
call PrintWord
pop eax
and eax, 0000ffffh
call PrintWord
ret
DrawInitScreen:
pusha
mov ax, 0b800h
mov es, ax
mov di, 0
mov si, initscreen
mov cx, 80*2
mov ah, 00000111b
.loop_0:
cld
lodsb
stosw
loop .loop_0
mov cx, 80*23
mov ah, 00000111b
mov al, 32
.loop_1:
stosw
loop .loop_1
mov ah, 02h
mov bh, 0
mov dh, 2
mov dl, 0
int 10h
popa
ret
;;entry point of the 16 bit code.
start_of_code16:
;;Code of 16 bit
mov ax, KERNEL_BASE
mov es, ax
mov ds, ax
mov ax, KERNEL_STACK_BASE
mov ss, ax
mov sp, STACK_SIZE_16BIT
xor ax, ax
xor bx, bx
xor cx, cx
xor dx, dx
xor si, si
xor di, di
xor bp, bp
call DrawInitScreen
;;Test cup 386+ ?
testcpu:
pushf
pop ax
mov dx, ax
xor ax, 4000h
push ax
popf
pushf
pop ax
and ax, 4000h
and dx, 4000h
cmp ax,dx
jnz testcpu_ok
mov si, str_not386
call PrintStr
jmp $
testcpu_ok:
resetregs:
;;Reset the 32 bit registers and stack
mov ax, KERNEL_BASE
mov es, ax
mov ds, ax
mov ax, KERNEL_STACK_BASE ; init stack segment base regester
mov ss, ax
mov sp, STACK_SIZE_16BIT ; int stack pointer regester-indicate the size of stack
xor eax, eax
xor ebx, ebx
xor ecx, ecx
xor edx, edx
xor esi, esi
xor edi, edi
xor ebp, ebp
resetregs_ok:
memsize:
mov ebx, 0
mov di, mem_range_buffer
.next_range:
clc
mov eax, 0e820h
mov ecx, 20
mov edx, 0534d4150h
int 15h
jc .fail
inc word [mem_range_count] ; One AddressRangeMemory has been read done
mov eax, dword [di+16]
cmp eax, 1 ; Type is 1 ?
jne .is_last ; Not 1, but 2 or others, goto test is this one the last AddressRangeMemory ?
mov eax, dword [di] ; Type is 1, BaseAddressLow
mov esi, dword [di+8] ; LengthLow
add eax, esi ; Add the LengthLow to the BaseAddressLow
mov [mem_size], eax ; Save the memory size;
;;;;;;;;;;;;;;;;;;;;;;;;DEBUG_CODE;;;;;;;;;;;;;;;;;;;;;;;;
; mov si, char_newline
; call PrintStr
; mov eax, [mem_size]
; call PrintDWord
;;;;;;;;;;;;;;;;;;;;;;;;DEBUG_CODE;;;;;;;;;;;;;;;;;;;;;;;;
.is_last:
test ebx, ebx ; Is the last AddressRangeMemory ?
jz .memsize_ok ; Yes, get memory size done
jne .next_range ; No, get next AddressRangeMemory
.fail:
mov si, str_memsizeunknow
call PrintStr
jmp $
.memsize_ok:
mov eax, [mem_size]
cmp eax, 01000000h ;At least 16M
jae memsize_end
mov si, str_notenoughmem
call PrintStr
jmp $
memsize_end:
storememsize:
push es
xor ax, ax
mov es, ax
mov dword [es:MEMORY_SIZE], eax
pop es
storememsize_end:
;;Load diskette to memory. Each time read and move 18 sectors(One track or One cylinder).
loadfloppyimage:
mov si, str_loaddisk
call PrintStr
mov ax, 0000h ; Reset drive
mov dx, 0000h
int 13h
mov cx, 0001h ; Number of start cyl and sector
mov dx, 0000h ; Number of start head and drive
push word 80*2 ; Count of tracks
.readmove_loop:
pusha
xor si, si ; Error count
.read18sectors:
push word 0
pop es
mov bx, 0a000h ; es:bx -> data area
mov al, 18; ; Number of sectors to read
mov ah, 02h ; Read
int 13h
cmp ah, 0
jz .read18sectorsOK
add si, 1
cmp si, 10
jnz .read18sectors
mov si, str_badsect
call PrintStr
jmp $
.read18sectorsOK:
; move -> 1mb
mov si, .movedesc
push word 1000h
pop es
mov cx, 256*18
mov ah, 0x87
int 15h
cmp ah, 00h ; Move ok ?
je .moveok
mov dx, 03f2fh ; Floppy motor off
mov al, 00h
out dx, al
mov si, str_memmovefailed
call PrintStr
jmp $
.moveok:
mov eax, [.movedesc+18h+2]
add eax, 512*18
mov [.movedesc+18h+2], eax
popa
inc dh ; Head+1
cmp dh, 2 ; Current head is number 1 ?
jnz .headinc ; No, read the other track on current Cylinder
mov dh, 0 ; Yes, read next two track on next Cylinder(Cylinder+1)
inc ch ; Cylinder+1;
pusha ; Display prosentage
push word KERNEL_BASE
pop es
xor eax, eax ; 5
mov al, ch
shr eax, 2
and eax, 1
mov ebx, 5
mul bx
add al, 30h
mov [str_pros+1], al
xor eax, eax ; 10
mov al, ch
shr eax, 3
add al, 30h
mov [str_pros], al
mov si, str_pros
call PrintStr
popa
.headinc:
pop ax
dec ax
push ax
cmp ax, 0 ; All read and move done?
jnz .readmove_loop ; No, read and move next 18 sectors
mov dx, 03f2h ; Floppy motor off
mov al, 0
out dx, al
jmp .readmovedone ; Yes, all sectors read and move done
.movedesc:
db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0 ; reserved
db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0 ; reserved
db 0xff,0xff ; segment length
db 0x0,0xa0,0x00 ; source address
db 0x93 ; access privalige
db 0x0,0x0 ; reserved
db 0xff,0xff ; segment length
db 0x00,0x00,0x10 ; dest address
db 0x93 ; access privalige
db 0x0,0x0 ; reserved
db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0 ; reserved
db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0 ; reserved
db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0 ; reserved
db 0x00,0x00,0x0,0x00,0x00,0x00,0x0,0x0 ; reserved
.readmovedone:
pop ax
mov si, char_backspace
call PrintStr
mov si, str_okt
call PrintStr
loadfloppyimage_end:
;;;;;;;;;;;;;;;;;;;;;;;;DEBUG_CODE;;;;;;;;;;;;;;;;;;;;;;;;
; mov si, str_debug
; call PrintStr
;;;;;;;;;;;;;;;;;;;;;;;;DEBUG_CODE;;;;;;;;;;;;;;;;;;;;;;;;
; mov si, char_newline
; call PrintStr
; mov ax, [cs:gdts-KERNEL_BASE*16]
; call PrintWord
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; SWITCH TO PROTECTMODEL OF 32 BIT
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
sel_os_code equ os_code_l - gdts + 0
sel_os_data equ os_data_l - gdts + 0
sel_os_stack equ os_stack_l - gdts + 0
sel_video_data equ video_data_l - gdts + 3
sel_int_stack equ int_stack_l - gdts +0
sel_sysc_stack equ sysc_stack_l - gdts + 0
sel_ring1_code equ ring1_code_l - gdts + 1
sel_ring1_data equ ring1_data_l - gdts + 1
sel_ring1_stack equ ring1_stack_l - gdts + 1
sel_ring2_code equ ring2_code_l - gdts + 2
sel_ring2_data equ ring2_data_l - gdts + 2
sel_ring2_stack equ ring2_stack_l - gdts + 2
sel_tss_int0 equ tss_interrupt0_l - gdts + 0
sel_tss_process0 equ tss_process0_l - gdts + 0
sel_tg_process0 equ tg_process0_l - gdts + 0
sel_tss_sysc0 equ tss_syscall0_l - gdts + 0
sel_user_code equ user_code_l - gdts + 3
sel_user_data equ user_data_l - gdts + 3
;; Set CR0 register - Protect mode.
cli
lgdt [cs:gdts-KERNEL_BASE*16] ; Load GDT
in al, 92h ; Enable A20
or al, 02h
out 92h, al
mov eax, cr0
or eax, 01h
mov cr0, eax
jmp pword sel_os_code:pm32_entry
use32
kernel_32bit:
org (KERNEL_BASE*16 + (kernel_32bit - kernel_start))
macro align value
{
rb (value-1) - ($ + value-1) mod value
}
boot_debug db 'debug string.', 0dh, 0ah, 'debugstring...debugstring...debugstring...debugstring...debugstring...debugstring...debugstring...debugstring...debugstring...debugstring...debugstring...debugstring...', 0
boot_str_rcpuid db 'Reading CPUIDs...', 0
boot_str_rpirqs db 'Setting all IRQs...', 0
boot_str_setitss db 'Setting interrupt TSS...', 0
boot_str_setitssdesc db 'Setting GDT with interrupt TSS descriptors...', 0
boot_str_setitaskgate db 'Setting IDT with interrupt task gate...', 0
boot_str_setrdfs db 'Setting ramdisk file system...', 0
boot_str_setsysctss db 'Setting syscall TSS...', 0
boot_str_setsysctssdesc db 'Setting GDT with syscall TSS descriptors...', 0
boot_str_setsysctaskgate db 'Setting IDT with syscall task gate...', 0
boot_str_setptss db 'Setting process TSS...', 0
boot_str_setpcb db 'Setting process control block...', 0
boot_str_setptssdesc db 'Setting GDT with process TSS descriptors...', 0
boot_str_setptaskgate db 'Setting GDT with process task gate...', 0
boot_str_setprocessseg db 'Setting GDT with process segment descriptor...', 0
boot_str_settimer db 'Setting timer(8259)...', 0
boot_str_setostask db 'Setting system process...', 0
boot_str_enirqs db 'Enabling all IRQs...', 0
boot_str_initshell db 'Initializing PShell...', 0
boot_str_presenter db 'All settings have done! Press ENTER key to start!', 0
shell_path db '\shell', 0
promot_row db 0
promot_ok db '[ OK ]', 0
promot_failed db '[FAILED]', 0
cpuid_0 dd 0, 0, 0, 0
cpuid_1 dd 0, 0, 0, 0
cpuid_2 dd 0, 0, 0, 0
cpuid_3 dd 0, 0, 0, 0
byte2HexStr:
;; Convert byte data to hex string
;; al:[in] byte to convert
;; ds-edi:[in] dest buffer to save hex chars
push edi
push eax
push eax
shr al, 4
add al, 30h
cmp al, 3ah
jb .notalpha_h
add al, 7
.notalpha_h:
mov [edi], al
pop eax
and al, 0fh
add al, 30h
cmp al, 3ah
jb .notalpha_l
add al, 7
.notalpha_l:
mov [edi+1], al
pop eax
pop edi
ret
word2Hstr:
push edi
push eax
push eax
shr ax, 8
call byte2HexStr
pop eax
add edi, 2
call byte2HexStr
pop eax
pop edi
ret
dword2HexStr:
push edi
push eax
push eax
shr eax, 16
call word2Hstr
pop eax
add edi, 4
call word2Hstr
pop eax
pop edi
ret
boot_promot:
pusha
xor eax, eax
mov al, [promot_row]
mov ecx, 160
mul ecx ; x*80*2
mov edi, eax
cld
mov ah, 0fh ; Black background, White forground, and Hilght
.next_char:
lodsb
cmp al, 0
je .exit_p
mov [gs:edi], ax
add edi, 2
jmp .next_char
.exit_p:
popa
ret
boot_promot_status:
pusha
jc .failed
.ok:
mov esi, promot_ok
push 0a00h ; Black background, Green forground, and Hilght
jmp .show_string
.failed:
mov esi, promot_failed
push 0c00h ; Black background, Red forground, and Hilght
.show_string:
xor eax, eax
mov al, [promot_row]
mov ecx, 160
mul ecx ; x*80*2
add eax, 50*2
mov edi, eax
cld
pop eax
.next_char:
lodsb
cmp al, 0
je .exit_p
mov [gs:edi], ax
add edi, 2
jmp .next_char
.exit_p:
mov al, [promot_row]
inc al
mov [promot_row], al
popa
ret
read_cpuid:
stc
pushfd ; get current flags
pop eax
mov ecx, eax
xor eax, 00200000h ; attempt to toggle ID bit
push eax
popfd
pushfd ; get new EFLAGS
pop eax
push ecx ; restore original flags
popfd
and eax, 00200000h ; if we couldn't toggle ID,
and ecx, 00200000h ; then this is i486
cmp eax, ecx
jz .exit_p ; It's not Pentium or later. ret
mov edi, cpuid_0 ; It's Pentium use CPUID instruction read again
mov esi, 0
.cpuid_new_read:
mov eax, esi
cpuid
mov [edi+00h], eax
mov [edi+04h], ebx
mov [edi+08h], ecx
mov [edi+0ch], edx
add edi, 4*4
cmp esi, 3
jge .exit_p
cmp esi, [cpuid_0]
jge .exit_p
inc esi
jmp .cpuid_new_read
.exit_p:
clc
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; 32 BIT CODE
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
pm32_entry:
;; Set ds, es, fs, ss, esp gs
mov ax, sel_os_data ;;0
mov ds, ax
mov es, ax
mov fs, ax
mov ax, sel_os_stack
mov ss, ax
mov esp, STACK_SIZE_32BIT
mov ax, sel_video_data
mov gs, ax
;;Clear screen
push es
mov ax, gs
mov es, ax
xor edi, edi
mov ecx, 80*25*8
mov ax, 0720h
cld
rep stosw
pop es
;;Set paging tables
;;Set Pageing Directory Entrys
SetPDEs:
xor edx, edx
mov eax, dword [ds:MEMORY_SIZE]
mov ebx, 400000h
div ebx
mov ecx, eax
test edx, edx
jz .no_remainder
inc ecx
.no_remainder:
push ecx
mov ax, sel_os_data
mov es, ax
mov edi, PDE_OFFSET
mov eax, PTE_OFFSET+7
cld
.loop_0:
stosd
add eax, 4096 ; One PDE has 1024 PTEs(4Byte)
loop .loop_0
SetPDEs_ok:
;;Set paging table entry 4 kb paging
SetPTEs:
mov ax, sel_os_data
mov es, ax
pop eax
mov ebx, 1024
mul ebx
mov ecx, eax ;Count of PTEs =1024*count of PDEs
mov edi, PTE_OFFSET
mov eax, 0+7 ; For 0 M
cld
.loop_0:
stosd
add eax, 4096
loop .loop_0
SetPTEs_ok:
EnablePaging:
mov eax, PDE_OFFSET+8+16 ; Page directory and enable caches
mov cr3, eax
mov eax, cr0
or eax, 80000000h
mov cr0, eax
jmp short EnablePaging_ok
EnablePaging_ok:
;;Save & clear 0h-0efffh
mov esi, 0x0000
mov edi, LOW_MEMORY_SAVE_BASE
mov ecx, 0f000h / 4
cld
rep movsd
xor eax, eax
mov edi, 0
mov ecx, 0f000h / 4
cld
rep stosd
;;debugcode
; mov di, 0
; mov cx, 20
; mov al, 'a'
; debug_loop:
; mov ah, 07h
; mov [gs:di], ax
; inc al
; add di, 2
; loop debug_loop
; mov di, ((80*4)+0)*2
; mov cx, 20
; mov al, 'A'
; debug_loop2:
; mov ah, 0ch
; mov [gs:di], ax
; inc al
; add di, 2
; loop debug_loop2
;;Set Row start and cursor position
call CrtfnDisableCursor
mov ax, 0
mov [row_start], ax
call CrtfnSetStartRow
mov ax, 0
mov [y_cursor], ax
mov cx, 0
mov [x_cursor], cx
call CrtfnSetCursorPos
;;Redirect all IRQs to INTs 020h~02fh
mov esi, boot_str_rpirqs
call boot_promot
call ResetIRQs
call boot_promot_status
;;Set interrupts
mov esi, boot_str_setitss
call boot_promot
call set_interrupt_tss
call boot_promot_status
mov esi, boot_str_setitssdesc
call boot_promot
call set_gdt_interrupt_tss_descriptor
call boot_promot_status
mov esi, boot_str_setitaskgate
call boot_promot
call set_idt_interrupt_taskgate_descriptor
call boot_promot_status
lidt [cs:idts]
;;Set ramdisk file system
mov esi, boot_str_setrdfs
call boot_promot
mov eax, DISKIMG_BASE
mov ebx, NEW_FAT_BASE
call RdfsInit
call boot_promot_status
;;Set syscalls
mov esi, boot_str_setsysctss
call boot_promot
call set_syscall_tss
call boot_promot_status
mov esi, boot_str_setsysctssdesc
call boot_promot
call set_gdt_syscall_tss_descriptor
call boot_promot_status
mov esi, boot_str_setsysctaskgate
call boot_promot
call set_idt_syscall_taskgate_descriptor
call boot_promot_status
;;Set timer to 1/100 s
mov esi, boot_str_settimer
call boot_promot
mov al, 34h ; Set model 2, 16 bit counter
out 43h, al
mov al, 9bh ; [msb:lsb]=[2e9bh]=[11931] lsb=9bh
out 40h, al
mov al, 2eh ; msb=2eh
out 40h, al
clc
call boot_promot_status
;;Read CPUID
mov esi,boot_str_rcpuid
call boot_promot
call read_cpuid
call boot_promot_status
;;Set processes
mov esi, boot_str_setptss
call boot_promot
call set_process_tss
call boot_promot_status
mov esi, boot_str_setpcb
call boot_promot
call set_process_control_block
call boot_promot_status
mov esi, boot_str_setptssdesc
call boot_promot
call set_gdt_process_tss_descriptor
call boot_promot_status
mov esi, boot_str_setptaskgate
call boot_promot
call set_gdt_process_taskgate_descriptor
call boot_promot_status
mov esi, boot_str_setprocessseg
call boot_promot
call set_gdt_process_segment_descriptor
call boot_promot_status
;;;;;;;;;;;;;;;;Debug;;;;;;;;;;;;;;;;;;;;;;
;mov [400000h], byte 0h
;jmp $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Set OS task
mov esi, boot_str_setostask
call boot_promot
mov ax, sel_tss_process0 ;set tss to save the temp task
add ax, (max_processes+1)*8
ltr ax
mov [ts.eflags], dword 0x11202 ; sti and resume
mov [ts.ss0], sel_os_stack
mov [ts.ss1], sel_ring1_stack
mov [ts.ss2], sel_ring2_stack
mov [ts.esp0], RING0_ESP_0
mov [ts.esp1], RING1_ESP_1
mov [ts.esp2], RING2_ESP_2
mov eax, cr3
mov [ts.cr3], eax
mov [ts.eip], mainosloop
mov [ts.esp], STACK_SIZE_32BIT
mov [ts.cs], sel_os_code
mov [ts.ss], sel_os_stack
mov [ts.ds], sel_os_data
mov [ts.es], sel_os_data
mov [ts.fs], sel_os_data
mov [ts.gs], sel_video_data
mov esi, tss_struct
mov edi, 0
imul edi, tss_unit_process_size
add edi, tss_block_process_base
mov ecx, 120/4
cld
rep movsd
mov edi, 0
imul edi, PCB_SIZE
add edi, PCB_TABLE_BASE
mov [edi+PID_OFFSET], dword 0 ;;pid
mov [edi+PPID_OFFSET], dword 0 ;;ppid
mov [edi+MLOC_OFFSET], dword 0 ;;mlocation
mov [edi+TICK_OFFSET], dword 0 ;;tickcount
mov [edi+STAT_OFFSET], byte PS_READY ;;status
mov [edi+PCBS_OFFSET], byte PCBS_USED ;;pcb status
mov [pcb_current_base], edi
mov [pcb_current_no], dword 0
mov [pcb_total_count], dword 1
clc
call boot_promot_status
;;Set test task a
; mov [ts.eflags], dword 0x11202 ; sti and resume
; mov [ts.ss0], sel_os_stack
; mov [ts.ss1], sel_ring1_stack
; mov [ts.ss2], sel_ring2_stack
; mov [ts.esp0], RING0_ESP_0
; mov [ts.esp1], RING1_ESP_1
; mov [ts.esp2], RING2_ESP_2
; mov eax, cr3
; mov [ts.cr3], eax
; mov [ts.eip], 0
; mov [ts.esp], STACK_SIZE_32BIT
; mov ax, sel_user_code
; add ax, 8
; mov [ts.cs], ax
; mov ax, sel_user_data
; add ax, 8
; mov [ts.ss], ax
; mov [ts.ds], ax
; mov [ts.es], ax
; mov [ts.fs], ax
; mov [ts.gs], sel_video_data
; mov esi, tss_struct
; mov edi, 1
; imul edi, tss_unit_process_size
; add edi, tss_block_process_base
; mov ecx, 120/4
; cld
; rep movsd
; mov ebx, 1
; mov edi, 1
; imul edi, PCB_SIZE
; add edi, PCB_TABLE_BASE
; mov [edi+PID_OFFSET], dword 1000 ;;pid
; mov [edi+PPID_OFFSET], dword 0 ;;ppid
; mov eax, app_mem_size
; imul eax, ebx
; add eax, app_mem_base
; mov [edi+MLOC_OFFSET], eax ;;mlocation
; mov [edi+TICK_OFFSET], dword 0 ;;tickcount
; mov [edi+STAT_OFFSET], byte PS_READY ;;status
; mov [edi+PCBS_OFFSET], byte PCBS_USED ;;pcb status
; mov [pcb_current_base], dword PCB_TABLE_BASE
; mov [pcb_current_no], dword 0
; mov [pcb_total_count], dword 2
mov esi, boot_str_initshell
call boot_promot
mov esi, shell_path
mov eax, 0
call create_process
clc
call boot_promot_status
;;Set test task b
; mov [ts.eflags], dword 0x11202 ; sti and resume
; mov [ts.ss0], sel_os_stack
; mov [ts.ss1], sel_ring1_stack
; mov [ts.ss2], sel_ring2_stack
; mov [ts.esp0], RING0_ESP_0
; mov [ts.esp1], RING1_ESP_1
; mov [ts.esp2], RING2_ESP_2
; mov eax, cr3
; mov [ts.cr3], eax
; mov [ts.eip], testproc_b
; mov [ts.esp], STACK_SIZE_32BIT
; mov [ts.cs], sel_os_code
; mov [ts.ss], sel_os_stack
; mov [ts.ds], sel_os_data
; mov [ts.es], sel_os_data
; mov [ts.fs], sel_os_data
; mov [ts.gs], sel_video_data
; mov esi, tss_struct
; mov edi, 2
; imul edi, tss_unit_process_size
; add edi, tss_block_process_base
; mov ecx, 120/4
; cld
; rep movsd
; mov edi, 2
; imul edi, PCB_SIZE
; add edi, PCB_TABLE_BASE
; mov [edi+PID_OFFSET], dword 1001 ;;pid
; mov [edi+PPID_OFFSET], dword 0 ;;ppid
; mov [edi+MLOC_OFFSET], dword 0 ;;mlocation
; mov [edi+TICK_OFFSET], dword 0 ;;tickcount
; mov [edi+STAT_OFFSET], byte PS_READY ;;status
; mov [pcb_current_base], dword PCB_TABLE_BASE
; mov [pcb_current_no], dword 0
; mov [pcb_total_count], dword 3
;;Test function area
; mov ax, 22
; mov [y_cursor], ax
; mov cx, 0
; mov [x_cursor], cx
; call CrtfnSetCursorPos
; mov esi, .shelln
; call rdfsFindInRootDir
; push eax
; mov esi, shell_path
; mov edi, 0a00000h
; call RdfsLoadFile
; mov edi, .fat_num
; call word2Hstr
; mov esi, .fatstr
; call Kfn_PrintString
; pop eax
; push eax
; mov edi, 0a00000h
; call RdfsReadFile
; jmp test_ok
; .shelln db 'SHELL BIN', 0
; .path db '\readme', 0
; .dirn db 'BIN ', 0
; .fn db 'EYES RAW', 0
; .fatstr db 'FAT=0x'
; .fat_num db '0000', 0
; test_ok:
;;Wait for ENTER key
add [promot_row], byte 3
mov esi, boot_str_presenter
call boot_promot
.waitkey:
in al, 64h
test al, 01
jz .waitkey
in al, 60h
cmp al, 9ch
jne .waitkey
;;Clear screen
push es
mov ax, gs
mov es, ax
xor edi, edi
mov ecx, 80*25*8
mov ax, 0720h
cld
rep stosw
pop es
;;Reset cursor postion
call CrtfnEnableCursor
mov ax, 0
mov [row_start], ax
call CrtfnSetStartRow
mov ax, 0
mov [y_cursor], ax
mov cx, 0
mov [x_cursor], cx
call CrtfnSetCursorPos
;;Enalbe all IRQs
call EnableAllIRQs
call FlushAllIRQs
sti
jmp $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Main OS Loop
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;main os task loop (idle task)
mainosloop:
call oslfn_checkkbled
jmp mainosloop
jmp $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; 32 BIT INCLUDE CODE
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include ".\misc.inc"
include ".\sys32.inc"
include ".\process.inc"
include ".\drivers\console.inc"
include ".\drivers\i8259A.inc"
include ".\drivers\keyboard.inc"
include ".\drivers\ramdiskfs.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; KERNEL FUNCTIONS
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
oslfn_checkkbled:
cmp [kbled_stat_change], byte 0
je .notchange
call KbChangeLeds
mov [kbled_stat_change], byte 0
.notchange:
ret
io_delay:
jmp .id_ret
.id_ret:
ret
Kfn_WriteVideoBuffer:
;; write source buffer to the vide buffer at specified offset
;; ds:esi = source buffer
;; edi = dest offset in video buffer
;; ecx = count of word to write
push esi
push edi
push ecx
push es
mov ax, gs
mov es, ax
cld
rep movsw
pop es
pop ecx
pop edi
pop esi
ret
Kfn_WriteCharToCursor:
;; write char to current position of cursor
;; al = char
;; ah = attribute
push ebx
push edi
push ecx
push edx
mov ecx, eax
cmp al, 20h
jb .is_cr
mov ax, [y_cursor]
mov bx, 80
mul bx
mov di, ax
mov ax, [x_cursor]
add di, ax
mov ax, di
inc ax
xor edx, edx
mov bx, 80
div bx
mov word [x_cursor], dx
mov word [y_cursor], ax
mov ax, [row_start]
mov bx, 80
mul bx
add di, ax
shl di, 1
mov eax, ecx
mov [gs:di], ax
jmp .move_cursor
.is_cr:
cmp al, ASC_CC_CR ;if al=return
jne .is_lf
mov word [x_cursor], 0
jmp .move_cursor
.is_lf:
cmp al, ASC_CC_LF ;if al=linefeed
jne .is_bs
inc word [y_cursor]
jmp .move_cursor
.is_bs:
cmp al, ASC_CC_BS
jne .invalidchar
mov ax, [x_cursor]
add ax, 79
xor edx, edx
mov bx, 80
div bx
mov word [x_cursor], dx
dec word [y_cursor]
add word [y_cursor], ax
mov ax, [y_cursor]
mov bx, 80
mul bx
mov di, ax
mov ax, [x_cursor]
add di, ax
mov ax, [row_start]
mov bx, 80
mul bx
add di, ax
shl di, 1
mov ax, 0720h
mov [gs:di], ax
jmp .move_cursor
.invalidchar:
mov cl, 20h
mov ax, [y_cursor]
mov bx, 80
mul bx
mov di, ax
mov ax, [x_cursor]
add di, ax
mov di, ax
inc ax
xor edx, edx
mov bx, 80
div bx
mov word [x_cursor], dx
add word [y_cursor], ax
mov ax, [row_start]
mov bx, 80
mul bx
add di, ax
shl di, 1
mov eax, ecx
mov [gs:di], ax
jmp .move_cursor
.move_cursor:
cmp [y_cursor], word 25
jne .noturnpage
cmp [x_cursor], word 0
jne .noturnpage
inc word [row_start]
mov ax, [row_start]
call CrtfnSetStartRow
mov [y_cursor], word 24
.noturnpage:
mov ax, [row_start]
add ax, [y_cursor]
mov cx, [x_cursor]
call CrtfnSetCursorPos
pop edx
pop ecx
pop edi
pop ebx
ret
Kfn_PrintString:
;; Print string at the cursor position
;; ds:esi = string buffer
push eax
push esi
cld
.next_char:
lodsb
cmp al, 0
je .exit_p
mov ah, 07h
call Kfn_WriteCharToCursor
jmp .next_char
.exit_p:
pop esi
pop eax
ret
delay_ms: ; delay in 1/1000 sec
push eax
push ecx
mov ecx, esi
imul ecx, 33941
shr ecx, 9
in al, 61h
and al, 10h
mov ah, al
cld
.loop_0:
in al, 61h
and al, 10h
cmp al, ah
jz .loop_0
mov ah, al
loop .loop_0
pop ecx
pop eax
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; SYSTEM CALL FUNCTIONS
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
sysc_gettick:
cli
mov eax, [sys_tic]
sti
mov [esp+36], eax
ret
sysc_getkey:
cmp byte [kasbuf_count], 0
je .kbufempty
movzx edi, byte [kasbuf_head]
add edi, kasbuf_base
mov cl, [edi]
movzx ax, byte [kasbuf_head]
inc ax
mov bh, kasbuf_len
idiv bh
mov [kasbuf_head], ah
dec byte [kasbuf_count]
mov al, cl
jmp .ret
.kbufempty:
mov eax, 0ffffffffh
.ret:
sti
mov [esp+36], eax
ret
sysc_screenandcursor:
cli
cmp eax, 0
je .clearsc
cmp eax, 1
je .setcursor
cmp eax, 2
je .getcursor
.clearsc:
push es
push eax
push ecx
mov ax, gs
mov es, ax
xor edi, edi
mov ecx, 80*25*8
mov ax, 0720h
cld
rep stosw
pop ecx
pop eax
pop es
sti
ret
.setcursor:
push ebx
mov [y_cursor], bx
shr ebx, 16
mov [x_cursor], bx
pop ebx
call CrtfnSetCursorPos
sti
ret
.getcursor:
xor ebx, ebx
mov bx, [x_cursor]
shl ebx, 16
mov bx, [y_cursor]
sti
ret
sysc_putchar:
mov ah, 07h
cli
call Kfn_WriteCharToCursor
sti
ret
sysc_print:
push edi
mov edi, [pcb_current_base]
add esi, [edi+MLOC_OFFSET]
pop edi
cld
.next_char:
lodsb
cmp al, 0
je .print_done
mov ah, 07h
cli
call Kfn_WriteCharToCursor
sti
jmp .next_char
.print_done:
ret
align 4
sysc_time:
cli
.test_status:
mov al, 0ah
out 70h, al
call io_delay
in al, 71h
test al, 1000000b
jnz .test_status
mov al, 0
out 70h, al
in al, 71h ; seconds
movzx ecx, al
shl ecx, 16
mov al, 02
out 70h, al
in al, 71h ; minutes
movzx edx, al
shl edx, 8
add ecx, edx
mov al, 04
out 70h, al
in al, 71h ; hours
movzx edx, al
add ecx, edx
sti
mov [esp+36], ecx ; ecx:|notuse|s|m|h| BCD
ret
align 4
sysc_date:
cli
.test_status:
mov al, 0ah
out 70h, al
call io_delay
in al, 71h
test al, 1000000b
jnz .test_status
mov al, 6
out 70h, al
call io_delay
in al, 71h ; day of week
mov ch, al
mov al, 7
out 70h, al
call io_delay
in al, 71h ; date
mov cl, al
shl ecx, 16
mov al, 8
out 70h, al
call io_delay
in al, 71h ; month
mov ch, al
mov al, 9
out 70h, al
call io_delay
in al, 71h ; year
mov cl, al
sti
mov [esp+36], ecx ; ecx:|dw|d|m|y|
ret
align 4
sysc_createprocess:
cli
mov edi, [pcb_current_base]
add esi, [edi+MLOC_OFFSET]
add eax, [edi+MLOC_OFFSET]
call create_process
sti
mov [esp+36], eax
ret
align 4
sysc_exitprocess:
mov eax, [pcb_current_no]
call terminate_process
ret
align 4
sysc_waitpid:
cli
call wait_process_id
sti
mov [esp+36], eax
ret
FSOP_FATTR equ 00h
FSOP_FREAD equ 01h
FSOP_FWRITE equ 02h
align 4
sysc_rdfs:
cli
cmp eax, FSOP_FATTR
je .fattr
cmp eax, FSOP_FREAD
je .fread
cmp eax, FSOP_FWRITE
je .fwrite
.fattr:
mov edi, [pcb_current_base]
add ebx, [edi+MLOC_OFFSET]
add esi, [edi+MLOC_OFFSET]
mov edi, ebx
call RdfsGetFileItem
mov [esp+36], eax
sti
ret
.fread:
mov edi, [pcb_current_base]
add ebx, [edi+MLOC_OFFSET]
add esi, [edi+MLOC_OFFSET]
mov edi, ebx
call RdfsReadFile
mov [esp+36], eax
sti
ret
.fwrite:
mov [esp+36], eax
sti
ret
| 17.731995 | 215 | 0.629136 |
b89a8f8f403aaeaf3bb0fc41372fe7cbf3dd50a7 | 490 | asm | Assembly | oeis/061/A061094.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/061/A061094.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/061/A061094.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A061094: The alternating group A_n contains an element x which is not conjugate to its inverse (equivalently not all the entries in the character table of A_n are real numbers).
; Submitted by Jon Maiga
; 3,4,7,8,9,11,12,13,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77
mov $1,$0
add $0,4
lpb $0
div $0,3
add $0,$1
pow $1,11
lpe
add $0,3
| 37.692308 | 209 | 0.689796 |
40b0fe4b4269e90a96c59a53607f2c1d5fcf3c81 | 512 | asm | Assembly | int-tests/windows/link/nasm/main.asm | kreilley/Disassembler | 7c5c293aa1b585dba6ffd2f8eceb2150b05574b6 | [
"BSD-3-Clause"
] | 1 | 2021-09-05T02:24:20.000Z | 2021-09-05T02:24:20.000Z | int-tests/windows/link/nasm/main.asm | kreilley/Disassembler | 7c5c293aa1b585dba6ffd2f8eceb2150b05574b6 | [
"BSD-3-Clause"
] | 27 | 2020-11-14T06:21:41.000Z | 2021-03-08T19:34:07.000Z | int-tests/windows/link/nasm/main.asm | kreilley/Disassembler | 7c5c293aa1b585dba6ffd2f8eceb2150b05574b6 | [
"BSD-3-Clause"
] | 1 | 2021-03-03T03:06:45.000Z | 2021-03-03T03:06:45.000Z | global main
extern GetStdHandle
extern WriteFile
section .text
main:
mov rcx, 0fffffff5h
call GetStdHandle
mov rcx, rax
mov rdx, NtlpBuffer
mov r8, [NtnNBytesToWrite]
mov r9, NtlpNBytesWritten
sub rsp, 40
mov dword [rsp + 32], 00h
call WriteFile
add rsp, 40
ExitProgram:
xor eax, eax
ret
section .data
NtlpBuffer: db 'Hello, World!', 00h
NtnNBytesToWrite: dq 0eh
section .bss
NtlpNBytesWritten: resd 01h | 18.962963 | 45 | 0.619141 |
3d497a22d98994bafa890401f0e1a6e8bda08fed | 720 | asm | Assembly | oeis/038/A038806.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/038/A038806.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/038/A038806.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A038806: Convolution of A008549 with A000302 (powers of 4).
; Submitted by Christian Krause
; 0,1,10,69,406,2186,11124,54445,259006,1205790,5519020,24918306,111250140,492051124,2159081192,9409526397,40766269774,175707380630,753876367356,3221460111958,13716223138388,58210889582796,246319029011800,1039521058383314,4376353907025036,18383356268468716,77063554988421304,322444273162786980,1346801053439305336,5616302299126502376,23385416524485225936,97237040045896996381,403785190040289404270,1674701215718375535174,6937859629144523543836,28710773867157087089166,118692396669330180465444
add $0,2
mov $1,$0
add $0,1
mul $1,2
bin $1,$0
sub $0,1
mul $1,2
mov $2,4
pow $2,$0
add $0,1
mul $1,2
sub $2,$1
mul $0,$2
div $0,16
| 37.894737 | 492 | 0.830556 |
432887663f2cfe776fbc1dc0894d9a56aa5b6675 | 3,707 | asm | Assembly | base/mvdm/wow16/user/user2a.asm | npocmaka/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 17 | 2020-11-13T13:42:52.000Z | 2021-09-16T09:13:13.000Z | base/mvdm/wow16/user/user2a.asm | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 2 | 2020-10-19T08:02:06.000Z | 2020-10-19T08:23:18.000Z | base/mvdm/wow16/user/user2a.asm | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 14 | 2020-11-14T09:43:20.000Z | 2021-08-28T08:59:57.000Z | ;
; USER2A.ASM
; More Win16 USER thunks
;
; History:
;
; Created 25-Jan-1991 by Jeff Parsons (jeffpar)
; Added Win 31 thunks 22nd-March-1992 by Chandan S. Chauhan (ChandanC)
; Split off from USER.ASM 9-Jun-92 by BobDay
;
;--
TITLE USER2A.ASM
PAGE ,132
.286p
.xlist
include wow.inc
include wowusr.inc
include cmacros.inc
NOEXTERNS=1 ; to suppress including most of the stuff in user.inc
include user.inc
.list
externFP GetModuleHandle
externFP WOW16Call
createSeg _TEXT,CODE,WORD,PUBLIC,CODE
createSeg _DATA,DATA,WORD,PUBLIC,DATA,DGROUP
defgrp DGROUP,DATA
sBegin CODE
assumes CS,CODE
assumes DS,DATA
assumes ES,NOTHING
UserThunk GETUPDATERECT
UserThunk GETUPDATERGN
UserThunk GETWC2
UserThunk GETWINDOWDC
DUserThunk GETWINDOWLONG
UserThunk GETWINDOWTASK
EUserThunk GETWINDOWTEXT ;Use the empty buffer user thunk.
UserThunk GETWINDOWTEXTLENGTH
DUserThunk GETWINDOWWORD
DUserThunk GLOBALADDATOM
DUserThunk GLOBALDELETEATOM
UserThunk GLOBALFINDATOM
DUserThunk GLOBALGETATOMNAME
UserThunk GRAYSTRING
UserThunk HIDECARET
UserThunk HILITEMENUITEM
DUserThunk ICONSIZE ;;;;;;
;;; UserThunk INFLATERECT ; LOCALAPI in winrect.asm
;;; DUserThunk INITAPP ;LOCALAPI in user.asm
DUserThunk INSENDMESSAGE,0
UserThunk INSERTMENU
;;; UserThunk INTERSECTRECT ; LOCALAPI in winrect.asm
UserThunk INVALIDATERECT
UserThunk INVALIDATERGN
UserThunk INVERTRECT
; Hack to use original IDs. These functions have local implementations
; that thunk to Win32 if the locale is other than U.S. English.
FUN_WIN32ISCHARALPHA equ FUN_ISCHARALPHA
FUN_WIN32ISCHARALPHANUMERIC equ FUN_ISCHARALPHANUMERIC
FUN_WIN32ISCHARLOWER equ FUN_ISCHARLOWER
FUN_WIN32ISCHARUPPER equ FUN_ISCHARUPPER
DUserThunk WIN32ISCHARALPHA, %(size ISCHARALPHA16)
DUserThunk WIN32ISCHARALPHANUMERIC, %(size ISCHARALPHANUMERIC16)
DUserThunk WIN32ISCHARLOWER, %(size ISCHARLOWER16)
DUserThunk WIN32ISCHARUPPER, %(size ISCHARUPPER16)
DUserThunk ISCLIPBOARDFORMATAVAILABLE
UserThunk ISDIALOGMESSAGE
UserThunk ISDLGBUTTONCHECKED
;;; UserThunk ISRECTEMPTY ; LOCALAPI in winrect.asm
DUserThunk ISTWOBYTECHARPREFIX ;;;;;;
DUserThunk ISUSERIDLE
DUserThunk KILLSYSTEMTIMER ;;;;;
UserThunk KILLTIMER
UserThunk KILLTIMER2
UserThunk LBOXCARETBLINKER
;;; UserThunk LBOXCTLWNDPROC ;LOCALAPI in wsubcls.c
;;; UserThunk LOADACCELERATORS ; localapi in rmload.c
FUN_WOWLOADBITMAP EQU FUN_LOADBITMAP
DUserThunk WOWLOADBITMAP, %(size LOADBITMAP16)
FUN_WOWLOADCURSORICON EQU FUN_LOADCURSOR
DUserThunk WOWLOADCURSORICON, %(size LOADCURSOR16)
;FUN_WOWLOADICON EQU FUN_LOADICON
; DUserThunk WOWLOADICON, %(size LOADICON16)
DUserThunk LOADICONHANDLER
FUN_WOWLOADMENU EQU FUN_LOADMENU
DUserThunk WOWLOADMENU, %(size LOADMENU16)
UserThunk LOADMENUINDIRECT
;;; UserThunk LOADSTRING ;LOCALAPI in rmload.c
DUserThunk LOCKMYTASK
DUserThunk LOOKUPMENUHANDLE
; Hack to use original IDs. These functions have local implementations
; that thunk to Win32 if the locale is other than U.S. English.
FUN_WIN32LSTRCMP equ FUN_LSTRCMP
FUN_WIN32LSTRCMPI equ FUN_LSTRCMPI
DUserThunk WIN32LSTRCMP, %(size LSTRCMP16)
DUserThunk WIN32LSTRCMPI, %(size LSTRCMPI16)
sEnd CODE
end
| 30.385246 | 76 | 0.694362 |
60f0bd5061d4df3e50303d1c98057b8e716fd82f | 897 | asm | Assembly | Wizardry/ExternalHacks/TradeFix/trade_fix_WM.asm | sme23/OneHourBlitz | 2c6cb94ffe1d39743be6505a1a940128ac7fbc39 | [
"CC0-1.0"
] | 1 | 2020-10-12T07:09:33.000Z | 2020-10-12T07:09:33.000Z | Wizardry/ExternalHacks/TradeFix/trade_fix_WM.asm | sme23/WhatHeck | 746a2be83358aaa4e855182176b47c4808f2587a | [
"CC0-1.0"
] | null | null | null | Wizardry/ExternalHacks/TradeFix/trade_fix_WM.asm | sme23/WhatHeck | 746a2be83358aaa4e855182176b47c4808f2587a | [
"CC0-1.0"
] | null | null | null | .thumb
.org 0 @paste to e184c-8b4
@at 9b550 write 46f07cf9
@need to save r0 actually
@change r1,r2 to r0,r1
@change r4,r5 to r2,r3
push {r4-r6,lr}
mov r6,r0 @save r0 for later
mov r5,r1 @save inventory ptrs
ldrh r0,[r4] @get item data
ldr r1, AbilityGetter
mov lr,r1
.short 0xF800
mov r1, #0x10 @unsellable
and r0,r1
cmp r0,#0
bne NoTrade
ldrh r0,[r5]
ldr r1, AbilityGetter
mov lr,r1
.short 0xF800
mov r1,#0x10
and r0,r1
cmp r0,#0
bne NoTrade
ldrh r1,[r5]
ldrh r0,[r4]
strh r1,[r4]
strh r0,[r5]
mov r0,r6
b End
NoTrade:
ldr r0, MuteCheck
ldrb r0,[r0]
lsl r0,r0,#0x1e
cmp r0,#0
blt Mute
mov r0,#0x6c
ldr r1, PlaySound
mov lr,r1
.short 0xF800
Mute:
pop {r4-r6}
pop {r0}
pop {r4-r6}
pop {r0}
ldr r0, ReturnSkip
bx r0
End:
pop {r4-r6}
pop {r1}
bx r1
.align
AbilityGetter:
.long 0x0801756c
PlaySound:
.long 0x080d01fc
ReturnSkip:
@.long 0x0809be1b
.long 0x0809bc89
MuteCheck:
.long 0x0202bc31
| 13.590909 | 33 | 0.716834 |
d20be0350fb7ae6b973dd7e543f79892734702a4 | 500 | asm | Assembly | programs/oeis/036/A036562.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/036/A036562.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/036/A036562.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A036562: a(n) = 4^(n+1) + 3*2^n + 1.
; 1,8,23,77,281,1073,4193,16577,65921,262913,1050113,4197377,16783361,67121153,268460033,1073790977,4295065601,17180065793,68719869953,274878693377,1099513200641,4398049656833,17592192335873,70368756760577,281475001876481,1125899957174273,4503599728033793
mov $5,7
lpb $0
trn $1,5
mov $6,$1
add $6,10
add $1,$6
mov $3,$1
add $3,7
mov $4,$0
add $4,$0
sub $0,1
mul $3,2
lpe
mov $2,$3
sub $2,$4
div $5,2
add $5,$2
mul $1,$5
div $1,50
add $1,1
| 20.833333 | 255 | 0.684 |
b0cff7f39b42dcf48da1c909a988bca6baefd7e1 | 302 | asm | Assembly | programs/oeis/072/A072703.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/072/A072703.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/072/A072703.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A072703: Indices of Fibonacci numbers whose last digit is 5.
; 5,10,20,25,35,40,50,55,65,70,80,85,95,100,110,115,125,130,140,145,155,160,170,175,185,190,200,205,215,220,230,235,245,250,260,265,275,280,290,295,305,310,320,325,335,340,350,355,365,370,380
mul $0,6
mov $1,$0
div $1,4
mul $1,5
add $1,5
| 33.555556 | 191 | 0.705298 |
863537479503cc5ebcb0d75f4546dabf519784f2 | 719 | asm | Assembly | oeis/164/A164577.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/164/A164577.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/164/A164577.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A164577: Integer averages of the first perfect cubes up to some n^3.
; 1,12,25,45,112,162,225,396,507,637,960,1156,1377,1900,2205,2541,3312,3750,4225,5292,5887,6525,7936,8712,9537,11340,12321,13357,15600,16810,18081,20812,22275,23805,27072,28812,30625,34476,36517,38637,43120,45486,47937,53100,55815,58621,64512,67600,70785,77452,80937,84525,92016,95922,99937,108300,112651,117117,126400,131220,136161,146412,151725,157165,168432,174262,180225,192556,198927,205437,218880,225816,232897,247500,255025,262701,278512,286650,294945,312012,320787,329725,348096,357532,367137
add $0,2
mul $0,8
div $0,6
mov $1,1
sub $1,$0
mov $2,$1
mul $2,$0
lpb $0
sub $0,1
sub $2,1
lpe
mul $1,$2
sub $1,4
div $1,4
add $1,1
mov $0,$1
| 35.95 | 500 | 0.757997 |
8bdb8fcf50cfe4ee30924cc078bc8419b071c67c | 4,088 | asm | Assembly | Working Disassembly/General/Sprites/Knuckles/Anim - Knuckles.asm | TeamASM-Blur/Sonic-3-Blue-Balls-Edition | 7e8a2c5df02271615ff4cae529521e6b1560d6b1 | [
"Apache-2.0"
] | 5 | 2021-07-09T08:17:56.000Z | 2022-02-27T19:57:47.000Z | Working Disassembly/General/Sprites/Knuckles/Anim - Knuckles.asm | TeamASM-Blur/Sonic-3-Blue-Balls-Edition | 7e8a2c5df02271615ff4cae529521e6b1560d6b1 | [
"Apache-2.0"
] | null | null | null | Working Disassembly/General/Sprites/Knuckles/Anim - Knuckles.asm | TeamASM-Blur/Sonic-3-Blue-Balls-Edition | 7e8a2c5df02271615ff4cae529521e6b1560d6b1 | [
"Apache-2.0"
] | null | null | null | dc.w byte_17F3E-AniKnuckles
dc.w byte_17F48-AniKnuckles
dc.w byte_17F52-AniKnuckles
dc.w byte_17F5C-AniKnuckles
dc.w byte_17F66-AniKnuckles
dc.w byte_17F70-AniKnuckles
dc.w byte_18008-AniKnuckles
dc.w byte_18032-AniKnuckles
dc.w byte_18037-AniKnuckles
dc.w byte_1803C-AniKnuckles
dc.w byte_18048-AniKnuckles
dc.w byte_1805F-AniKnuckles
dc.w byte_18062-AniKnuckles
dc.w byte_18088-AniKnuckles
dc.w byte_1808F-AniKnuckles
dc.w byte_18092-AniKnuckles
dc.w byte_1809E-AniKnuckles
dc.w byte_180A2-AniKnuckles
dc.w byte_180A6-AniKnuckles
dc.w byte_180AC-AniKnuckles
dc.w byte_180B5-AniKnuckles
dc.w byte_180B8-AniKnuckles
dc.w byte_180BF-AniKnuckles
dc.w byte_180C2-AniKnuckles
dc.w byte_180C5-AniKnuckles
dc.w byte_180C8-AniKnuckles
dc.w byte_180CB-AniKnuckles
dc.w byte_180CE-AniKnuckles
dc.w byte_180D1-AniKnuckles
dc.w byte_180D4-AniKnuckles
dc.w byte_180D8-AniKnuckles
dc.w byte_180FE-AniKnuckles
dc.w byte_180E0-AniKnuckles
dc.w byte_180E3-AniKnuckles
dc.w byte_180E8-AniKnuckles
dc.w byte_180EC-AniKnuckles
dc.w byte_180F0-AniKnuckles
byte_17F3E: dc.b $FF, 7, 8, 1, 2, 3, 4, 5, 6, $FF
byte_17F48: dc.b $FF, $21, $22, $23, $24, $FF, $FF, $FF, $FF, $FF
byte_17F52: dc.b $FE, $9A, $96, $9A, $97, $9A, $98, $9A, $99, $FF
byte_17F5C: dc.b $FE, $9A, $96, $9A, $97, $9A, $98, $9A, $99, $FF
byte_17F66: dc.b $FD, $CE, $CF, $D0, $D1, $FF, $FF, $FF, $FF, $FF
byte_17F70: dc.b 5, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56
dc.b $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56
dc.b $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $56, $D2, $D2, $D2, $D3, $D3, $D3, $D2, $D2, $D2
dc.b $D3, $D3, $D3, $D2, $D2, $D2, $D3, $D3, $D3, $D2, $D2, $D2, $D3, $D3, $D3, $D2, $D2, $D2, $D3, $D3
dc.b $D3, $D2, $D2, $D2, $D3, $D3, $D3, $D2, $D2, $D2, $D3, $D3, $D3, $D2, $D2, $D2, $D3, $D3, $D3, $D2
dc.b $D2, $D2, $D3, $D3, $D3, $D4, $D4, $D4, $D4, $D4, $D7, $D8, $D9, $DA, $DB, $D8, $D9, $DA, $DB, $D8
dc.b $D9, $DA, $DB, $D8, $D9, $DA, $DB, $D8, $D9, $DA, $DB, $D8, $D9, $DA, $DB, $D8, $D9, $DA, $DB, $D8
dc.b $D9, $DA, $DB, $DC, 221, 220, 221, 222, 222, 216, 215, 255
byte_18008: dc.b 3, $9F, $9F, $A0, $A0, $A1, $A1, $A2, $A2, $A3, $A3, $A4, $A4, $A5, $A5, $A5, $A5, $A5, $A5, $A5
dc.b $A5, $A5, $A5, $A5, $A5, $A5, $A5, $A5, $A6, $A6, $A6, $A7, $A7, $A7, $A8, $A8, $A9, $A9, $AA, $AA
dc.b $FE, 6
byte_18032: dc.b 5, $D5, $D6, $FE, 1
byte_18037: dc.b 5, $9B, $9C, $FE, 1
byte_1803C: dc.b 0, $86, $87, $86, $88, $86, $89, $86, $8A, $86, $8B, $FF
byte_18048: dc.b 9, $BA, $C5, $C6, $C6, $C6, $C6, $C6, $C6, $C7, $C7, $C7, $C7, $C7, $C7, $C7, $C7, $C7, $C7, $C7
dc.b $C7, $FD, 0
byte_1805F: dc.b $F, $8F, $FF
byte_18062: dc.b 3, $A1, $A1, $A2, $A2, $A3, $A3, $A4, $A4, $A5, $A5, $A5, $A5, $A5, $A5, $A5, $A5, $A5, $A5, $A5
dc.b $A5, $A5, $A5, $A5, $A6, $A6, $A6, $A7, $A7, $A7, $A8, $A8, $A9, $A9, $AA, $AA, $FE, 6
byte_18088: dc.b 3, $9D, $9E, $9F, $A0, $FD, 0
byte_1808F: dc.b 7, $C0, $FF
byte_18092: dc.b 5, $C0, $C1, $C2, $C3, $C4, $C5, $C6, $C7, $C8, $C9, $FF
byte_1809E: dc.b $2F, $8E, $FD, 0
byte_180A2: dc.b 1, $AE, $AF, $FF
byte_180A6: dc.b $F, $43, $43, $43, $FE, 1
byte_180AC: dc.b 5, $B1, $B2, $B2, $B2, $B3, $B4, $FE, 1
byte_180B5: dc.b $13, $91, $FF
byte_180B8: dc.b $B, $B0, $B0, 3, 4, $FD, 0
byte_180BF: dc.b $20, $AC, $FF
byte_180C2: dc.b $20, $AD, $FF
byte_180C5: dc.b $20, $AB, $FF
byte_180C8: dc.b 9, $8C, $FF
byte_180CB: dc.b $40, $8D, $FF
byte_180CE: dc.b 9, $8C, $FF
byte_180D1: dc.b $77, 0, $FF
byte_180D4: dc.b $13, $D0, $D1, $FF
byte_180D8: dc.b 3, $CF, $C8, $C9, $CA, $CB, $FE, 4
byte_180E0: dc.b $1F, $C0, $FF
byte_180E3: dc.b 7, $CA, $CB, $FE, 1
byte_180E8: dc.b $F, $CD, $FD, 0
byte_180EC: dc.b $F, $9C, $FD, 0
byte_180F0: dc.b 7, $B1, $B3, $B3, $B3, $B3, $B3, $B3, $B2, $B3, $B4, $B3, $FE, 4
byte_180FE: dc.b 2, $EB, $EB, $EC, $ED, $EC, $ED, $EC, $ED, $EC, $ED, $EC, $ED, $FD, 0
even
| 46.988506 | 116 | 0.560176 |
fd1d1891f312c88d561b08766d285fd21f60b4bf | 1,125 | asm | Assembly | src/tables/cosine.asm | furrtek/GB303 | 2f275fff085b05fdc7843074dcc062956a1d8d56 | [
"CC-BY-4.0"
] | 90 | 2015-06-19T14:26:19.000Z | 2022-01-05T08:19:41.000Z | src/tables/cosine.asm | furrtek/GB303 | 2f275fff085b05fdc7843074dcc062956a1d8d56 | [
"CC-BY-4.0"
] | 2 | 2015-06-21T20:55:40.000Z | 2022-02-09T08:02:04.000Z | src/tables/cosine.asm | furrtek/GB303 | 2f275fff085b05fdc7843074dcc062956a1d8d56 | [
"CC-BY-4.0"
] | 10 | 2015-06-21T20:43:11.000Z | 2020-12-08T13:24:16.000Z | ;256 signed values
lut_cos:
.db $7F,$7F,$7F,$7E,$7E,$7E,$7D,$7D,$7C,$7B,$7A,$7A,$79,$78,$76,$75
.db $74,$73,$71,$70,$6F,$6D,$6B,$6A,$68,$66,$64,$62,$60,$5E,$5C,$5A
.db $58,$55,$53,$51,$4E,$4C,$49,$47,$44,$41,$3F,$3C,$39,$36,$34,$31
.db $2E,$2B,$28,$25,$22,$1F,$1C,$19,$16,$13,$10,$D,$9,$6,$3,$0
.db $FD,$FA,$F7,$F4,$F1,$ED,$EA,$E7,$E4,$E1,$DE,$DB,$D8,$D5,$D2,$D0
.db $CD,$CA,$C7,$C4,$C2,$BF,$BC,$BA,$B7,$B4,$B2,$B0,$AD,$AB,$A9,$A6
.db $A4,$A2,$A0,$9E,$9C,$9A,$98,$96,$95,$93,$92,$90,$8F,$8D,$8C,$8B
.db $8A,$88,$87,$87,$86,$85,$84,$83,$83,$82,$82,$82,$81,$81,$81,$81
.db $81,$81,$81,$82,$82,$82,$83,$83,$84,$85,$86,$86,$87,$88,$89,$8B
.db $8C,$8D,$8E,$90,$91,$93,$95,$96,$98,$9A,$9C,$9E,$A0,$A2,$A4,$A6
.db $A8,$AB,$AD,$AF,$B2,$B4,$B7,$B9,$BC,$BE,$C1,$C4,$C7,$C9,$CC,$CF
.db $D2,$D5,$D8,$DB,$DE,$E1,$E4,$E7,$EA,$ED,$F0,$F3,$F6,$F9,$FD,$0
.db $3,$6,$9,$C,$F,$12,$15,$18,$1C,$1F,$22,$25,$28,$2A,$2D,$30
.db $33,$36,$39,$3C,$3E,$41,$44,$46,$49,$4B,$4E,$50,$53,$55,$57,$5A
.db $5C,$5E,$60,$62,$64,$66,$68,$69,$6B,$6D,$6E,$70,$71,$73,$74,$75
.db $76,$77,$78,$79,$7A,$7B,$7C,$7C,$7D,$7E,$7E,$7E,$7F,$7F,$7F,$7F
| 56.25 | 68 | 0.493333 |
5c2d96925ac1156220fb6cdbd370241180007a0e | 746 | asm | Assembly | oeis/002/A002884.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/002/A002884.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/002/A002884.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A002884: Number of nonsingular n X n matrices over GF(2); order of Chevalley group A_n (2); order of projective special linear group PSL_n(2).
; Submitted by Jamie Morken(s1.)
; 1,1,6,168,20160,9999360,20158709760,163849992929280,5348063769211699200,699612310033197642547200,366440137299948128422802227200,768105432118265670534631586896281600,6441762292785762141878919881400879415296000,216123289355092695876117433338079655078664339456000,29005806383140729950522834209814601639147584498136252416000,15571898495080403735163399512932270930492602798087054670480539648000,33439887126531088671831929227837976590084758712242507868731544889972490240000
mov $2,1
mov $4,1
lpb $0
sub $0,1
add $3,$2
mul $4,$3
mul $4,$2
mul $2,2
lpe
mov $0,$4
| 49.733333 | 469 | 0.847185 |
0621c827ef2a09973ad00d1fdd683d5112c775b2 | 91,727 | asm | Assembly | raid/Setup/list/drvsetup.asm | OS2World/DRV-VRAID | 7154196d3d06293259354572f72fd3b36f39924c | [
"BSD-3-Clause"
] | null | null | null | raid/Setup/list/drvsetup.asm | OS2World/DRV-VRAID | 7154196d3d06293259354572f72fd3b36f39924c | [
"BSD-3-Clause"
] | null | null | null | raid/Setup/list/drvsetup.asm | OS2World/DRV-VRAID | 7154196d3d06293259354572f72fd3b36f39924c | [
"BSD-3-Clause"
] | null | null | null | title drvsetup.cpp
.386
.387
includelib CPPOM30.LIB
includelib OS2386.LIB
CODE32 segment dword use32 public 'CODE'
CODE32 ends
DATA32 segment dword use32 public 'DATA'
DATA32 ends
CONST32_RO segment dword use32 public 'CONST'
CONST32_RO ends
BSS32 segment dword use32 public 'BSS'
BSS32 ends
EH_CODE segment dword use32 public 'CODE'
EH_CODE ends
CTOR_DTOR1 segment dword use32 public 'DATA'
CTOR_DTOR1 ends
CTOR_DTOR2 segment dword use32 public 'DATA'
CTOR_DTOR2 ends
CTOR_DTOR3 segment dword use32 public 'DATA'
CTOR_DTOR3 ends
EH_DATA segment para use32 public 'DATA'
EH_DATA ends
_VFT segment para use32 public 'DATA'
_VFT ends
DGROUP group BSS32, DATA32
assume cs:FLAT, ds:FLAT, ss:FLAT, es:FLAT
extrn WinQuerySysColor:proc
extrn ProfileRead:proc
extrn WinQueryWindowPos:proc
extrn Verbose:proc
extrn WinCreateWindow:proc
extrn MyMessageBox__FCiCUlPce:proc
extrn WinGetLastError:proc
extrn memset:proc
extrn WinSendMsg:proc
extrn WinLoadMenu:proc
extrn WinQueryPointerPos:proc
extrn WinMapWindowPoints:proc
extrn SearchCnr__FUlPFUlPvT2PUl_UlPvN23:proc
extrn EmphInuse2Source__FUlP9_MYRECORDPUlT3:proc
extrn WinPopupMenu:proc
extrn DrgAllocDraginfo:proc
extrn DrgAddStrHandle:proc
extrn DrgSetDragitem:proc
extrn DrgDrag:proc
extrn DrgFreeDraginfo:proc
extrn _sprintfieee:proc
extrn WinMessageBox:proc
extrn LookupDisk__FUlP9_MYRECORDP5VRDevPP9_MYRECORD:proc
extrn WinPostMsg:proc
extrn WinQueryWindowPtr:proc
extrn __nw__FUi:proc
extrn _beginthread:proc
extrn DrvscanThread:proc
extrn _errno:proc
extrn EmphSource__FUlP9_MYRECORDPUlT3:proc
extrn QueryInuse__FUlP9_MYRECORDPUlPP9_MYRECORD:proc
extrn WinDlgBox:proc
extrn DrvtypeDlgProc:proc
extrn memcpy:proc
extrn time:proc
extrn __dl__FPv:proc
extrn __ct__7VSingleFPUc:proc
extrn __ct__6VChainFPUci:proc
extrn __ct__7VStripeFPUci:proc
extrn __ct__7VMirrorFPUci:proc
extrn EmphInuse__FUlP9_MYRECORDPUlT3:proc
extrn QueryAny__FUlP9_MYRECORDPUlPP9_MYRECORD:proc
extrn WinDestroyWindow:proc
extrn WinQueryWindow:proc
extrn ProfileWrite:proc
extrn WinSetWindowPos:proc
extrn WinQueryPresParam:proc
extrn WinInvalidateRect:proc
extrn strlen:proc
extrn WinDefWindowProc:proc
extrn _Exception_CPP:proc
extrn WinInitialize:proc
extrn WinCreateMsgQueue:proc
extrn WinCancelShutdown:proc
extrn WinRegisterClass:proc
extrn WinCreateStdWindow:proc
extrn WinSetWindowPtr:proc
extrn WinQueryTaskSizePos:proc
extrn WinGetMsg:proc
extrn WinDispatchMsg:proc
extrn WinDestroyMsgQueue:proc
extrn WinTerminate:proc
extrn usHostId:word
extrn _fltused:dword
CONST32_RO segment
@CBE1 db "Background",0h
align 04h
@CBE2 db "Foreground",0h
align 04h
@CBE3 db "DrvSetup",0h
align 04h
@CBE4 db "client window %u,%u %u,%"
db "u",0h
align 04h
@CBE5 db "WinCreateWindow(...,WC_C"
db "ONTAINER,...) - error %#"
db "x",0h
align 04h
@CBE6 db "WinLoadMenu failed (last"
db " error %#x)",0h
@CBE7 db "popup menues %#x,%#x,%#x"
db 0h
align 04h
@CBE8 db "DoPopup: %lu records in "
db "use",0h
@CBE9 db "CM_ALLOCRECORD: %#x",0h
@CBE10 db "WinSendMsg(CM_INSERTRECO"
db "RD) failed - last error "
db "%#x",0h
@CBE11 db "DragInit: record %#x",0h
align 04h
@CBE12 db "DragInit: record passed "
db "checks",0h
align 04h
@CBE13 db "DRT_CUSTOMER",0h
align 04h
@CBE14 db "DRM_SHAREMEM,DRM_UNKNOWN"
db 0h
align 04h
@CBE15 db "DragLeave, record %#x",0h
align 04h
@CBE16 db "DragOver, record %#x",0h
align 04h
@CBE17 db "DragOver, no target",0h
@CBE18 db "DragOver, no destination"
db 0h
align 04h
@CBE19 db "DragOver, pRecord != pmr"
db "DragDestination!",0h
align 04h
@CBE20 db "DragOver, destination %#"
db "x",0h
align 04h
@CBE21 db "DragOver, source == dest"
db "ination!",0h
align 04h
@CBE22 db "DragOver, source too sma"
db "ll",0h
align 04h
@CBE23 db "DragOver, bad destinatio"
db "n",0h
align 04h
@CBE24 db "DragOver, bad destinatio"
db "n type",0h
align 04h
@CBE25 db "DragOver, destination is"
db " acceptable",0h
@CBE26 db "DragDrop, record %#x",0h
align 04h
@CBE27 db "DragDrop, can't use exte"
db "rnal data",0h
align 04h
@CBE28 db "This will destroy all da"
db "ta on the dropped device"
db " ID %02X%02X%02X%02X%02X"
db "%02X. Are you sure you "
db "want to do this?",0h
align 04h
@CBE29 db "Just curious...",0h
@CBE30 db "DragDrop: found as recor"
db "d %lu",0h
align 04h
@CBE31 db "WUM_START",0h
align 04h
@CBE32 db "_beginthread(DrvscanThre"
db "ad) failed - errno %u",0h
align 04h
@CBE33 db "WUM_DEVTREE",0h
@CBE34 db "WM_CONTROL",0h
align 04h
@CBE35 db "WM_CONTROL (id %#x, CN_C"
db "ONTEXTMENU)",0h
@CBE36 db "WM_CONTROL (id %#x, CN_E"
db "NTER)",0h
align 04h
@CBE37 db "Internal error, can't us"
db "e NULL device",0h
align 04h
@CBE38 db "Can't work on this devic"
db "e, remove parent first.",0h
@CBE39 db "Can't work on this devic"
db "e, create physdevice fir"
db "st.",0h
@CBE40 db "This device (or part of "
db "it) is in use by OS/2, r"
db "emove recognized filesys"
db "tems first.",0h
@CBE41 db "WinSendMsg(CM_SETRECORDE"
db "MPHASIS) failed - last e"
db "rror %#x)",0h
align 04h
@CBE42 db "WM_CONTROL (id %#x, CN_I"
db "NITDRAG)",0h
align 04h
@CBE43 db "WM_CONTROL (id %#x, CN_D"
db "RAGOVER)",0h
align 04h
@CBE44 db "WM_CONTROL (id %#x, CN_D"
db "RAGLEAVE)",0h
align 04h
@CBE45 db "WM_CONTROL (id %#x, CN_D"
db "ROP)",0h
align 04h
@CBE46 db "WM_CONTROL (id %#x, noti"
db "fy code %#x)",0h
align 04h
@CBE47 db "WM_CONTEXTMENU",0h
align 04h
@CBE48 db "WM_MENUEND",0h
align 04h
@CBE49 db "WM_COMMAND",0h
align 04h
@CBE50 db "WM_COMMAND, IDM_CREATE_P"
db "DEV",0h
@CBE51 db "WM_COMMAND, IDM_COMBINE_"
db "DRV",0h
@CBE52 db "%lu drives are ",022h,"in-use",022h,0h
@CBE53 db "WM_COMMAND, IDM_DESTROY_"
db "DRV",0h
@CBE54 db "Are you sure?",0h
align 04h
@CBE55 db "WM_COMMAND, IDM_DELETE_P"
db "DEV",0h
@CBE56 db "Are you sure you want to"
db " destroy ID %02X%02X%02X"
db "%02X%02X%02X?",0h
align 04h
@CBE57 db "WM_COMMAND, IDM_REMOVE_C"
db "HILD",0h
align 04h
@CBE58 db "Are you sure you want to"
db " remove ID %02X%02X%02X%"
db "02X%02X%02X from array?",0h
@CBE59 db "WM_COMMAND %u",0h
align 04h
@CBE60 db "WM_CREATE",0h
align 04h
@CBE61 db "DrvsetupWindow",0h
align 04h
@CBE62 db "WM_CLOSE",0h
align 04h
@CBE63 db "%lu drives are available"
db 0h
align 04h
@CBE64 db "WM_DESTROY",0h
align 04h
@CBE65 db "WM_SIZE",0h
@CBE66 db "Size",0h
align 04h
@CBE67 db "WM_MOVE",0h
@CBE68 db "Position",0h
align 04h
@CBE69 db "WM_QUERYTRACKINFO (track"
db "ing flags %#x)",0h
align 04h
@CBE70 db "WM_PRESPARAMCHANGED(type"
db " %#x)",0h
align 04h
@CBE71 db "WinQueryPresParam failed"
db " - last error %#x",0h
align 04h
@CBE72 db "Set foreground colour to"
db " %#x",0h
align 04h
@CBE73 db "Set background colour to"
db " %#x",0h
align 04h
@CBE74 db "Set font to ",022h,"%s",022h,0h
align 04h
@CBE75 db "Font",0h
align 04h
@CBE76 db "WM_PRESPARAMCHANGED(unsu"
db "pported type %#x)",0h
align 04h
@CBE77 db "startup",0h
@CBE78 db "WinInitialize failed!?!",0h
@CBE79 db "WinCreateMsgQueue - erro"
db "r %#x",0h
align 04h
@CBE80 db "WinRegisterClass - error"
db " %#x",0h
align 04h
@CBE81 db "VSetup - Drive Definitio"
db "n Window",0h
align 04h
@CBE82 db "WinCreateStdWindow - err"
db "or %#x",0h
align 04h
@CBE83 db "WinSetWindowPtr failed -"
db " error %#",0h
align 04h
@CBE84 db "Copying old size of wind"
db "ow",0h
align 04h
@CBE85 db "Copying old position of "
db "window",0h
align 04h
@CBE86 db "WinSetWindowPos failed ("
db "last error %#x)",0h
@CBE87 db "DrvSetupThread: stopped",0h
@1vcid db "$Id: drvsetup.cpp,v 2.9 "
db "2000/04/10 01:12:09 vitu"
db "s Exp $",0h
CONST32_RO ends
DATA32 segment
@2rgbBackground dd 0ffffff01h
@3rgbForeground dd 0ffffff01h
DATA32 ends
BSS32 segment
@bcregular dd 0h
BSS32 ends
EH_DATA segment
@11e__fsm_tab db 0adh,0deh,0efh,0beh
db 04h,0h,0h,0h
dd -010h
dd offset FLAT:__dl__FPv
db 0fdh,0ffh,0ffh,0ffh
db "0",0h,0h,0h
db 0h,0h
db 0h,0h
dd -014h
dd offset FLAT:__dl__FPv
db 0fdh,0ffh,0ffh,0ffh
db "0",01h,0h,0h
db 0h,0h
db 0h,0h
dd -018h
dd offset FLAT:__dl__FPv
db 0fdh,0ffh,0ffh,0ffh
db "0",01h,0h,0h
db 0h,0h
db 0h,0h
dd -01ch
dd offset FLAT:__dl__FPv
db 0fdh,0ffh,0ffh,0ffh
db "4",01h,0h,0h
db 0h,0h
db 0h,0h
EH_DATA ends
CODE32 segment
; 1524 DrvsetupThread(void *dummy)
public DrvsetupThread
DrvsetupThread proc
push ebp
; 1534 Verbose(2, "DrvSetup", "startup");
mov ecx,offset FLAT:@CBE77
; 1524 DrvsetupThread(void *dummy)
mov ebp,esp
push ebx
; 1534 Verbose(2, "DrvSetup", "startup");
mov ebx,offset FLAT:@CBE3
; 1524 DrvsetupThread(void *dummy)
push edi
mov edi,eax
push esi
; 1534 Verbose(2, "DrvSetup", "startup");
mov edx,ebx
; 1524 DrvsetupThread(void *dummy)
sub esp,08ch
; 1534 Verbose(2, "DrvSetup", "startup");
mov eax,02h
call Verbose
; 1537 work = new WORK;
mov eax,028h
call __nw__FUi
mov esi,eax
; 1538 memset(work, 0, sizeof(WORK));
mov ecx,028h
xor edx,edx
call memset
; 1541 if( !(work->hab = WinInitialize(0)) )
push 0h
; 1537 work = new WORK;
mov [ebp-010h],esi; work
; 1538 memset(work, 0, sizeof(WORK));
mov eax,edi
; 1539 work->self = dta;
mov [esi],eax
; 1541 if( !(work->hab = WinInitialize(0)) )
call WinInitialize
add esp,04h
mov [esi+04h],eax
cmp dword ptr [esi+04h],0h
mov edx,ebx
jne @BLBL130
; 1543 Verbose(0, "DrvSetup", "WinInitialize failed!?!");
xor eax,eax
mov ecx,offset FLAT:@CBE78
call Verbose
; 1544 break;
jmp @BLBL131
@BLBL130:
; 1547 if( !(hmq = WinCreateMsgQueue(work->hab, 0)) )
mov ebx,[ebp-010h]; work
push 0h
push dword ptr [ebx+04h]
call WinCreateMsgQueue
add esp,08h
mov [ebp-01ch],eax; hmq
test eax,eax
jne @BLBL132
; 1549 Verbose(0, "DrvSetup", "WinCreateMsgQueue - error %#x",
push dword ptr [ebx+04h]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE79
sub esp,0ch
mov edx,offset FLAT:@CBE3
xor eax,eax
call Verbose
add esp,014h
; 1551 break;
jmp @BLBL131
@BLBL132:
; 1553 WinCancelShutdown(hmq, TRUE); /* don't want to handle it */
push 01h
; 1555 if( !WinRegisterClass(work->hab, WC_DRVSETUP, DrvsetupWindowProc,
mov ebx,[ebp-010h]; work
; 1553 WinCancelShutdown(hmq, TRUE); /* don't want to handle it */
push dword ptr [ebp-01ch]; hmq
call WinCancelShutdown
; 1555 if( !WinRegisterClass(work->hab, WC_DRVSETUP, DrvsetupWindowProc,
push 04h
push 01h
push offset FLAT: DrvsetupWindowProc
push offset FLAT:@CBE61
push dword ptr [ebx+04h]
call WinRegisterClass
add esp,01ch
test eax,eax
jne @BLBL133
; 1558 Verbose(0, "DrvSetup", "WinRegisterClass - error %#x",
push dword ptr [ebx+04h]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE80
sub esp,0ch
mov edx,offset FLAT:@CBE3
xor eax,eax
call Verbose
add esp,014h
; 1560 break;
jmp @BLBL131
@BLBL133:
; 1566 hwndFrame = WinCreateStdWindow(HWND_DESKTOP, WS_ANIMATE, &flCreate,
lea ebx,[ebp-014h]; hwndClient
push ebx
lea ebx,[ebp-020h]; flCreate
push 0190h
; 1563 flCreate = FCF_SIZEBORDER | FCF_TASKLIST | FCF_SYSMENU | FCF_TITLEBAR
mov dword ptr [ebp-020h],0483bh; flCreate
; 1566 hwndFrame = WinCreateStdWindow(HWND_DESKTOP, WS_ANIMATE, &flCreate,
push 0h
push 0h
push offset FLAT:@CBE81
push offset FLAT:@CBE61
push ebx
push 0400000h
push 01h
call WinCreateStdWindow
add esp,024h
mov [ebp-024h],eax; hwndFrame
; 1572 if( hwndFrame == 0 || hwndClient == 0 )
test eax,eax
je @BLBL134
cmp dword ptr [ebp-014h],0h; hwndClient
jne @BLBL135
@BLBL134:
; 1574 Verbose(0, "DrvSetup", "WinCreateStdWindow - error %#x",
mov ebx,[ebp-010h]; work
push dword ptr [ebx+04h]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE82
sub esp,0ch
mov edx,offset FLAT:@CBE3
xor eax,eax
call Verbose
add esp,014h
; 1576 break; /* couldn't create window for some
jmp @BLBL131
@BLBL135:
; 1582 bool = WinSetWindowPtr(hwndClient, 0, work);
mov ebx,[ebp-010h]; work
push ebx
push 0h
push dword ptr [ebp-014h]; hwndClient
call WinSetWindowPtr
add esp,0ch
; 1583 if( bool == FALSE )
test eax,eax
jne @BLBL136
; 1585 MyMessageBox(0, HWND_DESKTOP,
push dword ptr [ebx+04h]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE83
sub esp,0ch
mov edx,01h
xor eax,eax
call MyMessageBox__FCiCUlPce
add esp,014h
; 1588 break;
jmp @BLBL131
@BLBL136:
; 1591 WinPostMsg(hwndClient, WUM_START, 0, 0);
push 0h
; 1603 WinQueryTaskSizePos(work->hab, 0, &swp);
lea ebx,[ebp-048h]; swp
; 1591 WinPostMsg(hwndClient, WUM_START, 0, 0);
push 0h
push 01002h
push dword ptr [ebp-014h]; hwndClient
call WinPostMsg
; 1603 WinQueryTaskSizePos(work->hab, 0, &swp);
push ebx
mov ebx,[ebp-010h]; work
push 0h
push dword ptr [ebx+04h]
; 1606 if( ProfileRead(WC_DRVSETUP, "Size", &cb, &tmp) == 0 )
lea ebx,[ebp-06ch]; tmp
; 1603 WinQueryTaskSizePos(work->hab, 0, &swp);
call WinQueryTaskSizePos
; 1606 if( ProfileRead(WC_DRVSETUP, "Size", &cb, &tmp) == 0 )
push ebx
; 1605 cb = sizeof(tmp);
mov dword ptr [ebp-018h],024h; cb
; 1606 if( ProfileRead(WC_DRVSETUP, "Size", &cb, &tmp) == 0 )
sub esp,0ch
lea ecx,[ebp-018h]; cb
mov edx,offset FLAT:@CBE66
mov eax,offset FLAT:@CBE61
call ProfileRead
add esp,02ch
test eax,eax
jne @BLBL137
; 1608 Verbose(3, "DrvSetup", "Copying old size of window");
mov ecx,offset FLAT:@CBE84
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
; 1609 swp.cx = tmp.cx;
mov eax,[ebp-064h]; tmp
mov [ebp-040h],eax; swp
; 1610 swp.cy = tmp.cy;
mov eax,[ebp-068h]; tmp
; 1611 swp.fl |= SWP_SIZE;
or byte ptr [ebp-048h],01h; swp
; 1610 swp.cy = tmp.cy;
mov [ebp-044h],eax; swp
; 1612 }
@BLBL137:
; 1614 if( ProfileRead(WC_DRVSETUP, "Position", &cb, &tmp) == 0 )
lea ebx,[ebp-06ch]; tmp
push ebx
; 1613 cb = sizeof(tmp);
mov dword ptr [ebp-018h],024h; cb
; 1614 if( ProfileRead(WC_DRVSETUP, "Position", &cb, &tmp) == 0 )
sub esp,0ch
lea ecx,[ebp-018h]; cb
mov edx,offset FLAT:@CBE68
mov eax,offset FLAT:@CBE61
call ProfileRead
add esp,010h
test eax,eax
jne @BLBL138
; 1616 Verbose(3, "DrvSetup", "Copying old position of window");
mov ecx,offset FLAT:@CBE85
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
; 1617 swp.x = tmp.x;
mov eax,[ebp-05ch]; tmp
mov [ebp-038h],eax; swp
; 1618 swp.y = tmp.y;
mov eax,[ebp-060h]; tmp
; 1619 swp.fl |= SWP_MOVE;
or byte ptr [ebp-048h],02h; swp
; 1618 swp.y = tmp.y;
mov [ebp-03ch],eax; swp
; 1620 }
@BLBL138:
; 1622 swp.fl |= SWP_SHOW;
mov ebx,[ebp-048h]; swp
or bl,08h
; 1623 bool = WinSetWindowPos(hwndFrame, HWND_TOP,
push ebx
; 1622 swp.fl |= SWP_SHOW;
mov [ebp-048h],ebx; swp
; 1623 bool = WinSetWindowPos(hwndFrame, HWND_TOP,
push dword ptr [ebp-044h]; swp
push dword ptr [ebp-040h]; swp
push dword ptr [ebp-03ch]; swp
push dword ptr [ebp-038h]; swp
push 03h
push dword ptr [ebp-024h]; hwndFrame
call WinSetWindowPos
add esp,01ch
; 1625 if( bool == FALSE )
test eax,eax
jne @BLBL139
; 1626 Verbose(1, "DrvSetup", "WinSetWindowPos failed (last error %#x)",
mov ebx,[ebp-010h]; work
push dword ptr [ebx+04h]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE86
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,01h
call Verbose
add esp,014h
; 1627 WinGetLastError(work->hab));
@BLBL139:
; 1632 while( WinGetMsg(work->hab, &qmsg, 0L, 0, 0) )
push 0h
lea ecx,[ebp-08ch]; qmsg
push 0h
mov ebx,[ebp-010h]; work
push 0h
push ecx
push dword ptr [ebx+04h]
call WinGetMsg
add esp,014h
test eax,eax
je @BLBL140
mov edi,ebx
@BLBL141:
; 1633 WinDispatchMsg(work->hab, &qmsg);
lea ebx,[ebp-08ch]; qmsg
push ebx
push dword ptr [edi+04h]
call WinDispatchMsg
; 1632 while( WinGetMsg(work->hab, &qmsg, 0L, 0, 0) )
push 0h
push 0h
push 0h
push ebx
push dword ptr [edi+04h]
call WinGetMsg
add esp,01ch
test eax,eax
jne @BLBL141
@BLBL140:
; 1637 WinDestroyWindow(hwndFrame);
push dword ptr [ebp-024h]; hwndFrame
; 1639 WinTerminate(work->hab);
mov esi,[ebp-010h]; work
; 1637 WinDestroyWindow(hwndFrame);
call WinDestroyWindow
; 1638 WinDestroyMsgQueue(hmq);
push dword ptr [ebp-01ch]; hmq
call WinDestroyMsgQueue
; 1639 WinTerminate(work->hab);
push dword ptr [esi+04h]
call WinTerminate
mov eax,esi
; 1640 delete work;
call __dl__FPv
add esp,0ch
; 1642 while(0);
@BLBL131:
; 1644 Verbose(2, "DrvSetup", "DrvSetupThread: stopped");
mov ecx,offset FLAT:@CBE87
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
; 1645 return;
add esp,08ch
pop esi
pop edi
pop ebx
pop ebp
ret
DrvsetupThread endp
; 888 DrvsetupWindowProc(HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
DrvsetupWindowProc proc
push ebp
mov ebp,esp
push offset FLAT: _Exception_CPP
push fs:[0h]
mov fs:[0h],esp
push 0fffffefch
sub esp,045ch
; 889 {
mov dword ptr [ebp-0104h],0h; __es
; 888 DrvsetupWindowProc(HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
push ebx
; 889 {
mov dword ptr [ebp-0fch],offset FLAT:@11e__fsm_tab; __es
; 888 DrvsetupWindowProc(HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
push edi
push esi
; 891 WORK * const work = (PWORK)WinQueryWindowPtr(hwnd, 0);
push 0h
push dword ptr [ebp+08h]; hwnd
call WinQueryWindowPtr
; 894 switch( msg )
mov ecx,[ebp+0ch]; msg
; 891 WORK * const work = (PWORK)WinQueryWindowPtr(hwnd, 0);
add esp,08h
mov [ebp-020h],eax; work
; 894 switch( msg )
cmp ecx,02fh
jl @BLBL162
je @BLBL160
cmp ecx,04fh
jl @BLBL163
je @BLBL161
cmp ecx,0424h
je @BLBL151
cmp ecx,01002h
je @BLBL148
cmp ecx,0100ah
je @BLBL149
jmp @BLBL147
@BLBL163:
cmp ecx,030h
je @BLBL150
cmp ecx,035h
je @BLBL152
cmp ecx,04ch
je @BLBL159
jmp @BLBL147
@BLBL162:
cmp ecx,06h
jl @BLBL164
je @BLBL158
cmp ecx,07h
je @BLBL157
cmp ecx,020h
je @BLBL153
cmp ecx,029h
je @BLBL155
jmp @BLBL147
@BLBL164:
cmp ecx,01h
je @BLBL154
cmp ecx,02h
je @BLBL156
jmp @BLBL147
@BLBL148:
; 904 CreateCnr(hwnd, work);
mov edi,[ebp+08h]; hwnd
; 903 Verbose(3, "DrvSetup", "WUM_START");
sub esp,0ch
mov ebx,offset FLAT:@CBE3
mov ecx,offset FLAT:@CBE31
mov edx,ebx
mov eax,03h
call Verbose
add esp,04h
; 904 CreateCnr(hwnd, work);
mov edx,[ebp-020h]; work
mov eax,edi
call CreateCnr__FUlP5_WORK
add esp,04h
; 907 PTHR_DRVSCAN dta = new THR_DRVSCAN;
mov eax,04h
call __nw__FUi
add esp,04h
; 909 dta->parent = hwnd;
mov [eax],edi
; 910 tid = _beginthread(DrvscanThread, NULL, STACK_SIZE, dta);
push eax
mov ecx,0100000h
sub esp,0ch
xor edx,edx
mov eax,offset FLAT: DrvscanThread
call _beginthread
add esp,010h
; 911 if( tid == -1 )
cmp eax,0ffffffffh
jne @BLBL75
; 912 Verbose(1, "DrvSetup",
call _errno
mov edx,ebx
push dword ptr [eax]
mov ecx,offset FLAT:@CBE32
sub esp,0ch
mov eax,01h
call Verbose
add esp,010h
; 913 "_beginthread(DrvscanThread) failed - errno %u", errno);
@BLBL75:
; 916 return 0;
pop esi
; 915 regular = TRUE;
mov dword ptr @bcregular,01h
; 916 return 0;
pop edi
xor eax,eax
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL149:
; 920 Verbose(3, "DrvSetup", "WUM_DEVTREE");
sub esp,0ch
mov ecx,offset FLAT:@CBE33
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
; 921 work->hwndScanner = HWNDFROMMP(mp2);
mov eax,[ebp-020h]; work
mov ecx,[ebp+014h]; mp2
mov [eax+0ch],ecx
; 922 DisplayDisk(work, NULL, (VRDev *)PVOIDFROMMP(mp1));
mov ecx,[ebp+010h]; mp1
xor edx,edx
call DisplayDisk__FP5_WORKP9_MYRECORDP5VRDev
add esp,0ch
; 923 return 0;
xor eax,eax
pop esi
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL150:
; 931 Verbose(3, "DrvSetup", "WM_CONTROL");
sub esp,0ch
mov ecx,offset FLAT:@CBE34
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
; 933 USHORT const id = SHORT1FROMMP(mp1);
mov eax,[ebp+010h]; mp1
; 931 Verbose(3, "DrvSetup", "WM_CONTROL");
add esp,0ch
; 933 USHORT const id = SHORT1FROMMP(mp1);
mov [ebp-02ah],ax; id
; 934 USHORT const ncode = SHORT2FROMMP(mp1);
shr eax,010h
mov [ebp-066h],ax; ncode
; 937 switch( ncode )
movzx eax,ax
cmp eax,068h
jl @BLBL172
je @BLBL170
cmp eax,06ah
je @BLBL166
cmp eax,06bh
je @BLBL167
cmp eax,077h
je @BLBL165
jmp @BLBL171
@BLBL172:
cmp eax,066h
je @BLBL169
cmp eax,067h
je @BLBL168
jmp @BLBL171
@BLBL165:
; 944 Verbose(3, "DrvSetup", "WM_CONTROL (id %#x, CN_CONTEXTMENU)", id);
mov ecx,offset FLAT:@CBE35
movzx ebx,word ptr [ebp-02ah]; id
push ebx
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,03h
call Verbose
add esp,08h
; 945 DoPopup(hwnd, work);
mov edx,[ebp-020h]; work
mov eax,[ebp+08h]; hwnd
call DoPopup__FUlCP5_WORK
add esp,08h
; 946 break;
jmp @BLBL147
@BLBL166:
; 949 Verbose(3, "DrvSetup", "WM_CONTROL (id %#x, CN_ENTER)",id);
mov ecx,offset FLAT:@CBE36
movzx ebx,word ptr [ebp-02ah]; id
push ebx
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,03h
call Verbose
; 951 PNOTIFYRECORDENTER rec = (PNOTIFYRECORDENTER)PVOIDFROMMP(mp2);
mov ebx,[ebp+014h]; mp2
; 949 Verbose(3, "DrvSetup", "WM_CONTROL (id %#x, CN_ENTER)",id);
add esp,010h
; 951 PNOTIFYRECORDENTER rec = (PNOTIFYRECORDENTER)PVOIDFROMMP(mp2);
mov [ebp-03ch],ebx; rec
; 953 if( rec == NULL )
test ebx,ebx
jne @BLBL76
; 954 return 0; /* dblk click on background? */
pop esi
xor eax,eax
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL76:
; 956 VRDev * dsk = ((PMYRECORD)(rec->pRecord))->dsk;
mov eax,[ebp-03ch]; rec
mov eax,[eax+08h]
mov eax,[eax+01ch]
mov [ebp-038h],eax; dsk
; 957 if( dsk == NULL )
test eax,eax
jne @BLBL77
; 958 MyMessageBox(0, hwnd,
mov edx,[ebp+08h]; hwnd
sub esp,0ch
mov ecx,offset FLAT:@CBE37
xor eax,eax
call MyMessageBox__FCiCUlPce
add esp,0ch
; 959 "Internal error, can't use NULL device");
jmp @BLBL78
@BLBL77:
; 960 else if( dsk->getParent() != NULL )
mov eax,[ebp-038h]; dsk
cmp dword ptr [eax+04h],0h
je @BLBL79
; 961 MyMessageBox(1, hwnd,
mov edx,[ebp+08h]; hwnd
sub esp,0ch
mov ecx,offset FLAT:@CBE38
mov eax,01h
call MyMessageBox__FCiCUlPce
add esp,0ch
; 963 " remove parent first.");
jmp @BLBL78
@BLBL79:
; 964 else if( dsk->isHostdrive() && dsk->isArray() == 0 )
sub esp,04h
mov edi,[ebp-038h]; dsk
mov ecx,[edi]
mov eax,[ecx+06ch]
add eax,edi
call dword ptr [ecx+068h]
add esp,04h
test al,al
mov eax,edi
je @BLBL81
mov ecx,[eax]
sub esp,04h
mov edx,[ecx+064h]
add eax,edx
call dword ptr [ecx+060h]
add esp,04h
test al,al
jne @BLBL81
; 965 MyMessageBox(1, hwnd,
mov edx,[ebp+08h]; hwnd
sub esp,0ch
mov ecx,offset FLAT:@CBE39
mov eax,01h
call MyMessageBox__FCiCUlPce
add esp,0ch
; 967 " create physdevice first.");
jmp @BLBL78
@BLBL81:
; 968 else if( !dsk->isWritable() )
sub esp,04h
mov eax,[ebp-038h]; dsk
mov ebx,[eax]
mov ecx,[ebx+0ch]
add eax,ecx
call dword ptr [ebx+08h]
add esp,04h
test al,al
jne @BLBL83
; 969 MyMessageBox(1, hwnd,
mov edx,[ebp+08h]; hwnd
sub esp,0ch
mov ecx,offset FLAT:@CBE40
mov eax,01h
call MyMessageBox__FCiCUlPce
add esp,0ch
; 972 " first.");
jmp @BLBL78
@BLBL83:
; 975 bool = (BOOL)WinSendMsg(rec->hwndCnr,
mov ebx,[ebp-03ch]; rec
push 080001h
push dword ptr [ebx+08h]
push 034ah
push dword ptr [ebx]
call WinSendMsg
add esp,010h
mov [ebp-024h],eax; bool
; 979 if( bool == FALSE )
test eax,eax
jne @BLBL78
; 980 Verbose(1, "DrvSetup",
mov ebx,[ebp-020h]; work
push dword ptr [ebx+04h]
call WinGetLastError
add esp,04h
mov ecx,offset FLAT:@CBE41
push eax
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,01h
call Verbose
add esp,010h
; 984 }
@BLBL78:
; 986 return 0;
pop esi
xor eax,eax
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL167:
; 990 Verbose(3, "DrvSetup", "WM_CONTROL (id %#x, CN_INITDRAG)", id);
mov ecx,offset FLAT:@CBE42
movzx ebx,word ptr [ebp-02ah]; id
push ebx
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,03h
call Verbose
add esp,04h
; 991 return DragInit(hwnd, work,(PCNRDRAGINIT)PVOIDFROMMP(mp2));
mov ecx,[ebp+014h]; mp2
mov edx,[ebp-020h]; work
mov eax,[ebp+08h]; hwnd
call DragInit__FUlCP5_WORKCP12_CNRDRAGINIT
add esp,0ch
pop esi
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL168:
; 994 Verbose(3, "DrvSetup", "WM_CONTROL (id %#x, CN_DRAGOVER)", id);
mov ecx,offset FLAT:@CBE43
movzx ebx,word ptr [ebp-02ah]; id
push ebx
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,03h
call Verbose
add esp,04h
; 995 return DragOver(hwnd, work, (PCNRDRAGINFO)PVOIDFROMMP(mp2));
mov ecx,[ebp+014h]; mp2
mov edx,[ebp-020h]; work
mov eax,[ebp+08h]; hwnd
call DragOver__FUlCP5_WORKP12_CNRDRAGINFO
add esp,0ch
pop esi
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL169:
; 998 Verbose(3, "DrvSetup", "WM_CONTROL (id %#x, CN_DRAGLEAVE)", id);
mov ecx,offset FLAT:@CBE44
movzx ebx,word ptr [ebp-02ah]; id
push ebx
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,03h
call Verbose
add esp,04h
; 999 return DragLeave(hwnd, work, (PCNRDRAGINFO)PVOIDFROMMP(mp2));
mov ecx,[ebp+014h]; mp2
mov edx,[ebp-020h]; work
mov eax,[ebp+08h]; hwnd
call DragLeave__FUlCP5_WORKP12_CNRDRAGINFO
add esp,0ch
pop esi
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL170:
; 1002 Verbose(3, "DrvSetup", "WM_CONTROL (id %#x, CN_DROP)", id);
mov ecx,offset FLAT:@CBE45
movzx ebx,word ptr [ebp-02ah]; id
push ebx
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,03h
call Verbose
add esp,04h
; 1003 return DragDrop(hwnd, work, (PCNRDRAGINFO)PVOIDFROMMP(mp2));
mov ecx,[ebp+014h]; mp2
mov edx,[ebp-020h]; work
mov eax,[ebp+08h]; hwnd
call DragDrop__FUlCP5_WORKP12_CNRDRAGINFO
add esp,0ch
pop esi
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL171:
; 1006 Verbose(3, "DrvSetup", "WM_CONTROL (id %#x, notify code %#x)",
mov ecx,offset FLAT:@CBE46
movzx eax,word ptr [ebp-066h]; ncode
push eax
movzx eax,word ptr [ebp-02ah]; id
push eax
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,03h
call Verbose
add esp,014h
; 1011 break;
jmp @BLBL147
@BLBL151:
; 1018 Verbose(3, "DrvSetup", "WM_CONTEXTMENU");
sub esp,0ch
mov ecx,offset FLAT:@CBE47
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,04h
; 1019 DoPopup(hwnd, work);
mov edx,[ebp-020h]; work
mov eax,[ebp+08h]; hwnd
call DoPopup__FUlCP5_WORK
add esp,08h
; 1020 break;
jmp @BLBL147
@BLBL152:
; 1029 Verbose(3, "DrvSetup", "WM_MENUEND");
sub esp,0ch
mov ecx,offset FLAT:@CBE48
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,0ch
; 1030 if( work->pmrMenu == NULL )
mov ebx,[ebp-020h]; work
cmp dword ptr [ebx+01ch],0h
jne @BLBL86
; 1032 WinSendMsg(work->hwndCnr, CM_SETRECORDEMPHASIS,
push 040000000h
push 0h
push 034ah
push dword ptr [ebx+08h]
call WinSendMsg
add esp,010h
; 1034 }
jmp @BLBL87
@BLBL86:
; 1043 SearchCnr(work->hwndCnr, (PFNSRCH)EmphSource, &bool, &dummy, NULL);
push 0h
lea ebx,[ebp-040h]; dummy
push ebx
; 1041 bool = FALSE;
mov dword ptr [ebp-024h],0h; bool
; 1042 dummy = 0;
mov dword ptr [ebp-040h],0h; dummy
; 1043 SearchCnr(work->hwndCnr, (PFNSRCH)EmphSource, &bool, &dummy, NULL);
sub esp,0ch
mov eax,[ebp-020h]; work
lea ecx,[ebp-024h]; bool
mov eax,[eax+08h]
mov edx,offset FLAT: EmphSource__FUlP9_MYRECORDPUlT3
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
add esp,014h
; 1044 }
@BLBL87:
; 1045 break;
jmp @BLBL147
@BLBL153:
; 1053 Verbose(3, "DrvSetup", "WM_COMMAND");
sub esp,0ch
mov ecx,offset FLAT:@CBE49
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
; 1055 USHORT const cmd = SHORT1FROMMP(mp1);
mov eax,[ebp+010h]; mp1
; 1053 Verbose(3, "DrvSetup", "WM_COMMAND");
add esp,0ch
; 1055 USHORT const cmd = SHORT1FROMMP(mp1);
mov [ebp-068h],ax; cmd
; 1058 switch( cmd )
movzx eax,ax
cmp eax,01bah
jl @BLBL180
je @BLBL176
cmp eax,01bbh
je @BLBL178
cmp eax,01bch
je @BLBL175
cmp eax,01bdh
je @BLBL174
jmp @BLBL179
@BLBL180:
cmp eax,01b8h
je @BLBL173
cmp eax,01b9h
je @BLBL177
jmp @BLBL179
@BLBL173:
; 1061 Verbose(3, "DrvSetup", "WM_COMMAND, IDM_CREATE_PDEV");
sub esp,0ch
mov ecx,offset FLAT:@CBE50
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,0ch
; 1063 PMINIRECORDCORE ap[1] = {(PMINIRECORDCORE)work->pmrMenu};
mov ebx,[ebp-020h]; work
; 1067 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
push 030001h
; 1063 PMINIRECORDCORE ap[1] = {(PMINIRECORDCORE)work->pmrMenu};
mov ecx,[ebx+01ch]
mov [ebp-044h],ecx; ap
; 1067 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
lea ecx,[ebp-044h]; ap
push ecx
push 0346h
push dword ptr [ebx+08h]
call WinSendMsg
add esp,010h
; 1073 WinPostMsg(work->hwndScanner, WUM_MKPDEV,
mov ecx,[ebx+01ch]
push 0h
push dword ptr [ecx+01ch]
push 0100dh
push dword ptr [ebx+0ch]
call WinPostMsg
add esp,010h
; 1076 return 0;
xor eax,eax
pop esi
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL174:
; 1081 Verbose(3, "DrvSetup", "WM_COMMAND, IDM_COMBINE_DRV");
sub esp,0ch
mov ebx,offset FLAT:@CBE3
mov ecx,offset FLAT:@CBE51
mov edx,ebx
mov eax,03h
call Verbose
add esp,0ch
; 1089 SearchCnr(work->hwndCnr, (PFNSRCH)QueryInuse,
lea eax,[ebp-0e8h]; info
push 0h
; 1088 info.cnt = 0;
mov dword ptr [ebp-0ech],0h; info
; 1089 SearchCnr(work->hwndCnr, (PFNSRCH)QueryInuse,
push eax
lea ecx,[ebp-0ech]; info
sub esp,0ch
mov eax,[ebp-020h]; work
mov edx,offset FLAT: QueryInuse__FUlP9_MYRECORDPUlPP9_MYRECORD
mov eax,[eax+08h]
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
add esp,014h
mov edx,ebx
; 1091 Verbose(2, "DrvSetup", "%lu drives are \"in-use\"",info.cnt);
push dword ptr [ebp-0ech]; info
mov ecx,offset FLAT:@CBE52
sub esp,0ch
mov eax,02h
call Verbose
add esp,010h
; 1095 ul = WinDlgBox(HWND_DESKTOP, hwnd, DrvtypeDlgProc,
lea eax,[ebp-0f0h]; info
push eax
push 02bch
push 0h
push offset FLAT: DrvtypeDlgProc
push dword ptr [ebp+08h]; hwnd
push 01h
call WinDlgBox
add esp,018h
; 1097 if( DID_OK == ul )
cmp eax,01h
jne @BLBL88
; 1107 memcpy(&newid[0], &usHostId, sizeof(usHostId));
lea eax,[ebp-030h]; newid
sub esp,0ch
mov ecx,02h
mov edx,offset FLAT:usHostId
call memcpy
add esp,08h
; 1108 *(PULONG)&newid[2] = time(NULL);
xor eax,eax
call time
add esp,04h
; 1110 switch( info.type )
mov ebx,[ebp-0f0h]; info
; 1108 *(PULONG)&newid[2] = time(NULL);
mov [ebp-02eh],eax; newid
; 1110 switch( info.type )
cmp ebx,02h
jl @BLBL186
je @BLBL183
cmp ebx,03h
je @BLBL184
cmp ebx,04h
je @BLBL185
jmp @BLBL181
@BLBL186:
cmp ebx,01h
jne @BLBL181
@BLBL182:
; 1113 drv = new VSingle(newid);
sub esp,04h
mov eax,030h
call __nw__FUi
add esp,04h
mov [ebp-010h],eax; __66
test eax,eax
je @BLBL90
lea edx,[ebp-030h]; newid
sub esp,08h
mov dword ptr [ebp-0104h],01h; __es
call __ct__7VSingleFPUc
add esp,08h
mov dword ptr [ebp-0104h],0h; __es
@BLBL90:
mov eax,[ebp-010h]; __66
mov [ebp-034h],eax; drv
; 1114 break;
jmp @BLBL181
@BLBL183:
; 1116 drv = new VChain(newid, (int)info.cnt);
sub esp,04h
mov eax,0130h
call __nw__FUi
add esp,04h
mov [ebp-014h],eax; __67
test eax,eax
je @BLBL92
lea edx,[ebp-030h]; newid
sub esp,0ch
mov ecx,[ebp-0ech]; info
mov dword ptr [ebp-0104h],02h; __es
call __ct__6VChainFPUci
add esp,0ch
mov dword ptr [ebp-0104h],0h; __es
@BLBL92:
mov eax,[ebp-014h]; __67
mov [ebp-034h],eax; drv
; 1117 break;
jmp @BLBL181
@BLBL184:
; 1119 drv = new VStripe(newid, (int)info.cnt);
sub esp,04h
mov eax,0130h
call __nw__FUi
add esp,04h
mov [ebp-018h],eax; __68
test eax,eax
je @BLBL94
lea edx,[ebp-030h]; newid
sub esp,0ch
mov ecx,[ebp-0ech]; info
mov dword ptr [ebp-0104h],03h; __es
call __ct__7VStripeFPUci
add esp,0ch
mov dword ptr [ebp-0104h],0h; __es
@BLBL94:
mov eax,[ebp-018h]; __68
mov [ebp-034h],eax; drv
; 1120 break;
jmp @BLBL181
@BLBL185:
; 1122 drv = new VMirror(newid, (int)info.cnt);
sub esp,04h
mov eax,0134h
call __nw__FUi
add esp,04h
mov [ebp-01ch],eax; __69
test eax,eax
je @BLBL96
lea edx,[ebp-030h]; newid
sub esp,0ch
mov ecx,[ebp-0ech]; info
mov dword ptr [ebp-0104h],04h; __es
call __ct__7VMirrorFPUci
add esp,0ch
mov dword ptr [ebp-0104h],0h; __es
@BLBL96:
mov eax,[ebp-01ch]; __69
mov [ebp-034h],eax; drv
; 1123 break;
@BLBL181:
; 1130 for( ul = 0; ul < info.cnt; ++ul )
cmp dword ptr [ebp-0ech],0h; info
jbe @BLBL97
mov ebx,[ebp-034h]; drv
mov esi,[ebp-020h]; work
xor edi,edi
@BLBL98:
; 1135 drv->addChild(info.child[ul]->dsk, False, Tru
; 1135 e);
push 01h
; 1132 PMINIRECORDCORE ap[1]
lea eax,dword ptr [ebp+edi*04h-0f0h]
; 1135 drv->addChild(info.child[ul]->dsk, False, Tru
; 1135 e);
sub esp,0ch
; 1132 PMINIRECORDCORE ap[1]
mov edx,[eax+08h]
mov [ebp-0468h],eax; @CBE89
mov [ebp-048h],edx; ap
; 1135 drv->addChild(info.child[ul]->dsk, False, Tru
; 1135 e);
mov esi,[ebx]
mov edx,[edx+01ch]
mov eax,[esi+08ch]
xor ecx,ecx
add eax,ebx
call dword ptr [esi+088h]
mov eax,[ebp-0468h]; @CBE89
mov esi,[ebp-020h]; work
; 1136 if( !info.child[ul]->dsk->isWritable() )
mov eax,[eax+08h]
; 1135 drv->addChild(info.child[ul]->dsk, False, Tru
; 1135 e);
add esp,0ch
; 1136 if( !info.child[ul]->dsk->isWritable() )
mov eax,[eax+01ch]
mov ecx,[eax]
mov edx,[ecx+0ch]
add eax,edx
call dword ptr [ecx+08h]
add esp,04h
test al,al
jne @BLBL99
; 1137 drv->forceUnwritable();
mov ecx,[ebx]
sub esp,04h
mov eax,[ecx+034h]
add eax,ebx
call dword ptr [ecx+030h]
add esp,04h
@BLBL99:
; 1141 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
push 030001h
lea eax,[ebp-048h]; ap
push eax
; 1130 for( ul = 0; ul < info.cnt; ++ul )
inc edi
; 1141 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
push 0346h
push dword ptr [esi+08h]
call WinSendMsg
add esp,010h
; 1130 for( ul = 0; ul < info.cnt; ++ul )
cmp [ebp-0ech],edi; info
ja @BLBL98
@BLBL97:
; 1145 WinPostMsg(work->hwndScanner, WUM_DEVTREE, drv, NULL);
push 0h
mov ebx,[ebp-020h]; work
push dword ptr [ebp-034h]; drv
push 0100ah
push dword ptr [ebx+0ch]
call WinPostMsg
add esp,010h
; 1146 }
jmp @BLBL103
@BLBL88:
; 1151 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
push 0h
lea ebx,[ebp-028h]; dummy
push ebx
; 1149 bool = FALSE;
mov dword ptr [ebp-024h],0h; bool
; 1150 dummy = 0;
mov dword ptr [ebp-028h],0h; dummy
; 1151 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
sub esp,0ch
mov eax,[ebp-020h]; work
lea ecx,[ebp-024h]; bool
mov eax,[eax+08h]
mov edx,offset FLAT: EmphInuse__FUlP9_MYRECORDPUlT3
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
add esp,014h
; 1152 }
@BLBL103:
; 1154 return 0;
pop esi
xor eax,eax
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL175:
; 1162 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
push 0h
lea ebx,[ebp-028h]; dummy
push ebx
; 1160 bool = FALSE;
mov dword ptr [ebp-024h],0h; bool
; 1161 dummy = 0;
mov dword ptr [ebp-028h],0h; dummy
; 1162 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
sub esp,0ch
mov eax,[ebp-020h]; work
lea ecx,[ebp-024h]; bool
mov eax,[eax+08h]
mov edx,offset FLAT: EmphInuse__FUlP9_MYRECORDPUlT3
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
add esp,014h
; 1163 return 0;
xor eax,eax
pop esi
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL176:
; 1170 Verbose(3, "DrvSetup", "WM_COMMAND, IDM_DESTROY_DRV");
sub esp,0ch
mov ecx,offset FLAT:@CBE53
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,0ch
; 1176 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
lea ecx,[ebp-028h]; dummy
push 0h
; 1174 bool = FALSE;
mov dword ptr [ebp-024h],0h; bool
; 1176 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
push ecx
; 1175 dummy = 0;
mov dword ptr [ebp-028h],0h; dummy
; 1176 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
sub esp,0ch
mov ebx,[ebp-020h]; work
lea ecx,[ebp-024h]; bool
mov eax,[ebx+08h]
mov edx,offset FLAT: EmphInuse__FUlP9_MYRECORDPUlT3
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
add esp,014h
; 1181 VRDrive * drv = (VRDrive *)work->pmrMenu->dsk; /* !!! */
mov edi,[ebx+01ch]
; 1184 response = WinMessageBox(HWND_DESKTOP, hwnd,
push 04014h
; 1181 VRDrive * drv = (VRDrive *)work->pmrMenu->dsk; /* !!! */
mov edi,[edi+01ch]
; 1184 response = WinMessageBox(HWND_DESKTOP, hwnd,
push 0ffffffffh
push offset FLAT:@CBE29
push offset FLAT:@CBE54
push dword ptr [ebp+08h]; hwnd
push 01h
call WinMessageBox
add esp,018h
; 1187 if( response == MBID_YES )
cmp eax,06h
jne @BLBL104
; 1193 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
push 030001h
; 1189 PMINIRECORDCORE ap[1] = {(PMINIRECORDCORE)work->pmrMenu};
mov ecx,[ebx+01ch]
mov [ebp-04ch],ecx; ap
; 1193 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
lea ecx,[ebp-04ch]; ap
push ecx
push 0346h
push dword ptr [ebx+08h]
call WinSendMsg
add esp,010h
; 1200 WinPostMsg(work->hwndScanner, WUM_DELDRV, drv, NULL);
push 0h
push edi
push 0100ch
push dword ptr [ebx+0ch]
call WinPostMsg
add esp,010h
; 1201 }
@BLBL104:
; 1203 return 0;
pop esi
xor eax,eax
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL177:
; 1206 Verbose(3, "DrvSetup", "WM_COMMAND, IDM_DELETE_PDEV");
sub esp,0ch
mov ecx,offset FLAT:@CBE55
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,0ch
; 1212 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
lea ecx,[ebp-028h]; dummy
push 0h
; 1210 bool = FALSE;
mov dword ptr [ebp-024h],0h; bool
; 1212 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
push ecx
; 1211 dummy = 0;
mov dword ptr [ebp-028h],0h; dummy
; 1212 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
sub esp,0ch
mov ebx,[ebp-020h]; work
lea ecx,[ebp-024h]; bool
mov eax,[ebx+08h]
mov edx,offset FLAT: EmphInuse__FUlP9_MYRECORDPUlT3
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
; 1217 VRDev * rdev = work->pmrMenu->dsk;
mov edi,[ebx+01ch]
; 1212 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
add esp,014h
; 1217 VRDev * rdev = work->pmrMenu->dsk;
mov edi,[edi+01ch]
; 1221 sprintf(str,"Are you sure you want to destroy"
lea ecx,[edi+08h]
movzx edx,byte ptr [ecx+05h]
push edx
movzx edx,byte ptr [ecx+04h]
push edx
movzx edx,byte ptr [ecx+03h]
push edx
movzx edx,byte ptr [ecx+02h]
push edx
movzx edx,byte ptr [ecx+01h]
push edx
movzx ecx,byte ptr [ecx]
push ecx
lea esi,[ebp-0378h]; str
sub esp,08h
mov edx,offset FLAT:@CBE56
mov eax,esi
call _sprintfieee
add esp,020h
; 1226 response = WinMessageBox(HWND_DESKTOP, hwnd,
push 04014h
push 0ffffffffh
push offset FLAT:@CBE29
push esi
push dword ptr [ebp+08h]; hwnd
push 01h
call WinMessageBox
add esp,018h
; 1229 if( response == MBID_YES )
cmp eax,06h
jne @BLBL105
; 1235 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
push 030001h
; 1231 PMINIRECORDCORE ap[1] = {(PMINIRECORDCORE)work->pmrMenu};
mov ecx,[ebx+01ch]
mov [ebp-050h],ecx; ap
; 1235 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
lea ecx,[ebp-050h]; ap
push ecx
push 0346h
push dword ptr [ebx+08h]
call WinSendMsg
add esp,010h
; 1239 WinPostMsg(work->hwndScanner, WUM_DELPDEV, rdev, NULL);
push 0h
push edi
push 0100bh
push dword ptr [ebx+0ch]
call WinPostMsg
add esp,010h
; 1240 }
@BLBL105:
; 1242 return 0;
pop esi
xor eax,eax
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL178:
; 1245 Verbose(3, "DrvSetup", "WM_COMMAND, IDM_REMOVE_CHILD");
sub esp,0ch
mov ecx,offset FLAT:@CBE57
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,0ch
; 1251 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
lea ecx,[ebp-028h]; dummy
push 0h
; 1249 bool = FALSE;
mov dword ptr [ebp-024h],0h; bool
; 1251 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
push ecx
; 1250 dummy = 0;
mov dword ptr [ebp-028h],0h; dummy
; 1251 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
sub esp,0ch
mov ebx,[ebp-020h]; work
lea ecx,[ebp-024h]; bool
mov eax,[ebx+08h]
mov edx,offset FLAT: EmphInuse__FUlP9_MYRECORDPUlT3
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
; 1256 VRDev * rdev = work->pmrMenu->dsk;
mov ebx,[ebx+01ch]
; 1251 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse, &bool, &dummy, NULL);
add esp,014h
; 1256 VRDev * rdev = work->pmrMenu->dsk;
mov ebx,[ebx+01ch]
mov [ebp-060h],ebx; rdev
; 1260 sprintf(str,"Are you sure you want to remove"
lea ecx,[ebx+08h]
movzx edx,byte ptr [ecx+05h]
push edx
movzx edx,byte ptr [ecx+04h]
push edx
movzx edx,byte ptr [ecx+03h]
push edx
movzx edx,byte ptr [ecx+02h]
push edx
movzx edx,byte ptr [ecx+01h]
push edx
movzx ecx,byte ptr [ecx]
push ecx
lea edi,[ebp-0440h]; str
sub esp,08h
mov edx,offset FLAT:@CBE58
mov eax,edi
call _sprintfieee
add esp,020h
; 1265 response = WinMessageBox(HWND_DESKTOP, hwnd,
push 04014h
push 0ffffffffh
push offset FLAT:@CBE29
push edi
push dword ptr [ebp+08h]; hwnd
push 01h
call WinMessageBox
add esp,018h
; 1268 if( response == MBID_YES )
cmp eax,06h
jne @BLBL106
; 1272 VRDrive * parent = rdev->getParent();
mov ecx,[ebx+04h]
mov [ebp-064h],ecx; parent
; 1276 VRDev * highest = parent;
mov [ebp-054h],ecx; highest
; 1277 while( highest->getParent() != 0 )
cmp dword ptr [ecx+04h],0h
je @BLBL107
@BLBL108:
; 1278 highest = highest->getParent();
mov ecx,[ecx+04h]
; 1277 while( highest->getParent() != 0 )
cmp dword ptr [ecx+04h],0h
jne @BLBL108
mov [ebp-054h],ecx; highest
@BLBL107:
; 1279 SearchCnr(work->hwndCnr, (PFNSRCH)LookupDisk,
push 0h
lea ecx,[ebp-058h]; myrcd
push ecx
mov ecx,[ebp-054h]; highest
sub esp,0ch
mov ebx,[ebp-020h]; work
mov edx,offset FLAT: LookupDisk__FUlP9_MYRECORDP5VRDevPP9_MYRECORD
mov eax,[ebx+08h]
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
add esp,014h
; 1281 ap[0] = (PMINIRECORDCORE)myrcd;
mov ecx,[ebp-058h]; myrcd
; 1283 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
push 030001h
; 1281 ap[0] = (PMINIRECORDCORE)myrcd;
mov [ebp-05ch],ecx; ap
; 1283 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
lea ecx,[ebp-05ch]; ap
push ecx
push 0346h
push dword ptr [ebx+08h]
call WinSendMsg
add esp,010h
; 1290 WinPostMsg(work->hwndScanner, WUM_REMCHILD, rdev, parent);
push dword ptr [ebp-064h]; parent
push dword ptr [ebp-060h]; rdev
push 0100eh
push dword ptr [ebx+0ch]
call WinPostMsg
add esp,010h
; 1291 }
@BLBL106:
; 1293 return 0;
pop esi
xor eax,eax
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
@BLBL179:
; 1297 Verbose(2, "DrvSetup", "WM_COMMAND %u", cmd);
mov ecx,offset FLAT:@CBE59
movzx eax,word ptr [ebp-068h]; cmd
push eax
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,02h
call Verbose
add esp,010h
; 1301 break; /* continue with default */
jmp @BLBL147
@BLBL154:
; 1309 Verbose(3, "DrvSetup", "WM_CREATE");
sub esp,0ch
mov ecx,offset FLAT:@CBE60
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,08h
; 1310 LoadPresParam(WC_DRVSETUP);
mov eax,offset FLAT:@CBE61
call LoadPresParam__FPc
add esp,04h
; 1311 break; /* keep on going... */
jmp @BLBL147
@BLBL155:
; 1319 Verbose(3, "DrvSetup", "WM_CLOSE");
sub esp,0ch
mov ebx,offset FLAT:@CBE3
mov ecx,offset FLAT:@CBE62
mov edx,ebx
mov eax,03h
call Verbose
add esp,0ch
; 1327 SearchCnr(work->hwndCnr, (PFNSRCH)QueryAny,
lea eax,[ebp-0184h]; info
push 0h
; 1326 info.cnt = 0;
mov dword ptr [ebp-0188h],0h; info
; 1327 SearchCnr(work->hwndCnr, (PFNSRCH)QueryAny,
push eax
lea ecx,[ebp-0188h]; info
sub esp,0ch
mov edi,[ebp-020h]; work
mov edx,offset FLAT: QueryAny__FUlP9_MYRECORDPUlPP9_MYRECORD
mov eax,[edi+08h]
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
add esp,014h
mov edx,ebx
; 1329 Verbose(2, "DrvSetup", "%lu drives are available", info.cnt);
push dword ptr [ebp-0188h]; info
mov ecx,offset FLAT:@CBE63
sub esp,0ch
mov eax,02h
call Verbose
add esp,010h
; 1330 for( ul = 0; ul < info.cnt; ++ul )
cmp dword ptr [ebp-0188h],0h; info
jbe @BLBL112
mov esi,edi
xor edi,edi
@BLBL113:
; 1332 WinPostMsg(work->hwndScanner, WUM_CLOSEDEV,
push 0h
mov eax,dword ptr [ebp+edi*04h-0184h]
; 1330 for( ul = 0; ul < info.cnt; ++ul )
inc edi
; 1332 WinPostMsg(work->hwndScanner, WUM_CLOSEDEV,
push dword ptr [eax+01ch]
push 0100fh
push dword ptr [esi+0ch]
call WinPostMsg
add esp,010h
; 1330 for( ul = 0; ul < info.cnt; ++ul )
cmp [ebp-0188h],edi; info
ja @BLBL113
@BLBL112:
; 1336 WinPostMsg(work->hwndScanner, WM_CLOSE, 0, 0);
push 0h
mov ebx,[ebp-020h]; work
push 0h
push 029h
push dword ptr [ebx+0ch]
call WinPostMsg
add esp,010h
; 1337 break; /* continue... */
jmp @BLBL147
@BLBL156:
; 1347 Verbose(3, "DrvSetup", "WM_DESTROY");
sub esp,0ch
mov ecx,offset FLAT:@CBE64
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,0ch
; 1349 WinDestroyWindow(work->hwndSngPopup);
mov ebx,[ebp-020h]; work
push dword ptr [ebx+014h]
call WinDestroyWindow
add esp,04h
; 1350 WinDestroyWindow(work->hwndMulPopup);
push dword ptr [ebx+018h]
call WinDestroyWindow
add esp,04h
; 1351 WinDestroyWindow(work->hwndCnr);
push dword ptr [ebx+08h]
call WinDestroyWindow
add esp,04h
; 1352 WinPostMsg(work->self->parent, WUM_THREADENDED, work->self, 0);
mov ecx,[ebx]
push 0h
push ecx
push 01003h
push dword ptr [ecx]
call WinPostMsg
add esp,010h
; 1354 break;
jmp @BLBL147
@BLBL157:
; 1368 if( WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &size) == TRUE )
lea ebx,[ebp-01b0h]; size
; 1364 Verbose(3, "DrvSetup", "WM_SIZE");
sub esp,0ch
mov ecx,offset FLAT:@CBE65
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,0ch
; 1368 if( WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &size) == TRUE )
push 05h
push dword ptr [ebp+08h]; hwnd
call WinQueryWindow
add esp,08h
push ebx
push eax
call WinQueryWindowPos
add esp,08h
cmp eax,01h
jne @BLBL117
; 1369 ProfileWrite(WC_DRVSETUP, "Size", sizeof(size), &size);
push ebx
mov ecx,024h
sub esp,0ch
mov edx,offset FLAT:@CBE66
mov eax,offset FLAT:@CBE61
call ProfileWrite
add esp,010h
@BLBL117:
; 1371 if( WinQueryWindowPos(hwnd, &size) == TRUE )
lea ebx,[ebp-01b0h]; size
push ebx
push dword ptr [ebp+08h]; hwnd
call WinQueryWindowPos
add esp,08h
cmp eax,01h
jne @BLBL118
; 1372 WinSetWindowPos(work->hwndCnr, HWND_TOP,
push 08bh
mov ecx,[ebp+014h]; mp2
mov ebx,ecx
shr ecx,010h
movzx ecx,cx
push ecx
movzx ebx,bx
push ebx
mov ebx,[ebp-020h]; work
push 0h
push 0h
push 03h
push dword ptr [ebx+08h]
call WinSetWindowPos
add esp,01ch
; 1375 SWP_SIZE|SWP_MOVE|SWP_SHOW|SWP_ACTIVATE);
@BLBL118:
; 1377 break;
jmp @BLBL147
@BLBL158:
; 1389 if( WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp) == TRUE )
lea ebx,[ebp-0464h]; swp
; 1385 Verbose(3, "DrvSetup", "WM_MOVE");
sub esp,0ch
mov ecx,offset FLAT:@CBE67
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,0ch
; 1389 if( WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp) == TRUE )
push 05h
push dword ptr [ebp+08h]; hwnd
call WinQueryWindow
add esp,08h
push ebx
push eax
call WinQueryWindowPos
add esp,08h
cmp eax,01h
jne @BLBL119
; 1390 ProfileWrite(WC_DRVSETUP, "Position", sizeof(swp), &swp);
push ebx
mov ecx,024h
sub esp,0ch
mov edx,offset FLAT:@CBE68
mov eax,offset FLAT:@CBE61
call ProfileWrite
add esp,010h
@BLBL119:
; 1392 break;
jmp @BLBL147
@BLBL159:
; 1403 Verbose(1, "DrvSetup", "WM_QUERYTRACKINFO (tracking flags %#x)",tf);
mov ax,[ebp+010h]; mp1
movzx eax,ax
push eax
mov ecx,offset FLAT:@CBE69
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,01h
call Verbose
add esp,010h
; 1405 break; /* has to do default processing! */
jmp @BLBL147
@BLBL160:
; 1418 Verbose(3, "DrvSetup", "WM_PRESPARAMCHANGED(type %#x)", LONGFROMMP(mp1));
mov eax,[ebp+010h]; mp1
push eax
mov ecx,offset FLAT:@CBE70
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
add esp,010h
; 1419 if( work == NULL )
cmp dword ptr [ebp-020h],0h; work
jne @BLBL120
; 1420 break;
jmp @BLBL147
@BLBL120:
; 1422 switch( LONGFROMMP(mp1) )
mov eax,[ebp+010h]; mp1
cmp eax,01h
je @BLBL187
cmp eax,03h
je @BLBL188
cmp eax,0fh
je @BLBL189
jmp @BLBL190
@BLBL187:
; 1425 cb = WinQueryPresParam(hwnd, PP_FOREGROUNDCOLOR, 0, NULL,
push 01h
push offset FLAT:@3rgbForeground
push 04h
push 0h
push 0h
push 01h
push dword ptr [ebp+08h]; hwnd
call WinQueryPresParam
add esp,01ch
; 1428 if( cb == 0 )
test eax,eax
jne @BLBL121
; 1429 Verbose(1, "DrvSetup",
mov ebx,[ebp-020h]; work
push dword ptr [ebx+04h]
call WinGetLastError
add esp,04h
mov ecx,offset FLAT:@CBE71
push eax
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,01h
call Verbose
add esp,010h
; 1431 WinGetLastError(work-
; 1431 >hab));
jmp @BLBL122
@BLBL121:
; 1434 Verbose(2, "DrvSetup", "Set foreground colour to %#x",
push dword ptr @3rgbForeground
mov ecx,offset FLAT:@CBE72
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
add esp,010h
; 1436 ProfileWrite(WC_DRVSETUP, "Foreground",
mov ecx,04h
push offset FLAT:@3rgbForeground
mov edx,offset FLAT:@CBE2
sub esp,0ch
mov eax,offset FLAT:@CBE61
call ProfileWrite
add esp,010h
; 1438 WinInvalidateRect(hwnd, NULL, FALSE);
push 0h
push 0h
push dword ptr [ebp+08h]; hwnd
call WinInvalidateRect
add esp,0ch
; 1439 }
@BLBL122:
; 1440 break;
jmp @BLBL147
@BLBL188:
; 1443 cb = WinQueryPresParam(hwnd, PP_BACKGROUNDCOLOR, 0, NULL,
push 01h
push offset FLAT:@2rgbBackground
push 04h
push 0h
push 0h
push 03h
push dword ptr [ebp+08h]; hwnd
call WinQueryPresParam
add esp,01ch
; 1446 if( cb == 0 )
test eax,eax
jne @BLBL123
; 1447 Verbose(1, "DrvSetup",
mov ebx,[ebp-020h]; work
push dword ptr [ebx+04h]
call WinGetLastError
add esp,04h
mov ecx,offset FLAT:@CBE71
push eax
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,01h
call Verbose
add esp,010h
; 1449 WinGetLastError(work->hab));
jmp @BLBL124
@BLBL123:
; 1452 Verbose(2, "DrvSetup", "Set background colour to %#x",
push dword ptr @2rgbBackground
mov ecx,offset FLAT:@CBE73
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
add esp,010h
; 1454 ProfileWrite(WC_DRVSETUP, "Background",
mov ecx,04h
push offset FLAT:@2rgbBackground
mov edx,offset FLAT:@CBE1
sub esp,0ch
mov eax,offset FLAT:@CBE61
call ProfileWrite
add esp,010h
; 1456 WinInvalidateRect(hwnd, NULL, FALSE);
push 0h
push 0h
push dword ptr [ebp+08h]; hwnd
call WinInvalidateRect
add esp,0ch
; 1457 }
@BLBL124:
; 1458 break;
jmp @BLBL147
@BLBL189:
; 1461 cb = WinQueryPresParam(hwnd, PP_FONTNAMESIZE, 0, NULL,
push 01h
lea ebx,[ebp-02b0h]; fontname
push ebx
push 0100h
push 0h
push 0h
push 0fh
push dword ptr [ebp+08h]; hwnd
call WinQueryPresParam
add esp,01ch
; 1464 if( cb == 0 )
test eax,eax
jne @BLBL125
; 1465 Verbose(1, "DrvSetup",
mov ebx,[ebp-020h]; work
push dword ptr [ebx+04h]
call WinGetLastError
add esp,04h
mov ecx,offset FLAT:@CBE71
push eax
mov edx,offset FLAT:@CBE3
sub esp,0ch
mov eax,01h
call Verbose
add esp,010h
; 1467 WinGetLastError(work->hab));
jmp @BLBL126
@BLBL125:
; 1470 Verbose(2, "DrvSetup", "Set font to \"%s\"", fontname);
lea ebx,[ebp-02b0h]; fontname
push ebx
mov ecx,offset FLAT:@CBE74
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
add esp,0ch
; 1471 ProfileWrite(WC_DRVSETUP, "Font", strlen(fontname), &fontname);
mov eax,ebx
call strlen
add esp,04h
mov ecx,eax
push ebx
mov edx,offset FLAT:@CBE75
sub esp,0ch
mov eax,offset FLAT:@CBE61
call ProfileWrite
add esp,010h
; 1472 WinInvalidateRect(hwnd, NULL, FALSE);
push 0h
push 0h
push dword ptr [ebp+08h]; hwnd
call WinInvalidateRect
add esp,0ch
; 1473 }
@BLBL126:
; 1474 break;
jmp @BLBL147
@BLBL190:
; 1477 Verbose(1, "DrvSetup", "WM_PRESPARAMCHANGED(unsupported type %#x)",
mov eax,[ebp+010h]; mp1
push eax
mov ecx,offset FLAT:@CBE76
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,01h
call Verbose
add esp,010h
; 1482 break;
jmp @BLBL147
@BLBL161:
; 1490 return (MRESULT)TRUE;
pop esi
mov eax,01h
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
; 1494 break;
@BLBL147:
; 1497 return WinDefWindowProc(hwnd, msg, mp1, mp2);
push dword ptr [ebp+014h]; mp2
push dword ptr [ebp+010h]; mp1
push dword ptr [ebp+0ch]; msg
push dword ptr [ebp+08h]; hwnd
call WinDefWindowProc
add esp,010h
pop esi
pop edi
pop ebx
add esp,0460h
pop fs:[0h]
leave
ret
DrvsetupWindowProc endp
; 791 DragDrop(HWND hwndClient,PWORK const work,PCNRDRAGINFO drag)
DragDrop__FUlCP5_WORKP12_CNRDRAGINFO proc
push ebp
mov ebp,esp
push ebx
mov ebx,ecx
push edi
mov [ebp+010h],ebx; drag
push esi
mov esi,eax
sub esp,0ech
mov [ebp+0ch],edx; work
mov [ebp+08h],esi; hwndClient
; 793 VRDev * const dest = ((PMYRECORD)drag->pRecord)->dsk;
mov eax,[ebx+04h]
; 798 Verbose(2, "DrvSetup", "DragDrop, record %#x", drag->pRecord);
push eax
; 793 VRDev * const dest = ((PMYRECORD)drag->pRecord)->dsk;
mov eax,[eax+01ch]
; 798 Verbose(2, "DrvSetup", "DragDrop, record %#x", drag->pRecord);
sub esp,0ch
; 793 VRDev * const dest = ((PMYRECORD)drag->pRecord)->dsk;
mov [ebp-01ch],eax; dest
; 798 Verbose(2, "DrvSetup", "DragDrop, record %#x", drag->pRecord);
mov edi,offset FLAT:@CBE3
mov ecx,offset FLAT:@CBE26
mov edx,edi
mov eax,02h
call Verbose
mov ecx,ebx
mov eax,esi
; 800 if( drag->pDragInfo->hwndSource != hwndClient )
mov ecx,[ecx]
; 798 Verbose(2, "DrvSetup", "DragDrop, record %#x", drag->pRecord);
add esp,010h
; 800 if( drag->pDragInfo->hwndSource != hwndClient )
cmp [ecx+08h],eax
; 798 Verbose(2, "DrvSetup", "DragDrop, record %#x", drag->pRecord);
mov edx,edi
; 800 if( drag->pDragInfo->hwndSource != hwndClient )
je @BLBL66
; 802 Verbose(2, "DrvSetup", "DragDrop, can't use external data");
mov ecx,offset FLAT:@CBE27
mov eax,02h
call Verbose
; 803 return 0;
add esp,0ech
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL66:
; 806 id = work->pmrDragSource->dsk->queryID();
mov ebx,[ebp+0ch]; work
; 812 switch( dest->isArray() )
mov eax,[ebp-01ch]; dest
; 806 id = work->pmrDragSource->dsk->queryID();
mov ebx,[ebx+020h]
mov ebx,[ebx+01ch]
add ebx,08h
mov [ebp-024h],ebx; id
; 812 switch( dest->isArray() )
mov ebx,[eax]
mov ecx,[ebx+064h]
add eax,ecx
call dword ptr [ebx+060h]
movzx eax,al
cmp eax,02h
je @BLBL192
cmp eax,04h
jne @BLBL191
@BLBL192:
; 816 sprintf(str, "This will destroy all data on the"
mov ecx,[ebp-024h]; id
lea ebx,[ebp-0ech]; str
movzx edx,byte ptr [ecx+05h]
push edx
movzx edx,byte ptr [ecx+04h]
push edx
movzx edx,byte ptr [ecx+03h]
push edx
movzx edx,byte ptr [ecx+02h]
push edx
movzx edx,byte ptr [ecx+01h]
push edx
movzx ecx,byte ptr [ecx]
push ecx
mov edx,offset FLAT:@CBE28
sub esp,08h
mov eax,ebx
call _sprintfieee
; 820 response = WinMessageBox(HWND_DESKTOP, hwndClient,
push 04014h
push 0ffffffffh
push offset FLAT:@CBE29
push ebx
push dword ptr [ebp+08h]; hwndClient
push 01h
call WinMessageBox
add esp,038h
; 823 if( response == MBID_YES )
cmp eax,06h
jne @BLBL67
; 828 ((VRDrive *)dest)->addChild(work->pmrDragSource->dsk, False, False);
push 0h
; 826 PMYRECORD myrcd = (PMYRECORD)drag->pRecord;
mov ebx,[ebp+010h]; drag
; 828 ((VRDrive *)dest)->addChild(work->pmrDragSource->dsk, False, False);
sub esp,0ch
mov edi,[ebp-01ch]; dest
mov edx,[ebp+0ch]; work
; 826 PMYRECORD myrcd = (PMYRECORD)drag->pRecord;
mov ebx,[ebx+04h]
mov [ebp-010h],ebx; myrcd
; 828 ((VRDrive *)dest)->addChild(work->pmrDragSource->dsk, False, False);
mov ebx,[edi]
mov edx,[edx+020h]
mov eax,[ebx+08ch]
mov edx,[edx+01ch]
xor ecx,ecx
add eax,edi
call dword ptr [ebx+088h]
add esp,010h
; 834 VRDev * highest = dest;
mov [ebp-020h],edi; highest
; 835 while( highest->getParent() != 0 )
cmp dword ptr [edi+04h],0h
je @BLBL68
@BLBL69:
; 836 highest = highest->getParent();
mov edi,[edi+04h]
; 835 while( highest->getParent() != 0 )
cmp dword ptr [edi+04h],0h
jne @BLBL69
mov [ebp-020h],edi; highest
@BLBL68:
; 837 SearchCnr(work->hwndCnr, (PFNSRCH)LookupDisk, highest,
; 837 &myrcd, NULL);
push 0h
lea ecx,[ebp-010h]; myrcd
push ecx
mov edi,[ebp+0ch]; work
mov ebx,[ebp-020h]; highest
sub esp,0ch
mov eax,[edi+08h]
mov ecx,ebx
mov edx,offset FLAT: LookupDisk__FUlP9_MYRECORDP5VRDevPP9_MYRECORD
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
; 838 Verbose(2, "DrvSetup", "DragDrop: found as record %lu", myrcd);
push dword ptr [ebp-010h]; myrcd
mov ecx,offset FLAT:@CBE30
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
; 842 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
push 030002h
; 840 ap[0] = (PMINIRECORDCORE)work->pmrDragSource;
mov eax,[edi+020h]
mov [ebp-018h],eax; ap
; 841 ap[1] = (PMINIRECORDCORE)myrcd;
mov eax,[ebp-010h]; myrcd
mov [ebp-014h],eax; ap
; 842 WinSendMsg(work->hwndCnr, CM_REMOVERECORD,
lea eax,[ebp-018h]; ap
push eax
push 0346h
push dword ptr [edi+08h]
call WinSendMsg
; 850 WinPostMsg(work->hwndScanner, WUM_DEVTREE, highest, NULL);
push 0h
push ebx
push 0100ah
push dword ptr [edi+0ch]
call WinPostMsg
add esp,044h
; 851 }
@BLBL67:
; 857 break;
@BLBL191:
; 863 work->pmrDragSource = NULL;
mov ebx,[ebp+0ch]; work
; 865 return 0;
xor eax,eax
; 863 work->pmrDragSource = NULL;
mov dword ptr [ebx+020h],0h
; 864 work->pmrDragDestination = NULL;
mov dword ptr [ebx+024h],0h
; 865 return 0;
add esp,0ech
pop esi
pop edi
pop ebx
pop ebp
ret
DragDrop__FUlCP5_WORKP12_CNRDRAGINFO endp
; 659 DragOver(HWND hwndClient,PWORK const work,PCNRDRAGINFO drag)
DragOver__FUlCP5_WORKP12_CNRDRAGINFO proc
push ebp
mov ebp,esp
push ebx
mov ebx,ecx
push edi
mov [ebp+08h],eax; hwndClient
push esi
mov [ebp+010h],ebx; drag
sub esp,034h
mov [ebp+0ch],edx; work
; 661 Verbose(2, "DrvSetup", "DragOver, record %#x", drag->pRecord);
push dword ptr [ebx+04h]
mov edi,offset FLAT:@CBE3
sub esp,0ch
mov ecx,offset FLAT:@CBE16
mov edx,edi
mov eax,02h
call Verbose
mov ecx,ebx
add esp,010h
; 668 if( drag->pRecord == NULL )
cmp dword ptr [ecx+04h],0h
; 661 Verbose(2, "DrvSetup", "DragOver, record %#x", drag->pRecord);
mov edx,edi
; 668 if( drag->pRecord == NULL )
jne @BLBL58
; 670 Verbose(2, "DrvSetup", "DragOver, no target");
mov ecx,offset FLAT:@CBE17
mov eax,02h
call Verbose
; 671 return MRFROM2SHORT(DOR_NODROP,DO_DEFAULT);
add esp,034h
mov eax,0bffe0000h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL58:
; 678 WinQueryPointerPos(HWND_DESKTOP, &ptlMouse);
lea ebx,[ebp-014h]; ptlMouse
push ebx
push 01h
call WinQueryPointerPos
; 686 WinMapWindowPoints(HWND_DESKTOP, hwndClient, (PPOINTL)&qrfrQuery.rect, 2);
push 02h
; 682 qrfrQuery.rect.xLeft = ptlMouse.x;
mov ebx,[ebp-014h]; ptlMouse
mov [ebp-030h],ebx; qrfrQuery
; 683 qrfrQuery.rect.xRight = ptlMouse.x+1;
inc ebx
mov [ebp-028h],ebx; qrfrQuery
; 684 qrfrQuery.rect.yBottom = ptlMouse.y;
mov ebx,[ebp-010h]; ptlMouse
mov [ebp-02ch],ebx; qrfrQuery
; 685 qrfrQuery.rect.yTop = ptlMouse.y+1;
inc ebx
mov [ebp-024h],ebx; qrfrQuery
; 686 WinMapWindowPoints(HWND_DESKTOP, hwndClient, (PPOINTL)&qrfrQuery.rect, 2);
lea ebx,[ebp-030h]; qrfrQuery
push ebx
; 681 qrfrQuery.cb = sizeof(QUERYRECFROMRECT);
mov dword ptr [ebp-034h],018h; qrfrQuery
; 686 WinMapWindowPoints(HWND_DESKTOP, hwndClient, (PPOINTL)&qrfrQuery.rect, 2);
push dword ptr [ebp+08h]; hwndClient
; 693 work->pmrDragDestination
lea ebx,[ebp-034h]; qrfrQuery
; 686 WinMapWindowPoints(HWND_DESKTOP, hwndClient, (PPOINTL)&qrfrQuery.rect, 2);
push 01h
call WinMapWindowPoints
; 693 work->pmrDragDestination
push ebx
mov ebx,[ebp+0ch]; work
push 010h
; 688 qrfrQuery.fsSearch = CMA_PARTIAL|CMA_ITEMORDER;
mov dword ptr [ebp-020h],02001h; qrfrQuery
; 693 work->pmrDragDestination
push 0342h
push dword ptr [ebx+08h]
call WinSendMsg
add esp,028h
mov [ebx+024h],eax
; 696 if( work->pmrDragDestination == NULL )
test eax,eax
jne @BLBL59
; 698 Verbose(2, "DrvSetup", "DragOver, no destination");
mov ecx,offset FLAT:@CBE18
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
; 699 return MRFROM2SHORT(DOR_NODROP,DO_DEFAULT);
add esp,034h
mov eax,0bffe0000h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL59:
; 702 if( work->pmrDragDestination != (PMYRECORD)drag->pRecord )
mov ecx,[ebp+010h]; drag
mov ebx,[ebp+0ch]; work
mov ecx,[ecx+04h]
cmp [ebx+024h],ecx
je @BLBL60
; 704 Verbose(1, "DrvSetup", "DragOver, pRecord != pmrDragDestination!");
mov ecx,offset FLAT:@CBE19
mov edx,offset FLAT:@CBE3
mov eax,01h
call Verbose
; 705 return MRFROM2SHORT(DOR_NODROP,DO_DEFAULT);
add esp,034h
mov eax,0bffe0000h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL60:
; 712 VRDev * const rdev = work->pmrDragDestination->dsk;
mov ebx,[ebp+0ch]; work
; 715 Verbose(2, "DrvSetup", "DragOver, destination %#x", rdev);
mov esi,offset FLAT:@CBE3
; 712 VRDev * const rdev = work->pmrDragDestination->dsk;
mov edi,[ebx+024h]
mov edi,[edi+01ch]
mov [ebp-018h],edi; rdev
; 713 UCHAR const rdtype = rdev->isArray();
mov ecx,[edi]
mov eax,[ecx+064h]
add eax,edi
call dword ptr [ecx+060h]
; 715 Verbose(2, "DrvSetup", "DragOver, destination %#x", rdev);
push edi
mov ecx,offset FLAT:@CBE20
sub esp,0ch
; 713 UCHAR const rdtype = rdev->isArray();
mov [ebp-019h],al; rdtype
; 715 Verbose(2, "DrvSetup", "DragOver, destination %#x", rdev);
mov edx,esi
mov eax,02h
call Verbose
; 716 if( work->pmrDragSource->dsk == rdev )
mov eax,[ebx+020h]
; 715 Verbose(2, "DrvSetup", "DragOver, destination %#x", rdev);
add esp,010h
; 716 if( work->pmrDragSource->dsk == rdev )
cmp [eax+01ch],edi
; 715 Verbose(2, "DrvSetup", "DragOver, destination %#x", rdev);
mov edx,esi
; 716 if( work->pmrDragSource->dsk == rdev )
jne @BLBL61
; 718 Verbose(2, "DrvSetup", "DragOver, source == destination!");
mov ecx,offset FLAT:@CBE21
mov eax,02h
call Verbose
; 719 return MRFROM2SHORT(DOR_NODROP,DO_DEFAULT);
add esp,034h
mov eax,0bffe0000h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL61:
; 723 switch( rdtype )
movzx eax,byte ptr [ebp-019h]; rdtype
cmp eax,02h
je @BLBL195
cmp eax,04h
jne @BLBL196
@BLBL194:
; 729 if( work->pmrDragSource->dsk->querySize() < rdev->querySize() )
mov ebx,[ebp+0ch]; work
mov eax,[ebx+020h]
mov eax,[eax+01ch]
mov ecx,[eax]
mov edx,[ecx+014h]
add eax,edx
call dword ptr [ecx+010h]
mov edi,eax
mov eax,[ebp-018h]; rdev
mov ecx,[eax]
mov edx,[ecx+014h]
add eax,edx
call dword ptr [ecx+010h]
cmp edi,eax
jae @BLBL62
; 731 Verbose(2, "DrvSetup", "DragOver, source too small");
mov ecx,offset FLAT:@CBE22
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
; 732 work->pmrDragDestination = NULL;
mov dword ptr [ebx+024h],0h
; 733 return MRFROM2SHORT(DOR_NODROP,DO_DEFAULT);
add esp,034h
mov eax,0bffe0000h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL62:
; 735 break;
jmp @BLBL193
@BLBL195:
; 741 if( rdev->getParent() != NULL )
mov ebx,[ebp-018h]; rdev
cmp dword ptr [ebx+04h],0h
je @BLBL63
; 747 work->pmrDragDestination = NULL;
mov ebx,[ebp+0ch]; work
; 746 Verbose(2, "DrvSetup", "DragOver, bad destination");
mov ecx,offset FLAT:@CBE23
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
; 747 work->pmrDragDestination = NULL;
mov dword ptr [ebx+024h],0h
; 748 return MRFROM2SHORT(DOR_NODROP,DO_DEFAULT);
add esp,034h
mov eax,0bffe0000h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL63:
; 750 break;
jmp @BLBL193
@BLBL196:
; 757 work->pmrDragDestination = NULL;
mov ebx,[ebp+0ch]; work
; 756 Verbose(2, "DrvSetup", "DragOver, bad destination type");
mov ecx,offset FLAT:@CBE24
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
; 757 work->pmrDragDestination = NULL;
mov dword ptr [ebx+024h],0h
; 758 return MRFROM2SHORT(DOR_NODROP,DO_DEFAULT);
add esp,034h
mov eax,0bffe0000h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL193:
; 761 Verbose(3, "DrvSetup", "DragOver, destination is acceptable");
mov ecx,offset FLAT:@CBE25
mov edx,offset FLAT:@CBE3
mov eax,03h
call Verbose
; 762 return MRFROM2SHORT(DOR_DROP,DO_MOVE);
add esp,034h
mov eax,0200001h
pop esi
pop edi
pop ebx
pop ebp
ret
DragOver__FUlCP5_WORKP12_CNRDRAGINFO endp
; 623 DragLeave(HWND hwndClient,PWORK const work,PCNRDRAGINFO drag)
DragLeave__FUlCP5_WORKP12_CNRDRAGINFO proc
push ebx
mov ebx,edx
; 625 Verbose(2, "DrvSetup", "DragLeave, record %#x", drag->pRecord);
push dword ptr [ecx+04h]
mov ecx,offset FLAT:@CBE15
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
add esp,010h
mov edx,ebx
; 629 return 0;
pop ebx
; 627 work->pmrDragSource = NULL; /* reflect in work area */
mov dword ptr [edx+020h],0h
; 628 work->pmrDragDestination = NULL;
mov dword ptr [edx+024h],0h
; 629 return 0;
xor eax,eax
ret
DragLeave__FUlCP5_WORKP12_CNRDRAGINFO endp
; 542 DragInit(HWND hwndClient,PWORK const work,PCNRDRAGINIT const drag)
DragInit__FUlCP5_WORKCP12_CNRDRAGINIT proc
push ebp
mov ebp,esp
push ebx
mov ebx,ecx
push edi
mov [ebp+0ch],edx; work
push esi
mov [ebp+08h],eax; hwndClient
sub esp,04ch
mov [ebp+010h],ebx; drag
; 544 Verbose(2, "DrvSetup", "DragInit: record %#x",drag->pRecord);
push dword ptr [ebx+04h]
mov ecx,offset FLAT:@CBE11
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
mov ecx,ebx
add esp,010h
; 546 if( drag->pRecord == NULL )
cmp dword ptr [ecx+04h],0h
jne @BLBL49
; 547 return 0; /* no record selected */
xor eax,eax
add esp,04ch
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL49:
; 548 if( work->pmrDragSource != NULL )
mov ecx,[ebp+0ch]; work
cmp dword ptr [ecx+020h],0h
je @BLBL50
; 549 return 0; /* already active drag */
xor eax,eax
add esp,04ch
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL50:
; 555 VRDev * const rdev = ((PMYRECORD)drag->pRecord)->dsk;
mov ecx,[ebp+010h]; drag
mov ecx,[ecx+04h]
mov ecx,[ecx+01ch]
mov [ebp-010h],ecx; rdev
; 556 if( rdev->getParent() != NULL )
cmp dword ptr [ecx+04h],0h
je @BLBL51
; 557 return 0; /* sorry, no dragging of children */
xor eax,eax
add esp,04ch
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL51:
; 558 if( rdev->isWritable() == False )
mov eax,[ebp-010h]; rdev
mov ecx,[eax]
mov edx,[ecx+0ch]
add eax,edx
call dword ptr [ecx+08h]
test al,al
jne @BLBL52
; 559 return 0; /* can't write = no drag */
xor eax,eax
add esp,04ch
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL52:
; 560 if( rdev->isHostdrive() == True && rdev->isArray() == 0 )
mov ebx,[ebp-010h]; rdev
mov ecx,[ebx]
mov eax,[ecx+06ch]
add eax,ebx
call dword ptr [ecx+068h]
cmp al,01h
mov eax,ebx
jne @BLBL53
mov ecx,[eax]
mov edx,[ecx+064h]
add eax,edx
call dword ptr [ecx+060h]
test al,al
jne @BLBL53
; 561 return 0; /* not even PHYSDEVICE! */
xor eax,eax
add esp,04ch
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL53:
; 568 work->pmrDragSource
; 568 = (PMYRECORD)drag->pRecord;
mov ebx,[ebp+010h]; drag
; 567 Verbose(2, "DrvSetup", "DragInit: record passed checks");
mov ecx,offset FLAT:@CBE12
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
; 568 work->pmrDragSource
; 568 = (PMYRECORD)drag->pRecord;
mov edi,[ebp+0ch]; work
; 570 PDRAGINFO dinfo = DrgAllocDraginfo(1);
push 01h
; 568 work->pmrDragSource
; 568 = (PMYRECORD)drag->pRecord;
mov ecx,[ebx+04h]
mov [edi+020h],ecx
; 570 PDRAGINFO dinfo = DrgAllocDraginfo(1);
call DrgAllocDraginfo
; 574 ditem.hstrType = DrgAddStrHandle("DRT_CUSTOMER");
push offset FLAT:@CBE13
; 572 ditem.hwndItem = hwndClient;
mov esi,[ebp+08h]; hwndClient
mov [ebp-034h],esi; ditem
; 573 ditem.ulItemID = (ULONG)drag->pRecord;
mov ecx,[ebx+04h]
mov ebx,eax
mov [ebp-030h],ecx; ditem
; 574 ditem.hstrType = DrgAddStrHandle("DRT_CUSTOMER");
call DrgAddStrHandle
; 575 ditem.hstrRMF = DrgAddStrHandle("DRM_SHAREMEM,DRM_UNKNOWN");
push offset FLAT:@CBE14
; 574 ditem.hstrType = DrgAddStrHandle("DRT_CUSTOMER");
mov [ebp-02ch],eax; ditem
; 575 ditem.hstrRMF = DrgAddStrHandle("DRM_SHAREMEM,DRM_UNKNOWN");
call DrgAddStrHandle
; 579 DrgSetDragitem(dinfo, /* Set item in DRAGINFO */
push 0h
lea ecx,[ebp-034h]; ditem
push 024h
; 575 ditem.hstrRMF = DrgAddStrHandle("DRM_SHAREMEM,DRM_UNKNOWN");
mov [ebp-028h],eax; ditem
; 579 DrgSetDragitem(dinfo, /* Set item in DRAGINFO */
push ecx
; 576 ditem.fsControl = DC_REMOVEABLEMEDIA; /* can't be recovered... */
mov word ptr [ebp-014h],020h; ditem
; 579 DrgSetDragitem(dinfo, /* Set item in DRAGINFO */
push ebx
; 577 ditem.fsSupportedOps = DO_MOVEABLE;
mov word ptr [ebp-012h],02h; ditem
; 579 DrgSetDragitem(dinfo, /* Set item in DRAGINFO */
call DrgSetDragitem
; 585 dimage.cb = sizeof(DRAGIMAGE); /* Initialize DRAGIMAGE */
mov word ptr [ebp-04ch],018h; dimage
; 586 dimage.cptl = 0; /* Not a polygon */
mov word ptr [ebp-04ah],0h; dimage
; 587 dimage.hImage = work->pmrDragSource->dsk->queryIcon();
mov eax,[edi+020h]
mov eax,[eax+01ch]
mov ecx,[eax]
mov edx,[ecx+07ch]
add eax,edx
call dword ptr [ecx+078h]
; 592 /*hDrop =*/ DrgDrag(hwndClient, /* initiate drag */
push 0h
lea ecx,[ebp-04ch]; dimage
push 038h
; 587 dimage.hImage = work->pmrDragSource->dsk->queryIcon();
mov [ebp-048h],eax; dimage
; 592 /*hDrop =*/ DrgDrag(hwndClient, /* initiate drag */
push 01h
; 588 dimage.fl = DRG_ICON; /* Dragging an icon */
mov dword ptr [ebp-03ch],01h; dimage
; 592 /*hDrop =*/ DrgDrag(hwndClient, /* initiate drag */
push ecx
; 589 dimage.cxOffset = 0; /* No hotspot */
mov word ptr [ebp-038h],0h; dimage
; 592 /*hDrop =*/ DrgDrag(hwndClient, /* initiate drag */
push ebx
; 590 dimage.cyOffset = 0;
mov word ptr [ebp-036h],0h; dimage
; 592 /*hDrop =*/ DrgDrag(hwndClient, /* initiate drag */
push esi
call DrgDrag
; 599 DrgFreeDraginfo(dinfo); /* Free DRAGINFO struct */
push ebx
call DrgFreeDraginfo
add esp,038h
; 601 return 0;
add esp,04ch
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
DragInit__FUlCP5_WORKCP12_CNRDRAGINIT endp
; 478 DisplayDisk(PWORK work,PMYRECORD parent,VRDev * dsk)
DisplayDisk__FP5_WORKP9_MYRECORDP5VRDev proc
push ebp
mov ebp,esp
push ebx
mov ebx,ecx
push edi
mov edi,eax
push esi
mov [ebp+010h],ebx; dsk
sub esp,030h
mov [ebp-030h],edx; @CBE90
; 486 address = (PMYRECORD)WinSendMsg(work->hwndCnr, CM_ALLOCRECORD,
push 01h
; 478 DisplayDisk(PWORK work,PMYRECORD parent,VRDev * dsk)
mov [ebp+08h],edi; work
; 486 address = (PMYRECORD)WinSendMsg(work->hwndCnr, CM_ALLOCRECORD,
push 04h
push 0331h
push dword ptr [edi+08h]
call WinSendMsg
mov esi,eax
; 488 Verbose(3, "DrvSetup", "CM_ALLOCRECORD: %#x",address);
push esi
; 486 address = (PMYRECORD)WinSendMsg(work->hwndCnr, CM_ALLOCRECORD,
mov [ebp-010h],esi; address
; 488 Verbose(3, "DrvSetup", "CM_ALLOCRECORD: %#x",address);
sub esp,0ch
mov eax,offset FLAT:@CBE3
mov edx,eax
mov ecx,offset FLAT:@CBE9
mov eax,03h
call Verbose
; 490 address->dsk = dsk;
mov [esi+01ch],ebx
; 491 descr = dsk->allocateDescription();
mov ecx,[ebx]
mov eax,[ecx+074h]
add eax,ebx
call dword ptr [ecx+070h]
mov edx,ebx
mov ebx,eax
; 492 address->record.hptrIcon = dsk->queryIcon();
mov ecx,[edx]
mov eax,[ecx+07ch]
add edx,eax
mov eax,edx
call dword ptr [ecx+078h]
mov ecx,ebx
; 493 address->record.pszIcon = descr;
mov [esi+014h],ecx
; 492 address->record.hptrIcon = dsk->queryIcon();
mov [esi+018h],eax
; 495 memset(&ins, 0, sizeof(ins));
lea ebx,[ebp-02ch]; ins
mov eax,ebx
mov ecx,018h
xor edx,edx
call memset
lea ecx,[ebp-02ch]; ins
; 505 i = (int)WinSendMsg(work->hwndCnr, CM_INSERTRECORD,
push ecx
; 495 memset(&ins, 0, sizeof(ins));
mov edx,[ebp-030h]; @CBE90
; 505 i = (int)WinSendMsg(work->hwndCnr, CM_INSERTRECORD,
push esi
; 496 ins.cb = sizeof(ins);
mov dword ptr [ebp-02ch],018h; ins
; 505 i = (int)WinSendMsg(work->hwndCnr, CM_INSERTRECORD,
push 0339h
; 497 ins.pRecordOrder = (PRECORDCORE)CMA_END;
mov dword ptr [ebp-028h],040h; ins
; 498 ins.pRecordParent = (PRECORDCORE)parent; /* none (only RAID drives have) */
mov [ebp-024h],edx; ins
; 495 memset(&ins, 0, sizeof(ins));
mov ebx,offset FLAT:@CBE3
; 499 ins.zOrder = CMA_TOP;
mov dword ptr [ebp-01ch],01h; ins
; 500 ins.fInvalidateRecord = TRUE; /* invalidate record now/later */
mov dword ptr [ebp-020h],01h; ins
; 501 ins.cRecordsInsert = 1;
mov dword ptr [ebp-018h],01h; ins
; 505 i = (int)WinSendMsg(work->hwndCnr, CM_INSERTRECORD,
push dword ptr [edi+08h]
call WinSendMsg
add esp,030h
; 507 if( i == 0 )
test eax,eax
mov eax,edi
jne @BLBL39
; 508 Verbose(1, "DrvSetup", "WinSendMsg(CM_INSERTRECORD) failed - last error %#x",
push dword ptr [eax+04h]
call WinGetLastError
push eax
mov edx,ebx
sub esp,0ch
mov ecx,offset FLAT:@CBE10
mov eax,01h
call Verbose
; 509 WinGetLastError(work->hab));
add esp,044h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL39:
; 510 else if( dsk != NULL && dsk->isArray() )
mov esi,[ebp+010h]; dsk
test esi,esi
je @BLBL40
mov ecx,[esi]
mov eax,[ecx+064h]
add eax,esi
call dword ptr [ecx+060h]
test al,al
mov eax,esi
je @BLBL40
; 512 VRDrive * drv = (VRDrive *)dsk; /* xxx hack? */
mov [ebp-014h],eax; drv
; 514 for( i = 0; i < drv->queryChildren(); ++i )
mov ecx,[eax]
mov edx,[ecx+094h]
add eax,edx
call dword ptr [ecx+090h]
test eax,eax
jle @BLBL40
mov ebx,[ebp-010h]; address
mov esi,[ebp+08h]; work
xor edi,edi
@BLBL43:
; 515 DisplayDisk(work, address, drv->getChild(i));
mov ebx,[ebp-014h]; drv
mov edx,edi
mov ecx,[ebx]
; 514 for( i = 0; i < drv->queryChildren(); ++i )
inc edi
; 515 DisplayDisk(work, address, drv->getChild(i));
mov eax,[ecx+09ch]
add eax,ebx
mov ebx,[ebp-010h]; address
call dword ptr [ecx+098h]
mov ecx,eax
mov edx,ebx
mov eax,esi
call DisplayDisk__FP5_WORKP9_MYRECORDP5VRDev
mov eax,[ebp-014h]; drv
; 514 for( i = 0; i < drv->queryChildren(); ++i )
mov ecx,[eax]
mov edx,[ecx+094h]
add eax,edx
call dword ptr [ecx+090h]
cmp eax,edi
jg @BLBL43
@BLBL40:
; 517 return;
add esp,030h
pop esi
pop edi
pop ebx
pop ebp
ret
DisplayDisk__FP5_WORKP9_MYRECORDP5VRDev endp
; 309 DoPopup(HWND hwndClient,PWORK const work)
DoPopup__FUlCP5_WORK proc
push ebp
mov ebp,esp
push ebx
mov ebx,edx
push edi
mov edi,eax
push esi
mov [ebp+0ch],ebx; work
sub esp,044h
; 315 WinQueryPointerPos(HWND_DESKTOP, &ptlMouse);
lea ecx,[ebp-018h]; ptlMouse
push ecx
; 309 DoPopup(HWND hwndClient,PWORK const work)
mov [ebp+08h],edi; hwndClient
; 315 WinQueryPointerPos(HWND_DESKTOP, &ptlMouse);
push 01h
; 311 HWND popup = NULLHANDLE;
mov dword ptr [ebp-010h],0h; popup
; 315 WinQueryPointerPos(HWND_DESKTOP, &ptlMouse);
call WinQueryPointerPos
; 323 WinMapWindowPoints(HWND_DESKTOP, hwndClient, (PPOINTL)&qrfrQuery.rect, 2);
push 02h
; 319 qrfrQuery.rect.xLeft = ptlMouse.x;
mov ecx,[ebp-018h]; ptlMouse
mov [ebp-03ch],ecx; qrfrQuery
; 320 qrfrQuery.rect.xRight = ptlMouse.x+1;
inc ecx
mov [ebp-034h],ecx; qrfrQuery
; 321 qrfrQuery.rect.yBottom = ptlMouse.y;
mov ecx,[ebp-014h]; ptlMouse
mov [ebp-038h],ecx; qrfrQuery
; 322 qrfrQuery.rect.yTop = ptlMouse.y+1;
inc ecx
mov [ebp-030h],ecx; qrfrQuery
; 323 WinMapWindowPoints(HWND_DESKTOP, hwndClient, (PPOINTL)&qrfrQuery.rect, 2);
lea ecx,[ebp-03ch]; qrfrQuery
push ecx
; 315 WinQueryPointerPos(HWND_DESKTOP, &ptlMouse);
mov eax,edi
; 323 WinMapWindowPoints(HWND_DESKTOP, hwndClient, (PPOINTL)&qrfrQuery.rect, 2);
push eax
; 318 qrfrQuery.cb = sizeof(QUERYRECFROMRECT);
mov dword ptr [ebp-040h],018h; qrfrQuery
; 323 WinMapWindowPoints(HWND_DESKTOP, hwndClient, (PPOINTL)&qrfrQuery.rect, 2);
push 01h
call WinMapWindowPoints
; 325 qrfrQuery.fsSearch = CMA_PARTIAL|CMA_ITEMORDER;
mov dword ptr [ebp-02ch],02001h; qrfrQuery
; 327 work->pmrMenu
lea ecx,[ebp-040h]; qrfrQuery
push ecx
push 010h
push 0342h
push dword ptr [ebx+08h]
call WinSendMsg
add esp,028h
mov [ebx+01ch],eax
; 331 if( work->pmrMenu != NULL )
test eax,eax
je @BLBL12
; 333 if( (work->pmrMenu->record.flRecordAttr & CRA_INUSE) != 0 )
test byte ptr [eax+04h],08h
je @BLBL13
; 338 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse2Source, &bSet, &cnt, NULL);
push 0h
lea ecx,[ebp-01ch]; cnt
push ecx
; 335 ULONG cnt = 0;
mov dword ptr [ebp-01ch],0h; cnt
; 337 bSet = TRUE;
mov dword ptr [ebp-020h],01h; bSet
; 338 SearchCnr(work->hwndCnr, (PFNSRCH)EmphInuse2Source, &bSet, &cnt, NULL);
sub esp,0ch
mov eax,[ebx+08h]
lea ecx,[ebp-020h]; bSet
mov edx,offset FLAT: EmphInuse2Source__FUlP9_MYRECORDPUlT3
call SearchCnr__FUlPFUlPvT2PUl_UlPvN23
; 339 Verbose(2, "DrvSetup", "DoPopup: %lu records in use", cnt);
push dword ptr [ebp-01ch]; cnt
mov ecx,offset FLAT:@CBE8
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,02h
call Verbose
mov edx,ebx
add esp,024h
; 345 popup = work->hwndMulPopup;
mov eax,[edx+018h]
mov [ebp-010h],eax; popup
; 346 }
jmp @BLBL15
@BLBL13:
; 349 popup = work->hwndSngPopup;
mov ebx,[ebp+0ch]; work
; 350 WinSendMsg(work->hwndCnr, CM_SETRECORDEMPHASIS,
push 040000001h
; 349 popup = work->hwndSngPopup;
mov ecx,[ebx+014h]
mov [ebp-010h],ecx; popup
; 350 WinSendMsg(work->hwndCnr, CM_SETRECORDEMPHASIS,
push dword ptr [ebx+01ch]
push 034ah
push dword ptr [ebx+08h]
call WinSendMsg
add esp,010h
; 353 }
jmp @BLBL15
@BLBL12:
; 357 WinSendMsg(work->hwndCnr, CM_SETRECORDEMPHASIS,
push 040000001h
; 356 popup = work->hwndNonePopup;
mov ebx,[ebp+0ch]; work
; 357 WinSendMsg(work->hwndCnr, CM_SETRECORDEMPHASIS,
push 0h
; 356 popup = work->hwndNonePopup;
mov ecx,[ebx+010h]
; 357 WinSendMsg(work->hwndCnr, CM_SETRECORDEMPHASIS,
push 034ah
; 356 popup = work->hwndNonePopup;
mov [ebp-010h],ecx; popup
; 357 WinSendMsg(work->hwndCnr, CM_SETRECORDEMPHASIS,
push dword ptr [ebx+08h]
call WinSendMsg
add esp,010h
; 359 }
@BLBL15:
; 361 WinPopupMenu(HWND_DESKTOP, hwndClient, popup,
push 02c6h
mov ebx,[ebp-010h]; popup
push 0h
push dword ptr [ebp-014h]; ptlMouse
push dword ptr [ebp-018h]; ptlMouse
push ebx
push dword ptr [ebp+08h]; hwndClient
push 01h
call WinPopupMenu
; 367 if( popup == work->hwndSngPopup )
mov ecx,[ebp+0ch]; work
; 361 WinPopupMenu(HWND_DESKTOP, hwndClient, popup,
add esp,01ch
; 367 if( popup == work->hwndSngPopup )
cmp [ecx+014h],ebx
jne @BLBL16
; 371 if( work->pmrMenu->dsk == NULL )
mov ecx,[ecx+01ch]
cmp dword ptr [ecx+01ch],0h
jne @BLBL17
; 375 WinEnableMenuItem(popup, IDM_CREATE_PDEV, FALSE);
push 040004000h
push 0101b8h
push 0192h
push ebx
call WinSendMsg
; 376 WinEnableMenuItem(popup, IDM_DELETE_PDEV, FALSE);
push 040004000h
push 0101b9h
push 0192h
push ebx
call WinSendMsg
; 377 WinEnableMenuItem(popup, IDM_DESTROY_DRV, FALSE);
push 040004000h
push 0101bah
push 0192h
push ebx
call WinSendMsg
; 378 WinEnableMenuItem(popup, IDM_REMOVE_CHILD, FALSE);
push 040004000h
push 0101bbh
push 0192h
push ebx
call WinSendMsg
add esp,040h
; 379 }
jmp @BLBL16
@BLBL17:
; 380 else if( work->pmrMenu->dsk->getParent() != NULL )
mov ebx,[ebp+0ch]; work
mov eax,[ebx+01ch]
mov eax,[eax+01ch]
mov esi,[eax+04h]
test esi,esi
je @BLBL19
; 382 VRDrive * const parent = work->pmrMenu->dsk->getParent();
mov [ebp-028h],esi; parent
; 392 if( work->pmrMenu->dsk->getParent()->isArray() == RDTYPE_MIRROR )
mov ecx,[esi]
mov eax,[ecx+064h]
add eax,esi
call dword ptr [ecx+060h]
cmp al,04h
mov eax,esi
jne @BLBL20
; 394 int const cnt = parent->queryChildren();
mov ecx,[eax]
mov edx,[ecx+094h]
add eax,edx
call dword ptr [ecx+090h]
; 397 for( i = v = 0; i < cnt; ++i )
mov dword ptr [ebp-024h],0h; v
test eax,eax
jle @BLBL21
mov ecx,ebx
mov [ebp-048h],eax; cnt
mov ebx,eax
xor esi,esi
xor edi,edi
@BLBL22:
; 399 VRDev * const vrd = parent->getChild(i);
mov ebx,[ebp-028h]; parent
mov edx,edi
mov ecx,[ebx]
mov eax,[ecx+09ch]
add eax,ebx
call dword ptr [ecx+098h]
mov ecx,[ebp+0ch]; work
xchg ebx,eax
; 400 if( vrd != work->pmrMenu->dsk
mov edx,[ecx+01ch]
cmp [edx+01ch],ebx
mov ebx,[ebp-048h]; cnt
je @BLBL24
mov [ebp-044h],esi; @CBE92
; 402 ++v;
mov ecx,[eax]
mov edx,edi
mov esi,[ecx+0a4h]
add eax,esi
mov esi,[ebp+0ch]; work
call dword ptr [ecx+0a0h]
cmp al,01h
sete al
movzx eax,al
mov ecx,esi
mov edx,[ebp-044h]; @CBE92
mov esi,eax
add esi,edx
; 403 }
@BLBL24:
; 397 for( i = v = 0; i < cnt; ++i )
inc edi
cmp edi,ebx
jl @BLBL22
mov [ebp-024h],esi; v
@BLBL21:
; 404 if( v != 0 )
cmp dword ptr [ebp-024h],0h; v
je @BLBL27
; 405 WinEnableMenuItem(popup, IDM_REMOVE_CHILD, TRUE);
push 04000h
push 0101bbh
push 0192h
push dword ptr [ebp-010h]; popup
call WinSendMsg
add esp,010h
jmp @BLBL29
@BLBL27:
; 407 WinEnableMenuItem(popup, IDM_REMOVE_CHILD, FALSE);
push 040004000h
push 0101bbh
push 0192h
push dword ptr [ebp-010h]; popup
call WinSendMsg
add esp,010h
; 408 }
jmp @BLBL29
@BLBL20:
; 410 WinEnableMenuItem(popup, IDM_REMOVE_CHILD, FALSE);
push 040004000h
push 0101bbh
push 0192h
push dword ptr [ebp-010h]; popup
call WinSendMsg
add esp,010h
@BLBL29:
; 411 WinEnableMenuItem(popup, IDM_CREATE_PDEV, FALSE);
push 040004000h
mov ebx,[ebp-010h]; popup
push 0101b8h
push 0192h
push ebx
call WinSendMsg
; 412 WinEnableMenuItem(popup, IDM_DELETE_PDEV, FALSE);
push 040004000h
push 0101b9h
push 0192h
push ebx
call WinSendMsg
; 413 WinEnableMenuItem(popup, IDM_DESTROY_DRV, FALSE);
push 040004000h
push 0101bah
push 0192h
push ebx
call WinSendMsg
add esp,030h
; 414 }
jmp @BLBL16
@BLBL19:
; 415 else if( work->pmrMenu->dsk->isWritable() == False )
mov ebx,[eax]
mov ecx,[ebx+0ch]
add eax,ecx
call dword ptr [ebx+08h]
test al,al
jne @BLBL31
; 420 WinEnableMenuItem(popup, IDM_CREATE_PDEV, FALSE);
push 040004000h
mov ebx,[ebp-010h]; popup
push 0101b8h
push 0192h
push ebx
call WinSendMsg
; 421 WinEnableMenuItem(popup, IDM_DELETE_PDEV, FALSE);
push 040004000h
push 0101b9h
push 0192h
push ebx
call WinSendMsg
; 422 WinEnableMenuItem(popup, IDM_DESTROY_DRV, FALSE);
push 040004000h
push 0101bah
push 0192h
push ebx
call WinSendMsg
; 423 WinEnableMenuItem(popup, IDM_REMOVE_CHILD, FALSE);
push 040004000h
push 0101bbh
push 0192h
push ebx
call WinSendMsg
add esp,040h
; 424 }
jmp @BLBL16
@BLBL31:
; 425 else if( work->pmrMenu->dsk->isArray() != 0 )
mov eax,[ebp+0ch]; work
mov eax,[eax+01ch]
mov eax,[eax+01ch]
mov ebx,[eax]
mov ecx,[ebx+064h]
add eax,ecx
call dword ptr [ebx+060h]
test al,al
je @BLBL33
; 429 WinEnableMenuItem(popup, IDM_CREATE_PDEV, FALSE);
push 040004000h
mov ebx,[ebp-010h]; popup
push 0101b8h
push 0192h
push ebx
call WinSendMsg
; 430 WinEnableMenuItem(popup, IDM_DELETE_PDEV, FALSE);
push 040004000h
push 0101b9h
push 0192h
push ebx
call WinSendMsg
; 431 WinEnableMenuItem(popup, IDM_DESTROY_DRV, TRUE);
push 04000h
push 0101bah
push 0192h
push ebx
call WinSendMsg
; 432 WinEnableMenuItem(popup, IDM_REMOVE_CHILD, FALSE);
push 040004000h
push 0101bbh
push 0192h
push ebx
call WinSendMsg
add esp,040h
; 433 }
jmp @BLBL16
@BLBL33:
; 434 else if( work->pmrMenu->dsk->isHostdrive() == True )
mov eax,[ebp+0ch]; work
mov eax,[eax+01ch]
mov eax,[eax+01ch]
mov ebx,[eax]
mov ecx,[ebx+06ch]
add eax,ecx
call dword ptr [ebx+068h]
cmp al,01h
jne @BLBL35
; 439 WinEnableMenuItem(popup, IDM_CREATE_PDEV, TRUE);
push 04000h
mov ebx,[ebp-010h]; popup
push 0101b8h
push 0192h
push ebx
call WinSendMsg
; 440 WinEnableMenuItem(popup, IDM_DELETE_PDEV, FALSE);
push 040004000h
push 0101b9h
push 0192h
push ebx
call WinSendMsg
; 441 WinEnableMenuItem(popup, IDM_DESTROY_DRV, FALSE);
push 040004000h
push 0101bah
push 0192h
push ebx
call WinSendMsg
; 442 WinEnableMenuItem(popup, IDM_REMOVE_CHILD, FALSE);
push 040004000h
push 0101bbh
push 0192h
push ebx
call WinSendMsg
add esp,040h
; 443 }
jmp @BLBL16
@BLBL35:
; 449 WinEnableMenuItem(popup, IDM_CREATE_PDEV, FALSE);
push 040004000h
mov ebx,[ebp-010h]; popup
push 0101b8h
push 0192h
push ebx
call WinSendMsg
; 450 WinEnableMenuItem(popup, IDM_DELETE_PDEV, TRUE);
push 04000h
push 0101b9h
push 0192h
push ebx
call WinSendMsg
; 451 WinEnableMenuItem(popup, IDM_DESTROY_DRV, FALSE);
push 040004000h
push 0101bah
push 0192h
push ebx
call WinSendMsg
; 452 WinEnableMenuItem(popup, IDM_REMOVE_CHILD, FALSE);
push 040004000h
push 0101bbh
push 0192h
push ebx
call WinSendMsg
add esp,040h
; 454 } /* hwndSngPopup */
@BLBL16:
; 456 return TRUE; /* xxx TRUE? */
add esp,044h
mov eax,01h
pop esi
pop edi
pop ebx
pop ebp
ret
DoPopup__FUlCP5_WORK endp
; 224 CreateCnr(HWND hwndClient,PWORK work)
CreateCnr__FUlP5_WORK proc
push ebp
mov ebp,esp
push ebx
mov ebx,edx
push edi
mov edi,eax
sub esp,08ch
; 229 WinQueryWindowPos(hwndClient, &size);
lea ecx,[ebp-02ch]; size
push ecx
; 224 CreateCnr(HWND hwndClient,PWORK work)
mov [ebp+0ch],ebx; work
; 229 WinQueryWindowPos(hwndClient, &size);
push edi
call WinQueryWindowPos
; 230 Verbose(3, "DrvSetup", "client window %u,%u %u,%u",
push dword ptr [ebp-028h]; size
mov ecx,offset FLAT:@CBE4
push dword ptr [ebp-024h]; size
mov edx,offset FLAT:@CBE3
push dword ptr [ebp-020h]; size
mov eax,03h
push dword ptr [ebp-01ch]; size
sub esp,0ch
call Verbose
; 233 work->hwndCnr = WinCreateWindow(hwndClient, WC_CONTAINER,
push 0h
; 230 Verbose(3, "DrvSetup", "client window %u,%u %u,%u",
mov eax,edi
; 233 work->hwndCnr = WinCreateWindow(hwndClient, WC_CONTAINER,
push 0h
push 01a4h
push 03h
push eax
push dword ptr [ebp-028h]; size
push dword ptr [ebp-024h]; size
push 0h
push 0h
push 080000079h
push 0h
push 0ffff0025h
push eax
call WinCreateWindow
mov edx,ebx
add esp,058h
mov [edx+08h],eax
; 242 if( work->hwndCnr == NULLHANDLE )
test eax,eax
jne @BLBL7
; 244 MyMessageBox(0, HWND_DESKTOP,
push dword ptr [edx+04h]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE5
sub esp,0ch
mov edx,01h
xor eax,eax
call MyMessageBox__FCiCUlPce
add esp,014h
; 247 return 1;
add esp,08ch
mov eax,01h
pop edi
pop ebx
pop ebp
ret
@BLBL7:
; 250 memset(&cnrinfo, 0, sizeof(cnrinfo));
lea ebx,[ebp-088h]; cnrinfo
mov ecx,05ch
xor edx,edx
mov eax,ebx
call memset
; 253 WinSendMsg(work->hwndCnr, CM_SETCNRINFO,
push 04h
; 251 cnrinfo.cb = sizeof(cnrinfo);
mov dword ptr [ebp-088h],05ch; cnrinfo
; 253 WinSendMsg(work->hwndCnr, CM_SETCNRINFO,
push ebx
mov ebx,[ebp+0ch]; work
push 0349h
; 252 cnrinfo.flWindowAttr = CV_TREE|CV_ICON |CA_TREELINE;
mov dword ptr [ebp-074h],0400044h; cnrinfo
; 253 WinSendMsg(work->hwndCnr, CM_SETCNRINFO,
push dword ptr [ebx+08h]
call WinSendMsg
; 259 work->hwndNonePopup = WinLoadMenu(HWND_OBJECT, NULLHANDLE, IDPM_NODRV);
push 01b0h
push 0h
push 02h
call WinLoadMenu
; 260 work->hwndSngPopup = WinLoadMenu(HWND_OBJECT, NULLHANDLE, IDPM_SNGDRV);
push 01aeh
; 259 work->hwndNonePopup = WinLoadMenu(HWND_OBJECT, NULLHANDLE, IDPM_NODRV);
mov [ebx+010h],eax
; 260 work->hwndSngPopup = WinLoadMenu(HWND_OBJECT, NULLHANDLE, IDPM_SNGDRV);
push 0h
push 02h
call WinLoadMenu
; 261 work->hwndMulPopup = WinLoadMenu(HWND_OBJECT, NULLHANDLE, IDPM_MULDRV);
push 01afh
; 260 work->hwndSngPopup = WinLoadMenu(HWND_OBJECT, NULLHANDLE, IDPM_SNGDRV);
mov [ebx+014h],eax
; 261 work->hwndMulPopup = WinLoadMenu(HWND_OBJECT, NULLHANDLE, IDPM_MULDRV);
push 0h
push 02h
call WinLoadMenu
add esp,034h
; 262 if( work->hwndSngPopup == NULLHANDLE
cmp dword ptr [ebx+014h],0h
; 261 work->hwndMulPopup = WinLoadMenu(HWND_OBJECT, NULLHANDLE, IDPM_MULDRV);
mov [ebx+018h],eax
; 262 if( work->hwndSngPopup == NULLHANDLE
je @BLBL8
test eax,eax
je @BLBL8
cmp dword ptr [ebx+010h],0h
jne @BLBL9
@BLBL8:
; 265 Verbose(1, "DrvSetup", "WinLoadMenu failed (last error %#x)",
mov ebx,[ebp+0ch]; work
push dword ptr [ebx+04h]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE6
sub esp,0ch
mov edx,offset FLAT:@CBE3
mov eax,01h
call Verbose
add esp,014h
; 266 WinGetLastError(work->hab));
@BLBL9:
; 267 Verbose(3, "DrvSetup", "popup menues %#x,%#x,%#x",
mov ebx,[ebp+0ch]; work
mov ecx,offset FLAT:@CBE7
push dword ptr [ebx+010h]
mov edx,offset FLAT:@CBE3
push dword ptr [ebx+018h]
mov eax,03h
push dword ptr [ebx+014h]
sub esp,0ch
call Verbose
add esp,018h
; 272 return 0;
add esp,08ch
xor eax,eax
pop edi
pop ebx
pop ebp
ret
CreateCnr__FUlP5_WORK endp
; 183 LoadPresParam(char * app)
LoadPresParam__FPc proc
sub esp,08h
; 185 if( rgbBackground == RGB_ERROR )
cmp dword ptr @2rgbBackground,0ffffff01h
; 183 LoadPresParam(char * app)
push ebx
; 185 if( rgbBackground == RGB_ERROR )
jne @BLBL3
; 189 rgbBackground = WinQuerySysColor(HWND_DESKTOP, SYSCLR_WINDOW, 0);
push 0h
; 185 if( rgbBackground == RGB_ERROR )
mov ebx,eax
; 189 rgbBackground = WinQuerySysColor(HWND_DESKTOP, SYSCLR_WINDOW, 0);
push 0ffffffech
push 01h
call WinQuerySysColor
; 191 ProfileRead(app, "Background", &cb, &rgbBackground);
push offset FLAT:@2rgbBackground
; 189 rgbBackground = WinQuerySysColor(HWND_DESKTOP, SYSCLR_WINDOW, 0);
mov dword ptr @2rgbBackground,eax
; 190 cb = sizeof(rgbBackground);
mov dword ptr [esp+018h],04h; cb
; 191 ProfileRead(app, "Background", &cb, &rgbBackground);
sub esp,0ch
mov edx,offset FLAT:@CBE1
lea ecx,[esp+024h]; cb
mov eax,ebx
call ProfileRead
mov eax,ebx
add esp,01ch
; 192 }
@BLBL3:
; 193 if( rgbForeground == RGB_ERROR )
cmp dword ptr @3rgbForeground,0ffffff01h
jne @BLBL4
; 197 rgbForeground = WinQuerySysColor(HWND_DESKTOP, SYSCLR_OUTPUTTEXT, 0);
push 0h
; 193 if( rgbForeground == RGB_ERROR )
mov ebx,eax
; 197 rgbForeground = WinQuerySysColor(HWND_DESKTOP, SYSCLR_OUTPUTTEXT, 0);
push 0ffffffe5h
push 01h
call WinQuerySysColor
; 199 ProfileRead(app, "Foreground", &cb, &rgbForeground );
push offset FLAT:@3rgbForeground
; 197 rgbForeground = WinQuerySysColor(HWND_DESKTOP, SYSCLR_OUTPUTTEXT, 0);
mov dword ptr @3rgbForeground,eax
; 199 ProfileRead(app, "Foreground", &cb, &rgbForeground );
sub esp,0ch
; 197 rgbForeground = WinQuerySysColor(HWND_DESKTOP, SYSCLR_OUTPUTTEXT, 0);
mov eax,ebx
; 198 cb = sizeof(rgbForeground);
mov dword ptr [esp+020h],04h; cb
; 199 ProfileRead(app, "Foreground", &cb, &rgbForeground );
lea ecx,[esp+020h]; cb
mov edx,offset FLAT:@CBE2
call ProfileRead
add esp,01ch
; 200 }
@BLBL4:
; 201 return;
pop ebx
add esp,08h
ret
LoadPresParam__FPc endp
CODE32 ends
end
| 20.343092 | 85 | 0.690168 |
88d0b26b1d393aaf97524b535020923fbdad39fe | 118 | asm | Assembly | Read/read_double.asm | berkcetinsaya/MIPSLanguageExamples | e1ec7ae15a38621e09fcf211f033497c495ee06b | [
"Apache-2.0"
] | null | null | null | Read/read_double.asm | berkcetinsaya/MIPSLanguageExamples | e1ec7ae15a38621e09fcf211f033497c495ee06b | [
"Apache-2.0"
] | null | null | null | Read/read_double.asm | berkcetinsaya/MIPSLanguageExamples | e1ec7ae15a38621e09fcf211f033497c495ee06b | [
"Apache-2.0"
] | null | null | null | .text
li $v0, 7 # service code 7 to read .double
# input will be stored in $f0
syscall # to execute the service
| 23.6 | 43 | 0.677966 |
864fa795fa1de9110ebcba860feafac76f50ee5b | 77 | asm | Assembly | libsrc/math/mbf32/c/asm/___mbf32_LOG.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/math/mbf32/c/asm/___mbf32_LOG.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/math/mbf32/c/asm/___mbf32_LOG.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z | SECTION code_fp_mbf32
PUBLIC ___mbf32_LOG
EXTERN LOG
defc ___mbf32_LOG = LOG
| 15.4 | 23 | 0.857143 |
4f23491cb6d20e0ff6622ade89205efe3fd7f349 | 667 | asm | Assembly | programs/oeis/070/A070354.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/070/A070354.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/070/A070354.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A070354: a(n) = 3^n mod 16.
; 1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3,9,11,1,3
mod $0,4
mov $1,$0
lpb $0,1
sub $0,2
add $1,2
lpe
mul $1,2
add $1,1
| 55.583333 | 563 | 0.548726 |
a85f85ca4edc9d7f3c30e1c426c384fcbd61c934 | 810 | asm | Assembly | data/mapObjects/Route25.asm | AmateurPanda92/pokemon-rby-dx | f7ba1cc50b22d93ed176571e074a52d73360da93 | [
"MIT"
] | 9 | 2020-07-12T19:44:21.000Z | 2022-03-03T23:32:40.000Z | data/mapObjects/Route25.asm | JStar-debug2020/pokemon-rby-dx | c2fdd8145d96683addbd8d9075f946a68d1527a1 | [
"MIT"
] | 7 | 2020-07-16T10:48:52.000Z | 2021-01-28T18:32:02.000Z | data/mapObjects/Route25.asm | JStar-debug2020/pokemon-rby-dx | c2fdd8145d96683addbd8d9075f946a68d1527a1 | [
"MIT"
] | 2 | 2021-03-28T18:33:43.000Z | 2021-05-06T13:12:09.000Z | Route25_Object:
db $2c ; border block
db 1 ; warps
warp 45, 3, 0, BILLS_HOUSE
db 1 ; signs
sign 43, 3, 11 ; Route25Text11
db 10 ; objects
object SPRITE_BUG_CATCHER, 14, 2, STAY, DOWN, 1, OPP_YOUNGSTER, 5
object SPRITE_BUG_CATCHER, 18, 5, STAY, UP, 2, OPP_YOUNGSTER, 6
object SPRITE_BLACK_HAIR_BOY_1, 24, 4, STAY, DOWN, 3, OPP_JR_TRAINER_M, 2
object SPRITE_LASS, 18, 8, STAY, RIGHT, 4, OPP_LASS, 9
object SPRITE_BUG_CATCHER, 32, 3, STAY, LEFT, 5, OPP_YOUNGSTER, 7
object SPRITE_LASS, 37, 4, STAY, DOWN, 6, OPP_LASS, 10
object SPRITE_HIKER, 8, 4, STAY, RIGHT, 7, OPP_HIKER, 2
object SPRITE_HIKER, 23, 9, STAY, UP, 8, OPP_HIKER, 3
object SPRITE_HIKER, 13, 7, STAY, RIGHT, 9, OPP_HIKER, 4
object SPRITE_BALL, 22, 2, STAY, NONE, 10, TM_19
; warp-to
warp_to 45, 3, ROUTE_25_WIDTH ; BILLS_HOUSE
| 33.75 | 74 | 0.711111 |
8dae64ed7968cd63ce4d201e4b064d9c5e993a33 | 695 | asm | Assembly | oeis/136/A136557.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/136/A136557.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/136/A136557.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A136557: a(n) = Sum_{k=0..n} binomial(2^k + n-k-1, k).
; Submitted by Simon Strandgaard
; 1,2,6,45,1436,171836,68149425,89431630740,396956313475102,6099399658235428041,331007760926212498510464,64484289650612910347505873728,45677712418497545460138258802186905,118839865015562658165188156089307452422800,1144687031207024129665942123506904936168792319810,41082677532261722628878416854680586666911801778287585993,5522782981689393897272208429754210084594590369927656976682905444,2793143568955316076231149273403606016638055239416602607089054644596141924
mov $2,$0
mov $5,$0
lpb $2
mov $0,$5
sub $2,1
sub $0,$2
mov $3,$5
add $4,1
bin $3,$4
add $1,$3
add $5,$0
lpe
mov $0,$1
add $0,1
| 36.578947 | 459 | 0.811511 |
ca482f5877b6d4bc05e089e14533554d9daa7860 | 1,299 | asm | Assembly | Gilaion5-Elhanan/q1.asm | Avigdor-Kolonimus/ASM | 23327c9765ab1cc6bfe3dfaaa9a129dda5aac77a | [
"MIT"
] | null | null | null | Gilaion5-Elhanan/q1.asm | Avigdor-Kolonimus/ASM | 23327c9765ab1cc6bfe3dfaaa9a129dda5aac77a | [
"MIT"
] | null | null | null | Gilaion5-Elhanan/q1.asm | Avigdor-Kolonimus/ASM | 23327c9765ab1cc6bfe3dfaaa9a129dda5aac77a | [
"MIT"
] | null | null | null | DATA SEGMENT
A DB 1,8,2,1,12,2,14,1
NA DB 8
B DB 7,1,1,7,8,10,7,7,1,1
NB DB 10
C DB 18 DUP (?)
NC DB 0
DATA ENDS
sseg segment stack
dw 100h dup(?)
sseg ends
cseg segment
assume ds:DATA,cs:cseg,ss:sseg
sort proc
L5: mov al,C[di]
cmp al,C[di+1]
jbe L4
xchg al,C[di+1]
mov C[di],al
mov ah,1
;promotion of array C
L4: inc di
loop L5
ret
sort endp
start: mov ax,DATA
mov ds,ax
;initialization for A
mov ax,0
mov si,0
mov cx,0
mov cl,NA
;transfer of the array A to the array C
L1: mov al,A[si]
mov C[si],al
inc si
inc NC
loop L1
;initialization for B
mov di,0
mov cl,NB
;transfer of the array B to the array C
L2: mov al,B[di]
mov C[si],al
inc si
inc di
inc NC
loop L2
;sorting of the array C
L3: mov ax,0
mov di,0
mov cl,NC
call sort
cmp ah,0
jne L3
;delete duplicate
xor si,si
mov cl,NC
dec cl
jz SOF
L8: mov al,C[si]
cmp al,C[si+1]
jne L6
;duplicate
mov di,si
inc di
mov ah,cl
dec ah
L7: mov al,C[di+1]
mov C[di],al
inc di
dec ah
jnz L7
mov C[di],0
dec NC
loop L8
jmp SOF
;not duplicate
L6: inc si
loop L8
SOF: mov ah,4ch
int 21h
cseg ends
end start
| 14.931034 | 43 | 0.56428 |
0b172f1d90248674d861bcb58419f1a19e1b137f | 614 | asm | Assembly | hello-world/pointer.asm | RossRKK/c64-tests | adef0f7c66ea44759ca72444415fc95d01ae2835 | [
"MIT"
] | null | null | null | hello-world/pointer.asm | RossRKK/c64-tests | adef0f7c66ea44759ca72444415fc95d01ae2835 | [
"MIT"
] | null | null | null | hello-world/pointer.asm | RossRKK/c64-tests | adef0f7c66ea44759ca72444415fc95d01ae2835 | [
"MIT"
] | null | null | null | *=$1000
;take the text pointer and load it into the memory address that's used as an
;argument fo print_str
ldx >text_ptr
stx print_ptr
ldx <text_ptr
stx print_ptr+1
jmp print_str
text_ptr
.null "hello, world!"
chrout = $ffd2
print_ptr = $2000
print_str
lda print_ptr,x ;load the current char into the accumulator
; check if the character is null
cmp #$0 ;compare the accumulator to 0
beq loop ;trap us in a loop if this is null
jsr chrout ;print the character using kernal sub-routine
inx ;move the text cursor
;jump back to the next character
jmp print_str
loop jmp loop
| 19.1875 | 76 | 0.726384 |
7daf2b7c742661014db5e50b6f2e580c052cc172 | 556 | asm | Assembly | src/libYARP_dev/56f807/cotroller_dc/Support/Fp568d.asm | robotology-legacy/yarp1 | 21434f5b776edea201b39a9644552dca59339dbc | [
"Artistic-1.0-Perl"
] | null | null | null | src/libYARP_dev/56f807/cotroller_dc/Support/Fp568d.asm | robotology-legacy/yarp1 | 21434f5b776edea201b39a9644552dca59339dbc | [
"Artistic-1.0-Perl"
] | null | null | null | src/libYARP_dev/56f807/cotroller_dc/Support/Fp568d.asm | robotology-legacy/yarp1 | 21434f5b776edea201b39a9644552dca59339dbc | [
"Artistic-1.0-Perl"
] | null | null | null | ;=============================================================
;=== FILE: Fp568d.asm
;===
;=== Copyright (c)1998 Metrowerks, Inc. All rights reserved.
;=============================================================
; Recommended tab stop = 8.
;===============================================================================
; GLOBAL DATA: fpe_state -- one word of state per process, indicating the
; prevailing rouding mode and holding the sticky exception flags.
;
SECTION fp_state GLOBAL
GLOBAL FPE_state
ORG X:
FPE_state:
DC $0000
ENDSEC
| 25.272727 | 80 | 0.444245 |
34048e15bc702eb6ccec4418fe3149e0004682f8 | 5,626 | asm | Assembly | base/mvdm/wow16/toolhelp/terminat.asm | npocmaka/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 17 | 2020-11-13T13:42:52.000Z | 2021-09-16T09:13:13.000Z | base/mvdm/wow16/toolhelp/terminat.asm | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 2 | 2020-10-19T08:02:06.000Z | 2020-10-19T08:23:18.000Z | base/mvdm/wow16/toolhelp/terminat.asm | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 14 | 2020-11-14T09:43:20.000Z | 2021-08-28T08:59:57.000Z | PAGE 60,150
;***************************************************************************
;* TERMINAT.ASM
;*
;* Assembly code routine used for the TOOLHELP.DLL app terminate
;* routine.
;*
;***************************************************************************
INCLUDE TOOLPRIV.INC
INCLUDE TDB.INC
;** Symbols
I_EXCEPTION EQU 0
I_INTERRUPT EQU 1
MAX_INTERRUPT EQU 5
GIVE_WDEB386 EQU 8000h
Q_HACK_30 EQU 54h
.286p
;** Data
sBegin DATA
wTermFlags DW ? ;Save terminate flags across Yield
sEnd
;** Imported values
externFP InterruptUnRegister
externFP NotifyUnRegister
externFP GetCurrentTask
externFP FatalAppExit
externFP TaskSetCSIP
externFP DirectedYield
externFP TaskSwitch
sBegin CODE
assumes CS,CODE
assumes DS,DATA
; TerminateApp
; Terminates the task in one of two ways: TERMINATE_NORMAL or
; TERMINATE_USER_DISPLAY. TERMINATE_NORMAL calls KERNEL to display
; the UAE box and terminates the app. TERMINATE_USER_DISPLAY also
; terminates the app but assumes the user has displayed some warning.
; If the task passed in is not the current task, this function does
; the DirectedYield() to switch to the correct task before terminating
; it.
; This function does not return when terminating the current task
; except when WDEB386 is installed and the (undocumented) GIVE_WDEB386
; flag is set.
; Caller: TerminateApp(
; HANDLE hTask, (If NULL, does current task)
; WORD wFlags)
cProc TerminateApp, <FAR,PUBLIC>, <si,di,ds>
parmW hTask
parmW wFlags
cBegin
mov ax, _DATA ;Get our DS
mov ds, ax
;** Save the flags in the DS so we can get after DYield
mov ax,wFlags ;Get the parameter flags
mov wTermFlags,ax ;Save them
;** Get the task value
cCall GetCurrentTask ;Get the task
mov si,hTask ;Get the hTask value
or si,si ;Zero?
jnz TA_10 ;No
mov es,ax ;Point ES at current task
jmp SHORT TA_NukeCurrent ;In this case we always nuke current
TA_10:
;** If this is the current task, just nuke it and don't return
cmp ax,si ;Current?
mov es,si ;Point ES at task
je TA_NukeCurrent ;Yes, nuke it directly
;** Switch to the new task and prepare to nuke it
lea ax,TA_NewTask ;Get address of new task entry
cCall TaskSwitch, <si,cs,ax> ;Switch to this task
jmp SHORT TA_End ;Get out
;** We're in the new task now
TA_NewTask:
mov ax,_DATA ;Get the TOOLHELP DS
mov ds,ax
mov es,segKernel ;Get the KERNEL segment
mov bx,npwTDBCur ;Get the current task pointer
mov es,es:[bx] ;Get the TDB pointer in ES
;** HACK ALERT!!!! In order to get USER to allow us to terminate
;* this app, we are manually nuking the semaphore. This is
;* at a fixed offsets in the Q structure and only needs to
;** be done in 3.0
test wTHFlags,TH_WIN30 ;In 3.0?
jz TA_NukeCurrent ;No, don't do this ugly hack
push es ;Save ES while we play with the queue
mov es,es:[TDB_Queue] ;ES points to queue now
mov bx,Q_HACK_30 ;Get 3.0 offset
mov WORD PTR es:[bx],0 ;Clear the semaphore count
mov WORD PTR es:[bx + 2],0 ; and the semaphore value to wait for
pop es ;ES points to TDB again
TA_NukeCurrent:
;** Check the flag values. If NO_UAE_BOX, tell KERNEL
;** not to display the normal UAE box.
test wTermFlags,NO_UAE_BOX ;Display the box?
jz TA_20 ;Yes, so skip this stuff
or es:[TDB_ErrMode],02 ;Set the no display box flag
TA_20:
;** Terminate the app using KERNEL
cCall FatalAppExit, <0,0,0> ;Do it
;** If we're flagged that this is an internal terminate, we just want
;* to return if WDEB is installed so that we can pass the
;** fault on. To do this, we must return here to the caller.
test wFlags,GIVE_WDEB386 ;Internal entry?
jnz TA_End ;Yes, don't nuke app
;** If KERNEL doesn't nuke the app (does this if WDEB386
;** is installed), nuke it ourselves (no UAE box)
mov es,segKernel ;Get the KERNEL segment
mov bx,npwTDBCur ;Get the current task pointer
mov es,es:[bx] ; in ES
cmp WORD PTR es:[TDB_USignalProc] + 2,0 ;USER signal proc?
jz @F ;No
mov bx,0666h ;Death knell
mov di, -1
cCall es:[TDB_USignalProc],<es,bx,di,es:[TDB_Module],es:[TDB_Queue]>
@@: mov ax,4CFFH ;Nuke the app
int 21h ;We don't return here
TA_End:
cEnd
sEnd
END
| 38.534247 | 79 | 0.518663 |
c0331d3f5f978be4de2e29d34d27980f5d15ee47 | 5,990 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_380_449.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_380_449.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_380_449.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r8
push %r9
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x1d631, %rsi
lea addresses_A_ht+0xe351, %rdi
nop
sub %rax, %rax
mov $20, %rcx
rep movsq
nop
sub $10862, %rbx
lea addresses_WC_ht+0x2c31, %rsi
lea addresses_A_ht+0x4e4d, %rdi
clflush (%rsi)
nop
sub %r9, %r9
mov $99, %rcx
rep movsq
nop
nop
nop
nop
nop
xor %rsi, %rsi
lea addresses_D_ht+0x1e3b5, %rcx
cmp %r13, %r13
movups (%rcx), %xmm0
vpextrq $0, %xmm0, %rsi
nop
nop
nop
nop
xor $33736, %rbx
lea addresses_D_ht+0x8651, %rsi
lea addresses_A_ht+0x9e31, %rdi
nop
nop
nop
nop
nop
inc %rax
mov $117, %rcx
rep movsq
nop
nop
nop
nop
nop
xor $56730, %rax
lea addresses_A_ht+0x19e31, %rax
nop
nop
dec %rbx
mov (%rax), %rdi
xor %rax, %rax
lea addresses_WC_ht+0x122e1, %rsi
nop
nop
nop
nop
sub $19658, %rax
mov $0x6162636465666768, %rbx
movq %rbx, %xmm1
movups %xmm1, (%rsi)
nop
nop
nop
nop
cmp %r13, %r13
lea addresses_normal_ht+0x67c1, %rsi
lea addresses_A_ht+0xdef1, %rdi
and %r8, %r8
mov $122, %rcx
rep movsl
nop
xor %rbx, %rbx
lea addresses_normal_ht+0x9f59, %rcx
nop
nop
nop
sub %rdi, %rdi
mov (%rcx), %si
nop
nop
nop
and %rbx, %rbx
lea addresses_WC_ht+0xe231, %rsi
lea addresses_normal_ht+0x2b31, %rdi
clflush (%rsi)
add %r8, %r8
mov $30, %rcx
rep movsw
nop
nop
nop
nop
xor $8288, %rdi
lea addresses_normal_ht+0x1aef1, %rdi
clflush (%rdi)
nop
inc %rsi
movw $0x6162, (%rdi)
nop
nop
add $59961, %r9
lea addresses_D_ht+0xa931, %r9
inc %rbx
movw $0x6162, (%r9)
nop
nop
nop
nop
nop
xor $44904, %r13
lea addresses_WC_ht+0x14631, %rsi
lea addresses_WT_ht+0xcb31, %rdi
nop
and $11760, %rbx
mov $75, %rcx
rep movsb
nop
nop
nop
nop
and %r8, %r8
lea addresses_normal_ht+0x3901, %rsi
lea addresses_D_ht+0x1dd31, %rdi
and $58340, %r9
mov $54, %rcx
rep movsl
nop
nop
nop
and %r8, %r8
lea addresses_WT_ht+0x1e49, %rsi
lea addresses_D_ht+0x15c31, %rdi
nop
nop
nop
nop
nop
inc %rax
mov $90, %rcx
rep movsb
nop
nop
and $45992, %rbx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r9
pop %r8
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
// Store
mov $0x3ff0ca0000000f21, %rsi
nop
nop
inc %rcx
movw $0x5152, (%rsi)
nop
nop
dec %rsi
// Faulty Load
lea addresses_WT+0x18631, %rax
xor %rbx, %rbx
movb (%rax), %cl
lea oracles, %rbx
and $0xff, %rcx
shlq $12, %rcx
mov (%rbx,%rcx,1), %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_WT', 'same': False, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_NC', 'same': False, 'size': 2, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_WT', 'same': True, 'size': 1, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_UC_ht', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': True}, 'OP': 'REPM'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 16, 'congruent': 2, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'congruent': 2, 'same': True}, 'dst': {'type': 'addresses_A_ht', 'congruent': 9, 'same': True}, 'OP': 'REPM'}
{'src': {'type': 'addresses_A_ht', 'same': False, 'size': 8, 'congruent': 11, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_WC_ht', 'same': False, 'size': 16, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 6, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 2, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 2, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 2, 'congruent': 7, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 8, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}, 'OP': 'REPM'}
{'39': 380}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
| 26.387665 | 1,139 | 0.655927 |
7fad5b89808d714984402d798565f18647da4257 | 2,520 | asm | Assembly | programs/oeis/282/A282154.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/282/A282154.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/282/A282154.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A282154: Coefficients in expansion of Eisenstein series -q*(d/dq)(q*(d/dq)E_2).
; 0,24,288,864,2688,3600,10368,9408,23040,25272,43200,34848,96768,56784,112896,129600,190464,124848,303264,173280,403200,338688,418176,304704,829440,465000,681408,699840,1053696,605520,1555200,738048,1548288,1254528,1498176,1411200,2830464,1248528,2079360,2044224,3456000,1694448,4064256,1952544,3902976,3790800,3656448,2544768,6856704,3284568,5580000,4494528,6359808,3640464,8398080,5227200,9031680,6238080,7266240,5012640,14515200,5536848,8856576,9906624,12484608,8517600,15054336,7326048,13982976,10969344,16934400,8710848,24261120,9464304,14982336,16740000,19407360,13660416,24530688,11982720,28569600,19053144,20333376,13888224,37933056,18727200,23430528,21798720,33454080,17109360,45489600,22259328,34126848,26569728,30537216,25992000,55738368,22129968,39414816,36694944,52080000,24972048,53934336,26480064,54512640,50803200,43685568,29675808,78382080,31365840,62726400,44947008,74661888,34935984,74856960,45705600,67818240,59793552,60151680,48940416,124416000,46734072,66442176,61000128,82661376,58500000,118879488,49548288,100270080,70291584,102211200,54366048,140507136,67925760,87912576,104976000,119854080,62162928,131632128,64918560,158054400,91611648,104530176,82450368,200558592,90828000,113571648,118244448,139835136,79923600,200880000,83178048,166348800,131464944,163924992,110707200,228953088,93469008,143792640,131056704,232243200,119443968,228637728,104575584,189778176,188179200,166658688,112448448,325140480,125439912,224726400,182463840,218684928,124983504,261584640,182280000,276553728,180455040,205312320,138417120,424569600,143100048,267111936,199326528,292515840,187279200,318836736,181279296,285014016,274337280,311904000,168104448,449445888,173431344,265559616,306633600,367871616,184420368,440339328,190084800,446400000,263737728,299664576,237363840,503387136,254167200,317760768,320853312,450637824,251602560,609638400,226522848,407731968,313590528,356109696,292881600,671846400,289314816,376390080,340714944,585446400,295390368,539364096,267343104,606928896,489645000,419231808,281966688,698664960,289474320,548467200,491774976,581299200,304887024,717522624,381715200,561415680,431377920,587284992,329016960,1028505600,337334448,560808864,515852064,620126976,492685200,732001536,409980480,708526080,499976064
cal $0,282097 ; Coefficients in q-expansion of (3*E_2*E_4 - 2*E_6 - E_2^3)/1728, where E_2, E_4, E_6 are the Eisenstein series shown in A006352, A004009, A013973, respectively.
mov $1,$0
mul $1,24
| 360 | 2,239 | 0.868651 |
42c77de20e253259a057c9fa4c56530f2aebc2e9 | 684 | asm | Assembly | oeis/085/A085354.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/085/A085354.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/085/A085354.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A085354: a(n) = 3*4^n - (n+4)*2^(n-1).
; 1,7,36,164,704,2928,11968,48448,195072,783104,3138560,12567552,50298880,201256960,805158912,3220914176,12884246528,51538231296,206155546624,824627691520,3298522300416,13194113318912,52776503607296,211106119286784,844424695250944,3377699233988608,13510797875478528,54043193448071168,216172777818816512,864691119596765184,3458764495566929920,13835058017701199872,55340232143819243520,221360928725600829440,885443715211640963072,3541774861482219012096,14167099447234546106368,56668397791618244018176
mov $1,$0
lpb $1
mov $2,$1
sub $1,1
seq $2,54127 ; a(1) = 2; a(n) = 9*2^(n-2) - n - 2, n>1.
add $0,$2
mul $0,2
lpe
div $0,2
add $0,1
| 48.857143 | 498 | 0.789474 |
d455bdd605dc05d1ba2d1cbb102e60f90e35a356 | 11,035 | asm | Assembly | logo.asm | gidouin/pacifist-emulator | ec3bb9ffcabf35ea8b3f8a295232f80120e7c942 | [
"Apache-2.0"
] | 9 | 2015-10-30T02:34:34.000Z | 2022-03-13T10:50:34.000Z | logo.asm | gidouin/pacifist-emulator | ec3bb9ffcabf35ea8b3f8a295232f80120e7c942 | [
"Apache-2.0"
] | null | null | null | logo.asm | gidouin/pacifist-emulator | ec3bb9ffcabf35ea8b3f8a295232f80120e7c942 | [
"Apache-2.0"
] | 3 | 2015-10-26T15:53:47.000Z | 2021-11-05T08:31:22.000Z | ;
; bin2asm by Altomcat/Sector One Jan/95
;
;fichier de base : PACILOGO.BIN
DD 0E200E20h,0E200E20h,0E200E20h,0E200E20h,0E200E20h
DD 0E200E20h,0E200E20h,0E200E20h,0E200E20h,0E200E20h
DD 0E200E20h,0E200E20h,0E200E20h,0E200E20h,0E200E20h
DD 07200E20h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,01200720h,01200120h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,047204720h,047204720h,047204720h,047204720h
DD 047204720h,047204720h,047204720h,047204720h,047204720h
DD 047204720h,047204720h,047204720h,07204720h,07200720h
DD 01200020h,01200120h,07200120h,07200720h,07200720h
DD 047204720h,047204720h,047204720h,047204720h,06204720h
DD 07200720h,07200720h,07200720h,047200720h,047204720h
DD 047204720h,047204720h,047204720h,07204720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 047200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,047200720h,07200720h
DD 01200120h,07200120h,07200720h,07200720h,047204720h
DD 07200720h,07200720h,07200720h,07200720h,046200720h
DD 07200620h,07200720h,07200720h,07204720h,07200720h
DD 07200720h,07200720h,07200720h,047200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,047200720h
DD 07204720h,07200720h,0EDB0620h,0EDB0EDBh,0EDB0EDBh
DD 0EDB0EDBh,0EDB0EDBh,0EDB0EDBh,0EDB0EDBh,0EDB0EDBh
DD 0EDB0EDBh,0EDB0EDBh,0EDB0EDBh,047200720h,07200720h
DD 01200120h,07200120h,07200720h,047200720h,07200720h
DD 0EDB0720h,0EDB0EDBh,0EDB0EDBh,0EDB0EDBh,07200620h
DD 07204720h,07200720h,047200720h,07200720h,06200620h
DD 0EDB0EDBh,0EDB0EDBh,0EDB0EDBh,047200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07204720h
DD 07200720h,0EDB0EDBh,0EDB0EDBh,07200EDBh,07200720h
DD 07200720h,07200720h,07200720h,0EDB0720h,0EDB0EDBh
DD 07200720h,07200720h,07200720h,047200720h,07200720h
DD 01200120h,07200120h,07200720h,07204720h,0EDB0720h
DD 0EDB0EDBh,07200720h,0EDB0720h,0EDB0EDBh,07200EDBh
DD 047200720h,07200720h,047200720h,06200720h,0EDB0EDBh
DD 0EDB0EDBh,07200720h,07200720h,047200720h,07200720h
DD 047204720h,047204720h,047204720h,07200720h,07204720h
DD 0EDB0620h,0EDB0EDBh,07200720h,07200720h,07200720h
DD 07200720h,047204720h,07204720h,0EDB0720h,0EDB0EDBh
DD 07200720h,047200720h,047204720h,07204720h,07200720h
DD 01200120h,07200120h,047200720h,07200720h,0EDB0EDBh
DD 07200EDBh,07200720h,07200720h,0EDB0EDBh,0EDB0EDBh
DD 07200720h,047204720h,07204720h,0EDB0720h,0EDB0EDBh
DD 07200720h,07200720h,07200720h,047204720h,047204720h
DD 07200720h,07200720h,07200720h,047204720h,07200720h
DD 0EDB0720h,0EDB0EDBh,07200EDBh,07200720h,07200720h
DD 047200720h,07200720h,047200720h,0EDB0720h,0EDB0EDBh
DD 07200720h,07204720h,07200720h,07200720h,07200720h
DD 018201820h,018201820h,047201820h,07200720h,0EDB0EDBh
DD 07200720h,07200720h,0EDB0720h,0EDB0EDBh,07200EDBh
DD 07200720h,07200720h,07200720h,0EDB0EDBh,07200EDBh
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 028200720h,028202820h,07202820h,07200720h,07200720h
DD 07200720h,0EDB0EDBh,0EDB0EDBh,07200EDBh,07200720h
DD 07200720h,018204720h,047201820h,07200720h,0EDB0EDBh
DD 07200EDBh,018204720h,018201820h,018201820h,018201820h
DD 018201820h,018201820h,047201820h,0EDB0720h,0EDB0EDBh
DD 0EDB0EDBh,0EDB0EDBh,0EDB0EDBh,07200EDBh,07200720h
DD 07200720h,07200720h,0EDB0720h,0EDB0EDBh,07200EDBh
DD 07200720h,07200720h,028200720h,07202820h,07200720h
DD 028202820h,07200F20h,06200720h,07200720h,028202820h
DD 07200720h,07200720h,0EDB0720h,0EDB0EDBh,0EDB0EDBh
DD 07200620h,047200720h,018201820h,07204720h,0EDB0EDBh
DD 07200EDBh,047200720h,018201820h,018201820h,018201820h
DD 018201820h,018201820h,07204720h,0EDB0720h,0EDB0EDBh
DD 07200720h,07200720h,07200720h,07200720h,028202820h
DD 07202820h,07200720h,0EDB0720h,0EDB0EDBh,07200EDBh
DD 07200720h,07200720h,07200720h,07200720h,06200720h
DD 028202820h,06200620h,0F200F20h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,0EDB0EDBh
DD 06200EDBh,047200720h,018201820h,07204720h,0EDB0720h
DD 0EDB0EDBh,07200720h,018204720h,018201820h,018201820h
DD 018201820h,018201820h,07204720h,0EDB0EDBh,0EDB0EDBh
DD 07200720h,047204720h,07200720h,028200720h,07202820h
DD 028202820h,07200720h,07200720h,0EDB0EDBh,0EDB0EDBh
DD 07200720h,07200720h,028200720h,07202820h,06200720h
DD 028202820h,028202820h,07202820h,07200720h,028202820h
DD 07200720h,07200720h,07200720h,0EDB0720h,0EDB0EDBh
DD 06200EDBh,047200720h,018201820h,047201820h,0EDB0720h
DD 0EDB0EDBh,07200720h,018204720h,018201820h,018201820h
DD 018201820h,018201820h,07204720h,0EDB0EDBh,07200EDBh
DD 047200720h,018201820h,07204720h,028200720h,028202820h
DD 028202820h,07200720h,07200720h,0EDB0720h,0EDB0EDBh
DD 07200EDBh,07200720h,07200720h,028202820h,06200720h
DD 028202820h,06200620h,07200720h,028200720h,07202820h
DD 06200720h,07200620h,0EDB0720h,0EDB0EDBh,0EDB0EDBh
DD 07200720h,047200720h,018201820h,047201820h,07200720h
DD 0EDB0EDBh,07200EDBh,047200720h,018201820h,018201820h
DD 01200120h,07200120h,07204720h,0EDB0EDBh,07200720h
DD 07204720h,07200720h,07204720h,028200720h,07202820h
DD 028202820h,07202820h,047200720h,07200720h,0EDB0EDBh
DD 0EDB0EDBh,0EDB0EDBh,07200EDBh,028200720h,07202820h
DD 028202820h,07200720h,07200720h,028202820h,07200720h
DD 07200720h,0EDB0EDBh,0EDB0EDBh,07200EDBh,07200720h
DD 047200720h,07204720h,07200720h,07200720h,07204720h
DD 0EDB0720h,0EDB0EDBh,047200720h,07200720h,07200720h
DD 01200120h,07200120h,07204720h,07200720h,047200720h
DD 07200720h,07200720h,047200720h,07200720h,07200720h
DD 07200720h,07200720h,07204720h,07204720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,047200720h,07204720h,07200720h,047200720h
DD 07204720h,07200720h,07200720h,07200720h,047204720h
DD 07204720h,07200720h,07200720h,07200720h,047200720h
DD 07200720h,07200720h,047200720h,07200720h,07200720h
DD 01200120h,07200120h,047200720h,047204720h,07204720h
DD 07200720h,07200720h,07200720h,047204720h,047204720h
DD 047204720h,047204720h,07200720h,047200720h,047204720h
DD 047204720h,047204720h,047204720h,047204720h,047204720h
DD 047204720h,07204720h,047200720h,047204720h,07204720h
DD 047200720h,047204720h,047204720h,047204720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 047204720h,047204720h,07204720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
DD 07200720h,07200720h,07200720h,07200720h,07200720h
| 53.309179 | 58 | 0.870231 |
cdc674691f8887d8a6a30de93c465730a79cc493 | 2,670 | asm | Assembly | source/rom10/r10_maps_dur.asm | evanbowman/Red | 85735269a46757305a81ad39f47034bc6cd97846 | [
"BSD-2-Clause"
] | 5 | 2021-08-30T16:18:55.000Z | 2021-10-30T20:23:32.000Z | source/rom10/r10_maps_dur.asm | evanbowman/gbc-project | 85735269a46757305a81ad39f47034bc6cd97846 | [
"BSD-2-Clause"
] | null | null | null | source/rom10/r10_maps_dur.asm | evanbowman/gbc-project | 85735269a46757305a81ad39f47034bc6cd97846 | [
"BSD-2-Clause"
] | null | null | null | ;; generated by encode_room_layouts.py
r10_room_data_dur::
;;0.json
DB $0e, $0e, $0e, $0e, $0e, $08, $39, $39, $39, $39, $0e, $0e, $0e, $0e, $0a, $0e, $0e, $0e, $0e, $0e, $0c, $39, $39, $39, $38, $39, $02, $0e, $0e, $0c, $11, $06, $0e, $0e, $0e, $0e, $08, $39, $38, $39, $39, $39, $39, $06, $0e, $08, $12, $06, $0e, $0e, $0e, $0c, $39, $39, $39, $39, $39, $39, $39, $02, $08, $11, $13, $06, $0e, $0e, $0e, $08, $39, $39, $39, $39, $39, $38, $39, $39, $11, $12, $13, $06, $0e, $0e, $08, $39, $39, $39, $39, $39, $39, $39, $39, $11, $12, $13, $01, $0a, $0e, $0c, $39, $39, $39, $38, $39, $39, $3a, $3a, $11, $12, $13, $13, $39, $39, $0e, $0c, $39, $39, $39, $39, $38, $39, $3a, $3a, $12, $13, $13, $3b, $39, $39, $0e, $0c, $39, $39, $39, $11, $11, $11, $3a, $3a, $13, $3b, $3b, $38, $39, $39, $0e, $0c, $39, $39, $11, $12, $12, $12, $3a, $3a, $13, $39, $39, $39, $39, $39, $0e, $08, $11, $11, $12, $13, $13, $13, $39, $38, $3b, $39, $39, $39, $05, $0d, $08, $11, $12, $12, $13, $13, $13, $3b, $39, $39, $39, $39, $39, $39, $06, $0e, $11, $12, $13, $13, $03, $3b, $3b, $39, $39, $39, $39, $39, $39, $38, $06, $0e, $12, $13, $05, $0d, $0c, $39, $39, $39, $38, $39, $39, $39, $39, $39, $06, $0e, $13, $05, $0e, $0e, $0c, $39, $39, $39, $39, $39, $39, $05, $0d, $0d, $0e, $0e, $05, $0e, $0e, $0e, $0e, $0b, $39, $39, $39, $39, $05, $0e, $0e, $0e, $0e, $0e,
;;1.json
DB $0e, $0e, $0e, $0e, $0e, $08, $39, $39, $39, $39, $0e, $0e, $0e, $0e, $0a, $0e, $0e, $0e, $0e, $0e, $0c, $39, $39, $39, $38, $39, $02, $0e, $0e, $0c, $11, $06, $0e, $0e, $0e, $0e, $08, $39, $38, $39, $39, $39, $39, $06, $0e, $08, $12, $06, $0e, $0e, $0e, $0c, $39, $39, $39, $39, $39, $39, $39, $02, $08, $11, $13, $06, $0e, $0e, $0e, $08, $39, $39, $39, $39, $39, $38, $39, $39, $11, $12, $13, $06, $0e, $0e, $08, $39, $39, $39, $39, $39, $39, $39, $39, $11, $12, $13, $01, $0a, $0e, $0c, $39, $39, $39, $38, $39, $39, $3a, $3a, $11, $12, $13, $13, $39, $39, $0e, $0c, $39, $39, $39, $39, $38, $39, $3a, $3a, $12, $13, $13, $3b, $39, $39, $0e, $0c, $39, $39, $39, $11, $11, $11, $3a, $3a, $13, $3b, $3b, $38, $39, $39, $0e, $0c, $39, $39, $11, $12, $12, $12, $3a, $3a, $13, $39, $39, $39, $39, $39, $0e, $08, $11, $11, $12, $13, $13, $13, $39, $38, $3b, $39, $39, $39, $39, $05, $08, $11, $12, $12, $13, $13, $13, $3b, $39, $39, $39, $39, $39, $39, $39, $06, $11, $12, $13, $13, $03, $3b, $3b, $39, $39, $39, $39, $39, $39, $38, $39, $06, $12, $13, $05, $0d, $0c, $39, $39, $39, $38, $39, $39, $39, $39, $39, $39, $06, $13, $05, $0e, $0e, $0c, $39, $39, $39, $39, $39, $39, $05, $0d, $0d, $0d, $0e, $05, $0e, $0e, $0e, $0e, $0b, $39, $39, $39, $39, $05, $0e, $0e, $0e, $0e, $0e,
r10_room_data_dur_end::
| 296.666667 | 1,283 | 0.414981 |
92bd22a89d56f664edeefe88d1c987f9e039a50e | 4,780 | asm | Assembly | Transynther/x86/_processed/US/_zr_/i9-9900K_12_0xa0.log_21829_1719.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/US/_zr_/i9-9900K_12_0xa0.log_21829_1719.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/US/_zr_/i9-9900K_12_0xa0.log_21829_1719.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r15
push %rcx
push %rdi
lea addresses_WT_ht+0x1afa8, %rcx
nop
nop
nop
nop
nop
dec %rdi
mov $0x6162636465666768, %r13
movq %r13, %xmm4
vmovups %ymm4, (%rcx)
nop
nop
and %r15, %r15
pop %rdi
pop %rcx
pop %r15
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r15
push %r9
push %rbp
push %rbx
push %rdi
// Store
lea addresses_WT+0xe9c8, %r12
xor %rbx, %rbx
movl $0x51525354, (%r12)
nop
nop
nop
cmp %r15, %r15
// Store
lea addresses_RW+0x10388, %r9
nop
nop
dec %rdi
mov $0x5152535455565758, %rbx
movq %rbx, (%r9)
nop
xor %rbp, %rbp
// Store
lea addresses_WC+0xc4fa, %r9
nop
nop
nop
nop
add $6826, %r12
movl $0x51525354, (%r9)
nop
nop
nop
xor %r9, %r9
// Faulty Load
lea addresses_US+0x12a8, %r12
nop
nop
add $24573, %rbp
mov (%r12), %r9d
lea oracles, %rbp
and $0xff, %r9
shlq $12, %r9
mov (%rbp,%r9,1), %r9
pop %rdi
pop %rbx
pop %rbp
pop %r9
pop %r15
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_US', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_WT', 'AVXalign': False, 'size': 4}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_RW', 'AVXalign': False, 'size': 8}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 1, 'type': 'addresses_WC', 'AVXalign': False, 'size': 4}}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_US', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 6, 'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 32}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 47.326733 | 2,999 | 0.65795 |
9686d04a3510694253bf2933039d739f96c5be09 | 3,762 | asm | Assembly | windows32/arraySearch.asm | joncardasis/Assembly-ArraySearch | 35b1df04138719ea2f7283af9443fbb4eb2578fd | [
"MIT"
] | null | null | null | windows32/arraySearch.asm | joncardasis/Assembly-ArraySearch | 35b1df04138719ea2f7283af9443fbb4eb2578fd | [
"MIT"
] | null | null | null | windows32/arraySearch.asm | joncardasis/Assembly-ArraySearch | 35b1df04138719ea2f7283af9443fbb4eb2578fd | [
"MIT"
] | 1 | 2021-02-07T23:03:34.000Z | 2021-02-07T23:03:34.000Z | ; Program Name: Assignment 3 - Array Load and Search
; Programmer Name: Jonathan Cardasis
; Description: Takes input for a collection of positive integers and stored them into an array of
; doublewords (maximum of 10 elements). Any number n<=0 can be used to stop reading input
; values for the array. The user enters a value to search for in the array, and can continue
; to search for more values, to stop searching and end the program "N" or "n" is entered.
;
; Date Created: 11/22/16
.586
.MODEL FLAT
INCLUDE io-asm.h ; header file for input/output
.STACK 4096
.DATA
string BYTE 40 DUP (?) ; used for user input
numbers DWORD 10 dup (?) ; array of ten possible elements
numbersCount DWORD 0
searchValue DWORD ?
count DWORD ?
outputString BYTE 11 DUP (?), 0 ; used to print out
; Input Prompts
inputPrompt BYTE "Enter a value to add to the array: ", 0
searchPrompt BYTE "Enter a value to search for:", 0
continuePrompt BYTE "Would you like to search for more numbers?", 0
; Output Prompts
invalidInputPrompt BYTE "input is invalid", 0
emptyOutputPrompt BYTE "array is empty", 0
valueNotFoundPrompt BYTE " not in the array", 0
valueFoundPrompt BYTE " is element ", 0
.CODE
_MainProc PROC
lea esi, numbers ; load array address
mov ecx, 10 ; max number of elements we can add
arrayInput:
input inputPrompt, string, 40 ; read input
atod string ; convert to integer
cmp eax, 0 ; loop while input > 0
jle endArrayInput
;cmp numbersCount, 10 ; AND loop while numbersCount < 10
;jge endArrayInput
inc numbersCount ; add 1 to array count
mov [esi], eax ; add element to array
add esi, 4 ; point esi to next element
loop arrayInput ; repeat
endArrayInput:
; Check for zero elements
cmp numbersCount, 0
jne search
output emptyOutputPrompt, emptyOutputPrompt
jmp end_program
search:
input searchPrompt, string, 40
atod string
mov searchValue, eax
cmp searchValue, 0
jg validInput
dtoa outputString, searchValue ; Do for invalid input
output invalidInputPrompt, outputString
jmp search
validInput:
lea esi, numbers ; load array address
mov count, 0 ; start count at zero
forever:
mov eax, numbersCount
cmp count, eax
jle canSearch
dtoa outputString, searchValue
output valueNotFoundPrompt, outputString ; do if we count value is outside array bounds
jmp endSearch
canSearch:
;if searchvalue == current array element
mov eax, searchValue
cmp eax, [esi]
jne notEqual
; They are equal:
dtoa outputString, count
output valueFoundPrompt, outputString ; will print 'is element ' + index it was found at
jmp endSearch
notEqual:
inc count
add esi, 4 ; point esi to next element
jmp forever
endSearch:
input continuePrompt, string, 40
mov dl, byte PTR [string] ; get first character of string and store in low byte
cmp dl, 'N' ; compare input for "N" and "n" to stop program
je end_program
cmp dl, 'n'
je end_program
jmp search ; do search loop again if continue input was not "N"/"n"
end_program:
mov eax, 0 ; exit with return code 0
ret
_MainProc ENDP
END ; end of source code
| 31.090909 | 105 | 0.605529 |
024cde9ff8b5a025f0f9642755ebf4aae097b0d8 | 708 | asm | Assembly | oeis/087/A087603.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/087/A087603.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/087/A087603.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A087603: a(n) = (1/8)*Sum_{k=0..n} binomial(n,k)*Fibonacci(k)*8^k.
; Submitted by Christian Krause
; 1,10,155,2100,29525,410750,5731375,79905000,1114275625,15537531250,216660471875,3021168937500,42128015328125,587444444843750,8191485291484375,114224297381250000,1592774664844140625,22210083004410156250,309703436610529296875,4318588931347851562500,60219578327057626953125,839718174494708105468750,11709258552935250537109375,163277085126561451171875000,2276780071677053291259765625,31748040398731412727050781250,442703307929552058289794921875,6173175301225748282885742187500
add $0,1
mov $3,1
lpb $0
sub $0,1
add $2,$3
mov $3,$1
mov $1,$2
mul $1,55
mul $2,5
add $3,$2
lpe
mov $0,$1
div $0,55
| 39.333333 | 474 | 0.812147 |
7ea5fcd60c9536d2ff789252820b58d1da4449de | 2,203 | asm | Assembly | programs/oeis/239/A239195.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/239/A239195.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/239/A239195.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A239195: Sum of the next to smallest parts in the partitions of 4n into 4 parts with smallest part = 1.
; 1,5,17,42,78,134,215,315,447,616,812,1052,1341,1665,2045,2486,2970,3522,4147,4823,5579,6420,7320,8312,9401,10557,11817,13186,14630,16190,17871,19635,21527,23552,25668,27924,30325,32825,35477,38286,41202,44282,47531,50895,54435,58156,62000,66032,70257,74613,79169,83930,88830,93942,99271,104747,110447,116376,122460,128780,135341,142065,149037,156262,163658,171314,179235,187335,195707,204356,213192,222312,231721,241325,251225,261426,271830,282542,293567,304803,316359,328240,340340,352772,365541,378537,391877,405566,419490,433770,448411,463295,478547,494172,510048,526304,542945,559845,577137,594826,612782,631142,649911,668955,688415,708296,728460,749052,770077,791393,813149,835350,857850,880802,904211,927927,952107,976756,1001720,1027160,1053081,1079325,1106057,1133282,1160838,1188894,1217455,1246355,1275767,1305696,1335972,1366772,1398101,1429785,1462005,1494766,1527890,1561562,1595787,1630383,1665539,1701260,1737360,1774032,1811281,1848917,1887137,1925946,1965150,2004950,2045351,2086155,2127567,2169592,2212028,2255084,2298765,2342865,2387597,2432966,2478762,2525202,2572291,2619815,2667995,2716836,2766120,2816072,2866697,2917773,2969529,3021970,3074870,3128462,3182751,3237507,3292967,3349136,3405780,3463140,3521221,3579785,3639077,3699102,3759618,3820874,3882875,3945375,4008627,4072636,4137152,4202432,4268481,4335045,4402385,4470506,4539150,4608582,4678807,4749563,4821119,4893480,4966380,5040092,5114621,5189697,5265597,5342326,5419610,5497730,5576691,5656215,5736587,5817812,5899608,5982264,6065785,6149885,6234857,6320706,6407142,6494462,6582671,6671475,6761175,6851776,6942980,7035092,7128117,7221753,7316309,7411790,7507890,7604922,7702891,7801487,7901027,8001516,8102640,8204720,8307761,8411445,8516097,8621722,8727998,8835254,8943495,9052395,9162287,9273176
mov $3,$0
add $3,1
mov $7,$0
lpb $3,1
mov $0,$7
sub $3,1
sub $0,$3
mul $0,8
add $0,6
mul $0,2
mov $2,$0
mov $5,8
lpb $2,1
mov $2,$5
lpb $5,1
div $0,6
sub $5,$5
add $6,7
lpe
lpb $6,1
pow $0,2
div $0,4
mov $6,$4
lpe
lpe
add $1,$0
lpe
| 71.064516 | 1,785 | 0.790286 |
364d7086b26abe3b2302420f33cbb28acd049fff | 885 | asm | Assembly | oeis/085/A085362.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/085/A085362.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/085/A085362.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A085362: a(0)=1; for n>0, a(n) = 2*5^(n-1) - (1/2)*Sum_{i=1..n-1} a(i)*a(n-i).
; Submitted by Jon Maiga
; 1,2,8,34,150,678,3116,14494,68032,321590,1528776,7301142,35003238,168359754,812041860,3926147730,19022666310,92338836390,448968093320,2186194166950,10659569748370,52037098259090,254308709196660,1244063987615130,6091458343936900,29851422385561898,146401584666653096,718519354782813034,3528748863489872682,17340937720606848150,85266006597940769964,419483136494749262958,2064779020978804560672,10168098300400059060966,50095735785982443602520,246913867209896389630278,1217485132357806088588626
mov $5,2
mov $6,$0
lpb $5
mov $0,$6
sub $5,1
add $0,$5
trn $0,1
mov $3,1
lpb $3
mov $2,$0
seq $2,26375 ; a(n) = Sum_{k=0..n} binomial(n,k)*binomial(2*k,k).
sub $3,1
lpe
mov $0,$2
mov $4,$5
mul $4,$2
add $7,$4
lpe
min $6,1
mul $6,$0
mov $0,$7
sub $0,$6
| 32.777778 | 491 | 0.729944 |
dc4d70eb20fb5542b98eae876f61a88be79d630a | 173 | asm | Assembly | libsrc/_DEVELOPMENT/math/float/math32/lm32/c/sccz80/acos.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | null | null | null | libsrc/_DEVELOPMENT/math/float/math32/lm32/c/sccz80/acos.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | null | null | null | libsrc/_DEVELOPMENT/math/float/math32/lm32/c/sccz80/acos.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | null | null | null |
SECTION code_fp_math32
PUBLIC acos
EXTERN cm32_sccz80_acos
defc acos = cm32_sccz80_acos
; SDCC bridge for Classic
IF __CLASSIC
PUBLIC _acos
defc _acos = acos
ENDIF
| 11.533333 | 29 | 0.791908 |
7d7fbc636493d5475089c3446f53d371ad08e34e | 1,598 | asm | Assembly | programs/oeis/255/A255994.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/255/A255994.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/255/A255994.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A255994: Number of length n+3 0..1 arrays with at most one downstep in every n consecutive neighbor pairs.
; 16,32,53,80,114,156,207,268,340,424,521,632,758,900,1059,1236,1432,1648,1885,2144,2426,2732,3063,3420,3804,4216,4657,5128,5630,6164,6731,7332,7968,8640,9349,10096,10882,11708,12575,13484,14436,15432,16473,17560,18694,19876,21107,22388,23720,25104,26541,28032,29578,31180,32839,34556,36332,38168,40065,42024,44046,46132,48283,50500,52784,55136,57557,60048,62610,65244,67951,70732,73588,76520,79529,82616,85782,89028,92355,95764,99256,102832,106493,110240,114074,117996,122007,126108,130300,134584,138961,143432,147998,152660,157419,162276,167232,172288,177445,182704,188066,193532,199103,204780,210564,216456,222457,228568,234790,241124,247571,254132,260808,267600,274509,281536,288682,295948,303335,310844,318476,326232,334113,342120,350254,358516,366907,375428,384080,392864,401781,410832,420018,429340,438799,448396,458132,468008,478025,488184,498486,508932,519523,530260,541144,552176,563357,574688,586170,597804,609591,621532,633628,645880,658289,670856,683582,696468,709515,722724,736096,749632,763333,777200,791234,805436,819807,834348,849060,863944,879001,894232,909638,925220,940979,956916,973032,989328,1005805,1022464,1039306,1056332,1073543,1090940,1108524,1126296,1144257,1162408,1180750,1199284,1218011,1236932,1256048,1275360,1294869,1314576,1334482,1354588,1374895,1395404,1416116,1437032,1458153,1479480,1501014,1522756,1544707,1566868,1589240,1611824
add $0,1
mov $1,4
mov $2,6
mov $3,10
lpb $0,1
sub $0,1
sub $1,1
add $2,1
sub $3,4
add $3,$2
add $1,$3
lpe
| 99.875 | 1,369 | 0.814143 |
7a5bd981656311625cad5ebf13d17e7e6a582b86 | 555 | asm | Assembly | data/baseStats/venomoth.asm | AmateurPanda92/pokemon-rby-dx | f7ba1cc50b22d93ed176571e074a52d73360da93 | [
"MIT"
] | 9 | 2020-07-12T19:44:21.000Z | 2022-03-03T23:32:40.000Z | data/baseStats/venomoth.asm | JStar-debug2020/pokemon-rby-dx | c2fdd8145d96683addbd8d9075f946a68d1527a1 | [
"MIT"
] | 7 | 2020-07-16T10:48:52.000Z | 2021-01-28T18:32:02.000Z | data/baseStats/venomoth.asm | JStar-debug2020/pokemon-rby-dx | c2fdd8145d96683addbd8d9075f946a68d1527a1 | [
"MIT"
] | 2 | 2021-03-28T18:33:43.000Z | 2021-05-06T13:12:09.000Z | db DEX_VENOMOTH ; pokedex id
db 70 ; base hp
db 65 ; base attack
db 60 ; base defense
db 90 ; base speed
db 90 ; base special
db BUG ; species type 1
db POISON ; species type 2
db 75 ; catch rate
db 138 ; base exp yield
INCBIN "pic/bmon/venomoth.pic",0,1 ; 77, sprite dimensions
dw VenomothPicFront
dw VenomothPicBack
; attacks known at lvl 0
db TACKLE
db DISABLE
db POISONPOWDER
db LEECH_LIFE
db 0 ; growth rate
; learnset
tmlearn 2,4,6
tmlearn 9,10,15
tmlearn 20,21,22
tmlearn 29,30,31,32
tmlearn 33,34,39
tmlearn 44,46
tmlearn 50
db 0 ; padding
| 19.137931 | 58 | 0.740541 |
e289ff864fadb5dd19de54a19101790019360035 | 3,004 | asm | Assembly | src/engine/soundplayer.asm | tbsp/Adjustris | d899e2f539c07ac49fd42c055605bf778a2df09d | [
"CC0-1.0"
] | 11 | 2017-10-30T17:27:32.000Z | 2021-08-30T19:52:51.000Z | src/engine/soundplayer.asm | tbsp/Adjustris | d899e2f539c07ac49fd42c055605bf778a2df09d | [
"CC0-1.0"
] | 2 | 2017-11-18T01:15:58.000Z | 2018-02-01T07:09:09.000Z | src/engine/soundplayer.asm | tbsp/Adjustris | d899e2f539c07ac49fd42c055605bf778a2df09d | [
"CC0-1.0"
] | 3 | 2017-10-31T16:25:15.000Z | 2019-08-31T22:10:49.000Z | ;******************************************************************************
;*
;* Adjustris - Block dropping puzzle game for Gameboy
;*
;* Written in 2017 by Dave VanEe (tbsp) dave.vanee@gmail.com
;*
;* To the extent possible under law, the author(s) have dedicated all copyright
;* and related and neighboring rights to this software to the public domain
;* worldwide. This software is distributed without any warranty.
;*
;* You should have received a copy of the CC0 Public Domain Dedication along with
;* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
;*
;******************************************************************************
SECTION "Sound Player",ROM0
MS_sfxM1:
ld a,[hli]
ldh [MS_M1tmr],a
ld a,[hli]
ldh [$10],a
ld a,[hli]
ldh [$11],a
ld a,[hli]
ldh [$12],a
ld a,[hli]
ldh [$13],a
ld a,[hl]
ldh [$14],a
ldh a,[$25]
or %00010001
ldh [$25],a
ret
MS_sfxM2:
ld a,[hli]
ldh [MS_M2tmr],a
ld a,[hli]
ldh [$16],a
ld a,[hli]
ldh [$17],a
ld a,[hli]
ldh [$18],a
ld a,[hl]
ldh [$19],a
ldh a,[$25]
or %00100010
ldh [$25],a
ret
MS_sfxM3:
ld a,[hli]
ldh [MS_M3tmr],a
xor a
ldh [$1E],a
ld a,$80
ldh [$1A],a
ld a,[hli]
ldh [$1B],a
ld a,[hli]
ldh [$1C],a
ld a,[hli]
ldh [$1D],a
ld a,[hl]
ldh [$1E],a
or $80
ldh [$1E],a
ld hl,MS_wavedata ; leave hl hanging and include wavedata with each effect
ld de,$FF30
ld bc,$0010
call mem_Copy
ldh a,[$25]
or %01000100
ldh [$25],a
ret
MS_sfxM4:
ld a,[hli]
ldh [MS_M4tmr],a
ld a,[hli]
ldh [$20],a
ld a,[hli]
ldh [$21],a
ld a,[hli]
ldh [$22],a
ld a,[hl]
ldh [$23],a
ldh a,[$25]
or %10001000
ldh [$25],a
ret
MS_player:
ldh a,[MS_M1tmr]
cp 0
jr z,.m2t
dec a
ldh [MS_M1tmr],a
.m2t
ldh a,[MS_M2tmr]
cp 0
jr z,.m3t
dec a
ldh [MS_M2tmr],a
.m3t
ldh a,[MS_M3tmr]
cp 0
jr z,.m4t
dec a
ldh [MS_M3tmr],a
.m4t
ldh a,[MS_M4tmr]
cp 0
jr z,.mdt
dec a
ldh [MS_M4tmr],a
.mdt
ldh a,[MS_M1tmr]
cp 0
jr nz,.play_M2
ldh a,[$25]
res 0,a
res 4,a
;xor %00010001
ldh [$25],a
.play_M2
ldh a,[MS_M2tmr]
cp 0
jr nz,.play_M3
ldh a,[$25]
res 1,a
res 5,a
;xor %00100010
ldh [$25],a
.play_M3
ldh a,[MS_M3tmr]
cp 0
jr nz,.play_M4
ldh a,[$25]
res 2,a
res 6,a
;xor %01000100
ldh [$25],a
.play_M4
ldh a,[MS_M4tmr]
cp 0
jr nz,.done_cycle
ldh a,[$25]
res 3,a
res 7,a
;xor %10001000
ldh [$25],a
.done_cycle
ret
MS_setup_sound:
ld a,%10000000
ldh [$26],a
ld a,%01110111
ldh [$24],a
ld a,%10000000
ldh [$1A],a
xor a
ldh [$25],a
;ld hl,MS_wavedata
;ld de,$FF30
;ld bc,$0010
;call mem_Copy
ret
| 17.567251 | 83 | 0.498003 |
4754d0e003e2811e053c9216fe4aa4dd9ae33886 | 1,265 | asm | Assembly | ubb/asc/lab06/c.asm | AlexanderChristian/private_courses | c80f3526af539e35f93b460f3909f669aaef573c | [
"MIT"
] | null | null | null | ubb/asc/lab06/c.asm | AlexanderChristian/private_courses | c80f3526af539e35f93b460f3909f669aaef573c | [
"MIT"
] | 6 | 2020-03-04T20:52:39.000Z | 2022-03-31T00:33:07.000Z | ubb/asc/lab06/c.asm | AlexanderChristian/private_courses | c80f3526af539e35f93b460f3909f669aaef573c | [
"MIT"
] | null | null | null | assume cs:code, ds:data
data segment
;a dd 0aa00bf12h ;a= 1010 1010 0000 0000 1011 1111 0001 0010
; 5df ; 0000 0000 0000 0000 0000 0110 1101 1111
a dd 0fffffh
bmask dw ?
nbits dw 0
data ends
code segment
start:
mov ax, data
mov ds, ax
mov ax, word ptr a
mov dx, word ptr a + 2
mov cx, 16
mov si, 0 ; this is where we keep the number of 1 bits from the representation
cnt_biti_ax:
dec cx
mov bx, ax
mov bmask, 1
shl bmask, cl
and bx, bmask
cmp bx, 0
jne incr_bits_ax
jmp not_incr_ax
incr_bits_ax:
inc si
not_incr_ax:
inc cx
loop cnt_biti_ax
mov cx, 16
cnt_biti_dx: ; now count the 1 bits from the dx register
dec cx
mov bx, dx
mov bmask, 1
shl bmask, cl
and bx, bmask
cmp bx, 0
jne incr_bits_dx
jmp not_incr_dx
incr_bits_dx:
inc si
not_incr_dx:
inc cx
loop cnt_biti_dx
mov nbits, si
cmp si, 16
ja invert
jmp divide
invert:
xor ax, 0000000101010000b
xor dx, 0000001000000000b
jmp end_of_pr
divide:
mov cx, 2
divide_by_two:
sar dx, 1
rcr ax, 1
loop divide_by_two
end_of_pr:
mov word ptr a, ax
mov word ptr a + 2, dx
mov ax, 4c00h
int 21h
code ends
end start
for(int i = 0 ; i < 16 ; ++ i) {
if(ax & (1 << i)) {
++ cnt
}
}
| 13.457447 | 80 | 0.64664 |
a4c4a70e1ddcfb6b27425892cdf5afd17c05e1b3 | 7,472 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xa0.log_21829_207.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xa0.log_21829_207.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xa0.log_21829_207.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r15
push %r9
push %rax
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x8f8f, %rax
nop
nop
nop
nop
nop
inc %r10
movb (%rax), %r11b
nop
cmp $35702, %rax
lea addresses_D_ht+0x12207, %rsi
lea addresses_WT_ht+0x238f, %rdi
and %r9, %r9
mov $68, %rcx
rep movsb
nop
and $44748, %r9
lea addresses_A_ht+0x9e8f, %rsi
nop
xor $28176, %r10
movl $0x61626364, (%rsi)
nop
nop
nop
nop
nop
and %r11, %r11
lea addresses_WT_ht+0xfd8d, %r9
nop
nop
nop
inc %rax
mov $0x6162636465666768, %r11
movq %r11, %xmm6
movups %xmm6, (%r9)
nop
nop
inc %rax
lea addresses_D_ht+0x104cf, %r9
nop
nop
nop
nop
nop
sub %r11, %r11
mov (%r9), %r10w
nop
dec %rsi
lea addresses_A_ht+0x2343, %r11
nop
nop
add $2657, %rdi
movb (%r11), %r10b
nop
nop
nop
and $23842, %r11
lea addresses_WT_ht+0xc60f, %r10
sub $60986, %r9
mov (%r10), %rcx
nop
nop
nop
nop
and %rcx, %rcx
lea addresses_WT_ht+0x5d8f, %rsi
lea addresses_WC_ht+0x14d8f, %rdi
nop
nop
nop
xor $15148, %r15
mov $46, %rcx
rep movsl
nop
inc %r11
lea addresses_WC_ht+0x16a74, %r10
cmp %r9, %r9
mov $0x6162636465666768, %rcx
movq %rcx, (%r10)
nop
nop
nop
nop
inc %r11
lea addresses_UC_ht+0x378f, %rsi
lea addresses_A_ht+0xd38f, %rdi
clflush (%rdi)
nop
add %r9, %r9
mov $9, %rcx
rep movsq
nop
nop
nop
nop
cmp %rax, %rax
lea addresses_A_ht+0x1af8f, %r15
clflush (%r15)
cmp $45691, %r9
movb $0x61, (%r15)
nop
nop
nop
nop
sub $64122, %r15
lea addresses_A_ht+0x11c0f, %rsi
lea addresses_A_ht+0x418f, %rdi
nop
nop
nop
nop
nop
xor $25711, %r11
mov $71, %rcx
rep movsw
and $63965, %r9
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r15
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r15
push %rax
push %rbp
push %rbx
push %rsi
// Load
lea addresses_WC+0x404f, %rbp
nop
nop
nop
cmp %r10, %r10
vmovaps (%rbp), %ymm5
vextracti128 $0, %ymm5, %xmm5
vpextrq $0, %xmm5, %rsi
nop
sub $16574, %r10
// Load
mov $0x3638b90000000633, %r11
nop
nop
nop
sub $64094, %rax
vmovups (%r11), %ymm5
vextracti128 $0, %ymm5, %xmm5
vpextrq $0, %xmm5, %rbp
nop
nop
nop
add $38845, %r15
// Faulty Load
lea addresses_normal+0xbf8f, %r10
sub $45857, %rax
movb (%r10), %bl
lea oracles, %rsi
and $0xff, %rbx
shlq $12, %rbx
mov (%rsi,%rbx,1), %rbx
pop %rsi
pop %rbx
pop %rbp
pop %rax
pop %r15
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_normal', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_WC', 'AVXalign': True, 'size': 32}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 2, 'type': 'addresses_NC', 'AVXalign': False, 'size': 32}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_normal', 'AVXalign': False, 'size': 1}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'NT': False, 'same': False, 'congruent': 10, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 1}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 3, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 9, 'type': 'addresses_WT_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 8, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 4}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 16}}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 2, 'type': 'addresses_A_ht', 'AVXalign': True, 'size': 1}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 8}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 9, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 8, 'type': 'addresses_WC_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 8}}
{'src': {'same': False, 'congruent': 9, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 10, 'type': 'addresses_A_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 8, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 1}}
{'src': {'same': False, 'congruent': 6, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 8, 'type': 'addresses_A_ht'}}
{'34': 21829}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
| 34.915888 | 2,999 | 0.655112 |
1e34f4026457b7baf0c49d32f33c9946f65c3f36 | 2,413 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_st_sm_/i3-7100_9_0xca_notsx.log_7_1281.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_st_sm_/i3-7100_9_0xca_notsx.log_7_1281.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_st_sm_/i3-7100_9_0xca_notsx.log_7_1281.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r9
push %rbx
push %rcx
push %rdi
push %rdx
lea addresses_UC_ht+0x1519e, %r9
nop
add %rbx, %rbx
movb $0x61, (%r9)
nop
nop
cmp $51590, %rdx
lea addresses_normal_ht+0xce9e, %rcx
nop
nop
inc %r9
movups (%rcx), %xmm5
vpextrq $1, %xmm5, %rdx
nop
cmp $24325, %rdx
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r9
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r14
push %r8
push %rax
push %rcx
push %rdi
push %rsi
// REPMOV
lea addresses_RW+0x16906, %rsi
lea addresses_UC+0x69e, %rdi
clflush (%rsi)
nop
nop
nop
inc %r12
mov $59, %rcx
rep movsl
nop
dec %rdi
// Store
lea addresses_normal+0x269e, %r8
nop
nop
nop
sub %r14, %r14
movl $0x51525354, (%r8)
nop
nop
nop
cmp %rcx, %rcx
// Store
lea addresses_normal+0x269e, %r8
clflush (%r8)
nop
nop
nop
nop
and $52433, %r12
movl $0x51525354, (%r8)
nop
nop
nop
nop
dec %r8
// REPMOV
lea addresses_US+0x405e, %rsi
lea addresses_WT+0x1c49e, %rdi
nop
nop
nop
nop
nop
sub %rax, %rax
mov $33, %rcx
rep movsq
nop
nop
nop
sub $33835, %r14
// Faulty Load
lea addresses_normal+0x269e, %r12
nop
nop
nop
nop
nop
and $41592, %rax
mov (%r12), %esi
lea oracles, %r12
and $0xff, %rsi
shlq $12, %rsi
mov (%r12,%rsi,1), %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r8
pop %r14
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_normal', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_RW', 'congruent': 3, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC', 'congruent': 11, 'same': False}}
{'OP': 'STOR', 'dst': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_normal', 'size': 4, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_normal', 'size': 4, 'AVXalign': False}}
{'src': {'type': 'addresses_US', 'congruent': 3, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT', 'congruent': 9, 'same': False}}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': True, 'type': 'addresses_normal', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'same': True, 'congruent': 7, 'NT': False, 'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 11, 'NT': False, 'type': 'addresses_normal_ht', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
{'54': 7}
54 54 54 54 54 54 54
*/
| 18.007463 | 143 | 0.648156 |
8a05891aad35d06be292c5b785b17bbd0ebf7cb9 | 979 | asm | Assembly | boot.asm | aolvos/imageboot-16 | 0e989e3c6e29f5e992693fd61a781908fec12577 | [
"MIT"
] | null | null | null | boot.asm | aolvos/imageboot-16 | 0e989e3c6e29f5e992693fd61a781908fec12577 | [
"MIT"
] | null | null | null | boot.asm | aolvos/imageboot-16 | 0e989e3c6e29f5e992693fd61a781908fec12577 | [
"MIT"
] | null | null | null | ;imageboot-16 by aolvos, 2020
Bits 16
;set videomode
mov ah,00h
mov al,13h
int 10h
;create stack
cli
mov ax,0x0000
mov ss,ax
mov sp,0xFFFF
sti
;main module
boot_ok:
call splash_image
cli
hlt
splash_image:
;load data in memory
mov cl,0x02
call read_data
xor di,di
;setup palette
mov bx,0
setup_palette:
lodsb
mov dh,al
lodsb
mov ch,al
lodsb
mov cl,al
mov ax,1010h
int 10h
inc bx
cmp bx,16
jne setup_palette
;write data
mov cx,32000
call write_data
mov cl,0x21
call read_data
mov di,31968
mov cx,64000
call write_data
mov dx,0x3C8
xor al,al
out dx,al
mov dx,0x3C9
mov cx,768
ret
write_data:
lodsb
push ax
shr al,4
stosb
pop ax
shl al,4
shr al,4
stosb
cmp di,cx
jne write_data
ret
read_data:
mov ax,07c0h
mov ds,ax
mov es,ax
mov ah,02h
mov al,32
mov ch,0
mov dh,0
mov bx,0x1000
int 13h
mov ax,0A000h
mov es,ax
mov si,0x1000
ret
times 510-($-$$) db 0
dw 0xAA55 | 9.693069 | 30 | 0.66905 |
a7d974913535e889ddb176383d24ee97a09c695d | 1,374 | asm | Assembly | Chapter 3/3.1 - The IDT/bootloader/protected_mode/init_pt.asm | gmarino2048/64bit-os-tutorial | 2e297d04d5a2e0f7fead84ad057e6b283a8c6972 | [
"MIT"
] | 87 | 2020-12-04T23:18:31.000Z | 2022-03-20T11:05:57.000Z | Chapter 3/3.1 - The IDT/bootloader/protected_mode/init_pt.asm | limpingstone/64bit-os-tutorial | 94f0582b9a3ecf80dfcc82278449654351e73730 | [
"MIT"
] | 6 | 2021-01-28T17:58:36.000Z | 2022-03-26T01:43:53.000Z | Chapter 3/3.1 - The IDT/bootloader/protected_mode/init_pt.asm | limpingstone/64bit-os-tutorial | 94f0582b9a3ecf80dfcc82278449654351e73730 | [
"MIT"
] | 9 | 2020-12-04T22:18:03.000Z | 2022-03-26T17:53:17.000Z | ;
; Long Mode
;
; init_pt.asm
;
[bits 32]
; Initialize the page table
init_pt_protected:
pushad
; Clear the memory area using rep stosd
mov edi, 0x1000
mov cr3, edi
xor eax, eax
mov ecx, 4096
rep stosd
; Set edi back to PML4T[0]
mov edi, cr3
; Set up the first entry of each table
mov dword[edi], 0x2003 ; Set PML4T[0] to address 0x2000 (PDPT) with flags 0x0003
add edi, 0x1000 ; Go to PDPT[0]
mov dword[edi], 0x3003 ; Set PDPT[0] to address 0x3000 (PDT) with flags 0x0003
add edi, 0x1000 ; Go to PDT[0]
mov dword[edi], 0x4003 ; Set PDT[0] to address 0x4000 (PT) with flags 0x0003
; Fill in the final page table
; NOTE: edi is at 0x3000
add edi, 0x1000 ; Go to PT[0]
mov ebx, 0x00000003 ; EBX has address 0x0000 with flags 0x0003
mov ecx, 512 ; Do the operation 512 times
add_page_entry_protected:
mov dword[edi], ebx
add ebx, 0x1000
add edi, 8
loop add_page_entry_protected
; Set up PAE paging, but don't enable it quite yet
mov eax, cr4
or eax, 1 << 5 ; Set the PAE-bit, which is the 5th bit
mov cr4, eax
; Now we should have a page table that identities maps the lowest 2MB of physical memory into
; virtual memory!
popad
ret
| 26.941176 | 97 | 0.604076 |
294cacfeeacd617a0ab06bf2496b68cdba31f927 | 1,691 | asm | Assembly | programs/oeis/083/A083744.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/083/A083744.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/083/A083744.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A083744: a(1) = 1; if a(n-1) + n is composite then a(n) = a(n-1) + n, else a(n) = a(n-1).
; 1,1,4,8,8,14,21,21,30,40,51,63,76,90,105,121,138,156,175,195,216,238,261,285,310,336,363,391,420,450,481,513,546,580,615,651,688,726,765,805,846,888,931,975,1020,1066,1113,1161,1210,1260,1311,1363,1416,1470,1525,1581,1638,1696,1755,1815,1876,1938,2001,2065,2130,2196,2263,2331,2400,2470,2541,2613,2686,2760,2835,2911,2988,3066,3145,3225,3306,3388,3471,3555,3640,3726,3813,3901,3990,4080,4171,4263,4356,4450,4545,4641,4738,4836,4935,5035,5136,5238,5341,5445,5550,5656,5763,5871,5980,6090,6201,6313,6426,6540,6655,6771,6888,7006,7125,7245,7366,7488,7611,7735,7860,7986,8113,8241,8370,8500,8631,8763,8896,9030,9165,9301,9438,9576,9715,9855,9996,10138,10281,10425,10570,10716,10863,11011,11160,11310,11461,11613,11766,11920,12075,12231,12388,12546,12705,12865,13026,13188,13351,13515,13680,13846,14013,14181,14350,14520,14691,14863,15036,15210,15385,15561,15738,15916,16095,16275,16456,16638,16821,17005,17190,17376,17563,17751,17940,18130,18321,18513,18706,18900,19095,19291,19488,19686,19885,20085,20286,20488,20691,20895,21100,21306,21513,21721,21930,22140,22351,22563,22776,22990,23205,23421,23638,23856,24075,24295,24516,24738,24961,25185,25410,25636,25863,26091,26320,26550,26781,27013,27246,27480,27715,27951,28188,28426,28665,28905,29146,29388,29631,29875,30120,30366,30613,30861,31110,31360
mov $3,$0
mov $8,$0
add $8,1
lpb $8
mov $0,$3
sub $8,1
sub $0,$8
add $0,2
mov $2,3
mov $5,$0
mov $6,0
add $6,$0
add $0,1
lpb $0
add $0,1
gcd $2,$5
mov $4,$2
mul $4,2
sub $0,$4
mul $0,2
sub $0,1
mov $6,1
lpe
mov $7,$6
sub $7,1
add $1,$7
lpe
| 54.548387 | 1,297 | 0.722058 |
03ea5e0011d55e397a33093d015e45bd4466a4d1 | 210,870 | asm | Assembly | reports/16_dense_array.combine.asm | arnaudroger/re2j-benchmark | ecfb2d6975948a1fbb53ccf101b285655b850058 | [
"MIT"
] | null | null | null | reports/16_dense_array.combine.asm | arnaudroger/re2j-benchmark | ecfb2d6975948a1fbb53ccf101b285655b850058 | [
"MIT"
] | null | null | null | reports/16_dense_array.combine.asm | arnaudroger/re2j-benchmark | ecfb2d6975948a1fbb53ccf101b285655b850058 | [
"MIT"
] | null | null | null | # JMH version: 1.19
# VM version: JDK 1.8.0_131, VM 25.131-b11
# VM invoker: /usr/lib/jvm/java-8-oracle/jre/bin/java
# VM options: <none>
# Warmup: 20 iterations, 1 s each
# Measurement: 20 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Throughput, ops/time
# Benchmark: com.github.arnaudroger.re2j.Re2jFindRegex.testCombine
# Run progress: 0.00% complete, ETA 00:00:40
# Fork: 1 of 1
# Preparing profilers: LinuxPerfAsmProfiler
# Profilers consume stdout and stderr from target VM, use -v EXTRA to copy to console
# Warmup Iteration 1: 3421.612 ops/s
# Warmup Iteration 2: 9214.636 ops/s
# Warmup Iteration 3: 9266.575 ops/s
# Warmup Iteration 4: 9266.686 ops/s
# Warmup Iteration 5: 9266.488 ops/s
# Warmup Iteration 6: 9265.533 ops/s
# Warmup Iteration 7: 9262.777 ops/s
# Warmup Iteration 8: 9187.816 ops/s
# Warmup Iteration 9: 9233.015 ops/s
# Warmup Iteration 10: 9313.870 ops/s
# Warmup Iteration 11: 9318.363 ops/s
# Warmup Iteration 12: 9008.314 ops/s
# Warmup Iteration 13: 9315.568 ops/s
# Warmup Iteration 14: 9296.202 ops/s
# Warmup Iteration 15: 9295.572 ops/s
# Warmup Iteration 16: 9296.214 ops/s
# Warmup Iteration 17: 9327.534 ops/s
# Warmup Iteration 18: 8761.738 ops/s
# Warmup Iteration 19: 7456.400 ops/s
# Warmup Iteration 20: 9299.653 ops/s
Iteration 1: 9299.630 ops/s
Iteration 2: 9298.574 ops/s
Iteration 3: 9302.378 ops/s
Iteration 4: 9304.161 ops/s
Iteration 5: 9301.039 ops/s
Iteration 6: 9302.907 ops/s
Iteration 7: 9301.188 ops/s
Iteration 8: 9301.096 ops/s
Iteration 9: 9266.368 ops/s
Iteration 10: 9278.805 ops/s
Iteration 11: 8253.764 ops/s
Iteration 12: 9283.972 ops/s
Iteration 13: 9282.390 ops/s
Iteration 14: 9283.751 ops/s
Iteration 15: 9283.293 ops/s
Iteration 16: 9285.805 ops/s
Iteration 17: 9276.439 ops/s
Iteration 18: 9279.542 ops/s
Iteration 19: 9282.784 ops/s
Iteration 20: 9315.554 ops/s
# Processing profiler results: LinuxPerfAsmProfiler
Result "com.github.arnaudroger.re2j.Re2jFindRegex.testCombine":
9239.172 ±(99.9%) 201.694 ops/s [Average]
(min, avg, max) = (8253.764, 9239.172, 9315.554), stdev = 232.271
CI (99.9%): [9037.478, 9440.866] (assumes normal distribution)
Secondary result "com.github.arnaudroger.re2j.Re2jFindRegex.testCombine:·asm":
PrintAssembly processed: 196559 total address lines.
Perf output processed (skipped 23.349 seconds):
Column 1: cycles (20617 events)
Column 2: instructions (20617 events)
Hottest code regions (>10.00% "cycles" events):
....[Hottest Region 1]..............................................................................
C2, level 4, com.google.re2j.Machine::match, version 541 (1534 bytes)
0x00007fc83d244fcb: cmp $0x1,%r8d
0x00007fc83d244fcf: je 0x00007fc83d246651 ;*if_icmpeq
; - com.google.re2j.Machine::match@19 (line 186)
0x00007fc83d244fd5: cmp $0x2,%r8d
0x00007fc83d244fd9: je 0x00007fc83d246679 ;*if_icmpne
; - com.google.re2j.Machine::match@24 (line 186)
0x00007fc83d244fdf: mov %r12b,0x10(%r10) ;*putfield matched
; - com.google.re2j.Machine::match@35 (line 190)
0x00007fc83d244fe3: mov 0x28(%r10),%r14d ;*getfield matchcap
; - com.google.re2j.Machine::match@39 (line 191)
0.01% 0x00007fc83d244fe7: mov 0xc(%r12,%r14,8),%ebp ;*arraylength
; - java.util.Arrays::fill@3 (line 2881)
; - com.google.re2j.Machine::match@43 (line 191)
; implicit exception: dispatches to 0x00007fc83d246ed1
0x00007fc83d244fec: test %ebp,%ebp
0x00007fc83d244fee: jg 0x00007fc83d2466a1 ;*if_icmpge
; - java.util.Arrays::fill@7 (line 2881)
; - com.google.re2j.Machine::match@43 (line 191)
0x00007fc83d244ff4: mov 0x8(%rdx),%r8d ; implicit exception: dispatches to 0x00007fc83d246ee1
0x00007fc83d244ff8: mov 0x20(%r10),%ecx ;*getfield q1
; - com.google.re2j.Machine::match@53 (line 192)
0.00% 0x00007fc83d244ffc: mov 0x1c(%r10),%edi ;*getfield q0
; - com.google.re2j.Machine::match@47 (line 192)
0x00007fc83d245000: cmp $0xf8019b8e,%r8d ; {metadata('com/google/re2j/MachineInput$UTF16Input')}
0x00007fc83d245007: jne 0x00007fc83d246381
0x00007fc83d24500d: mov %rdx,%rbx ;*invokevirtual step
; - com.google.re2j.Machine::match@60 (line 193)
0.00% 0x00007fc83d245010: mov 0xc(%rbx),%edx ;*getfield start
; - com.google.re2j.MachineInput$UTF16Input::step@2 (line 185)
; - com.google.re2j.Machine::match@60 (line 193)
0x00007fc83d245013: mov 0x10(%rbx),%eax ;*getfield end
; - com.google.re2j.MachineInput$UTF16Input::step@9 (line 186)
; - com.google.re2j.Machine::match@60 (line 193)
0x00007fc83d245016: vmovd %xmm0,%r8d
0x00007fc83d24501b: add %edx,%r8d ;*iadd
; - com.google.re2j.MachineInput$UTF16Input::step@5 (line 185)
; - com.google.re2j.Machine::match@60 (line 193)
0x00007fc83d24501e: cmp %eax,%r8d
0x00007fc83d245021: jge 0x00007fc83d2461a5 ;*if_icmpge
; - com.google.re2j.MachineInput$UTF16Input::step@12 (line 186)
; - com.google.re2j.Machine::match@60 (line 193)
0.01% 0x00007fc83d245027: mov 0x14(%rbx),%r13d ;*getfield str
; - com.google.re2j.MachineInput$UTF16Input::step@16 (line 187)
; - com.google.re2j.Machine::match@60 (line 193)
0x00007fc83d24502b: mov 0x8(%r12,%r13,8),%ebp ; implicit exception: dispatches to 0x00007fc83d246ef5
0x00007fc83d245030: cmp $0xf80002da,%ebp ; {metadata('java/lang/String')}
0x00007fc83d245036: jne 0x00007fc83d2463b1
0.00% 0x00007fc83d24503c: lea (%r12,%r13,8),%rbp ;*invokeinterface charAt
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@60 (line 193)
0.00% 0x00007fc83d245040: test %r8d,%r8d
0x00007fc83d245043: jl 0x00007fc83d24654d ;*iflt
; - java.lang.String::charAt@1 (line 657)
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@60 (line 193)
0x00007fc83d245049: mov %eax,0x64(%rsp)
0x00007fc83d24504d: mov %edx,0x60(%rsp)
0.00% 0x00007fc83d245051: mov 0xc(%rbp),%edx ;*getfield value
; - java.lang.String::charAt@6 (line 657)
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@60 (line 193)
0.00% 0x00007fc83d245054: mov 0xc(%r12,%rdx,8),%eax ;*arraylength
; - java.lang.String::charAt@9 (line 657)
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@60 (line 193)
; implicit exception: dispatches to 0x00007fc83d246f09
0x00007fc83d245059: cmp %eax,%r8d
0x00007fc83d24505c: jge 0x00007fc83d2466cd ;*if_icmplt
; - java.lang.String::charAt@10 (line 657)
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@60 (line 193)
0x00007fc83d245062: cmp %eax,%r8d
0x00007fc83d245065: jae 0x00007fc83d246209
0x00007fc83d24506b: mov %eax,0x1c(%rsp)
0.00% 0x00007fc83d24506f: vmovd %edx,%xmm1
0x00007fc83d245073: mov %rbp,%rax
0x00007fc83d245076: mov %rbx,0x48(%rsp)
0x00007fc83d24507b: mov %edi,0x34(%rsp)
0.00% 0.01% 0x00007fc83d24507f: mov %ecx,%edx
0x00007fc83d245081: mov %r9d,0x40(%rsp)
0x00007fc83d245086: mov %r11d,0x3c(%rsp)
0x00007fc83d24508b: mov %r10,%rbx
0.00% 0x00007fc83d24508e: vmovd %xmm1,%r10d
0x00007fc83d245093: lea (%r12,%r10,8),%r9
0x00007fc83d245097: movzwl 0x10(%r9,%r8,2),%r10d ;*caload
; - java.lang.String::charAt@27 (line 660)
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@60 (line 193)
0.00% 0x00007fc83d24509d: cmp $0xd800,%r10d
0x00007fc83d2450a4: jge 0x00007fc83d24670d ;*if_icmplt
; - java.lang.Character::isHighSurrogate@3 (line 4729)
; - java.lang.Character::codePointAt@9 (line 4867)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@60 (line 193)
0.00% 0.01% 0x00007fc83d2450aa: shl $0x3,%r10d ;*ishl
; - com.google.re2j.MachineInput$UTF16Input::step@38 (line 190)
; - com.google.re2j.Machine::match@60 (line 193)
0x00007fc83d2450ae: mov %r10d,%r11d
0x00007fc83d2450b1: and $0x7,%r11d
0x00007fc83d2450b5: or $0x1,%r10d
0.01% 0.01% 0x00007fc83d2450b9: mov %r10d,%ebp
0x00007fc83d2450bc: or $0x1,%r11d ;*ior ; - com.google.re2j.MachineInput$UTF16Input::step@41 (line 190)
; - com.google.re2j.Machine::match@60 (line 193)
0x00007fc83d2450c0: mov %r11d,0x28(%rsp)
0.00% 0x00007fc83d2450c5: mov %r10d,%r8d
0.00% 0.01% 0x00007fc83d2450c8: sar $0x3,%r8d ;*ishr
; - com.google.re2j.Machine::match@68 (line 194)
0x00007fc83d2450cc: cmp $0xfffffff8,%r10d
0x00007fc83d2450d0: je 0x00007fc83d2461b4 ;*if_icmpeq
; - com.google.re2j.Machine::match@88 (line 198)
0x00007fc83d2450d6: vmovd %xmm0,%r10d
0x00007fc83d2450db: add %r11d,%r10d
0.00% 0.00% 0x00007fc83d2450de: add 0x60(%rsp),%r10d ;*iadd
; - com.google.re2j.MachineInput$UTF16Input::step@5 (line 185)
; - com.google.re2j.Machine::match@96 (line 199)
0x00007fc83d2450e3: mov %r10d,%edi
0x00007fc83d2450e6: cmp 0x64(%rsp),%r10d
0x00007fc83d2450eb: jge 0x00007fc83d245a63 ;*if_icmpge
; - com.google.re2j.MachineInput$UTF16Input::step@12 (line 186)
; - com.google.re2j.Machine::match@96 (line 199)
0x00007fc83d2450f1: test %r10d,%r10d
0x00007fc83d2450f4: jl 0x00007fc83d2465d1 ;*iflt
; - java.lang.String::charAt@1 (line 657)
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@96 (line 199)
0.01% 0x00007fc83d2450fa: cmp 0x1c(%rsp),%r10d
0x00007fc83d2450ff: jge 0x00007fc83d246761 ;*if_icmplt
; - java.lang.String::charAt@10 (line 657)
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@96 (line 199)
0x00007fc83d245105: cmp 0x1c(%rsp),%r10d
0x00007fc83d24510a: jae 0x00007fc83d246249
0.00% 0x00007fc83d245110: movzwl 0x10(%r9,%r10,2),%r9d ;*caload
; - java.lang.String::charAt@27 (line 660)
; - java.lang.Character::codePointAt@2 (line 4866)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@96 (line 199)
0x00007fc83d245116: cmp $0xd800,%r9d
0x00007fc83d24511d: jge 0x00007fc83d2467b9 ;*if_icmplt
; - java.lang.Character::isHighSurrogate@3 (line 4729)
; - java.lang.Character::codePointAt@9 (line 4867)
; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
; - com.google.re2j.Machine::match@96 (line 199)
0.01% 0.00% 0x00007fc83d245123: shl $0x3,%r9d ;*ishl
; - com.google.re2j.MachineInput$UTF16Input::step@38 (line 190)
; - com.google.re2j.Machine::match@96 (line 199)
0x00007fc83d245127: mov %r9d,%r10d
0x00007fc83d24512a: or $0x1,%r10d
0x00007fc83d24512e: and $0x7,%r9d
0.00% 0x00007fc83d245132: sar $0x3,%r10d
0.00% 0x00007fc83d245136: or $0x1,%r9d ;*ishr
; - com.google.re2j.Machine::match@104 (line 200)
0x00007fc83d24513a: vmovd %xmm0,%ecx
0x00007fc83d24513e: test %ecx,%ecx
0x00007fc83d245140: jne 0x00007fc83d246589 ;*ifne
; - com.google.re2j.Machine::match@115 (line 204)
0.01% 0x00007fc83d245146: test %r8d,%r8d
0x00007fc83d245149: jl 0x00007fc83d245a4b ;*ifge
; - com.google.re2j.Utils::emptyOpContext@21 (line 179)
; - com.google.re2j.Machine::match@121 (line 205)
0x00007fc83d24514f: mov %r10d,0x2c(%rsp)
0x00007fc83d245154: mov %r9d,0x30(%rsp)
0x00007fc83d245159: mov $0x5,%r9d ;*iload_1
; - com.google.re2j.Utils::emptyOpContext@29 (line 182)
; - com.google.re2j.Machine::match@121 (line 205)
0.01% 0.00% 0x00007fc83d24515f: cmp $0xa,%r8d
0x00007fc83d245163: je 0x00007fc83d245a71 ;*iload_0
; - com.google.re2j.Utils::emptyOpContext@39 (line 185)
; - com.google.re2j.Machine::match@121 (line 205)
0x00007fc83d245169: mov %r8d,%r10d
0x00007fc83d24516c: add $0xffffffbf,%r10d
0x00007fc83d245170: cmp $0x1a,%r10d
╭ 0x00007fc83d245174: jb 0x00007fc83d245187 ;*if_icmple
│ ; - com.google.re2j.Utils::isWordRune@9 (line 149)
│ ; - com.google.re2j.Utils::emptyOpContext@44 (line 185)
│ ; - com.google.re2j.Machine::match@121 (line 205)
0.00% │ 0x00007fc83d245176: mov %r8d,%r11d
│ 0x00007fc83d245179: add $0xffffff9f,%r11d
│ 0x00007fc83d24517d: cmp $0x1a,%r11d
│ 0x00007fc83d245181: jae 0x00007fc83d245a80 ;*iconst_1
│ ; - com.google.re2j.Utils::isWordRune@42 (line 149)
│ ; - com.google.re2j.Utils::emptyOpContext@44 (line 185)
│ ; - com.google.re2j.Machine::match@121 (line 205)
0.00% 0.01% ↘ 0x00007fc83d245187: or $0x10,%r9d ;*ior ; - com.google.re2j.Utils::emptyOpContext@53 (line 186)
; - com.google.re2j.Machine::match@121 (line 205)
0.00% 0x00007fc83d24518b: mov %r9d,0x38(%rsp) ;*iload_2
; - com.google.re2j.Utils::emptyOpContext@63 (line 190)
; - com.google.re2j.Machine::match@121 (line 205)
0x00007fc83d245190: mov 0x3c(%rsp),%r10d
0x00007fc83d245195: test %r10d,%r10d
0x00007fc83d245198: jne 0x00007fc83d2463f1 ;*aload
; - com.google.re2j.Machine::match@136 (line 211)
0.00% 0x00007fc83d24519e: movzbl 0x11(%rbx),%r10d ;*getfield captures
; - com.google.re2j.Machine::match@283 (line 240)
0.00% 0x00007fc83d2451a3: mov 0x40(%rsp),%r9d
0.00% 0x00007fc83d2451a8: and $0x4,%r9d ;*iand
; - com.google.re2j.Machine::match@147 (line 212)
0x00007fc83d2451ac: mov %r9d,0x44(%rsp)
0.00% 0x00007fc83d2451b1: mov %rdx,%r11
0.00% 0x00007fc83d2451b4: shl $0x3,%r11 ;*getfield q1
; - com.google.re2j.Machine::match@53 (line 192)
0x00007fc83d2451b8: mov %r11,0x20(%rsp)
0x00007fc83d2451bd: vmovd %r10d,%xmm4
0.01% 0x00007fc83d2451c2: xor %eax,%eax
0.00% 0.00% 0x00007fc83d2451c4: mov $0x1,%r10d
0x00007fc83d2451ca: xor %r11d,%r11d
0.00% 0x00007fc83d2451cd: mov %r10d,0x14(%rsp)
0x00007fc83d2451d2: mov %r11d,0x5c(%rsp)
0.00% ╭ 0x00007fc83d2451d7: jmpq 0x00007fc83d245423 ;*ifeq
│ ; - com.google.re2j.Machine::match@286 (line 240)
0.01% │ ↗ 0x00007fc83d2451dc: mov %r14,%r8
0.07% 0.00% │ │ 0x00007fc83d2451df: shl $0x3,%r8 ;*getfield matchcap
│ │ ; - com.google.re2j.Machine::match@307 (line 243)
0.25% 0.03% │ │ 0x00007fc83d2451e3: mov %r10,%rsi
0.01% │ │ 0x00007fc83d2451e6: mov 0x18(%rsp),%rdx
0.03% 0.01% │ │ 0x00007fc83d2451eb: mov 0x5c(%rsp),%ecx
0.06% 0.03% │ │ 0x00007fc83d2451ef: mov 0x38(%rsp),%r9d
0.27% 0.06% │ │ 0x00007fc83d2451f4: xor %edi,%edi
0.01% │ │ 0x00007fc83d2451f6: mov 0x50(%rsp),%r10
0.02% │ │ 0x00007fc83d2451fb: mov %r10,(%rsp)
0.08% 0.01% │ │ 0x00007fc83d2451ff: vmovss %xmm4,0x8(%rsp)
0.19% 0.12% │ │ 0x00007fc83d245205: xchg %ax,%ax
0.01% │ │ 0x00007fc83d245207: callq 0x00007fc83d046020 ; OopMap{[24]=Oop [32]=Oop [52]=NarrowOop [72]=Oop [80]=Oop off=652}
│ │ ;*invokevirtual add
│ │ ; - com.google.re2j.Machine::match@318 (line 243)
│ │ ; {optimized virtual_call}
0.21% 0.24% │ │↗ 0x00007fc83d24520c: mov 0x58(%rsp),%ebx
0.08% 0.09% │ ││ 0x00007fc83d245210: test %ebx,%ebx
│╭ ││ 0x00007fc83d245212: jl 0x00007fc83d245583 ;*ifge
││ ││ ; - com.google.re2j.Utils::emptyOpContext@3 (line 173)
││ ││ ; - com.google.re2j.Machine::match@326 (line 245)
0.17% 0.21% ││ ││ 0x00007fc83d245218: xor %r10d,%r10d ;*iload_0
││ ││ ; - com.google.re2j.Utils::emptyOpContext@10 (line 176)
││ ││ ; - com.google.re2j.Machine::match@326 (line 245)
0.27% 0.32% ││ ││↗ 0x00007fc83d24521b: cmp $0xa,%ebx
││ │││ 0x00007fc83d24521e: je 0x00007fc83d245727 ;*iload_1
││ │││ ; - com.google.re2j.Utils::emptyOpContext@20 (line 179)
││ │││ ; - com.google.re2j.Machine::match@326 (line 245)
0.12% 0.12% ││ │││ 0x00007fc83d245224: mov 0x2c(%rsp),%r11d
0.03% 0.05% ││ │││ 0x00007fc83d245229: test %r11d,%r11d
││╭ │││ 0x00007fc83d24522c: jl 0x00007fc83d24558e ;*iload_1
│││ │││ ; - com.google.re2j.Utils::emptyOpContext@29 (line 182)
│││ │││ ; - com.google.re2j.Machine::match@326 (line 245)
0.17% 0.16% │││ │││↗ 0x00007fc83d245232: cmp $0xa,%r11d
│││ ││││ 0x00007fc83d245236: je 0x00007fc83d245730 ;*iload_0
│││ ││││ ; - com.google.re2j.Utils::emptyOpContext@39 (line 185)
│││ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.29% 0.26% │││ ││││ 0x00007fc83d24523c: mov 0x58(%rsp),%r8d
0.13% 0.16% │││ ││││ 0x00007fc83d245241: add $0xffffffbf,%r8d
0.05% 0.04% │││ ││││ 0x00007fc83d245245: cmp $0x1a,%r8d
│││╭ ││││ 0x00007fc83d245249: jb 0x00007fc83d24525e ;*if_icmple
││││ ││││ ; - com.google.re2j.Utils::isWordRune@9 (line 149)
││││ ││││ ; - com.google.re2j.Utils::emptyOpContext@40 (line 185)
││││ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.19% 0.15% ││││ ││││ 0x00007fc83d24524b: mov 0x58(%rsp),%r9d
0.22% 0.39% ││││ ││││ 0x00007fc83d245250: add $0xffffff9f,%r9d
0.11% 0.14% ││││ ││││ 0x00007fc83d245254: cmp $0x1a,%r9d
││││ ││││ 0x00007fc83d245258: jae 0x00007fc83d2459da ;*iconst_1
││││ ││││ ; - com.google.re2j.Utils::isWordRune@42 (line 149)
││││ ││││ ; - com.google.re2j.Utils::emptyOpContext@40 (line 185)
││││ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.10% 0.05% │││↘ ││││ 0x00007fc83d24525e: mov $0x1,%ebp ;*ireturn
│││ ││││ ; - com.google.re2j.Utils::isWordRune@47 (line 149)
│││ ││││ ; - com.google.re2j.Utils::emptyOpContext@40 (line 185)
│││ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.20% 0.21% │││ ││││ 0x00007fc83d245263: mov 0x2c(%rsp),%r8d
0.30% 0.32% │││ ││││ 0x00007fc83d245268: add $0xffffffbf,%r8d
0.09% 0.13% │││ ││││ 0x00007fc83d24526c: cmp $0x1a,%r8d
│││ ╭ ││││ 0x00007fc83d245270: jb 0x00007fc83d245285 ;*if_icmple
│││ │ ││││ ; - com.google.re2j.Utils::isWordRune@9 (line 149)
│││ │ ││││ ; - com.google.re2j.Utils::emptyOpContext@44 (line 185)
│││ │ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.09% 0.06% │││ │ ││││ 0x00007fc83d245272: mov 0x2c(%rsp),%r9d
0.19% 0.16% │││ │ ││││ 0x00007fc83d245277: add $0xffffff9f,%r9d
0.25% 0.26% │││ │ ││││ 0x00007fc83d24527b: cmp $0x1a,%r9d
│││ │ ││││ 0x00007fc83d24527f: jae 0x00007fc83d2459fd ;*iconst_1
│││ │ ││││ ; - com.google.re2j.Utils::isWordRune@42 (line 149)
│││ │ ││││ ; - com.google.re2j.Utils::emptyOpContext@44 (line 185)
│││ │ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.18% 0.19% │││ ↘ ││││ 0x00007fc83d245285: mov $0x1,%r8d ;*ireturn
│││ ││││ ; - com.google.re2j.Utils::isWordRune@47 (line 149)
│││ ││││ ; - com.google.re2j.Utils::emptyOpContext@44 (line 185)
│││ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.14% 0.18% │││ ││││ 0x00007fc83d24528b: cmp %r8d,%ebp
│││ ╭ ││││ 0x00007fc83d24528e: je 0x00007fc83d24529b ;*if_icmpeq
│││ │ ││││ ; - com.google.re2j.Utils::emptyOpContext@47 (line 185)
│││ │ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.13% 0.16% │││ │ ││││ 0x00007fc83d245290: or $0x10,%r10d ;*ior ; - com.google.re2j.Utils::emptyOpContext@53 (line 186)
│││ │ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.02% 0.01% │││ │ ││││ 0x00007fc83d245294: mov %r10d,0x38(%rsp)
0.13% 0.16% │││ │╭ ││││ 0x00007fc83d245299: jmp 0x00007fc83d2452a4
0.16% 0.24% │││ ↘│ ││││ 0x00007fc83d24529b: or $0x20,%r10d ;*ior ; - com.google.re2j.Utils::emptyOpContext@61 (line 188)
│││ │ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.20% 0.27% │││ │ ││││ 0x00007fc83d24529f: mov %r10d,0x38(%rsp) ;*iload_2
│││ │ ││││ ; - com.google.re2j.Utils::emptyOpContext@63 (line 190)
│││ │ ││││ ; - com.google.re2j.Machine::match@326 (line 245)
0.19% 0.23% │││ ↘ ││││ 0x00007fc83d2452a4: mov 0x48(%rsp),%r8
0.08% 0.13% │││ ││││ 0x00007fc83d2452a9: mov 0x10(%r8),%r10d ;*getfield end
│││ ││││ ; - com.google.re2j.MachineInput$UTF16Input::endPos@1 (line 221)
│││ ││││ ; - com.google.re2j.Machine::match@348 (line 246)
0.50% 0.31% │││ ││││ 0x00007fc83d2452ad: mov 0x5c(%rsp),%ecx
0.16% 0.22% │││ ││││ 0x00007fc83d2452b1: cmp %r10d,%ecx
│││ ╭ ││││ 0x00007fc83d2452b4: je 0x00007fc83d245597 ;*if_icmpne
│││ │ ││││ ; - com.google.re2j.Machine::match@351 (line 246)
0.38% 0.32% │││ │ ││││ 0x00007fc83d2452ba: xor %r10d,%r10d ;*invokespecial step
│││ │ ││││ ; - com.google.re2j.Machine::match@359 (line 246)
0.05% 0.06% │││ │ ││││↗ 0x00007fc83d2452bd: mov %rax,-0x8(%rsp)
0.10% 0.15% │││ │ │││││ 0x00007fc83d2452c2: mov 0x5c(%rsp),%eax
0.11% 0.17% │││ │ │││││ 0x00007fc83d2452c6: mov %eax,0x58(%rsp)
0.28% 0.18% │││ │ │││││ 0x00007fc83d2452ca: mov -0x8(%rsp),%rax ;*invokevirtual endPos
│││ │ │││││ ; - com.google.re2j.Machine::match@348 (line 246)
0.42% 0.15% │││ │ │││││ 0x00007fc83d2452cf: add 0x28(%rsp),%ecx ;*iadd
│││ │ │││││ ; - com.google.re2j.Machine::match@340 (line 246)
0.16% 0.10% │││ │ │││││ 0x00007fc83d2452d3: mov %ecx,0x5c(%rsp)
0.18% 0.18% │││ │ │││││ 0x00007fc83d2452d7: mov 0x50(%rsp),%rsi
0.19% 0.21% │││ │ │││││ 0x00007fc83d2452dc: mov 0x18(%rsp),%rdx
0.14% 0.06% │││ │ │││││ 0x00007fc83d2452e1: mov 0x20(%rsp),%rcx
0.10% 0.11% │││ │ │││││ 0x00007fc83d2452e6: mov 0x58(%rsp),%r8d
0.20% 0.18% │││ │ │││││ 0x00007fc83d2452eb: mov 0x5c(%rsp),%r9d
0.46% 0.34% │││ │ │││││ 0x00007fc83d2452f0: mov %ebx,%edi
0.05% 0.03% │││ │ │││││ 0x00007fc83d2452f2: mov 0x38(%rsp),%ebx
0.09% 0.19% │││ │ │││││ 0x00007fc83d2452f6: mov %ebx,(%rsp)
0.14% 0.20% │││ │ │││││ 0x00007fc83d2452f9: xor %ebx,%ebx
0.20% 0.21% │││ │ │││││ 0x00007fc83d2452fb: mov %ebx,0x8(%rsp)
0.07% 0.08% │││ │ │││││ 0x00007fc83d2452ff: mov %r10d,0x10(%rsp)
0.08% 0.09% │││ │ │││││ 0x00007fc83d245304: data16 xchg %ax,%ax
0.16% 0.17% │││ │ │││││ 0x00007fc83d245307: callq 0x00007fc83d046020 ; OopMap{[24]=Oop [32]=Oop [52]=NarrowOop [72]=Oop [80]=Oop off=908}
│││ │ │││││ ;*invokespecial step
│││ │ │││││ ; - com.google.re2j.Machine::match@359 (line 246)
│││ │ │││││ ; {optimized virtual_call}
0.05% 0.08% │││ │ │││││ 0x00007fc83d24530c: mov 0x50(%rsp),%r10
0.55% 0.80% │││ │ │││││ 0x00007fc83d245311: movzbl 0x11(%r10),%ecx ;*getfield captures
│││ │ │││││ ; - com.google.re2j.Machine::match@371 (line 250)
0.05% 0.01% │││ │ │││││ 0x00007fc83d245316: movzbl 0x10(%r10),%eax ;*getfield matched
│││ │ │││││ ; - com.google.re2j.Machine::match@378 (line 250)
0.03% 0.03% │││ │ │││││ 0x00007fc83d24531b: mov 0x28(%rsp),%r8d
0.52% 0.61% │││ │ │││││ 0x00007fc83d245320: test %r8d,%r8d
│││ │╭ │││││ 0x00007fc83d245323: je 0x00007fc83d2455b1 ;*ifne
│││ ││ │││││ ; - com.google.re2j.Machine::match@364 (line 247)
│││ ││ │││││ 0x00007fc83d245329: test %ecx,%ecx
│││ ││ │││││ 0x00007fc83d24532b: jne 0x00007fc83d245c05 ;*ifne
│││ ││ │││││ ; - com.google.re2j.Machine::match@374 (line 250)
0.00% 0.02% │││ ││ │││││ 0x00007fc83d245331: test %eax,%eax
│││ ││ │││││ 0x00007fc83d245333: jne 0x00007fc83d245e3d ;*ifeq
│││ ││ │││││ ; - com.google.re2j.Machine::match@381 (line 250)
0.06% 0.05% │││ ││ │││││ 0x00007fc83d245339: mov %r10,%rbx
0.61% 0.65% │││ ││ │││││ 0x00007fc83d24533c: mov 0x48(%rsp),%r10
0.00% │││ ││ │││││ 0x00007fc83d245341: mov 0x10(%r10),%r11d ;*getfield end
│││ ││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@9 (line 186)
│││ ││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.01% 0.04% │││ ││ │││││ 0x00007fc83d245345: mov 0xc(%r10),%r9d ;*getfield start
│││ ││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@2 (line 185)
│││ ││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.01% 0.04% │││ ││ │││││ 0x00007fc83d245349: mov 0x14(%r10),%r13d ;*getfield str
│││ ││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@16 (line 187)
│││ ││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.62% 0.81% │││ ││ │││││ 0x00007fc83d24534d: mov 0x2c(%rsp),%r8d
│││ ││ │││││ 0x00007fc83d245352: cmp $0xffffffff,%r8d
│││ ││╭ │││││ 0x00007fc83d245356: je 0x00007fc83d2455a2 ;*if_icmpeq
│││ │││ │││││ ; - com.google.re2j.Machine::match@403 (line 258)
0.00% │││ │││ │││││ 0x00007fc83d24535c: mov 0x30(%rsp),%r8d
0.03% 0.08% │││ │││ │││││ 0x00007fc83d245361: add 0x5c(%rsp),%r8d
0.53% 0.76% │││ │││ │││││ 0x00007fc83d245366: add %r9d,%r8d ;*iadd
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@5 (line 185)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
│││ │││ │││││ 0x00007fc83d245369: cmp %r11d,%r8d
│││ │││ │││││ 0x00007fc83d24536c: jge 0x00007fc83d24571a ;*if_icmpge
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@12 (line 186)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.04% │││ │││ │││││ 0x00007fc83d245372: mov 0x8(%r12,%r13,8),%r10d ; implicit exception: dispatches to 0x00007fc83d246e59
0.67% 0.71% │││ │││ │││││ 0x00007fc83d245377: cmp $0xf80002da,%r10d ; {metadata('java/lang/String')}
│││ │││ │││││ 0x00007fc83d24537e: jne 0x00007fc83d245b49
0.54% 0.68% │││ │││ │││││ 0x00007fc83d245384: lea (%r12,%r13,8),%rdx ;*invokeinterface charAt
│││ │││ │││││ ; - java.lang.Character::codePointAt@2 (line 4866)
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
│││ │││ │││││ 0x00007fc83d245388: test %r8d,%r8d
│││ │││ │││││ 0x00007fc83d24538b: jl 0x00007fc83d245c59 ;*iflt
│││ │││ │││││ ; - java.lang.String::charAt@1 (line 657)
│││ │││ │││││ ; - java.lang.Character::codePointAt@2 (line 4866)
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.03% 0.02% │││ │││ │││││ 0x00007fc83d245391: mov 0xc(%rdx),%r10d ;*getfield value
│││ │││ │││││ ; - java.lang.String::charAt@6 (line 657)
│││ │││ │││││ ; - java.lang.Character::codePointAt@2 (line 4866)
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.07% 0.07% │││ │││ │││││ 0x00007fc83d245395: mov 0xc(%r12,%r10,8),%ebp ;*arraylength
│││ │││ │││││ ; - java.lang.String::charAt@9 (line 657)
│││ │││ │││││ ; - java.lang.Character::codePointAt@2 (line 4866)
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
│││ │││ │││││ ; implicit exception: dispatches to 0x00007fc83d246e6d
2.31% 2.68% │││ │││ │││││ 0x00007fc83d24539a: cmp %ebp,%r8d
│││ │││ │││││ 0x00007fc83d24539d: jge 0x00007fc83d245e91 ;*if_icmplt
│││ │││ │││││ ; - java.lang.String::charAt@10 (line 657)
│││ │││ │││││ ; - java.lang.Character::codePointAt@2 (line 4866)
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.55% 0.72% │││ │││ │││││ 0x00007fc83d2453a3: cmp %ebp,%r8d
│││ │││ │││││ 0x00007fc83d2453a6: jae 0x00007fc83d245ad7
0.21% 0.25% │││ │││ │││││ 0x00007fc83d2453ac: shl $0x3,%r10
0.01% │││ │││ │││││ 0x00007fc83d2453b0: movzwl 0x10(%r10,%r8,2),%edi ;*caload
│││ │││ │││││ ; - java.lang.String::charAt@27 (line 660)
│││ │││ │││││ ; - java.lang.Character::codePointAt@2 (line 4866)
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.26% 0.32% │││ │││ │││││ 0x00007fc83d2453b6: cmp $0xd800,%edi
│││ │││ │││││ 0x00007fc83d2453bc: jge 0x00007fc83d245ef1 ;*if_icmplt
│││ │││ │││││ ; - java.lang.Character::isHighSurrogate@3 (line 4729)
│││ │││ │││││ ; - java.lang.Character::codePointAt@9 (line 4867)
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@20 (line 187)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.40% 0.67% │││ │││ │││││ 0x00007fc83d2453c2: shl $0x3,%edi ;*ishl
│││ │││ │││││ ; - com.google.re2j.MachineInput$UTF16Input::step@38 (line 190)
│││ │││ │││││ ; - com.google.re2j.Machine::match@411 (line 259)
0.30% 0.37% │││ │││ │││││ 0x00007fc83d2453c5: mov %edi,%r10d
0.00% 0.00% │││ │││ │││││ 0x00007fc83d2453c8: or $0x1,%r10d
0.51% 0.65% │││ │││ │││││ 0x00007fc83d2453cc: and $0x7,%edi
0.01% 0.02% │││ │││ │││││ 0x00007fc83d2453cf: sar $0x3,%r10d ;*ishr
│││ │││ │││││ ; - com.google.re2j.Machine::match@419 (line 260)
0.56% 0.72% │││ │││ │││││ 0x00007fc83d2453d3: or $0x1,%edi ; OopMap{rbx=Oop r13=NarrowOop [24]=Oop [32]=Oop [72]=Oop off=1110}
│││ │││ │││││ ;*goto
│││ │││ │││││ ; - com.google.re2j.Machine::match@441 (line 266)
0.01% 0.00% │││ │││ │││││↗ 0x00007fc83d2453d6: test %eax,0x18549c24(%rip) # 0x00007fc85578f000
│││ │││ ││││││ ;*goto
│││ │││ ││││││ ; - com.google.re2j.Machine::match@441 (line 266)
│││ │││ ││││││ ; {poll}
0.04% 0.04% │││ │││ ││││││ 0x00007fc83d2453dc: mov 0x28(%rbx),%r14d ;*getfield matchcap
│││ │││ ││││││ ; - com.google.re2j.Machine::match@307 (line 243)
0.01% 0.02% │││ │││ ││││││ 0x00007fc83d2453e0: mov 0x14(%rbx),%esi ;*getfield re2
│││ │││ ││││││ ; - com.google.re2j.Machine::match@169 (line 220)
0.57% 0.74% │││ │││ ││││││ 0x00007fc83d2453e3: mov 0x20(%rsp),%r8
│││ │││ ││││││ 0x00007fc83d2453e8: mov %r8,%rdx
0.02% 0.01% │││ │││ ││││││ 0x00007fc83d2453eb: shr $0x3,%rdx
0.01% 0.01% │││ │││ ││││││ 0x00007fc83d2453ef: mov %edx,0x34(%rsp)
0.67% 0.65% │││ │││ ││││││ 0x00007fc83d2453f3: mov 0x2c(%rsp),%r8d
0.00% │││ │││ ││││││ 0x00007fc83d2453f8: mov %r10d,0x2c(%rsp)
0.01% 0.03% │││ │││ ││││││ 0x00007fc83d2453fd: mov 0x18(%rsp),%r10
0.01% 0.01% │││ │││ ││││││ 0x00007fc83d245402: mov %r10,0x20(%rsp)
0.50% 0.72% │││ │││ ││││││ 0x00007fc83d245407: vmovd %ecx,%xmm4
0.00% │││ │││ ││││││ 0x00007fc83d24540b: mov 0x30(%rsp),%r10d
0.02% 0.02% │││ │││ ││││││ 0x00007fc83d245410: mov %r10d,0x28(%rsp)
0.01% 0.01% │││ │││ ││││││ 0x00007fc83d245415: mov %edi,0x30(%rsp)
0.55% 0.80% │││ │││ ││││││ 0x00007fc83d245419: mov %r9d,0x60(%rsp)
│││ │││ ││││││ 0x00007fc83d24541e: mov %r11d,0x64(%rsp)
0.02% 0.02% ↘││ │││ ││││││ 0x00007fc83d245423: mov 0x34(%rsp),%r11d
0.20% 0.07% ││ │││ ││││││ 0x00007fc83d245428: movzbl 0x18(%r12,%r11,8),%r11d ; implicit exception: dispatches to 0x00007fc83d246e1e
0.59% 0.70% ││ │││ ││││││ 0x00007fc83d24542e: mov 0x34(%rsp),%r10d
0.02% 0.00% ││ │││ ││││││ 0x00007fc83d245433: shl $0x3,%r10 ;*aload
││ │││ ││││││ ; - com.google.re2j.Machine::match@136 (line 211)
0.01% ││ │││ ││││││ 0x00007fc83d245437: mov %r10,0x18(%rsp)
0.01% 0.01% ││ │││ ││││││ 0x00007fc83d24543c: test %r11d,%r11d
││ │││╭ ││││││ 0x00007fc83d24543f: je 0x00007fc83d245483 ;*ifeq
││ ││││ ││││││ ; - com.google.re2j.Machine::match@141 (line 211)
0.21% 0.20% ││ ││││ ││││││ 0x00007fc83d245441: mov 0x44(%rsp),%r11d
0.01% 0.00% ││ ││││ ││││││ 0x00007fc83d245446: test %r11d,%r11d
││ ││││ ││││││ 0x00007fc83d245449: jne 0x00007fc83d246071 ;*ifeq
││ ││││ ││││││ ; - com.google.re2j.Machine::match@148 (line 212)
││ ││││ ││││││ 0x00007fc83d24544f: test %eax,%eax
││ ││││ ││││││ 0x00007fc83d245451: jne 0x00007fc83d2460d1 ;*ifeq
││ ││││ ││││││ ; - com.google.re2j.Machine::match@162 (line 216)
0.01% 0.01% ││ ││││ ││││││ 0x00007fc83d245457: mov 0x24(%r12,%rsi,8),%r10d ;*getfield prefix
││ ││││ ││││││ ; - com.google.re2j.Machine::match@172 (line 220)
││ ││││ ││││││ ; implicit exception: dispatches to 0x00007fc83d246e91
0.19% 0.26% ││ ││││ ││││││ 0x00007fc83d24545c: mov %r10d,%r9d
0.00% ││ ││││ ││││││ 0x00007fc83d24545f: mov 0xc(%r12,%r10,8),%r10d ;*getfield value
││ ││││ ││││││ ; - java.lang.String::isEmpty@1 (line 635)
││ ││││ ││││││ ; - com.google.re2j.Machine::match@175 (line 220)
││ ││││ ││││││ ; implicit exception: dispatches to 0x00007fc83d246ea1
││ ││││ ││││││ 0x00007fc83d245464: vmovd %r10d,%xmm0
0.02% 0.01% ││ ││││ ││││││ 0x00007fc83d245469: mov 0xc(%r12,%r10,8),%r10d ;*arraylength
││ ││││ ││││││ ; - java.lang.String::isEmpty@4 (line 635)
││ ││││ ││││││ ; - com.google.re2j.Machine::match@175 (line 220)
││ ││││ ││││││ ; implicit exception: dispatches to 0x00007fc83d246eb1
0.26% 0.24% ││ ││││ ││││││ 0x00007fc83d24546e: mov %r10d,0x50(%rsp)
0.03% 0.00% ││ ││││ ││││││ 0x00007fc83d245473: test %r10d,%r10d
││ ││││ ││││││ 0x00007fc83d245476: jne 0x00007fc83d2457e4 ;*ifne
││ ││││ ││││││ ; - com.google.re2j.Machine::match@178 (line 220)
││ ││││ ││││││ 0x00007fc83d24547c: mov %r8d,0x58(%rsp)
0.02% 0.00% ││ ││││╭││││││ 0x00007fc83d245481: jmp 0x00007fc83d245488
0.32% 0.38% ││ │││↘│││││││ 0x00007fc83d245483: mov %r8d,0x58(%rsp) ;*iload_3
││ │││ │││││││ ; - com.google.re2j.Machine::match@267 (line 237)
0.31% 0.19% ││ │││ ↘││││││ 0x00007fc83d245488: test %eax,%eax
││ │││ ││││││ 0x00007fc83d24548a: jne 0x00007fc83d245bad ;*ifne
││ │││ ││││││ ; - com.google.re2j.Machine::match@279 (line 237)
0.01% 0.02% ││ │││ ││││││ 0x00007fc83d245490: vmovd %xmm4,%r10d
0.02% 0.00% ││ │││ ││││││ 0x00007fc83d245495: test %r10d,%r10d
││ │││ ││││││ 0x00007fc83d245498: jne 0x00007fc83d245d25 ;*ifeq
││ │││ ││││││ ; - com.google.re2j.Machine::match@286 (line 240)
0.32% 0.30% ││ │││ ││││││ 0x00007fc83d24549e: mov %rbx,%r11
0.23% 0.09% ││ │││ ││││││ 0x00007fc83d2454a1: mov 0x18(%rbx),%r8d ;*getfield prog
││ │││ ││││││ ; - com.google.re2j.Machine::match@297 (line 243)
0.04% 0.01% ││ │││ ││││││ 0x00007fc83d2454a5: mov 0x1c(%r12,%r8,8),%ebp ;*getfield startInst
││ │││ ││││││ ; - com.google.re2j.Machine::match@300 (line 243)
││ │││ ││││││ ; implicit exception: dispatches to 0x00007fc83d246e2d
0.01% ││ │││ ││││││ 0x00007fc83d2454aa: mov %r11,0x50(%rsp)
0.36% 0.31% ││ │││ ││││││ 0x00007fc83d2454af: mov 0x8(%r12,%rbp,8),%r11d ; implicit exception: dispatches to 0x00007fc83d246e3d
0.23% 0.06% ││ │││ ││││││ 0x00007fc83d2454b4: lea (%r12,%rbp,8),%r10
0.01% 0.01% ││ │││ ││││││ 0x00007fc83d2454b8: cmp $0xf8019a09,%r11d ; {metadata('com/google/re2j/Inst$Alt5Inst')}
││ │││ ╰│││││ 0x00007fc83d2454bf: je 0x00007fc83d2451dc
0.00% ││ │││ │││││ 0x00007fc83d2454c5: cmp $0xf8019909,%r11d ; {metadata('com/google/re2j/Inst$MatchInst')}
││ │││ │││││ 0x00007fc83d2454cc: jne 0x00007fc83d245d81 ;*invokevirtual add
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.28% 0.24% ││ │││ │││││ 0x00007fc83d2454d2: mov 0x18(%r10),%ecx ;*getfield pc
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
││ │││ │││││ 0x00007fc83d2454d6: cmp $0x40,%ecx
││ │││ │││││ 0x00007fc83d2454d9: jg 0x00007fc83d245f4d ;*if_icmpgt
││ │││ │││││ ; - com.google.re2j.Machine$Queue::contains@3 (line 41)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.02% 0.01% ││ │││ │││││ 0x00007fc83d2454df: mov %r10,%r9
0.00% 0.00% ││ │││ │││││ 0x00007fc83d2454e2: mov $0x1,%r8d
0.25% 0.23% ││ │││ │││││ 0x00007fc83d2454e8: shl %cl,%r8 ;*lshl
││ │││ │││││ ; - com.google.re2j.Machine$Queue::contains@12 (line 42)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.03% 0.04% ││ │││ │││││ 0x00007fc83d2454eb: mov 0x34(%rsp),%r11d
0.25% 0.16% ││ │││ │││││ 0x00007fc83d2454f0: mov 0x10(%r12,%r11,8),%r10 ;*getfield pcsl
││ │││ │││││ ; - com.google.re2j.Machine$Queue::contains@7 (line 42)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.01% ││ │││ │││││ 0x00007fc83d2454f5: mov %r10,%r11
0.01% ││ │││ │││││ 0x00007fc83d2454f8: and %r8,%r11 ;*land
││ │││ │││││ ; - com.google.re2j.Machine$Queue::contains@13 (line 42)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.01% 0.01% ││ │││ │││││ 0x00007fc83d2454fb: test %r11,%r11
││ │││ │││││ 0x00007fc83d2454fe: jne 0x00007fc83d245fa5 ;*ifeq
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.32% 0.15% ││ │││ │││││ 0x00007fc83d245504: cmp $0x40,%ecx
││ │││ │││││ 0x00007fc83d245507: jge 0x00007fc83d246019 ;*if_icmpge
││ │││ │││││ ; - com.google.re2j.Machine$Queue::add@3 (line 51)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.00% ││ │││ │││││ 0x00007fc83d24550d: mov 0x34(%rsp),%r11d
0.01% 0.01% ││ │││ │││││ 0x00007fc83d245512: mov %r12b,0x18(%r12,%r11,8) ;*putfield empty
││ │││ │││││ ; - com.google.re2j.Machine$Queue::add@33 (line 56)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.01% 0.02% ││ │││ │││││ 0x00007fc83d245517: mov 0x20(%r12,%r11,8),%ebx ;*getfield denseThreadsInstructions
││ │││ │││││ ; - com.google.re2j.Machine$Queue::addThread@1 (line 66)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.26% 0.19% ││ │││ │││││ 0x00007fc83d24551c: mov 0xc(%r12,%r11,8),%ebp ;*getfield size
││ │││ │││││ ; - com.google.re2j.Machine$Queue::addThread@6 (line 66)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
││ │││ │││││ 0x00007fc83d245521: or %r10,%r8
0.01% 0.01% ││ │││ │││││ 0x00007fc83d245524: mov %r8,0x10(%r12,%r11,8) ;*putfield pcsl
││ │││ │││││ ; - com.google.re2j.Machine$Queue::add@15 (line 52)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.00% 0.01% ││ │││ │││││ 0x00007fc83d245529: mov %ebp,%r11d
0.29% 0.25% ││ │││ │││││ 0x00007fc83d24552c: inc %r11d
││ │││ │││││ 0x00007fc83d24552f: mov 0x34(%rsp),%r10d
0.01% 0.02% ││ │││ │││││ 0x00007fc83d245534: mov %r11d,0xc(%r12,%r10,8) ;*putfield size
││ │││ │││││ ; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.02% 0.01% ││ │││ │││││ 0x00007fc83d245539: mov 0xc(%r12,%rbx,8),%r11d ; implicit exception: dispatches to 0x00007fc83d246e7d
0.23% 0.31% ││ │││ │││││ 0x00007fc83d24553e: cmp %r11d,%ebp
││ │││ │││││ 0x00007fc83d245541: jae 0x00007fc83d245cc9
0.09% 0.04% ││ │││ │││││ 0x00007fc83d245547: mov 0x8(%r12,%rbx,8),%r11d
0.01% ││ │││ │││││ 0x00007fc83d24554c: cmp $0xf8019807,%r11d ; {metadata('com/google/re2j/Inst'[])}
││ │││ │││││ 0x00007fc83d245553: jne 0x00007fc83d245de1
0.04% 0.04% ││ │││ │││││ 0x00007fc83d245559: mov %r9,%r11
0.24% 0.15% ││ │││ │││││ 0x00007fc83d24555c: shr $0x3,%r11 ;*aastore
││ │││ │││││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.03% 0.01% ││ │││ │││││ 0x00007fc83d245560: lea (%r12,%rbx,8),%r10 ;*getfield denseThreadsInstructions
││ │││ │││││ ; - com.google.re2j.Machine$Queue::addThread@1 (line 66)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.00% 0.00% ││ │││ │││││ 0x00007fc83d245564: lea 0x10(%r10,%rbp,4),%r10
0.07% 0.03% ││ │││ │││││ 0x00007fc83d245569: mov %r11d,(%r10)
0.33% 0.27% ││ │││ │││││ 0x00007fc83d24556c: shr $0x9,%r10
0.02% 0.00% ││ │││ │││││ 0x00007fc83d245570: movabs $0x7fc84e197000,%r11
0.00% 0.00% ││ │││ │││││ 0x00007fc83d24557a: mov %r12b,(%r11,%r10,1) ;*aastore
││ │││ │││││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││ │││ │││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ │││ │││││ ; - com.google.re2j.Machine::match@318 (line 243)
0.31% 0.33% ││ │││ ╰││││ 0x00007fc83d24557e: jmpq 0x00007fc83d24520c
0.00% ↘│ │││ ││││ 0x00007fc83d245583: mov $0x5,%r10d
│ │││ ╰│││ 0x00007fc83d245589: jmpq 0x00007fc83d24521b
0.01% ↘ │││ │││ 0x00007fc83d24558e: or $0xa,%r10d ;*ior ; - com.google.re2j.Utils::emptyOpContext@27 (line 180)
│││ │││ ; - com.google.re2j.Machine::match@326 (line 245)
│││ ╰││ 0x00007fc83d245592: jmpq 0x00007fc83d245232
0.00% ↘││ ││ 0x00007fc83d245597: mov $0x1,%r10d
││ ╰│ 0x00007fc83d24559d: jmpq 0x00007fc83d2452bd
│↘ │ 0x00007fc83d2455a2: mov 0x30(%rsp),%edi
0.01% 0.00% │ │ 0x00007fc83d2455a6: mov $0xffffffff,%r10d
│ ╰ 0x00007fc83d2455ac: jmpq 0x00007fc83d2453d6
↘ 0x00007fc83d2455b1: test %ecx,%ecx
0x00007fc83d2455b3: jne 0x00007fc83d2468e8 ;*ifeq
; - com.google.re2j.Machine::freeQueue@4 (line 150)
; - com.google.re2j.Machine::freeQueue@3 (line 146)
; - com.google.re2j.Machine::match@447 (line 267)
0.00% 0x00007fc83d2455b9: jmpq 0x00007fc83d2456e3
0x00007fc83d2455be: test %edi,%edi
0x00007fc83d2455c0: jl 0x00007fc83d2456d2 ;*ifge
; - com.google.re2j.MachineInput$UTF16Input::index@22 (line 205)
; - com.google.re2j.Machine::match@206 (line 224)
0x00007fc83d2455c6: mov %edi,%r10d
0x00007fc83d2455c9: sub 0x2c(%rsp),%r10d ;*isub
; - com.google.re2j.MachineInput$UTF16Input::index@31 (line 205)
; - com.google.re2j.Machine::match@206 (line 224)
0x00007fc83d2455ce: test %r10d,%r10d
0x00007fc83d2455d1: jl 0x00007fc83d2456d2 ;*ifge
; - com.google.re2j.Machine::match@213 (line 225)
0.00% 0x00007fc83d2455d7: mov 0x5c(%rsp),%r8d
0x00007fc83d2455dc: add %r10d,%r8d ;*iadd
; - com.google.re2j.Machine::match@222 (line 228)
0x00007fc83d2455df: mov %r8d,%edi
0x00007fc83d2455e2: mov %r8d,%r10d
0.00% 0x00007fc83d2455e5: add 0x60(%rsp),%r10d ;*iadd
; - com.google.re2j.MachineInput$UTF16Input::step@5 (line 185)
; - com.google.re2j.Machine::match@226 (line 229)
0x00007fc83d2455ea: mov %r10d,%r9d
0x00007fc83d2455ed: cmp 0x64(%rsp),%r10d
0x00007fc83d2455f2: jge 0x00007fc83d245aac ;*if_icmpge
; - com.google.re2j.MachineInput$UTF16Input::step@12 (line 186)
; - com.google.re2j.Machine::match@226 (line 229)
0x00007fc83d2455f8: test %r10d,%r10d
0x00007fc83d2455fb: jl 0x00007fc83d246b09 ;*iflt
; - java.lang.String::charAt@1 (line 657)
....................................................................................................
28.59% 29.86% <total for region 1>
....[Hottest Region 2]..............................................................................
C2, level 4, com.google.re2j.Machine::step, version 494 (195 bytes)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Machine::step@214 (line 317)
; {optimized virtual_call}
0x00007fc83d21fe60: test %rax,%rax
0x00007fc83d21fe63: jne 0x00007fc83d2212fd
0x00007fc83d21fe69: mov 0x48(%rsp),%r11 ;*synchronization entry
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.10% 0.07% 0x00007fc83d21fe6e: mov 0x28(%rsp),%r14
0.05% 0.07% 0x00007fc83d21fe73: mov 0xac(%rsp),%eax
0.16% 0.22% 0x00007fc83d21fe7a: mov 0x30(%rsp),%r13
0.08% 0.16% 0x00007fc83d21fe7f: mov 0xa4(%rsp),%r10d ;*synchronization entry
; - com.google.re2j.Machine::step@-1 (line 280)
0.07% 0.11% 0x00007fc83d21fe87: mov 0xa8(%rsp),%r8d
0.05% 0.07% 0x00007fc83d21fe8f: mov 0xb0(%rsp),%ebx ;*aload
; - com.google.re2j.Machine::step@219 (line 320)
1.39% 1.30% 0x00007fc83d21fe96: inc %r10d ;*iinc
; - com.google.re2j.Machine::step@230 (line 286)
0.18% 0.19% 0x00007fc83d21fe99: cmp %eax,%r10d
0x00007fc83d21fe9c: jge 0x00007fc83d21ff7d
0.97% 1.01% 0x00007fc83d21fea2: mov %r11,%r9
0.10% 0.09% 0x00007fc83d21fea5: mov %r8d,0xa8(%rsp)
1.02% 1.14% 0x00007fc83d21fead: mov %ebx,0xb0(%rsp) ;*iload
; - com.google.re2j.Machine::step@43 (line 289)
0.20% 0.27% 0x00007fc83d21feb4: mov 0x10(%r13,%r10,4),%r8d ;*aaload
; - com.google.re2j.Machine::step@99 (line 299)
1.16% 1.32% 0x00007fc83d21feb9: mov 0xc(%r12,%r8,8),%r11d ;*getfield op
; - com.google.re2j.Machine::step@104 (line 301)
; implicit exception: dispatches to 0x00007fc83d221369
1.72% 1.86% 0x00007fc83d21febe: cmp $0x6,%r11d
0x00007fc83d21fec2: je 0x00007fc83d21ffc5 ;*if_icmpne
; - com.google.re2j.Machine::step@109 (line 301)
1.70% 1.70% 0x00007fc83d21fec8: cmp $0xa,%r11d
0x00007fc83d21fecc: je 0x00007fc83d21f9dd ;*if_icmpne
; - com.google.re2j.Inst::matchRune@6 (line 90)
; - com.google.re2j.Machine::step@191 (line 316)
0.61% 0.66% 0x00007fc83d21fed2: cmp $0xb,%r11d
0x00007fc83d21fed6: je 0x00007fc83d22006a ;*if_icmpne
; - com.google.re2j.Inst::matchRune@17 (line 94)
; - com.google.re2j.Machine::step@191 (line 316)
1.25% 1.15% 0x00007fc83d21fedc: mov 0x1c(%r12,%r8,8),%ecx ;*getfield f0
; - com.google.re2j.Inst::matchRune@42 (line 99)
; - com.google.re2j.Machine::step@191 (line 316)
0.08% 0.07% 0x00007fc83d21fee1: cmp $0x9,%r11d
╭ 0x00007fc83d21fee5: jne 0x00007fc83d21fef9 ;*if_icmpne
│ ; - com.google.re2j.Inst::matchRune@38 (line 98)
│ ; - com.google.re2j.Machine::step@191 (line 316)
0.36% 0.16% │ 0x00007fc83d21fee7: cmp 0x18(%rsp),%ecx
│ 0x00007fc83d21feeb: je 0x00007fc83d21ffba ;*if_icmpne
│ ; - com.google.re2j.Inst::matchRune@46 (line 99)
│ ; - com.google.re2j.Machine::step@191 (line 316)
0.05% 0.04% │ 0x00007fc83d21fef1: xor %r11d,%r11d
0.27% 0.12% │ 0x00007fc83d21fef4: jmpq 0x00007fc83d21f933
0.91% 1.02% ↘ 0x00007fc83d21fef9: cmp $0xc,%r11d
0x00007fc83d21fefd: jne 0x00007fc83d220099 ;*if_icmpne
; - com.google.re2j.Inst::matchRune@61 (line 102)
; - com.google.re2j.Machine::step@191 (line 316)
0.88% 1.02% 0x00007fc83d21ff03: cmp 0x18(%rsp),%ecx
0x00007fc83d21ff07: je 0x00007fc83d21ffaf ;*if_icmpeq
; - com.google.re2j.Inst::matchRune@69 (line 103)
; - com.google.re2j.Machine::step@191 (line 316)
0.94% 0.97% 0x00007fc83d21ff0d: mov 0x20(%r12,%r8,8),%r11d ;*getfield f1
; - com.google.re2j.Inst::matchRune@73 (line 103)
; - com.google.re2j.Machine::step@191 (line 316)
0.03% 0.04% 0x00007fc83d21ff12: cmp 0x18(%rsp),%r11d
0x00007fc83d21ff17: je 0x00007fc83d21ffaf ;*if_icmpeq
; - com.google.re2j.Inst::matchRune@77 (line 103)
; - com.google.re2j.Machine::step@191 (line 316)
1.56% 1.60% 0x00007fc83d21ff1d: mov 0x24(%r12,%r8,8),%ebp ;*getfield f2
; - com.google.re2j.Inst::matchRune@81 (line 103)
; - com.google.re2j.Machine::step@191 (line 316)
0.21% 0.16% 0x00007fc83d21ff22: cmp 0x18(%rsp),%ebp
0x00007fc83d21ff26: je 0x00007fc83d2200c9 ;*if_icmpeq
; - com.google.re2j.Inst::matchRune@85 (line 103)
; - com.google.re2j.Machine::step@191 (line 316)
1.43% 1.47% 0x00007fc83d21ff2c: mov 0x28(%r12,%r8,8),%ebp ;*getfield f3
; - com.google.re2j.Inst::matchRune@89 (line 103)
; - com.google.re2j.Machine::step@191 (line 316)
0.01% 0.05% 0x00007fc83d21ff31: cmp 0x18(%rsp),%ebp
0x00007fc83d21ff35: jne 0x00007fc83d21f930 ;*if_icmpne
; - com.google.re2j.Inst::matchRune@93 (line 103)
; - com.google.re2j.Machine::step@191 (line 316)
0x00007fc83d21ff3b: mov $0xffffff65,%esi
0x00007fc83d21ff40: mov %r10d,0xa4(%rsp)
0x00007fc83d21ff48: mov %r8d,0xac(%rsp)
0x00007fc83d21ff50: mov %r14,0x28(%rsp)
0x00007fc83d21ff55: mov %r9,0x30(%rsp)
....................................................................................................
17.51% 18.10% <total for region 2>
....[Hottest Region 3]..............................................................................
C2, level 4, com.google.re2j.Machine::step, version 494 (1013 bytes)
0x00007fc83d21f9c0: mov %r11d,(%rdx)
0x00007fc83d21f9c3: shr $0x9,%r10
0x00007fc83d21f9c7: movabs $0x7fc84e197000,%r11
0x00007fc83d21f9d1: mov %r12b,(%r11,%r10,1) ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21f9d5: mov %r13,%r11
0x00007fc83d21f9d8: jmpq 0x00007fc83d21fe6e
0.20% 0.15% 0x00007fc83d21f9dd: mov 0x2c(%r12,%r8,8),%r11d ;*getfield outInst
; - com.google.re2j.Machine::step@199 (line 317)
0.23% 0.15% 0x00007fc83d21f9e2: mov 0x8(%r12,%r11,8),%ebx ; implicit exception: dispatches to 0x00007fc83d221379
1.01% 0.74% 0x00007fc83d21f9e7: lea (%r12,%r11,8),%r8
0.01% 0.01% 0x00007fc83d21f9eb: cmp $0xf8019843,%ebx ; {metadata('com/google/re2j/Inst$Alt2Inst')}
╭ 0x00007fc83d21f9f1: je 0x00007fc83d21faa7
0.10% 0.04% │ 0x00007fc83d21f9f7: cmp $0xf8019909,%ebx ; {metadata('com/google/re2j/Inst$MatchInst')}
│ 0x00007fc83d21f9fd: jne 0x00007fc83d2207e9 ;*invokevirtual add
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.04% 0.02% │ 0x00007fc83d21fa03: mov 0x18(%r8),%edx ;*getfield pc
│ ; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
│ ; - com.google.re2j.Machine::step@214 (line 317)
│ 0x00007fc83d21fa07: mov %r9,%r11
│ 0x00007fc83d21fa0a: mov 0x10(%r9),%r9 ;*getfield pcsl
│ ; - com.google.re2j.Machine$Queue::contains@7 (line 42)
│ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ ; - com.google.re2j.Machine::step@214 (line 317)
│ ; implicit exception: dispatches to 0x00007fc83d221441
0.03% │ 0x00007fc83d21fa0e: cmp $0x40,%edx
│ 0x00007fc83d21fa11: jg 0x00007fc83d220ec9 ;*if_icmpgt
│ ; - com.google.re2j.Machine$Queue::contains@3 (line 41)
│ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.06% 0.00% │ 0x00007fc83d21fa17: mov $0x1,%ebx
│ 0x00007fc83d21fa1c: mov %edx,%ecx
│ 0x00007fc83d21fa1e: shl %cl,%rbx ;*lshl
│ ; - com.google.re2j.Machine$Queue::contains@12 (line 42)
│ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.14% 0.05% │ 0x00007fc83d21fa21: mov %r9,%rcx
│ 0x00007fc83d21fa24: and %rbx,%rcx ;*land
│ ; - com.google.re2j.Machine$Queue::contains@13 (line 42)
│ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.00% │ 0x00007fc83d21fa27: test %rcx,%rcx
│ 0x00007fc83d21fa2a: jne 0x00007fc83d220047 ;*ifeq
│ ; - com.google.re2j.Machine$Queue::contains@16 (line 42)
│ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.02% 0.03% │ 0x00007fc83d21fa30: xor %ebp,%ebp ;*ireturn
│ ; - com.google.re2j.Machine$Queue::contains@24 (line 42)
│ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.03% 0.01% │ 0x00007fc83d21fa32: test %rcx,%rcx
│ 0x00007fc83d21fa35: jne 0x00007fc83d220f51 ;*ifeq
│ ; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.02% 0.02% │ 0x00007fc83d21fa3b: cmp $0x40,%edx
│ 0x00007fc83d21fa3e: jge 0x00007fc83d220fc1 ;*if_icmpge
│ ; - com.google.re2j.Machine$Queue::add@3 (line 51)
│ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.01% 0.01% │ 0x00007fc83d21fa44: mov %r12b,0x18(%r11) ;*putfield empty
│ ; - com.google.re2j.Machine$Queue::add@33 (line 56)
│ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.00% │ 0x00007fc83d21fa48: or %r9,%rbx
0.04% 0.00% │ 0x00007fc83d21fa4b: mov %rbx,0x10(%r11) ;*putfield pcsl
│ ; - com.google.re2j.Machine$Queue::add@15 (line 52)
│ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.01% 0.03% │ 0x00007fc83d21fa4f: mov 0x20(%r11),%edx ;*getfield denseThreadsInstructions
│ ; - com.google.re2j.Machine$Queue::addThread@1 (line 66)
│ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.01% 0.00% │ 0x00007fc83d21fa53: mov 0xc(%r11),%ebp ;*getfield size
│ ; - com.google.re2j.Machine$Queue::addThread@6 (line 66)
│ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.04% │ 0x00007fc83d21fa57: mov %ebp,%ecx
0.03% 0.00% │ 0x00007fc83d21fa59: inc %ecx
0.09% 0.04% │ 0x00007fc83d21fa5b: mov %ecx,0xc(%r11) ;*putfield size
│ ; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
│ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.05% 0.01% │ 0x00007fc83d21fa5f: mov 0xc(%r12,%rdx,8),%ecx ; implicit exception: dispatches to 0x00007fc83d221455
0.01% 0.01% │ 0x00007fc83d21fa64: cmp %ecx,%ebp
│ 0x00007fc83d21fa66: jae 0x00007fc83d220761
0.02% 0.00% │ 0x00007fc83d21fa6c: mov 0x8(%r12,%rdx,8),%ecx
0.02% 0.02% │ 0x00007fc83d21fa71: cmp $0xf8019807,%ecx ; {metadata('com/google/re2j/Inst'[])}
│ 0x00007fc83d21fa77: jne 0x00007fc83d22085d ;*aastore
│ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
│ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.03% 0.01% │ 0x00007fc83d21fa7d: lea (%r12,%rdx,8),%r9 ;*getfield denseThreadsInstructions
│ ; - com.google.re2j.Machine$Queue::addThread@1 (line 66)
│ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│ ; - com.google.re2j.Machine::step@214 (line 317)
│ 0x00007fc83d21fa81: lea 0x10(%r9,%rbp,4),%r9
0.05% 0.01% │ 0x00007fc83d21fa86: shr $0x3,%r8
0.02% 0.00% │ 0x00007fc83d21fa8a: mov %r8d,(%r9)
0.31% 0.11% │ 0x00007fc83d21fa8d: mov %r9,%r8
│ 0x00007fc83d21fa90: shr $0x9,%r8
│ 0x00007fc83d21fa94: movabs $0x7fc84e197000,%r9
0.01% 0.02% │ 0x00007fc83d21fa9e: mov %r12b,(%r9,%r8,1) ;*aastore
│ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
│ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.13% 0.12% │ 0x00007fc83d21faa2: jmpq 0x00007fc83d21fe87 ;*invokevirtual add
│ ; - com.google.re2j.Machine::step@214 (line 317)
0.20% 0.30% ↘ 0x00007fc83d21faa7: mov 0x18(%r8),%edx ;*getfield pc
; - com.google.re2j.Inst$Alt2Inst::add@2 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.03% 0.04% 0x00007fc83d21faab: mov %r9,%r11
0.02% 0.01% 0x00007fc83d21faae: mov 0x10(%r9),%r9 ;*getfield pcsl
; - com.google.re2j.Machine$Queue::contains@7 (line 42)
; - com.google.re2j.Inst$Alt2Inst::add@5 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
; implicit exception: dispatches to 0x00007fc83d2213ad
0x00007fc83d21fab2: cmp $0x40,%edx
0x00007fc83d21fab5: jg 0x00007fc83d2204e9 ;*if_icmpgt
; - com.google.re2j.Machine$Queue::contains@3 (line 41)
; - com.google.re2j.Inst$Alt2Inst::add@5 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.30% 0.26% 0x00007fc83d21fabb: mov $0x1,%ebx
0.00% 0x00007fc83d21fac0: mov %edx,%ecx
0.01% 0.00% 0x00007fc83d21fac2: shl %cl,%rbx ;*lshl
; - com.google.re2j.Machine$Queue::contains@12 (line 42)
; - com.google.re2j.Inst$Alt2Inst::add@5 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.50% 0.46% 0x00007fc83d21fac5: mov %r9,%rcx
0.00% 0x00007fc83d21fac8: and %rbx,%rcx
0x00007fc83d21facb: test %rcx,%rcx
0x00007fc83d21face: jne 0x00007fc83d21fe87 ;*ifeq
; - com.google.re2j.Machine$Queue::contains@16 (line 42)
; - com.google.re2j.Inst$Alt2Inst::add@5 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.13% 0.08% 0x00007fc83d21fad4: cmp $0x40,%edx
0x00007fc83d21fad7: jge 0x00007fc83d220565 ;*if_icmpge
; - com.google.re2j.Machine$Queue::add@3 (line 51)
; - com.google.re2j.Inst$Alt2Inst::add@19 (line 178)
; - com.google.re2j.Machine::step@-1 (line 280)
0.16% 0.14% 0x00007fc83d21fadd: mov %r12b,0x18(%r11) ;*putfield empty
; - com.google.re2j.Machine$Queue::add@33 (line 56)
; - com.google.re2j.Inst$Alt2Inst::add@19 (line 178)
; - com.google.re2j.Machine::step@-1 (line 280)
0.01% 0.00% 0x00007fc83d21fae1: mov 0x2c(%r8),%ebp ;*getfield outInst
; - com.google.re2j.Inst$Alt2Inst::add@23 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.00% 0.00% 0x00007fc83d21fae5: or %r9,%rbx ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
; - com.google.re2j.Inst$Alt2Inst::add@19 (line 178)
; - com.google.re2j.Machine::step@-1 (line 280)
0.11% 0.06% 0x00007fc83d21fae8: mov %rbx,0x10(%r11) ;*putfield pcsl
; - com.google.re2j.Machine$Queue::add@15 (line 52)
; - com.google.re2j.Inst$Alt2Inst::add@19 (line 178)
; - com.google.re2j.Machine::step@-1 (line 280)
0.22% 0.13% 0x00007fc83d21faec: mov 0x8(%r12,%rbp,8),%esi ; implicit exception: dispatches to 0x00007fc83d2213c1
0.38% 0.18% 0x00007fc83d21faf1: cmp $0xf8019909,%esi ; {metadata('com/google/re2j/Inst$MatchInst')}
0x00007fc83d21faf7: jne 0x00007fc83d220175
0.33% 0.18% 0x00007fc83d21fafd: lea (%r12,%rbp,8),%r9 ;*invokevirtual add
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.01% 0x00007fc83d21fb01: mov 0x18(%r9),%ecx ;*getfield pc
; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.14% 0.09% 0x00007fc83d21fb05: cmp $0x40,%ecx
0x00007fc83d21fb08: jg 0x00007fc83d2205e1 ;*if_icmpgt
; - com.google.re2j.Machine$Queue::contains@3 (line 41)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.19% 0.22% 0x00007fc83d21fb0e: mov $0x1,%edi
0.05% 0.05% 0x00007fc83d21fb13: shl %cl,%rdi ;*lshl
; - com.google.re2j.Machine$Queue::contains@12 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.49% 0.42% 0x00007fc83d21fb16: mov %rbx,%rdx
0.01% 0.03% 0x00007fc83d21fb19: and %rdi,%rdx ;*land
; - com.google.re2j.Machine$Queue::contains@13 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21fb1c: test %rdx,%rdx
0x00007fc83d21fb1f: jne 0x00007fc83d220017 ;*ifeq
; - com.google.re2j.Machine$Queue::contains@16 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.16% 0.19% 0x00007fc83d21fb25: xor %ebp,%ebp ;*ireturn
; - com.google.re2j.Machine$Queue::contains@24 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.10% 0.07% 0x00007fc83d21fb27: test %rdx,%rdx
0x00007fc83d21fb2a: jne 0x00007fc83d220661 ;*ifeq
; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.22% 0.15% 0x00007fc83d21fb30: cmp $0x40,%ecx
0x00007fc83d21fb33: jge 0x00007fc83d2206e1 ;*if_icmpge
; - com.google.re2j.Machine$Queue::add@3 (line 51)
; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.00% 0x00007fc83d21fb39: or %rdi,%rbx ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.02% 0.01% 0x00007fc83d21fb3c: mov %rbx,0x10(%r11) ;*putfield pcsl
; - com.google.re2j.Machine$Queue::add@15 (line 52)
; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.07% 0.08% 0x00007fc83d21fb40: mov 0x20(%r11),%edi ;*getfield denseThreadsInstructions
; - com.google.re2j.Machine$Queue::addThread@1 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.19% 0.16% 0x00007fc83d21fb44: mov 0xc(%r11),%ecx ;*getfield size
; - com.google.re2j.Machine$Queue::addThread@6 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21fb48: mov %ecx,%edx
0.01% 0.02% 0x00007fc83d21fb4a: inc %edx ;*iadd
; - com.google.re2j.Machine$Queue::addThread@11 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.11% 0.05% 0x00007fc83d21fb4c: mov %edx,0xc(%r11) ;*putfield size
; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.19% 0.13% 0x00007fc83d21fb50: mov 0xc(%r12,%rdi,8),%esi ; implicit exception: dispatches to 0x00007fc83d2213d5
0.01% 0.01% 0x00007fc83d21fb55: cmp %esi,%ecx
0x00007fc83d21fb57: jae 0x00007fc83d2200f5
0.09% 0.06% 0x00007fc83d21fb5d: vmovd %edx,%xmm2
0.08% 0.06% 0x00007fc83d21fb61: mov %ecx,0xc(%rsp)
0.24% 0.10% 0x00007fc83d21fb65: vmovd %edi,%xmm0
0x00007fc83d21fb69: mov %r10d,0xa4(%rsp)
0.03% 0.07% 0x00007fc83d21fb71: mov %r13,0x30(%rsp)
0.06% 0.04% 0x00007fc83d21fb76: mov %eax,0xac(%rsp)
0.18% 0.13% 0x00007fc83d21fb7d: mov %r11,%r13
0x00007fc83d21fb80: mov %r14,0x28(%rsp)
0.02% 0.06% 0x00007fc83d21fb85: mov 0x8(%r12,%rdi,8),%r11d
0.06% 0.07% 0x00007fc83d21fb8a: cmp $0xf8019807,%r11d ; {metadata('com/google/re2j/Inst'[])}
0x00007fc83d21fb91: jne 0x00007fc83d2201f1 ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.18% 0.16% 0x00007fc83d21fb97: mov 0x34(%r8),%r10d ;*getfield inst2
; - com.google.re2j.Inst$Alt2Inst::add@43 (line 181)
; - com.google.re2j.Machine::step@-1 (line 280)
0.00% 0x00007fc83d21fb9b: mov %r10d,%ecx
0.05% 0.07% 0x00007fc83d21fb9e: mov %r9,%r10
0.10% 0.05% 0x00007fc83d21fba1: shr $0x3,%r10 ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.22% 0.18% 0x00007fc83d21fba5: lea (%r12,%rdi,8),%r9 ;*getfield denseThreadsInstructions
; - com.google.re2j.Machine$Queue::addThread@1 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21fba9: mov 0xc(%rsp),%r11d
0.03% 0.03% 0x00007fc83d21fbae: lea 0x10(%r9,%r11,4),%r11
0.09% 0.11% 0x00007fc83d21fbb3: mov %r10d,(%r11)
0.16% 0.16% 0x00007fc83d21fbb6: mov %r11,%r10
0x00007fc83d21fbb9: shr $0x9,%r10
0.07% 0.03% 0x00007fc83d21fbbd: movabs $0x7fc84e197000,%r11
0.07% 0.08% 0x00007fc83d21fbc7: mov %r12b,(%r11,%r10,1) ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Machine::step@-1 (line 280)
0.24% 0.10% 0x00007fc83d21fbcb: mov %ecx,%r10d
0.00% 0x00007fc83d21fbce: mov 0x8(%r12,%r10,8),%r8d ;*invokevirtual add
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Machine::step@-1 (line 280)
; implicit exception: dispatches to 0x00007fc83d2213f1
0.03% 0.03% 0x00007fc83d21fbd3: movslq 0xc(%rsp),%r10
0.08% 0.03% 0x00007fc83d21fbd8: lea (%r9,%r10,4),%rdi ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.21% 0.14% 0x00007fc83d21fbdc: mov %rdi,%rdx
0x00007fc83d21fbdf: add $0x14,%rdx ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Machine::step@-1 (line 280)
0.08% 0.02% 0x00007fc83d21fbe3: mov %ecx,%r10d
0.11% 0.09% 0x00007fc83d21fbe6: lea (%r12,%r10,8),%rax
0.14% 0.19% 0x00007fc83d21fbea: mov 0xc(%rsp),%r10d
0x00007fc83d21fbef: add $0x2,%r10d ;*iadd
; - com.google.re2j.Machine$Queue::addThread@11 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Machine::step@-1 (line 280)
0.08% 0.03% 0x00007fc83d21fbf3: cmp $0xf8019885,%r8d ; {metadata('com/google/re2j/Inst$CaptureInst')}
0x00007fc83d21fbfa: jne 0x00007fc83d21f953 ;*invokevirtual add
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Machine::step@-1 (line 280)
0.06% 0.09% 0x00007fc83d21fc00: mov 0x18(%rax),%r11d ;*getfield pc
; - com.google.re2j.Inst$CaptureInst::add@2 (line 461)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.16% 0.09% 0x00007fc83d21fc04: mov %r11d,%r14d
0x00007fc83d21fc07: cmp $0x40,%r11d
0x00007fc83d21fc0b: jg 0x00007fc83d2209a9 ;*if_icmpgt
; - com.google.re2j.Machine$Queue::contains@3 (line 41)
; - com.google.re2j.Inst$CaptureInst::add@5 (line 461)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.03% 0.03% 0x00007fc83d21fc11: mov $0x1,%r8d
0.05% 0.02% 0x00007fc83d21fc17: mov %r11d,%ecx
0.19% 0.05% 0x00007fc83d21fc1a: shl %cl,%r8 ;*lshl
; - com.google.re2j.Machine$Queue::contains@12 (line 42)
; - com.google.re2j.Inst$CaptureInst::add@5 (line 461)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.14% 0.02% 0x00007fc83d21fc1d: mov %rbx,%r11
0.21% 0.10% 0x00007fc83d21fc20: and %r8,%r11 ;*land
; - com.google.re2j.Machine$Queue::contains@13 (line 42)
; - com.google.re2j.Inst$CaptureInst::add@5 (line 461)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21fc23: test %r11,%r11
0x00007fc83d21fc26: jne 0x00007fc83d220021 ;*ifeq
; - com.google.re2j.Machine$Queue::contains@16 (line 42)
; - com.google.re2j.Inst$CaptureInst::add@5 (line 461)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.03% 0.04% 0x00007fc83d21fc2c: xor %ebp,%ebp ;*ireturn
; - com.google.re2j.Machine$Queue::contains@24 (line 42)
; - com.google.re2j.Inst$CaptureInst::add@5 (line 461)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.07% 0.05% 0x00007fc83d21fc2e: test %r11,%r11
0x00007fc83d21fc31: jne 0x00007fc83d220a29 ;*ifeq
; - com.google.re2j.Inst$CaptureInst::add@8 (line 461)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.17% 0.12% 0x00007fc83d21fc37: mov %ecx,%r11d
0x00007fc83d21fc3a: cmp $0x40,%r11d
0x00007fc83d21fc3e: jge 0x00007fc83d220a79 ;*if_icmpge
; - com.google.re2j.Machine$Queue::add@3 (line 51)
; - com.google.re2j.Inst$CaptureInst::add@19 (line 464)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.03% 0.04% 0x00007fc83d21fc44: or %r8,%rbx ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
; - com.google.re2j.Inst$CaptureInst::add@19 (line 464)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.06% 0.06% 0x00007fc83d21fc47: mov %rbx,0x10(%r13) ;*putfield pcsl
; - com.google.re2j.Machine$Queue::add@15 (line 52)
; - com.google.re2j.Inst$CaptureInst::add@19 (line 464)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.15% 0.07% 0x00007fc83d21fc4b: mov 0x2c(%rax),%ebp ;*getfield outInst
; - com.google.re2j.Inst$CaptureInst::add@82 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.00% 0x00007fc83d21fc4e: mov 0x8(%r12,%rbp,8),%r8d ; implicit exception: dispatches to 0x00007fc83d221405
0.05% 0.02% 0x00007fc83d21fc53: cmp $0xf8019843,%r8d ; {metadata('com/google/re2j/Inst$Alt2Inst')}
0x00007fc83d21fc5a: jne 0x00007fc83d220435
0.05% 0.00% 0x00007fc83d21fc60: lea (%r12,%rbp,8),%rax ;*invokevirtual add
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.19% 0.16% 0x00007fc83d21fc64: mov 0x18(%rax),%r11d ;*getfield pc
; - com.google.re2j.Inst$Alt2Inst::add@2 (line 175)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21fc68: mov %r11d,%ecx
0.05% 0.07% 0x00007fc83d21fc6b: cmp $0x40,%r11d
0x00007fc83d21fc6f: jg 0x00007fc83d220c61 ;*if_icmpgt
; - com.google.re2j.Machine$Queue::contains@3 (line 41)
; - com.google.re2j.Inst$Alt2Inst::add@5 (line 175)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.08% 0.07% 0x00007fc83d21fc75: mov $0x1,%r8d
0.15% 0.19% 0x00007fc83d21fc7b: shl %cl,%r8 ;*lshl
; - com.google.re2j.Machine$Queue::contains@12 (line 42)
; - com.google.re2j.Inst$Alt2Inst::add@5 (line 175)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.13% 0.19% 0x00007fc83d21fc7e: mov %rbx,%r11
0.21% 0.26% 0x00007fc83d21fc81: and %r8,%r11
0x00007fc83d21fc84: test %r11,%r11
0x00007fc83d21fc87: jne 0x00007fc83d220035 ;*ifeq
; - com.google.re2j.Machine$Queue::contains@16 (line 42)
; - com.google.re2j.Inst$Alt2Inst::add@5 (line 175)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.04% 0.04% 0x00007fc83d21fc8d: mov %ecx,%r11d
0.07% 0.09% 0x00007fc83d21fc90: cmp $0x40,%r11d
0x00007fc83d21fc94: jge 0x00007fc83d220ce1 ;*if_icmpge
; - com.google.re2j.Machine$Queue::add@3 (line 51)
; - com.google.re2j.Inst$Alt2Inst::add@19 (line 178)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.17% 0.16% 0x00007fc83d21fc9a: mov 0x2c(%rax),%ebp ;*getfield outInst
; - com.google.re2j.Inst$Alt2Inst::add@23 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.00% 0x00007fc83d21fc9d: or %r8,%rbx ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
; - com.google.re2j.Inst$Alt2Inst::add@19 (line 178)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.03% 0.02% 0x00007fc83d21fca0: mov %rbx,0x10(%r13) ;*putfield pcsl
; - com.google.re2j.Machine$Queue::add@15 (line 52)
; - com.google.re2j.Inst$Alt2Inst::add@19 (line 178)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.09% 0.13% 0x00007fc83d21fca4: mov 0x8(%r12,%rbp,8),%r8d ; implicit exception: dispatches to 0x00007fc83d221419
0.19% 0.29% 0x00007fc83d21fca9: cmp $0xf8019909,%r8d ; {metadata('com/google/re2j/Inst$MatchInst')}
0x00007fc83d21fcb0: jne 0x00007fc83d220481
0x00007fc83d21fcb6: lea (%r12,%rbp,8),%r14 ;*invokevirtual add
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.07% 0.03% 0x00007fc83d21fcba: mov 0x18(%r14),%r11d ;*getfield pc
; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.06% 0.06% 0x00007fc83d21fcbe: vmovd %r11d,%xmm1
0.21% 0.16% 0x00007fc83d21fcc3: cmp $0x40,%r11d
0x00007fc83d21fcc7: jg 0x00007fc83d220d61 ;*if_icmpgt
; - com.google.re2j.Machine$Queue::contains@3 (line 41)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21fccd: mov $0x1,%r8d
0.03% 0.05% 0x00007fc83d21fcd3: mov %r11d,%ecx
0.08% 0.08% 0x00007fc83d21fcd6: shl %cl,%r8 ;*lshl
; - com.google.re2j.Machine$Queue::contains@12 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.23% 0.32% 0x00007fc83d21fcd9: mov %rbx,%r11
0.07% 0.11% 0x00007fc83d21fcdc: and %r8,%r11 ;*land
; - com.google.re2j.Machine$Queue::contains@13 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.20% 0.25% 0x00007fc83d21fcdf: test %r11,%r11
0x00007fc83d21fce2: jne 0x00007fc83d22003d ;*ifeq
; - com.google.re2j.Machine$Queue::contains@16 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.01% 0x00007fc83d21fce8: xor %ebp,%ebp ;*ireturn
; - com.google.re2j.Machine$Queue::contains@24 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.01% 0.02% 0x00007fc83d21fcea: test %r11,%r11
0x00007fc83d21fced: jne 0x00007fc83d220de9 ;*ifeq
; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.06% 0.05% 0x00007fc83d21fcf3: mov %ecx,%r11d
0.14% 0.18% 0x00007fc83d21fcf6: cmp $0x40,%r11d
0x00007fc83d21fcfa: jge 0x00007fc83d220e45 ;*if_icmpge
; - com.google.re2j.Machine$Queue::add@3 (line 51)
; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21fd00: mov %r10d,0xc(%r13) ;*putfield size
; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.07% 0.06% 0x00007fc83d21fd04: or %r8,%rbx ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.06% 0.06% 0x00007fc83d21fd07: mov %rbx,0x10(%r13) ;*putfield pcsl
; - com.google.re2j.Machine$Queue::add@15 (line 52)
; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.17% 0.21% 0x00007fc83d21fd0b: cmp %esi,%r10d
0x00007fc83d21fd0e: jae 0x00007fc83d220339 ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21fd14: mov 0x34(%rax),%r10d ;*getfield inst2
; - com.google.re2j.Inst$Alt2Inst::add@43 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.05% 0.02% 0x00007fc83d21fd18: mov %rdx,%r8
0.08% 0.07% 0x00007fc83d21fd1b: mov %r14,%r11
0.25% 0.18% 0x00007fc83d21fd1e: shr $0x3,%r11
0.00% 0x00007fc83d21fd22: mov %r11d,(%rdx)
0.03% 0.05% 0x00007fc83d21fd25: shr $0x9,%r8
0.06% 0.09% 0x00007fc83d21fd29: movabs $0x7fc84e197000,%r11
0.18% 0.22% 0x00007fc83d21fd33: mov %r12b,(%r11,%r8,1) ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@37 (line 180)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.00% 0.00% 0x00007fc83d21fd37: mov 0x8(%r12,%r10,8),%r11d ; implicit exception: dispatches to 0x00007fc83d22142d
0.05% 0.08% 0x00007fc83d21fd3c: lea (%r12,%r10,8),%r8
0.04% 0.06% 0x00007fc83d21fd40: cmp $0xf8019885,%r11d ; {metadata('com/google/re2j/Inst$CaptureInst')}
0x00007fc83d21fd47: je 0x00007fc83d21fdd7
0.16% 0.23% 0x00007fc83d21fd4d: cmp $0xf8019909,%r11d ; {metadata('com/google/re2j/Inst$MatchInst')}
0x00007fc83d21fd54: jne 0x00007fc83d2208e5 ;*invokevirtual add
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.04% 0.02% 0x00007fc83d21fd5a: mov 0x18(%r8),%ecx ;*getfield pc
; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.03% 0.07% 0x00007fc83d21fd5e: cmp $0x40,%ecx
0x00007fc83d21fd61: jg 0x00007fc83d221199 ;*if_icmpgt
; - com.google.re2j.Machine$Queue::contains@3 (line 41)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.06% 0.15% 0x00007fc83d21fd67: mov $0x1,%r11d
0.18% 0.23% 0x00007fc83d21fd6d: shl %cl,%r11 ;*lshl
; - com.google.re2j.Machine$Queue::contains@12 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.21% 0.17% 0x00007fc83d21fd70: mov %rbx,%r10
0.15% 0.06% 0x00007fc83d21fd73: and %r11,%r10 ;*land
; - com.google.re2j.Machine$Queue::contains@13 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.00% 0.00% 0x00007fc83d21fd76: test %r10,%r10
0x00007fc83d21fd79: jne 0x00007fc83d22005b ;*ifeq
; - com.google.re2j.Machine$Queue::contains@16 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.06% 0.09% 0x00007fc83d21fd7f: mov %ecx,%edx
0.03% 0.08% 0x00007fc83d21fd81: mov %r8,%rcx
0.16% 0.19% 0x00007fc83d21fd84: xor %ebp,%ebp ;*ireturn
; - com.google.re2j.Machine$Queue::contains@24 (line 42)
; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.00% 0.00% 0x00007fc83d21fd86: test %r10,%r10
0x00007fc83d21fd89: jne 0x00007fc83d221211 ;*ifeq
; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.10% 0.14% 0x00007fc83d21fd8f: cmp $0x40,%edx
0x00007fc83d21fd92: jge 0x00007fc83d221285 ;*if_icmpge
; - com.google.re2j.Machine$Queue::add@3 (line 51)
; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.05% 0.11% 0x00007fc83d21fd98: or %r11,%rbx
0.14% 0.23% 0x00007fc83d21fd9b: mov %r13,%r11
0.01% 0x00007fc83d21fd9e: mov %rbx,0x10(%r11) ;*putfield pcsl
; - com.google.re2j.Machine$Queue::add@15 (line 52)
; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.09% 0.14% 0x00007fc83d21fda2: add $0x18,%rdi
0.03% 0.05% 0x00007fc83d21fda6: mov %rcx,%r10
0.16% 0.19% 0x00007fc83d21fda9: shr $0x3,%r10
0.01% 0x00007fc83d21fdad: mov %r10d,(%rdi) ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.09% 0.13% 0x00007fc83d21fdb0: mov %rdi,%r10
0.04% 0.05% 0x00007fc83d21fdb3: mov 0xc(%rsp),%r8d
0.16% 0.15% 0x00007fc83d21fdb8: add $0x3,%r8d
0.00% 0x00007fc83d21fdbc: mov %r8d,0xc(%r11) ;*putfield size
; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.12% 0.09% 0x00007fc83d21fdc0: shr $0x9,%r10
0.06% 0.07% 0x00007fc83d21fdc4: movabs $0x7fc84e197000,%r8
0.17% 0.06% 0x00007fc83d21fdce: mov %r12b,(%r8,%r10,1) ;*aastore
; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
0.01% 0.03% 0x00007fc83d21fdd2: jmpq 0x00007fc83d21fe6e ;*invokevirtual add
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Inst$CaptureInst::add@96 (line 472)
; - com.google.re2j.Inst$Alt2Inst::add@-1 (line 175)
; - com.google.re2j.Machine::step@-1 (line 280)
....................................................................................................
17.38% 14.97% <total for region 3>
....[Hottest Region 4]..............................................................................
C2, level 4, com.google.re2j.Inst$Alt5Inst::add, version 511 (867 bytes)
# parm5: [sp+0x80] = 'com/google/re2j/Machine' (sp of caller)
# parm6: [sp+0x88] = boolean
0x00007fc83d223cc0: mov 0x8(%rsi),%r10d
0x00007fc83d223cc4: shl $0x3,%r10
0x00007fc83d223cc8: cmp %r10,%rax
0x00007fc83d223ccb: jne 0x00007fc83d045e20 ; {runtime_call}
0x00007fc83d223cd1: data16 xchg %ax,%ax
0x00007fc83d223cd4: nopl 0x0(%rax,%rax,1)
0x00007fc83d223cdc: data16 data16 xchg %ax,%ax
[Verified Entry Point]
0.08% 0.03% 0x00007fc83d223ce0: mov %eax,-0x14000(%rsp)
0.28% 0.22% 0x00007fc83d223ce7: push %rbp
0.02% 0x00007fc83d223ce8: sub $0x70,%rsp ;*synchronization entry
; - com.google.re2j.Inst$Alt5Inst::add@-1 (line 260)
0.29% 0.31% 0x00007fc83d223cec: vmovd %r9d,%xmm4
0.01% 0.02% 0x00007fc83d223cf1: vmovq %r8,%xmm3
0.00% 0.00% 0x00007fc83d223cf6: vmovq %rsi,%xmm2
0.04% 0.06% 0x00007fc83d223cfb: mov %ecx,%r13d
0.23% 0.14% 0x00007fc83d223cfe: mov 0x18(%rsi),%ecx ;*getfield pc
; - com.google.re2j.Inst$Alt5Inst::add@2 (line 260)
0.02% 0.03% 0x00007fc83d223d01: mov 0x10(%rdx),%r11 ;*getfield pcsl
; - com.google.re2j.Machine$Queue::contains@7 (line 42)
; - com.google.re2j.Inst$Alt5Inst::add@5 (line 260)
; implicit exception: dispatches to 0x00007fc83d224605
0.01% 0.01% 0x00007fc83d223d05: cmp $0x40,%ecx
0x00007fc83d223d08: jg 0x00007fc83d224215 ;*if_icmpgt
; - com.google.re2j.Machine$Queue::contains@3 (line 41)
; - com.google.re2j.Inst$Alt5Inst::add@5 (line 260)
0.05% 0.07% 0x00007fc83d223d0e: mov $0x1,%esi
0.24% 0.29% 0x00007fc83d223d13: mov $0x1,%r9d
0.00% 0.01% 0x00007fc83d223d19: shl %cl,%r9 ;*lshl
; - com.google.re2j.Machine$Queue::contains@12 (line 42)
; - com.google.re2j.Inst$Alt5Inst::add@5 (line 260)
0.29% 0.33% 0x00007fc83d223d1c: mov %r11,%r10
0.01% 0.01% 0x00007fc83d223d1f: and %r9,%r10 ;*land
; - com.google.re2j.Machine$Queue::contains@13 (line 42)
; - com.google.re2j.Inst$Alt5Inst::add@5 (line 260)
0.01% 0.01% 0x00007fc83d223d22: test %r10,%r10
╭ 0x00007fc83d223d25: jne 0x00007fc83d224044 ;*ifeq
│ ; - com.google.re2j.Machine$Queue::contains@16 (line 42)
│ ; - com.google.re2j.Inst$Alt5Inst::add@5 (line 260)
0.08% 0.04% │ 0x00007fc83d223d2b: xor %ebp,%ebp ;*ireturn
│ ; - com.google.re2j.Machine$Queue::contains@24 (line 42)
│ ; - com.google.re2j.Inst$Alt5Inst::add@5 (line 260)
0.22% 0.28% │ ↗ 0x00007fc83d223d2d: test %r10,%r10
│ │ 0x00007fc83d223d30: jne 0x00007fc83d224249 ;*ifeq
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@8 (line 260)
0.03% 0.00% │ │ 0x00007fc83d223d36: cmp $0x40,%ecx
│ │ 0x00007fc83d223d39: jge 0x00007fc83d224279 ;*if_icmpge
│ │ ; - com.google.re2j.Machine$Queue::add@3 (line 51)
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@19 (line 263)
0.01% │ │ 0x00007fc83d223d3f: mov %r12b,0x18(%rdx) ;*putfield empty
│ │ ; - com.google.re2j.Machine$Queue::add@33 (line 56)
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@19 (line 263)
0.06% 0.07% │ │ 0x00007fc83d223d43: vmovq %xmm2,%r10
0.22% 0.26% │ │ 0x00007fc83d223d48: mov 0x2c(%r10),%ebp ;*getfield outInst
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@23 (line 265)
0.02% 0.01% │ │ 0x00007fc83d223d4c: or %r11,%r9 ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@19 (line 263)
0.01% 0.01% │ │ 0x00007fc83d223d4f: mov %r9,0x10(%rdx) ;*putfield pcsl
│ │ ; - com.google.re2j.Machine$Queue::add@15 (line 52)
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@19 (line 263)
0.06% 0.07% │ │ 0x00007fc83d223d53: mov 0x8(%r12,%rbp,8),%r11d ; implicit exception: dispatches to 0x00007fc83d224619
0.23% 0.26% │ │ 0x00007fc83d223d58: cmp $0xf8019909,%r11d ; {metadata('com/google/re2j/Inst$MatchInst')}
│ │ 0x00007fc83d223d5f: jne 0x00007fc83d2240f9
0.02% 0.01% │ │ 0x00007fc83d223d65: lea (%r12,%rbp,8),%r11 ;*invokevirtual add
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.02% │ │ 0x00007fc83d223d69: mov 0x18(%r11),%ecx ;*getfield pc
│ │ ; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.05% 0.10% │ │ 0x00007fc83d223d6d: cmp $0x40,%ecx
│ │ 0x00007fc83d223d70: jg 0x00007fc83d2242ad ;*if_icmpgt
│ │ ; - com.google.re2j.Machine$Queue::contains@3 (line 41)
│ │ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.33% 0.23% │ │ 0x00007fc83d223d76: mov $0x1,%r10d
0.00% │ │ 0x00007fc83d223d7c: shl %cl,%r10 ;*lshl
│ │ ; - com.google.re2j.Machine$Queue::contains@12 (line 42)
│ │ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.32% 0.48% │ │ 0x00007fc83d223d7f: mov %r9,%r8
0.02% 0.02% │ │ 0x00007fc83d223d82: and %r10,%r8 ;*land
│ │ ; - com.google.re2j.Machine$Queue::contains@13 (line 42)
│ │ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│ │ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.02% │ │ 0x00007fc83d223d85: test %r8,%r8
│╭ │ 0x00007fc83d223d88: jne 0x00007fc83d22404e ;*ifeq
││ │ ; - com.google.re2j.Machine$Queue::contains@16 (line 42)
││ │ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ │ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.08% 0.09% ││ │ 0x00007fc83d223d8e: xor %ebp,%ebp ;*ireturn
││ │ ; - com.google.re2j.Machine$Queue::contains@24 (line 42)
││ │ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ │ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.26% 0.19% ││ │↗ 0x00007fc83d223d90: test %r8,%r8
││ ││ 0x00007fc83d223d93: jne 0x00007fc83d2242e9 ;*ifeq
││ ││ ; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.00% 0.00% ││ ││ 0x00007fc83d223d99: cmp $0x40,%ecx
││ ││ 0x00007fc83d223d9c: jge 0x00007fc83d22431d ;*if_icmpge
││ ││ ; - com.google.re2j.Machine$Queue::add@3 (line 51)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.01% 0.01% ││ ││ 0x00007fc83d223da2: or %r10,%r9 ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.07% 0.07% ││ ││ 0x00007fc83d223da5: mov %r9,0x10(%rdx) ;*putfield pcsl
││ ││ ; - com.google.re2j.Machine$Queue::add@15 (line 52)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.27% 0.37% ││ ││ 0x00007fc83d223da9: mov 0x88(%rsp),%r8d
0.02% 0.01% ││ ││ 0x00007fc83d223db1: test %r8d,%r8d
││ ││ 0x00007fc83d223db4: jne 0x00007fc83d22435d ;*ifeq
││ ││ ; - com.google.re2j.Inst$MatchInst::add@24 (line 149)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.00% 0.03% ││ ││ 0x00007fc83d223dba: mov 0xc(%rdx),%ecx ;*getfield size
││ ││ ; - com.google.re2j.Machine$Queue::addThread@6 (line 66)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.05% 0.09% ││ ││ 0x00007fc83d223dbd: mov 0x20(%rdx),%ebx ;*getfield denseThreadsInstructions
││ ││ ; - com.google.re2j.Machine$Queue::addThread@1 (line 66)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.26% 0.41% ││ ││ 0x00007fc83d223dc0: mov %ecx,%edi
0.03% 0.02% ││ ││ 0x00007fc83d223dc2: inc %edi ;*iadd
││ ││ ; - com.google.re2j.Machine$Queue::addThread@11 (line 66)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.00% 0.00% ││ ││ 0x00007fc83d223dc4: mov %edi,0xc(%rdx) ;*putfield size
││ ││ ; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.05% 0.06% ││ ││ 0x00007fc83d223dc7: mov 0xc(%r12,%rbx,8),%r10d ; implicit exception: dispatches to 0x00007fc83d224641
0.20% 0.24% ││ ││ 0x00007fc83d223dcc: cmp %r10d,%ecx
││ ││ 0x00007fc83d223dcf: jae 0x00007fc83d22407d
0.02% 0.01% ││ ││ 0x00007fc83d223dd5: vmovd %edi,%xmm0
0.01% 0.01% ││ ││ 0x00007fc83d223dd9: mov %ebx,%edi
0.07% 0.07% ││ ││ 0x00007fc83d223ddb: mov %ecx,%eax
0.18% 0.30% ││ ││ 0x00007fc83d223ddd: mov %r11,%rcx
0.01% 0.01% ││ ││ 0x00007fc83d223de0: mov 0x88(%rsp),%r11d
0.01% 0.01% ││ ││ 0x00007fc83d223de8: mov 0x8(%r12,%rbx,8),%r8d
0.06% 0.04% ││ ││ 0x00007fc83d223ded: cmp $0xf8019807,%r8d ; {metadata('com/google/re2j/Inst'[])}
││ ││ 0x00007fc83d223df4: jne 0x00007fc83d224129 ;*aastore
││ ││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.26% 0.27% ││ ││ 0x00007fc83d223dfa: vmovq %xmm2,%r11
0.00% 0.03% ││ ││ 0x00007fc83d223dff: mov 0x34(%r11),%ebp ;*getfield inst2
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@43 (line 266)
0.00% ││ ││ 0x00007fc83d223e03: shr $0x3,%rcx ;*aastore
││ ││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.08% 0.05% ││ ││ 0x00007fc83d223e07: lea (%r12,%rbx,8),%r11 ;*getfield denseThreadsInstructions
││ ││ ; - com.google.re2j.Machine$Queue::addThread@1 (line 66)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.19% 0.23% ││ ││ 0x00007fc83d223e0b: lea 0x10(%r11,%rax,4),%r8
0.01% 0.02% ││ ││ 0x00007fc83d223e10: mov %ecx,(%r8)
0.01% 0.01% ││ ││ 0x00007fc83d223e13: mov %r8,%rcx
0.06% 0.06% ││ ││ 0x00007fc83d223e16: shr $0x9,%rcx
0.25% 0.16% ││ ││ 0x00007fc83d223e1a: movabs $0x7fc84e197000,%r8
0.01% 0.01% ││ ││ 0x00007fc83d223e24: mov %r12b,(%r8,%rcx,1) ;*aastore
││ ││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@37 (line 265)
0.05% 0.03% ││ ││ 0x00007fc83d223e28: mov 0x8(%r12,%rbp,8),%ebx ; implicit exception: dispatches to 0x00007fc83d22465d
0.05% 0.04% ││ ││ 0x00007fc83d223e2d: cmp $0xf8019909,%ebx ; {metadata('com/google/re2j/Inst$MatchInst')}
││ ││ 0x00007fc83d223e33: jne 0x00007fc83d224169
0.21% 0.10% ││ ││ 0x00007fc83d223e39: lea (%r12,%rbp,8),%r14 ;*invokevirtual add
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.00% 0.00% ││ ││ 0x00007fc83d223e3d: mov 0x18(%r14),%ecx ;*getfield pc
││ ││ ; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.19% 0.27% ││ ││ 0x00007fc83d223e41: vmovd %ecx,%xmm1
0.15% 0.10% ││ ││ 0x00007fc83d223e45: cmp $0x40,%ecx
││ ││ 0x00007fc83d223e48: jg 0x00007fc83d224399 ;*if_icmpgt
││ ││ ; - com.google.re2j.Machine$Queue::contains@3 (line 41)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.15% 0.19% ││ ││ 0x00007fc83d223e4e: mov $0x1,%ebx
0.01% ││ ││ 0x00007fc83d223e53: shl %cl,%rbx ;*lshl
││ ││ ; - com.google.re2j.Machine$Queue::contains@12 (line 42)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.40% 0.56% ││ ││ 0x00007fc83d223e56: mov %r9,%rcx
0.01% ││ ││ 0x00007fc83d223e59: and %rbx,%rcx ;*land
││ ││ ; - com.google.re2j.Machine$Queue::contains@13 (line 42)
││ ││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.03% 0.02% ││ ││ 0x00007fc83d223e5c: test %rcx,%rcx
││╭ ││ 0x00007fc83d223e5f: jne 0x00007fc83d224058 ;*ifeq
│││ ││ ; - com.google.re2j.Machine$Queue::contains@16 (line 42)
│││ ││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.16% 0.17% │││ ││ 0x00007fc83d223e65: xor %ebp,%ebp ;*ireturn
│││ ││ ; - com.google.re2j.Machine$Queue::contains@24 (line 42)
│││ ││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│││ ││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.11% 0.07% │││ ││↗ 0x00007fc83d223e67: test %rcx,%rcx
│││ │││ 0x00007fc83d223e6a: jne 0x00007fc83d2243d5 ;*ifeq
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.07% 0.10% │││ │││ 0x00007fc83d223e70: vmovd %xmm1,%ecx
0.03% 0.05% │││ │││ 0x00007fc83d223e74: cmp $0x40,%ecx
│││ │││ 0x00007fc83d223e77: jge 0x00007fc83d224409 ;*if_icmpge
│││ │││ ; - com.google.re2j.Machine$Queue::add@3 (line 51)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.17% 0.18% │││ │││ 0x00007fc83d223e7d: or %rbx,%r9 ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.11% 0.13% │││ │││ 0x00007fc83d223e80: mov %r9,0x10(%rdx) ;*putfield pcsl
│││ │││ ; - com.google.re2j.Machine$Queue::add@15 (line 52)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.03% 0.02% │││ │││ 0x00007fc83d223e84: mov %eax,%ebx
0.01% 0.03% │││ │││ 0x00007fc83d223e86: add $0x2,%ebx
0.17% 0.20% │││ │││ 0x00007fc83d223e89: mov %ebx,0xc(%rdx) ;*putfield size
│││ │││ ; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.14% 0.19% │││ │││ 0x00007fc83d223e8c: mov %eax,%ebx
0.02% 0.03% │││ │││ 0x00007fc83d223e8e: add $0x4,%ebx ;*iadd
│││ │││ ; - com.google.re2j.Machine$Queue::addThread@11 (line 66)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.02% 0.02% │││ │││ 0x00007fc83d223e91: cmp %r10d,%ebx
│││ │││ 0x00007fc83d223e94: jae 0x00007fc83d2240bd ;*aastore
│││ │││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.13% 0.16% │││ │││ 0x00007fc83d223e9a: vmovq %xmm2,%r10
0.10% 0.12% │││ │││ 0x00007fc83d223e9f: mov 0x38(%r10),%ebp ;*getfield inst3
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@63 (line 267)
0.01% 0.01% │││ │││ 0x00007fc83d223ea3: mov %r14,%rcx
0.02% 0.02% │││ │││ 0x00007fc83d223ea6: shr $0x3,%rcx ;*aastore
│││ │││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.16% 0.20% │││ │││ 0x00007fc83d223eaa: movslq %eax,%r10
0.21% 0.15% │││ │││ 0x00007fc83d223ead: lea (%r11,%r10,4),%rdi ;*aastore
│││ │││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.00% 0.03% │││ │││ 0x00007fc83d223eb1: mov %rdi,%r10
0.03% 0.03% │││ │││ 0x00007fc83d223eb4: add $0x14,%r10
0.17% 0.23% │││ │││ 0x00007fc83d223eb8: mov %ecx,(%r10)
0.14% 0.07% │││ │││ 0x00007fc83d223ebb: shr $0x9,%r10
0.02% 0.00% │││ │││ 0x00007fc83d223ebf: mov %r12b,(%r8,%r10,1) ;*aastore
│││ │││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@57 (line 266)
0.02% 0.05% │││ │││ 0x00007fc83d223ec3: mov 0x8(%r12,%rbp,8),%ecx ; implicit exception: dispatches to 0x00007fc83d224685
0.13% 0.17% │││ │││ 0x00007fc83d223ec8: cmp $0xf8019909,%ecx ; {metadata('com/google/re2j/Inst$MatchInst')}
│││ │││ 0x00007fc83d223ece: jne 0x00007fc83d224195
0.11% 0.16% │││ │││ 0x00007fc83d223ed4: lea (%r12,%rbp,8),%r14 ;*invokevirtual add
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.01% 0.02% │││ │││ 0x00007fc83d223ed8: mov 0x18(%r14),%ecx ;*getfield pc
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.02% 0.03% │││ │││ 0x00007fc83d223edc: vmovd %ecx,%xmm1
0.16% 0.21% │││ │││ 0x00007fc83d223ee0: cmp $0x40,%ecx
│││ │││ 0x00007fc83d223ee3: jg 0x00007fc83d224445 ;*if_icmpgt
│││ │││ ; - com.google.re2j.Machine$Queue::contains@3 (line 41)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.13% 0.16% │││ │││ 0x00007fc83d223ee9: mov $0x1,%r10d
0.02% 0.02% │││ │││ 0x00007fc83d223eef: shl %cl,%r10 ;*lshl
│││ │││ ; - com.google.re2j.Machine$Queue::contains@12 (line 42)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.38% 0.38% │││ │││ 0x00007fc83d223ef2: mov %r9,%rcx
0.00% 0.01% │││ │││ 0x00007fc83d223ef5: and %r10,%rcx ;*land
│││ │││ ; - com.google.re2j.Machine$Queue::contains@13 (line 42)
│││ │││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│││ │││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.02% 0.03% │││ │││ 0x00007fc83d223ef8: test %rcx,%rcx
│││╭│││ 0x00007fc83d223efb: jne 0x00007fc83d224062 ;*ifeq
│││││││ ; - com.google.re2j.Machine$Queue::contains@16 (line 42)
│││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.20% 0.17% │││││││ 0x00007fc83d223f01: xor %ebp,%ebp ;*ireturn
│││││││ ; - com.google.re2j.Machine$Queue::contains@24 (line 42)
│││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
│││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.10% 0.13% │││││││↗ 0x00007fc83d223f03: test %rcx,%rcx
││││││││ 0x00007fc83d223f06: jne 0x00007fc83d224481 ;*ifeq
││││││││ ; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.01% 0.03% ││││││││ 0x00007fc83d223f0c: vmovd %xmm1,%ecx
0.03% 0.04% ││││││││ 0x00007fc83d223f10: cmp $0x40,%ecx
││││││││ 0x00007fc83d223f13: jge 0x00007fc83d2244b5 ;*if_icmpge
││││││││ ; - com.google.re2j.Machine$Queue::add@3 (line 51)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.16% 0.10% ││││││││ 0x00007fc83d223f19: or %r10,%r9 ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.10% 0.16% ││││││││ 0x00007fc83d223f1c: mov %r9,0x10(%rdx) ;*putfield pcsl
││││││││ ; - com.google.re2j.Machine$Queue::add@15 (line 52)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.04% 0.02% ││││││││ 0x00007fc83d223f20: vmovq %xmm2,%r10
0.01% 0.02% ││││││││ 0x00007fc83d223f25: mov 0x3c(%r10),%ebp ;*getfield inst4
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@83 (line 268)
0.16% 0.17% ││││││││ 0x00007fc83d223f29: mov %rdi,%r10
0.10% 0.09% ││││││││ 0x00007fc83d223f2c: add $0x18,%r10
0.02% 0.02% ││││││││ 0x00007fc83d223f30: mov %r14,%rcx
0.02% 0.03% ││││││││ 0x00007fc83d223f33: shr $0x3,%rcx
0.18% 0.12% ││││││││ 0x00007fc83d223f37: mov %ecx,(%r10) ;*aastore
││││││││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.11% 0.18% ││││││││ 0x00007fc83d223f3a: mov %eax,%ecx
0.01% 0.01% ││││││││ 0x00007fc83d223f3c: add $0x3,%ecx
0.03% 0.04% ││││││││ 0x00007fc83d223f3f: mov %ecx,0xc(%rdx) ;*putfield size
││││││││ ; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.19% 0.12% ││││││││ 0x00007fc83d223f42: shr $0x9,%r10
0.12% 0.12% ││││││││ 0x00007fc83d223f46: mov %r12b,(%r8,%r10,1) ;*aastore
││││││││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@77 (line 267)
0.02% 0.01% ││││││││ 0x00007fc83d223f4a: mov 0x8(%r12,%rbp,8),%ecx ; implicit exception: dispatches to 0x00007fc83d2246ad
0.03% 0.04% ││││││││ 0x00007fc83d223f4f: cmp $0xf8019909,%ecx ; {metadata('com/google/re2j/Inst$MatchInst')}
││││││││ 0x00007fc83d223f55: jne 0x00007fc83d2241c1
0.16% 0.17% ││││││││ 0x00007fc83d223f5b: lea (%r12,%rbp,8),%r14 ;*invokevirtual add
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.08% 0.14% ││││││││ 0x00007fc83d223f5f: mov 0x18(%r14),%ecx ;*getfield pc
││││││││ ; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.01% 0.02% ││││││││ 0x00007fc83d223f63: vmovd %ecx,%xmm0
0.07% 0.05% ││││││││ 0x00007fc83d223f67: cmp $0x40,%ecx
││││││││ 0x00007fc83d223f6a: jg 0x00007fc83d2244f1 ;*if_icmpgt
││││││││ ; - com.google.re2j.Machine$Queue::contains@3 (line 41)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.14% 0.12% ││││││││ 0x00007fc83d223f70: mov $0x1,%r10d
0.13% 0.15% ││││││││ 0x00007fc83d223f76: shl %cl,%r10 ;*lshl
││││││││ ; - com.google.re2j.Machine$Queue::contains@12 (line 42)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.26% 0.17% ││││││││ 0x00007fc83d223f79: mov %r9,%rcx
0.10% 0.11% ││││││││ 0x00007fc83d223f7c: and %r10,%rcx ;*land
││││││││ ; - com.google.re2j.Machine$Queue::contains@13 (line 42)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.01% 0.02% ││││││││ 0x00007fc83d223f7f: test %rcx,%rcx
││││││││ 0x00007fc83d223f82: jne 0x00007fc83d22406c ;*ifeq
││││││││ ; - com.google.re2j.Machine$Queue::contains@16 (line 42)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.03% 0.05% ││││││││ 0x00007fc83d223f88: xor %ebp,%ebp ;*ireturn
││││││││ ; - com.google.re2j.Machine$Queue::contains@24 (line 42)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.14% 0.11% ││││││││ 0x00007fc83d223f8a: test %rcx,%rcx
││││││││ 0x00007fc83d223f8d: jne 0x00007fc83d22452d ;*ifeq
││││││││ ; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.09% 0.17% ││││││││ 0x00007fc83d223f93: vmovd %xmm0,%ecx
0.02% 0.03% ││││││││ 0x00007fc83d223f97: cmp $0x40,%ecx
││││││││ 0x00007fc83d223f9a: jge 0x00007fc83d224561 ;*if_icmpge
││││││││ ; - com.google.re2j.Machine$Queue::add@3 (line 51)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.05% 0.08% ││││││││ 0x00007fc83d223fa0: mov %ebx,0xc(%rdx) ;*putfield size
││││││││ ; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.13% 0.17% ││││││││ 0x00007fc83d223fa3: vmovq %xmm2,%rcx
0.13% 0.23% ││││││││ 0x00007fc83d223fa8: mov 0x40(%rcx),%ebp ;*getfield inst5
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@103 (line 269)
0.02% 0.03% ││││││││ 0x00007fc83d223fab: mov %rdi,%rcx
0.03% 0.05% ││││││││ 0x00007fc83d223fae: add $0x1c,%rcx ;*aastore
││││││││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.13% 0.22% ││││││││ 0x00007fc83d223fb2: or %r10,%r9 ;*lor ; - com.google.re2j.Machine$Queue::add@14 (line 52)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.10% 0.16% ││││││││ 0x00007fc83d223fb5: mov %r9,0x10(%rdx) ;*putfield pcsl
││││││││ ; - com.google.re2j.Machine$Queue::add@15 (line 52)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.03% 0.03% ││││││││ 0x00007fc83d223fb9: mov %r14,%r10
0.05% 0.05% ││││││││ 0x00007fc83d223fbc: shr $0x3,%r10
0.16% 0.16% ││││││││ 0x00007fc83d223fc0: mov %r10d,(%rcx)
0.13% 0.16% ││││││││ 0x00007fc83d223fc3: mov %rcx,%r10
0.01% 0.04% ││││││││ 0x00007fc83d223fc6: shr $0x9,%r10
0.02% 0.03% ││││││││ 0x00007fc83d223fca: mov %r12b,(%r8,%r10,1) ;*aastore
││││││││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@97 (line 268)
0.18% 0.21% ││││││││ 0x00007fc83d223fce: mov 0x8(%r12,%rbp,8),%r10d ; implicit exception: dispatches to 0x00007fc83d2246d5
0.08% 0.17% ││││││││ 0x00007fc83d223fd3: cmp $0xf8019909,%r10d ; {metadata('com/google/re2j/Inst$MatchInst')}
││││││││ 0x00007fc83d223fda: jne 0x00007fc83d2241ed
0.01% 0.01% ││││││││ 0x00007fc83d223fe0: lea (%r12,%rbp,8),%r10 ;*invokevirtual add
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.02% 0.03% ││││││││ 0x00007fc83d223fe4: mov 0x18(%r10),%ecx ;*getfield pc
││││││││ ; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.15% 0.21% ││││││││ 0x00007fc83d223fe8: cmp $0x40,%ecx
││││││││ 0x00007fc83d223feb: jg 0x00007fc83d22459d ;*if_icmpgt
││││││││ ; - com.google.re2j.Machine$Queue::contains@3 (line 41)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.12% 0.16% ││││││││ 0x00007fc83d223ff1: shl %cl,%rsi ;*lshl
││││││││ ; - com.google.re2j.Machine$Queue::contains@12 (line 42)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.24% 0.29% ││││││││ 0x00007fc83d223ff4: mov %r9,%rbx
0.12% 0.11% ││││││││ 0x00007fc83d223ff7: and %rsi,%rbx ;*land
││││││││ ; - com.google.re2j.Machine$Queue::contains@13 (line 42)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.02% 0.01% ││││││││ 0x00007fc83d223ffa: test %rbx,%rbx
││││││││ 0x00007fc83d223ffd: jne 0x00007fc83d224076 ;*ifeq
││││││││ ; - com.google.re2j.Machine$Queue::contains@16 (line 42)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.06% 0.06% ││││││││ 0x00007fc83d223fff: xor %ebp,%ebp ;*ireturn
││││││││ ; - com.google.re2j.Machine$Queue::contains@24 (line 42)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@5 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.16% 0.18% ││││││││ 0x00007fc83d224001: test %rbx,%rbx
││││││││ 0x00007fc83d224004: jne 0x00007fc83d2245c1 ;*ifeq
││││││││ ; - com.google.re2j.Inst$MatchInst::add@8 (line 144)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.12% 0.19% ││││││││ 0x00007fc83d22400a: cmp $0x40,%ecx
││││││││ 0x00007fc83d22400d: jge 0x00007fc83d2245e1 ;*if_icmpge
││││││││ ; - com.google.re2j.Machine$Queue::add@3 (line 51)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.04% 0.02% ││││││││ 0x00007fc83d224013: or %rsi,%r9
0.04% 0.03% ││││││││ 0x00007fc83d224016: mov %r9,0x10(%rdx) ;*putfield pcsl
││││││││ ; - com.google.re2j.Machine$Queue::add@15 (line 52)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@19 (line 147)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.15% 0.13% ││││││││ 0x00007fc83d22401a: add $0x20,%rdi
0.09% 0.14% ││││││││ 0x00007fc83d22401e: shr $0x3,%r10
0.02% 0.01% ││││││││ 0x00007fc83d224022: mov %r10d,(%rdi) ;*aastore
││││││││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.04% 0.02% ││││││││ 0x00007fc83d224025: mov %rdi,%r10
0.11% 0.14% ││││││││ 0x00007fc83d224028: add $0x5,%eax
0.18% 0.17% ││││││││ 0x00007fc83d22402b: mov %eax,0xc(%rdx) ;*putfield size
││││││││ ; - com.google.re2j.Machine$Queue::addThread@12 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.01% 0.02% ││││││││ 0x00007fc83d22402e: shr $0x9,%r10
0.03% 0.07% ││││││││ 0x00007fc83d224032: mov %r12b,(%r8,%r10,1) ;*aastore
││││││││ ; - com.google.re2j.Machine$Queue::addThread@16 (line 66)
││││││││ ; - com.google.re2j.Inst$MatchInst::add@72 (line 158)
││││││││ ; - com.google.re2j.Inst$Alt5Inst::add@117 (line 269)
0.14% 0.22% ││││││││ 0x00007fc83d224036: xor %eax,%eax
0.12% 0.18% ││││││││ 0x00007fc83d224038: add $0x70,%rsp
0.02% 0.02% ││││││││ 0x00007fc83d22403c: pop %rbp
0.03% 0.05% ││││││││ 0x00007fc83d22403d: test %eax,0x1856afbd(%rip) # 0x00007fc85578f000
││││││││ ; {poll_return}
0.16% 0.14% ││││││││ 0x00007fc83d224043: retq
↘│││││││ 0x00007fc83d224044: mov $0x1,%ebp
│││╰│││ 0x00007fc83d224049: jmpq 0x00007fc83d223d2d
↘││ │││ 0x00007fc83d22404e: mov $0x1,%ebp
││ ╰││ 0x00007fc83d224053: jmpq 0x00007fc83d223d90
↘│ ││ 0x00007fc83d224058: mov $0x1,%ebp
│ ╰│ 0x00007fc83d22405d: jmpq 0x00007fc83d223e67
↘ │ 0x00007fc83d224062: mov $0x1,%ebp
╰ 0x00007fc83d224067: jmpq 0x00007fc83d223f03
0x00007fc83d22406c: mov $0x1,%ebp
....................................................................................................
16.60% 18.57% <total for region 4>
....[Hottest Region 5]..............................................................................
C2, level 4, com.google.re2j.Machine::step, version 494 (174 bytes)
# parm6: [sp+0xa8] = int
# parm7: [sp+0xb0] = boolean
0x00007fc83d21f880: mov 0x8(%rsi),%r10d
0x00007fc83d21f884: shl $0x3,%r10
0x00007fc83d21f888: cmp %r10,%rax
0x00007fc83d21f88b: jne 0x00007fc83d045e20 ; {runtime_call}
0x00007fc83d21f891: data16 xchg %ax,%ax
0x00007fc83d21f894: nopl 0x0(%rax,%rax,1)
0x00007fc83d21f89c: data16 data16 xchg %ax,%ax
[Verified Entry Point]
0.34% 0.29% 0x00007fc83d21f8a0: mov %eax,-0x14000(%rsp)
0.24% 0.28% 0x00007fc83d21f8a7: push %rbp
0.29% 0.21% 0x00007fc83d21f8a8: sub $0x90,%rsp ;*synchronization entry
; - com.google.re2j.Machine::step@-1 (line 280)
0.21% 0.20% 0x00007fc83d21f8af: mov %edi,0x18(%rsp)
0.23% 0.22% 0x00007fc83d21f8b3: mov %r9d,0x14(%rsp)
0.35% 0.20% 0x00007fc83d21f8b8: mov %r8d,0x10(%rsp)
0.22% 0.16% 0x00007fc83d21f8bd: mov %rcx,%r9
0.07% 0.06% 0x00007fc83d21f8c0: mov %rsi,0x20(%rsp)
0.22% 0.17% 0x00007fc83d21f8c5: mov 0x14(%rsi),%r10d ;*getfield re2
; - com.google.re2j.Machine::step@1 (line 280)
0.10% 0.18% 0x00007fc83d21f8c9: movzbl 0x18(%r12,%r10,8),%r10d ;*getfield longest
; - com.google.re2j.Machine::step@4 (line 280)
; implicit exception: dispatches to 0x00007fc83d22138d
1.39% 1.38% 0x00007fc83d21f8cf: mov %r10d,0x1c(%rsp)
0.29% 0.28% 0x00007fc83d21f8d4: mov %rdx,%r14
0.14% 0.12% 0x00007fc83d21f8d7: mov 0xc(%rdx),%eax ;*getfield size
; - com.google.re2j.Machine::step@10 (line 281)
; implicit exception: dispatches to 0x00007fc83d22139d
0.11% 0.09% 0x00007fc83d21f8da: test %eax,%eax
0x00007fc83d21f8dc: jle 0x00007fc83d21ff7d ;*if_icmpge
; - com.google.re2j.Machine::step@40 (line 286)
0.09% 0.10% 0x00007fc83d21f8e2: mov 0x24(%rdx),%r11d ;*getfield denseThreadsCapture
; - com.google.re2j.Machine::step@28 (line 284)
0.79% 0.81% 0x00007fc83d21f8e6: mov %r11d,0x40(%rsp)
0.24% 0.13% 0x00007fc83d21f8eb: movzbl 0x11(%rsi),%r11d ;*getfield captures
; - com.google.re2j.Machine::step@16 (line 282)
0.08% 0.16% 0x00007fc83d21f8f0: mov 0x20(%rdx),%r10d ;*getfield denseThreadsInstructions
; - com.google.re2j.Machine::step@22 (line 283)
0.16% 0.21% 0x00007fc83d21f8f4: mov %r10d,0x3c(%rsp)
0.27% 0.32% 0x00007fc83d21f8f9: test %r11d,%r11d
0x00007fc83d21f8fc: jne 0x00007fc83d22024d ;*iload
; - com.google.re2j.Machine::step@43 (line 289)
0.11% 0.13% 0x00007fc83d21f902: mov 0xc(%r12,%r10,8),%r8d ;*aaload
; - com.google.re2j.Machine::step@99 (line 299)
; implicit exception: dispatches to 0x00007fc83d22024d
0.62% 0.60% 0x00007fc83d21f907: test %r8d,%r8d
0x00007fc83d21f90a: jbe 0x00007fc83d22024d
0.11% 0.07% 0x00007fc83d21f910: mov %eax,%ecx
0.33% 0.30% 0x00007fc83d21f912: dec %ecx
0.08% 0.14% 0x00007fc83d21f914: cmp %r8d,%ecx
0x00007fc83d21f917: jae 0x00007fc83d22024d ;*iload
; - com.google.re2j.Machine::step@43 (line 289)
0.10% 0.13% 0x00007fc83d21f91d: lea (%r12,%r10,8),%r13 ;*getfield denseThreadsInstructions
; - com.google.re2j.Machine::step@22 (line 283)
0.12% 0.11% 0x00007fc83d21f921: xor %r10d,%r10d
0.27% 0.32% 0x00007fc83d21f924: jmpq 0x00007fc83d21feb4
0x00007fc83d21f929: nopl 0x0(%rax)
1.07% 1.05% 0x00007fc83d21f930: xor %r11d,%r11d
0.19% 0.09% 0x00007fc83d21f933: test %r11d,%r11d
0x00007fc83d21f936: jne 0x00007fc83d21f9dd
1.39% 0.91% 0x00007fc83d21f93c: mov 0xa8(%rsp),%r8d
0.08% 0.08% 0x00007fc83d21f944: mov 0xb0(%rsp),%ebx ;*ifnull
; - com.google.re2j.Machine::step@221 (line 320)
1.02% 1.02% 0x00007fc83d21f94b: mov %r9,%r11
0.05% 0.05% 0x00007fc83d21f94e: jmpq 0x00007fc83d21fe96
0x00007fc83d21f953: cmp $0xf8019909,%r8d ; {metadata('com/google/re2j/Inst$MatchInst')}
0x00007fc83d21f95a: jne 0x00007fc83d2203c1 ;*invokevirtual add
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21f960: mov 0x18(%rax),%r11d ;*getfield pc
; - com.google.re2j.Inst$MatchInst::add@2 (line 144)
; - com.google.re2j.Inst$Alt2Inst::add@57 (line 181)
; - com.google.re2j.Machine::step@-1 (line 280)
0x00007fc83d21f964: cmp $0x40,%r11d
0x00007fc83d21f968: jg 0x00007fc83d220af9 ;*if_icmpgt
....................................................................................................
11.37% 10.57% <total for region 5>
....[Hottest Regions]...............................................................................
28.59% 29.86% C2, level 4 com.google.re2j.Machine::match, version 541 (1534 bytes)
17.51% 18.10% C2, level 4 com.google.re2j.Machine::step, version 494 (195 bytes)
17.38% 14.97% C2, level 4 com.google.re2j.Machine::step, version 494 (1013 bytes)
16.60% 18.57% C2, level 4 com.google.re2j.Inst$Alt5Inst::add, version 511 (867 bytes)
11.37% 10.57% C2, level 4 com.google.re2j.Machine::step, version 494 (174 bytes)
2.77% 2.53% C2, level 4 com.google.re2j.Machine::step, version 494 (61 bytes)
1.54% 1.53% [kernel.kallsyms] [unknown] (6 bytes)
1.39% 1.52% C2, level 4 com.google.re2j.Machine::match, version 541 (163 bytes)
0.15% 0.11% C2, level 4 com.google.re2j.Pattern::find, version 546 (12 bytes)
0.13% 0.07% C2, level 4 com.google.re2j.Pattern::find, version 546 (28 bytes)
0.10% 0.04% C2, level 4 com.google.re2j.Pattern::find, version 546 (8 bytes)
0.10% [kernel.kallsyms] [unknown] (45 bytes)
0.10% 0.00% [kernel.kallsyms] [unknown] (18 bytes)
0.09% 0.04% C2, level 4 com.google.re2j.Pattern::find, version 546 (0 bytes)
0.08% 0.01% [kernel.kallsyms] [unknown] (0 bytes)
0.06% 0.09% C2, level 4 com.google.re2j.Machine::match, version 541 (185 bytes)
0.05% 0.04% C2, level 4 com.google.re2j.Machine::match, version 541 (185 bytes)
0.05% 0.01% C2, level 4 com.google.re2j.Machine::match, version 541 (89 bytes)
0.04% C2, level 4 com.google.re2j.Pattern::find, version 546 (36 bytes)
0.03% 0.08% libjvm.so _ZN13RelocIterator10initializeEP7nmethodPhS2_ (102 bytes)
1.85% 1.84% <...other 413 warm regions...>
....................................................................................................
100.00% 100.00% <totals>
....[Hottest Methods (after inlining)]..............................................................
49.06% 46.18% C2, level 4 com.google.re2j.Machine::step, version 494
30.17% 31.54% C2, level 4 com.google.re2j.Machine::match, version 541
16.60% 18.57% C2, level 4 com.google.re2j.Inst$Alt5Inst::add, version 511
2.59% 2.32% [kernel.kallsyms] [unknown]
0.65% 0.32% C2, level 4 com.google.re2j.Pattern::find, version 546
0.06% 0.01% C2, level 4 com.github.arnaudroger.re2j.generated.Re2jFindRegex_testCombine_jmhTest::testCombine_thrpt_jmhStub, version 620
0.06% 0.05% C2, level 4 java.util.Collections::shuffle, version 567
0.06% 0.02% [vdso] [unknown]
0.04% 0.02% hsdis-amd64.so [unknown]
0.03% 0.08% libjvm.so _ZN13RelocIterator10initializeEP7nmethodPhS2_
0.03% 0.09% libjvm.so _ZN10fileStream5writeEPKcm
0.02% 0.01% libjvm.so _ZN12outputStream15update_positionEPKcm
0.02% 0.06% libc-2.26.so vfprintf
0.02% 0.01% libc-2.26.so __strlen_avx2
0.02% 0.03% libpthread-2.26.so __pthread_enable_asynccancel
0.02% 0.01% libjvm.so _ZN19GenericTaskQueueSetI17OverflowTaskQueueI8StarTaskL10MemoryType1ELj131072EELS2_1EE15steal_best_of_2EjPiRS1_
0.02% 0.01% libc-2.26.so __clock_gettime
0.02% 0.02% libjvm.so _ZN13xmlTextStream5writeEPKcm
0.01% 0.03% libc-2.26.so _IO_default_xsputn
0.01% 0.05% libc-2.26.so _IO_fwrite
0.45% 0.23% <...other 75 warm methods...>
....................................................................................................
100.00% 99.69% <totals>
....[Distribution by Source]........................................................................
96.63% 96.67% C2, level 4
2.59% 2.32% [kernel.kallsyms]
0.39% 0.59% libjvm.so
0.18% 0.29% libc-2.26.so
0.06% 0.02% [vdso]
0.05% 0.03% hsdis-amd64.so
0.05% 0.06% libpthread-2.26.so
0.02% 0.01% interpreter
0.01% C1, level 3
0.00% runtime stub
0.00% libzip.so
....................................................................................................
100.00% 100.00% <totals>
# Run complete. Total time: 00:00:45
Benchmark Mode Cnt Score Error Units
Re2jFindRegex.testCombine thrpt 20 9239.172 ± 201.694 ops/s
Re2jFindRegex.testCombine:·asm thrpt NaN ---
| 99.84375 | 155 | 0.381908 |
fc7e92c3471c4d4be34499aa645122eb6ed0a39e | 937 | asm | Assembly | kernel/src/syscall_entry.asm | bordode/radium | cb838205cd6733bf8ee40c9ad4c39d01fa1eb63d | [
"MIT"
] | 10 | 2015-05-14T02:10:54.000Z | 2019-08-24T11:15:22.000Z | kernel/src/syscall_entry.asm | bordode/radium | cb838205cd6733bf8ee40c9ad4c39d01fa1eb63d | [
"MIT"
] | null | null | null | kernel/src/syscall_entry.asm | bordode/radium | cb838205cd6733bf8ee40c9ad4c39d01fa1eb63d | [
"MIT"
] | 5 | 2015-02-02T03:23:14.000Z | 2020-12-21T15:24:42.000Z | use32
extern syscall_dispatch
global syscall_entry
global syscall_init
%define IA32_SYSENTER_CS 0x174
%define IA32_SYSENTER_ESP 0x175
%define IA32_SYSENTER_EIP 0x176
%define KERNEL_CODE 0x08
%define KERNEL_DATA 0x10
syscall_init:
xor edx, edx
mov ecx, IA32_SYSENTER_CS
mov eax, KERNEL_CODE
wrmsr
mov ecx, IA32_SYSENTER_ESP
mov eax, 0x0ffffffc
wrmsr
mov ecx, IA32_SYSENTER_EIP
mov eax, syscall_entry
wrmsr
ret
syscall_entry:
pusha
push dword 0
push dword 0
mov ebp, esp
lea eax, [esp + 8]
push eax
call syscall_dispatch
add esp, 12 ; 4 bytes for the argument we passed to syscall_dispatch, and
; another 8 to compensate for the fake stack frame we pushed.
popa
; STI apparently waits one instruction before enabling interrupts, so
; despite how it appears, this return sequence should be race-free.
sti
sysexit
| 18.372549 | 77 | 0.70651 |
d5a21d12c2b07406ae81f2cdad0f5db2207254ea | 2,962 | asm | Assembly | src/drivers/cpu/common_ia86.asm | pwk4m1/TinyBIOS | f9f0ec8b725717cac1756836cf68267e0ed77114 | [
"BSD-3-Clause"
] | 23 | 2019-09-28T17:33:32.000Z | 2022-03-26T20:30:22.000Z | src/drivers/cpu/common_ia86.asm | pwk4m1/TinyBIOS | f9f0ec8b725717cac1756836cf68267e0ed77114 | [
"BSD-3-Clause"
] | null | null | null | src/drivers/cpu/common_ia86.asm | pwk4m1/TinyBIOS | f9f0ec8b725717cac1756836cf68267e0ed77114 | [
"BSD-3-Clause"
] | 1 | 2022-03-24T13:12:04.000Z | 2022-03-24T13:12:04.000Z | ; BSD 3-Clause License
;
; Copyright (c) 2020, k4m1 <k4m1@protonmail.com>
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are met:
;
; * Redistributions of source code must retain the above copyright notice,
; this list of conditions and the following disclaimer.
;
; * Redistributions in binary form must reproduce the above copyright notice,
; this list of conditions and the following disclaimer in the documentation
; and/or other materials provided with the distribution.
;
; * Neither the name of the copyright holder nor the names of its
; contributors may be used to endorse or promote products derived from
; this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
; PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
; EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;
; ======================================================================== ;
; Helper to get cpuid related stuff
; ======================================================================== ;
; Function to get cpu vendor string, requires:
; di: pointer to memory where to store the string
; Returns:
; nothing
;
cpuid_get_cpu_vendor:
pusha
; eax = 0, cpuid _should_ return cpu vendor string in
; ebx,ecx,edx
xor eax, eax
cpuid
; store right-most byte at time to di
.loop_ebx:
mov al, bl
stosb
shr ebx, 8
test ebx, ebx
jnz .loop_ebx
.loop_edx:
mov al, dl
stosb
shr edx, 8
test edx, edx
jnz .loop_edx
.loop_ecx:
mov al, cl
stosb
shr ecx, 8
test ecx, ecx
jnz .loop_ecx
; EOL + null-terminator
mov al, 0x0D
stosb
mov al, 0x0A
stosb
xor al, al
stosb
popa
ret
; Function to print cpu vendor string, requires no arguments
; and returns nothing.
;
; cpu vendor is printed over serial line
;
cpuid_print_cpu_vendor:
push bp
mov bp, sp
push cx
push di
push si
push ax
mov cx, 16
call malloc
test di, di
jz .end
push di
call cpuid_get_cpu_vendor
mov si, msg_cpuid_vendor
call serial_print
pop si
mov di, si
xor ax, ax
call serial_ram_print
call free
.end:
pop ax
pop si
pop di
pop cx
mov sp, bp
pop bp
ret
msg_cpuid_vendor:
db "CPU VENDOR: ", 0
| 23.887097 | 77 | 0.689737 |
dedcfb68c716c4a63d37a83d83768abb60c3f490 | 752 | asm | Assembly | oeis/141/A141978.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/141/A141978.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/141/A141978.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A141978: Primes congruent to 2 mod 29.
; Submitted by Jamie Morken(s1)
; 2,31,89,263,379,727,1249,1307,1423,1481,1597,2003,2293,2351,2467,2699,3163,3221,3511,3917,4091,4729,4787,4903,5077,5309,5483,5657,6121,6353,6469,6701,6991,7687,7919,8093,8209,8731,8963,9137,9311,9601,9833,9949,10007,10181,10529,10993,11399,11689,11863,12037,12211,12269,12791,12907,13313,13487,14009,14821,14879,15053,15227,15401,15749,15923,16097,16561,16619,17257,17431,17489,17837,18127,18301,19403,19577,19751,19867,20389,20563,21143,21317,21433,21491,21839,22013,22129,22303,22651,22709,23057
lpb $0
sub $0,1
mov $2,$0
mov $0,0
max $2,0
seq $2,108978 ; Numbers k such that 29*k + 31 is prime.
add $3,$2
add $4,$3
add $4,1
lpe
mov $0,$4
mul $0,29
add $0,2
| 41.777778 | 499 | 0.739362 |
30928802b117cebe6d90416a6a08ca545a934f9f | 34,110 | asm | Assembly | 05_arraylistvsarray/Seq2ListAccess1000.asm | arnaudroger/blog_samples | b4c6b5acc5e10f8007595d4b001b9c9face4812c | [
"MIT"
] | null | null | null | 05_arraylistvsarray/Seq2ListAccess1000.asm | arnaudroger/blog_samples | b4c6b5acc5e10f8007595d4b001b9c9face4812c | [
"MIT"
] | null | null | null | 05_arraylistvsarray/Seq2ListAccess1000.asm | arnaudroger/blog_samples | b4c6b5acc5e10f8007595d4b001b9c9face4812c | [
"MIT"
] | 1 | 2018-08-30T22:54:24.000Z | 2018-08-30T22:54:24.000Z | # JMH version: 1.19
# VM version: JDK 1.8.0_131, VM 25.131-b11
# VM invoker: /usr/lib/jvm/java-8-oracle/jre/bin/java
# VM options: <none>
# Warmup: 20 iterations, 1 s each
# Measurement: 20 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: com.github.arnaudroger.Seq2ListAccess.testIndexed
# Parameters: (size = 1000)
# Run progress: 0.00% complete, ETA 00:00:40
# Fork: 1 of 1
# Preparing profilers: LinuxPerfAsmProfiler
# Profilers consume stdout and stderr from target VM, use -v EXTRA to copy to console
# Warmup Iteration 1: 620.200 ns/op
# Warmup Iteration 2: 572.946 ns/op
# Warmup Iteration 3: 591.995 ns/op
# Warmup Iteration 4: 588.487 ns/op
# Warmup Iteration 5: 588.582 ns/op
# Warmup Iteration 6: 597.984 ns/op
# Warmup Iteration 7: 585.770 ns/op
# Warmup Iteration 8: 585.683 ns/op
# Warmup Iteration 9: 587.221 ns/op
# Warmup Iteration 10: 586.070 ns/op
# Warmup Iteration 11: 591.396 ns/op
# Warmup Iteration 12: 588.212 ns/op
# Warmup Iteration 13: 586.689 ns/op
# Warmup Iteration 14: 585.743 ns/op
# Warmup Iteration 15: 585.454 ns/op
# Warmup Iteration 16: 592.898 ns/op
# Warmup Iteration 17: 590.476 ns/op
# Warmup Iteration 18: 590.021 ns/op
# Warmup Iteration 19: 587.877 ns/op
# Warmup Iteration 20: 592.600 ns/op
Iteration 1: 592.030 ns/op
Iteration 2: 590.549 ns/op
Iteration 3: 587.782 ns/op
Iteration 4: 591.367 ns/op
Iteration 5: 589.181 ns/op
Iteration 6: 590.558 ns/op
Iteration 7: 590.167 ns/op
Iteration 8: 592.218 ns/op
Iteration 9: 587.237 ns/op
Iteration 10: 588.109 ns/op
Iteration 11: 591.575 ns/op
Iteration 12: 587.019 ns/op
Iteration 13: 587.964 ns/op
Iteration 14: 588.089 ns/op
Iteration 15: 591.043 ns/op
Iteration 16: 593.752 ns/op
Iteration 17: 589.666 ns/op
Iteration 18: 589.986 ns/op
Iteration 19: 589.216 ns/op
Iteration 20: 588.004 ns/op
# Processing profiler results: LinuxPerfAsmProfiler
Result "com.github.arnaudroger.Seq2ListAccess.testIndexed":
589.776 ±(99.9%) 1.623 ns/op [Average]
(min, avg, max) = (587.019, 589.776, 593.752), stdev = 1.869
CI (99.9%): [588.152, 591.399] (assumes normal distribution)
Secondary result "com.github.arnaudroger.Seq2ListAccess.testIndexed:·asm":
PrintAssembly processed: 176672 total address lines.
Perf output processed (skipped 23.523 seconds):
Column 1: cycles (20338 events)
Column 2: instructions (20332 events)
Hottest code regions (>10.00% "cycles" events):
....[Hottest Region 1]..............................................................................
C2, level 4, com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub, version 534 (415 bytes)
; implicit exception: dispatches to 0x00007fb1f12362e1
0x00007fb1f1235e79: test %r10d,%r10d
0x00007fb1f1235e7c: jne 0x00007fb1f1236079 ;*ifeq
; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@33 (line 234)
0x00007fb1f1235e82: mov $0x1,%ebp
╭ 0x00007fb1f1235e87: jmp 0x00007fb1f1235ec0
│↗ 0x00007fb1f1235e89: xor %edx,%edx ;*if_icmpge
││ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@18 (line 62)
││ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
││ ↗ ↗ 0x00007fb1f1235e8b: mov %rax,0x68(%rsp)
0.03% ││ │ │ 0x00007fb1f1235e90: mov %r14,0x60(%rsp)
││ │ │ 0x00007fb1f1235e95: mov 0x10(%rsp),%rsi
││ │ │ 0x00007fb1f1235e9a: nop
││ │ │ 0x00007fb1f1235e9b: callq 0x00007fb1f1046020 ; OopMap{[96]=Oop [104]=Oop [112]=Oop [16]=Oop off=512}
││ │ │ ;*invokevirtual consume
││ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@20 (line 232)
││ │ │ ; {optimized virtual_call}
0.42% 0.22% ││ │ │ 0x00007fb1f1235ea0: mov 0x68(%rsp),%rax
││ │ │ 0x00007fb1f1235ea5: movzbl 0x94(%rax),%r11d ;*getfield isDone
││ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@30 (line 234)
0.01% 0.00% ││ │ │ 0x00007fb1f1235ead: add $0x1,%rbp ; OopMap{rax=Oop [96]=Oop [112]=Oop [16]=Oop off=529}
││ │ │ ;*ifeq
││ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@33 (line 234)
0.05% 0.00% ││ │ │ 0x00007fb1f1235eb1: test %eax,0x17e13149(%rip) # 0x00007fb209049000
││ │ │ ; {poll}
││ │ │ 0x00007fb1f1235eb7: test %r11d,%r11d
││ │ │ 0x00007fb1f1235eba: jne 0x00007fb1f123607e ;*aload
││ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@13 (line 232)
0.01% ↘│ │ │ 0x00007fb1f1235ec0: mov 0x60(%rsp),%r14
│ │ │ 0x00007fb1f1235ec5: mov 0x10(%r14),%r13d ;*getfield data
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@1 (line 59)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.07% 0.05% │ │ │ 0x00007fb1f1235ec9: mov 0x10(%r12,%r13,8),%r8d ;*getfield size
│ │ │ ; - java.util.ArrayList::size@1 (line 278)
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@6 (line 60)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
│ │ │ ; implicit exception: dispatches to 0x00007fb1f1236289
0.01% 0.04% │ │ │ 0x00007fb1f1235ece: test %r8d,%r8d
╰ │ │ 0x00007fb1f1235ed1: jle 0x00007fb1f1235e89 ;*if_icmpge
│ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@18 (line 62)
│ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.03% 0.02% │ │ 0x00007fb1f1235ed3: mov 0x14(%r12,%r13,8),%r10d ;*getfield elementData
│ │ ; - java.util.ArrayList::elementData@1 (line 418)
│ │ ; - java.util.ArrayList::get@7 (line 431)
│ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
│ │ 0x00007fb1f1235ed8: mov 0xc(%r12,%r10,8),%r9d ;*aaload
│ │ ; - java.util.ArrayList::elementData@5 (line 418)
│ │ ; - java.util.ArrayList::get@7 (line 431)
│ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
│ │ ; implicit exception: dispatches to 0x00007fb1f12360f8
0.16% 0.08% │ │ 0x00007fb1f1235edd: test %r9d,%r9d
│ │ 0x00007fb1f1235ee0: jbe 0x00007fb1f12360f8
0.03% 0.00% │ │ 0x00007fb1f1235ee6: mov %r8d,%r11d
│ │ 0x00007fb1f1235ee9: dec %r11d
│ │ 0x00007fb1f1235eec: cmp %r9d,%r11d
│ │ 0x00007fb1f1235eef: jae 0x00007fb1f12360f8
0.01% 0.02% │ │ 0x00007fb1f1235ef5: mov $0x1,%r11d
│ │ 0x00007fb1f1235efb: cmp %r8d,%r11d
│ │ 0x00007fb1f1235efe: mov $0x1,%esi
│ │ 0x00007fb1f1235f03: cmovg %r8d,%esi
0.04% 0.06% │ │ 0x00007fb1f1235f07: lea (%r12,%r10,8),%r9
0.00% │ │ 0x00007fb1f1235f0b: xor %r11d,%r11d
│ │ 0x00007fb1f1235f0e: xor %edx,%edx ;*lload_3
│ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@21 (line 63)
│ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.06% 0.05% ↗ │ │ 0x00007fb1f1235f10: cmp %r8d,%r11d
│ │ │ 0x00007fb1f1235f13: jge 0x00007fb1f1236131 ;*if_icmplt
│ │ │ ; - java.util.ArrayList::rangeCheck@5 (line 652)
│ │ │ ; - java.util.ArrayList::get@2 (line 429)
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
│ │ │ 0x00007fb1f1235f19: mov 0x10(%r9,%r11,4),%edi
0.00% │ │ │ 0x00007fb1f1235f1e: mov 0x8(%r12,%rdi,8),%r10d ; implicit exception: dispatches to 0x00007fb1f123604b
0.19% 0.02% │ │ │ 0x00007fb1f1235f23: lea (%r12,%rdi,8),%rcx ;*aaload
│ │ │ ; - java.util.ArrayList::elementData@5 (line 418)
│ │ │ ; - java.util.ArrayList::get@7 (line 431)
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
│ │ │ 0x00007fb1f1235f27: cmp $0xf80022ae,%r10d ; {metadata('java/lang/Long')}
│ │ │ 0x00007fb1f1235f2e: jne 0x00007fb1f1236257 ;*checkcast
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.06% 0.01% │ │ │ 0x00007fb1f1235f34: add 0x10(%rcx),%rdx ;*ladd
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@34 (line 63)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.02% 0.00% │ │ │ 0x00007fb1f1235f38: inc %r11d ;*iinc
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@36 (line 62)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
│ │ │ 0x00007fb1f1235f3b: cmp %esi,%r11d
╰ │ │ 0x00007fb1f1235f3e: jl 0x00007fb1f1235f10 ;*if_icmpge
│ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@18 (line 62)
│ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
│ │ 0x00007fb1f1235f40: mov %r8d,%r10d
0.02% │ │ 0x00007fb1f1235f43: add $0xfffffffd,%r10d
0.00% 0.01% │ │ 0x00007fb1f1235f47: cmp %r10d,%r8d
│ │ 0x00007fb1f1235f4a: mov $0x80000000,%esi
│ │ 0x00007fb1f1235f4f: cmovl %esi,%r10d
0.05% 0.00% │ │ 0x00007fb1f1235f53: cmp %r10d,%r11d
╭ │ │ 0x00007fb1f1235f56: jge 0x00007fb1f1235ffc
│ │ │ 0x00007fb1f1235f5c: nopl 0x0(%rax) ;*lload_3
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@21 (line 63)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.62% 0.63% │↗│ │ 0x00007fb1f1235f60: mov 0x10(%r9,%r11,4),%edi
4.09% 3.42% │││ │ 0x00007fb1f1235f65: mov 0x8(%r12,%rdi,8),%esi ; implicit exception: dispatches to 0x00007fb1f123604b
5.80% 6.07% │││ │ 0x00007fb1f1235f6a: lea (%r12,%rdi,8),%rcx ;*aaload
│││ │ ; - java.util.ArrayList::elementData@5 (line 418)
│││ │ ; - java.util.ArrayList::get@7 (line 431)
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
3.10% 2.96% │││ │ 0x00007fb1f1235f6e: cmp $0xf80022ae,%esi ; {metadata('java/lang/Long')}
│││ │ 0x00007fb1f1235f74: jne 0x00007fb1f1236257 ;*checkcast
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
2.84% 3.10% │││ │ 0x00007fb1f1235f7a: add 0x10(%rcx),%rdx ;*ladd
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@34 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
9.16% 8.84% │││ │ 0x00007fb1f1235f7e: movslq %r11d,%rbx
1.18% 1.04% │││ │ 0x00007fb1f1235f81: mov 0x14(%r9,%rbx,4),%edi ;*aaload
│││ │ ; - java.util.ArrayList::elementData@5 (line 418)
│││ │ ; - java.util.ArrayList::get@7 (line 431)
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
2.70% 2.38% │││ │ 0x00007fb1f1235f86: test %edi,%edi
│││ │ 0x00007fb1f1235f88: je 0x00007fb1f123603c ;*checkcast
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.93% 1.02% │││ │ 0x00007fb1f1235f8e: mov 0x8(%r12,%rdi,8),%esi
10.85% 10.69% │││ │ 0x00007fb1f1235f93: lea (%r12,%rdi,8),%rcx ;*aaload
│││ │ ; - java.util.ArrayList::elementData@5 (line 418)
│││ │ ; - java.util.ArrayList::get@7 (line 431)
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.84% 0.62% │││ │ 0x00007fb1f1235f97: cmp $0xf80022ae,%esi ; {metadata('java/lang/Long')}
│││ │ 0x00007fb1f1235f9d: jne 0x00007fb1f1236254 ;*checkcast
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
4.52% 4.76% │││ │ 0x00007fb1f1235fa3: mov 0x18(%r9,%rbx,4),%esi ;*aaload
│││ │ ; - java.util.ArrayList::elementData@5 (line 418)
│││ │ ; - java.util.ArrayList::get@7 (line 431)
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.89% 0.77% │││ │ 0x00007fb1f1235fa8: add 0x10(%rcx),%rdx ;*ladd
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@34 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
9.09% 9.74% │││ │ 0x00007fb1f1235fac: test %esi,%esi
│││ │ 0x00007fb1f1235fae: je 0x00007fb1f1236041 ;*checkcast
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.70% 0.60% │││ │ 0x00007fb1f1235fb4: mov 0x8(%r12,%rsi,8),%edi
3.70% 4.18% │││ │ 0x00007fb1f1235fb9: lea (%r12,%rsi,8),%rcx ;*aaload
│││ │ ; - java.util.ArrayList::elementData@5 (line 418)
│││ │ ; - java.util.ArrayList::get@7 (line 431)
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.86% 0.57% │││ │ 0x00007fb1f1235fbd: cmp $0xf80022ae,%edi ; {metadata('java/lang/Long')}
│││ │ 0x00007fb1f1235fc3: jne 0x00007fb1f123624e ;*checkcast
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
7.20% 7.29% │││ │ 0x00007fb1f1235fc9: mov 0x1c(%r9,%rbx,4),%esi ;*aaload
│││ │ ; - java.util.ArrayList::elementData@5 (line 418)
│││ │ ; - java.util.ArrayList::get@7 (line 431)
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.77% 0.63% │││ │ 0x00007fb1f1235fce: add 0x10(%rcx),%rdx ;*ladd
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@34 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
6.51% 7.35% │││ │ 0x00007fb1f1235fd2: test %esi,%esi
│││ │ 0x00007fb1f1235fd4: je 0x00007fb1f1236047 ;*checkcast
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.81% 0.64% │││ │ 0x00007fb1f1235fd6: mov 0x8(%r12,%rsi,8),%edi
6.08% 6.45% │││ │ 0x00007fb1f1235fdb: lea (%r12,%rsi,8),%rcx ;*aaload
│││ │ ; - java.util.ArrayList::elementData@5 (line 418)
│││ │ ; - java.util.ArrayList::get@7 (line 431)
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.51% 0.65% │││ │ 0x00007fb1f1235fdf: cmp $0xf80022ae,%edi ; {metadata('java/lang/Long')}
│││ │ 0x00007fb1f1235fe5: jne 0x00007fb1f1236248 ;*checkcast
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
4.67% 4.95% │││ │ 0x00007fb1f1235feb: add 0x10(%rcx),%rdx ;*ladd
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@34 (line 63)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
2.49% 3.00% │││ │ 0x00007fb1f1235fef: add $0x4,%r11d ;*iinc
│││ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@36 (line 62)
│││ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
4.45% 4.08% │││ │ 0x00007fb1f1235ff3: cmp %r10d,%r11d
│╰│ │ 0x00007fb1f1235ff6: jl 0x00007fb1f1235f60 ;*if_icmpge
│ │ │ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@18 (line 62)
│ │ │ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.01% 0.00% ↘ │ │ 0x00007fb1f1235ffc: cmp %r8d,%r11d
╰ │ 0x00007fb1f1235fff: jge 0x00007fb1f1235e8b
0.16% 0.11% │ 0x00007fb1f1236005: data16 xchg %ax,%ax ;*lload_3
│ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@21 (line 63)
│ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.00% 0.01% ↗│ 0x00007fb1f1236008: cmp %r8d,%r11d
││ 0x00007fb1f123600b: jge 0x00007fb1f1236138 ;*if_icmplt
││ ; - java.util.ArrayList::rangeCheck@5 (line 652)
││ ; - java.util.ArrayList::get@2 (line 429)
││ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
││ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.03% 0.03% ││ 0x00007fb1f1236011: mov 0x10(%r9,%r11,4),%edi
0.22% 0.14% ││ 0x00007fb1f1236016: mov 0x8(%r12,%rdi,8),%esi ; implicit exception: dispatches to 0x00007fb1f1236299
0.30% 0.35% ││ 0x00007fb1f123601b: lea (%r12,%rdi,8),%rcx ;*aaload
││ ; - java.util.ArrayList::elementData@5 (line 418)
││ ; - java.util.ArrayList::get@7 (line 431)
││ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@25 (line 63)
││ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
││ 0x00007fb1f123601f: cmp $0xf80022ae,%esi ; {metadata('java/lang/Long')}
││ 0x00007fb1f1236025: jne 0x00007fb1f1236241 ;*checkcast
││ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@28 (line 63)
││ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.10% 0.13% ││ 0x00007fb1f123602b: add 0x10(%rcx),%rdx ;*ladd
││ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@34 (line 63)
││ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
0.25% 0.11% ││ 0x00007fb1f123602f: inc %r11d ;*iinc
││ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@36 (line 62)
││ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
││ 0x00007fb1f1236032: cmp %r8d,%r11d
╰│ 0x00007fb1f1236035: jl 0x00007fb1f1236008 ;*if_icmpge
│ ; - com.github.arnaudroger.Seq2ListAccess::testIndexed@18 (line 62)
│ ; - com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub@17 (line 232)
╰ 0x00007fb1f1236037: jmpq 0x00007fb1f1235e8b
0x00007fb1f123603c: inc %r11d
....................................................................................................
97.73% 97.98% <total for region 1>
....[Hottest Regions]...............................................................................
97.73% 97.98% C2, level 4 com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub, version 534 (415 bytes)
0.24% 0.05% C2, level 4 org.openjdk.jmh.infra.Blackhole::consume, version 512 (40 bytes)
0.21% 0.21% [kernel.kallsyms] [unknown] (0 bytes)
0.14% 0.01% [kernel.kallsyms] [unknown] (49 bytes)
0.11% 0.04% [kernel.kallsyms] [unknown] (109 bytes)
0.04% 0.00% [kernel.kallsyms] [unknown] (0 bytes)
0.04% [kernel.kallsyms] [unknown] (28 bytes)
0.03% 0.01% [kernel.kallsyms] [unknown] (11 bytes)
0.03% 0.01% libjvm.so _ZN10fileStream5writeEPKcm (69 bytes)
0.03% 0.03% libjvm.so _ZN13RelocIterator10initializeEP7nmethodPhS2_ (72 bytes)
0.02% 0.01% [kernel.kallsyms] [unknown] (39 bytes)
0.02% 0.02% libc-2.26.so __strchrnul_avx2 (42 bytes)
0.02% 0.00% libpthread-2.26.so __libc_write (16 bytes)
0.02% 0.02% [kernel.kallsyms] [unknown] (0 bytes)
0.02% 0.02% [kernel.kallsyms] [unknown] (9 bytes)
0.02% 0.03% [kernel.kallsyms] [unknown] (26 bytes)
0.02% 0.01% [kernel.kallsyms] [unknown] (7 bytes)
0.02% libjvm.so _ZN10decode_env12handle_eventEPKcPh (19 bytes)
0.02% 0.00% libjvm.so _ZN13xmlTextStream5writeEPKcm (37 bytes)
0.01% 0.03% [kernel.kallsyms] [unknown] (75 bytes)
1.18% 1.48% <...other 320 warm regions...>
....................................................................................................
100.00% 100.00% <totals>
....[Hottest Methods (after inlining)]..............................................................
97.73% 97.98% C2, level 4 com.github.arnaudroger.generated.Seq2ListAccess_testIndexed_jmhTest::testIndexed_avgt_jmhStub, version 534
1.33% 1.20% [kernel.kallsyms] [unknown]
0.24% 0.05% C2, level 4 org.openjdk.jmh.infra.Blackhole::consume, version 512
0.07% 0.06% hsdis-amd64.so decode_instructions
0.04% 0.02% libjvm.so _ZN10fileStream5writeEPKcm
0.03% 0.01% libpthread-2.26.so __libc_write
0.03% 0.05% libc-2.26.so vfprintf
0.03% 0.04% libjvm.so _ZN13RelocIterator10initializeEP7nmethodPhS2_
0.02% 0.00% libjvm.so _ZN10decode_env12handle_eventEPKcPh
0.02% 0.02% libc-2.26.so __strchrnul_avx2
0.02% 0.02% libjvm.so _ZN13xmlTextStream5writeEPKcm
0.02% libjvm.so jio_print
0.02% 0.03% libjvm.so _ZN13defaultStream4holdEl
0.01% 0.02% libc-2.26.so __strlen_avx2
0.01% 0.01% libjvm.so _ZN13defaultStream5writeEPKcm
0.01% 0.07% libc-2.26.so _IO_fwrite
0.01% 0.00% libpthread-2.26.so __pthread_disable_asynccancel
0.01% 0.02% libc-2.26.so _IO_fflush
0.01% libjvm.so _ZNK6Symbol14print_value_onEP12outputStream
0.01% 0.00% libpthread-2.26.so __pthread_enable_asynccancel
0.30% 0.18% <...other 56 warm methods...>
....................................................................................................
100.00% 99.82% <totals>
....[Distribution by Source]........................................................................
97.97% 98.03% C2, level 4
1.33% 1.20% [kernel.kallsyms]
0.37% 0.33% libjvm.so
0.16% 0.31% libc-2.26.so
0.07% 0.07% hsdis-amd64.so
0.07% 0.04% libpthread-2.26.so
0.02% 0.01% interpreter
0.00% Unknown, level 0
0.00% 0.00% C1, level 3
....................................................................................................
100.00% 100.00% <totals>
# Run complete. Total time: 00:00:45
Benchmark (size) Mode Cnt Score Error Units
Seq2ListAccess.testIndexed 1000 avgt 20 589.776 ± 1.623 ns/op
Seq2ListAccess.testIndexed:·asm 1000 avgt NaN ---
Benchmark result is saved to jmh-result2.csv
| 90.477454 | 185 | 0.477514 |
4ba546a7ce15f0ce832191c874f34371b27d12ab | 7,694 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_zr_/i7-8650U_0xd2_notsx.log_309_1247.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_zr_/i7-8650U_0xd2_notsx.log_309_1247.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_zr_/i7-8650U_0xd2_notsx.log_309_1247.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r15
push %r8
push %rax
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0xeac6, %r13
nop
nop
nop
nop
sub %rax, %rax
mov $0x6162636465666768, %rbp
movq %rbp, (%r13)
nop
nop
nop
nop
nop
mfence
lea addresses_normal_ht+0x17ac6, %r15
nop
xor $11912, %rbp
mov $0x6162636465666768, %rcx
movq %rcx, %xmm5
movups %xmm5, (%r15)
inc %rbp
lea addresses_A_ht+0x12daa, %rsi
lea addresses_normal_ht+0x154c6, %rdi
nop
nop
xor $2763, %r13
mov $21, %rcx
rep movsb
dec %r8
lea addresses_D_ht+0x7bbe, %rsi
nop
nop
cmp %rbp, %rbp
mov (%rsi), %rdi
nop
nop
nop
nop
inc %rax
lea addresses_UC_ht+0x76c6, %rsi
lea addresses_UC_ht+0x19fc6, %rdi
nop
nop
cmp $1570, %r8
mov $65, %rcx
rep movsl
nop
nop
nop
xor %r15, %r15
lea addresses_D_ht+0x8ac6, %r15
nop
nop
nop
inc %rsi
vmovups (%r15), %ymm7
vextracti128 $1, %ymm7, %xmm7
vpextrq $0, %xmm7, %rax
nop
nop
xor %rcx, %rcx
lea addresses_D_ht+0xc5e6, %rax
nop
inc %rsi
movl $0x61626364, (%rax)
nop
nop
add $15300, %r13
lea addresses_UC_ht+0x11016, %rsi
nop
nop
nop
nop
nop
add $6393, %rax
movb (%rsi), %r15b
nop
nop
sub $50946, %rcx
lea addresses_UC_ht+0x2aeb, %r8
nop
xor %r13, %r13
movb $0x61, (%r8)
nop
nop
nop
nop
nop
and $38697, %r8
lea addresses_UC_ht+0x1e3fc, %r8
nop
nop
and $15973, %rbp
movb $0x61, (%r8)
nop
nop
sub %rcx, %rcx
lea addresses_UC_ht+0x1cdd6, %rsi
lea addresses_D_ht+0x15446, %rdi
nop
nop
nop
nop
nop
xor $14015, %r13
mov $0, %rcx
rep movsl
nop
nop
xor %rcx, %rcx
lea addresses_D_ht+0x18c6, %rsi
lea addresses_WC_ht+0x4bec, %rdi
nop
nop
cmp %r8, %r8
mov $51, %rcx
rep movsl
nop
nop
nop
nop
sub %rsi, %rsi
lea addresses_normal_ht+0x19068, %rsi
nop
nop
nop
nop
and $5892, %rax
mov $0x6162636465666768, %r13
movq %r13, %xmm6
and $0xffffffffffffffc0, %rsi
vmovaps %ymm6, (%rsi)
sub $40112, %rbp
lea addresses_normal_ht+0x34c6, %rbp
nop
nop
nop
nop
nop
dec %r13
movups (%rbp), %xmm7
vpextrq $1, %xmm7, %r15
nop
cmp $37494, %rbp
lea addresses_D_ht+0xb1c6, %rdi
nop
nop
nop
nop
add %r13, %r13
movw $0x6162, (%rdi)
nop
inc %r13
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r8
pop %r15
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r15
push %r8
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
// Store
lea addresses_D+0x11ac6, %r12
nop
nop
nop
nop
and %rbx, %rbx
mov $0x5152535455565758, %r13
movq %r13, %xmm0
vmovups %ymm0, (%r12)
nop
nop
nop
sub %rbx, %rbx
// Store
lea addresses_A+0x14c6, %rbx
nop
nop
nop
nop
nop
cmp %rdx, %rdx
movb $0x51, (%rbx)
nop
nop
nop
nop
cmp %r15, %r15
// Store
lea addresses_WC+0x70c6, %r8
clflush (%r8)
nop
nop
and $11408, %r15
movl $0x51525354, (%r8)
nop
nop
nop
nop
sub $7322, %rbx
// Store
lea addresses_UC+0x7b46, %rdx
and $56962, %r13
movb $0x51, (%rdx)
nop
nop
nop
nop
sub %rcx, %rcx
// Store
lea addresses_D+0x99ba, %rcx
nop
nop
nop
inc %rdx
mov $0x5152535455565758, %r15
movq %r15, (%rcx)
nop
dec %r8
// REPMOV
lea addresses_D+0x15e6, %rsi
mov $0xb86, %rdi
add $43258, %rbx
mov $68, %rcx
rep movsw
nop
sub $26437, %r15
// Store
mov $0x89e, %rdx
xor $7672, %r12
movb $0x51, (%rdx)
nop
nop
nop
cmp $64236, %r12
// Store
lea addresses_RW+0x190c6, %r12
nop
nop
nop
nop
cmp %r8, %r8
movw $0x5152, (%r12)
nop
nop
nop
cmp %rdi, %rdi
// Faulty Load
mov $0x55157800000002c6, %rbx
nop
nop
nop
nop
add $58811, %r13
mov (%rbx), %rsi
lea oracles, %r12
and $0xff, %rsi
shlq $12, %rsi
mov (%r12,%rsi,1), %rsi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r8
pop %r15
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC', 'size': 1, 'AVXalign': False, 'NT': True, 'congruent': 6, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_P', 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_P', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_RW', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'size': 8, 'AVXalign': True, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 10, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 7, 'same': True}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 9, 'same': True}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 8, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 5, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 4, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 1, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'size': 32, 'AVXalign': True, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'00': 309}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 22.830861 | 926 | 0.646868 |
950cd1b60ca2a67e0d151dc4e597621d99fa3dac | 284 | asm | Assembly | libsrc/_DEVELOPMENT/arch/ts2068/display/c/sccz80/tshc_aaddrpleft.asm | Frodevan/z88dk | f27af9fe840ff995c63c80a73673ba7ee33fffac | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/_DEVELOPMENT/arch/ts2068/display/c/sccz80/tshc_aaddrpleft.asm | Frodevan/z88dk | f27af9fe840ff995c63c80a73673ba7ee33fffac | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/_DEVELOPMENT/arch/ts2068/display/c/sccz80/tshc_aaddrpleft.asm | Frodevan/z88dk | f27af9fe840ff995c63c80a73673ba7ee33fffac | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z | ; void *tshc_aaddrpleft(void *aaddr, uchar bitmask)
SECTION code_clib
SECTION code_arch
PUBLIC tshc_aaddrpleft
EXTERN zx_saddrpleft
defc tshc_aaddrpleft = zx_saddrpleft
; SDCC bridge for Classic
IF __CLASSIC
PUBLIC _tshc_aaddrpleft
defc _tshc_aaddrpleft = tshc_aaddrpleft
ENDIF
| 15.777778 | 51 | 0.834507 |
c94bcda301a4bdc686cb0b6780daf17a59bc9a8b | 83 | asm | Assembly | test/asm/new-pushed-section.asm | michealccc/rgbds | b51e1c7c2c4ce2769f01e016967d0115893a7a88 | [
"MIT"
] | 522 | 2017-02-25T21:10:13.000Z | 2020-09-13T14:26:18.000Z | test/asm/new-pushed-section.asm | michealccc/rgbds | b51e1c7c2c4ce2769f01e016967d0115893a7a88 | [
"MIT"
] | 405 | 2017-02-25T21:32:37.000Z | 2020-09-13T16:43:29.000Z | test/asm/new-pushed-section.asm | michealccc/rgbds | b51e1c7c2c4ce2769f01e016967d0115893a7a88 | [
"MIT"
] | 84 | 2017-02-25T21:10:26.000Z | 2020-09-13T14:28:25.000Z | SECTION FRAGMENT "A", ROM0
db 1
PUSHS
SECTION FRAGMENT "A", ROM0
db 2
POPS
db 3
| 10.375 | 26 | 0.698795 |
b3ed5179e79296ae9b928f99af99b89c91973267 | 587 | asm | Assembly | programs/oeis/326/A326663.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/326/A326663.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/326/A326663.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A326663: Column 3 of the array at A309157; see Comments.
; 5,12,20,26,33,41,47,54,61,68,75,83,89,96,104,110,117,124,131,138,146,152,159,167,173,180,188,194,201,209,215,222,230,236,243,250,257,264,272,278,285,293,299,306,313,320,327,335,341,348,356,362,369,377,383,390,398,404,411,419,425,432,439,446,453,461,467,474,482,488,495,502,509,516,524,530,537,545,551,558,565,572,579,587,593,600,608,614,621,628,635,642,650,656,663,671,677,684,691,698
mov $3,$0
add $0,1
mov $4,1
lpb $0
dif $0,3
mul $4,3
lpe
mov $0,$4
lpb $0
sub $0,8
lpe
trn $0,2
add $0,5
mov $2,$3
mul $2,7
add $0,$2
| 29.35 | 386 | 0.686542 |
accfddc4d2cf999c9032afc1c48bf4438a204392 | 1,973 | asm | Assembly | Delfino/SingleCore/SmartWinch/DCL/source/DCL_PI_CLA.asm | vlad314/FYP_SmartWinch | fca9c23e89d5ea14bfcd18b6565c0a241d7cf3ab | [
"MIT"
] | null | null | null | Delfino/SingleCore/SmartWinch/DCL/source/DCL_PI_CLA.asm | vlad314/FYP_SmartWinch | fca9c23e89d5ea14bfcd18b6565c0a241d7cf3ab | [
"MIT"
] | 5 | 2018-02-15T10:21:58.000Z | 2018-09-21T10:33:36.000Z | Delfino/SingleCore/SmartWinch/DCL/source/DCL_PI_CLA.asm | vlad314/FYP_SmartWinch | fca9c23e89d5ea14bfcd18b6565c0a241d7cf3ab | [
"MIT"
] | 2 | 2018-05-24T16:47:00.000Z | 2019-10-05T15:11:32.000Z | ; DCL_PI_CLA.asm - PI controller
; version 1.0, August 2015
; C prototype:
; float DCL_runPIc(PI *p, float rk, float yk)
; argument 1 = *p : 32-bit PID structure address [MAR0]
; argument 2 = rk : 32-bit floating-point reference [MR0]
; argument 3 = yk : 32-bit floating-point feedback [MR1]
; return = uk : 32-bit floating-point [MR0]
; C type definition:
; typedef volatile struct {
; float Kp; // [0] proportional gain
; float Ki; // [2] integral gain
; float i10; // [4] I storage
; float Umax; // [6] upper saturation limit
; float Umin; // [8] lower saturation limit
; float i6; // [A] saturation storage
; } PI;
.def _DCL_runPIc ; C callable function label
.def __cla_DCL_runPIc_sp
SIZEOF_LFRAME .set 5
LFRAME_MR3 .set 0
.align 2
__cla_DCL_runPIc_sp .usect ".scratchpad:Cla1Prog:_DCL_runPIc", SIZEOF_LFRAME, 0, 1
.asg __cla_DCL_runPIc_sp, LFRAME
.sect "Cla1Prog:_DCL_runPIc"
_DCL_runPIc:
; MDEBUGSTOP
MMOV32 @LFRAME + LFRAME_MR3, MR3 ; save MR3
;*** servo error ***
MSUBF32 MR2, MR0, MR1 ; MR2 = v1
;*** proportional path ***
MMOV32 MR1, *MAR0[2]++ ; MR1 = Kp
MMPYF32 MR2, MR1, MR2 ; MR2 = v2
;*** integral path ***
|| MMOV32 MR1, *MAR0[8]++ ; MR1 = Ki
MMPYF32 MR0, MR2, MR1 ; MR0 = v3
|| MMOV32 MR1, *MAR0[-6]++ ; MR1 = i6
MMPYF32 MR0, MR0, MR1 ; MR0 = v8
|| MMOV32 MR1, *MAR0 ; MR1 = i10
MADDF32 MR0, MR0, MR1 ; MR0 = v4
MMOV32 *MAR0[2]++, MR0 ; save i10
MADDF32 MR0, MR0, MR2 ; MR0 = v5
;*** output saturation ***
MMOVF32 MR2, #0.0f ; MR2 = 0.0f
MMOVF32 MR3, #1.0f ; MR3 = 1.0f
MMOV32 MR1, *MAR0[2]++ ; MR1 = Umax
MMINF32 MR0, MR1 ; MR0 = sat+
MMOV32 MR3, MR2, GT ; MR3 = v6
MMOV32 MR1, *MAR0[2]++ ; MR1 = Umin
MMAXF32 MR0, MR1 ; MR0 = sat-
MRCNDD UNC ; return call
MMOV32 MR3, MR2, LT ; MR3 = v6
MMOV32 *MAR0, MR3 ; save i6
MMOV32 MR3, @LFRAME + LFRAME_MR3 ; restore MR3
.unasg LFRAME
; end of file
| 28.185714 | 82 | 0.613786 |
15f388f312052e4bc856afb64d1ee9b1f8336f8e | 8,681 | asm | Assembly | Z80_ISA_tools/test_dot.asm | ped7g/ZXSpectrumNextMisc | 0148cd8f0529bff4451f089fd7106ea06713e766 | [
"MIT"
] | 15 | 2019-04-06T20:38:41.000Z | 2022-02-27T16:50:31.000Z | Z80_ISA_tools/test_dot.asm | ped7g/ZXSpectrumNextMisc | 0148cd8f0529bff4451f089fd7106ea06713e766 | [
"MIT"
] | 7 | 2020-05-01T08:14:54.000Z | 2022-03-30T19:54:34.000Z | Z80_ISA_tools/test_dot.asm | ped7g/ZXSpectrumNextMisc | 0148cd8f0529bff4451f089fd7106ea06713e766 | [
"MIT"
] | 1 | 2020-08-23T17:36:20.000Z | 2020-08-23T17:36:20.000Z | ;; NextZXOS dot command to test functionality of GetZ80NOpcodeSize
;;
;; © Peter Helcmanovsky 2020, license: https://opensource.org/licenses/MIT
; switch sjasmplus to correct syntax variant
OPT reset --zxnext --syntax=abfw
IFNDEF snafile
; dot command is raw binary targetting $2000
ORG $2000
ELSE
; snapshot file does uset ZX48 snapshot to make testing easier in any emulator
DEVICE ZXSPECTRUM48, $5FFF
ORG $8000
ENDIF
start:
; test regular instructions (no prefix, or prefix + 00)
ld ix,expectedSize_regular
ld hl,machineCode
.testRegularLoop:
call GetZ80NOpcodeSize
cp (ix)
jp nz,wrongValueDetected
ld de,machineCode
sbc hl,de
jp nz,modifiedHlDetected
ex de,hl ; restore HL to machineCode
inc ix ; advance IX (expected value address)
inc (hl)
jr nz,.testRegularLoop
; test ED prefix
ld ix,expectedSize_ED_prefix
ld hl,machineCode
ld (hl),$ED
inc hl
ld (hl),$00
call testOneBytePrefix
; test DD (IX) prefix
ld ix,expectedSize_DD_prefix
ld hl,machineCode
ld (hl),$DD
inc hl
ld (hl),$00
call testOneBytePrefix
; test FD (IY) prefix
ld ix,expectedSize_DD_prefix ; same as FD
ld hl,machineCode
ld (hl),$FD
inc hl
ld (hl),$00
call testOneBytePrefix
; test CB prefix (bit instructions)
ld hl,$02FE
ld (testOneBytePrefix.cp),hl ; modify `cp (ix+0)` to `cp 2 : nop`
ld hl,machineCode
ld (hl),$CB
inc hl
ld (hl),$00
call testOneBytePrefix
; test DDCB prefix (IX bit instructions)
ld hl,machineCode
ld (hl),$DD
inc hl
ld (hl),$CB
inc hl
ld (hl),$00
ld c,4 ; expected length for all of them is 4
call testTwoBytePrefix
; test FDCB prefix (IY bit instructions)
ld hl,machineCode
ld (hl),$FD
inc hl
ld (hl),$CB
inc hl
ld (hl),$00
ld c,4 ; expected length for all of them is 4
call testTwoBytePrefix
; test DD/FD prefix chains
ld hl,chainOfDdPrefix
call testChainedPrefix
ld hl,chainOfDdFdPrefix
call testChainedPrefix
ld hl,chainOfFdPrefix
call testChainedPrefix
; green border to signal everything went OK
ld a,4
out (254),a
ret
modifiedHlDetected:
add hl,de ; restore HL back to the wrong value
; TODO all - currently just continues into wrongValueDetected
wrongValueDetected:
push af
ld a,2
out (254),a
pop af
; TODO all - currently just red border and freeze
jr $
testOneBytePrefix:
; HL = machineCode+1 (after the prefix)
; IX = expected values table
dec hl
call GetZ80NOpcodeSize
.cp: cp (ix)
jr nz,wrongValueDetected
ld de,machineCode
sbc hl,de
jr nz,modifiedHlDetected
ex de,hl ; restore HL to machineCode
inc ix ; advance IX (expected value address)
inc hl ; affect second byte of opcode
inc (hl)
jr nz,testOneBytePrefix
ret
testTwoBytePrefix:
; HL = machineCode+2 (after the prefixes)
; C = expected values table
dec hl
dec hl
call GetZ80NOpcodeSize
cp c
jr nz,wrongValueDetected
ld de,machineCode
sbc hl,de
jr nz,modifiedHlDetected
ex de,hl ; restore HL to machineCode
inc hl
inc hl ; affect third byte of opcode
inc (hl)
jr nz,testTwoBytePrefix
ret
testChainedPrefix:
; HL = chain of prefix bytes (FD or DD) (should be 8 bytes initially)
ld b,3 ; do at least three attempts (incrementing HL)
.testLoop:
call GetZ80NOpcodeSize
cp 1
jr nz,wrongValueDetected
inc hl
djnz .testLoop
ret
__GetZ80NOpcodeSize_INCLUDE_START:
INCLUDE "Z80N_instructions_size.asm"
;GetZ80NOpcodeSize:
;; returns size of opcode in memory in bytes
;; In: HL = address of opcode
;; Out: A = opcode size
;; Modifies: DE
__GetZ80NOpcodeSize_INCLUDE_END:
machineCode:
BLOCK 5, 0
chainOfDdPrefix:
HEX DD DD DD DD DD DD DD DD
chainOfDdFdPrefix:
HEX DD FD DD FD DD FD DD FD
chainOfFdPrefix:
HEX FD FD FD FD FD FD FD FD
expectedSize_regular:
; x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF - regular instructions
DB 1, 3, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1 ; 0x
DB 2, 3, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1 ; 1x
DB 2, 3, 3, 1, 1, 1, 2, 1, 2, 1, 3, 1, 1, 1, 2, 1 ; 2x
DB 2, 3, 3, 1, 1, 1, 2, 1, 2, 1, 3, 1, 1, 1, 2, 1 ; 3x
DB 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ; 4x
DB 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ; 5x
DB 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ; 6x
DB 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ; 7x
DB 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ; 8x
DB 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ; 9x
DB 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ; Ax
DB 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ; Bx
DB 1, 1, 3, 3, 3, 1, 2, 1, 1, 1, 3, 2, 3, 3, 2, 1 ; Cx
DB 1, 1, 3, 2, 3, 1, 2, 1, 1, 1, 3, 2, 3, 2, 2, 1 ; Dx
DB 1, 1, 3, 1, 3, 1, 2, 1, 1, 1, 3, 1, 3, 2, 2, 1 ; Ex
DB 1, 1, 3, 1, 3, 1, 2, 1, 1, 1, 3, 1, 3, 2, 2, 1 ; Fx
expectedSize_ED_prefix:
; x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF - ED prefix - Z80N version
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; 0x
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; 1x
DB 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2 ; 2x
DB 2, 2, 2, 2, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; 3x
DB 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2 ; 4x
DB 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2 ; 5x
DB 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2 ; 6x
DB 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2 ; 7x
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2 ; 8x
DB 2, 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; 9x
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; Ax
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; Bx
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; Cx
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; Dx
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; Ex
DB 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ; Fx
expectedSize_DD_prefix:
; x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF - DD/FD (IX/IY) prefix
DB 2, 4, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 ; 0x
DB 3, 4, 2, 2, 2, 2, 3, 2, 3, 2, 2, 2, 2, 2, 3, 2 ; 1x
DB 3, 4, 4, 2, 2, 2, 3, 2, 3, 2, 4, 2, 2, 2, 3, 2 ; 2x
DB 3, 4, 4, 2, 3, 3, 4, 2, 3, 2, 4, 2, 2, 2, 3, 2 ; 3x
DB 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 ; 4x
DB 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 ; 5x
DB 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 ; 6x
DB 3, 3, 3, 3, 3, 3, 2, 3, 2, 2, 2, 2, 2, 2, 3, 2 ; 7x
DB 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 ; 8x
DB 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 ; 9x
DB 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 ; Ax
DB 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 ; Bx
DB 2, 2, 4, 4, 4, 2, 3, 2, 2, 2, 4, 4, 4, 4, 3, 2 ; Cx
DB 2, 2, 4, 3, 4, 2, 3, 2, 2, 2, 4, 3, 4, 1, 3, 2 ; Dx
DB 2, 2, 4, 2, 4, 2, 3, 2, 2, 2, 4, 2, 4, 1, 3, 2 ; Ex
DB 2, 2, 4, 2, 4, 2, 3, 2, 2, 2, 4, 2, 4, 1, 3, 2 ; Fx
IFDEF snafile
sna_start:
call start
jr $
SAVESNA "test.sna", sna_start
DISPLAY "code size of GetZ80NOpcodeSize include: ", /D, __GetZ80NOpcodeSize_INCLUDE_END-__GetZ80NOpcodeSize_INCLUDE_START
ENDIF
| 36.170833 | 129 | 0.463656 |
28c765b15c818d998eda0d256c8f06d7b48a265d | 3,496 | asm | Assembly | src/shaders/h264/mc/load_Intra_Ref_UV.asm | me176c-dev/android_hardware_intel-vaapi-driver | 0f2dca8d604220405e4678c0b6c4faa578d994ec | [
"MIT"
] | 192 | 2018-01-26T11:51:55.000Z | 2022-03-25T20:04:19.000Z | src/shaders/h264/mc/load_Intra_Ref_UV.asm | me176c-dev/android_hardware_intel-vaapi-driver | 0f2dca8d604220405e4678c0b6c4faa578d994ec | [
"MIT"
] | 256 | 2017-01-23T02:10:27.000Z | 2018-01-23T10:00:05.000Z | src/shaders/h264/mc/load_Intra_Ref_UV.asm | me176c-dev/android_hardware_intel-vaapi-driver | 0f2dca8d604220405e4678c0b6c4faa578d994ec | [
"MIT"
] | 64 | 2018-01-30T19:51:53.000Z | 2021-11-24T01:26:14.000Z | /*
* Load all reference U/V samples from neighboring macroblocks
* Copyright © <2010>, Intel Corporation.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* This file was originally licensed under the following license
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#if !defined(__LOAD_INTRA_REF_UV__) // Make sure this is only included once
#define __LOAD_INTRA_REF_UV__
// Module name: load_Intra_Ref_UV.asm
//
// Load all reference U/V samples from neighboring macroblocks
//
// Note: Since loading of U/V data always follows writing of Y, the message descriptor is manipulated
// to avoid recalculating due to frame/field variztions.
// First load top 20x1 row U/V reference samples
// 4 from macroblock D (actually use 2), 16 from macroblock B
//
shr (1) I_ORIY<1>:w I_ORIY<0;1,0>:w 1:w // Adjust I_ORIY for NV12 format
add (2) MSGSRC.0<1>:d I_ORIX<2;2,1>:w TOP_REF_OFFSET<2;2,1>:b {NoDDClr} // Reference samples positioned at (-4, -1)
mov (1) MSGSRC.2:ud 0x00000013:ud {NoDDChk} // Block width and height (20x1)
// Update message descriptor based on previous Y block write
//
#ifdef DEV_ILK
add (1) MSGDSC MSGDSC RESP_LEN(1)+DWBRMSGDSC_RC+DESTUV-DWBWMSGDSC_WC-0x10000000-DESTY:ud // Set message descriptor
#else
add (1) MSGDSC MSGDSC RESP_LEN(1)+DWBRMSGDSC_RC+DESTUV-DWBWMSGDSC_WC-0x00800000-DESTY:ud // Set message descriptor
#endif // DEV_ILK
send (8) INTRA_REF_TOP_D(0) MSGHDR MSGSRC<8;8,1>:ud DAPREAD MSGDSC
// Then load left 4x8 reference samples (actually use 1x8 column)
//
add (1) MSGSRC.1<1>:d MSGSRC.1<0;1,0>:d 1:w {NoDDClr} // Reference samples positioned next row
mov (1) MSGSRC.2:ud 0x00070003:ud {NoDDChk} // Block width and height (4x8)
send (8) INTRA_REF_LEFT_D(0) MSGHDRUV MSGSRC<8;8,1>:ud DAPREAD MSGDSC
// End of load_Intra_Ref_UV
#endif // !defined(__LOAD_INTRA_REF_UV__)
| 46.613333 | 120 | 0.731693 |
6136234f8f37cc1befa1bc002194e11ca083fa2c | 8,102 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_st_/i7-7700_9_0xca_notsx.log_21829_960.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i7-7700_9_0xca_notsx.log_21829_960.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i7-7700_9_0xca_notsx.log_21829_960.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r13
push %r14
push %r9
push %rax
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x19480, %r9
nop
nop
nop
nop
xor %r14, %r14
and $0xffffffffffffffc0, %r9
vmovntdqa (%r9), %ymm0
vextracti128 $1, %ymm0, %xmm0
vpextrq $0, %xmm0, %rcx
cmp $31237, %r10
lea addresses_D_ht+0xa800, %r9
nop
nop
nop
dec %r14
movl $0x61626364, (%r9)
add %rax, %rax
lea addresses_WC_ht+0x48ac, %rsi
lea addresses_WT_ht+0x0, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
cmp %r13, %r13
mov $99, %rcx
rep movsq
nop
xor $43320, %rax
lea addresses_WC_ht+0x1d800, %r13
nop
nop
nop
nop
and %rdi, %rdi
vmovups (%r13), %ymm0
vextracti128 $1, %ymm0, %xmm0
vpextrq $1, %xmm0, %rcx
nop
nop
nop
nop
cmp $21087, %r13
lea addresses_WT_ht+0x9410, %rsi
lea addresses_D_ht+0x1a80, %rdi
nop
xor $63631, %r13
mov $9, %rcx
rep movsl
nop
nop
nop
nop
nop
add %r9, %r9
lea addresses_normal_ht+0xa520, %rdi
cmp $33765, %r13
mov (%rdi), %r9w
nop
inc %rdi
lea addresses_normal_ht+0x5312, %r10
nop
nop
nop
dec %r9
movb (%r10), %r13b
nop
nop
nop
nop
cmp $26686, %r9
lea addresses_UC_ht+0x5c38, %r10
nop
nop
nop
nop
add %r9, %r9
mov (%r10), %r14d
nop
nop
sub %rax, %rax
lea addresses_A_ht+0x13600, %r10
nop
nop
nop
xor %rsi, %rsi
mov (%r10), %rdi
sub %r9, %r9
lea addresses_UC_ht+0x1ba8, %rax
nop
nop
nop
nop
nop
cmp %rdi, %rdi
mov $0x6162636465666768, %r9
movq %r9, (%rax)
nop
nop
nop
nop
nop
inc %rdi
lea addresses_WT_ht+0x19b00, %r9
clflush (%r9)
nop
nop
nop
inc %rdi
vmovups (%r9), %ymm0
vextracti128 $1, %ymm0, %xmm0
vpextrq $0, %xmm0, %r10
nop
nop
nop
nop
nop
cmp $837, %rsi
lea addresses_D_ht+0x14460, %rdi
nop
nop
nop
dec %rax
mov (%rdi), %esi
nop
nop
nop
and %rsi, %rsi
lea addresses_UC_ht+0x1d940, %rsi
lea addresses_A_ht+0xf854, %rdi
nop
nop
nop
nop
cmp $20945, %r10
mov $44, %rcx
rep movsl
nop
nop
nop
xor %rdi, %rdi
lea addresses_D_ht+0x3030, %rsi
lea addresses_UC_ht+0x1c500, %rdi
clflush (%rsi)
clflush (%rdi)
dec %r10
mov $105, %rcx
rep movsl
nop
add %rdi, %rdi
lea addresses_UC_ht+0x1ceb8, %rsi
lea addresses_D_ht+0x17f9a, %rdi
clflush (%rsi)
nop
nop
nop
dec %r13
mov $37, %rcx
rep movsb
nop
nop
dec %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r14
pop %r13
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r8
push %r9
push %rcx
push %rdi
push %rdx
// Store
lea addresses_UC+0x11100, %rdx
nop
nop
nop
sub $47492, %r8
movw $0x5152, (%rdx)
add $44839, %r12
// Faulty Load
lea addresses_D+0x4000, %rdi
nop
cmp %rcx, %rcx
movntdqa (%rdi), %xmm6
vpextrq $0, %xmm6, %rdx
lea oracles, %r10
and $0xff, %rdx
shlq $12, %rdx
mov (%r10,%rdx,1), %rdx
pop %rdx
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 0, 'same': False, 'type': 'addresses_D'}, 'OP': 'LOAD'}
{'dst': {'NT': True, 'AVXalign': False, 'size': 2, 'congruent': 8, 'same': False, 'type': 'addresses_UC'}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'NT': True, 'AVXalign': False, 'size': 16, 'congruent': 0, 'same': True, 'type': 'addresses_D'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'NT': True, 'AVXalign': False, 'size': 32, 'congruent': 6, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 10, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'STOR'}
{'src': {'congruent': 2, 'same': False, 'type': 'addresses_WC_ht'}, 'dst': {'congruent': 10, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'REPM'}
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 11, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 3, 'same': False, 'type': 'addresses_WT_ht'}, 'dst': {'congruent': 6, 'same': True, 'type': 'addresses_D_ht'}, 'OP': 'REPM'}
{'src': {'NT': True, 'AVXalign': False, 'size': 2, 'congruent': 5, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 3, 'same': True, 'type': 'addresses_UC_ht'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 8, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 2, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'STOR'}
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 7, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'LOAD'}
{'src': {'NT': True, 'AVXalign': False, 'size': 4, 'congruent': 5, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 4, 'same': False, 'type': 'addresses_UC_ht'}, 'dst': {'congruent': 0, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'REPM'}
{'src': {'congruent': 1, 'same': False, 'type': 'addresses_D_ht'}, 'dst': {'congruent': 8, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'REPM'}
{'src': {'congruent': 3, 'same': False, 'type': 'addresses_UC_ht'}, 'dst': {'congruent': 0, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'REPM'}
{'36': 21829}
36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36
*/
| 32.538153 | 2,999 | 0.655517 |
d7d2ea636ec78afb9fa9b931472c367ec168f274 | 316 | asm | Assembly | programs/oeis/270/A270567.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/270/A270567.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/270/A270567.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A270567: Expansion of (1+4*x)/(1-5*x).
; 1,9,45,225,1125,5625,28125,140625,703125,3515625,17578125,87890625,439453125,2197265625,10986328125,54931640625,274658203125,1373291015625,6866455078125,34332275390625,171661376953125,858306884765625,4291534423828125,21457672119140625
mov $1,5
pow $1,$0
mul $1,9
div $1,5
| 39.5 | 236 | 0.806962 |
f2185b31ddb7123b12dc28554c4aca2a85ef7ed2 | 478 | asm | Assembly | oeis/315/A315748.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/315/A315748.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/315/A315748.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A315748: Coordination sequence Gal.5.294.4 where G.u.t.v denotes the coordination sequence for a vertex of type v in tiling number t in the Galebach list of u-uniform tilings.
; Submitted by Jamie Morken(s2)
; 1,6,12,18,23,29,34,40,46,52,58,64,70,75,81,86,92,98,104,110,116,122,127,133,138,144,150,156,162,168,174,179,185,190,196,202,208,214,220,226,231,237,242,248,254,260,266,272,278,283
mul $0,26
mov $2,$0
add $0,3
div $0,9
add $0,1
sub $2,4
div $2,9
add $2,$0
mov $0,$2
| 34.142857 | 181 | 0.711297 |
752114a44842bec010d12e3dad4917f0afca3d02 | 4,695 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1031.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1031.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1031.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r14
push %r9
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0x1a400, %r9
nop
nop
nop
nop
and %rbx, %rbx
vmovups (%r9), %ymm4
vextracti128 $1, %ymm4, %xmm4
vpextrq $0, %xmm4, %rdx
nop
sub %r12, %r12
lea addresses_WT_ht+0x516, %rsi
lea addresses_UC_ht+0x17fa2, %rdi
nop
nop
nop
and $16954, %r14
mov $37, %rcx
rep movsq
nop
nop
nop
nop
nop
inc %r9
lea addresses_WT_ht+0x5ce0, %rbx
nop
nop
nop
nop
cmp $37312, %rdi
mov (%rbx), %r14
cmp %rdi, %rdi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r9
pop %r14
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %rbp
push %rcx
push %rdi
push %rsi
// Faulty Load
lea addresses_RW+0x9f80, %rbp
sub %r12, %r12
vmovups (%rbp), %ymm5
vextracti128 $0, %ymm5, %xmm5
vpextrq $0, %xmm5, %r10
lea oracles, %rdi
and $0xff, %r10
shlq $12, %r10
mov (%rdi,%r10,1), %r10
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_RW', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_RW', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': False, 'congruent': 5, 'NT': False, 'type': 'addresses_WC_ht', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 0, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 0, 'same': False}}
{'src': {'same': True, 'congruent': 5, 'NT': False, 'type': 'addresses_WT_ht', 'size': 8, 'AVXalign': False}, 'OP': 'LOAD'}
{'32': 21829}
32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32
*/
| 49.946809 | 2,999 | 0.661555 |
0c76029a1fc01b21fbc09a225f41fd102d007002 | 458 | nasm | Assembly | Projetos/F-Assembly/src/nasm/abs.nasm | mariaeduardabicalho/Z01 | a08eb895cb064aad16e512d20b09c3f02704f98d | [
"Unlicense"
] | 2 | 2018-03-21T01:20:58.000Z | 2018-04-16T14:35:51.000Z | Projetos/F-Assembly/src/nasm/abs.nasm | mariaeduardabicalho/Z01 | a08eb895cb064aad16e512d20b09c3f02704f98d | [
"Unlicense"
] | 70 | 2018-03-13T12:19:23.000Z | 2018-05-16T20:38:45.000Z | Projetos/F-Assembly/src/nasm/abs.nasm | mariaeduardabicalho/Z01 | a08eb895cb064aad16e512d20b09c3f02704f98d | [
"Unlicense"
] | null | null | null | ; Arquivo: Abs.nasm
; Curso: Elementos de Sistemas
; Criado por: Luciano Soares
; Data: 27/03/2017
; Copia o valor de RAM[1] para RAM[0] deixando o valor sempre positivo.
leaw $1, %A
movw (%A), %S ; salva o que esta na RAM
leaw $MENOR, %A
jl %S ; checa se o número é negativo, se for pula para MENOR
nop
leaw $0, %A
movw %S, (%A) ;salva na ram
leaw $FIM, %A
jmp
nop
MENOR:
negw %S
leaw $0, %A
movw %S, (%A) ; salva na ram
FIM:
nop | 18.32 | 72 | 0.624454 |
a68c80812cdd106477cd081398da5a493502f6c8 | 247 | asm | Assembly | store_sum_and_carry.asm | sekharkaredla/8085 | bca7395498d013c0a337f696aad49ead34f8cbdd | [
"MIT"
] | 1 | 2019-07-31T04:41:42.000Z | 2019-07-31T04:41:42.000Z | store_sum_and_carry.asm | sekharkaredla/8085 | bca7395498d013c0a337f696aad49ead34f8cbdd | [
"MIT"
] | null | null | null | store_sum_and_carry.asm | sekharkaredla/8085 | bca7395498d013c0a337f696aad49ead34f8cbdd | [
"MIT"
] | 1 | 2022-01-11T07:50:34.000Z | 2022-01-11T07:50:34.000Z | ;add numbers from 2000 to 2005 and store in 3000,store carry in 3001
STC ;CY=1
CMC ;complement carry flag
MVI C,06H
MVI A,00H
MVI B,00H
LXI H,2000H
zone:
ADD M
JNC next
INR B
next:
INX H
DCR C
JNZ zone
STA 3000H
MOV A,B
STA 3001H
RST 1
| 11.227273 | 68 | 0.708502 |
28b29cbf197cabe015cc7410821f9baf435694fc | 7,115 | asm | Assembly | Lab5/longop.asm | YuriySavchenko/Assembler | d8ab6e8451d97255e639f0039f623ec00d5e9e2b | [
"Apache-2.0"
] | null | null | null | Lab5/longop.asm | YuriySavchenko/Assembler | d8ab6e8451d97255e639f0039f623ec00d5e9e2b | [
"Apache-2.0"
] | null | null | null | Lab5/longop.asm | YuriySavchenko/Assembler | d8ab6e8451d97255e639f0039f623ec00d5e9e2b | [
"Apache-2.0"
] | null | null | null | section .data
; variables which will be using as counters for loops
counter dd 0
length dd 0
Value_Ai dd 0
tmp dd 0
section .code
; procedure for adding number increased bit rate
Add_608_LONGOP:
push ebp ; write EBP to STACK
mov ebp, esp ; write pinter on STACK to register EBP
mov esi, [ebp+16] ; ESI - adress of A
mov ebx, [ebp+12] ; EBX - adress of B
mov edi, [ebp+8] ; EDI - adress of Result
mov ecx, 19 ; count of repeat
mov edx, 0 ; number of 32-bit group
clc ; set null bit CF for register EFLAGS
.cycle:
mov eax, dword [esi+4*edx] ; write A to register EAX
adc eax, dword [ebx+4*edx] ; adding group of 32-bits
mov dword [edi+4*edx], eax ; write result of adding of last 32-bit group to register EAX
inc edx ; set counter for number of 32-bit group more on 1 point
dec ecx ; set counter less on 1 point
jnz .cycle ; while value in ECX not equal 0 we are repeat cycle
pop ebp ; restoration stack
ret 12 ; exit of procedure
; procedure for subtraction numbers increased bit rate
Sub_512_LONGOP:
push ebp ; write EBP to STACK
mov ebp, esp ; write pinter on STACK to register EBP
mov esi, [ebp+16] ; ESI - adress of A
mov ebx, [ebp+12] ; EBX - adress of B
mov edi, [ebp+8] ; EDI - adress of Result
mov ecx, 16 ; count of repeat
mov edx, 0 ; number of 32-bit group
clc ; set null bit CF for register EFLAGS
.cycle:
mov eax, dword [esi+4*edx] ; write A to register EAX
sbb eax, dword [ebx+4*edx] ; subtruction group of 32-bits
mov dword [edi+4*edx], eax ; write result of subtraction of last 32-bit group to register EAX
inc edx ; set counter for number of 32-bit group more on 1 point
dec ecx ; set counter less on 1 point
jnz .cycle ; while value in ECX not equal 0 we are repeat cycle
pop ebp ; restoration stack
ret 12 ; exit of procedure
; procedure for multiplication number on 32-bit number
Mul_Nx32_LONGOP:
push ebp ; write EBP to STACK
mov ebp, esp ; write pinter on STACK to register EBP
mov ecx, [ebp+8] ; setup counter
mov esi, [ebp+16] ; ESI = address A
mov ebp, [ebp+12] ; EBP = address B
xor ebx, ebx ; set null value for EBP
xor edi, edi ; set null value for EDI
.cycle:
mov eax, [ebp] ; EAX = B
mul dword [esi+4*edi] ; multiplication of operands
clc ; set null bit CF for register EFLAGS
adc eax, ebx ; addition of younger and older digits to the result of past multiplication
adc edx, 0 ; addition EDX and null
mov dword [esi+4*edi], eax ; write value from EAX to address [EAX+4*EDI]
mov ebx, edx ; write value from EDX to EBX
inc edi ; increment EDI
dec ecx ; decrement ECX
jnz .cycle ; while value in ECX not equal 0 we are repeat cycle
pop ebp ; restoration stack
ret 12 ; exit of procedure
; procedure for multiplication number on number
Mul_NxN_LONGOP:
push ebp ; write EBP to STACK
mov ebp, esp ; write pointer on STACK to register EBP
mov eax, [ebp+8] ; move value counter to EAX
mov [length], eax ; write value from EAX in variable length
mov esi, [ebp+12] ; ESI = address B
mov edi, [ebp+16] ; EDI = address A
mov ebp, [ebp+20] ; EBP = address RESULT
mov dword [counter], 0 ; setup variable counter as null
@cycle_Mul_NxN_out: ; begin of first loop
mov eax, [counter] ; write value from variable counter to EAX
inc eax ; increment EAX
cmp eax, [length] ; equal EAX and variable length
jg @exit_proc ; exit of program
mov [counter], eax ; write value from EAX to variable counter
mov ecx, [length] ; setup counter for second loop
mov ebx, dword [esi+4*eax-4] ; write to memory Аix32
mov [Value_Ai], ebx ; write value from EBX to variable Value_Ai
xor ebx, ebx ; set null value for EBX
@cycle_Mul_NxN_in: ; begin of second loop
mov eax, [Value_Ai] ; write value from Value_Ai to EAX
mul dword [edi+4*ebx] ; multiplication of operands
clc ; set null bit CF for register EFLAGS
add dword [ebp+4*ebx], eax ; addition without transfer
adc dword [ebp+4*ebx+4], edx ; addition with transfer
jnc @not_res_cor ; repeat loop
mov eax, 1 ; write digit 1 in EAX
add eax, ebx ; addition EAX and EBX without transfer
stc ; setup transfer as digit 1
res_cor2: ; begin of res_cor2
inc eax ; increment EAX
adc dword [ebp+4*eax], 0 ; add value from address and transfer
jb res_cor2 ; go to begin res_cor2
@not_res_cor: ; begin of loop not_res_cor
inc ebx ; increment EBX
dec ecx ; decrement ECX
jnz @cycle_Mul_NxN_in ; if counter not equal 1 then go to cycle_Mul_NxN
add ebp, 4 ; add digit 4 to register EBP
jmp @cycle_Mul_NxN_out ; repeat cycle_Mul_NxN_out
; procedure for exit of program
@exit_proc:
pop ebp ; delete pointer on STACK
ret 16 ; stop procedure
| 43.121212 | 117 | 0.463809 |
659b627d1300fd4bf9bc2b70eda31743c2967ff7 | 1,029 | asm | Assembly | programs/oeis/339/A339358.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/339/A339358.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/339/A339358.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A339358: Maximum number of copies of a 1234567 permutation pattern in an alternating (or zig-zag) permutation of length n + 11.
; 32,64,320,576,1696,2816,6400,9984,19392,28800,50304,71808,116160,160512,244992,329472,480480,631488,887744,1144000,1560416,1976832,2629120,3281408,4271488,5261568,6723840,8186112,10294656,12403200,15379968,18356736,22480800,26604864
mov $14,$0
mov $16,$0
add $16,1
lpb $16
clr $0,14
mov $0,$14
sub $16,1
sub $0,$16
mov $11,$0
mov $13,$0
add $13,1
lpb $13
mov $0,$11
sub $13,1
sub $0,$13
mov $7,$0
mov $9,2
lpb $9
mov $0,$7
sub $9,1
add $0,$9
sub $0,1
div $0,2
mov $3,5
add $3,$0
mov $0,$3
sub $0,2
mov $2,$0
bin $3,5
mul $2,$3
mul $2,2
mov $1,$2
mov $10,$9
lpb $10
mov $8,$1
sub $10,1
lpe
lpe
lpb $7
mov $7,0
sub $8,$1
lpe
mov $1,$8
div $1,6
mul $1,32
add $12,$1
lpe
add $15,$12
lpe
mov $1,$15
| 19.055556 | 234 | 0.542274 |
793d8e88fc2c00cc46b56fe772ef3c92a6db88f3 | 7,493 | asm | Assembly | Transynther/x86/_processed/NONE/_st_/i7-7700_9_0xca_notsx.log_21829_1781.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_st_/i7-7700_9_0xca_notsx.log_21829_1781.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_st_/i7-7700_9_0xca_notsx.log_21829_1781.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r15
push %r9
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0xbe59, %rsi
lea addresses_WT_ht+0x19059, %rdi
nop
nop
cmp $43521, %r15
mov $22, %rcx
rep movsw
nop
nop
nop
nop
add $58663, %r15
lea addresses_UC_ht+0x19ddd, %rdi
add $23794, %rsi
movups (%rdi), %xmm2
vpextrq $1, %xmm2, %r12
cmp %r15, %r15
lea addresses_WC_ht+0x4f48, %rbx
nop
xor %r9, %r9
mov $0x6162636465666768, %rdi
movq %rdi, %xmm5
and $0xffffffffffffffc0, %rbx
movntdq %xmm5, (%rbx)
nop
nop
sub $61796, %rdi
lea addresses_WT_ht+0x7a61, %rsi
lea addresses_D_ht+0x11e59, %rdi
nop
nop
nop
nop
nop
xor $15978, %r12
mov $60, %rcx
rep movsq
nop
nop
nop
nop
xor %rcx, %rcx
lea addresses_A_ht+0x1ce59, %rsi
lea addresses_D_ht+0x1bd37, %rdi
nop
nop
nop
xor %r12, %r12
mov $61, %rcx
rep movsb
nop
xor %rdi, %rdi
lea addresses_D_ht+0x10659, %rdi
nop
add %rsi, %rsi
movups (%rdi), %xmm6
vpextrq $1, %xmm6, %rbx
nop
nop
dec %r12
lea addresses_normal_ht+0x1dc59, %rsi
lea addresses_UC_ht+0x14b9, %rdi
nop
nop
nop
nop
sub $30576, %r11
mov $86, %rcx
rep movsb
nop
nop
nop
nop
inc %rdi
lea addresses_D_ht+0x8659, %rsi
lea addresses_WC_ht+0x181e9, %rdi
clflush (%rdi)
nop
nop
nop
and $17063, %rbx
mov $124, %rcx
rep movsb
add $63460, %rcx
lea addresses_D_ht+0x12559, %rbx
nop
nop
and %rdi, %rdi
vmovups (%rbx), %ymm6
vextracti128 $0, %ymm6, %xmm6
vpextrq $1, %xmm6, %rsi
nop
nop
nop
and $20596, %r9
lea addresses_A_ht+0xb950, %r15
nop
nop
nop
sub $36279, %rcx
movups (%r15), %xmm6
vpextrq $0, %xmm6, %r9
nop
sub %r9, %r9
lea addresses_WC_ht+0x1c0c, %rsi
lea addresses_normal_ht+0x15929, %rdi
nop
nop
nop
nop
nop
and %r15, %r15
mov $20, %rcx
rep movsb
nop
nop
nop
nop
and $20272, %r12
lea addresses_UC_ht+0x2c89, %rsi
cmp %rbx, %rbx
movb $0x61, (%rsi)
nop
nop
nop
nop
inc %r15
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r9
pop %r15
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r9
push %rbp
push %rcx
push %rdi
push %rsi
// REPMOV
lea addresses_normal+0x1d0d9, %rsi
lea addresses_PSE+0x10e59, %rdi
nop
nop
nop
nop
nop
and $33015, %r12
mov $76, %rcx
rep movsw
xor %rsi, %rsi
// Faulty Load
lea addresses_PSE+0x10e59, %r9
nop
nop
sub %r13, %r13
movb (%r9), %cl
lea oracles, %rdi
and $0xff, %rcx
shlq $12, %rcx
mov (%rdi,%rcx,1), %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 0, 'same': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'src': {'congruent': 4, 'same': False, 'type': 'addresses_normal'}, 'dst': {'congruent': 0, 'same': True, 'type': 'addresses_PSE'}, 'OP': 'REPM'}
[Faulty Load]
{'src': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0, 'same': True, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'congruent': 10, 'same': False, 'type': 'addresses_D_ht'}, 'dst': {'congruent': 9, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'REPM'}
{'src': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 1, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'LOAD'}
{'dst': {'NT': True, 'AVXalign': False, 'size': 16, 'congruent': 0, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'STOR'}
{'src': {'congruent': 3, 'same': True, 'type': 'addresses_WT_ht'}, 'dst': {'congruent': 11, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'REPM'}
{'src': {'congruent': 11, 'same': False, 'type': 'addresses_A_ht'}, 'dst': {'congruent': 1, 'same': True, 'type': 'addresses_D_ht'}, 'OP': 'REPM'}
{'src': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 11, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 9, 'same': False, 'type': 'addresses_normal_ht'}, 'dst': {'congruent': 5, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'REPM'}
{'src': {'congruent': 9, 'same': False, 'type': 'addresses_D_ht'}, 'dst': {'congruent': 4, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM'}
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 6, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 0, 'same': False, 'type': 'addresses_WC_ht'}, 'dst': {'congruent': 4, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'REPM'}
{'dst': {'NT': True, 'AVXalign': False, 'size': 1, 'congruent': 3, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'STOR'}
{'34': 21829}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
| 35.178404 | 2,999 | 0.659949 |
0eea0382ebfd16b7193cb60e90d31963ff34b2f4 | 2,286 | asm | Assembly | libsrc/target/sms/set_sprite.asm | dikdom/z88dk | 40c55771062b0ea9bb2f0d5b73e2f754fc12b6b0 | [
"ClArtistic"
] | 1 | 2022-03-08T11:55:58.000Z | 2022-03-08T11:55:58.000Z | libsrc/target/sms/set_sprite.asm | dikdom/z88dk | 40c55771062b0ea9bb2f0d5b73e2f754fc12b6b0 | [
"ClArtistic"
] | 2 | 2022-03-20T22:17:35.000Z | 2022-03-24T16:10:00.000Z | libsrc/target/sms/set_sprite.asm | jorgegv/z88dk | 127130cf11f9ff268ba53e308138b12d2b9be90a | [
"ClArtistic"
] | null | null | null | SECTION code_clib
PUBLIC set_sprite
PUBLIC _set_sprite
PUBLIC asm_set_sprite
EXTERN CONSOLE_YOFFSET
EXTERN CONSOLE_XOFFSET
EXTERN l_tms9918_disable_interrupts
EXTERN l_tms9918_enable_interrupts_jp
include "sms.hdr"
;==============================================================
; set_sprite(int sprite, int x, int y, int tile)
;==============================================================
; Set information for the specified sprite
;==============================================================
set_sprite:
_set_sprite:
ld hl, 2
add hl, sp
ld d, (hl) ; tile
inc hl
inc hl
ld a, +(CONSOLE_YOFFSET*8)
add (hl) ; y
ld b, a
inc hl
inc hl
ld a, +(CONSOLE_XOFFSET*8)
add (hl) ; x
ld c, a
inc hl
inc hl
ld e, (hl) ; sprite
;==============================================================
; Set sprite data
;==============================================================
; Parameters:
; d = tile number
; e = Sprite number
; b = Sprite y position
; c = Sprite x position
;==============================================================
asm_set_sprite:
call l_tms9918_disable_interrupts
;vdp set addr (Y table)
ld a, e
out (__IO_VDP_COMMAND), a
ld a, VDP_SET_VRAM|(SpriteTableAddress>>8)
out (__IO_VDP_COMMAND), a
ld a, b
out (__IO_VDP_DATA), a ; Set Y
;vdp set addr (X/Tile table)
ld a, e
add a, a
or $80
out (__IO_VDP_COMMAND), a
ld a, VDP_SET_VRAM|(SpriteTableAddress>>8)
out (__IO_VDP_COMMAND), a
ld a, c
out (__IO_VDP_DATA), a ; Set X
nop ;4
nop
nop
nop
nop
nop
ld a, d ;4
out (__IO_VDP_DATA), a ; Set Tile
; exit through l_tms9918_enable_interrupts_jp
jp l_tms9918_enable_interrupts_jp
| 28.936709 | 63 | 0.394138 |
e5ca5b5ac29cad21cc884456962220243c221788 | 18 | asm | Assembly | yasm-1.3.0/modules/arch/x86/tests/smx.asm | xu5343/ffmpegtoolkit_CentOS7 | 974496c709a1c8c69034e46ae5ce7101cf03716f | [
"Apache-2.0"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | third_party/yasm/source/patched-yasm/modules/arch/x86/tests/smx.asm | cangulcan/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | third_party/yasm/source/patched-yasm/modules/arch/x86/tests/smx.asm | cangulcan/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | [bits 32]
getsec
| 4.5 | 9 | 0.666667 |
f9d71a0fc648f990642c0b4f1fe454b435cdebc5 | 694 | asm | Assembly | oeis/266/A266435.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/266/A266435.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/266/A266435.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A266435: Binary representation of the n-th iteration of the "Rule 23" elementary cellular automaton starting with a single ON (black) cell.
; Submitted by Jamie Morken(s2)
; 1,111,0,1111111,0,11111111111,0,111111111111111,0,1111111111111111111,0,11111111111111111111111,0,111111111111111111111111111,0,1111111111111111111111111111111,0,11111111111111111111111111111111111,0,111111111111111111111111111111111111111,0,1111111111111111111111111111111111111111111,0,11111111111111111111111111111111111111111111111,0,111111111111111111111111111111111111111111111111111,0,1111111111111111111111111111111111111111111111111111111,0
dif $0,-2
mul $0,2
add $0,1
mov $2,10
pow $2,$0
mov $0,$2
div $0,9
| 57.833333 | 451 | 0.854467 |
74cc3029fe80262c9ea99a84b62709eb8822e524 | 2,224 | asm | Assembly | Lista2/Lista2/Parte4/Questao1.asm | GustavoLR548/ACII-GLR | 135690945f5e29938ef640a3d5475f8a12dbd76c | [
"MIT"
] | 1 | 2021-11-03T17:22:02.000Z | 2021-11-03T17:22:02.000Z | Lista2/Lista2/Parte4/Questao1.asm | GustavoLR548/ACII-GLR | 135690945f5e29938ef640a3d5475f8a12dbd76c | [
"MIT"
] | null | null | null | Lista2/Lista2/Parte4/Questao1.asm | GustavoLR548/ACII-GLR | 135690945f5e29938ef640a3d5475f8a12dbd76c | [
"MIT"
] | null | null | null | .data
endereco: .word 0x10010020 #Endereco de memoria
tam: .word 3 #Quantidade de elementos
.text
main:
addi $t0, $zero, 30 #Criando variavel para armazenar o numero limite de elementos
lw $a0, endereco #Carregando da memoria o endereco
lw $a1, tam #Carregando da memoria o tamanho do array
verificar:
bgt $a1, $t0, maiorDoQue30 #Se o tamanho do array for maior do que 30, va para maiorDoQue30
dentro:
add $s0, $zero, $a0 #s0 = Endereco de memoria
add $t0, $zero, $a1 #t0 = quantidade de elementos
sll $t0, $t0, 2 #t0*= 2^2
add $s1, $t0, $s0 #s1 = array[Quantidade-1]
j somar #ir para somar
maiorDoQue30:
add $s0, $zero, $a0 #s0 = Endereco de memoria
addi $t0, $zero, 30 #t0 = 0 + 30
sll $t0, $t0, 2 #t0*= 2^2
add $s1, $t0, $s0 #s1 = array[29]
j somar
somar:
addi $t0, $zero, 0 #resetar t0
parOuImpar:
andi $t1, $t0, 1 #Decidi se t1 for par ou impar
beqz $t1, par #Se t1 for par
j impar #Caso contrario
ret:
addi $t0, $t0, 1 #t0++
sll $t6, $t0, 2 #t6 = t0 * 2^2
add $t6, $s0, $t6 #t6 = s0 + t6
bne $t6, $s1, parOuImpar #Va para parOuImpar, se t6 for diferente de s1
j fim #Ir para fim
impar:
add $t2, $zero, $t0 # t2 = t0
mult $t2, $t2 # t2 * t2 -> vai para LO e HI
mflo $t2 # pegar o conteudo em LO e passar para t2
sll $t5, $t0, 2 # t5 = t0 * 2^2
add $t5, $s0, $t5 # t5 = s0 + t5
sw $t2, ($t5) # Salvar t2 na posicao de memoria de t5
j ret # ir para ret
par:
addi $t2, $zero, 1 # t2 = 1
addi $t3, $zero, 2 # t3 = 2
mult $t3, $t0 # t3 * t0 -> vai para LO e HI
mflo $t3 # armazene o conteudo de LO em t3
mult $t0, $t0 # t0 * t0 -> vai para LO e HI
mflo $t4 # armazene o conteudo de LO em t4
sll $t4, $t4, 1 # t4 *= 2^1
add $t2, $t2, $t3 # t2 += t3
add $t2, $t2, $t4 # t2 += t4
sll $t5, $t0, 2 # t5 = t0 * 2^2
add $t5, $s0, $t5 # t5 += s0
sw $t2, ($t5) # salvar t2 na posicao de memoria em t5
j ret # ir para ret
retornar:
add $t0, $zero, $a0 #t0 = a0
mult $t0, $t0 #t0 * t0 -> vai para LO e HI
mflo $t0, #armazena o conteudo de LO em t0
addu $v0, $zero, $t0 #v0 = t0
jr $ra #retornar
fim:
li $v0, 10
syscall
| 30.465753 | 93 | 0.572842 |
b17f6f2c5c6f9a8d7da20884d400e2b6c353484d | 4,054 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_2659_491.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_2659_491.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_2659_491.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r12
push %rax
push %rbp
push %rcx
lea addresses_D_ht+0xf410, %rax
nop
xor %r12, %r12
vmovups (%rax), %ymm2
vextracti128 $0, %ymm2, %xmm2
vpextrq $0, %xmm2, %rbp
nop
sub $9745, %rcx
pop %rcx
pop %rbp
pop %rax
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r12
push %r9
push %rdx
push %rsi
// Faulty Load
lea addresses_normal+0x15810, %r12
nop
nop
nop
nop
nop
inc %rdx
mov (%r12), %si
lea oracles, %r11
and $0xff, %rsi
shlq $12, %rsi
mov (%r11,%rsi,1), %rsi
pop %rsi
pop %rdx
pop %r9
pop %r12
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'34': 2659}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
| 65.387097 | 2,999 | 0.663296 |
1d7e4f61e20229a6988103a6530e5ae74ff71569 | 10,525 | asm | Assembly | coverage/IN_CTS/0521-COVERAGE-tiny-ptr-vector-h-85/work/variant/1_spirv_asm/shader.frag.asm | asuonpaa/ShaderTests | 6a3672040dcfa0d164d313224446496d1775a15e | [
"Apache-2.0"
] | null | null | null | coverage/IN_CTS/0521-COVERAGE-tiny-ptr-vector-h-85/work/variant/1_spirv_asm/shader.frag.asm | asuonpaa/ShaderTests | 6a3672040dcfa0d164d313224446496d1775a15e | [
"Apache-2.0"
] | 47 | 2021-03-11T07:42:51.000Z | 2022-03-14T06:30:14.000Z | coverage/IN_CTS/0521-COVERAGE-tiny-ptr-vector-h-85/work/variant/1_spirv_asm/shader.frag.asm | asuonpaa/ShaderTests | 6a3672040dcfa0d164d313224446496d1775a15e | [
"Apache-2.0"
] | 4 | 2021-03-09T13:37:19.000Z | 2022-02-25T07:32:11.000Z | ; SPIR-V
; Version: 1.0
; Generator: Khronos Glslang Reference Front End; 10
; Bound: 221
; Schema: 0
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main" %180
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
OpName %8 "a"
OpName %16 "arr"
OpName %19 "buf0"
OpMemberName %19 0 "_GLF_uniform_int_values"
OpName %21 ""
OpName %51 "i"
OpName %60 "j"
OpName %68 "idx"
OpName %76 "k"
OpName %87 "l"
OpName %158 "ref"
OpName %180 "_GLF_color"
OpName %194 "i"
OpDecorate %18 ArrayStride 16
OpMemberDecorate %19 0 Offset 0
OpDecorate %19 Block
OpDecorate %21 DescriptorSet 0
OpDecorate %21 Binding 0
OpDecorate %180 Location 0
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeInt 32 1
%7 = OpTypePointer Function %6
%9 = OpTypeFloat 32
%10 = OpConstant %9 1
%12 = OpTypeInt 32 0
%13 = OpConstant %12 9
%14 = OpTypeArray %6 %13
%15 = OpTypePointer Function %14
%17 = OpConstant %12 11
%18 = OpTypeArray %6 %17
%19 = OpTypeStruct %18
%20 = OpTypePointer Uniform %19
%21 = OpVariable %20 Uniform
%22 = OpConstant %6 0
%23 = OpConstant %6 6
%24 = OpTypePointer Uniform %6
%27 = OpConstant %6 8
%30 = OpConstant %6 1
%33 = OpConstant %6 2
%38 = OpConstant %6 3
%41 = OpConstant %6 4
%44 = OpConstant %6 5
%47 = OpConstant %6 9
%58 = OpTypeBool
%72 = OpConstant %6 7
%97 = OpConstant %6 10
%178 = OpTypeVector %9 4
%179 = OpTypePointer Output %178
%180 = OpVariable %179 Output
%4 = OpFunction %2 None %3
%5 = OpLabel
%8 = OpVariable %7 Function
%16 = OpVariable %15 Function
%51 = OpVariable %7 Function
%60 = OpVariable %7 Function
%68 = OpVariable %7 Function
%76 = OpVariable %7 Function
%87 = OpVariable %7 Function
%158 = OpVariable %15 Function
%194 = OpVariable %7 Function
%11 = OpBitcast %6 %10
OpStore %8 %11
%25 = OpAccessChain %24 %21 %22 %23
%26 = OpLoad %6 %25
%28 = OpAccessChain %24 %21 %22 %27
%29 = OpLoad %6 %28
%31 = OpAccessChain %24 %21 %22 %30
%32 = OpLoad %6 %31
%34 = OpAccessChain %24 %21 %22 %33
%35 = OpLoad %6 %34
%36 = OpAccessChain %24 %21 %22 %22
%37 = OpLoad %6 %36
%39 = OpAccessChain %24 %21 %22 %38
%40 = OpLoad %6 %39
%42 = OpAccessChain %24 %21 %22 %41
%43 = OpLoad %6 %42
%45 = OpAccessChain %24 %21 %22 %44
%46 = OpLoad %6 %45
%48 = OpAccessChain %24 %21 %22 %47
%49 = OpLoad %6 %48
%50 = OpCompositeConstruct %14 %26 %29 %32 %35 %37 %40 %43 %46 %49
OpStore %16 %50
OpStore %51 %22
OpBranch %52
%52 = OpLabel
OpLoopMerge %54 %55 None
OpBranch %56
%56 = OpLabel
%57 = OpLoad %6 %51
%59 = OpSLessThan %58 %57 %44
OpBranchConditional %59 %53 %54
%53 = OpLabel
OpStore %60 %22
OpBranch %61
%61 = OpLabel
OpLoopMerge %63 %64 None
OpBranch %65
%65 = OpLabel
%66 = OpLoad %6 %60
%67 = OpSLessThan %58 %66 %44
OpBranchConditional %67 %62 %63
%62 = OpLabel
%69 = OpLoad %6 %8
%70 = OpExtInst %6 %1 SClamp %69 %22 %27
OpStore %68 %70
%71 = OpLoad %6 %68
%73 = OpAccessChain %24 %21 %22 %72
%74 = OpLoad %6 %73
%75 = OpAccessChain %7 %16 %71
OpStore %75 %74
%77 = OpAccessChain %24 %21 %22 %72
%78 = OpLoad %6 %77
OpStore %76 %78
OpBranch %79
%79 = OpLabel
OpLoopMerge %81 %82 None
OpBranch %83
%83 = OpLabel
%84 = OpLoad %6 %76
%85 = OpLoad %6 %51
%86 = OpSLessThan %58 %84 %85
OpBranchConditional %86 %80 %81
%80 = OpLabel
OpStore %87 %22
OpBranch %88
%88 = OpLabel
OpLoopMerge %90 %91 None
OpBranch %92
%92 = OpLabel
%93 = OpLoad %6 %87
%94 = OpLoad %6 %60
%95 = OpSLessThan %58 %93 %94
OpBranchConditional %95 %89 %90
%89 = OpLabel
%96 = OpLoad %6 %8
%98 = OpAccessChain %24 %21 %22 %97
%99 = OpLoad %6 %98
%100 = OpISub %6 %96 %99
OpSelectionMerge %106 None
OpSwitch %100 %106 6 %101 7 %102 8 %103 9 %104 10 %105
%101 = OpLabel
%107 = OpLoad %6 %68
%108 = OpAccessChain %24 %21 %22 %23
%109 = OpLoad %6 %108
%110 = OpAccessChain %7 %16 %107
%111 = OpLoad %6 %110
%112 = OpIAdd %6 %111 %109
%113 = OpAccessChain %7 %16 %107
OpStore %113 %112
OpBranch %106
%102 = OpLabel
%115 = OpLoad %6 %68
%116 = OpAccessChain %24 %21 %22 %27
%117 = OpLoad %6 %116
%118 = OpAccessChain %7 %16 %115
%119 = OpLoad %6 %118
%120 = OpIAdd %6 %119 %117
%121 = OpAccessChain %7 %16 %115
OpStore %121 %120
OpBranch %106
%103 = OpLabel
%123 = OpLoad %6 %68
%124 = OpAccessChain %24 %21 %22 %30
%125 = OpLoad %6 %124
%126 = OpAccessChain %7 %16 %123
%127 = OpLoad %6 %126
%128 = OpIAdd %6 %127 %125
%129 = OpAccessChain %7 %16 %123
OpStore %129 %128
OpBranch %106
%104 = OpLabel
%131 = OpLoad %6 %68
%132 = OpAccessChain %24 %21 %22 %33
%133 = OpLoad %6 %132
%134 = OpAccessChain %7 %16 %131
%135 = OpLoad %6 %134
%136 = OpIAdd %6 %135 %133
%137 = OpAccessChain %7 %16 %131
OpStore %137 %136
OpBranch %106
%105 = OpLabel
%139 = OpLoad %6 %68
%140 = OpAccessChain %24 %21 %22 %22
%141 = OpLoad %6 %140
%142 = OpAccessChain %7 %16 %139
%143 = OpLoad %6 %142
%144 = OpIAdd %6 %143 %141
%145 = OpAccessChain %7 %16 %139
OpStore %145 %144
OpBranch %106
%106 = OpLabel
OpBranch %91
%91 = OpLabel
%148 = OpLoad %6 %87
%149 = OpIAdd %6 %148 %30
OpStore %87 %149
OpBranch %88
%90 = OpLabel
OpBranch %82
%82 = OpLabel
%150 = OpLoad %6 %76
%151 = OpIAdd %6 %150 %30
OpStore %76 %151
OpBranch %79
%81 = OpLabel
%152 = OpLoad %6 %8
%153 = OpIAdd %6 %152 %30
OpStore %8 %153
OpBranch %64
%64 = OpLabel
%154 = OpLoad %6 %60
%155 = OpIAdd %6 %154 %30
OpStore %60 %155
OpBranch %61
%63 = OpLabel
OpBranch %55
%55 = OpLabel
%156 = OpLoad %6 %51
%157 = OpIAdd %6 %156 %30
OpStore %51 %157
OpBranch %52
%54 = OpLabel
%159 = OpAccessChain %24 %21 %22 %23
%160 = OpLoad %6 %159
%161 = OpAccessChain %24 %21 %22 %27
%162 = OpLoad %6 %161
%163 = OpAccessChain %24 %21 %22 %30
%164 = OpLoad %6 %163
%165 = OpAccessChain %24 %21 %22 %33
%166 = OpLoad %6 %165
%167 = OpAccessChain %24 %21 %22 %22
%168 = OpLoad %6 %167
%169 = OpAccessChain %24 %21 %22 %38
%170 = OpLoad %6 %169
%171 = OpAccessChain %24 %21 %22 %41
%172 = OpLoad %6 %171
%173 = OpAccessChain %24 %21 %22 %44
%174 = OpLoad %6 %173
%175 = OpAccessChain %24 %21 %22 %72
%176 = OpLoad %6 %175
%177 = OpCompositeConstruct %14 %160 %162 %164 %166 %168 %170 %172 %174 %176
OpStore %158 %177
%181 = OpAccessChain %24 %21 %22 %23
%182 = OpLoad %6 %181
%183 = OpConvertSToF %9 %182
%184 = OpAccessChain %24 %21 %22 %72
%185 = OpLoad %6 %184
%186 = OpConvertSToF %9 %185
%187 = OpAccessChain %24 %21 %22 %72
%188 = OpLoad %6 %187
%189 = OpConvertSToF %9 %188
%190 = OpAccessChain %24 %21 %22 %23
%191 = OpLoad %6 %190
%192 = OpConvertSToF %9 %191
%193 = OpCompositeConstruct %178 %183 %186 %189 %192
OpStore %180 %193
%195 = OpAccessChain %24 %21 %22 %72
%196 = OpLoad %6 %195
OpStore %194 %196
OpBranch %197
%197 = OpLabel
OpLoopMerge %199 %200 None
OpBranch %201
%201 = OpLabel
%202 = OpLoad %6 %194
%203 = OpAccessChain %24 %21 %22 %47
%204 = OpLoad %6 %203
%205 = OpSLessThan %58 %202 %204
OpBranchConditional %205 %198 %199
%198 = OpLabel
%206 = OpLoad %6 %194
%207 = OpAccessChain %7 %16 %206
%208 = OpLoad %6 %207
%209 = OpLoad %6 %194
%210 = OpAccessChain %7 %158 %209
%211 = OpLoad %6 %210
%212 = OpINotEqual %58 %208 %211
OpSelectionMerge %214 None
OpBranchConditional %212 %213 %214
%213 = OpLabel
%215 = OpAccessChain %24 %21 %22 %72
%216 = OpLoad %6 %215
%217 = OpConvertSToF %9 %216
%218 = OpCompositeConstruct %178 %217 %217 %217 %217
OpStore %180 %218
OpBranch %214
%214 = OpLabel
OpBranch %200
%200 = OpLabel
%219 = OpLoad %6 %194
%220 = OpIAdd %6 %219 %30
OpStore %194 %220
OpBranch %197
%199 = OpLabel
OpReturn
OpFunctionEnd
| 33.951613 | 84 | 0.466128 |
1e36dab288d29688ad1b86c12e8c5827c4be9738 | 6,280 | asm | Assembly | sourcecode/strtest.asm | kbilsted/CompilerTeknik | f4effdde5ee060eac1c186bc11dd261f1e47d958 | [
"Apache-2.0"
] | null | null | null | sourcecode/strtest.asm | kbilsted/CompilerTeknik | f4effdde5ee060eac1c186bc11dd261f1e47d958 | [
"Apache-2.0"
] | null | null | null | sourcecode/strtest.asm | kbilsted/CompilerTeknik | f4effdde5ee060eac1c186bc11dd261f1e47d958 | [
"Apache-2.0"
] | null | null | null | DOSSEG
.MODEL SMALL
.STACK 100h
.DATA
hobptr dw 0
hob dw 120h dup(0) ; allocate hob
; error messages
oomstr db 10,13,'Out of memory! Can not allocate another class.','$',0,0
.CODE
jmp START
; ------------ STANDARD FUNCTIONS BEGIN ----------:
new PROC
mov ax, hobptr ; get hop size
push ax ; save pos. of class in stack
add ax, cx ; add size of obj
cmp ax, 120h
jg OutOfMem ; if ax < HOBSIZE jump to OutOfMemory
mov hobptr, ax ; save hop size
pop ax ; ax = pos. of class in hob
ret
OutOfMem:
mov dx, OFFSET oomstr; write out of mem string to screen
mov ah, 9h
int 21h
jmp SystemExit
new ENDP
SystemOutPrint PROC
mov ah, 2h
int 21h
ret
SystemOutPrint ENDP
SystemInRead PROC
mov ah, 1h ; read with screen echo
int 21h
mov ah, 0 ; clear AH as only AL contains userinput
ret
SystemInRead ENDP
SystemExit PROC
mov ah, 4ch
int 21h
ret
SystemExit ENDP
String_charAt PROC
mov bp, sp
sub bp, 2
mov si, bx ; pos in hob where obj begins
mov ax, [bp+4] ; get (first) argument telling pos to get
mov dx, 2 ; ax = ax *2
mul dx ; in hob every char takes 2 places
add si, ax ; pos in hob to fetch character
mov ax, hob[si+2] ; +2 as first field contains str_len
ret
String_charAt ENDP
String_concat PROC
mov bp, sp
sub bp, 2
mov cx, hob[bx] ; size of caller str
mov si, [bp+4] ; pos in hob of 2nd str len
add cx, hob[si] ; add 2nd str len
add cx, 2 ; add space for sizefield
push cx
call new ; alloc new String object
pop cx ; total strsize
mov si, ax ; can't just use the AX
mov hob[si], cx ; set concat'ed String size
mov cx, hob[bx] ; size of str1
add bx, 4 ; start in 2nd pos (but why +4 instead of +2 ??)
mov di, ax ; destination ptr = adr of new String obj
add di, 2 ; start in 2nd pos
strcat1:
mov si, [bx] ; we can't just use [bx]
mov hob[di], si
add bx, 2
add di, 2
loop strcat1
mov si, [bp+4] ; pos in hob of 2nd str len
mov cx, hob[si] ; size of 2nd str len
mov bx, [bp+4] ; point at start of 2nd string
add bx, 4 ; start in 2nd pos (but why +4??)
strcat2:
mov si, [bx] ; we can't just use [bx]
mov hob[di], si
add bx, 2
add di, 2
loop strcat2
ret
String_concat ENDP
String_length PROC ; str_len length()
mov ax, hob[bx] ; first field in string
ret
String_length ENDP
String_print PROC
mov cx, hob[bx] ; str size
mov si, bx ; source-print ptr
add si, 2
printloop:
mov dx, hob[si]
add si, 2 ; next char
push cx
push si
xor cx, cx ; zero cx
call SystemOutPrint ; print dx
pop si
pop cx
loop printloop
ret
String_print ENDP
; ------------ STANDARD FUNCTIONS END ----------:
START:
mov ax, @data ; setup DOS program
mov ds, ax
; allocate 'main' function
mov cx, 10
call new
mov bp, sp ; adjust bp to point at functions local variable
sub bp, 2 ;
mov bx, ax ; store main's 'this'
; execute mains contents
push 0 ; push local variables to stack
push 0 ; push local variables to stack
push 0 ; push local variables to stack
push 0 ; push local variables to stack
push 0 ; push local variables to stack
; assign
; string - allocate class and return pointer on stack
mov cx, 12 ; length of 2*str + 2
call new
mov si, ax ; mov (adr of obj in hob) to si
mov hob[si], 5 ; insert strlength
mov hob[si+2], 'h'
mov hob[si+4], 'e'
mov hob[si+6], 'l'
mov hob[si+8], 'l'
mov hob[si+10], 'o'
push ax
pop ax ; get value (assign)
mov [bp-0], ax ; set local variable s1
; assign
; string - allocate class and return pointer on stack
mov cx, 32 ; length of 2*str + 2
call new
mov si, ax ; mov (adr of obj in hob) to si
mov hob[si], 15 ; insert strlength
mov hob[si+2], ' '
mov hob[si+4], 'a'
mov hob[si+6], 's'
mov hob[si+8], 's'
mov hob[si+10], 'e'
mov hob[si+12], 'm'
mov hob[si+14], 'b'
mov hob[si+16], 'l'
mov hob[si+18], 'y'
mov hob[si+20], ' '
mov hob[si+22], 'w'
mov hob[si+24], 'o'
mov hob[si+26], 'r'
mov hob[si+28], 'l'
mov hob[si+30], 'd'
push ax
pop ax ; get value (assign)
mov [bp-2], ax ; set local variable s2
; assign
; fnccallGen
push bp
push bx
mov bx, [bp-0] ; push callers class' 'this'
mov ax, [bp-2] ; get local variable s2
push ax
call String_concat
pop cx ; de-stack arguments
pop bx ; restore this class' 'this'
pop bp
push ax ; 'emulated' return value on the stack
pop ax ; get value (assign)
mov [bp-4], ax ; set local variable s3
; fnccallGen
push bp
push bx
mov bx, [bp-4] ; push callers class' 'this'
call String_print
pop bx ; restore this class' 'this'
pop bp
; assign
; fnccallGen
push bp
push bx
mov bx, [bp-4] ; push callers class' 'this'
call String_length
pop bx ; restore this class' 'this'
pop bp
push ax ; 'emulated' return value on the stack
pop ax ; get value (assign)
mov [bp-6], ax ; set local variable len
; fnccallGen
mov ax, [bp-6] ; get local variable len
push ax
pop cx ; print DX ; System.out.print()
add cx, 48 ; convert to ASCII
mov dx, 0 ; clear DX
mov dl, cl
mov cx, 0 ; clear CX
call SystemOutPrint
; assign
; fnccallGen
push bp
push bx
mov bx, [bp-0] ; push callers class' 'this'
mov ax, 1
push ax
call String_charAt
pop cx ; de-stack arguments
pop bx ; restore this class' 'this'
pop bp
push ax ; 'emulated' return value on the stack
pop ax ; get value (assign)
mov [bp-8], ax ; set local variable c
; fnccallGen
mov ax, [bp-8] ; get local variable c
push ax
pop cx ; print DX ; System.out.print()
;;;;;;;;;;;;;;;;;;;;;;; add cx, 48 ; convert to ASCII
mov dx, 0 ; clear DX
mov dl, cl
mov cx, 0 ; clear CX
call SystemOutPrint
jmp SystemExit
END
| 25.632653 | 76 | 0.578344 |
8a4d98abfd3266d2f556a55ee51d4b22f51483f5 | 40,036 | asm | Assembly | fun.asm | prakhar987/xv6-system-calls | 4a28c04e3013723a77249dd4ba97a855b40b12cf | [
"MIT-0"
] | 5 | 2018-04-02T23:25:23.000Z | 2020-12-06T21:27:33.000Z | fun.asm | prakhar987/xv6-system-calls | 4a28c04e3013723a77249dd4ba97a855b40b12cf | [
"MIT-0"
] | null | null | null | fun.asm | prakhar987/xv6-system-calls | 4a28c04e3013723a77249dd4ba97a855b40b12cf | [
"MIT-0"
] | 7 | 2018-04-02T05:13:36.000Z | 2022-03-23T23:20:36.000Z |
_fun: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
#include "types.h"
#include "stat.h"
#include "user.h"
#include "fs.h"
int main ()
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 51 push %ecx
e: 83 ec 04 sub $0x4,%esp
printf(2, "~~HELLO~~");
11: 83 ec 08 sub $0x8,%esp
14: 68 bc 07 00 00 push $0x7bc
19: 6a 02 push $0x2
1b: e8 e6 03 00 00 call 406 <printf>
20: 83 c4 10 add $0x10,%esp
return 0;
23: b8 00 00 00 00 mov $0x0,%eax
}
28: 8b 4d fc mov -0x4(%ebp),%ecx
2b: c9 leave
2c: 8d 61 fc lea -0x4(%ecx),%esp
2f: c3 ret
00000030 <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
30: 55 push %ebp
31: 89 e5 mov %esp,%ebp
33: 57 push %edi
34: 53 push %ebx
asm volatile("cld; rep stosb" :
35: 8b 4d 08 mov 0x8(%ebp),%ecx
38: 8b 55 10 mov 0x10(%ebp),%edx
3b: 8b 45 0c mov 0xc(%ebp),%eax
3e: 89 cb mov %ecx,%ebx
40: 89 df mov %ebx,%edi
42: 89 d1 mov %edx,%ecx
44: fc cld
45: f3 aa rep stos %al,%es:(%edi)
47: 89 ca mov %ecx,%edx
49: 89 fb mov %edi,%ebx
4b: 89 5d 08 mov %ebx,0x8(%ebp)
4e: 89 55 10 mov %edx,0x10(%ebp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
51: 90 nop
52: 5b pop %ebx
53: 5f pop %edi
54: 5d pop %ebp
55: c3 ret
00000056 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
56: 55 push %ebp
57: 89 e5 mov %esp,%ebp
59: 83 ec 10 sub $0x10,%esp
char *os;
os = s;
5c: 8b 45 08 mov 0x8(%ebp),%eax
5f: 89 45 fc mov %eax,-0x4(%ebp)
while((*s++ = *t++) != 0)
62: 90 nop
63: 8b 45 08 mov 0x8(%ebp),%eax
66: 8d 50 01 lea 0x1(%eax),%edx
69: 89 55 08 mov %edx,0x8(%ebp)
6c: 8b 55 0c mov 0xc(%ebp),%edx
6f: 8d 4a 01 lea 0x1(%edx),%ecx
72: 89 4d 0c mov %ecx,0xc(%ebp)
75: 0f b6 12 movzbl (%edx),%edx
78: 88 10 mov %dl,(%eax)
7a: 0f b6 00 movzbl (%eax),%eax
7d: 84 c0 test %al,%al
7f: 75 e2 jne 63 <strcpy+0xd>
;
return os;
81: 8b 45 fc mov -0x4(%ebp),%eax
}
84: c9 leave
85: c3 ret
00000086 <strcmp>:
int
strcmp(const char *p, const char *q)
{
86: 55 push %ebp
87: 89 e5 mov %esp,%ebp
while(*p && *p == *q)
89: eb 08 jmp 93 <strcmp+0xd>
p++, q++;
8b: 83 45 08 01 addl $0x1,0x8(%ebp)
8f: 83 45 0c 01 addl $0x1,0xc(%ebp)
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
93: 8b 45 08 mov 0x8(%ebp),%eax
96: 0f b6 00 movzbl (%eax),%eax
99: 84 c0 test %al,%al
9b: 74 10 je ad <strcmp+0x27>
9d: 8b 45 08 mov 0x8(%ebp),%eax
a0: 0f b6 10 movzbl (%eax),%edx
a3: 8b 45 0c mov 0xc(%ebp),%eax
a6: 0f b6 00 movzbl (%eax),%eax
a9: 38 c2 cmp %al,%dl
ab: 74 de je 8b <strcmp+0x5>
p++, q++;
return (uchar)*p - (uchar)*q;
ad: 8b 45 08 mov 0x8(%ebp),%eax
b0: 0f b6 00 movzbl (%eax),%eax
b3: 0f b6 d0 movzbl %al,%edx
b6: 8b 45 0c mov 0xc(%ebp),%eax
b9: 0f b6 00 movzbl (%eax),%eax
bc: 0f b6 c0 movzbl %al,%eax
bf: 29 c2 sub %eax,%edx
c1: 89 d0 mov %edx,%eax
}
c3: 5d pop %ebp
c4: c3 ret
000000c5 <strlen>:
uint
strlen(char *s)
{
c5: 55 push %ebp
c6: 89 e5 mov %esp,%ebp
c8: 83 ec 10 sub $0x10,%esp
int n;
for(n = 0; s[n]; n++)
cb: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
d2: eb 04 jmp d8 <strlen+0x13>
d4: 83 45 fc 01 addl $0x1,-0x4(%ebp)
d8: 8b 55 fc mov -0x4(%ebp),%edx
db: 8b 45 08 mov 0x8(%ebp),%eax
de: 01 d0 add %edx,%eax
e0: 0f b6 00 movzbl (%eax),%eax
e3: 84 c0 test %al,%al
e5: 75 ed jne d4 <strlen+0xf>
;
return n;
e7: 8b 45 fc mov -0x4(%ebp),%eax
}
ea: c9 leave
eb: c3 ret
000000ec <memset>:
void*
memset(void *dst, int c, uint n)
{
ec: 55 push %ebp
ed: 89 e5 mov %esp,%ebp
stosb(dst, c, n);
ef: 8b 45 10 mov 0x10(%ebp),%eax
f2: 50 push %eax
f3: ff 75 0c pushl 0xc(%ebp)
f6: ff 75 08 pushl 0x8(%ebp)
f9: e8 32 ff ff ff call 30 <stosb>
fe: 83 c4 0c add $0xc,%esp
return dst;
101: 8b 45 08 mov 0x8(%ebp),%eax
}
104: c9 leave
105: c3 ret
00000106 <strchr>:
char*
strchr(const char *s, char c)
{
106: 55 push %ebp
107: 89 e5 mov %esp,%ebp
109: 83 ec 04 sub $0x4,%esp
10c: 8b 45 0c mov 0xc(%ebp),%eax
10f: 88 45 fc mov %al,-0x4(%ebp)
for(; *s; s++)
112: eb 14 jmp 128 <strchr+0x22>
if(*s == c)
114: 8b 45 08 mov 0x8(%ebp),%eax
117: 0f b6 00 movzbl (%eax),%eax
11a: 3a 45 fc cmp -0x4(%ebp),%al
11d: 75 05 jne 124 <strchr+0x1e>
return (char*)s;
11f: 8b 45 08 mov 0x8(%ebp),%eax
122: eb 13 jmp 137 <strchr+0x31>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
124: 83 45 08 01 addl $0x1,0x8(%ebp)
128: 8b 45 08 mov 0x8(%ebp),%eax
12b: 0f b6 00 movzbl (%eax),%eax
12e: 84 c0 test %al,%al
130: 75 e2 jne 114 <strchr+0xe>
if(*s == c)
return (char*)s;
return 0;
132: b8 00 00 00 00 mov $0x0,%eax
}
137: c9 leave
138: c3 ret
00000139 <gets>:
char*
gets(char *buf, int max)
{
139: 55 push %ebp
13a: 89 e5 mov %esp,%ebp
13c: 83 ec 18 sub $0x18,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
13f: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
146: eb 42 jmp 18a <gets+0x51>
cc = read(0, &c, 1);
148: 83 ec 04 sub $0x4,%esp
14b: 6a 01 push $0x1
14d: 8d 45 ef lea -0x11(%ebp),%eax
150: 50 push %eax
151: 6a 00 push $0x0
153: e8 47 01 00 00 call 29f <read>
158: 83 c4 10 add $0x10,%esp
15b: 89 45 f0 mov %eax,-0x10(%ebp)
if(cc < 1)
15e: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
162: 7e 33 jle 197 <gets+0x5e>
break;
buf[i++] = c;
164: 8b 45 f4 mov -0xc(%ebp),%eax
167: 8d 50 01 lea 0x1(%eax),%edx
16a: 89 55 f4 mov %edx,-0xc(%ebp)
16d: 89 c2 mov %eax,%edx
16f: 8b 45 08 mov 0x8(%ebp),%eax
172: 01 c2 add %eax,%edx
174: 0f b6 45 ef movzbl -0x11(%ebp),%eax
178: 88 02 mov %al,(%edx)
if(c == '\n' || c == '\r')
17a: 0f b6 45 ef movzbl -0x11(%ebp),%eax
17e: 3c 0a cmp $0xa,%al
180: 74 16 je 198 <gets+0x5f>
182: 0f b6 45 ef movzbl -0x11(%ebp),%eax
186: 3c 0d cmp $0xd,%al
188: 74 0e je 198 <gets+0x5f>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
18a: 8b 45 f4 mov -0xc(%ebp),%eax
18d: 83 c0 01 add $0x1,%eax
190: 3b 45 0c cmp 0xc(%ebp),%eax
193: 7c b3 jl 148 <gets+0xf>
195: eb 01 jmp 198 <gets+0x5f>
cc = read(0, &c, 1);
if(cc < 1)
break;
197: 90 nop
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
198: 8b 55 f4 mov -0xc(%ebp),%edx
19b: 8b 45 08 mov 0x8(%ebp),%eax
19e: 01 d0 add %edx,%eax
1a0: c6 00 00 movb $0x0,(%eax)
return buf;
1a3: 8b 45 08 mov 0x8(%ebp),%eax
}
1a6: c9 leave
1a7: c3 ret
000001a8 <stat>:
int
stat(char *n, struct stat *st)
{
1a8: 55 push %ebp
1a9: 89 e5 mov %esp,%ebp
1ab: 83 ec 18 sub $0x18,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
1ae: 83 ec 08 sub $0x8,%esp
1b1: 6a 00 push $0x0
1b3: ff 75 08 pushl 0x8(%ebp)
1b6: e8 0c 01 00 00 call 2c7 <open>
1bb: 83 c4 10 add $0x10,%esp
1be: 89 45 f4 mov %eax,-0xc(%ebp)
if(fd < 0)
1c1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1c5: 79 07 jns 1ce <stat+0x26>
return -1;
1c7: b8 ff ff ff ff mov $0xffffffff,%eax
1cc: eb 25 jmp 1f3 <stat+0x4b>
r = fstat(fd, st);
1ce: 83 ec 08 sub $0x8,%esp
1d1: ff 75 0c pushl 0xc(%ebp)
1d4: ff 75 f4 pushl -0xc(%ebp)
1d7: e8 03 01 00 00 call 2df <fstat>
1dc: 83 c4 10 add $0x10,%esp
1df: 89 45 f0 mov %eax,-0x10(%ebp)
close(fd);
1e2: 83 ec 0c sub $0xc,%esp
1e5: ff 75 f4 pushl -0xc(%ebp)
1e8: e8 c2 00 00 00 call 2af <close>
1ed: 83 c4 10 add $0x10,%esp
return r;
1f0: 8b 45 f0 mov -0x10(%ebp),%eax
}
1f3: c9 leave
1f4: c3 ret
000001f5 <atoi>:
int
atoi(const char *s)
{
1f5: 55 push %ebp
1f6: 89 e5 mov %esp,%ebp
1f8: 83 ec 10 sub $0x10,%esp
int n;
n = 0;
1fb: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
while('0' <= *s && *s <= '9')
202: eb 25 jmp 229 <atoi+0x34>
n = n*10 + *s++ - '0';
204: 8b 55 fc mov -0x4(%ebp),%edx
207: 89 d0 mov %edx,%eax
209: c1 e0 02 shl $0x2,%eax
20c: 01 d0 add %edx,%eax
20e: 01 c0 add %eax,%eax
210: 89 c1 mov %eax,%ecx
212: 8b 45 08 mov 0x8(%ebp),%eax
215: 8d 50 01 lea 0x1(%eax),%edx
218: 89 55 08 mov %edx,0x8(%ebp)
21b: 0f b6 00 movzbl (%eax),%eax
21e: 0f be c0 movsbl %al,%eax
221: 01 c8 add %ecx,%eax
223: 83 e8 30 sub $0x30,%eax
226: 89 45 fc mov %eax,-0x4(%ebp)
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
229: 8b 45 08 mov 0x8(%ebp),%eax
22c: 0f b6 00 movzbl (%eax),%eax
22f: 3c 2f cmp $0x2f,%al
231: 7e 0a jle 23d <atoi+0x48>
233: 8b 45 08 mov 0x8(%ebp),%eax
236: 0f b6 00 movzbl (%eax),%eax
239: 3c 39 cmp $0x39,%al
23b: 7e c7 jle 204 <atoi+0xf>
n = n*10 + *s++ - '0';
return n;
23d: 8b 45 fc mov -0x4(%ebp),%eax
}
240: c9 leave
241: c3 ret
00000242 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
242: 55 push %ebp
243: 89 e5 mov %esp,%ebp
245: 83 ec 10 sub $0x10,%esp
char *dst, *src;
dst = vdst;
248: 8b 45 08 mov 0x8(%ebp),%eax
24b: 89 45 fc mov %eax,-0x4(%ebp)
src = vsrc;
24e: 8b 45 0c mov 0xc(%ebp),%eax
251: 89 45 f8 mov %eax,-0x8(%ebp)
while(n-- > 0)
254: eb 17 jmp 26d <memmove+0x2b>
*dst++ = *src++;
256: 8b 45 fc mov -0x4(%ebp),%eax
259: 8d 50 01 lea 0x1(%eax),%edx
25c: 89 55 fc mov %edx,-0x4(%ebp)
25f: 8b 55 f8 mov -0x8(%ebp),%edx
262: 8d 4a 01 lea 0x1(%edx),%ecx
265: 89 4d f8 mov %ecx,-0x8(%ebp)
268: 0f b6 12 movzbl (%edx),%edx
26b: 88 10 mov %dl,(%eax)
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
26d: 8b 45 10 mov 0x10(%ebp),%eax
270: 8d 50 ff lea -0x1(%eax),%edx
273: 89 55 10 mov %edx,0x10(%ebp)
276: 85 c0 test %eax,%eax
278: 7f dc jg 256 <memmove+0x14>
*dst++ = *src++;
return vdst;
27a: 8b 45 08 mov 0x8(%ebp),%eax
}
27d: c9 leave
27e: c3 ret
0000027f <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
27f: b8 01 00 00 00 mov $0x1,%eax
284: cd 40 int $0x40
286: c3 ret
00000287 <exit>:
SYSCALL(exit)
287: b8 02 00 00 00 mov $0x2,%eax
28c: cd 40 int $0x40
28e: c3 ret
0000028f <wait>:
SYSCALL(wait)
28f: b8 03 00 00 00 mov $0x3,%eax
294: cd 40 int $0x40
296: c3 ret
00000297 <pipe>:
SYSCALL(pipe)
297: b8 04 00 00 00 mov $0x4,%eax
29c: cd 40 int $0x40
29e: c3 ret
0000029f <read>:
SYSCALL(read)
29f: b8 05 00 00 00 mov $0x5,%eax
2a4: cd 40 int $0x40
2a6: c3 ret
000002a7 <write>:
SYSCALL(write)
2a7: b8 10 00 00 00 mov $0x10,%eax
2ac: cd 40 int $0x40
2ae: c3 ret
000002af <close>:
SYSCALL(close)
2af: b8 15 00 00 00 mov $0x15,%eax
2b4: cd 40 int $0x40
2b6: c3 ret
000002b7 <kill>:
SYSCALL(kill)
2b7: b8 06 00 00 00 mov $0x6,%eax
2bc: cd 40 int $0x40
2be: c3 ret
000002bf <exec>:
SYSCALL(exec)
2bf: b8 07 00 00 00 mov $0x7,%eax
2c4: cd 40 int $0x40
2c6: c3 ret
000002c7 <open>:
SYSCALL(open)
2c7: b8 0f 00 00 00 mov $0xf,%eax
2cc: cd 40 int $0x40
2ce: c3 ret
000002cf <mknod>:
SYSCALL(mknod)
2cf: b8 11 00 00 00 mov $0x11,%eax
2d4: cd 40 int $0x40
2d6: c3 ret
000002d7 <unlink>:
SYSCALL(unlink)
2d7: b8 12 00 00 00 mov $0x12,%eax
2dc: cd 40 int $0x40
2de: c3 ret
000002df <fstat>:
SYSCALL(fstat)
2df: b8 08 00 00 00 mov $0x8,%eax
2e4: cd 40 int $0x40
2e6: c3 ret
000002e7 <link>:
SYSCALL(link)
2e7: b8 13 00 00 00 mov $0x13,%eax
2ec: cd 40 int $0x40
2ee: c3 ret
000002ef <mkdir>:
SYSCALL(mkdir)
2ef: b8 14 00 00 00 mov $0x14,%eax
2f4: cd 40 int $0x40
2f6: c3 ret
000002f7 <chdir>:
SYSCALL(chdir)
2f7: b8 09 00 00 00 mov $0x9,%eax
2fc: cd 40 int $0x40
2fe: c3 ret
000002ff <dup>:
SYSCALL(dup)
2ff: b8 0a 00 00 00 mov $0xa,%eax
304: cd 40 int $0x40
306: c3 ret
00000307 <getpid>:
SYSCALL(getpid)
307: b8 0b 00 00 00 mov $0xb,%eax
30c: cd 40 int $0x40
30e: c3 ret
0000030f <sbrk>:
SYSCALL(sbrk)
30f: b8 0c 00 00 00 mov $0xc,%eax
314: cd 40 int $0x40
316: c3 ret
00000317 <sleep>:
SYSCALL(sleep)
317: b8 0d 00 00 00 mov $0xd,%eax
31c: cd 40 int $0x40
31e: c3 ret
0000031f <uptime>:
SYSCALL(uptime)
31f: b8 0e 00 00 00 mov $0xe,%eax
324: cd 40 int $0x40
326: c3 ret
00000327 <fun>:
SYSCALL(fun)
327: b8 16 00 00 00 mov $0x16,%eax
32c: cd 40 int $0x40
32e: c3 ret
0000032f <putc>:
#include "stat.h"
#include "user.h"
static void
putc(int fd, char c)
{
32f: 55 push %ebp
330: 89 e5 mov %esp,%ebp
332: 83 ec 18 sub $0x18,%esp
335: 8b 45 0c mov 0xc(%ebp),%eax
338: 88 45 f4 mov %al,-0xc(%ebp)
write(fd, &c, 1);
33b: 83 ec 04 sub $0x4,%esp
33e: 6a 01 push $0x1
340: 8d 45 f4 lea -0xc(%ebp),%eax
343: 50 push %eax
344: ff 75 08 pushl 0x8(%ebp)
347: e8 5b ff ff ff call 2a7 <write>
34c: 83 c4 10 add $0x10,%esp
}
34f: 90 nop
350: c9 leave
351: c3 ret
00000352 <printint>:
static void
printint(int fd, int xx, int base, int sgn)
{
352: 55 push %ebp
353: 89 e5 mov %esp,%ebp
355: 53 push %ebx
356: 83 ec 24 sub $0x24,%esp
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
359: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
if(sgn && xx < 0){
360: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
364: 74 17 je 37d <printint+0x2b>
366: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
36a: 79 11 jns 37d <printint+0x2b>
neg = 1;
36c: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp)
x = -xx;
373: 8b 45 0c mov 0xc(%ebp),%eax
376: f7 d8 neg %eax
378: 89 45 ec mov %eax,-0x14(%ebp)
37b: eb 06 jmp 383 <printint+0x31>
} else {
x = xx;
37d: 8b 45 0c mov 0xc(%ebp),%eax
380: 89 45 ec mov %eax,-0x14(%ebp)
}
i = 0;
383: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
do{
buf[i++] = digits[x % base];
38a: 8b 4d f4 mov -0xc(%ebp),%ecx
38d: 8d 41 01 lea 0x1(%ecx),%eax
390: 89 45 f4 mov %eax,-0xc(%ebp)
393: 8b 5d 10 mov 0x10(%ebp),%ebx
396: 8b 45 ec mov -0x14(%ebp),%eax
399: ba 00 00 00 00 mov $0x0,%edx
39e: f7 f3 div %ebx
3a0: 89 d0 mov %edx,%eax
3a2: 0f b6 80 20 0a 00 00 movzbl 0xa20(%eax),%eax
3a9: 88 44 0d dc mov %al,-0x24(%ebp,%ecx,1)
}while((x /= base) != 0);
3ad: 8b 5d 10 mov 0x10(%ebp),%ebx
3b0: 8b 45 ec mov -0x14(%ebp),%eax
3b3: ba 00 00 00 00 mov $0x0,%edx
3b8: f7 f3 div %ebx
3ba: 89 45 ec mov %eax,-0x14(%ebp)
3bd: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
3c1: 75 c7 jne 38a <printint+0x38>
if(neg)
3c3: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
3c7: 74 2d je 3f6 <printint+0xa4>
buf[i++] = '-';
3c9: 8b 45 f4 mov -0xc(%ebp),%eax
3cc: 8d 50 01 lea 0x1(%eax),%edx
3cf: 89 55 f4 mov %edx,-0xc(%ebp)
3d2: c6 44 05 dc 2d movb $0x2d,-0x24(%ebp,%eax,1)
while(--i >= 0)
3d7: eb 1d jmp 3f6 <printint+0xa4>
putc(fd, buf[i]);
3d9: 8d 55 dc lea -0x24(%ebp),%edx
3dc: 8b 45 f4 mov -0xc(%ebp),%eax
3df: 01 d0 add %edx,%eax
3e1: 0f b6 00 movzbl (%eax),%eax
3e4: 0f be c0 movsbl %al,%eax
3e7: 83 ec 08 sub $0x8,%esp
3ea: 50 push %eax
3eb: ff 75 08 pushl 0x8(%ebp)
3ee: e8 3c ff ff ff call 32f <putc>
3f3: 83 c4 10 add $0x10,%esp
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
3f6: 83 6d f4 01 subl $0x1,-0xc(%ebp)
3fa: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
3fe: 79 d9 jns 3d9 <printint+0x87>
putc(fd, buf[i]);
}
400: 90 nop
401: 8b 5d fc mov -0x4(%ebp),%ebx
404: c9 leave
405: c3 ret
00000406 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
406: 55 push %ebp
407: 89 e5 mov %esp,%ebp
409: 83 ec 28 sub $0x28,%esp
char *s;
int c, i, state;
uint *ap;
state = 0;
40c: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
ap = (uint*)(void*)&fmt + 1;
413: 8d 45 0c lea 0xc(%ebp),%eax
416: 83 c0 04 add $0x4,%eax
419: 89 45 e8 mov %eax,-0x18(%ebp)
for(i = 0; fmt[i]; i++){
41c: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
423: e9 59 01 00 00 jmp 581 <printf+0x17b>
c = fmt[i] & 0xff;
428: 8b 55 0c mov 0xc(%ebp),%edx
42b: 8b 45 f0 mov -0x10(%ebp),%eax
42e: 01 d0 add %edx,%eax
430: 0f b6 00 movzbl (%eax),%eax
433: 0f be c0 movsbl %al,%eax
436: 25 ff 00 00 00 and $0xff,%eax
43b: 89 45 e4 mov %eax,-0x1c(%ebp)
if(state == 0){
43e: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
442: 75 2c jne 470 <printf+0x6a>
if(c == '%'){
444: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
448: 75 0c jne 456 <printf+0x50>
state = '%';
44a: c7 45 ec 25 00 00 00 movl $0x25,-0x14(%ebp)
451: e9 27 01 00 00 jmp 57d <printf+0x177>
} else {
putc(fd, c);
456: 8b 45 e4 mov -0x1c(%ebp),%eax
459: 0f be c0 movsbl %al,%eax
45c: 83 ec 08 sub $0x8,%esp
45f: 50 push %eax
460: ff 75 08 pushl 0x8(%ebp)
463: e8 c7 fe ff ff call 32f <putc>
468: 83 c4 10 add $0x10,%esp
46b: e9 0d 01 00 00 jmp 57d <printf+0x177>
}
} else if(state == '%'){
470: 83 7d ec 25 cmpl $0x25,-0x14(%ebp)
474: 0f 85 03 01 00 00 jne 57d <printf+0x177>
if(c == 'd'){
47a: 83 7d e4 64 cmpl $0x64,-0x1c(%ebp)
47e: 75 1e jne 49e <printf+0x98>
printint(fd, *ap, 10, 1);
480: 8b 45 e8 mov -0x18(%ebp),%eax
483: 8b 00 mov (%eax),%eax
485: 6a 01 push $0x1
487: 6a 0a push $0xa
489: 50 push %eax
48a: ff 75 08 pushl 0x8(%ebp)
48d: e8 c0 fe ff ff call 352 <printint>
492: 83 c4 10 add $0x10,%esp
ap++;
495: 83 45 e8 04 addl $0x4,-0x18(%ebp)
499: e9 d8 00 00 00 jmp 576 <printf+0x170>
} else if(c == 'x' || c == 'p'){
49e: 83 7d e4 78 cmpl $0x78,-0x1c(%ebp)
4a2: 74 06 je 4aa <printf+0xa4>
4a4: 83 7d e4 70 cmpl $0x70,-0x1c(%ebp)
4a8: 75 1e jne 4c8 <printf+0xc2>
printint(fd, *ap, 16, 0);
4aa: 8b 45 e8 mov -0x18(%ebp),%eax
4ad: 8b 00 mov (%eax),%eax
4af: 6a 00 push $0x0
4b1: 6a 10 push $0x10
4b3: 50 push %eax
4b4: ff 75 08 pushl 0x8(%ebp)
4b7: e8 96 fe ff ff call 352 <printint>
4bc: 83 c4 10 add $0x10,%esp
ap++;
4bf: 83 45 e8 04 addl $0x4,-0x18(%ebp)
4c3: e9 ae 00 00 00 jmp 576 <printf+0x170>
} else if(c == 's'){
4c8: 83 7d e4 73 cmpl $0x73,-0x1c(%ebp)
4cc: 75 43 jne 511 <printf+0x10b>
s = (char*)*ap;
4ce: 8b 45 e8 mov -0x18(%ebp),%eax
4d1: 8b 00 mov (%eax),%eax
4d3: 89 45 f4 mov %eax,-0xc(%ebp)
ap++;
4d6: 83 45 e8 04 addl $0x4,-0x18(%ebp)
if(s == 0)
4da: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
4de: 75 25 jne 505 <printf+0xff>
s = "(null)";
4e0: c7 45 f4 c6 07 00 00 movl $0x7c6,-0xc(%ebp)
while(*s != 0){
4e7: eb 1c jmp 505 <printf+0xff>
putc(fd, *s);
4e9: 8b 45 f4 mov -0xc(%ebp),%eax
4ec: 0f b6 00 movzbl (%eax),%eax
4ef: 0f be c0 movsbl %al,%eax
4f2: 83 ec 08 sub $0x8,%esp
4f5: 50 push %eax
4f6: ff 75 08 pushl 0x8(%ebp)
4f9: e8 31 fe ff ff call 32f <putc>
4fe: 83 c4 10 add $0x10,%esp
s++;
501: 83 45 f4 01 addl $0x1,-0xc(%ebp)
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
505: 8b 45 f4 mov -0xc(%ebp),%eax
508: 0f b6 00 movzbl (%eax),%eax
50b: 84 c0 test %al,%al
50d: 75 da jne 4e9 <printf+0xe3>
50f: eb 65 jmp 576 <printf+0x170>
putc(fd, *s);
s++;
}
} else if(c == 'c'){
511: 83 7d e4 63 cmpl $0x63,-0x1c(%ebp)
515: 75 1d jne 534 <printf+0x12e>
putc(fd, *ap);
517: 8b 45 e8 mov -0x18(%ebp),%eax
51a: 8b 00 mov (%eax),%eax
51c: 0f be c0 movsbl %al,%eax
51f: 83 ec 08 sub $0x8,%esp
522: 50 push %eax
523: ff 75 08 pushl 0x8(%ebp)
526: e8 04 fe ff ff call 32f <putc>
52b: 83 c4 10 add $0x10,%esp
ap++;
52e: 83 45 e8 04 addl $0x4,-0x18(%ebp)
532: eb 42 jmp 576 <printf+0x170>
} else if(c == '%'){
534: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
538: 75 17 jne 551 <printf+0x14b>
putc(fd, c);
53a: 8b 45 e4 mov -0x1c(%ebp),%eax
53d: 0f be c0 movsbl %al,%eax
540: 83 ec 08 sub $0x8,%esp
543: 50 push %eax
544: ff 75 08 pushl 0x8(%ebp)
547: e8 e3 fd ff ff call 32f <putc>
54c: 83 c4 10 add $0x10,%esp
54f: eb 25 jmp 576 <printf+0x170>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
551: 83 ec 08 sub $0x8,%esp
554: 6a 25 push $0x25
556: ff 75 08 pushl 0x8(%ebp)
559: e8 d1 fd ff ff call 32f <putc>
55e: 83 c4 10 add $0x10,%esp
putc(fd, c);
561: 8b 45 e4 mov -0x1c(%ebp),%eax
564: 0f be c0 movsbl %al,%eax
567: 83 ec 08 sub $0x8,%esp
56a: 50 push %eax
56b: ff 75 08 pushl 0x8(%ebp)
56e: e8 bc fd ff ff call 32f <putc>
573: 83 c4 10 add $0x10,%esp
}
state = 0;
576: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
57d: 83 45 f0 01 addl $0x1,-0x10(%ebp)
581: 8b 55 0c mov 0xc(%ebp),%edx
584: 8b 45 f0 mov -0x10(%ebp),%eax
587: 01 d0 add %edx,%eax
589: 0f b6 00 movzbl (%eax),%eax
58c: 84 c0 test %al,%al
58e: 0f 85 94 fe ff ff jne 428 <printf+0x22>
putc(fd, c);
}
state = 0;
}
}
}
594: 90 nop
595: c9 leave
596: c3 ret
00000597 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
597: 55 push %ebp
598: 89 e5 mov %esp,%ebp
59a: 83 ec 10 sub $0x10,%esp
Header *bp, *p;
bp = (Header*)ap - 1;
59d: 8b 45 08 mov 0x8(%ebp),%eax
5a0: 83 e8 08 sub $0x8,%eax
5a3: 89 45 f8 mov %eax,-0x8(%ebp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
5a6: a1 3c 0a 00 00 mov 0xa3c,%eax
5ab: 89 45 fc mov %eax,-0x4(%ebp)
5ae: eb 24 jmp 5d4 <free+0x3d>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
5b0: 8b 45 fc mov -0x4(%ebp),%eax
5b3: 8b 00 mov (%eax),%eax
5b5: 3b 45 fc cmp -0x4(%ebp),%eax
5b8: 77 12 ja 5cc <free+0x35>
5ba: 8b 45 f8 mov -0x8(%ebp),%eax
5bd: 3b 45 fc cmp -0x4(%ebp),%eax
5c0: 77 24 ja 5e6 <free+0x4f>
5c2: 8b 45 fc mov -0x4(%ebp),%eax
5c5: 8b 00 mov (%eax),%eax
5c7: 3b 45 f8 cmp -0x8(%ebp),%eax
5ca: 77 1a ja 5e6 <free+0x4f>
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
5cc: 8b 45 fc mov -0x4(%ebp),%eax
5cf: 8b 00 mov (%eax),%eax
5d1: 89 45 fc mov %eax,-0x4(%ebp)
5d4: 8b 45 f8 mov -0x8(%ebp),%eax
5d7: 3b 45 fc cmp -0x4(%ebp),%eax
5da: 76 d4 jbe 5b0 <free+0x19>
5dc: 8b 45 fc mov -0x4(%ebp),%eax
5df: 8b 00 mov (%eax),%eax
5e1: 3b 45 f8 cmp -0x8(%ebp),%eax
5e4: 76 ca jbe 5b0 <free+0x19>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
5e6: 8b 45 f8 mov -0x8(%ebp),%eax
5e9: 8b 40 04 mov 0x4(%eax),%eax
5ec: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
5f3: 8b 45 f8 mov -0x8(%ebp),%eax
5f6: 01 c2 add %eax,%edx
5f8: 8b 45 fc mov -0x4(%ebp),%eax
5fb: 8b 00 mov (%eax),%eax
5fd: 39 c2 cmp %eax,%edx
5ff: 75 24 jne 625 <free+0x8e>
bp->s.size += p->s.ptr->s.size;
601: 8b 45 f8 mov -0x8(%ebp),%eax
604: 8b 50 04 mov 0x4(%eax),%edx
607: 8b 45 fc mov -0x4(%ebp),%eax
60a: 8b 00 mov (%eax),%eax
60c: 8b 40 04 mov 0x4(%eax),%eax
60f: 01 c2 add %eax,%edx
611: 8b 45 f8 mov -0x8(%ebp),%eax
614: 89 50 04 mov %edx,0x4(%eax)
bp->s.ptr = p->s.ptr->s.ptr;
617: 8b 45 fc mov -0x4(%ebp),%eax
61a: 8b 00 mov (%eax),%eax
61c: 8b 10 mov (%eax),%edx
61e: 8b 45 f8 mov -0x8(%ebp),%eax
621: 89 10 mov %edx,(%eax)
623: eb 0a jmp 62f <free+0x98>
} else
bp->s.ptr = p->s.ptr;
625: 8b 45 fc mov -0x4(%ebp),%eax
628: 8b 10 mov (%eax),%edx
62a: 8b 45 f8 mov -0x8(%ebp),%eax
62d: 89 10 mov %edx,(%eax)
if(p + p->s.size == bp){
62f: 8b 45 fc mov -0x4(%ebp),%eax
632: 8b 40 04 mov 0x4(%eax),%eax
635: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
63c: 8b 45 fc mov -0x4(%ebp),%eax
63f: 01 d0 add %edx,%eax
641: 3b 45 f8 cmp -0x8(%ebp),%eax
644: 75 20 jne 666 <free+0xcf>
p->s.size += bp->s.size;
646: 8b 45 fc mov -0x4(%ebp),%eax
649: 8b 50 04 mov 0x4(%eax),%edx
64c: 8b 45 f8 mov -0x8(%ebp),%eax
64f: 8b 40 04 mov 0x4(%eax),%eax
652: 01 c2 add %eax,%edx
654: 8b 45 fc mov -0x4(%ebp),%eax
657: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
65a: 8b 45 f8 mov -0x8(%ebp),%eax
65d: 8b 10 mov (%eax),%edx
65f: 8b 45 fc mov -0x4(%ebp),%eax
662: 89 10 mov %edx,(%eax)
664: eb 08 jmp 66e <free+0xd7>
} else
p->s.ptr = bp;
666: 8b 45 fc mov -0x4(%ebp),%eax
669: 8b 55 f8 mov -0x8(%ebp),%edx
66c: 89 10 mov %edx,(%eax)
freep = p;
66e: 8b 45 fc mov -0x4(%ebp),%eax
671: a3 3c 0a 00 00 mov %eax,0xa3c
}
676: 90 nop
677: c9 leave
678: c3 ret
00000679 <morecore>:
static Header*
morecore(uint nu)
{
679: 55 push %ebp
67a: 89 e5 mov %esp,%ebp
67c: 83 ec 18 sub $0x18,%esp
char *p;
Header *hp;
if(nu < 4096)
67f: 81 7d 08 ff 0f 00 00 cmpl $0xfff,0x8(%ebp)
686: 77 07 ja 68f <morecore+0x16>
nu = 4096;
688: c7 45 08 00 10 00 00 movl $0x1000,0x8(%ebp)
p = sbrk(nu * sizeof(Header));
68f: 8b 45 08 mov 0x8(%ebp),%eax
692: c1 e0 03 shl $0x3,%eax
695: 83 ec 0c sub $0xc,%esp
698: 50 push %eax
699: e8 71 fc ff ff call 30f <sbrk>
69e: 83 c4 10 add $0x10,%esp
6a1: 89 45 f4 mov %eax,-0xc(%ebp)
if(p == (char*)-1)
6a4: 83 7d f4 ff cmpl $0xffffffff,-0xc(%ebp)
6a8: 75 07 jne 6b1 <morecore+0x38>
return 0;
6aa: b8 00 00 00 00 mov $0x0,%eax
6af: eb 26 jmp 6d7 <morecore+0x5e>
hp = (Header*)p;
6b1: 8b 45 f4 mov -0xc(%ebp),%eax
6b4: 89 45 f0 mov %eax,-0x10(%ebp)
hp->s.size = nu;
6b7: 8b 45 f0 mov -0x10(%ebp),%eax
6ba: 8b 55 08 mov 0x8(%ebp),%edx
6bd: 89 50 04 mov %edx,0x4(%eax)
free((void*)(hp + 1));
6c0: 8b 45 f0 mov -0x10(%ebp),%eax
6c3: 83 c0 08 add $0x8,%eax
6c6: 83 ec 0c sub $0xc,%esp
6c9: 50 push %eax
6ca: e8 c8 fe ff ff call 597 <free>
6cf: 83 c4 10 add $0x10,%esp
return freep;
6d2: a1 3c 0a 00 00 mov 0xa3c,%eax
}
6d7: c9 leave
6d8: c3 ret
000006d9 <malloc>:
void*
malloc(uint nbytes)
{
6d9: 55 push %ebp
6da: 89 e5 mov %esp,%ebp
6dc: 83 ec 18 sub $0x18,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
6df: 8b 45 08 mov 0x8(%ebp),%eax
6e2: 83 c0 07 add $0x7,%eax
6e5: c1 e8 03 shr $0x3,%eax
6e8: 83 c0 01 add $0x1,%eax
6eb: 89 45 ec mov %eax,-0x14(%ebp)
if((prevp = freep) == 0){
6ee: a1 3c 0a 00 00 mov 0xa3c,%eax
6f3: 89 45 f0 mov %eax,-0x10(%ebp)
6f6: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
6fa: 75 23 jne 71f <malloc+0x46>
base.s.ptr = freep = prevp = &base;
6fc: c7 45 f0 34 0a 00 00 movl $0xa34,-0x10(%ebp)
703: 8b 45 f0 mov -0x10(%ebp),%eax
706: a3 3c 0a 00 00 mov %eax,0xa3c
70b: a1 3c 0a 00 00 mov 0xa3c,%eax
710: a3 34 0a 00 00 mov %eax,0xa34
base.s.size = 0;
715: c7 05 38 0a 00 00 00 movl $0x0,0xa38
71c: 00 00 00
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
71f: 8b 45 f0 mov -0x10(%ebp),%eax
722: 8b 00 mov (%eax),%eax
724: 89 45 f4 mov %eax,-0xc(%ebp)
if(p->s.size >= nunits){
727: 8b 45 f4 mov -0xc(%ebp),%eax
72a: 8b 40 04 mov 0x4(%eax),%eax
72d: 3b 45 ec cmp -0x14(%ebp),%eax
730: 72 4d jb 77f <malloc+0xa6>
if(p->s.size == nunits)
732: 8b 45 f4 mov -0xc(%ebp),%eax
735: 8b 40 04 mov 0x4(%eax),%eax
738: 3b 45 ec cmp -0x14(%ebp),%eax
73b: 75 0c jne 749 <malloc+0x70>
prevp->s.ptr = p->s.ptr;
73d: 8b 45 f4 mov -0xc(%ebp),%eax
740: 8b 10 mov (%eax),%edx
742: 8b 45 f0 mov -0x10(%ebp),%eax
745: 89 10 mov %edx,(%eax)
747: eb 26 jmp 76f <malloc+0x96>
else {
p->s.size -= nunits;
749: 8b 45 f4 mov -0xc(%ebp),%eax
74c: 8b 40 04 mov 0x4(%eax),%eax
74f: 2b 45 ec sub -0x14(%ebp),%eax
752: 89 c2 mov %eax,%edx
754: 8b 45 f4 mov -0xc(%ebp),%eax
757: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
75a: 8b 45 f4 mov -0xc(%ebp),%eax
75d: 8b 40 04 mov 0x4(%eax),%eax
760: c1 e0 03 shl $0x3,%eax
763: 01 45 f4 add %eax,-0xc(%ebp)
p->s.size = nunits;
766: 8b 45 f4 mov -0xc(%ebp),%eax
769: 8b 55 ec mov -0x14(%ebp),%edx
76c: 89 50 04 mov %edx,0x4(%eax)
}
freep = prevp;
76f: 8b 45 f0 mov -0x10(%ebp),%eax
772: a3 3c 0a 00 00 mov %eax,0xa3c
return (void*)(p + 1);
777: 8b 45 f4 mov -0xc(%ebp),%eax
77a: 83 c0 08 add $0x8,%eax
77d: eb 3b jmp 7ba <malloc+0xe1>
}
if(p == freep)
77f: a1 3c 0a 00 00 mov 0xa3c,%eax
784: 39 45 f4 cmp %eax,-0xc(%ebp)
787: 75 1e jne 7a7 <malloc+0xce>
if((p = morecore(nunits)) == 0)
789: 83 ec 0c sub $0xc,%esp
78c: ff 75 ec pushl -0x14(%ebp)
78f: e8 e5 fe ff ff call 679 <morecore>
794: 83 c4 10 add $0x10,%esp
797: 89 45 f4 mov %eax,-0xc(%ebp)
79a: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
79e: 75 07 jne 7a7 <malloc+0xce>
return 0;
7a0: b8 00 00 00 00 mov $0x0,%eax
7a5: eb 13 jmp 7ba <malloc+0xe1>
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
7a7: 8b 45 f4 mov -0xc(%ebp),%eax
7aa: 89 45 f0 mov %eax,-0x10(%ebp)
7ad: 8b 45 f4 mov -0xc(%ebp),%eax
7b0: 8b 00 mov (%eax),%eax
7b2: 89 45 f4 mov %eax,-0xc(%ebp)
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
7b5: e9 6d ff ff ff jmp 727 <malloc+0x4e>
}
7ba: c9 leave
7bb: c3 ret
| 34.073191 | 60 | 0.419423 |
e9dd97f637c0d704cde6349e0ef3a336c8936eda | 1,496 | asm | Assembly | programs/oeis/288/A288625.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/288/A288625.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/288/A288625.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A288625: Positions of 0 in A288375; complement of A283794.
; 2,3,5,7,8,11,12,14,17,18,20,22,23,27,28,30,32,33,36,37,39,43,44,46,48,49,52,53,55,58,59,61,63,64,69,70,72,74,75,78,79,81,84,85,87,89,90,94,95,97,99,100,103,104,106,111,112,114,116,117,120,121,123,126,127,129,131,132,136,137,139,141,142,145,146,148,152,153,155,157,158,161,162,164,167,168,170,172,173,179,180,182,184,185,188,189,191,194,195,197,199,200,204,205,207,209,210,213,214,216,220,221,223,225,226,229,230,232,235,236,238,240,241,246,247,249,251,252,255,256,258,261,262,264,266,267,271,272,274,276,277,280,281,283,289,290,292,294,295,298,299,301,304,305,307,309,310,314,315,317,319,320,323,324,326,330,331,333,335,336,339,340,342,345,346,348,350,351,356,357,359,361,362,365,366,368,371,372,374,376,377,381,382,384,386,387,390,391,393,398,399,401,403,404,407,408,410,413,414,416,418,419,423,424,426,428,429,432,433,435,439,440,442,444,445,448,449,451,454,455,457,459,460,467,468,470,472,473,476,477,479,482,483,485,487,488,492,493,495,497
mov $3,$0
add $3,1
mov $9,$0
lpb $3
mov $0,$9
sub $3,1
sub $0,$3
mov $5,$0
mov $7,2
lpb $7
mov $0,$5
sub $7,1
add $0,$7
lpb $0
sub $0,1
mov $2,1
mov $4,$0
cal $4,219641 ; a(n) = n minus (number of 1's in Zeckendorf expansion of n).
mov $0,0
add $2,$4
lpe
mov $4,$2
mov $8,$7
lpb $8
mov $6,$4
sub $8,1
lpe
lpe
lpb $5
mov $5,0
sub $6,$4
lpe
mov $4,$6
add $4,1
add $1,$4
lpe
| 37.4 | 945 | 0.637032 |
0c114633f6cb26927c3d00855fd77d69965c2400 | 512 | asm | Assembly | programs/oeis/108/A108920.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/108/A108920.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/108/A108920.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A108920: Number of positive integers k>n such that n+k divides n^2+k^2.
; 0,1,2,2,2,4,2,3,4,5,2,7,2,5,7,4,2,8,2,7,8,5,2,10,4,5,6,7,2,15,2,5,8,5,7,13,2,5,8,10,2,15,2,8,12,5,2,13,4,9,8,8,2,12,8,10,8,5,2,23,2,5,13,6,8,15,2,8,8,16,2,17,2,5,13,8,7,16,2,13,8,5,2,23,8,5,8,10,2,26,7,8,8,5,8
add $0,1
mov $2,$0
lpb $0
mul $2,2
mul $2,$0
lpb $0
mov $3,$2
mov $4,$0
cmp $4,0
add $0,$4
dif $3,$0
sub $0,1
cmp $3,$2
cmp $3,0
mul $3,50
add $1,$3
lpe
lpe
div $1,50
mov $0,$1
| 21.333333 | 211 | 0.517578 |
016072e89b1bffedd45c526424859008e843f10a | 873 | asm | Assembly | boot.asm | faineance/uos | 3be6e08a74347ec074512ee80ca1bad13f6d9c2b | [
"MIT"
] | null | null | null | boot.asm | faineance/uos | 3be6e08a74347ec074512ee80ca1bad13f6d9c2b | [
"MIT"
] | null | null | null | boot.asm | faineance/uos | 3be6e08a74347ec074512ee80ca1bad13f6d9c2b | [
"MIT"
] | null | null | null | bits 16
org 0x07C00
cli
call clear
mov si, hello_world
call puts
call getc
call putc
hlt
halt: jmp halt
puts: ; DS:SI -> string to print
lodsb ; assume: DF = 0
test al,al
jz putc.ret
push puts
putc: ; al -> char to print
mov ah,0eh
xor bh,bh
int 10h ; int 29h ? (http://www.fysnet.net/undoc.htm)
.ret: ret
gets:
call getc
cmp al, 0x0D ;enter
je getc.ret
push gets
getc:
xor ah, ah
int 0x16
call putc
.ret: ret
reboot:
db 0x0ea
dw 0x0000
dw 0xffff
clear:
mov ax,0003h
int 10h
ret
; 10 -> new line ascii
; 13 -> carriage return
%define NEWLINE 13, 10
hello_world db NEWLINE, 'Hello World', NEWLINE, 0
; fill remaining with 0, add magic
TIMES 512-2 - ($ - $$) db 0
DW 0xAA55 | 15.315789 | 65 | 0.544101 |
bbe8737cefd63891a187f5fc5bb13f46ac450277 | 473 | asm | Assembly | bin2hex.asm | suriya-1403/Assemble-language | 2e389341ff4c95a5c43b1653d1bf8071a52e7da7 | [
"MIT"
] | null | null | null | bin2hex.asm | suriya-1403/Assemble-language | 2e389341ff4c95a5c43b1653d1bf8071a52e7da7 | [
"MIT"
] | null | null | null | bin2hex.asm | suriya-1403/Assemble-language | 2e389341ff4c95a5c43b1653d1bf8071a52e7da7 | [
"MIT"
] | null | null | null | ASSUME CS:CODE,DS:DATA
DATA SEGMENT
NUM DB '1010','$'
DATA ENDS
CODE SEGMENT
START:
MOV AX,DATA
MOV DS,AX
MOV AX,0000H
MOV CX,0000H
MOV SI,OFFSET NUM
L1:
MOV AX,[SI]
CMP AX,'$'
JE LV2
INC CX
INC SI
JMP L1
LV2:
DEC SI
MOV BX,0000
MOV AX,0001
L2:
MOV DX,[SI]
CMP DL,'1'
JE L3
JMP ENDLOOP
L3:
ADD BX,AX
ENDLOOP:
MOV DX,0002
MUL DX
DEC SI
LOOP L2
MOV AX,BX
HLT
CODE ENDS
END START
| 12.128205 | 22 | 0.566596 |
d36becd43df1871a71c013ea52fcd313f7fb4b0e | 366 | asm | Assembly | oeis/095/A095265.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/095/A095265.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/095/A095265.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A095265: A sequence generated from a 4th degree Pascal's Triangle polynomial.
; 1,22,103,284,605,1106,1827,2808,4089,5710,7711,10132,13013,16394,20315,24816,29937,35718,42199,49420,57421,66242,75923,86504,98025,110526,124047,138628,154309,171130,189131,208352,228833,250614,273735,298236
mov $1,$0
add $0,1
mul $0,2
bin $0,3
mul $0,5
add $1,1
add $1,$0
mov $0,$1
| 30.5 | 209 | 0.754098 |
ce633a984e6ae3d44e034d7c1bf83d46651aa20e | 537 | asm | Assembly | oeis/006/A006893.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/006/A006893.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/006/A006893.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A006893: Smallest number whose representation requires n triangular numbers with greedy algorithm; also number of 1-2 rooted trees of height n.
; Submitted by Christian Krause
; 1,2,5,20,230,26795,359026205,64449908476890320,2076895351339769460477611370186680,2156747150208372213435450937462082366919951682912789656986079991220,2325779134965967427487810008002168938006567536111554301529048698796969115778520822121347163627529767530146944024732879347696758531030
mov $1,2
lpb $0
sub $0,1
add $1,1
bin $1,2
lpe
mov $0,$1
sub $0,1
| 41.307692 | 285 | 0.8473 |
0ecf37baaf290c0516cd647f133e09aae5789247 | 385 | asm | Assembly | oeis/047/A047315.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/047/A047315.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/047/A047315.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A047315: Numbers that are congruent to {2, 4, 5, 6} mod 7.
; Submitted by Jamie Morken(s3)
; 2,4,5,6,9,11,12,13,16,18,19,20,23,25,26,27,30,32,33,34,37,39,40,41,44,46,47,48,51,53,54,55,58,60,61,62,65,67,68,69,72,74,75,76,79,81,82,83,86,88,89,90,93,95,96,97,100,102,103,104,107,109,110,111
mul $0,7
add $0,7
mov $1,$0
sub $0,1
div $1,2
sub $0,$1
div $0,2
mod $1,2
add $1,$0
mov $0,$1
| 25.666667 | 196 | 0.636364 |
1796cfa4da29cb7f6b23beae835beee8dca3fd35 | 938 | asm | Assembly | src/resources/sound_extend.asm | h1romas4/z88dk-msx-template | 8667669ba30f343c59f5ba394ac8be899cc8a8e6 | [
"MIT"
] | 5 | 2021-09-06T15:25:33.000Z | 2022-03-24T06:38:12.000Z | src/resources/sound_extend.asm | h1romas4/z88dk-msx-template | 8667669ba30f343c59f5ba394ac8be899cc8a8e6 | [
"MIT"
] | null | null | null | src/resources/sound_extend.asm | h1romas4/z88dk-msx-template | 8667669ba30f343c59f5ba394ac8be899cc8a8e6 | [
"MIT"
] | null | null | null | ; license:MIT License
; copyright-holders:Hiromasa Tanaka
_sound_extend:
DB 0
DW _sound_extend_trk1
DW _sound_extend_trk2
DW _sound_extend_trk3
_sound_extend_trk1:
DB 201, %10, 200, 14 , 20 , 15 , 200, 0 , 0 , 5 , 200, 14 , 20 , 5 , 200, 0
DB 0 , 5 , 200, 14 , 20 , 5 , 200, 0 , 0 , 5 , 200, 14 , 20 , 5 , 200, 0
DB 0 , 5 , 200, 14 , 20 , 30 , 22 , 30 , 24 , 50
DB 255
_sound_extend_trk2:
DB 201, %10, 200, 14 , 60 , 15 , 200, 0 , 0 , 5 , 200, 14 , 60 , 5 , 200, 0
DB 0 , 5 , 200, 14 , 60 , 5 , 200, 0 , 0 , 5 , 200, 14 , 60 , 5 , 200, 0
DB 0 , 5 , 200, 14 , 60 , 30 , 62 , 30 , 64 , 50
DB 255
_sound_extend_trk3:
DB 201, %10, 200, 14 , 56 , 15 , 200, 0 , 0 , 5 , 200, 14 , 56 , 5 , 200, 0
DB 0 , 5 , 200, 14 , 56 , 5 , 200, 0 , 0 , 5 , 200, 14 , 56 , 5 , 200, 0
DB 0 , 5 , 200, 14 , 56 , 30 , 58 , 30 , 60 , 50
DB 255
| 40.782609 | 84 | 0.476546 |
156f1dde5c14ac69bbbada24a1dd7bd3ed89a969 | 689 | asm | Assembly | programs/oeis/163/A163400.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/163/A163400.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/163/A163400.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A163400: Number of bits in binary expansion of n-th nonprime.
; 1,1,3,3,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9
cal $0,141468 ; Zero together with the nonprime numbers A018252.
mov $2,$0
cmp $2,0
add $0,$2
log $0,2
add $0,1
mov $1,$0
| 62.636364 | 501 | 0.551524 |
1822f1fa24a1463579d7c222d548ee1e7bdae40f | 32,097 | asm | Assembly | Library/Kernel/Local/dateTimeFormat.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 504 | 2018-11-18T03:35:53.000Z | 2022-03-29T01:02:51.000Z | Library/Kernel/Local/dateTimeFormat.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 96 | 2018-11-19T21:06:50.000Z | 2022-03-06T10:26:48.000Z | Library/Kernel/Local/dateTimeFormat.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 73 | 2018-11-19T20:46:53.000Z | 2022-03-29T00:59:26.000Z | COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) GeoWorks 1990 -- All Rights Reserved
PROJECT: PC GEOS
MODULE:
FILE: dateTimeFormat.asm
AUTHOR: John Wedgwood, Nov 28, 1990
ROUTINES:
Name Description
---- -----------
DateTimeFormat Format a date/time generically.
REVISION HISTORY:
Name Date Description
---- ---- -----------
John 11/28/90 Initial revision
DESCRIPTION:
High level formatting routines for dates and times.
$Id: dateTimeFormat.asm,v 1.1 97/04/05 01:17:00 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
Format segment resource
COMMENT @-----------------------------------------------------------------------
FUNCTION: LocalCalcDayOfWeek
DESCRIPTION: Figure the day of the week given its absolute date.
CALLED BY: INTERNAL
TimerSetDateAndTime
PASS:
ax - year (1980 through 2099)
bl - month (1 through 12)
bh - day (1 through 31)
RETURN:
cl - day of the week
DESTROYED:
nothing
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 10/88 Initial version
-------------------------------------------------------------------------------@
LocalCalcDayOfWeek proc far
uses ax, bx, dx, ds
.enter
push cx
mov cx, seg kcode
mov ds, cx ;ds = kcode
assume ds:kcode
sub ax,1904
; add in extra days for leap years
mov dx,ax
shr ax,1
shr ax,1
; if jan or feb and leap year then adjust
test dl,00000011b
jnz noLeap
cmp bl,3
jae noLeap
dec ax ;adjust
noLeap:
add ax,dx
;add in offset for JAN 1, 1904 which was a FRIDAY
add ax,5
; add days
mov cl,bh
clr ch
add ax,cx ;ax = total
clr bh ;bx = months
jmp noInc
dayLoop:
add al,ds:[bx][daysPerMonth-1]
jnc noInc
inc ah
noInc:
dec bx
jnz dayLoop
mov bl,7
div bl ; ah <- DOW (remainder)
pop cx
mov cl, ah
.leave
assume ds:dgroup
ret
LocalCalcDayOfWeek endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
LocalFormatFileDateTime
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Like LocalFormatDateTime, except it works off a FileDate
and a FileTime record
CALLED BY: (GLOBAL)
PASS: ax = FileDate
bx = FileTime
si = DateTimeFormat
es:di = buffer into which to format
RETURN: cx = # of characters in formatted string, not including
null terminator
DESTROYED: nothing
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ardeb 11/ 3/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
LocalFormatFileDateTime proc far
uses ax, bx, dx
.enter
if FULL_EXECUTE_IN_PLACE
EC < push bx, si >
EC < movdw bxsi, esdi >
EC < call ECAssertValidFarPointerXIP >
EC < pop bx, si >
endif
mov dx, bx ; preserve time
;
; Break FileDate into its components
; ax <- year
; bl <- month (1-12)
; bh <- day (1-31)
; cl <- weekday
;
mov bx, ax
and bx, mask FD_MONTH ; month
EC < ERROR_Z DATE_TIME_ILLEGAL_MONTH >
mov cl, offset FD_MONTH
shr bx, cl ; bl <- month
EC < cmp bx, 12 >
EC < ERROR_A DATE_TIME_ILLEGAL_MONTH >
CheckHack <offset FD_DAY eq 0 and width FD_DAY lt 8>
mov bh, al ; bh = day
and bh, mask FD_DAY ; day
EC < ERROR_Z DATE_TIME_ILLEGAL_DAY >
EC < cmp bh, 31 >
EC < ERROR_A DATE_TIME_ILLEGAL_DAY >
CheckHack <offset FD_YEAR + width FD_YEAR eq width FileDate>
mov cl, offset FD_YEAR
shr ax, cl ; ax = DOS year
add ax, 1980 ; ax <- actual year
;
; Break FileTime into its components
; ch <- hours (0-23)
; dl <- minutes (0-59)
; dh <- seconds (0-59)
;
push si
mov si, dx
CheckHack <offset FT_HOUR + width FT_HOUR eq width FileTime>
mov cl, offset FT_HOUR
shr dx, cl
EC < cmp dl, 23 >
EC < ERROR_A DATE_TIME_ILLEGAL_HOUR >
mov ch, dl ; ch = hours
mov dx, si ; minute
andnf dx, mask FT_MIN
mov cl, offset FT_MIN
shr dx, cl ; dl <- minutes
EC < cmp dl, 59 >
EC < ERROR_A DATE_TIME_ILLEGAL_MINUTE >
xchg cx, si
andnf cx, mask FT_2SEC
shl cx, 1
mov dh, cl ; dh <- seconds
EC < cmp dh, 59 >
EC < ERROR_A DATE_TIME_ILLEGAL_SECONDS >
mov cx, si
pop si
call LocalCalcDayOfWeek ; cl <- day of week
call LocalFormatDateTime
.leave
ret
LocalFormatFileDateTime endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
LocalFormatDateTime
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Format a date/time generically.
CALLED BY: Global.
PASS: es:di = place to put the formatted text.
si = DateTimeFormat. (Format enum to use).
ax = Year
bl = Month (1-12)
bh = Day (1-31)
cl = Weekday (0-6)
ch = Hours (0-23)
dl = Minutes (0-59)
dh = Seconds (0-59)
You only need valid information in the registers which will
actually be referenced. The registers used will depend on
the data used as part of the format.
RETURN: es:di = the formatted string.
cx = # of characters in formatted string.
This does not include the NULL terminator at the
end of the string.
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
jcw 11/28/90 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
LocalFormatDateTime proc far
uses ds, si
.enter
if FULL_EXECUTE_IN_PLACE
EC < push bx, si >
EC < movdw bxsi, esdi >
EC < call ECAssertValidFarPointerXIP >
EC < pop bx, si >
endif
;
; Make sure that the generic format passed is valid.
;
EC < cmp si, DateTimeFormat >
EC < ERROR_AE DATE_TIME_ILLEGAL_FORMAT ; Bad format in si. >
EC < call ECDateTimeCheckESDI ; Make sure ptr is OK. >
call LockStringsDS
shl si, 1 ; si <- offset into chunks
add si, offset DateLong ; Always the first one.
mov si, ds:[si] ; ds:si <- formatting string.
call DateTimeFieldFormat ; Do the formatting.
call UnlockStrings
.leave
ret
LocalFormatDateTime endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ECDateTimeCheckESDI
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Check to see if es:di points to a reasonable place.
CALLED BY: Utility.
PASS: es:di = pointer to check.
RETURN: nothing
DESTROYED: nothing, not even flags.
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
jcw 11/28/90 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
if ERROR_CHECK
ECDateTimeCheckESDI proc far
uses cx
.enter
clr cx ; Writing nothing
call ECDateTimeCheckESDIForWrite
.leave
ret
ECDateTimeCheckESDI endp
endif
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ECDateTimeCheckESDIForWrite
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Check a pointer and a number of bytes to make sure that
we can write the data out safely.
This routine is also called to check ds:si to see if it is
a valid pointer to read from, see ECDateTimeCheckDSSI() for
more information.
CALLED BY: Utility
PASS: es:di = pointer.
cx = # of bytes to write.
RETURN: nothing
DESTROYED: nothing, not even flags.
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
jcw 11/28/90 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
if ERROR_CHECK
ECDateTimeCheckESDIForWrite proc far
uses ax, bx, cx, dx, bp, di, si
.enter
pushf ; Save flags too.
;
; If the code dies in ECCheckSegment(), then one of two things is
; possible:
; 1 - es got trashed by one of the internal formatting routines.
; 2 - es was no good when it was passed to a formatting routine.
; I expect that #2 is the most likely.
;
; Keep in mind that if this is called from ECDateTimeCheckDSSI()
; then the pointer we are checking is actually the format string
; that we are reading from.
;
mov ax, es ; ax <- segment to check.
call ECCheckSegment ; Double check es.
push cx, di ; Save # of bytes we expect to write.
;
; Now we want to make sure that di is in the bounds of the block
; of which es is the segment.
;
mov cx, ax ; cx <- segment address.
call MemSegmentToHandle ; cx <- handle.
jc 10$ ; found, continue
pop dx, di ; not found, pop stuff off stack
jmp short skipLockCheck ; and get out (block is kdata, probably)
10$:
mov bx, cx ; bx <- handle.
mov ax, MGIT_FLAGS_AND_LOCK_COUNT
call MemGetInfo
mov cx, ax ; ch <- lock count.
mov ax, MGIT_SIZE
call MemGetInfo
pop dx, di ; dx <- # of bytes we expect to write.
add di, dx ; di <- byte we will have written to.
;
; If the code dies in the next compare, then the formatting code has
; a pointer past the end of the block, and is (in all likelyhood)
; going to attempt to write data there. This can happen if:
; - The buffer allocated to hold the formatted string is not
; large enough. This means the caller didn't allocate enough
; space, or the system constants are incorrect, and didn't
; account for the true size of the formatted text.
; - di got trashed in one of the internal formatting routines.
;
; Keep in mind that if this is called from ECDateTimeCheckDSSI()
; then the pointer we are checking is actually the format string
; that we are reading from.
;
cmp di, ax
ERROR_A DATE_TIME_POINTER_BEYOND_BLOCK_END
;
; If the code dies in the next section, then the formatting code
; is attempting to write to a block which isn't locked.
;
; Keep in mind that if this is called from ECDateTimeCheckDSSI()
; then the pointer we are checking is actually the format string
; that we are reading from.
;
test cl, mask HF_FIXED ; Check for a fixed block.
jnz skipLockCheck
tst ch
ERROR_Z DATE_TIME_POINTER_INTO_UNLOCKED_BLOCK
skipLockCheck:
popf ; Restore flags.
.leave
ret
ECDateTimeCheckESDIForWrite endp
endif
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ECDateTimeCheckDSSI
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Check a pointer to see if we are still reading valid data.
CALLED BY: Utility
PASS: ds:si = pointer to check.
RETURN: nothing
DESTROYED: nothing, not even flags.
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
jcw 11/28/90 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
if ERROR_CHECK
ECDateTimeCheckDSSI proc far
uses es, di
.enter
segmov es, ds
mov di, si
call ECDateTimeCheckESDI
.leave
ret
ECDateTimeCheckDSSI endp
endif
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
LocalGetDateTimeFormat
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Get a date/time format from our resource.
CALLED BY: Global.
PASS: es:di = place to put new format string
si = DateTimeFormat. (Format enum to use).
RETURN: nothing
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
cbh 12/10/90 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
LocalGetDateTimeFormat proc far
uses ax, bx, cx, dx, di, si
.enter
if FULL_EXECUTE_IN_PLACE
EC < push bx, si >
EC < movdw bxsi, esdi >
EC < call ECAssertValidFarPointerXIP >
EC < pop bx, si >
endif
shl si, 1 ; double for offset into chunks
add si, offset DateLong ; start of chunks
call StoreResourceString ; Return the string in es:di.
SBCS < clr al ; store a null terminator >
DBCS < clr ax >
LocalPutChar esdi, ax
.leave
ret
LocalGetDateTimeFormat endp
COMMENT @----------------------------------------------------------------------
ROUTINE: IsLegalFormatChar
SYNOPSIS: Checks to see if character is legal for the given format.
Only checks non-token characters; tokens must be dealt with
another way.
CALLED BY: EXTERNAL
PASS: SBCS:
al - char to check
DBCS:
ax - char to check
si - DateTimeFormat (format enum to use)
RETURN: zero flag clear if legal, set if not.
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Chris 1/ 2/91 Initial version
------------------------------------------------------------------------------@
IsLegalFormatChar proc far
uses ds, si, bx, ax, cx
.enter
EC < cmp si, DateTimeFormat >
EC < ERROR_AE DATE_TIME_ILLEGAL_FORMAT ; Bad format in si. >
SBCS < mov cl, al ; keep character to check in cl >
DBCS < mov cx, ax ; keep character to check in cx >
call LockStringsDS
shl si, 1 ;
add si, offset DateLong ; format string in *ds:si now
mov si, ds:[si] ; dereference
doChar:
LocalGetChar ax, dssi ; get a character.
LocalIsNull ax ; are we done?
jne tryChar ; no, try the character
clr al ; else set the zero flag
jmp exit ; and exit
tryChar:
;
; If this is a token, we'll ignore it, unless it represents
; the delimiter character itself.
;
LocalCmpChar ax, TOKEN_DELIMITER ; is it the delimiter?
jne compareToFormatChar ; no, normal non-token char, do compare
SBCS < add si, 3 >
DBCS < add si, 3*(size wchar) >
SBCS < cmp {word} ds:[si]-3, TOKEN_TOKEN_DELIMITER >
DBCS < cmp {wchar} ds:[si]-6, TOKEN_TOKEN_CHAR_1 >
jne doChar ; if not representing the delimiter char
DBCS < cmp {wchar} ds:[si]-4, TOKEN_TOKEN_CHAR_2 >
DBCS < jne doChar >
; ignore this token altogether,
; else we'll compare to the delimiter
; character (it's still in al)
compareToFormatChar:
SBCS < cmp al, cl ; see if we have a match >
DBCS < cmp ax, cx ; see if we have a match >
jne doChar ; no match, try another one
or al, 0ffh ; else clear the zero flag for a match
exit:
;
; Unlock the resource.
;
call UnlockStrings
.leave
ret
IsLegalFormatChar endp
Format ends
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
LocalSetDateTimeFormat
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Set a date/time format.
CALLED BY: Global.
PASS: es:di = the new format string
si = DateTimeFormat. (Format enum to use).
RETURN: nothing
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
cbh 12/10/90 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ObscureInitExit segment resource
if FULL_EXECUTE_IN_PLACE
CopyStackCodeXIP segment resource
LocalSetDateTimeFormat proc far
mov ss:[TPD_dataBX], handle LocalSetDateTimeFormatReal
mov ss:[TPD_dataAX], offset LocalSetDateTimeFormatReal
GOTO SysCallMovableXIPWithESDI
LocalSetDateTimeFormat endp
CopyStackCodeXIP ends
else
LocalSetDateTimeFormat proc far
FALL_THRU LocalSetDateTimeFormatReal
LocalSetDateTimeFormat endp
endif
LocalSetDateTimeFormatReal proc far
uses ax, cx, dx, si, bp, ds
.enter
push si ; save resource num
push di ; save es:di (our string)
push es
call SetupFormatParameters ; setup parameters
call LocalWriteStringAsData ; write the stuff out
pop es
pop di ; restore es:di, new format str
pop si ; restore format enum
shl si, 1 ;
add si, offset DateLong ;
call SetResourceString ; set the resource string
.leave
ret
LocalSetDateTimeFormatReal endp
COMMENT @----------------------------------------------------------------------
ROUTINE: SetResourceString
SYNOPSIS: Sets a new resource string, over the old one.
CALLED BY: DateTimeInitFormats
PASS: es:di -- buffer containing string to use
cx -- number of characters to store
^lLocalStrings:si -- resource chunk to set
RETURN: nothing
DESTROYED: ax, cx
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Chris 12/12/90 Initial version
------------------------------------------------------------------------------@
SetResourceString proc near uses ds, es, di, si
.enter
if DBCS_PCGEOS
call LocalStringLength ;cx <- # chars w/o NULL
inc cx ;cx <- # chars w/NULL
shl cx, 1 ;cx <- # bytes
else
push di
mov cx, -1
clr al
repne scasb ; find null byte to get size
not cx
pop di
endif
call LockStringsDS ; ax <- resource segment address.
;
; Resize the resource chunk to hold the new string.
;
mov ax, si ; chunk handle in ax
call LMemReAlloc ; resize the resource chunk.
mov si, ds:[si] ; Dereference chunk handle.
;
; Source in es:di now, destination in ds:si. Swap registers and copy.
;
mov ax, es ;
segmov es, ds
mov ds, ax
xchg si, di
DBCS < shr cx, 1 >
LocalCopyNString ; rep movsb/movsw
;
; Unlock the resource.
;
call UnlockStrings ; Unlock the resource.
.leave
ret
SetResourceString endp
ObscureInitExit ends
COMMENT @----------------------------------------------------------------------
ROUTINE: DateTimeInitFormats
SYNOPSIS: Initializes any user-defined formats.
CALLED BY: LocalInit
PASS: nothing
RETURN: nothing
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Chris 12/12/9 Initial version
------------------------------------------------------------------------------@
ObscureInitExit segment resource
DateTimeInitFormats proc near
sub sp, (DATE_TIME_FORMAT_SIZE+1)/2*2 ; leave room for format string
mov di, sp ; have di point to format buffer
segmov es, ss ; have es point to format buffer
mov si, DateTimeFormat-1 ; do all the formats
doFormat:
push si
call SetupFormatParameters ; setup parameters
mov bp, DATE_TIME_FORMAT_SIZE ; max size to read in
call LocalGetStringAsData ; destroys cx
pop si ; restore format
jc doNext ; nothing read, go do next one
push si
shl si, 1 ;
add si, offset DateLong ;
call SetResourceString ; set the resource string
pop si
doNext:
dec si ; next format
jns doFormat ; do another format if not done
add sp, (DATE_TIME_FORMAT_SIZE+1)/2*2 ; restore stack
ret
DateTimeInitFormats endp
COMMENT @----------------------------------------------------------------------
ROUTINE: SetupFormatParameters
SYNOPSIS: Sets up some stuff for reading and writing to .ini files.
CALLED BY: DateTimeSetFormat, DateTimeGetFormat
PASS: es:di -- buffer to read from / write to
si -- format to get info for
RETURN: ds:si -- category ASCIIZ string
cx:dx -- key ASCIIZ string
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Chris 12/10/90 Initial version
------------------------------------------------------------------------------@
SetupFormatParameters proc near
;
; Make sure that the generic format passed is valid.
;
EC < cmp si, DateTimeFormat >
EC < ERROR_AE DATE_TIME_ILLEGAL_FORMAT ; Bad format in si. >
EC < call ECDateTimeCheckESDI ; Make sure ptr is OK. >
;
; Figure out what key to set.
;
segmov ds, cs
assume ds:ObscureInitExit
mov cx, ds
shl si, 1 ; double for word offset
mov dx, ds:formatKeyPointers[si] ; cx:dx holds key
mov si, offset localizationCategory ; ds:si holds category string
ret
SetupFormatParameters endp
assume ds:dgroup
formatKeyPointers nptr \
offset longDate,
offset longCondensedDate,
offset longDateNoWeekday,
offset longCondensedDateNoWeekday,
offset shortDate,
offset zeroPaddedShortDate,
offset monthDayLongDate,
offset monthDayLongDateNoWeekday,
offset monthDayShort,
offset monthYearLong,
offset monthYearShort,
offset yearStr,
offset month,
offset dayStr,
offset weekday,
offset hoursMinsSecsTime,
offset hoursMinsTime,
offset hoursTime,
offset minsSecsTime,
offset hoursMinsSecs24HourTime,
offset hoursMins24HourTime
CheckHack <(length formatKeyPointers) eq (DateTimeFormat)>
localizationCategory char "localization",0
longDate char "longDate", 0
longCondensedDate char "longCondensedDate",0
longDateNoWeekday char "longDateNoWeekday",0
longCondensedDateNoWeekday char "longCondensedDateNoWeekday",0
shortDate char "shortDate",0
zeroPaddedShortDate char "zeroPaddedShortDate",0
monthDayLongDate char "monthDayLongDate",0
monthDayLongDateNoWeekday char "monthDayLongDateNoWeekday",0
monthDayShort char "monthDayShort",0
monthYearLong char "monthYearLong",0
monthYearShort char "monthYearShort",0
yearStr char "year",0
month char "month",0
dayStr char "day",0
weekday char "weekday",0
hoursMinsSecsTime char "hoursMinsSecsTime",0
hoursMinsTime char "hoursMinsTime",0
hoursTime char "hoursTime",0
minsSecsTime char "minsSecsTime",0
hoursMinsSecs24HourTime char "hoursMinsSecs24HourTime",0
hoursMins24HourTime char "hoursMins24HourTime",0
ObscureInitExit ends
idata segment
localTimezone sword -8*60
localDST BooleanByte FALSE
idata ends
Format segment resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
LocalGetTimezone
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Get the timezone information
CALLED BY: (GLOBAL)
PASS: none
RETURN: ax - offset to GMT
bl - TRUE if offset adjusted for Daylight Savings Time
DESTROYED: nothing
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
gene 8/11/99 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
LocalGetTimezone proc far
uses ds
.enter
LoadVarSeg ds
mov ax, ds:localTimezone ;ax <- offset to GMT
mov bl, ds:localDST ;bl <- DST adjusted
.leave
ret
LocalGetTimezone endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
LocalCompareDateTimes
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Compare two normalized date/times
CALLED BY: (GLOBAL)
PASS: ds:si - ptr to TimerDateAndTime #1
es:di - ptr to TimerDateAndTime #2
RETURN: flags set for cmp #1, #2
DESTROYED: none
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
compare date/times in decreasing order of significance:
year
month
day
hour
minute
seconds
REVISION HISTORY:
Name Date Description
---- ---- -----------
gene 8/21/99 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
LocalCompareDateTimes proc far
uses cx, si, di
.enter
;
; for ease of coding, we compare TDAT_dayOfWeek after TDAT_day
; which is OK as they should be equal if and only if TDAT_day
; is equal, too, if the year and month were also equal.
; Assuming they were normalized correctly, of course...
;
mov cx, (size TimerDateAndTime)/(size word)
repe cmpsw
CheckHack <offset TDAT_year eq 0>
CheckHack <(offset TDAT_month) eq (offset TDAT_year)+(size word)>
CheckHack <(offset TDAT_day) eq (offset TDAT_month)+(size word)>
CheckHack <(offset TDAT_dayOfWeek) eq (offset TDAT_day)+(size word)>
CheckHack <(offset TDAT_hours) eq (offset TDAT_dayOfWeek)+(size word)>
CheckHack <(offset TDAT_minutes) eq (offset TDAT_hours)+(size word)>
CheckHack <(offset TDAT_seconds) eq (offset TDAT_minutes)+(size word)>
CheckHack <(size TimerDateAndTime) eq 14>
.leave
ret
LocalCompareDateTimes endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
LocalNormalizeDateTime
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Normalize a date/time, i.e., convert to GMT
CALLED BY: (GLOBAL)
PASS: ds:si - ptr to src TimerDateAndTime
es:di - ptr to dest TimerDateAndTime
ax - offset to GMT
RETURN: none
DESTROYED: none
SIDE EFFECTS:
NOTE: es:di = ds:si is OK, i.e., in place conversion is OK
PSEUDO CODE/STRATEGY:
We use byte-sized math where ever possible (months, days, hours,
and minutes) to save on code size.
seconds = seconds
minutes += timezone%60
hours += timezone/60 + borrow
days += borrow
months += borrow
years += borrow
At each stage, if the result wraps below the minimum value, we
adjust the value to be within range and 'borrow' -1 at the next
stage. If the result wraps above the maximum value, we adjust the
value to be within range and 'borrow' +1 at the next stage.
Note that on 12/31 or 1/1, depending on the time and timezone, the
adjustment can ripple through minutes, hours, the day, the month and
the year.
NOTE: this routine is optimized for small size first, speed second.
REVISION HISTORY:
Name Date Description
---- ---- -----------
gene 8/21/99 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
LocalNormalizeDateTime proc far
uses ax, bx, cx, dx
.enter
;
; convert the offsetGMT into hours (/60) and minutes (%60)
;
mov cl, 60 ;cl <- 60
idiv cl ;al <- tz/60,ah <- tz%60
mov bl, al ;bl <- tz/60
;
; minutes = minutes - timezone%60
;
doMinutes::
mov al, {byte}ds:[si].TDAT_minutes ;al <- minutes
sub al, ah ;al <- minutes - tz%60
mov cx, 59 or (0 shl 8) ;cl <- max, ch <- min
call doNormalization
mov es:[di].TDAT_minutes, ax
;
; hours = hours - timezone/60 + borrow
;
doHours::
mov al, {byte}ds:[si].TDAT_hours ;al <- hours
sub al, bl ;al <- hours -= tz/60
add al, dl ;al <- hours += borrow
mov cx, 23 or (0 shl 8) ;cl <- max, ch <- min
call doNormalization
mov es:[di].TDAT_hours, ax
;
; days = days + borrow
;
doDay::
mov ax, ds:[si].TDAT_year ;ax <- year
mov bl, {byte}ds:[si].TDAT_month ;bl <- month
call LocalCalcDaysInMonth
mov cl, ch ;cl <- days in month
mov ch, 1 ;ch <- min
mov al, {byte}ds:[si].TDAT_day ;al <- day
add al, dl ;al <- day += borrow
cmp al, 1
jl dayBM1 ;branch if <1
call doNormalization
doneDay:
mov es:[di].TDAT_day, ax
;
; month = month + borrow
;
doMonth::
mov al, {byte}ds:[si].TDAT_month ;al <- month
add al, dl ;al <- month += borrow
mov cx, 12 or (1 shl 8) ;cl <- max, ch <- min
call doNormalization
mov es:[di].TDAT_month, ax
;
; year = year + borrow
;
doYear::
mov al, dl ;al <- borrow
cbw ;ax <- borrow
add ax, ds:[si].TDAT_year ;ax <- year += borrow
mov es:[di].TDAT_year, ax
;
; copy seconds -- no adjustment needed
;
mov ax, ds:[si].TDAT_seconds
mov es:[di].TDAT_seconds, ax
;
; calculate the new day of the week; it's easier than adjusting
; as we'd need to check for it wrapping, too.
;
doDOW::
mov ax, es:[di].TDAT_year ;ax <- year
mov bl, {byte}es:[di].TDAT_month ;bl <- month
mov bh, {byte}es:[di].TDAT_day ;bh <- day
call LocalCalcDayOfWeek ;cl <- day of week
clr ch
mov es:[di].TDAT_dayOfWeek, cx
done::
.leave
ret
;
; Pass:
; al - value
; cl - maximum
; ch - minimum
; Return:
; al - adjusted value
; dl - borrow
;
doNormalization:
clr dl ;dl <- assume no borrow
cmp al, ch ;<min?
jge dnMinOK ;branch if >= min
dec dl ;dl <- borrow -1
sub cl, ch ;cl <- range-1
inc cl ;cl <- range
add al, cl
jmp dnMaxOK
dnMinOK:
cmp al, cl ;>max?
jle dnMaxOK ;branch if <= max
inc dl ;dl <- borrow +1
sub cl, ch ;cl <- range-1
inc cl ;cl <- range
sub al, cl
dnMaxOK:
clr ah
retn
;
; days < 1; add days in *previous* month and subtract 1 month
;
dayBM1:
mov dl, -1 ;dl <- borrow -1 month
;
; get the days in the previous month, taking care to wrap the month
; as needed
;
push ax
mov ax, ds:[si].TDAT_year ;ax <- year
mov bl, {byte}ds:[si].TDAT_month ;bl <- month
dec bl ;bl <- month - 1
jnz gotPrevMonth
mov bl, 12
dec ax
gotPrevMonth:
call LocalCalcDaysInMonth ;ch <- days in prev. mth
pop ax
add al, ch ;al <- += days prev. mth
clr ah ;ax <- day
jmp doneDay
LocalNormalizeDateTime endp
Format ends
ObscureInitExit segment resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
LocalSetTimezone
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Set the timezone information
CALLED BY: (GLOBAL)
PASS: ax - offset to GMT
bl - TRUE if offset adjusted for Daylight Savings Time
RETURN: none
DESTROYED: none
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
gene 8/11/99 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
timezoneKey char "timezone", 0
dstKey char "useDST", 0
LocalSetTimezone proc far
uses cx, dx, bp, ds, si
.enter
;
; store the timezone info
;
LoadVarSeg ds, cx
mov ds:localTimezone, ax
mov ds:localDST, bl
;
; save it in the INI file
;
segmov ds, cs, cx
mov si, offset localizationCategory ;ds:si <- category
mov dx, offset timezoneKey ;cx:dx <- key
mov bp, ax ;bp <- offset GMT
call InitFileWriteInteger
clr ax
mov al, bl ;ax <- use DST value
mov dx, offset dstKey ;cx:dx <- key
call InitFileWriteBoolean
.leave
ret
LocalSetTimezone endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
InitTimezone
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: initialize the timezone information
CALLED BY: (GLOBAL)
PASS: none
RETURN: none
DESTROYED: ax, bx, ds
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
gene 8/11/99 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
InitTimezone proc near
uses si, cx, dx
.enter
segmov ds, cs, cx
mov si, offset localizationCategory
mov dx, offset timezoneKey
mov ax, -8*60 ;ax <- assume PST
call InitFileReadInteger
push ax
mov dx, offset dstKey
mov ax, FALSE ;ax <- assume no DST
call InitFileReadBoolean
mov bl, al
ornf bl, ah ;bl <- zero/non-zero
pop ax
LoadVarSeg ds, cx
mov ds:localTimezone, ax ;store offset GMT
mov ds:localDST, bl ;store DST
.leave
ret
InitTimezone endp
ObscureInitExit ends
| 24.785328 | 81 | 0.584167 |
5984bc4b774468edac80d3a8c30f2dbfc11a08d2 | 424 | asm | Assembly | programs/oeis/047/A047565.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/047/A047565.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/047/A047565.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A047565: Numbers that are congruent to {0, 1, 3, 4, 5, 6, 7} mod 8.
; 0,1,3,4,5,6,7,8,9,11,12,13,14,15,16,17,19,20,21,22,23,24,25,27,28,29,30,31,32,33,35,36,37,38,39,40,41,43,44,45,46,47,48,49,51,52,53,54,55,56,57,59,60,61,62,63,64,65,67,68,69,70,71,72,73,75,76,77,78,79,80,81,83,84,85,86,87,88,89,91,92,93,94,95,96,97,99,100,101,102,103,104,105,107,108,109,110,111,112,113
mov $1,8
mul $1,$0
add $1,5
div $1,7
mov $0,$1
| 47.111111 | 305 | 0.641509 |
487285a17f03632f7700f9a632c4b368e52ff004 | 7,553 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_st_/i7-7700_9_0x48_notsx.log_21829_175.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i7-7700_9_0x48_notsx.log_21829_175.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i7-7700_9_0x48_notsx.log_21829_175.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r13
push %r15
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_UC_ht+0xb239, %rbx
nop
and %r15, %r15
movups (%rbx), %xmm0
vpextrq $0, %xmm0, %r12
nop
nop
nop
nop
nop
xor %r13, %r13
lea addresses_WC_ht+0x20b9, %r13
clflush (%r13)
nop
nop
nop
nop
nop
lfence
movb $0x61, (%r13)
sub %r13, %r13
lea addresses_UC_ht+0x14219, %r12
nop
nop
nop
nop
nop
xor $9188, %r10
movb $0x61, (%r12)
nop
and $3324, %rbx
lea addresses_D_ht+0x1b739, %r13
nop
nop
nop
xor %r15, %r15
mov $0x6162636465666768, %rbx
movq %rbx, (%r13)
nop
nop
xor $51217, %r10
lea addresses_D_ht+0x16c39, %rsi
lea addresses_WT_ht+0x116d3, %rdi
nop
nop
nop
nop
nop
sub %r13, %r13
mov $106, %rcx
rep movsq
nop
nop
nop
nop
sub %r13, %r13
lea addresses_D_ht+0x4039, %rsi
lea addresses_WT_ht+0x1a939, %rdi
clflush (%rsi)
nop
nop
nop
nop
sub $8808, %r12
mov $89, %rcx
rep movsq
nop
nop
cmp $27516, %rsi
lea addresses_A_ht+0x1ee39, %rsi
lea addresses_A_ht+0xb1f5, %rdi
nop
nop
and %r12, %r12
mov $25, %rcx
rep movsq
nop
nop
nop
nop
cmp $5948, %rsi
lea addresses_WC_ht+0x8e39, %rsi
lea addresses_WT_ht+0xc22d, %rdi
nop
add %rdx, %rdx
mov $96, %rcx
rep movsl
nop
nop
dec %rcx
lea addresses_WT_ht+0x1639, %r10
nop
nop
nop
nop
xor %rsi, %rsi
movb (%r10), %bl
nop
add $39514, %r10
lea addresses_normal_ht+0x5950, %rsi
lea addresses_normal_ht+0x2639, %rdi
nop
nop
nop
nop
nop
xor %r13, %r13
mov $116, %rcx
rep movsq
nop
nop
nop
nop
nop
sub %rdx, %rdx
lea addresses_UC_ht+0x5ff9, %r12
nop
nop
nop
nop
nop
xor $58267, %r15
mov (%r12), %edi
and $27406, %r15
lea addresses_WC_ht+0x1eb97, %r12
nop
dec %rcx
mov $0x6162636465666768, %r13
movq %r13, %xmm1
movups %xmm1, (%r12)
nop
inc %rdx
lea addresses_D_ht+0x3d39, %rsi
lea addresses_normal_ht+0x4bd7, %rdi
nop
nop
nop
nop
xor %r13, %r13
mov $10, %rcx
rep movsl
add $17798, %rcx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r15
pop %r13
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %r8
push %rdx
push %rsi
// Store
lea addresses_WT+0x16b39, %r8
add $57639, %rdx
movw $0x5152, (%r8)
nop
nop
nop
nop
cmp %r13, %r13
// Faulty Load
lea addresses_WC+0xce39, %r13
cmp $53596, %rsi
mov (%r13), %r11
lea oracles, %r8
and $0xff, %r11
shlq $12, %r11
mov (%r8,%r11,1), %r11
pop %rsi
pop %rdx
pop %r8
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': True, 'NT': True, 'AVXalign': False, 'size': 16, 'type': 'addresses_WC', 'congruent': 0}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_WT', 'congruent': 8}, 'OP': 'STOR'}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': True, 'AVXalign': False, 'size': 8, 'type': 'addresses_WC', 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_UC_ht', 'congruent': 9}}
{'dst': {'same': True, 'NT': False, 'AVXalign': True, 'size': 1, 'type': 'addresses_WC_ht', 'congruent': 6}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_UC_ht', 'congruent': 5}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': True, 'size': 8, 'type': 'addresses_D_ht', 'congruent': 8}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 1, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'congruent': 8, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 5, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'congruent': 2, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_A_ht'}}
{'dst': {'same': True, 'congruent': 2, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_WC_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_WT_ht', 'congruent': 11}}
{'dst': {'same': False, 'congruent': 10, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 0, 'type': 'addresses_normal_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': True, 'AVXalign': False, 'size': 4, 'type': 'addresses_UC_ht', 'congruent': 5}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_WC_ht', 'congruent': 1}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 0, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': True, 'congruent': 8, 'type': 'addresses_D_ht'}}
{'38': 21829}
38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38
*/
| 34.022523 | 2,999 | 0.658149 |
d5ab4dd90f8fe5876cd03c255def38cc17732258 | 7,188 | asm | Assembly | Transynther/x86/_processed/NONE/_zr_/i7-8650U_0xd2.log_21829_81.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_zr_/i7-8650U_0xd2.log_21829_81.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_zr_/i7-8650U_0xd2.log_21829_81.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r12
push %r14
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x2181, %rsi
nop
nop
nop
nop
lfence
movl $0x61626364, (%rsi)
nop
xor $50062, %rbp
lea addresses_WC_ht+0x193e0, %r10
nop
nop
nop
nop
nop
dec %rbp
mov (%r10), %r12w
nop
nop
dec %r14
lea addresses_A_ht+0x170a0, %rsi
lea addresses_normal_ht+0x1ac4, %rdi
clflush (%rdi)
nop
nop
nop
cmp %rbp, %rbp
mov $68, %rcx
rep movsq
nop
nop
nop
nop
nop
inc %r11
lea addresses_WC_ht+0x8838, %rsi
lea addresses_normal_ht+0x12c44, %rdi
nop
nop
nop
nop
add %r14, %r14
mov $3, %rcx
rep movsq
xor %rdi, %rdi
lea addresses_D_ht+0xa748, %rsi
lea addresses_WC_ht+0x7495, %rdi
nop
nop
nop
xor %r14, %r14
mov $85, %rcx
rep movsb
nop
nop
nop
dec %rbp
lea addresses_UC_ht+0x66a8, %rsi
lea addresses_UC_ht+0x1b2c0, %rdi
nop
sub $34166, %r12
mov $34, %rcx
rep movsw
nop
nop
nop
nop
nop
xor %r12, %r12
lea addresses_D_ht+0xce40, %rsi
lea addresses_WT_ht+0x1e3d2, %rdi
clflush (%rsi)
nop
cmp $62934, %rbp
mov $110, %rcx
rep movsq
nop
nop
nop
nop
and %r14, %r14
lea addresses_A_ht+0x10e40, %rsi
lea addresses_D_ht+0x11a40, %rdi
clflush (%rsi)
nop
nop
nop
nop
nop
cmp %r12, %r12
mov $115, %rcx
rep movsq
nop
add $59084, %rsi
lea addresses_UC_ht+0x9e40, %r12
clflush (%r12)
nop
nop
nop
nop
sub $64148, %rcx
mov $0x6162636465666768, %r14
movq %r14, %xmm7
vmovups %ymm7, (%r12)
nop
nop
nop
sub %rsi, %rsi
lea addresses_WC_ht+0x2440, %rbp
nop
nop
add %r14, %r14
mov (%rbp), %ecx
nop
nop
nop
cmp %r11, %r11
lea addresses_normal_ht+0x9240, %rsi
lea addresses_A_ht+0xcbd0, %rdi
nop
sub %r14, %r14
mov $28, %rcx
rep movsl
nop
nop
xor $21730, %rdi
lea addresses_D_ht+0x15840, %r12
nop
nop
nop
nop
nop
cmp %r10, %r10
movw $0x6162, (%r12)
cmp %r10, %r10
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r14
pop %r12
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r14
push %r8
push %rax
push %rdi
push %rsi
// Faulty Load
lea addresses_UC+0xba40, %r14
clflush (%r14)
nop
nop
nop
nop
sub $15390, %rsi
movups (%r14), %xmm6
vpextrq $1, %xmm6, %r8
lea oracles, %rdi
and $0xff, %r8
shlq $12, %r8
mov (%rdi,%r8,1), %r8
pop %rsi
pop %rdi
pop %rax
pop %r8
pop %r14
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_UC', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_UC', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 2, 'AVXalign': False, 'NT': True, 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 1, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 1, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 0, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 1, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 11, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 4, 'AVXalign': True, 'NT': False, 'congruent': 6, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 4, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 34.392344 | 2,999 | 0.66138 |
8e7d684acab8199da3ce30c6c3fd288b4ab467e2 | 5,313 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_st_zr_/i7-7700_9_0x48.log_21829_953.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_st_zr_/i7-7700_9_0x48.log_21829_953.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_st_zr_/i7-7700_9_0x48.log_21829_953.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r15
push %rdi
lea addresses_D_ht+0x15aa6, %r11
nop
nop
nop
nop
and %r13, %r13
mov (%r11), %r15d
nop
nop
nop
dec %rdi
pop %rdi
pop %r15
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r14
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
// Store
lea addresses_UC+0xdd8e, %rbx
and $59878, %r14
movl $0x51525354, (%rbx)
cmp $25267, %r14
// Store
lea addresses_A+0x17efc, %r12
nop
nop
nop
nop
xor $10443, %rcx
mov $0x5152535455565758, %rdi
movq %rdi, %xmm4
movups %xmm4, (%r12)
cmp %rax, %rax
// Store
lea addresses_RW+0x1b98e, %rdi
clflush (%rdi)
nop
sub $47803, %rbx
mov $0x5152535455565758, %r14
movq %r14, (%rdi)
nop
nop
nop
nop
nop
and %rax, %rax
// Store
lea addresses_UC+0xe8c6, %rdi
nop
nop
add $21031, %rsi
movw $0x5152, (%rdi)
nop
nop
nop
nop
xor $31717, %r14
// Store
mov $0x6dc9e0000000018e, %r12
nop
nop
nop
sub $42326, %rdi
mov $0x5152535455565758, %rax
movq %rax, %xmm4
movntdq %xmm4, (%r12)
and %r12, %r12
// Faulty Load
mov $0x61704d000000098e, %r12
and $16088, %rdi
mov (%r12), %r14d
lea oracles, %r12
and $0xff, %r14
shlq $12, %r14
mov (%r12,%r14,1), %r14
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r14
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'AVXalign': False, 'congruent': 0, 'size': 2, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC', 'AVXalign': True, 'congruent': 9, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A', 'AVXalign': False, 'congruent': 1, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_RW', 'AVXalign': False, 'congruent': 9, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC', 'AVXalign': False, 'congruent': 2, 'size': 2, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_NC', 'AVXalign': False, 'congruent': 10, 'size': 16, 'same': False, 'NT': True}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'AVXalign': False, 'congruent': 0, 'size': 4, 'same': True, 'NT': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 2, 'size': 4, 'same': False, 'NT': True}}
{'58': 21802, '00': 27}
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58
*/
| 43.54918 | 2,999 | 0.654997 |
9abfb7653987905eaa2ed713ff1fca1f418998c3 | 8,063 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_1239.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_1239.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_1239.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r14
push %r15
push %r8
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_normal_ht+0x16e7f, %r11
nop
sub %r15, %r15
mov $0x6162636465666768, %rdx
movq %rdx, (%r11)
nop
nop
nop
nop
nop
cmp $21351, %rbp
lea addresses_D_ht+0x1b82f, %r14
nop
nop
nop
nop
dec %r13
movw $0x6162, (%r14)
nop
nop
nop
nop
xor %r11, %r11
lea addresses_WC_ht+0x17bbb, %r11
nop
nop
nop
nop
dec %r13
and $0xffffffffffffffc0, %r11
movntdqa (%r11), %xmm1
vpextrq $0, %xmm1, %rbp
add %r14, %r14
lea addresses_normal_ht+0x9f21, %rsi
lea addresses_A_ht+0xa7cd, %rdi
nop
nop
nop
nop
add $22078, %r15
mov $40, %rcx
rep movsw
nop
nop
cmp $30481, %r15
lea addresses_D_ht+0x5fff, %rdi
nop
nop
xor $37368, %r14
movl $0x61626364, (%rdi)
nop
nop
nop
nop
sub %r11, %r11
lea addresses_A_ht+0x148ff, %rsi
lea addresses_A_ht+0x136df, %rdi
nop
nop
nop
nop
cmp $4940, %rdx
mov $75, %rcx
rep movsw
nop
nop
nop
nop
nop
sub %r14, %r14
lea addresses_UC_ht+0x13e5f, %rdx
sub $10912, %r13
movw $0x6162, (%rdx)
nop
nop
nop
nop
add $20820, %r8
lea addresses_D_ht+0x7f9f, %rsi
lea addresses_normal_ht+0x98df, %rdi
nop
nop
nop
add $11844, %r13
mov $57, %rcx
rep movsl
nop
nop
nop
nop
inc %r8
lea addresses_normal_ht+0xfa5f, %r11
sub $9178, %r8
movl $0x61626364, (%r11)
nop
nop
add %r15, %r15
lea addresses_normal_ht+0x10f9f, %r11
nop
nop
nop
dec %r15
movb (%r11), %r13b
nop
add $11193, %rbp
lea addresses_normal_ht+0x1d45f, %rsi
lea addresses_WT_ht+0x3c1f, %rdi
xor %r13, %r13
mov $2, %rcx
rep movsw
nop
nop
nop
and $56128, %rcx
lea addresses_D_ht+0x17f9f, %rsi
lea addresses_D_ht+0xe2bf, %rdi
nop
dec %r8
mov $31, %rcx
rep movsl
nop
nop
nop
dec %r8
lea addresses_A_ht+0xf9f, %rdi
nop
nop
lfence
movw $0x6162, (%rdi)
nop
nop
nop
dec %rsi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %r8
pop %r15
pop %r14
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r14
push %r9
push %rax
push %rcx
push %rsi
// Load
lea addresses_D+0x1cb9f, %rcx
clflush (%rcx)
nop
add %rsi, %rsi
mov (%rcx), %r10w
nop
nop
nop
nop
nop
add $50720, %r14
// Store
lea addresses_A+0x1037f, %r10
nop
nop
nop
nop
nop
cmp %rsi, %rsi
mov $0x5152535455565758, %rcx
movq %rcx, (%r10)
and $10326, %rsi
// Store
lea addresses_D+0x11c03, %rsi
nop
nop
nop
sub %r11, %r11
mov $0x5152535455565758, %r9
movq %r9, %xmm0
movaps %xmm0, (%rsi)
nop
nop
nop
nop
nop
cmp %rsi, %rsi
// Faulty Load
lea addresses_US+0x1679f, %r9
nop
dec %rax
mov (%r9), %r14d
lea oracles, %r11
and $0xff, %r14
shlq $12, %r14
mov (%r11,%r14,1), %r14
pop %rsi
pop %rcx
pop %rax
pop %r9
pop %r14
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'AVXalign': False, 'congruent': 0, 'size': 16, 'same': True, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D', 'AVXalign': False, 'congruent': 10, 'size': 2, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A', 'AVXalign': True, 'congruent': 4, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D', 'AVXalign': True, 'congruent': 2, 'size': 16, 'same': False, 'NT': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'AVXalign': False, 'congruent': 0, 'size': 4, 'same': True, 'NT': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 5, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 3, 'size': 2, 'same': True, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 1, 'size': 16, 'same': False, 'NT': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 5, 'size': 4, 'same': True, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 5, 'size': 2, 'same': True, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 5, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 9, 'size': 1, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 10, 'size': 2, 'same': False, 'NT': False}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 31.869565 | 2,999 | 0.657944 |
578680a5fedccfc8b2e434905ca6f7fafc3bd627 | 329 | asm | Assembly | programs/oeis/097/A097814.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/097/A097814.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/097/A097814.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A097814: E.g.f. exp(3x)/(1-3x).
; 1,6,45,432,5265,79218,1426653,29961900,719092161,19415508030,582465299949,19221355075464,691968783248145,26986782548271978,1133444867032206045,51005019016463620932,2448240912790296851457
add $0,1
mov $2,1
lpb $0
sub $0,1
mul $2,3
add $1,$2
mul $1,3
mul $2,$0
lpe
div $1,9
mov $0,$1
| 21.933333 | 188 | 0.729483 |
010f5024608e6c79944b8bf0cf3a6704125d054d | 673 | asm | Assembly | oeis/099/A099902.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/099/A099902.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/099/A099902.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A099902: Multiplies by 2 and shifts right under the XOR BINOMIAL transform (A099901).
; Submitted by Jon Maiga
; 1,3,7,11,23,59,103,139,279,827,1895,2955,5655,14395,24679,32907,65815,197435,460647,723851,1512983,3881019,6774887,9142411,18219287,54002491,123733863,192940939,369104407,939538491,1610637415,2147516555,4295033111,12885099323,30065231719,47245364107,98785760791,253406951483,442388406375,597009596555,1198314094871,3551991956283,8139086759783,12691821300619,24288409163287,61826993764411,105997108535399,141336636326027,282668977684759,847963983381307,1978433735690087,3108869128260491
mov $2,$0
mul $2,2
seq $2,101624 ; Stern-Jacobsthal numbers.
mov $0,$2
| 74.777778 | 487 | 0.845468 |
8ea3241bece0a483a820f5a6a8bf99b147d99b6c | 164,329 | asm | Assembly | intel52.asm | bencz/IntelAssembler | 4270148a4122a11f0b1ff0cb47b6914530e01056 | [
"Apache-2.0"
] | null | null | null | intel52.asm | bencz/IntelAssembler | 4270148a4122a11f0b1ff0cb47b6914530e01056 | [
"Apache-2.0"
] | null | null | null | intel52.asm | bencz/IntelAssembler | 4270148a4122a11f0b1ff0cb47b6914530e01056 | [
"Apache-2.0"
] | null | null | null | %cpx 100h
pushad
mov ah,ptext ;introduction text
mov dx,intro
mov bx,1
int 21h
mov bx,cs ;get size
mov ds,bx ;prepair
mov ax,cs:[2] ;get exact
sub ax,bx
dec ax
cmp ax,5000h ;320K (64 program,64 insts,64 labels,64 data)
jae short memgood ;64K direct
mov ah,ptext
mov dx,memerr
int 21h
jmp near ending
memgood: mov ax,cs
mov ds,ax ;make sure..
add ax,1000h
mov fs,ax ;create inst
add ax,1000h
mov es,ax ;create labels
add ax,1000h
mov gs,ax ;set up data area
add ax,1000h
mov [direct_segment],ax ;segment for Direct information
cmp byte ptr [129],0 ;anything in the line segment?
je near proguse2
cmp byte ptr [129],13 ;anything in the line segment?
je near proguse2
mov si,files ;prepair output
mov bx,130 ;get location start
xor cx,cx ;clear
jmp short chalk_cheat ;start in the middle
chalkboard_0: inc bx ;start (at the next letter)
cmp byte ptr [bx]," " ;space?
jne short chalkboard_1
mov byte ptr [bx],0 ;set up null (ending)
inc bx ;fix, first letter, not null
chalk_cheat: mov [si],bx ;save (also middle)
dec bx
add si,2 ;move up 2
inc cx ;number count
chalkboard_1: cmp byte ptr [bx],13 ;ending
je short chalkboard_2 ;see if ending
jmp short chalkboard_0 ;no? Start
chalkboard_2: mov byte ptr [bx],0 ;set up null (ending)
cmp cx,2
jb near proguse2 ;see if enough parts
cmp cx,3
jb short chalkboard_7
mov bx,files ;prepair for working
mov si,[bx+4] ;get start
chalkboard_3: cmp byte ptr [si],"M"
jne short chalkboard_4
mov byte ptr [fst],2 ;make?
chalkboard_4: cmp byte ptr [si],"F"
jne short chalkboard_5
mov byte ptr [fst],1 ;use?
chalkboard_5: cmp byte ptr [si],"D"
jne short chalkboard_5A
mov byte ptr [dbg],1 ;debug text (screen)?
chalkboard_5A: cmp byte ptr [si],"O"
jne short chalkboard_5B
mov byte ptr [optimize],1 ;optimize?
chalkboard_5B: cmp byte ptr [si],"Q"
jne short chalkboard_5C
mov byte ptr [optimize],2 ;Quick?
mov byte ptr [loopback],3 ;skip out, make smaller loop
chalkboard_5C: cmp byte ptr [si],"T"
jne short chalkboard_6
mov byte ptr [tmpkeep],1 ;optimize?
chalkboard_6: cmp byte ptr [si],0 ;ending?
je short chalkboard_7
inc si
jmp short chalkboard_3
chalkboard_7:
;enough parts.. start here
mov dx,gs ;set up
call near getline_clear ;prepairs 'getline' as required (1 segment)
mov dx,es ;set up
call near getline_clear ;prepairs 'getline' using LABEL segment
;until the includes are complete..
mov ah,open ;paste in for testing, need to add the rest here
mov al,readonly ;later on
mov dx,Instruction_set
int 21h
jc short nosets ;check for error, if so, clear
push ax
mov [file1],ax
mov bx,ax ;get file handle
push fs ;set up segment
pop ds
mov ah,read ;read it
mov cx,-1 ;full size
xor dx,dx ;at 0
int 21h
push cs
pop ds ;restore segments
mov bx,[file1] ;close instruction set
mov ah,close ;unneeded now
int 21h
jmp short issets ;skip past the clearing.
;prepair debug window now..
nosets: mov dx,err4 ;error with set file
mov ah,ptext ;print it out
int 21h
push fs ;set up segment
pop ds
xor cx,cx ;clear out counter
mov ax,cx ;clear information
preclear_set:mov si,cx
mov ds:[si],al ;clear it
loop short preclear_set
push cs
pop ds ;return DS to proper segment
;check for setfiles now :)
mov ax,internal_set_L ;get number (if exsists)
cmp ax,0
je short issets
mov ah,ptext
mov dx,err5 ;tell redirect
int 21h
mov si,internal_set ;ok, get source
xor di,di ;locate destination
mov cx,internal_set_L ;put in length
internalset_loop:mov al,cs:[si] ;get byte
mov fs:[di],al ;write byte
inc si
inc di ;increase
loop short internalset_loop
;set check added here
issets: mov bx,fs:[ident_verset] ;skip past date
cmp byte ptr fs:[bx+4],Ver_Major;check major
ja short issets_vererr
cmp byte ptr fs:[bx+5],Ver_Minor;check minor
ja short issets_vererr
cmp byte ptr fs:[bx+6],Ver_Revision ;check revision
ja short issets_vererr
jmp short issets_vernoerr
issets_vererr:mov ah,ptext ;print on screen
mov dx,verseterr ;the error
mov bx,1 ;screen? (Making sure)
int 21h ;go do it
issets_vernoerr:
mov dx,debugfile ;file name 'debug'
mov ah,create ;create it
mov al,writeonly ;write only
mov cx,0 ;clear attributes
int 21h
jnc short debug_txt
mov byte ptr [file3],1 ;since error set up screen
mov byte ptr [dbg],0 ;will be screened instead
debug_txt:mov [file3],ax
mov bx,files ;prepair for working
;kill all comments
;kill spaces
mov ah,open ;open source file
mov dx,[bx]
mov al,readonly ;readonly
int 21h
jnc short beginning1 ;quit if error
mov ah,ptext ;tell error
mov bx,1 ;to the screen
mov dx,err ;the error message
int 21h
jmp near ending
beginning1: mov [file1],ax ;save handle
mov ah,create ;open temporary file
xor cx,cx
mov dx,tempfile1 ;second file
int 21h
jnc short beginning2 ;quit if error
mov ah,ptext ;tell error
mov bx,1
mov dx,err3
int 21h
call near closefirst
jmp near proguse2
beginning2: mov [file2],ax ;save handle
;ok, this is where 'includes' are placed.
;;some bug is here, so for sakes of simpleness, this SHOULD fix it
;pushad
beg_inc:mov bx,cs:[file1] ;from read
mov dx,gs
call near getline ;get 1 line
push gs ;set information DATA
pop ds
;ok, now the fun parts :)
cmp cx,0 ;check end of file
je near beg_inc_found
;write it first
xor dx,dx ;0 location
mov ah,write ;write it out
mov bx,cs:[file2] ;output
int 21h ;write it
;now check for anything odd :P
xor bx,bx ;clear pointer
eg_inc_maybe:push bx ;backup start
cmp byte [bx],"*" ;check full
jne short beg_inc_notfull
;ok, seek out ending of file name
mov dx,bx
inc dx
mov cx,ax ;limit (bytes written :P)
beg_inc_full_nsp:cmp byte [bx],13 ;ending check?
je short beg_inc_full_sp
cmp byte [bx],10 ;ending check
je short beg_inc_full_sp
inc bx ;onwards
loop short beg_inc_full_nsp ;oh boy, a limit :P
jmp short beg_inc_notfull ;skip out
beg_inc_full_sp:mov byte [bx],0 ;put null pointer on
mov ah,open ;open file
xor cx,cx ;not sure
mov al,readonly ;read it only (DX SET)
int 21h
jnc short beg_inc_fullnerr ;on error, just skip it
mov byte [bx],":" ;put up basic message
mov word [bx+1],"Mi"
mov word [bx+3],"ss"
mov word [bx+5],"in"
mov word [bx+7],"g."
mov word [bx+9],0A0Dh
mov byte [bx+11],"$"
mov ah,ptext
int 21h ;print message
jmp short beg_inc_notfull
beg_inc_fullnerr:mov cs:[file4],ax ;write out handle
beg_inc_full_read:mov bx,cs:[file4] ;from read
mov dx,es
call near getline ;get 1 line
push es ;set information LABEL
pop ds ;for this include
cmp cx,0 ;check end of file
je short beg_inc_full_done
mov ah,write ;ok write to file
mov bx,cs:[file2] ;to temp file
mov dx,0 ;starting 0 (assumed)
int 21h ;assumed data isn't as nice to work with
jmp short beg_inc_full_read
beg_inc_full_done:mov ah,close ;close include file
mov bx,cs:[file4] ;Include handle
int 21h ;do it
push gs ;return now
pop ds
beg_inc_notfull:pop bx ;return start
;check other includes..
cmp word [bx],"<I" ;includes part
je short beg_inc_found
cmp word [bx],"<i" ;other check (lowercase)
jne near beg_inc
beg_inc_found:cmp byte cs:[includez],1;check if done this before
je near beg_inc_next ;if so, had to be through EOF executed, END
cmp cx,0 ;check end of file?
je short beg_inc_nosave
push cx
mov ax,PointerCur ;prepair cursor save
xor dx,dx
mov cx,dx ;clear pointer
mov bx,cs:[file1] ;get pointer
int 21h ;go get it
pop cx ;return count (EOF?)
;DX is low?
mov bx,gs:[gleft] ;get buffer size
sub bx,gs:[gstat] ;gone through already
sub ax,bx ;back up remainder in buffer
sbb dx,0 ;minus carry
push dx ;preserve pointer
push ax
;probably want to clean it out..
mov dx,es
call getline_clear ;ok, cleared this
mov dx,gs
call getline_clear ;cleared that
beg_inc_nosave:push cx ;save number (Tells later to resume, or end)
;ok, start at beginning of file again, look only for # and !'s :)
mov ax,pointerSof
xor cx,cx
xor dx,dx ;start at beginning
mov bx,cs:[file1]
int 21h ;point it
mov word cs:[file4],0 ;clear handle, special
beg_inc_pt2:mov bx,cs:[file1] ;from read
mov dx,gs
call near getline ;get 1 line
push gs ;set information DATA
pop ds
cmp cx,0
je near beg_inc_pt2_end
;ok, now for 1 of 2 functions :)
xor bx,bx ;clear
cmp byte [bx],"#" ;look for include
jne short beg_inc_pt2_notinc
push cx
;ok, the easy part..
cmp word cs:[file4],0 ;check for open file
je short beg_inc_pt2_inc1
mov ah,close ;close this file
mov bx,cs:[file4] ;since it's all done
int 21h ; :)
beg_inc_pt2_inc1:pop cx ;limit, length
beg_inc_pt2_inc_nsp:cmp byte [bx],13 ;ending check?
je short beg_inc_pt2_inc_sp
cmp byte [bx],10 ;ending check
je short beg_inc_pt2_inc_sp
inc bx ;onwards
loop short beg_inc_pt2_inc_nsp ;oh boy, a limit :P
jmp short beg_inc_pt2_notinc ;skip out
beg_inc_pt2_inc_sp:mov byte [bx],0 ;put null pointer on
mov ah,open ;open file
xor cx,cx ;not sure
mov al,readonly ;read it only (DX SET)
mov dx,cx ;put up pointer
inc dx ;fix and ready
int 21h
jnc short beg_inc_pt2_inc_nerr ;on error, just skip it
mov byte [bx],":" ;put up basic message
mov word [bx+1],"Mi"
mov word [bx+3],"ss"
mov word [bx+5],"in"
mov word [bx+7],"g."
mov word [bx+9],0A0Dh
mov byte [bx+11],"$"
mov ah,ptext
int 21h ;print message
jmp short beg_inc_pt2_notinc
beg_inc_pt2_inc_nerr:mov cs:[file4],ax ;write out handle
;that was easy :)
beg_inc_pt2_notinc:cmp byte [bx],"!" ;look for include
jne near beg_inc_pt2_notfun
;now the HARD part..
cmp word cs:[file4],0 ;not open
je near beg_inc_pt2_notfun ;and skip
pushad ;save all, for simpleness
;limit the size of the compare first.. find the first space.
;bx should be 0 still
;cx is set
beg_inc_pt2_sp:cmp byte [bx],13 ;find space
je short beg_inc_pt2_fsp
cmp byte [bx],10 ;find space
je short beg_inc_pt2_fsp
cmp byte [bx]," " ;find space
je short beg_inc_pt2_fsp
inc bx
loop short beg_inc_pt2_sp
jmp short beg_inc_pt2_done ;skip out
beg_inc_pt2_fsp:mov si,bx ;save counter
mov dx,es
call near getline_clear
mov ax,pointersof ;start at beginning of file
xor cx,cx ;cleared
xor dx,dx
mov bx,cs:[file4] ;handle of the include file
int 21h ;do it
xor di,di ;counter, special
beg_inc_pt2_inc2:mov bx,cs:[file4] ;from read, label
mov dx,es
call near getline ;get 1 line
inc di ;line counter
push es ;set information DATA
pop ds
cmp cx,0 ;anything in line?
je short beg_inc_pt2_donez ;skip out
mov cx,si ;set limit
xor bx,bx ;clear pointer
beg_inc_pt2_inc3:mov al,es:[bx] ;get byte
cmp gs:[bx],al ;compare it
jne short beg_inc_pt2_inc2
inc bx ;increase check
loop short beg_inc_pt2_inc3 ;loop the compare
;if you get this far, it all matched enough.
;we should be on a space..
inc bx ;fix position
mov dx,es ;put segment up
mov si,bx ;put information in
call near getnum ;grab number
push ax ;save number
beg_inc_pt2_inc4:cmp byte [bx]," " ;find separator
je short beg_inc_pt2_inc5
inc bx ;mov pointer
jmp short beg_inc_pt2_inc4 ;continue on
beg_inc_pt2_inc5:inc bx ;fix from space
mov si,bx ;put information in
call near getnum ;grab number
pop bp ;set number up
mov si,ax ;set up number
;ok, bp contains start, si contains finnish
beg_inc_pt2_inc6:mov bx,cs:[file4] ;from read, label
mov dx,es
call near getline ;get 1 line
inc di ;line counter
push es ;set information DATA
pop ds
cmp cx,0 ;anything in line?
je short beg_inc_pt2_done ;skip out
cmp di,bp ;low enough?
jb short beg_inc_pt2_inc6
cmp di,si ;find ending
ja short beg_inc_pt2_done
mov bx,cs:[file2] ;output to temp
;cx is here already
xor dx,dx ;pointer
mov ah,write ;write it
int 21h
jmp short beg_inc_pt2_inc6 ;loop till done
beg_inc_pt2_donez:mov ah,ptext ;print text
push gs
pop ds
mov byte [bx],":" ;put up basic message
mov word [bx+1],"Un"
mov word [bx+3],"kn"
mov word [bx+5],"ow"
mov word [bx+7],"n "
mov word [bx+9],"Fu"
mov word [bx+11],"nc"
mov word [bx+13],"ti"
mov word [bx+15],"on"
mov word [bx+17],0A0Dh
mov byte [bx+19],"$"
mov dx,1 ;starting at
int 21h ;print
beg_inc_pt2_done:popad ;return all.. whatever :P
beg_inc_pt2_notfun:jmp near beg_inc_pt2 ;ok, next line
beg_inc_pt2_end:pop cx ;see if anything left
cmp cx,0
je short beg_inc_next ;ok, skip out
;No? Ok, return to previous spot..
pop dx
pop cx ;pull out pointer info
mov ax,pointersof ;Start of file
mov bx,cs:[file1] ;of temp file
int 21h ;and continue where we left off at..
mov byte cs:[includez],1;so we don't put 2 of everything..
jmp near beg_inc ;back to getting lines..
;at this point, let's move onto the rest of the process (temp to temp)
beg_inc_next:push cs ;prepair segments
pop ds ;closes both files now
call near closeboth ;close both temp files
cmp word cs:[file4],0 ;check for open file
je short beg_inc_next_file
mov ah,close ;close this file
mov bx,cs:[file4] ;since it's all done
int 21h ; :)
beg_inc_next_file:mov ah,open ;open source file
mov dx,tempfile1
xor cx,cx
mov al,readonly ;readonly
int 21h
jnc short beg_inc_x1 ;quit if error
mov ah,ptext ;tell error
mov bx,1 ;to the screen
mov dx,err3 ;the error message
int 21h
jmp near ending
beg_inc_x1: mov [file1],ax ;save handle
cmp byte [optimize],1 ;check if the loops are to be done?
jne short beg_inc_notop
mov bx,ax ;and handle
mov ax,pointereof;get length
xor cx,cx
xor dx,dx ;clear pointer
int 21h ;ok, has length
push ax
push dx
mov ax,pointersof;start of file
mov bx,[file1]
xor cx,cx
xor dx,dx
int 21h ;ok, at beginning again
xor eax,eax
pop ax ;get high order
shl eax,16 ;mov register
pop ax ;ok, saved it all
xor edx,edx
mov ecx,10000 ;10,000 for check (for every loop)
div ecx
cmp word ax,255 ;override size
jb short beg_inc_notop1
mov word ax,255 ;max size set
beg_inc_notop1: cmp ax,loopback_minimum ;check for minimum
jb short beg_inc_notop ;failed minimum, and stays where it is
beg_inc_notop2:mov [loopback],ax ;save number for reloops
beg_inc_notop:mov ah,create ;open temporary file
xor cx,cx
mov dx,tempfile2 ;second file
int 21h
jnc short beg_inc_x2 ;quit if error
mov ah,ptext ;tell error
mov bx,1
mov dx,err3
int 21h
call near closefirst
jmp near proguse2
beg_inc_x2: mov [file2],ax ;save handle
;since ucase only has to be used once, let's do it here..
;job, open up, capitalize everything (except for in "'s)
beginning3: mov bx,cs:[file1] ;from read
mov dx,gs
call near getline ;get 1 line
push gs ;set information DATA
pop ds
cmp cx,0
je near beginning4
cmp cx,2
jbe short beginning3 ;sift out empty lines
;ok, since i had trouble with this ALREADY it will find empty lines AGAIN
xor bx,bx ;prepair (first)
mov dx,bx
BLANKITY0:cmp byte ptr [bx],10 ;ending check
je short BLANKITY1
cmp byte ptr [bx],13 ;skip
je short BLANKITY2
cmp byte ptr [bx]," " ;space check
je short BLANKITY2
inc dx ;fail count
BLANKITY2:inc bx
jmp short BLANKITY0 ;ok, skip the number, just go on
BLANKITY1:cmp dx,0
je short beginning3 ;line SKIPPED because it's all spaces
mov bx,0 ;check first letter
cmp byte ptr [bx],"!"
je short beginning3
cmp byte ptr [bx],"#"
je short beginning3 ;includes delete
cmp byte ptr [bx],"*"
je short beginning3
cmp byte ptr [bx],59
je short beginning3 ;skip whole lines of comments
xor bx,bx ;prepair (first)
mov ax,cx
mov dx,1
comment1:cmp byte ptr [bx],34 ;check ''
jne short comment1_0
neg dx ;reverse
comment1_0:cmp dx,1 ;see if in range?
jne short comment1_1 ;if not in range, skip
cmp byte ptr [bx],59 ;find comment (right side)
je short comment2_0 ;if comment, move on
comment1_1:inc bx
loop short comment1
mov bx,ax ;return
cmp byte ptr [bx-2],13 ;is this the ending?
jne short comment2_0
dec bx
mov byte ptr [bx-1],10 ;take it out
comment2_0:dec bx
cmp byte ptr [bx],10 ;at end too far?
jne short comment2a
jmp short comment2_0
comment2a:mov cx,bx ;current location as pointer
comment2:cmp byte ptr [bx]," " ;check for space (end)
jne short comment3
dec bx
loop short comment2
jmp near beginning3
comment3:inc bx
mov byte ptr [bx],10 ;save
mov ax,bx ;save
mov cx,bx ;length prepair
xor bx,bx ;beginning
comment4:cmp byte ptr [bx]," " ;begginning space remove
jne short comment5
inc bx
loop short comment4
jmp near beginning3
comment5:mov cx,ax
sub cx,bx ;make new size
push cx
push bx
mov dx,1
ucase_start:mov al,[bx] ;get letter
cmp al,34 ; check "'s
jne short ucase_mid ;if not, move on
neg dx
ucase_mid:cmp al,9
jne short ucase_mid1;exchange the tabs for spaces
mov al," "
ucase_mid1:cmp al,13
jne short ucase_mid2;exchange the ending for space
mov al," "
ucase_mid2:cmp dx,1 ;see if skipped?
jne short ucase_end ;if not 1, skip
cmp al,"a" ;not in area, and works.
jb short ucase_end
cmp al,"z" ;check in range
ja short ucase_end
sub al,32 ;fix
mov [bx],al
ucase_end: inc bx
loop short ucase_start
pop dx ;return starting address
pop cx ;size to save
inc cx ;fix bug
mov bx,cs:[file2] ;output temp
mov ah,write
int 21h ;write new section
jmp near beginning3
beginning4:push cs
pop ds ;return data
;continue the work here
call near closeboth
mov ah,open ;open source file
mov dx,tempfile2
mov al,readonly
int 21h
jnc short middle1 ;quit if error
mov ah,ptext ;tell error
mov bx,1
mov dx,err3
int 21h
jmp near ending
middle1:mov cs:[file1],ax ;save handle
mov bx,files ;prepair for working
mov dx,[bx+2]
mov ah,create ;open destination file
xor cx,cx
int 21h
jnc short middle2 ;quit if error
mov ah,ptext ;tell error
mov bx,1
mov dx,err2
int 21h
call near closefirst
jmp near ending
middle2:mov cs:[file2],ax ;save handle
xor ax,ax
mov word ptr es:[lab],1 ;1 label (auto, cpx)
mov word ptr es:[labcpx],ax;clear location of cpx?
mov bx,labstart
mov word ptr es:[bx],0403h ;save start
mov word ptr es:[bx+2],"CP" ;save fist half
mov byte ptr es:[bx+4],"X" ;save start
mov word ptr es:[bx+5],ax ;save zero
mov word ptr es:[bx+7],ax ;save zero
cmp byte [fst],1 ;fastfile make
jne short middle3 ;skip since it's not real
mov bx,files ;prepair for working
mov si,[bx] ;grab source file
mov cx,120 ;limit checks
Makeu_search:cmp byte [si],"." ;look for period
je short Makeu_Ext1
cmp byte [si],0 ;look for ending
je short Makeu_Ext1
inc si ;ok, add on
loop short Makeu_Search
jmp short middle3 ;skipping (Unknown)
Makeu_Ext1:mov word [si],".f"
mov word [si+2],"st"
mov byte [si+4],0
mov ah,open ;access fastfile
mov dx,[bx] ;first section
mov al,readonly ;readonly
xor cx,cx ;clear details
int 21h
jc short middle3 ;skip it all, don't worry
push ax
mov bx,ax ;set up handle
mov ah,read ;read from file
mov cx,-1 ;set for max size (who cares if it's enough :P)
mov dx,0 ;set location to write to
push ds ;preserve
push es ;set for writing
pop ds ;ready to write
int 21h ;let her rip
pop ds ;return DS
pop bx ;get handle
mov ah,close ;close the file
int 21h ;all done :)
;oh, as another note.. clear out the LOOPBACK since it's not needed :)
mov word cs:[loopback],0;cleared :)
jmp near half2_2 ;skip out
middle3:mov bx,cs:[file1] ;from read
mov dx,gs
call near getline ;get 1 line
;in this part, find and save labels..
;method suggested, move up as needed and save new part in middle (ES?)
cmp cx,0
je near half2
mov bx,1 ;prepair base
xor di,di ;prepair di
mov al,1 ;bytes needed for this
cmp byte ptr gs:[di],"^" ;1 byte, byte
je short middle3_2
mov al,2 ;bytes needed for this
cmp byte ptr gs:[di],"@" ;2 bytes, word
je short middle3_2
mov al,4 ;bytes needed for this
cmp byte ptr gs:[di],"%" ;4 bytes, doubleword (quad)
je short middle3_2
cmp byte ptr gs:[di],"$" ;4 bytes, length
je short middle3_2
;scanner for labels now
dec bx
middle3_1:cmp byte ptr gs:[di]," " ;instruction?
je short middle3
cmp byte ptr gs:[di],10
je short middle3
cmp byte ptr gs:[di],":" ;label?
je short middle4
inc di
jmp short middle3_1
middle3_2:cmp byte ptr gs:[di]," " ;end of section?
je short middle4
cmp byte ptr gs:[di],10
je short middle4
inc di
jmp short middle3_2
middle4: sub di,bx ;find length?
mov dx,di
mov dh,al
mov di,bx ;prepair di
mov si,labstart
mov cx,es:[lab] ;get count
labsearch0:mov ax,es:[si] ;get size (determine?)
cmp al,dl ;check
jb near labadd ;if smaller then text (passed)
ja short labsearch2 ;if larger (still to go)
push di ;equal, see if another match?
push si ;save values
push cx
push ax
xor cx,cx
mov cl,dl
labsearch0_1:mov al,es:[si+2];get first letter
cmp gs:[di],al ;see if different
je short labsearch1
pop ax
pop cx
pop si
pop di
jmp short labsearch2
labsearch1:inc si
inc di
loop short labsearch0_1;continue loop
pop ax ;bug fix
pop cx ;equals, now skip
pop si
pop di
jmp near middle3
labsearch2:add al,ah ;get size
mov ah,0 ;fix
inc ax
inc ax ;header?
add si,ax ;prepair
loop short labsearch0 ;continue
labadd: push di
mov di,si ;save location
mov ax,dx ;get info
add al,ah ;get size
mov ah,0 ;fix
inc ax
inc ax ;header?
mov bx,ax ;distance located
cmp cx,0
je short labadd2_2
labadd1:mov ax,es:[si] ;get size (determine?)
add al,ah ;get size
mov ah,0 ;fix
inc ax
inc ax ;header?
add si,ax ;prepair
loop short labadd1 ;continue
mov bp,si ;backup
sub si,di ;find difference
mov cx,si
mov si,bp
labadd2:dec si
mov al,es:[si] ;grab letter
mov es:[si+bx],al;save a few spaces ahead
loop short labadd2
labadd2_2:mov es:[si],dx;save label information
pop di ;location of label (0/1?) bug fix?
mov cl,dl ;prepair size (cx is 0 already)
labadd3:mov al,gs:[di] ;get letter
mov es:[si+2],al;save +2
inc si
inc di
loop short labadd3
mov cl,dh ;prepair size (cx is 0 already)
mov al,0 ;prepair
labadd4:mov es:[si+2],al;save +2
inc si
loop short labadd4 ;clear number to go by
inc word ptr es:[lab] ;add another one to it
jmp near middle3
half2:
;find and clarify CPX now :)
mov si,labstart
mov cx,es:[lab] ;get count
half2_0:mov ax,es:[si] ;get size (determine?)
cmp ax,0403h ;information (CPX)
jne short half2_1
cmp word ptr es:[si+2],"CP"
jne short half2_1
cmp byte ptr es:[si+4],"X"
jne short half2_1
add si,5 ;fix, exact location (4 bytes)
mov es:[labcpx],si ;get count
sub si,5
jmp short half2_2 ;skip
half2_1:add al,ah ;get size
mov ah,0 ;fix
inc ax
inc ax ;header?
add si,ax ;prepair
loop short half2_0 ;continue
half2_2:mov bx,cs:[file1] ;source
mov ax,pointersof
xor cx,cx
mov dx,cx ;clear
int 21h
half2_3:mov byte [size_ident],0 ;size reset
mov bx,cs:[file1] ;from read
mov dx,gs
call near getline ;get 1 line
cmp cx,0
je near half3_1
;set up a search and replace algorythmn here.
cmp byte ptr gs:[0],"<"
jne short half2_35
call near specials
jmp short half2_3
half2_35:call near replace
mov bx,1 ;prepair base
xor di,di ;prepair di
mov al,1 ;bytes needed for this
cmp byte ptr gs:[di],"^" ;1 byte, byte
je short half2_5
mov al,2 ;bytes needed for this
cmp byte ptr gs:[di],"@" ;2 bytes, word
je short half2_5
mov al,4 ;bytes needed for this
cmp byte ptr gs:[di],"%" ;4 bytes, doubleword (quad)
je short half2_5
cmp byte ptr gs:[di],"$" ;4 bytes, length
je short half2_5
cmp byte ptr gs:[di],"-" ;special, unknown
je short half2_5
cmp byte ptr gs:[di],"+" ;Special, unknown
je short half2_5
;scanner for labels now
dec bx
half2_4:cmp byte ptr gs:[di]," " ;instruction?
je near half3_2more ;considered an instruction
cmp byte ptr gs:[di],10
jne near half2_4x ;identify here
xor di,di
jmp near half3
half2_4x:cmp byte ptr gs:[di],":" ;label?
je short half2_6 ;save location CPX
inc di
jmp short half2_4
half2_5:cmp byte ptr gs:[di]," " ;end of section?
je short half2_6
cmp byte ptr gs:[di],10
je short half2_6
inc di
jmp short half2_5
half2_6:mov bp,di
inc bp
sub di,bx ;find length?
mov dx,di
mov dh,al
mov di,bx ;prepair di
mov si,labstart
mov cx,es:[lab] ;get count
labs0: mov ax,es:[si] ;get size (determine?)
cmp al,dl ;check
jb near half3 ;if smaller then text (passed)
ja near labs2 ;if larger (still to go)
push di ;equal, see if another match?
push si ;save values
push cx
push ax
xor cx,cx
mov cl,dl
labs0_1:mov al,es:[si+2];get first letter
cmp gs:[di],al ;see if different
je short labs1
pop ax
pop cx
pop si
pop di
jmp near labs2
labs1: inc si
inc di
loop short labs0_1 ;continue loop
pop ax
pop cx ;equals, now skip
pop si
pop di
;get to number (if one?) determine if number needed? $(current lastused-CPX)
;no bugs, continue here..
cmp di,1 ;label?
je short labs_x0
mov bx,dx
mov bh,0 ;set up add
inc bx
inc bx ;pointer fix
add bx,si ;prepair
mov eax,[thecpx] ;grab number
mov es:[bx],eax ;save label locator
mov [cpxstart],eax ;$
mov di,bp
jmp near half3 ;identify section
labs_x0:cmp byte ptr gs:[0],"$" ;see if length
jne short labs_x1
mov eax,[thecpx] ;get current location
sub eax,[cpxstart] ;get start, and difference
jmp short auto_bx ;skipper (on to prepair)
labs_x1:xchg si,bp ;prepair read
push dx
mov dx,gs
call near getnum ;get number (eax)
pop dx
xchg si,bp ;return
auto_bx:push dx
mov dh,0 ;get location
inc dx
inc dx
add si,dx ;set up
pop dx
cmp byte ptr gs:[0],"-" ;remove checks
jne short not_Subtraction
cmp dh,1
jne short subtract_1
sub es:[si],al
subtract_1:cmp dh,2
jne short subtract_2
sub es:[si],ax
subtract_2:cmp dh,4
jne short subtract_3
sub es:[si],eax
subtract_3:cmp es:[labcpx],si
jne near half2_3;little check (makes an easy skip)
sub [thecpx],eax;save new CPX info
jmp near half2_3;now let's go again
not_subtraction:cmp byte ptr gs:[0],"+" ;remove checks
jne short not_Addition
cmp dh,1
jne short addition_1
add es:[si],al
addition_1:cmp dh,2
jne short addition_2
add es:[si],ax
addition_2:cmp dh,4
jne short addition_3
add es:[si],eax
addition_3:cmp es:[labcpx],si
jne near half2_3;little check (makes an easy skip)
add [thecpx],eax;save new CPX info
jmp near half2_3;now let's go again
not_addition:cmp dh,1
jne short not1
mov es:[si],al ;save number
not1: cmp dh,2
jne short not2
mov es:[si],ax ;save number
not2: cmp dh,4
jne short not4
mov es:[si],eax ;save number
not4: cmp es:[labcpx],si
jne near half2_3;little check (makes an easy skip)
mov [thecpx],eax;save new CPX info
jmp near half2_3;now let's go again
labs2: add al,ah ;get size
mov ah,0 ;fix
inc ax
inc ax ;header?
add si,ax ;prepair
loop near labs0 ;continue (a cheat. i will fix later)
half3_2more:xor di,di
half3: cmp byte ptr cs:[loopback],0
jne short still_loopback
pusha
;the debugger set
mov si,di
half3_debug0:cmp byte ptr gs:[di],10
je short half3_debug1
inc di
jmp short half3_debug0
half3_debug1:sub di,si ;get length
cmp di,0
je short still_loopbacks1;skip, for labels only?
call near debug_thecpx ;get number location
mov cx,8
sub cx,[debugcpx_needed];prepair true size?
mov bx,[file3] ;debug
mov dx,debugcpx
add dx,cx ;size fix? (debugcpx-needed)
mov cx,[debugcpx_needed];fix sizers
inc cx ;size fix2 (for print)
mov ah,write
int 21h
cmp byte ptr cs:[dbg],1 ;screen?
jne short half3_dbg_debug1
mov cx,8
sub cx,[debugcpx_needed];prepair true size?
mov bx,1 ;screen
mov dx,debugcpx
add dx,cx ;size fix? (debugcpx-needed)
mov cx,[debugcpx_needed];fix sizers
inc cx ;size fix2 (for print)
mov ah,write
int 21h
half3_dbg_debug1:mov cx,di ;set length
half_3_rmsp:cmp byte gs:[si]," ";see if byte
jne short half3_dbg_removespaces
inc si
loop short half_3_rmsp
half3_dbg_removespaces:mov di,cx ;set length
mov dx,si ;set data
mov bx,[file3] ;set 'debug'
mov ah,write
push gs ;set print
pop ds
int 21h ;print
cmp byte ptr cs:[dbg],1 ;debug?
jne short still_loopbacks
mov cx,di ;set length
mov dx,si ;set data
mov bx,1 ;set 'screen'
mov ah,write
int 21h ;print
still_loopbacks:push cs ;return
pop ds
still_loopbacks1:popa
still_loopback:call near identify ;identify the instruction
xor ecx,ecx
mov cl,[size_ident]
mov eax,[thecpx] ;get size
add eax,ecx ;add on
mov cx,[direct_size_ident] ;direct size, if any
add eax,ecx ;add on
mov [thecpx],eax ;save new value
mov bx,es:[labcpx]
mov es:[bx],eax ;save cpx info
cmp byte ptr cs:[loopback],0 ;write error comment
jne short still_loopback1
cmp byte gs:[di],10 ;at end?
je short still_loopback1 ;skip out, it's a label
pusha
mov ax,err_ident_L
xor cx,cx
mov dx,cx ;clear paths
mov cl,[err_ident]
mul cx ;multiply
add ax,err0_ident ;prepair
mov dx,ax
mov si,dx ;location, find lenths
still_loopback_0:cmp byte ptr [si],10 ;check length
je short still_loopback_1
inc si
jmp short still_loopback_0
still_loopback_1:mov cx,si ;prepair and do size
sub cx,dx
inc cx ;needed????!?!?!?!?
mov ah,write
mov bx,[file3] ;for 'debug'
int 21h
cmp byte ptr [dbg],1 ;see if debug to screen?
jne short still_loopback0
mov ax,err_ident_L
xor cx,cx
mov dx,cx ;clear paths
mov cl,[err_ident]
mul cx ;multiply
add ax,err0_ident ;prepair
mov dx,ax
mov ah,ptext
mov bx,1 ;screen
int 21h
still_loopback0:popa
still_loopback1:cmp byte ptr cs:[loopback],0 ;save info
jne short still_loopback2
cmp byte [direct_on_ident],1 ;see if direct (special)
jne short still_notdirect
;direct_size_ident
pusha
mov cx,[direct_size_ident]
mov bx,[file2] ;output
mov ah,write ;write it
mov dx,[direct_segment]
mov ds,dx ;set up data
xor dx,dx ;beginning start
int 21h
mov dx,cs
mov ds,dx ;return regular data
popa
jmp short still_loopback2
still_notdirect:pusha
mov dx,real_ident ;prepair write
xor ax,ax ;clear
mov al,[start_ident] ;get start
sub dx,ax ;prepair
mov al,[size_ident] ;get size
mov cx,ax
mov bx,[file2] ;output
mov ah,write ;write it
int 21h
popa
still_loopback2:jmp near half2_3 ;continue half loop
half3_1:cmp byte ptr cs:[loopback],0
je short half3_2
dec word cs:[loopback] ;decrease one (next)
;wait a sec, clear out CPX (override here, special :) )
xor eax,eax ;clear number (0)
mov cs:[thecpx],eax ;CPX cleared
jmp near half2_2 ;continue at start
half3_2:call near closeboth
;ok, write FAST FILE if needed (M)
cmp byte [fst],2 ;Ok, check for make.. (1)
jne short half3_3
mov bx,files ;prepair for working
mov si,[bx] ;grab source file
mov cx,120 ;limit checks
Make_search:cmp byte [si],"." ;look for period
je short Make_Ext1
cmp byte [si],0 ;look for ending
je short Make_Ext1
inc si ;ok, add on
loop short Make_Search
jmp short half3_3 ;skipping (Unknown)
Make_Ext1:mov word [si],".f"
mov word [si+2],"st"
mov byte [si+4],0
mov ah,create ;open source file
mov dx,[bx]
mov al,writeonly ;readonly
xor cx,cx ;clear details
int 21h
jnc short Make_Cfile ;skip if error
mov ah,ptext ;print to screen
mov dx,fsterr ;error text
int 21h
jmp short half3_3 ;skip to end
Make_Cfile:push ax ;preserve handle
mov bx,ax ;mov handle to proper section
;mini function meant to pull size info into CX
;pulled from REPLACE
pusha
mov si,labstart
mov cx,es:[lab] ;get count
make_re_1:mov ax,es:[si] ;get size (determine?)
add al,ah ;get size
mov ah,0 ;fix
add ax,2 ;skip header
add si,ax ;prepair
loop short make_re_1
mov bp,sp ;grab pointer
mov [bp+pcx],si ;replace CX with new value
popa ;quit
mov ah,write ;save data
mov dx,0
push es ;labels segment prepair
pop ds
int 21h
;these will be restored in a second
pop bx ;pull out handle
mov ah,close ;close file
int 21h ;done :)
;Deleting the TEMPS now
half3_3:push cs ;ensure right
pop ds
cmp byte [tmpkeep],1 ;see if keep
je short half3_4 ;skip out
mov ah,delete ;prepair
mov dx,tempfile1 ;set first temp
int 21h ;delete
mov ah,delete ;prepair
mov dx,tempfile2 ;set first temp
int 21h ;delete
half3_4:jmp near ending ;to the ending
closeboth:mov ah,close
mov bx,cs:[file2]
int 21h
closefirst:mov ah,close
mov bx,cs:[file1]
int 21h
ret
proguse2:mov ah,ptext ;say program use
mov dx,proguse
mov bx,1
int 21h
ending: mov ah,ptext ;ending text
mov dx,exit
mov bx,1
int 21h
popad
ret
;input Dx=data location(on first run, only meant for 1 file's usage)
;output, none
getline_clear: pusha
push ds
mov ds,dx
xor si,si ;set up location
mov cx,si ;prepair 64K loop
mov al,0 ;null
getline_clear_1:mov [si],al ;clear (null)
inc si
loop short getline_clear_1
pop ds
popa ;return
ret
;input DX=Data location, BX file handle
;output cx, (size) (start at 0)
;the new GETLINE will need a 64K block, and will return a 1024
;block at a time. (512 if it's set for unicode translate)
getline:pusha
push ds ;save old DS
mov ds,dx ;set up data, alone now
xor di,di ;prepair counter (premenant)
mov bp,di ;save starting pointer (write)
mov si,[gstat] ;get location
mov cx,[gleft] ;get
mov ax,cx
sub ax,si
cmp ax,0
jne short getline_1done
getline_1start: mov ah,read
mov dx,gstuff
xor cx,cx
dec cx ;make 64K check
sub cx,gsize ;get size (manual, slower but still fast)
sub cx,4 ;other data (location and size)
shr cx,1
shl cx,1 ;make sure it's even (kills the first bit (far right))
int 21h
xor cx,cx ;clear?
mov [gstat],cx
mov [gleft],ax ;new value save
getline_1done:cmp ax,0
je short getline_skip
mov si,[gstat] ;get location
add si,gstuff ;get REAL location
mov cx,ax ;get size remaining
cmp byte ptr cs:[unicode],1 ;unicode in?
je short getline_unicode
cmp byte ptr cs:[unicode],2 ;turn unicode?
je short getline_turn_unicode
;REGULAR IN
getline_2:mov al,[si] ;grab letter
mov ds:[bp],al ;save letter
inc si
inc bp ;letter moving saved
inc di ;increase information grabbed
cmp al,10
je short getline_2gotit
loop short getline_2
jmp short getline_1start;if ran out of numbers, grab more..
getline_2gotit:sub si,gstuff
mov [gstat],si ;location
jmp short getline_skip
;UNICODE IN
getline_unicode:mov ax,[si] ;grab letter
mov ds:[bp],ax ;save letter
add si,2
add bp,2
add di,2
cmp ax,10
je short getline_2unicode_gotit
loop short getline_unicode
jmp short getline_1start;if ran out of numbers, grab more..
getline_2unicode_gotit:sub si,gstuff
mov [gstat],si ;location
jmp short getline_skip
;TURN ASCII TO UNICODE
getline_turn_unicode:mov ah,0
getline_turn_unicodex:mov al,[si] ;grab letter
mov ds:[bp],ax ;save letter
inc si ;increase 1 byte
add bp,2;fix new location (saved)
add di,2;fix data entered (unicode)
cmp al,10
je short getline_2turn_unicode_gotit
loop short getline_turn_unicodex
jmp near getline_1start;if ran out of numbers, grab more..
getline_2turn_unicode_gotit:
sub si,gstuff
mov [gstat],si ;location
;jmp short getline_skip ;unneeded
getline_skip: pop ds ;return
mov bp,sp
mov [bp+pcx],di ;save value in stack (cx)
popa ;return
ret ;exit
;first search over, see if a space or 32 or 10 comes first,
;if 32 first, then do a search from after that, until 10 is come across.
;if a match is found, exhange (move as nessisary)
replace:pushad
xor di,di
replace_s1:cmp byte ptr gs:[di]," "
je short replace_start
cmp byte ptr gs:[di],10
je short replace_exit
inc di
jmp short replace_s1
replace_start:inc di
cmp byte ptr gs:[di],10 ;ending?
je short replace_exit
mov si,labstart
mov cx,es:[lab] ;get count
replace_1:mov ax,es:[si] ;get size (determine?)
push di ;equal, see if another match?
push si ;save values
push cx
push ax
xor cx,cx
mov cl,al
replace_2:mov al,es:[si+2];get first letter
cmp gs:[di],al ;see if different
je short replace_3
pop ax
pop cx
pop si
pop di
jmp short replace_4
replace_3:inc si
inc di
loop short replace_2 ;continue loop
jmp short replace_5 ;successful to later section
replace_4:add al,ah ;get size
mov ah,0 ;fix
inc ax
inc ax ;header?
add si,ax ;prepair
loop short replace_1
jmp short replace_start
replace_exit:popad ;quit
ret
replace_5:pop ax
pop cx ;equals, now skip
pop si
pop di
mov bx,ax
mov bh,0 ;set up add
inc bx
inc bx ;pointer fix
add si,bx
xor edx,edx ;clear number
cmp ah,1
jne short replace_5_1
mov dl,es:[si] ;get number
replace_5_1:cmp ah,2
jne short replace_5_2
mov dx,es:[si] ;get number
replace_5_2:cmp ah,4
jne short replace_5_3
mov edx,es:[si] ;get number
replace_5_3:mov si,di ;clear region
xor cx,cx
mov cl,al ;get size to clear
replace_6:mov byte ptr gs:[si]," "
inc si
loop short replace_6
mov bx,ax ;save info
xor eax,eax ;clear
mov ecx,eax
mov bh,cl ;clear (quick)
mov si,ax ;clear
xchg edx,eax ;at a go
inc si ;Ending H on it?
mov cx,16
cmp eax,16 ;within decimal range?
ja short replace_7_1
mov cx,10 ;change to DECIMAL format
dec si ;ending H?
replace_7_1:push eax ;save number
replace_7_2:cmp eax,0 ;see if anything left
je short replace_8
xor dx,dx ;clear number
div ecx ;get next part
inc si ;add 1 to counter
jmp short replace_7_2
replace_8:cmp dl,10 ;see if decimal (or needing an ending type)
jnae short replace_8_1
inc si
replace_8_1:cmp si,0
jne short replace_8_1_2
inc si ;need at least one
replace_8_1_2:cmp si,bx
je short replace_9
jb short replace_8_5
;space too small, make room
push si
push di
push cx ;save divisor
mov cx,si ;prepair
sub cx,bx ;find difference
mov si,di
replace_8_2:cmp byte ptr gs:[si],10 ;find ending
je short replace_8_3
inc si
jmp short replace_8_2
replace_8_3:mov bp,si ;get length count
sub bp,di
sub bp,bx ;take out already spaced
mov di,si ;prepair
add di,cx ;move upwards
mov cx,bp ;tell loop
inc cx
replace_8_4:mov al,gs:[si]
mov gs:[di],al
dec si
dec di
loop short replace_8_4
pop cx ;restore divisor
pop di
pop si
jmp short replace_9
;space too big,shrink
;took chunk from too small, find problems and fix them in repeat
replace_8_5:push si
push di
push cx ;save divisor
mov cx,si ;prepair
sub bx,cx ;find difference (to shrink it with)
mov si,di
add si,bx ;spaces already
replace_8_6:cmp byte ptr gs:[si],10 ;find ending
je short replace_8_7
inc si
jmp short replace_8_6
replace_8_7:mov bp,si ;get length count
sub bp,di
sub bp,bx ;remove needed space
add di,cx ;prepair
mov si,di ;prepair
add si,bx
mov cx,bp ;tell loop
replace_8_8:mov al,gs:[si]
mov gs:[di],al
inc si
inc di
loop short replace_8_8
pop cx ;restore divisor
pop di
pop si
replace_9:pop eax ;get number again
add di,si
dec di ;fix?
xor dx,dx
cmp cx,16
jne short replace_9_1
mov byte ptr gs:[di],"H"
dec di
replace_9_1:cmp eax,0 ;precheck, if already 0?
je short replace_9_2_1 ;is 0, should get it's number
replace_9_2:cmp eax,0
je short replace_10
replace_9_2_1:xor dx,dx
div ecx
cmp dl,10
jb short replace_9_3
add dl,7 ;little trick
replace_9_3:add dl,"0" ;make number
mov gs:[di],dl ;failsafe (hex)
dec di
jmp short replace_9_2
replace_10:cmp dl,"9"
jbe short replace_10_1
mov byte ptr gs:[di],"0";failsafe (hex)
replace_10_1:popad ;successful ending
jmp near replace ;start over :P
debug_thecpx: pushad
mov si,debugcpx
add si,7 ;fix at end
mov eax,[thecpx];grab current number
mov cx,8 ;size of numbers
mov ebx,16 ;prepair divisor
debug_thecpx_1: xor edx,edx ;clear remainder
div ebx ;divide
add dl,"0"
cmp dl,"9" ;hex?
jbe short debug_thecpx_2
add dl,7 ;make hex
debug_thecpx_2:mov cs:[si],dl ;save
dec si ;move down
loop short debug_thecpx_1
popad ;return
ret
;check <?> Information
;first byte only matters
; I = Include
; . = CPU
; O = ORG (CPX)
; 3 = 32 bits
; 1 = 16 bits
; S = SET Number (Binary i hope :P)
;
specials: pusha
int 3
mov si,1
mov dh,gs:[si] ;get letter
cmp dh,"."
jne short specials_1
mov dx,gs
inc si
call near getnum
mov di,cpuformula
specials_0_1:cmp byte ptr [di],0
je short specials_1
mov cx,[di]
mov dl,[di+2]
cmp cx,ax
je short specials_0_2
add di,3
jmp short specials_0_1
specials_0_2: mov [compverset],dl ;save new information
jmp short specials_exit
specials_1: cmp dh,"I"
jne short specials_2
;include special..
nop ;ignore, another section earlier takes care of it
jmp short specials_exit
specials_2: cmp dh,"O"
jne short specials_3
specials_2_0: mov dh,gs:[si] ;grab letter
cmp dh," " ;find space
je short specials_2_1
cmp dh,13 ;ending?
je short specials_exit
cmp dh,10 ;ending?
je short specials_exit
cmp dh,">" ;ending?
je short specials_exit
inc si
jmp short specials_2_0
specials_2_1: inc si ;fix to number?
mov dx,gs ;segment
call near getnum ;get number
mov cs:[thecpx],eax ;save new value
mov bx,es:[labcpx]
mov es:[bx],eax ;written in now.
jmp short specials_exit
specials_3: cmp dh,"1"
jne short specials_4
mov byte cs:[bit32_set],1;make sure it's 16 bit
jmp short specials_exit
specials_4: cmp dh,"3"
jne short specials_5
mov byte cs:[bit32_set],2;make sure it's 32 bit
jmp short specials_exit
specials_5: cmp dh,"S"
jne short specials_6
specials_5_0: mov dh,gs:[si] ;grab letter
cmp dh," " ;find space
je short specials_5_1
cmp dh,13 ;ending?
je short specials_exit
cmp dh,10 ;ending?
je short specials_exit
cmp dh,">" ;ending?
je short specials_exit
inc si
jmp short specials_5_0
specials_5_1: inc si ;fix to number?
mov dx,gs ;segment
call near getnum ;get number
mov cs:[opinclude_set],al;save new data
jmp short specials_exit
specials_6: ;cmp dh,"I"
;jne short specials_3
specials_exit: popa
ret
;for certain parts :P
;INPUT dx:si
;output EAX
getnum: pushad
push ds
mov ds,dx ;prepair data (alone)
xor eax,eax
mov ecx,eax
mov edx,eax
getnum_start:push edx
xor eax,eax
cmp byte ptr [si],0
jne short getnum_extendly
inc si ;skips (was an extention)
getnum_extendly:
cmp byte ptr [si],10 ;ending?
je near getnum_done
cmp byte ptr [si],13 ;ending?
je near getnum_done
cmp byte ptr [si],">" ;ending (Specials)
je near getnum_done
cmp byte ptr [si],"," ;ending?
je near getnum_done
cmp byte ptr [si],"]" ;ending?
je near getnum_done
cmp byte ptr [si]," " ;ending?
je near getnum_done
cmp byte ptr [si],")" ;ending? (direct)
je near getnum_done
mov bl,1
cmp byte ptr [si],"+" ;accepted types
je short getnum_type
mov bl,2
cmp byte ptr [si],"-"
je short getnum_type
mov bl,3
cmp byte ptr [si],"\" ;remainder find
je short getnum_type
mov bl,4
cmp byte ptr [si],"/" ;round up
je short getnum_type
mov bl,5
cmp byte ptr [si],"*"
je short getnum_type
mov bl,1 ;regular number?
jmp short getnum_nsign
getnum_type:inc si ;move up from sign
getnum_nsign:push si ;save location
getnum_fend:
cmp byte ptr [si],"+" ;locate next parts?
je short getnum_next
cmp byte ptr [si],"-"
je short getnum_next
cmp byte ptr [si],"/"
je short getnum_next
cmp byte ptr [si],"\"
je short getnum_next
cmp byte ptr [si],"*"
je short getnum_next
cmp byte ptr [si],")" ;for directs
je short getnum_next
cmp byte ptr [si],"]" ;for mem
je short getnum_next
cmp byte ptr [si],10
je short getnum_next
cmp byte ptr [si],13
je short getnum_next
cmp byte ptr [si],","
je short getnum_next
cmp byte ptr [si]," "
je short getnum_next
cmp byte ptr [si],">"
je short getnum_next
inc si
jmp short getnum_fend
getnum_next: dec si
mov cl,2
cmp byte ptr [si],"B" ;binary
je short getnum_onward
mov cl,4
cmp byte ptr [si],"Q" ;quad
je short getnum_onward
mov cl,6
cmp byte ptr [si],"X" ;heX
je short getnum_onward
mov cl,8
cmp byte ptr [si],"O" ;octal
je short getnum_onward
mov cl,16
cmp byte ptr [si],"H" ;Hexidecimal
je short getnum_onward
mov cl,10
inc si
jmp short getnum_onward1
getnum_onward: mov byte ptr [si],0 ;null, special
getnum_onward1: mov di,si
pop si
sub di,si ;find loop to follow
cmp di,0
je short getnum_quotesin;multiple signs..
cmp byte [si],34 ;look for quotes
je near getnum_quotes
cmp byte [si],"0" ;not number?!?
jb near getnum_notnumber
cmp byte [si],"9"
ja near getnum_notnumber
cmp word [si],"0X" ;check for hex (other way)
jne short getnum_not2hex;no hex
mov cl,16 ;become hex
inc si
inc si
dec di
dec di
getnum_not2hex: mov bh,[si] ;grab letter
sub bh,"0" ;get decimal number
cmp bh,9 ;is decimal?
jbe short getnum_isdec
sub bh,7 ;find hex real
getnum_isdec: xor edx,edx ;proceed with add in
mul ecx
mov dl,bh
add eax,edx
inc si
dec di
cmp di,0 ;loop, special
ja short getnum_not2hex ;next character check
getnum_quotesin:pop edx ;get number
cmp bl,1 ;add?
jne short getnum_not1
add edx,eax
getnum_not1: cmp bl,2 ;subtract?
jne short getnum_not2
sub edx,eax
getnum_not2: cmp bl,3 ;Find Remainder
jne short getnum_not3
mov ecx,eax ;get divisor
mov eax,edx ;prepair number
xor edx,edx ;prepair remainder?
div ecx
; mov edx,eax ;done
getnum_not3: cmp bl,4 ;Divide (without remainder, round down)
jne short getnum_not4
mov ecx,eax ;get divisor
mov eax,edx ;prepair number
xor edx,edx ;prepair remainder?
div ecx
mov edx,eax ;done
getnum_not4: cmp bl,5 ;multiply
jne short getnum_not5
mov ecx,eax ;get multiplier
mov eax,edx ;prepair number
xor edx,edx ;prepair multiply
mul ecx
cmp edx,0
je short getnum_not51
; pop eax ;already popped?
xor eax,eax
mov byte ptr cs:[err_ident],5 ;number TOO big
jmp short getnum_Skipeax
getnum_not51: mov edx,eax
getnum_not5: jmp near getnum_start
;ok, this is a special rule, sorry..
getnum_quotes: xor cx,cx ;prepair shifter
push bx ;save formula (change?)
getnum_quotes0: inc si ;move up by one
cmp byte [si],34 ;double quotes
je short getnum_quotes1
xor ebx,ebx ;prepair
mov bl,gs:[si] ;grab letter
shl ebx,cl ;move over some bits
add eax,ebx ;add on
add cl,8 ;prepair next add (good up to 4)
jmp short getnum_quotes0
getnum_quotes1: inc si ;fix after quotes
pop bx ;return formula
jmp short getnum_quotesin
getnum_notnumber:pop eax
xor eax,eax
mov byte ptr cs:[err_ident],4 ;not number
jmp short getnum_Skipeax
;getnum_type_err:
; pop eax
; xor eax,eax
; mov byte ptr cs:[err_ident],6 ;no div/mul allowed
; jmp short getnum_Skipeax
getnum_done: pop eax
getnum_Skipeax: pop ds ;return real data
mov bp,sp
mov [bp+peax],eax ;carry over
popad
ret
identify: pushad
mov si,null_ident
mov cx,D_Data_Size ;(whole area)
mov al,0 ;null
ident_clear: mov [si],al ;clear search half
inc si
loop short ident_clear
cmp byte ptr gs:[di],10 ;if empty line (few)
je near ident_NoParErr
cmp word ptr gs:[di],200ah ;uncertain
je near ident_NoParErr
cmp word ptr gs:[di],0a20h ;uncertain until certain
je near ident_NoParErr
push di ;save instruction information
xor cx,cx ;save text size
ident_pre: mov si,prefix_data ;types identity
ident_pre0: cmp byte ptr gs:[di],10 ;end of text
je short ident_pre4
mov cl,[si] ;get text size
cmp cx,0
je short ident_pre3
push di ;save location
mov ax,[si+1] ;get extended information
add si,3 ;locate text
mov bx,cx ;save backup?
ident_pre1: mov dl,[si] ;get letter
cmp gs:[di],dl ;compare
jne short ident_pre2 ;continue?
inc si
inc di ;get other location set
loop short ident_pre1
pop di ;get start location
mov cx,bx ;set up count
ident_pre5: cmp byte gs:[di],"[" ;memory headers
je short ident_pre6 ;skip it out
cmp byte gs:[di],"," ;comma, information separator
je short ident_pre6 ;skip it out (leaving it)
mov byte ptr gs:[di]," ";clear out
ident_pre6: inc di ;move up one
loop short ident_pre5 ;clear area (text)
xor bx,bx ;clear
mov bl,al
add bx,null_ident ;prepair save
mov [bx],ah
jmp short ident_pre ;jump to next location
ident_pre2: pop di ;return base
add si,cx ;increase size
jmp short ident_pre0 ;continue looping
ident_pre3: inc di
jmp short ident_pre
ident_pre4: pop di
;check for optimize
cmp byte cs:[optimize],1
jnae short ident_blk
mov byte cs:[dist_ident],0 ;clear distance information
;fix out spaces (all spaces gone, but 1, plus inside "'s
ident_blk: cmp byte ptr gs:[di]," "
jne short ident_blk0
inc di ;move up one
jmp short ident_blk
ident_blk0: xor cx,cx ;prepair count (0)
mov ch,1
mov si,di ;start location
push di ;save start
ident_blk1: cmp byte ptr gs:[di],34 ;check for quotes
jne short ident_blk2
neg ch ;setting on
ident_blk2: cmp ch,1 ;see if quote on
je short ident_blk3 ;skip if so
jmp short ident_blk4 ;write reguardless
ident_blk3: cmp byte ptr gs:[di]," ";check space
jne short ident_blk4 ;space?
cmp cl,0 ;is space
jne short ident_blk5
inc cl ;update space
ident_blk4: mov al,gs:[di] ;get byte
mov gs:[si],al ;save byte
inc si
ident_blk5: cmp byte ptr gs:[di],10 ;check end of line
je short ident_blk6 ;at end of line
inc di ;move up (also space skip)
jmp short ident_blk1
ident_blk6: cmp word ptr gs:[si-3],0a20h ;see if it's this?
jne short ident_blk7
mov byte ptr gs:[si-3],10
ident_blk7: pop di
mov si,di
xor cx,cx
ident_define: cmp byte ptr gs:[si]," ";check space (at least 1)
jne short ident_define1
inc cx
ident_define1: cmp byte ptr gs:[si],",";check comma (2)
jne short ident_define2
inc cx
jmp short ident_define3 ;knowing 2, skip
ident_define2: cmp byte ptr gs:[si],10 ;check ending
je short ident_define3
inc si
jmp short ident_define ;reloop (look until satisfied)
ident_define3: cmp byte gs:[di+2]," " ;if qualify in the 2 byte range
;identify if db, dw, dq/dd
jne short ident_define6
xor ax,ax ;clear data
inc ax ;make 1
cmp word gs:[di],"DB" ;see if byte
jne short ident_define611
call near ident_direct
jmp short ident_define62;skip ahead past idents
ident_define611:inc ax ;make 2
cmp word gs:[di],"DW" ;see if word
jne short ident_define612
call near ident_direct
jmp short ident_define62;skip ahead past idents
ident_define612:inc ax ;make 4
inc ax
cmp word gs:[di],"DQ" ;see if doubleword/quad
jne short ident_define613
call near ident_direct
jmp short ident_define62;skip ahead past idents
ident_define613:cmp word gs:[di],"DD" ;see if doubleword/quad
jne short ident_define6
call near ident_direct
jmp short ident_define62;skip ahead past idents
ident_define6: cmp cx,0
jne short ident_define4
call near ident_1
ident_define4: cmp word ptr gs:[si-1],0a20h
jne short ident_define41
mov byte ptr gs:[si-1],0ah
xor cx,cx ;null empty section
call near ident_1
ident_define41: cmp cx,1
jne short ident_define5
call near ident_part
call near ident_2
ident_define5: cmp cx,2
jne short ident_define62
call near ident_part
call near ident_3
;moved stuff around
;if there's a size, disable the 9'illegal' one
ident_define62: cmp byte cs:[bit32_ident],3 ;is it 64?
jne short ident_3_define62a ;if not
mov byte cs:[bit32_ident],0 ;it is, now clear
ident_3_define62a:
cmp byte [err_ident],9 ;see if illegal
jne short ident_define63;skip out
cmp byte [size_ident],0 ;check size of instruction
je short ident_define63
mov byte [err_ident],0 ;no longer illegal (bug somewhere)
ident_define63: mov si,real_ident ;location of instruction write
mov dx,[prefix_data_32] ;prefix save
xor cx,cx
mov ch,[size_ident] ;get size
mov al,[seg_ident] ;get segment
cmp al,0 ;segment override?
je short ident_nosegs
dec si
mov [si],al
inc cx
ident_nosegs: mov ah,[bit32_set] ;get 32 info
mov al,[bit32_ident] ;using 32 registers?
cmp al,0 ;if 8 bit, ignore
je short ident_no32s
cmp al,ah
je short ident_no32s ;they are the same?
dec si
mov [si],dl ;66h?
inc cx
ident_no32s: mov al,[dist32_ident] ;get distance (32?)
cmp al,0 ;Undeclaired?
je short ident_nodist32
cmp al,ah
je short ident_nodist32
dec si
mov [si],dh ;67h?
inc cx
ident_nodist32: mov al,[rep_ident] ;get Rep info
cmp al,0 ;Repeat addon? (higher then 0)
je short ident_no_addons
dec si
mov [si],al
inc cx
ident_no_addons:cmp byte [opinclude_ident],0
je short ident_noIncludes
push cx
xor ax,ax ;clear
mov ch,al ;clear
mov cl,[opinclude_ident] ;grab number
mov al,10000000b ;set first bit
shr ax,cl ;locate
test [opinclude_set],al ;check to see if enabled
jz short ident_includes1
mov di,fs:[ident_opinclude] ;grab new location info
ident_opincludex_1:mov al,fs:[di] ;get size
inc ax ;fix in other data size
add di,ax ;new location
loop short ident_opincludex_1 ;locate
mov cl,fs:[di] ;get include (1 byte?)
push cx ;save size
sub si,cx ;move by that many bytes
inc di
ident_opincludex_2:mov al,fs:[di] ;get byte
mov [si],al ;write byte
inc si
inc di
loop short ident_opincludex_2
pop ax
pop cx
add cx,ax ;return and update
jmp short ident_noincludes
ident_includes1: pop cx ;refused and continue
ident_noIncludes:add ch,cl ;prepair
mov [size_ident],ch ;save instruction size
mov [start_ident],cl ;save location of start
cmp ch,16
jbe short ident_NoParErr
mov byte ptr [err_ident],3 ;save 'instruction too big' error
ident_NoParErr: popad
ret
ident_1: pusha
;determine length, and then search through library.
;also, save and get location of library fs:(2)
mov si,fs:[ident_pt1]
push di ;save
ident_1_length: cmp byte ptr gs:[di],10 ;see if this is end
je short ident_1_length1
inc di ;not end, continue
jmp short ident_1_length;look next
ident_1_length1:mov dx,di ;get location
pop di ;return value
sub dx,di ;find real length
;dl size ;dh Comp
ident_1_start: mov cx,fs:[si] ;get sizes
mov dh,fs:[si+2] ;grab instruction computer version
add si,3
cmp cl,0 ;see if there is anything
je short ident_1_nomore ;skip it all
cmp dl,cl ;see if matches size
jne short ident_1_next ;if not skip
push di ;save
ident_1_goagain:cmp cl,0 ;end of count?
je short ident_1_found
mov al,gs:[di] ;get letter
cmp fs:[si],al ;see if match
jne short ident_1_notfound
inc si ;move up one
inc di ;move up one
dec cx ;fix count
jmp short ident_1_goagain
ident_1_found: pop di
cmp [CompVerSet],dh ;check
jae short ident_1_compauto ;worked
mov byte ptr [err_ident],2 ;put up 'not on model' but work anyway
jmp short ident_1_next
ident_1_compauto:xchg ch,cl ;get number
mov di,real_ident ;prepair location
shl cx,4 ;get bit
shr cl,4 ;return size?
;any other used stuff, shove in here
push cx
mov cl,0 ;clear
ror cx,2 ;adjust
mov [opinclude_ident],ch;save opinclude
pop cx
and ch,3 ;32bit save
mov [bit32_ident],ch ;sends 32bit used?
mov [size_ident],cl ;save size
mov ch,0 ;clear
ident_1_copyinst:mov al,fs:[si] ;get letter
mov [di],al ;copy
inc si
inc di
loop short ident_1_copyinst ;copy whole instruction
jmp short ident_1_gotit
ident_1_notfound:pop di ;return location
ident_1_next: and ch,0fh ;grab right half only?
add cl,ch ;get remainder (if any)
mov ch,0 ;clear
add si,cx ;add on
jmp short ident_1_start ;continue
ident_1_nomore: mov byte ptr [err_ident],1;put up 'not identified'
ident_1_gotit: popa
ret
ident_2: pushad
;determine length, and then search through library.
;also, save and get location of library fs:(2)
mov si,fs:[ident_pt2]
push di
ident_2_start: cmp byte ptr gs:[di],32 ;end of text?
je short ident_2_flen
inc di
jmp short ident_2_start
ident_2_flen: mov dx,di
pop di ;prepair
sub dx,di ;find length
xor ax,ax ;hmm
ident_2_ftype: push di
xor cx,cx ;clear counter
mov cl,fs:[si] ;get text size
cmp cl,0
je near ident_2_nomore ;enter error code
inc si ;prepair
cmp dl,cl ;match size?
jne short ident_2_nomatch
ident_2_fmatch: mov al,gs:[di] ;compare text
cmp al,fs:[si]
jne short ident_2_nomatch ;if not match, next text
inc si
inc di
loop short ident_2_fmatch
jmp short ident_2_match
ident_2_nomatch:pop di
add si,cx ;find ending of text
;got to skip to next text now
mov cl,fs:[si] ;get number of unders
inc si ;start here
ident_2_nomatch2:add si,3
mov al,fs:[si] ;get size of instruction
add si,ax ;save and update
inc si
loop short ident_2_nomatch2 ;go until end of area
jmp short ident_2_ftype
ident_2_match: mov cl,fs:[si] ;get unders
inc si
ident_2_under: xor ax,ax
mov al,fs:[si] ;get first info (compare)
;Data 0 (1 section)
;8/16/32/64? (2 bit)??
;Exact match? (1 bit)
;relation (Regs type) 4 bit
;
;Type (register, memory, number) (bit 2)
;
;If Register
;helps with the encoding. (11 ??? Reg)
;If memory,
;helps with the encoding. (?? INT ???)
;64 bit enabled will expand memory limits
;If number
;(header) (000 = none, 100 unknown?)
;0 = size (byte, word, dword)(direct)
;1 = Distance (short, near, far) (Reletive)
;
;opinclude(7 include types (if enabled, special))
;
;/beyond
;system familiar (which computer type)
;size of instructions
; 0 00 0 0000b,11 001 000b
; 1, 1, D5
shl ax,1
cmp ah,0 ;Data 0
jne near ident_2_illegal
shl ax,2 ;8/16/32/64?
mov [null_ident],ah ;save info
mov ah,dh ;cleared (i am sure)
shl ax,1
shr al,4 ;number (exact match in bh, and relation bl)
mov bx,ax ;get number prepaired
;si +1 here on
mov al,fs:[si+1]
mov ah,dh ;clear
shl ax,2 ;TYPE (at least one here..)
cmp ah,0 ;say illegal?
je near ident_2_illegal
cmp [type1_ident],ah ;the kicker?
jne near ident_2_nomatch4
mov ah,dh ;clear
shl ax,3 ;get number qualify (size/type)
ror al,5 ;set up opinclude?
mov bp,ax
cmp byte ptr [type1_ident],3 ;see if number (related)
jne near ident_2_nocheck
cmp ah,4
ja short ident_2_dcheck
;number half.. check for at least value, to qualify (that number, or less)
cmp byte ptr [dist_ident],0
jne near ident_2_nomatch4 ;a distance value needed?
and ah,3 ;save only number part
cmp ah,3 ;see if 4 bytes?
jne short ident_2_xxcheck2
inc ah ;fix
ident_2_xxcheck2:cmp [numtype_ident],ah ;good for number
je short ident_2_xxcheck2_exact0;will work?
jmp near ident_2_nomatch4 ;didn't pass check
ident_2_xxcheck2_exact0:cmp bh,1 ;check for exact
jne near ident_2_nocheck;continue original
pushad
mov ecx,[number_ident] ;get number
xor ebx,ebx
mov dl,fs:[si+3] ;get size of instruction
sub dl,ah ;get real instruction size
add si,4
add si,dx ;adjust?
xor edx,edx
cmp ah,1
jne short ident_2_xxcheck2_exact1
mov dl,fs:[si]
ident_2_xxcheck2_exact1:cmp ah,2
jne short ident_2_xxcheck2_exact2
mov dx,fs:[si]
ident_2_xxcheck2_exact2:cmp ah,4
jne short ident_2_xxcheck2_exact3
mov edx,fs:[si]
ident_2_xxcheck2_exact3:cmp ecx,edx
je short ident_2_xxcheck2_exact4
popad
jmp near ident_2_nomatch4
ident_2_xxcheck2_exact4:mov [size_ident_e],ah ;extra space to remove
popad
jmp short ident_2_nocheck ;done here
;base off size, get true location, then determine if it's true or not
;SINCE of no use, it will be saved for later.. if used later..
;check distance half
ident_2_dcheck:and ah,3 ;save only that part
cmp ah,3
jne short ident_2_dcheck2
inc ah ;fix
ident_2_dcheck2:cmp [dist_ident],ah
je short ident_2_nocheck
cmp byte [dist_ident],0 ;check if no value present
jne near ident_2_nomatch4 ;see if it is worth seeing for more
pushad ;push all (easier this way)
mov dh,ah ;save data
mov eax,[number_ident] ;get number
mov ebx,[thecpx] ;grab location
sub eax,ebx ;number to save
cmp eax,0 ;check for 0
jl short ident_2_dcheck3
add eax,127 ;extream UP, removes the neg?
add eax,5 ;equalizer
ident_2_dcheck3:sub eax,5 ;equalizer
;add eax,50 ;extream DOWN
call near Ident_number_size
cmp dl,dh ;see if good
jbe short ident_2_jmp_numgood
ident_2_dcheck5:popad ;not good, skip out
jmp near ident_2_nomatch4 ;out of here
ident_2_jmp_numgood:cmp byte cs:[optimize],2 ;see if Quick
jne short ident_2_dcheck4 ;nope, quit out
cmp dh,1
je short ident_2_dcheck5
ident_2_dcheck4:mov [dist_ident],dh ;write the distance out
popad ;get back information
;AT THIS POINT ON, USE FAILURES NOMATCH3
ident_2_nocheck:push bp ;save data info (types distance)
cmp byte [type1_ident],1;register?
jne short ident_2_noregcheck ;relation check
;not going to save ax for now..
xor ax,ax ;needed?
mov al,[reg_ident]
shl ax,4
shr al,4 ;separate
cmp ah,bl ;relation check
jne near ident_2_nomatch3 ;not in the related part, keep searching
;assume all went well? Can't prove otherwise.
cmp bh,1 ;check for exact
jne short ident_2_noregcheck
xor ax,ax
mov al,fs:[si+3] ;grab instruction size
push si
dec ax ;remove exact (register 1 byte)
add si,4 ;ajust
add si,ax
mov al,fs:[si] ;get register compare
pop si
cmp al,0
je near ident_2_illegalbase ;register isn't put in right
mov ah,[reg_ident]
cmp al,ah
je short ident_2_regcheck_e1
jmp near ident_2_nomatch3 ;not exact, so can't use
ident_2_regcheck_e1:mov byte [size_ident_E],1 ;set for register delete
ident_2_noregcheck:cmp byte [type1_ident],2
jne short ident_2_nomemcheck
;assuming the information isn't higher then 3
mov ax,bp ;grab data
cmp ah,3 ;3=4
jne short ident_2_memch1
inc ah ;fix to 4
ident_2_memch1:cmp byte [null_ident],3 ;see if 64
jne short ident_2_memch2
shl ah,2 ;X4
ident_2_memch2:cmp [numtype_ident],ah ;ok, see if it's in range.
;ok, see if within range of size..
ja near ident_2_nomatch3;skip out, don't work
cmp bh,1 ;ok, no matches needed to satisfy
jne short ident_2_nomemcheck
push bp ;special save
mov bp,memdata_ident
xor ax,ax
mov al,fs:[si+3] ;grab instruction size
push si
dec ax ;remove exact (memory (16 assumed))
add si,4 ;ajust
add si,ax
mov al,fs:[si] ;get register compare
pop si
cmp cs:[bp+2],al
jne near ident_2_nomatch3
pop bp
ident_2_nomemcheck:shl bl,4
shl bx,4 ;save information
mov bl,fs:[si+2] ;get computer version
cmp [CompVerSet],bl
jb near ident_2_nomatch3
mov dl,fs:[si+3] ;get size of instruction
cmp dl,0
je near ident_2_illegalbase2 ;instruction size fails (0) error
ident_2_notExact:shr bx,4 ;put information back
shr bl,4
mov ah,dh ;since it seems to match, continue
shl ax,3
mov [opinclude_ident],ah ;save new includes (if any)
;successful, now add on..
push si ;remove annoying bug
add si,4 ;already have size
mov di,real_ident ;prepair write
mov cx,dx ;prepair loop
sub cl,[size_ident_e] ;fix by means of exacts?
mov [size_ident],cl ;save size
;exact adjustments :P (later)
ident_2_saveit:mov al,fs:[si] ;grab
mov [di],al ;save
inc si
inc di
loop short ident_2_saveit
;process first letter.
pop si ;annoying little bug fixed (mem)
;this pop SI is for a nasty bug in MEM, it skips a whole instruction if
;left alone. Took a while to get this one
mov al,[null_ident] ;grab (untouched) type
mov [bit32_ident],al ;save info
mov ax,bp ;opinclude
mov [opinclude_ident],al
pop ax ;aquire information
cmp byte ptr [type1_ident],2 ;check if memory
jne short ident_2_no_override
; cmp ah,3 ;see if 4 bytes?
; jne short ident_2_memcheck
; inc ah ;fix
;ident_2_memcheck:cmp [numtype_ident],ah ;good for number
; jne near ident_2_nomatch4 ;quit
;already checked
cmp bh,1
jne short ident_2_no_override ;match out with encoded source
mov bp,memdata_ident ;grab required area
xor cx,cx ;create size looper
mov cl,cs:[bp] ;get data size (1-2)
add byte [size_ident],cl;increase size accordingly
mov eax,[memnum_ident] ;grab number
mov [di],eax ;save number (may be null)
ident_2_no_override:cmp bh,1
je near ident_2_gotit ;if exact was used..
;ok, now for the checks..
ident_2_nochecks2:cmp byte ptr [type1_ident],1 ;register
jne near ident_2_1go_on
;build the format.. based on, 11 XXX (unused) ???
mov ax,bp
shl ah,3 ;place at location (extra data)
mov al,[reg_ident] ;get register
and al,7 ;grab the important bits
add al,300o ;put in format (300o)
add al,ah ;put in extra data
add byte [size_ident],1 ;increase size accordingly
mov [di],al
jmp near ident_2_gotit
ident_2_1go_on: cmp byte ptr [type1_ident],2 ;memory
jne near ident_2_2go_on
;build the format.. based on, ?? MEM enc
mov ax,bp ;backup, and will use AH a little
mov bp,memdata_ident ;grab required area
xor cx,cx ;create size looper
push si
mov si,cx ;get cleared side counter
mov cl,cs:[bp] ;get data size (1-2)
add byte [size_ident],cl;increase size accordingly
add si,2
;prepair first pass
mov al,cs:[bp+si] ;get mem byte
shl bl,3 ;fix encoding
add al,bl ;add encoding
jmp short ident_2_mm2 ;skip for first run
ident_2_mm: mov al,cs:[bp+si] ;grab mem byte
ident_2_mm2: mov [di],al ;save byte (First pass)
inc di ;update
inc si
loop short ident_2_mm
mov cl,cs:[bp+1] ;grab size to save (of side data)
add byte [size_ident],cl;increase size accordingly
mov eax,[memnum_ident] ;grab number
mov [di],eax ;save number (may be null)
; xor ax,ax
; mov al,fs:[si-4]
; and al,7 ;grab the 3 bits we need
;they are already SET
; call near memory_part ;identify and set memory
pop si ;resume previous number
ident_2_2go_on: cmp byte ptr [type1_ident],3 ;numbers done
jne near ident_2_3go_on
cmp ah,4
jae short ident_2_distance
cmp ah,3
jne short ident_2_sze
inc ah
ident_2_sze: add [size_ident],ah ;increase size accordingly
mov eax,[number_ident] ;get number
jmp near ident_2_numgood;SHOULD save it
ident_2_distance:and ah,3 ;sift out
cmp ah,3 ;is it 4 bytes?
jne short ident_2_dst
inc ah
ident_2_dst: xor ecx,ecx
add [size_ident],ah ;increase size accordingly
mov cl,[size_ident] ;grab size
mov eax,[number_ident] ;get number
mov ebx,[thecpx] ;grab location
add ebx,ecx ;real location to start.
sub eax,ebx ;number to save
mov dh,[dist_ident] ;get the specified type (followed)
call near Ident_number_size
cmp dl,dh
je short ident_2_numgood
jb short ident_2_canBsmaller
xor eax,eax
mov byte ptr [err_ident],7 ;Don't work
jmp short ident_2_numgood
ident_2_canBsmaller:mov byte ptr [err_ident],8 ;can be short?
ident_2_numgood:mov [di],eax ;save in right location
ident_2_3go_on: jmp short ident_2_gotit
;---
ident_2_nomatch3:pop bp
ident_2_nomatch4:add si,3
mov ah,0 ;clear (anyway)
mov al,fs:[si] ;get size of instruction
cmp al,0
je short ident_2_illegalbase ;check for size problems
cmp al,64
jae short ident_2_illegalbase ;continue checking
add si,ax ;save and update
inc si
loop near ident_2_under
pop di
jmp near ident_2_ftype
ident_2_illegal:mov byte ptr [err_ident],9 ;put up 'Illegal'
jmp short ident_2_gotit
ident_2_illegalbase2:pop ax ;fix sp location
ident_2_illegalbase:mov byte ptr [err_ident],10 ;put up 'Illegal/database'
jmp short ident_2_gotit
ident_2_nomore: mov byte ptr [err_ident],1;put up 'not identified'
ident_2_gotit: pop di
popad
ret
ident_3: pushad
;determine length, and then search through library.
;also, save and get location of library fs:(2)
mov si,fs:[ident_pt3]
push di
ident_3_start: cmp byte ptr gs:[di],32 ;end of text?
je short ident_3_flen
inc di
jmp short ident_3_start
ident_3_flen: mov dx,di
pop di ;prepair
sub dx,di ;find length
xor ax,ax ;hmm
ident_3_ftype: push di
xor cx,cx ;clear counter
mov cl,fs:[si] ;get text size
cmp cl,0
je near ident_3_nomore ;enter error code
inc si ;prepair
cmp dl,cl ;match size?
jne short ident_3_nomatch
ident_3_fmatch: mov al,gs:[di] ;compare text
cmp al,fs:[si]
jne short ident_3_nomatch ;if not match, next text
inc si
inc di
loop short ident_3_fmatch
jmp short ident_3_match
ident_3_nomatch:pop di
add si,cx ;find ending of text
;got to skip to next text now
mov cl,fs:[si] ;get number of unders
inc si ;start here
ident_3_nomatch2:add si,4
mov al,fs:[si] ;get size of instruction
add si,ax ;save and update
inc si
loop short ident_3_nomatch2 ;go until end of area
jmp short ident_3_ftype
ident_3_match: mov cl,fs:[si] ;get unders
inc si
ident_3_under: xor ax,ax
mov al,fs:[si] ;get first info (compare)
;Instruction 2 data?
;
;(Exacts on TYPE, size not included with that part.)
;(if register, 1 byte compare, or byte,word,doubleword)
;
;Data (1 bit)1 (2 sections)
;8/16/32/64? (2 bit)
;exact first? (1 bit)
;exact second? (1 bit)
;opinclude (3 bits)
;relation1 (4 bits)
;relation2 (4 bits)
;Type1 (2 bits)(register, memory, number)
;Type2 (2 bits)(register, memory, number)
;number size (2 bits)(byte, word, dword)(direct)
;overrides (2 bits)
; ON (Exact second=1) and (type1=1 and type2=1) then
; numbersize+unused = Extra Opcode encoding info
; ON (Exact Second=1) And (Type1=2 and type2=3) then
; RELATION1 = Extra Opcode
; ON (Exact first=1) And (Type1=1 and type2=3) then
; override is size (special)
; Both stored in BP (Back side)
;override info (As neccisary)
;will be more then 0 on these following circomstances
;WITHOUT AN EXACT!!
; REG REG (reverse these values)
; REG IMM (real size to save 1-4)
; REG MEM (UNUSED)
; MEM REG (UNUSED)
; MEM IMM (real size to save 1-4)
;/beyond
;system familiar (which computer type)
;size of instructions
shl ax,1
cmp ah,1 ;Data 1
jne near ident_3_illegal
mov ah,dh ;clear
shl ax,2 ;8/16/32/64?
mov [null_ident],ah ;save info
mov ah,dh ;cleared (i am sure)
push ax ;save for a moment
shl ax,2
mov al,0
shr ax,1 ;prepair the exacts
shr al,7 ;exacts
bswap eax ;extra save space
pop ax ;ok, opinclude
shl ax,2
mov ah,dh
shl ax,3 ;ok, opcode here..
mov bp,ax
;si +1 here on
mov al,fs:[si+1]
mov ah,dh ;clear
shl ax,4 ;TYPE (at least one here..)
shr al,4
mov bx,ax ;save relations
mov al,fs:[si+2]
mov ah,dh ;clear
shl ax,2 ;TYPE (at least one here..)
cmp ah,0 ;say illegal?
je near ident_3_illegal
cmp [type1_ident],ah ;the kicker?
jne near ident_3_nomatch4
mov ah,dh ;clear
shl ax,2 ;TYPE (at least one here..)
cmp ah,0 ;say illegal? (2)
je near ident_3_illegal
cmp [type2_ident],ah ;the kicker?
jne near ident_3_nomatch4
mov ah,dh ;clear
;addin.. For when type1 and type2, registers.. exacts? (RCL RCR Ect)
cmp word [type1_ident],0101h ;check for both registers first
jne short ident_3_Not111
bswap eax ;grab exacts (for a second)
cmp ax,0 ;any exacts?
je short ident_3_111_no
;ok, can grab the info now
bswap eax ;return
shl ax,4 ;grab last 3 bits (3 are encoded)
bswap ebp
mov bp,ax ;save
bswap ebp ;return
xor ax,ax ;no need to keep a value
jmp short ident_3_not111 ;close out
ident_3_111_no:bswap eax ;reverse
;addin.. For when type1 is Mem, Type 2 number, and Exact 2. (RCL RCR Ect)
ident_3_not111:cmp word [type1_ident],0302h;check for both registers first
jne short ident_3_Not231
bswap eax ;grab exacts (for a second)
cmp ax,0 ;any exacts?
je short ident_3_231_no
;ok, can grab the info now
push bx ;save
mov bl,0 ;clear upper
xchg bh,bl ;switch correctly
bswap ebp
mov bp,bx ;save
bswap ebp ;return
pop bx ;return to normal
ident_3_231_no:bswap eax ;reverse
ident_3_not231:shl ax,2 ;get number qualify (size/type)
;overrides added here
push ax ;saved for dad
xchg al,ah ;put in order
mov ah,0 ;clear
cmp al,3 ;see if should be 4
jne short ident_3_not3264A ;if not
inc ax ;fix size to 4 (32)
ident_3_not3264A:
cmp byte [null_ident],3;64 bit?
jne short ident_3_not3264B
shl ax,2 ;X4 (1 is 32, 2 is 64, 3 is 128)
ident_3_not3264B:
add bp,ax ;make bp type information
pop ax
;start overrides
mov ah,0 ;clear
shl ax,2 ;get override
cmp ah,3 ;check for special override
jne short ident_3_notveryspec ;don't bother
cmp word [type1_ident],0102h ;reg and mem check
je short ident_3_veryspec
cmp word [type1_ident],0201h ;reg and mem check
jne short ident_3_notveryspec
;ok, forced check.
ident_3_veryspec:
mov ax,bp ;get data (in al)
cmp [numtype_ident],al ;see if inside range
ja near ident_3_nomatch4 ;ok, too big? Small enough?
xor ax,ax ;clear unneeded
ident_3_notveryspec:
bswap EDI ;save overrides (special)
xor di,di
xchg al,ah ;put in order (lower)
mov di,ax
bswap EDI ;(put back in order)
mov ax,bp ;make ax that as well
cmp byte ptr [type1_ident],3
je near ident_3_illegalbase ;first section CAN'T be a number
cmp byte ptr [type2_ident],1 ;check for register (2)
jne short ident_3_noregch
mov ah,dh
push si
mov si,reg_ident
mov al,[si+1] ;get information
pop si
shl ax,4 ;split relation
shr al,4 ;split exact
cmp ah,bl
jne near ident_3_nomatch4
ident_3_noregch:cmp byte ptr [type2_ident],2 ;check memory (2)
jne short ident_3_nomemch
cmp byte ptr [type1_ident],2
je near ident_3_illegalbase
nop ;nothing really to check..
ident_3_nomemch:cmp byte ptr [type1_ident],1 ;check register (1)
jne short ident_3_noregch1
mov ah,dh
push si
mov si,reg_ident
mov al,[si] ;get information (Reg 2)
pop si
shl ax,4 ;split relation
shr al,4 ;split exact
cmp ah,bh
jne near ident_3_nomatch4
ident_3_noregch1:cmp byte ptr [type1_ident],2 ;check memory (2)
jne short ident_3_nomemch1
nop ;there's nothing to check
ident_3_nomemch1:cmp byte ptr [type2_ident],3 ;check number size (3)
jne short ident_3_nocheck
mov ax,bp ;prepair
cmp al,0
je near ident_3_illegal
;ok from here we will see if it fits in the byte sizes
cmp [numtype_ident],al ;compare with number stored (size)
jbe short ident_3_nocheck
mov byte ptr [err_ident],9 ;put up 'Number Too big'
jmp near ident_3_nomatch4
ident_3_nocheck:mov ax,bp ;get includes
mov [opinclude_ident],ah ;save new includes (if any)
push bx ;save vital information
bswap ebx
pop bx
mov bh,bl ;save alternate data (bl)
mov bl,fs:[si+3] ;get computer version
cmp [CompVerSet],bl
jb near ident_3_nomatch4
mov dl,fs:[si+4] ;get size of instruction
cmp dl,0
je near ident_3_illegalbase ;instruction size fails (0) error
ident_3_notExact:mov [size_ident],dl ;save size (needed)
mov ah,dh ;since it seems to match, continue
shl ax,3
;successful, now add on..
;AX and CX and BX are free
;moved information, SI becomes SI+5
BSWAP EAX ;AH is 1, AL is 2
push si
push di
push ax
push cx
xor cx,cx ;Clear out for checks
cmp ah,1
jne short ident_3_e_1
cmp byte [type1_ident],1 ;register check, 1 byte
jne short ident_3_e_1a
inc cx ;Add 1
;memory checks are invalid, for either part..
ident_3_e_1a:cmp byte [type1_ident],2 ;check for mem (illegal)
jne short ident_3_e_1 ;found bug :)
; pop cx
; pop ax
; pop di
; pop si
; jmp near ident_3_illegal
; inc cx ;can only be 1 choice
ident_3_e_1:cmp al,1
jne short ident_3_e_2 ;check for exact
cmp byte [type2_ident],1 ;register check, 1 byte
jne short ident_3_e_2a
inc cx ;Add 1
ident_3_e_2a:cmp byte [type2_ident],3 ;number check
jne short ident_3_e_2b
add cl,[numtype_ident] ;add size to the check.
ident_3_e_2b:cmp byte [type2_ident],2 ;check mem (illegal)
jne short ident_3_e_2 ;found bug :)
; pop cx
; pop ax
; pop di
; pop si
; jmp near ident_3_illegal
; inc cx ;can only be one thing
ident_3_e_2:mov ch,[size_ident] ;get size (real one) and add on
mov [size_ident_e],cl ;adjust
sub ch,cl
mov cl,dh ;clear
xchg ch,cl ;switch..
add si,cx
mov di,reg_ident
cmp ah,1 ;ident1
jne short ident_3_e_e1b
cmp byte [type1_ident],1 ;check register (1)
jne short ident_3_e_e1a
mov ah,fs:[si+5] ;ok, get register, and compare
cmp [di],ah ;check first one
jne near ident_3_nomatch_ex ;special nomatch4 :)
inc si
ident_3_e_e1a:
cmp byte [type1_ident],2 ;check memroy (2)
jne short ident_3_e_e1b
cmp [memdata_ident],1
jne near ident_3_nomatch_ex ;doesn't work
cmp [memdata_ident+2],6
jne near ident_3_nomatch_ex ;doesn't work
; mov byte [memdata_ident],0 ;remove the header
ident_3_e_e1b:cmp al,1 ;ident2
jne short ident_3_e_e1c
cmp byte [type2_ident],1 ;registers
jne short ident_3_e_e2a
mov ah,fs:[si+5] ;get register info.
cmp [di+1],ah ;bug here.. checks SECOND one
jne near ident_3_nomatch_ex ;special nomatch4 :)
ident_3_e_e2a:cmp byte [type2_ident],3 ;number check
jne short ident_3_e_e1
;bug found, compared according to the size
mov ecx,[number_ident] ;extract number
cmp byte [numtype_ident],1 ;byte check
je short ident_3_e_e3a
cmp byte [numtype_ident],2 ;word check
je short ident_3_e_e3b
cmp byte [numtype_ident],4 ;quad check
je short ident_3_e_e3c
pop cx
pop ax
pop di
pop si
jmp near ident_3_illegal ;something's wrong
ident_3_e_e3a: cmp fs:[si+5],cl ;byte check
jne near ident_3_nomatch_ex
jmp short ident_3_e_e1
ident_3_e_e3b: cmp fs:[si+5],cx ;word check
jne near ident_3_nomatch_ex
jmp short ident_3_e_e1
ident_3_e_e3c: cmp fs:[si+5],ecx ;quad check
jne near ident_3_nomatch_ex
ident_3_e_e1: cmp byte [type2_ident],2 ;check memroy (2)
jne short ident_3_e_e1c
cmp [memdata_ident],1
jne near ident_3_nomatch_ex ;doesn't work
cmp [memdata_ident+2],6
jne near ident_3_nomatch_ex ;doesn't work
; mov byte [memdata_ident],0 ;remove the header
ident_3_e_e1c: pop cx
pop ax
pop di
pop si
BSWAP EAX
;exact adjustments :P (later)
add si,5 ;already have size
mov di,real_ident ;prepair write
mov cx,dx ;prepair loop
sub cl,[size_ident_e] ;fix by means of exacts?
mov [size_ident],cl ;save size
;need information here, exacts specifically, now check it out.
ident_3_saveit:mov al,fs:[si] ;grab
mov [di],al ;save
inc si
inc di
loop short ident_3_saveit
;process first letter.
mov al,[null_ident] ;grab (untouched) type
mov [bit32_ident],al ;save info
mov ax,bp ;opinclude
mov [opinclude_ident],al
;disabled until i think it's needed again.. (Is it?)
;check for exacts, and use them accordingly
bswap eax ;grab information
cmp ax,0
jne near ident_3_final_exacts
ident_3_final_11:
cmp byte ptr [type1_ident],1 ;reg / reg
jne short ident_3_final_12
cmp byte ptr [type2_ident],1
jne short ident_3_final_12
; 11 Reg1 Reg2
push si
mov si,reg_ident
mov al,[si] ;get information (Reg 1)
shl ax,4 ;split relation
shr al,4 ;split exact
mov bh,al
mov al,[si+1] ;get information (Reg 2)
shl ax,4 ;split relation
shr al,4 ;split exact
mov bl,al
pop si
;override added here
;this override, if higher then 1, will reverse the two data pieces (bl bh)
bswap edi ;pull override out of the shadows
cmp di,1
jne short ident_3_final_11a
xchg bl,bh ;reverse now
ident_3_final_11a:bswap edi ;return to normal
shl bl,5 ;place at end
shl bx,3 ;converse to places
add bh,0c0h ;put in format (300o)
add byte [size_ident],1 ;increase size accordingly
mov [di],bh
inc di ;move up
bswap edi ;pull override out of the shadows
cmp di,2
jne short ident_3_final_11b
;ok, found the information we needed.. add in number
bswap edi
mov al,[numtype_ident] ;get data
add [size_ident],al ;increase size accordingly
mov eax,[number_ident] ;get number
mov [di],eax ;save in right location
jmp short ident_3_final_11c
ident_3_final_11b:bswap edi ;return to normal
ident_3_final_11c:jmp near ident_3_gotit
ident_3_final_12:
cmp byte ptr [type1_ident],1 ;reg / mem
jne short ident_3_final_21
cmp byte ptr [type2_ident],2
jne short ident_3_final_21
;build the format.. based on, ?? Reg ???
mov ax,bp ;backup, and will use AH a little
mov bp,memdata_ident ;grab required area
xor cx,cx ;create size looper
push si
mov si,reg_ident
mov al,[si] ;get information (Reg 1)
shl ax,4 ;split relation
shr al,4 ;split exact
mov bl,al
ident_3_final_21_skip:
mov si,cx ;get cleared side counter
mov cl,cs:[bp] ;get data size (1-2)
add byte [size_ident],cl;increase size accordingly
add si,2
;prepair first pass
cmp cx,0
je short ident_3_mm3 ;there are no passes.
mov al,cs:[bp+si] ;get mem byte
shl bl,3 ;fix encoding
add al,bl ;add encoding
jmp short ident_3_mm2 ;skip for first run
ident_3_mm: mov al,cs:[bp+si] ;grab mem byte
ident_3_mm2: mov [di],al ;save byte (First pass)
inc di ;update
inc si
loop short ident_3_mm
ident_3_mm3: mov cl,cs:[bp+1] ;grab size to save (of side data)
add byte [size_ident],cl;increase size accordingly
mov eax,[memnum_ident] ;grab number
mov [di],eax ;save number (may be null)
;they are already SET
pop si ;resume previous number
jmp near ident_3_gotit
ident_3_final_21:
cmp byte ptr [type1_ident],2 ;mem / reg
jne short ident_3_final_13
cmp byte ptr [type2_ident],1
jne short ident_3_final_13
mov ax,bp ;backup, and will use AH a little
mov bp,memdata_ident ;grab required area
xor cx,cx ;create size looper
push si
mov si,reg_ident
mov al,[si+1] ;get information (Reg 1)
shl ax,4 ;split relation
shr al,4 ;split exact
mov bl,al
jmp short ident_3_final_21_skip
ident_3_final_13:
cmp byte ptr [type1_ident],1 ;reg / num
jne short ident_3_final_23
cmp byte ptr [type2_ident],3
jne short ident_3_final_23
; 11 Enc Reg1
push si
mov si,reg_ident
mov al,[si] ;get information (Reg 1)
shl ax,4 ;split relation
shr al,4 ;split exact
mov bl,al
pop si
shl bh,3 ;put in place
add bh,bl
add bh,0c0h ;put in format (300o)
add byte [size_ident],1 ;increase size accordingly
mov [di],bh
inc di ;fix
bswap edi ;grab overrides
cmp di,0
je short ident_3_final_13c
mov ax,di ;get override data
xchg al,ah ;replace locations
jmp short ident_3_final_13d;skip into the rest of it all
;grabbed from (Exacts 3)
ident_3_final_13c:mov ah,[numtype_ident] ;grab size
ident_3_final_13d:bswap edi ;return
add [size_ident],ah ;increase size accordingly
mov eax,[number_ident] ;get number
mov [di],eax ;save in right location
jmp near ident_3_gotit
ident_3_final_23:cmp byte ptr [type1_ident],2 ;mem / num
jne short ident_3_final_33
cmp byte ptr [type2_ident],3
jne short ident_3_final_33
;based on ?? Re2 ???
mov ax,bp ;backup, and will use AH a little
mov bp,memdata_ident ;grab required area
xor cx,cx ;create size looper
push si
bswap ebx ;data is in BL
mov bh,0 ;clear
;ident_3_final_23_skip:
mov si,cx ;get cleared side counter
mov cl,cs:[bp] ;get data size (1-2)
add byte [size_ident],cl;increase size accordingly
add si,2
;prepair first pass
mov al,cs:[bp+si] ;get mem byte
cmp bl,8
jb short ident_3_final_23_testenc
and bl,3 ;ensure it doesn't interphere
xchg al,bl ;switch
ident_3_final_23_testenc:shl bl,3 ;fix encoding
add al,bl ;add encoding
jmp short ident_3_mm223 ;skip for first run
ident_3_mm23: mov al,cs:[bp+si] ;grab mem byte
ident_3_mm223: mov [di],al ;save byte (First pass)
inc di ;update
inc si
loop short ident_3_mm23
mov cl,cs:[bp+1] ;grab size to save (of side data)
add byte [size_ident],cl;increase size accordingly
mov eax,[memnum_ident] ;grab number
mov [di],eax ;save number (may be null)
add di,cx ;increase for memnum
;grabbed from (Exacts 3)
bswap edi ;grab overrides
cmp di,0
je short ident_3_final_23c
mov ax,di ;get override data
xchg al,ah ;replace locations
jmp short ident_3_final_23d;skip into the rest of it all
;grabbed from (Exacts 3)
ident_3_final_23c:mov ah,[numtype_ident];grab size
ident_3_final_23d:
bswap edi ;return
add [size_ident],ah ;increase size accordingly
mov eax,[number_ident] ;get number
mov [di],eax ;save in right location
pop si ;resume previous number
jmp near ident_3_gotit
ident_3_final_33:jmp near ident_3_gotit ;both numbers impossible
;ok here's the separator..
ident_3_final_exacts:jmp short ident_3_final_exacts_notmem
;ok, there are weak parts, let's find them and use them.
;first check mem stuff..
ident_3_final_exacts_mem:nop
;ok, we need to see what we can find here.. data suggests 3(mem) is exact
;build the format.. based on, 11 REG (unused) ??? (treat REG as the data)
bswap ebp ;grab saved special
mov bx,bp ;transfer
bswap ebp ;return to normal ?
mov bp,memdata_ident ;grab required area
xor cx,cx ;create size looper
push si
mov si,cx ;get cleared side counter
mov cl,cs:[bp] ;get data size (1-2)
add byte [size_ident],cl;increase size accordingly
add si,2
;prepair first pass
mov al,cs:[bp+si] ;get mem byte
shl bl,3 ;fix encoding
add al,bl ;add encoding
jmp short ident_3_final_mm223 ;skip for first run
ident_3_final_mm23:mov al,cs:[bp+si] ;grab mem byte
ident_3_final_mm223:mov [di],al ;save byte (First pass)
inc di ;update
inc si
loop short ident_3_final_mm23
mov cl,cs:[bp+1] ;grab size to save (of side data)
add byte [size_ident],cl;increase size accordingly
mov eax,[memnum_ident] ;grab number
mov [di],eax ;save number (may be null)
add di,cx ;increase for memnum
;grabbed from (Exacts 3)
pop si ;resume previous number
jmp near ident_3_gotit
ident_3_final_exacts_notmem:
;special memcheck
cmp ah,1 ;see if exacts
jne short ident_3_final_exacts_spmem1
cmp byte [type1_ident],2;see if mem
jne short ident_3_final_exacts_spmem1
push eax ;fix for ENTER and other specials
mov eax,[memnum_ident] ;grab number
mov [di],eax ;save
mov ah,0
mov al,[memdata_ident+1] ;grab size
add [size_ident],al ;increase size accordingly
add di,ax ;update position
pop eax
ident_3_final_exacts_spmem1:
cmp al,1 ;see if exacts
jne short ident_3_final_exacts_spmem2
cmp byte [type2_ident],2;see if mem
jne short ident_3_final_exacts_spmem2
push eax ;fix for ENTER and other specials
mov eax,[memnum_ident] ;grab number
mov [di],eax ;save
mov ah,0
mov al,[memdata_ident+1] ;grab size
add [size_ident],al ;increase size accordingly
add di,ax ;update position
pop eax
ident_3_final_exacts_spmem2:
cmp ax,0101h ;ok, here we are.. Shall we?
je near ident_3_gotit ;save the data here, all done
cmp ah,1 ;check first one
je short ident_3_final_exacts_first
cmp byte [type1_ident],2 ;mem?
je near ident_3_final_exacts_mem
;build the format.. based on, 11 REG (unused) ???
;from the original set (Ident_2) changed as needed
cmp byte [type1_ident],1 ;regs?
jne short ident_3_final_exacts_first
;ok, check to see if qualify, if so, grab the OTHER bp
cmp word [type1_ident],0101h
jne short ident_3_final_exacts_first_NOTBP
bswap ebp ;grab saved special
mov ax,bp ;transfer
bswap ebp ;return to normal ?
jmp short ident_3_final_exacts_first_BP
ident_3_final_exacts_first_NOTBP:mov ax,bp
bswap ebx ;extract relations
mov ah,bl ;grab second (extended data)
ident_3_final_exacts_first_BP:mov al,[reg_ident] ;get register
and al,7 ;grab the important bits
shl ah,3 ;place at location xx ENC reg
add al,0C0h ;put in format (300o)
add al,ah ;put in extra data
add byte [size_ident],1 ;increase size accordingly
mov [di],al ;move on
jmp near ident_2_gotit
ident_3_final_exacts_first:cmp al,1 ;check first one
je short ident_3_final_exacts_second
cmp byte [type2_ident],2 ;mem?
je near ident_3_final_exacts_mem
cmp byte [type2_ident],1
jne short ident_3_final_exacts_first1
;build the format.. based on, 11 REG (unused) ???
;from the original set (Ident_2) changed as needed
cmp word [type1_ident],0101h
jne short ident_3_final_exacts_secon_NOTBP
;ident_3_final_exacts_first_okBP:
bswap ebp ;grab saved special
mov ax,bp ;transfer
bswap ebp ;return to normal ?
jmp short ident_3_final_exacts_secon_BP
ident_3_final_exacts_secon_NOTBP:mov ax,bp
ident_3_final_exacts_secon_BP:mov al,[reg_ident+1];get second register
shl ah,3 ;place at location (extra data)
and al,7 ;grab the important bits
add al,300o ;put in format (300o)
add al,ah ;put in extra data
add byte [size_ident],1 ;increase size accordingly
mov [di],al
jmp near ident_2_gotit
ident_3_final_exacts_first1:cmp byte [type2_ident],3
jne short ident_3_final_exacts_second
bswap edi ;grab overrides
cmp di,0
je short ident_3_final_exacts_first2a
mov ax,di ;get override data
xchg al,ah ;replace locations
jmp short ident_3_final_exacts_first2b ;skip into the rest
;grabbed from (Exacts 3)
ident_3_final_exacts_first2a:mov ah,[numtype_ident];grab size
ident_3_final_exacts_first2b:cmp ah,3 ;safe (3=4)
jne short ident_3_final_exacts_first2c
inc ah
ident_3_final_exacts_first2c:bswap edi ;return
add [size_ident],ah ;increase size accordingly
mov eax,[number_ident] ;get number
mov [di],eax ;save in right location
jmp short ident_3_gotit
ident_3_final_exacts_second:jmp near ident_3_gotit ;last resort, end it all
ident_3_nomatch_ex:pop cx
pop ax ;little problem with exacts.. Fixed :)
pop di
pop si
ident_3_nomatch4:add si,4
mov ah,0 ;clear (anyway)
mov al,fs:[si] ;get size of instruction
cmp al,0
je short ident_3_illegalbase ;check for size problems
cmp al,64
jae short ident_3_illegalbase ;continue checking
add si,ax ;save and update
inc si
loop near ident_3_under
pop di
jmp near ident_3_ftype
ident_3_illegal:mov byte ptr [err_ident],9 ;put up 'Illegal'
jmp short ident_3_gotit
ident_3_illegalbase2:pop ax ;fix sp location
ident_3_illegalbase:mov byte ptr [err_ident],10 ;put up 'Illegal/database'
jmp short ident_3_gotit
ident_3_nomore: mov byte ptr [err_ident],1;put up 'not identified'
ident_3_gotit: pop di
popad
ret
ident_part: pusha
mov cx,3
mov si,type1_ident
mov byte ptr [si],0 ;clear prepair
mov byte ptr [si+1],0
ident_part_0: cmp byte ptr gs:[di]," ";check for space
je short ident_part_1
cmp byte ptr gs:[di],",";check comma (end, beginning?)
je short ident_part_1
cmp byte ptr gs:[di],10 ;check ending?
je near ident_part_gotit;at end anyway
inc di ;no continue
jmp short ident_part_0
ident_part_1: inc di ;move up one (worked)
;first the number (easiest)
push di
ident_part_11: cmp byte ptr gs:[di],"-";negative?
jne short ident_part_2
inc di ;negative dissapear?
ident_part_2: cmp byte ptr gs:[di],34 ;ok, will qualify as number now
je short ident_part_3
cmp byte ptr gs:[di],"0";within range?
jb short ident_part_notnumber
cmp byte ptr gs:[di],"9"
ja short ident_part_notnumber
ident_part_3: mov byte ptr [si],3 ;save as 'number'
;not perfect
pop di ;return to normal (if changed from neg)
pushad ;prepair special save
mov dx,gs ;save segment
mov si,di ;get location to read
call near getnum ;get the number
ident_part_4:
; mov [number_ident],eax ;save number
call near Ident_number_size ;get size in DL
cmp byte [numtype_ident],0;already set?
je short ident_part_numberISset1 ;is not set, and will be set
;work around... if both are numbers, the first is treated like a memory
;location
cmp quad [number_ident],0 ;save number
je short ident_part_numberISseta
;has confirmed the information, now to use it all.
push eax ;save number
mov byte [type1_ident],2;set as memory
mov eax,[number_ident] ;grab the 32 bit number
mov [memnum_ident],eax ;place it correctly
mov byte [memdata_ident],1 ;set size as 1
mov byte [memdata_ident+1],2 ;assume word.
mov byte [memdata_ident+2],6 ;set as input direct
pop eax
jmp short ident_part_numberISset1;save it as was a 0
;size of instruction, size of memnum to accept, instruction, Junk
ident_part_numberISseta:cmp [numtype_ident],dl ;is equal or greater already?
jae short ident_part_numberISset4;is set perfectly/small
ident_part_numberISset0:mov byte ptr [err_ident],5;put 'too large' error on.
xor eax,eax ;clear
jmp short ident_part_numberISset4;save 0
;too large? (if NEAR, might be ok?)
ident_part_numberISset1:mov [numtype_ident],dl ;set number
ident_part_numberISset4:mov [number_ident],eax ;save number (new save)
ident_part_numberISset2:popad ;return from
;there's a bug here, now to get rid of it.
cmp gs:[di],34 ;look for quotes
jne short ident_part_numberISset3
ident_part_numberISset2b:inc di ;move up
cmp gs:[di],34
je short ident_part_numberISset3;is quotes?
cmp gs:[di],13
je short ident_part_numberISset3b;is end?
cmp gs:[di],10
je short ident_part_numberISset3b;is end?
jmp short ident_part_numberISset2b
ident_part_numberISset3:inc di ;final fix
ident_part_numberISset3b:jmp near ident_part_next;ok, skip out
ident_part_notnumber:pop di ;return first
cmp byte ptr gs:[di],"[" ;required as a memory
jne short ident_part_notmem
mov byte ptr [si],2 ;save as 'memory'
;memory stuff here, but incomplete yet
call near memory_part
jmp near ident_part_next
ident_part_notmem:push si ;needed?
mov si,di ;save and checs
ident_part_fsize1:cmp byte ptr gs:[si],","
je short ident_part_fsize2
cmp byte ptr gs:[si],10 ;check end of part
je short ident_part_fsize2
inc si
jmp short ident_part_fsize1
ident_part_fsize2:sub si,di ;size check
push cx ;save loops (whole)
mov dx,si ;get size
mov bp,fs:[ident_pt0] ;location of registers
ident_part_regcheck:
mov ax,fs:[bp]
cmp al,0
je short ident_part_Nnext ;skip early (if nothing left)
xor bx,bx
xchg bh,al
shr bx,4 ;fix out information
shr bl,4
shr ax,4
shr al,4
;ah=text length al=#size bh=type bl=number of registers
;dl=text size compare
cmp dl,ah ;check sizes
jne short ident_part_scheck
mov si,bp ;prepair
add si,2 ;fix location
mov cl,bl ;prepair loops
ident_part_scheck2:push cx ;save
push ax
push di ;save location
mov cl,ah ;prepair texts
ident_part_scheck0:mov al,fs:[si] ;grab letter
cmp gs:[di],al ;compare
jne short ident_part_scheck1
inc si
inc di
loop short ident_part_scheck0
;if equal
pop di ;return location
pop ax
pop cx
sub bl,cl ;number it
shl bl,4 ;prepair
shr bx,4 ;fit in 1 byte
pop cx ;count
mov si,reg_ident
cmp cx,3 ;see if first one
je short ident_part_saveitall
inc si ;fix location (second)
ident_part_saveitall:mov [si],bl;save information on the register
mov si,reg_ident_info
cmp cx,3 ;see if first one
je short ident_part_saveitall2
inc si ;fix location (second)
ident_part_saveitall2:mov [si],al;save data size of register
pop si ;location to save
mov byte ptr [si],1;count as 'register'
jmp short ident_part_next
ident_part_scheck1:pop di ;return location
pop ax ;return information
add si,cx ;add remainder of register check
pop cx ;get loop
loop short ident_part_scheck2
mov bp,si ;locate?
jmp short ident_part_regcheck
ident_part_scheck:mov al,ah ;move text size over
mov ah,0 ;prepair multiply
mul bl ;find length skip
add ax,2 ;fix location
add bp,ax ;set up :)
jmp short ident_part_regcheck
ident_part_Nnext:pop cx ;get original CX loops
pop si ;previous pop?
ident_part_next:inc si ;location of ident
loop near ident_part_0 ;resumeing
ident_part_gotit:popa
ret
;input
;DI=start of instruction location
;AL=type of direct (byte size per area (divide remainder ect))
ident_direct: pushad ;save for function
mov byte [err_ident],0 ;kill other (in case)
push fs
mov bx,[direct_segment]
mov fs,bx ;pepair segment
mov ah,0
mov bp,ax ;save information
xor cx,cx ;blank out size
mov si,cx ;location to start saving at
;at this point, we have GS (text) FS (data area)
;DI instruction location
;SI data location
;CX size information
;BP backup of divider/size
add di,2 ;(start of information?)
ident_direct_lo:inc di
ident_direct_st:cmp byte ptr gs:[di],22h;look for quotes
je near ident_direct_text
push di
cmp byte ptr gs:[di],"-";negative?
jne short ident_direct_neg
inc di ;negative dissapear?
ident_direct_neg:cmp byte ptr gs:[di],"0";within range?
jb short ident_direct_other
cmp byte ptr gs:[di],"9"
ja short ident_direct_other
pop di
push si
mov si,di ;instruction grab
mov dx,gs ;segment save
call near getnum
pop si
mov fs:[si],eax ;save new bytes
add cx,bp ;add new byte information
add si,bp ;next location to write at
ident_direct_fc:cmp byte gs:[di],"," ;look for next part
je short ident_direct_lo;hmm :)
cmp byte gs:[di],0ah
je near ident_direct_end;done here
inc di
jmp short ident_direct_fc
ident_direct_other:cmp word gs:[di],"DU";time to test this..
; cmp quad gs:[di],"DUP(";failed for now
jne near ident_direct_errors
cmp word gs:[di+2],"P(" ;time to test this..
jne near ident_direct_errors
pop di
;ok, now for the dup instruction.
add di,4 ;(fix location)
push si
mov si,di
mov dx,gs
call near getnum
pop si
xor dx,dx ;clear out for remainder
div bp ;find remainder?
cmp dx,0
je short ident_direct_dupts ;done here
inc ax ;round up
xor dx,dx
ident_direct_dupts:mul bp ;fix size
cmp eax,0 ;see if neg.. (Special fix)
jg short ident_direct_numbugfix
mov ax,bp ;make minimum of count
ident_direct_numbugfix:
cmp ax,65532
jbe short ident_direct_numbugfix2
mov ax,65532 ;push to max
ident_direct_numbugfix2:
add cx,ax ;add new size (bytes)
push cx
mov cx,ax ;set for size now
;k now search quickly for the next part (comma)
ident_direct_dup0:cmp byte gs:[di],"," ;find comma
je short ident_direct_dup1
inc di
jmp short ident_direct_dup0
ident_direct_dup1:inc di ;fix location
;k, now identify if number or text (simple test)
cmp byte gs:[di],34
je short ident_direct_dupt
;assumed number, don't mess it up now
mov dx,gs
push si
mov si,di
call near getnum ;get new number
pop si
ident_direct_dupn:mov fs:[si],eax ;write number there (fill)
add si,bp
sub cx,bp
cmp cx,0
je short ident_direct_dupn2 ;loop messes up the count
jmp short ident_direct_dupn
ident_direct_dupn2:pop cx ;fix
jmp short ident_direct_fc;fix
ident_direct_dupt:inc di
cmp byte gs:[di],34 ;test if empty
jne short ident_direct_dupt2
xor eax,eax
jmp short ident_direct_dupn;empty, so null text
ident_direct_dupt1:pop di ;hmm.. a little close :P
ident_direct_dupt2:push di ;assumes something is here
ident_direct_dupt3:mov al,gs:[di] ;grab text byte
cmp al,34
je short ident_direct_dupt1 ;restart text
mov fs:[si],al ;save text
inc si
inc di
loop short ident_direct_dupt3 ;continue grabbing text
pop di
pop cx ;previous information size?
jmp near ident_direct_fc;fix
ident_direct_text:mov dx,cx ;save information (for later)
inc di ;skip out the quotes
ident_direct_nx:mov al,gs:[di]
cmp al,34 ;look for new quotes
je short ident_direct_qu
mov fs:[si],al ;save new byte
inc cx ;update size, and locations
inc si
inc di
jmp short ident_direct_nx
ident_direct_qu:mov ax,cx
sub ax,dx ;get size
xor dx,dx ;clear out for remainder
div bp ;find remainder?
cmp dx,0
je near ident_direct_fc;done here
push bp ;save size
sub bp,dx ;fix
add cx,bp ;update
push cx
mov cx,bp ;set up loop
mov al,dh ;empty byte
ident_direct_cl:mov fs:[si],al ;clear
inc si
loop short ident_direct_cl
pop cx
pop bp ;return
jmp near ident_direct_fc
ident_direct_errors:pop di
mov byte [err_ident],11 ;check line
ident_direct_end:pop fs
;ok, save information
mov byte [direct_on_ident],1 ;turn on
mov [direct_size_ident],cx ;save size
mov byte [size_ident],0 ;kill other (in case)
popad
ret
;determine size (NEC?), IN: EAX, OUT: DL
Ident_number_size:pushad
mov dl,4 ;size auto determine
test eax,80000000h
jnz short Ident_number_sizeISneg ;(if it matches?)
cmp eax,65535
ja short Ident_number_sizeISset
mov dl,2 ;ok 16 next
cmp word eax,255
ja short Ident_number_sizeISset
mov dl,1 ;save as 1 byte qualify (barely?)
jmp short Ident_number_sizeISset
Ident_number_sizeISneg:cmp eax,-32768
jl short Ident_number_sizeISset
mov dl,2 ;ok 16 next
cmp eax,-128
jl short Ident_number_sizeISset
mov dl,1 ;save as 1 byte qualify (barely?)
Ident_number_sizeISset:mov bp,sp;grab stack location
mov eax,[bp+pedx];prepair number
mov al,dl ;return a single value
mov [bp+pedx],eax;save number
popad
ret
;simple, remove all registers from memory location, while saving their
;order, any numbers left will be dealt with.. (no special math please)
memory_part: pushad
push di ;save instruction information
xor cx,cx ;save text size
mov bp,cx ;prepair 386 count
memory_part_pre:mov si,memory_data
memory_part_pre0:cmp byte ptr gs:[di],"]";end of text
je short memory_part_pre4
mov cl,[si] ;get text size
cmp cx,0
je short memory_part_pre3
push di ;save location
mov ax,[si+1] ;get extended information
add si,3 ;locate text
mov bx,cx ;save backup?
memory_part_pre1:mov dl,[si] ;get letter
cmp gs:[di],dl ;compare
jne short memory_part_pre2 ;continue?
inc si
inc di ;get other location set
loop short memory_part_pre1
pop di ;get start location
mov cx,bx ;set up count
memory_part_pre5:mov byte ptr gs:[di]," " ;clear out
inc di ;move up one
loop short memory_part_pre5 ;clear area (text)
xor bx,bx ;clear
mov bl,al
;enter in here, extended 386 half, as well as notifyer
cmp bx,3
jne short memory_part_pre5_2
add bx,bp ;add new location
inc bp ;increase by one
inc byte ptr [memdata_ident] ;add count to 386's
memory_part_pre5_2:mov [bx+memdata_ident],ah ;save
jmp short memory_part_pre ;jump to next location
memory_part_pre2:pop di ;return base
add si,cx ;increase size
jmp short memory_part_pre0 ;continue looping
memory_part_pre3:inc di
jmp short memory_part_pre
memory_part_pre4:pop di
;cut and paste from Ident earlier (space remove) all but 1
memory_part_blk:cmp byte ptr gs:[di]," "
jne short memory_part_blk0
inc di ;move up one
jmp short memory_part_blk
memory_part_blk0:xor cx,cx ;prepair count (0)
mov ch,1
mov si,di ;start location
push di ;save start
memory_part_blk1:cmp byte ptr gs:[di],34;check for quotes
jne short memory_part_blk2
neg ch ;setting on
memory_part_blk2:cmp ch,1 ;see if quote on
je short memory_part_blk3 ;skip if so
jmp short memory_part_blk4 ;write reguardless
memory_part_blk3:cmp byte ptr gs:[di]," ";check space
je short memory_part_blk5 ;space?
memory_part_blk4:mov al,gs:[di] ;get byte
mov gs:[si],al ;save byte
inc si
memory_part_blk5:cmp byte ptr gs:[di],10;check end of line
je short memory_part_blk6 ;at end of line
inc di ;move up (also space skip)
jmp short memory_part_blk1
memory_part_blk6:cmp word ptr gs:[si-3],0a20h ;see if it's this?
jne short memory_part_blk7
mov byte ptr gs:[si-3],10
memory_part_blk7:pop di
mov dx,gs ;prepair
inc di ;fix past [
mov si,di
call near getnum
mov cs:[memnum_ident],eax ;save data
;onto tedious work
;use translation table if 16 bit is used, or resort to 32bit
;16 bit assumed first
mov bx,memdata_ident
cmp byte ptr cs:[bx],0
je near memory_part_not32
;32 bit code here
mov byte ptr cs:[dist32_ident],2;set 32bit flag
xor dx,dx ;dx will be data.
cmp eax,0
je short memory_part_32_num
inc dh ;add to number
cmp eax,127
jg short memory_part_32_num2
cmp eax,-128
jl short memory_part_32_num2
jmp short memory_part_32_num
memory_part_32_num2:inc dh ;set 32 bit..
memory_part_32_num:
;ok, on to other stuff..
cmp byte ptr cs:[bx],2
je short memory_part_32_two ;ok, single, this will treat as a normal formula
mov dl,cs:[bx+3]
mov cx,dx ;backup
mov cx,dx
cmp cl,2 ;update 32bit
jne short memory_part_32_one
add cl,cl ;double
memory_part_32_one:
shl dl,2 ;prepair (right side)
shr dx,2 ;put in place
mov byte ptr cs:[bx],1 ;set the size up
mov cs:[bx+1],ch ;size of memory addin
mov cs:[bx+2],dl ;put in data
jmp near memory_part_resume
memory_part_32_two:mov dl,4 ;sp (opcode extend)
mov cx,dx
cmp cl,2
jne short memory_part_32_two2
add cl,cl ;double
memory_part_32_two2:
shl dl,2 ;prepair (right side)
shl dx,6 ;put in place
mov dl,cs:[bx+7] ;Scale (SIB)
shl dl,3 ;put in place
add dl,cs:[bx+4] ;Index
shl dl,3 ;put in place
add dl,cs:[bx+3] ;Base
mov byte ptr cs:[bx],2 ;set the size up
mov cs:[bx+1],ch ;size of memory addin
mov cs:[bx+2],dh ;put in data
mov cs:[bx+3],dl ;put in data
jmp near memory_part_resume
memory_part_not32:mov byte ptr cs:[dist32_ident],1;set 16bit flag
cmp word ptr cs:[bx+1],0 ;empty at all?
je short memory_part_not16
;16 bit code here
xor dx,dx ;dx will be data.
cmp eax,0
je short memory_part_16_num
inc dh ;add to number
cmp eax,127
jg short memory_part_16_num2
cmp eax,-128
jl short memory_part_16_num2
jmp short memory_part_16_num
memory_part_16_num2:inc dh ;set 16 bit..
cmp eax,32767
jg short memory_part_16_num3
cmp eax,-32768
jl short memory_part_16_num3
jmp short memory_part_16_num
memory_part_16_num3:xor eax,eax ;ok, illegal, but work anyway
mov cs:[memnum_ident],eax ;save null
memory_part_16_num:mov ax,cs:[bx+1] ;grab 2 byte information
mov si,memory_data2_T
mov cx,8 ;max count (locked in place)
memory_part_16_fix:cmp cs:[si],ax
jne short memory_part_16_fix1 ;if it doesn't fit
mov ax,cs:[si+2] ;update
jmp short memory_part_16_fix2
memory_part_16_fix1:add si,4 ;increase on
loop short memory_part_16_fix
memory_part_16_fix2:cmp ah,6 ;open part BP
jne short memory_part_16_fix3 ;is it?
cmp dh,0 ;any carryover?
jne short memory_part_16_fix3 ;if higher then 0, don't bother
inc dh ;make at least +0
memory_part_16_fix3:mov byte ptr cs:[bx],1 ;set the size up
mov cs:[bx+1],dh ;size of memory addin
shr ax,6 ;move in place
mov ah,dh ;get important byte size
shr ax,2 ;final update
mov cs:[bx+2],al ;put in data
jmp short memory_part_resume
memory_part_not16:
;ok, pure memory (number in only) 32/16?
cmp eax,65535
jg short memory_part_dr_num
cmp eax,-32768
jl short memory_part_dr_num
jmp short memory_part_dr_num1
memory_part_dr_num:mov byte ptr cs:[dist32_ident],2 ;set 32bit flag
mov dh,4 ;32 bits
mov dl,4 ;sp? (Mem)?
jmp short memory_part_dr_num2
memory_part_dr_num1:mov dh,2 ;16 bits
mov dl,6 ;bp+0 (mem)
memory_part_dr_num2:mov byte ptr cs:[bx],1
mov byte ptr cs:[bx+1],dh ;save size info
mov byte ptr cs:[bx+2],dl ;save actual half
memory_part_resume:nop
memory_part_alldone:popad
ret
Memory_data:
;format, size of text, location to save text (plus memdata_ident), value, text
;0 is null :P
;1, 2 and 7 are fixed, 3's are open, each time used, they will increase 1
;theory
;Info, Info2, BX/BP, SI/DI, E, E, E, times
db 2,1,1,"BX"
db 2,1,2,"BP"
db 2,2,1,"SI"
db 2,2,2,"DI"
db 2,7,0,"*1"
db 2,7,1,"*2"
db 2,7,2,"*4"
db 2,7,3,"*8"
db 3,3,0,"EAX"
db 3,3,1,"ECX"
db 3,3,2,"EDX"
db 3,3,3,"EBX"
db 3,3,4,"ESP"
db 3,3,5,"EBP"
db 3,3,6,"ESI"
db 3,3,7,"EDI"
db 0
;real 1
;extended
;register 1
;register 2
;register 3
;multiplyer
memory_data2_T:
db 0,1,0,4 ;backwards checked.. SI
db 0,2,0,5 ;DI
db 1,0,0,7 ;BX
db 2,0,0,6 ;there is no BP, but BP+0 there is... need check later
db 1,1,0,0 ;SI+BX
db 2,1,0,2 ;SI+BP
db 1,2,0,1 ;DI+BX
db 2,2,0,3 ;DI+BP
db 0,0,0,0
;db 1,0,0,4 ;backwards checked.. SI
;db 2,0,0,5 ;DI
;db 0,1,0,7 ;BX
;db 0,2,0,6 ;there is no BP, but BP+0 there is... need check later
;db 1,1,0,0 ;SI+BX
;db 1,2,0,2 ;SI+BP
;db 2,1,0,1 ;DI+BX
;db 2,2,0,3 ;DI+BP
;db 0,0,0,0
direct_segment:dw 0 ;segment for Direct information
prefix_data_32:db 66h,67h ;this is the data information (locked) prefixes
CompVerSet: db 0ffh ;set up for system (255 = all instructions)
bit32_set: db 1 ;16 bit by default
opinclude_set: db 0 ;turned off (contains 0???????)
null_ident: db 0 ;a null location (nothing important)
direct_on_ident:db 0 ;if set to 1, will be a direct input data
direct_size_ident:dw 0 ;size of data (starting 0 from segment)
dist_ident: db 0 ;distance identify
numtype_ident: db 0 ;number size (or larger)
type1_ident: db 0 ;identify half
type2_ident: db 0 ;identify half
type3_ident: db 0 ;identify half
;0 nothing, 1 register, 2 memory, 3 number
memnum_ident: dw 0,0 ;the memory location, if there is one
memdata_ident: dw 0,0,0,0 ;reserved for the memory funciton
;also data when memory done.
;size of instruction, size of memnum to accept, instruction, Junk
number_ident: dw 0,0 ;the number, if there is one
numberEXT_ident: dw 0,0 ;extended instructions, unused for now
seg_ident: db 0 ;segment override?
rep_ident: db 0 ;repeats are defined
reg_ident: db 0,0 ;the 2 sections of registers (if needed)
reg_ident_info: db 0,0 ;remainder information (size of registers)
err_ident: db 0 ;errors encountered (only 1 allowed)
start_ident: db 0 ;minus from real
size_ident: db 0 ;instruction size
size_ident_E: db 0 ;Exact Size, subtract from Size_ident
bit32_ident: db 0 ;intruction type/size
dist32_ident: db 0 ;distance 32bit?
opinclude_ident: db 0 ;the special, optional include
prefix_ident: db 0,0,0,0,0
;allows, a segment override (1 byte) 2 type overrides (mem / register),
;and an instruction override (rep)
; 1 extra (just in case)
real_ident: dw 0,0,0,0,0,0,0,0
^D_Data_Size cpx-null_ident ;Starting at null?
prefix_data:
;format, size of text, location to save text (plus dist_ident), value, text
;0 is null :P
db 5,dist_ident-null_ident,1,"SH","ORT"
db 4,dist_ident-null_ident,2,"NE","AR"
db 3,dist_ident-null_ident,4,"FA","R"
db 5,numtype_ident-null_ident,16,"TBY","TE" ;for FPU
db 6,numtype_ident-null_ident,8,"DOU","BLE" ;for FPU
db 5,numtype_ident-null_ident,8,"DQ","UAD"
db 5,numtype_ident-null_ident,8,"QW","ORD"
db 6,numtype_ident-null_ident,4,"SIN","GLE" ;for FPU
db 5,numtype_ident-null_ident,4,"FLO","AT" ;for FPU
db 5,numtype_ident-null_ident,4,"DW","ORD"
db 4,numtype_ident-null_ident,4,"QU","AD"
db 4,numtype_ident-null_ident,2,"WO","RD"
db 4,numtype_ident-null_ident,1,"BY","TE"
db 3,null_ident-null_ident,0,"PT","R" ;0
db 4,seg_ident-null_ident,2eh,"[CS",":" ;removes label possibility
db 4,seg_ident-null_ident,3eh,"[DS",":"
db 4,seg_ident-null_ident,26h,"[ES",":"
db 4,seg_ident-null_ident,64h,"[FS",":"
db 4,seg_ident-null_ident,65h,"[GS",":"
db 4,seg_ident-null_ident,36h,"[SS",":"
db 4,seg_ident-null_ident,2eh," CS",":"
db 4,seg_ident-null_ident,3eh," DS",":"
db 4,seg_ident-null_ident,26h," ES",":"
db 4,seg_ident-null_ident,64h," FS",":"
db 4,seg_ident-null_ident,65h," GS",":"
db 4,seg_ident-null_ident,36h," SS",":"
db 4,seg_ident-null_ident,2eh,",CS",":"
db 4,seg_ident-null_ident,3eh,",DS",":"
db 4,seg_ident-null_ident,26h,",ES",":"
db 4,seg_ident-null_ident,64h,",FS",":"
db 4,seg_ident-null_ident,65h,",GS",":"
db 4,seg_ident-null_ident,36h,",SS",":"
db 5,rep_ident-null_ident,0f2h,"RE","PNE"
db 4,rep_ident-null_ident,0f0h,"LO","CK"
db 4,rep_ident-null_ident,0f3h,"RE","PZ"
db 4,rep_ident-null_ident,0f3h,"RE","PE"
db 3,rep_ident-null_ident,0f2h,"RE","P"
db 0
;a cheat, this will have to do (all texts the same size)
err0_ident: db 13,10,"$ SPace, Junk Data",32,"unIMPORTant!!!!------"
$err_ident_L
db 59,"Unknown Instruction",13,10,"$ "
db 59,"Instruction Not on That Computer Model",13,10,"$"
db 59,"Instruction Too Big (over 16 bytes)",13,10,"$ "
db 59,"Is not a Number, or Register",13,10,"$ "
db 59,"Number too large",13,10,"$ "
db 59,"No Division or Multiplacation allowed",13,10,"$ "
db 59,"Jump Too big (No Jump) >",13,10,"$ "
db 59,"Jump Is Small enough <=",13,10,"$ "
db 59,"Illegal Instruction",13,10,"$ "
db 59,"Database Has Errors / Illegal",13,10,"$ "
db 59,"Please Confirm this line (Db, Dw, Dq)",13,10,"$ "
;db 59,"Error in Memory Line []",13,10,"$ "
db 59,"Unknown",13,10,"$ "
tempfile1: db "temp.asm",0,0,0,0,0
tempfile2: db "temp1.asm",0,0,0,0
debugfile: db "debug.txt",0,0,0,0
Instruction_set: db "test.set",0,0,0,0,0
dbg: db 0
includez: db 0
fst: db 0 ;1 use, 2 make
tmpkeep: db 0 ;1 keep 0 delete
optimize: db 0 ;if 1, then short and near jumps are undefined.
unicode: db 0 ;used later, leave alone for now
file1: dw 0
file2: dw 0
file3: dw 0 ;debug.txt
file4: dw 0 ;includes
files: dw 0,0,0,0,0,0,0,0,0,0 ;junk area, just in case, only 3 needed
thecpx: dw 0,0 ;get location for CPX
cpxstart:dw 0,0 ;save location of labels here ($)
loopback: dw loopback_minimum ;for extra info. (more complex code?)
^loopback_minimum 7 ;new minimum.. change as needed
debugcpx: db "00000000:$" ;information, just a cut and paste.. Locked
debugcpx_needed: dw 8 ;prepair count to keep (8 at default)
cpuformula:
dw 8088
db 0
dw 8086
db 1
dw 186
db 1
dw 286
db 2
dw 386
db 3
dw 486
db 4
dw 586
db 5
dw 686
db 6
dw 786
db 7
dw 886
db 8
dw 986
db 9
dw 1086
db 10
dw 1186
db 11
dw 1286
db 12
db 0
Intro:
db " Intel/Assembler V",13,10,"$"
db "Created by Alexandre Savelli Bencz", 13,10, "$"
Proguse:
db "Assembler Usage: Intelasm [Input.asm] [Output.com] [DMFOQT]",13,10
db "Other options:",13,10,13,10
db "D - Debug code.. (True assembly)",13,10
db "M - Make fast file [input].fst",13,10
db "F - Use Fast file [input].fst",13,10
db "O - Optimize jumps (Make Short, Near Jumps Undeclaired)",13,10
db "Q - Quick jumps (Make all jumps at least Near (Fast))",13,10
db "T - Keep Temp Files",13,10,13,10,"$"
Exit: db "Thanks for using this :)",13,10, "$"
Err: db "Unable to access Source File",13,10,13,10,"$"
Err2: db "Unable to access Destination File",13,10,13,10,"$"
Err3: db "Unable to Create/use Temporary Files",13,10,13,10,"$"
Err4: db "Unable to Access .set File",13,10,13,10,"$"
Err5: db "Redirecting .set From Internal Presets",13,10,13,10,"$"
memerr: db "Not Enough Memory to Run Program",13,10,"$"
dbgerr: db "There was an error trying to open Debug.txt, for the output.",13,10,"$"
fsterr: db "There was an error while creating the FASTFILE.",13,10,"$"
verseterr: db "This Program is not compadible with the SET file. Please Update",13,10,13,10,"$"
internal_set:
*idtest.txt
$internal_set_L
;version settings now
^digit "0"
^Ver_Major 0
^Ver_Minor 5
^Ver_Revision 2
;month, day, year
;upper, lower (upper is decades)
^Ver_LUuM 0
^Ver_LUlM 4
^Ver_LUuD 1
^Ver_LUlD 1
^Ver_LUuY 0
^Ver_LUlY 2
%cpx 0
lab:
+cpx 2
labcpx:
+cpx 2
labstart:
;info for location structure IN the structure of the library
%cpx 0
ident_pt0:
+cpx 2
ident_pt1:
+cpx 2
ident_pt2:
+cpx 2
ident_pt3:
+cpx 2
ident_pt4: ;don't ask, it's just the way it is.
+cpx 2
ident_opinclude:
+cpx 2
ident_verset:
;NOTE: this structure is for Getline, GLINE only.. don't use it for
;anything else.. and this is for 64K only, at lines to be expected at up to
;10240 bytes (why it would be bigger, i have no idea..)
@gsize 1024
%cpx 0
gline:
+cpx gsize
;stat, for where the text is to be read/scanned next
gstat:
+cpx 2
;left, how many bytes were read, based on position, it will be
;able to tell what is left, before it has to do a real read again
gleft:
+cpx 2
gstuff:
^Delete 41h
^Open 3Dh
^Create 3Ch
^OpenCreate 6Ch
^Close 3Eh
^Read 3Fh
^Write 40h
^ReadOnly 0
^WriteOnly 1
^Random 2
@PointerSof 4200h
@PointerCur 4201h
@PointerEof 4202h
^Ptext 9
;note, these are + to bp (SS) from a PUSHA PUSHAD to carry over information
;at the POPA POPAD
^pax 14
^pcx 12
^pdx 10
^pbx 8
^psp 6
^pbp 4
^psi 2
^pdi 0
^peax 28
^pecx 24
^pedx 20
^pebx 16
^pesp 12
^pebp 8
^pesi 4
^pedi 0
;rules:
;1) fs: Is the data section. (instructions)
;2) gs: Data in/out (text, and translation area (un-needed?)
;
; 3 numbers, starts of each item, each end with 1 0
| 34.313844 | 97 | 0.502005 |
68c370a69b9e5bfac38ed17337ba004cf107701c | 6,101 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_2690.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_2690.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_2690.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r14
push %r15
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x3572, %rdi
and %r15, %r15
movb $0x61, (%rdi)
nop
nop
xor %rbp, %rbp
lea addresses_WC_ht+0x75e9, %rsi
lea addresses_WT_ht+0x13b62, %rdi
nop
nop
nop
inc %r12
mov $107, %rcx
rep movsq
nop
nop
nop
nop
add $10233, %r10
lea addresses_A_ht+0x19582, %r12
clflush (%r12)
nop
nop
add $28897, %rsi
movl $0x61626364, (%r12)
dec %rcx
lea addresses_D_ht+0x1202, %r15
nop
nop
and %rdi, %rdi
mov $0x6162636465666768, %r12
movq %r12, (%r15)
nop
nop
inc %rcx
lea addresses_WC_ht+0x119cc, %rbp
sub $49529, %r15
vmovups (%rbp), %ymm1
vextracti128 $1, %ymm1, %xmm1
vpextrq $0, %xmm1, %r10
cmp $41737, %rdi
lea addresses_normal_ht+0x3302, %rsi
sub %rbp, %rbp
mov (%rsi), %r12w
nop
nop
nop
nop
nop
sub %r12, %r12
lea addresses_A_ht+0x8502, %rsi
lea addresses_D_ht+0x8c02, %rdi
nop
cmp $30584, %r10
mov $66, %rcx
rep movsq
nop
nop
nop
nop
sub $1764, %rsi
lea addresses_A_ht+0xc002, %rsi
lea addresses_D_ht+0x10a02, %rdi
nop
nop
nop
nop
xor %r14, %r14
mov $31, %rcx
rep movsb
add $14241, %r10
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r15
pop %r14
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r9
push %rbx
push %rdx
push %rsi
// Load
mov $0x682, %r13
nop
cmp %r9, %r9
mov (%r13), %r12
nop
nop
nop
nop
inc %r9
// Faulty Load
lea addresses_PSE+0x1c202, %r12
add $60420, %r13
mov (%r12), %dx
lea oracles, %r9
and $0xff, %rdx
shlq $12, %rdx
mov (%r9,%rdx,1), %rdx
pop %rsi
pop %rdx
pop %rbx
pop %r9
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_PSE', 'same': False, 'size': 4, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_P', 'same': False, 'size': 8, 'congruent': 7, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_PSE', 'same': True, 'size': 2, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 1, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 4, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 8, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 32, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 2, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 6, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 10, 'same': True}, 'OP': 'REPM'}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
| 41.503401 | 2,999 | 0.656286 |
65c33ea5447b2b9f87dad01f76099df841333889 | 287 | asm | Assembly | data/pokemon/pickup_mons.asm | AtmaBuster/pokeplat-gen2 | fa83b2e75575949b8f72cb2c48f7a1042e97f70f | [
"blessing"
] | 6 | 2021-06-19T06:41:19.000Z | 2022-02-15T17:12:33.000Z | data/pokemon/pickup_mons.asm | AtmaBuster/pokeplat-gen2-old | 01e42c55db5408d72d89133dc84a46c699d849ad | [
"blessing"
] | null | null | null | data/pokemon/pickup_mons.asm | AtmaBuster/pokeplat-gen2-old | 01e42c55db5408d72d89133dc84a46c699d849ad | [
"blessing"
] | 3 | 2021-01-15T18:45:40.000Z | 2021-10-16T03:35:27.000Z | SECTION "Pickup Data", ROMX
_IsPickupMon::
ld a, b
call GetPokemonIndexFromID
ld b, h
ld c, l
ld hl, PickupMons
ld de, 2
call IsInHalfwordArray
ret
PickupMons:
dw MEOWTH
dw AIPOM
dw TEDDIURSA
dw PHANPY
dw ZIGZAGOON
dw LINOONE
dw PACHIRISU
dw AMBIPOM
dw MUNCHLAX
dw -1
| 12.478261 | 27 | 0.731707 |
20453f39ae6d7372c0e481d8ddb3e31d5f3f8374 | 6,583 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_1010_787.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_1010_787.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_1010_787.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r14
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0x1c5ef, %rsi
lea addresses_UC_ht+0xd6b5, %rdi
nop
nop
xor %rdx, %rdx
mov $56, %rcx
rep movsb
nop
nop
nop
nop
cmp $8709, %r14
lea addresses_A_ht+0x1db41, %r11
nop
xor %rdi, %rdi
mov $0x6162636465666768, %rcx
movq %rcx, %xmm2
movups %xmm2, (%r11)
nop
nop
nop
add %rsi, %rsi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r14
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %r15
push %rax
push %rcx
push %rdi
push %rdx
// Load
lea addresses_WT+0x12c95, %rax
nop
nop
nop
nop
and $49343, %rdi
mov (%rax), %rcx
nop
nop
nop
nop
sub %rcx, %rcx
// Store
mov $0x15, %rdi
nop
nop
dec %r11
mov $0x5152535455565758, %rdx
movq %rdx, %xmm3
movups %xmm3, (%rdi)
nop
dec %r15
// Store
lea addresses_PSE+0x18de5, %rcx
inc %r15
movl $0x51525354, (%rcx)
nop
nop
nop
nop
sub $33290, %r15
// Store
lea addresses_PSE+0x100b5, %r13
nop
nop
nop
nop
and %rdi, %rdi
movl $0x51525354, (%r13)
nop
nop
cmp %r15, %r15
// Store
lea addresses_A+0x1b995, %rax
nop
and %rcx, %rcx
movw $0x5152, (%rax)
nop
nop
add $28439, %rdi
// Store
lea addresses_A+0x7e95, %r15
nop
nop
inc %rcx
movw $0x5152, (%r15)
nop
nop
nop
nop
nop
xor $13010, %r11
// Store
lea addresses_WT+0x6f4d, %rax
nop
nop
xor $258, %rdi
movw $0x5152, (%rax)
nop
nop
sub $13150, %r13
// Store
lea addresses_WT+0x18a15, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
add $50030, %r11
mov $0x5152535455565758, %rdx
movq %rdx, %xmm4
vmovaps %ymm4, (%rdi)
nop
nop
nop
cmp %r11, %r11
// Store
lea addresses_UC+0x1b295, %rax
nop
nop
nop
xor $11783, %r11
movb $0x51, (%rax)
nop
add %r13, %r13
// Faulty Load
lea addresses_WT+0x12c95, %r13
nop
xor %r15, %r15
mov (%r13), %rdi
lea oracles, %rax
and $0xff, %rdi
shlq $12, %rdi
mov (%rax,%rdi,1), %rdi
pop %rdx
pop %rdi
pop %rcx
pop %rax
pop %r15
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_WT', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_WT', 'size': 8, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_P', 'size': 16, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 4, 'NT': False, 'type': 'addresses_PSE', 'size': 4, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 5, 'NT': False, 'type': 'addresses_PSE', 'size': 4, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 7, 'NT': False, 'type': 'addresses_A', 'size': 2, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 9, 'NT': False, 'type': 'addresses_A', 'size': 2, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 3, 'NT': False, 'type': 'addresses_WT', 'size': 2, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_WT', 'size': 32, 'AVXalign': True}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_UC', 'size': 1, 'AVXalign': True}}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_WT', 'size': 8, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WC_ht', 'congruent': 1, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_A_ht', 'size': 16, 'AVXalign': False}}
{'39': 1010}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
| 33.93299 | 2,999 | 0.651071 |
c50cadd16403d20e462065ab3db402b4548f72a4 | 7,876 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_1385.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_1385.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_1385.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r8
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x18739, %r11
inc %r13
mov $0x6162636465666768, %r8
movq %r8, %xmm7
movups %xmm7, (%r11)
nop
nop
nop
sub $37695, %r13
lea addresses_D_ht+0x165e0, %rsi
lea addresses_D_ht+0x12339, %rdi
clflush (%rdi)
dec %rbx
mov $54, %rcx
rep movsb
nop
dec %rbx
lea addresses_A_ht+0xc0e9, %r8
nop
nop
nop
nop
nop
sub %rcx, %rcx
mov (%r8), %di
nop
cmp $16460, %r8
lea addresses_normal_ht+0x1d507, %rbx
and %r11, %r11
mov $0x6162636465666768, %r8
movq %r8, %xmm3
movups %xmm3, (%rbx)
nop
add %rsi, %rsi
lea addresses_WC_ht+0x1beb9, %rcx
nop
nop
nop
add %rbx, %rbx
movw $0x6162, (%rcx)
nop
nop
nop
xor %r11, %r11
lea addresses_normal_ht+0x1e5f9, %rsi
lea addresses_A_ht+0x1a145, %rdi
xor %rbp, %rbp
mov $9, %rcx
rep movsl
sub $9652, %r8
lea addresses_UC_ht+0x1a02c, %rsi
lea addresses_A_ht+0xf3bf, %rdi
nop
nop
xor $22013, %r11
mov $34, %rcx
rep movsq
nop
nop
xor %r11, %r11
lea addresses_normal_ht+0xbf39, %rsi
lea addresses_WC_ht+0xb239, %rdi
nop
nop
add $5140, %rbx
mov $122, %rcx
rep movsw
nop
nop
nop
nop
add $44297, %r11
lea addresses_WC_ht+0x6c39, %r8
sub %rcx, %rcx
mov (%r8), %rbx
nop
nop
nop
nop
nop
inc %rbx
lea addresses_normal_ht+0xd079, %rsi
lea addresses_A_ht+0xef39, %rdi
nop
nop
cmp %r11, %r11
mov $49, %rcx
rep movsb
nop
dec %r8
lea addresses_UC_ht+0x116c, %rbp
nop
xor %rcx, %rcx
mov $0x6162636465666768, %rbx
movq %rbx, %xmm1
vmovups %ymm1, (%rbp)
nop
nop
nop
cmp %r13, %r13
lea addresses_A_ht+0x7229, %r13
clflush (%r13)
nop
inc %rbp
mov $0x6162636465666768, %r8
movq %r8, %xmm6
movups %xmm6, (%r13)
nop
nop
add $45911, %r8
lea addresses_WC_ht+0x15739, %rsi
lea addresses_D_ht+0x1e739, %rdi
nop
and $24482, %r11
mov $39, %rcx
rep movsw
nop
nop
nop
cmp $41261, %rbp
lea addresses_WC_ht+0x18c5, %rsi
lea addresses_WT_ht+0x2f9, %rdi
nop
nop
xor %r11, %r11
mov $112, %rcx
rep movsl
nop
xor %rdi, %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r8
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r15
push %r9
push %rax
push %rcx
push %rdi
push %rsi
// Store
lea addresses_normal+0xfc91, %rcx
sub $26506, %rsi
mov $0x5152535455565758, %rax
movq %rax, %xmm1
movups %xmm1, (%rcx)
inc %rsi
// Faulty Load
lea addresses_WT+0x14f39, %r12
nop
nop
nop
sub $8198, %r15
mov (%r12), %edi
lea oracles, %r9
and $0xff, %rdi
shlq $12, %rdi
mov (%r9,%rdi,1), %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r15
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_WT', 'same': False, 'size': 1, 'congruent': 0, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_normal', 'same': False, 'size': 16, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_WT', 'same': True, 'size': 4, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 16, 'congruent': 7, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_D_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_A_ht', 'same': False, 'size': 2, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 16, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WC_ht', 'same': False, 'size': 2, 'congruent': 7, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 2, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_UC_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 8, 'congruent': 7, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_A_ht', 'same': True, 'size': 16, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 6, 'same': False}, 'OP': 'REPM'}
{'39': 21829}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
| 36.976526 | 2,999 | 0.659345 |
22ed0cdeb1dacbbf3f883aca83aaf9542502b3d2 | 1,110 | asm | Assembly | programs/oeis/055/A055944.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/055/A055944.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/055/A055944.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A055944: n + reversal of base 2 digits of n (written in base 10).
; 0,2,3,6,5,10,9,14,9,18,15,24,15,24,21,30,17,34,27,44,25,42,35,52,27,44,37,54,35,52,45,62,33,66,51,84,45,78,63,96,45,78,63,96,57,90,75,108,51,84,69,102,63,96,81,114,63,96,81,114,75,108,93,126,65,130,99,164,85,150,119,184,81,146,115,180,101,166,135,200,85,150,119,184,105,170,139,204,101,166,135,200,121,186,155,220,99,164,133,198,119,184,153,218,115,180,149,214,135,200,169,234,119,184,153,218,139,204,173,238,135,200,169,234,155,220,189,254,129,258,195,324,165,294,231,360,153,282,219,348,189,318,255,384,153,282,219,348,189,318,255,384,177,306,243,372,213,342,279,408,165,294,231,360,201,330,267,396,189,318,255,384,225,354,291,420,189,318,255,384,225,354,291,420,213,342,279,408,249,378,315,444,195,324,261,390,231,360,297,426,219,348,285,414,255,384,321,450,219,348,285,414,255,384,321,450,243,372,309,438,279,408,345,474,231,360,297,426,267,396,333,462,255,384,321,450,291,420,357,486,255,384,321,450,291,420,357,486,279,408
mov $2,$0
mov $3,$0
lpb $2
sub $0,$4
div $2,2
sub $0,$2
mov $4,$2
sub $4,$0
lpe
mov $1,$0
add $1,$3
| 74 | 930 | 0.700901 |
b931033e5cccd378236d42785ad6e65fa7bf9a7f | 361 | asm | Assembly | oeis/052/A052711.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/052/A052711.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/052/A052711.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A052711: E.g.f. x*(1-2*x-sqrt(1-4*x))/2.
; Submitted by Jamie Morken(s3)
; 0,0,0,6,48,600,10080,211680,5322240,155675520,5189184000,194075481600,8045310873600,366061644748800,18134130709094400,971471287987200000,55956746188062720000,3448334483839365120000
mov $1,$0
sub $1,3
mov $2,1
lpb $1
sub $1,1
add $2,2
mul $0,$2
mul $0,2
lpe
div $0,3
mul $0,6
| 22.5625 | 182 | 0.722992 |
e0d84e05becd21fd00ef5d5fadd2f62c659a4540 | 341 | asm | Assembly | programs/oeis/061/A061086.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/061/A061086.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/061/A061086.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A061086: a(n) is the concatenation of n with n^3.
; 11,28,327,464,5125,6216,7343,8512,9729,101000,111331,121728,132197,142744,153375,164096,174913,185832,196859,208000,219261,2210648,2312167,2413824,2515625,2617576,2719683,2821952,2924389,3027000,3129791,3232768,3335937
mov $2,1
add $2,$0
seq $0,61087 ; a(n) = A061086(n) / n.
mul $0,$2
| 42.625 | 220 | 0.753666 |
155e68eb24f0e38ce18c943e6fb729535893373f | 80 | asm | Assembly | src/kernel/start.asm | JohanLi2333/JAHA-OS | a960171a82411199f8f905a6495123efcfe8e988 | [
"MIT"
] | 2 | 2022-02-15T23:40:48.000Z | 2022-02-16T11:58:23.000Z | src/kernel/start.asm | JohanLi2333/JAHA-OS | a960171a82411199f8f905a6495123efcfe8e988 | [
"MIT"
] | null | null | null | src/kernel/start.asm | JohanLi2333/JAHA-OS | a960171a82411199f8f905a6495123efcfe8e988 | [
"MIT"
] | 1 | 2022-02-17T10:03:30.000Z | 2022-02-17T10:03:30.000Z | [bits 32]
extern kernel_init
global _start
_start:
call kernel_init
jmp $
| 8.888889 | 18 | 0.7375 |
afabc25347a78bd9d31ca8feef8ee3b96254bb5a | 8,611 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_ht_st_zr_/i7-8650U_0xd2_notsx.log_3388_79.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_ht_st_zr_/i7-8650U_0xd2_notsx.log_3388_79.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_ht_st_zr_/i7-8650U_0xd2_notsx.log_3388_79.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r12
push %r9
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x297f, %r9
nop
nop
nop
cmp $62403, %r12
movb $0x61, (%r9)
nop
nop
nop
nop
cmp %r10, %r10
lea addresses_WT_ht+0x9ff, %r11
nop
nop
nop
inc %r9
mov (%r11), %r12
nop
nop
and %r11, %r11
lea addresses_normal_ht+0x25ff, %rsi
lea addresses_D_ht+0x4d8d, %rdi
nop
nop
nop
nop
dec %r11
mov $73, %rcx
rep movsl
nop
nop
nop
nop
nop
xor $54220, %rcx
lea addresses_A_ht+0xe57f, %rsi
lea addresses_A_ht+0xd7fb, %rdi
nop
nop
and %r9, %r9
mov $19, %rcx
rep movsb
nop
nop
nop
xor %r9, %r9
lea addresses_A_ht+0x1d3ff, %rsi
lea addresses_normal_ht+0x27cf, %rdi
nop
nop
nop
dec %r9
mov $36, %rcx
rep movsw
nop
nop
nop
nop
cmp %rsi, %rsi
lea addresses_D_ht+0x195ff, %rbp
sub %r9, %r9
movb (%rbp), %r10b
nop
nop
nop
nop
xor %rcx, %rcx
lea addresses_WC_ht+0x213, %rdi
nop
nop
sub $38522, %r12
movb $0x61, (%rdi)
nop
nop
nop
cmp %rdi, %rdi
lea addresses_D_ht+0x19d0f, %rdi
sub $10306, %rcx
mov (%rdi), %r9d
nop
nop
nop
nop
xor $54535, %r11
lea addresses_D_ht+0xc47f, %rsi
lea addresses_D_ht+0xfa3f, %rdi
clflush (%rsi)
nop
cmp %r11, %r11
mov $97, %rcx
rep movsq
nop
nop
nop
nop
nop
sub %rsi, %rsi
lea addresses_D_ht+0x173ff, %rsi
lea addresses_D_ht+0x1519f, %rdi
nop
nop
nop
nop
add $47196, %r9
mov $126, %rcx
rep movsl
nop
nop
nop
inc %r9
lea addresses_UC_ht+0xd35f, %r12
clflush (%r12)
nop
nop
nop
nop
nop
cmp %rsi, %rsi
movb $0x61, (%r12)
nop
nop
nop
nop
nop
sub $31971, %rsi
lea addresses_D_ht+0x59ff, %r12
add $9296, %r9
movb $0x61, (%r12)
nop
xor $12270, %rbp
lea addresses_normal_ht+0x109ff, %rbp
sub %r11, %r11
mov $0x6162636465666768, %r12
movq %r12, %xmm4
vmovups %ymm4, (%rbp)
nop
cmp $44127, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r12
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r14
push %r9
push %rax
push %rcx
push %rdi
push %rsi
// Store
lea addresses_WC+0x7abf, %rsi
nop
nop
nop
nop
nop
cmp $32842, %rax
movb $0x51, (%rsi)
nop
nop
nop
nop
sub %rax, %rax
// Store
lea addresses_WC+0x2aff, %r14
nop
nop
and %r11, %r11
mov $0x5152535455565758, %rsi
movq %rsi, %xmm3
movups %xmm3, (%r14)
nop
nop
nop
sub %rax, %rax
// REPMOV
lea addresses_normal+0x1dcff, %rsi
lea addresses_PSE+0x5d1f, %rdi
dec %r12
mov $57, %rcx
rep movsw
nop
nop
nop
nop
dec %rax
// Store
lea addresses_WC+0x123f, %r11
nop
nop
nop
cmp %rsi, %rsi
movw $0x5152, (%r11)
nop
nop
nop
xor %r9, %r9
// Store
lea addresses_WT+0x149ff, %rdi
clflush (%rdi)
nop
xor %rsi, %rsi
mov $0x5152535455565758, %rcx
movq %rcx, (%rdi)
nop
nop
sub $32184, %rcx
// Faulty Load
lea addresses_A+0x181ff, %r11
nop
nop
xor %r9, %r9
movntdqa (%r11), %xmm2
vpextrq $1, %xmm2, %r14
lea oracles, %r11
and $0xff, %r14
shlq $12, %r14
mov (%r11,%r14,1), %r14
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r14
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_A', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'size': 1, 'AVXalign': False, 'NT': True, 'congruent': 2, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_PSE', 'congruent': 5, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 6, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_A', 'size': 16, 'AVXalign': False, 'NT': True, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 1, 'AVXalign': False, 'NT': True, 'congruent': 6, 'same': True}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 10, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 1, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 0, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 3, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'size': 1, 'AVXalign': False, 'NT': True, 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 4, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 5, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': True, 'NT': False, 'congruent': 5, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'00': 476, '34': 2591, '46': 142, '45': 154, '44': 25}
00 34 34 00 34 34 00 00 34 34 34 34 34 34 34 34 46 45 34 34 34 34 34 34 46 34 34 00 00 34 00 34 34 00 34 34 00 00 34 34 34 00 44 00 34 34 34 34 34 34 34 34 46 45 34 34 34 34 00 00 34 34 46 00 34 34 00 00 34 34 34 46 34 00 00 34 34 00 00 00 34 34 34 34 45 34 45 34 34 34 00 46 34 00 34 00 00 34 34 34 46 00 34 00 34 34 34 34 34 34 00 00 00 00 00 34 00 45 00 34 34 00 34 00 46 00 00 34 44 34 34 34 34 00 00 46 46 46 34 46 34 34 34 00 00 00 34 34 45 45 45 34 34 46 46 00 00 00 34 45 46 45 00 34 34 34 45 00 34 34 00 44 34 34 46 00 34 34 34 00 46 34 46 00 34 34 34 34 34 34 34 00 34 46 34 34 34 34 00 34 34 34 34 34 34 34 00 34 34 34 34 34 34 34 34 34 34 34 00 34 34 34 34 34 34 34 34 34 34 34 34 46 00 34 34 34 34 34 34 34 34 34 34 34 46 34 00 00 34 45 34 34 45 34 34 34 34 34 34 00 00 34 34 34 34 34 34 34 34 34 34 00 34 34 34 34 34 46 34 34 34 34 34 34 34 00 45 34 34 34 00 34 00 34 45 45 34 34 34 34 34 34 00 34 34 34 34 46 34 34 34 34 34 34 34 34 34 34 34 34 34 00 34 34 45 34 00 00 00 00 46 45 34 34 34 34 34 34 34 34 34 34 34 00 34 45 34 34 34 34 34 00 34 34 34 34 34 34 34 00 34 34 34 34 00 34 34 34 34 34 34 34 00 34 34 34 34 00 34 34 00 34 45 46 34 34 34 00 34 00 34 46 45 34 34 34 34 34 00 34 45 46 00 34 34 34 34 00 00 34 34 34 34 34 34 44 00 46 34 34 34 00 34 34 46 00 34 00 34 34 44 34 34 34 34 34 45 00 00 46 34 00 00 34 34 34 34 34 34 34 34 34 34 00 34 34 34 44 34 34 34 34 34 34 34 34 34 34 34 34 34 34 00 00 34 34 34 00 34 45 34 34 34 34 34 34 34 34 00 00 46 34 34 34 34 34 34 34 34 34 44 34 34 34 34 46 34 45 34 34 34 34 34 34 34 34 34 34 34 46 34 34 34 34 34 34 34 46 34 34 00 00 34 34 45 34 34 34 00 34 34 34 34 34 44 34 45 34 34 34 34 34 44 34 34 46 34 46 34 34 34 34 34 34 34 34 34 34 34 34 00 34 34 34 34 34 34 45 34 34 00 34 34 34 34 34 34 34 46 34 34 34 34 34 34 34 34 00 34 34 34 34 34 34 34 34 00 00 34 00 34 34 34 00 34 34 34 34 00 45 34 34 34 34 34 34 34 34 34 45 34 34 34 34 34 34 00 34 34 00 34 00 34 34 34 34 34 34 34 34 34 34 34 46 00 34 34 34 34 45 34 34 34 34 34 34 34 34 34 46 34 34 34 34 00 34 34 00 34 34 34 34 34 34 34 00 00 44 00 34 34 34 45 00 00 34 34 45 34 34 46 34 34 00 34 00 34 45 00 34 45 00 00 34 34 34 00 34 34 34 34 46 45 34 00 44 00 00 34 34 34 34 34 45 00 00 00 34 46 34 34 34 34 34 34 46 34 34 34 34 00 34 34 34 46 00 34 00 34 00 34 00 00 00 34 00 46 45 34 46 34 00 34 34 34 00 00 45 00 34 34 00 00 46 34 00 00 34 34 00 34 34 34 34 34 34 00 46 46 00 45 34 34 34 34 34 34 34 46 34 46 34 00 00 34 34 00 34 34 34 34 34 00 34 34 00 34 34 00 34 34 46 00 34 46 34 46 34 34 00 34 45 34 00 00 34 45 00 00 34 34 45 34 45 34 46 34 34 34 46 44 00 34 34 00 34 34 00 34 34 34 34 45 45 46 34 34 34 34 34 34 34 34 44 34 34 44 34 34 45 34 34 34 00 34 34 34 34 34 34 34 45 34 00 34 45 00 34 34 34 34 34 34 34 00 34 34 34 34 34 00 34 34 00 00 34 34 34 34 34 00 34 34 34 34 34 34 34 00 34 00 34 34 34 00 34 34 34 34 34 34 34 34 34 34 00 34 34 34 34 34 45 00 34 45 34 00 34 34 34 34 34 00 34 46 34 34 46 34 34 00 34 34 34 34 00 00 34 34 34 34 34 34 34 34 46 45 34 45 00
*/
| 30.644128 | 2,999 | 0.652654 |
68df35275ae8b54c50c835493b37a281375b6689 | 6,172 | asm | Assembly | Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xca.log_21829_181.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xca.log_21829_181.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xca.log_21829_181.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x17be3, %r11
nop
nop
nop
and $5421, %rbp
mov (%r11), %eax
nop
nop
nop
nop
sub %r13, %r13
lea addresses_A_ht+0x13217, %rbx
nop
nop
xor %rdi, %rdi
mov $0x6162636465666768, %rax
movq %rax, (%rbx)
xor %rdi, %rdi
lea addresses_WT_ht+0x40d3, %rbp
nop
dec %rsi
mov $0x6162636465666768, %rax
movq %rax, (%rbp)
nop
nop
add %rsi, %rsi
lea addresses_UC_ht+0xb063, %rsi
lea addresses_UC_ht+0x1ca3, %rdi
cmp $31709, %rbp
mov $16, %rcx
rep movsw
sub %r13, %r13
lea addresses_WT_ht+0x13be3, %rbp
sub %r11, %r11
vmovups (%rbp), %ymm2
vextracti128 $0, %ymm2, %xmm2
vpextrq $0, %xmm2, %rdi
nop
nop
nop
nop
nop
and $46292, %rsi
lea addresses_UC_ht+0x16be3, %rsi
lea addresses_D_ht+0x494b, %rdi
nop
nop
and %rax, %rax
mov $66, %rcx
rep movsw
nop
nop
sub %rbx, %rbx
lea addresses_normal_ht+0xdbe3, %rbp
add $40148, %rdi
movl $0x61626364, (%rbp)
nop
dec %rbp
lea addresses_WT_ht+0x131e3, %r13
nop
nop
nop
add %rsi, %rsi
mov $0x6162636465666768, %rdi
movq %rdi, (%r13)
nop
and %rdi, %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r9
push %rbx
push %rcx
push %rdx
// Store
lea addresses_UC+0x563, %r13
nop
nop
and $23437, %rbx
mov $0x5152535455565758, %rdx
movq %rdx, (%r13)
nop
nop
nop
nop
nop
cmp $36168, %rdx
// Faulty Load
lea addresses_UC+0x73e3, %rcx
clflush (%rcx)
nop
nop
nop
nop
nop
cmp %rbx, %rbx
movb (%rcx), %r9b
lea oracles, %r13
and $0xff, %r9
shlq $12, %r9
mov (%r13,%r9,1), %r9
pop %rdx
pop %rcx
pop %rbx
pop %r9
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_UC', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': True, 'type': 'addresses_UC', 'same': False, 'AVXalign': False, 'congruent': 7}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_UC', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 7}, 'dst': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 3}}
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_WT_ht', 'same': True, 'AVXalign': False, 'congruent': 11}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 11}, 'dst': {'same': False, 'type': 'addresses_D_ht', 'congruent': 2}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 11}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 40.605263 | 2,999 | 0.657971 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.