cs352/project1
2
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
project1/obj/kern/kernel.asm

3350 lines
134 KiB
NASM
Raw Normal View History

inital checkout from try
2024-09-25 19:00:19 +00:00
obj/kern/kernel: file format elf32-i386
Disassembly of section .text:
f0100000 <_start+0xeffffff4>:
.globl _start
_start = RELOC(entry)
.globl entry
entry:
movw $0x1234,0x472 # warm boot
f0100000: 02 b0 ad 1b 00 00 add 0x1bad(%eax),%dh
f0100006: 00 00 add %al,(%eax)
f0100008: fe 4f 52 decb 0x52(%edi)
f010000b: e4 .byte 0xe4
f010000c <entry>:
f010000c: 66 c7 05 72 04 00 00 movw $0x1234,0x472
f0100013: 34 12
# sufficient until we set up our real page table in mem_init
# in lab 2.
# Load the physical address of entry_pgdir into cr3. entry_pgdir
# is defined in entrypgdir.c.
movl $(RELOC(entry_pgdir)), %eax
f0100015: b8 00 00 11 00 mov $0x110000,%eax
movl %eax, %cr3
f010001a: 0f 22 d8 mov %eax,%cr3
# Turn on paging.
movl %cr0, %eax
f010001d: 0f 20 c0 mov %cr0,%eax
orl $(CR0_PE|CR0_PG|CR0_WP), %eax
f0100020: 0d 01 00 01 80 or $0x80010001,%eax
movl %eax, %cr0
f0100025: 0f 22 c0 mov %eax,%cr0
# Now paging is enabled, but we're still running at a low EIP
# (why is this okay?). Jump up above KERNBASE before entering
# C code.
mov $relocated, %eax
f0100028: b8 2f 00 10 f0 mov $0xf010002f,%eax
jmp *%eax
f010002d: ff e0 jmp *%eax
f010002f <relocated>:
relocated:
# Clear the frame pointer register (EBP)
# so that once we get into debugging C code,
# stack backtraces will be terminated properly.
movl $0x0,%ebp # nuke frame pointer
f010002f: bd 00 00 00 00 mov $0x0,%ebp
# Set the stack pointer
movl $(bootstacktop),%esp
f0100034: bc 00 00 11 f0 mov $0xf0110000,%esp
# now to C code
call i386_init
f0100039: e8 5a 00 00 00 call f0100098 <i386_init>
f010003e <spin>:
# Should never get here, but in case we do, just spin.
spin: jmp spin
f010003e: eb fe jmp f010003e <spin>
f0100040 <test_backtrace>:
#include <kern/console.h>
// Test the stack backtrace function (lab 1 only)
void
test_backtrace(int x)
{
f0100040: f3 0f 1e fb endbr32
f0100044: 55 push %ebp
f0100045: 89 e5 mov %esp,%ebp
f0100047: 53 push %ebx
f0100048: 83 ec 0c sub $0xc,%esp
f010004b: 8b 5d 08 mov 0x8(%ebp),%ebx
cprintf("entering test_backtrace %d\n", x);
f010004e: 53 push %ebx
f010004f: 68 a0 18 10 f0 push $0xf01018a0
f0100054: e8 ce 08 00 00 call f0100927 <cprintf>
if (x > 0)
f0100059: 83 c4 10 add $0x10,%esp
f010005c: 85 db test %ebx,%ebx
f010005e: 7e 25 jle f0100085 <test_backtrace+0x45>
test_backtrace(x-1);
f0100060: 83 ec 0c sub $0xc,%esp
f0100063: 8d 43 ff lea -0x1(%ebx),%eax
f0100066: 50 push %eax
f0100067: e8 d4 ff ff ff call f0100040 <test_backtrace>
f010006c: 83 c4 10 add $0x10,%esp
else
mon_backtrace(0, 0, 0);
cprintf("leaving test_backtrace %d\n", x);
f010006f: 83 ec 08 sub $0x8,%esp
f0100072: 53 push %ebx
f0100073: 68 bc 18 10 f0 push $0xf01018bc
f0100078: e8 aa 08 00 00 call f0100927 <cprintf>
}
f010007d: 83 c4 10 add $0x10,%esp
f0100080: 8b 5d fc mov -0x4(%ebp),%ebx
f0100083: c9 leave
f0100084: c3 ret
mon_backtrace(0, 0, 0);
f0100085: 83 ec 04 sub $0x4,%esp
f0100088: 6a 00 push $0x0
f010008a: 6a 00 push $0x0
f010008c: 6a 00 push $0x0
f010008e: e8 ff 06 00 00 call f0100792 <mon_backtrace>
f0100093: 83 c4 10 add $0x10,%esp
f0100096: eb d7 jmp f010006f <test_backtrace+0x2f>
f0100098 <i386_init>:
void
i386_init(void)
{
f0100098: f3 0f 1e fb endbr32
f010009c: 55 push %ebp
f010009d: 89 e5 mov %esp,%ebp
f010009f: 83 ec 0c sub $0xc,%esp
extern char edata[], end[];
// Before doing anything else, complete the ELF loading process.
// Clear the uninitialized global data (BSS) section of our program.
// This ensures that all static/global variables start out zero.
memset(edata, 0, end - edata);
f01000a2: b8 40 29 11 f0 mov $0xf0112940,%eax
f01000a7: 2d 00 23 11 f0 sub $0xf0112300,%eax
f01000ac: 50 push %eax
f01000ad: 6a 00 push $0x0
f01000af: 68 00 23 11 f0 push $0xf0112300
f01000b4: e8 62 13 00 00 call f010141b <memset>
// Initialize the console.
// Can't call cprintf until after we do this!
cons_init();
f01000b9: e8 af 04 00 00 call f010056d <cons_init>
cprintf("6828 decimal is %o octal!\n", 6828);
f01000be: 83 c4 08 add $0x8,%esp
f01000c1: 68 ac 1a 00 00 push $0x1aac
f01000c6: 68 d7 18 10 f0 push $0xf01018d7
f01000cb: e8 57 08 00 00 call f0100927 <cprintf>
// Test the stack backtrace function (lab 1 only)
test_backtrace(5);
f01000d0: c7 04 24 05 00 00 00 movl $0x5,(%esp)
f01000d7: e8 64 ff ff ff call f0100040 <test_backtrace>
f01000dc: 83 c4 10 add $0x10,%esp
// Drop into the kernel monitor.
while (1)
monitor(NULL);
f01000df: 83 ec 0c sub $0xc,%esp
f01000e2: 6a 00 push $0x0
f01000e4: e8 b3 06 00 00 call f010079c <monitor>
f01000e9: 83 c4 10 add $0x10,%esp
f01000ec: eb f1 jmp f01000df <i386_init+0x47>
f01000ee <_panic>:
* Panic is called on unresolvable fatal errors.
* It prints "panic: mesg", and then enters the kernel monitor.
*/
void
_panic(const char *file, int line, const char *fmt,...)
{
f01000ee: f3 0f 1e fb endbr32
f01000f2: 55 push %ebp
f01000f3: 89 e5 mov %esp,%ebp
f01000f5: 56 push %esi
f01000f6: 53 push %ebx
f01000f7: 8b 75 10 mov 0x10(%ebp),%esi
va_list ap;
if (panicstr)
f01000fa: 83 3d 44 29 11 f0 00 cmpl $0x0,0xf0112944
f0100101: 74 0f je f0100112 <_panic+0x24>
va_end(ap);
dead:
/* break into the kernel monitor */
while (1)
monitor(NULL);
f0100103: 83 ec 0c sub $0xc,%esp
f0100106: 6a 00 push $0x0
f0100108: e8 8f 06 00 00 call f010079c <monitor>
f010010d: 83 c4 10 add $0x10,%esp
f0100110: eb f1 jmp f0100103 <_panic+0x15>
panicstr = fmt;
f0100112: 89 35 44 29 11 f0 mov %esi,0xf0112944
asm volatile("cli; cld");
f0100118: fa cli
f0100119: fc cld
va_start(ap, fmt);
f010011a: 8d 5d 14 lea 0x14(%ebp),%ebx
cprintf("kernel panic at %s:%d: ", file, line);
f010011d: 83 ec 04 sub $0x4,%esp
f0100120: ff 75 0c pushl 0xc(%ebp)
f0100123: ff 75 08 pushl 0x8(%ebp)
f0100126: 68 f2 18 10 f0 push $0xf01018f2
f010012b: e8 f7 07 00 00 call f0100927 <cprintf>
vcprintf(fmt, ap);
f0100130: 83 c4 08 add $0x8,%esp
f0100133: 53 push %ebx
f0100134: 56 push %esi
f0100135: e8 c3 07 00 00 call f01008fd <vcprintf>
cprintf("\n");
f010013a: c7 04 24 2e 19 10 f0 movl $0xf010192e,(%esp)
f0100141: e8 e1 07 00 00 call f0100927 <cprintf>
f0100146: 83 c4 10 add $0x10,%esp
f0100149: eb b8 jmp f0100103 <_panic+0x15>
f010014b <_warn>:
}
/* like panic, but don't */
void
_warn(const char *file, int line, const char *fmt,...)
{
f010014b: f3 0f 1e fb endbr32
f010014f: 55 push %ebp
f0100150: 89 e5 mov %esp,%ebp
f0100152: 53 push %ebx
f0100153: 83 ec 08 sub $0x8,%esp
va_list ap;
va_start(ap, fmt);
f0100156: 8d 5d 14 lea 0x14(%ebp),%ebx
cprintf("kernel warning at %s:%d: ", file, line);
f0100159: ff 75 0c pushl 0xc(%ebp)
f010015c: ff 75 08 pushl 0x8(%ebp)
f010015f: 68 0a 19 10 f0 push $0xf010190a
f0100164: e8 be 07 00 00 call f0100927 <cprintf>
vcprintf(fmt, ap);
f0100169: 83 c4 08 add $0x8,%esp
f010016c: 53 push %ebx
f010016d: ff 75 10 pushl 0x10(%ebp)
f0100170: e8 88 07 00 00 call f01008fd <vcprintf>
cprintf("\n");
f0100175: c7 04 24 2e 19 10 f0 movl $0xf010192e,(%esp)
f010017c: e8 a6 07 00 00 call f0100927 <cprintf>
va_end(ap);
}
f0100181: 83 c4 10 add $0x10,%esp
f0100184: 8b 5d fc mov -0x4(%ebp),%ebx
f0100187: c9 leave
f0100188: c3 ret
f0100189 <serial_proc_data>:
static bool serial_exists;
static int
serial_proc_data(void)
{
f0100189: f3 0f 1e fb endbr32
static inline uint8_t
inb(int port)
{
uint8_t data;
asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
f010018d: ba fd 03 00 00 mov $0x3fd,%edx
f0100192: ec in (%dx),%al
if (!(inb(COM1+COM_LSR) & COM_LSR_DATA))
f0100193: a8 01 test $0x1,%al
f0100195: 74 0a je f01001a1 <serial_proc_data+0x18>
f0100197: ba f8 03 00 00 mov $0x3f8,%edx
f010019c: ec in (%dx),%al
return -1;
return inb(COM1+COM_RX);
f010019d: 0f b6 c0 movzbl %al,%eax
f01001a0: c3 ret
return -1;
f01001a1: b8 ff ff ff ff mov $0xffffffff,%eax
}
f01001a6: c3 ret
f01001a7 <cons_intr>:
// called by device interrupt routines to feed input characters
// into the circular console input buffer.
static void
cons_intr(int (*proc)(void))
{
f01001a7: 55 push %ebp
f01001a8: 89 e5 mov %esp,%ebp
f01001aa: 53 push %ebx
f01001ab: 83 ec 04 sub $0x4,%esp
f01001ae: 89 c3 mov %eax,%ebx
int c;
while ((c = (*proc)()) != -1) {
f01001b0: ff d3 call *%ebx
f01001b2: 83 f8 ff cmp $0xffffffff,%eax
f01001b5: 74 29 je f01001e0 <cons_intr+0x39>
if (c == 0)
f01001b7: 85 c0 test %eax,%eax
f01001b9: 74 f5 je f01001b0 <cons_intr+0x9>
continue;
cons.buf[cons.wpos++] = c;
f01001bb: 8b 0d 24 25 11 f0 mov 0xf0112524,%ecx
f01001c1: 8d 51 01 lea 0x1(%ecx),%edx
f01001c4: 88 81 20 23 11 f0 mov %al,-0xfeedce0(%ecx)
if (cons.wpos == CONSBUFSIZE)
f01001ca: 81 fa 00 02 00 00 cmp $0x200,%edx
cons.wpos = 0;
f01001d0: b8 00 00 00 00 mov $0x0,%eax
f01001d5: 0f 44 d0 cmove %eax,%edx
f01001d8: 89 15 24 25 11 f0 mov %edx,0xf0112524
f01001de: eb d0 jmp f01001b0 <cons_intr+0x9>
}
}
f01001e0: 83 c4 04 add $0x4,%esp
f01001e3: 5b pop %ebx
f01001e4: 5d pop %ebp
f01001e5: c3 ret
f01001e6 <kbd_proc_data>:
{
f01001e6: f3 0f 1e fb endbr32
f01001ea: 55 push %ebp
f01001eb: 89 e5 mov %esp,%ebp
f01001ed: 53 push %ebx
f01001ee: 83 ec 04 sub $0x4,%esp
f01001f1: ba 64 00 00 00 mov $0x64,%edx
f01001f6: ec in (%dx),%al
if ((stat & KBS_DIB) == 0)
f01001f7: a8 01 test $0x1,%al
f01001f9: 0f 84 f2 00 00 00 je f01002f1 <kbd_proc_data+0x10b>
if (stat & KBS_TERR)
f01001ff: a8 20 test $0x20,%al
f0100201: 0f 85 f1 00 00 00 jne f01002f8 <kbd_proc_data+0x112>
f0100207: ba 60 00 00 00 mov $0x60,%edx
f010020c: ec in (%dx),%al
f010020d: 89 c2 mov %eax,%edx
if (data == 0xE0) {
f010020f: 3c e0 cmp $0xe0,%al
f0100211: 74 61 je f0100274 <kbd_proc_data+0x8e>
} else if (data & 0x80) {
f0100213: 84 c0 test %al,%al
f0100215: 78 70 js f0100287 <kbd_proc_data+0xa1>
} else if (shift & E0ESC) {
f0100217: 8b 0d 00 23 11 f0 mov 0xf0112300,%ecx
f010021d: f6 c1 40 test $0x40,%cl
f0100220: 74 0e je f0100230 <kbd_proc_data+0x4a>
data |= 0x80;
f0100222: 83 c8 80 or $0xffffff80,%eax
f0100225: 89 c2 mov %eax,%edx
shift &= ~E0ESC;
f0100227: 83 e1 bf and $0xffffffbf,%ecx
f010022a: 89 0d 00 23 11 f0 mov %ecx,0xf0112300
shift |= shiftcode[data];
f0100230: 0f b6 d2 movzbl %dl,%edx
f0100233: 0f b6 82 80 1a 10 f0 movzbl -0xfefe580(%edx),%eax
f010023a: 0b 05 00 23 11 f0 or 0xf0112300,%eax
shift ^= togglecode[data];
f0100240: 0f b6 8a 80 19 10 f0 movzbl -0xfefe680(%edx),%ecx
f0100247: 31 c8 xor %ecx,%eax
f0100249: a3 00 23 11 f0 mov %eax,0xf0112300
c = charcode[shift & (CTL | SHIFT)][data];
f010024e: 89 c1 mov %eax,%ecx
f0100250: 83 e1 03 and $0x3,%ecx
f0100253: 8b 0c 8d 60 19 10 f0 mov -0xfefe6a0(,%ecx,4),%ecx
f010025a: 0f b6 14 11 movzbl (%ecx,%edx,1),%edx
f010025e: 0f b6 da movzbl %dl,%ebx
if (shift & CAPSLOCK) {
f0100261: a8 08 test $0x8,%al
f0100263: 74 61 je f01002c6 <kbd_proc_data+0xe0>
if ('a' <= c && c <= 'z')
f0100265: 89 da mov %ebx,%edx
f0100267: 8d 4b 9f lea -0x61(%ebx),%ecx
f010026a: 83 f9 19 cmp $0x19,%ecx
f010026d: 77 4b ja f01002ba <kbd_proc_data+0xd4>
c += 'A' - 'a';
f010026f: 83 eb 20 sub $0x20,%ebx
f0100272: eb 0c jmp f0100280 <kbd_proc_data+0x9a>
shift |= E0ESC;
f0100274: 83 0d 00 23 11 f0 40 orl $0x40,0xf0112300
return 0;
f010027b: bb 00 00 00 00 mov $0x0,%ebx
}
f0100280: 89 d8 mov %ebx,%eax
f0100282: 8b 5d fc mov -0x4(%ebp),%ebx
f0100285: c9 leave
f0100286: c3 ret
data = (shift & E0ESC ? data : data & 0x7F);
f0100287: 8b 0d 00 23 11 f0 mov 0xf0112300,%ecx
f010028d: 89 cb mov %ecx,%ebx
f010028f: 83 e3 40 and $0x40,%ebx
f0100292: 83 e0 7f and $0x7f,%eax
f0100295: 85 db test %ebx,%ebx
f0100297: 0f 44 d0 cmove %eax,%edx
shift &= ~(shiftcode[data] | E0ESC);
f010029a: 0f b6 d2 movzbl %dl,%edx
f010029d: 0f b6 82 80 1a 10 f0 movzbl -0xfefe580(%edx),%eax
f01002a4: 83 c8 40 or $0x40,%eax
f01002a7: 0f b6 c0 movzbl %al,%eax
f01002aa: f7 d0 not %eax
f01002ac: 21 c8 and %ecx,%eax
f01002ae: a3 00 23 11 f0 mov %eax,0xf0112300
return 0;
f01002b3: bb 00 00 00 00 mov $0x0,%ebx
f01002b8: eb c6 jmp f0100280 <kbd_proc_data+0x9a>
else if ('A' <= c && c <= 'Z')
f01002ba: 83 ea 41 sub $0x41,%edx
c += 'a' - 'A';
f01002bd: 8d 4b 20 lea 0x20(%ebx),%ecx
f01002c0: 83 fa 1a cmp $0x1a,%edx
f01002c3: 0f 42 d9 cmovb %ecx,%ebx
if (!(~shift & (CTL | ALT)) && c == KEY_DEL) {
f01002c6: f7 d0 not %eax
f01002c8: a8 06 test $0x6,%al
f01002ca: 75 b4 jne f0100280 <kbd_proc_data+0x9a>
f01002cc: 81 fb e9 00 00 00 cmp $0xe9,%ebx
f01002d2: 75 ac jne f0100280 <kbd_proc_data+0x9a>
cprintf("Rebooting!\n");
f01002d4: 83 ec 0c sub $0xc,%esp
f01002d7: 68 24 19 10 f0 push $0xf0101924
f01002dc: e8 46 06 00 00 call f0100927 <cprintf>
}
static inline void
outb(int port, uint8_t data)
{
asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
f01002e1: b8 03 00 00 00 mov $0x3,%eax
f01002e6: ba 92 00 00 00 mov $0x92,%edx
f01002eb: ee out %al,(%dx)
}
f01002ec: 83 c4 10 add $0x10,%esp
f01002ef: eb 8f jmp f0100280 <kbd_proc_data+0x9a>
return -1;
f01002f1: bb ff ff ff ff mov $0xffffffff,%ebx
f01002f6: eb 88 jmp f0100280 <kbd_proc_data+0x9a>
return -1;
f01002f8: bb ff ff ff ff mov $0xffffffff,%ebx
f01002fd: eb 81 jmp f0100280 <kbd_proc_data+0x9a>
f01002ff <cons_putc>:
}
// output a character to the console
static void
cons_putc(int c)
{
f01002ff: 55 push %ebp
f0100300: 89 e5 mov %esp,%ebp
f0100302: 57 push %edi
f0100303: 56 push %esi
f0100304: 53 push %ebx
f0100305: 83 ec 1c sub $0x1c,%esp
f0100308: 89 c1 mov %eax,%ecx
for (i = 0;
f010030a: be 00 00 00 00 mov $0x0,%esi
asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
f010030f: bf fd 03 00 00 mov $0x3fd,%edi
f0100314: bb 84 00 00 00 mov $0x84,%ebx
f0100319: 89 fa mov %edi,%edx
f010031b: ec in (%dx),%al
!(inb(COM1 + COM_LSR) & COM_LSR_TXRDY) && i < 12800;
f010031c: a8 20 test $0x20,%al
f010031e: 75 13 jne f0100333 <cons_putc+0x34>
f0100320: 81 fe ff 31 00 00 cmp $0x31ff,%esi
f0100326: 7f 0b jg f0100333 <cons_putc+0x34>
f0100328: 89 da mov %ebx,%edx
f010032a: ec in (%dx),%al
f010032b: ec in (%dx),%al
f010032c: ec in (%dx),%al
f010032d: ec in (%dx),%al
i++)
f010032e: 83 c6 01 add $0x1,%esi
f0100331: eb e6 jmp f0100319 <cons_putc+0x1a>
outb(COM1 + COM_TX, c);
f0100333: 88 4d e7 mov %cl,-0x19(%ebp)
asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
f0100336: ba f8 03 00 00 mov $0x3f8,%edx
f010033b: 89 c8 mov %ecx,%eax
f010033d: ee out %al,(%dx)
for (i = 0; !(inb(0x378+1) & 0x80) && i < 12800; i++)
f010033e: be 00 00 00 00 mov $0x0,%esi
asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
f0100343: bf 79 03 00 00 mov $0x379,%edi
f0100348: bb 84 00 00 00 mov $0x84,%ebx
f010034d: 89 fa mov %edi,%edx
f010034f: ec in (%dx),%al
f0100350: 81 fe ff 31 00 00 cmp $0x31ff,%esi
f0100356: 7f 0f jg f0100367 <cons_putc+0x68>
f0100358: 84 c0 test %al,%al
f010035a: 78 0b js f0100367 <cons_putc+0x68>
f010035c: 89 da mov %ebx,%edx
f010035e: ec in (%dx),%al
f010035f: ec in (%dx),%al
f0100360: ec in (%dx),%al
f0100361: ec in (%dx),%al
f0100362: 83 c6 01 add $0x1,%esi
f0100365: eb e6 jmp f010034d <cons_putc+0x4e>
asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
f0100367: ba 78 03 00 00 mov $0x378,%edx
f010036c: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
f0100370: ee out %al,(%dx)
f0100371: ba 7a 03 00 00 mov $0x37a,%edx
f0100376: b8 0d 00 00 00 mov $0xd,%eax
f010037b: ee out %al,(%dx)
f010037c: b8 08 00 00 00 mov $0x8,%eax
f0100381: ee out %al,(%dx)
c |= 0x0700;
f0100382: 89 c8 mov %ecx,%eax
f0100384: 80 cc 07 or $0x7,%ah
f0100387: f7 c1 00 ff ff ff test $0xffffff00,%ecx
f010038d: 0f 44 c8 cmove %eax,%ecx
switch (c & 0xff) {
f0100390: 0f b6 c1 movzbl %cl,%eax
f0100393: 80 f9 0a cmp $0xa,%cl
f0100396: 0f 84 dd 00 00 00 je f0100479 <cons_putc+0x17a>
f010039c: 83 f8 0a cmp $0xa,%eax
f010039f: 7f 46 jg f01003e7 <cons_putc+0xe8>
f01003a1: 83 f8 08 cmp $0x8,%eax
f01003a4: 0f 84 a7 00 00 00 je f0100451 <cons_putc+0x152>
f01003aa: 83 f8 09 cmp $0x9,%eax
f01003ad: 0f 85 d3 00 00 00 jne f0100486 <cons_putc+0x187>
cons_putc(' ');
f01003b3: b8 20 00 00 00 mov $0x20,%eax
f01003b8: e8 42 ff ff ff call f01002ff <cons_putc>
cons_putc(' ');
f01003bd: b8 20 00 00 00 mov $0x20,%eax
f01003c2: e8 38 ff ff ff call f01002ff <cons_putc>
cons_putc(' ');
f01003c7: b8 20 00 00 00 mov $0x20,%eax
f01003cc: e8 2e ff ff ff call f01002ff <cons_putc>
cons_putc(' ');
f01003d1: b8 20 00 00 00 mov $0x20,%eax
f01003d6: e8 24 ff ff ff call f01002ff <cons_putc>
cons_putc(' ');
f01003db: b8 20 00 00 00 mov $0x20,%eax
f01003e0: e8 1a ff ff ff call f01002ff <cons_putc>
break;
f01003e5: eb 25 jmp f010040c <cons_putc+0x10d>
switch (c & 0xff) {
f01003e7: 83 f8 0d cmp $0xd,%eax
f01003ea: 0f 85 96 00 00 00 jne f0100486 <cons_putc+0x187>
crt_pos -= (crt_pos % CRT_COLS);
f01003f0: 0f b7 05 28 25 11 f0 movzwl 0xf0112528,%eax
f01003f7: 69 c0 cd cc 00 00 imul $0xcccd,%eax,%eax
f01003fd: c1 e8 16 shr $0x16,%eax
f0100400: 8d 04 80 lea (%eax,%eax,4),%eax
f0100403: c1 e0 04 shl $0x4,%eax
f0100406: 66 a3 28 25 11 f0 mov %ax,0xf0112528
if (crt_pos >= CRT_SIZE) {
f010040c: 66 81 3d 28 25 11 f0 cmpw $0x7cf,0xf0112528
f0100413: cf 07
f0100415: 0f 87 8e 00 00 00 ja f01004a9 <cons_putc+0x1aa>
outb(addr_6845, 14);
f010041b: 8b 0d 30 25 11 f0 mov 0xf0112530,%ecx
f0100421: b8 0e 00 00 00 mov $0xe,%eax
f0100426: 89 ca mov %ecx,%edx
f0100428: ee out %al,(%dx)
outb(addr_6845 + 1, crt_pos >> 8);
f0100429: 0f b7 1d 28 25 11 f0 movzwl 0xf0112528,%ebx
f0100430: 8d 71 01 lea 0x1(%ecx),%esi
f0100433: 89 d8 mov %ebx,%eax
f0100435: 66 c1 e8 08 shr $0x8,%ax
f0100439: 89 f2 mov %esi,%edx
f010043b: ee out %al,(%dx)
f010043c: b8 0f 00 00 00 mov $0xf,%eax
f0100441: 89 ca mov %ecx,%edx
f0100443: ee out %al,(%dx)
f0100444: 89 d8 mov %ebx,%eax
f0100446: 89 f2 mov %esi,%edx
f0100448: ee out %al,(%dx)
serial_putc(c);
lpt_putc(c);
cga_putc(c);
}
f0100449: 8d 65 f4 lea -0xc(%ebp),%esp
f010044c: 5b pop %ebx
f010044d: 5e pop %esi
f010044e: 5f pop %edi
f010044f: 5d pop %ebp
f0100450: c3 ret
if (crt_pos > 0) {
f0100451: 0f b7 05 28 25 11 f0 movzwl 0xf0112528,%eax
f0100458: 66 85 c0 test %ax,%ax
f010045b: 74 be je f010041b <cons_putc+0x11c>
crt_pos--;
f010045d: 83 e8 01 sub $0x1,%eax
f0100460: 66 a3 28 25 11 f0 mov %ax,0xf0112528
crt_buf[crt_pos] = (c & ~0xff) | ' ';
f0100466: 0f b7 d0 movzwl %ax,%edx
f0100469: b1 00 mov $0x0,%cl
f010046b: 83 c9 20 or $0x20,%ecx
f010046e: a1 2c 25 11 f0 mov 0xf011252c,%eax
f0100473: 66 89 0c 50 mov %cx,(%eax,%edx,2)
f0100477: eb 93 jmp f010040c <cons_putc+0x10d>
crt_pos += CRT_COLS;
f0100479: 66 83 05 28 25 11 f0 addw $0x50,0xf0112528
f0100480: 50
f0100481: e9 6a ff ff ff jmp f01003f0 <cons_putc+0xf1>
crt_buf[crt_pos++] = c; /* write the character */
f0100486: 0f b7 05 28 25 11 f0 movzwl 0xf0112528,%eax
f010048d: 8d 50 01 lea 0x1(%eax),%edx
f0100490: 66 89 15 28 25 11 f0 mov %dx,0xf0112528
f0100497: 0f b7 c0 movzwl %ax,%eax
f010049a: 8b 15 2c 25 11 f0 mov 0xf011252c,%edx
f01004a0: 66 89 0c 42 mov %cx,(%edx,%eax,2)
break;
f01004a4: e9 63 ff ff ff jmp f010040c <cons_putc+0x10d>
memmove(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
f01004a9: a1 2c 25 11 f0 mov 0xf011252c,%eax
f01004ae: 83 ec 04 sub $0x4,%esp
f01004b1: 68 00 0f 00 00 push $0xf00
f01004b6: 8d 90 a0 00 00 00 lea 0xa0(%eax),%edx
f01004bc: 52 push %edx
f01004bd: 50 push %eax
f01004be: e8 a4 0f 00 00 call f0101467 <memmove>
crt_buf[i] = 0x0700 | ' ';
f01004c3: 8b 15 2c 25 11 f0 mov 0xf011252c,%edx
f01004c9: 8d 82 00 0f 00 00 lea 0xf00(%edx),%eax
f01004cf: 81 c2 a0 0f 00 00 add $0xfa0,%edx
f01004d5: 83 c4 10 add $0x10,%esp
f01004d8: 66 c7 00 20 07 movw $0x720,(%eax)
f01004dd: 83 c0 02 add $0x2,%eax
for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i++)
f01004e0: 39 d0 cmp %edx,%eax
f01004e2: 75 f4 jne f01004d8 <cons_putc+0x1d9>
crt_pos -= CRT_COLS;
f01004e4: 66 83 2d 28 25 11 f0 subw $0x50,0xf0112528
f01004eb: 50
f01004ec: e9 2a ff ff ff jmp f010041b <cons_putc+0x11c>
f01004f1 <serial_intr>:
{
f01004f1: f3 0f 1e fb endbr32
if (serial_exists)
f01004f5: 80 3d 34 25 11 f0 00 cmpb $0x0,0xf0112534
f01004fc: 75 01 jne f01004ff <serial_intr+0xe>
f01004fe: c3 ret
{
f01004ff: 55 push %ebp
f0100500: 89 e5 mov %esp,%ebp
f0100502: 83 ec 08 sub $0x8,%esp
cons_intr(serial_proc_data);
f0100505: b8 89 01 10 f0 mov $0xf0100189,%eax
f010050a: e8 98 fc ff ff call f01001a7 <cons_intr>
}
f010050f: c9 leave
f0100510: c3 ret
f0100511 <kbd_intr>:
{
f0100511: f3 0f 1e fb endbr32
f0100515: 55 push %ebp
f0100516: 89 e5 mov %esp,%ebp
f0100518: 83 ec 08 sub $0x8,%esp
cons_intr(kbd_proc_data);
f010051b: b8 e6 01 10 f0 mov $0xf01001e6,%eax
f0100520: e8 82 fc ff ff call f01001a7 <cons_intr>
}
f0100525: c9 leave
f0100526: c3 ret
f0100527 <cons_getc>:
{
f0100527: f3 0f 1e fb endbr32
f010052b: 55 push %ebp
f010052c: 89 e5 mov %esp,%ebp
f010052e: 83 ec 08 sub $0x8,%esp
serial_intr();
f0100531: e8 bb ff ff ff call f01004f1 <serial_intr>
kbd_intr();
f0100536: e8 d6 ff ff ff call f0100511 <kbd_intr>
if (cons.rpos != cons.wpos) {
f010053b: a1 20 25 11 f0 mov 0xf0112520,%eax
return 0;
f0100540: ba 00 00 00 00 mov $0x0,%edx
if (cons.rpos != cons.wpos) {
f0100545: 3b 05 24 25 11 f0 cmp 0xf0112524,%eax
f010054b: 74 1c je f0100569 <cons_getc+0x42>
c = cons.buf[cons.rpos++];
f010054d: 8d 48 01 lea 0x1(%eax),%ecx
f0100550: 0f b6 90 20 23 11 f0 movzbl -0xfeedce0(%eax),%edx
cons.rpos = 0;
f0100557: 3d ff 01 00 00 cmp $0x1ff,%eax
f010055c: b8 00 00 00 00 mov $0x0,%eax
f0100561: 0f 45 c1 cmovne %ecx,%eax
f0100564: a3 20 25 11 f0 mov %eax,0xf0112520
}
f0100569: 89 d0 mov %edx,%eax
f010056b: c9 leave
f010056c: c3 ret
f010056d <cons_init>:
// initialize the console devices
void
cons_init(void)
{
f010056d: f3 0f 1e fb endbr32
f0100571: 55 push %ebp
f0100572: 89 e5 mov %esp,%ebp
f0100574: 57 push %edi
f0100575: 56 push %esi
f0100576: 53 push %ebx
f0100577: 83 ec 0c sub $0xc,%esp
was = *cp;
f010057a: 0f b7 15 00 80 0b f0 movzwl 0xf00b8000,%edx
*cp = (uint16_t) 0xA55A;
f0100581: 66 c7 05 00 80 0b f0 movw $0xa55a,0xf00b8000
f0100588: 5a a5
if (*cp != 0xA55A) {
f010058a: 0f b7 05 00 80 0b f0 movzwl 0xf00b8000,%eax
f0100591: 66 3d 5a a5 cmp $0xa55a,%ax
f0100595: 0f 84 b7 00 00 00 je f0100652 <cons_init+0xe5>
addr_6845 = MONO_BASE;
f010059b: c7 05 30 25 11 f0 b4 movl $0x3b4,0xf0112530
f01005a2: 03 00 00
cp = (uint16_t*) (KERNBASE + MONO_BUF);
f01005a5: be 00 00 0b f0 mov $0xf00b0000,%esi
outb(addr_6845, 14);
f01005aa: 8b 3d 30 25 11 f0 mov 0xf0112530,%edi
f01005b0: b8 0e 00 00 00 mov $0xe,%eax
f01005b5: 89 fa mov %edi,%edx
f01005b7: ee out %al,(%dx)
pos = inb(addr_6845 + 1) << 8;
f01005b8: 8d 4f 01 lea 0x1(%edi),%ecx
asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
f01005bb: 89 ca mov %ecx,%edx
f01005bd: ec in (%dx),%al
f01005be: 0f b6 c0 movzbl %al,%eax
f01005c1: c1 e0 08 shl $0x8,%eax
f01005c4: 89 c3 mov %eax,%ebx
asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
f01005c6: b8 0f 00 00 00 mov $0xf,%eax
f01005cb: 89 fa mov %edi,%edx
f01005cd: ee out %al,(%dx)
asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
f01005ce: 89 ca mov %ecx,%edx
f01005d0: ec in (%dx),%al
crt_buf = (uint16_t*) cp;
f01005d1: 89 35 2c 25 11 f0 mov %esi,0xf011252c
pos |= inb(addr_6845 + 1);
f01005d7: 0f b6 c0 movzbl %al,%eax
f01005da: 09 d8 or %ebx,%eax
crt_pos = pos;
f01005dc: 66 a3 28 25 11 f0 mov %ax,0xf0112528
asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
f01005e2: bb 00 00 00 00 mov $0x0,%ebx
f01005e7: b9 fa 03 00 00 mov $0x3fa,%ecx
f01005ec: 89 d8 mov %ebx,%eax
f01005ee: 89 ca mov %ecx,%edx
f01005f0: ee out %al,(%dx)
f01005f1: bf fb 03 00 00 mov $0x3fb,%edi
f01005f6: b8 80 ff ff ff mov $0xffffff80,%eax
f01005fb: 89 fa mov %edi,%edx
f01005fd: ee out %al,(%dx)
f01005fe: b8 0c 00 00 00 mov $0xc,%eax
f0100603: ba f8 03 00 00 mov $0x3f8,%edx
f0100608: ee out %al,(%dx)
f0100609: be f9 03 00 00 mov $0x3f9,%esi
f010060e: 89 d8 mov %ebx,%eax
f0100610: 89 f2 mov %esi,%edx
f0100612: ee out %al,(%dx)
f0100613: b8 03 00 00 00 mov $0x3,%eax
f0100618: 89 fa mov %edi,%edx
f010061a: ee out %al,(%dx)
f010061b: ba fc 03 00 00 mov $0x3fc,%edx
f0100620: 89 d8 mov %ebx,%eax
f0100622: ee out %al,(%dx)
f0100623: b8 01 00 00 00 mov $0x1,%eax
f0100628: 89 f2 mov %esi,%edx
f010062a: ee out %al,(%dx)
asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
f010062b: ba fd 03 00 00 mov $0x3fd,%edx
f0100630: ec in (%dx),%al
f0100631: 89 c3 mov %eax,%ebx
serial_exists = (inb(COM1+COM_LSR) != 0xFF);
f0100633: 3c ff cmp $0xff,%al
f0100635: 0f 95 05 34 25 11 f0 setne 0xf0112534
f010063c: 89 ca mov %ecx,%edx
f010063e: ec in (%dx),%al
f010063f: ba f8 03 00 00 mov $0x3f8,%edx
f0100644: ec in (%dx),%al
cga_init();
kbd_init();
serial_init();
if (!serial_exists)
f0100645: 80 fb ff cmp $0xff,%bl
f0100648: 74 23 je f010066d <cons_init+0x100>
cprintf("Serial port does not exist!\n");
}
f010064a: 8d 65 f4 lea -0xc(%ebp),%esp
f010064d: 5b pop %ebx
f010064e: 5e pop %esi
f010064f: 5f pop %edi
f0100650: 5d pop %ebp
f0100651: c3 ret
*cp = was;
f0100652: 66 89 15 00 80 0b f0 mov %dx,0xf00b8000
addr_6845 = CGA_BASE;
f0100659: c7 05 30 25 11 f0 d4 movl $0x3d4,0xf0112530
f0100660: 03 00 00
cp = (uint16_t*) (KERNBASE + CGA_BUF);
f0100663: be 00 80 0b f0 mov $0xf00b8000,%esi
f0100668: e9 3d ff ff ff jmp f01005aa <cons_init+0x3d>
cprintf("Serial port does not exist!\n");
f010066d: 83 ec 0c sub $0xc,%esp
f0100670: 68 30 19 10 f0 push $0xf0101930
f0100675: e8 ad 02 00 00 call f0100927 <cprintf>
f010067a: 83 c4 10 add $0x10,%esp
}
f010067d: eb cb jmp f010064a <cons_init+0xdd>
f010067f <cputchar>:
// `High'-level console I/O. Used by readline and cprintf.
void
cputchar(int c)
{
f010067f: f3 0f 1e fb endbr32
f0100683: 55 push %ebp
f0100684: 89 e5 mov %esp,%ebp
f0100686: 83 ec 08 sub $0x8,%esp
cons_putc(c);
f0100689: 8b 45 08 mov 0x8(%ebp),%eax
f010068c: e8 6e fc ff ff call f01002ff <cons_putc>
}
f0100691: c9 leave
f0100692: c3 ret
f0100693 <getchar>:
int
getchar(void)
{
f0100693: f3 0f 1e fb endbr32
f0100697: 55 push %ebp
f0100698: 89 e5 mov %esp,%ebp
f010069a: 83 ec 08 sub $0x8,%esp
int c;
while ((c = cons_getc()) == 0)
f010069d: e8 85 fe ff ff call f0100527 <cons_getc>
f01006a2: 85 c0 test %eax,%eax
f01006a4: 74 f7 je f010069d <getchar+0xa>
/* do nothing */;
return c;
}
f01006a6: c9 leave
f01006a7: c3 ret
f01006a8 <iscons>:
int
iscons(int fdnum)
{
f01006a8: f3 0f 1e fb endbr32
// used by readline
return 1;
}
f01006ac: b8 01 00 00 00 mov $0x1,%eax
f01006b1: c3 ret
f01006b2 <mon_help>:
/***** Implementations of basic kernel monitor commands *****/
int
mon_help(int argc, char **argv, struct Trapframe *tf)
{
f01006b2: f3 0f 1e fb endbr32
f01006b6: 55 push %ebp
f01006b7: 89 e5 mov %esp,%ebp
f01006b9: 83 ec 0c sub $0xc,%esp
int i;
for (i = 0; i < ARRAY_SIZE(commands); i++)
cprintf("%s - %s\n", commands[i].name, commands[i].desc);
f01006bc: 68 80 1b 10 f0 push $0xf0101b80
f01006c1: 68 9e 1b 10 f0 push $0xf0101b9e
f01006c6: 68 a3 1b 10 f0 push $0xf0101ba3
f01006cb: e8 57 02 00 00 call f0100927 <cprintf>
f01006d0: 83 c4 0c add $0xc,%esp
f01006d3: 68 0c 1c 10 f0 push $0xf0101c0c
f01006d8: 68 ac 1b 10 f0 push $0xf0101bac
f01006dd: 68 a3 1b 10 f0 push $0xf0101ba3
f01006e2: e8 40 02 00 00 call f0100927 <cprintf>
return 0;
}
f01006e7: b8 00 00 00 00 mov $0x0,%eax
f01006ec: c9 leave
f01006ed: c3 ret
f01006ee <mon_kerninfo>:
int
mon_kerninfo(int argc, char **argv, struct Trapframe *tf)
{
f01006ee: f3 0f 1e fb endbr32
f01006f2: 55 push %ebp
f01006f3: 89 e5 mov %esp,%ebp
f01006f5: 83 ec 14 sub $0x14,%esp
extern char _start[], entry[], etext[], edata[], end[];
cprintf("Special kernel symbols:\n");
f01006f8: 68 b5 1b 10 f0 push $0xf0101bb5
f01006fd: e8 25 02 00 00 call f0100927 <cprintf>
cprintf(" _start %08x (phys)\n", _start);
f0100702: 83 c4 08 add $0x8,%esp
f0100705: 68 0c 00 10 00 push $0x10000c
f010070a: 68 34 1c 10 f0 push $0xf0101c34
f010070f: e8 13 02 00 00 call f0100927 <cprintf>
cprintf(" entry %08x (virt) %08x (phys)\n", entry, entry - KERNBASE);
f0100714: 83 c4 0c add $0xc,%esp
f0100717: 68 0c 00 10 00 push $0x10000c
f010071c: 68 0c 00 10 f0 push $0xf010000c
f0100721: 68 5c 1c 10 f0 push $0xf0101c5c
f0100726: e8 fc 01 00 00 call f0100927 <cprintf>
cprintf(" etext %08x (virt) %08x (phys)\n", etext, etext - KERNBASE);
f010072b: 83 c4 0c add $0xc,%esp
f010072e: 68 8d 18 10 00 push $0x10188d
f0100733: 68 8d 18 10 f0 push $0xf010188d
f0100738: 68 80 1c 10 f0 push $0xf0101c80
f010073d: e8 e5 01 00 00 call f0100927 <cprintf>
cprintf(" edata %08x (virt) %08x (phys)\n", edata, edata - KERNBASE);
f0100742: 83 c4 0c add $0xc,%esp
f0100745: 68 00 23 11 00 push $0x112300
f010074a: 68 00 23 11 f0 push $0xf0112300
f010074f: 68 a4 1c 10 f0 push $0xf0101ca4
f0100754: e8 ce 01 00 00 call f0100927 <cprintf>
cprintf(" end %08x (virt) %08x (phys)\n", end, end - KERNBASE);
f0100759: 83 c4 0c add $0xc,%esp
f010075c: 68 40 29 11 00 push $0x112940
f0100761: 68 40 29 11 f0 push $0xf0112940
f0100766: 68 c8 1c 10 f0 push $0xf0101cc8
f010076b: e8 b7 01 00 00 call f0100927 <cprintf>
cprintf("Kernel executable memory footprint: %dKB\n",
f0100770: 83 c4 08 add $0x8,%esp
ROUNDUP(end - entry, 1024) / 1024);
f0100773: b8 40 29 11 f0 mov $0xf0112940,%eax
f0100778: 2d 0d fc 0f f0 sub $0xf00ffc0d,%eax
cprintf("Kernel executable memory footprint: %dKB\n",
f010077d: c1 f8 0a sar $0xa,%eax
f0100780: 50 push %eax
f0100781: 68 ec 1c 10 f0 push $0xf0101cec
f0100786: e8 9c 01 00 00 call f0100927 <cprintf>
return 0;
}
f010078b: b8 00 00 00 00 mov $0x0,%eax
f0100790: c9 leave
f0100791: c3 ret
f0100792 <mon_backtrace>:
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
f0100792: f3 0f 1e fb endbr32
// Your code here.
return 0;
}
f0100796: b8 00 00 00 00 mov $0x0,%eax
f010079b: c3 ret
f010079c <monitor>:
return 0;
}
void
monitor(struct Trapframe *tf)
{
f010079c: f3 0f 1e fb endbr32
f01007a0: 55 push %ebp
f01007a1: 89 e5 mov %esp,%ebp
f01007a3: 57 push %edi
f01007a4: 56 push %esi
f01007a5: 53 push %ebx
f01007a6: 83 ec 58 sub $0x58,%esp
char *buf;
cprintf("Welcome to the JOS kernel monitor!\n");
f01007a9: 68 18 1d 10 f0 push $0xf0101d18
f01007ae: e8 74 01 00 00 call f0100927 <cprintf>
cprintf("Type 'help' for a list of commands.\n");
f01007b3: c7 04 24 3c 1d 10 f0 movl $0xf0101d3c,(%esp)
f01007ba: e8 68 01 00 00 call f0100927 <cprintf>
f01007bf: 83 c4 10 add $0x10,%esp
f01007c2: e9 cf 00 00 00 jmp f0100896 <monitor+0xfa>
while (*buf && strchr(WHITESPACE, *buf))
f01007c7: 83 ec 08 sub $0x8,%esp
f01007ca: 0f be c0 movsbl %al,%eax
f01007cd: 50 push %eax
f01007ce: 68 d2 1b 10 f0 push $0xf0101bd2
f01007d3: e8 fe 0b 00 00 call f01013d6 <strchr>
f01007d8: 83 c4 10 add $0x10,%esp
f01007db: 85 c0 test %eax,%eax
f01007dd: 74 6c je f010084b <monitor+0xaf>
*buf++ = 0;
f01007df: c6 03 00 movb $0x0,(%ebx)
f01007e2: 89 f7 mov %esi,%edi
f01007e4: 8d 5b 01 lea 0x1(%ebx),%ebx
f01007e7: 89 fe mov %edi,%esi
while (*buf && strchr(WHITESPACE, *buf))
f01007e9: 0f b6 03 movzbl (%ebx),%eax
f01007ec: 84 c0 test %al,%al
f01007ee: 75 d7 jne f01007c7 <monitor+0x2b>
argv[argc] = 0;
f01007f0: c7 44 b5 a8 00 00 00 movl $0x0,-0x58(%ebp,%esi,4)
f01007f7: 00
if (argc == 0)
f01007f8: 85 f6 test %esi,%esi
f01007fa: 0f 84 96 00 00 00 je f0100896 <monitor+0xfa>
if (strcmp(argv[0], commands[i].name) == 0)
f0100800: 83 ec 08 sub $0x8,%esp
f0100803: 68 9e 1b 10 f0 push $0xf0101b9e
f0100808: ff 75 a8 pushl -0x58(%ebp)
f010080b: e8 60 0b 00 00 call f0101370 <strcmp>
f0100810: 83 c4 10 add $0x10,%esp
f0100813: 85 c0 test %eax,%eax
f0100815: 0f 84 a7 00 00 00 je f01008c2 <monitor+0x126>
f010081b: 83 ec 08 sub $0x8,%esp
f010081e: 68 ac 1b 10 f0 push $0xf0101bac
f0100823: ff 75 a8 pushl -0x58(%ebp)
f0100826: e8 45 0b 00 00 call f0101370 <strcmp>
f010082b: 83 c4 10 add $0x10,%esp
f010082e: 85 c0 test %eax,%eax
f0100830: 0f 84 87 00 00 00 je f01008bd <monitor+0x121>
cprintf("Unknown command '%s'\n", argv[0]);
f0100836: 83 ec 08 sub $0x8,%esp
f0100839: ff 75 a8 pushl -0x58(%ebp)
f010083c: 68 f4 1b 10 f0 push $0xf0101bf4
f0100841: e8 e1 00 00 00 call f0100927 <cprintf>
return 0;
f0100846: 83 c4 10 add $0x10,%esp
f0100849: eb 4b jmp f0100896 <monitor+0xfa>
if (*buf == 0)
f010084b: 80 3b 00 cmpb $0x0,(%ebx)
f010084e: 74 a0 je f01007f0 <monitor+0x54>
if (argc == MAXARGS-1) {
f0100850: 83 fe 0f cmp $0xf,%esi
f0100853: 74 2f je f0100884 <monitor+0xe8>
argv[argc++] = buf;
f0100855: 8d 7e 01 lea 0x1(%esi),%edi
f0100858: 89 5c b5 a8 mov %ebx,-0x58(%ebp,%esi,4)
while (*buf && !strchr(WHITESPACE, *buf))
f010085c: 0f b6 03 movzbl (%ebx),%eax
f010085f: 84 c0 test %al,%al
f0100861: 74 84 je f01007e7 <monitor+0x4b>
f0100863: 83 ec 08 sub $0x8,%esp
f0100866: 0f be c0 movsbl %al,%eax
f0100869: 50 push %eax
f010086a: 68 d2 1b 10 f0 push $0xf0101bd2
f010086f: e8 62 0b 00 00 call f01013d6 <strchr>
f0100874: 83 c4 10 add $0x10,%esp
f0100877: 85 c0 test %eax,%eax
f0100879: 0f 85 68 ff ff ff jne f01007e7 <monitor+0x4b>
buf++;
f010087f: 83 c3 01 add $0x1,%ebx
f0100882: eb d8 jmp f010085c <monitor+0xc0>
cprintf("Too many arguments (max %d)\n", MAXARGS);
f0100884: 83 ec 08 sub $0x8,%esp
f0100887: 6a 10 push $0x10
f0100889: 68 d7 1b 10 f0 push $0xf0101bd7
f010088e: e8 94 00 00 00 call f0100927 <cprintf>
return 0;
f0100893: 83 c4 10 add $0x10,%esp
while (1) {
buf = readline("K> ");
f0100896: 83 ec 0c sub $0xc,%esp
f0100899: 68 ce 1b 10 f0 push $0xf0101bce
f010089e: e8 e5 08 00 00 call f0101188 <readline>
f01008a3: 89 c3 mov %eax,%ebx
if (buf != NULL)
f01008a5: 83 c4 10 add $0x10,%esp
f01008a8: 85 c0 test %eax,%eax
f01008aa: 74 ea je f0100896 <monitor+0xfa>
argv[argc] = 0;
f01008ac: c7 45 a8 00 00 00 00 movl $0x0,-0x58(%ebp)
argc = 0;
f01008b3: be 00 00 00 00 mov $0x0,%esi
f01008b8: e9 2c ff ff ff jmp f01007e9 <monitor+0x4d>
for (i = 0; i < ARRAY_SIZE(commands); i++) {
f01008bd: b8 01 00 00 00 mov $0x1,%eax
return commands[i].func(argc, argv, tf);
f01008c2: 83 ec 04 sub $0x4,%esp
f01008c5: 8d 04 40 lea (%eax,%eax,2),%eax
f01008c8: ff 75 08 pushl 0x8(%ebp)
f01008cb: 8d 55 a8 lea -0x58(%ebp),%edx
f01008ce: 52 push %edx
f01008cf: 56 push %esi
f01008d0: ff 14 85 6c 1d 10 f0 call *-0xfefe294(,%eax,4)
if (runcmd(buf, tf) < 0)
f01008d7: 83 c4 10 add $0x10,%esp
f01008da: 85 c0 test %eax,%eax
f01008dc: 79 b8 jns f0100896 <monitor+0xfa>
break;
}
}
f01008de: 8d 65 f4 lea -0xc(%ebp),%esp
f01008e1: 5b pop %ebx
f01008e2: 5e pop %esi
f01008e3: 5f pop %edi
f01008e4: 5d pop %ebp
f01008e5: c3 ret
f01008e6 <putch>:
#include <inc/stdarg.h>
static void
putch(int ch, int *cnt)
{
f01008e6: f3 0f 1e fb endbr32
f01008ea: 55 push %ebp
f01008eb: 89 e5 mov %esp,%ebp
f01008ed: 83 ec 14 sub $0x14,%esp
cputchar(ch);
f01008f0: ff 75 08 pushl 0x8(%ebp)
f01008f3: e8 87 fd ff ff call f010067f <cputchar>
*cnt++;
}
f01008f8: 83 c4 10 add $0x10,%esp
f01008fb: c9 leave
f01008fc: c3 ret
f01008fd <vcprintf>:
int
vcprintf(const char *fmt, va_list ap)
{
f01008fd: f3 0f 1e fb endbr32
f0100901: 55 push %ebp
f0100902: 89 e5 mov %esp,%ebp
f0100904: 83 ec 18 sub $0x18,%esp
int cnt = 0;
f0100907: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
vprintfmt((void*)putch, &cnt, fmt, ap);
f010090e: ff 75 0c pushl 0xc(%ebp)
f0100911: ff 75 08 pushl 0x8(%ebp)
f0100914: 8d 45 f4 lea -0xc(%ebp),%eax
f0100917: 50 push %eax
f0100918: 68 e6 08 10 f0 push $0xf01008e6
f010091d: e8 d3 03 00 00 call f0100cf5 <vprintfmt>
return cnt;
}
f0100922: 8b 45 f4 mov -0xc(%ebp),%eax
f0100925: c9 leave
f0100926: c3 ret
f0100927 <cprintf>:
int
cprintf(const char *fmt, ...)
{
f0100927: f3 0f 1e fb endbr32
f010092b: 55 push %ebp
f010092c: 89 e5 mov %esp,%ebp
f010092e: 83 ec 10 sub $0x10,%esp
va_list ap;
int cnt;
va_start(ap, fmt);
f0100931: 8d 45 0c lea 0xc(%ebp),%eax
cnt = vcprintf(fmt, ap);
f0100934: 50 push %eax
f0100935: ff 75 08 pushl 0x8(%ebp)
f0100938: e8 c0 ff ff ff call f01008fd <vcprintf>
va_end(ap);
return cnt;
}
f010093d: c9 leave
f010093e: c3 ret
f010093f <stab_binsearch>:
// will exit setting left = 118, right = 554.
//
static void
stab_binsearch(const struct Stab *stabs, int *region_left, int *region_right,
int type, uintptr_t addr)
{
f010093f: 55 push %ebp
f0100940: 89 e5 mov %esp,%ebp
f0100942: 57 push %edi
f0100943: 56 push %esi
f0100944: 53 push %ebx
f0100945: 83 ec 14 sub $0x14,%esp
f0100948: 89 45 ec mov %eax,-0x14(%ebp)
f010094b: 89 55 e4 mov %edx,-0x1c(%ebp)
f010094e: 89 4d e0 mov %ecx,-0x20(%ebp)
f0100951: 8b 75 08 mov 0x8(%ebp),%esi
int l = *region_left, r = *region_right, any_matches = 0;
f0100954: 8b 1a mov (%edx),%ebx
f0100956: 8b 01 mov (%ecx),%eax
f0100958: 89 45 f0 mov %eax,-0x10(%ebp)
f010095b: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
while (l <= r) {
f0100962: eb 23 jmp f0100987 <stab_binsearch+0x48>
// search for earliest stab with right type
while (m >= l && stabs[m].n_type != type)
m--;
if (m < l) { // no match in [l, m]
l = true_m + 1;
f0100964: 8d 5f 01 lea 0x1(%edi),%ebx
continue;
f0100967: eb 1e jmp f0100987 <stab_binsearch+0x48>
}
// actual binary search
any_matches = 1;
if (stabs[m].n_value < addr) {
f0100969: 8d 14 40 lea (%eax,%eax,2),%edx
f010096c: 8b 4d ec mov -0x14(%ebp),%ecx
f010096f: 8b 54 91 08 mov 0x8(%ecx,%edx,4),%edx
f0100973: 3b 55 0c cmp 0xc(%ebp),%edx
f0100976: 73 46 jae f01009be <stab_binsearch+0x7f>
*region_left = m;
f0100978: 8b 5d e4 mov -0x1c(%ebp),%ebx
f010097b: 89 03 mov %eax,(%ebx)
l = true_m + 1;
f010097d: 8d 5f 01 lea 0x1(%edi),%ebx
any_matches = 1;
f0100980: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp)
while (l <= r) {
f0100987: 3b 5d f0 cmp -0x10(%ebp),%ebx
f010098a: 7f 5f jg f01009eb <stab_binsearch+0xac>
int true_m = (l + r) / 2, m = true_m;
f010098c: 8b 45 f0 mov -0x10(%ebp),%eax
f010098f: 8d 14 03 lea (%ebx,%eax,1),%edx
f0100992: 89 d0 mov %edx,%eax
f0100994: c1 e8 1f shr $0x1f,%eax
f0100997: 01 d0 add %edx,%eax
f0100999: 89 c7 mov %eax,%edi
f010099b: d1 ff sar %edi
f010099d: 83 e0 fe and $0xfffffffe,%eax
f01009a0: 01 f8 add %edi,%eax
f01009a2: 8b 4d ec mov -0x14(%ebp),%ecx
f01009a5: 8d 54 81 04 lea 0x4(%ecx,%eax,4),%edx
f01009a9: 89 f8 mov %edi,%eax
while (m >= l && stabs[m].n_type != type)
f01009ab: 39 c3 cmp %eax,%ebx
f01009ad: 7f b5 jg f0100964 <stab_binsearch+0x25>
f01009af: 0f b6 0a movzbl (%edx),%ecx
f01009b2: 83 ea 0c sub $0xc,%edx
f01009b5: 39 f1 cmp %esi,%ecx
f01009b7: 74 b0 je f0100969 <stab_binsearch+0x2a>
m--;
f01009b9: 83 e8 01 sub $0x1,%eax
f01009bc: eb ed jmp f01009ab <stab_binsearch+0x6c>
} else if (stabs[m].n_value > addr) {
f01009be: 3b 55 0c cmp 0xc(%ebp),%edx
f01009c1: 76 14 jbe f01009d7 <stab_binsearch+0x98>
*region_right = m - 1;
f01009c3: 83 e8 01 sub $0x1,%eax
f01009c6: 89 45 f0 mov %eax,-0x10(%ebp)
f01009c9: 8b 7d e0 mov -0x20(%ebp),%edi
f01009cc: 89 07 mov %eax,(%edi)
any_matches = 1;
f01009ce: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp)
f01009d5: eb b0 jmp f0100987 <stab_binsearch+0x48>
r = m - 1;
} else {
// exact match for 'addr', but continue loop to find
// *region_right
*region_left = m;
f01009d7: 8b 7d e4 mov -0x1c(%ebp),%edi
f01009da: 89 07 mov %eax,(%edi)
l = m;
addr++;
f01009dc: 83 45 0c 01 addl $0x1,0xc(%ebp)
f01009e0: 89 c3 mov %eax,%ebx
any_matches = 1;
f01009e2: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp)
f01009e9: eb 9c jmp f0100987 <stab_binsearch+0x48>
}
}
if (!any_matches)
f01009eb: 83 7d e8 00 cmpl $0x0,-0x18(%ebp)
f01009ef: 75 15 jne f0100a06 <stab_binsearch+0xc7>
*region_right = *region_left - 1;
f01009f1: 8b 45 e4 mov -0x1c(%ebp),%eax
f01009f4: 8b 00 mov (%eax),%eax
f01009f6: 83 e8 01 sub $0x1,%eax
f01009f9: 8b 7d e0 mov -0x20(%ebp),%edi
f01009fc: 89 07 mov %eax,(%edi)
l > *region_left && stabs[l].n_type != type;
l--)
/* do nothing */;
*region_left = l;
}
}
f01009fe: 83 c4 14 add $0x14,%esp
f0100a01: 5b pop %ebx
f0100a02: 5e pop %esi
f0100a03: 5f pop %edi
f0100a04: 5d pop %ebp
f0100a05: c3 ret
for (l = *region_right;
f0100a06: 8b 45 e0 mov -0x20(%ebp),%eax
f0100a09: 8b 00 mov (%eax),%eax
l > *region_left && stabs[l].n_type != type;
f0100a0b: 8b 7d e4 mov -0x1c(%ebp),%edi
f0100a0e: 8b 0f mov (%edi),%ecx
f0100a10: 8d 14 40 lea (%eax,%eax,2),%edx
f0100a13: 8b 7d ec mov -0x14(%ebp),%edi
f0100a16: 8d 54 97 04 lea 0x4(%edi,%edx,4),%edx
for (l = *region_right;
f0100a1a: eb 03 jmp f0100a1f <stab_binsearch+0xe0>
l--)
f0100a1c: 83 e8 01 sub $0x1,%eax
for (l = *region_right;
f0100a1f: 39 c1 cmp %eax,%ecx
f0100a21: 7d 0a jge f0100a2d <stab_binsearch+0xee>
l > *region_left && stabs[l].n_type != type;
f0100a23: 0f b6 1a movzbl (%edx),%ebx
f0100a26: 83 ea 0c sub $0xc,%edx
f0100a29: 39 f3 cmp %esi,%ebx
f0100a2b: 75 ef jne f0100a1c <stab_binsearch+0xdd>
*region_left = l;
f0100a2d: 8b 7d e4 mov -0x1c(%ebp),%edi
f0100a30: 89 07 mov %eax,(%edi)
}
f0100a32: eb ca jmp f01009fe <stab_binsearch+0xbf>
f0100a34 <debuginfo_eip>:
// negative if not. But even if it returns negative it has stored some
// information into '*info'.
//
int
debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info)
{
f0100a34: f3 0f 1e fb endbr32
f0100a38: 55 push %ebp
f0100a39: 89 e5 mov %esp,%ebp
f0100a3b: 57 push %edi
f0100a3c: 56 push %esi
f0100a3d: 53 push %ebx
f0100a3e: 83 ec 1c sub $0x1c,%esp
f0100a41: 8b 7d 08 mov 0x8(%ebp),%edi
f0100a44: 8b 75 0c mov 0xc(%ebp),%esi
const struct Stab *stabs, *stab_end;
const char *stabstr, *stabstr_end;
int lfile, rfile, lfun, rfun, lline, rline;
// Initialize *info
info->eip_file = "<unknown>";
f0100a47: c7 06 7c 1d 10 f0 movl $0xf0101d7c,(%esi)
info->eip_line = 0;
f0100a4d: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
info->eip_fn_name = "<unknown>";
f0100a54: c7 46 08 7c 1d 10 f0 movl $0xf0101d7c,0x8(%esi)
info->eip_fn_namelen = 9;
f0100a5b: c7 46 0c 09 00 00 00 movl $0x9,0xc(%esi)
info->eip_fn_addr = addr;
f0100a62: 89 7e 10 mov %edi,0x10(%esi)
info->eip_fn_narg = 0;
f0100a65: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
// Find the relevant set of stabs
if (addr >= ULIM) {
f0100a6c: 81 ff ff ff 7f ef cmp $0xef7fffff,%edi
f0100a72: 0f 86 db 00 00 00 jbe f0100b53 <debuginfo_eip+0x11f>
// Can't search for user-level addresses yet!
panic("User address");
}
// String table validity checks
if (stabstr_end <= stabstr || stabstr_end[-1] != 0)
f0100a78: b8 d7 7b 10 f0 mov $0xf0107bd7,%eax
f0100a7d: 3d 2d 62 10 f0 cmp $0xf010622d,%eax
f0100a82: 0f 86 5e 01 00 00 jbe f0100be6 <debuginfo_eip+0x1b2>
f0100a88: 80 3d d6 7b 10 f0 00 cmpb $0x0,0xf0107bd6
f0100a8f: 0f 85 58 01 00 00 jne f0100bed <debuginfo_eip+0x1b9>
// 'eip'. First, we find the basic source file containing 'eip'.
// Then, we look in that source file for the function. Then we look
// for the line number.
// Search the entire set of stabs for the source file (type N_SO).
lfile = 0;
f0100a95: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
rfile = (stab_end - stabs) - 1;
f0100a9c: b8 2c 62 10 f0 mov $0xf010622c,%eax
f0100aa1: 2d b4 1f 10 f0 sub $0xf0101fb4,%eax
f0100aa6: c1 f8 02 sar $0x2,%eax
f0100aa9: 69 c0 ab aa aa aa imul $0xaaaaaaab,%eax,%eax
f0100aaf: 83 e8 01 sub $0x1,%eax
f0100ab2: 89 45 e0 mov %eax,-0x20(%ebp)
stab_binsearch(stabs, &lfile, &rfile, N_SO, addr);
f0100ab5: 83 ec 08 sub $0x8,%esp
f0100ab8: 57 push %edi
f0100ab9: 6a 64 push $0x64
f0100abb: 8d 4d e0 lea -0x20(%ebp),%ecx
f0100abe: 8d 55 e4 lea -0x1c(%ebp),%edx
f0100ac1: b8 b4 1f 10 f0 mov $0xf0101fb4,%eax
f0100ac6: e8 74 fe ff ff call f010093f <stab_binsearch>
if (lfile == 0)
f0100acb: 8b 45 e4 mov -0x1c(%ebp),%eax
f0100ace: 83 c4 10 add $0x10,%esp
f0100ad1: 85 c0 test %eax,%eax
f0100ad3: 0f 84 1b 01 00 00 je f0100bf4 <debuginfo_eip+0x1c0>
return -1;
// Search within that file's stabs for the function definition
// (N_FUN).
lfun = lfile;
f0100ad9: 89 45 dc mov %eax,-0x24(%ebp)
rfun = rfile;
f0100adc: 8b 45 e0 mov -0x20(%ebp),%eax
f0100adf: 89 45 d8 mov %eax,-0x28(%ebp)
stab_binsearch(stabs, &lfun, &rfun, N_FUN, addr);
f0100ae2: 83 ec 08 sub $0x8,%esp
f0100ae5: 57 push %edi
f0100ae6: 6a 24 push $0x24
f0100ae8: 8d 4d d8 lea -0x28(%ebp),%ecx
f0100aeb: 8d 55 dc lea -0x24(%ebp),%edx
f0100aee: b8 b4 1f 10 f0 mov $0xf0101fb4,%eax
f0100af3: e8 47 fe ff ff call f010093f <stab_binsearch>
if (lfun <= rfun) {
f0100af8: 8b 5d dc mov -0x24(%ebp),%ebx
f0100afb: 83 c4 10 add $0x10,%esp
f0100afe: 3b 5d d8 cmp -0x28(%ebp),%ebx
f0100b01: 7f 64 jg f0100b67 <debuginfo_eip+0x133>
// stabs[lfun] points to the function name
// in the string table, but check bounds just in case.
if (stabs[lfun].n_strx < stabstr_end - stabstr)
f0100b03: 8d 04 5b lea (%ebx,%ebx,2),%eax
f0100b06: c1 e0 02 shl $0x2,%eax
f0100b09: 8d 90 b4 1f 10 f0 lea -0xfefe04c(%eax),%edx
f0100b0f: 8b 88 b4 1f 10 f0 mov -0xfefe04c(%eax),%ecx
f0100b15: b8 d7 7b 10 f0 mov $0xf0107bd7,%eax
f0100b1a: 2d 2d 62 10 f0 sub $0xf010622d,%eax
f0100b1f: 39 c1 cmp %eax,%ecx
f0100b21: 73 09 jae f0100b2c <debuginfo_eip+0xf8>
info->eip_fn_name = stabstr + stabs[lfun].n_strx;
f0100b23: 81 c1 2d 62 10 f0 add $0xf010622d,%ecx
f0100b29: 89 4e 08 mov %ecx,0x8(%esi)
info->eip_fn_addr = stabs[lfun].n_value;
f0100b2c: 8b 42 08 mov 0x8(%edx),%eax
f0100b2f: 89 46 10 mov %eax,0x10(%esi)
info->eip_fn_addr = addr;
lline = lfile;
rline = rfile;
}
// Ignore stuff after the colon.
info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name;
f0100b32: 83 ec 08 sub $0x8,%esp
f0100b35: 6a 3a push $0x3a
f0100b37: ff 76 08 pushl 0x8(%esi)
f0100b3a: e8 bc 08 00 00 call f01013fb <strfind>
f0100b3f: 2b 46 08 sub 0x8(%esi),%eax
f0100b42: 89 46 0c mov %eax,0xc(%esi)
// Search backwards from the line number for the relevant filename
// stab.
// We can't just use the "lfile" stab because inlined functions
// can interpolate code from a different file!
// Such included source files use the N_SOL stab type.
while (lline >= lfile
f0100b45: 8b 4d e4 mov -0x1c(%ebp),%ecx
f0100b48: 8d 04 5b lea (%ebx,%ebx,2),%eax
f0100b4b: c1 e0 02 shl $0x2,%eax
f0100b4e: 83 c4 10 add $0x10,%esp
f0100b51: eb 22 jmp f0100b75 <debuginfo_eip+0x141>
panic("User address");
f0100b53: 83 ec 04 sub $0x4,%esp
f0100b56: 68 86 1d 10 f0 push $0xf0101d86
f0100b5b: 6a 7f push $0x7f
f0100b5d: 68 93 1d 10 f0 push $0xf0101d93
f0100b62: e8 87 f5 ff ff call f01000ee <_panic>
info->eip_fn_addr = addr;
f0100b67: 89 7e 10 mov %edi,0x10(%esi)
lline = lfile;
f0100b6a: 8b 5d e4 mov -0x1c(%ebp),%ebx
f0100b6d: eb c3 jmp f0100b32 <debuginfo_eip+0xfe>
&& stabs[lline].n_type != N_SOL
&& (stabs[lline].n_type != N_SO || !stabs[lline].n_value))
lline--;
f0100b6f: 83 eb 01 sub $0x1,%ebx
f0100b72: 83 e8 0c sub $0xc,%eax
while (lline >= lfile
f0100b75: 39 d9 cmp %ebx,%ecx
f0100b77: 7f 3a jg f0100bb3 <debuginfo_eip+0x17f>
&& stabs[lline].n_type != N_SOL
f0100b79: 0f b6 90 b8 1f 10 f0 movzbl -0xfefe048(%eax),%edx
f0100b80: 80 fa 84 cmp $0x84,%dl
f0100b83: 74 0e je f0100b93 <debuginfo_eip+0x15f>
&& (stabs[lline].n_type != N_SO || !stabs[lline].n_value))
f0100b85: 80 fa 64 cmp $0x64,%dl
f0100b88: 75 e5 jne f0100b6f <debuginfo_eip+0x13b>
f0100b8a: 83 b8 bc 1f 10 f0 00 cmpl $0x0,-0xfefe044(%eax)
f0100b91: 74 dc je f0100b6f <debuginfo_eip+0x13b>
if (lline >= lfile && stabs[lline].n_strx < stabstr_end - stabstr)
f0100b93: 8d 04 5b lea (%ebx,%ebx,2),%eax
f0100b96: 8b 14 85 b4 1f 10 f0 mov -0xfefe04c(,%eax,4),%edx
f0100b9d: b8 d7 7b 10 f0 mov $0xf0107bd7,%eax
f0100ba2: 2d 2d 62 10 f0 sub $0xf010622d,%eax
f0100ba7: 39 c2 cmp %eax,%edx
f0100ba9: 73 08 jae f0100bb3 <debuginfo_eip+0x17f>
info->eip_file = stabstr + stabs[lline].n_strx;
f0100bab: 81 c2 2d 62 10 f0 add $0xf010622d,%edx
f0100bb1: 89 16 mov %edx,(%esi)
// Set eip_fn_narg to the number of arguments taken by the function,
// or 0 if there was no containing function.
if (lfun < rfun)
f0100bb3: 8b 45 dc mov -0x24(%ebp),%eax
f0100bb6: 8b 4d d8 mov -0x28(%ebp),%ecx
for (lline = lfun + 1;
lline < rfun && stabs[lline].n_type == N_PSYM;
lline++)
info->eip_fn_narg++;
return 0;
f0100bb9: ba 00 00 00 00 mov $0x0,%edx
if (lfun < rfun)
f0100bbe: 39 c8 cmp %ecx,%eax
f0100bc0: 7d 3e jge f0100c00 <debuginfo_eip+0x1cc>
for (lline = lfun + 1;
f0100bc2: 83 c0 01 add $0x1,%eax
f0100bc5: eb 07 jmp f0100bce <debuginfo_eip+0x19a>
info->eip_fn_narg++;
f0100bc7: 83 46 14 01 addl $0x1,0x14(%esi)
lline++)
f0100bcb: 83 c0 01 add $0x1,%eax
for (lline = lfun + 1;
f0100bce: 39 c1 cmp %eax,%ecx
f0100bd0: 74 29 je f0100bfb <debuginfo_eip+0x1c7>
lline < rfun && stabs[lline].n_type == N_PSYM;
f0100bd2: 8d 14 40 lea (%eax,%eax,2),%edx
f0100bd5: 80 3c 95 b8 1f 10 f0 cmpb $0xa0,-0xfefe048(,%edx,4)
f0100bdc: a0
f0100bdd: 74 e8 je f0100bc7 <debuginfo_eip+0x193>
return 0;
f0100bdf: ba 00 00 00 00 mov $0x0,%edx
f0100be4: eb 1a jmp f0100c00 <debuginfo_eip+0x1cc>
return -1;
f0100be6: ba ff ff ff ff mov $0xffffffff,%edx
f0100beb: eb 13 jmp f0100c00 <debuginfo_eip+0x1cc>
f0100bed: ba ff ff ff ff mov $0xffffffff,%edx
f0100bf2: eb 0c jmp f0100c00 <debuginfo_eip+0x1cc>
return -1;
f0100bf4: ba ff ff ff ff mov $0xffffffff,%edx
f0100bf9: eb 05 jmp f0100c00 <debuginfo_eip+0x1cc>
return 0;
f0100bfb: ba 00 00 00 00 mov $0x0,%edx
}
f0100c00: 89 d0 mov %edx,%eax
f0100c02: 8d 65 f4 lea -0xc(%ebp),%esp
f0100c05: 5b pop %ebx
f0100c06: 5e pop %esi
f0100c07: 5f pop %edi
f0100c08: 5d pop %ebp
f0100c09: c3 ret
f0100c0a <printnum>:
* using specified putch function and associated pointer putdat.
*/
static void
printnum(void (*putch)(int, void*), void *putdat,
unsigned long long num, unsigned base, int width, int padc)
{
f0100c0a: 55 push %ebp
f0100c0b: 89 e5 mov %esp,%ebp
f0100c0d: 57 push %edi
f0100c0e: 56 push %esi
f0100c0f: 53 push %ebx
f0100c10: 83 ec 1c sub $0x1c,%esp
f0100c13: 89 c7 mov %eax,%edi
f0100c15: 89 d6 mov %edx,%esi
f0100c17: 8b 45 08 mov 0x8(%ebp),%eax
f0100c1a: 8b 55 0c mov 0xc(%ebp),%edx
f0100c1d: 89 d1 mov %edx,%ecx
f0100c1f: 89 c2 mov %eax,%edx
f0100c21: 89 45 d8 mov %eax,-0x28(%ebp)
f0100c24: 89 4d dc mov %ecx,-0x24(%ebp)
f0100c27: 8b 45 10 mov 0x10(%ebp),%eax
f0100c2a: 8b 5d 14 mov 0x14(%ebp),%ebx
// first recursively print all preceding (more significant) digits
if (num >= base) {
f0100c2d: 89 45 e0 mov %eax,-0x20(%ebp)
f0100c30: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
f0100c37: 39 c2 cmp %eax,%edx
f0100c39: 1b 4d e4 sbb -0x1c(%ebp),%ecx
f0100c3c: 72 3e jb f0100c7c <printnum+0x72>
printnum(putch, putdat, num / base, base, width - 1, padc);
f0100c3e: 83 ec 0c sub $0xc,%esp
f0100c41: ff 75 18 pushl 0x18(%ebp)
f0100c44: 83 eb 01 sub $0x1,%ebx
f0100c47: 53 push %ebx
f0100c48: 50 push %eax
f0100c49: 83 ec 08 sub $0x8,%esp
f0100c4c: ff 75 e4 pushl -0x1c(%ebp)
f0100c4f: ff 75 e0 pushl -0x20(%ebp)
f0100c52: ff 75 dc pushl -0x24(%ebp)
f0100c55: ff 75 d8 pushl -0x28(%ebp)
f0100c58: e8 d3 09 00 00 call f0101630 <__udivdi3>
f0100c5d: 83 c4 18 add $0x18,%esp
f0100c60: 52 push %edx
f0100c61: 50 push %eax
f0100c62: 89 f2 mov %esi,%edx
f0100c64: 89 f8 mov %edi,%eax
f0100c66: e8 9f ff ff ff call f0100c0a <printnum>
f0100c6b: 83 c4 20 add $0x20,%esp
f0100c6e: eb 13 jmp f0100c83 <printnum+0x79>
} else {
// print any needed pad characters before first digit
while (--width > 0)
putch(padc, putdat);
f0100c70: 83 ec 08 sub $0x8,%esp
f0100c73: 56 push %esi
f0100c74: ff 75 18 pushl 0x18(%ebp)
f0100c77: ff d7 call *%edi
f0100c79: 83 c4 10 add $0x10,%esp
while (--width > 0)
f0100c7c: 83 eb 01 sub $0x1,%ebx
f0100c7f: 85 db test %ebx,%ebx
f0100c81: 7f ed jg f0100c70 <printnum+0x66>
}
// then print this (the least significant) digit
putch("0123456789abcdef"[num % base], putdat);
f0100c83: 83 ec 08 sub $0x8,%esp
f0100c86: 56 push %esi
f0100c87: 83 ec 04 sub $0x4,%esp
f0100c8a: ff 75 e4 pushl -0x1c(%ebp)
f0100c8d: ff 75 e0 pushl -0x20(%ebp)
f0100c90: ff 75 dc pushl -0x24(%ebp)
f0100c93: ff 75 d8 pushl -0x28(%ebp)
f0100c96: e8 a5 0a 00 00 call f0101740 <__umoddi3>
f0100c9b: 83 c4 14 add $0x14,%esp
f0100c9e: 0f be 80 a1 1d 10 f0 movsbl -0xfefe25f(%eax),%eax
f0100ca5: 50 push %eax
f0100ca6: ff d7 call *%edi
}
f0100ca8: 83 c4 10 add $0x10,%esp
f0100cab: 8d 65 f4 lea -0xc(%ebp),%esp
f0100cae: 5b pop %ebx
f0100caf: 5e pop %esi
f0100cb0: 5f pop %edi
f0100cb1: 5d pop %ebp
f0100cb2: c3 ret
f0100cb3 <sprintputch>:
int cnt;
};
static void
sprintputch(int ch, struct sprintbuf *b)
{
f0100cb3: f3 0f 1e fb endbr32
f0100cb7: 55 push %ebp
f0100cb8: 89 e5 mov %esp,%ebp
f0100cba: 8b 45 0c mov 0xc(%ebp),%eax
b->cnt++;
f0100cbd: 83 40 08 01 addl $0x1,0x8(%eax)
if (b->buf < b->ebuf)
f0100cc1: 8b 10 mov (%eax),%edx
f0100cc3: 3b 50 04 cmp 0x4(%eax),%edx
f0100cc6: 73 0a jae f0100cd2 <sprintputch+0x1f>
*b->buf++ = ch;
f0100cc8: 8d 4a 01 lea 0x1(%edx),%ecx
f0100ccb: 89 08 mov %ecx,(%eax)
f0100ccd: 8b 45 08 mov 0x8(%ebp),%eax
f0100cd0: 88 02 mov %al,(%edx)
}
f0100cd2: 5d pop %ebp
f0100cd3: c3 ret
f0100cd4 <printfmt>:
{
f0100cd4: f3 0f 1e fb endbr32
f0100cd8: 55 push %ebp
f0100cd9: 89 e5 mov %esp,%ebp
f0100cdb: 83 ec 08 sub $0x8,%esp
va_start(ap, fmt);
f0100cde: 8d 45 14 lea 0x14(%ebp),%eax
vprintfmt(putch, putdat, fmt, ap);
f0100ce1: 50 push %eax
f0100ce2: ff 75 10 pushl 0x10(%ebp)
f0100ce5: ff 75 0c pushl 0xc(%ebp)
f0100ce8: ff 75 08 pushl 0x8(%ebp)
f0100ceb: e8 05 00 00 00 call f0100cf5 <vprintfmt>
}
f0100cf0: 83 c4 10 add $0x10,%esp
f0100cf3: c9 leave
f0100cf4: c3 ret
f0100cf5 <vprintfmt>:
{
f0100cf5: f3 0f 1e fb endbr32
f0100cf9: 55 push %ebp
f0100cfa: 89 e5 mov %esp,%ebp
f0100cfc: 57 push %edi
f0100cfd: 56 push %esi
f0100cfe: 53 push %ebx
f0100cff: 83 ec 3c sub $0x3c,%esp
f0100d02: 8b 75 08 mov 0x8(%ebp),%esi
f0100d05: 8b 5d 0c mov 0xc(%ebp),%ebx
f0100d08: 8b 7d 10 mov 0x10(%ebp),%edi
f0100d0b: e9 5d 03 00 00 jmp f010106d <vprintfmt+0x378>
padc = ' ';
f0100d10: c6 45 d3 20 movb $0x20,-0x2d(%ebp)
altflag = 0;
f0100d14: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
precision = -1;
f0100d1b: c7 45 d8 ff ff ff ff movl $0xffffffff,-0x28(%ebp)
width = -1;
f0100d22: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp)
lflag = 0;
f0100d29: b9 00 00 00 00 mov $0x0,%ecx
switch (ch = *(unsigned char *) fmt++) {
f0100d2e: 8d 47 01 lea 0x1(%edi),%eax
f0100d31: 89 45 e4 mov %eax,-0x1c(%ebp)
f0100d34: 0f b6 17 movzbl (%edi),%edx
f0100d37: 8d 42 dd lea -0x23(%edx),%eax
f0100d3a: 3c 55 cmp $0x55,%al
f0100d3c: 0f 87 ae 03 00 00 ja f01010f0 <vprintfmt+0x3fb>
f0100d42: 0f b6 c0 movzbl %al,%eax
f0100d45: 3e ff 24 85 30 1e 10 notrack jmp *-0xfefe1d0(,%eax,4)
f0100d4c: f0
f0100d4d: 8b 7d e4 mov -0x1c(%ebp),%edi
padc = '-';
f0100d50: c6 45 d3 2d movb $0x2d,-0x2d(%ebp)
f0100d54: eb d8 jmp f0100d2e <vprintfmt+0x39>
switch (ch = *(unsigned char *) fmt++) {
f0100d56: 8b 7d e4 mov -0x1c(%ebp),%edi
f0100d59: c6 45 d3 30 movb $0x30,-0x2d(%ebp)
f0100d5d: eb cf jmp f0100d2e <vprintfmt+0x39>
f0100d5f: 0f b6 d2 movzbl %dl,%edx
f0100d62: 8b 7d e4 mov -0x1c(%ebp),%edi
for (precision = 0; ; ++fmt) {
f0100d65: b8 00 00 00 00 mov $0x0,%eax
f0100d6a: 89 4d e4 mov %ecx,-0x1c(%ebp)
precision = precision * 10 + ch - '0';
f0100d6d: 8d 04 80 lea (%eax,%eax,4),%eax
f0100d70: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
ch = *fmt;
f0100d74: 0f be 17 movsbl (%edi),%edx
if (ch < '0' || ch > '9')
f0100d77: 8d 4a d0 lea -0x30(%edx),%ecx
f0100d7a: 83 f9 09 cmp $0x9,%ecx
f0100d7d: 77 55 ja f0100dd4 <vprintfmt+0xdf>
for (precision = 0; ; ++fmt) {
f0100d7f: 83 c7 01 add $0x1,%edi
precision = precision * 10 + ch - '0';
f0100d82: eb e9 jmp f0100d6d <vprintfmt+0x78>
precision = va_arg(ap, int);
f0100d84: 8b 45 14 mov 0x14(%ebp),%eax
f0100d87: 8b 00 mov (%eax),%eax
f0100d89: 89 45 d8 mov %eax,-0x28(%ebp)
f0100d8c: 8b 45 14 mov 0x14(%ebp),%eax
f0100d8f: 8d 40 04 lea 0x4(%eax),%eax
f0100d92: 89 45 14 mov %eax,0x14(%ebp)
switch (ch = *(unsigned char *) fmt++) {
f0100d95: 8b 7d e4 mov -0x1c(%ebp),%edi
if (width < 0)
f0100d98: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
f0100d9c: 79 90 jns f0100d2e <vprintfmt+0x39>
width = precision, precision = -1;
f0100d9e: 8b 45 d8 mov -0x28(%ebp),%eax
f0100da1: 89 45 d4 mov %eax,-0x2c(%ebp)
f0100da4: c7 45 d8 ff ff ff ff movl $0xffffffff,-0x28(%ebp)
f0100dab: eb 81 jmp f0100d2e <vprintfmt+0x39>
f0100dad: 8b 45 d4 mov -0x2c(%ebp),%eax
f0100db0: 85 c0 test %eax,%eax
f0100db2: ba 00 00 00 00 mov $0x0,%edx
f0100db7: 0f 49 d0 cmovns %eax,%edx
f0100dba: 89 55 d4 mov %edx,-0x2c(%ebp)
switch (ch = *(unsigned char *) fmt++) {
f0100dbd: 8b 7d e4 mov -0x1c(%ebp),%edi
goto reswitch;
f0100dc0: e9 69 ff ff ff jmp f0100d2e <vprintfmt+0x39>
switch (ch = *(unsigned char *) fmt++) {
f0100dc5: 8b 7d e4 mov -0x1c(%ebp),%edi
altflag = 1;
f0100dc8: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
goto reswitch;
f0100dcf: e9 5a ff ff ff jmp f0100d2e <vprintfmt+0x39>
f0100dd4: 8b 4d e4 mov -0x1c(%ebp),%ecx
f0100dd7: 89 45 d8 mov %eax,-0x28(%ebp)
f0100dda: eb bc jmp f0100d98 <vprintfmt+0xa3>
lflag++;
f0100ddc: 83 c1 01 add $0x1,%ecx
switch (ch = *(unsigned char *) fmt++) {
f0100ddf: 8b 7d e4 mov -0x1c(%ebp),%edi
goto reswitch;
f0100de2: e9 47 ff ff ff jmp f0100d2e <vprintfmt+0x39>
putch(va_arg(ap, int), putdat);
f0100de7: 8b 45 14 mov 0x14(%ebp),%eax
f0100dea: 8d 78 04 lea 0x4(%eax),%edi
f0100ded: 83 ec 08 sub $0x8,%esp
f0100df0: 53 push %ebx
f0100df1: ff 30 pushl (%eax)
f0100df3: ff d6 call *%esi
break;
f0100df5: 83 c4 10 add $0x10,%esp
putch(va_arg(ap, int), putdat);
f0100df8: 89 7d 14 mov %edi,0x14(%ebp)
break;
f0100dfb: e9 6a 02 00 00 jmp f010106a <vprintfmt+0x375>
err = va_arg(ap, int);
f0100e00: 8b 45 14 mov 0x14(%ebp),%eax
f0100e03: 8d 78 04 lea 0x4(%eax),%edi
f0100e06: 8b 00 mov (%eax),%eax
f0100e08: 99 cltd
f0100e09: 31 d0 xor %edx,%eax
f0100e0b: 29 d0 sub %edx,%eax
if (err >= MAXERROR || (p = error_string[err]) == NULL)
f0100e0d: 83 f8 06 cmp $0x6,%eax
f0100e10: 7f 23 jg f0100e35 <vprintfmt+0x140>
f0100e12: 8b 14 85 88 1f 10 f0 mov -0xfefe078(,%eax,4),%edx
f0100e19: 85 d2 test %edx,%edx
f0100e1b: 74 18 je f0100e35 <vprintfmt+0x140>
printfmt(putch, putdat, "%s", p);
f0100e1d: 52 push %edx
f0100e1e: 68 c2 1d 10 f0 push $0xf0101dc2
f0100e23: 53 push %ebx
f0100e24: 56 push %esi
f0100e25: e8 aa fe ff ff call f0100cd4 <printfmt>
f0100e2a: 83 c4 10 add $0x10,%esp
err = va_arg(ap, int);
f0100e2d: 89 7d 14 mov %edi,0x14(%ebp)
f0100e30: e9 35 02 00 00 jmp f010106a <vprintfmt+0x375>
printfmt(putch, putdat, "error %d", err);
f0100e35: 50 push %eax
f0100e36: 68 b9 1d 10 f0 push $0xf0101db9
f0100e3b: 53 push %ebx
f0100e3c: 56 push %esi
f0100e3d: e8 92 fe ff ff call f0100cd4 <printfmt>
f0100e42: 83 c4 10 add $0x10,%esp
err = va_arg(ap, int);
f0100e45: 89 7d 14 mov %edi,0x14(%ebp)
printfmt(putch, putdat, "error %d", err);
f0100e48: e9 1d 02 00 00 jmp f010106a <vprintfmt+0x375>
if ((p = va_arg(ap, char *)) == NULL)
f0100e4d: 8b 45 14 mov 0x14(%ebp),%eax
f0100e50: 83 c0 04 add $0x4,%eax
f0100e53: 89 45 c8 mov %eax,-0x38(%ebp)
f0100e56: 8b 45 14 mov 0x14(%ebp),%eax
f0100e59: 8b 10 mov (%eax),%edx
p = "(null)";
f0100e5b: 85 d2 test %edx,%edx
f0100e5d: b8 b2 1d 10 f0 mov $0xf0101db2,%eax
f0100e62: 0f 45 c2 cmovne %edx,%eax
f0100e65: 89 45 cc mov %eax,-0x34(%ebp)
if (width > 0 && padc != '-')
f0100e68: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
f0100e6c: 7e 06 jle f0100e74 <vprintfmt+0x17f>
f0100e6e: 80 7d d3 2d cmpb $0x2d,-0x2d(%ebp)
f0100e72: 75 0d jne f0100e81 <vprintfmt+0x18c>
for (width -= strnlen(p, precision); width > 0; width--)
f0100e74: 8b 45 cc mov -0x34(%ebp),%eax
f0100e77: 89 c7 mov %eax,%edi
f0100e79: 03 45 d4 add -0x2c(%ebp),%eax
f0100e7c: 89 45 d4 mov %eax,-0x2c(%ebp)
f0100e7f: eb 55 jmp f0100ed6 <vprintfmt+0x1e1>
f0100e81: 83 ec 08 sub $0x8,%esp
f0100e84: ff 75 d8 pushl -0x28(%ebp)
f0100e87: ff 75 cc pushl -0x34(%ebp)
f0100e8a: e8 fb 03 00 00 call f010128a <strnlen>
f0100e8f: 8b 55 d4 mov -0x2c(%ebp),%edx
f0100e92: 29 c2 sub %eax,%edx
f0100e94: 89 55 c4 mov %edx,-0x3c(%ebp)
f0100e97: 83 c4 10 add $0x10,%esp
f0100e9a: 89 d7 mov %edx,%edi
putch(padc, putdat);
f0100e9c: 0f be 45 d3 movsbl -0x2d(%ebp),%eax
f0100ea0: 89 45 d4 mov %eax,-0x2c(%ebp)
for (width -= strnlen(p, precision); width > 0; width--)
f0100ea3: 85 ff test %edi,%edi
f0100ea5: 7e 11 jle f0100eb8 <vprintfmt+0x1c3>
putch(padc, putdat);
f0100ea7: 83 ec 08 sub $0x8,%esp
f0100eaa: 53 push %ebx
f0100eab: ff 75 d4 pushl -0x2c(%ebp)
f0100eae: ff d6 call *%esi
for (width -= strnlen(p, precision); width > 0; width--)
f0100eb0: 83 ef 01 sub $0x1,%edi
f0100eb3: 83 c4 10 add $0x10,%esp
f0100eb6: eb eb jmp f0100ea3 <vprintfmt+0x1ae>
f0100eb8: 8b 55 c4 mov -0x3c(%ebp),%edx
f0100ebb: 85 d2 test %edx,%edx
f0100ebd: b8 00 00 00 00 mov $0x0,%eax
f0100ec2: 0f 49 c2 cmovns %edx,%eax
f0100ec5: 29 c2 sub %eax,%edx
f0100ec7: 89 55 d4 mov %edx,-0x2c(%ebp)
f0100eca: eb a8 jmp f0100e74 <vprintfmt+0x17f>
putch(ch, putdat);
f0100ecc: 83 ec 08 sub $0x8,%esp
f0100ecf: 53 push %ebx
f0100ed0: 52 push %edx
f0100ed1: ff d6 call *%esi
f0100ed3: 83 c4 10 add $0x10,%esp
f0100ed6: 8b 4d d4 mov -0x2c(%ebp),%ecx
f0100ed9: 29 f9 sub %edi,%ecx
for (; (ch = *p++) != '\0' && (precision < 0 || --precision >= 0); width--)
f0100edb: 83 c7 01 add $0x1,%edi
f0100ede: 0f b6 47 ff movzbl -0x1(%edi),%eax
f0100ee2: 0f be d0 movsbl %al,%edx
f0100ee5: 85 d2 test %edx,%edx
f0100ee7: 74 4b je f0100f34 <vprintfmt+0x23f>
f0100ee9: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
f0100eed: 78 06 js f0100ef5 <vprintfmt+0x200>
f0100eef: 83 6d d8 01 subl $0x1,-0x28(%ebp)
f0100ef3: 78 1e js f0100f13 <vprintfmt+0x21e>
if (altflag && (ch < ' ' || ch > '~'))
f0100ef5: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
f0100ef9: 74 d1 je f0100ecc <vprintfmt+0x1d7>
f0100efb: 0f be c0 movsbl %al,%eax
f0100efe: 83 e8 20 sub $0x20,%eax
f0100f01: 83 f8 5e cmp $0x5e,%eax
f0100f04: 76 c6 jbe f0100ecc <vprintfmt+0x1d7>
putch('?', putdat);
f0100f06: 83 ec 08 sub $0x8,%esp
f0100f09: 53 push %ebx
f0100f0a: 6a 3f push $0x3f
f0100f0c: ff d6 call *%esi
f0100f0e: 83 c4 10 add $0x10,%esp
f0100f11: eb c3 jmp f0100ed6 <vprintfmt+0x1e1>
f0100f13: 89 cf mov %ecx,%edi
f0100f15: eb 0e jmp f0100f25 <vprintfmt+0x230>
putch(' ', putdat);
f0100f17: 83 ec 08 sub $0x8,%esp
f0100f1a: 53 push %ebx
f0100f1b: 6a 20 push $0x20
f0100f1d: ff d6 call *%esi
for (; width > 0; width--)
f0100f1f: 83 ef 01 sub $0x1,%edi
f0100f22: 83 c4 10 add $0x10,%esp
f0100f25: 85 ff test %edi,%edi
f0100f27: 7f ee jg f0100f17 <vprintfmt+0x222>
if ((p = va_arg(ap, char *)) == NULL)
f0100f29: 8b 45 c8 mov -0x38(%ebp),%eax
f0100f2c: 89 45 14 mov %eax,0x14(%ebp)
f0100f2f: e9 36 01 00 00 jmp f010106a <vprintfmt+0x375>
f0100f34: 89 cf mov %ecx,%edi
f0100f36: eb ed jmp f0100f25 <vprintfmt+0x230>
if (lflag >= 2)
f0100f38: 83 f9 01 cmp $0x1,%ecx
f0100f3b: 7f 1f jg f0100f5c <vprintfmt+0x267>
else if (lflag)
f0100f3d: 85 c9 test %ecx,%ecx
f0100f3f: 74 67 je f0100fa8 <vprintfmt+0x2b3>
return va_arg(*ap, long);
f0100f41: 8b 45 14 mov 0x14(%ebp),%eax
f0100f44: 8b 00 mov (%eax),%eax
f0100f46: 89 45 d8 mov %eax,-0x28(%ebp)
f0100f49: 89 c1 mov %eax,%ecx
f0100f4b: c1 f9 1f sar $0x1f,%ecx
f0100f4e: 89 4d dc mov %ecx,-0x24(%ebp)
f0100f51: 8b 45 14 mov 0x14(%ebp),%eax
f0100f54: 8d 40 04 lea 0x4(%eax),%eax
f0100f57: 89 45 14 mov %eax,0x14(%ebp)
f0100f5a: eb 17 jmp f0100f73 <vprintfmt+0x27e>
return va_arg(*ap, long long);
f0100f5c: 8b 45 14 mov 0x14(%ebp),%eax
f0100f5f: 8b 50 04 mov 0x4(%eax),%edx
f0100f62: 8b 00 mov (%eax),%eax
f0100f64: 89 45 d8 mov %eax,-0x28(%ebp)
f0100f67: 89 55 dc mov %edx,-0x24(%ebp)
f0100f6a: 8b 45 14 mov 0x14(%ebp),%eax
f0100f6d: 8d 40 08 lea 0x8(%eax),%eax
f0100f70: 89 45 14 mov %eax,0x14(%ebp)
if ((long long) num < 0) {
f0100f73: 8b 55 d8 mov -0x28(%ebp),%edx
f0100f76: 8b 4d dc mov -0x24(%ebp),%ecx
base = 10;
f0100f79: b8 0a 00 00 00 mov $0xa,%eax
if ((long long) num < 0) {
f0100f7e: 85 c9 test %ecx,%ecx
f0100f80: 0f 89 ca 00 00 00 jns f0101050 <vprintfmt+0x35b>
putch('-', putdat);
f0100f86: 83 ec 08 sub $0x8,%esp
f0100f89: 53 push %ebx
f0100f8a: 6a 2d push $0x2d
f0100f8c: ff d6 call *%esi
num = -(long long) num;
f0100f8e: 8b 55 d8 mov -0x28(%ebp),%edx
f0100f91: 8b 4d dc mov -0x24(%ebp),%ecx
f0100f94: f7 da neg %edx
f0100f96: 83 d1 00 adc $0x0,%ecx
f0100f99: f7 d9 neg %ecx
f0100f9b: 83 c4 10 add $0x10,%esp
base = 10;
f0100f9e: b8 0a 00 00 00 mov $0xa,%eax
f0100fa3: e9 a8 00 00 00 jmp f0101050 <vprintfmt+0x35b>
return va_arg(*ap, int);
f0100fa8: 8b 45 14 mov 0x14(%ebp),%eax
f0100fab: 8b 00 mov (%eax),%eax
f0100fad: 89 45 d8 mov %eax,-0x28(%ebp)
f0100fb0: 99 cltd
f0100fb1: 89 55 dc mov %edx,-0x24(%ebp)
f0100fb4: 8b 45 14 mov 0x14(%ebp),%eax
f0100fb7: 8d 40 04 lea 0x4(%eax),%eax
f0100fba: 89 45 14 mov %eax,0x14(%ebp)
f0100fbd: eb b4 jmp f0100f73 <vprintfmt+0x27e>
if (lflag >= 2)
f0100fbf: 83 f9 01 cmp $0x1,%ecx
f0100fc2: 7f 1b jg f0100fdf <vprintfmt+0x2ea>
else if (lflag)
f0100fc4: 85 c9 test %ecx,%ecx
f0100fc6: 74 2c je f0100ff4 <vprintfmt+0x2ff>
return va_arg(*ap, unsigned long);
f0100fc8: 8b 45 14 mov 0x14(%ebp),%eax
f0100fcb: 8b 10 mov (%eax),%edx
f0100fcd: b9 00 00 00 00 mov $0x0,%ecx
f0100fd2: 8d 40 04 lea 0x4(%eax),%eax
f0100fd5: 89 45 14 mov %eax,0x14(%ebp)
base = 10;
f0100fd8: b8 0a 00 00 00 mov $0xa,%eax
return va_arg(*ap, unsigned long);
f0100fdd: eb 71 jmp f0101050 <vprintfmt+0x35b>
return va_arg(*ap, unsigned long long);
f0100fdf: 8b 45 14 mov 0x14(%ebp),%eax
f0100fe2: 8b 10 mov (%eax),%edx
f0100fe4: 8b 48 04 mov 0x4(%eax),%ecx
f0100fe7: 8d 40 08 lea 0x8(%eax),%eax
f0100fea: 89 45 14 mov %eax,0x14(%ebp)
base = 10;
f0100fed: b8 0a 00 00 00 mov $0xa,%eax
return va_arg(*ap, unsigned long long);
f0100ff2: eb 5c jmp f0101050 <vprintfmt+0x35b>
return va_arg(*ap, unsigned int);
f0100ff4: 8b 45 14 mov 0x14(%ebp),%eax
f0100ff7: 8b 10 mov (%eax),%edx
f0100ff9: b9 00 00 00 00 mov $0x0,%ecx
f0100ffe: 8d 40 04 lea 0x4(%eax),%eax
f0101001: 89 45 14 mov %eax,0x14(%ebp)
base = 10;
f0101004: b8 0a 00 00 00 mov $0xa,%eax
return va_arg(*ap, unsigned int);
f0101009: eb 45 jmp f0101050 <vprintfmt+0x35b>
putch('X', putdat);
f010100b: 83 ec 08 sub $0x8,%esp
f010100e: 53 push %ebx
f010100f: 6a 58 push $0x58
f0101011: ff d6 call *%esi
putch('X', putdat);
f0101013: 83 c4 08 add $0x8,%esp
f0101016: 53 push %ebx
f0101017: 6a 58 push $0x58
f0101019: ff d6 call *%esi
putch('X', putdat);
f010101b: 83 c4 08 add $0x8,%esp
f010101e: 53 push %ebx
f010101f: 6a 58 push $0x58
f0101021: ff d6 call *%esi
break;
f0101023: 83 c4 10 add $0x10,%esp
f0101026: eb 42 jmp f010106a <vprintfmt+0x375>
putch('0', putdat);
f0101028: 83 ec 08 sub $0x8,%esp
f010102b: 53 push %ebx
f010102c: 6a 30 push $0x30
f010102e: ff d6 call *%esi
putch('x', putdat);
f0101030: 83 c4 08 add $0x8,%esp
f0101033: 53 push %ebx
f0101034: 6a 78 push $0x78
f0101036: ff d6 call *%esi
num = (unsigned long long)
f0101038: 8b 45 14 mov 0x14(%ebp),%eax
f010103b: 8b 10 mov (%eax),%edx
f010103d: b9 00 00 00 00 mov $0x0,%ecx
goto number;
f0101042: 83 c4 10 add $0x10,%esp
(uintptr_t) va_arg(ap, void *);
f0101045: 8d 40 04 lea 0x4(%eax),%eax
f0101048: 89 45 14 mov %eax,0x14(%ebp)
base = 16;
f010104b: b8 10 00 00 00 mov $0x10,%eax
printnum(putch, putdat, num, base, width, padc);
f0101050: 83 ec 0c sub $0xc,%esp
f0101053: 0f be 7d d3 movsbl -0x2d(%ebp),%edi
f0101057: 57 push %edi
f0101058: ff 75 d4 pushl -0x2c(%ebp)
f010105b: 50 push %eax
f010105c: 51 push %ecx
f010105d: 52 push %edx
f010105e: 89 da mov %ebx,%edx
f0101060: 89 f0 mov %esi,%eax
f0101062: e8 a3 fb ff ff call f0100c0a <printnum>
break;
f0101067: 83 c4 20 add $0x20,%esp
if ((p = va_arg(ap, char *)) == NULL)
f010106a: 8b 7d e4 mov -0x1c(%ebp),%edi
while ((ch = *(unsigned char *) fmt++) != '%') {
f010106d: 83 c7 01 add $0x1,%edi
f0101070: 0f b6 47 ff movzbl -0x1(%edi),%eax
f0101074: 83 f8 25 cmp $0x25,%eax
f0101077: 0f 84 93 fc ff ff je f0100d10 <vprintfmt+0x1b>
if (ch == '\0')
f010107d: 85 c0 test %eax,%eax
f010107f: 0f 84 8b 00 00 00 je f0101110 <vprintfmt+0x41b>
putch(ch, putdat);
f0101085: 83 ec 08 sub $0x8,%esp
f0101088: 53 push %ebx
f0101089: 50 push %eax
f010108a: ff d6 call *%esi
f010108c: 83 c4 10 add $0x10,%esp
f010108f: eb dc jmp f010106d <vprintfmt+0x378>
if (lflag >= 2)
f0101091: 83 f9 01 cmp $0x1,%ecx
f0101094: 7f 1b jg f01010b1 <vprintfmt+0x3bc>
else if (lflag)
f0101096: 85 c9 test %ecx,%ecx
f0101098: 74 2c je f01010c6 <vprintfmt+0x3d1>
return va_arg(*ap, unsigned long);
f010109a: 8b 45 14 mov 0x14(%ebp),%eax
f010109d: 8b 10 mov (%eax),%edx
f010109f: b9 00 00 00 00 mov $0x0,%ecx
f01010a4: 8d 40 04 lea 0x4(%eax),%eax
f01010a7: 89 45 14 mov %eax,0x14(%ebp)
base = 16;
f01010aa: b8 10 00 00 00 mov $0x10,%eax
return va_arg(*ap, unsigned long);
f01010af: eb 9f jmp f0101050 <vprintfmt+0x35b>
return va_arg(*ap, unsigned long long);
f01010b1: 8b 45 14 mov 0x14(%ebp),%eax
f01010b4: 8b 10 mov (%eax),%edx
f01010b6: 8b 48 04 mov 0x4(%eax),%ecx
f01010b9: 8d 40 08 lea 0x8(%eax),%eax
f01010bc: 89 45 14 mov %eax,0x14(%ebp)
base = 16;
f01010bf: b8 10 00 00 00 mov $0x10,%eax
return va_arg(*ap, unsigned long long);
f01010c4: eb 8a jmp f0101050 <vprintfmt+0x35b>
return va_arg(*ap, unsigned int);
f01010c6: 8b 45 14 mov 0x14(%ebp),%eax
f01010c9: 8b 10 mov (%eax),%edx
f01010cb: b9 00 00 00 00 mov $0x0,%ecx
f01010d0: 8d 40 04 lea 0x4(%eax),%eax
f01010d3: 89 45 14 mov %eax,0x14(%ebp)
base = 16;
f01010d6: b8 10 00 00 00 mov $0x10,%eax
return va_arg(*ap, unsigned int);
f01010db: e9 70 ff ff ff jmp f0101050 <vprintfmt+0x35b>
putch(ch, putdat);
f01010e0: 83 ec 08 sub $0x8,%esp
f01010e3: 53 push %ebx
f01010e4: 6a 25 push $0x25
f01010e6: ff d6 call *%esi
break;
f01010e8: 83 c4 10 add $0x10,%esp
f01010eb: e9 7a ff ff ff jmp f010106a <vprintfmt+0x375>
putch('%', putdat);
f01010f0: 83 ec 08 sub $0x8,%esp
f01010f3: 53 push %ebx
f01010f4: 6a 25 push $0x25
f01010f6: ff d6 call *%esi
for (fmt--; fmt[-1] != '%'; fmt--)
f01010f8: 83 c4 10 add $0x10,%esp
f01010fb: 89 f8 mov %edi,%eax
f01010fd: 80 78 ff 25 cmpb $0x25,-0x1(%eax)
f0101101: 74 05 je f0101108 <vprintfmt+0x413>
f0101103: 83 e8 01 sub $0x1,%eax
f0101106: eb f5 jmp f01010fd <vprintfmt+0x408>
f0101108: 89 45 e4 mov %eax,-0x1c(%ebp)
f010110b: e9 5a ff ff ff jmp f010106a <vprintfmt+0x375>
}
f0101110: 8d 65 f4 lea -0xc(%ebp),%esp
f0101113: 5b pop %ebx
f0101114: 5e pop %esi
f0101115: 5f pop %edi
f0101116: 5d pop %ebp
f0101117: c3 ret
f0101118 <vsnprintf>:
int
vsnprintf(char *buf, int n, const char *fmt, va_list ap)
{
f0101118: f3 0f 1e fb endbr32
f010111c: 55 push %ebp
f010111d: 89 e5 mov %esp,%ebp
f010111f: 83 ec 18 sub $0x18,%esp
f0101122: 8b 45 08 mov 0x8(%ebp),%eax
f0101125: 8b 55 0c mov 0xc(%ebp),%edx
struct sprintbuf b = {buf, buf+n-1, 0};
f0101128: 89 45 ec mov %eax,-0x14(%ebp)
f010112b: 8d 4c 10 ff lea -0x1(%eax,%edx,1),%ecx
f010112f: 89 4d f0 mov %ecx,-0x10(%ebp)
f0101132: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
if (buf == NULL || n < 1)
f0101139: 85 c0 test %eax,%eax
f010113b: 74 26 je f0101163 <vsnprintf+0x4b>
f010113d: 85 d2 test %edx,%edx
f010113f: 7e 22 jle f0101163 <vsnprintf+0x4b>
return -E_INVAL;
// print the string to the buffer
vprintfmt((void*)sprintputch, &b, fmt, ap);
f0101141: ff 75 14 pushl 0x14(%ebp)
f0101144: ff 75 10 pushl 0x10(%ebp)
f0101147: 8d 45 ec lea -0x14(%ebp),%eax
f010114a: 50 push %eax
f010114b: 68 b3 0c 10 f0 push $0xf0100cb3
f0101150: e8 a0 fb ff ff call f0100cf5 <vprintfmt>
// null terminate the buffer
*b.buf = '\0';
f0101155: 8b 45 ec mov -0x14(%ebp),%eax
f0101158: c6 00 00 movb $0x0,(%eax)
return b.cnt;
f010115b: 8b 45 f4 mov -0xc(%ebp),%eax
f010115e: 83 c4 10 add $0x10,%esp
}
f0101161: c9 leave
f0101162: c3 ret
return -E_INVAL;
f0101163: b8 fd ff ff ff mov $0xfffffffd,%eax
f0101168: eb f7 jmp f0101161 <vsnprintf+0x49>
f010116a <snprintf>:
int
snprintf(char *buf, int n, const char *fmt, ...)
{
f010116a: f3 0f 1e fb endbr32
f010116e: 55 push %ebp
f010116f: 89 e5 mov %esp,%ebp
f0101171: 83 ec 08 sub $0x8,%esp
va_list ap;
int rc;
va_start(ap, fmt);
f0101174: 8d 45 14 lea 0x14(%ebp),%eax
rc = vsnprintf(buf, n, fmt, ap);
f0101177: 50 push %eax
f0101178: ff 75 10 pushl 0x10(%ebp)
f010117b: ff 75 0c pushl 0xc(%ebp)
f010117e: ff 75 08 pushl 0x8(%ebp)
f0101181: e8 92 ff ff ff call f0101118 <vsnprintf>
va_end(ap);
return rc;
}
f0101186: c9 leave
f0101187: c3 ret
f0101188 <readline>:
#define BUFLEN 1024
static char buf[BUFLEN];
char *
readline(const char *prompt)
{
f0101188: f3 0f 1e fb endbr32
f010118c: 55 push %ebp
f010118d: 89 e5 mov %esp,%ebp
f010118f: 57 push %edi
f0101190: 56 push %esi
f0101191: 53 push %ebx
f0101192: 83 ec 0c sub $0xc,%esp
f0101195: 8b 45 08 mov 0x8(%ebp),%eax
int i, c, echoing;
if (prompt != NULL)
f0101198: 85 c0 test %eax,%eax
f010119a: 74 11 je f01011ad <readline+0x25>
cprintf("%s", prompt);
f010119c: 83 ec 08 sub $0x8,%esp
f010119f: 50 push %eax
f01011a0: 68 c2 1d 10 f0 push $0xf0101dc2
f01011a5: e8 7d f7 ff ff call f0100927 <cprintf>
f01011aa: 83 c4 10 add $0x10,%esp
i = 0;
echoing = iscons(0);
f01011ad: 83 ec 0c sub $0xc,%esp
f01011b0: 6a 00 push $0x0
f01011b2: e8 f1 f4 ff ff call f01006a8 <iscons>
f01011b7: 89 c7 mov %eax,%edi
f01011b9: 83 c4 10 add $0x10,%esp
i = 0;
f01011bc: be 00 00 00 00 mov $0x0,%esi
f01011c1: eb 4b jmp f010120e <readline+0x86>
while (1) {
c = getchar();
if (c < 0) {
cprintf("read error: %e\n", c);
f01011c3: 83 ec 08 sub $0x8,%esp
f01011c6: 50 push %eax
f01011c7: 68 a4 1f 10 f0 push $0xf0101fa4
f01011cc: e8 56 f7 ff ff call f0100927 <cprintf>
return NULL;
f01011d1: 83 c4 10 add $0x10,%esp
f01011d4: b8 00 00 00 00 mov $0x0,%eax
cputchar('\n');
buf[i] = 0;
return buf;
}
}
}
f01011d9: 8d 65 f4 lea -0xc(%ebp),%esp
f01011dc: 5b pop %ebx
f01011dd: 5e pop %esi
f01011de: 5f pop %edi
f01011df: 5d pop %ebp
f01011e0: c3 ret
if (echoing)
f01011e1: 85 ff test %edi,%edi
f01011e3: 75 05 jne f01011ea <readline+0x62>
i--;
f01011e5: 83 ee 01 sub $0x1,%esi
f01011e8: eb 24 jmp f010120e <readline+0x86>
cputchar('\b');
f01011ea: 83 ec 0c sub $0xc,%esp
f01011ed: 6a 08 push $0x8
f01011ef: e8 8b f4 ff ff call f010067f <cputchar>
f01011f4: 83 c4 10 add $0x10,%esp
f01011f7: eb ec jmp f01011e5 <readline+0x5d>
cputchar(c);
f01011f9: 83 ec 0c sub $0xc,%esp
f01011fc: 53 push %ebx
f01011fd: e8 7d f4 ff ff call f010067f <cputchar>
f0101202: 83 c4 10 add $0x10,%esp
buf[i++] = c;
f0101205: 88 9e 40 25 11 f0 mov %bl,-0xfeedac0(%esi)
f010120b: 8d 76 01 lea 0x1(%esi),%esi
c = getchar();
f010120e: e8 80 f4 ff ff call f0100693 <getchar>
f0101213: 89 c3 mov %eax,%ebx
if (c < 0) {
f0101215: 85 c0 test %eax,%eax
f0101217: 78 aa js f01011c3 <readline+0x3b>
} else if ((c == '\b' || c == '\x7f') && i > 0) {
f0101219: 83 f8 08 cmp $0x8,%eax
f010121c: 0f 94 c2 sete %dl
f010121f: 83 f8 7f cmp $0x7f,%eax
f0101222: 0f 94 c0 sete %al
f0101225: 08 c2 or %al,%dl
f0101227: 74 04 je f010122d <readline+0xa5>
f0101229: 85 f6 test %esi,%esi
f010122b: 7f b4 jg f01011e1 <readline+0x59>
} else if (c >= ' ' && i < BUFLEN-1) {
f010122d: 83 fb 1f cmp $0x1f,%ebx
f0101230: 7e 0e jle f0101240 <readline+0xb8>
f0101232: 81 fe fe 03 00 00 cmp $0x3fe,%esi
f0101238: 7f 06 jg f0101240 <readline+0xb8>
if (echoing)
f010123a: 85 ff test %edi,%edi
f010123c: 74 c7 je f0101205 <readline+0x7d>
f010123e: eb b9 jmp f01011f9 <readline+0x71>
} else if (c == '\n' || c == '\r') {
f0101240: 83 fb 0a cmp $0xa,%ebx
f0101243: 74 05 je f010124a <readline+0xc2>
f0101245: 83 fb 0d cmp $0xd,%ebx
f0101248: 75 c4 jne f010120e <readline+0x86>
if (echoing)
f010124a: 85 ff test %edi,%edi
f010124c: 75 11 jne f010125f <readline+0xd7>
buf[i] = 0;
f010124e: c6 86 40 25 11 f0 00 movb $0x0,-0xfeedac0(%esi)
return buf;
f0101255: b8 40 25 11 f0 mov $0xf0112540,%eax
f010125a: e9 7a ff ff ff jmp f01011d9 <readline+0x51>
cputchar('\n');
f010125f: 83 ec 0c sub $0xc,%esp
f0101262: 6a 0a push $0xa
f0101264: e8 16 f4 ff ff call f010067f <cputchar>
f0101269: 83 c4 10 add $0x10,%esp
f010126c: eb e0 jmp f010124e <readline+0xc6>
f010126e <strlen>:
// Primespipe runs 3x faster this way.
#define ASM 1
int
strlen(const char *s)
{
f010126e: f3 0f 1e fb endbr32
f0101272: 55 push %ebp
f0101273: 89 e5 mov %esp,%ebp
f0101275: 8b 55 08 mov 0x8(%ebp),%edx
int n;
for (n = 0; *s != '\0'; s++)
f0101278: b8 00 00 00 00 mov $0x0,%eax
f010127d: 80 3c 02 00 cmpb $0x0,(%edx,%eax,1)
f0101281: 74 05 je f0101288 <strlen+0x1a>
n++;
f0101283: 83 c0 01 add $0x1,%eax
f0101286: eb f5 jmp f010127d <strlen+0xf>
return n;
}
f0101288: 5d pop %ebp
f0101289: c3 ret
f010128a <strnlen>:
int
strnlen(const char *s, size_t size)
{
f010128a: f3 0f 1e fb endbr32
f010128e: 55 push %ebp
f010128f: 89 e5 mov %esp,%ebp
f0101291: 8b 4d 08 mov 0x8(%ebp),%ecx
f0101294: 8b 55 0c mov 0xc(%ebp),%edx
int n;
for (n = 0; size > 0 && *s != '\0'; s++, size--)
f0101297: b8 00 00 00 00 mov $0x0,%eax
f010129c: 39 d0 cmp %edx,%eax
f010129e: 74 0d je f01012ad <strnlen+0x23>
f01012a0: 80 3c 01 00 cmpb $0x0,(%ecx,%eax,1)
f01012a4: 74 05 je f01012ab <strnlen+0x21>
n++;
f01012a6: 83 c0 01 add $0x1,%eax
f01012a9: eb f1 jmp f010129c <strnlen+0x12>
f01012ab: 89 c2 mov %eax,%edx
return n;
}
f01012ad: 89 d0 mov %edx,%eax
f01012af: 5d pop %ebp
f01012b0: c3 ret
f01012b1 <strcpy>:
char *
strcpy(char *dst, const char *src)
{
f01012b1: f3 0f 1e fb endbr32
f01012b5: 55 push %ebp
f01012b6: 89 e5 mov %esp,%ebp
f01012b8: 53 push %ebx
f01012b9: 8b 4d 08 mov 0x8(%ebp),%ecx
f01012bc: 8b 5d 0c mov 0xc(%ebp),%ebx
char *ret;
ret = dst;
while ((*dst++ = *src++) != '\0')
f01012bf: b8 00 00 00 00 mov $0x0,%eax
f01012c4: 0f b6 14 03 movzbl (%ebx,%eax,1),%edx
f01012c8: 88 14 01 mov %dl,(%ecx,%eax,1)
f01012cb: 83 c0 01 add $0x1,%eax
f01012ce: 84 d2 test %dl,%dl
f01012d0: 75 f2 jne f01012c4 <strcpy+0x13>
/* do nothing */;
return ret;
}
f01012d2: 89 c8 mov %ecx,%eax
f01012d4: 5b pop %ebx
f01012d5: 5d pop %ebp
f01012d6: c3 ret
f01012d7 <strcat>:
char *
strcat(char *dst, const char *src)
{
f01012d7: f3 0f 1e fb endbr32
f01012db: 55 push %ebp
f01012dc: 89 e5 mov %esp,%ebp
f01012de: 53 push %ebx
f01012df: 83 ec 10 sub $0x10,%esp
f01012e2: 8b 5d 08 mov 0x8(%ebp),%ebx
int len = strlen(dst);
f01012e5: 53 push %ebx
f01012e6: e8 83 ff ff ff call f010126e <strlen>
f01012eb: 83 c4 08 add $0x8,%esp
strcpy(dst + len, src);
f01012ee: ff 75 0c pushl 0xc(%ebp)
f01012f1: 01 d8 add %ebx,%eax
f01012f3: 50 push %eax
f01012f4: e8 b8 ff ff ff call f01012b1 <strcpy>
return dst;
}
f01012f9: 89 d8 mov %ebx,%eax
f01012fb: 8b 5d fc mov -0x4(%ebp),%ebx
f01012fe: c9 leave
f01012ff: c3 ret
f0101300 <strncpy>:
char *
strncpy(char *dst, const char *src, size_t size) {
f0101300: f3 0f 1e fb endbr32
f0101304: 55 push %ebp
f0101305: 89 e5 mov %esp,%ebp
f0101307: 56 push %esi
f0101308: 53 push %ebx
f0101309: 8b 75 08 mov 0x8(%ebp),%esi
f010130c: 8b 55 0c mov 0xc(%ebp),%edx
f010130f: 89 f3 mov %esi,%ebx
f0101311: 03 5d 10 add 0x10(%ebp),%ebx
size_t i;
char *ret;
ret = dst;
for (i = 0; i < size; i++) {
f0101314: 89 f0 mov %esi,%eax
f0101316: 39 d8 cmp %ebx,%eax
f0101318: 74 11 je f010132b <strncpy+0x2b>
*dst++ = *src;
f010131a: 83 c0 01 add $0x1,%eax
f010131d: 0f b6 0a movzbl (%edx),%ecx
f0101320: 88 48 ff mov %cl,-0x1(%eax)
// If strlen(src) < size, null-pad 'dst' out to 'size' chars
if (*src != '\0')
src++;
f0101323: 80 f9 01 cmp $0x1,%cl
f0101326: 83 da ff sbb $0xffffffff,%edx
f0101329: eb eb jmp f0101316 <strncpy+0x16>
}
return ret;
}
f010132b: 89 f0 mov %esi,%eax
f010132d: 5b pop %ebx
f010132e: 5e pop %esi
f010132f: 5d pop %ebp
f0101330: c3 ret
f0101331 <strlcpy>:
size_t
strlcpy(char *dst, const char *src, size_t size)
{
f0101331: f3 0f 1e fb endbr32
f0101335: 55 push %ebp
f0101336: 89 e5 mov %esp,%ebp
f0101338: 56 push %esi
f0101339: 53 push %ebx
f010133a: 8b 75 08 mov 0x8(%ebp),%esi
f010133d: 8b 4d 0c mov 0xc(%ebp),%ecx
f0101340: 8b 55 10 mov 0x10(%ebp),%edx
f0101343: 89 f0 mov %esi,%eax
char *dst_in;
dst_in = dst;
if (size > 0) {
f0101345: 85 d2 test %edx,%edx
f0101347: 74 21 je f010136a <strlcpy+0x39>
f0101349: 8d 44 16 ff lea -0x1(%esi,%edx,1),%eax
f010134d: 89 f2 mov %esi,%edx
while (--size > 0 && *src != '\0')
f010134f: 39 c2 cmp %eax,%edx
f0101351: 74 14 je f0101367 <strlcpy+0x36>
f0101353: 0f b6 19 movzbl (%ecx),%ebx
f0101356: 84 db test %bl,%bl
f0101358: 74 0b je f0101365 <strlcpy+0x34>
*dst++ = *src++;
f010135a: 83 c1 01 add $0x1,%ecx
f010135d: 83 c2 01 add $0x1,%edx
f0101360: 88 5a ff mov %bl,-0x1(%edx)
f0101363: eb ea jmp f010134f <strlcpy+0x1e>
f0101365: 89 d0 mov %edx,%eax
*dst = '\0';
f0101367: c6 00 00 movb $0x0,(%eax)
}
return dst - dst_in;
f010136a: 29 f0 sub %esi,%eax
}
f010136c: 5b pop %ebx
f010136d: 5e pop %esi
f010136e: 5d pop %ebp
f010136f: c3 ret
f0101370 <strcmp>:
int
strcmp(const char *p, const char *q)
{
f0101370: f3 0f 1e fb endbr32
f0101374: 55 push %ebp
f0101375: 89 e5 mov %esp,%ebp
f0101377: 8b 4d 08 mov 0x8(%ebp),%ecx
f010137a: 8b 55 0c mov 0xc(%ebp),%edx
while (*p && *p == *q)
f010137d: 0f b6 01 movzbl (%ecx),%eax
f0101380: 84 c0 test %al,%al
f0101382: 74 0c je f0101390 <strcmp+0x20>
f0101384: 3a 02 cmp (%edx),%al
f0101386: 75 08 jne f0101390 <strcmp+0x20>
p++, q++;
f0101388: 83 c1 01 add $0x1,%ecx
f010138b: 83 c2 01 add $0x1,%edx
f010138e: eb ed jmp f010137d <strcmp+0xd>
return (int) ((unsigned char) *p - (unsigned char) *q);
f0101390: 0f b6 c0 movzbl %al,%eax
f0101393: 0f b6 12 movzbl (%edx),%edx
f0101396: 29 d0 sub %edx,%eax
}
f0101398: 5d pop %ebp
f0101399: c3 ret
f010139a <strncmp>:
int
strncmp(const char *p, const char *q, size_t n)
{
f010139a: f3 0f 1e fb endbr32
f010139e: 55 push %ebp
f010139f: 89 e5 mov %esp,%ebp
f01013a1: 53 push %ebx
f01013a2: 8b 45 08 mov 0x8(%ebp),%eax
f01013a5: 8b 55 0c mov 0xc(%ebp),%edx
f01013a8: 89 c3 mov %eax,%ebx
f01013aa: 03 5d 10 add 0x10(%ebp),%ebx
while (n > 0 && *p && *p == *q)
f01013ad: eb 06 jmp f01013b5 <strncmp+0x1b>
n--, p++, q++;
f01013af: 83 c0 01 add $0x1,%eax
f01013b2: 83 c2 01 add $0x1,%edx
while (n > 0 && *p && *p == *q)
f01013b5: 39 d8 cmp %ebx,%eax
f01013b7: 74 16 je f01013cf <strncmp+0x35>
f01013b9: 0f b6 08 movzbl (%eax),%ecx
f01013bc: 84 c9 test %cl,%cl
f01013be: 74 04 je f01013c4 <strncmp+0x2a>
f01013c0: 3a 0a cmp (%edx),%cl
f01013c2: 74 eb je f01013af <strncmp+0x15>
if (n == 0)
return 0;
else
return (int) ((unsigned char) *p - (unsigned char) *q);
f01013c4: 0f b6 00 movzbl (%eax),%eax
f01013c7: 0f b6 12 movzbl (%edx),%edx
f01013ca: 29 d0 sub %edx,%eax
}
f01013cc: 5b pop %ebx
f01013cd: 5d pop %ebp
f01013ce: c3 ret
return 0;
f01013cf: b8 00 00 00 00 mov $0x0,%eax
f01013d4: eb f6 jmp f01013cc <strncmp+0x32>
f01013d6 <strchr>:
// Return a pointer to the first occurrence of 'c' in 's',
// or a null pointer if the string has no 'c'.
char *
strchr(const char *s, char c)
{
f01013d6: f3 0f 1e fb endbr32
f01013da: 55 push %ebp
f01013db: 89 e5 mov %esp,%ebp
f01013dd: 8b 45 08 mov 0x8(%ebp),%eax
f01013e0: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
for (; *s; s++)
f01013e4: 0f b6 10 movzbl (%eax),%edx
f01013e7: 84 d2 test %dl,%dl
f01013e9: 74 09 je f01013f4 <strchr+0x1e>
if (*s == c)
f01013eb: 38 ca cmp %cl,%dl
f01013ed: 74 0a je f01013f9 <strchr+0x23>
for (; *s; s++)
f01013ef: 83 c0 01 add $0x1,%eax
f01013f2: eb f0 jmp f01013e4 <strchr+0xe>
return (char *) s;
return 0;
f01013f4: b8 00 00 00 00 mov $0x0,%eax
}
f01013f9: 5d pop %ebp
f01013fa: c3 ret
f01013fb <strfind>:
// Return a pointer to the first occurrence of 'c' in 's',
// or a pointer to the string-ending null character if the string has no 'c'.
char *
strfind(const char *s, char c)
{
f01013fb: f3 0f 1e fb endbr32
f01013ff: 55 push %ebp
f0101400: 89 e5 mov %esp,%ebp
f0101402: 8b 45 08 mov 0x8(%ebp),%eax
f0101405: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
for (; *s; s++)
f0101409: 0f b6 10 movzbl (%eax),%edx
if (*s == c)
f010140c: 38 ca cmp %cl,%dl
f010140e: 74 09 je f0101419 <strfind+0x1e>
f0101410: 84 d2 test %dl,%dl
f0101412: 74 05 je f0101419 <strfind+0x1e>
for (; *s; s++)
f0101414: 83 c0 01 add $0x1,%eax
f0101417: eb f0 jmp f0101409 <strfind+0xe>
break;
return (char *) s;
}
f0101419: 5d pop %ebp
f010141a: c3 ret
f010141b <memset>:
#if ASM
void *
memset(void *v, int c, size_t n)
{
f010141b: f3 0f 1e fb endbr32
f010141f: 55 push %ebp
f0101420: 89 e5 mov %esp,%ebp
f0101422: 57 push %edi
f0101423: 56 push %esi
f0101424: 53 push %ebx
f0101425: 8b 7d 08 mov 0x8(%ebp),%edi
f0101428: 8b 4d 10 mov 0x10(%ebp),%ecx
char *p;
if (n == 0)
f010142b: 85 c9 test %ecx,%ecx
f010142d: 74 31 je f0101460 <memset+0x45>
return v;
if ((int)v%4 == 0 && n%4 == 0) {
f010142f: 89 f8 mov %edi,%eax
f0101431: 09 c8 or %ecx,%eax
f0101433: a8 03 test $0x3,%al
f0101435: 75 23 jne f010145a <memset+0x3f>
c &= 0xFF;
f0101437: 0f b6 55 0c movzbl 0xc(%ebp),%edx
c = (c<<24)|(c<<16)|(c<<8)|c;
f010143b: 89 d3 mov %edx,%ebx
f010143d: c1 e3 08 shl $0x8,%ebx
f0101440: 89 d0 mov %edx,%eax
f0101442: c1 e0 18 shl $0x18,%eax
f0101445: 89 d6 mov %edx,%esi
f0101447: c1 e6 10 shl $0x10,%esi
f010144a: 09 f0 or %esi,%eax
f010144c: 09 c2 or %eax,%edx
f010144e: 09 da or %ebx,%edx
asm volatile("cld; rep stosl\n"
:: "D" (v), "a" (c), "c" (n/4)
f0101450: c1 e9 02 shr $0x2,%ecx
asm volatile("cld; rep stosl\n"
f0101453: 89 d0 mov %edx,%eax
f0101455: fc cld
f0101456: f3 ab rep stos %eax,%es:(%edi)
f0101458: eb 06 jmp f0101460 <memset+0x45>
: "cc", "memory");
} else
asm volatile("cld; rep stosb\n"
f010145a: 8b 45 0c mov 0xc(%ebp),%eax
f010145d: fc cld
f010145e: f3 aa rep stos %al,%es:(%edi)
:: "D" (v), "a" (c), "c" (n)
: "cc", "memory");
return v;
}
f0101460: 89 f8 mov %edi,%eax
f0101462: 5b pop %ebx
f0101463: 5e pop %esi
f0101464: 5f pop %edi
f0101465: 5d pop %ebp
f0101466: c3 ret
f0101467 <memmove>:
void *
memmove(void *dst, const void *src, size_t n)
{
f0101467: f3 0f 1e fb endbr32
f010146b: 55 push %ebp
f010146c: 89 e5 mov %esp,%ebp
f010146e: 57 push %edi
f010146f: 56 push %esi
f0101470: 8b 45 08 mov 0x8(%ebp),%eax
f0101473: 8b 75 0c mov 0xc(%ebp),%esi
f0101476: 8b 4d 10 mov 0x10(%ebp),%ecx
const char *s;
char *d;
s = src;
d = dst;
if (s < d && s + n > d) {
f0101479: 39 c6 cmp %eax,%esi
f010147b: 73 32 jae f01014af <memmove+0x48>
f010147d: 8d 14 0e lea (%esi,%ecx,1),%edx
f0101480: 39 c2 cmp %eax,%edx
f0101482: 76 2b jbe f01014af <memmove+0x48>
s += n;
d += n;
f0101484: 8d 3c 08 lea (%eax,%ecx,1),%edi
if ((int)s%4 == 0 && (int)d%4 == 0 && n%4 == 0)
f0101487: 89 fe mov %edi,%esi
f0101489: 09 ce or %ecx,%esi
f010148b: 09 d6 or %edx,%esi
f010148d: f7 c6 03 00 00 00 test $0x3,%esi
f0101493: 75 0e jne f01014a3 <memmove+0x3c>
asm volatile("std; rep movsl\n"
:: "D" (d-4), "S" (s-4), "c" (n/4) : "cc", "memory");
f0101495: 83 ef 04 sub $0x4,%edi
f0101498: 8d 72 fc lea -0x4(%edx),%esi
f010149b: c1 e9 02 shr $0x2,%ecx
asm volatile("std; rep movsl\n"
f010149e: fd std
f010149f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
f01014a1: eb 09 jmp f01014ac <memmove+0x45>
else
asm volatile("std; rep movsb\n"
:: "D" (d-1), "S" (s-1), "c" (n) : "cc", "memory");
f01014a3: 83 ef 01 sub $0x1,%edi
f01014a6: 8d 72 ff lea -0x1(%edx),%esi
asm volatile("std; rep movsb\n"
f01014a9: fd std
f01014aa: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
// Some versions of GCC rely on DF being clear
asm volatile("cld" ::: "cc");
f01014ac: fc cld
f01014ad: eb 1a jmp f01014c9 <memmove+0x62>
} else {
if ((int)s%4 == 0 && (int)d%4 == 0 && n%4 == 0)
f01014af: 89 c2 mov %eax,%edx
f01014b1: 09 ca or %ecx,%edx
f01014b3: 09 f2 or %esi,%edx
f01014b5: f6 c2 03 test $0x3,%dl
f01014b8: 75 0a jne f01014c4 <memmove+0x5d>
asm volatile("cld; rep movsl\n"
:: "D" (d), "S" (s), "c" (n/4) : "cc", "memory");
f01014ba: c1 e9 02 shr $0x2,%ecx
asm volatile("cld; rep movsl\n"
f01014bd: 89 c7 mov %eax,%edi
f01014bf: fc cld
f01014c0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
f01014c2: eb 05 jmp f01014c9 <memmove+0x62>
else
asm volatile("cld; rep movsb\n"
f01014c4: 89 c7 mov %eax,%edi
f01014c6: fc cld
f01014c7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
:: "D" (d), "S" (s), "c" (n) : "cc", "memory");
}
return dst;
}
f01014c9: 5e pop %esi
f01014ca: 5f pop %edi
f01014cb: 5d pop %ebp
f01014cc: c3 ret
f01014cd <memcpy>:
}
#endif
void *
memcpy(void *dst, const void *src, size_t n)
{
f01014cd: f3 0f 1e fb endbr32
f01014d1: 55 push %ebp
f01014d2: 89 e5 mov %esp,%ebp
f01014d4: 83 ec 0c sub $0xc,%esp
return memmove(dst, src, n);
f01014d7: ff 75 10 pushl 0x10(%ebp)
f01014da: ff 75 0c pushl 0xc(%ebp)
f01014dd: ff 75 08 pushl 0x8(%ebp)
f01014e0: e8 82 ff ff ff call f0101467 <memmove>
}
f01014e5: c9 leave
f01014e6: c3 ret
f01014e7 <memcmp>:
int
memcmp(const void *v1, const void *v2, size_t n)
{
f01014e7: f3 0f 1e fb endbr32
f01014eb: 55 push %ebp
f01014ec: 89 e5 mov %esp,%ebp
f01014ee: 56 push %esi
f01014ef: 53 push %ebx
f01014f0: 8b 45 08 mov 0x8(%ebp),%eax
f01014f3: 8b 55 0c mov 0xc(%ebp),%edx
f01014f6: 89 c6 mov %eax,%esi
f01014f8: 03 75 10 add 0x10(%ebp),%esi
const uint8_t *s1 = (const uint8_t *) v1;
const uint8_t *s2 = (const uint8_t *) v2;
while (n-- > 0) {
f01014fb: 39 f0 cmp %esi,%eax
f01014fd: 74 1c je f010151b <memcmp+0x34>
if (*s1 != *s2)
f01014ff: 0f b6 08 movzbl (%eax),%ecx
f0101502: 0f b6 1a movzbl (%edx),%ebx
f0101505: 38 d9 cmp %bl,%cl
f0101507: 75 08 jne f0101511 <memcmp+0x2a>
return (int) *s1 - (int) *s2;
s1++, s2++;
f0101509: 83 c0 01 add $0x1,%eax
f010150c: 83 c2 01 add $0x1,%edx
f010150f: eb ea jmp f01014fb <memcmp+0x14>
return (int) *s1 - (int) *s2;
f0101511: 0f b6 c1 movzbl %cl,%eax
f0101514: 0f b6 db movzbl %bl,%ebx
f0101517: 29 d8 sub %ebx,%eax
f0101519: eb 05 jmp f0101520 <memcmp+0x39>
}
return 0;
f010151b: b8 00 00 00 00 mov $0x0,%eax
}
f0101520: 5b pop %ebx
f0101521: 5e pop %esi
f0101522: 5d pop %ebp
f0101523: c3 ret
f0101524 <memfind>:
void *
memfind(const void *s, int c, size_t n)
{
f0101524: f3 0f 1e fb endbr32
f0101528: 55 push %ebp
f0101529: 89 e5 mov %esp,%ebp
f010152b: 8b 45 08 mov 0x8(%ebp),%eax
f010152e: 8b 4d 0c mov 0xc(%ebp),%ecx
const void *ends = (const char *) s + n;
f0101531: 89 c2 mov %eax,%edx
f0101533: 03 55 10 add 0x10(%ebp),%edx
for (; s < ends; s++)
f0101536: 39 d0 cmp %edx,%eax
f0101538: 73 09 jae f0101543 <memfind+0x1f>
if (*(const unsigned char *) s == (unsigned char) c)
f010153a: 38 08 cmp %cl,(%eax)
f010153c: 74 05 je f0101543 <memfind+0x1f>
for (; s < ends; s++)
f010153e: 83 c0 01 add $0x1,%eax
f0101541: eb f3 jmp f0101536 <memfind+0x12>
break;
return (void *) s;
}
f0101543: 5d pop %ebp
f0101544: c3 ret
f0101545 <strtol>:
long
strtol(const char *s, char **endptr, int base)
{
f0101545: f3 0f 1e fb endbr32
f0101549: 55 push %ebp
f010154a: 89 e5 mov %esp,%ebp
f010154c: 57 push %edi
f010154d: 56 push %esi
f010154e: 53 push %ebx
f010154f: 8b 4d 08 mov 0x8(%ebp),%ecx
f0101552: 8b 5d 10 mov 0x10(%ebp),%ebx
int neg = 0;
long val = 0;
// gobble initial whitespace
while (*s == ' ' || *s == '\t')
f0101555: eb 03 jmp f010155a <strtol+0x15>
s++;
f0101557: 83 c1 01 add $0x1,%ecx
while (*s == ' ' || *s == '\t')
f010155a: 0f b6 01 movzbl (%ecx),%eax
f010155d: 3c 20 cmp $0x20,%al
f010155f: 74 f6 je f0101557 <strtol+0x12>
f0101561: 3c 09 cmp $0x9,%al
f0101563: 74 f2 je f0101557 <strtol+0x12>
// plus/minus sign
if (*s == '+')
f0101565: 3c 2b cmp $0x2b,%al
f0101567: 74 2a je f0101593 <strtol+0x4e>
int neg = 0;
f0101569: bf 00 00 00 00 mov $0x0,%edi
s++;
else if (*s == '-')
f010156e: 3c 2d cmp $0x2d,%al
f0101570: 74 2b je f010159d <strtol+0x58>
s++, neg = 1;
// hex or octal base prefix
if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x'))
f0101572: f7 c3 ef ff ff ff test $0xffffffef,%ebx
f0101578: 75 0f jne f0101589 <strtol+0x44>
f010157a: 80 39 30 cmpb $0x30,(%ecx)
f010157d: 74 28 je f01015a7 <strtol+0x62>
s += 2, base = 16;
else if (base == 0 && s[0] == '0')
s++, base = 8;
else if (base == 0)
base = 10;
f010157f: 85 db test %ebx,%ebx
f0101581: b8 0a 00 00 00 mov $0xa,%eax
f0101586: 0f 44 d8 cmove %eax,%ebx
f0101589: b8 00 00 00 00 mov $0x0,%eax
f010158e: 89 5d 10 mov %ebx,0x10(%ebp)
f0101591: eb 46 jmp f01015d9 <strtol+0x94>
s++;
f0101593: 83 c1 01 add $0x1,%ecx
int neg = 0;
f0101596: bf 00 00 00 00 mov $0x0,%edi
f010159b: eb d5 jmp f0101572 <strtol+0x2d>
s++, neg = 1;
f010159d: 83 c1 01 add $0x1,%ecx
f01015a0: bf 01 00 00 00 mov $0x1,%edi
f01015a5: eb cb jmp f0101572 <strtol+0x2d>
if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x'))
f01015a7: 80 79 01 78 cmpb $0x78,0x1(%ecx)
f01015ab: 74 0e je f01015bb <strtol+0x76>
else if (base == 0 && s[0] == '0')
f01015ad: 85 db test %ebx,%ebx
f01015af: 75 d8 jne f0101589 <strtol+0x44>
s++, base = 8;
f01015b1: 83 c1 01 add $0x1,%ecx
f01015b4: bb 08 00 00 00 mov $0x8,%ebx
f01015b9: eb ce jmp f0101589 <strtol+0x44>
s += 2, base = 16;
f01015bb: 83 c1 02 add $0x2,%ecx
f01015be: bb 10 00 00 00 mov $0x10,%ebx
f01015c3: eb c4 jmp f0101589 <strtol+0x44>
// digits
while (1) {
int dig;
if (*s >= '0' && *s <= '9')
dig = *s - '0';
f01015c5: 0f be d2 movsbl %dl,%edx
f01015c8: 83 ea 30 sub $0x30,%edx
dig = *s - 'a' + 10;
else if (*s >= 'A' && *s <= 'Z')
dig = *s - 'A' + 10;
else
break;
if (dig >= base)
f01015cb: 3b 55 10 cmp 0x10(%ebp),%edx
f01015ce: 7d 3a jge f010160a <strtol+0xc5>
break;
s++, val = (val * base) + dig;
f01015d0: 83 c1 01 add $0x1,%ecx
f01015d3: 0f af 45 10 imul 0x10(%ebp),%eax
f01015d7: 01 d0 add %edx,%eax
if (*s >= '0' && *s <= '9')
f01015d9: 0f b6 11 movzbl (%ecx),%edx
f01015dc: 8d 72 d0 lea -0x30(%edx),%esi
f01015df: 89 f3 mov %esi,%ebx
f01015e1: 80 fb 09 cmp $0x9,%bl
f01015e4: 76 df jbe f01015c5 <strtol+0x80>
else if (*s >= 'a' && *s <= 'z')
f01015e6: 8d 72 9f lea -0x61(%edx),%esi
f01015e9: 89 f3 mov %esi,%ebx
f01015eb: 80 fb 19 cmp $0x19,%bl
f01015ee: 77 08 ja f01015f8 <strtol+0xb3>
dig = *s - 'a' + 10;
f01015f0: 0f be d2 movsbl %dl,%edx
f01015f3: 83 ea 57 sub $0x57,%edx
f01015f6: eb d3 jmp f01015cb <strtol+0x86>
else if (*s >= 'A' && *s <= 'Z')
f01015f8: 8d 72 bf lea -0x41(%edx),%esi
f01015fb: 89 f3 mov %esi,%ebx
f01015fd: 80 fb 19 cmp $0x19,%bl
f0101600: 77 08 ja f010160a <strtol+0xc5>
dig = *s - 'A' + 10;
f0101602: 0f be d2 movsbl %dl,%edx
f0101605: 83 ea 37 sub $0x37,%edx
f0101608: eb c1 jmp f01015cb <strtol+0x86>
// we don't properly detect overflow!
}
if (endptr)
f010160a: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
f010160e: 74 05 je f0101615 <strtol+0xd0>
*endptr = (char *) s;
f0101610: 8b 75 0c mov 0xc(%ebp),%esi
f0101613: 89 0e mov %ecx,(%esi)
return (neg ? -val : val);
f0101615: 89 c2 mov %eax,%edx
f0101617: f7 da neg %edx
f0101619: 85 ff test %edi,%edi
f010161b: 0f 45 c2 cmovne %edx,%eax
}
f010161e: 5b pop %ebx
f010161f: 5e pop %esi
f0101620: 5f pop %edi
f0101621: 5d pop %ebp
f0101622: c3 ret
f0101623: 66 90 xchg %ax,%ax
f0101625: 66 90 xchg %ax,%ax
f0101627: 66 90 xchg %ax,%ax
f0101629: 66 90 xchg %ax,%ax
f010162b: 66 90 xchg %ax,%ax
f010162d: 66 90 xchg %ax,%ax
f010162f: 90 nop
f0101630 <__udivdi3>:
f0101630: f3 0f 1e fb endbr32
f0101634: 55 push %ebp
f0101635: 57 push %edi
f0101636: 56 push %esi
f0101637: 53 push %ebx
f0101638: 83 ec 1c sub $0x1c,%esp
f010163b: 8b 54 24 3c mov 0x3c(%esp),%edx
f010163f: 8b 6c 24 30 mov 0x30(%esp),%ebp
f0101643: 8b 74 24 34 mov 0x34(%esp),%esi
f0101647: 8b 5c 24 38 mov 0x38(%esp),%ebx
f010164b: 85 d2 test %edx,%edx
f010164d: 75 19 jne f0101668 <__udivdi3+0x38>
f010164f: 39 f3 cmp %esi,%ebx
f0101651: 76 4d jbe f01016a0 <__udivdi3+0x70>
f0101653: 31 ff xor %edi,%edi
f0101655: 89 e8 mov %ebp,%eax
f0101657: 89 f2 mov %esi,%edx
f0101659: f7 f3 div %ebx
f010165b: 89 fa mov %edi,%edx
f010165d: 83 c4 1c add $0x1c,%esp
f0101660: 5b pop %ebx
f0101661: 5e pop %esi
f0101662: 5f pop %edi
f0101663: 5d pop %ebp
f0101664: c3 ret
f0101665: 8d 76 00 lea 0x0(%esi),%esi
f0101668: 39 f2 cmp %esi,%edx
f010166a: 76 14 jbe f0101680 <__udivdi3+0x50>
f010166c: 31 ff xor %edi,%edi
f010166e: 31 c0 xor %eax,%eax
f0101670: 89 fa mov %edi,%edx
f0101672: 83 c4 1c add $0x1c,%esp
f0101675: 5b pop %ebx
f0101676: 5e pop %esi
f0101677: 5f pop %edi
f0101678: 5d pop %ebp
f0101679: c3 ret
f010167a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
f0101680: 0f bd fa bsr %edx,%edi
f0101683: 83 f7 1f xor $0x1f,%edi
f0101686: 75 48 jne f01016d0 <__udivdi3+0xa0>
f0101688: 39 f2 cmp %esi,%edx
f010168a: 72 06 jb f0101692 <__udivdi3+0x62>
f010168c: 31 c0 xor %eax,%eax
f010168e: 39 eb cmp %ebp,%ebx
f0101690: 77 de ja f0101670 <__udivdi3+0x40>
f0101692: b8 01 00 00 00 mov $0x1,%eax
f0101697: eb d7 jmp f0101670 <__udivdi3+0x40>
f0101699: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
f01016a0: 89 d9 mov %ebx,%ecx
f01016a2: 85 db test %ebx,%ebx
f01016a4: 75 0b jne f01016b1 <__udivdi3+0x81>
f01016a6: b8 01 00 00 00 mov $0x1,%eax
f01016ab: 31 d2 xor %edx,%edx
f01016ad: f7 f3 div %ebx
f01016af: 89 c1 mov %eax,%ecx
f01016b1: 31 d2 xor %edx,%edx
f01016b3: 89 f0 mov %esi,%eax
f01016b5: f7 f1 div %ecx
f01016b7: 89 c6 mov %eax,%esi
f01016b9: 89 e8 mov %ebp,%eax
f01016bb: 89 f7 mov %esi,%edi
f01016bd: f7 f1 div %ecx
f01016bf: 89 fa mov %edi,%edx
f01016c1: 83 c4 1c add $0x1c,%esp
f01016c4: 5b pop %ebx
f01016c5: 5e pop %esi
f01016c6: 5f pop %edi
f01016c7: 5d pop %ebp
f01016c8: c3 ret
f01016c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
f01016d0: 89 f9 mov %edi,%ecx
f01016d2: b8 20 00 00 00 mov $0x20,%eax
f01016d7: 29 f8 sub %edi,%eax
f01016d9: d3 e2 shl %cl,%edx
f01016db: 89 54 24 08 mov %edx,0x8(%esp)
f01016df: 89 c1 mov %eax,%ecx
f01016e1: 89 da mov %ebx,%edx
f01016e3: d3 ea shr %cl,%edx
f01016e5: 8b 4c 24 08 mov 0x8(%esp),%ecx
f01016e9: 09 d1 or %edx,%ecx
f01016eb: 89 f2 mov %esi,%edx
f01016ed: 89 4c 24 08 mov %ecx,0x8(%esp)
f01016f1: 89 f9 mov %edi,%ecx
f01016f3: d3 e3 shl %cl,%ebx
f01016f5: 89 c1 mov %eax,%ecx
f01016f7: d3 ea shr %cl,%edx
f01016f9: 89 f9 mov %edi,%ecx
f01016fb: 89 5c 24 0c mov %ebx,0xc(%esp)
f01016ff: 89 eb mov %ebp,%ebx
f0101701: d3 e6 shl %cl,%esi
f0101703: 89 c1 mov %eax,%ecx
f0101705: d3 eb shr %cl,%ebx
f0101707: 09 de or %ebx,%esi
f0101709: 89 f0 mov %esi,%eax
f010170b: f7 74 24 08 divl 0x8(%esp)
f010170f: 89 d6 mov %edx,%esi
f0101711: 89 c3 mov %eax,%ebx
f0101713: f7 64 24 0c mull 0xc(%esp)
f0101717: 39 d6 cmp %edx,%esi
f0101719: 72 15 jb f0101730 <__udivdi3+0x100>
f010171b: 89 f9 mov %edi,%ecx
f010171d: d3 e5 shl %cl,%ebp
f010171f: 39 c5 cmp %eax,%ebp
f0101721: 73 04 jae f0101727 <__udivdi3+0xf7>
f0101723: 39 d6 cmp %edx,%esi
f0101725: 74 09 je f0101730 <__udivdi3+0x100>
f0101727: 89 d8 mov %ebx,%eax
f0101729: 31 ff xor %edi,%edi
f010172b: e9 40 ff ff ff jmp f0101670 <__udivdi3+0x40>
f0101730: 8d 43 ff lea -0x1(%ebx),%eax
f0101733: 31 ff xor %edi,%edi
f0101735: e9 36 ff ff ff jmp f0101670 <__udivdi3+0x40>
f010173a: 66 90 xchg %ax,%ax
f010173c: 66 90 xchg %ax,%ax
f010173e: 66 90 xchg %ax,%ax
f0101740 <__umoddi3>:
f0101740: f3 0f 1e fb endbr32
f0101744: 55 push %ebp
f0101745: 57 push %edi
f0101746: 56 push %esi
f0101747: 53 push %ebx
f0101748: 83 ec 1c sub $0x1c,%esp
f010174b: 8b 44 24 3c mov 0x3c(%esp),%eax
f010174f: 8b 74 24 30 mov 0x30(%esp),%esi
f0101753: 8b 5c 24 34 mov 0x34(%esp),%ebx
f0101757: 8b 7c 24 38 mov 0x38(%esp),%edi
f010175b: 85 c0 test %eax,%eax
f010175d: 75 19 jne f0101778 <__umoddi3+0x38>
f010175f: 39 df cmp %ebx,%edi
f0101761: 76 5d jbe f01017c0 <__umoddi3+0x80>
f0101763: 89 f0 mov %esi,%eax
f0101765: 89 da mov %ebx,%edx
f0101767: f7 f7 div %edi
f0101769: 89 d0 mov %edx,%eax
f010176b: 31 d2 xor %edx,%edx
f010176d: 83 c4 1c add $0x1c,%esp
f0101770: 5b pop %ebx
f0101771: 5e pop %esi
f0101772: 5f pop %edi
f0101773: 5d pop %ebp
f0101774: c3 ret
f0101775: 8d 76 00 lea 0x0(%esi),%esi
f0101778: 89 f2 mov %esi,%edx
f010177a: 39 d8 cmp %ebx,%eax
f010177c: 76 12 jbe f0101790 <__umoddi3+0x50>
f010177e: 89 f0 mov %esi,%eax
f0101780: 89 da mov %ebx,%edx
f0101782: 83 c4 1c add $0x1c,%esp
f0101785: 5b pop %ebx
f0101786: 5e pop %esi
f0101787: 5f pop %edi
f0101788: 5d pop %ebp
f0101789: c3 ret
f010178a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
f0101790: 0f bd e8 bsr %eax,%ebp
f0101793: 83 f5 1f xor $0x1f,%ebp
f0101796: 75 50 jne f01017e8 <__umoddi3+0xa8>
f0101798: 39 d8 cmp %ebx,%eax
f010179a: 0f 82 e0 00 00 00 jb f0101880 <__umoddi3+0x140>
f01017a0: 89 d9 mov %ebx,%ecx
f01017a2: 39 f7 cmp %esi,%edi
f01017a4: 0f 86 d6 00 00 00 jbe f0101880 <__umoddi3+0x140>
f01017aa: 89 d0 mov %edx,%eax
f01017ac: 89 ca mov %ecx,%edx
f01017ae: 83 c4 1c add $0x1c,%esp
f01017b1: 5b pop %ebx
f01017b2: 5e pop %esi
f01017b3: 5f pop %edi
f01017b4: 5d pop %ebp
f01017b5: c3 ret
f01017b6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
f01017bd: 8d 76 00 lea 0x0(%esi),%esi
f01017c0: 89 fd mov %edi,%ebp
f01017c2: 85 ff test %edi,%edi
f01017c4: 75 0b jne f01017d1 <__umoddi3+0x91>
f01017c6: b8 01 00 00 00 mov $0x1,%eax
f01017cb: 31 d2 xor %edx,%edx
f01017cd: f7 f7 div %edi
f01017cf: 89 c5 mov %eax,%ebp
f01017d1: 89 d8 mov %ebx,%eax
f01017d3: 31 d2 xor %edx,%edx
f01017d5: f7 f5 div %ebp
f01017d7: 89 f0 mov %esi,%eax
f01017d9: f7 f5 div %ebp
f01017db: 89 d0 mov %edx,%eax
f01017dd: 31 d2 xor %edx,%edx
f01017df: eb 8c jmp f010176d <__umoddi3+0x2d>
f01017e1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
f01017e8: 89 e9 mov %ebp,%ecx
f01017ea: ba 20 00 00 00 mov $0x20,%edx
f01017ef: 29 ea sub %ebp,%edx
f01017f1: d3 e0 shl %cl,%eax
f01017f3: 89 44 24 08 mov %eax,0x8(%esp)
f01017f7: 89 d1 mov %edx,%ecx
f01017f9: 89 f8 mov %edi,%eax
f01017fb: d3 e8 shr %cl,%eax
f01017fd: 8b 4c 24 08 mov 0x8(%esp),%ecx
f0101801: 89 54 24 04 mov %edx,0x4(%esp)
f0101805: 8b 54 24 04 mov 0x4(%esp),%edx
f0101809: 09 c1 or %eax,%ecx
f010180b: 89 d8 mov %ebx,%eax
f010180d: 89 4c 24 08 mov %ecx,0x8(%esp)
f0101811: 89 e9 mov %ebp,%ecx
f0101813: d3 e7 shl %cl,%edi
f0101815: 89 d1 mov %edx,%ecx
f0101817: d3 e8 shr %cl,%eax
f0101819: 89 e9 mov %ebp,%ecx
f010181b: 89 7c 24 0c mov %edi,0xc(%esp)
f010181f: d3 e3 shl %cl,%ebx
f0101821: 89 c7 mov %eax,%edi
f0101823: 89 d1 mov %edx,%ecx
f0101825: 89 f0 mov %esi,%eax
f0101827: d3 e8 shr %cl,%eax
f0101829: 89 e9 mov %ebp,%ecx
f010182b: 89 fa mov %edi,%edx
f010182d: d3 e6 shl %cl,%esi
f010182f: 09 d8 or %ebx,%eax
f0101831: f7 74 24 08 divl 0x8(%esp)
f0101835: 89 d1 mov %edx,%ecx
f0101837: 89 f3 mov %esi,%ebx
f0101839: f7 64 24 0c mull 0xc(%esp)
f010183d: 89 c6 mov %eax,%esi
f010183f: 89 d7 mov %edx,%edi
f0101841: 39 d1 cmp %edx,%ecx
f0101843: 72 06 jb f010184b <__umoddi3+0x10b>
f0101845: 75 10 jne f0101857 <__umoddi3+0x117>
f0101847: 39 c3 cmp %eax,%ebx
f0101849: 73 0c jae f0101857 <__umoddi3+0x117>
f010184b: 2b 44 24 0c sub 0xc(%esp),%eax
f010184f: 1b 54 24 08 sbb 0x8(%esp),%edx
f0101853: 89 d7 mov %edx,%edi
f0101855: 89 c6 mov %eax,%esi
f0101857: 89 ca mov %ecx,%edx
f0101859: 0f b6 4c 24 04 movzbl 0x4(%esp),%ecx
f010185e: 29 f3 sub %esi,%ebx
f0101860: 19 fa sbb %edi,%edx
f0101862: 89 d0 mov %edx,%eax
f0101864: d3 e0 shl %cl,%eax
f0101866: 89 e9 mov %ebp,%ecx
f0101868: d3 eb shr %cl,%ebx
f010186a: d3 ea shr %cl,%edx
f010186c: 09 d8 or %ebx,%eax
f010186e: 83 c4 1c add $0x1c,%esp
f0101871: 5b pop %ebx
f0101872: 5e pop %esi
f0101873: 5f pop %edi
f0101874: 5d pop %ebp
f0101875: c3 ret
f0101876: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
f010187d: 8d 76 00 lea 0x0(%esi),%esi
f0101880: 29 fe sub %edi,%esi
f0101882: 19 c3 sbb %eax,%ebx
f0101884: 89 f2 mov %esi,%edx
f0101886: 89 d9 mov %ebx,%ecx
f0101888: e9 1d ff ff ff jmp f01017aa <__umoddi3+0x6a>
Reference in a new issue Copy permalink