finals for cis and spanish

• consists of a variety of programs that support the operation of a computer – Text editor, Compiler, Loader or Linker, Debugger, Assembler, Marco processor, Operating system
• differs in machine dependency, it is often machine dependent

intended to support the operation and use of the computer itself, rather than any particular application. For this reason, they are usually related to the architecture of the machine on which they are to run.

simplified instructional computer

simplified instructional computer extra equipement or extra expensive

consists of 8-bit bytes, any 3 consecutive bytes for a word

all adddresses in sic are byte addresses, words are addressed by the location of the their lowest numbered byte

There are a total of 32,768 (215) bytes in SIC memory

• There are five registers, all of which have special uses.
• Each register is 24 bits in length

accumulator

All arithmetic operations involve register A and a word in memory

index register, used for addressing

linkage register, jump to subroutine instruction stores the return address in this register

program counter, contains the address of the next instruction to be fetched for execution

status word, contains a variety of info, including condition code(CC)

stored as 24-bit binary numbers; 2’s complement representation is used for negative values

no floating point in sic

8 bite opcode + 1 bit indicator(direct or indirect) + 15 bit address

compares the value in register A with a word in memory; this instruction sets a condition code CC to indicate the result (<, =, or >).

provided to subroutine linkage

are performed by transferring 1 byte at a time to or from the rightmost 8 bits of register A


Each device is assigned a unique 8-bit code

TD (Test Device), RD (Read Data), WD (Write Data)

1 Mbyte

base register, used for addressing

general working register no special use

floating point accumulator(48 bits)

SIC/XE provides the same data formats as SIC


In addition, a 48-bit floating-point data type is also provided. See the top of Page 8 1 bit sign, 11 bit exponent and 36 bit fraction

8 bit opcode

8 bit opcode, 2 four bit registers

6 bit opcode, nixbpe, 12 bit displacement

6 bit opcode nixbpe, 20 bit address

b=1, 0<=disp<=4095

p=1 -2048<=disp<=2047

both b and p are set to 0 in formats 3 and 4

if bit x is set to 1, the term (X) is added in the target address calculation

if bits i=1 and n=0, the target address itself is used as the operand value; no memory reference is performed

if bits i=0 and n=1, the word at

the location given by the target address is fetched; the value contained in this word is taken as the address of the operand value

if bits i and n are both 0 or both 1, the target address is taken as the location of the operand

includes all in sic and there are new ones to load and store the new registers LDB, STB, etc and perform floating point arithmetic ops(ADDF, SUBF, MULF, DIVF)

Register-to-register arithmetic operations

Supervisor call instruction

The machines described in this section are classified as Complex Instruction Set Computers (CISC).



CISC machines generally have a relatively large and complicated instruction set, several different instruction formats and lengths, and many different addressing modes



The implementation of such architecture in hardware tends to be complex

The RISC (Reduced Instruction Set Computers) concept, developed in the early 1980s, was intended to simplify the design of processors



This simplified design can result in faster and less expensive processor development, greater reliability, and faster instruction execution times



In general, a RISC system is characterized by a standard, fixed instruction length (usually equal to one machine word), and single-cycle execution of most instructions

Specify name and starting address for the program

Indicate the end of the source program and (optionally) specify the first executable instruction in the program;

Generate character or hexadecimal constant, occupying as many bytes as needed to represent the constant

Generate one-word integer constant

Reserve the indicated number of bytes for a data area

Reserve the indicated number of words for a data area.

1) Convert mnemonic operation codes to their machine language equivalents – e.g., translates STL to 14 (line 10);

• 2) Convert symbolic operands to their equivalent machine addresses – e.g., translate RETADR to 1033 (line 10);
• 3) Build the machine instructions in the proper format;
• 4) Convert the data constants specified in the source program into their internal machine representations – e.g., translate EOF to 454F46 (line 80);

5) Write the object program and the assembly listing.

scans the source program for label definitions and assigns addresses.

performs most of the actual translation

assembler directives (or pseudo-instructions).

The assembler must write the generated object code onto some output device. This object program will later be loaded into memory for execution

Header, Text, and End

the Operation Code Table (OPTAB) and the Symbol Table (SYMTAB

must contain (at least) the mnemonic operation code and its machine language equivalent. In more complex assemblers, this table also contains information about instruction format and length.

• During Pass 1, OPTAB is used to look up and validate operation codes in the source program.
• In Pass 2, it is used to translate the operation codes to machine language

includes the name and value (address) for each label in the source program, together with flags to indicate error condition (e.g., a symbol defined in two different places).

• During Pass 1, labels are entered into SYMTAB as they are encountered in the source program, along with their assigned addresses (from LOCCTR).
• 􀁺 During Pass 2, symbols used as operands are looked up in SYMTAB to obtain the addresses to be inserted in the assembled instruction.

used to be a variable and help in the assignment of addresses. Whenever a label in the source program is read, the current value of LOCCTR gives the address to be associated with that label.

@ - indirect addressing


# - immediate operands


+ - extended instruction format

either the program-counter relative or the base relative mode. The assemble directive BASE (Fig 2.5, line 13) is used in conjunction with base relative addressing

the use of register-to-register instructions (lines 150, 165). In addition, immediate addressing and indirect addressing have been used as much as possible (lines 25, 55, and 70).

relocatable program.

shown in P.64.

stored in half-bytes (rather than byte)

field of a modification record is the location of the byte containing the leftmost bits of the address field to be modified

Note that a literal is identified with the prefix =, which followed by a specification of the literal value.

• 1. With immediate addressing, the operand value is assembled as part of the machine instruction.
• 2. With a literal, the assembler generates the specified value as a constant at some other memory location. The address of this generated constant is used as target address for the machine instruction.

All of the literal operands used in a program are gathered together into one or more literal pools

• 1. When the assembler encounters a LTORG statement, it creates a literal pool that contains all of the literal operands used since the previous LTORG (or the beginning of the program).
• 2. This literal pool is placed in the object program at the location where the LTORG directive was encountered
• 3. Of course, literals placed in a pool by LTORG will not be repeated in the pool at the end of the program.

as labels on instructions or data areas. The value of such a label is the address assigned to the statement on which it appears

allows the programmer to define symbols and specify their value. The assembler directive generally used is EQU

• Another common use of EQU is in defining mnemonic names for registers. For example: A EQU 0
• X EQU 1
• L EQU 2

• One common use of EQU is to establish symbolic names that can be used for improved readability in place of numeric values. +LDT +4096 → MAXLEN EQU 4096
• +LDT #MAXLEN
• When the assembler encounters the EQU statement, it enters MAXLEN into SYMTAB (with value 4096).

When this statement is encountered during assembly of a program, the assembler resets its location counter (LOCCTR) to the specified value. Since the values of symbols are taken from LOCCTR, the ORG statement will affect the values of all labels defined until the next ORG.

• Expressions are classified as either absolute expressions or relative expressions
• must be evaluated by the assembler to produce a single operand address or value

means independent of program location. A constant is an absolute term

is one in which all of the relative terms except one can be paired as described above; the remaining unpaired relative term must have a positive sign.



Example: 107 MAXLEN EQU BUFEND－BUFFER both BUFEND and BUFFER

are referred to be segments of code that are rearranged within a single object program unit, and control sections (appeared in next subsection) to be segments that are translated into independent object program units

indicates which portions of the source program belong to the various blocks

The assembler accomplishes this logical rearrangement of code by maintaining, during Pass 1, a separate location counter for each program block. Thus each label in the program is assigned an address that is relative to the start of the block that contains it.

the latest value of the location counter for each block indicates the length of that block. The assembler can then assign to each block a starting address in the object program

the assembler needs the address for each symbol relative to the start of the object program (not the start of an individual program block). This is easily found from the information in SYMTAB. The assembler simply adds the location of the symbol, relative to the start of its block, to the assigned block starting address

separation of the program into blocks

is a part of the program that maintains its identity after assembly; each such control section can be loaded and relocated independently of the others. Different control sections are most often used for subroutines or other logical subdivisions of a program

they are handled separately by the assembler.

The EXTDEF statement in a control section names symbols, called external symbols, that are defined in this control section and may be used by other sections

The EXTREF statement names symbols that are used in this control section and are defined elsewhere

gives information about external symbols that are defined in this control section – that is, symbols named by EXTDEF

lists symbols that are used as external reference by the control section – that is, symbols named by EXTREF.

erforms the actual loading, relocation, and linking.

main structure needed for the loader, the external symbol table

program load address


is the beginning address in memory where the linked program is to be loaded. Its value is supplied to the loader by the OS

contains the starting address assigned to the control section currently being scanned by the loader. This value is added to all relative addresses within the control section to convert them to actual addresses.

shows these symbols and their addresses. For the example of Figs 3.9 and 3.10, such a load map might look like as shown on the top of page 143

the loader arbitrarily uses the last one encountered.

the loader uses the beginning of the linked program (i.e., PROGADDR) as the transfer point

often thought of as OS service functions

fewer different features than are found in a typical assembler. They include the use of an automatic library search process for handling external reference and some common options that can be selected at the time of loading and linking

automatically incorporate routines from a subprogram library into the program being loaded

keep track of external symbols that are referred to, but not defined, in the primary input to the loader.

It is therefore necessary to repeat the library search process until all references are resolved.

• option 1: allows the selection of alternative sources of input.
• Ex.,

INCLUDE program-name (library-name)

• option 2: allows the user to delete external symbols or entire control sections.
• Ex.,

DELETE csect-name

• might instruct the loader to delete the named control section(s) from the set of programs being loaded.
• CHANGE name1, name2
• might cause the external symbol name1 to be changed to name2 wherever it appears in the object programs

• involves the automatic inclusion of library routines to satisfy external references. Ex., LIBRARY MYLIB
• Such user-specified libraries are normally searched before the standard system libraries. This allows the user to use special versions of the standard routines.
• NOCALL STDDEV, PLOT, CORREL
• To instruct the loader that these external references are to remain unresolved. This avoids the overhead of loading and linking the unneeded routines, and saves the memory space that would otherwise be required

which perform linking prior to load time

which the linking function is performed at execution time

performs all linking and relocation operations, including automatic library search if specified, and loads the linked program directly into memory for execution

produces a linked version of the program (load module or executable image), which is written to a file or library for later execution



This means that the loading can be accomplished in one pass with no external symbol table required



performs relocation of all control sections relative to the start of the linked program. Thus, all items that need to be modified at load time have values that are relative to the start of the linked program.

build packages of subroutines or other control sections that are generally used together. This can be useful when dealing with subroutine libraries that support high-level programming languages.

in general tend to offer more flexibility and control

the program is loaded for execution at load time

postpones the linking function until execution time: a subroutine is loaded and linked to the rest of the program when it is first called



avoid the necessity of loading the entire library for each execution except those necessary subroutines

represents a commonly used group of statements in the source programming language. The macro processor replaces each macro instruction with the corresponding group of source language statements. This is called expanding the macros

write a shorthand version of a program, and leave the mechanical details to be handled by the macro processor

is in assembler language programming. However, macro processors can also be used with high-level programming languages, operating system command languages, etc.

tells begining of macro definition

define a pattern or prototype for the macro instructions used by the programmer

assembler directive marks the end of the macro definition.

This allows the programmer to use a macro instruction in exactly the same way as an assembler language mnemonic

the expanded file (Fig 4.2) can be used as input to the assembler

only once, regardless of how many times the subroutine is called

contains the macro prototype and the statements that make up the macro body (with a few modifications). Comment lines from the macro definition are not entered into DEFTAB because they will not be part of the macro expansion

The macro names are entered into NAMTAB, which serves as an index to DEFTAB. For each macro instruction defined, NAMTAB contains pointers to the beginning and end of the definition in DEFTAB

used during the expansion of macro invocations

• When a macro invocation statement is recognized, the arguments are stored in ARGTAB according to their position in the argument list.
• As the macro is expanded, arguments from ARGTAB are substituted for the corresponding parameters in the macro body

which is called when the beginning of a macro definition is recognized, makes the appropriate entries in DEFTAB and NAMTAB.

maintains a counter named level. each time the macro directive is read the value of level is incremented



The above process is very much like matching left and right parentheses when scanning an arithmetic expression

cancatenation operator for macro processors.

all occurrences of the concatenation operator immediately after performing parameter substitution, so 􀃆 will not appear in the macro expansion

avoids dups

modify the sequence of statements generated for a macro expansion, depending on the arguments supplied in the macro invocation. This is called conditional macro expansion

This SET statement assigns the value 1 to &EORCK

Note any symbol that begins with the character & and that is not a macro instruction parameter is assumed to be a macro-time variable


All such variables are initialized to a value of 0

a symbol table that contains the values of all macro-time variables used. Entries in this table are made or modified when SET statements are processed. The table is used to look up the current value of a macro-time variable whenever it is required.

occurs at the time macros are expanded.

can be done if writing macro in a language that handles recursive calls.

another name for microprocessors

The simplest method of achieving this sort of combination is a line-by-line macro processor. Using this approach, the macro processor reads the source program statements and performs all of its functions as previously described

• For the purposes of compiler construction, a high-level programming language is usually described in terms of grammar. This grammar specifies the form, or syntax, of legal statements in the language.
• The problem of compilation then becomes one of matching statements written by the programmer to structures defined by the grammar, and generating the

appropriate object code for each statement

may be thought of as the fundamental building blocks of the language

The task of scanning the source statement, recognizing and classifying the various tokens, is known as

performs lexical analysis

This process, called syntactic analysis or parsing, is performed by a part of the compiler that is usually called the parser

the generation of object code. Most compilers create machine-language programs directly instead of producing a symbolic program for later translation by an assembler

A BNF grammar consists of a set of rules, each of which defines the syntax of some construct in the programming language

Character strings enclosed between the angle brackets < and > are called nonterminal symbols (such as ‘<read>’ and ‘<id-list>’). These are the names of constructs defined in the grammar

not enclosed in brackets

It is often convenient to display the analysis of a source statement in terms of a grammar as a tree

scanning the program to be compiled and recognizing the tokens that make up the source statements. Scanners are usually designed to recognize keywords, operators, and identifiers, as well as integers, floating-point numbers, character strings, and other similar items

The tokens of most programming languages can be recognized by a finite automaton

bottom-up and top-down – according to the way in which the parse tree is constructed

recursive-descent parsing) begin with the rule of the grammar that specifies the goal of the analysis (i.e., the root of the tree), and attempt to construct the tree so that the terminal nodes match the statements being analyzed.

ex. operator-precedence parsing) begin with the terminal nodes of the tree (the statements being analyzed), and attempt to combine these into successively higher-level nodes until the root is reached

This method is based on examining pairs of consecutive operators in the source program, and making decisions about which operation should be performed first.

Shift-reduce parsers make use of a stack to store tokens that have not yet been recognized in terms of the grammar.

The other parsing technique is a top-down method known as recursive descent. A recursive descent parser is made up of a procedure for each nonterminal symbol