【施工完成】MIT 6.828 lab 1: C, Assembly, Tools and Bootstrapping

 1    
 2    #include <inc/mmu.h>
 3    
 4    # Start the CPU: switch to 32-bit protected mode, jump into C.
 5    # The BIOS loads this code from the first sector of the hard disk into
 6    # memory at physical address 0x7c00 and starts executing in real mode
 7    # with %cs=0 %ip=7c00.
 8    
 9    .set PROT_MODE_CSEG, 0x8         # kernel code segment selector
10    .set PROT_MODE_DSEG, 0x10        # kernel data segment selector
11    .set CR0_PE_ON,      0x1         # protected mode enable flag
12    
13    .globl start
14    start:
15      .code16                     # Assemble for 16-bit mode
16      cli                         # Disable interrupts
17      cld                         # String operations increment
18    
19      # Set up the important data segment registers (DS, ES, SS).
20      xorw    %ax,%ax             # Segment number zero
21      movw    %ax,%ds             # - Data Segment
22      movw    %ax,%es             # - Extra Segment
23      movw    %ax,%ss             # - Stack Segment
24    
25      # Enable A20:
26      #   For backwards compatibility with the earliest PCs, physical
27      #   address line 20 is tied low, so that addresses higher than
28      #   1MB wrap around to zero by default.  This code undoes this.
29    seta20.1:
30      inb     $0x64,%al               # Wait for not busy
31      testb   $0x2,%al
32      jnz     seta20.1
33    
34      movb    $0xd1,%al               # 0xd1 - port 0x64
35      outb    %al,$0x64
36    
37    seta20.2:
38      inb     $0x64,%al               # Wait for not busy
39      testb   $0x2,%al
40      jnz     seta20.2
41    
42      movb    $0xdf,%al               # 0xdf - port 0x60
43      outb    %al,$0x60
44    
45      # Switch from real to protected mode, using a bootstrap GDT
46      # and segment translation that makes virtual addresses 
47      # identical to their physical addresses, so that the 
48      # effective memory map does not change during the switch.
49      lgdt    gdtdesc  # lgdt means load global descriptor table
50      movl    %cr0, x
51      orl     $CR0_PE_ON, x  # cr0 = cr0 | 1
52      movl    x, %cr0
53      
54      # Jump to next instruction, but in 32-bit code segment.
55      # Switches processor into 32-bit mode.
56      ljmp    $PROT_MODE_CSEG, $protcseg
57    
58      .code32                     # Assemble for 32-bit mode
59    protcseg:
60      # Set up the protected-mode data segment registers
61      movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
62      movw    %ax, %ds                # - DS: Data Segment
63      movw    %ax, %es                # - ES: Extra Segment
64      movw    %ax, %fs                # - FS
65      movw    %ax, %gs                # - GS
66      movw    %ax, %ss                # - SS: Stack Segment
67      
68      # Set up the stack pointer and call into C.
69      movl    $start, %esp
70      call bootmain
71    
72      # If bootmain returns (it shouldn't), loop.
73    spin:
74      jmp spin
75    
76    # Bootstrap GDT
77    .p2align 2                                # force 4 byte alignment
78    gdt:
79      SEG_NULL                              # null seg
80      SEG(STA_X|STA_R, 0x0, 0xffffffff)     # code seg
81      SEG(STA_W, 0x0, 0xffffffff)           # data seg
82    
83    gdtdesc:
84      .word   0x17                            # sizeof(gdt) - 1
85      .long   gdt                             # address gdt
86
87

 1    .data		
 2    var:		
 3    .byte 64	/* Declare a byte, referred to as location var, containing the value 64. */
 4    .byte 10	/* Declare a byte with no label, containing the value 10. Its location is var + 1. */
 5    x:		
 6    .short 42	/* Declare a 2-byte value initialized to 42, referred to as location x. */
 7    y:		
 8    .long 30000    	/* Declare a 4-byte value, referred to as location y, initialized to 30000. */
 9    
10    
11    s:		
12    .long 1, 2, 3	/* Declare three 4-byte values, initialized to 1, 2, and 3. 
13    The value at location s + 8 will be 3. */
14    barr:		
15    .zero 10	/* Declare 10 bytes starting at location barr, initialized to 0. */
16    str:		
17    .string "hello"   	/* Declare 6 bytes starting at the address str initialized to 
18    the ASCII character values for hello followed by a nul (0) byte. */
19

 1    #ifdef __ASSEMBLER__
 2    
 3    /*
 4     * Macros to build GDT entries in assembly.
 5     */
 6    #define SEG_NULL                                                \
 7            .word 0, 0;                                             \
 8            .byte 0, 0, 0, 0
 9    #define SEG(type,base,lim)                                      \
10            .word (((lim) > 12) & 0xffff), ((base) & 0xffff);      \
11            .byte (((base) > 16) & 0xff), (0x90 | (type)),         \
12                    (0xC0 | (((lim) > 28) & 0xf)), (((base) > 24) & 0xff)
13    
14    #else   // not __ASSEMBLER__
15

  1    
  2    #include <inc/x86.h                                                                                                                                                                          
  3    #include <inc/elf.h                                                                                                                                                                          
  4                                                                                                                                                                                                  
  5    /**********************************************************************                                                                                                                       
  6     * This a dirt simple boot loader, whose sole job is to boot                                                                                                                                  
  7     * an ELF kernel image from the first IDE hard disk.                                                                                                                                          
  8     *                                                                                                                                                                                            
  9     * DISK LAYOUT                                                                                                                                                                                
 10     *  * This program(boot.S and main.c) is the bootloader.  It should                                                                                                                           
 11     *    be stored in the first sector of the disk.                                                                                                                                              
 12     *                                                                                                                                                                                            
 13     *  * The 2nd sector onward holds the kernel image.                                                                                                                                           
 14     *                                                                                                                                                                                            
 15     *  * The kernel image must be in ELF format.                                                                                                                                                 
 16     *                                                                                                      c                                                                                      
 17     * BOOT UP STEPS                                                                                                                                                                              
 18     *  * when the CPU boots it loads the BIOS into memory and executes it                                                                                                                        
 19     *                                                                                                                                                                                            
 20     *  * the BIOS intializes devices, sets of the interrupt routines, and
 21     *    reads the first sector of the boot device(e.g., hard-drive)
 22     *    into memory and jumps to it.
 23     *
 24     *  * Assuming this boot loader is stored in the first sector of the
 25     *    hard-drive, this code takes over...
 26     *
 27     *  * control starts in boot.S -- which sets up protected mode,
 28     *    and a stack so C code then run, then calls bootmain()
 29     *
 30     *  * bootmain() in this file takes over, reads in the kernel and jumps to it.
 31     **********************************************************************/
 32    
 33    #define SECTSIZE        512
 34    #define ELFHDR          ((struct Elf *) 0x10000) // scratch space
 35    
 36    void readsect(void*, uint32_t);
 37    void readseg(uint32_t, uint32_t, uint32_t);
 38    
 39    void
 40    bootmain(void)
 41    {
 42            struct Proghdr *ph, *eph;
 43    
 44            // read 1st page off disk
 45            readseg((uint32_t) ELFHDR, SECTSIZE*8, 0);
 46    
 47            // is this a valid ELF?
 48            if (ELFHDR->e_magic != ELF_MAGIC)
 49                    goto bad;
 50    
 51            // load each program segment (ignores ph flags)
 52            ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
 53            eph = ph + ELFHDR->e_phnum;
 54            for (; ph < eph; ph++)
 55                    // p_pa is the load address of this segment (as well
 56                    // as the physical address)
 57                    readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
 58    
 59            // call the entry point from the ELF header
 60            // note: does not return!
 61            ((void (*)(void)) (ELFHDR->e_entry))();
 62    
 63    bad:
 64            outw(0x8A00, 0x8A00);
 65            outw(0x8A00, 0x8E00);
 66            while (1)
 67                    /* do nothing */;
 68    }
 69    
 70    // Read 'count' bytes at 'offset' from kernel into physical address 'pa'.
 71    // Might copy more than asked
 72    void
 73    readseg(uint32_t pa, uint32_t count, uint32_t offset)
 74    {
 75            uint32_t end_pa;
 76    
 77            end_pa = pa + count;
 78    
 79            // round down to sector boundary
 80            pa &= ~(SECTSIZE - 1);
 81    
 82            // translate from bytes to sectors, and kernel starts at sector 1
 83            offset = (offset / SECTSIZE) + 1;
 84    
 85            // If this is too slow, we could read lots of sectors at a time.
 86            // We'd write more to memory than asked, but it doesn't matter --
 87            // we load in increasing order.
 88            while (pa < end_pa) {
 89                    // Since we haven't enabled paging yet and we're using
 90                    // an identity segment mapping (see boot.S), we can
 91                    // use physical addresses directly.  This won't be the
 92                    // case once JOS enables the MMU.
 93                    readsect((uint8_t*) pa, offset);
 94                    pa += SECTSIZE;
 95                    offset++;
 96            }
 97    }
 98    
 99    void
100    waitdisk(void)
101    {
102            // wait for disk reaady
103            while ((inb(0x1F7) & 0xC0) != 0x40)
104                    /* do nothing */;
105    }
106    
107    void
108    readsect(void *dst, uint32_t offset)
109    {
110            // wait for disk to be ready
111            waitdisk();
112    
113            outb(0x1F2, 1);         // count = 1
114            outb(0x1F3, offset);
115            outb(0x1F4, offset > 8);
116            outb(0x1F5, offset > 16);
117            outb(0x1F6, (offset > 24) | 0xE0);
118            outb(0x1F7, 0x20);      // cmd 0x20 - read sectors
119    
120            // wait for disk to be ready
121            waitdisk();
122    
123            // read a sector
124            insl(0x1F0, dst, SECTSIZE/4);
125    }
126

 1    static inline void
 2    outb(int port, uint8_t data)
 3    {
 4            asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
 5    }
 6    
 7    
 8    static inline void
 9    insl(int port, void *addr, int cnt)
10    {
11            asm volatile("cld\n\trepne\n\tinsl"
12                         : "=D" (addr), "=c" (cnt)
13                         : "d" (port), "0" (addr), "1" (cnt)
14                         : "memory", "cc");
15    }
16    static inline uint8_t
17    inb(int port)
18    {       
19            uint8_t data;
20            asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
21            return data;
22    }
23

 1   #ifndef JOS_INC_ELF_H
 2   #define JOS_INC_ELF_H
 3   
 4   #define ELF_MAGIC 0x464C457FU	/* "\x7FELF" in little endian */
 5   
 6   struct Elf {
 7   	uint32_t e_magic;	// must equal ELF_MAGIC
 8   	uint8_t e_elf[12];
 9   	/* e_elf[0] 1 for signed 32 bit , 2 for signed 64-bit
10   	        [1] 1 for little endianness ,2 for big endianness
11                   [2] version type
12                   [3] target OS
13                   [4] ABI version
14                   [5..11]  unused
15   	*/
16   	uint16_t e_type;     // object file type
17   	uint16_t e_machine;  // instruction set arch , x86/MIPS/IA-64 and etc.
18   	uint32_t e_version; 
19   	uint32_t e_entry;    // the memory address of the entry point where process start executing.
20   	uint32_t e_phoff;    // points to the start of the program header table.
21   	uint32_t e_shoff;    // Points to the start of the section header table.
22   	uint32_t e_flags;  
23   	uint16_t e_ehsize;   // size of this header. 64byte for 64-bit,52bytes for 32-bit
24   	uint16_t e_phentsize; // the size of a program header table entry.
25   	uint16_t e_phnum;    // the number of entries in the program header table.
26   	uint16_t e_shentsize; // the size of a section  header table entry.
27   	uint16_t e_shnum;    // the number of entries in the section header table.
28   	uint16_t e_shstrndx; 
29   };
30   
31   struct Proghdr {
32   	uint32_t p_type;    // type of the segment
33   	uint32_t p_offset;  //  offset of the segment in the file image
34   	uint32_t p_va;      // virtual address of the segment in memory
35   	uint32_t p_pa;      // physical address for segment(?)
36   	uint32_t p_filesz;  // Size in bytes of the segment in the file image. May be 0.
37   	uint32_t p_memsz;   // Size in bytes of the segment in memory. May be 0.
38   	uint32_t p_flags;
39   	uint32_t p_align;   // 0 and 1 specify no alignment. Otherwise should be a positive, integral power of 2
40   };
41   
42   struct Secthdr {
43   	uint32_t sh_name; // An offset to a string in the .shstrtab section that represents the name of this section
44   	uint32_t sh_type; // the type of this header
45   	uint32_t sh_flags; // the attributes of the section
46   	uint32_t sh_addr; // Virtual address of the section in memory
47   	uint32_t sh_offset;  // Offset of the section in the file image
48   	uint32_t sh_size;    // Size in bytes of the section in the file image. May be 0.
49   	uint32_t sh_link;    // 
50   	uint32_t sh_info;
51   	uint32_t sh_addralign;
52   	uint32_t sh_entsize;
53           /*
54             Contains the size, in bytes, of each entry, for sections that contain fixed-size entries. 
55             Otherwise, this field contains zero.
56            */
57   };
58   
59   // Values for Proghdr::p_type
60   #define ELF_PROG_LOAD		1
61   
62   // Flag bits for Proghdr::p_flags
63   #define ELF_PROG_FLAG_EXEC	1
64   #define ELF_PROG_FLAG_WRITE	2
65   #define ELF_PROG_FLAG_READ	4
66   
67   // Values for Secthdr::sh_type
68   #define ELF_SHT_NULL		0
69   #define ELF_SHT_PROGBITS	1
70   #define ELF_SHT_SYMTAB		2
71   #define ELF_SHT_STRTAB		3
72   
73   // Values for Secthdr::sh_name
74   #define ELF_SHN_UNDEF		0
75   
76   #endif /* !JOS_INC_ELF_H */

  1
  2    obj/boot/boot.out:     file format elf32-i386                                                                                                                                                 
  3                                                                                                                                                                                                  
  4                                                                                                                                                                                                  
  5    Disassembly of section .text:                                                                                                                                                                 
  6                                                                                                                                                                                                  
  7    00007c00 <start>:                                                                                                                                                                             
  8    .set CR0_PE_ON,      0x1         # protected mode enable flag                                                                                                                                 
  9                                                                                                                                                                                                  
 10    .globl start                                                                                                                                                                                  
 11    start:                                                                                                                                                                                        
 12      .code16                     # Assemble for 16-bit mode                                                                                                                                      
 13      cli                         # Disable interrupts                                                                                                                                            
 14        7c00:       fa                      cli                                                                                                                                                   
 15      cld                         # String operations increment                                                                                                                                   
 16        7c01:       fc                      cld                                                                                                                                                   
 17                                                                                                                                                                                                  
 18      # Set up the important data segment registers (DS, ES, SS).                                                                                                                                 
 19      xorw    %ax,%ax             # Segment number zero                                                                                                                                           
 20        7c02:       31 c0                   xor    x,x                                                                                                                                      
 21      movw    %ax,%ds             # - Data Segment                                                                                                                                               
 22        7c04:       8e d8                   mov    x,%ds                                                                                                                                       
 23      movw    %ax,%es             # - Extra Segment                                                                                                                                              
 24        7c06:       8e c0                   mov    x,%es                                                                                                                                       
 25      movw    %ax,%ss             # - Stack Segment                                                                                                                                              
 26        7c08:       8e d0                   mov    x,%ss                                                                                                                                       
 27                                                                                                                                                                                                  
 28    00007c0a <seta20.1>:
 29      # Enable A20:
 30      #   For backwards compatibility with the earliest PCs, physical
 31      #   address line 20 is tied low, so that addresses higher than
 32      #   1MB wrap around to zero by default.  This code undoes this.
 33    seta20.1:
 34      inb     $0x64,%al               # Wait for not busy
 35        7c0a:       e4 64                   in     $0x64,%al
 36      testb   $0x2,%al
 37        7c0c:       a8 02                   test   $0x2,%al
 38      jnz     seta20.1
 39        7c0e:       75 fa                   jne    7c0a <seta20.1>
 40    
 41      movb    $0xd1,%al               # 0xd1 - port 0x64
 42        7c10:       b0 d1                   mov    $0xd1,%al
 43      outb    %al,$0x64
 44        7c12:       e6 64                   out    %al,$0x64
 45    
 46    00007c14 <seta20.2>:
 47    
 48    seta20.2:
 49      inb     $0x64,%al               # Wait for not busy
 50        7c14:       e4 64                   in     $0x64,%al
 51      testb   $0x2,%al
 52        7c16:       a8 02                   test   $0x2,%al
 53      jnz     seta20.2
 54        7c18:       75 fa                   jne    7c14 <seta20.2>
 55    
 56      movb    $0xdf,%al               # 0xdf - port 0x60
 57        7c1a:       b0 df                   mov    $0xdf,%al
 58      outb    %al,$0x60
 59        7c1c:       e6 60                   out    %al,$0x60
 60    
 61      # Switch from real to protected mode, using a bootstrap GDT
 62      # and segment translation that makes virtual addresses 
 63      # identical to their physical addresses, so that the 
 64      # effective memory map does not change during the switch.
 65      lgdt    gdtdesc  # lgdt means load global descriptor table
 66        7c1e:       0f 01 16                lgdtl  (%esi)
 67        7c21:       64 7c 0f                fs jl  7c33 <protcseg+0x1>
 68      movl    %cr0, x
 69        7c24:       20 c0                   and    %al,%al
 70      orl     $CR0_PE_ON, x  # crx = crx | 1
 71        7c26:       66 83 c8 01             or     $0x1,%ax
 72      movl    x, %cr0
 73        7c2a:       0f 22 c0                mov    x,%cr0
 74      
 75      # Jump to next instruction, but in 32-bit code segment.
 76      # Switches processor into 32-bit mode.
 77      ljmp    $PROT_MODE_CSEG, $protcseg
 78        7c2d:       ea                      .byte 0xea
 79        7c2e:       32 7c 08 00             xor    0x0(x,x,1),%bh
 80    
 81    00007c32 <protcseg>:
 82    
 83      .code32                     # Assemble for 32-bit mode
 84    protcseg:
 85      # Set up the protected-mode data segment registers
 86      movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
 87        7c32:       66 b8 10 00             mov    $0x10,%ax
 88      movw    %ax, %ds                # - DS: Data Segment
 89        7c36:       8e d8                   mov    x,%ds
 90      movw    %ax, %es                # - ES: Extra Segment
 91        7c38:       8e c0                   mov    x,%es
 92      movw    %ax, %fs                # - FS
 93        7c3a:       8e e0                   mov    x,%fs
 94      movw    %ax, %gs                # - GS
 95        7c3c:       8e e8                   mov    x,%gs
 96      movw    %ax, %ss                # - SS: Stack Segment
 97        7c3e:       8e d0                   mov    x,%ss
 98      
 99      # Set up the stack pointer and call into C.
100      movl    $start, %esp
101        7c40:       bc 00 7c 00 00          mov    $0x7c00,%esp
102      call bootmain
103        7c45:       e8 c0 00 00 00          call   7d0a <bootmain>
104    
105    00007c4a <spin>:
106    
107      # If bootmain returns (it shouldn't), loop.
108    spin:
109      jmp spin
110        7c4a:       eb fe                   jmp    7c4a <spin>
111    
112    00007c4c <gdt>:
113            ...
114        7c54:       ff                      (bad)  
115        7c55:       ff 00                   incl   (x)
116        7c57:       00 00                   add    %al,(x)
117        7c59:       9a cf 00 ff ff 00 00    lcall  $0x0,$0xffff00cf
118        7c60:       00                      .byte 0x0
119        7c61:       92                      xchg   x,x
120        7c62:       cf                      iret   
121            ...
122    
123    00007c64 <gdtdesc>:
124        7c64:       17                      pop    %ss
125        7c65:       00 4c 7c 00             add    %cl,0x0(%esp,i,2)
126            ...
127    
128    00007c6a <waitdisk>:
129            }
130    }
131    
132    void
133    waitdisk(void)
134    {
135        7c6a:       55                      push   p
136    
137    static inline uint8_t
138    inb(int port)
139    {
140            uint8_t data;
141            asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
142        7c6b:       ba f7 01 00 00          mov    $0x1f7,x
143        7c70:       89 e5                   mov    %esp,p
144        7c72:       ec                      in     (%dx),%al
145            // wait for disk reaady
146            while ((inb(0x1F7) & 0xC0) != 0x40)
147        7c73:       83 e0 c0                and    $0xffffffc0,x
148        7c76:       3c 40                   cmp    $0x40,%al
149        7c78:       75 f8                   jne    7c72 <waitdisk+0x8>
150                    /* do nothing */;
151    }
152        7c7a:       5d                      pop    p
153        7c7b:       c3                      ret    
154    
155    00007c7c <readsect>:
156    
157    void
158    readsect(void *dst, uint32_t offset)
159    {
160        7c7c:       55                      push   p
161        7c7d:       89 e5                   mov    %esp,p
162        7c7f:       57                      push   i
163        7c80:       53                      push   x
164        7c81:       8b 5d 0c                mov    0xc(p),x
165            // wait for disk to be ready
166            waitdisk();
167        7c84:       e8 e1 ff ff ff          call   7c6a <waitdisk>
168    }
169    
170    static inline void
171    outb(int port, uint8_t data)
172    {
173            asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
174        7c89:       ba f2 01 00 00          mov    $0x1f2,x
175        7c8e:       b0 01                   mov    $0x1,%al
176        7c90:       ee                      out    %al,(%dx)
177        7c91:       0f b6 c3                movzbl %bl,x
178        7c94:       b2 f3                   mov    $0xf3,%dl
179        7c96:       ee                      out    %al,(%dx)
180        7c97:       0f b6 c7                movzbl %bh,x
181        7c9a:       b2 f4                   mov    $0xf4,%dl
182        7c9c:       ee                      out    %al,(%dx)
183    
184            outb(0x1F2, 1);         // count = 1
185            outb(0x1F3, offset);
186            outb(0x1F4, offset > 8);
187            outb(0x1F5, offset > 16);
188        7c9d:       89 d8                   mov    x,x
189        7c9f:       b2 f5                   mov    $0xf5,%dl
190        7ca1:       c1 e8 10                shr    $0x10,x
191        7ca4:       0f b6 c0                movzbl %al,x
192        7ca7:       ee                      out    %al,(%dx)
193            outb(0x1F6, (offset > 24) | 0xE0);
194        7ca8:       c1 eb 18                shr    $0x18,x
195        7cab:       b2 f6                   mov    $0xf6,%dl
196        7cad:       88 d8                   mov    %bl,%al
197        7caf:       83 c8 e0                or     $0xffffffe0,x
198        7cb2:       ee                      out    %al,(%dx)
199        7cb3:       b0 20                   mov    $0x20,%al
200        7cb5:       b2 f7                   mov    $0xf7,%dl
201        7cb7:       ee                      out    %al,(%dx)
202            outb(0x1F7, 0x20);      // cmd 0x20 - read sectors
203    
204            // wait for disk to be ready
205            waitdisk();
206        7cb8:       e8 ad ff ff ff          call   7c6a <waitdisk>
207    }
208    
209    static inline void
210    insl(int port, void *addr, int cnt)
211    {
212            asm volatile("cld\n\trepne\n\tinsl"
213        7cbd:       8b 7d 08                mov    0x8(p),i
214        7cc0:       b9 80 00 00 00          mov    $0x80,x
215        7cc5:       ba f0 01 00 00          mov    $0x1f0,x
216        7cca:       fc                      cld    
217        7ccb:       f2 6d                   repnz insl (%dx),%es:(i)
218    
219            // read a sector
220            insl(0x1F0, dst, SECTSIZE/4);
221    }
222        7ccd:       5b                      pop    x
223        7cce:       5f                      pop    i
224        7ccf:       5d                      pop    p
225        7cd0:       c3                      ret    
226    
227    00007cd1 <readseg>:
228    
229    // Read 'count' bytes at 'offset' from kernel into physical address 'pa'.
230    // Might copy more than asked
231    void
232    readseg(uint32_t pa, uint32_t count, uint32_t offset)
233    {
234        7cd1:       55                      push   p
235        7cd2:       89 e5                   mov    %esp,p
236        7cd4:       57                      push   i
237            uint32_t end_pa;
238    
239            end_pa = pa + count;
240        7cd5:       8b 7d 0c                mov    0xc(p),i
241    
242    // Read 'count' bytes at 'offset' from kernel into physical address 'pa'.
243    // Might copy more than asked
244    void
245    readseg(uint32_t pa, uint32_t count, uint32_t offset)
246    {
247        7cd8:       56                      push   %esi
248        7cd9:       8b 75 10                mov    0x10(p),%esi
249        7cdc:       53                      push   x
250        7cdd:       8b 5d 08                mov    0x8(p),x
251    
252            // round down to sector boundary
253            pa &= ~(SECTSIZE - 1);
254    
255            // translate from bytes to sectors, and kernel starts at sector 1
256            offset = (offset / SECTSIZE) + 1;
257        7ce0:       c1 ee 09                shr    $0x9,%esi
258    void
259    readseg(uint32_t pa, uint32_t count, uint32_t offset)
260    {
261            uint32_t end_pa;
262    
263            end_pa = pa + count;
264        7ce3:       01 df                   add    x,i
265    
266            // round down to sector boundary
267            pa &= ~(SECTSIZE - 1);
268    
269            // translate from bytes to sectors, and kernel starts at sector 1
270            offset = (offset / SECTSIZE) + 1;
271        7ce5:       46                      inc    %esi
272            uint32_t end_pa;
273    
274            end_pa = pa + count;
275    
276            // round down to sector boundary
277            pa &= ~(SECTSIZE - 1);
278        7ce6:       81 e3 00 fe ff ff       and    $0xfffffe00,x
279            offset = (offset / SECTSIZE) + 1;
280    
281            // If this is too slow, we could read lots of sectors at a time.
282            // We'd write more to memory than asked, but it doesn't matter --
283            // we load in increasing order.
284            while (pa < end_pa) {
285        7cec:       39 fb                   cmp    i,x
286        7cee:       73 12                   jae    7d02 <readseg+0x31>
287                    // Since we haven't enabled paging yet and we're using
288                    // an identity segment mapping (see boot.S), we can
289                    // use physical addresses directly.  This won't be the
290                    // case once JOS enables the MMU.
291                    readsect((uint8_t*) pa, offset);
292        7cf0:       56                      push   %esi
293                    pa += SECTSIZE;
294                    offset++;
295        7cf1:       46                      inc    %esi
296            while (pa < end_pa) {
297                    // Since we haven't enabled paging yet and we're using
298                    // an identity segment mapping (see boot.S), we can
299                    // use physical addresses directly.  This won't be the
300                    // case once JOS enables the MMU.
301                    readsect((uint8_t*) pa, offset);
302        7cf2:       53                      push   x
303                    pa += SECTSIZE;
304        7cf3:       81 c3 00 02 00 00       add    $0x200,x
305            while (pa < end_pa) {
306                    // Since we haven't enabled paging yet and we're using
307                    // an identity segment mapping (see boot.S), we can
308                    // use physical addresses directly.  This won't be the
309                    // case once JOS enables the MMU.
310                    readsect((uint8_t*) pa, offset);
311        7cf9:       e8 7e ff ff ff          call   7c7c <readsect>
312                    pa += SECTSIZE;
313                    offset++;
314        7cfe:       58                      pop    x
315        7cff:       5a                      pop    x
316        7d00:       eb ea                   jmp    7cec <readseg+0x1b>
317            }
318    }
319        7d02:       8d 65 f4                lea    -0xc(p),%esp
320        7d05:       5b                      pop    x
321        7d06:       5e                      pop    %esi
322        7d07:       5f                      pop    i
323        7d08:       5d                      pop    p
324        7d09:       c3                      ret    
325    
326    00007d0a <bootmain>:
327    void readsect(void*, uint32_t);
328    void readseg(uint32_t, uint32_t, uint32_t);
329    
330    void
331    bootmain(void)
332    {
333        7d0a:       55                      push   p
334        7d0b:       89 e5                   mov    %esp,p
335        7d0d:       56                      push   %esi
336        7d0e:       53                      push   x
337            struct Proghdr *ph, *eph;
338    
339            // read 1st page off disk
340            readseg((uint32_t) ELFHDR, SECTSIZE*8, 0);
341        7d0f:       6a 00                   push   $0x0
342        7d11:       68 00 10 00 00          push   $0x1000
343        7d16:       68 00 00 01 00          push   $0x10000
344        7d1b:       e8 b1 ff ff ff          call   7cd1 <readseg>
345    
346            // is this a valid ELF?
347            if (ELFHDR->e_magic != ELF_MAGIC)
348        7d20:       83 c4 0c                add    $0xc,%esp
349        7d23:       81 3d 00 00 01 00 7f    cmpl   $0x464c457f,0x10000
350        7d2a:       45 4c 46 
351        7d2d:       75 38                   jne    7d67 <bootmain+0x5d>
352                    goto bad;
353    
354            // load each program segment (ignores ph flags)
355            ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
356        7d2f:       a1 1c 00 01 00          mov    0x1001c,x
357        7d34:       8d 98 00 00 01 00       lea    0x10000(x),x
358            eph = ph + ELFHDR->e_phnum;
359        7d3a:       0f b7 05 2c 00 01 00    movzwl 0x1002c,x
360        7d41:       c1 e0 05                shl    $0x5,x
361        7d44:       8d 34 03                lea    (x,x,1),%esi
362            for (; ph < eph; ph++)
363        7d47:       39 f3                   cmp    %esi,x
364        7d49:       73 16                   jae    7d61 <bootmain+0x57>
365                    // p_pa is the load address of this segment (as well
366                    // as the physical address)
367                    readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
368        7d4b:       ff 73 04                pushl  0x4(x)
369                    goto bad;
370    
371            // load each program segment (ignores ph flags)
372            ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
373            eph = ph + ELFHDR->e_phnum;
374            for (; ph < eph; ph++)
375        7d4e:       83 c3 20                add    $0x20,x
376                    // p_pa is the load address of this segment (as well
377                    // as the physical address)
378                    readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
379        7d51:       ff 73 f4                pushl  -0xc(x)
380        7d54:       ff 73 ec                pushl  -0x14(x)
381        7d57:       e8 75 ff ff ff          call   7cd1 <readseg>
382                    goto bad;
383    
384            // load each program segment (ignores ph flags)
385            ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
386            eph = ph + ELFHDR->e_phnum;
387            for (; ph < eph; ph++)
388        7d5c:       83 c4 0c                add    $0xc,%esp
389        7d5f:       eb e6                   jmp    7d47 <bootmain+0x3d>
390                    // as the physical address)
391                    readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
392    
393            // call the entry point from the ELF header
394            // note: does not return!
395            ((void (*)(void)) (ELFHDR->e_entry))();
396        7d61:       ff 15 18 00 01 00       call   *0x10018
397    }
398    
399    static inline void
400    outw(int port, uint16_t data)
401    {
402            asm volatile("outw %0,%w1" : : "a" (data), "d" (port));
403        7d67:       ba 00 8a 00 00          mov    $0x8a00,x
404        7d6c:       b8 00 8a ff ff          mov    $0xffff8a00,x
405        7d71:       66 ef                   out    %ax,(%dx)
406        7d73:       b8 00 8e ff ff          mov    $0xffff8e00,x
407        7d78:       66 ef                   out    %ax,(%dx)
408        7d7a:       eb fe                   jmp    7d7a <bootmain+0x70>
409    
410

 1    [f000:fff0]    0xffff0: ljmp   $0xf000,$0xe05b
 2    [f000:e05b]    0xfe05b: cmpl   $0x0,%cs:0x6ac8
 3    [f000:e062]    0xfe062: jne    0xfd2e1
 4    [f000:e066]    0xfe066: xor    %dx,%dx
 5    [f000:e068]    0xfe068: mov    %dx,%ss
 6    [f000:e06a]    0xfe06a: mov    $0x7000,%esp
 7    [f000:e070]    0xfe070: mov    $0xf34c2,x
 8    [f000:e076]    0xfe076: jmp    0xfd15c
 9    [f000:d15c]    0xfd15c: mov    x,x
10    [f000:d15f]    0xfd15f: cli  
11    [f000:d160]    0xfd160: cld 
12    [f000:d161]    0xfd161: mov    $0x8f,x
13    [f000:d167]    0xfd167: out    %al,$0x70
14    [f000:d169]    0xfd169: in     $0x71,%al
15    [f000:d16b]    0xfd16b: in     $0x92,%al
16    [f000:d16d]    0xfd16d: or     $0x2,%al
17    [f000:d16f]    0xfd16f: out    %al,$0x92
18    [f000:d171]    0xfd171: lidtw  %cs:0x6ab8
19    [f000:d177]    0xfd177: lgdtw  %cs:0x6a74
20    [f000:d17d]    0xfd17d: mov    %cr0,x
21    [f000:d180]    0xfd180: or     $0x1,x
22    [f000:d184]    0xfd184: mov    x,%cr0
23    [f000:d187]    0xfd187: ljmpl  $0x8,$0xfd18f
24    
25    The target architecture is assumed to be i386
26    0xfd18f:     mov    $0x10,x
27    0xfd194:     mov    x,%ds
28    0xfd196:     mov    x,%es
29    0xfd198:     mov    x,%ss
30    0xfd19a:     mov    x,%fs
31    0xfd19c:     mov    x,%gs
32    0xfd19e:     mov    x,x
33    0xfd1a0:     jmp    *x
34    0xf34c2:     push   x
35    0xf34c3:     sub    $0x2c,%esp
36    0xf34c6:     movl   $0xf5b5c,0x4(%esp)
37    0xf34ce:     movl   $0xf447b,(%esp)
38    0xf34d5:     call   0xf099e
39    0xf099e:     lea    0x8(%esp),x
40    0xf09a2:     mov    0x4(%esp),x
41    0xf09a6:     mov    $0xf5b58,x
42    0xf09ab:     call   0xf0574
43    0xf0574:     push   p
44    0xf0575:     push   i
45    0xf0576:     push   %esi
46    0xf0577:     push   x
47    0xf0578:     sub    $0xc,%esp
48    0xf057b:     mov    x,0x4(%esp)
49    0xf057f:     mov    x,p
50    0xf0581:     mov    x,%esi
51    0xf0583:     movsbl 0x0(p),x
52    0xf0587:     test   %dl,%dl
53    0xf0589:     je     0xf0758
54    0xf058f:     cmp    $0x25,%dl
55    0xf0592:     jne    0xf0741
56    0xf0741:     mov    0x4(%esp),x
57    
58    

 1    #include <stdio.h>
 2    #include <stdlib.h>
 3    
 4    void
 5    f(void)
 6    {
 7        int a[4];
 8        int *b = malloc(16);
 9        int *c;
10        int i;
11    
12        printf("1: a = %p, b = %p, c = %p\n", a, b, c);
13    
14        c = a;
15        for (i = 0; i < 4; i++)
16    	a[i] = 100 + i;
17        c[0] = 200;
18        printf("2: a[0] = %d, a[1] = %d, a[2] = %d, a[3] = %d\n",
19    	   a[0], a[1], a[2], a[3]);
20    
21        c[1] = 300;
22        *(c + 2) = 301;
23        3[c] = 302;
24        printf("3: a[0] = %d, a[1] = %d, a[2] = %d, a[3] = %d\n",
25    	   a[0], a[1], a[2], a[3]);
26    
27        c = c + 1;
28        *c = 400;
29        printf("4: a[0] = %d, a[1] = %d, a[2] = %d, a[3] = %d\n",
30    	   a[0], a[1], a[2], a[3]);
31    
32        c = (int *) ((char *) c + 1);
33        *c = 500;
34        printf("5: a[0] = %d, a[1] = %d, a[2] = %d, a[3] = %d\n",
35    	   a[0], a[1], a[2], a[3]);
36    
37        b = (int *) a + 1;
38        c = (int *) ((char *) a + 1);
39        printf("6: a = %p, b = %p, c = %p\n", a, b, c);
40    }
41    
42    int
43    main(int ac, char **av)
44    {
45        f();
46        return 0;
47    }
48    
49

 1    objdump -h obj/kern/kernel
 2    
 3    obj/kern/kernel:     file format elf32-i386
 4    
 5    Sections:
 6    Idx Name          Size      VMA       LMA       File off  Algn
 7      0 .text         00001917  f0100000  00100000  00001000  2**4
 8                      CONTENTS, ALLOC, LOAD, READONLY, CODE
 9      1 .rodata       00000714  f0101920  00101920  00002920  2**5
10                      CONTENTS, ALLOC, LOAD, READONLY, DATA
11      2 .stab         00003889  f0102034  00102034  00003034  2**2
12                      CONTENTS, ALLOC, LOAD, READONLY, DATA
13      3 .stabstr      000018af  f01058bd  001058bd  000068bd  2**0
14                      CONTENTS, ALLOC, LOAD, READONLY, DATA
15      4 .data         0000a300  f0108000  00108000  00009000  2**12
16                      CONTENTS, ALLOC, LOAD, DATA
17      5 .bss          00000648  f0112300  00112300  00013300  2**5
18                      CONTENTS, ALLOC, LOAD, DATA
19      6 .comment      00000023  00000000  00000000  00013948  2**0
20                      CONTENTS, READONLY
21

 1    protcseg:
 2      # Set up the protected-mode data segment registers
 3      movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
 4        9c32:       66 b8 10 00             mov    $0x10,%ax
 5      movw    %ax, %ds                # - DS: Data Segment
 6        9c36:       8e d8                   mov    x,%ds
 7      movw    %ax, %es                # - ES: Extra Segment
 8        9c38:       8e c0                   mov    x,%es
 9      movw    %ax, %fs                # - FS
10        9c3a:       8e e0                   mov    x,%fs
11      movw    %ax, %gs                # - GS
12        9c3c:       8e e8                   mov    x,%gs
13      movw    %ax, %ss                # - SS: Stack Segment
14        9c3e:       8e d0                   mov    x,%ss
15    
16      # Set up the stack pointer and call into C.
17      movl    $start, %esp
18        9c40:       bc 00 9c 00 00          mov    $0x9c00,%esp
19      call bootmain
20        9c45:       e8 c0 00 00 00          call   9d0a <bootmain>
21    
22    00009c4a <spin>:
23    
24      # If bootmain returns (it shouldn't), loop.
25    spin:
26      jmp spin
27        9c4a:       eb fe                   jmp    9c4a <spin>

 1    (gdb) x/8x 0xf0100000                                                                                                 
 2    0xf0100000 <_start+4026531828>: 0x00000000      0x00000000      0x00000000      0x00000000                                                                                 
 3    0xf0100010 <entry+4>:   0x00000000      0x00000000      0x00000000      0x00000000 
 4    
 5    x/8i 0x00100000                                                                                                                                                      │·······································
 6       0x100000:    add    0x1bad(x),%dh                                                                                                                                    │·······································
 7       0x100006:    add    %al,(x)                                                                                                                                          │·······································
 8       0x100008:    decb   0x52(i)                                                                                                                                          │·······································
 9       0x10000b:    in     $0x66,%al                                                                                                                                           │·······································
10       0x10000d:    movl   $0xb81234,0x472                                                                                                                                     │·······································
11       0x100017:    add    %dl,(x)                                                                                                                                          │·······································
12       0x100019:    add    %cl,(i)                                                                                                                                          │·······································
13       0x10001b:    and    %al,%bl
14
15

1    case 'o':
2    			// Replace this with your code.
3    			num = getuint(&ap,lflag);
4    			base = 8;
5    			goto number;

 1     
 2     if (crt_pos >= CRT_SIZE) {
 3              int i;
 4              memmove(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
 5              for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i++)
 6              crt_buf[i] = 0x0700 | ' ';
 7              crt_pos -= CRT_COLS;
 8     }
 9 
10 

1    
2    int a = 0x12345678
3    char *c = reinterpret_cast<char*>(&a);
4    printf("%x %x %x %x\n",c[0],c[1],c[2],c[3]);
5    //小端输出:78 56 34 12
6    //大端输出:12 34 56 78

 1    f010002c <relocated>:
 2    relocated:
 3    
 4            # Clear the frame pointer register (EBP)
 5            # so that once we get into debugging C code,
 6            # stack backtraces will be terminated properly.
 7            movl    $0x0,p                       # nuke frame pointer
 8    f010002c:       bd 00 00 00 00          mov    $0x0,p
 9    
10            # Set the stack pointer
11            movl    $(bootstacktop),%esp
12    f0100031:       bc 00 00 11 f0          mov    $0xf0110000,%esp

 1    // All physical memory mapped at this address
 2    #define	KERNBASE	0xF0000000
 3    
 4    // At IOPHYSMEM (640K) there is a 384K hole for I/O.  From the kernel,
 5    // IOPHYSMEM can be addressed at KERNBASE + IOPHYSMEM.  The hole ends
 6    // at physical address EXTPHYSMEM.
 7    #define IOPHYSMEM	0x0A0000
 8    #define EXTPHYSMEM	0x100000
 9    
10    // Kernel stack.
11    #define KSTACKTOP	KERNBASE
12    #define KSTKSIZE	(8*PGSIZE)   		// size of a kernel stack
13    #define KSTKGAP		(8*PGSIZE)   		// size of a kernel stack guard
14    
15    // Memory-mapped IO.
16    #define MMIOLIM		(KSTACKTOP - PTSIZE)
17    #define MMIOBASE	(MMIOLIM - PTSIZE)

 1    // Test the stack backtrace function (lab 1 only)
 2    void
 3    test_backtrace(int x)
 4    {
 5    f0100040:       55                      push   p
 6    f0100041:       89 e5                   mov    %esp,p
 7    f0100043:       53                      push   x
 8    f0100044:       83 ec 14                sub    $0x14,%esp
 9    f0100047:       8b 5d 08                mov    0x8(p),x
10            cprintf("entering test_backtrace %d\n", x);
11    f010004a:       89 5c 24 04             mov    x,0x4(%esp)
12    f010004e:       c7 04 24 e0 18 10 f0    movl   $0xf01018e0,(%esp)
13    f0100055:       e8 d7 08 00 00          call   f0100931 <cprintf>
14            if (x  0)
15    f010005a:       85 db                   test   x,x
16    f010005c:       7e 0d                   jle    f010006b <test_backtrace+0x2b>
17                    test_backtrace(x-1);
18    f010005e:       8d 43 ff                lea    -0x1(x),x
19    f0100061:       89 04 24                mov    x,(%esp)
20    f0100064:       e8 d7 ff ff ff          call   f0100040 <test_backtrace>
21    f0100069:       eb 1c                   jmp    f0100087 <test_backtrace+0x47>
22            else
23                    mon_backtrace(0, 0, 0);
24    f010006b:       c7 44 24 08 00 00 00    movl   $0x0,0x8(%esp)
25    f0100072:       00 
26    f0100073:       c7 44 24 04 00 00 00    movl   $0x0,0x4(%esp)
27    f010007a:       00 
28    f010007b:       c7 04 24 00 00 00 00    movl   $0x0,(%esp)
29    f0100082:       e8 18 07 00 00          call   f010079f <mon_backtrace>
30            cprintf("leaving test_backtrace %d\n", x);
31    f0100087:       89 5c 24 04             mov    x,0x4(%esp)
32    f010008b:       c7 04 24 fc 18 10 f0    movl   $0xf01018fc,(%esp)
33    f0100092:       e8 9a 08 00 00          call   f0100931 <cprintf>
34    }
35    f0100097:       83 c4 14                add    $0x14,%esp
36    f010009a:       5b                      pop    x
37    f010009b:       5d                      pop    p
38    f010009c:       c3                      ret

 1    int
 2    mon_backtrace(int argc, char **argv, struct Trapframe *tf)
 3    {
 4            // Your code here.
 5            uint32_t *ebp = (uint32_t*)read_ebp();
 6            int i ;
 7            while (ebp)
 8            {
 9                    cprintf("ebp x  eip x  ",ebp,*(ebp+1));
10                    cprintf("args");
11                    for ( i = 2 ; i < 7 ; i++)
12                    {
13                            cprintf(" x",*(ebp+i));
14                    }
15                    cprintf("\n");
16                    ebp = (uint32_t*)*ebp;
17            }
18            return 0;
19    }
20

  1    int
  2    debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info)
  3    {
  4    	const struct Stab *stabs, *stab_end;
  5    	const char *stabstr, *stabstr_end;
  6    	int lfile, rfile, lfun, rfun, lline, rline;
  7    
  8    	// Initialize *info
  9    	info->eip_file = "<unknown>";
 10    	info->eip_line = 0;
 11    	info->eip_fn_name = "<unknown>";
 12    	info->eip_fn_namelen = 9;
 13    	info->eip_fn_addr = addr;
 14    	info->eip_fn_narg = 0;
 15    
 16    	// Find the relevant set of stabs
 17    	if (addr >= ULIM) {
 18    		stabs = __STAB_BEGIN__;
 19    		stab_end = __STAB_END__;
 20    		stabstr = __STABSTR_BEGIN__;
 21    		stabstr_end = __STABSTR_END__;
 22    	} else {
 23    		// Can't search for user-level addresses yet!
 24      	        panic("User address");
 25    	}
 26    
 27    	// String table validity checks
 28    	if (stabstr_end <= stabstr || stabstr_end[-1] != 0)
 29    		return -1;
 30    
 31    	// Now we find the right stabs that define the function containing
 32    	// 'eip'.  First, we find the basic source file containing 'eip'.
 33    	// Then, we look in that source file for the function.  Then we look
 34    	// for the line number.
 35    
 36    	// Search the entire set of stabs for the source file (type N_SO).
 37    	lfile = 0;
 38    	rfile = (stab_end - stabs) - 1;
 39    	stab_binsearch(stabs, &lfile, &rfile, N_SO, addr);
 40    	if (lfile == 0)
 41    		return -1;
 42    
 43    	// Search within that file's stabs for the function definition
 44    	// (N_FUN).
 45    	lfun = lfile;
 46    	rfun = rfile;
 47    	stab_binsearch(stabs, &lfun, &rfun, N_FUN, addr);
 48    
 49    	if (lfun <= rfun) {
 50    		// stabs[lfun] points to the function name
 51    		// in the string table, but check bounds just in case.
 52    		if (stabs[lfun].n_strx < stabstr_end - stabstr)
 53    			info->eip_fn_name = stabstr + stabs[lfun].n_strx;
 54    		info->eip_fn_addr = stabs[lfun].n_value;
 55    		addr -= info->eip_fn_addr;
 56    		// Search within the function definition for the line number.
 57    		lline = lfun;
 58    		rline = rfun;
 59    	} else {
 60    		// Couldn't find function stab!  Maybe we're in an assembly
 61    		// file.  Search the whole file for the line number.
 62    		info->eip_fn_addr = addr;
 63    		lline = lfile;
 64    		rline = rfile;
 65    	}
 66    	// Ignore stuff after the colon.
 67    	info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name;
 68    
 69    
 70    	// Search within [lline, rline] for the line number stab.
 71    	// If found, set info->eip_line to the right line number.
 72    	// If not found, return -1.
 73    	//
 74    	// Hint:
 75    	//	There's a particular stabs type used for line numbers.
 76    	//	Look at the STABS documentation and <inc/stab.h to find
 77    	//	which one.
 78    	//   use N_SLINE
 79    
 80    	// Your code here.
 81    
 82    
 83    
 84    
 85    
 86    	// Search backwards from the line number for the relevant filename
 87    	// stab.
 88    	// We can't just use the "lfile" stab because inlined functions
 89    	// can interpolate code from a different file!
 90    	// Such included source files use the N_SOL stab type.
 91    	while (lline >= lfile
 92    	       && stabs[lline].n_type != N_SOL
 93    	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value))
 94    		lline--;
 95    	if (lline >= lfile && stabs[lline].n_strx < stabstr_end - stabstr)
 96    		info->eip_file = stabstr + stabs[lline].n_strx;
 97    
 98    
 99    	// Set eip_fn_narg to the number of arguments taken by the function,
100    	// or 0 if there was no containing function.
101    	if (lfun < rfun)
102    		for (lline = lfun + 1;
103    		     lline < rfun && stabs[lline].n_type == N_PSYM;
104    		     lline++)
105    			info->eip_fn_narg++;
106    
107    	return 0;
108    }
109
110```c
111发现要补全的地方...其实很容易写？ 因为在要补全的二分之前，已经做了两次二分...照着写一下就好了。
112
113```c    
114            stab_binsearch(stabs, &lline, &rline, N_SLINE, addr);
115            if (lline == 0) return -1;
116            info->eip_line = stabs[rline].n_desc;