|
|
For more etymology and history of the technical jargon in open source and embedded communities, see the following HTML documentation:
This is the location for terms for all systems and nearly every technology.
This has become a very popular online dictionary.
This gives definitions in many languages on computers.
This is a site for all ages with some basics.
This provides one of the most popular online dictionaries for UNIX systems.
This is the main online dictionary for Microsoft Windows systems.
Application Binary Interface, which defines how programs should interface with an operating system. It specifies interactions such as executable format, calling conventions, and chip-specific requirements.
A register being used for arithmetic or logic (as opposed to addressing or a loop index), especially one being used to accumulate a sum or count of many items.
A number identifying a location in the computer's memory that informs the computer where to find information such as a file name or data for processing. See also bus.
Application Programming Interface, which defines how programmers write source code that makes use of a library's or an operating system's facilities by accessing the behavior and state of classes and objects. EL/IX is the API for GNUPro Toolkit, for instance. See also classes and objects.
A term for a family of processors, generally used in reference to features common to all members.
Annotated Reference Manual for C++, often used to describe a name-mangling style; see name-mangling.
A collection of data items, all of the same type, in which integers designate each item's position.
American Standard Code for Information Interchange, the predominant character set encoding of present-day computers. The modern version uses seven bits for each character, whereas most earlier codes (including an early version of ASCII) had fewer assignments.
An assembly shell. See shell.
1) Software performing either the final stage in a process, or a task not apparent to the user, such as with a compiler with its backend generating machine language and performing optimizations specific to a machine's architecture.
2) A set of functions that appear in a particular target vector.
3) The implementation within BFD of a specific object file format.
Used very generally as a sample name for absolutely anything, especially programs and files. See foo.
A basic command shell (Bourne Again Shell), typically for UNIX or Linux operating systems, based on the Bourne shell. See shell.
Background Debugging Mode, referring to Motorola chips controlled through a special set of pins.
Refers to a processor or toolchain that supports both big-endian and little-endian code. See big-endian and little-endian.
A byte-ordering scheme in which the most significant bytes are at lower addresses (big-end-first), such as the Motorola 68000 family of microprocessors and most of the various RISC designs.
A multiple-precision computer representation for very large integers. Most computer languages provide a kind of integer-based data, but such computer integers are usually very limited in size; to work with larger numbers, use floating-point numbers, which are usually accurate to only six or seven decimal places. Computer languages that provide bignums can perform exact calculations on very large numbers, such as 1000! (the factorial of 1000, which is 1000 x 999 x 998 x ... x 2 x 1).
Base-two number system, of which the only digits are 0 and 1. Used as a signal for processing as either off (0) or on (1); from right to left, the digits have a binary value of 1, 2, 4, 8, 16, and so on in multiples of 2, exponentially (the binary number of 101, for instance, is equivalent to the decimal number, 5, and the binary number of 1011 is equivalent to the decimal number, 13). See also unary and ternary. Compare floating-point notation.
Basic Input Output System, which loads and executes operation functionality usually stored on the computer's hard disk (in ROM mode); also may be accessible from CD-ROM or floppy disk at install time.
The GNU parser generator, a workalike for yacc.
A computational quantity that can take on one of two values, such as true and false or 0 and 1. A bit is said to be set if its value is true or 1, and reset or clear if its value is false or 0. One speaks of setting and clearing bits. To toggle or invert a bit is to change it, either from 0 to 1 or from 1 to 0.
Reference to the measure of the time elapsed for a Linux system to perform processes; see also MIPS.
The action for a machine to run through its opening processes, for instance, for a compiler's initialization. Known by having to put on boots by pulling on the sidestraps before going out in the world. See also network boot.
Boot protocol, which lets a network user be automatically configured (for instance, to receive an IP address) and have an operating system booted or initiated without user involvement. A BOOTP server, managed by a network administrator, automatically assigns the IP address from a pool of addresses for a certain duration of time.
BOOTP is the basis for a more advanced network manager protocol, DHCP. See DHCP.
What makes a program stop whenever a certain point is reached in a debugging process. See also catchpoint, watchpoint, and tracepoint.
Berkeley SSoftware Distribution, a family of UNIX software tools from U.C. Berkeley, originally licensed from AT&T, and later upgraded to all-free code. Formed the basis for SunOS, incorporating paged virtual memory, TCP/IP networking enhancements, among other features. See also FreeBSD and NetBSD.
Board Support Package, typically referring to the low-level code or scripts that build programs running on a particular chip on a particular circuit board. Provides memory sizing, testing, interrupt/DMA control, and other features. Also refers to the ROM that boots an RTOS onto a specific board. Exact meaning varies.
What happens when you try to stuff more data into a buffer than the buffer has been constructed to hold.
A holding area in a program's memory (like an Emacs buffer holding text waiting to be edited.
As a verb, the process of configuring, compiling, and linking a set of tools, source files, libraries, executable files to produce binary resources. As a noun, the results of the build process. The build process has four steps: editing code, compiling the code into object files, linking the object files to make an executable, and debugging the executable; the build process repeats until the executable is a working program. See also Makefile and target .
1) Collection of wires through which data transmits; buses consist of two parts: an address bus and a data bus, with the data bus transferring actual data and the address bus transferring information about where the data should go.
2) In networking, a bus is a central cable that connects all devices on a local-area network (see
LAN).
Recently accessed data in storage on disk on a computer or network, using a process for filing the boot process, as well as archives, kernel information and other data. See also disk caching.
A compilation of a program with a compiler for some other host and target pair; for example, to build a Motorola 68000 cross compiler that runs on a 486 PC using a Sun SPARC station.
The standard state or manner or usage in technical terminology. The term is derived from computation theory and mathematical logic. For instance, two formulas such as 1 + x and x + 1 are said to be equivalent because they mean the same thing, but the second one is in canonical form because it is written in the usual way, with the highest power of x first. Also refers to the naming of host operating system combinations with target boards, such as the i686-elix-linux-gnu canonical name.
A special breakpoint when debugging that stops your program when a certain kind of event occurs, such as the throwing of a C++ exception or the loading of a library.
A framework for generating CPU-related tools such as assemblers, disassemblers, and simulators.
Complex Instruction Set Computer, a class of machines typically having variable-length instructions with a variety of addressing modes.
In object-oriented programming, objects that define instance, variables, and methods, whose combined action is to specify the interfaces that a class implements and the immediate superclass or hierarchy of the class and all its properties. See also objects.
The Java binary file format for the Java Virtual Machine (JVM) for the .class file that, after compiling, contains bytecode and symbols (like an object file). See also bytecode and JVM.
Common Object File Format, a format formerly common for UNIX, and still used by some embedded systems.
A tool that translates high-level source code in a language such as C or Pascal into machine-executable programs. The term may also refer specifically to the tool that translates from source to machine code.
A shell script command that sets up an environment in which programs will compile correctly for a machine and operating system, installing the programs in proper places.
In object-oriented programming, an object that retains a consistent value throughout the execution of a program. Compare variables.
The copyright notice for GNU Emacs and other GNU software, the GNU General Public License, which grants reuse and reproduction rights to all users.
Common Object Request Broker Architecture, from Xerox PARC, a system to define and document interfaces between the modules of non-distributed programs.
A segment of code in which a thread uses resources (such as instance variables) that can be used by other threads, but that must not be used by them simultaneously.
A carriage return (CR; for the ASCII, 0001101...for the octal, \015...for the hex, 0x0f) followed by a line feed (LF; for the ASCII, 0001010...for the octal, \012...for the hex format, 0x0c).
A different target machine than the development tools themselves, which run on the host--for example, when working on a software application with a SPARC station that generates and debugs code for a Motorola Power PC-based board.
Writing assembler code for an application or project when it would be more expediently performed by a compiler.
Common Sub-expression Elimination, for compiler optimization. See also GCSE .
C shell, a command shell for users to type commands, interacting with the operating system. Uses a C-like command syntax, typically for UNIX or Linux developers.
A UNIX emulation library for Windows 98 and Windows NT operating systems. Cygwin is a UNIX or Linux shell environment and portability layer enabling delivery of open source projects to Windows. Cygwin provides corporate IT and software developers a solution for integrating a heterogeneous environment of Windows and UNIX-based systems. In addition, developers can use Cygwin to quickly migrate applications from UNIX or Linux to Windows. For more information detailing Cygwin, see http://sources.redhat.com/cygwin/
A continuously running server process that waits for some condition(s) to occur. See also HTTPD.
In programming, classification in a file of a particular type of information for a computer to use. For specific types of files that computers can store for use, see filetype.
A tool that allows programmers to examine and control a program, typically for the purpose of stopping the program while it runs and finding errors in the program.
Binding of an identifier to the information to which it relates in a program's source code; declaration happens in source code where actual binding happens at compile time or runtime.
A regression testing framework for use on nearly any program, based on the embeddable scripting language, tcl , and its derivative, expect , which runs scripts that can simulate input.
See Embedded DevKit.
GNU file-comparison utilities ( diff, diff3, sdiff, and cmp), which generate a listing of changes, especially giving differences between (and additions to) lines of source code or between different formats. See also patch.
Dynamic Host Configuration Protocol, a protocol for getting an IP address (specifically, an Ethernet address). DHCP assigns IP addresses, delivering TCP/IP stack configuration parameters, while also providing other configuration information such as addresses for routers, printers, time and news servers. A demonstration program, dhcpd, comes with the Embedded DevKit software to show this protocol's usage. See also BOOTP.
Extended Binary Coded Decimal Interchange Code, a character set used by IBM before its open-systems policy, allegedly adapted from punched card code.
E xtended COFF, a format used with MIPS and Alpha processors, both for workstations and embedded uses.
Embedded Configurable Operating System, a complete, open-source run-time environment, allowing embedded system developers to focus on differentiating their products instead of developing, maintaining, or configuring proprietary, real-time kernels.
Electrically Erasable Programmable Read- Only Memory, a special type of EPROM that can be erased when exposed to an electrical charge and reprogrammed. EEPROM retains its contents even when the system powers down.
Historical name for the GNUPro compiler tools, EGCS is pronounced eggs with the C silent. See GCC.
An API, a layered subset of the POSIX API, that is scalable, configurable and meant for development of embedded and real-time applications, using Linux or other compliant embedded operating systems. See also Embedded DevKit.
GNU programmable text editor (derived from Editing MACro S), including facilities to run compilation subprocesses and send and receive mail.
Development for machines that do not run a desktop environment, such as a printer, an engine controller card, or a cellular phone. Development typically uses cross-compilation; for example, a SPARC host operating system generating and debugging code for a Motorola Power PC-based target processor board.
Ability of a program or device to imitate another program or device. For instance, the Cygwin tools allow developers to use UNIX tools while working with Windows systems. See Cygwin.
A data type restricted to sequencing of named values given in a particular order. See also data type.
Usually, a host operating system. In the case of a target environment, a host operating system and a target (usually, a processor board) working together with an executable application.
Assignments for an operating system server or client, dependent upon discretion of the user or developer and their requirements.
Erasable Programmable Read- Only Memory, non-volatile memory chips that are programmed after they are manufactured, and, if necessary, made erasable and reprogrammed. A special type of ROM that retains its contents until it is exposed to ultraviolet light. Compare with diskless, EEPROM, and PROM.
Software for booting x86 PCs over a network. It is useful for:
See also boot/bootstrap, BOOTP, ethernet, network boot, and RAM Disk.
An event during program execution that prevents the program from continuing normally; generally, an error.
Event that occurs when a block of code reacts to a specific type of exception. If the exception is for an error from which the tool (the debugger, for instance) can recover, the debugger resumes its process.
A binary-format file bound by a linker, containing machine instructions, object files and libraries, in a ready-to-run application.
The process of running a compressed data set through an algorithm that restores the data set to its original size.
A specification for an address or numeric value. An empty expression has no value (being either whitespace or null). An integer expression is one or more arguments delimited by operators. Arguments can use symbols, numbers or sub-expressions. Sub-expressions have a parenthetical usage containing an integer expression, or they are a prefix operator followed by an argument. See Using as in GNUPro Auxiliary Development Tools for more discussion of these subjects.
There are many types of files:
An hierarchical directory structure where files may exist at any level of the directory hierarchy. See also cache/cache file system.
A variation of EEPROM that can be erased and programmed as units of memory called blocks; EEPROM is erasable and is rewritten at the byte level, which is slower than flash memory updating. Flash memory is for digital cellular phones, digital cameras, LAN switches, embedded controllers, and other embedded devices.
A number representing a mantissa (usually a value between 0 and 1) and an exponent according to a given base (usually a value of 2).
Numeric system used to represent very large and very small real numbers. With two parts, a mantissa and an exponent. For example, 153,000,000 and 0.0009375 have the floating point notation of 153E6 and 9375E-7, respectively. See also FLOPS.
Floating-point operations per second, a measure of computer's speed of performing floating-point operations. Compare MIPS.
Used very generally as a sample name for absolutely anything, especially programs and files. Etymology from Army slang acronym, FUBAR (bowdlerized to mean Fouled Up Beyond All Repair). See bar.
When a program stops, you can use debugging commands to have access to and information about the location of a function call, arguments about the call, called local variables, and the block of data called the stack frame (using these commands is referred to as examining the stack). See also stack and stack frame.
A free UNIX operating system for PCs. See BSD.
File Transfer Protocol, based on TCP/IP , which enables getting and storing files between hosts on the web. Use the ftp command to direct files to new location.
Segments of C or C++ programming languages that provide a means for a program to transfer and to generate data in a modular way. A function consists of parameters and a return value to define a compiler's requirements for action with a program. A program can have many functions but only one main function to which all other functions address. See also library and subroutine.
The automatic detection and freeing of memory that is no longer in use. A runtime system performs garbage collection so that programmers never explicitly free objects.
GNU Compiler Collection, consisting of gcc, g++ and other compiler development tools. For more information, see GNUPro Compiler Tools.
Global Common Sub-expression Elimination, for compiler optimization. See also CSE.
Acronym for the GNU debugger. See also Insight.
A small, special-purpose debugging application running on a target. gdb connects to the gdbserver using either a serial or an ethernet (TCP/IP) connection.
Obsolete name for the GUI debugger. See Insight.
GNU ANSI C library, a fully POSIX and ANSI compliant C library, more suited to native UNIX systems and heavily used for Linux. See newlib.
Any program variable whose values affect a whole system and are external to a function. Compare local variable and see variables.
Recursive acronym for GNU's Not UNIX. A project to build a free operating system, started by Richard Stallman in 1985, with many useful spinoffs, such as the Emacs text editor, a C compiler ( gcc or egcs), a debugger ( gdb), and many other programming tools.
Freeware 32-bit DOS extender. Also the name for GNU tools ported to DOS using GO32. See: http://www.delorie.com/djgpp/
Program for determining which parts of a program are taking most of the execution time; see also http://sources.redhat.com/binutils/docs-2.10/gprof.html for more profiling information. Profiling allows you to learn where your program spent its time and which functions called which other functions while it was executing. from this you learn which pieces of your program are slower than you expected, which might be candidates for rewriting to make your program execute faster, and which functions are being called more or less often than you expected.
Characteristic of components that contain dissimilar constituents. Also, the ability of a component to contain or to be part of a network that consists of different components that can interoperate. In updating or accessing the GNUPro tools, this term refers to configuring them on networks with strategical symbolic links. See Tools, Toolchains and Usage and Configuring the Location of the Tools for information about using the --exec and --exec-prefix= options in a heterogeneous environment.
The numbering system that uses 16 as its base. The characters 0-9 and a-f represent the digits 0 through 15.
Hyper Text Transfer Protocol Daemon, a Web server program providing information to a client using the HTTP protocol (the standard for communicating information on the World Wide Web). See: http://www.apache.org/
In- Circuit Emulator, a hardware device that gives an engineer control over the execution of a processor while it is connected to the rest of a system's circuitry. Emulators are powerful hardware debugging tools that can connect to debuggers.
Institute of Electrical and Electronics Engineers, a non-profit, international, technical professional association. Its members are authorities in technical areas who set the standards for areas such as computer engineering, biomedical technology, telecommunications, electric power, aerospace, and consumer electronics, among others. See http://www.ieee.org/ and http://standards.ieee.org/ for more information.
Execution of source code for a process whose result is a program that builds and runs.
Often designated as #include , files using or assigning duplication of a portion (or whole) of another file, sometimes leading to excessive multi-leveled inclusion.
Command to initialize a RAM Disk with a Linux operating system. See RAM Disk.
In object-oriented programming, the ability of one class of objects to derive properties from another class.
The GNUPro visual debugger, formerly known as GDBTk. Default debugger for the GNUPro Toolkit. See Debug with Insight and, for more detailed information, see "Insight, GDB's Alternative Interface" in GNUPro Debugger Tools.
An object (not a reference) is defined as an instance of exactly one class (in classical object oriented programming), called its most derived class. An object not directly contained in any other class is called the complete object.
Internet Protocol, the basic protocol of the Internet, enabling the delivery of individual packets from one computer to another across the web. A packet may not be instantly delivered, or if multiple packets are sent simultaneously, they may not simultaneously arrive in the order they were sent. Protocols built on top of this add the notions of connection and reliability. See also TCP/IP.
Just- in- time compiler that converts all of the bytecode into native machine code just as a Java program is run, resulting in run-time speed improvements over code interpreted by a Java Virtual Machine (see JVM).
Joint Test Advisory Group, referring to a type of hardware interface that allows the testing of chips and boards within a complete system; programs running on processors with JTAG support may be controlled through the processor's JTAG port.
From Brian Kernighan and Dennis Ritchie's book, The C Programming Language (Prentice-Hall, 1978; ISBN 0-113-110163-3), generally signifying the C standards.
Local Area Networking that connects systems in order to share information and expensive computing resources.
The GNU linker. Interchangeably used with capitalization (as LD). See linker.
Nested functions that can access all the variables of the containing function that are visible at the point of its definition.
Lesser GNU Public License. See General Licenses and Terms for Using GNUPro Toolkit and GNU Lesser General Public License.
GNU library for manipulating machine opcodes. Its main use is disassembling binary files. Distributed under the GPL, used by the GNU binary utilities, assembler and debugger.
A collection of precompiled routines that a program can use. The routines, sometimes called modules, are stored in object format. Libraries are particularly useful for storing frequently used routines because you do not need to link them explicitly to every program that uses them. However, libraries cannot execute by their own routine. Multiple executables can include the library and other libraries can include the library. The linker automatically looks in libraries for routines not found elsewhere. Depending on the operating system, a library's routine is the product of special tools that linkers or other library tools merge to activate. See also function and subroutine.
GNU command line editing program, distributed under the GPL. This library implements full Emacs or vi key bindings with history support. Used by the GNU debugger.
GNU object file manipulation library, distributed under the GPL and used by the GNU binary utilities, assembler, linker, and debugger. It can read and write files in any supported object file format, and presents a somewhat loosely defined standard for manipulating object files. See also BFD, FreeBSD, and NetBSD.
Library comprising the precompiled routines for embedded environment development. See also library.
A tool that merges object files and library archives (such as compiled classes), building an executable, a complete program or a single executable file. For GNU, ld is the linker tool.
A set of programmer-supplied instructions that tell the linker how to handle object file sections, how to lay out memory, and so forth. For native linking, the contents of the linker script are normally determined by the needs of the operating system; for embedded targets, the programmer explicitly supplies the linker script.
A UNIX operating system for many kinds of computers, created by Linus Torvalds and friends starting about 1990.
LISt Processing language, based on the ideas of variable-length lists and/or trees as fundamental data types, and the interpretation of code as data (and vice-versa).
The basic representation of any integer, floating point, or character value. For example, 3.0 is a single-precision floating point literal, and a is a character literal.
A data item known within a block, but inaccessible to code outside the block. For example, any variable defined within a Tcl method is a local variable and cannot be used outside the method.
A byte-ordering scheme, such as used by the Intel x86 family, which is all little-endian. Describes a computer architecture in which, within a given 16- or 32-bit word, bytes at lower addresses have lower significance (the word is stored little-end-first). See also big-endian.
Used for general register (for intermediary and temporary results), index register (for arithmetic operation and addressing memory), pointer register (for arithmetic operation and addressing memory), and segment register (for built-in memory management) purposes.
A set of instructions for a program that a compiler substitutes whenever the macro's name appears in the source code. Compare function and see build and library.
A program's fundamental system call for processing memory allocation and initialization resources for the program.
The GNU utility for automating recompilation, linking, and other program processes that take account of the interdependencies of modules and their modification times. make reads instructions from a file, Makefile, which specifies a set of targets to build, a set of files on which the targets depend, and the commands to execute in order to produce them. If make is run with no arguments, it looks for a makefile, Makefile. For historical purposes, see also Make: A Program for Maintaining Computer Programs by A.I. Feldman (a Bell Labs publication).
A specific script that tells a UNIX program, make, how to build a particular computer program or set of programs. A makefile contains variable assignments and rules that say if any files have been modified more recently than a target file (or if the target does not exist), then execute the commands that will build the target. For an example of a makefile, see "A simple makefile" and "Writing makefiles" with Using make in GNUPro Development Tools.
makefile is a file run by make, the recompilation utility. See also build and target.
The process by which C++ types and classes are turned into symbols in object files that are compatible with other languages.
Alternative term for method.
A character in a program conveying information rather than representing the character. The backslash character (/) is an example in C programming that indicates that the letter following the backslash character is an escape sequence. This enables C to display characters such as a tab or a carriage return.
A tutorial version of UNIX, written by Andy Tanenbaum and described in his textbook. Minix is said to have been the inspiration for Linux.
A self-contained hardware or software component that interacts with a larger system. For instance, modular programming has evolved into object-oriented programming, which provides formal rules for developing self-contained software modules.
Process or command for remote systems to use to move files from one location to another system.
A collection of libraries, built with different GNU compiler options, for target processors whose variants each require changes in code generation. This ensures that a program using -msoft-float (enabling software floating point functionality) will link with libraries built using the same option.
In object-oriented programming, arelationship between objects, where an object derives its behavior from more than one other object. See also inheritance.
Functionality of a program that is designed to have parts of its code execute concurrently. See also thread.
To make changes to a file, irrevocably, such as a comprehensive rewrite of a routine, data structure or a whole program. Often an unintentional process of corrupting a file or memory block so that it is unusable, unreadable, unviewable, or unrecoverable.
Object to provide mutually exclusive resource locking for a program using pthreads.
The process by which C++ types and classes are turned into symbols in object files that are compatible with other languages.
An ANSI/ISO standard in development for the C++ libraries that allows users to identify the scope for selecting specific functions by class or type from separate libraries, while still being able to let libraries work together and separately.
A function defined inside another function. See also lexical scoping.
A free UNIX operating system for PCs and other kinds of computers. See also BSD.
A process for getting system files over a network link, allowing any updating of files to happen at that single, robust server. See also boot/bootstrap and BOOTP.
The ASCII LF character (for 0001010), used under UNIX as a text line terminator. See also CRLF.
Network File System, a way to share files between machines as if shared on a local hard drive. With NFS, export files systems to other systems, and mount file systems exported from other machines. See also BOOTP, filesystem, network boot, and RAM Disk.
The principal building blocks of object-oriented programs. Each object is a programming unit consisting of data variables and functionality. See also classes.
A binary-format file containing machine instructions and possibly symbolic relocation information. Typically produced by an assembler for a linker, for compiling with a program into an executable file.
Assembler macros that provide commands instructing a specific device to perform a specific task.
A flag on some processors indicating an attempt to calculate a result too large for a register to hold.
In programming languages, a feature that allows an object to have different meanings depending on its context. Used most often in reference to operators that can behave differently depending on the data type, or class, of the operands. For example, x+y can mean different things depending on whether x and y are simple integers or complex data structures.
The swap space on a system's disk for storing idle portions of the memory used by running programs, and the filesystem space to store directories and files.
A change in source code to correct or to enhance processes. Also a file that contains changes to source code; specifically, the results of a differentiation and comparison between the new file(s) and the old file(s). See diff utilities.
A filename, fully specified relative to the root directory (as opposed to relative to the current directory; the latter is sometimes called a relative path). Also called a pathname or full path. With UNIX and MS-DOS, the search path is an environment variable that specifies the directories in which the shell (or Command.com, under MS-DOS) should look for commands. Other similar constructs exist with UNIX (for example, the C preprocessor has a search path it uses in looking for #include files).
Peripheral Component Interconnect bus, a high-performance means to carry signals for transferring data between the processor and any peripheral devices.
Practical Extraction Report Language, a scripting language that Larry Wall designed which interprets data from text files and converts the data into an intermediate form before executing the data as a program. See http://www.perl.com/, the Perl Home Page.
An ANSI C command comment that conveys non-essential yet pragmatic information, often to help with optimization when compiling.
A collection of references to source code files, the location of the files and how to operate on them.
The result, a combination of which is a file that represents: a program's structures, the location of function declarations, the components of function declarations such as symbols and other references, and the relationship between a program's components.
Programmable Read- Only Memory, ROM that can be programmed using special equipment. PROMs can be programmed only once. See also ROM and EPROM.
Assembler directives. See also opcodes.
Pseudo registers can only contain scalar variables that cannot be aliased. This means that global variables, local variables that have their addresses taken, and aggregates (such as structures and unions) cannot be stored in pseudo registers, and thus they must be accessed with separate load and store instructions. Because of the guarantee that pseudo registers are not aliased, they are ideal targets for optimization.
Random- Access Memory, the volatile memory of an operating system, from which a microprocessor can read data or to which a microprocessor can write data.
A disk drive that resides in memory, taking up very little space, for storing temporary work files or to help decrease the I/O load on a system's disks. Can use RAM from the buffer cache to dynamically grow in size. See also RAM.
A shell, for interactive use or for use with scripts, providing C-syntax features with better quoting rules then C or Bourne shells.
runcom files, using a startup script file that contains startup instructions for an application program (or an entire operating system), usually a text file containing commands of the sort that might have been invoked manually once the system was running but are to be executed automatically each time the system starts.
Revision Control System, the tools for controlling software revisions. See also CVS.
A ROM monitor. RedBoot is a standard bootstrap and debugging environment for embedded systems from Red Hat.
A characteristic of library functions for multiple processes to use the same address space with assurance that the values stored in those spaces will remain constant between calls. libm library functions ensure that, when possible, they are reentrant.
Registers are settings representing values that serve as temporary storage devices in a processor, allowing for faster access to data. Registers are divided into several classes: pseudo registers, temporary registers, and machine registers.
When doing assembly, assigning run-time addresses to sections, which includes the task of adjusting the mention of object-file addresses so that they refer to the proper run-time addresses. See section.
See target.
Request For Comment(s), one of a long-established series of numbered Internet informational documents and standards widely followed by commercial software and freeware in the Internet and UNIX communities.
Reduced Instruction Set Computer, machines typically having fixed-length instructions, limited addressing modes, many registers, and visible pipelines.
Read- Only Memory, non-volatile memory that can be read, but not written, by the microprocessor, pre-recorded, often holding critical programs, such as boot data.
In a hierarchy of items or of separate files in a directory, the one item or directory from which all other items or directory paths descend. Also the name of the primary administrative account on Linux and other UNIX machines.
Network device that determines the optimal path along which network traffic should be forwarded, using packets from one network to another based on network layer data.
Red Hat Package Manager, a means for having all the necessary components of the Linux software in a single file, from which an install process unpackages and then moves to appropriate directories.
To perform tasks with RPM, use the rpm --help | more command line input.
Remote shell protocol that allows a user to execute commands on a remote system without having to log into the system.
A real-time operating system for telephones, automobile control systems, kitchen appliances, complex air traffic control systems, military weapon systems, and production line control including robotics and automation and other rapidly changing technology.
Real- Time Operating System. See also RTEMS.
Rules determining where a name is usable, such as a function or variable name (the general rule being that a name can be used from the point of declaration to its innermost enclosing compound statement).
A terminal line that disgorges an infinite number of random characters at an operating system. See also tty.
Object files and executables that are composed of a range of addresses, having optional data and optional relocation information. An object file written by the GNU assembler, as, has at least three sections, any of which may be empty; they are the text, data and bss sections.
Stream-oriented version of the ed editor. For running repetitive edits on files or on files in several directories. Also for creating conversion programs.
An error in which a running program attempts to access memory not allocated to it and core dumps with a segmentation violation error.
When configuring libraries, the linker's usage of source in libraries, whereby the linking explicitly includes those libraries in the linking instruction.
A library of functions used by many executables, linked into each executable only when the particular executable runs.
An interface program for accessing resources and for performing tasks. The original Multics shell ran programs by starting processes that were dynamically linking programs into existing code, calling them as subroutines (see stub) and dynamically de-linking them on return.
The main shells in use are ash, bash, csh, ksh, sh, and tcsh.
A means to interpret, classify, and present information about an embedded system's behavior that is being modeled. It comprises both hardware and software elements.
A tool that imitates the behavior of an embedded system so developers can run their code to see how the code will work once the actual hardware is available for testing. (For instance, a simulator could show what happens when pressing cellphone buttons or what happens when moving video game's joystick). A simulator makes simultaneous development of code and hardware then possible.
State of waiting, especially in debugging a program with loops, where code needs to have an awakening for an expected action to occur.
A binary download format, consisting of a series of records, each beginning with S, with symbolic data encoded as hexadecimal digits. Before downloading to a board, for instance, a program must be converted using S-records.
A standard C shell. See shell.
Based on symbol tables, a debug format introduced with the Berkeley UNIX system which records debugging information in certain symbols in the object file's symbol table. stabs information may also be encapsulated in COFF or ELF files.
The layers (TCP, IP, and sometimes others) through which all data passes at both client and server ends of a data exchange. A data area or buffer used for storing requests that need to be handled, as in a list of tasks or, specifically, the contiguous parts of the data associated with one call to a specified function in a frame. The frame contains the arguments given to the function, the function's local variables, and the address at which the program is executing. In The Art of Computer Programming [2nd edition, vol. I, pg. 236], Donald Knuth writes, "Many people who realized the importance of stacks and queues independently have given other names to these structures: stacks have been called push-down lists, reversion storages, cellars, nesting stores, piles, last-in-first-out ( LIFO) lists, and even yo-yo lists!"
When debugging, the location of a function call, arguments about the call, and the called local variables are within a block of data called the stack frame. Stack frames are allocated in a region of memory called the call stack. When a program stops, debugging commands for examining the stack enable you to see all this information.
A small piece of code that executes on the target and communicates with the debugger, acting as its agent, collecting registers, setting memory values, etc. Also, in a native shared library system, the part of the shared library that actually gets linked with a program. See also subroutine.
Part of a program that calls another part of a program so that developers can simplify code in their programs and save memory. See also stub.
Moving blocks of information in units known as pages between memory and disk during execution of an application. For example, moving data from fast-access memory to a slow-access memory (swap out) or reverse (swap in). Supported by many operating systems, a process of exchanging two values; for instance, swapping could be exchanging values between two variables. Especially for use as temporary storage during reconfiguration.
Symbols are used to refer to variables, labels, functions, methods, macros, and other procedures or programatic constructs in a program; basically, symbols are names and addresses, representing simple instructions for a program. Typically every global function and variable in a C program will have an associated symbol.
(1) An actual physical device, such as a target microprocessor motherboard that gets files from a host operating system.
(2) An application or program run on a target board.
(3) A class of devices whose types include executables and libraries, either of which may include other libraries and object files.
A host operating system and a target (usually, a processor board) when working together with an executable application.
The code language used to develop an IDE. Developed by John Ousterhout, Tcl is the basic programming language while Tk is a toolkit of widgets (graphical objects similar to those of other GUI toolkits, such as Xlib, Xview and Motif). Unlike many of the other toolkits, it is not necessary to use C or C++ in order to manipulate the widgets, and useful applications can be built very rapidly with Tcl/Tk. For more information, see ftp://ftp.tcl.tk/pub/tcl/ (distribution sources) and http://www.tcl.tk (Tcl Developer Xchange).
Transmission control protocol (based on IP), an internet protocol that provides for the reliable delivery of streams of data across the web.
Standard terminal emulation protocol in the TCP/IP protocol stack, when using a remote terminal connection, enabling remote log in to systems, thereby using resources as if connected to a local system.
Temporary registers are used to hold intermediate results of computations within a basic block. Each temporary register must be defined and used in exactly one place. Never assign to a temporary register a value that is never used, and do not use the value in a temporary register more than once.
Trivial File Transfer Protocol, used when getting an IP address with tftpboot command line input. A restricted version of TCP with no authentication, using UDP rather than TCP. See also TCP/IP.
The basic unit of instructions for a program to execute. A process can have several threads running concurrently, each performing a different job, such as waiting for events or performing a time-consuming job that the program does not need to complete before resuming. For a debugging process, when a thread finishes its job, the debugger suspends or destroys the thread running.
See Canadian cross.
A complete set of GNUPro tools for a particular native or host architecture and a target environment, typically using the naming convention combining a host name and a target name as a prefix to the tool name. See Naming Conventions and Tools, Toolchains and Usage for more explanation. A program follows a standard of four stages: compiling, assembling, archiving, linking, and debugging.
On-the-fly generation by a compiler (such as gcc) of small executable code objects that do indirection between code sections, taking the address of a nested function.
See Canadian cross.
Any serial port, whether or not the device connected to it is a terminal. So called because under UNIX such devices have names of the form, tty*. Its derivation is from the term, tele type.
A small and insignificant change to a program. Derived from squiggle, or in ASCII shorthand, tilde (for the ASCII character definition, 1111110, of the character, ~).
A classification in a file of particular information for a computer to use. Information can be about the nature of a variable, such as an integer, floating-point number or text character, with the variable defining and restricting the values that it can hold. For specific types of files that computers can store for use, see filetype.
In C programming, a keyword for naming new data types. See data type.
A structure using different types of variables, such as integers, characters or Boolean values, storing them in the same location, only one at a time.
UNIX operating system (lowercase spelling of Unix used interchangeably). Invented in 1969 by Ken Thompson after Bell Labs left the Multics project, UNIX subsequently underwent mutations and expansions under many different hands, resulting in a uniquely flexible and developer-friendly environment, becoming what was once the most accepted multiuser, general-purpose operating system in the world.
A variable is a symbol or name that a program uses to represent a value.
Virtual File System; its function, among other things, is to flush the read buffer when it detects a disk change on the floppy disk drive.
Visual Interface, a screen editor crafted together by Bill Joy for an early BSD release. Became the de facto standard UNIX editor and a nearly undisputed hacker favorite (arguably) outside of MIT until Emacs after about 1984. See also ed and Emacs.
An abstract specification for a computing device that can be implemented in different ways, in software or hardware. Compiling to the instruction set of a virtual machine is much like compiling to the instruction set of a microprocessor, using a bytecode instruction set, a set of registers, a stack, a garbage-collected heap, and an area for storing methods.
A special breakpoint that stops a program's debugging process when the value of an expression changes.
In code, newlines, spaces and tab characters which the compiler treats as a contiguous, single character. An instance that is noticeable for the program output, and only as formatting for human readability.
The components of software by which we get many of the interface features that provide interoperability, such as the scrollbars or the means of selecting text with a cursor or pointer with the functionality of object-oriented programming.
A virus program (one that propagates itself over a network, reproducing itself as it goes, the famous Great Worm of 1988 being one of the best-known of the early examples; it was Robert T. Morris's 1988 virus, a benign one that got out of control and hogged hundreds of Sun and VAX systems across the U.S.).
A windowing system developed at MIT that lets users run applications on other systems on a network and view the output on their computer screen. The X Windows window manager component of the GUI allows multiple resizable, relocatable X windows to be viewed on screen, allowing simultaneous processes to develop.
A way of implementing a big-endian ISA. See PPC (PowerPC) for example members.
The X Windows system terminal program. See X.