2728 lines
106 KiB
NASM
2728 lines
106 KiB
NASM
|
|
_sh: file format elf32-i386
|
|
|
|
|
|
Disassembly of section .text:
|
|
|
|
00000000 <main>:
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int main(void) {
|
|
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
|
|
4: 83 e4 f0 and $0xfffffff0,%esp
|
|
7: ff 71 fc push -0x4(%ecx)
|
|
a: 55 push %ebp
|
|
b: 89 e5 mov %esp,%ebp
|
|
d: 51 push %ecx
|
|
e: 83 ec 04 sub $0x4,%esp
|
|
static char buf[100];
|
|
int fd;
|
|
|
|
// Ensure that three file descriptors are open.
|
|
while ((fd = open("console", O_RDWR)) >= 0) {
|
|
11: eb 0e jmp 21 <main+0x21>
|
|
13: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
17: 90 nop
|
|
if (fd >= 3) {
|
|
18: 83 f8 02 cmp $0x2,%eax
|
|
1b: 0f 8f 01 01 00 00 jg 122 <main+0x122>
|
|
while ((fd = open("console", O_RDWR)) >= 0) {
|
|
21: 83 ec 08 sub $0x8,%esp
|
|
24: 6a 02 push $0x2
|
|
26: 68 99 13 00 00 push $0x1399
|
|
2b: e8 8b 0e 00 00 call ebb <open>
|
|
30: 83 c4 10 add $0x10,%esp
|
|
33: 85 c0 test %eax,%eax
|
|
35: 79 e1 jns 18 <main+0x18>
|
|
37: eb 33 jmp 6c <main+0x6c>
|
|
39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
// Read and run input commands.
|
|
while (getcmd(buf, sizeof(buf)) >= 0) {
|
|
if (buf[0] == 'e' && buf[1] == 'x' && buf[2] == 'i' && buf[3] == 't') {
|
|
exit();
|
|
}
|
|
if (buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' ') {
|
|
40: 3c 63 cmp $0x63,%al
|
|
42: 75 0d jne 51 <main+0x51>
|
|
44: 80 3d 41 1a 00 00 64 cmpb $0x64,0x1a41
|
|
4b: 0f 84 7f 00 00 00 je d0 <main+0xd0>
|
|
}
|
|
|
|
int fork1(void) {
|
|
int pid;
|
|
|
|
pid = fork();
|
|
51: e8 f5 0d 00 00 call e4b <fork>
|
|
if (pid == -1) {
|
|
56: 83 f8 ff cmp $0xffffffff,%eax
|
|
59: 0f 84 e9 00 00 00 je 148 <main+0x148>
|
|
if (fork1() == 0) {
|
|
5f: 85 c0 test %eax,%eax
|
|
61: 0f 84 cc 00 00 00 je 133 <main+0x133>
|
|
wait();
|
|
67: e8 ef 0d 00 00 call e5b <wait>
|
|
printf(2, "$ ");
|
|
6c: 83 ec 08 sub $0x8,%esp
|
|
6f: 68 f8 12 00 00 push $0x12f8
|
|
74: 6a 02 push $0x2
|
|
76: e8 55 0f 00 00 call fd0 <printf>
|
|
memset(buf, 0, nbuf);
|
|
7b: 83 c4 0c add $0xc,%esp
|
|
7e: 6a 64 push $0x64
|
|
80: 6a 00 push $0x0
|
|
82: 68 40 1a 00 00 push $0x1a40
|
|
87: e8 34 0c 00 00 call cc0 <memset>
|
|
gets(buf, nbuf);
|
|
8c: 58 pop %eax
|
|
8d: 5a pop %edx
|
|
8e: 6a 64 push $0x64
|
|
90: 68 40 1a 00 00 push $0x1a40
|
|
95: e8 86 0c 00 00 call d20 <gets>
|
|
if (buf[0] == 0) { // EOF
|
|
9a: 0f b6 05 40 1a 00 00 movzbl 0x1a40,%eax
|
|
a1: 83 c4 10 add $0x10,%esp
|
|
a4: 84 c0 test %al,%al
|
|
a6: 74 1f je c7 <main+0xc7>
|
|
if (buf[0] == 'e' && buf[1] == 'x' && buf[2] == 'i' && buf[3] == 't') {
|
|
a8: 3c 65 cmp $0x65,%al
|
|
aa: 75 94 jne 40 <main+0x40>
|
|
ac: 80 3d 41 1a 00 00 78 cmpb $0x78,0x1a41
|
|
b3: 75 9c jne 51 <main+0x51>
|
|
b5: 80 3d 42 1a 00 00 69 cmpb $0x69,0x1a42
|
|
bc: 75 93 jne 51 <main+0x51>
|
|
be: 80 3d 43 1a 00 00 74 cmpb $0x74,0x1a43
|
|
c5: 75 8a jne 51 <main+0x51>
|
|
exit();
|
|
c7: e8 87 0d 00 00 call e53 <exit>
|
|
cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
if (buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' ') {
|
|
d0: 80 3d 42 1a 00 00 20 cmpb $0x20,0x1a42
|
|
d7: 0f 85 74 ff ff ff jne 51 <main+0x51>
|
|
buf[strlen(buf) - 1] = 0; // chop \n
|
|
dd: 83 ec 0c sub $0xc,%esp
|
|
e0: 68 40 1a 00 00 push $0x1a40
|
|
e5: e8 a6 0b 00 00 call c90 <strlen>
|
|
if (chdir(buf + 3) < 0) {
|
|
ea: c7 04 24 43 1a 00 00 movl $0x1a43,(%esp)
|
|
buf[strlen(buf) - 1] = 0; // chop \n
|
|
f1: c6 80 3f 1a 00 00 00 movb $0x0,0x1a3f(%eax)
|
|
if (chdir(buf + 3) < 0) {
|
|
f8: e8 8e 0d 00 00 call e8b <chdir>
|
|
fd: 83 c4 10 add $0x10,%esp
|
|
100: 85 c0 test %eax,%eax
|
|
102: 0f 89 64 ff ff ff jns 6c <main+0x6c>
|
|
printf(2, "cannot cd %s\n", buf + 3);
|
|
108: 51 push %ecx
|
|
109: 68 43 1a 00 00 push $0x1a43
|
|
10e: 68 a1 13 00 00 push $0x13a1
|
|
113: 6a 02 push $0x2
|
|
115: e8 b6 0e 00 00 call fd0 <printf>
|
|
11a: 83 c4 10 add $0x10,%esp
|
|
11d: e9 4a ff ff ff jmp 6c <main+0x6c>
|
|
close(fd);
|
|
122: 83 ec 0c sub $0xc,%esp
|
|
125: 50 push %eax
|
|
126: e8 c0 0d 00 00 call eeb <close>
|
|
break;
|
|
12b: 83 c4 10 add $0x10,%esp
|
|
12e: e9 39 ff ff ff jmp 6c <main+0x6c>
|
|
runcmd(parsecmd(buf));
|
|
133: 83 ec 0c sub $0xc,%esp
|
|
136: 68 40 1a 00 00 push $0x1a40
|
|
13b: e8 50 0a 00 00 call b90 <parsecmd>
|
|
140: 89 04 24 mov %eax,(%esp)
|
|
143: e8 98 00 00 00 call 1e0 <runcmd>
|
|
panic("fork");
|
|
148: 83 ec 0c sub $0xc,%esp
|
|
14b: 68 fb 12 00 00 push $0x12fb
|
|
150: e8 4b 00 00 00 call 1a0 <panic>
|
|
155: 66 90 xchg %ax,%ax
|
|
157: 66 90 xchg %ax,%ax
|
|
159: 66 90 xchg %ax,%ax
|
|
15b: 66 90 xchg %ax,%ax
|
|
15d: 66 90 xchg %ax,%ax
|
|
15f: 90 nop
|
|
|
|
00000160 <getcmd>:
|
|
int getcmd(char *buf, int nbuf) {
|
|
160: 55 push %ebp
|
|
161: 89 e5 mov %esp,%ebp
|
|
163: 56 push %esi
|
|
164: 53 push %ebx
|
|
165: 8b 75 0c mov 0xc(%ebp),%esi
|
|
168: 8b 5d 08 mov 0x8(%ebp),%ebx
|
|
printf(2, "$ ");
|
|
16b: 83 ec 08 sub $0x8,%esp
|
|
16e: 68 f8 12 00 00 push $0x12f8
|
|
173: 6a 02 push $0x2
|
|
175: e8 56 0e 00 00 call fd0 <printf>
|
|
memset(buf, 0, nbuf);
|
|
17a: 83 c4 0c add $0xc,%esp
|
|
17d: 56 push %esi
|
|
17e: 6a 00 push $0x0
|
|
180: 53 push %ebx
|
|
181: e8 3a 0b 00 00 call cc0 <memset>
|
|
gets(buf, nbuf);
|
|
186: 58 pop %eax
|
|
187: 5a pop %edx
|
|
188: 56 push %esi
|
|
189: 53 push %ebx
|
|
18a: e8 91 0b 00 00 call d20 <gets>
|
|
if (buf[0] == 0) { // EOF
|
|
18f: 83 c4 10 add $0x10,%esp
|
|
192: 80 3b 01 cmpb $0x1,(%ebx)
|
|
195: 19 c0 sbb %eax,%eax
|
|
}
|
|
197: 8d 65 f8 lea -0x8(%ebp),%esp
|
|
19a: 5b pop %ebx
|
|
19b: 5e pop %esi
|
|
19c: 5d pop %ebp
|
|
19d: c3 ret
|
|
19e: 66 90 xchg %ax,%ax
|
|
|
|
000001a0 <panic>:
|
|
void panic(char *s) {
|
|
1a0: 55 push %ebp
|
|
1a1: 89 e5 mov %esp,%ebp
|
|
1a3: 83 ec 0c sub $0xc,%esp
|
|
printf(2, "%s\n", s);
|
|
1a6: ff 75 08 push 0x8(%ebp)
|
|
1a9: 68 95 13 00 00 push $0x1395
|
|
1ae: 6a 02 push $0x2
|
|
1b0: e8 1b 0e 00 00 call fd0 <printf>
|
|
exit();
|
|
1b5: e8 99 0c 00 00 call e53 <exit>
|
|
1ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
|
|
000001c0 <fork1>:
|
|
int fork1(void) {
|
|
1c0: 55 push %ebp
|
|
1c1: 89 e5 mov %esp,%ebp
|
|
1c3: 83 ec 08 sub $0x8,%esp
|
|
pid = fork();
|
|
1c6: e8 80 0c 00 00 call e4b <fork>
|
|
if (pid == -1) {
|
|
1cb: 83 f8 ff cmp $0xffffffff,%eax
|
|
1ce: 74 02 je 1d2 <fork1+0x12>
|
|
}
|
|
return pid;
|
|
}
|
|
1d0: c9 leave
|
|
1d1: c3 ret
|
|
panic("fork");
|
|
1d2: 83 ec 0c sub $0xc,%esp
|
|
1d5: 68 fb 12 00 00 push $0x12fb
|
|
1da: e8 c1 ff ff ff call 1a0 <panic>
|
|
1df: 90 nop
|
|
|
|
000001e0 <runcmd>:
|
|
void runcmd(struct cmd *cmd) {
|
|
1e0: 55 push %ebp
|
|
1e1: 89 e5 mov %esp,%ebp
|
|
1e3: 53 push %ebx
|
|
1e4: 83 ec 14 sub $0x14,%esp
|
|
1e7: 8b 5d 08 mov 0x8(%ebp),%ebx
|
|
if (cmd == 0) {
|
|
1ea: 85 db test %ebx,%ebx
|
|
1ec: 74 42 je 230 <runcmd+0x50>
|
|
switch (cmd->type) {
|
|
1ee: 83 3b 05 cmpl $0x5,(%ebx)
|
|
1f1: 0f 87 e3 00 00 00 ja 2da <runcmd+0xfa>
|
|
1f7: 8b 03 mov (%ebx),%eax
|
|
1f9: ff 24 85 b0 13 00 00 jmp *0x13b0(,%eax,4)
|
|
if (ecmd->argv[0] == 0) {
|
|
200: 8b 43 04 mov 0x4(%ebx),%eax
|
|
203: 85 c0 test %eax,%eax
|
|
205: 74 29 je 230 <runcmd+0x50>
|
|
exec(ecmd->argv[0], ecmd->argv);
|
|
207: 8d 53 04 lea 0x4(%ebx),%edx
|
|
20a: 51 push %ecx
|
|
20b: 51 push %ecx
|
|
20c: 52 push %edx
|
|
20d: 50 push %eax
|
|
20e: e8 68 0c 00 00 call e7b <exec>
|
|
printf(2, "exec %s failed\n", ecmd->argv[0]);
|
|
213: 83 c4 0c add $0xc,%esp
|
|
216: ff 73 04 push 0x4(%ebx)
|
|
219: 68 07 13 00 00 push $0x1307
|
|
21e: 6a 02 push $0x2
|
|
220: e8 ab 0d 00 00 call fd0 <printf>
|
|
break;
|
|
225: 83 c4 10 add $0x10,%esp
|
|
228: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
22f: 90 nop
|
|
exit();
|
|
230: e8 1e 0c 00 00 call e53 <exit>
|
|
if (fork1() == 0) {
|
|
235: e8 86 ff ff ff call 1c0 <fork1>
|
|
23a: 85 c0 test %eax,%eax
|
|
23c: 75 f2 jne 230 <runcmd+0x50>
|
|
23e: e9 8c 00 00 00 jmp 2cf <runcmd+0xef>
|
|
if (pipe(p) < 0) {
|
|
243: 83 ec 0c sub $0xc,%esp
|
|
246: 8d 45 f0 lea -0x10(%ebp),%eax
|
|
249: 50 push %eax
|
|
24a: e8 14 0c 00 00 call e63 <pipe>
|
|
24f: 83 c4 10 add $0x10,%esp
|
|
252: 85 c0 test %eax,%eax
|
|
254: 0f 88 a2 00 00 00 js 2fc <runcmd+0x11c>
|
|
if (fork1() == 0) {
|
|
25a: e8 61 ff ff ff call 1c0 <fork1>
|
|
25f: 85 c0 test %eax,%eax
|
|
261: 0f 84 a2 00 00 00 je 309 <runcmd+0x129>
|
|
if (fork1() == 0) {
|
|
267: e8 54 ff ff ff call 1c0 <fork1>
|
|
26c: 85 c0 test %eax,%eax
|
|
26e: 0f 84 c3 00 00 00 je 337 <runcmd+0x157>
|
|
close(p[0]);
|
|
274: 83 ec 0c sub $0xc,%esp
|
|
277: ff 75 f0 push -0x10(%ebp)
|
|
27a: e8 6c 0c 00 00 call eeb <close>
|
|
close(p[1]);
|
|
27f: 58 pop %eax
|
|
280: ff 75 f4 push -0xc(%ebp)
|
|
283: e8 63 0c 00 00 call eeb <close>
|
|
wait();
|
|
288: e8 ce 0b 00 00 call e5b <wait>
|
|
wait();
|
|
28d: e8 c9 0b 00 00 call e5b <wait>
|
|
break;
|
|
292: 83 c4 10 add $0x10,%esp
|
|
295: eb 99 jmp 230 <runcmd+0x50>
|
|
if (fork1() == 0) {
|
|
297: e8 24 ff ff ff call 1c0 <fork1>
|
|
29c: 85 c0 test %eax,%eax
|
|
29e: 74 2f je 2cf <runcmd+0xef>
|
|
wait();
|
|
2a0: e8 b6 0b 00 00 call e5b <wait>
|
|
runcmd(lcmd->right);
|
|
2a5: 83 ec 0c sub $0xc,%esp
|
|
2a8: ff 73 08 push 0x8(%ebx)
|
|
2ab: e8 30 ff ff ff call 1e0 <runcmd>
|
|
close(rcmd->fd);
|
|
2b0: 83 ec 0c sub $0xc,%esp
|
|
2b3: ff 73 14 push 0x14(%ebx)
|
|
2b6: e8 30 0c 00 00 call eeb <close>
|
|
if (open(rcmd->file, rcmd->mode) < 0) {
|
|
2bb: 58 pop %eax
|
|
2bc: 5a pop %edx
|
|
2bd: ff 73 10 push 0x10(%ebx)
|
|
2c0: ff 73 08 push 0x8(%ebx)
|
|
2c3: e8 f3 0b 00 00 call ebb <open>
|
|
2c8: 83 c4 10 add $0x10,%esp
|
|
2cb: 85 c0 test %eax,%eax
|
|
2cd: 78 18 js 2e7 <runcmd+0x107>
|
|
runcmd(bcmd->cmd);
|
|
2cf: 83 ec 0c sub $0xc,%esp
|
|
2d2: ff 73 04 push 0x4(%ebx)
|
|
2d5: e8 06 ff ff ff call 1e0 <runcmd>
|
|
panic("runcmd");
|
|
2da: 83 ec 0c sub $0xc,%esp
|
|
2dd: 68 00 13 00 00 push $0x1300
|
|
2e2: e8 b9 fe ff ff call 1a0 <panic>
|
|
printf(2, "open %s failed\n", rcmd->file);
|
|
2e7: 51 push %ecx
|
|
2e8: ff 73 08 push 0x8(%ebx)
|
|
2eb: 68 17 13 00 00 push $0x1317
|
|
2f0: 6a 02 push $0x2
|
|
2f2: e8 d9 0c 00 00 call fd0 <printf>
|
|
exit();
|
|
2f7: e8 57 0b 00 00 call e53 <exit>
|
|
panic("pipe");
|
|
2fc: 83 ec 0c sub $0xc,%esp
|
|
2ff: 68 27 13 00 00 push $0x1327
|
|
304: e8 97 fe ff ff call 1a0 <panic>
|
|
close(1);
|
|
309: 83 ec 0c sub $0xc,%esp
|
|
30c: 6a 01 push $0x1
|
|
30e: e8 d8 0b 00 00 call eeb <close>
|
|
dup(p[1]);
|
|
313: 58 pop %eax
|
|
314: ff 75 f4 push -0xc(%ebp)
|
|
317: e8 77 0b 00 00 call e93 <dup>
|
|
close(p[0]);
|
|
31c: 58 pop %eax
|
|
31d: ff 75 f0 push -0x10(%ebp)
|
|
320: e8 c6 0b 00 00 call eeb <close>
|
|
close(p[1]);
|
|
325: 58 pop %eax
|
|
326: ff 75 f4 push -0xc(%ebp)
|
|
329: e8 bd 0b 00 00 call eeb <close>
|
|
runcmd(pcmd->left);
|
|
32e: 5a pop %edx
|
|
32f: ff 73 04 push 0x4(%ebx)
|
|
332: e8 a9 fe ff ff call 1e0 <runcmd>
|
|
close(0);
|
|
337: 83 ec 0c sub $0xc,%esp
|
|
33a: 6a 00 push $0x0
|
|
33c: e8 aa 0b 00 00 call eeb <close>
|
|
dup(p[0]);
|
|
341: 5a pop %edx
|
|
342: ff 75 f0 push -0x10(%ebp)
|
|
345: e8 49 0b 00 00 call e93 <dup>
|
|
close(p[0]);
|
|
34a: 59 pop %ecx
|
|
34b: ff 75 f0 push -0x10(%ebp)
|
|
34e: e8 98 0b 00 00 call eeb <close>
|
|
close(p[1]);
|
|
353: 58 pop %eax
|
|
354: ff 75 f4 push -0xc(%ebp)
|
|
357: e8 8f 0b 00 00 call eeb <close>
|
|
runcmd(pcmd->right);
|
|
35c: 58 pop %eax
|
|
35d: ff 73 08 push 0x8(%ebx)
|
|
360: e8 7b fe ff ff call 1e0 <runcmd>
|
|
365: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
36c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
|
|
00000370 <execcmd>:
|
|
|
|
|
|
// Constructors
|
|
|
|
struct cmd* execcmd(void) {
|
|
370: 55 push %ebp
|
|
371: 89 e5 mov %esp,%ebp
|
|
373: 53 push %ebx
|
|
374: 83 ec 10 sub $0x10,%esp
|
|
struct execcmd *cmd;
|
|
|
|
cmd = malloc(sizeof(*cmd));
|
|
377: 6a 54 push $0x54
|
|
379: e8 82 0e 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
37e: 83 c4 0c add $0xc,%esp
|
|
381: 6a 54 push $0x54
|
|
cmd = malloc(sizeof(*cmd));
|
|
383: 89 c3 mov %eax,%ebx
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
385: 6a 00 push $0x0
|
|
387: 50 push %eax
|
|
388: e8 33 09 00 00 call cc0 <memset>
|
|
cmd->type = EXEC;
|
|
38d: c7 03 01 00 00 00 movl $0x1,(%ebx)
|
|
return (struct cmd*)cmd;
|
|
}
|
|
393: 89 d8 mov %ebx,%eax
|
|
395: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
398: c9 leave
|
|
399: c3 ret
|
|
39a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
|
|
000003a0 <redircmd>:
|
|
|
|
struct cmd* redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd) {
|
|
3a0: 55 push %ebp
|
|
3a1: 89 e5 mov %esp,%ebp
|
|
3a3: 53 push %ebx
|
|
3a4: 83 ec 10 sub $0x10,%esp
|
|
struct redircmd *cmd;
|
|
|
|
cmd = malloc(sizeof(*cmd));
|
|
3a7: 6a 18 push $0x18
|
|
3a9: e8 52 0e 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
3ae: 83 c4 0c add $0xc,%esp
|
|
3b1: 6a 18 push $0x18
|
|
cmd = malloc(sizeof(*cmd));
|
|
3b3: 89 c3 mov %eax,%ebx
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
3b5: 6a 00 push $0x0
|
|
3b7: 50 push %eax
|
|
3b8: e8 03 09 00 00 call cc0 <memset>
|
|
cmd->type = REDIR;
|
|
cmd->cmd = subcmd;
|
|
3bd: 8b 45 08 mov 0x8(%ebp),%eax
|
|
cmd->type = REDIR;
|
|
3c0: c7 03 02 00 00 00 movl $0x2,(%ebx)
|
|
cmd->cmd = subcmd;
|
|
3c6: 89 43 04 mov %eax,0x4(%ebx)
|
|
cmd->file = file;
|
|
3c9: 8b 45 0c mov 0xc(%ebp),%eax
|
|
3cc: 89 43 08 mov %eax,0x8(%ebx)
|
|
cmd->efile = efile;
|
|
3cf: 8b 45 10 mov 0x10(%ebp),%eax
|
|
3d2: 89 43 0c mov %eax,0xc(%ebx)
|
|
cmd->mode = mode;
|
|
3d5: 8b 45 14 mov 0x14(%ebp),%eax
|
|
3d8: 89 43 10 mov %eax,0x10(%ebx)
|
|
cmd->fd = fd;
|
|
3db: 8b 45 18 mov 0x18(%ebp),%eax
|
|
3de: 89 43 14 mov %eax,0x14(%ebx)
|
|
return (struct cmd*)cmd;
|
|
}
|
|
3e1: 89 d8 mov %ebx,%eax
|
|
3e3: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
3e6: c9 leave
|
|
3e7: c3 ret
|
|
3e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
3ef: 90 nop
|
|
|
|
000003f0 <pipecmd>:
|
|
|
|
struct cmd* pipecmd(struct cmd *left, struct cmd *right) {
|
|
3f0: 55 push %ebp
|
|
3f1: 89 e5 mov %esp,%ebp
|
|
3f3: 53 push %ebx
|
|
3f4: 83 ec 10 sub $0x10,%esp
|
|
struct pipecmd *cmd;
|
|
|
|
cmd = malloc(sizeof(*cmd));
|
|
3f7: 6a 0c push $0xc
|
|
3f9: e8 02 0e 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
3fe: 83 c4 0c add $0xc,%esp
|
|
401: 6a 0c push $0xc
|
|
cmd = malloc(sizeof(*cmd));
|
|
403: 89 c3 mov %eax,%ebx
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
405: 6a 00 push $0x0
|
|
407: 50 push %eax
|
|
408: e8 b3 08 00 00 call cc0 <memset>
|
|
cmd->type = PIPE;
|
|
cmd->left = left;
|
|
40d: 8b 45 08 mov 0x8(%ebp),%eax
|
|
cmd->type = PIPE;
|
|
410: c7 03 03 00 00 00 movl $0x3,(%ebx)
|
|
cmd->left = left;
|
|
416: 89 43 04 mov %eax,0x4(%ebx)
|
|
cmd->right = right;
|
|
419: 8b 45 0c mov 0xc(%ebp),%eax
|
|
41c: 89 43 08 mov %eax,0x8(%ebx)
|
|
return (struct cmd*)cmd;
|
|
}
|
|
41f: 89 d8 mov %ebx,%eax
|
|
421: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
424: c9 leave
|
|
425: c3 ret
|
|
426: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
42d: 8d 76 00 lea 0x0(%esi),%esi
|
|
|
|
00000430 <listcmd>:
|
|
|
|
struct cmd* listcmd(struct cmd *left, struct cmd *right) {
|
|
430: 55 push %ebp
|
|
431: 89 e5 mov %esp,%ebp
|
|
433: 53 push %ebx
|
|
434: 83 ec 10 sub $0x10,%esp
|
|
struct listcmd *cmd;
|
|
|
|
cmd = malloc(sizeof(*cmd));
|
|
437: 6a 0c push $0xc
|
|
439: e8 c2 0d 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
43e: 83 c4 0c add $0xc,%esp
|
|
441: 6a 0c push $0xc
|
|
cmd = malloc(sizeof(*cmd));
|
|
443: 89 c3 mov %eax,%ebx
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
445: 6a 00 push $0x0
|
|
447: 50 push %eax
|
|
448: e8 73 08 00 00 call cc0 <memset>
|
|
cmd->type = LIST;
|
|
cmd->left = left;
|
|
44d: 8b 45 08 mov 0x8(%ebp),%eax
|
|
cmd->type = LIST;
|
|
450: c7 03 04 00 00 00 movl $0x4,(%ebx)
|
|
cmd->left = left;
|
|
456: 89 43 04 mov %eax,0x4(%ebx)
|
|
cmd->right = right;
|
|
459: 8b 45 0c mov 0xc(%ebp),%eax
|
|
45c: 89 43 08 mov %eax,0x8(%ebx)
|
|
return (struct cmd*)cmd;
|
|
}
|
|
45f: 89 d8 mov %ebx,%eax
|
|
461: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
464: c9 leave
|
|
465: c3 ret
|
|
466: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
46d: 8d 76 00 lea 0x0(%esi),%esi
|
|
|
|
00000470 <backcmd>:
|
|
|
|
struct cmd* backcmd(struct cmd *subcmd) {
|
|
470: 55 push %ebp
|
|
471: 89 e5 mov %esp,%ebp
|
|
473: 53 push %ebx
|
|
474: 83 ec 10 sub $0x10,%esp
|
|
struct backcmd *cmd;
|
|
|
|
cmd = malloc(sizeof(*cmd));
|
|
477: 6a 08 push $0x8
|
|
479: e8 82 0d 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
47e: 83 c4 0c add $0xc,%esp
|
|
481: 6a 08 push $0x8
|
|
cmd = malloc(sizeof(*cmd));
|
|
483: 89 c3 mov %eax,%ebx
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
485: 6a 00 push $0x0
|
|
487: 50 push %eax
|
|
488: e8 33 08 00 00 call cc0 <memset>
|
|
cmd->type = BACK;
|
|
cmd->cmd = subcmd;
|
|
48d: 8b 45 08 mov 0x8(%ebp),%eax
|
|
cmd->type = BACK;
|
|
490: c7 03 05 00 00 00 movl $0x5,(%ebx)
|
|
cmd->cmd = subcmd;
|
|
496: 89 43 04 mov %eax,0x4(%ebx)
|
|
return (struct cmd*)cmd;
|
|
}
|
|
499: 89 d8 mov %ebx,%eax
|
|
49b: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
49e: c9 leave
|
|
49f: c3 ret
|
|
|
|
000004a0 <gettoken>:
|
|
// Parsing
|
|
|
|
char whitespace[] = " \t\r\n\v";
|
|
char symbols[] = "<|>&;()";
|
|
|
|
int gettoken(char **ps, char *es, char **q, char **eq) {
|
|
4a0: 55 push %ebp
|
|
4a1: 89 e5 mov %esp,%ebp
|
|
4a3: 57 push %edi
|
|
4a4: 56 push %esi
|
|
4a5: 53 push %ebx
|
|
4a6: 83 ec 0c sub $0xc,%esp
|
|
char *s;
|
|
int ret;
|
|
|
|
s = *ps;
|
|
4a9: 8b 45 08 mov 0x8(%ebp),%eax
|
|
int gettoken(char **ps, char *es, char **q, char **eq) {
|
|
4ac: 8b 5d 0c mov 0xc(%ebp),%ebx
|
|
4af: 8b 75 10 mov 0x10(%ebp),%esi
|
|
s = *ps;
|
|
4b2: 8b 38 mov (%eax),%edi
|
|
while (s < es && strchr(whitespace, *s)) {
|
|
4b4: 39 df cmp %ebx,%edi
|
|
4b6: 72 0f jb 4c7 <gettoken+0x27>
|
|
4b8: eb 25 jmp 4df <gettoken+0x3f>
|
|
4ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
s++;
|
|
4c0: 83 c7 01 add $0x1,%edi
|
|
while (s < es && strchr(whitespace, *s)) {
|
|
4c3: 39 fb cmp %edi,%ebx
|
|
4c5: 74 18 je 4df <gettoken+0x3f>
|
|
4c7: 0f be 07 movsbl (%edi),%eax
|
|
4ca: 83 ec 08 sub $0x8,%esp
|
|
4cd: 50 push %eax
|
|
4ce: 68 1c 1a 00 00 push $0x1a1c
|
|
4d3: e8 08 08 00 00 call ce0 <strchr>
|
|
4d8: 83 c4 10 add $0x10,%esp
|
|
4db: 85 c0 test %eax,%eax
|
|
4dd: 75 e1 jne 4c0 <gettoken+0x20>
|
|
}
|
|
if (q) {
|
|
4df: 85 f6 test %esi,%esi
|
|
4e1: 74 02 je 4e5 <gettoken+0x45>
|
|
*q = s;
|
|
4e3: 89 3e mov %edi,(%esi)
|
|
}
|
|
ret = *s;
|
|
4e5: 0f b6 07 movzbl (%edi),%eax
|
|
switch (*s) {
|
|
4e8: 3c 3c cmp $0x3c,%al
|
|
4ea: 0f 8f d0 00 00 00 jg 5c0 <gettoken+0x120>
|
|
4f0: 3c 3a cmp $0x3a,%al
|
|
4f2: 0f 8f b4 00 00 00 jg 5ac <gettoken+0x10c>
|
|
4f8: 84 c0 test %al,%al
|
|
4fa: 75 44 jne 540 <gettoken+0xa0>
|
|
4fc: 31 f6 xor %esi,%esi
|
|
while (s < es && !strchr(whitespace, *s) && !strchr(symbols, *s)) {
|
|
s++;
|
|
}
|
|
break;
|
|
}
|
|
if (eq) {
|
|
4fe: 8b 55 14 mov 0x14(%ebp),%edx
|
|
501: 85 d2 test %edx,%edx
|
|
503: 74 05 je 50a <gettoken+0x6a>
|
|
*eq = s;
|
|
505: 8b 45 14 mov 0x14(%ebp),%eax
|
|
508: 89 38 mov %edi,(%eax)
|
|
}
|
|
|
|
while (s < es && strchr(whitespace, *s)) {
|
|
50a: 39 df cmp %ebx,%edi
|
|
50c: 72 09 jb 517 <gettoken+0x77>
|
|
50e: eb 1f jmp 52f <gettoken+0x8f>
|
|
s++;
|
|
510: 83 c7 01 add $0x1,%edi
|
|
while (s < es && strchr(whitespace, *s)) {
|
|
513: 39 fb cmp %edi,%ebx
|
|
515: 74 18 je 52f <gettoken+0x8f>
|
|
517: 0f be 07 movsbl (%edi),%eax
|
|
51a: 83 ec 08 sub $0x8,%esp
|
|
51d: 50 push %eax
|
|
51e: 68 1c 1a 00 00 push $0x1a1c
|
|
523: e8 b8 07 00 00 call ce0 <strchr>
|
|
528: 83 c4 10 add $0x10,%esp
|
|
52b: 85 c0 test %eax,%eax
|
|
52d: 75 e1 jne 510 <gettoken+0x70>
|
|
}
|
|
*ps = s;
|
|
52f: 8b 45 08 mov 0x8(%ebp),%eax
|
|
532: 89 38 mov %edi,(%eax)
|
|
return ret;
|
|
}
|
|
534: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
537: 89 f0 mov %esi,%eax
|
|
539: 5b pop %ebx
|
|
53a: 5e pop %esi
|
|
53b: 5f pop %edi
|
|
53c: 5d pop %ebp
|
|
53d: c3 ret
|
|
53e: 66 90 xchg %ax,%ax
|
|
switch (*s) {
|
|
540: 79 5e jns 5a0 <gettoken+0x100>
|
|
while (s < es && !strchr(whitespace, *s) && !strchr(symbols, *s)) {
|
|
542: 39 fb cmp %edi,%ebx
|
|
544: 77 34 ja 57a <gettoken+0xda>
|
|
if (eq) {
|
|
546: 8b 45 14 mov 0x14(%ebp),%eax
|
|
549: be 61 00 00 00 mov $0x61,%esi
|
|
54e: 85 c0 test %eax,%eax
|
|
550: 75 b3 jne 505 <gettoken+0x65>
|
|
552: eb db jmp 52f <gettoken+0x8f>
|
|
554: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
while (s < es && !strchr(whitespace, *s) && !strchr(symbols, *s)) {
|
|
558: 0f be 07 movsbl (%edi),%eax
|
|
55b: 83 ec 08 sub $0x8,%esp
|
|
55e: 50 push %eax
|
|
55f: 68 14 1a 00 00 push $0x1a14
|
|
564: e8 77 07 00 00 call ce0 <strchr>
|
|
569: 83 c4 10 add $0x10,%esp
|
|
56c: 85 c0 test %eax,%eax
|
|
56e: 75 22 jne 592 <gettoken+0xf2>
|
|
s++;
|
|
570: 83 c7 01 add $0x1,%edi
|
|
while (s < es && !strchr(whitespace, *s) && !strchr(symbols, *s)) {
|
|
573: 39 fb cmp %edi,%ebx
|
|
575: 74 cf je 546 <gettoken+0xa6>
|
|
577: 0f b6 07 movzbl (%edi),%eax
|
|
57a: 83 ec 08 sub $0x8,%esp
|
|
57d: 0f be f0 movsbl %al,%esi
|
|
580: 56 push %esi
|
|
581: 68 1c 1a 00 00 push $0x1a1c
|
|
586: e8 55 07 00 00 call ce0 <strchr>
|
|
58b: 83 c4 10 add $0x10,%esp
|
|
58e: 85 c0 test %eax,%eax
|
|
590: 74 c6 je 558 <gettoken+0xb8>
|
|
ret = 'a';
|
|
592: be 61 00 00 00 mov $0x61,%esi
|
|
597: e9 62 ff ff ff jmp 4fe <gettoken+0x5e>
|
|
59c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
switch (*s) {
|
|
5a0: 3c 26 cmp $0x26,%al
|
|
5a2: 74 08 je 5ac <gettoken+0x10c>
|
|
5a4: 8d 48 d8 lea -0x28(%eax),%ecx
|
|
5a7: 80 f9 01 cmp $0x1,%cl
|
|
5aa: 77 96 ja 542 <gettoken+0xa2>
|
|
ret = *s;
|
|
5ac: 0f be f0 movsbl %al,%esi
|
|
s++;
|
|
5af: 83 c7 01 add $0x1,%edi
|
|
break;
|
|
5b2: e9 47 ff ff ff jmp 4fe <gettoken+0x5e>
|
|
5b7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
5be: 66 90 xchg %ax,%ax
|
|
switch (*s) {
|
|
5c0: 3c 3e cmp $0x3e,%al
|
|
5c2: 75 1c jne 5e0 <gettoken+0x140>
|
|
if (*s == '>') {
|
|
5c4: 80 7f 01 3e cmpb $0x3e,0x1(%edi)
|
|
s++;
|
|
5c8: 8d 47 01 lea 0x1(%edi),%eax
|
|
if (*s == '>') {
|
|
5cb: 74 1c je 5e9 <gettoken+0x149>
|
|
s++;
|
|
5cd: 89 c7 mov %eax,%edi
|
|
5cf: be 3e 00 00 00 mov $0x3e,%esi
|
|
5d4: e9 25 ff ff ff jmp 4fe <gettoken+0x5e>
|
|
5d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
switch (*s) {
|
|
5e0: 3c 7c cmp $0x7c,%al
|
|
5e2: 74 c8 je 5ac <gettoken+0x10c>
|
|
5e4: e9 59 ff ff ff jmp 542 <gettoken+0xa2>
|
|
s++;
|
|
5e9: 83 c7 02 add $0x2,%edi
|
|
ret = '+';
|
|
5ec: be 2b 00 00 00 mov $0x2b,%esi
|
|
5f1: e9 08 ff ff ff jmp 4fe <gettoken+0x5e>
|
|
5f6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
5fd: 8d 76 00 lea 0x0(%esi),%esi
|
|
|
|
00000600 <peek>:
|
|
|
|
int peek(char **ps, char *es, char *toks) {
|
|
600: 55 push %ebp
|
|
601: 89 e5 mov %esp,%ebp
|
|
603: 57 push %edi
|
|
604: 56 push %esi
|
|
605: 53 push %ebx
|
|
606: 83 ec 0c sub $0xc,%esp
|
|
609: 8b 7d 08 mov 0x8(%ebp),%edi
|
|
60c: 8b 75 0c mov 0xc(%ebp),%esi
|
|
char *s;
|
|
|
|
s = *ps;
|
|
60f: 8b 1f mov (%edi),%ebx
|
|
while (s < es && strchr(whitespace, *s)) {
|
|
611: 39 f3 cmp %esi,%ebx
|
|
613: 72 12 jb 627 <peek+0x27>
|
|
615: eb 28 jmp 63f <peek+0x3f>
|
|
617: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
61e: 66 90 xchg %ax,%ax
|
|
s++;
|
|
620: 83 c3 01 add $0x1,%ebx
|
|
while (s < es && strchr(whitespace, *s)) {
|
|
623: 39 de cmp %ebx,%esi
|
|
625: 74 18 je 63f <peek+0x3f>
|
|
627: 0f be 03 movsbl (%ebx),%eax
|
|
62a: 83 ec 08 sub $0x8,%esp
|
|
62d: 50 push %eax
|
|
62e: 68 1c 1a 00 00 push $0x1a1c
|
|
633: e8 a8 06 00 00 call ce0 <strchr>
|
|
638: 83 c4 10 add $0x10,%esp
|
|
63b: 85 c0 test %eax,%eax
|
|
63d: 75 e1 jne 620 <peek+0x20>
|
|
}
|
|
*ps = s;
|
|
63f: 89 1f mov %ebx,(%edi)
|
|
return *s && strchr(toks, *s);
|
|
641: 0f be 03 movsbl (%ebx),%eax
|
|
644: 31 d2 xor %edx,%edx
|
|
646: 84 c0 test %al,%al
|
|
648: 75 0e jne 658 <peek+0x58>
|
|
}
|
|
64a: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
64d: 89 d0 mov %edx,%eax
|
|
64f: 5b pop %ebx
|
|
650: 5e pop %esi
|
|
651: 5f pop %edi
|
|
652: 5d pop %ebp
|
|
653: c3 ret
|
|
654: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
return *s && strchr(toks, *s);
|
|
658: 83 ec 08 sub $0x8,%esp
|
|
65b: 50 push %eax
|
|
65c: ff 75 10 push 0x10(%ebp)
|
|
65f: e8 7c 06 00 00 call ce0 <strchr>
|
|
664: 83 c4 10 add $0x10,%esp
|
|
667: 31 d2 xor %edx,%edx
|
|
669: 85 c0 test %eax,%eax
|
|
66b: 0f 95 c2 setne %dl
|
|
}
|
|
66e: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
671: 5b pop %ebx
|
|
672: 89 d0 mov %edx,%eax
|
|
674: 5e pop %esi
|
|
675: 5f pop %edi
|
|
676: 5d pop %ebp
|
|
677: c3 ret
|
|
678: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
67f: 90 nop
|
|
|
|
00000680 <parseredirs>:
|
|
cmd = pipecmd(cmd, parsepipe(ps, es));
|
|
}
|
|
return cmd;
|
|
}
|
|
|
|
struct cmd* parseredirs(struct cmd *cmd, char **ps, char *es) {
|
|
680: 55 push %ebp
|
|
681: 89 e5 mov %esp,%ebp
|
|
683: 57 push %edi
|
|
684: 56 push %esi
|
|
685: 53 push %ebx
|
|
686: 83 ec 2c sub $0x2c,%esp
|
|
689: 8b 75 0c mov 0xc(%ebp),%esi
|
|
68c: 8b 5d 10 mov 0x10(%ebp),%ebx
|
|
int tok;
|
|
char *q, *eq;
|
|
|
|
while (peek(ps, es, "<>")) {
|
|
68f: 90 nop
|
|
690: 83 ec 04 sub $0x4,%esp
|
|
693: 68 49 13 00 00 push $0x1349
|
|
698: 53 push %ebx
|
|
699: 56 push %esi
|
|
69a: e8 61 ff ff ff call 600 <peek>
|
|
69f: 83 c4 10 add $0x10,%esp
|
|
6a2: 85 c0 test %eax,%eax
|
|
6a4: 0f 84 f6 00 00 00 je 7a0 <parseredirs+0x120>
|
|
tok = gettoken(ps, es, 0, 0);
|
|
6aa: 6a 00 push $0x0
|
|
6ac: 6a 00 push $0x0
|
|
6ae: 53 push %ebx
|
|
6af: 56 push %esi
|
|
6b0: e8 eb fd ff ff call 4a0 <gettoken>
|
|
6b5: 89 c7 mov %eax,%edi
|
|
if (gettoken(ps, es, &q, &eq) != 'a') {
|
|
6b7: 8d 45 e4 lea -0x1c(%ebp),%eax
|
|
6ba: 50 push %eax
|
|
6bb: 8d 45 e0 lea -0x20(%ebp),%eax
|
|
6be: 50 push %eax
|
|
6bf: 53 push %ebx
|
|
6c0: 56 push %esi
|
|
6c1: e8 da fd ff ff call 4a0 <gettoken>
|
|
6c6: 83 c4 20 add $0x20,%esp
|
|
6c9: 83 f8 61 cmp $0x61,%eax
|
|
6cc: 0f 85 d9 00 00 00 jne 7ab <parseredirs+0x12b>
|
|
panic("missing file for redirection");
|
|
}
|
|
switch (tok) {
|
|
6d2: 83 ff 3c cmp $0x3c,%edi
|
|
6d5: 74 69 je 740 <parseredirs+0xc0>
|
|
6d7: 83 ff 3e cmp $0x3e,%edi
|
|
6da: 74 05 je 6e1 <parseredirs+0x61>
|
|
6dc: 83 ff 2b cmp $0x2b,%edi
|
|
6df: 75 af jne 690 <parseredirs+0x10>
|
|
cmd = malloc(sizeof(*cmd));
|
|
6e1: 83 ec 0c sub $0xc,%esp
|
|
break;
|
|
case '>':
|
|
cmd = redircmd(cmd, q, eq, O_WRONLY | O_CREATE, 1);
|
|
break;
|
|
case '+': // >>
|
|
cmd = redircmd(cmd, q, eq, O_WRONLY | O_CREATE, 1);
|
|
6e4: 8b 55 e4 mov -0x1c(%ebp),%edx
|
|
6e7: 8b 4d e0 mov -0x20(%ebp),%ecx
|
|
cmd = malloc(sizeof(*cmd));
|
|
6ea: 6a 18 push $0x18
|
|
cmd = redircmd(cmd, q, eq, O_WRONLY | O_CREATE, 1);
|
|
6ec: 89 55 d0 mov %edx,-0x30(%ebp)
|
|
6ef: 89 4d d4 mov %ecx,-0x2c(%ebp)
|
|
cmd = malloc(sizeof(*cmd));
|
|
6f2: e8 09 0b 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
6f7: 83 c4 0c add $0xc,%esp
|
|
6fa: 6a 18 push $0x18
|
|
cmd = malloc(sizeof(*cmd));
|
|
6fc: 89 c7 mov %eax,%edi
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
6fe: 6a 00 push $0x0
|
|
700: 50 push %eax
|
|
701: e8 ba 05 00 00 call cc0 <memset>
|
|
cmd->type = REDIR;
|
|
706: c7 07 02 00 00 00 movl $0x2,(%edi)
|
|
cmd->cmd = subcmd;
|
|
70c: 8b 45 08 mov 0x8(%ebp),%eax
|
|
break;
|
|
70f: 83 c4 10 add $0x10,%esp
|
|
cmd->cmd = subcmd;
|
|
712: 89 47 04 mov %eax,0x4(%edi)
|
|
cmd->file = file;
|
|
715: 8b 4d d4 mov -0x2c(%ebp),%ecx
|
|
718: 89 4f 08 mov %ecx,0x8(%edi)
|
|
cmd->efile = efile;
|
|
71b: 8b 55 d0 mov -0x30(%ebp),%edx
|
|
cmd->mode = mode;
|
|
71e: c7 47 10 01 02 00 00 movl $0x201,0x10(%edi)
|
|
cmd->efile = efile;
|
|
725: 89 57 0c mov %edx,0xc(%edi)
|
|
cmd->fd = fd;
|
|
728: c7 47 14 01 00 00 00 movl $0x1,0x14(%edi)
|
|
break;
|
|
72f: 89 7d 08 mov %edi,0x8(%ebp)
|
|
732: e9 59 ff ff ff jmp 690 <parseredirs+0x10>
|
|
737: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
73e: 66 90 xchg %ax,%ax
|
|
cmd = malloc(sizeof(*cmd));
|
|
740: 83 ec 0c sub $0xc,%esp
|
|
cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
|
|
743: 8b 55 e4 mov -0x1c(%ebp),%edx
|
|
746: 8b 4d e0 mov -0x20(%ebp),%ecx
|
|
cmd = malloc(sizeof(*cmd));
|
|
749: 6a 18 push $0x18
|
|
cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
|
|
74b: 89 55 d0 mov %edx,-0x30(%ebp)
|
|
74e: 89 4d d4 mov %ecx,-0x2c(%ebp)
|
|
cmd = malloc(sizeof(*cmd));
|
|
751: e8 aa 0a 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
756: 83 c4 0c add $0xc,%esp
|
|
759: 6a 18 push $0x18
|
|
cmd = malloc(sizeof(*cmd));
|
|
75b: 89 c7 mov %eax,%edi
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
75d: 6a 00 push $0x0
|
|
75f: 50 push %eax
|
|
760: e8 5b 05 00 00 call cc0 <memset>
|
|
cmd->cmd = subcmd;
|
|
765: 8b 45 08 mov 0x8(%ebp),%eax
|
|
cmd->file = file;
|
|
768: 8b 4d d4 mov -0x2c(%ebp),%ecx
|
|
break;
|
|
76b: 89 7d 08 mov %edi,0x8(%ebp)
|
|
cmd->efile = efile;
|
|
76e: 8b 55 d0 mov -0x30(%ebp),%edx
|
|
cmd->type = REDIR;
|
|
771: c7 07 02 00 00 00 movl $0x2,(%edi)
|
|
break;
|
|
777: 83 c4 10 add $0x10,%esp
|
|
cmd->cmd = subcmd;
|
|
77a: 89 47 04 mov %eax,0x4(%edi)
|
|
cmd->file = file;
|
|
77d: 89 4f 08 mov %ecx,0x8(%edi)
|
|
cmd->efile = efile;
|
|
780: 89 57 0c mov %edx,0xc(%edi)
|
|
cmd->mode = mode;
|
|
783: c7 47 10 00 00 00 00 movl $0x0,0x10(%edi)
|
|
cmd->fd = fd;
|
|
78a: c7 47 14 00 00 00 00 movl $0x0,0x14(%edi)
|
|
break;
|
|
791: e9 fa fe ff ff jmp 690 <parseredirs+0x10>
|
|
796: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
79d: 8d 76 00 lea 0x0(%esi),%esi
|
|
}
|
|
}
|
|
return cmd;
|
|
}
|
|
7a0: 8b 45 08 mov 0x8(%ebp),%eax
|
|
7a3: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
7a6: 5b pop %ebx
|
|
7a7: 5e pop %esi
|
|
7a8: 5f pop %edi
|
|
7a9: 5d pop %ebp
|
|
7aa: c3 ret
|
|
panic("missing file for redirection");
|
|
7ab: 83 ec 0c sub $0xc,%esp
|
|
7ae: 68 2c 13 00 00 push $0x132c
|
|
7b3: e8 e8 f9 ff ff call 1a0 <panic>
|
|
7b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
7bf: 90 nop
|
|
|
|
000007c0 <parseexec>:
|
|
gettoken(ps, es, 0, 0);
|
|
cmd = parseredirs(cmd, ps, es);
|
|
return cmd;
|
|
}
|
|
|
|
struct cmd* parseexec(char **ps, char *es) {
|
|
7c0: 55 push %ebp
|
|
7c1: 89 e5 mov %esp,%ebp
|
|
7c3: 57 push %edi
|
|
7c4: 56 push %esi
|
|
7c5: 53 push %ebx
|
|
7c6: 83 ec 30 sub $0x30,%esp
|
|
7c9: 8b 75 08 mov 0x8(%ebp),%esi
|
|
7cc: 8b 7d 0c mov 0xc(%ebp),%edi
|
|
char *q, *eq;
|
|
int tok, argc;
|
|
struct execcmd *cmd;
|
|
struct cmd *ret;
|
|
|
|
if (peek(ps, es, "(")) {
|
|
7cf: 68 4c 13 00 00 push $0x134c
|
|
7d4: 57 push %edi
|
|
7d5: 56 push %esi
|
|
7d6: e8 25 fe ff ff call 600 <peek>
|
|
7db: 83 c4 10 add $0x10,%esp
|
|
7de: 85 c0 test %eax,%eax
|
|
7e0: 0f 85 aa 00 00 00 jne 890 <parseexec+0xd0>
|
|
cmd = malloc(sizeof(*cmd));
|
|
7e6: 83 ec 0c sub $0xc,%esp
|
|
7e9: 89 c3 mov %eax,%ebx
|
|
7eb: 6a 54 push $0x54
|
|
7ed: e8 0e 0a 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
7f2: 83 c4 0c add $0xc,%esp
|
|
7f5: 6a 54 push $0x54
|
|
7f7: 6a 00 push $0x0
|
|
7f9: 50 push %eax
|
|
7fa: 89 45 d0 mov %eax,-0x30(%ebp)
|
|
7fd: e8 be 04 00 00 call cc0 <memset>
|
|
cmd->type = EXEC;
|
|
802: 8b 45 d0 mov -0x30(%ebp),%eax
|
|
|
|
ret = execcmd();
|
|
cmd = (struct execcmd*)ret;
|
|
|
|
argc = 0;
|
|
ret = parseredirs(ret, ps, es);
|
|
805: 83 c4 0c add $0xc,%esp
|
|
cmd->type = EXEC;
|
|
808: c7 00 01 00 00 00 movl $0x1,(%eax)
|
|
ret = parseredirs(ret, ps, es);
|
|
80e: 57 push %edi
|
|
80f: 56 push %esi
|
|
810: 50 push %eax
|
|
811: e8 6a fe ff ff call 680 <parseredirs>
|
|
while (!peek(ps, es, "|)&;")) {
|
|
816: 83 c4 10 add $0x10,%esp
|
|
ret = parseredirs(ret, ps, es);
|
|
819: 89 45 d4 mov %eax,-0x2c(%ebp)
|
|
while (!peek(ps, es, "|)&;")) {
|
|
81c: eb 15 jmp 833 <parseexec+0x73>
|
|
81e: 66 90 xchg %ax,%ax
|
|
cmd->eargv[argc] = eq;
|
|
argc++;
|
|
if (argc >= MAXARGS) {
|
|
panic("too many args");
|
|
}
|
|
ret = parseredirs(ret, ps, es);
|
|
820: 83 ec 04 sub $0x4,%esp
|
|
823: 57 push %edi
|
|
824: 56 push %esi
|
|
825: ff 75 d4 push -0x2c(%ebp)
|
|
828: e8 53 fe ff ff call 680 <parseredirs>
|
|
82d: 83 c4 10 add $0x10,%esp
|
|
830: 89 45 d4 mov %eax,-0x2c(%ebp)
|
|
while (!peek(ps, es, "|)&;")) {
|
|
833: 83 ec 04 sub $0x4,%esp
|
|
836: 68 63 13 00 00 push $0x1363
|
|
83b: 57 push %edi
|
|
83c: 56 push %esi
|
|
83d: e8 be fd ff ff call 600 <peek>
|
|
842: 83 c4 10 add $0x10,%esp
|
|
845: 85 c0 test %eax,%eax
|
|
847: 75 5f jne 8a8 <parseexec+0xe8>
|
|
if ((tok = gettoken(ps, es, &q, &eq)) == 0) {
|
|
849: 8d 45 e4 lea -0x1c(%ebp),%eax
|
|
84c: 50 push %eax
|
|
84d: 8d 45 e0 lea -0x20(%ebp),%eax
|
|
850: 50 push %eax
|
|
851: 57 push %edi
|
|
852: 56 push %esi
|
|
853: e8 48 fc ff ff call 4a0 <gettoken>
|
|
858: 83 c4 10 add $0x10,%esp
|
|
85b: 85 c0 test %eax,%eax
|
|
85d: 74 49 je 8a8 <parseexec+0xe8>
|
|
if (tok != 'a') {
|
|
85f: 83 f8 61 cmp $0x61,%eax
|
|
862: 75 62 jne 8c6 <parseexec+0x106>
|
|
cmd->argv[argc] = q;
|
|
864: 8b 45 e0 mov -0x20(%ebp),%eax
|
|
867: 8b 55 d0 mov -0x30(%ebp),%edx
|
|
86a: 89 44 9a 04 mov %eax,0x4(%edx,%ebx,4)
|
|
cmd->eargv[argc] = eq;
|
|
86e: 8b 45 e4 mov -0x1c(%ebp),%eax
|
|
871: 89 44 9a 2c mov %eax,0x2c(%edx,%ebx,4)
|
|
argc++;
|
|
875: 83 c3 01 add $0x1,%ebx
|
|
if (argc >= MAXARGS) {
|
|
878: 83 fb 0a cmp $0xa,%ebx
|
|
87b: 75 a3 jne 820 <parseexec+0x60>
|
|
panic("too many args");
|
|
87d: 83 ec 0c sub $0xc,%esp
|
|
880: 68 55 13 00 00 push $0x1355
|
|
885: e8 16 f9 ff ff call 1a0 <panic>
|
|
88a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
return parseblock(ps, es);
|
|
890: 89 7d 0c mov %edi,0xc(%ebp)
|
|
893: 89 75 08 mov %esi,0x8(%ebp)
|
|
}
|
|
cmd->argv[argc] = 0;
|
|
cmd->eargv[argc] = 0;
|
|
return ret;
|
|
}
|
|
896: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
899: 5b pop %ebx
|
|
89a: 5e pop %esi
|
|
89b: 5f pop %edi
|
|
89c: 5d pop %ebp
|
|
return parseblock(ps, es);
|
|
89d: e9 ae 01 00 00 jmp a50 <parseblock>
|
|
8a2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
cmd->argv[argc] = 0;
|
|
8a8: 8b 45 d0 mov -0x30(%ebp),%eax
|
|
8ab: c7 44 98 04 00 00 00 movl $0x0,0x4(%eax,%ebx,4)
|
|
8b2: 00
|
|
cmd->eargv[argc] = 0;
|
|
8b3: c7 44 98 2c 00 00 00 movl $0x0,0x2c(%eax,%ebx,4)
|
|
8ba: 00
|
|
}
|
|
8bb: 8b 45 d4 mov -0x2c(%ebp),%eax
|
|
8be: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
8c1: 5b pop %ebx
|
|
8c2: 5e pop %esi
|
|
8c3: 5f pop %edi
|
|
8c4: 5d pop %ebp
|
|
8c5: c3 ret
|
|
panic("syntax");
|
|
8c6: 83 ec 0c sub $0xc,%esp
|
|
8c9: 68 4e 13 00 00 push $0x134e
|
|
8ce: e8 cd f8 ff ff call 1a0 <panic>
|
|
8d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
8da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
|
|
000008e0 <parsepipe>:
|
|
struct cmd* parsepipe(char **ps, char *es) {
|
|
8e0: 55 push %ebp
|
|
8e1: 89 e5 mov %esp,%ebp
|
|
8e3: 57 push %edi
|
|
8e4: 56 push %esi
|
|
8e5: 53 push %ebx
|
|
8e6: 83 ec 14 sub $0x14,%esp
|
|
8e9: 8b 75 08 mov 0x8(%ebp),%esi
|
|
8ec: 8b 7d 0c mov 0xc(%ebp),%edi
|
|
cmd = parseexec(ps, es);
|
|
8ef: 57 push %edi
|
|
8f0: 56 push %esi
|
|
8f1: e8 ca fe ff ff call 7c0 <parseexec>
|
|
if (peek(ps, es, "|")) {
|
|
8f6: 83 c4 0c add $0xc,%esp
|
|
8f9: 68 68 13 00 00 push $0x1368
|
|
cmd = parseexec(ps, es);
|
|
8fe: 89 c3 mov %eax,%ebx
|
|
if (peek(ps, es, "|")) {
|
|
900: 57 push %edi
|
|
901: 56 push %esi
|
|
902: e8 f9 fc ff ff call 600 <peek>
|
|
907: 83 c4 10 add $0x10,%esp
|
|
90a: 85 c0 test %eax,%eax
|
|
90c: 75 12 jne 920 <parsepipe+0x40>
|
|
}
|
|
90e: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
911: 89 d8 mov %ebx,%eax
|
|
913: 5b pop %ebx
|
|
914: 5e pop %esi
|
|
915: 5f pop %edi
|
|
916: 5d pop %ebp
|
|
917: c3 ret
|
|
918: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
91f: 90 nop
|
|
gettoken(ps, es, 0, 0);
|
|
920: 6a 00 push $0x0
|
|
922: 6a 00 push $0x0
|
|
924: 57 push %edi
|
|
925: 56 push %esi
|
|
926: e8 75 fb ff ff call 4a0 <gettoken>
|
|
cmd = pipecmd(cmd, parsepipe(ps, es));
|
|
92b: 58 pop %eax
|
|
92c: 5a pop %edx
|
|
92d: 57 push %edi
|
|
92e: 56 push %esi
|
|
92f: e8 ac ff ff ff call 8e0 <parsepipe>
|
|
cmd = malloc(sizeof(*cmd));
|
|
934: c7 04 24 0c 00 00 00 movl $0xc,(%esp)
|
|
cmd = pipecmd(cmd, parsepipe(ps, es));
|
|
93b: 89 c7 mov %eax,%edi
|
|
cmd = malloc(sizeof(*cmd));
|
|
93d: e8 be 08 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
942: 83 c4 0c add $0xc,%esp
|
|
945: 6a 0c push $0xc
|
|
cmd = malloc(sizeof(*cmd));
|
|
947: 89 c6 mov %eax,%esi
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
949: 6a 00 push $0x0
|
|
94b: 50 push %eax
|
|
94c: e8 6f 03 00 00 call cc0 <memset>
|
|
cmd->left = left;
|
|
951: 89 5e 04 mov %ebx,0x4(%esi)
|
|
cmd->right = right;
|
|
954: 83 c4 10 add $0x10,%esp
|
|
957: 89 f3 mov %esi,%ebx
|
|
cmd->type = PIPE;
|
|
959: c7 06 03 00 00 00 movl $0x3,(%esi)
|
|
}
|
|
95f: 89 d8 mov %ebx,%eax
|
|
cmd->right = right;
|
|
961: 89 7e 08 mov %edi,0x8(%esi)
|
|
}
|
|
964: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
967: 5b pop %ebx
|
|
968: 5e pop %esi
|
|
969: 5f pop %edi
|
|
96a: 5d pop %ebp
|
|
96b: c3 ret
|
|
96c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
|
|
00000970 <parseline>:
|
|
struct cmd* parseline(char **ps, char *es) {
|
|
970: 55 push %ebp
|
|
971: 89 e5 mov %esp,%ebp
|
|
973: 57 push %edi
|
|
974: 56 push %esi
|
|
975: 53 push %ebx
|
|
976: 83 ec 24 sub $0x24,%esp
|
|
979: 8b 75 08 mov 0x8(%ebp),%esi
|
|
97c: 8b 7d 0c mov 0xc(%ebp),%edi
|
|
cmd = parsepipe(ps, es);
|
|
97f: 57 push %edi
|
|
980: 56 push %esi
|
|
981: e8 5a ff ff ff call 8e0 <parsepipe>
|
|
while (peek(ps, es, "&")) {
|
|
986: 83 c4 10 add $0x10,%esp
|
|
cmd = parsepipe(ps, es);
|
|
989: 89 c3 mov %eax,%ebx
|
|
while (peek(ps, es, "&")) {
|
|
98b: eb 3b jmp 9c8 <parseline+0x58>
|
|
98d: 8d 76 00 lea 0x0(%esi),%esi
|
|
gettoken(ps, es, 0, 0);
|
|
990: 6a 00 push $0x0
|
|
992: 6a 00 push $0x0
|
|
994: 57 push %edi
|
|
995: 56 push %esi
|
|
996: e8 05 fb ff ff call 4a0 <gettoken>
|
|
cmd = malloc(sizeof(*cmd));
|
|
99b: c7 04 24 08 00 00 00 movl $0x8,(%esp)
|
|
9a2: e8 59 08 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
9a7: 83 c4 0c add $0xc,%esp
|
|
9aa: 6a 08 push $0x8
|
|
9ac: 6a 00 push $0x0
|
|
9ae: 50 push %eax
|
|
9af: 89 45 e4 mov %eax,-0x1c(%ebp)
|
|
9b2: e8 09 03 00 00 call cc0 <memset>
|
|
cmd->type = BACK;
|
|
9b7: 8b 55 e4 mov -0x1c(%ebp),%edx
|
|
cmd->cmd = subcmd;
|
|
9ba: 83 c4 10 add $0x10,%esp
|
|
cmd->type = BACK;
|
|
9bd: c7 02 05 00 00 00 movl $0x5,(%edx)
|
|
cmd->cmd = subcmd;
|
|
9c3: 89 5a 04 mov %ebx,0x4(%edx)
|
|
9c6: 89 d3 mov %edx,%ebx
|
|
while (peek(ps, es, "&")) {
|
|
9c8: 83 ec 04 sub $0x4,%esp
|
|
9cb: 68 6a 13 00 00 push $0x136a
|
|
9d0: 57 push %edi
|
|
9d1: 56 push %esi
|
|
9d2: e8 29 fc ff ff call 600 <peek>
|
|
9d7: 83 c4 10 add $0x10,%esp
|
|
9da: 85 c0 test %eax,%eax
|
|
9dc: 75 b2 jne 990 <parseline+0x20>
|
|
if (peek(ps, es, ";")) {
|
|
9de: 83 ec 04 sub $0x4,%esp
|
|
9e1: 68 66 13 00 00 push $0x1366
|
|
9e6: 57 push %edi
|
|
9e7: 56 push %esi
|
|
9e8: e8 13 fc ff ff call 600 <peek>
|
|
9ed: 83 c4 10 add $0x10,%esp
|
|
9f0: 85 c0 test %eax,%eax
|
|
9f2: 75 0c jne a00 <parseline+0x90>
|
|
}
|
|
9f4: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
9f7: 89 d8 mov %ebx,%eax
|
|
9f9: 5b pop %ebx
|
|
9fa: 5e pop %esi
|
|
9fb: 5f pop %edi
|
|
9fc: 5d pop %ebp
|
|
9fd: c3 ret
|
|
9fe: 66 90 xchg %ax,%ax
|
|
gettoken(ps, es, 0, 0);
|
|
a00: 6a 00 push $0x0
|
|
a02: 6a 00 push $0x0
|
|
a04: 57 push %edi
|
|
a05: 56 push %esi
|
|
a06: e8 95 fa ff ff call 4a0 <gettoken>
|
|
cmd = listcmd(cmd, parseline(ps, es));
|
|
a0b: 58 pop %eax
|
|
a0c: 5a pop %edx
|
|
a0d: 57 push %edi
|
|
a0e: 56 push %esi
|
|
a0f: e8 5c ff ff ff call 970 <parseline>
|
|
cmd = malloc(sizeof(*cmd));
|
|
a14: c7 04 24 0c 00 00 00 movl $0xc,(%esp)
|
|
cmd = listcmd(cmd, parseline(ps, es));
|
|
a1b: 89 c7 mov %eax,%edi
|
|
cmd = malloc(sizeof(*cmd));
|
|
a1d: e8 de 07 00 00 call 1200 <malloc>
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
a22: 83 c4 0c add $0xc,%esp
|
|
a25: 6a 0c push $0xc
|
|
cmd = malloc(sizeof(*cmd));
|
|
a27: 89 c6 mov %eax,%esi
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
a29: 6a 00 push $0x0
|
|
a2b: 50 push %eax
|
|
a2c: e8 8f 02 00 00 call cc0 <memset>
|
|
cmd->left = left;
|
|
a31: 89 5e 04 mov %ebx,0x4(%esi)
|
|
cmd->right = right;
|
|
a34: 83 c4 10 add $0x10,%esp
|
|
a37: 89 f3 mov %esi,%ebx
|
|
cmd->type = LIST;
|
|
a39: c7 06 04 00 00 00 movl $0x4,(%esi)
|
|
}
|
|
a3f: 89 d8 mov %ebx,%eax
|
|
cmd->right = right;
|
|
a41: 89 7e 08 mov %edi,0x8(%esi)
|
|
}
|
|
a44: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
a47: 5b pop %ebx
|
|
a48: 5e pop %esi
|
|
a49: 5f pop %edi
|
|
a4a: 5d pop %ebp
|
|
a4b: c3 ret
|
|
a4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
|
|
00000a50 <parseblock>:
|
|
struct cmd* parseblock(char **ps, char *es) {
|
|
a50: 55 push %ebp
|
|
a51: 89 e5 mov %esp,%ebp
|
|
a53: 57 push %edi
|
|
a54: 56 push %esi
|
|
a55: 53 push %ebx
|
|
a56: 83 ec 10 sub $0x10,%esp
|
|
a59: 8b 5d 08 mov 0x8(%ebp),%ebx
|
|
a5c: 8b 75 0c mov 0xc(%ebp),%esi
|
|
if (!peek(ps, es, "(")) {
|
|
a5f: 68 4c 13 00 00 push $0x134c
|
|
a64: 56 push %esi
|
|
a65: 53 push %ebx
|
|
a66: e8 95 fb ff ff call 600 <peek>
|
|
a6b: 83 c4 10 add $0x10,%esp
|
|
a6e: 85 c0 test %eax,%eax
|
|
a70: 74 4a je abc <parseblock+0x6c>
|
|
gettoken(ps, es, 0, 0);
|
|
a72: 6a 00 push $0x0
|
|
a74: 6a 00 push $0x0
|
|
a76: 56 push %esi
|
|
a77: 53 push %ebx
|
|
a78: e8 23 fa ff ff call 4a0 <gettoken>
|
|
cmd = parseline(ps, es);
|
|
a7d: 58 pop %eax
|
|
a7e: 5a pop %edx
|
|
a7f: 56 push %esi
|
|
a80: 53 push %ebx
|
|
a81: e8 ea fe ff ff call 970 <parseline>
|
|
if (!peek(ps, es, ")")) {
|
|
a86: 83 c4 0c add $0xc,%esp
|
|
a89: 68 88 13 00 00 push $0x1388
|
|
cmd = parseline(ps, es);
|
|
a8e: 89 c7 mov %eax,%edi
|
|
if (!peek(ps, es, ")")) {
|
|
a90: 56 push %esi
|
|
a91: 53 push %ebx
|
|
a92: e8 69 fb ff ff call 600 <peek>
|
|
a97: 83 c4 10 add $0x10,%esp
|
|
a9a: 85 c0 test %eax,%eax
|
|
a9c: 74 2b je ac9 <parseblock+0x79>
|
|
gettoken(ps, es, 0, 0);
|
|
a9e: 6a 00 push $0x0
|
|
aa0: 6a 00 push $0x0
|
|
aa2: 56 push %esi
|
|
aa3: 53 push %ebx
|
|
aa4: e8 f7 f9 ff ff call 4a0 <gettoken>
|
|
cmd = parseredirs(cmd, ps, es);
|
|
aa9: 83 c4 0c add $0xc,%esp
|
|
aac: 56 push %esi
|
|
aad: 53 push %ebx
|
|
aae: 57 push %edi
|
|
aaf: e8 cc fb ff ff call 680 <parseredirs>
|
|
}
|
|
ab4: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
ab7: 5b pop %ebx
|
|
ab8: 5e pop %esi
|
|
ab9: 5f pop %edi
|
|
aba: 5d pop %ebp
|
|
abb: c3 ret
|
|
panic("parseblock");
|
|
abc: 83 ec 0c sub $0xc,%esp
|
|
abf: 68 6c 13 00 00 push $0x136c
|
|
ac4: e8 d7 f6 ff ff call 1a0 <panic>
|
|
panic("syntax - missing )");
|
|
ac9: 83 ec 0c sub $0xc,%esp
|
|
acc: 68 77 13 00 00 push $0x1377
|
|
ad1: e8 ca f6 ff ff call 1a0 <panic>
|
|
ad6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
add: 8d 76 00 lea 0x0(%esi),%esi
|
|
|
|
00000ae0 <nulterminate>:
|
|
|
|
// NUL-terminate all the counted strings.
|
|
struct cmd* nulterminate(struct cmd *cmd) {
|
|
ae0: 55 push %ebp
|
|
ae1: 89 e5 mov %esp,%ebp
|
|
ae3: 53 push %ebx
|
|
ae4: 83 ec 04 sub $0x4,%esp
|
|
ae7: 8b 5d 08 mov 0x8(%ebp),%ebx
|
|
struct execcmd *ecmd;
|
|
struct listcmd *lcmd;
|
|
struct pipecmd *pcmd;
|
|
struct redircmd *rcmd;
|
|
|
|
if (cmd == 0) {
|
|
aea: 85 db test %ebx,%ebx
|
|
aec: 0f 84 8e 00 00 00 je b80 <nulterminate+0xa0>
|
|
return 0;
|
|
}
|
|
|
|
switch (cmd->type) {
|
|
af2: 83 3b 05 cmpl $0x5,(%ebx)
|
|
af5: 77 61 ja b58 <nulterminate+0x78>
|
|
af7: 8b 03 mov (%ebx),%eax
|
|
af9: ff 24 85 c8 13 00 00 jmp *0x13c8(,%eax,4)
|
|
nulterminate(pcmd->right);
|
|
break;
|
|
|
|
case LIST:
|
|
lcmd = (struct listcmd*)cmd;
|
|
nulterminate(lcmd->left);
|
|
b00: 83 ec 0c sub $0xc,%esp
|
|
b03: ff 73 04 push 0x4(%ebx)
|
|
b06: e8 d5 ff ff ff call ae0 <nulterminate>
|
|
nulterminate(lcmd->right);
|
|
b0b: 58 pop %eax
|
|
b0c: ff 73 08 push 0x8(%ebx)
|
|
b0f: e8 cc ff ff ff call ae0 <nulterminate>
|
|
break;
|
|
b14: 83 c4 10 add $0x10,%esp
|
|
b17: 89 d8 mov %ebx,%eax
|
|
bcmd = (struct backcmd*)cmd;
|
|
nulterminate(bcmd->cmd);
|
|
break;
|
|
}
|
|
return cmd;
|
|
}
|
|
b19: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
b1c: c9 leave
|
|
b1d: c3 ret
|
|
b1e: 66 90 xchg %ax,%ax
|
|
nulterminate(bcmd->cmd);
|
|
b20: 83 ec 0c sub $0xc,%esp
|
|
b23: ff 73 04 push 0x4(%ebx)
|
|
b26: e8 b5 ff ff ff call ae0 <nulterminate>
|
|
break;
|
|
b2b: 89 d8 mov %ebx,%eax
|
|
b2d: 83 c4 10 add $0x10,%esp
|
|
}
|
|
b30: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
b33: c9 leave
|
|
b34: c3 ret
|
|
b35: 8d 76 00 lea 0x0(%esi),%esi
|
|
for (i = 0; ecmd->argv[i]; i++) {
|
|
b38: 8b 4b 04 mov 0x4(%ebx),%ecx
|
|
b3b: 8d 43 08 lea 0x8(%ebx),%eax
|
|
b3e: 85 c9 test %ecx,%ecx
|
|
b40: 74 16 je b58 <nulterminate+0x78>
|
|
b42: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
*ecmd->eargv[i] = 0;
|
|
b48: 8b 50 24 mov 0x24(%eax),%edx
|
|
for (i = 0; ecmd->argv[i]; i++) {
|
|
b4b: 83 c0 04 add $0x4,%eax
|
|
*ecmd->eargv[i] = 0;
|
|
b4e: c6 02 00 movb $0x0,(%edx)
|
|
for (i = 0; ecmd->argv[i]; i++) {
|
|
b51: 8b 50 fc mov -0x4(%eax),%edx
|
|
b54: 85 d2 test %edx,%edx
|
|
b56: 75 f0 jne b48 <nulterminate+0x68>
|
|
switch (cmd->type) {
|
|
b58: 89 d8 mov %ebx,%eax
|
|
}
|
|
b5a: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
b5d: c9 leave
|
|
b5e: c3 ret
|
|
b5f: 90 nop
|
|
nulterminate(rcmd->cmd);
|
|
b60: 83 ec 0c sub $0xc,%esp
|
|
b63: ff 73 04 push 0x4(%ebx)
|
|
b66: e8 75 ff ff ff call ae0 <nulterminate>
|
|
*rcmd->efile = 0;
|
|
b6b: 8b 43 0c mov 0xc(%ebx),%eax
|
|
break;
|
|
b6e: 83 c4 10 add $0x10,%esp
|
|
*rcmd->efile = 0;
|
|
b71: c6 00 00 movb $0x0,(%eax)
|
|
break;
|
|
b74: 89 d8 mov %ebx,%eax
|
|
}
|
|
b76: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
b79: c9 leave
|
|
b7a: c3 ret
|
|
b7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
b7f: 90 nop
|
|
return 0;
|
|
b80: 31 c0 xor %eax,%eax
|
|
b82: eb 95 jmp b19 <nulterminate+0x39>
|
|
b84: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
b8b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
b8f: 90 nop
|
|
|
|
00000b90 <parsecmd>:
|
|
struct cmd* parsecmd(char *s) {
|
|
b90: 55 push %ebp
|
|
b91: 89 e5 mov %esp,%ebp
|
|
b93: 57 push %edi
|
|
b94: 56 push %esi
|
|
cmd = parseline(&s, es);
|
|
b95: 8d 7d 08 lea 0x8(%ebp),%edi
|
|
struct cmd* parsecmd(char *s) {
|
|
b98: 53 push %ebx
|
|
b99: 83 ec 18 sub $0x18,%esp
|
|
es = s + strlen(s);
|
|
b9c: 8b 5d 08 mov 0x8(%ebp),%ebx
|
|
b9f: 53 push %ebx
|
|
ba0: e8 eb 00 00 00 call c90 <strlen>
|
|
cmd = parseline(&s, es);
|
|
ba5: 59 pop %ecx
|
|
ba6: 5e pop %esi
|
|
es = s + strlen(s);
|
|
ba7: 01 c3 add %eax,%ebx
|
|
cmd = parseline(&s, es);
|
|
ba9: 53 push %ebx
|
|
baa: 57 push %edi
|
|
bab: e8 c0 fd ff ff call 970 <parseline>
|
|
peek(&s, es, "");
|
|
bb0: 83 c4 0c add $0xc,%esp
|
|
bb3: 68 16 13 00 00 push $0x1316
|
|
cmd = parseline(&s, es);
|
|
bb8: 89 c6 mov %eax,%esi
|
|
peek(&s, es, "");
|
|
bba: 53 push %ebx
|
|
bbb: 57 push %edi
|
|
bbc: e8 3f fa ff ff call 600 <peek>
|
|
if (s != es) {
|
|
bc1: 8b 45 08 mov 0x8(%ebp),%eax
|
|
bc4: 83 c4 10 add $0x10,%esp
|
|
bc7: 39 d8 cmp %ebx,%eax
|
|
bc9: 75 13 jne bde <parsecmd+0x4e>
|
|
nulterminate(cmd);
|
|
bcb: 83 ec 0c sub $0xc,%esp
|
|
bce: 56 push %esi
|
|
bcf: e8 0c ff ff ff call ae0 <nulterminate>
|
|
}
|
|
bd4: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
bd7: 89 f0 mov %esi,%eax
|
|
bd9: 5b pop %ebx
|
|
bda: 5e pop %esi
|
|
bdb: 5f pop %edi
|
|
bdc: 5d pop %ebp
|
|
bdd: c3 ret
|
|
printf(2, "leftovers: %s\n", s);
|
|
bde: 52 push %edx
|
|
bdf: 50 push %eax
|
|
be0: 68 8a 13 00 00 push $0x138a
|
|
be5: 6a 02 push $0x2
|
|
be7: e8 e4 03 00 00 call fd0 <printf>
|
|
panic("syntax");
|
|
bec: c7 04 24 4e 13 00 00 movl $0x134e,(%esp)
|
|
bf3: e8 a8 f5 ff ff call 1a0 <panic>
|
|
bf8: 66 90 xchg %ax,%ax
|
|
bfa: 66 90 xchg %ax,%ax
|
|
bfc: 66 90 xchg %ax,%ax
|
|
bfe: 66 90 xchg %ax,%ax
|
|
|
|
00000c00 <strcpy>:
|
|
#include "stat.h"
|
|
#include "fcntl.h"
|
|
#include "user.h"
|
|
#include "x86.h"
|
|
|
|
char*strcpy(char *s, const char *t) {
|
|
c00: 55 push %ebp
|
|
char *os;
|
|
|
|
os = s;
|
|
while ((*s++ = *t++) != 0) {
|
|
c01: 31 c0 xor %eax,%eax
|
|
char*strcpy(char *s, const char *t) {
|
|
c03: 89 e5 mov %esp,%ebp
|
|
c05: 53 push %ebx
|
|
c06: 8b 4d 08 mov 0x8(%ebp),%ecx
|
|
c09: 8b 5d 0c mov 0xc(%ebp),%ebx
|
|
c0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
while ((*s++ = *t++) != 0) {
|
|
c10: 0f b6 14 03 movzbl (%ebx,%eax,1),%edx
|
|
c14: 88 14 01 mov %dl,(%ecx,%eax,1)
|
|
c17: 83 c0 01 add $0x1,%eax
|
|
c1a: 84 d2 test %dl,%dl
|
|
c1c: 75 f2 jne c10 <strcpy+0x10>
|
|
;
|
|
}
|
|
return os;
|
|
}
|
|
c1e: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
c21: 89 c8 mov %ecx,%eax
|
|
c23: c9 leave
|
|
c24: c3 ret
|
|
c25: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
c2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
|
|
00000c30 <strcmp>:
|
|
|
|
int strcmp(const char *p, const char *q) {
|
|
c30: 55 push %ebp
|
|
c31: 89 e5 mov %esp,%ebp
|
|
c33: 53 push %ebx
|
|
c34: 8b 55 08 mov 0x8(%ebp),%edx
|
|
c37: 8b 4d 0c mov 0xc(%ebp),%ecx
|
|
while (*p && *p == *q) {
|
|
c3a: 0f b6 02 movzbl (%edx),%eax
|
|
c3d: 84 c0 test %al,%al
|
|
c3f: 75 17 jne c58 <strcmp+0x28>
|
|
c41: eb 3a jmp c7d <strcmp+0x4d>
|
|
c43: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
c47: 90 nop
|
|
c48: 0f b6 42 01 movzbl 0x1(%edx),%eax
|
|
p++, q++;
|
|
c4c: 83 c2 01 add $0x1,%edx
|
|
c4f: 8d 59 01 lea 0x1(%ecx),%ebx
|
|
while (*p && *p == *q) {
|
|
c52: 84 c0 test %al,%al
|
|
c54: 74 1a je c70 <strcmp+0x40>
|
|
p++, q++;
|
|
c56: 89 d9 mov %ebx,%ecx
|
|
while (*p && *p == *q) {
|
|
c58: 0f b6 19 movzbl (%ecx),%ebx
|
|
c5b: 38 c3 cmp %al,%bl
|
|
c5d: 74 e9 je c48 <strcmp+0x18>
|
|
}
|
|
return (uchar) * p - (uchar) * q;
|
|
c5f: 29 d8 sub %ebx,%eax
|
|
}
|
|
c61: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
c64: c9 leave
|
|
c65: c3 ret
|
|
c66: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
c6d: 8d 76 00 lea 0x0(%esi),%esi
|
|
return (uchar) * p - (uchar) * q;
|
|
c70: 0f b6 59 01 movzbl 0x1(%ecx),%ebx
|
|
c74: 31 c0 xor %eax,%eax
|
|
c76: 29 d8 sub %ebx,%eax
|
|
}
|
|
c78: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
c7b: c9 leave
|
|
c7c: c3 ret
|
|
return (uchar) * p - (uchar) * q;
|
|
c7d: 0f b6 19 movzbl (%ecx),%ebx
|
|
c80: 31 c0 xor %eax,%eax
|
|
c82: eb db jmp c5f <strcmp+0x2f>
|
|
c84: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
c8b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
c8f: 90 nop
|
|
|
|
00000c90 <strlen>:
|
|
|
|
uint strlen(const char *s) {
|
|
c90: 55 push %ebp
|
|
c91: 89 e5 mov %esp,%ebp
|
|
c93: 8b 55 08 mov 0x8(%ebp),%edx
|
|
int n;
|
|
|
|
for (n = 0; s[n]; n++) {
|
|
c96: 80 3a 00 cmpb $0x0,(%edx)
|
|
c99: 74 15 je cb0 <strlen+0x20>
|
|
c9b: 31 c0 xor %eax,%eax
|
|
c9d: 8d 76 00 lea 0x0(%esi),%esi
|
|
ca0: 83 c0 01 add $0x1,%eax
|
|
ca3: 80 3c 02 00 cmpb $0x0,(%edx,%eax,1)
|
|
ca7: 89 c1 mov %eax,%ecx
|
|
ca9: 75 f5 jne ca0 <strlen+0x10>
|
|
;
|
|
}
|
|
return n;
|
|
}
|
|
cab: 89 c8 mov %ecx,%eax
|
|
cad: 5d pop %ebp
|
|
cae: c3 ret
|
|
caf: 90 nop
|
|
for (n = 0; s[n]; n++) {
|
|
cb0: 31 c9 xor %ecx,%ecx
|
|
}
|
|
cb2: 5d pop %ebp
|
|
cb3: 89 c8 mov %ecx,%eax
|
|
cb5: c3 ret
|
|
cb6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
cbd: 8d 76 00 lea 0x0(%esi),%esi
|
|
|
|
00000cc0 <memset>:
|
|
|
|
void* memset(void *dst, int c, uint n) {
|
|
cc0: 55 push %ebp
|
|
cc1: 89 e5 mov %esp,%ebp
|
|
cc3: 57 push %edi
|
|
cc4: 8b 55 08 mov 0x8(%ebp),%edx
|
|
"d" (port), "0" (addr), "1" (cnt) :
|
|
"cc");
|
|
}
|
|
|
|
static inline void stosb(void *addr, int data, int cnt) {
|
|
asm volatile ("cld; rep stosb" :
|
|
cc7: 8b 4d 10 mov 0x10(%ebp),%ecx
|
|
cca: 8b 45 0c mov 0xc(%ebp),%eax
|
|
ccd: 89 d7 mov %edx,%edi
|
|
ccf: fc cld
|
|
cd0: f3 aa rep stos %al,%es:(%edi)
|
|
stosb(dst, c, n);
|
|
return dst;
|
|
}
|
|
cd2: 8b 7d fc mov -0x4(%ebp),%edi
|
|
cd5: 89 d0 mov %edx,%eax
|
|
cd7: c9 leave
|
|
cd8: c3 ret
|
|
cd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
|
|
00000ce0 <strchr>:
|
|
|
|
char* strchr(const char *s, char c) {
|
|
ce0: 55 push %ebp
|
|
ce1: 89 e5 mov %esp,%ebp
|
|
ce3: 8b 45 08 mov 0x8(%ebp),%eax
|
|
ce6: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
|
|
for (; *s; s++) {
|
|
cea: 0f b6 10 movzbl (%eax),%edx
|
|
ced: 84 d2 test %dl,%dl
|
|
cef: 75 12 jne d03 <strchr+0x23>
|
|
cf1: eb 1d jmp d10 <strchr+0x30>
|
|
cf3: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
cf7: 90 nop
|
|
cf8: 0f b6 50 01 movzbl 0x1(%eax),%edx
|
|
cfc: 83 c0 01 add $0x1,%eax
|
|
cff: 84 d2 test %dl,%dl
|
|
d01: 74 0d je d10 <strchr+0x30>
|
|
if (*s == c) {
|
|
d03: 38 d1 cmp %dl,%cl
|
|
d05: 75 f1 jne cf8 <strchr+0x18>
|
|
return (char*)s;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
d07: 5d pop %ebp
|
|
d08: c3 ret
|
|
d09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
return 0;
|
|
d10: 31 c0 xor %eax,%eax
|
|
}
|
|
d12: 5d pop %ebp
|
|
d13: c3 ret
|
|
d14: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
d1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
d1f: 90 nop
|
|
|
|
00000d20 <gets>:
|
|
|
|
char* gets(char *buf, int max) {
|
|
d20: 55 push %ebp
|
|
d21: 89 e5 mov %esp,%ebp
|
|
d23: 57 push %edi
|
|
d24: 56 push %esi
|
|
int i, cc;
|
|
char c;
|
|
|
|
for (i = 0; i + 1 < max;) {
|
|
cc = read(0, &c, 1);
|
|
d25: 8d 7d e7 lea -0x19(%ebp),%edi
|
|
char* gets(char *buf, int max) {
|
|
d28: 53 push %ebx
|
|
for (i = 0; i + 1 < max;) {
|
|
d29: 31 db xor %ebx,%ebx
|
|
char* gets(char *buf, int max) {
|
|
d2b: 83 ec 1c sub $0x1c,%esp
|
|
for (i = 0; i + 1 < max;) {
|
|
d2e: eb 27 jmp d57 <gets+0x37>
|
|
cc = read(0, &c, 1);
|
|
d30: 83 ec 04 sub $0x4,%esp
|
|
d33: 6a 01 push $0x1
|
|
d35: 57 push %edi
|
|
d36: 6a 00 push $0x0
|
|
d38: e8 2e 01 00 00 call e6b <read>
|
|
if (cc < 1) {
|
|
d3d: 83 c4 10 add $0x10,%esp
|
|
d40: 85 c0 test %eax,%eax
|
|
d42: 7e 1d jle d61 <gets+0x41>
|
|
break;
|
|
}
|
|
buf[i++] = c;
|
|
d44: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
|
|
d48: 8b 55 08 mov 0x8(%ebp),%edx
|
|
d4b: 88 44 1a ff mov %al,-0x1(%edx,%ebx,1)
|
|
if (c == '\n' || c == '\r') {
|
|
d4f: 3c 0a cmp $0xa,%al
|
|
d51: 74 1d je d70 <gets+0x50>
|
|
d53: 3c 0d cmp $0xd,%al
|
|
d55: 74 19 je d70 <gets+0x50>
|
|
for (i = 0; i + 1 < max;) {
|
|
d57: 89 de mov %ebx,%esi
|
|
d59: 83 c3 01 add $0x1,%ebx
|
|
d5c: 3b 5d 0c cmp 0xc(%ebp),%ebx
|
|
d5f: 7c cf jl d30 <gets+0x10>
|
|
break;
|
|
}
|
|
}
|
|
buf[i] = '\0';
|
|
d61: 8b 45 08 mov 0x8(%ebp),%eax
|
|
d64: c6 04 30 00 movb $0x0,(%eax,%esi,1)
|
|
return buf;
|
|
}
|
|
d68: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
d6b: 5b pop %ebx
|
|
d6c: 5e pop %esi
|
|
d6d: 5f pop %edi
|
|
d6e: 5d pop %ebp
|
|
d6f: c3 ret
|
|
buf[i] = '\0';
|
|
d70: 8b 45 08 mov 0x8(%ebp),%eax
|
|
d73: 89 de mov %ebx,%esi
|
|
d75: c6 04 30 00 movb $0x0,(%eax,%esi,1)
|
|
}
|
|
d79: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
d7c: 5b pop %ebx
|
|
d7d: 5e pop %esi
|
|
d7e: 5f pop %edi
|
|
d7f: 5d pop %ebp
|
|
d80: c3 ret
|
|
d81: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
d88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
d8f: 90 nop
|
|
|
|
00000d90 <stat>:
|
|
|
|
int stat(const char *n, struct stat *st) {
|
|
d90: 55 push %ebp
|
|
d91: 89 e5 mov %esp,%ebp
|
|
d93: 56 push %esi
|
|
d94: 53 push %ebx
|
|
int fd;
|
|
int r;
|
|
|
|
fd = open(n, O_RDONLY);
|
|
d95: 83 ec 08 sub $0x8,%esp
|
|
d98: 6a 00 push $0x0
|
|
d9a: ff 75 08 push 0x8(%ebp)
|
|
d9d: e8 19 01 00 00 call ebb <open>
|
|
if (fd < 0) {
|
|
da2: 83 c4 10 add $0x10,%esp
|
|
da5: 85 c0 test %eax,%eax
|
|
da7: 78 27 js dd0 <stat+0x40>
|
|
return -1;
|
|
}
|
|
r = fstat(fd, st);
|
|
da9: 83 ec 08 sub $0x8,%esp
|
|
dac: ff 75 0c push 0xc(%ebp)
|
|
daf: 89 c3 mov %eax,%ebx
|
|
db1: 50 push %eax
|
|
db2: e8 cc 00 00 00 call e83 <fstat>
|
|
close(fd);
|
|
db7: 89 1c 24 mov %ebx,(%esp)
|
|
r = fstat(fd, st);
|
|
dba: 89 c6 mov %eax,%esi
|
|
close(fd);
|
|
dbc: e8 2a 01 00 00 call eeb <close>
|
|
return r;
|
|
dc1: 83 c4 10 add $0x10,%esp
|
|
}
|
|
dc4: 8d 65 f8 lea -0x8(%ebp),%esp
|
|
dc7: 89 f0 mov %esi,%eax
|
|
dc9: 5b pop %ebx
|
|
dca: 5e pop %esi
|
|
dcb: 5d pop %ebp
|
|
dcc: c3 ret
|
|
dcd: 8d 76 00 lea 0x0(%esi),%esi
|
|
return -1;
|
|
dd0: be ff ff ff ff mov $0xffffffff,%esi
|
|
dd5: eb ed jmp dc4 <stat+0x34>
|
|
dd7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
dde: 66 90 xchg %ax,%ax
|
|
|
|
00000de0 <atoi>:
|
|
|
|
int atoi(const char *s) {
|
|
de0: 55 push %ebp
|
|
de1: 89 e5 mov %esp,%ebp
|
|
de3: 53 push %ebx
|
|
de4: 8b 55 08 mov 0x8(%ebp),%edx
|
|
int n;
|
|
|
|
n = 0;
|
|
while ('0' <= *s && *s <= '9') {
|
|
de7: 0f be 02 movsbl (%edx),%eax
|
|
dea: 8d 48 d0 lea -0x30(%eax),%ecx
|
|
ded: 80 f9 09 cmp $0x9,%cl
|
|
n = 0;
|
|
df0: b9 00 00 00 00 mov $0x0,%ecx
|
|
while ('0' <= *s && *s <= '9') {
|
|
df5: 77 1e ja e15 <atoi+0x35>
|
|
df7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
dfe: 66 90 xchg %ax,%ax
|
|
n = n * 10 + *s++ - '0';
|
|
e00: 83 c2 01 add $0x1,%edx
|
|
e03: 8d 0c 89 lea (%ecx,%ecx,4),%ecx
|
|
e06: 8d 4c 48 d0 lea -0x30(%eax,%ecx,2),%ecx
|
|
while ('0' <= *s && *s <= '9') {
|
|
e0a: 0f be 02 movsbl (%edx),%eax
|
|
e0d: 8d 58 d0 lea -0x30(%eax),%ebx
|
|
e10: 80 fb 09 cmp $0x9,%bl
|
|
e13: 76 eb jbe e00 <atoi+0x20>
|
|
}
|
|
return n;
|
|
}
|
|
e15: 8b 5d fc mov -0x4(%ebp),%ebx
|
|
e18: 89 c8 mov %ecx,%eax
|
|
e1a: c9 leave
|
|
e1b: c3 ret
|
|
e1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
|
|
00000e20 <memmove>:
|
|
|
|
void* memmove(void *vdst, const void *vsrc, int n) {
|
|
e20: 55 push %ebp
|
|
e21: 89 e5 mov %esp,%ebp
|
|
e23: 57 push %edi
|
|
e24: 8b 45 10 mov 0x10(%ebp),%eax
|
|
e27: 8b 55 08 mov 0x8(%ebp),%edx
|
|
e2a: 56 push %esi
|
|
e2b: 8b 75 0c mov 0xc(%ebp),%esi
|
|
char *dst;
|
|
const char *src;
|
|
|
|
dst = vdst;
|
|
src = vsrc;
|
|
while (n-- > 0) {
|
|
e2e: 85 c0 test %eax,%eax
|
|
e30: 7e 13 jle e45 <memmove+0x25>
|
|
e32: 01 d0 add %edx,%eax
|
|
dst = vdst;
|
|
e34: 89 d7 mov %edx,%edi
|
|
e36: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
e3d: 8d 76 00 lea 0x0(%esi),%esi
|
|
*dst++ = *src++;
|
|
e40: a4 movsb %ds:(%esi),%es:(%edi)
|
|
while (n-- > 0) {
|
|
e41: 39 f8 cmp %edi,%eax
|
|
e43: 75 fb jne e40 <memmove+0x20>
|
|
}
|
|
return vdst;
|
|
}
|
|
e45: 5e pop %esi
|
|
e46: 89 d0 mov %edx,%eax
|
|
e48: 5f pop %edi
|
|
e49: 5d pop %ebp
|
|
e4a: c3 ret
|
|
|
|
00000e4b <fork>:
|
|
name: \
|
|
movl $SYS_ ## name, %eax; \
|
|
int $T_SYSCALL; \
|
|
ret
|
|
|
|
SYSCALL(fork)
|
|
e4b: b8 01 00 00 00 mov $0x1,%eax
|
|
e50: cd 40 int $0x40
|
|
e52: c3 ret
|
|
|
|
00000e53 <exit>:
|
|
SYSCALL(exit)
|
|
e53: b8 02 00 00 00 mov $0x2,%eax
|
|
e58: cd 40 int $0x40
|
|
e5a: c3 ret
|
|
|
|
00000e5b <wait>:
|
|
SYSCALL(wait)
|
|
e5b: b8 03 00 00 00 mov $0x3,%eax
|
|
e60: cd 40 int $0x40
|
|
e62: c3 ret
|
|
|
|
00000e63 <pipe>:
|
|
SYSCALL(pipe)
|
|
e63: b8 04 00 00 00 mov $0x4,%eax
|
|
e68: cd 40 int $0x40
|
|
e6a: c3 ret
|
|
|
|
00000e6b <read>:
|
|
SYSCALL(read)
|
|
e6b: b8 05 00 00 00 mov $0x5,%eax
|
|
e70: cd 40 int $0x40
|
|
e72: c3 ret
|
|
|
|
00000e73 <kill>:
|
|
SYSCALL(kill)
|
|
e73: b8 06 00 00 00 mov $0x6,%eax
|
|
e78: cd 40 int $0x40
|
|
e7a: c3 ret
|
|
|
|
00000e7b <exec>:
|
|
SYSCALL(exec)
|
|
e7b: b8 07 00 00 00 mov $0x7,%eax
|
|
e80: cd 40 int $0x40
|
|
e82: c3 ret
|
|
|
|
00000e83 <fstat>:
|
|
SYSCALL(fstat)
|
|
e83: b8 08 00 00 00 mov $0x8,%eax
|
|
e88: cd 40 int $0x40
|
|
e8a: c3 ret
|
|
|
|
00000e8b <chdir>:
|
|
SYSCALL(chdir)
|
|
e8b: b8 09 00 00 00 mov $0x9,%eax
|
|
e90: cd 40 int $0x40
|
|
e92: c3 ret
|
|
|
|
00000e93 <dup>:
|
|
SYSCALL(dup)
|
|
e93: b8 0a 00 00 00 mov $0xa,%eax
|
|
e98: cd 40 int $0x40
|
|
e9a: c3 ret
|
|
|
|
00000e9b <getpid>:
|
|
SYSCALL(getpid)
|
|
e9b: b8 0b 00 00 00 mov $0xb,%eax
|
|
ea0: cd 40 int $0x40
|
|
ea2: c3 ret
|
|
|
|
00000ea3 <sbrk>:
|
|
SYSCALL(sbrk)
|
|
ea3: b8 0c 00 00 00 mov $0xc,%eax
|
|
ea8: cd 40 int $0x40
|
|
eaa: c3 ret
|
|
|
|
00000eab <sleep>:
|
|
SYSCALL(sleep)
|
|
eab: b8 0d 00 00 00 mov $0xd,%eax
|
|
eb0: cd 40 int $0x40
|
|
eb2: c3 ret
|
|
|
|
00000eb3 <uptime>:
|
|
SYSCALL(uptime)
|
|
eb3: b8 0e 00 00 00 mov $0xe,%eax
|
|
eb8: cd 40 int $0x40
|
|
eba: c3 ret
|
|
|
|
00000ebb <open>:
|
|
SYSCALL(open)
|
|
ebb: b8 0f 00 00 00 mov $0xf,%eax
|
|
ec0: cd 40 int $0x40
|
|
ec2: c3 ret
|
|
|
|
00000ec3 <write>:
|
|
SYSCALL(write)
|
|
ec3: b8 10 00 00 00 mov $0x10,%eax
|
|
ec8: cd 40 int $0x40
|
|
eca: c3 ret
|
|
|
|
00000ecb <mknod>:
|
|
SYSCALL(mknod)
|
|
ecb: b8 11 00 00 00 mov $0x11,%eax
|
|
ed0: cd 40 int $0x40
|
|
ed2: c3 ret
|
|
|
|
00000ed3 <unlink>:
|
|
SYSCALL(unlink)
|
|
ed3: b8 12 00 00 00 mov $0x12,%eax
|
|
ed8: cd 40 int $0x40
|
|
eda: c3 ret
|
|
|
|
00000edb <link>:
|
|
SYSCALL(link)
|
|
edb: b8 13 00 00 00 mov $0x13,%eax
|
|
ee0: cd 40 int $0x40
|
|
ee2: c3 ret
|
|
|
|
00000ee3 <mkdir>:
|
|
SYSCALL(mkdir)
|
|
ee3: b8 14 00 00 00 mov $0x14,%eax
|
|
ee8: cd 40 int $0x40
|
|
eea: c3 ret
|
|
|
|
00000eeb <close>:
|
|
SYSCALL(close)
|
|
eeb: b8 15 00 00 00 mov $0x15,%eax
|
|
ef0: cd 40 int $0x40
|
|
ef2: c3 ret
|
|
|
|
00000ef3 <getch>:
|
|
SYSCALL(getch)
|
|
ef3: b8 16 00 00 00 mov $0x16,%eax
|
|
ef8: cd 40 int $0x40
|
|
efa: c3 ret
|
|
|
|
00000efb <greeting>:
|
|
SYSCALL(greeting)
|
|
efb: b8 17 00 00 00 mov $0x17,%eax
|
|
f00: cd 40 int $0x40
|
|
f02: c3 ret
|
|
|
|
00000f03 <shutdown>:
|
|
SYSCALL(shutdown)
|
|
f03: b8 18 00 00 00 mov $0x18,%eax
|
|
f08: cd 40 int $0x40
|
|
f0a: c3 ret
|
|
|
|
00000f0b <screen>:
|
|
SYSCALL(screen)
|
|
f0b: b8 19 00 00 00 mov $0x19,%eax
|
|
f10: cd 40 int $0x40
|
|
f12: c3 ret
|
|
|
|
00000f13 <cls>:
|
|
SYSCALL(cls)
|
|
f13: b8 1a 00 00 00 mov $0x1a,%eax
|
|
f18: cd 40 int $0x40
|
|
f1a: c3 ret
|
|
f1b: 66 90 xchg %ax,%ax
|
|
f1d: 66 90 xchg %ax,%ax
|
|
f1f: 90 nop
|
|
|
|
00000f20 <printint>:
|
|
|
|
static void putc(int fd, char c) {
|
|
write(fd, &c, 1);
|
|
}
|
|
|
|
static void printint(int fd, int xx, int base, int sgn) {
|
|
f20: 55 push %ebp
|
|
f21: 89 e5 mov %esp,%ebp
|
|
f23: 57 push %edi
|
|
f24: 56 push %esi
|
|
f25: 53 push %ebx
|
|
f26: 83 ec 3c sub $0x3c,%esp
|
|
f29: 89 4d c4 mov %ecx,-0x3c(%ebp)
|
|
uint x;
|
|
|
|
neg = 0;
|
|
if (sgn && xx < 0) {
|
|
neg = 1;
|
|
x = -xx;
|
|
f2c: 89 d1 mov %edx,%ecx
|
|
static void printint(int fd, int xx, int base, int sgn) {
|
|
f2e: 89 45 b8 mov %eax,-0x48(%ebp)
|
|
if (sgn && xx < 0) {
|
|
f31: 85 d2 test %edx,%edx
|
|
f33: 0f 89 7f 00 00 00 jns fb8 <printint+0x98>
|
|
f39: f6 45 08 01 testb $0x1,0x8(%ebp)
|
|
f3d: 74 79 je fb8 <printint+0x98>
|
|
neg = 1;
|
|
f3f: c7 45 bc 01 00 00 00 movl $0x1,-0x44(%ebp)
|
|
x = -xx;
|
|
f46: f7 d9 neg %ecx
|
|
}
|
|
else {
|
|
x = xx;
|
|
}
|
|
|
|
i = 0;
|
|
f48: 31 db xor %ebx,%ebx
|
|
f4a: 8d 75 d7 lea -0x29(%ebp),%esi
|
|
f4d: 8d 76 00 lea 0x0(%esi),%esi
|
|
do {
|
|
buf[i++] = digits[x % base];
|
|
f50: 89 c8 mov %ecx,%eax
|
|
f52: 31 d2 xor %edx,%edx
|
|
f54: 89 cf mov %ecx,%edi
|
|
f56: f7 75 c4 divl -0x3c(%ebp)
|
|
f59: 0f b6 92 40 14 00 00 movzbl 0x1440(%edx),%edx
|
|
f60: 89 45 c0 mov %eax,-0x40(%ebp)
|
|
f63: 89 d8 mov %ebx,%eax
|
|
f65: 8d 5b 01 lea 0x1(%ebx),%ebx
|
|
}
|
|
while ((x /= base) != 0);
|
|
f68: 8b 4d c0 mov -0x40(%ebp),%ecx
|
|
buf[i++] = digits[x % base];
|
|
f6b: 88 14 1e mov %dl,(%esi,%ebx,1)
|
|
while ((x /= base) != 0);
|
|
f6e: 39 7d c4 cmp %edi,-0x3c(%ebp)
|
|
f71: 76 dd jbe f50 <printint+0x30>
|
|
if (neg) {
|
|
f73: 8b 4d bc mov -0x44(%ebp),%ecx
|
|
f76: 85 c9 test %ecx,%ecx
|
|
f78: 74 0c je f86 <printint+0x66>
|
|
buf[i++] = '-';
|
|
f7a: c6 44 1d d8 2d movb $0x2d,-0x28(%ebp,%ebx,1)
|
|
buf[i++] = digits[x % base];
|
|
f7f: 89 d8 mov %ebx,%eax
|
|
buf[i++] = '-';
|
|
f81: ba 2d 00 00 00 mov $0x2d,%edx
|
|
}
|
|
|
|
while (--i >= 0) {
|
|
f86: 8b 7d b8 mov -0x48(%ebp),%edi
|
|
f89: 8d 5c 05 d7 lea -0x29(%ebp,%eax,1),%ebx
|
|
f8d: eb 07 jmp f96 <printint+0x76>
|
|
f8f: 90 nop
|
|
putc(fd, buf[i]);
|
|
f90: 0f b6 13 movzbl (%ebx),%edx
|
|
f93: 83 eb 01 sub $0x1,%ebx
|
|
write(fd, &c, 1);
|
|
f96: 83 ec 04 sub $0x4,%esp
|
|
f99: 88 55 d7 mov %dl,-0x29(%ebp)
|
|
f9c: 6a 01 push $0x1
|
|
f9e: 56 push %esi
|
|
f9f: 57 push %edi
|
|
fa0: e8 1e ff ff ff call ec3 <write>
|
|
while (--i >= 0) {
|
|
fa5: 83 c4 10 add $0x10,%esp
|
|
fa8: 39 de cmp %ebx,%esi
|
|
faa: 75 e4 jne f90 <printint+0x70>
|
|
}
|
|
}
|
|
fac: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
faf: 5b pop %ebx
|
|
fb0: 5e pop %esi
|
|
fb1: 5f pop %edi
|
|
fb2: 5d pop %ebp
|
|
fb3: c3 ret
|
|
fb4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
neg = 0;
|
|
fb8: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp)
|
|
fbf: eb 87 jmp f48 <printint+0x28>
|
|
fc1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
fc8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
fcf: 90 nop
|
|
|
|
00000fd0 <printf>:
|
|
|
|
// Print to the given fd. Only understands %d, %x, %p, %s.
|
|
void printf(int fd, const char *fmt, ...) {
|
|
fd0: 55 push %ebp
|
|
fd1: 89 e5 mov %esp,%ebp
|
|
fd3: 57 push %edi
|
|
fd4: 56 push %esi
|
|
fd5: 53 push %ebx
|
|
fd6: 83 ec 2c sub $0x2c,%esp
|
|
int c, i, state;
|
|
uint *ap;
|
|
|
|
state = 0;
|
|
ap = (uint*)(void*)&fmt + 1;
|
|
for (i = 0; fmt[i]; i++) {
|
|
fd9: 8b 5d 0c mov 0xc(%ebp),%ebx
|
|
void printf(int fd, const char *fmt, ...) {
|
|
fdc: 8b 75 08 mov 0x8(%ebp),%esi
|
|
for (i = 0; fmt[i]; i++) {
|
|
fdf: 0f b6 13 movzbl (%ebx),%edx
|
|
fe2: 84 d2 test %dl,%dl
|
|
fe4: 74 6a je 1050 <printf+0x80>
|
|
ap = (uint*)(void*)&fmt + 1;
|
|
fe6: 8d 45 10 lea 0x10(%ebp),%eax
|
|
fe9: 83 c3 01 add $0x1,%ebx
|
|
write(fd, &c, 1);
|
|
fec: 8d 7d e7 lea -0x19(%ebp),%edi
|
|
state = 0;
|
|
fef: 31 c9 xor %ecx,%ecx
|
|
ap = (uint*)(void*)&fmt + 1;
|
|
ff1: 89 45 d0 mov %eax,-0x30(%ebp)
|
|
ff4: eb 36 jmp 102c <printf+0x5c>
|
|
ff6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
ffd: 8d 76 00 lea 0x0(%esi),%esi
|
|
1000: 89 4d d4 mov %ecx,-0x2c(%ebp)
|
|
c = fmt[i] & 0xff;
|
|
if (state == 0) {
|
|
if (c == '%') {
|
|
state = '%';
|
|
1003: b9 25 00 00 00 mov $0x25,%ecx
|
|
if (c == '%') {
|
|
1008: 83 f8 25 cmp $0x25,%eax
|
|
100b: 74 15 je 1022 <printf+0x52>
|
|
write(fd, &c, 1);
|
|
100d: 83 ec 04 sub $0x4,%esp
|
|
1010: 88 55 e7 mov %dl,-0x19(%ebp)
|
|
1013: 6a 01 push $0x1
|
|
1015: 57 push %edi
|
|
1016: 56 push %esi
|
|
1017: e8 a7 fe ff ff call ec3 <write>
|
|
101c: 8b 4d d4 mov -0x2c(%ebp),%ecx
|
|
}
|
|
else {
|
|
putc(fd, c);
|
|
101f: 83 c4 10 add $0x10,%esp
|
|
for (i = 0; fmt[i]; i++) {
|
|
1022: 0f b6 13 movzbl (%ebx),%edx
|
|
1025: 83 c3 01 add $0x1,%ebx
|
|
1028: 84 d2 test %dl,%dl
|
|
102a: 74 24 je 1050 <printf+0x80>
|
|
c = fmt[i] & 0xff;
|
|
102c: 0f b6 c2 movzbl %dl,%eax
|
|
if (state == 0) {
|
|
102f: 85 c9 test %ecx,%ecx
|
|
1031: 74 cd je 1000 <printf+0x30>
|
|
}
|
|
}
|
|
else if (state == '%') {
|
|
1033: 83 f9 25 cmp $0x25,%ecx
|
|
1036: 75 ea jne 1022 <printf+0x52>
|
|
if (c == 'd') {
|
|
1038: 83 f8 25 cmp $0x25,%eax
|
|
103b: 0f 84 07 01 00 00 je 1148 <printf+0x178>
|
|
1041: 83 e8 63 sub $0x63,%eax
|
|
1044: 83 f8 15 cmp $0x15,%eax
|
|
1047: 77 17 ja 1060 <printf+0x90>
|
|
1049: ff 24 85 e8 13 00 00 jmp *0x13e8(,%eax,4)
|
|
putc(fd, c);
|
|
}
|
|
state = 0;
|
|
}
|
|
}
|
|
}
|
|
1050: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
1053: 5b pop %ebx
|
|
1054: 5e pop %esi
|
|
1055: 5f pop %edi
|
|
1056: 5d pop %ebp
|
|
1057: c3 ret
|
|
1058: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
105f: 90 nop
|
|
write(fd, &c, 1);
|
|
1060: 83 ec 04 sub $0x4,%esp
|
|
1063: 88 55 d4 mov %dl,-0x2c(%ebp)
|
|
1066: 6a 01 push $0x1
|
|
1068: 57 push %edi
|
|
1069: 56 push %esi
|
|
106a: c6 45 e7 25 movb $0x25,-0x19(%ebp)
|
|
106e: e8 50 fe ff ff call ec3 <write>
|
|
putc(fd, c);
|
|
1073: 0f b6 55 d4 movzbl -0x2c(%ebp),%edx
|
|
write(fd, &c, 1);
|
|
1077: 83 c4 0c add $0xc,%esp
|
|
107a: 88 55 e7 mov %dl,-0x19(%ebp)
|
|
107d: 6a 01 push $0x1
|
|
107f: 57 push %edi
|
|
1080: 56 push %esi
|
|
1081: e8 3d fe ff ff call ec3 <write>
|
|
putc(fd, c);
|
|
1086: 83 c4 10 add $0x10,%esp
|
|
state = 0;
|
|
1089: 31 c9 xor %ecx,%ecx
|
|
108b: eb 95 jmp 1022 <printf+0x52>
|
|
108d: 8d 76 00 lea 0x0(%esi),%esi
|
|
printint(fd, *ap, 16, 0);
|
|
1090: 83 ec 0c sub $0xc,%esp
|
|
1093: b9 10 00 00 00 mov $0x10,%ecx
|
|
1098: 6a 00 push $0x0
|
|
109a: 8b 45 d0 mov -0x30(%ebp),%eax
|
|
109d: 8b 10 mov (%eax),%edx
|
|
109f: 89 f0 mov %esi,%eax
|
|
10a1: e8 7a fe ff ff call f20 <printint>
|
|
ap++;
|
|
10a6: 83 45 d0 04 addl $0x4,-0x30(%ebp)
|
|
10aa: 83 c4 10 add $0x10,%esp
|
|
state = 0;
|
|
10ad: 31 c9 xor %ecx,%ecx
|
|
10af: e9 6e ff ff ff jmp 1022 <printf+0x52>
|
|
10b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
s = (char*)*ap;
|
|
10b8: 8b 45 d0 mov -0x30(%ebp),%eax
|
|
10bb: 8b 10 mov (%eax),%edx
|
|
ap++;
|
|
10bd: 83 c0 04 add $0x4,%eax
|
|
10c0: 89 45 d0 mov %eax,-0x30(%ebp)
|
|
if (s == 0) {
|
|
10c3: 85 d2 test %edx,%edx
|
|
10c5: 0f 84 8d 00 00 00 je 1158 <printf+0x188>
|
|
while (*s != 0) {
|
|
10cb: 0f b6 02 movzbl (%edx),%eax
|
|
state = 0;
|
|
10ce: 31 c9 xor %ecx,%ecx
|
|
while (*s != 0) {
|
|
10d0: 84 c0 test %al,%al
|
|
10d2: 0f 84 4a ff ff ff je 1022 <printf+0x52>
|
|
10d8: 89 5d d4 mov %ebx,-0x2c(%ebp)
|
|
10db: 89 d3 mov %edx,%ebx
|
|
10dd: 8d 76 00 lea 0x0(%esi),%esi
|
|
write(fd, &c, 1);
|
|
10e0: 83 ec 04 sub $0x4,%esp
|
|
s++;
|
|
10e3: 83 c3 01 add $0x1,%ebx
|
|
10e6: 88 45 e7 mov %al,-0x19(%ebp)
|
|
write(fd, &c, 1);
|
|
10e9: 6a 01 push $0x1
|
|
10eb: 57 push %edi
|
|
10ec: 56 push %esi
|
|
10ed: e8 d1 fd ff ff call ec3 <write>
|
|
while (*s != 0) {
|
|
10f2: 0f b6 03 movzbl (%ebx),%eax
|
|
10f5: 83 c4 10 add $0x10,%esp
|
|
10f8: 84 c0 test %al,%al
|
|
10fa: 75 e4 jne 10e0 <printf+0x110>
|
|
state = 0;
|
|
10fc: 8b 5d d4 mov -0x2c(%ebp),%ebx
|
|
10ff: 31 c9 xor %ecx,%ecx
|
|
1101: e9 1c ff ff ff jmp 1022 <printf+0x52>
|
|
1106: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
110d: 8d 76 00 lea 0x0(%esi),%esi
|
|
printint(fd, *ap, 10, 1);
|
|
1110: 83 ec 0c sub $0xc,%esp
|
|
1113: b9 0a 00 00 00 mov $0xa,%ecx
|
|
1118: 6a 01 push $0x1
|
|
111a: e9 7b ff ff ff jmp 109a <printf+0xca>
|
|
111f: 90 nop
|
|
putc(fd, *ap);
|
|
1120: 8b 45 d0 mov -0x30(%ebp),%eax
|
|
write(fd, &c, 1);
|
|
1123: 83 ec 04 sub $0x4,%esp
|
|
putc(fd, *ap);
|
|
1126: 8b 00 mov (%eax),%eax
|
|
write(fd, &c, 1);
|
|
1128: 6a 01 push $0x1
|
|
112a: 57 push %edi
|
|
112b: 56 push %esi
|
|
putc(fd, *ap);
|
|
112c: 88 45 e7 mov %al,-0x19(%ebp)
|
|
write(fd, &c, 1);
|
|
112f: e8 8f fd ff ff call ec3 <write>
|
|
ap++;
|
|
1134: 83 45 d0 04 addl $0x4,-0x30(%ebp)
|
|
1138: 83 c4 10 add $0x10,%esp
|
|
state = 0;
|
|
113b: 31 c9 xor %ecx,%ecx
|
|
113d: e9 e0 fe ff ff jmp 1022 <printf+0x52>
|
|
1142: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
putc(fd, c);
|
|
1148: 88 55 e7 mov %dl,-0x19(%ebp)
|
|
write(fd, &c, 1);
|
|
114b: 83 ec 04 sub $0x4,%esp
|
|
114e: e9 2a ff ff ff jmp 107d <printf+0xad>
|
|
1153: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
1157: 90 nop
|
|
s = "(null)";
|
|
1158: ba e0 13 00 00 mov $0x13e0,%edx
|
|
while (*s != 0) {
|
|
115d: 89 5d d4 mov %ebx,-0x2c(%ebp)
|
|
1160: b8 28 00 00 00 mov $0x28,%eax
|
|
1165: 89 d3 mov %edx,%ebx
|
|
1167: e9 74 ff ff ff jmp 10e0 <printf+0x110>
|
|
116c: 66 90 xchg %ax,%ax
|
|
116e: 66 90 xchg %ax,%ax
|
|
|
|
00001170 <free>:
|
|
typedef union header Header;
|
|
|
|
static Header base;
|
|
static Header *freep;
|
|
|
|
void free(void *ap) {
|
|
1170: 55 push %ebp
|
|
Header *bp, *p;
|
|
|
|
bp = (Header*)ap - 1;
|
|
for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr) {
|
|
1171: a1 a4 1a 00 00 mov 0x1aa4,%eax
|
|
void free(void *ap) {
|
|
1176: 89 e5 mov %esp,%ebp
|
|
1178: 57 push %edi
|
|
1179: 56 push %esi
|
|
117a: 53 push %ebx
|
|
117b: 8b 5d 08 mov 0x8(%ebp),%ebx
|
|
bp = (Header*)ap - 1;
|
|
117e: 8d 4b f8 lea -0x8(%ebx),%ecx
|
|
for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr) {
|
|
1181: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
|
|
1188: 89 c2 mov %eax,%edx
|
|
118a: 8b 00 mov (%eax),%eax
|
|
118c: 39 ca cmp %ecx,%edx
|
|
118e: 73 30 jae 11c0 <free+0x50>
|
|
1190: 39 c1 cmp %eax,%ecx
|
|
1192: 72 04 jb 1198 <free+0x28>
|
|
if (p >= p->s.ptr && (bp > p || bp < p->s.ptr)) {
|
|
1194: 39 c2 cmp %eax,%edx
|
|
1196: 72 f0 jb 1188 <free+0x18>
|
|
break;
|
|
}
|
|
}
|
|
if (bp + bp->s.size == p->s.ptr) {
|
|
1198: 8b 73 fc mov -0x4(%ebx),%esi
|
|
119b: 8d 3c f1 lea (%ecx,%esi,8),%edi
|
|
119e: 39 f8 cmp %edi,%eax
|
|
11a0: 74 30 je 11d2 <free+0x62>
|
|
bp->s.size += p->s.ptr->s.size;
|
|
bp->s.ptr = p->s.ptr->s.ptr;
|
|
11a2: 89 43 f8 mov %eax,-0x8(%ebx)
|
|
}
|
|
else {
|
|
bp->s.ptr = p->s.ptr;
|
|
}
|
|
if (p + p->s.size == bp) {
|
|
11a5: 8b 42 04 mov 0x4(%edx),%eax
|
|
11a8: 8d 34 c2 lea (%edx,%eax,8),%esi
|
|
11ab: 39 f1 cmp %esi,%ecx
|
|
11ad: 74 3a je 11e9 <free+0x79>
|
|
p->s.size += bp->s.size;
|
|
p->s.ptr = bp->s.ptr;
|
|
11af: 89 0a mov %ecx,(%edx)
|
|
}
|
|
else {
|
|
p->s.ptr = bp;
|
|
}
|
|
freep = p;
|
|
}
|
|
11b1: 5b pop %ebx
|
|
freep = p;
|
|
11b2: 89 15 a4 1a 00 00 mov %edx,0x1aa4
|
|
}
|
|
11b8: 5e pop %esi
|
|
11b9: 5f pop %edi
|
|
11ba: 5d pop %ebp
|
|
11bb: c3 ret
|
|
11bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
|
|
if (p >= p->s.ptr && (bp > p || bp < p->s.ptr)) {
|
|
11c0: 39 c2 cmp %eax,%edx
|
|
11c2: 72 c4 jb 1188 <free+0x18>
|
|
11c4: 39 c1 cmp %eax,%ecx
|
|
11c6: 73 c0 jae 1188 <free+0x18>
|
|
if (bp + bp->s.size == p->s.ptr) {
|
|
11c8: 8b 73 fc mov -0x4(%ebx),%esi
|
|
11cb: 8d 3c f1 lea (%ecx,%esi,8),%edi
|
|
11ce: 39 f8 cmp %edi,%eax
|
|
11d0: 75 d0 jne 11a2 <free+0x32>
|
|
bp->s.size += p->s.ptr->s.size;
|
|
11d2: 03 70 04 add 0x4(%eax),%esi
|
|
11d5: 89 73 fc mov %esi,-0x4(%ebx)
|
|
bp->s.ptr = p->s.ptr->s.ptr;
|
|
11d8: 8b 02 mov (%edx),%eax
|
|
11da: 8b 00 mov (%eax),%eax
|
|
11dc: 89 43 f8 mov %eax,-0x8(%ebx)
|
|
if (p + p->s.size == bp) {
|
|
11df: 8b 42 04 mov 0x4(%edx),%eax
|
|
11e2: 8d 34 c2 lea (%edx,%eax,8),%esi
|
|
11e5: 39 f1 cmp %esi,%ecx
|
|
11e7: 75 c6 jne 11af <free+0x3f>
|
|
p->s.size += bp->s.size;
|
|
11e9: 03 43 fc add -0x4(%ebx),%eax
|
|
freep = p;
|
|
11ec: 89 15 a4 1a 00 00 mov %edx,0x1aa4
|
|
p->s.size += bp->s.size;
|
|
11f2: 89 42 04 mov %eax,0x4(%edx)
|
|
p->s.ptr = bp->s.ptr;
|
|
11f5: 8b 4b f8 mov -0x8(%ebx),%ecx
|
|
11f8: 89 0a mov %ecx,(%edx)
|
|
}
|
|
11fa: 5b pop %ebx
|
|
11fb: 5e pop %esi
|
|
11fc: 5f pop %edi
|
|
11fd: 5d pop %ebp
|
|
11fe: c3 ret
|
|
11ff: 90 nop
|
|
|
|
00001200 <malloc>:
|
|
hp->s.size = nu;
|
|
free((void*)(hp + 1));
|
|
return freep;
|
|
}
|
|
|
|
void* malloc(uint nbytes) {
|
|
1200: 55 push %ebp
|
|
1201: 89 e5 mov %esp,%ebp
|
|
1203: 57 push %edi
|
|
1204: 56 push %esi
|
|
1205: 53 push %ebx
|
|
1206: 83 ec 1c sub $0x1c,%esp
|
|
Header *p, *prevp;
|
|
uint nunits;
|
|
|
|
nunits = (nbytes + sizeof(Header) - 1) / sizeof(Header) + 1;
|
|
1209: 8b 45 08 mov 0x8(%ebp),%eax
|
|
if ((prevp = freep) == 0) {
|
|
120c: 8b 3d a4 1a 00 00 mov 0x1aa4,%edi
|
|
nunits = (nbytes + sizeof(Header) - 1) / sizeof(Header) + 1;
|
|
1212: 8d 70 07 lea 0x7(%eax),%esi
|
|
1215: c1 ee 03 shr $0x3,%esi
|
|
1218: 83 c6 01 add $0x1,%esi
|
|
if ((prevp = freep) == 0) {
|
|
121b: 85 ff test %edi,%edi
|
|
121d: 0f 84 9d 00 00 00 je 12c0 <malloc+0xc0>
|
|
base.s.ptr = freep = prevp = &base;
|
|
base.s.size = 0;
|
|
}
|
|
for (p = prevp->s.ptr;; prevp = p, p = p->s.ptr) {
|
|
1223: 8b 17 mov (%edi),%edx
|
|
if (p->s.size >= nunits) {
|
|
1225: 8b 4a 04 mov 0x4(%edx),%ecx
|
|
1228: 39 f1 cmp %esi,%ecx
|
|
122a: 73 6a jae 1296 <malloc+0x96>
|
|
122c: bb 00 10 00 00 mov $0x1000,%ebx
|
|
1231: 39 de cmp %ebx,%esi
|
|
1233: 0f 43 de cmovae %esi,%ebx
|
|
p = sbrk(nu * sizeof(Header));
|
|
1236: 8d 04 dd 00 00 00 00 lea 0x0(,%ebx,8),%eax
|
|
123d: 89 45 e4 mov %eax,-0x1c(%ebp)
|
|
1240: eb 17 jmp 1259 <malloc+0x59>
|
|
1242: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
for (p = prevp->s.ptr;; prevp = p, p = p->s.ptr) {
|
|
1248: 8b 02 mov (%edx),%eax
|
|
if (p->s.size >= nunits) {
|
|
124a: 8b 48 04 mov 0x4(%eax),%ecx
|
|
124d: 39 f1 cmp %esi,%ecx
|
|
124f: 73 4f jae 12a0 <malloc+0xa0>
|
|
p->s.size = nunits;
|
|
}
|
|
freep = prevp;
|
|
return (void*)(p + 1);
|
|
}
|
|
if (p == freep) {
|
|
1251: 8b 3d a4 1a 00 00 mov 0x1aa4,%edi
|
|
1257: 89 c2 mov %eax,%edx
|
|
1259: 39 d7 cmp %edx,%edi
|
|
125b: 75 eb jne 1248 <malloc+0x48>
|
|
p = sbrk(nu * sizeof(Header));
|
|
125d: 83 ec 0c sub $0xc,%esp
|
|
1260: ff 75 e4 push -0x1c(%ebp)
|
|
1263: e8 3b fc ff ff call ea3 <sbrk>
|
|
if (p == (char*)-1) {
|
|
1268: 83 c4 10 add $0x10,%esp
|
|
126b: 83 f8 ff cmp $0xffffffff,%eax
|
|
126e: 74 1c je 128c <malloc+0x8c>
|
|
hp->s.size = nu;
|
|
1270: 89 58 04 mov %ebx,0x4(%eax)
|
|
free((void*)(hp + 1));
|
|
1273: 83 ec 0c sub $0xc,%esp
|
|
1276: 83 c0 08 add $0x8,%eax
|
|
1279: 50 push %eax
|
|
127a: e8 f1 fe ff ff call 1170 <free>
|
|
return freep;
|
|
127f: 8b 15 a4 1a 00 00 mov 0x1aa4,%edx
|
|
if ((p = morecore(nunits)) == 0) {
|
|
1285: 83 c4 10 add $0x10,%esp
|
|
1288: 85 d2 test %edx,%edx
|
|
128a: 75 bc jne 1248 <malloc+0x48>
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
128c: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
return 0;
|
|
128f: 31 c0 xor %eax,%eax
|
|
}
|
|
1291: 5b pop %ebx
|
|
1292: 5e pop %esi
|
|
1293: 5f pop %edi
|
|
1294: 5d pop %ebp
|
|
1295: c3 ret
|
|
if (p->s.size >= nunits) {
|
|
1296: 89 d0 mov %edx,%eax
|
|
1298: 89 fa mov %edi,%edx
|
|
129a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
if (p->s.size == nunits) {
|
|
12a0: 39 ce cmp %ecx,%esi
|
|
12a2: 74 4c je 12f0 <malloc+0xf0>
|
|
p->s.size -= nunits;
|
|
12a4: 29 f1 sub %esi,%ecx
|
|
12a6: 89 48 04 mov %ecx,0x4(%eax)
|
|
p += p->s.size;
|
|
12a9: 8d 04 c8 lea (%eax,%ecx,8),%eax
|
|
p->s.size = nunits;
|
|
12ac: 89 70 04 mov %esi,0x4(%eax)
|
|
freep = prevp;
|
|
12af: 89 15 a4 1a 00 00 mov %edx,0x1aa4
|
|
}
|
|
12b5: 8d 65 f4 lea -0xc(%ebp),%esp
|
|
return (void*)(p + 1);
|
|
12b8: 83 c0 08 add $0x8,%eax
|
|
}
|
|
12bb: 5b pop %ebx
|
|
12bc: 5e pop %esi
|
|
12bd: 5f pop %edi
|
|
12be: 5d pop %ebp
|
|
12bf: c3 ret
|
|
base.s.ptr = freep = prevp = &base;
|
|
12c0: c7 05 a4 1a 00 00 a8 movl $0x1aa8,0x1aa4
|
|
12c7: 1a 00 00
|
|
base.s.size = 0;
|
|
12ca: bf a8 1a 00 00 mov $0x1aa8,%edi
|
|
base.s.ptr = freep = prevp = &base;
|
|
12cf: c7 05 a8 1a 00 00 a8 movl $0x1aa8,0x1aa8
|
|
12d6: 1a 00 00
|
|
for (p = prevp->s.ptr;; prevp = p, p = p->s.ptr) {
|
|
12d9: 89 fa mov %edi,%edx
|
|
base.s.size = 0;
|
|
12db: c7 05 ac 1a 00 00 00 movl $0x0,0x1aac
|
|
12e2: 00 00 00
|
|
if (p->s.size >= nunits) {
|
|
12e5: e9 42 ff ff ff jmp 122c <malloc+0x2c>
|
|
12ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
|
|
prevp->s.ptr = p->s.ptr;
|
|
12f0: 8b 08 mov (%eax),%ecx
|
|
12f2: 89 0a mov %ecx,(%edx)
|
|
12f4: eb b9 jmp 12af <malloc+0xaf>
|