The beginnings of a bootloader using GNU-based tools

Question

This is a personal project of mine. I am currently in the research phase of developing my own bootloader that will be used to load a single task operating system. I am far away from the final goal, but have been trying to document my process as a reference. The content of my code documentation and code can be found at Bootloader 101.

If possible I would appreciate feedback. The wiki page is open to be edited, and if you feel like you can contribute please feel free to do so. I apologize beforehand for referencing you to another page. The format of the content is important.

First piece of code:

   # Author: Matthew Hoggan
   # Date Created: Tuesday, Mar 6, 2012
   .code16                        # Tell assembler to work in 16 bit mode (directive)
   .section .text
   .globl _start                  # Help linker find start of program
   _start:
       movb $0x0e,     %ah        # Function to print a character to the screen                 
       movb $0x00,     %bh        # Indicate the page number
       movb $0x07,     %bl        # Text attribute
       mov  $'A',      %al        # Move data into low nibble                   
       int  $0x10                 # Video Service Request to Bios                             
   _hang:                         
       jmp  _hang                 
       .end                       


   /* linker.ld */                
   SECTIONS                       
   {                              
       /* Set location counter to 0x7c00 */
       . = 0x7c00;                
       .text : { *(.text) }       
       .data : { *(.data) }       
       .other :                   
       {                          
            FILL(0x000000)         
            . = 0x1F2;            
            BYTE(0x55)              
            BYTE(0xAA)            
       }
   }

Second piece of code:

   # Author: Susam Pal <http://susam.in/>
   .code16                        # Tell the assembler to use 16 bit instructions
   .section .text              
   .globl _start                  
   _start:                        # Tell linker where entry point into program is
       mov $0xb800, %ax           # 0xb800 is the start address of character buffer                  
       mov %ax, %ds               # Move that address into the data segment
       movb $'B', %ds:0x00        # Write data directly to that buffer at 0
       movb $0x1e, %ds:0x01       # Write text attributes for the text right after
   idle:
       jmp idle


   /* linker.ld */ 
   SECTIONS
   {
       /* Set location counter to 0x7c00 */
       . = 0x7c00;
       .text : { *(.text) }
       .data : { *(.data) }
       .other :
       {
            FILL(0x000000)
            . = 0x1ED;
            BYTE(0x55)
            BYTE(0xAA)
       }
   }

Answer 1

• Your code is well-commented. Other assembly answers on this site mention the importance of good comments: and yours are good.
• An infinite loop at the end of the program is strange; instead I would have expected a ret or retf statement to return to the O/S shell which launched this program; but maybe that's different/excusable for what may in future evolve to become a boot-loader.
• Writing to memory at 0xb8000 may or may not work depending on the current video mode. Here is a thread which discusses whether it's safe to assume 0xb8000 on computer startup (perhaps it is, but there are alternatives)
• You code would be more compact (perhaps less readable) if you initialized entire words, instead of separate instructions for each byte; for example in the first program you could initialize ax and bx; and in the second program you could write 0x1E42 into the first word of video memory.

• Using the 2nd method you'll probably start writing whole strings (not single characters) to the screen; the lods/stos/movs opcodes are useful for that. For example, you could do:

  mov $0x1e, %ah # Write text attributes for the text right after
  loop:
  lodsb          # load byte from ds:si and increment si
  cmp $0x00, %al # test for end-of-string
  jz done
  stosw          # store word (not byte) to es:di and increment di
  jmp loop       # loop back to load-and-then-store next byte of the string
  done:
  

• For this kind of reason it's unconventional of you to use the ds register to point to video memory; I would have expected you to use the es register instead.

• According to the GNU Assembler manual if you write %ds:0x00 then it will emit the ds prefix, which is unnecessary (I think that ds is the default segment for memory access); perhaps (based on the manual, I don't know) the syntax without the segment prefix is something like just 0x00 or perhaps 0x00(,1).

(I'm unable to give you feedback on the linker.ld section).