Now that the project has no errors and builds correctly, we can turn our attention to uncovering exactly how our application fits in memory and how to navigate around it.

## Using Project Explorer features

The Project Explorer is the central focus for arranging your source code into projects, and it's a good place to show ancillary information gathered when CrossStudio builds your applications. This section will cover the features that the Project Explorer offers to give you an overview of your project.

###### Project code and data sizes

Developers are always interested in how much memory their applications take up, and with small embedded microcontrollers this is especially true. The Project Explorer can display the code and data sizes for each project and individual source file that is successfully compiled. To do this, click the Options dropdown on the Project Explorer tool bar and make sure that Show Code/Data Size is checked. Once checked, the Project Explorer displays two additional columns, Code and Data.

The Code column displays the total code space required for the project and the Data column displays the total data space required. The code and data sizes for each C and assembly source file are estimates, but good estimates nontheless. Because the linker removes any unreferenced code and data and performs a number of optimizations, the sizes for the linked project may not be the sum of the sizes of each individual file. The code and data sizes for the project, however, are accurate. As before, your numbers may not match these exactly.

###### Dependencies

The Project Explorer is very versatile: not only can you display the code and data sizes for each element of a project and the project as a whole, you can also configure the Project Explorer to show the dependencies for a file. As part of the compilation process, CrossStudio finds and records the relationships between files—that is, it finds which files are dependent upon other files. CrossStudio uses these relationships when it comes to build the project again so that it does the minimum amount of work to bring the project up to date.

To show the dependencies for a project, click the Options button on the Project Explorer tool bar and ensure that Show Dependencies is checked in the menu. Once checked, dependent files are shown as sub-nodes of the file which depends upon them.

In this case, `main.c` is dependent upon `cross_studio_io.h` because it it includes it with a #include directive. You can open cross_studio_io.h in an editor by double clicking it, so having dependencies turned on is an effective way of navigating to and summarising the files that a source file includes.

###### Output files

Another useful piece of information is knowing the files output files when compiling and linking the application. Needless to say, CrossStudio can display this information too. To turn on output file display, click the Options button on the Project Explorer tool bar and ensure that Show Output Files is checked in the menu. Once checked, output files are shown in an Output Files folder underneath the node that generates them.

In the above figure, we can see that the object files `fact.o`, `main.o`, and `crt0.o` are object files produced by compiling their corresponding source files; the map file `Tutorial.map` and the linked executable `Tutorial.elf` are produced by the linker. As a convenience, double clicking an object file or a linked executable file in the Project Explorer will open an editor showing the disassembled contents of the file.

###### Disassembling a project or file

You can disassemble a project either by double clicking the corresponding file as described above, or you can use the Disassemble tool to do it.

To disassemble a project or file, do one of the following:

- Click the appropriate project or file in the Project Explorer view.
- On the Project Explorer tool bar, click the Disassemble tool button — .

—or—

- Right click the appropriate project or file in the Project Explorer view.
- From the popup menu, click the Disassemble.

CrossStudio opens a new read-only editor and places a disassembled listing into it. If you change your project and rebuild it, causing a change in the object or executable file, the disassembly updates to keep the display up-to-date with the file on disk.

## Using Symbol Browser features

Whilst a map file produced by the linker is traditionally the best way (and in some cases, the only way) to see how your application is laid out in memory, CrossStudio provides a much better way to examine and navigate your application: the Symbol Browser. You can use the Symbol Browser to navigate your application, see which data objects and functions have been linked into your application, what their sizes are, which section they are in, and where they are placed in memory.

###### Displaying the Symbol Browser

To display the Symbol Browser window if it is hidden, do one of the following:

- From the View menu, click Symbol Browser.

—or—

- Type Ctrl+Alt+Y.

—or—

- Right click the tool bar area to display the View menu.
- From the popup menu, click Symbol Browser.

###### Drilling down into the application

The Tutorial project shows this in the Symbol Browser:

From this you can see:

- The .vectors section containing the ARM exception vectors is placed in memory between address 0x00000000 and 0x0000003B.
- The .fast section containing performance critical code and data is empty.
- The .init section containing the system startup code is placed in memory between address 0x0000003C and 0x00000213.
- The .text section containing the program code is placed in memory between address 0x00000214 and 0x0000065F.
- The .text_load section which is the section that the .text section image is loaded from is at the same address as .text. If the .text and .text_load section start addresses differ then the startup code will copy the contents of the .text_load section to the .text section before the program enters main. This feature allows the .text section to run from RAM in ROM based applications.
- The .bss section containing zeroed data is empty.
- The .ctors containing the global constructor table is empty.
- The .data section containing initialized data is empty.
- The .data_load section which is the section that the .data section image is loaded from is at the same address as .data. If the .data and .data_load section start addresses differ then the startup code will copy the contents of the .data_load section to the .data section before the program enters main. This feature is required for ROM based applications so that data can be initialized in RAM on startup.
- The .dtors section containing the global destructor table is empty.
- The .heap section is 1024 bytes in length and located at 0x00000678. Note that the size of the heap can be adjusted by modifying the size of the .heap section in the section placement file (sram_placement.xml in this example).
- The .stack section which contains the User/System mode stack is 1024 bytes in length and located at 0x00000A78. Note that the sizes of the stacks can be adjusted by modifying the size of the .stack sections in the section placement file (sram_placement.xml in this example).
- The .stack_irq section which contains the IRQ mode stack is 256 bytes in length and located at 0x00000E78.
- The .stack_fiq section which contains the FIQ mode stack is 256 bytes in length and located at 0x00000F78.
- The .stack_abt section which contains the Abort mode stack is 0 bytes in length.
- The .stack_svc section which contains the Supervisor mode stack is 0 bytes in length.
- The .stack_und section which contains the Undefined mode stack is 0 bytes in length.

To drill down, open the .text node by double clicking it: CrossStudio displays the individual functions that have been placed in memory and their sizes:

Here, we can see that main is 104 bytes in size and is placed in memory between addresses 0x00000270 and 0x000002D7 inclusive. Just as in the Project Explorer, you can double click a function and CrossStudio moves the cursor to the line containing the definition of that function, so you can easily navigate around your application using the Symbol Browser.

###### Printing Symbol Browser contents

You can print the contents of the Symbol Browser by focusing the Symbol Browser window and selecting Print from the File menu, or Print Preview if you want to see what it will look like before printing. CrossStudio prints only the columns that you have selected for display, and prints items in the same order they are displayed in the Symbol Browser, so you can choose which columns to print and how to print symbols by configuring the Symbol Browser display before you print.

We have touched on only some of the features that the Symbol Browser offers; to find out more, refer to Symbol browser where it is described in detail.