For more information on gas, see Using as in GNUPro Utilities.

 

 

binutils, the GNU binary utilities

•  objcopy

A few ROM monitors, such as a.out, load executable binary images, and, consequently, most load an S-record. An S-record is a printable ASCII representation of an executable binary image.

S-records are suitable both for building ROM images for standalone boards and for downloading images to embedded systems. Use the following example's input for this process.
 
objcopy -O srec infile outfile

infile in the previous example's input is the executable binary filename, and outfile is the filename for the S-record.

Most PROM burners also read S-records or some similar format. Use the following example's input to get a list of supported object file types for your architecture.
 
objdump -i

For more information on S-records, see the discussions for FORMAT output-format in the documentation for MRI compatible script files and the discussion for BFD in Using ld in GNUPro Utilities. For more discussion of making an executable binary image, see objcopy in Using binutils in GNUPro Utilities.

•  objdump

objdump displays information about one or more object files. The options control what particular information to display. This information is mostly useful to programmers who are working on the compilation tools, as opposed to programmers who just want their program to compile and work.

When specifying archives, objdump shows information on each of the member object files. objfile... designates the object files to be examined.
A few of the more useful options for commands are: -d, -disassembleand --prefix-addresses.
 
 
-d
--disassemble
Displays the assembler mnemonics for the machine instructions from objfile . This option only disassembles those sections that are expected to contain instructions.
--prefix-addresses
For disassembling, prints the complete address on each line, starting each output line with the address it's disassembling. This is the older disassembly format. Otherwise, you only get raw opcodes.

gdb, the debugging tool

Useful debugging routines

libgloss, newlib and libstd++, the GNU libraries

•  libgloss

libgloss , the library for GNU Low-level OS Support , contains the startup code, the I/O support for gcc and newlib (the C library), and the target board support packages that you need to port the GNU tools to an embedded execution target.
The C library used throughout this manual is newlib , however libgloss could easily be made to support other C libraries. Because libgloss resides in its own tree, it's able to run standalone, allowing it to support GDB's remote debugging and to be included in other GNU tools.
Several functions that are essential to gcc reside in libgloss. These include the following functions.
 
• crt0, the main startup script (see crt0, the main startup file)
• ld, the linker script (see The linker script)
• I/O support code (see I/O support code)

•   libstd++

The C++ library in development by Cygnus

crt0, the main startup file

 
•  crt0 initializes everything in your program that needs it.
 
This initialization section varies. If you are developing an application that gets downloaded to a ROM monitor, there is usually no need for special initialization because the ROM monitor handles it for you. If you plan to burn your code in a ROM, the crt0 file typically does all of the hardware initialization required to run an application. This can include things like initializing serial ports and running a memory check; however, results vary depending on your hardware.

1. Set up concatenation macros.

#define CONCAT2(a, b) a ## b

Later, you'll use these macros.
 
 
2. Set up label macros, using the following example's input.

#define __USER_LABEL_PREFIX__ _

#endif

#define SYM(x) CONCAT1 (__USER_LABEL_PREFIX__, x)

 
These macros make the code portable between coff and a.out. coff always has an __ (underline) prepended to the front of its global symbol names. a.out has none.
 
 
3. Set up register names (with the right prefix), using the following example's input.

#define __REGISTER_PREFIX__

#endif

/* Use the right prefix for registers. */

#define REG(x) CONCAT1 (__REGISTER_PREFIX__, x)

#define d0 REG (d0)

#define d1 REG (d1)

#define d2 REG (d2)

#define d3 REG (d3)

#define d4 REG (d4)

#define d5 REG (d5)

#define d6 REG (d6)

#define d7 REG (d7)

#define a0 REG (a0)

#define a1 REG (a1)

#define a2 REG (a2)

#define a3 REG (a3)

#define a4 REG (a4)

#define a5 REG (a5)

#define a6 REG (a6)

#define fp REG (fp)

#define sp REG (sp)

Register names are for portability between assemblers. Some register names have a % or $ prepended to them.
 
 
4. Set up space for the stack and grab a chunk of memory.

comm SYM (stack), stack_size

 
This can also be done in the linker script, although it typically gets done at this point.
 
 
5. Define an empty space for the environment, using the following example's input.

     .align 2

SYM (environ):

     .long 0

This is bogus on almost any ROM monitor, although it's best generally set up as a valid address, then passing the address to main() . This way, if an application checks for an empty environment, it finds one.
6. Set up a few global symbols that get used elsewhere.

.text

.global SYM (stack)

.global SYM (main)

.global SYM (exit)

.global __bss_start

This really should be __bss_start, not SYM (__bss_start.
 
__bss_start needs to be declared this way because its value is set in the linker script.
 
 
7. Set up the global symbol, start , for the linker to use as the default address for the .text section. This helps your program run.

link a6, #-8

moveal #SYM (stack) + stack_size, sp

 
• crt0 zeroes the .bss section
Make sure the .bss section is cleared for uninitialized data, using the following example's input. All of the addresses in the .bss section need to be initialized to zero so programs that forget to check new variables' default values will get predictable results.

moveal #SYM (end), a1

1:

movel #0, (a0)

leal 4(a0), a0

cmpal a0, a1

bne 1b

Applications can get wild side effects from the .bss section being left uncleared, and it can cause particular problems with some implementations of malloc() .
 
 
• crt0 calls main()

If your ROM monitor supports it, set up argc and argv for command line arguments and an environment pointer before the call to main(), using the following example's input.

         pea 0

         pea SYM (environ)

         pea sp@(4)

         pea 0

jsr SYM (main)

movel d0, sp@-4

 
• crt0 calls (exit)

After main() has run, the crt0 file cleans things up and returns control of the hardware from the application. On some hardware there is nothing to return to--especially if your program is in ROM--and if that's the case, you need to do a hardware reset or branch back to the original start address.

SYM (exit):

trap #0

Both rom68k and bug can handle a user-caused exception of 0 with no side effects. Although the bug monitor has a user-caused trap that returns control to the ROM monitor, the bug monitor is more portable.
 

The linker script

1. Use the STARTUP command, which loads the file so that it executes first.

If you use only ld to link, you control whether or not to link in crt0.o on the command line.
If you have multiple crt0 files, you can leave STARTUP out, and link in crt0.o in the makefile or use different linker scripts. Sometimes this option is used to initialize floating point values or to add device support.
 
 
2. Using GROUP, load the specified file.

3. SEARCH_DIR specifies the path in which to look for files.

4. Using _DYNAMIC, specify whether or not there are shared dynamic libraries. In the following example's case, there are no shared libraries.

5. Set _stack, the variable for specifying RAM for the ROM monitor.
 
 
6. Specify a name for a section that can be referred to later in the script. In the following example's case, it's only a pointer to the beginning of free RAM space with an upper limit at 2M. If the output file exceeds the upper limit, MEMORY produces an error message. First, in this case, we'll set up the memory map of the board's stack for high memory for both the rom68k and mon68k monitors.

{

    ram     :     ORIGIN = 0x10000, LENGTH = 2M

}

 

{

   .text :

   {

      CREATE_OBJECT_SYMBOLS

      *(.text)

      etext = .;

      __CTOR_LIST__ = .;

      LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)

      *(.ctors)

      LONG(0)

      __CTOR_END__ = .;

      __DTOR_LIST__ = .;

      LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)

      *(.dtors)

      LONG(0)

      __DTOR_END__ = .;

      *(.lit)

      *(.shdata) }

   > ram

   .shbss SIZEOF(.text) + ADDR(.text) : {

      *(.shbss)

   }

 
In a coff file, all the actual instructions reside in .text for also setting up the constructor and destructor tables for g++. Notice that the section description redirects itself to the RAM variable that was set up in Step 5 of the earlier process for the crt0 file, variable for specifying RAM for the ROM monitor.
 
Set up the .data section.
 

   .data : {

   *(.data)

   CONSTRUCTORS

   _edata = .;

} > ram

 

   .bss SIZEOF(.data) + ADDR(.data) :

   {

   __bss_start = ALIGN(0x8);

   *(.bss)

   *(COMMON)

      end = ALIGN(0x8);

      _end = ALIGN(0x8);

      __end = ALIGN(0x8);

   }

   .mstack : { } > ram

   .rstack : { } > ram

   .stab . (NOLOAD) :

   {

      [ .stab ]

   }

   .stabstr . (NOLOAD) :

   {

      [ .stabstr ]

   }

}

 

I/O support code

 

•  -inbyte
Returns a single byte from the console.

 

•  -outbyte
Used for low-level debugging, takes an argument for print() and prints a byte out to the console (typically used for ASCII text).

Memory support

•  sbrk()
The functions, malloc(), calloc(), and realloc() all call sbrk() at their lowest levels. sbrk() returns a pointer to the last memory address your application used before more memory was allocated.
•  caddr_t
Defined elsewhere as char *.
•  RAMSIZE
A compile-time option that moves a pointer to heap memory and checks for the upper limit.

Miscellaneous support routines

•  isatty()

Checks for a terminal device.
•  kill()
Simply exits.

•  getpd()
Can safely return any value greater than 1, although the value doesn't effect anything in newlib.

© 2005 Red Hat, Inc. All rights reserved. About Red Hat  :  Legal statement  :  Privacy statement  :  Contact