pjht/os
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
f2b9c1f481
os/init/dump
pjht f2b9c1f481 Fix warnings
2020-08-23 08:46:38 -05:00

3853 lines
161 KiB
Plaintext
Raw Blame History

init: file format elf32-i386
Disassembly of section .init:
08048074 <_init>:
8048074: e8 ff 00 00 00 call 8048178 <frame_dummy>
8048079: e8 06 1e 00 00 call 8049e84 <__do_global_ctors_aux>
804807e: c2 00 00 ret $0x0
Disassembly of section .text:
08048090 <_start>:
8048090: e8 14 08 00 00 call 80488a9 <__stdio_init>
8048095: e8 f5 04 00 00 call 804858f <main>
804809a: 6a 00 push $0x0
804809c: e8 93 1a 00 00 call 8049b34 <exit>
80480a1: c3 ret
80480a2: 66 90 xchg %ax,%ax
080480a4 <deregister_tm_clones>:
80480a4: b8 14 b0 04 08 mov $0x804b014,%eax
80480a9: 3d 14 b0 04 08 cmp $0x804b014,%eax
80480ae: 74 1c je 80480cc <deregister_tm_clones+0x28>
80480b0: b8 00 00 00 00 mov $0x0,%eax
80480b5: 85 c0 test %eax,%eax
80480b7: 74 13 je 80480cc <deregister_tm_clones+0x28>
80480b9: 55 push %ebp
80480ba: 89 e5 mov %esp,%ebp
80480bc: 83 ec 14 sub $0x14,%esp
80480bf: 68 14 b0 04 08 push $0x804b014
80480c4: ff d0 call *%eax
80480c6: 83 c4 10 add $0x10,%esp
80480c9: c9 leave
80480ca: c3 ret
80480cb: 90 nop
80480cc: c3 ret
80480cd: 8d 76 00 lea 0x0(%esi),%esi
080480d0 <register_tm_clones>:
80480d0: b8 14 b0 04 08 mov $0x804b014,%eax
80480d5: 2d 14 b0 04 08 sub $0x804b014,%eax
80480da: 89 c2 mov %eax,%edx
80480dc: c1 fa 02 sar $0x2,%edx
80480df: c1 e8 1f shr $0x1f,%eax
80480e2: 01 d0 add %edx,%eax
80480e4: d1 f8 sar %eax
80480e6: 74 1c je 8048104 <register_tm_clones+0x34>
80480e8: ba 00 00 00 00 mov $0x0,%edx
80480ed: 85 d2 test %edx,%edx
80480ef: 74 13 je 8048104 <register_tm_clones+0x34>
80480f1: 55 push %ebp
80480f2: 89 e5 mov %esp,%ebp
80480f4: 83 ec 10 sub $0x10,%esp
80480f7: 50 push %eax
80480f8: 68 14 b0 04 08 push $0x804b014
80480fd: ff d2 call *%edx
80480ff: 83 c4 10 add $0x10,%esp
8048102: c9 leave
8048103: c3 ret
8048104: c3 ret
8048105: 8d 76 00 lea 0x0(%esi),%esi
08048108 <__do_global_dtors_aux>:
8048108: 80 3d 20 b0 04 08 00 cmpb $0x0,0x804b020
804810f: 75 63 jne 8048174 <__do_global_dtors_aux+0x6c>
8048111: 55 push %ebp
8048112: 89 e5 mov %esp,%ebp
8048114: 56 push %esi
8048115: 53 push %ebx
8048116: bb 0c b0 04 08 mov $0x804b00c,%ebx
804811b: 81 eb 08 b0 04 08 sub $0x804b008,%ebx
8048121: c1 fb 02 sar $0x2,%ebx
8048124: 4b dec %ebx
8048125: be 08 b0 04 08 mov $0x804b008,%esi
804812a: a1 24 b0 04 08 mov 0x804b024,%eax
804812f: 39 d8 cmp %ebx,%eax
8048131: 73 13 jae 8048146 <__do_global_dtors_aux+0x3e>
8048133: 90 nop
8048134: 40 inc %eax
8048135: a3 24 b0 04 08 mov %eax,0x804b024
804813a: ff 14 86 call *(%esi,%eax,4)
804813d: a1 24 b0 04 08 mov 0x804b024,%eax
8048142: 39 d8 cmp %ebx,%eax
8048144: 72 ee jb 8048134 <__do_global_dtors_aux+0x2c>
8048146: e8 59 ff ff ff call 80480a4 <deregister_tm_clones>
804814b: b8 00 00 00 00 mov $0x0,%eax
8048150: 85 c0 test %eax,%eax
8048152: 74 10 je 8048164 <__do_global_dtors_aux+0x5c>
8048154: 83 ec 0c sub $0xc,%esp
8048157: 68 e4 9f 04 08 push $0x8049fe4
804815c: e8 9f 7e fb f7 call 0 <_init-0x8048074>
8048161: 83 c4 10 add $0x10,%esp
8048164: c6 05 20 b0 04 08 01 movb $0x1,0x804b020
804816b: 8d 65 f8 lea -0x8(%ebp),%esp
804816e: 5b pop %ebx
804816f: 5e pop %esi
8048170: 5d pop %ebp
8048171: c3 ret
8048172: 66 90 xchg %ax,%ax
8048174: c3 ret
8048175: 8d 76 00 lea 0x0(%esi),%esi
08048178 <frame_dummy>:
8048178: b8 00 00 00 00 mov $0x0,%eax
804817d: 85 c0 test %eax,%eax
804817f: 74 1f je 80481a0 <frame_dummy+0x28>
8048181: 55 push %ebp
8048182: 89 e5 mov %esp,%ebp
8048184: 83 ec 10 sub $0x10,%esp
8048187: 68 28 b0 04 08 push $0x804b028
804818c: 68 e4 9f 04 08 push $0x8049fe4
8048191: e8 6a 7e fb f7 call 0 <_init-0x8048074>
8048196: 83 c4 10 add $0x10,%esp
8048199: c9 leave
804819a: e9 31 ff ff ff jmp 80480d0 <register_tm_clones>
804819f: 90 nop
80481a0: e9 2b ff ff ff jmp 80480d0 <register_tm_clones>
080481a5 <getsize>:
char mtime[12];
char chksum[8];
char typeflag[1];
} tar_header;
size_t getsize(const char *in) {
80481a5: 55 push %ebp
80481a6: 89 e5 mov %esp,%ebp
80481a8: 83 ec 10 sub $0x10,%esp
size_t size=0;
80481ab: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
size_t j;
size_t count=1;
80481b2: c7 45 f4 01 00 00 00 movl $0x1,-0xc(%ebp)
for (j=11;j>0;j--,count*=8) {
80481b9: c7 45 f8 0b 00 00 00 movl $0xb,-0x8(%ebp)
80481c0: eb 21 jmp 80481e3 <getsize+0x3e>
size+=((in[j-1]-'0')*count);
80481c2: 8b 45 f8 mov -0x8(%ebp),%eax
80481c5: 8d 50 ff lea -0x1(%eax),%edx
80481c8: 8b 45 08 mov 0x8(%ebp),%eax
80481cb: 01 d0 add %edx,%eax
80481cd: 8a 00 mov (%eax),%al
80481cf: 0f be c0 movsbl %al,%eax
80481d2: 83 e8 30 sub $0x30,%eax
80481d5: 0f af 45 f4 imul -0xc(%ebp),%eax
80481d9: 01 45 fc add %eax,-0x4(%ebp)
for (j=11;j>0;j--,count*=8) {
80481dc: ff 4d f8 decl -0x8(%ebp)
80481df: c1 65 f4 03 shll $0x3,-0xc(%ebp)
80481e3: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
80481e7: 75 d9 jne 80481c2 <getsize+0x1d>
}
return size;
80481e9: 8b 45 fc mov -0x4(%ebp),%eax
}
80481ec: c9 leave
80481ed: c3 ret
080481ee <find_loc>:
size_t find_loc(char* name,char* initrd) {
80481ee: 55 push %ebp
80481ef: 89 e5 mov %esp,%ebp
80481f1: 81 ec c8 00 00 00 sub $0xc8,%esp
size_t pos=0;
80481f7: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
tar_header tar_hdr;
for (int i=0;;i++) {
80481fe: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
char* tar_hdr_ptr=(char*)&tar_hdr;
8048205: 8d 85 47 ff ff ff lea -0xb9(%ebp),%eax
804820b: 89 45 e8 mov %eax,-0x18(%ebp)
for (size_t i=0;i<sizeof(tar_hdr);i++) {
804820e: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
8048215: eb 1c jmp 8048233 <find_loc+0x45>
tar_hdr_ptr[i]=initrd[pos+i];
8048217: 8b 55 f4 mov -0xc(%ebp),%edx
804821a: 8b 45 ec mov -0x14(%ebp),%eax
804821d: 01 c2 add %eax,%edx
804821f: 8b 45 0c mov 0xc(%ebp),%eax
8048222: 01 d0 add %edx,%eax
8048224: 8b 4d e8 mov -0x18(%ebp),%ecx
8048227: 8b 55 ec mov -0x14(%ebp),%edx
804822a: 01 ca add %ecx,%edx
804822c: 8a 00 mov (%eax),%al
804822e: 88 02 mov %al,(%edx)
for (size_t i=0;i<sizeof(tar_hdr);i++) {
8048230: ff 45 ec incl -0x14(%ebp)
8048233: 81 7d ec 9c 00 00 00 cmpl $0x9c,-0x14(%ebp)
804823a: 76 db jbe 8048217 <find_loc+0x29>
}
if (tar_hdr.filename[0]=='\0') break;
804823c: 8a 85 47 ff ff ff mov -0xb9(%ebp),%al
8048242: 84 c0 test %al,%al
8048244: 74 64 je 80482aa <find_loc+0xbc>
size_t size=getsize(tar_hdr.size);
8048246: 8d 85 47 ff ff ff lea -0xb9(%ebp),%eax
804824c: 83 c0 7c add $0x7c,%eax
804824f: 50 push %eax
8048250: e8 50 ff ff ff call 80481a5 <getsize>
8048255: 83 c4 04 add $0x4,%esp
8048258: 89 45 e4 mov %eax,-0x1c(%ebp)
pos+=512;
804825b: 81 45 f4 00 02 00 00 addl $0x200,-0xc(%ebp)
if (strcmp(tar_hdr.filename,name)==0) {
8048262: 83 ec 08 sub $0x8,%esp
8048265: ff 75 08 pushl 0x8(%ebp)
8048268: 8d 85 47 ff ff ff lea -0xb9(%ebp),%eax
804826e: 50 push %eax
804826f: e8 50 14 00 00 call 80496c4 <strcmp>
8048274: 83 c4 10 add $0x10,%esp
8048277: 85 c0 test %eax,%eax
8048279: 75 05 jne 8048280 <find_loc+0x92>
return pos;
804827b: 8b 45 f4 mov -0xc(%ebp),%eax
804827e: eb 30 jmp 80482b0 <find_loc+0xc2>
break;
}
pos+=size;
8048280: 8b 45 e4 mov -0x1c(%ebp),%eax
8048283: 01 45 f4 add %eax,-0xc(%ebp)
if (pos%512!=0) {
8048286: 8b 45 f4 mov -0xc(%ebp),%eax
8048289: 25 ff 01 00 00 and $0x1ff,%eax
804828e: 85 c0 test %eax,%eax
8048290: 74 10 je 80482a2 <find_loc+0xb4>
pos+=512-(pos%512);
8048292: 8b 45 f4 mov -0xc(%ebp),%eax
8048295: 25 00 fe ff ff and $0xfffffe00,%eax
804829a: 05 00 02 00 00 add $0x200,%eax
804829f: 89 45 f4 mov %eax,-0xc(%ebp)
for (int i=0;;i++) {
80482a2: ff 45 f0 incl -0x10(%ebp)
80482a5: e9 5b ff ff ff jmp 8048205 <find_loc+0x17>
if (tar_hdr.filename[0]=='\0') break;
80482aa: 90 nop
}
}
return 0;
80482ab: b8 00 00 00 00 mov $0x0,%eax
}
80482b0: c9 leave
80482b1: c3 ret
080482b2 <load_proc>:
char load_proc(size_t datapos,char* initrd) {
80482b2: 55 push %ebp
80482b3: 89 e5 mov %esp,%ebp
80482b5: 81 ec 88 00 00 00 sub $0x88,%esp
int pos=0;
80482bb: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
elf_header header;
pos=datapos;
80482c2: 8b 45 08 mov 0x8(%ebp),%eax
80482c5: 89 45 f4 mov %eax,-0xc(%ebp)
char* hdr_ptr=(char*)&header;
80482c8: 8d 45 a0 lea -0x60(%ebp),%eax
80482cb: 89 45 e0 mov %eax,-0x20(%ebp)
for (size_t i=0;i<sizeof(elf_header);i++) {
80482ce: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
80482d5: eb 1a jmp 80482f1 <load_proc+0x3f>
hdr_ptr[i]=initrd[pos];
80482d7: 8b 55 f4 mov -0xc(%ebp),%edx
80482da: 8b 45 0c mov 0xc(%ebp),%eax
80482dd: 01 d0 add %edx,%eax
80482df: 8b 4d e0 mov -0x20(%ebp),%ecx
80482e2: 8b 55 f0 mov -0x10(%ebp),%edx
80482e5: 01 ca add %ecx,%edx
80482e7: 8a 00 mov (%eax),%al
80482e9: 88 02 mov %al,(%edx)
pos++;
80482eb: ff 45 f4 incl -0xc(%ebp)
for (size_t i=0;i<sizeof(elf_header);i++) {
80482ee: ff 45 f0 incl -0x10(%ebp)
80482f1: 83 7d f0 33 cmpl $0x33,-0x10(%ebp)
80482f5: 76 e0 jbe 80482d7 <load_proc+0x25>
}
if (header.magic!=ELF_MAGIC) {
80482f7: 8b 45 a0 mov -0x60(%ebp),%eax
80482fa: 3d 7f 45 4c 46 cmp $0x464c457f,%eax
80482ff: 74 07 je 8048308 <load_proc+0x56>
return 0;
8048301: b0 00 mov $0x0,%al
8048303: e9 01 01 00 00 jmp 8048409 <load_proc+0x157>
} else {
void* address_space=new_address_space();
8048308: e8 0d 05 00 00 call 804881a <new_address_space>
804830d: 89 45 dc mov %eax,-0x24(%ebp)
for (int i=0;i<header.pheader_ent_nm;i++) {
8048310: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
8048317: e9 c9 00 00 00 jmp 80483e5 <load_proc+0x133>
elf_pheader pheader;
pos=(header.prog_hdr)+(header.pheader_ent_sz*i)+datapos;
804831c: 8b 55 bc mov -0x44(%ebp),%edx
804831f: 66 8b 45 ca mov -0x36(%ebp),%ax
8048323: 0f b7 c0 movzwl %ax,%eax
8048326: 0f af 45 ec imul -0x14(%ebp),%eax
804832a: 01 c2 add %eax,%edx
804832c: 8b 45 08 mov 0x8(%ebp),%eax
804832f: 01 d0 add %edx,%eax
8048331: 89 45 f4 mov %eax,-0xc(%ebp)
char* phdr_ptr=(char*)&pheader;
8048334: 8d 45 80 lea -0x80(%ebp),%eax
8048337: 89 45 d8 mov %eax,-0x28(%ebp)
for (size_t i=0;i<sizeof(elf_pheader);i++) {
804833a: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
8048341: eb 1a jmp 804835d <load_proc+0xab>
phdr_ptr[i]=initrd[pos];
8048343: 8b 55 f4 mov -0xc(%ebp),%edx
8048346: 8b 45 0c mov 0xc(%ebp),%eax
8048349: 01 d0 add %edx,%eax
804834b: 8b 4d d8 mov -0x28(%ebp),%ecx
804834e: 8b 55 e8 mov -0x18(%ebp),%edx
8048351: 01 ca add %ecx,%edx
8048353: 8a 00 mov (%eax),%al
8048355: 88 02 mov %al,(%edx)
pos++;
8048357: ff 45 f4 incl -0xc(%ebp)
for (size_t i=0;i<sizeof(elf_pheader);i++) {
804835a: ff 45 e8 incl -0x18(%ebp)
804835d: 83 7d e8 1f cmpl $0x1f,-0x18(%ebp)
8048361: 76 e0 jbe 8048343 <load_proc+0x91>
}
char* ptr=alloc_memory(((pheader.memsz)/4096)+1);
8048363: 8b 45 94 mov -0x6c(%ebp),%eax
8048366: c1 e8 0c shr $0xc,%eax
8048369: 40 inc %eax
804836a: 83 ec 0c sub $0xc,%esp
804836d: 50 push %eax
804836e: e8 66 04 00 00 call 80487d9 <alloc_memory>
8048373: 83 c4 10 add $0x10,%esp
8048376: 89 45 d4 mov %eax,-0x2c(%ebp)
memset(ptr,0,pheader.memsz);
8048379: 8b 45 94 mov -0x6c(%ebp),%eax
804837c: 83 ec 04 sub $0x4,%esp
804837f: 50 push %eax
8048380: 6a 00 push $0x0
8048382: ff 75 d4 pushl -0x2c(%ebp)
8048385: e8 08 13 00 00 call 8049692 <memset>
804838a: 83 c4 10 add $0x10,%esp
if (pheader.filesz>0) {
804838d: 8b 45 90 mov -0x70(%ebp),%eax
8048390: 85 c0 test %eax,%eax
8048392: 74 36 je 80483ca <load_proc+0x118>
pos=pheader.offset+datapos;
8048394: 8b 55 84 mov -0x7c(%ebp),%edx
8048397: 8b 45 08 mov 0x8(%ebp),%eax
804839a: 01 d0 add %edx,%eax
804839c: 89 45 f4 mov %eax,-0xc(%ebp)
for (size_t i=0;i<pheader.filesz;i++) {
804839f: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
80483a6: eb 1a jmp 80483c2 <load_proc+0x110>
ptr[i]=initrd[pos];
80483a8: 8b 55 f4 mov -0xc(%ebp),%edx
80483ab: 8b 45 0c mov 0xc(%ebp),%eax
80483ae: 01 d0 add %edx,%eax
80483b0: 8b 4d d4 mov -0x2c(%ebp),%ecx
80483b3: 8b 55 e4 mov -0x1c(%ebp),%edx
80483b6: 01 ca add %ecx,%edx
80483b8: 8a 00 mov (%eax),%al
80483ba: 88 02 mov %al,(%edx)
pos++;
80483bc: ff 45 f4 incl -0xc(%ebp)
for (size_t i=0;i<pheader.filesz;i++) {
80483bf: ff 45 e4 incl -0x1c(%ebp)
80483c2: 8b 45 90 mov -0x70(%ebp),%eax
80483c5: 39 45 e4 cmp %eax,-0x1c(%ebp)
80483c8: 72 de jb 80483a8 <load_proc+0xf6>
}
}
copy_data(address_space,ptr,pheader.memsz,(void*)pheader.vaddr);
80483ca: 8b 45 88 mov -0x78(%ebp),%eax
80483cd: 89 c2 mov %eax,%edx
80483cf: 8b 45 94 mov -0x6c(%ebp),%eax
80483d2: 52 push %edx
80483d3: 50 push %eax
80483d4: ff 75 d4 pushl -0x2c(%ebp)
80483d7: ff 75 dc pushl -0x24(%ebp)
80483da: e8 57 04 00 00 call 8048836 <copy_data>
80483df: 83 c4 10 add $0x10,%esp
for (int i=0;i<header.pheader_ent_nm;i++) {
80483e2: ff 45 ec incl -0x14(%ebp)
80483e5: 8b 45 cc mov -0x34(%ebp),%eax
80483e8: 0f b7 c0 movzwl %ax,%eax
80483eb: 39 45 ec cmp %eax,-0x14(%ebp)
80483ee: 0f 8c 28 ff ff ff jl 804831c <load_proc+0x6a>
}
create_proc((void*)header.entry,address_space,NULL,NULL);
80483f4: 8b 45 b8 mov -0x48(%ebp),%eax
80483f7: 6a 00 push $0x0
80483f9: 6a 00 push $0x0
80483fb: ff 75 dc pushl -0x24(%ebp)
80483fe: 50 push %eax
80483ff: e8 11 17 00 00 call 8049b15 <create_proc>
8048404: 83 c4 10 add $0x10,%esp
}
return 1;
8048407: b0 01 mov $0x1,%al
}
8048409: c9 leave
804840a: c3 ret
0804840b <load_proc_devfs>:
char load_proc_devfs(size_t datapos) {
804840b: 55 push %ebp
804840c: 89 e5 mov %esp,%ebp
804840e: 83 ec 78 sub $0x78,%esp
FILE* initrd=fopen("/dev/initrd","r");
8048411: 83 ec 08 sub $0x8,%esp
8048414: 68 b8 9e 04 08 push $0x8049eb8
8048419: 68 ba 9e 04 08 push $0x8049eba
804841e: e8 8c 04 00 00 call 80488af <fopen>
8048423: 83 c4 10 add $0x10,%esp
8048426: 89 45 f0 mov %eax,-0x10(%ebp)
elf_header header;
fseek(initrd,datapos,SEEK_SET);
8048429: 8b 45 08 mov 0x8(%ebp),%eax
804842c: 83 ec 04 sub $0x4,%esp
804842f: 6a 03 push $0x3
8048431: 50 push %eax
8048432: ff 75 f0 pushl -0x10(%ebp)
8048435: e8 a4 0c 00 00 call 80490de <fseek>
804843a: 83 c4 10 add $0x10,%esp
fread(&header,sizeof(elf_header),1,initrd);
804843d: ff 75 f0 pushl -0x10(%ebp)
8048440: 6a 01 push $0x1
8048442: 6a 34 push $0x34
8048444: 8d 45 b4 lea -0x4c(%ebp),%eax
8048447: 50 push %eax
8048448: e8 1a 06 00 00 call 8048a67 <fread>
804844d: 83 c4 10 add $0x10,%esp
if (header.magic!=ELF_MAGIC) {
8048450: 8b 45 b4 mov -0x4c(%ebp),%eax
8048453: 3d 7f 45 4c 46 cmp $0x464c457f,%eax
8048458: 74 49 je 80484a3 <load_proc_devfs+0x98>
serial_print("Bad magic number (");
804845a: 83 ec 0c sub $0xc,%esp
804845d: 68 c6 9e 04 08 push $0x8049ec6
8048462: e8 2e 03 00 00 call 8048795 <serial_print>
8048467: 83 c4 10 add $0x10,%esp
char str[32];
hex_to_ascii(header.magic,str);
804846a: 8b 45 b4 mov -0x4c(%ebp),%eax
804846d: 83 ec 08 sub $0x8,%esp
8048470: 8d 55 94 lea -0x6c(%ebp),%edx
8048473: 52 push %edx
8048474: 50 push %eax
8048475: e8 04 14 00 00 call 804987e <hex_to_ascii>
804847a: 83 c4 10 add $0x10,%esp
serial_print(str);
804847d: 83 ec 0c sub $0xc,%esp
8048480: 8d 45 94 lea -0x6c(%ebp),%eax
8048483: 50 push %eax
8048484: e8 0c 03 00 00 call 8048795 <serial_print>
8048489: 83 c4 10 add $0x10,%esp
serial_print(")\n");
804848c: 83 ec 0c sub $0xc,%esp
804848f: 68 d9 9e 04 08 push $0x8049ed9
8048494: e8 fc 02 00 00 call 8048795 <serial_print>
8048499: 83 c4 10 add $0x10,%esp
return 0;
804849c: b0 00 mov $0x0,%al
804849e: e9 ea 00 00 00 jmp 804858d <load_proc_devfs+0x182>
} else {
void* address_space=new_address_space();
80484a3: e8 72 03 00 00 call 804881a <new_address_space>
80484a8: 89 45 ec mov %eax,-0x14(%ebp)
for (int i=0;i<header.pheader_ent_nm;i++) {
80484ab: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
80484b2: e9 b2 00 00 00 jmp 8048569 <load_proc_devfs+0x15e>
elf_pheader pheader;
fseek(initrd,(header.prog_hdr)+(header.pheader_ent_sz*i)+datapos,SEEK_SET);
80484b7: 8b 55 d0 mov -0x30(%ebp),%edx
80484ba: 66 8b 45 de mov -0x22(%ebp),%ax
80484be: 0f b7 c0 movzwl %ax,%eax
80484c1: 0f af 45 f4 imul -0xc(%ebp),%eax
80484c5: 01 c2 add %eax,%edx
80484c7: 8b 45 08 mov 0x8(%ebp),%eax
80484ca: 01 d0 add %edx,%eax
80484cc: 83 ec 04 sub $0x4,%esp
80484cf: 6a 03 push $0x3
80484d1: 50 push %eax
80484d2: ff 75 f0 pushl -0x10(%ebp)
80484d5: e8 04 0c 00 00 call 80490de <fseek>
80484da: 83 c4 10 add $0x10,%esp
fread(&pheader,sizeof(elf_pheader),1,initrd);
80484dd: ff 75 f0 pushl -0x10(%ebp)
80484e0: 6a 01 push $0x1
80484e2: 6a 20 push $0x20
80484e4: 8d 45 94 lea -0x6c(%ebp),%eax
80484e7: 50 push %eax
80484e8: e8 7a 05 00 00 call 8048a67 <fread>
80484ed: 83 c4 10 add $0x10,%esp
char* ptr=alloc_memory(((pheader.memsz)/4096)+1);
80484f0: 8b 45 a8 mov -0x58(%ebp),%eax
80484f3: c1 e8 0c shr $0xc,%eax
80484f6: 40 inc %eax
80484f7: 83 ec 0c sub $0xc,%esp
80484fa: 50 push %eax
80484fb: e8 d9 02 00 00 call 80487d9 <alloc_memory>
8048500: 83 c4 10 add $0x10,%esp
8048503: 89 45 e8 mov %eax,-0x18(%ebp)
memset(ptr,0,pheader.memsz);
8048506: 8b 45 a8 mov -0x58(%ebp),%eax
8048509: 83 ec 04 sub $0x4,%esp
804850c: 50 push %eax
804850d: 6a 00 push $0x0
804850f: ff 75 e8 pushl -0x18(%ebp)
8048512: e8 7b 11 00 00 call 8049692 <memset>
8048517: 83 c4 10 add $0x10,%esp
if (pheader.filesz>0) {
804851a: 8b 45 a4 mov -0x5c(%ebp),%eax
804851d: 85 c0 test %eax,%eax
804851f: 74 2d je 804854e <load_proc_devfs+0x143>
fseek(initrd,pheader.offset+datapos,SEEK_SET);
8048521: 8b 55 98 mov -0x68(%ebp),%edx
8048524: 8b 45 08 mov 0x8(%ebp),%eax
8048527: 01 d0 add %edx,%eax
8048529: 83 ec 04 sub $0x4,%esp
804852c: 6a 03 push $0x3
804852e: 50 push %eax
804852f: ff 75 f0 pushl -0x10(%ebp)
8048532: e8 a7 0b 00 00 call 80490de <fseek>
8048537: 83 c4 10 add $0x10,%esp
fread(ptr,sizeof(char),pheader.filesz,initrd);
804853a: 8b 45 a4 mov -0x5c(%ebp),%eax
804853d: ff 75 f0 pushl -0x10(%ebp)
8048540: 50 push %eax
8048541: 6a 01 push $0x1
8048543: ff 75 e8 pushl -0x18(%ebp)
8048546: e8 1c 05 00 00 call 8048a67 <fread>
804854b: 83 c4 10 add $0x10,%esp
}
copy_data(address_space,ptr,pheader.memsz,(void*)pheader.vaddr);
804854e: 8b 45 9c mov -0x64(%ebp),%eax
8048551: 89 c2 mov %eax,%edx
8048553: 8b 45 a8 mov -0x58(%ebp),%eax
8048556: 52 push %edx
8048557: 50 push %eax
8048558: ff 75 e8 pushl -0x18(%ebp)
804855b: ff 75 ec pushl -0x14(%ebp)
804855e: e8 d3 02 00 00 call 8048836 <copy_data>
8048563: 83 c4 10 add $0x10,%esp
for (int i=0;i<header.pheader_ent_nm;i++) {
8048566: ff 45 f4 incl -0xc(%ebp)
8048569: 8b 45 e0 mov -0x20(%ebp),%eax
804856c: 0f b7 c0 movzwl %ax,%eax
804856f: 39 45 f4 cmp %eax,-0xc(%ebp)
8048572: 0f 8c 3f ff ff ff jl 80484b7 <load_proc_devfs+0xac>
}
create_proc((void*)header.entry,address_space,NULL,NULL);
8048578: 8b 45 cc mov -0x34(%ebp),%eax
804857b: 6a 00 push $0x0
804857d: 6a 00 push $0x0
804857f: ff 75 ec pushl -0x14(%ebp)
8048582: 50 push %eax
8048583: e8 8d 15 00 00 call 8049b15 <create_proc>
8048588: 83 c4 10 add $0x10,%esp
}
return 1;
804858b: b0 01 mov $0x1,%al
}
804858d: c9 leave
804858e: c3 ret
0804858f <main>:
int main() {
804858f: 8d 4c 24 04 lea 0x4(%esp),%ecx
8048593: 83 e4 f0 and $0xfffffff0,%esp
8048596: ff 71 fc pushl -0x4(%ecx)
8048599: 55 push %ebp
804859a: 89 e5 mov %esp,%ebp
804859c: 51 push %ecx
804859d: 83 ec 14 sub $0x14,%esp
serial_print("Init running\n");
80485a0: 83 ec 0c sub $0xc,%esp
80485a3: 68 dc 9e 04 08 push $0x8049edc
80485a8: e8 e8 01 00 00 call 8048795 <serial_print>
80485ad: 83 c4 10 add $0x10,%esp
long size=initrd_sz();
80485b0: e8 f4 01 00 00 call 80487a9 <initrd_sz>
80485b5: 89 45 f4 mov %eax,-0xc(%ebp)
char* initrd=malloc(size);
80485b8: 8b 45 f4 mov -0xc(%ebp),%eax
80485bb: 83 ec 0c sub $0xc,%esp
80485be: 50 push %eax
80485bf: e8 97 0d 00 00 call 804935b <malloc>
80485c4: 83 c4 10 add $0x10,%esp
80485c7: 89 45 f0 mov %eax,-0x10(%ebp)
initrd_get(initrd);
80485ca: 83 ec 0c sub $0xc,%esp
80485cd: ff 75 f0 pushl -0x10(%ebp)
80485d0: e8 f0 01 00 00 call 80487c5 <initrd_get>
80485d5: 83 c4 10 add $0x10,%esp
size_t datapos=find_loc("vfs",initrd);
80485d8: 83 ec 08 sub $0x8,%esp
80485db: ff 75 f0 pushl -0x10(%ebp)
80485de: 68 ea 9e 04 08 push $0x8049eea
80485e3: e8 06 fc ff ff call 80481ee <find_loc>
80485e8: 83 c4 10 add $0x10,%esp
80485eb: 89 45 ec mov %eax,-0x14(%ebp)
load_proc(datapos,initrd);
80485ee: 83 ec 08 sub $0x8,%esp
80485f1: ff 75 f0 pushl -0x10(%ebp)
80485f4: ff 75 ec pushl -0x14(%ebp)
80485f7: e8 b6 fc ff ff call 80482b2 <load_proc>
80485fc: 83 c4 10 add $0x10,%esp
while(rpc_is_init(2)==0);
80485ff: 90 nop
8048600: 83 ec 0c sub $0xc,%esp
8048603: 6a 02 push $0x2
8048605: e8 17 16 00 00 call 8049c21 <rpc_is_init>
804860a: 83 c4 10 add $0x10,%esp
804860d: 84 c0 test %al,%al
804860f: 74 ef je 8048600 <main+0x71>
datapos=find_loc("devfs",initrd);
8048611: 83 ec 08 sub $0x8,%esp
8048614: ff 75 f0 pushl -0x10(%ebp)
8048617: 68 ee 9e 04 08 push $0x8049eee
804861c: e8 cd fb ff ff call 80481ee <find_loc>
8048621: 83 c4 10 add $0x10,%esp
8048624: 89 45 ec mov %eax,-0x14(%ebp)
load_proc(datapos,initrd);
8048627: 83 ec 08 sub $0x8,%esp
804862a: ff 75 f0 pushl -0x10(%ebp)
804862d: ff 75 ec pushl -0x14(%ebp)
8048630: e8 7d fc ff ff call 80482b2 <load_proc>
8048635: 83 c4 10 add $0x10,%esp
while(rpc_is_init(3)==0);
8048638: 90 nop
8048639: 83 ec 0c sub $0xc,%esp
804863c: 6a 03 push $0x3
804863e: e8 de 15 00 00 call 8049c21 <rpc_is_init>
8048643: 83 c4 10 add $0x10,%esp
8048646: 84 c0 test %al,%al
8048648: 74 ef je 8048639 <main+0xaa>
int err=mount("","devfs","/dev");
804864a: 83 ec 04 sub $0x4,%esp
804864d: 68 f4 9e 04 08 push $0x8049ef4
8048652: 68 ee 9e 04 08 push $0x8049eee
8048657: 68 f9 9e 04 08 push $0x8049ef9
804865c: e8 58 07 00 00 call 8048db9 <mount>
8048661: 83 c4 10 add $0x10,%esp
8048664: 89 45 e8 mov %eax,-0x18(%ebp)
if (err) {
8048667: 83 7d e8 00 cmpl $0x0,-0x18(%ebp)
804866b: 74 1a je 8048687 <main+0xf8>
serial_print("Failed to mount devfs\n");
804866d: 83 ec 0c sub $0xc,%esp
8048670: 68 fa 9e 04 08 push $0x8049efa
8048675: e8 1b 01 00 00 call 8048795 <serial_print>
804867a: 83 c4 10 add $0x10,%esp
exit(1);
804867d: 83 ec 0c sub $0xc,%esp
8048680: 6a 01 push $0x1
8048682: e8 ad 14 00 00 call 8049b34 <exit>
}
datapos=find_loc("initrd_drv",initrd);
8048687: 83 ec 08 sub $0x8,%esp
804868a: ff 75 f0 pushl -0x10(%ebp)
804868d: 68 11 9f 04 08 push $0x8049f11
8048692: e8 57 fb ff ff call 80481ee <find_loc>
8048697: 83 c4 10 add $0x10,%esp
804869a: 89 45 ec mov %eax,-0x14(%ebp)
load_proc(datapos,initrd);
804869d: 83 ec 08 sub $0x8,%esp
80486a0: ff 75 f0 pushl -0x10(%ebp)
80486a3: ff 75 ec pushl -0x14(%ebp)
80486a6: e8 07 fc ff ff call 80482b2 <load_proc>
80486ab: 83 c4 10 add $0x10,%esp
while(rpc_is_init(4)==0);
80486ae: 90 nop
80486af: 83 ec 0c sub $0xc,%esp
80486b2: 6a 04 push $0x4
80486b4: e8 68 15 00 00 call 8049c21 <rpc_is_init>
80486b9: 83 c4 10 add $0x10,%esp
80486bc: 84 c0 test %al,%al
80486be: 74 ef je 80486af <main+0x120>
serial_print("Loading VGA driver\n");
80486c0: 83 ec 0c sub $0xc,%esp
80486c3: 68 1c 9f 04 08 push $0x8049f1c
80486c8: e8 c8 00 00 00 call 8048795 <serial_print>
80486cd: 83 c4 10 add $0x10,%esp
datapos=find_loc("vga_drv",initrd);
80486d0: 83 ec 08 sub $0x8,%esp
80486d3: ff 75 f0 pushl -0x10(%ebp)
80486d6: 68 30 9f 04 08 push $0x8049f30
80486db: e8 0e fb ff ff call 80481ee <find_loc>
80486e0: 83 c4 10 add $0x10,%esp
80486e3: 89 45 ec mov %eax,-0x14(%ebp)
load_proc_devfs(datapos);
80486e6: 83 ec 0c sub $0xc,%esp
80486e9: ff 75 ec pushl -0x14(%ebp)
80486ec: e8 1a fd ff ff call 804840b <load_proc_devfs>
80486f1: 83 c4 10 add $0x10,%esp
while(rpc_is_init(5)==0);
80486f4: 90 nop
80486f5: 83 ec 0c sub $0xc,%esp
80486f8: 6a 05 push $0x5
80486fa: e8 22 15 00 00 call 8049c21 <rpc_is_init>
80486ff: 83 c4 10 add $0x10,%esp
8048702: 84 c0 test %al,%al
8048704: 74 ef je 80486f5 <main+0x166>
serial_print("Opening /dev/vga\n");
8048706: 83 ec 0c sub $0xc,%esp
8048709: 68 38 9f 04 08 push $0x8049f38
804870e: e8 82 00 00 00 call 8048795 <serial_print>
8048713: 83 c4 10 add $0x10,%esp
stdout=fopen("/dev/vga","w");
8048716: 83 ec 08 sub $0x8,%esp
8048719: 68 4a 9f 04 08 push $0x8049f4a
804871e: 68 4c 9f 04 08 push $0x8049f4c
8048723: e8 87 01 00 00 call 80488af <fopen>
8048728: 83 c4 10 add $0x10,%esp
804872b: a3 44 b0 04 08 mov %eax,0x804b044
if (!stdout) {
8048730: a1 44 b0 04 08 mov 0x804b044,%eax
8048735: 85 c0 test %eax,%eax
8048737: 75 1a jne 8048753 <main+0x1c4>
serial_print("Could not open /dev/vga\n");
8048739: 83 ec 0c sub $0xc,%esp
804873c: 68 55 9f 04 08 push $0x8049f55
8048741: e8 4f 00 00 00 call 8048795 <serial_print>
8048746: 83 c4 10 add $0x10,%esp
exit(1);
8048749: 83 ec 0c sub $0xc,%esp
804874c: 6a 01 push $0x1
804874e: e8 e1 13 00 00 call 8049b34 <exit>
}
serial_print("Writing to screen\n");
8048753: 83 ec 0c sub $0xc,%esp
8048756: 68 6e 9f 04 08 push $0x8049f6e
804875b: e8 35 00 00 00 call 8048795 <serial_print>
8048760: 83 c4 10 add $0x10,%esp
puts("Puts test");
8048763: 83 ec 0c sub $0xc,%esp
8048766: 68 81 9f 04 08 push $0x8049f81
804876b: e8 0c 04 00 00 call 8048b7c <puts>
8048770: 83 c4 10 add $0x10,%esp
printf("Printf test with file opened to %s\n","/dev/vga");
8048773: 83 ec 08 sub $0x8,%esp
8048776: 68 4c 9f 04 08 push $0x8049f4c
804877b: 68 8c 9f 04 08 push $0x8049f8c
8048780: e8 15 09 00 00 call 804909a <printf>
8048785: 83 c4 10 add $0x10,%esp
8048788: b8 00 00 00 00 mov $0x0,%eax
}
804878d: 8b 4d fc mov -0x4(%ebp),%ecx
8048790: c9 leave
8048791: 8d 61 fc lea -0x4(%ecx),%esp
8048794: c3 ret
08048795 <serial_print>:
#include <sys/syscalls.h>
#define QUAUX(X) #X
#define QU(X) QUAUX(X)
void serial_print(char* str) {
8048795: 55 push %ebp
8048796: 89 e5 mov %esp,%ebp
8048798: 53 push %ebx
asm volatile(" \
8048799: 8b 45 08 mov 0x8(%ebp),%eax
804879c: 89 c3 mov %eax,%ebx
804879e: b8 0b 00 00 00 mov $0xb,%eax
80487a3: cd 50 int $0x50
mov $" QU(SYSCALL_SERIAL_PRINT) ", %%eax; \
int $80; \
"::"b"(str));
}
80487a5: 90 nop
80487a6: 5b pop %ebx
80487a7: 5d pop %ebp
80487a8: c3 ret
080487a9 <initrd_sz>:
#include <sys/syscalls.h>
#define QUAUX(X) #X
#define QU(X) QUAUX(X)
long initrd_sz() {
80487a9: 55 push %ebp
80487aa: 89 e5 mov %esp,%ebp
80487ac: 53 push %ebx
80487ad: 83 ec 10 sub $0x10,%esp
long size;
asm volatile(" \
80487b0: b8 0c 00 00 00 mov $0xc,%eax
80487b5: cd 50 int $0x50
80487b7: 89 d8 mov %ebx,%eax
80487b9: 89 45 f8 mov %eax,-0x8(%ebp)
mov $" QU(SYSCALL_GET_INITRD_SZ) ", %%eax; \
int $80; \
":"=b"(size));
return size;
80487bc: 8b 45 f8 mov -0x8(%ebp),%eax
}
80487bf: 83 c4 10 add $0x10,%esp
80487c2: 5b pop %ebx
80487c3: 5d pop %ebp
80487c4: c3 ret
080487c5 <initrd_get>:
void initrd_get(char* initrd) {
80487c5: 55 push %ebp
80487c6: 89 e5 mov %esp,%ebp
80487c8: 53 push %ebx
asm volatile(" \
80487c9: 8b 45 08 mov 0x8(%ebp),%eax
80487cc: 89 c3 mov %eax,%ebx
80487ce: b8 0d 00 00 00 mov $0xd,%eax
80487d3: cd 50 int $0x50
mov $" QU(SYSCALL_COPY_INITRD) ", %%eax; \
int $80; \
"::"b"(initrd));
}
80487d5: 90 nop
80487d6: 5b pop %ebx
80487d7: 5d pop %ebp
80487d8: c3 ret
080487d9 <alloc_memory>:
#include <sys/syscalls.h>
#define QUAUX(X) #X
#define QU(X) QUAUX(X)
void* alloc_memory(int num_pages) {
80487d9: 55 push %ebp
80487da: 89 e5 mov %esp,%ebp
80487dc: 53 push %ebx
80487dd: 83 ec 10 sub $0x10,%esp
void* address;
asm volatile(" \
80487e0: 8b 45 08 mov 0x8(%ebp),%eax
80487e3: ba 00 00 00 00 mov $0x0,%edx
80487e8: 89 c3 mov %eax,%ebx
80487ea: 89 d1 mov %edx,%ecx
80487ec: b8 07 00 00 00 mov $0x7,%eax
80487f1: cd 50 int $0x50
80487f3: 89 d8 mov %ebx,%eax
80487f5: 89 45 f8 mov %eax,-0x8(%ebp)
mov $" QU(SYSCALL_ALLOC_MEM) ", %%eax; \
int $80; \
":"=b"(address):"b"(num_pages),"c"(NULL));
return address;
80487f8: 8b 45 f8 mov -0x8(%ebp),%eax
}
80487fb: 83 c4 10 add $0x10,%esp
80487fe: 5b pop %ebx
80487ff: 5d pop %ebp
8048800: c3 ret
08048801 <alloc_memory_virt>:
void alloc_memory_virt(int num_pages,void* addr) {
8048801: 55 push %ebp
8048802: 89 e5 mov %esp,%ebp
8048804: 53 push %ebx
asm volatile(" \
8048805: 8b 45 08 mov 0x8(%ebp),%eax
8048808: 8b 55 0c mov 0xc(%ebp),%edx
804880b: 89 c3 mov %eax,%ebx
804880d: 89 d1 mov %edx,%ecx
804880f: b8 07 00 00 00 mov $0x7,%eax
8048814: cd 50 int $0x50
mov $" QU(SYSCALL_ALLOC_MEM) ", %%eax; \
int $80; \
"::"b"(num_pages),"c"(addr));
}
8048816: 90 nop
8048817: 5b pop %ebx
8048818: 5d pop %ebp
8048819: c3 ret
0804881a <new_address_space>:
void* new_address_space() {
804881a: 55 push %ebp
804881b: 89 e5 mov %esp,%ebp
804881d: 53 push %ebx
804881e: 83 ec 10 sub $0x10,%esp
void* address_space;
asm volatile(" \
8048821: b8 09 00 00 00 mov $0x9,%eax
8048826: cd 50 int $0x50
8048828: 89 d8 mov %ebx,%eax
804882a: 89 45 f8 mov %eax,-0x8(%ebp)
mov $" QU(SYSCALL_NEW_ADDR_SPACE) ", %%eax; \
int $80; \
":"=b"(address_space));
return address_space;
804882d: 8b 45 f8 mov -0x8(%ebp),%eax
}
8048830: 83 c4 10 add $0x10,%esp
8048833: 5b pop %ebx
8048834: 5d pop %ebp
8048835: c3 ret
08048836 <copy_data>:
void copy_data(void* address_space, void* data,size_t size,void* virt_addr) {
8048836: 55 push %ebp
8048837: 89 e5 mov %esp,%ebp
8048839: 56 push %esi
804883a: 53 push %ebx
asm volatile(" \
804883b: 8b 45 08 mov 0x8(%ebp),%eax
804883e: 8b 4d 0c mov 0xc(%ebp),%ecx
8048841: 8b 55 10 mov 0x10(%ebp),%edx
8048844: 8b 75 14 mov 0x14(%ebp),%esi
8048847: 89 c3 mov %eax,%ebx
8048849: b8 0a 00 00 00 mov $0xa,%eax
804884e: cd 50 int $0x50
mov $" QU(SYSCALL_ADDR_SPACES_COPY_DATA) ", %%eax; \
int $80; \
"::"b"(address_space),"c"(data),"d"(size),"S"(virt_addr));
}
8048850: 90 nop
8048851: 5b pop %ebx
8048852: 5e pop %esi
8048853: 5d pop %ebp
8048854: c3 ret
08048855 <put_data>:
void* put_data(void* address_space, void* data,size_t size) {
8048855: 55 push %ebp
8048856: 89 e5 mov %esp,%ebp
8048858: 56 push %esi
8048859: 53 push %ebx
804885a: 83 ec 10 sub $0x10,%esp
void* virt_addr;
asm volatile(" \
804885d: 8b 45 08 mov 0x8(%ebp),%eax
8048860: 8b 4d 0c mov 0xc(%ebp),%ecx
8048863: 8b 55 10 mov 0x10(%ebp),%edx
8048866: be 00 00 00 00 mov $0x0,%esi
804886b: 89 c3 mov %eax,%ebx
804886d: b8 0a 00 00 00 mov $0xa,%eax
8048872: cd 50 int $0x50
8048874: 89 d8 mov %ebx,%eax
8048876: 89 45 f4 mov %eax,-0xc(%ebp)
mov $" QU(SYSCALL_ADDR_SPACES_COPY_DATA) ", %%eax; \
int $80; \
":"=b"(virt_addr):"b"(address_space),"c"(data),"d"(size),"S"(NULL));
return virt_addr;
8048879: 8b 45 f4 mov -0xc(%ebp),%eax
}
804887c: 83 c4 10 add $0x10,%esp
804887f: 5b pop %ebx
8048880: 5e pop %esi
8048881: 5d pop %ebp
8048882: c3 ret
08048883 <map_phys>:
void* map_phys(void* phys_addr,size_t num_pages) {
8048883: 55 push %ebp
8048884: 89 e5 mov %esp,%ebp
8048886: 53 push %ebx
8048887: 83 ec 10 sub $0x10,%esp
void* virt_addr;
asm volatile(" \
804888a: 8b 45 08 mov 0x8(%ebp),%eax
804888d: 8b 55 0c mov 0xc(%ebp),%edx
8048890: 89 c3 mov %eax,%ebx
8048892: 89 d1 mov %edx,%ecx
8048894: b8 08 00 00 00 mov $0x8,%eax
8048899: cd 50 int $0x50
804889b: 89 d8 mov %ebx,%eax
804889d: 89 45 f8 mov %eax,-0x8(%ebp)
mov $" QU(SYSCALL_PRIV_MAP_PAGES) ", %%eax; \
int $80; \
":"=b"(virt_addr):"b"(phys_addr),"c"(num_pages));
return virt_addr;
80488a0: 8b 45 f8 mov -0x8(%ebp),%eax
}
80488a3: 83 c4 10 add $0x10,%esp
80488a6: 5b pop %ebx
80488a7: 5d pop %ebp
80488a8: c3 ret
080488a9 <__stdio_init>:
/**
* Initialize stdio.
* Must not be called by user code.
*/
void __stdio_init() {
80488a9: 55 push %ebp
80488aa: 89 e5 mov %esp,%ebp
}
80488ac: 90 nop
80488ad: 5d pop %ebp
80488ae: c3 ret
080488af <fopen>:
FILE* fopen(char* filename,char* mode) {
80488af: 55 push %ebp
80488b0: 89 e5 mov %esp,%ebp
80488b2: 83 ec 28 sub $0x28,%esp
serdes_state state={0};
80488b5: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
80488bc: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
serialize_str(filename,&state);
80488c3: 83 ec 0c sub $0xc,%esp
80488c6: ff 75 08 pushl 0x8(%ebp)
80488c9: e8 55 0e 00 00 call 8049723 <strlen>
80488ce: 83 c4 10 add $0x10,%esp
80488d1: 40 inc %eax
80488d2: 89 c2 mov %eax,%edx
80488d4: 83 ec 08 sub $0x8,%esp
80488d7: 8d 45 dc lea -0x24(%ebp),%eax
80488da: 50 push %eax
80488db: 52 push %edx
80488dc: e8 61 13 00 00 call 8049c42 <serialize_int>
80488e1: 83 c4 10 add $0x10,%esp
80488e4: 83 ec 0c sub $0xc,%esp
80488e7: ff 75 08 pushl 0x8(%ebp)
80488ea: e8 34 0e 00 00 call 8049723 <strlen>
80488ef: 83 c4 10 add $0x10,%esp
80488f2: 8d 50 01 lea 0x1(%eax),%edx
80488f5: 83 ec 04 sub $0x4,%esp
80488f8: 8d 45 dc lea -0x24(%ebp),%eax
80488fb: 50 push %eax
80488fc: 52 push %edx
80488fd: ff 75 08 pushl 0x8(%ebp)
8048900: e8 d1 13 00 00 call 8049cd6 <serialize_ary>
8048905: 83 c4 10 add $0x10,%esp
void* retval=rpc_call(2,"open",state.buf,state.sizeorpos);
8048908: 8b 55 e0 mov -0x20(%ebp),%edx
804890b: 8b 45 dc mov -0x24(%ebp),%eax
804890e: 52 push %edx
804890f: 50 push %eax
8048910: 68 b0 9f 04 08 push $0x8049fb0
8048915: 6a 02 push $0x2
8048917: e8 7f 12 00 00 call 8049b9b <rpc_call>
804891c: 83 c4 10 add $0x10,%esp
804891f: 89 45 f4 mov %eax,-0xc(%ebp)
free(state.buf);
8048922: 8b 45 dc mov -0x24(%ebp),%eax
8048925: 83 ec 0c sub $0xc,%esp
8048928: 50 push %eax
8048929: e8 91 0c 00 00 call 80495bf <free>
804892e: 83 c4 10 add $0x10,%esp
start_deserialize(retval,&state);
8048931: 83 ec 08 sub $0x8,%esp
8048934: 8d 45 dc lea -0x24(%ebp),%eax
8048937: 50 push %eax
8048938: ff 75 f4 pushl -0xc(%ebp)
804893b: e8 f1 13 00 00 call 8049d31 <start_deserialize>
8048940: 83 c4 10 add $0x10,%esp
int err=deserialize_int(&state);
8048943: 83 ec 0c sub $0xc,%esp
8048946: 8d 45 dc lea -0x24(%ebp),%eax
8048949: 50 push %eax
804894a: e8 fa 13 00 00 call 8049d49 <deserialize_int>
804894f: 83 c4 10 add $0x10,%esp
8048952: 89 45 f0 mov %eax,-0x10(%ebp)
void* fs_data=deserialize_ptr(&state);
8048955: 83 ec 0c sub $0xc,%esp
8048958: 8d 45 dc lea -0x24(%ebp),%eax
804895b: 50 push %eax
804895c: e8 14 14 00 00 call 8049d75 <deserialize_ptr>
8048961: 83 c4 10 add $0x10,%esp
8048964: 89 45 ec mov %eax,-0x14(%ebp)
pid_t fs_pid=deserialize_int(&state);
8048967: 83 ec 0c sub $0xc,%esp
804896a: 8d 45 dc lea -0x24(%ebp),%eax
804896d: 50 push %eax
804896e: e8 d6 13 00 00 call 8049d49 <deserialize_int>
8048973: 83 c4 10 add $0x10,%esp
8048976: 89 45 e8 mov %eax,-0x18(%ebp)
rpc_deallocate_buf(retval,state.sizeorpos);
8048979: 8b 45 e0 mov -0x20(%ebp),%eax
804897c: 83 ec 08 sub $0x8,%esp
804897f: 50 push %eax
8048980: ff 75 f4 pushl -0xc(%ebp)
8048983: e8 5a 12 00 00 call 8049be2 <rpc_deallocate_buf>
8048988: 83 c4 10 add $0x10,%esp
if (err) {
804898b: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
804898f: 74 07 je 8048998 <fopen+0xe9>
return NULL;
8048991: b8 00 00 00 00 mov $0x0,%eax
8048996: eb 2e jmp 80489c6 <fopen+0x117>
} else {
FILE* file=malloc(sizeof(FILE));
8048998: 83 ec 0c sub $0xc,%esp
804899b: 6a 0c push $0xc
804899d: e8 b9 09 00 00 call 804935b <malloc>
80489a2: 83 c4 10 add $0x10,%esp
80489a5: 89 45 e4 mov %eax,-0x1c(%ebp)
file->fs_pid=fs_pid;
80489a8: 8b 45 e4 mov -0x1c(%ebp),%eax
80489ab: 8b 55 e8 mov -0x18(%ebp),%edx
80489ae: 89 10 mov %edx,(%eax)
file->fs_data=fs_data;
80489b0: 8b 45 e4 mov -0x1c(%ebp),%eax
80489b3: 8b 55 ec mov -0x14(%ebp),%edx
80489b6: 89 50 04 mov %edx,0x4(%eax)
file->pos=0;
80489b9: 8b 45 e4 mov -0x1c(%ebp),%eax
80489bc: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
return file;
80489c3: 8b 45 e4 mov -0x1c(%ebp),%eax
}
}
80489c6: c9 leave
80489c7: c3 ret
080489c8 <fputc>:
* \param stream The stream to write to
* \returns the written character, or EOF on failure
*/
int putc(int c, FILE* stream) __attribute__ ((alias ("fputc")));
int fputc(int c, FILE* stream) {
80489c8: 55 push %ebp
80489c9: 89 e5 mov %esp,%ebp
80489cb: 83 ec 18 sub $0x18,%esp
char str[]={c,'\0'};
80489ce: 8b 45 08 mov 0x8(%ebp),%eax
80489d1: 88 45 f6 mov %al,-0xa(%ebp)
80489d4: c6 45 f7 00 movb $0x0,-0x9(%ebp)
if (fputs(str,stream)==0) {
80489d8: 83 ec 08 sub $0x8,%esp
80489db: ff 75 0c pushl 0xc(%ebp)
80489de: 8d 45 f6 lea -0xa(%ebp),%eax
80489e1: 50 push %eax
80489e2: e8 25 02 00 00 call 8048c0c <fputs>
80489e7: 83 c4 10 add $0x10,%esp
80489ea: 85 c0 test %eax,%eax
80489ec: 75 07 jne 80489f5 <fputc+0x2d>
return EOF;
80489ee: b8 ff ff ff ff mov $0xffffffff,%eax
80489f3: eb 03 jmp 80489f8 <fputc+0x30>
} else {
return c;
80489f5: 8b 45 08 mov 0x8(%ebp),%eax
}
return EOF;
}
80489f8: c9 leave
80489f9: c3 ret
080489fa <fgetc>:
* \param stream The file to read from
* \returns the read character, or EOF if the read fails
*/
int getc(FILE* stream) __attribute__ ((alias ("fgetc")));
int fgetc(FILE* stream) {
80489fa: 55 push %ebp
80489fb: 89 e5 mov %esp,%ebp
80489fd: 83 ec 18 sub $0x18,%esp
char c[2];
if (fgets(&c[0],1,stream)==NULL) {
8048a00: 83 ec 04 sub $0x4,%esp
8048a03: ff 75 08 pushl 0x8(%ebp)
8048a06: 6a 01 push $0x1
8048a08: 8d 45 f6 lea -0xa(%ebp),%eax
8048a0b: 50 push %eax
8048a0c: e8 37 00 00 00 call 8048a48 <fgets>
8048a11: 83 c4 10 add $0x10,%esp
8048a14: 85 c0 test %eax,%eax
8048a16: 75 07 jne 8048a1f <fgetc+0x25>
return EOF;
8048a18: b8 ff ff ff ff mov $0xffffffff,%eax
8048a1d: eb 06 jmp 8048a25 <fgetc+0x2b>
} else {
return c[0];
8048a1f: 8a 45 f6 mov -0xa(%ebp),%al
8048a22: 0f be c0 movsbl %al,%eax
}
return EOF;
}
8048a25: c9 leave
8048a26: c3 ret
08048a27 <gets>:
char* gets(char* s) {
8048a27: 55 push %ebp
8048a28: 89 e5 mov %esp,%ebp
8048a2a: 83 ec 08 sub $0x8,%esp
return fgets(s,INT_MAX,stdin);
8048a2d: a1 40 b0 04 08 mov 0x804b040,%eax
8048a32: 83 ec 04 sub $0x4,%esp
8048a35: 50 push %eax
8048a36: 68 ff ff ff 7f push $0x7fffffff
8048a3b: ff 75 08 pushl 0x8(%ebp)
8048a3e: e8 05 00 00 00 call 8048a48 <fgets>
8048a43: 83 c4 10 add $0x10,%esp
}
8048a46: c9 leave
8048a47: c3 ret
08048a48 <fgets>:
char* fgets(char* str,int count,FILE* stream) {
8048a48: 55 push %ebp
8048a49: 89 e5 mov %esp,%ebp
8048a4b: 83 ec 08 sub $0x8,%esp
fread(str,1,count,stream);
8048a4e: 8b 45 0c mov 0xc(%ebp),%eax
8048a51: ff 75 10 pushl 0x10(%ebp)
8048a54: 50 push %eax
8048a55: 6a 01 push $0x1
8048a57: ff 75 08 pushl 0x8(%ebp)
8048a5a: e8 08 00 00 00 call 8048a67 <fread>
8048a5f: 83 c4 10 add $0x10,%esp
return str;
8048a62: 8b 45 08 mov 0x8(%ebp),%eax
}
8048a65: c9 leave
8048a66: c3 ret
08048a67 <fread>:
size_t fread(void* buffer_ptr,size_t size,size_t count,FILE* stream) {
8048a67: 55 push %ebp
8048a68: 89 e5 mov %esp,%ebp
8048a6a: 83 ec 28 sub $0x28,%esp
serdes_state state={0};
8048a6d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
8048a74: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
serialize_ptr(stream->fs_data,&state);
8048a7b: 8b 45 14 mov 0x14(%ebp),%eax
8048a7e: 8b 40 04 mov 0x4(%eax),%eax
8048a81: 83 ec 08 sub $0x8,%esp
8048a84: 8d 55 e4 lea -0x1c(%ebp),%edx
8048a87: 52 push %edx
8048a88: 50 push %eax
8048a89: e8 fe 11 00 00 call 8049c8c <serialize_ptr>
8048a8e: 83 c4 10 add $0x10,%esp
serialize_int(size*count,&state);
8048a91: 8b 45 0c mov 0xc(%ebp),%eax
8048a94: 0f af 45 10 imul 0x10(%ebp),%eax
8048a98: 89 c2 mov %eax,%edx
8048a9a: 83 ec 08 sub $0x8,%esp
8048a9d: 8d 45 e4 lea -0x1c(%ebp),%eax
8048aa0: 50 push %eax
8048aa1: 52 push %edx
8048aa2: e8 9b 11 00 00 call 8049c42 <serialize_int>
8048aa7: 83 c4 10 add $0x10,%esp
serialize_int(stream->pos,&state);
8048aaa: 8b 45 14 mov 0x14(%ebp),%eax
8048aad: 8b 40 08 mov 0x8(%eax),%eax
8048ab0: 83 ec 08 sub $0x8,%esp
8048ab3: 8d 55 e4 lea -0x1c(%ebp),%edx
8048ab6: 52 push %edx
8048ab7: 50 push %eax
8048ab8: e8 85 11 00 00 call 8049c42 <serialize_int>
8048abd: 83 c4 10 add $0x10,%esp
void* retbuf=rpc_call(stream->fs_pid,"read",state.buf,state.sizeorpos);
8048ac0: 8b 4d e8 mov -0x18(%ebp),%ecx
8048ac3: 8b 55 e4 mov -0x1c(%ebp),%edx
8048ac6: 8b 45 14 mov 0x14(%ebp),%eax
8048ac9: 8b 00 mov (%eax),%eax
8048acb: 51 push %ecx
8048acc: 52 push %edx
8048acd: 68 b5 9f 04 08 push $0x8049fb5
8048ad2: 50 push %eax
8048ad3: e8 c3 10 00 00 call 8049b9b <rpc_call>
8048ad8: 83 c4 10 add $0x10,%esp
8048adb: 89 45 f4 mov %eax,-0xc(%ebp)
free(state.buf);
8048ade: 8b 45 e4 mov -0x1c(%ebp),%eax
8048ae1: 83 ec 0c sub $0xc,%esp
8048ae4: 50 push %eax
8048ae5: e8 d5 0a 00 00 call 80495bf <free>
8048aea: 83 c4 10 add $0x10,%esp
state.buf=NULL;
8048aed: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
state.sizeorpos=0;
8048af4: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
start_deserialize(retbuf,&state);
8048afb: 83 ec 08 sub $0x8,%esp
8048afe: 8d 45 e4 lea -0x1c(%ebp),%eax
8048b01: 50 push %eax
8048b02: ff 75 f4 pushl -0xc(%ebp)
8048b05: e8 27 12 00 00 call 8049d31 <start_deserialize>
8048b0a: 83 c4 10 add $0x10,%esp
int bytes_read=deserialize_int(&state);
8048b0d: 83 ec 0c sub $0xc,%esp
8048b10: 8d 45 e4 lea -0x1c(%ebp),%eax
8048b13: 50 push %eax
8048b14: e8 30 12 00 00 call 8049d49 <deserialize_int>
8048b19: 83 c4 10 add $0x10,%esp
8048b1c: 89 45 f0 mov %eax,-0x10(%ebp)
if (bytes_read) {
8048b1f: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
8048b23: 74 2f je 8048b54 <fread+0xed>
void* ary=deserialize_ary(bytes_read,&state);
8048b25: 8b 45 f0 mov -0x10(%ebp),%eax
8048b28: 83 ec 08 sub $0x8,%esp
8048b2b: 8d 55 e4 lea -0x1c(%ebp),%edx
8048b2e: 52 push %edx
8048b2f: 50 push %eax
8048b30: e8 6c 12 00 00 call 8049da1 <deserialize_ary>
8048b35: 83 c4 10 add $0x10,%esp
8048b38: 89 45 ec mov %eax,-0x14(%ebp)
memcpy(buffer_ptr,ary,size*count);
8048b3b: 8b 45 0c mov 0xc(%ebp),%eax
8048b3e: 0f af 45 10 imul 0x10(%ebp),%eax
8048b42: 83 ec 04 sub $0x4,%esp
8048b45: 50 push %eax
8048b46: ff 75 ec pushl -0x14(%ebp)
8048b49: ff 75 08 pushl 0x8(%ebp)
8048b4c: e8 02 0b 00 00 call 8049653 <memcpy>
8048b51: 83 c4 10 add $0x10,%esp
}
rpc_deallocate_buf(retbuf,state.sizeorpos);
8048b54: 8b 45 e8 mov -0x18(%ebp),%eax
8048b57: 83 ec 08 sub $0x8,%esp
8048b5a: 50 push %eax
8048b5b: ff 75 f4 pushl -0xc(%ebp)
8048b5e: e8 7f 10 00 00 call 8049be2 <rpc_deallocate_buf>
8048b63: 83 c4 10 add $0x10,%esp
stream->pos+=bytes_read;
8048b66: 8b 45 14 mov 0x14(%ebp),%eax
8048b69: 8b 50 08 mov 0x8(%eax),%edx
8048b6c: 8b 45 f0 mov -0x10(%ebp),%eax
8048b6f: 01 c2 add %eax,%edx
8048b71: 8b 45 14 mov 0x14(%ebp),%eax
8048b74: 89 50 08 mov %edx,0x8(%eax)
return bytes_read;
8048b77: 8b 45 f0 mov -0x10(%ebp),%eax
}
8048b7a: c9 leave
8048b7b: c3 ret
08048b7c <puts>:
int puts(const char *s) {
8048b7c: 55 push %ebp
8048b7d: 89 e5 mov %esp,%ebp
8048b7f: 83 ec 18 sub $0x18,%esp
char* str=malloc(sizeof(char)*(strlen(s)+2));
8048b82: 83 ec 0c sub $0xc,%esp
8048b85: ff 75 08 pushl 0x8(%ebp)
8048b88: e8 96 0b 00 00 call 8049723 <strlen>
8048b8d: 83 c4 10 add $0x10,%esp
8048b90: 83 c0 02 add $0x2,%eax
8048b93: 83 ec 0c sub $0xc,%esp
8048b96: 50 push %eax
8048b97: e8 bf 07 00 00 call 804935b <malloc>
8048b9c: 83 c4 10 add $0x10,%esp
8048b9f: 89 45 f4 mov %eax,-0xc(%ebp)
strcpy(str,s);
8048ba2: 83 ec 08 sub $0x8,%esp
8048ba5: ff 75 08 pushl 0x8(%ebp)
8048ba8: ff 75 f4 pushl -0xc(%ebp)
8048bab: e8 98 0b 00 00 call 8049748 <strcpy>
8048bb0: 83 c4 10 add $0x10,%esp
str[strlen(s)]='\n';
8048bb3: 83 ec 0c sub $0xc,%esp
8048bb6: ff 75 08 pushl 0x8(%ebp)
8048bb9: e8 65 0b 00 00 call 8049723 <strlen>
8048bbe: 83 c4 10 add $0x10,%esp
8048bc1: 8b 55 f4 mov -0xc(%ebp),%edx
8048bc4: 01 d0 add %edx,%eax
8048bc6: c6 00 0a movb $0xa,(%eax)
str[strlen(s)+1]='\0';
8048bc9: 83 ec 0c sub $0xc,%esp
8048bcc: ff 75 08 pushl 0x8(%ebp)
8048bcf: e8 4f 0b 00 00 call 8049723 <strlen>
8048bd4: 83 c4 10 add $0x10,%esp
8048bd7: 8d 50 01 lea 0x1(%eax),%edx
8048bda: 8b 45 f4 mov -0xc(%ebp),%eax
8048bdd: 01 d0 add %edx,%eax
8048bdf: c6 00 00 movb $0x0,(%eax)
int code=fputs(str,stdout);
8048be2: a1 44 b0 04 08 mov 0x804b044,%eax
8048be7: 83 ec 08 sub $0x8,%esp
8048bea: 50 push %eax
8048beb: ff 75 f4 pushl -0xc(%ebp)
8048bee: e8 19 00 00 00 call 8048c0c <fputs>
8048bf3: 83 c4 10 add $0x10,%esp
8048bf6: 89 45 f0 mov %eax,-0x10(%ebp)
free(str);
8048bf9: 83 ec 0c sub $0xc,%esp
8048bfc: ff 75 f4 pushl -0xc(%ebp)
8048bff: e8 bb 09 00 00 call 80495bf <free>
8048c04: 83 c4 10 add $0x10,%esp
return code;
8048c07: 8b 45 f0 mov -0x10(%ebp),%eax
}
8048c0a: c9 leave
8048c0b: c3 ret
08048c0c <fputs>:
int fputs(const char* s, FILE* stream) {
8048c0c: 55 push %ebp
8048c0d: 89 e5 mov %esp,%ebp
8048c0f: 83 ec 18 sub $0x18,%esp
size_t retval=fwrite((void*)s,strlen(s),1,stream);
8048c12: 83 ec 0c sub $0xc,%esp
8048c15: ff 75 08 pushl 0x8(%ebp)
8048c18: e8 06 0b 00 00 call 8049723 <strlen>
8048c1d: 83 c4 10 add $0x10,%esp
8048c20: ff 75 0c pushl 0xc(%ebp)
8048c23: 6a 01 push $0x1
8048c25: 50 push %eax
8048c26: ff 75 08 pushl 0x8(%ebp)
8048c29: e8 1a 00 00 00 call 8048c48 <fwrite>
8048c2e: 83 c4 10 add $0x10,%esp
8048c31: 89 45 f4 mov %eax,-0xc(%ebp)
if (retval==0) {
8048c34: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
8048c38: 75 07 jne 8048c41 <fputs+0x35>
return 0;
8048c3a: b8 00 00 00 00 mov $0x0,%eax
8048c3f: eb 05 jmp 8048c46 <fputs+0x3a>
} else {
return EOF;
8048c41: b8 ff ff ff ff mov $0xffffffff,%eax
}
}
8048c46: c9 leave
8048c47: c3 ret
08048c48 <fwrite>:
size_t fwrite(void* buffer_ptr,size_t size,size_t count,FILE* stream) {
8048c48: 55 push %ebp
8048c49: 89 e5 mov %esp,%ebp
8048c4b: 83 ec 18 sub $0x18,%esp
serdes_state state={0};
8048c4e: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
8048c55: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
serialize_ptr(stream->fs_data,&state);
8048c5c: 8b 45 14 mov 0x14(%ebp),%eax
8048c5f: 8b 40 04 mov 0x4(%eax),%eax
8048c62: 83 ec 08 sub $0x8,%esp
8048c65: 8d 55 e8 lea -0x18(%ebp),%edx
8048c68: 52 push %edx
8048c69: 50 push %eax
8048c6a: e8 1d 10 00 00 call 8049c8c <serialize_ptr>
8048c6f: 83 c4 10 add $0x10,%esp
serialize_int(size*count,&state);
8048c72: 8b 45 0c mov 0xc(%ebp),%eax
8048c75: 0f af 45 10 imul 0x10(%ebp),%eax
8048c79: 89 c2 mov %eax,%edx
8048c7b: 83 ec 08 sub $0x8,%esp
8048c7e: 8d 45 e8 lea -0x18(%ebp),%eax
8048c81: 50 push %eax
8048c82: 52 push %edx
8048c83: e8 ba 0f 00 00 call 8049c42 <serialize_int>
8048c88: 83 c4 10 add $0x10,%esp
serialize_int(stream->pos,&state);
8048c8b: 8b 45 14 mov 0x14(%ebp),%eax
8048c8e: 8b 40 08 mov 0x8(%eax),%eax
8048c91: 83 ec 08 sub $0x8,%esp
8048c94: 8d 55 e8 lea -0x18(%ebp),%edx
8048c97: 52 push %edx
8048c98: 50 push %eax
8048c99: e8 a4 0f 00 00 call 8049c42 <serialize_int>
8048c9e: 83 c4 10 add $0x10,%esp
serialize_ary(buffer_ptr,size*count,&state);
8048ca1: 8b 45 0c mov 0xc(%ebp),%eax
8048ca4: 0f af 45 10 imul 0x10(%ebp),%eax
8048ca8: 83 ec 04 sub $0x4,%esp
8048cab: 8d 55 e8 lea -0x18(%ebp),%edx
8048cae: 52 push %edx
8048caf: 50 push %eax
8048cb0: ff 75 08 pushl 0x8(%ebp)
8048cb3: e8 1e 10 00 00 call 8049cd6 <serialize_ary>
8048cb8: 83 c4 10 add $0x10,%esp
void* retbuf=rpc_call(stream->fs_pid,"write",state.buf,state.sizeorpos);
8048cbb: 8b 4d ec mov -0x14(%ebp),%ecx
8048cbe: 8b 55 e8 mov -0x18(%ebp),%edx
8048cc1: 8b 45 14 mov 0x14(%ebp),%eax
8048cc4: 8b 00 mov (%eax),%eax
8048cc6: 51 push %ecx
8048cc7: 52 push %edx
8048cc8: 68 ba 9f 04 08 push $0x8049fba
8048ccd: 50 push %eax
8048cce: e8 c8 0e 00 00 call 8049b9b <rpc_call>
8048cd3: 83 c4 10 add $0x10,%esp
8048cd6: 89 45 f4 mov %eax,-0xc(%ebp)
free(state.buf);
8048cd9: 8b 45 e8 mov -0x18(%ebp),%eax
8048cdc: 83 ec 0c sub $0xc,%esp
8048cdf: 50 push %eax
8048ce0: e8 da 08 00 00 call 80495bf <free>
8048ce5: 83 c4 10 add $0x10,%esp
start_deserialize(retbuf,&state);
8048ce8: 83 ec 08 sub $0x8,%esp
8048ceb: 8d 45 e8 lea -0x18(%ebp),%eax
8048cee: 50 push %eax
8048cef: ff 75 f4 pushl -0xc(%ebp)
8048cf2: e8 3a 10 00 00 call 8049d31 <start_deserialize>
8048cf7: 83 c4 10 add $0x10,%esp
int bytes_wrote=deserialize_int(&state);
8048cfa: 83 ec 0c sub $0xc,%esp
8048cfd: 8d 45 e8 lea -0x18(%ebp),%eax
8048d00: 50 push %eax
8048d01: e8 43 10 00 00 call 8049d49 <deserialize_int>
8048d06: 83 c4 10 add $0x10,%esp
8048d09: 89 45 f0 mov %eax,-0x10(%ebp)
rpc_deallocate_buf(retbuf,state.sizeorpos);
8048d0c: 8b 45 ec mov -0x14(%ebp),%eax
8048d0f: 83 ec 08 sub $0x8,%esp
8048d12: 50 push %eax
8048d13: ff 75 f4 pushl -0xc(%ebp)
8048d16: e8 c7 0e 00 00 call 8049be2 <rpc_deallocate_buf>
8048d1b: 83 c4 10 add $0x10,%esp
stream->pos+=bytes_wrote;
8048d1e: 8b 45 14 mov 0x14(%ebp),%eax
8048d21: 8b 50 08 mov 0x8(%eax),%edx
8048d24: 8b 45 f0 mov -0x10(%ebp),%eax
8048d27: 01 c2 add %eax,%edx
8048d29: 8b 45 14 mov 0x14(%ebp),%eax
8048d2c: 89 50 08 mov %edx,0x8(%eax)
return bytes_wrote;
8048d2f: 8b 45 f0 mov -0x10(%ebp),%eax
}
8048d32: c9 leave
8048d33: c3 ret
08048d34 <register_fs>:
void register_fs(const char* name,pid_t pid) {
8048d34: 55 push %ebp
8048d35: 89 e5 mov %esp,%ebp
8048d37: 83 ec 18 sub $0x18,%esp
serdes_state state={0};
8048d3a: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
8048d41: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
serialize_str((char*)name,&state);
8048d48: 83 ec 0c sub $0xc,%esp
8048d4b: ff 75 08 pushl 0x8(%ebp)
8048d4e: e8 d0 09 00 00 call 8049723 <strlen>
8048d53: 83 c4 10 add $0x10,%esp
8048d56: 40 inc %eax
8048d57: 89 c2 mov %eax,%edx
8048d59: 83 ec 08 sub $0x8,%esp
8048d5c: 8d 45 f0 lea -0x10(%ebp),%eax
8048d5f: 50 push %eax
8048d60: 52 push %edx
8048d61: e8 dc 0e 00 00 call 8049c42 <serialize_int>
8048d66: 83 c4 10 add $0x10,%esp
8048d69: 83 ec 0c sub $0xc,%esp
8048d6c: ff 75 08 pushl 0x8(%ebp)
8048d6f: e8 af 09 00 00 call 8049723 <strlen>
8048d74: 83 c4 10 add $0x10,%esp
8048d77: 8d 50 01 lea 0x1(%eax),%edx
8048d7a: 83 ec 04 sub $0x4,%esp
8048d7d: 8d 45 f0 lea -0x10(%ebp),%eax
8048d80: 50 push %eax
8048d81: 52 push %edx
8048d82: ff 75 08 pushl 0x8(%ebp)
8048d85: e8 4c 0f 00 00 call 8049cd6 <serialize_ary>
8048d8a: 83 c4 10 add $0x10,%esp
serialize_int(pid,&state);
8048d8d: 83 ec 08 sub $0x8,%esp
8048d90: 8d 45 f0 lea -0x10(%ebp),%eax
8048d93: 50 push %eax
8048d94: ff 75 0c pushl 0xc(%ebp)
8048d97: e8 a6 0e 00 00 call 8049c42 <serialize_int>
8048d9c: 83 c4 10 add $0x10,%esp
rpc_call(2,"register_fs",state.buf,state.sizeorpos);
8048d9f: 8b 55 f4 mov -0xc(%ebp),%edx
8048da2: 8b 45 f0 mov -0x10(%ebp),%eax
8048da5: 52 push %edx
8048da6: 50 push %eax
8048da7: 68 c0 9f 04 08 push $0x8049fc0
8048dac: 6a 02 push $0x2
8048dae: e8 e8 0d 00 00 call 8049b9b <rpc_call>
8048db3: 83 c4 10 add $0x10,%esp
}
8048db6: 90 nop
8048db7: c9 leave
8048db8: c3 ret
08048db9 <mount>:
int mount(char* file,char* type,char* path) {
8048db9: 55 push %ebp
8048dba: 89 e5 mov %esp,%ebp
8048dbc: 83 ec 18 sub $0x18,%esp
serdes_state state={0};
8048dbf: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
8048dc6: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
serialize_str(type,&state);
8048dcd: 83 ec 0c sub $0xc,%esp
8048dd0: ff 75 0c pushl 0xc(%ebp)
8048dd3: e8 4b 09 00 00 call 8049723 <strlen>
8048dd8: 83 c4 10 add $0x10,%esp
8048ddb: 40 inc %eax
8048ddc: 89 c2 mov %eax,%edx
8048dde: 83 ec 08 sub $0x8,%esp
8048de1: 8d 45 ec lea -0x14(%ebp),%eax
8048de4: 50 push %eax
8048de5: 52 push %edx
8048de6: e8 57 0e 00 00 call 8049c42 <serialize_int>
8048deb: 83 c4 10 add $0x10,%esp
8048dee: 83 ec 0c sub $0xc,%esp
8048df1: ff 75 0c pushl 0xc(%ebp)
8048df4: e8 2a 09 00 00 call 8049723 <strlen>
8048df9: 83 c4 10 add $0x10,%esp
8048dfc: 8d 50 01 lea 0x1(%eax),%edx
8048dff: 83 ec 04 sub $0x4,%esp
8048e02: 8d 45 ec lea -0x14(%ebp),%eax
8048e05: 50 push %eax
8048e06: 52 push %edx
8048e07: ff 75 0c pushl 0xc(%ebp)
8048e0a: e8 c7 0e 00 00 call 8049cd6 <serialize_ary>
8048e0f: 83 c4 10 add $0x10,%esp
serialize_str(file,&state);
8048e12: 83 ec 0c sub $0xc,%esp
8048e15: ff 75 08 pushl 0x8(%ebp)
8048e18: e8 06 09 00 00 call 8049723 <strlen>
8048e1d: 83 c4 10 add $0x10,%esp
8048e20: 40 inc %eax
8048e21: 89 c2 mov %eax,%edx
8048e23: 83 ec 08 sub $0x8,%esp
8048e26: 8d 45 ec lea -0x14(%ebp),%eax
8048e29: 50 push %eax
8048e2a: 52 push %edx
8048e2b: e8 12 0e 00 00 call 8049c42 <serialize_int>
8048e30: 83 c4 10 add $0x10,%esp
8048e33: 83 ec 0c sub $0xc,%esp
8048e36: ff 75 08 pushl 0x8(%ebp)
8048e39: e8 e5 08 00 00 call 8049723 <strlen>
8048e3e: 83 c4 10 add $0x10,%esp
8048e41: 8d 50 01 lea 0x1(%eax),%edx
8048e44: 83 ec 04 sub $0x4,%esp
8048e47: 8d 45 ec lea -0x14(%ebp),%eax
8048e4a: 50 push %eax
8048e4b: 52 push %edx
8048e4c: ff 75 08 pushl 0x8(%ebp)
8048e4f: e8 82 0e 00 00 call 8049cd6 <serialize_ary>
8048e54: 83 c4 10 add $0x10,%esp
serialize_str(path,&state);
8048e57: 83 ec 0c sub $0xc,%esp
8048e5a: ff 75 10 pushl 0x10(%ebp)
8048e5d: e8 c1 08 00 00 call 8049723 <strlen>
8048e62: 83 c4 10 add $0x10,%esp
8048e65: 40 inc %eax
8048e66: 89 c2 mov %eax,%edx
8048e68: 83 ec 08 sub $0x8,%esp
8048e6b: 8d 45 ec lea -0x14(%ebp),%eax
8048e6e: 50 push %eax
8048e6f: 52 push %edx
8048e70: e8 cd 0d 00 00 call 8049c42 <serialize_int>
8048e75: 83 c4 10 add $0x10,%esp
8048e78: 83 ec 0c sub $0xc,%esp
8048e7b: ff 75 10 pushl 0x10(%ebp)
8048e7e: e8 a0 08 00 00 call 8049723 <strlen>
8048e83: 83 c4 10 add $0x10,%esp
8048e86: 8d 50 01 lea 0x1(%eax),%edx
8048e89: 83 ec 04 sub $0x4,%esp
8048e8c: 8d 45 ec lea -0x14(%ebp),%eax
8048e8f: 50 push %eax
8048e90: 52 push %edx
8048e91: ff 75 10 pushl 0x10(%ebp)
8048e94: e8 3d 0e 00 00 call 8049cd6 <serialize_ary>
8048e99: 83 c4 10 add $0x10,%esp
int* err=rpc_call(2,"mount",state.buf,state.sizeorpos);
8048e9c: 8b 55 f0 mov -0x10(%ebp),%edx
8048e9f: 8b 45 ec mov -0x14(%ebp),%eax
8048ea2: 52 push %edx
8048ea3: 50 push %eax
8048ea4: 68 cc 9f 04 08 push $0x8049fcc
8048ea9: 6a 02 push $0x2
8048eab: e8 eb 0c 00 00 call 8049b9b <rpc_call>
8048eb0: 83 c4 10 add $0x10,%esp
8048eb3: 89 45 f4 mov %eax,-0xc(%ebp)
return *err;
8048eb6: 8b 45 f4 mov -0xc(%ebp),%eax
8048eb9: 8b 00 mov (%eax),%eax
}
8048ebb: c9 leave
8048ebc: c3 ret
08048ebd <vfprintf>:
int vfprintf(FILE* stream,const char* format,va_list arg) {
8048ebd: 55 push %ebp
8048ebe: 89 e5 mov %esp,%ebp
8048ec0: 83 ec 38 sub $0x38,%esp
int c;
for(;*format!='\0';format++) {
8048ec3: e9 7d 01 00 00 jmp 8049045 <vfprintf+0x188>
if(*format!='%') {
8048ec8: 8b 45 0c mov 0xc(%ebp),%eax
8048ecb: 8a 00 mov (%eax),%al
8048ecd: 3c 25 cmp $0x25,%al
8048ecf: 74 1f je 8048ef0 <vfprintf+0x33>
c=fputc(*format,stream);
8048ed1: 8b 45 0c mov 0xc(%ebp),%eax
8048ed4: 8a 00 mov (%eax),%al
8048ed6: 0f be c0 movsbl %al,%eax
8048ed9: 83 ec 08 sub $0x8,%esp
8048edc: ff 75 08 pushl 0x8(%ebp)
8048edf: 50 push %eax
8048ee0: e8 e3 fa ff ff call 80489c8 <fputc>
8048ee5: 83 c4 10 add $0x10,%esp
8048ee8: 89 45 ec mov %eax,-0x14(%ebp)
continue;
8048eeb: e9 52 01 00 00 jmp 8049042 <vfprintf+0x185>
}
format++;
8048ef0: ff 45 0c incl 0xc(%ebp)
switch(*format) {
8048ef3: 8b 45 0c mov 0xc(%ebp),%eax
8048ef6: 8a 00 mov (%eax),%al
8048ef8: 0f be c0 movsbl %al,%eax
8048efb: 83 f8 78 cmp $0x78,%eax
8048efe: 0f 84 f1 00 00 00 je 8048ff5 <vfprintf+0x138>
8048f04: 83 f8 78 cmp $0x78,%eax
8048f07: 0f 8f 35 01 00 00 jg 8049042 <vfprintf+0x185>
8048f0d: 83 f8 73 cmp $0x73,%eax
8048f10: 0f 84 b0 00 00 00 je 8048fc6 <vfprintf+0x109>
8048f16: 83 f8 73 cmp $0x73,%eax
8048f19: 0f 8f 23 01 00 00 jg 8049042 <vfprintf+0x185>
8048f1f: 83 f8 63 cmp $0x63,%eax
8048f22: 74 0a je 8048f2e <vfprintf+0x71>
8048f24: 83 f8 64 cmp $0x64,%eax
8048f27: 74 3b je 8048f64 <vfprintf+0xa7>
8048f29: e9 14 01 00 00 jmp 8049042 <vfprintf+0x185>
case 'c': {
int i=va_arg(arg,int);
8048f2e: 8b 45 10 mov 0x10(%ebp),%eax
8048f31: 8d 50 04 lea 0x4(%eax),%edx
8048f34: 89 55 10 mov %edx,0x10(%ebp)
8048f37: 8b 00 mov (%eax),%eax
8048f39: 89 45 e4 mov %eax,-0x1c(%ebp)
c=fputc(i,stream);
8048f3c: 83 ec 08 sub $0x8,%esp
8048f3f: ff 75 08 pushl 0x8(%ebp)
8048f42: ff 75 e4 pushl -0x1c(%ebp)
8048f45: e8 7e fa ff ff call 80489c8 <fputc>
8048f4a: 83 c4 10 add $0x10,%esp
8048f4d: 89 45 ec mov %eax,-0x14(%ebp)
if (c==EOF) {
8048f50: 83 7d ec ff cmpl $0xffffffff,-0x14(%ebp)
8048f54: 0f 85 e1 00 00 00 jne 804903b <vfprintf+0x17e>
return EOF;
8048f5a: b8 ff ff ff ff mov $0xffffffff,%eax
8048f5f: e9 f3 00 00 00 jmp 8049057 <vfprintf+0x19a>
}
break;
}
case 'd': {
int i=va_arg(arg,int); //Fetch Decimal/Integer argument
8048f64: 8b 45 10 mov 0x10(%ebp),%eax
8048f67: 8d 50 04 lea 0x4(%eax),%edx
8048f6a: 89 55 10 mov %edx,0x10(%ebp)
8048f6d: 8b 00 mov (%eax),%eax
8048f6f: 89 45 f4 mov %eax,-0xc(%ebp)
if(i<0) {
8048f72: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
8048f76: 79 13 jns 8048f8b <vfprintf+0xce>
i=-i;
8048f78: f7 5d f4 negl -0xc(%ebp)
fputc('-',stream);
8048f7b: 83 ec 08 sub $0x8,%esp
8048f7e: ff 75 08 pushl 0x8(%ebp)
8048f81: 6a 2d push $0x2d
8048f83: e8 40 fa ff ff call 80489c8 <fputc>
8048f88: 83 c4 10 add $0x10,%esp
}
char str[11];
int_to_ascii(i,str);
8048f8b: 83 ec 08 sub $0x8,%esp
8048f8e: 8d 45 d9 lea -0x27(%ebp),%eax
8048f91: 50 push %eax
8048f92: ff 75 f4 pushl -0xc(%ebp)
8048f95: e8 53 08 00 00 call 80497ed <int_to_ascii>
8048f9a: 83 c4 10 add $0x10,%esp
c=fputs(str,stream);
8048f9d: 83 ec 08 sub $0x8,%esp
8048fa0: ff 75 08 pushl 0x8(%ebp)
8048fa3: 8d 45 d9 lea -0x27(%ebp),%eax
8048fa6: 50 push %eax
8048fa7: e8 60 fc ff ff call 8048c0c <fputs>
8048fac: 83 c4 10 add $0x10,%esp
8048faf: 89 45 ec mov %eax,-0x14(%ebp)
if (c==EOF) {
8048fb2: 83 7d ec ff cmpl $0xffffffff,-0x14(%ebp)
8048fb6: 0f 85 82 00 00 00 jne 804903e <vfprintf+0x181>
return EOF;
8048fbc: b8 ff ff ff ff mov $0xffffffff,%eax
8048fc1: e9 91 00 00 00 jmp 8049057 <vfprintf+0x19a>
// int i=va_arg(arg,unsigned int); //Fetch Octal representation
// puts(convert(i,8));
// break;
// }
case 's': {
char* s=va_arg(arg,char*);
8048fc6: 8b 45 10 mov 0x10(%ebp),%eax
8048fc9: 8d 50 04 lea 0x4(%eax),%edx
8048fcc: 89 55 10 mov %edx,0x10(%ebp)
8048fcf: 8b 00 mov (%eax),%eax
8048fd1: 89 45 e8 mov %eax,-0x18(%ebp)
c=fputs(s,stream);
8048fd4: 83 ec 08 sub $0x8,%esp
8048fd7: ff 75 08 pushl 0x8(%ebp)
8048fda: ff 75 e8 pushl -0x18(%ebp)
8048fdd: e8 2a fc ff ff call 8048c0c <fputs>
8048fe2: 83 c4 10 add $0x10,%esp
8048fe5: 89 45 ec mov %eax,-0x14(%ebp)
if (c==EOF) {
8048fe8: 83 7d ec ff cmpl $0xffffffff,-0x14(%ebp)
8048fec: 75 53 jne 8049041 <vfprintf+0x184>
return EOF;
8048fee: b8 ff ff ff ff mov $0xffffffff,%eax
8048ff3: eb 62 jmp 8049057 <vfprintf+0x19a>
}
break;
}
case 'x': {
unsigned int i=va_arg(arg, unsigned int);
8048ff5: 8b 45 10 mov 0x10(%ebp),%eax
8048ff8: 8d 50 04 lea 0x4(%eax),%edx
8048ffb: 89 55 10 mov %edx,0x10(%ebp)
8048ffe: 8b 00 mov (%eax),%eax
8049000: 89 45 f0 mov %eax,-0x10(%ebp)
char str[11];
str[0]='\0';
8049003: c6 45 ce 00 movb $0x0,-0x32(%ebp)
hex_to_ascii(i,str);
8049007: 83 ec 08 sub $0x8,%esp
804900a: 8d 45 ce lea -0x32(%ebp),%eax
804900d: 50 push %eax
804900e: ff 75 f0 pushl -0x10(%ebp)
8049011: e8 68 08 00 00 call 804987e <hex_to_ascii>
8049016: 83 c4 10 add $0x10,%esp
c=fputs(str,stream);
8049019: 83 ec 08 sub $0x8,%esp
804901c: ff 75 08 pushl 0x8(%ebp)
804901f: 8d 45 ce lea -0x32(%ebp),%eax
8049022: 50 push %eax
8049023: e8 e4 fb ff ff call 8048c0c <fputs>
8049028: 83 c4 10 add $0x10,%esp
804902b: 89 45 ec mov %eax,-0x14(%ebp)
if (c==EOF) {
804902e: 83 7d ec ff cmpl $0xffffffff,-0x14(%ebp)
8049032: 75 0e jne 8049042 <vfprintf+0x185>
return EOF;
8049034: b8 ff ff ff ff mov $0xffffffff,%eax
8049039: eb 1c jmp 8049057 <vfprintf+0x19a>
break;
804903b: 90 nop
804903c: eb 04 jmp 8049042 <vfprintf+0x185>
break;
804903e: 90 nop
804903f: eb 01 jmp 8049042 <vfprintf+0x185>
break;
8049041: 90 nop
for(;*format!='\0';format++) {
8049042: ff 45 0c incl 0xc(%ebp)
8049045: 8b 45 0c mov 0xc(%ebp),%eax
8049048: 8a 00 mov (%eax),%al
804904a: 84 c0 test %al,%al
804904c: 0f 85 76 fe ff ff jne 8048ec8 <vfprintf+0xb>
}
break;
}
}
}
return 1;
8049052: b8 01 00 00 00 mov $0x1,%eax
}
8049057: c9 leave
8049058: c3 ret
08049059 <fprintf>:
int fprintf(FILE* stream,const char* format,...) {
8049059: 55 push %ebp
804905a: 89 e5 mov %esp,%ebp
804905c: 83 ec 18 sub $0x18,%esp
va_list arg;
int code;
va_start(arg,format);
804905f: 8d 45 10 lea 0x10(%ebp),%eax
8049062: 89 45 f0 mov %eax,-0x10(%ebp)
code=vfprintf(stream,format,arg);
8049065: 8b 45 f0 mov -0x10(%ebp),%eax
8049068: 83 ec 04 sub $0x4,%esp
804906b: 50 push %eax
804906c: ff 75 0c pushl 0xc(%ebp)
804906f: ff 75 08 pushl 0x8(%ebp)
8049072: e8 46 fe ff ff call 8048ebd <vfprintf>
8049077: 83 c4 10 add $0x10,%esp
804907a: 89 45 f4 mov %eax,-0xc(%ebp)
va_end(arg);
if (code) {
804907d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
8049081: 74 10 je 8049093 <fprintf+0x3a>
return strlen(format);
8049083: 83 ec 0c sub $0xc,%esp
8049086: ff 75 0c pushl 0xc(%ebp)
8049089: e8 95 06 00 00 call 8049723 <strlen>
804908e: 83 c4 10 add $0x10,%esp
8049091: eb 05 jmp 8049098 <fprintf+0x3f>
} else {
return EOF;
8049093: b8 ff ff ff ff mov $0xffffffff,%eax
}
}
8049098: c9 leave
8049099: c3 ret
0804909a <printf>:
int printf(const char* format,...) {
804909a: 55 push %ebp
804909b: 89 e5 mov %esp,%ebp
804909d: 83 ec 18 sub $0x18,%esp
va_list arg;
int code;
va_start(arg,format);
80490a0: 8d 45 0c lea 0xc(%ebp),%eax
80490a3: 89 45 f0 mov %eax,-0x10(%ebp)
code=vfprintf(stdout,format,arg);
80490a6: 8b 55 f0 mov -0x10(%ebp),%edx
80490a9: a1 44 b0 04 08 mov 0x804b044,%eax
80490ae: 83 ec 04 sub $0x4,%esp
80490b1: 52 push %edx
80490b2: ff 75 08 pushl 0x8(%ebp)
80490b5: 50 push %eax
80490b6: e8 02 fe ff ff call 8048ebd <vfprintf>
80490bb: 83 c4 10 add $0x10,%esp
80490be: 89 45 f4 mov %eax,-0xc(%ebp)
va_end(arg);
if (code) {
80490c1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
80490c5: 74 10 je 80490d7 <printf+0x3d>
return strlen(format);
80490c7: 83 ec 0c sub $0xc,%esp
80490ca: ff 75 08 pushl 0x8(%ebp)
80490cd: e8 51 06 00 00 call 8049723 <strlen>
80490d2: 83 c4 10 add $0x10,%esp
80490d5: eb 05 jmp 80490dc <printf+0x42>
} else {
return EOF;
80490d7: b8 ff ff ff ff mov $0xffffffff,%eax
}
}
80490dc: c9 leave
80490dd: c3 ret
080490de <fseek>:
int fseek(FILE* stream,long offset,int origin) {
80490de: 55 push %ebp
80490df: 89 e5 mov %esp,%ebp
switch (origin) {
80490e1: 83 7d 10 03 cmpl $0x3,0x10(%ebp)
80490e5: 74 14 je 80490fb <fseek+0x1d>
80490e7: 83 7d 10 03 cmpl $0x3,0x10(%ebp)
80490eb: 7f 2c jg 8049119 <fseek+0x3b>
80490ed: 83 7d 10 01 cmpl $0x1,0x10(%ebp)
80490f1: 74 13 je 8049106 <fseek+0x28>
80490f3: 83 7d 10 02 cmpl $0x2,0x10(%ebp)
80490f7: 74 23 je 804911c <fseek+0x3e>
stream->pos+=offset;
break;
case SEEK_END:
break;
default:
break;
80490f9: eb 1e jmp 8049119 <fseek+0x3b>
stream->pos=offset;
80490fb: 8b 45 08 mov 0x8(%ebp),%eax
80490fe: 8b 55 0c mov 0xc(%ebp),%edx
8049101: 89 50 08 mov %edx,0x8(%eax)
break;
8049104: eb 17 jmp 804911d <fseek+0x3f>
stream->pos+=offset;
8049106: 8b 45 08 mov 0x8(%ebp),%eax
8049109: 8b 50 08 mov 0x8(%eax),%edx
804910c: 8b 45 0c mov 0xc(%ebp),%eax
804910f: 01 c2 add %eax,%edx
8049111: 8b 45 08 mov 0x8(%ebp),%eax
8049114: 89 50 08 mov %edx,0x8(%eax)
break;
8049117: eb 04 jmp 804911d <fseek+0x3f>
break;
8049119: 90 nop
804911a: eb 01 jmp 804911d <fseek+0x3f>
break;
804911c: 90 nop
}
return 0;
804911d: b8 00 00 00 00 mov $0x0,%eax
}
8049122: 5d pop %ebp
8049123: c3 ret
08049124 <get_bmap_bit>:
* Get a bit in a bitmap
* \param bmap The bitmap
* \param index The index in the bitmap
* \return the bit
*/
static char get_bmap_bit(char* bmap,size_t index) {
8049124: 55 push %ebp
8049125: 89 e5 mov %esp,%ebp
8049127: 53 push %ebx
8049128: 83 ec 10 sub $0x10,%esp
size_t byte=index/8;
804912b: 8b 45 0c mov 0xc(%ebp),%eax
804912e: c1 e8 03 shr $0x3,%eax
8049131: 89 45 f8 mov %eax,-0x8(%ebp)
size_t bit=index%8;
8049134: 8b 45 0c mov 0xc(%ebp),%eax
8049137: 83 e0 07 and $0x7,%eax
804913a: 89 45 f4 mov %eax,-0xc(%ebp)
char entry=bmap[byte];
804913d: 8b 55 08 mov 0x8(%ebp),%edx
8049140: 8b 45 f8 mov -0x8(%ebp),%eax
8049143: 01 d0 add %edx,%eax
8049145: 8a 00 mov (%eax),%al
8049147: 88 45 f3 mov %al,-0xd(%ebp)
return (entry&(1<<bit))>0;
804914a: 0f be 55 f3 movsbl -0xd(%ebp),%edx
804914e: 8b 45 f4 mov -0xc(%ebp),%eax
8049151: bb 01 00 00 00 mov $0x1,%ebx
8049156: 88 c1 mov %al,%cl
8049158: d3 e3 shl %cl,%ebx
804915a: 89 d8 mov %ebx,%eax
804915c: 21 d0 and %edx,%eax
804915e: 85 c0 test %eax,%eax
8049160: 0f 9f c0 setg %al
}
8049163: 83 c4 10 add $0x10,%esp
8049166: 5b pop %ebx
8049167: 5d pop %ebp
8049168: c3 ret
08049169 <set_bmap_bit>:
/**
* Set a bit in a bitmap
* \param bmap The bitmap
* \param index The index in the bitmap
*/
static void set_bmap_bit(char* bmap,size_t index) {
8049169: 55 push %ebp
804916a: 89 e5 mov %esp,%ebp
804916c: 53 push %ebx
804916d: 83 ec 10 sub $0x10,%esp
size_t byte=index/8;
8049170: 8b 45 0c mov 0xc(%ebp),%eax
8049173: c1 e8 03 shr $0x3,%eax
8049176: 89 45 f8 mov %eax,-0x8(%ebp)
size_t bit=index%8;
8049179: 8b 45 0c mov 0xc(%ebp),%eax
804917c: 83 e0 07 and $0x7,%eax
804917f: 89 45 f4 mov %eax,-0xc(%ebp)
bmap[byte]=bmap[byte]|(1<<bit);
8049182: 8b 55 08 mov 0x8(%ebp),%edx
8049185: 8b 45 f8 mov -0x8(%ebp),%eax
8049188: 01 d0 add %edx,%eax
804918a: 8a 10 mov (%eax),%dl
804918c: 8b 45 f4 mov -0xc(%ebp),%eax
804918f: bb 01 00 00 00 mov $0x1,%ebx
8049194: 88 c1 mov %al,%cl
8049196: d3 e3 shl %cl,%ebx
8049198: 89 d8 mov %ebx,%eax
804919a: 88 c3 mov %al,%bl
804919c: 8b 4d 08 mov 0x8(%ebp),%ecx
804919f: 8b 45 f8 mov -0x8(%ebp),%eax
80491a2: 01 c8 add %ecx,%eax
80491a4: 09 da or %ebx,%edx
80491a6: 88 10 mov %dl,(%eax)
}
80491a8: 90 nop
80491a9: 83 c4 10 add $0x10,%esp
80491ac: 5b pop %ebx
80491ad: 5d pop %ebp
80491ae: c3 ret
080491af <clear_bmap_bit>:
/**
* Clear a bit in a bitmap
* \param bmap The bitmap
* \param index The index in the bitmap
*/
static void clear_bmap_bit(char* bmap,size_t index) {
80491af: 55 push %ebp
80491b0: 89 e5 mov %esp,%ebp
80491b2: 53 push %ebx
80491b3: 83 ec 10 sub $0x10,%esp
size_t byte=index/8;
80491b6: 8b 45 0c mov 0xc(%ebp),%eax
80491b9: c1 e8 03 shr $0x3,%eax
80491bc: 89 45 f8 mov %eax,-0x8(%ebp)
size_t bit=index%8;
80491bf: 8b 45 0c mov 0xc(%ebp),%eax
80491c2: 83 e0 07 and $0x7,%eax
80491c5: 89 45 f4 mov %eax,-0xc(%ebp)
bmap[byte]=bmap[byte]&(~(1<<bit));
80491c8: 8b 55 08 mov 0x8(%ebp),%edx
80491cb: 8b 45 f8 mov -0x8(%ebp),%eax
80491ce: 01 d0 add %edx,%eax
80491d0: 8a 10 mov (%eax),%dl
80491d2: 8b 45 f4 mov -0xc(%ebp),%eax
80491d5: bb 01 00 00 00 mov $0x1,%ebx
80491da: 88 c1 mov %al,%cl
80491dc: d3 e3 shl %cl,%ebx
80491de: 89 d8 mov %ebx,%eax
80491e0: f7 d0 not %eax
80491e2: 88 c3 mov %al,%bl
80491e4: 8b 4d 08 mov 0x8(%ebp),%ecx
80491e7: 8b 45 f8 mov -0x8(%ebp),%eax
80491ea: 01 c8 add %ecx,%eax
80491ec: 21 da and %ebx,%edx
80491ee: 88 10 mov %dl,(%eax)
}
80491f0: 90 nop
80491f1: 83 c4 10 add $0x10,%esp
80491f4: 5b pop %ebx
80491f5: 5d pop %ebp
80491f6: c3 ret
080491f7 <reserve_block>:
/**
* Add a block to the heap
* \param mem_blks The number of pages that this block will use
*/
static void reserve_block(size_t mem_blks) {
80491f7: 55 push %ebp
80491f8: 89 e5 mov %esp,%ebp
80491fa: 53 push %ebx
80491fb: 83 ec 24 sub $0x24,%esp
size_t bmap_byts=((mem_blks*BLK_SZ)/4)/8;
80491fe: 8b 45 08 mov 0x8(%ebp),%eax
8049201: c1 e0 0c shl $0xc,%eax
8049204: c1 e8 05 shr $0x5,%eax
8049207: 89 45 f0 mov %eax,-0x10(%ebp)
entries[num_used_entries].bitmap=alloc_memory((size_t)ceilf((double)bmap_byts/BLK_SZ));
804920a: 8b 45 f0 mov -0x10(%ebp),%eax
804920d: ba 00 00 00 00 mov $0x0,%edx
8049212: 89 45 d8 mov %eax,-0x28(%ebp)
8049215: 89 55 dc mov %edx,-0x24(%ebp)
8049218: df 6d d8 fildll -0x28(%ebp)
804921b: dd 05 d8 9f 04 08 fldl 0x8049fd8
8049221: de f9 fdivrp %st,%st(1)
8049223: d9 5d d8 fstps -0x28(%ebp)
8049226: 8b 45 d8 mov -0x28(%ebp),%eax
8049229: 83 ec 0c sub $0xc,%esp
804922c: 50 push %eax
804922d: e8 c0 0b 00 00 call 8049df2 <ceilf>
8049232: 83 c4 10 add $0x10,%esp
8049235: d9 7d e6 fnstcw -0x1a(%ebp)
8049238: 66 8b 45 e6 mov -0x1a(%ebp),%ax
804923c: 80 cc 0c or $0xc,%ah
804923f: 66 89 45 e4 mov %ax,-0x1c(%ebp)
8049243: d9 6d e4 fldcw -0x1c(%ebp)
8049246: df 7d d8 fistpll -0x28(%ebp)
8049249: d9 6d e6 fldcw -0x1a(%ebp)
804924c: 8b 45 d8 mov -0x28(%ebp),%eax
804924f: 8b 1d 60 d8 04 08 mov 0x804d860,%ebx
8049255: 83 ec 0c sub $0xc,%esp
8049258: 50 push %eax
8049259: e8 7b f5 ff ff call 80487d9 <alloc_memory>
804925e: 83 c4 10 add $0x10,%esp
8049261: 89 c2 mov %eax,%edx
8049263: 89 d8 mov %ebx,%eax
8049265: c1 e0 02 shl $0x2,%eax
8049268: 01 d8 add %ebx,%eax
804926a: c1 e0 02 shl $0x2,%eax
804926d: 05 60 b0 04 08 add $0x804b060,%eax
8049272: 89 10 mov %edx,(%eax)
entries[num_used_entries].bitmap_byt_size=bmap_byts;
8049274: 8b 15 60 d8 04 08 mov 0x804d860,%edx
804927a: 89 d0 mov %edx,%eax
804927c: c1 e0 02 shl $0x2,%eax
804927f: 01 d0 add %edx,%eax
8049281: c1 e0 02 shl $0x2,%eax
8049284: 8d 90 64 b0 04 08 lea 0x804b064(%eax),%edx
804928a: 8b 45 f0 mov -0x10(%ebp),%eax
804928d: 89 02 mov %eax,(%edx)
entries[num_used_entries].bitmap_bit_size=bmap_byts*8;
804928f: 8b 15 60 d8 04 08 mov 0x804d860,%edx
8049295: 8b 45 f0 mov -0x10(%ebp),%eax
8049298: 8d 0c c5 00 00 00 00 lea 0x0(,%eax,8),%ecx
804929f: 89 d0 mov %edx,%eax
80492a1: c1 e0 02 shl $0x2,%eax
80492a4: 01 d0 add %edx,%eax
80492a6: c1 e0 02 shl $0x2,%eax
80492a9: 05 68 b0 04 08 add $0x804b068,%eax
80492ae: 89 08 mov %ecx,(%eax)
char* bmap=entries[num_used_entries].bitmap;
80492b0: 8b 15 60 d8 04 08 mov 0x804d860,%edx
80492b6: 89 d0 mov %edx,%eax
80492b8: c1 e0 02 shl $0x2,%eax
80492bb: 01 d0 add %edx,%eax
80492bd: c1 e0 02 shl $0x2,%eax
80492c0: 05 60 b0 04 08 add $0x804b060,%eax
80492c5: 8b 00 mov (%eax),%eax
80492c7: 89 45 ec mov %eax,-0x14(%ebp)
size_t bmap_byt_sz=entries[num_used_entries].bitmap_byt_size;
80492ca: 8b 15 60 d8 04 08 mov 0x804d860,%edx
80492d0: 89 d0 mov %edx,%eax
80492d2: c1 e0 02 shl $0x2,%eax
80492d5: 01 d0 add %edx,%eax
80492d7: c1 e0 02 shl $0x2,%eax
80492da: 05 64 b0 04 08 add $0x804b064,%eax
80492df: 8b 00 mov (%eax),%eax
80492e1: 89 45 e8 mov %eax,-0x18(%ebp)
for(size_t i=0;i<bmap_byt_sz;i++) {
80492e4: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
80492eb: eb 0e jmp 80492fb <reserve_block+0x104>
bmap[i]=0;
80492ed: 8b 55 ec mov -0x14(%ebp),%edx
80492f0: 8b 45 f4 mov -0xc(%ebp),%eax
80492f3: 01 d0 add %edx,%eax
80492f5: c6 00 00 movb $0x0,(%eax)
for(size_t i=0;i<bmap_byt_sz;i++) {
80492f8: ff 45 f4 incl -0xc(%ebp)
80492fb: 8b 45 f4 mov -0xc(%ebp),%eax
80492fe: 3b 45 e8 cmp -0x18(%ebp),%eax
8049301: 72 ea jb 80492ed <reserve_block+0xf6>
}
entries[num_used_entries].avail_data_size=mem_blks*BLK_SZ;
8049303: 8b 15 60 d8 04 08 mov 0x804d860,%edx
8049309: 8b 45 08 mov 0x8(%ebp),%eax
804930c: c1 e0 0c shl $0xc,%eax
804930f: 89 c1 mov %eax,%ecx
8049311: 89 d0 mov %edx,%eax
8049313: c1 e0 02 shl $0x2,%eax
8049316: 01 d0 add %edx,%eax
8049318: c1 e0 02 shl $0x2,%eax
804931b: 05 6c b0 04 08 add $0x804b06c,%eax
8049320: 89 08 mov %ecx,(%eax)
entries[num_used_entries].data_block=alloc_memory(mem_blks);
8049322: 8b 45 08 mov 0x8(%ebp),%eax
8049325: 8b 1d 60 d8 04 08 mov 0x804d860,%ebx
804932b: 83 ec 0c sub $0xc,%esp
804932e: 50 push %eax
804932f: e8 a5 f4 ff ff call 80487d9 <alloc_memory>
8049334: 83 c4 10 add $0x10,%esp
8049337: 89 c2 mov %eax,%edx
8049339: 89 d8 mov %ebx,%eax
804933b: c1 e0 02 shl $0x2,%eax
804933e: 01 d8 add %ebx,%eax
8049340: c1 e0 02 shl $0x2,%eax
8049343: 05 70 b0 04 08 add $0x804b070,%eax
8049348: 89 10 mov %edx,(%eax)
num_used_entries++;
804934a: a1 60 d8 04 08 mov 0x804d860,%eax
804934f: 40 inc %eax
8049350: a3 60 d8 04 08 mov %eax,0x804d860
}
8049355: 90 nop
8049356: 8b 5d fc mov -0x4(%ebp),%ebx
8049359: c9 leave
804935a: c3 ret
0804935b <malloc>:
void* malloc(size_t size) {
804935b: 55 push %ebp
804935c: 89 e5 mov %esp,%ebp
804935e: 57 push %edi
804935f: 56 push %esi
8049360: 53 push %ebx
8049361: 83 ec 6c sub $0x6c,%esp
size_t num_4b_grps=(size_t)ceilf((float)size/4);
8049364: 8b 45 08 mov 0x8(%ebp),%eax
8049367: ba 00 00 00 00 mov $0x0,%edx
804936c: 89 45 88 mov %eax,-0x78(%ebp)
804936f: 89 55 8c mov %edx,-0x74(%ebp)
8049372: df 6d 88 fildll -0x78(%ebp)
8049375: d9 05 e0 9f 04 08 flds 0x8049fe0
804937b: de f9 fdivrp %st,%st(1)
804937d: 83 ec 0c sub $0xc,%esp
8049380: 8d 64 24 fc lea -0x4(%esp),%esp
8049384: d9 1c 24 fstps (%esp)
8049387: e8 66 0a 00 00 call 8049df2 <ceilf>
804938c: 83 c4 10 add $0x10,%esp
804938f: d9 7d 96 fnstcw -0x6a(%ebp)
8049392: 66 8b 45 96 mov -0x6a(%ebp),%ax
8049396: 80 cc 0c or $0xc,%ah
8049399: 66 89 45 94 mov %ax,-0x6c(%ebp)
804939d: d9 6d 94 fldcw -0x6c(%ebp)
80493a0: df 7d 88 fistpll -0x78(%ebp)
80493a3: d9 6d 96 fldcw -0x6a(%ebp)
80493a6: 8b 45 88 mov -0x78(%ebp),%eax
80493a9: 89 45 c0 mov %eax,-0x40(%ebp)
num_4b_grps+=3;
80493ac: 83 45 c0 03 addl $0x3,-0x40(%ebp)
int blk_indx=-1;
80493b0: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp)
size_t bmap_index;
heap_block entry;
for (size_t i=0;i<num_used_entries;i++) {
80493b7: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
80493be: e9 ec 00 00 00 jmp 80494af <malloc+0x154>
size_t remaining_blks;
entry=entries[i];
80493c3: 8b 55 dc mov -0x24(%ebp),%edx
80493c6: 89 d0 mov %edx,%eax
80493c8: c1 e0 02 shl $0x2,%eax
80493cb: 01 d0 add %edx,%eax
80493cd: c1 e0 02 shl $0x2,%eax
80493d0: 8d 90 60 b0 04 08 lea 0x804b060(%eax),%edx
80493d6: 8d 45 98 lea -0x68(%ebp),%eax
80493d9: 89 d3 mov %edx,%ebx
80493db: ba 05 00 00 00 mov $0x5,%edx
80493e0: 89 c7 mov %eax,%edi
80493e2: 89 de mov %ebx,%esi
80493e4: 89 d1 mov %edx,%ecx
80493e6: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if (entry.avail_data_size>=size) {
80493e8: 8b 45 a4 mov -0x5c(%ebp),%eax
80493eb: 39 45 08 cmp %eax,0x8(%ebp)
80493ee: 0f 87 aa 00 00 00 ja 804949e <malloc+0x143>
char* bmap=entry.bitmap;
80493f4: 8b 45 98 mov -0x68(%ebp),%eax
80493f7: 89 45 bc mov %eax,-0x44(%ebp)
size_t bmap_byt_sz=entry.bitmap_byt_size;
80493fa: 8b 45 9c mov -0x64(%ebp),%eax
80493fd: 89 45 b8 mov %eax,-0x48(%ebp)
for(size_t i=0;i<bmap_byt_sz;i++) {
8049400: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
8049407: e9 83 00 00 00 jmp 804948f <malloc+0x134>
char got_0=0;
804940c: c6 45 d3 00 movb $0x0,-0x2d(%ebp)
remaining_blks=num_4b_grps;
8049410: 8b 45 c0 mov -0x40(%ebp),%eax
8049413: 89 45 d8 mov %eax,-0x28(%ebp)
size_t old_j;
for (size_t j=i*8;;j++) {
8049416: 8b 45 d4 mov -0x2c(%ebp),%eax
8049419: c1 e0 03 shl $0x3,%eax
804941c: 89 45 c8 mov %eax,-0x38(%ebp)
char bit=get_bmap_bit(bmap,j);
804941f: 83 ec 08 sub $0x8,%esp
8049422: ff 75 c8 pushl -0x38(%ebp)
8049425: ff 75 bc pushl -0x44(%ebp)
8049428: e8 f7 fc ff ff call 8049124 <get_bmap_bit>
804942d: 83 c4 10 add $0x10,%esp
8049430: 88 45 b7 mov %al,-0x49(%ebp)
if (got_0) {
8049433: 80 7d d3 00 cmpb $0x0,-0x2d(%ebp)
8049437: 74 27 je 8049460 <malloc+0x105>
if (bit) {
8049439: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
804943d: 74 1c je 804945b <malloc+0x100>
if (remaining_blks==0) {
804943f: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
8049443: 75 08 jne 804944d <malloc+0xf2>
bmap_index=old_j;
8049445: 8b 45 cc mov -0x34(%ebp),%eax
8049448: 89 45 e0 mov %eax,-0x20(%ebp)
break;
804944b: eb 39 jmp 8049486 <malloc+0x12b>
} else {
i+=j/8;
804944d: 8b 45 c8 mov -0x38(%ebp),%eax
8049450: c1 e8 03 shr $0x3,%eax
8049453: 01 45 d4 add %eax,-0x2c(%ebp)
i--;
8049456: ff 4d d4 decl -0x2c(%ebp)
break;
8049459: eb 2b jmp 8049486 <malloc+0x12b>
}
} else {
remaining_blks--;
804945b: ff 4d d8 decl -0x28(%ebp)
804945e: eb 13 jmp 8049473 <malloc+0x118>
}
} else {
if (!bit) {
8049460: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
8049464: 75 0d jne 8049473 <malloc+0x118>
got_0=1;
8049466: c6 45 d3 01 movb $0x1,-0x2d(%ebp)
old_j=j;
804946a: 8b 45 c8 mov -0x38(%ebp),%eax
804946d: 89 45 cc mov %eax,-0x34(%ebp)
remaining_blks--;
8049470: ff 4d d8 decl -0x28(%ebp)
}
}
if (remaining_blks==0) {
8049473: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
8049477: 75 08 jne 8049481 <malloc+0x126>
bmap_index=old_j;
8049479: 8b 45 cc mov -0x34(%ebp),%eax
804947c: 89 45 e0 mov %eax,-0x20(%ebp)
break;
804947f: eb 05 jmp 8049486 <malloc+0x12b>
for (size_t j=i*8;;j++) {
8049481: ff 45 c8 incl -0x38(%ebp)
8049484: eb 99 jmp 804941f <malloc+0xc4>
}
}
if (remaining_blks==0) {
8049486: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
804948a: 74 11 je 804949d <malloc+0x142>
for(size_t i=0;i<bmap_byt_sz;i++) {
804948c: ff 45 d4 incl -0x2c(%ebp)
804948f: 8b 45 d4 mov -0x2c(%ebp),%eax
8049492: 3b 45 b8 cmp -0x48(%ebp),%eax
8049495: 0f 82 71 ff ff ff jb 804940c <malloc+0xb1>
804949b: eb 01 jmp 804949e <malloc+0x143>
break;
804949d: 90 nop
}
}
}
if (remaining_blks==0) {
804949e: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
80494a2: 75 08 jne 80494ac <malloc+0x151>
blk_indx=i;
80494a4: 8b 45 dc mov -0x24(%ebp),%eax
80494a7: 89 45 e4 mov %eax,-0x1c(%ebp)
break;
80494aa: eb 11 jmp 80494bd <malloc+0x162>
for (size_t i=0;i<num_used_entries;i++) {
80494ac: ff 45 dc incl -0x24(%ebp)
80494af: a1 60 d8 04 08 mov 0x804d860,%eax
80494b4: 39 45 dc cmp %eax,-0x24(%ebp)
80494b7: 0f 82 06 ff ff ff jb 80493c3 <malloc+0x68>
}
}
if (blk_indx==-1) {
80494bd: 83 7d e4 ff cmpl $0xffffffff,-0x1c(%ebp)
80494c1: 75 20 jne 80494e3 <malloc+0x188>
// reserve_block((size_t)ceilf((double)size/BLK_SZ));
reserve_block(1024);
80494c3: 83 ec 0c sub $0xc,%esp
80494c6: 68 00 04 00 00 push $0x400
80494cb: e8 27 fd ff ff call 80491f7 <reserve_block>
80494d0: 83 c4 10 add $0x10,%esp
return malloc(size);
80494d3: 83 ec 0c sub $0xc,%esp
80494d6: ff 75 08 pushl 0x8(%ebp)
80494d9: e8 7d fe ff ff call 804935b <malloc>
80494de: 83 c4 10 add $0x10,%esp
80494e1: eb 78 jmp 804955b <malloc+0x200>
}
for (size_t i=0;i<num_4b_grps;i++) {
80494e3: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
80494ea: eb 1b jmp 8049507 <malloc+0x1ac>
set_bmap_bit(entry.bitmap,bmap_index+i);
80494ec: 8b 55 e0 mov -0x20(%ebp),%edx
80494ef: 8b 45 c4 mov -0x3c(%ebp),%eax
80494f2: 01 c2 add %eax,%edx
80494f4: 8b 45 98 mov -0x68(%ebp),%eax
80494f7: 83 ec 08 sub $0x8,%esp
80494fa: 52 push %edx
80494fb: 50 push %eax
80494fc: e8 68 fc ff ff call 8049169 <set_bmap_bit>
8049501: 83 c4 10 add $0x10,%esp
for (size_t i=0;i<num_4b_grps;i++) {
8049504: ff 45 c4 incl -0x3c(%ebp)
8049507: 8b 45 c4 mov -0x3c(%ebp),%eax
804950a: 3b 45 c0 cmp -0x40(%ebp),%eax
804950d: 72 dd jb 80494ec <malloc+0x191>
}
size_t data_offset=(bmap_index*8)+12;
804950f: 8b 45 e0 mov -0x20(%ebp),%eax
8049512: c1 e0 03 shl $0x3,%eax
8049515: 83 c0 0c add $0xc,%eax
8049518: 89 45 b0 mov %eax,-0x50(%ebp)
size_t* info=(void*)(((char*)entry.data_block)+data_offset-12);
804951b: 8b 45 a8 mov -0x58(%ebp),%eax
804951e: 8b 55 b0 mov -0x50(%ebp),%edx
8049521: 83 ea 0c sub $0xc,%edx
8049524: 01 d0 add %edx,%eax
8049526: 89 45 ac mov %eax,-0x54(%ebp)
info[0]=num_4b_grps;
8049529: 8b 45 ac mov -0x54(%ebp),%eax
804952c: 8b 55 c0 mov -0x40(%ebp),%edx
804952f: 89 10 mov %edx,(%eax)
info[1]=bmap_index;
8049531: 8b 45 ac mov -0x54(%ebp),%eax
8049534: 8d 50 04 lea 0x4(%eax),%edx
8049537: 8b 45 e0 mov -0x20(%ebp),%eax
804953a: 89 02 mov %eax,(%edx)
info[2]=blk_indx;
804953c: 8b 45 ac mov -0x54(%ebp),%eax
804953f: 8d 50 08 lea 0x8(%eax),%edx
8049542: 8b 45 e4 mov -0x1c(%ebp),%eax
8049545: 89 02 mov %eax,(%edx)
entry.avail_data_size-=size+12;
8049547: 8b 45 a4 mov -0x5c(%ebp),%eax
804954a: 2b 45 08 sub 0x8(%ebp),%eax
804954d: 83 e8 0c sub $0xc,%eax
8049550: 89 45 a4 mov %eax,-0x5c(%ebp)
return (void*)(((char*)entry.data_block)+data_offset);
8049553: 8b 55 a8 mov -0x58(%ebp),%edx
8049556: 8b 45 b0 mov -0x50(%ebp),%eax
8049559: 01 d0 add %edx,%eax
}
804955b: 8d 65 f4 lea -0xc(%ebp),%esp
804955e: 5b pop %ebx
804955f: 5e pop %esi
8049560: 5f pop %edi
8049561: 5d pop %ebp
8049562: c3 ret
08049563 <realloc>:
void* realloc(void *mem, size_t new_sz) {
8049563: 55 push %ebp
8049564: 89 e5 mov %esp,%ebp
8049566: 83 ec 18 sub $0x18,%esp
void* ptr=malloc(new_sz);
8049569: 83 ec 0c sub $0xc,%esp
804956c: ff 75 0c pushl 0xc(%ebp)
804956f: e8 e7 fd ff ff call 804935b <malloc>
8049574: 83 c4 10 add $0x10,%esp
8049577: 89 45 f4 mov %eax,-0xc(%ebp)
if (mem==NULL) {
804957a: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
804957e: 75 05 jne 8049585 <realloc+0x22>
return ptr;
8049580: 8b 45 f4 mov -0xc(%ebp),%eax
8049583: eb 38 jmp 80495bd <realloc+0x5a>
}
size_t num_4b_grps=*((size_t*)((char*)mem-12));
8049585: 8b 45 08 mov 0x8(%ebp),%eax
8049588: 8b 40 f4 mov -0xc(%eax),%eax
804958b: 89 45 f0 mov %eax,-0x10(%ebp)
memcpy(ptr,mem,num_4b_grps*4);
804958e: 8b 45 f0 mov -0x10(%ebp),%eax
8049591: c1 e0 02 shl $0x2,%eax
8049594: 83 ec 04 sub $0x4,%esp
8049597: 50 push %eax
8049598: ff 75 08 pushl 0x8(%ebp)
804959b: ff 75 f4 pushl -0xc(%ebp)
804959e: e8 b0 00 00 00 call 8049653 <memcpy>
80495a3: 83 c4 10 add $0x10,%esp
free(mem);
80495a6: 83 ec 0c sub $0xc,%esp
80495a9: ff 75 08 pushl 0x8(%ebp)
80495ac: e8 0e 00 00 00 call 80495bf <free>
80495b1: 83 c4 10 add $0x10,%esp
mem=ptr;
80495b4: 8b 45 f4 mov -0xc(%ebp),%eax
80495b7: 89 45 08 mov %eax,0x8(%ebp)
return ptr;
80495ba: 8b 45 f4 mov -0xc(%ebp),%eax
}
80495bd: c9 leave
80495be: c3 ret
080495bf <free>:
void free(void* mem) {
80495bf: 55 push %ebp
80495c0: 89 e5 mov %esp,%ebp
80495c2: 57 push %edi
80495c3: 56 push %esi
80495c4: 53 push %ebx
80495c5: 83 ec 30 sub $0x30,%esp
size_t* info=(size_t*)((char*)mem-12);
80495c8: 8b 45 08 mov 0x8(%ebp),%eax
80495cb: 83 e8 0c sub $0xc,%eax
80495ce: 89 45 ec mov %eax,-0x14(%ebp)
size_t num_4b_grps=info[0];
80495d1: 8b 45 ec mov -0x14(%ebp),%eax
80495d4: 8b 00 mov (%eax),%eax
80495d6: 89 45 e8 mov %eax,-0x18(%ebp)
size_t bmap_index=info[1];
80495d9: 8b 45 ec mov -0x14(%ebp),%eax
80495dc: 8b 40 04 mov 0x4(%eax),%eax
80495df: 89 45 e4 mov %eax,-0x1c(%ebp)
size_t blk_indx=info[2];
80495e2: 8b 45 ec mov -0x14(%ebp),%eax
80495e5: 8b 40 08 mov 0x8(%eax),%eax
80495e8: 89 45 e0 mov %eax,-0x20(%ebp)
heap_block entry=entries[blk_indx];
80495eb: 8b 55 e0 mov -0x20(%ebp),%edx
80495ee: 89 d0 mov %edx,%eax
80495f0: c1 e0 02 shl $0x2,%eax
80495f3: 01 d0 add %edx,%eax
80495f5: c1 e0 02 shl $0x2,%eax
80495f8: 8d 90 60 b0 04 08 lea 0x804b060(%eax),%edx
80495fe: 8d 45 cc lea -0x34(%ebp),%eax
8049601: 89 d3 mov %edx,%ebx
8049603: ba 05 00 00 00 mov $0x5,%edx
8049608: 89 c7 mov %eax,%edi
804960a: 89 de mov %ebx,%esi
804960c: 89 d1 mov %edx,%ecx
804960e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
for (size_t i=0;i<num_4b_grps;i++) {
8049610: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
8049617: eb 18 jmp 8049631 <free+0x72>
clear_bmap_bit(entry.bitmap,bmap_index+i);
8049619: 8b 55 e4 mov -0x1c(%ebp),%edx
804961c: 8b 45 f0 mov -0x10(%ebp),%eax
804961f: 01 c2 add %eax,%edx
8049621: 8b 45 cc mov -0x34(%ebp),%eax
8049624: 52 push %edx
8049625: 50 push %eax
8049626: e8 84 fb ff ff call 80491af <clear_bmap_bit>
804962b: 83 c4 08 add $0x8,%esp
for (size_t i=0;i<num_4b_grps;i++) {
804962e: ff 45 f0 incl -0x10(%ebp)
8049631: 8b 45 f0 mov -0x10(%ebp),%eax
8049634: 3b 45 e8 cmp -0x18(%ebp),%eax
8049637: 72 e0 jb 8049619 <free+0x5a>
}
entry.avail_data_size+=(num_4b_grps*4)+12;
8049639: 8b 45 d8 mov -0x28(%ebp),%eax
804963c: 8b 55 e8 mov -0x18(%ebp),%edx
804963f: 83 c2 03 add $0x3,%edx
8049642: c1 e2 02 shl $0x2,%edx
8049645: 01 d0 add %edx,%eax
8049647: 89 45 d8 mov %eax,-0x28(%ebp)
}
804964a: 90 nop
804964b: 8d 65 f4 lea -0xc(%ebp),%esp
804964e: 5b pop %ebx
804964f: 5e pop %esi
8049650: 5f pop %edi
8049651: 5d pop %ebp
8049652: c3 ret
08049653 <memcpy>:
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
void* memcpy(void* dest_ptr,const void* source_ptr,size_t len) {
8049653: 55 push %ebp
8049654: 89 e5 mov %esp,%ebp
8049656: 83 ec 10 sub $0x10,%esp
char* source=(char*)source_ptr;
8049659: 8b 45 0c mov 0xc(%ebp),%eax
804965c: 89 45 f8 mov %eax,-0x8(%ebp)
char* dest=(char*)dest_ptr;
804965f: 8b 45 08 mov 0x8(%ebp),%eax
8049662: 89 45 f4 mov %eax,-0xc(%ebp)
for(size_t i=0;i<len;i++) {
8049665: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
804966c: eb 17 jmp 8049685 <memcpy+0x32>
dest[i]=source[i];
804966e: 8b 55 f8 mov -0x8(%ebp),%edx
8049671: 8b 45 fc mov -0x4(%ebp),%eax
8049674: 01 d0 add %edx,%eax
8049676: 8b 4d f4 mov -0xc(%ebp),%ecx
8049679: 8b 55 fc mov -0x4(%ebp),%edx
804967c: 01 ca add %ecx,%edx
804967e: 8a 00 mov (%eax),%al
8049680: 88 02 mov %al,(%edx)
for(size_t i=0;i<len;i++) {
8049682: ff 45 fc incl -0x4(%ebp)
8049685: 8b 45 fc mov -0x4(%ebp),%eax
8049688: 3b 45 10 cmp 0x10(%ebp),%eax
804968b: 72 e1 jb 804966e <memcpy+0x1b>
}
return dest_ptr;
804968d: 8b 45 08 mov 0x8(%ebp),%eax
}
8049690: c9 leave
8049691: c3 ret
08049692 <memset>:
void* memset(void *dest_ptr,int val,size_t len) {
8049692: 55 push %ebp
8049693: 89 e5 mov %esp,%ebp
8049695: 83 ec 10 sub $0x10,%esp
char* dest=(char*)dest_ptr;
8049698: 8b 45 08 mov 0x8(%ebp),%eax
804969b: 89 45 f8 mov %eax,-0x8(%ebp)
for (size_t i=0;i<len;i++){
804969e: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
80496a5: eb 10 jmp 80496b7 <memset+0x25>
dest[i]=(char)val;
80496a7: 8b 55 f8 mov -0x8(%ebp),%edx
80496aa: 8b 45 fc mov -0x4(%ebp),%eax
80496ad: 01 d0 add %edx,%eax
80496af: 8b 55 0c mov 0xc(%ebp),%edx
80496b2: 88 10 mov %dl,(%eax)
for (size_t i=0;i<len;i++){
80496b4: ff 45 fc incl -0x4(%ebp)
80496b7: 8b 45 fc mov -0x4(%ebp),%eax
80496ba: 3b 45 10 cmp 0x10(%ebp),%eax
80496bd: 72 e8 jb 80496a7 <memset+0x15>
}
return dest_ptr;
80496bf: 8b 45 08 mov 0x8(%ebp),%eax
}
80496c2: c9 leave
80496c3: c3 ret
080496c4 <strcmp>:
int strcmp(const char* s1,const char* s2) {
80496c4: 55 push %ebp
80496c5: 89 e5 mov %esp,%ebp
80496c7: 83 ec 10 sub $0x10,%esp
int i;
for (i = 0; s1[i] == s2[i]; i++) {
80496ca: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
80496d1: eb 18 jmp 80496eb <strcmp+0x27>
if (s1[i] == '\0') return 0;
80496d3: 8b 55 fc mov -0x4(%ebp),%edx
80496d6: 8b 45 08 mov 0x8(%ebp),%eax
80496d9: 01 d0 add %edx,%eax
80496db: 8a 00 mov (%eax),%al
80496dd: 84 c0 test %al,%al
80496df: 75 07 jne 80496e8 <strcmp+0x24>
80496e1: b8 00 00 00 00 mov $0x0,%eax
80496e6: eb 39 jmp 8049721 <strcmp+0x5d>
for (i = 0; s1[i] == s2[i]; i++) {
80496e8: ff 45 fc incl -0x4(%ebp)
80496eb: 8b 55 fc mov -0x4(%ebp),%edx
80496ee: 8b 45 08 mov 0x8(%ebp),%eax
80496f1: 01 d0 add %edx,%eax
80496f3: 8a 10 mov (%eax),%dl
80496f5: 8b 4d fc mov -0x4(%ebp),%ecx
80496f8: 8b 45 0c mov 0xc(%ebp),%eax
80496fb: 01 c8 add %ecx,%eax
80496fd: 8a 00 mov (%eax),%al
80496ff: 38 c2 cmp %al,%dl
8049701: 74 d0 je 80496d3 <strcmp+0xf>
}
return s1[i] - s2[i];
8049703: 8b 55 fc mov -0x4(%ebp),%edx
8049706: 8b 45 08 mov 0x8(%ebp),%eax
8049709: 01 d0 add %edx,%eax
804970b: 8a 00 mov (%eax),%al
804970d: 0f be d0 movsbl %al,%edx
8049710: 8b 4d fc mov -0x4(%ebp),%ecx
8049713: 8b 45 0c mov 0xc(%ebp),%eax
8049716: 01 c8 add %ecx,%eax
8049718: 8a 00 mov (%eax),%al
804971a: 0f be c0 movsbl %al,%eax
804971d: 29 c2 sub %eax,%edx
804971f: 89 d0 mov %edx,%eax
}
8049721: c9 leave
8049722: c3 ret
08049723 <strlen>:
size_t strlen(const char* str) {
8049723: 55 push %ebp
8049724: 89 e5 mov %esp,%ebp
8049726: 83 ec 10 sub $0x10,%esp
size_t i;
for (i=0;str[i]!='\0';i++);
8049729: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
8049730: eb 03 jmp 8049735 <strlen+0x12>
8049732: ff 45 fc incl -0x4(%ebp)
8049735: 8b 55 08 mov 0x8(%ebp),%edx
8049738: 8b 45 fc mov -0x4(%ebp),%eax
804973b: 01 d0 add %edx,%eax
804973d: 8a 00 mov (%eax),%al
804973f: 84 c0 test %al,%al
8049741: 75 ef jne 8049732 <strlen+0xf>
return i;
8049743: 8b 45 fc mov -0x4(%ebp),%eax
}
8049746: c9 leave
8049747: c3 ret
08049748 <strcpy>:
char* strcpy(char* dest,const char* src) {
8049748: 55 push %ebp
8049749: 89 e5 mov %esp,%ebp
804974b: 83 ec 10 sub $0x10,%esp
size_t i;
for (i=0;i<strlen(src);i++) {
804974e: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
8049755: eb 17 jmp 804976e <strcpy+0x26>
dest[i]=src[i];
8049757: 8b 55 0c mov 0xc(%ebp),%edx
804975a: 8b 45 fc mov -0x4(%ebp),%eax
804975d: 01 d0 add %edx,%eax
804975f: 8b 4d 08 mov 0x8(%ebp),%ecx
8049762: 8b 55 fc mov -0x4(%ebp),%edx
8049765: 01 ca add %ecx,%edx
8049767: 8a 00 mov (%eax),%al
8049769: 88 02 mov %al,(%edx)
for (i=0;i<strlen(src);i++) {
804976b: ff 45 fc incl -0x4(%ebp)
804976e: ff 75 0c pushl 0xc(%ebp)
8049771: e8 ad ff ff ff call 8049723 <strlen>
8049776: 83 c4 04 add $0x4,%esp
8049779: 39 45 fc cmp %eax,-0x4(%ebp)
804977c: 72 d9 jb 8049757 <strcpy+0xf>
}
dest[i]='\0';
804977e: 8b 55 08 mov 0x8(%ebp),%edx
8049781: 8b 45 fc mov -0x4(%ebp),%eax
8049784: 01 d0 add %edx,%eax
8049786: c6 00 00 movb $0x0,(%eax)
return dest;
8049789: 8b 45 08 mov 0x8(%ebp),%eax
}
804978c: c9 leave
804978d: c3 ret
0804978e <strrev>:
char* strrev(char* str) {
804978e: 55 push %ebp
804978f: 89 e5 mov %esp,%ebp
8049791: 83 ec 10 sub $0x10,%esp
char chr;
int i,j;
for (i=0,j=strlen(str)-1;i<j;i++,j--) {
8049794: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
804979b: ff 75 08 pushl 0x8(%ebp)
804979e: e8 80 ff ff ff call 8049723 <strlen>
80497a3: 83 c4 04 add $0x4,%esp
80497a6: 48 dec %eax
80497a7: 89 45 f8 mov %eax,-0x8(%ebp)
80497aa: eb 34 jmp 80497e0 <strrev+0x52>
chr=str[i];
80497ac: 8b 55 fc mov -0x4(%ebp),%edx
80497af: 8b 45 08 mov 0x8(%ebp),%eax
80497b2: 01 d0 add %edx,%eax
80497b4: 8a 00 mov (%eax),%al
80497b6: 88 45 f7 mov %al,-0x9(%ebp)
str[i]=str[j];
80497b9: 8b 55 f8 mov -0x8(%ebp),%edx
80497bc: 8b 45 08 mov 0x8(%ebp),%eax
80497bf: 01 d0 add %edx,%eax
80497c1: 8b 4d fc mov -0x4(%ebp),%ecx
80497c4: 8b 55 08 mov 0x8(%ebp),%edx
80497c7: 01 ca add %ecx,%edx
80497c9: 8a 00 mov (%eax),%al
80497cb: 88 02 mov %al,(%edx)
str[j]=chr;
80497cd: 8b 55 f8 mov -0x8(%ebp),%edx
80497d0: 8b 45 08 mov 0x8(%ebp),%eax
80497d3: 01 c2 add %eax,%edx
80497d5: 8a 45 f7 mov -0x9(%ebp),%al
80497d8: 88 02 mov %al,(%edx)
for (i=0,j=strlen(str)-1;i<j;i++,j--) {
80497da: ff 45 fc incl -0x4(%ebp)
80497dd: ff 4d f8 decl -0x8(%ebp)
80497e0: 8b 45 fc mov -0x4(%ebp),%eax
80497e3: 3b 45 f8 cmp -0x8(%ebp),%eax
80497e6: 7c c4 jl 80497ac <strrev+0x1e>
}
return str;
80497e8: 8b 45 08 mov 0x8(%ebp),%eax
}
80497eb: c9 leave
80497ec: c3 ret
080497ed <int_to_ascii>:
void int_to_ascii(int n,char* str) {
80497ed: 55 push %ebp
80497ee: 89 e5 mov %esp,%ebp
80497f0: 83 ec 10 sub $0x10,%esp
int i;
int sign;
if ((sign = n)<0) {
80497f3: 8b 45 08 mov 0x8(%ebp),%eax
80497f6: 89 45 f8 mov %eax,-0x8(%ebp)
80497f9: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
80497fd: 79 03 jns 8049802 <int_to_ascii+0x15>
n=-n;
80497ff: f7 5d 08 negl 0x8(%ebp)
}
i=0;
8049802: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
do {
str[i++]=n%10+'0';
8049809: 8b 45 08 mov 0x8(%ebp),%eax
804980c: b9 0a 00 00 00 mov $0xa,%ecx
8049811: 99 cltd
8049812: f7 f9 idiv %ecx
8049814: 89 d0 mov %edx,%eax
8049816: 8d 48 30 lea 0x30(%eax),%ecx
8049819: 8b 45 fc mov -0x4(%ebp),%eax
804981c: 8d 50 01 lea 0x1(%eax),%edx
804981f: 89 55 fc mov %edx,-0x4(%ebp)
8049822: 89 c2 mov %eax,%edx
8049824: 8b 45 0c mov 0xc(%ebp),%eax
8049827: 01 d0 add %edx,%eax
8049829: 88 ca mov %cl,%dl
804982b: 88 10 mov %dl,(%eax)
} while ((n /= 10) > 0);
804982d: 8b 4d 08 mov 0x8(%ebp),%ecx
8049830: b8 67 66 66 66 mov $0x66666667,%eax
8049835: f7 e9 imul %ecx
8049837: c1 fa 02 sar $0x2,%edx
804983a: 89 c8 mov %ecx,%eax
804983c: c1 f8 1f sar $0x1f,%eax
804983f: 29 c2 sub %eax,%edx
8049841: 89 d0 mov %edx,%eax
8049843: 89 45 08 mov %eax,0x8(%ebp)
8049846: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
804984a: 7f bd jg 8049809 <int_to_ascii+0x1c>
if (sign < 0) {
804984c: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
8049850: 79 13 jns 8049865 <int_to_ascii+0x78>
str[i++] = '-';
8049852: 8b 45 fc mov -0x4(%ebp),%eax
8049855: 8d 50 01 lea 0x1(%eax),%edx
8049858: 89 55 fc mov %edx,-0x4(%ebp)
804985b: 89 c2 mov %eax,%edx
804985d: 8b 45 0c mov 0xc(%ebp),%eax
8049860: 01 d0 add %edx,%eax
8049862: c6 00 2d movb $0x2d,(%eax)
}
str[i]='\0';
8049865: 8b 55 fc mov -0x4(%ebp),%edx
8049868: 8b 45 0c mov 0xc(%ebp),%eax
804986b: 01 d0 add %edx,%eax
804986d: c6 00 00 movb $0x0,(%eax)
strrev(str);
8049870: ff 75 0c pushl 0xc(%ebp)
8049873: e8 16 ff ff ff call 804978e <strrev>
8049878: 83 c4 04 add $0x4,%esp
}
804987b: 90 nop
804987c: c9 leave
804987d: c3 ret
0804987e <hex_to_ascii>:
void hex_to_ascii(unsigned int n, char* str) {
804987e: 55 push %ebp
804987f: 89 e5 mov %esp,%ebp
8049881: 83 ec 18 sub $0x18,%esp
str[0]='\0';
8049884: 8b 45 0c mov 0xc(%ebp),%eax
8049887: c6 00 00 movb $0x0,(%eax)
append(str, '0');
804988a: 83 ec 08 sub $0x8,%esp
804988d: 6a 30 push $0x30
804988f: ff 75 0c pushl 0xc(%ebp)
8049892: e8 cb 00 00 00 call 8049962 <append>
8049897: 83 c4 10 add $0x10,%esp
append(str, 'x');
804989a: 83 ec 08 sub $0x8,%esp
804989d: 6a 78 push $0x78
804989f: ff 75 0c pushl 0xc(%ebp)
80498a2: e8 bb 00 00 00 call 8049962 <append>
80498a7: 83 c4 10 add $0x10,%esp
char zeros = 0;
80498aa: c6 45 f7 00 movb $0x0,-0x9(%ebp)
unsigned int tmp;
int i;
for (i = 28; i > 0; i -= 4) {
80498ae: c7 45 f0 1c 00 00 00 movl $0x1c,-0x10(%ebp)
80498b5: eb 61 jmp 8049918 <hex_to_ascii+0x9a>
tmp = (n >> i) & 0xF;
80498b7: 8b 45 f0 mov -0x10(%ebp),%eax
80498ba: 8b 55 08 mov 0x8(%ebp),%edx
80498bd: 88 c1 mov %al,%cl
80498bf: d3 ea shr %cl,%edx
80498c1: 89 d0 mov %edx,%eax
80498c3: 83 e0 0f and $0xf,%eax
80498c6: 89 45 ec mov %eax,-0x14(%ebp)
if (tmp == 0 && zeros == 0) continue;
80498c9: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
80498cd: 75 06 jne 80498d5 <hex_to_ascii+0x57>
80498cf: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
80498d3: 74 3e je 8049913 <hex_to_ascii+0x95>
zeros = 1;
80498d5: c6 45 f7 01 movb $0x1,-0x9(%ebp)
if (tmp >= 0xA) append(str, tmp - 0xA + 'a');
80498d9: 83 7d ec 09 cmpl $0x9,-0x14(%ebp)
80498dd: 76 1a jbe 80498f9 <hex_to_ascii+0x7b>
80498df: 8b 45 ec mov -0x14(%ebp),%eax
80498e2: 83 c0 57 add $0x57,%eax
80498e5: 0f be c0 movsbl %al,%eax
80498e8: 83 ec 08 sub $0x8,%esp
80498eb: 50 push %eax
80498ec: ff 75 0c pushl 0xc(%ebp)
80498ef: e8 6e 00 00 00 call 8049962 <append>
80498f4: 83 c4 10 add $0x10,%esp
80498f7: eb 1b jmp 8049914 <hex_to_ascii+0x96>
else append(str, tmp + '0');
80498f9: 8b 45 ec mov -0x14(%ebp),%eax
80498fc: 83 c0 30 add $0x30,%eax
80498ff: 0f be c0 movsbl %al,%eax
8049902: 83 ec 08 sub $0x8,%esp
8049905: 50 push %eax
8049906: ff 75 0c pushl 0xc(%ebp)
8049909: e8 54 00 00 00 call 8049962 <append>
804990e: 83 c4 10 add $0x10,%esp
8049911: eb 01 jmp 8049914 <hex_to_ascii+0x96>
if (tmp == 0 && zeros == 0) continue;
8049913: 90 nop
for (i = 28; i > 0; i -= 4) {
8049914: 83 6d f0 04 subl $0x4,-0x10(%ebp)
8049918: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
804991c: 7f 99 jg 80498b7 <hex_to_ascii+0x39>
}
tmp = n & 0xF;
804991e: 8b 45 08 mov 0x8(%ebp),%eax
8049921: 83 e0 0f and $0xf,%eax
8049924: 89 45 ec mov %eax,-0x14(%ebp)
if (tmp >= 0xA) append(str, tmp - 0xA + 'a');
8049927: 83 7d ec 09 cmpl $0x9,-0x14(%ebp)
804992b: 76 1a jbe 8049947 <hex_to_ascii+0xc9>
804992d: 8b 45 ec mov -0x14(%ebp),%eax
8049930: 83 c0 57 add $0x57,%eax
8049933: 0f be c0 movsbl %al,%eax
8049936: 83 ec 08 sub $0x8,%esp
8049939: 50 push %eax
804993a: ff 75 0c pushl 0xc(%ebp)
804993d: e8 20 00 00 00 call 8049962 <append>
8049942: 83 c4 10 add $0x10,%esp
else append(str, tmp + '0');
}
8049945: eb 18 jmp 804995f <hex_to_ascii+0xe1>
else append(str, tmp + '0');
8049947: 8b 45 ec mov -0x14(%ebp),%eax
804994a: 83 c0 30 add $0x30,%eax
804994d: 0f be c0 movsbl %al,%eax
8049950: 83 ec 08 sub $0x8,%esp
8049953: 50 push %eax
8049954: ff 75 0c pushl 0xc(%ebp)
8049957: e8 06 00 00 00 call 8049962 <append>
804995c: 83 c4 10 add $0x10,%esp
}
804995f: 90 nop
8049960: c9 leave
8049961: c3 ret
08049962 <append>:
void append(char* s, char n) {
8049962: 55 push %ebp
8049963: 89 e5 mov %esp,%ebp
8049965: 83 ec 14 sub $0x14,%esp
8049968: 8b 45 0c mov 0xc(%ebp),%eax
804996b: 88 45 ec mov %al,-0x14(%ebp)
int len = strlen(s);
804996e: ff 75 08 pushl 0x8(%ebp)
8049971: e8 ad fd ff ff call 8049723 <strlen>
8049976: 83 c4 04 add $0x4,%esp
8049979: 89 45 fc mov %eax,-0x4(%ebp)
s[len] = n;
804997c: 8b 55 fc mov -0x4(%ebp),%edx
804997f: 8b 45 08 mov 0x8(%ebp),%eax
8049982: 01 c2 add %eax,%edx
8049984: 8a 45 ec mov -0x14(%ebp),%al
8049987: 88 02 mov %al,(%edx)
s[len+1] = '\0';
8049989: 8b 45 fc mov -0x4(%ebp),%eax
804998c: 8d 50 01 lea 0x1(%eax),%edx
804998f: 8b 45 08 mov 0x8(%ebp),%eax
8049992: 01 d0 add %edx,%eax
8049994: c6 00 00 movb $0x0,(%eax)
}
8049997: 90 nop
8049998: c9 leave
8049999: c3 ret
0804999a <backspace>:
void backspace(char* s) {
804999a: 55 push %ebp
804999b: 89 e5 mov %esp,%ebp
804999d: 83 ec 10 sub $0x10,%esp
int len = strlen(s);
80499a0: ff 75 08 pushl 0x8(%ebp)
80499a3: e8 7b fd ff ff call 8049723 <strlen>
80499a8: 83 c4 04 add $0x4,%esp
80499ab: 89 45 fc mov %eax,-0x4(%ebp)
s[len-1] = '\0';
80499ae: 8b 45 fc mov -0x4(%ebp),%eax
80499b1: 8d 50 ff lea -0x1(%eax),%edx
80499b4: 8b 45 08 mov 0x8(%ebp),%eax
80499b7: 01 d0 add %edx,%eax
80499b9: c6 00 00 movb $0x0,(%eax)
}
80499bc: 90 nop
80499bd: c9 leave
80499be: c3 ret
080499bf <strtok_delim_check>:
static const char* strtok_str=NULL;
static size_t strtok_index;
static char strtok_delim_check(const char* delim) {
80499bf: 55 push %ebp
80499c0: 89 e5 mov %esp,%ebp
80499c2: 83 ec 10 sub $0x10,%esp
for (size_t i=0;i<strlen(delim);i++) {
80499c5: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
80499cc: eb 37 jmp 8049a05 <strtok_delim_check+0x46>
if (strtok_str[strtok_index]==delim[i]||strtok_str[strtok_index]=='\0') {
80499ce: 8b 15 64 d8 04 08 mov 0x804d864,%edx
80499d4: a1 68 d8 04 08 mov 0x804d868,%eax
80499d9: 01 d0 add %edx,%eax
80499db: 8a 10 mov (%eax),%dl
80499dd: 8b 4d 08 mov 0x8(%ebp),%ecx
80499e0: 8b 45 fc mov -0x4(%ebp),%eax
80499e3: 01 c8 add %ecx,%eax
80499e5: 8a 00 mov (%eax),%al
80499e7: 38 c2 cmp %al,%dl
80499e9: 74 13 je 80499fe <strtok_delim_check+0x3f>
80499eb: 8b 15 64 d8 04 08 mov 0x804d864,%edx
80499f1: a1 68 d8 04 08 mov 0x804d868,%eax
80499f6: 01 d0 add %edx,%eax
80499f8: 8a 00 mov (%eax),%al
80499fa: 84 c0 test %al,%al
80499fc: 75 04 jne 8049a02 <strtok_delim_check+0x43>
return 0;
80499fe: b0 00 mov $0x0,%al
8049a00: eb 15 jmp 8049a17 <strtok_delim_check+0x58>
for (size_t i=0;i<strlen(delim);i++) {
8049a02: ff 45 fc incl -0x4(%ebp)
8049a05: ff 75 08 pushl 0x8(%ebp)
8049a08: e8 16 fd ff ff call 8049723 <strlen>
8049a0d: 83 c4 04 add $0x4,%esp
8049a10: 39 45 fc cmp %eax,-0x4(%ebp)
8049a13: 72 b9 jb 80499ce <strtok_delim_check+0xf>
}
}
return 1;
8049a15: b0 01 mov $0x1,%al
}
8049a17: c9 leave
8049a18: c3 ret
08049a19 <strtok>:
char* strtok(const char* str, const char* delim) {
8049a19: 55 push %ebp
8049a1a: 89 e5 mov %esp,%ebp
8049a1c: 83 ec 18 sub $0x18,%esp
if (str!=NULL) {
8049a1f: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
8049a23: 74 12 je 8049a37 <strtok+0x1e>
strtok_str=str;
8049a25: 8b 45 08 mov 0x8(%ebp),%eax
8049a28: a3 64 d8 04 08 mov %eax,0x804d864
strtok_index=0;
8049a2d: c7 05 68 d8 04 08 00 movl $0x0,0x804d868
8049a34: 00 00 00
}
if (!strtok_str || strtok_index>strlen(strtok_str)) {
8049a37: a1 64 d8 04 08 mov 0x804d864,%eax
8049a3c: 85 c0 test %eax,%eax
8049a3e: 74 18 je 8049a58 <strtok+0x3f>
8049a40: a1 64 d8 04 08 mov 0x804d864,%eax
8049a45: 50 push %eax
8049a46: e8 d8 fc ff ff call 8049723 <strlen>
8049a4b: 83 c4 04 add $0x4,%esp
8049a4e: 8b 15 68 d8 04 08 mov 0x804d868,%edx
8049a54: 39 d0 cmp %edx,%eax
8049a56: 73 0a jae 8049a62 <strtok+0x49>
return NULL;
8049a58: b8 00 00 00 00 mov $0x0,%eax
8049a5d: e9 9b 00 00 00 jmp 8049afd <strtok+0xe4>
}
char* tok=malloc(sizeof(char)*32);
8049a62: 83 ec 0c sub $0xc,%esp
8049a65: 6a 20 push $0x20
8049a67: e8 ef f8 ff ff call 804935b <malloc>
8049a6c: 83 c4 10 add $0x10,%esp
8049a6f: 89 45 f4 mov %eax,-0xc(%ebp)
tok[0]='\0';
8049a72: 8b 45 f4 mov -0xc(%ebp),%eax
8049a75: c6 00 00 movb $0x0,(%eax)
size_t max_len=32;
8049a78: c7 45 f0 20 00 00 00 movl $0x20,-0x10(%ebp)
for (;strtok_delim_check(delim);strtok_index++) {
8049a7f: eb 5c jmp 8049add <strtok+0xc4>
if (strlen(tok)+1==max_len) {
8049a81: 83 ec 0c sub $0xc,%esp
8049a84: ff 75 f4 pushl -0xc(%ebp)
8049a87: e8 97 fc ff ff call 8049723 <strlen>
8049a8c: 83 c4 10 add $0x10,%esp
8049a8f: 40 inc %eax
8049a90: 39 45 f0 cmp %eax,-0x10(%ebp)
8049a93: 75 1c jne 8049ab1 <strtok+0x98>
tok=realloc(tok,sizeof(char)*(max_len+32));
8049a95: 8b 45 f0 mov -0x10(%ebp),%eax
8049a98: 83 c0 20 add $0x20,%eax
8049a9b: 83 ec 08 sub $0x8,%esp
8049a9e: 50 push %eax
8049a9f: ff 75 f4 pushl -0xc(%ebp)
8049aa2: e8 bc fa ff ff call 8049563 <realloc>
8049aa7: 83 c4 10 add $0x10,%esp
8049aaa: 89 45 f4 mov %eax,-0xc(%ebp)
max_len+=32;
8049aad: 83 45 f0 20 addl $0x20,-0x10(%ebp)
}
append(tok,strtok_str[strtok_index]);
8049ab1: 8b 15 64 d8 04 08 mov 0x804d864,%edx
8049ab7: a1 68 d8 04 08 mov 0x804d868,%eax
8049abc: 01 d0 add %edx,%eax
8049abe: 8a 00 mov (%eax),%al
8049ac0: 0f be c0 movsbl %al,%eax
8049ac3: 83 ec 08 sub $0x8,%esp
8049ac6: 50 push %eax
8049ac7: ff 75 f4 pushl -0xc(%ebp)
8049aca: e8 93 fe ff ff call 8049962 <append>
8049acf: 83 c4 10 add $0x10,%esp
for (;strtok_delim_check(delim);strtok_index++) {
8049ad2: a1 68 d8 04 08 mov 0x804d868,%eax
8049ad7: 40 inc %eax
8049ad8: a3 68 d8 04 08 mov %eax,0x804d868
8049add: 83 ec 0c sub $0xc,%esp
8049ae0: ff 75 0c pushl 0xc(%ebp)
8049ae3: e8 d7 fe ff ff call 80499bf <strtok_delim_check>
8049ae8: 83 c4 10 add $0x10,%esp
8049aeb: 84 c0 test %al,%al
8049aed: 75 92 jne 8049a81 <strtok+0x68>
}
strtok_index++;
8049aef: a1 68 d8 04 08 mov 0x804d868,%eax
8049af4: 40 inc %eax
8049af5: a3 68 d8 04 08 mov %eax,0x804d868
return tok;
8049afa: 8b 45 f4 mov -0xc(%ebp),%eax
}
8049afd: c9 leave
8049afe: c3 ret
08049aff <yield>:
#include <tasking.h>
#define QUAUX(X) #X
#define QU(X) QUAUX(X)
void yield() {
8049aff: 55 push %ebp
8049b00: 89 e5 mov %esp,%ebp
8049b02: 53 push %ebx
asm volatile(" \
8049b03: b8 00 00 00 00 mov $0x0,%eax
8049b08: 89 c3 mov %eax,%ebx
8049b0a: b8 01 00 00 00 mov $0x1,%eax
8049b0f: cd 50 int $0x50
mov $" QU(SYSCALL_YIELD) ", %%eax; \
int $80; \
"::"b"(0));
}
8049b11: 90 nop
8049b12: 5b pop %ebx
8049b13: 5d pop %ebp
8049b14: c3 ret
08049b15 <create_proc>:
void create_proc(void* start,void* address_space,void* param1,void* param2) {
8049b15: 55 push %ebp
8049b16: 89 e5 mov %esp,%ebp
8049b18: 56 push %esi
8049b19: 53 push %ebx
asm volatile(" \
8049b1a: 8b 45 08 mov 0x8(%ebp),%eax
8049b1d: 8b 4d 0c mov 0xc(%ebp),%ecx
8049b20: 8b 55 10 mov 0x10(%ebp),%edx
8049b23: 8b 75 14 mov 0x14(%ebp),%esi
8049b26: 89 c3 mov %eax,%ebx
8049b28: b8 00 00 00 00 mov $0x0,%eax
8049b2d: cd 50 int $0x50
mov $" QU(SYSCALL_CREATEPROC) ", %%eax; \
int $80; \
"::"b"(start),"c"(address_space),"d"(param1),"S"(param2));
}
8049b2f: 90 nop
8049b30: 5b pop %ebx
8049b31: 5e pop %esi
8049b32: 5d pop %ebp
8049b33: c3 ret
08049b34 <exit>:
__attribute__((noreturn)) void exit(int code) {
8049b34: 55 push %ebp
8049b35: 89 e5 mov %esp,%ebp
8049b37: 53 push %ebx
code=code&0xff;
8049b38: 81 65 08 ff 00 00 00 andl $0xff,0x8(%ebp)
asm volatile(" \
8049b3f: 8b 45 08 mov 0x8(%ebp),%eax
8049b42: 89 c3 mov %eax,%ebx
8049b44: b8 04 00 00 00 mov $0x4,%eax
8049b49: cd 50 int $0x50
mov $" QU(SYSCALL_EXIT) ", %%eax; \
int $80; \
"::"b"(code));
for(;;);
8049b4b: eb fe jmp 8049b4b <exit+0x17>
08049b4d <block_thread>:
}
void block_thread(thread_state state) {
8049b4d: 55 push %ebp
8049b4e: 89 e5 mov %esp,%ebp
8049b50: 53 push %ebx
asm volatile(" \
8049b51: 8b 45 08 mov 0x8(%ebp),%eax
8049b54: 89 c3 mov %eax,%ebx
8049b56: b8 02 00 00 00 mov $0x2,%eax
8049b5b: cd 50 int $0x50
mov $" QU(SYSCALL_BLOCK) ", %%eax; \
int $80; \
"::"b"(state));
}
8049b5d: 90 nop
8049b5e: 5b pop %ebx
8049b5f: 5d pop %ebp
8049b60: c3 ret
08049b61 <unblock_thread>:
void unblock_thread(pid_t pid,pid_t tid) {
8049b61: 55 push %ebp
8049b62: 89 e5 mov %esp,%ebp
8049b64: 53 push %ebx
asm volatile(" \
8049b65: 8b 45 08 mov 0x8(%ebp),%eax
8049b68: 8b 55 0c mov 0xc(%ebp),%edx
8049b6b: 89 c3 mov %eax,%ebx
8049b6d: 89 d1 mov %edx,%ecx
8049b6f: b8 03 00 00 00 mov $0x3,%eax
8049b74: cd 50 int $0x50
mov $" QU(SYSCALL_UNBLOCK) ", %%eax; \
int $80; \
"::"b"(pid),"c"(tid));
}
8049b76: 90 nop
8049b77: 5b pop %ebx
8049b78: 5d pop %ebp
8049b79: c3 ret
08049b7a <check_proc_exists>:
char check_proc_exists(pid_t pid) {
8049b7a: 55 push %ebp
8049b7b: 89 e5 mov %esp,%ebp
8049b7d: 53 push %ebx
8049b7e: 83 ec 10 sub $0x10,%esp
char exists;
asm volatile(" \
8049b81: 8b 45 08 mov 0x8(%ebp),%eax
8049b84: 89 c3 mov %eax,%ebx
8049b86: b8 14 00 00 00 mov $0x14,%eax
8049b8b: cd 50 int $0x50
8049b8d: 88 c8 mov %cl,%al
8049b8f: 88 45 fb mov %al,-0x5(%ebp)
mov $" QU(SYSCALL_CHECK_PROC_EXISTS) ", %%eax; \
int $80; \
":"=c"(exists):"b"(pid));
return exists;
8049b92: 8a 45 fb mov -0x5(%ebp),%al
}
8049b95: 83 c4 10 add $0x10,%esp
8049b98: 5b pop %ebx
8049b99: 5d pop %ebp
8049b9a: c3 ret
08049b9b <rpc_call>:
#define QUAUX(X) #X
#define QU(X) QUAUX(X)
void* rpc_call(pid_t pid,char* name,void* buf,size_t size) {
8049b9b: 55 push %ebp
8049b9c: 89 e5 mov %esp,%ebp
8049b9e: 57 push %edi
8049b9f: 56 push %esi
8049ba0: 53 push %ebx
8049ba1: 83 ec 10 sub $0x10,%esp
void* retbuf;
asm volatile(" \
8049ba4: 8b 45 08 mov 0x8(%ebp),%eax
8049ba7: 8b 4d 0c mov 0xc(%ebp),%ecx
8049baa: 8b 55 10 mov 0x10(%ebp),%edx
8049bad: 8b 75 14 mov 0x14(%ebp),%esi
8049bb0: 89 c3 mov %eax,%ebx
8049bb2: b8 0f 00 00 00 mov $0xf,%eax
8049bb7: cd 50 int $0x50
8049bb9: 89 f8 mov %edi,%eax
8049bbb: 89 45 f0 mov %eax,-0x10(%ebp)
mov $" QU(SYSCALL_CALL_RPC) ", %%eax; \
int $80; \
":"=D"(retbuf):"b"(pid),"c"(name),"d"(buf),"S"(size));
return retbuf;
8049bbe: 8b 45 f0 mov -0x10(%ebp),%eax
}
8049bc1: 83 c4 10 add $0x10,%esp
8049bc4: 5b pop %ebx
8049bc5: 5e pop %esi
8049bc6: 5f pop %edi
8049bc7: 5d pop %ebp
8049bc8: c3 ret
08049bc9 <rpc_register_func>:
void rpc_register_func(char* name,rpc_func code) {
8049bc9: 55 push %ebp
8049bca: 89 e5 mov %esp,%ebp
8049bcc: 53 push %ebx
asm volatile(" \
8049bcd: 8b 45 08 mov 0x8(%ebp),%eax
8049bd0: 8b 55 0c mov 0xc(%ebp),%edx
8049bd3: 89 c3 mov %eax,%ebx
8049bd5: 89 d1 mov %edx,%ecx
8049bd7: b8 10 00 00 00 mov $0x10,%eax
8049bdc: cd 50 int $0x50
mov $" QU(SYSCALL_REGISTER_RPC) ", %%eax; \
int $80; \
"::"b"(name),"c"(code));
}
8049bde: 90 nop
8049bdf: 5b pop %ebx
8049be0: 5d pop %ebp
8049be1: c3 ret
08049be2 <rpc_deallocate_buf>:
void rpc_deallocate_buf(void* buf,size_t size) {
8049be2: 55 push %ebp
8049be3: 89 e5 mov %esp,%ebp
8049be5: 53 push %ebx
asm volatile(" \
8049be6: 8b 45 08 mov 0x8(%ebp),%eax
8049be9: 8b 55 0c mov 0xc(%ebp),%edx
8049bec: 89 c3 mov %eax,%ebx
8049bee: 89 d1 mov %edx,%ecx
8049bf0: b8 11 00 00 00 mov $0x11,%eax
8049bf5: cd 50 int $0x50
mov $" QU(SYSCALL_DEALLOCTATE_RPC_RET) ", %%eax; \
int $80; \
"::"b"(buf),"c"(size));
}
8049bf7: 90 nop
8049bf8: 5b pop %ebx
8049bf9: 5d pop %ebp
8049bfa: c3 ret
08049bfb <rpc_return>:
void rpc_return(void* buf,size_t size) {
8049bfb: 55 push %ebp
8049bfc: 89 e5 mov %esp,%ebp
8049bfe: 53 push %ebx
asm volatile(" \
8049bff: 8b 45 08 mov 0x8(%ebp),%eax
8049c02: 8b 55 0c mov 0xc(%ebp),%edx
8049c05: 89 c3 mov %eax,%ebx
8049c07: 89 d1 mov %edx,%ecx
8049c09: b8 12 00 00 00 mov $0x12,%eax
8049c0e: cd 50 int $0x50
mov $" QU(SYSCALL_RPC_RET) ", %%eax; \
int $80; \
"::"b"(buf),"c"(size));
}
8049c10: 90 nop
8049c11: 5b pop %ebx
8049c12: 5d pop %ebp
8049c13: c3 ret
08049c14 <rpc_mark_as_init>:
void rpc_mark_as_init() {
8049c14: 55 push %ebp
8049c15: 89 e5 mov %esp,%ebp
asm volatile(" \
8049c17: b8 15 00 00 00 mov $0x15,%eax
8049c1c: cd 50 int $0x50
mov $" QU(SYSCALL_RPC_MARK_AS_INIT) ", %%eax; \
int $80; \
"::);
}
8049c1e: 90 nop
8049c1f: 5d pop %ebp
8049c20: c3 ret
08049c21 <rpc_is_init>:
char rpc_is_init(pid_t pid) {
8049c21: 55 push %ebp
8049c22: 89 e5 mov %esp,%ebp
8049c24: 53 push %ebx
8049c25: 83 ec 10 sub $0x10,%esp
char is_init;
asm volatile(" \
8049c28: 8b 45 08 mov 0x8(%ebp),%eax
8049c2b: 89 c3 mov %eax,%ebx
8049c2d: b8 16 00 00 00 mov $0x16,%eax
8049c32: cd 50 int $0x50
8049c34: 88 c8 mov %cl,%al
8049c36: 88 45 fb mov %al,-0x5(%ebp)
mov $" QU(SYSCALL_RPC_IS_INIT) ", %%eax; \
int $80; \
":"=c"(is_init):"b"(pid));
return is_init;
8049c39: 8a 45 fb mov -0x5(%ebp),%al
}
8049c3c: 83 c4 10 add $0x10,%esp
8049c3f: 5b pop %ebx
8049c40: 5d pop %ebp
8049c41: c3 ret
08049c42 <serialize_int>:
#include <serdes.h>
#include <stdlib.h>
#include <string.h>
void serialize_int(int num,serdes_state* state) {
8049c42: 55 push %ebp
8049c43: 89 e5 mov %esp,%ebp
8049c45: 83 ec 08 sub $0x8,%esp
state->buf=realloc(state->buf,state->sizeorpos+sizeof(int));
8049c48: 8b 45 0c mov 0xc(%ebp),%eax
8049c4b: 8b 40 04 mov 0x4(%eax),%eax
8049c4e: 8d 50 04 lea 0x4(%eax),%edx
8049c51: 8b 45 0c mov 0xc(%ebp),%eax
8049c54: 8b 00 mov (%eax),%eax
8049c56: 83 ec 08 sub $0x8,%esp
8049c59: 52 push %edx
8049c5a: 50 push %eax
8049c5b: e8 03 f9 ff ff call 8049563 <realloc>
8049c60: 83 c4 10 add $0x10,%esp
8049c63: 8b 55 0c mov 0xc(%ebp),%edx
8049c66: 89 02 mov %eax,(%edx)
*((int*)(state->buf+state->sizeorpos))=num;
8049c68: 8b 45 0c mov 0xc(%ebp),%eax
8049c6b: 8b 10 mov (%eax),%edx
8049c6d: 8b 45 0c mov 0xc(%ebp),%eax
8049c70: 8b 40 04 mov 0x4(%eax),%eax
8049c73: 01 c2 add %eax,%edx
8049c75: 8b 45 08 mov 0x8(%ebp),%eax
8049c78: 89 02 mov %eax,(%edx)
state->sizeorpos+=sizeof(int);
8049c7a: 8b 45 0c mov 0xc(%ebp),%eax
8049c7d: 8b 40 04 mov 0x4(%eax),%eax
8049c80: 8d 50 04 lea 0x4(%eax),%edx
8049c83: 8b 45 0c mov 0xc(%ebp),%eax
8049c86: 89 50 04 mov %edx,0x4(%eax)
}
8049c89: 90 nop
8049c8a: c9 leave
8049c8b: c3 ret
08049c8c <serialize_ptr>:
void serialize_ptr(void* ptr,serdes_state* state) {
8049c8c: 55 push %ebp
8049c8d: 89 e5 mov %esp,%ebp
8049c8f: 83 ec 08 sub $0x8,%esp
state->buf=realloc(state->buf,state->sizeorpos+sizeof(void*));
8049c92: 8b 45 0c mov 0xc(%ebp),%eax
8049c95: 8b 40 04 mov 0x4(%eax),%eax
8049c98: 8d 50 04 lea 0x4(%eax),%edx
8049c9b: 8b 45 0c mov 0xc(%ebp),%eax
8049c9e: 8b 00 mov (%eax),%eax
8049ca0: 83 ec 08 sub $0x8,%esp
8049ca3: 52 push %edx
8049ca4: 50 push %eax
8049ca5: e8 b9 f8 ff ff call 8049563 <realloc>
8049caa: 83 c4 10 add $0x10,%esp
8049cad: 8b 55 0c mov 0xc(%ebp),%edx
8049cb0: 89 02 mov %eax,(%edx)
*((void**)(state->buf+state->sizeorpos))=ptr;
8049cb2: 8b 45 0c mov 0xc(%ebp),%eax
8049cb5: 8b 10 mov (%eax),%edx
8049cb7: 8b 45 0c mov 0xc(%ebp),%eax
8049cba: 8b 40 04 mov 0x4(%eax),%eax
8049cbd: 01 c2 add %eax,%edx
8049cbf: 8b 45 08 mov 0x8(%ebp),%eax
8049cc2: 89 02 mov %eax,(%edx)
state->sizeorpos+=sizeof(void*);
8049cc4: 8b 45 0c mov 0xc(%ebp),%eax
8049cc7: 8b 40 04 mov 0x4(%eax),%eax
8049cca: 8d 50 04 lea 0x4(%eax),%edx
8049ccd: 8b 45 0c mov 0xc(%ebp),%eax
8049cd0: 89 50 04 mov %edx,0x4(%eax)
}
8049cd3: 90 nop
8049cd4: c9 leave
8049cd5: c3 ret
08049cd6 <serialize_ary>:
void serialize_ary(void* ary,size_t len,serdes_state* state) {
8049cd6: 55 push %ebp
8049cd7: 89 e5 mov %esp,%ebp
8049cd9: 83 ec 08 sub $0x8,%esp
state->buf=realloc(state->buf,state->sizeorpos+len);
8049cdc: 8b 45 10 mov 0x10(%ebp),%eax
8049cdf: 8b 50 04 mov 0x4(%eax),%edx
8049ce2: 8b 45 0c mov 0xc(%ebp),%eax
8049ce5: 01 c2 add %eax,%edx
8049ce7: 8b 45 10 mov 0x10(%ebp),%eax
8049cea: 8b 00 mov (%eax),%eax
8049cec: 83 ec 08 sub $0x8,%esp
8049cef: 52 push %edx
8049cf0: 50 push %eax
8049cf1: e8 6d f8 ff ff call 8049563 <realloc>
8049cf6: 83 c4 10 add $0x10,%esp
8049cf9: 8b 55 10 mov 0x10(%ebp),%edx
8049cfc: 89 02 mov %eax,(%edx)
memcpy(state->buf+state->sizeorpos,ary,len);
8049cfe: 8b 45 10 mov 0x10(%ebp),%eax
8049d01: 8b 10 mov (%eax),%edx
8049d03: 8b 45 10 mov 0x10(%ebp),%eax
8049d06: 8b 40 04 mov 0x4(%eax),%eax
8049d09: 01 d0 add %edx,%eax
8049d0b: 83 ec 04 sub $0x4,%esp
8049d0e: ff 75 0c pushl 0xc(%ebp)
8049d11: ff 75 08 pushl 0x8(%ebp)
8049d14: 50 push %eax
8049d15: e8 39 f9 ff ff call 8049653 <memcpy>
8049d1a: 83 c4 10 add $0x10,%esp
state->sizeorpos+=len;
8049d1d: 8b 45 10 mov 0x10(%ebp),%eax
8049d20: 8b 50 04 mov 0x4(%eax),%edx
8049d23: 8b 45 0c mov 0xc(%ebp),%eax
8049d26: 01 c2 add %eax,%edx
8049d28: 8b 45 10 mov 0x10(%ebp),%eax
8049d2b: 89 50 04 mov %edx,0x4(%eax)
}
8049d2e: 90 nop
8049d2f: c9 leave
8049d30: c3 ret
08049d31 <start_deserialize>:
void start_deserialize(char* buf,serdes_state* state) {
8049d31: 55 push %ebp
8049d32: 89 e5 mov %esp,%ebp
state->buf=buf;
8049d34: 8b 45 0c mov 0xc(%ebp),%eax
8049d37: 8b 55 08 mov 0x8(%ebp),%edx
8049d3a: 89 10 mov %edx,(%eax)
state->sizeorpos=0;
8049d3c: 8b 45 0c mov 0xc(%ebp),%eax
8049d3f: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
}
8049d46: 90 nop
8049d47: 5d pop %ebp
8049d48: c3 ret
08049d49 <deserialize_int>:
int deserialize_int(serdes_state* state) {
8049d49: 55 push %ebp
8049d4a: 89 e5 mov %esp,%ebp
8049d4c: 83 ec 10 sub $0x10,%esp
int num=*((int*)(state->buf+state->sizeorpos));
8049d4f: 8b 45 08 mov 0x8(%ebp),%eax
8049d52: 8b 10 mov (%eax),%edx
8049d54: 8b 45 08 mov 0x8(%ebp),%eax
8049d57: 8b 40 04 mov 0x4(%eax),%eax
8049d5a: 01 d0 add %edx,%eax
8049d5c: 8b 00 mov (%eax),%eax
8049d5e: 89 45 fc mov %eax,-0x4(%ebp)
state->sizeorpos+=sizeof(int);
8049d61: 8b 45 08 mov 0x8(%ebp),%eax
8049d64: 8b 40 04 mov 0x4(%eax),%eax
8049d67: 8d 50 04 lea 0x4(%eax),%edx
8049d6a: 8b 45 08 mov 0x8(%ebp),%eax
8049d6d: 89 50 04 mov %edx,0x4(%eax)
return num;
8049d70: 8b 45 fc mov -0x4(%ebp),%eax
}
8049d73: c9 leave
8049d74: c3 ret
08049d75 <deserialize_ptr>:
void* deserialize_ptr(serdes_state* state) {
8049d75: 55 push %ebp
8049d76: 89 e5 mov %esp,%ebp
8049d78: 83 ec 10 sub $0x10,%esp
void* ptr=*((void**)(state->buf+state->sizeorpos));
8049d7b: 8b 45 08 mov 0x8(%ebp),%eax
8049d7e: 8b 10 mov (%eax),%edx
8049d80: 8b 45 08 mov 0x8(%ebp),%eax
8049d83: 8b 40 04 mov 0x4(%eax),%eax
8049d86: 01 d0 add %edx,%eax
8049d88: 8b 00 mov (%eax),%eax
8049d8a: 89 45 fc mov %eax,-0x4(%ebp)
state->sizeorpos+=sizeof(void*);
8049d8d: 8b 45 08 mov 0x8(%ebp),%eax
8049d90: 8b 40 04 mov 0x4(%eax),%eax
8049d93: 8d 50 04 lea 0x4(%eax),%edx
8049d96: 8b 45 08 mov 0x8(%ebp),%eax
8049d99: 89 50 04 mov %edx,0x4(%eax)
return ptr;
8049d9c: 8b 45 fc mov -0x4(%ebp),%eax
}
8049d9f: c9 leave
8049da0: c3 ret
08049da1 <deserialize_ary>:
void* deserialize_ary(size_t len,serdes_state* state) {
8049da1: 55 push %ebp
8049da2: 89 e5 mov %esp,%ebp
8049da4: 83 ec 18 sub $0x18,%esp
void* ary_in_buf=((void*)(state->buf+state->sizeorpos));
8049da7: 8b 45 0c mov 0xc(%ebp),%eax
8049daa: 8b 10 mov (%eax),%edx
8049dac: 8b 45 0c mov 0xc(%ebp),%eax
8049daf: 8b 40 04 mov 0x4(%eax),%eax
8049db2: 01 d0 add %edx,%eax
8049db4: 89 45 f4 mov %eax,-0xc(%ebp)
state->sizeorpos+=len;
8049db7: 8b 45 0c mov 0xc(%ebp),%eax
8049dba: 8b 50 04 mov 0x4(%eax),%edx
8049dbd: 8b 45 08 mov 0x8(%ebp),%eax
8049dc0: 01 c2 add %eax,%edx
8049dc2: 8b 45 0c mov 0xc(%ebp),%eax
8049dc5: 89 50 04 mov %edx,0x4(%eax)
void* ary=malloc(len);
8049dc8: 83 ec 0c sub $0xc,%esp
8049dcb: ff 75 08 pushl 0x8(%ebp)
8049dce: e8 88 f5 ff ff call 804935b <malloc>
8049dd3: 83 c4 10 add $0x10,%esp
8049dd6: 89 45 f0 mov %eax,-0x10(%ebp)
memcpy(ary,ary_in_buf,len);
8049dd9: 83 ec 04 sub $0x4,%esp
8049ddc: ff 75 08 pushl 0x8(%ebp)
8049ddf: ff 75 f4 pushl -0xc(%ebp)
8049de2: ff 75 f0 pushl -0x10(%ebp)
8049de5: e8 69 f8 ff ff call 8049653 <memcpy>
8049dea: 83 c4 10 add $0x10,%esp
return ary;
8049ded: 8b 45 f0 mov -0x10(%ebp),%eax
}
8049df0: c9 leave
8049df1: c3 ret
08049df2 <ceilf>:
float ceilf(float num) {
8049df2: 55 push %ebp
8049df3: 89 e5 mov %esp,%ebp
8049df5: 83 ec 18 sub $0x18,%esp
int inum=(int)num;
8049df8: d9 45 08 flds 0x8(%ebp)
8049dfb: d9 7d ee fnstcw -0x12(%ebp)
8049dfe: 66 8b 45 ee mov -0x12(%ebp),%ax
8049e02: 80 cc 0c or $0xc,%ah
8049e05: 66 89 45 ec mov %ax,-0x14(%ebp)
8049e09: d9 6d ec fldcw -0x14(%ebp)
8049e0c: db 5d fc fistpl -0x4(%ebp)
8049e0f: d9 6d ee fldcw -0x12(%ebp)
if (num==(float)inum) {
8049e12: db 45 fc fildl -0x4(%ebp)
8049e15: d9 45 08 flds 0x8(%ebp)
8049e18: da e9 fucompp
8049e1a: df e0 fnstsw %ax
8049e1c: 80 e4 45 and $0x45,%ah
8049e1f: 80 f4 40 xor $0x40,%ah
8049e22: 75 05 jne 8049e29 <ceilf+0x37>
return (float)inum;
8049e24: db 45 fc fildl -0x4(%ebp)
8049e27: eb 0a jmp 8049e33 <ceilf+0x41>
}
return (float)(inum+1);
8049e29: 8b 45 fc mov -0x4(%ebp),%eax
8049e2c: 40 inc %eax
8049e2d: 89 45 e8 mov %eax,-0x18(%ebp)
8049e30: db 45 e8 fildl -0x18(%ebp)
}
8049e33: c9 leave
8049e34: c3 ret
08049e35 <ceil>:
double ceil(double num) {
8049e35: 55 push %ebp
8049e36: 89 e5 mov %esp,%ebp
8049e38: 83 ec 20 sub $0x20,%esp
8049e3b: 8b 45 08 mov 0x8(%ebp),%eax
8049e3e: 89 45 e8 mov %eax,-0x18(%ebp)
8049e41: 8b 45 0c mov 0xc(%ebp),%eax
8049e44: 89 45 ec mov %eax,-0x14(%ebp)
int inum=(int)num;
8049e47: dd 45 e8 fldl -0x18(%ebp)
8049e4a: d9 7d e6 fnstcw -0x1a(%ebp)
8049e4d: 66 8b 45 e6 mov -0x1a(%ebp),%ax
8049e51: 80 cc 0c or $0xc,%ah
8049e54: 66 89 45 e4 mov %ax,-0x1c(%ebp)
8049e58: d9 6d e4 fldcw -0x1c(%ebp)
8049e5b: db 5d fc fistpl -0x4(%ebp)
8049e5e: d9 6d e6 fldcw -0x1a(%ebp)
if (num==(double)inum) {
8049e61: db 45 fc fildl -0x4(%ebp)
8049e64: dd 45 e8 fldl -0x18(%ebp)
8049e67: da e9 fucompp
8049e69: df e0 fnstsw %ax
8049e6b: 80 e4 45 and $0x45,%ah
8049e6e: 80 f4 40 xor $0x40,%ah
8049e71: 75 05 jne 8049e78 <ceil+0x43>
return (double)inum;
8049e73: db 45 fc fildl -0x4(%ebp)
8049e76: eb 0a jmp 8049e82 <ceil+0x4d>
}
return (double)(inum+1);
8049e78: 8b 45 fc mov -0x4(%ebp),%eax
8049e7b: 40 inc %eax
8049e7c: 89 45 e0 mov %eax,-0x20(%ebp)
8049e7f: db 45 e0 fildl -0x20(%ebp)
}
8049e82: c9 leave
8049e83: c3 ret
08049e84 <__do_global_ctors_aux>:
8049e84: a1 00 b0 04 08 mov 0x804b000,%eax
8049e89: 83 f8 ff cmp $0xffffffff,%eax
8049e8c: 74 1a je 8049ea8 <__do_global_ctors_aux+0x24>
8049e8e: 55 push %ebp
8049e8f: 89 e5 mov %esp,%ebp
8049e91: 53 push %ebx
8049e92: 52 push %edx
8049e93: bb 00 b0 04 08 mov $0x804b000,%ebx
8049e98: ff d0 call *%eax
8049e9a: 83 eb 04 sub $0x4,%ebx
8049e9d: 8b 03 mov (%ebx),%eax
8049e9f: 83 f8 ff cmp $0xffffffff,%eax
8049ea2: 75 f4 jne 8049e98 <__do_global_ctors_aux+0x14>
8049ea4: 58 pop %eax
8049ea5: 5b pop %ebx
8049ea6: 5d pop %ebp
8049ea7: c3 ret
8049ea8: c3 ret
Disassembly of section .fini:
08049ea9 <_fini>:
8049ea9: e8 5a e2 ff ff call 8048108 <__do_global_dtors_aux>
8049eae: c2 00 00 ret $0x0
Reference in New Issue View Git Blame Copy Permalink