A specific memory address for an object specified in the source code, as opposed to the object being assigned a location by the linker

An expression which has an address as its value.

The program developed by the user of the IAR toolkit and which will be run as an embedded application on a target processor.

The GNU binary utility for creating, modifying, and extracting from archives, that is, libraries.

See Also Iarchive.

A term used by computer designers to designate the structure of complex information-processing systems. It includes the kinds of instructions and data used, the memory organization and addressing, and the methods by which the system is implemented. The two main architecture types used in processor design are called Harvard and von Neumann.

See Also Harvard architecture, von Neumann architecture.

The set of commands that control how the assembler operates.

A machine-specific set of mnemonics used to specify operations to the target processor and input or output registers or data areas. Assembler language might sometimes be preferred over C/C++ to save memory or to enhance the execution speed of the application.

Parameters you can specify to change the default behavior of the assembler.

The term refers to the fact that each time the function in which the variable is declared is called, a new instance of the variable is created automatically. This can be compared with the behavior of local variables in systems using static overlay, where a local variable only exists in one instance, even if the function is called recursively. Also called local variables.

See Also Register variables.

Information for keeping call frame information up to date so that the IAR C-SPY® Debugger can return from a function correctly.

See Also Call frame information.

Code that is distributed over several banks of memory. Each function must reside in only one bank.

Data that is distributed over several banks of memory. Each data object must fit inside one memory bank.

Has multiple storage locations for the same address.

See Also Memory bank.

Switching between different sets of memory banks. This software technique increases a computer's usable memory by allowing different pieces of memory to occupy the same address space.

Code that selects a memory bank.

A text file containing operating system commands which are executed by the command line interpreter. In Unix, this is called a “shell script” because it is the Unix shell which includes the command line interpreter. Batch files can be used as a simple way to combine existing commands into new commands.

A group of bits considered as a unit.

A continuous piece of code or data. It is either built up of blocks, overlays, and sections or it is empty. A block has a name, and the start and end address of the block can be referred to from the application. It can have attributes such as a maximum size, a specific size, or a minimum alignment. The contents can have a specific order or not.

Information that allows the IAR C-SPY® Debugger to show, without any runtime penalty, the complete stack of function calls—call stack—wherever the program counter is, provided that the code comes from compiled C functions.

See Also Backtrace.

A calling convention describes the way one function in a program calls another function. This includes how register parameters are handled, how the return value is returned, and which registers that will be preserved by the called function. The compiler handles this automatically for all C and C++ functions. All code written in assembler language must conform to the rules in the calling convention to be callable from C or C++, or to be able to call C and C++ functions. The C calling convention and the C++ calling conventions are not necessarily the same.

A small piece of data calculated from a larger block of data for the purpose of detecting errors that might have been introduced during its transmission or storage.

See Also CRC (cyclic redundancy check).

The code model controls how code is generated for an application. Typically, the code model controls behavior such as how functions are called and in which code segment/section functions will be located. All object files of an application must be compiled using the same code model.

A code pointer is a function pointer. As many microcontrollers allow several different methods of calling a function, compilers for embedded systems usually provide the users with the ability to use all these methods.

Do not confuse code pointers with data pointers.

Read-only sections that contain code.

See Also Section.

Parameters you can specify to change the default behavior of the compiler.

A context menu appears when you right-click in the user interface, and provides context-specific menu commands.

A checksum algorithm based on binary polynomials and an initial value. A CRC algorithm is more complex than a simple arithmetic checksum algorithm and has a greater error detecting capability. Most checksum calculation algorithms currently in wide used are based on CRC.

See Also Checksum.

Parameters you can specify to change the default behavior of the IAR C-SPY Debugger.

Code that sets up the system before the application starts executing.

A preprocessor is either a stand-alone application or an integrated part of a compiler, that performs preprocessing of the input stream before the actual compilation occurs. A C-style preprocessor follows the rules set up in Standard C and implements commands like #define, #if, and #include, which are used to handle textual macro substitution, conditional compilation, and inclusion of other files.

The data model specifies the default memory type. This means that the data model typically controls one or more of the following: The method used and the code generated to access static and global variables, dynamically allocated data, and the runtime stack. It also controls the default pointer type and in which data sections static and global variables will be located. A project can only use one data model at a time, and the same model must be used by all user modules and all library modules in the project.

Many cores have different addressing modes to access different memory types or address spaces. Compilers for embedded systems usually have a set of different data pointer types so they can access the available memory efficiently.

How different data types are laid out in memory and what value ranges they represent.

A specification to the compiler that an object, a variable or function, exists. The object itself must be defined in exactly one translation unit (source file). An object must either be declared or defined before it is used. Normally an object that is used in many files is defined in one source file. A declaration is normally placed in a header file that is included by the files that use the object. For example:

/* Variable "a" exists somewhere. Function
 "b" takes two int parameters and returns an
 int. */

extern int a; 
int b(int, int);

The variable or function itself. Only one definition can exist for each variable or function in an application.

See Also Tentative definition.

For example:

int a;
int b(int x, int y)
{
   return x + y;
}

To restore a mangled name to the more common C/C++ name.

See Also Mangling.

A file used by C-SPY that contains various device-specific information such as I/O register (SFR) definitions, interrupt vectors, and control register definitions.

Software that provides a high-level programming interface to a particular peripheral device.

A device that is similar to a microprocessor, except that the internal CPU is optimized for use in applications involving discrete-time signal processing. In addition to standard microprocessor instructions, digital signal processors usually support a set of complex instructions to perform common signal-processing computations quickly.

A C-SPY window that shows the memory contents disassembled as machine instructions, interspersed with the corresponding C source code (if available).

An industry-standard debugging format which supports source level debugging. This is the format used by the IAR ILINK Linker for representing debug information in an object.

Variables in a program written in C are initialized during the initial phase of execution, before the main function is called. These variables are always initialized with a static value, which is determined either at compile time or at link time. This is called static initialization. In C++, variables might require initialization to be performed by executing code, for example, running the constructor of global objects, or performing dynamic memory allocation.

There are two main strategies for storing variables: statically at link time, or dynamically at runtime. Dynamic memory allocation is often performed from the heap and it is the size of the heap that determines how much memory that can be used for dynamic objects and variables. The advantage of dynamic memory allocation is that several variables or objects that are not active at the same time can be stored in the same memory, thus reducing the memory requirements of an application.

See Also Heap memory.

An object that is allocated, created, destroyed, and released at runtime. Dynamic objects are almost always stored in memory that is dynamically allocated.

See Also Static object.

Electrically Erasable, Programmable Read-Only Memory. A type of ROM that can be erased electronically, and then be re-programmed.

Executable and Linking Format, an industry-standard object file format. This is the format used by the IAR ILINK Linker. The debug information is formatted using DWARF.

A subset of the C++ programming language, which is intended for embedded systems programming. The fact that performance and portability are particularly important in embedded systems development was considered when defining the language.

A combination of hardware and software, designed for a specific purpose. Embedded systems are often part of a larger system or product.

An emulator is a hardware device that performs emulation of one or more derivatives of a processor family. An emulator can often be used instead of the actual core and connects directly to the printed circuit board—where the core would have been connected—via a connecting device. An emulator always behaves exactly as the processor it emulates, and is used when debugging requires all systems actuators, or when debugging device drivers.

A specific ELF format that is loadable by the OSE operating system.

See Also ELF.

A type which includes in its definition an exhaustive list of possible values for variables of that type. Common examples include Boolean, which takes values from the list [true, false], and day-of-week which takes values [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]. Enumerated types are a feature of typed languages, including C and Ada. Characters, (fixed-size) integers, and even floating-point types might be (but are not usually) considered to be (large) enumerated types.

Erasable, Programmable Read-Only Memory. A type of ROM that can be erased by exposing it to ultraviolet light, and then be re-programmed.

An exception is an interrupt initiated by the processor hardware, or hardware that is tightly coupled with the processor, for instance, a memory management unit (MMU). The exception signals a violation of the rules of the architecture (access to protected memory), or an extreme error condition (division by zero).Do not confuse this use of the word exception with the term exception used in the C++ language (but not in Embedded C++).

Contains the executable image; the result of linking several relocatable object files and libraries. The file format used for an object file is ELF with embedded DWARF for debug information.

Non-standard keywords in C and C++. These usually control the definition and declaration of objects (that is, data and functions).

See Also Keywords.

How to fill up bytes—with a specific fill pattern—that exists between the sections in an executable image. These bytes exist because of the alignment demands on the sections.

Used to specify the format of strings sent by library functions such as printf. In the following example, the function call contains one format string with one format specifier, %c, that prints the value of a as a single ASCII character:

printf("a = %c", a);

Parameters you can specify to change the default behavior of all tools that are included in the IDE.

Pointers that have the ability to point to all different memory types in, for example, a core based on the Harvard architecture.

A processing engine with its own user register state and program counter, executing within a common user address space. Usually, when one thread is waiting for memory, other threads can continue. Hardware threads (harts) can make efficient use of the large register sets and can be a way to handle interrupts—no registers have to be saved or restored, instead another hardware thread can be executed. The only required hardware thread is thread zero.

A core based on the Harvard architecture has separate data and instruction buses. This allows execution to occur in parallel. As an instruction is being fetched, the current instruction is executing on the data bus. Once the current instruction is complete, the next instruction is ready to go. This theoretically allows for much faster execution than a von Neumann architecture, but adds some silicon complexity.

See Also von Neumann architecture.

The heap is a pool of memory in a system that is reserved for dynamic memory allocation. An application can request parts of the heap for its own use; once memory is allocated from the heap it remains valid until it is explicitly released back to the heap by the application. This type of memory is useful when the number of objects is not known until the application executes.

Note that this type of memory is risky to use in systems with a limited amount of memory or systems that are expected to run for a very long time.

Total size of memory that can be dynamically allocated.

The computer that communicates with the target processor. The term is used to distinguish the computer on which the debugger is running from the core the embedded application you develop runs on.

The IAR utility for creating archives, that is, libraries. Iarchive is delivered with IAR Embedded Workbench.

A programming environment with all necessary tools integrated into one single application.

The IAR utility for creating a text representation of the contents of ELF relocatable or executable image.

The IAR utility for performing various transformations on an ELF executable image, such as fill, checksum, and format conversion.

The IAR ILINK Linker which produces absolute output in the ELF/DWARF format.

The definition of available physical memories and the placement of sections—pieces of code and data—into those memories. ILINK requires a configuration to build an executable image.

A text file which is included into a source file. This is often done by the preprocessor.

Defines how to initialize RAM sections with their initializers. Normally, only non-constant non-noinit variables are initialized but, for example, pieces of code can be initialized as well.

Read-write sections that should be initialized with specific values at startup.

See Also Section.

Assembler language code that is inserted directly between C statements.

An optimization that replaces function calls with the body of the called function. This optimization increases the execution speed and can even reduce the size of the generated code.

A word or acronym used in assembler language to represent a machine instruction. Different processors have different instruction sets and therefore use a different set of mnemonics to represent them, such as, ADD, BR (branch), BLT (branch if less than), MOVE, LDR (load register).

On-chip circuitry which C-SPY uses to make it possible for the application running on the target system to send text to the stdout and stderr streams by way of trace output, rather than by temporarily stopping at a breakpoint.

In embedded systems, the use of interrupts is a method of detecting external events immediately, for example a timer overflow or the pressing of a button.Interrupts are asynchronous events that suspend normal processing and temporarily divert the flow of control through an “interrupt handler” routine. Interrupts can be caused by both hardware (I/O, timer, machine check) and software (supervisor, system call or trap instruction).

See Also Trap.

A small piece of code that will be executed, or a pointer that points to code that will be executed when an interrupt occurs.

A table containing interrupt vectors, indexed by interrupt type. This table contains the processor's mapping between interrupts and interrupt service routines and must be initialized by the programmer.

An adjective describing native compiler objects, properties, events, and methods.

1. Function calls that are directly expanded into specific sequences of machine code. 2. Functions called by the compiler for internal purposes (that is, floating-point arithmetic etc.).

The IAR utility for performing low-level manipulation of ELF object files.

Key shortcuts for menu commands used in the IDE.

A fixed set of symbols built into the syntax of a programming language. All keywords used in a language are reserved—they cannot be used as identifiers (in other words, user-defined objects such as variables or procedures).

See Also Extended keywords.

Target-specific extensions to the C language.

A file that contains a configuration of the runtime library. The file contains information about what functionality is part of the runtime environment. The file is used for tailoring a build of a runtime library.

See Also Runtime library.

A file that contains a configuration used by the IAR ILINK Linker when building an executable image.

See Also ILINK configuration.

A value that can be found on the left side of an assignment and that can, therefore, be changed. This includes plain variables and dereferenced pointers. Expressions like (x + 10) cannot be assigned a new value and are therefore not L-values.

A special instruction, or on-chip device, that performs a multiplication together with an addition. This is very useful when performing signal processing where many filters and transforms have the form:

The accumulator of the MAC usually has a higher precision (more bits) than normal registers.

See Also Digital signal processor (DSP).

The C-SPY macro language is like a simple dialect of C, but is less strict with types.

A mailbox in an RTOS is a point of communication between two or more tasks. One task can send messages to another task by placing the message in the mailbox of the other task. Mailboxes are also known as message queues or message ports.

Mangling is a technique used for mapping a complex C/C++ name into a simple name. Both mangled and demangled names can be produced for C/C++ symbols in ILINK messages.

A region of the memory.

The smallest unit of continuous memory in banked memory. One memory bank at a time is visible in a core’s physical address space.

A physical memory. The number of units it contains and how many bits a unit consists of, are defined in the linker configuration file. The memory is always addressable from 0x0 to size -1.

A map of the different memory areas available to the core.

Specifies the memory hierarchy and how much memory the system can handle. Your application must use only one memory model at a time, and the same model must be used by all user modules and all library modules.

A microprocessor on a single integrated circuit intended to operate as an embedded system. In addition to a CPU, a microcontroller typically includes small amounts of RAM, PROM, timers, and I/O ports.

A CPU contained on one (or a few) integrated circuits. A single-chip microprocessor can include other components such as memory, memory management, caches, floating-point unit, I/O ports and timers. Such devices are also known as microcontrollers.

An object. An object file contains a module and library contains one or more objects. The basic unit of linking. A module contains definitions for symbols (exports) and references to external symbols (imports). When you compile C/C++, each translation unit produces one module.

A technique which means that the compiler compiles several source files as one compilation unit, which enables for interprocedural optimizations such as inlining, cross call, and cross jump on multiple source files in a compilation unit.

A system where an interrupt can be interrupted by another interrupt is said to have nested interrupts.

Read-write sections that should not be initialized at startup.

See Also Section.

Has a single storage location for each memory address in a core’s physical address space.

Memory that can contain any value at reset, or in the case of a soft reset, can remember the value it had before the reset.

Memory devices such as battery-backed RAM, ROM, magnetic tape and magnetic disks that can retain data when electric power is shut off.

See Also Volatile storage.

No operation. This is an instruction that does not do anything, but is used to create a delay. In pipelined architectures, the NOP instruction can be used for synchronizing the pipeline.

See Also Pipeline.

A GNU binary utility for converting an absolute object file in ELF format into an absolute object file, for example the format Motorola-std or Intel-std.

See Also Ielftool.

An object file or a library member.

The result of compiling or assembling a source file. The file format used for an object file is ELF with embedded DWARF for debug information.

A symbol used as a function, with infix syntax if it has two arguments (+, for example) or prefix syntax if it has only one (for instance, bitwise negation, ~). Many languages use operators for built-in functions such as arithmetic and logic.

Each operator has a precedence number assigned to it that determines the order in which the operator and its operands are evaluated. The highest precedence operators are evaluated first. Use parentheses to group operators and operands to control the order in which the expressions are evaluated.

A set of commands that control the behavior of a tool, for example the compiler or linker. The options can be specified on the command line or via the IDE.

Like a block, but it contains several overlaid entities, each built up of blocks, overlays, and sections. The size of an overlay is determined by its largest constituent. Code in overlaid memory areas cannot be debugged in the C-SPY Debugger.

A hardware component other than the processor, for example memory or an I/O device.

A structure that consists of a sequence of stages through which a computation flows. New operations can be initiated at the start of the pipeline even though other operations are already in progress through the pipeline.

How to place blocks, overlays, and sections into a region. It determines how pieces of code and data are actually placed in the available physical memory.

An object that contains an address to another object of a specified type.

During compilation of a C/C++ program, the #pragma preprocessing directive causes the compiler to behave in an implementation-defined manner. This can include, for example, producing output on the console, changing the declaration of a subsequent object, changing the optimization level, or enabling/disabling language extensions.

An RTOS task is allowed to run until a higher priority process is activated. The higher priority task might become active as the result of an interrupt. The term preemptive indicates that although a task is allotted to run a given length of time (a timeslice), it might lose the processor at any time. Each time an interrupt occurs, the task scheduler looks for the highest priority task that is active and switches to that task. If the located task is different from the task that was executing before the interrupt, the previous task is suspended at the point of interruption.

See Also Round Robin.

A set of directives that are executed before the parsing of the actual code is started.

The different chip setups that the compiler supports.

A special processor register that is used to address instructions.

See Also Program location counter (PLC).

Used in the IAR Assembler to denote the code address of the current instruction. The PLC is represented by a special symbol (typically $) that can be used in arithmetic expressions. Also known as a location counter (LC).

The user application development project.

General options that apply to an entire project, for example the target processor that the application will run on.

Programmable Read-Only Memory. A type of ROM that can only be programmed once.

A range of consecutive addresses in a memory. A region is built up of ranges.

Refers to sections that contain code or constants.

See Also Section.

An operating system which guarantees the latency between an interrupt being triggered and the interrupt handler starting, and how tasks are scheduled. An RTOS is typically much smaller than a normal desktop operating system.

See Also Real-time system.

A computer system whose processes are time-sensitive.

See Also Real-time operating system (RTOS).

A region built up from region literals, regions, and the common set operations possible in the linker configuration file.

A set of non-overlapping ranges. The ranges can lie in one or more memories. Blocks, overlays, and sections are placed into regions in the linker configuration file.

A literal that defines a set of one or more non-overlapping ranges in a memory.

A small on-chip memory unit, usually just one or a few bytes in size, which is particularly efficient to access and therefore often reserved as a temporary storage area during program execution.

A register constant is a value that is loaded into a dedicated processor register when the system is initialized. The compiler can then generate code that assumes that the constants are present in the dedicated registers.

Register locking means that the compiler can be instructed that some processor registers shall not be used during normal code generation. This is useful in many situations. For example, some parts of a system might be written in assembler language to gain speed. These parts might be given dedicated processor registers. Or the register might be used by an operating system, or by other third-party software.

Typically, register variables are local variables that are placed in registers instead of on the (stack) frame of the function. Register variables are much more efficient than other variables because they do not require memory accesses, so the compiler can use shorter/faster instructions when working with them.

See Also Auto variables.

Refers to sections that have no fixed location in memory before linking.

A reset is a restart from the initial state of a system. A reset can originate from hardware (hard reset), or from software (soft reset). A hard reset can usually not be distinguished from the power-on condition, which a soft reset can be.

A piece of embedded software designed specifically for use as a debugging tool. It resides in the ROM of the evaluation board chip and communicates with a debugger via a serial port or network connection. The ROM-monitor provides a set of primitive commands to view and modify memory locations and registers, create and remove breakpoints, and execute your application. The debugger combines these primitives to fulfill higher-level requests like program download and single-step.

Task scheduling in an operating system, where all tasks have the same priority level and are executed in turn, one after the other.

See Also Pre-emptive multitasking.

A collection of relocatable object files that will be included in the executable image only if referred to from an object file, in other words conditionally linked.

A mechanism that is designed to prevent modules that are not compatible to be linked into an application. A runtime attribute is a pair constituted of a named key and its corresponding value.

ILINK uses the runtime model attributes when automatically choosing a library, to verify that the correct one is used.

A value that can be found on the right side of an assignment. This is just a plain value.

See Also L-value.

Most, if not all, C and C++ implementations use mod–2^N 2-complement-based arithmetics where an overflow wraps the value in the value domain, that is, (127 + 1) = -128. Saturation arithmetics, on the other hand, does not allow wrapping in the value domain, for instance, (127 + 1) = 127, if 127 is the upper limit. Saturation arithmetics is often used in signal processing, where an overflow condition would have been fatal if value wrapping had been allowed.

The part of an RTOS that performs task-switching. It is also responsible for selecting which task that should be allowed to run. Many scheduling algorithms exist, but most of them are either based on static scheduling (performed at compile-time), or on dynamic scheduling (where the actual choice of which task to run next is taken at runtime, depending on the state of the system at the time of the task-switch). Most real-time systems use static scheduling, because it makes it possible to prove that the system will not violate the real-time requirements.

The section of an application where a function or a variable can be referenced by name. The scope of an item can be limited to file, function, or block.

An entity that either contains data or text. Typically, one or more variables, or functions. A section is the smallest linkable unit.

Each section has a name and an attribute. The attribute defines what a section contains, that is, if the section content is read-only, read/write, code, data, etc.

A part of a section, typically a variable or a function.

In the linker configuration file, defining a set of sections by using section selectors. A section belongs to the most restrictive section selector if it can be part of more than one selection. Three different selectors can be used individually or in conjunction to select the set of sections: section attribute (selecting by the section content), section name (selecting by the section name), and object name (selecting from a specific object).

A semaphore is a type of flag that is used for guaranteeing exclusive access to resources. The resource can be a hardware port, a configuration memory, or a set of variables. If several tasks must access the same resource, the parts of the code (the critical sections) that access the resource must be made exclusive for every task. This is done by obtaining the semaphore that protects that resource, thus blocking all other tasks from it. If another task wishes to use the resource, it also must obtain the semaphore. If the semaphore is already in use, the second task must wait until the semaphore is released. After the semaphore is released, the second task is allowed to execute and can obtain the semaphore for its own exclusive access.

The level of seriousness of the diagnostic response from the assembler, compiler, or debugger, when it notices that something is wrong. Typical severity levels are remarks, warnings, errors, and fatal errors. A remark just points to a possible problem, while a fatal error means that the programming tool exits without finishing.

A physical memory that can be addressed in several ways. It is defined in the linker configuration file.

Many cores have special addressing modes for efficient access to internal RAM and memory mapped I/O. Short addressing is therefore provided as an extended feature by many compilers for embedded systems.

See Also Data pointers.

An expression in C or C++ is said to have a side-effect if it changes the state of the system. Examples are assignments to a variable, or using a variable with the post-increment operator. The C and C++ standards state that a variable that is subject to a side-effect should not be used more that once in an expression. As an example, this statement violates that rule:

*d++ = *d;

Signals provide event-based communication between tasks. A task can wait for one or more signals from other tasks. Once a task receives a signal it waits for, execution continues. A task in an RTOS that waits for a signal does not use any processing time, which allows other tasks to execute.

A debugging tool that runs on the host and behaves as similar to the target processor as possible. A simulator is used for debugging the application when the hardware is unavailable, or not needed for proper debugging. A simulator is usually not connected to any physical peripheral devices. A simulated processor is often slower, or even much slower, than the real hardware.

Executing one instruction or one C statement at a time in the debugger.

An incomplete code framework that allows the user to specialize the code.

A register that is used to read and write to the hardware components of the core.

Data structures containing data objects like preserved registers, local variables, and other data objects that must be stored temporary for a particular scope (usually a function). Earlier compilers usually had a fixed size and layout on a stack frame throughout a complete function, while modern compilers might have a dynamic layout and size that can change anywhere and anytime in a function.

The sections that reserve space for the stack(s). Most processors use the same stack for calls and parameters, but some have separate stacks.

The C and C++ library functions as specified by the C and C++ standard, and support routines for the compiler, like floating-point routines.

This kind of memory is allocated once and for all at link-time, and remains valid all through the execution of the application. Variables that are either global or declared static are allocated this way.

An object whose memory is allocated at link-time and is created during system startup (or at first use).

See Also Dynamic object.

Instead of using a dynamic allocation scheme for parameters and auto variables, the linker allocates space for parameters and auto variables at link time. This generates a worst-case scenario of stack usage, but might be preferable for small chips with expensive stack access or no stack access at all.

A collecting names for structs and unions. A struct is a collection of data object placed sequentially in memory (possibly with pad bytes between them). A union is a collection of data sharing the same memory location.

A location that uses a symbolic name because the exact address is unknown.

A task is an execution thread in a system. Systems that contain many tasks that execute in parallel are called multitasking systems. Because a processor only executes one instruction stream at the time, most systems implement some sort of task-switch mechanism (often called context switch) so that all tasks get their share of processing time. The process of determining which task that should be allowed to run next is called scheduling. Two common scheduling methods are pre-emptive multitasking and round robin.

See Also Pre-emptive multitasking, Round Robin.

A variable that can be defined in multiple files, provided that the definition is identical and that it is an absolute variable.

A simulated terminal window in C-SPY.

A peripheral that counts independent of the program execution.

The (longest) time an RTOS allows a task to run without running the task-scheduling algorithm. A task might be allowed to execute during several consecutive timeslices before being switched out. A task might also not be allowed to use its entire time slice, for example if, in a preemptive system, a higher priority task is activated by an interrupt.

A source file together with all the header files and source files included via the preprocessor directive #include, except for the lines skipped by conditional preprocessor directives such as #if and #ifdef.

A trap is an interrupt initiated by inserting a special instruction into the instruction stream. Many systems use traps to call operating system functions. Another name for trap is software interrupt.

In Standard C/C++, const or volatile. IAR compilers usually add target-specific type qualifiers for memory and other type attributes.

File format produced by some of the IAR programming tools, if your product package includes the XLINK linker.

A constant number that can be built up out of expressions that has a syntax similar to C expressions.

A small piece of code that is inserted as a springboard between caller and callee when the call instruction does not reach its destination.

An address that must be translated by the compiler, linker or the runtime system into a physical memory address before it is used. The virtual address is the address seen by the application, which can be different from the address seen by other parts of the system.

An IAR Embedded Workbench Editor feature which allows you to place the insertion point outside of the area where there are actual characters.

Data stored in a volatile storage device is not retained when the power to the device is turned off. To preserve data during a power-down cycle, you should store it in non-volatile storage. This should not be confused with the C keyword volatile.

See Also Non-volatile storage.

A computer architecture where both instructions and data are transferred over a common data channel.

See Also Harvard architecture.

Watchpoints keep track of the values of C variables or expressions in the C-SPY Watch window as the application is being executed.

An IAR tool that creates archives (libraries) in the UBROF format.

An IAR tool that creates archives (libraries) in the UBROF format, listing object code, converting and absolute object file into an absolute object file in another format.

The IAR XLINK Linker which uses the UBROF output format.

Refers to sections that should be initialized to zero at startup.

See Also Section.

A loop in which the loop condition, including branching back to the beginning of the loop, does not take any time at all. This is usually implemented as a special hardware feature of the processor and is not available in all architectures.

Different processors have widely differing memory architectures. Zone is the term C-SPY uses for a named memory area. For example, on processors with separately addressable code and data memory there would be at least two zones. A processor with an intricate banked memory scheme might have several zones.