DOCSLIB.ORG

Chapter 5 the LC-3

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Chapter 5 the LC-3 Instruction Set Architecture ISA = Programmer-visible components & operations • Memory organization Address space -- how may locations can be addressed? Addressibility -- how many bits per location? • Register set Chapter 5 How many? What size? How are they used? • Instruction set The LC-3 Opcodes Data types Addressing modes All information needed to write/gen machine language program Based on slides © McGraw-Hill Additional material © 2004/2005 Lewis/Martin CSE 240 5-2 LC-3 Overview: Memory and Registers LC-3 Overview: Instruction Set Memory Opcodes • Address space: 216 locations (16-bit addresses) • 16 opcodes • Addressibility: 16 bits • Operate instructions: ADD, AND, NOT, (MUL) • Data movement instructions: LD, LDI, LDR, LEA, ST, STR, STI Registers • Control instructions: BR, JSR, JSRR, RET, RTI, TRAP • Temporary storage, accessed in a single machine cycle • Some opcodes set/clear condition codes, based on result Memory access generally takes longer N = negative (<0), Z = zero (=0), P = positive (> 0) • Eight general-purpose registers: R0 - R7 Data Types Each 16 bits wide • 16-bit 2’s complement integer How many bits to uniquely identify a register? Addressing Modes • Other registers • How is the location of an operand specified? Not directly addressable, but used by (and affected by) • Non-memory addresses: register, immediate (literal) instructions PC (program counter), condition codes, MAR, MDR, etc. • Memory addresses: base+offset, PC-relative, indirect CSE 240 5-3 CSE 240 5-4 1 LC-3 Instruction Summary Operate Instructions (inside back cover) Only three operations • ADD, AND, NOT Source and destination operands are registers • Do not reference memory • ADD and AND can use “immediate” mode, (i.e., one operand is hard-wired into instruction) Will show abstracted datapath with each instruction • Illustrate when and where data moves to accomplish desired op. CSE 240 5-5 CSE 240 5-6 NOT (Register) ADD (Register) this zero means “register mode” 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 NOT 1 0 0 1 DR SR 1 1 1 1 1 1 ADD 0 0 0 1 DR SR1 0 0 0 SR2 Register File Register File ADD R3 R5 R0 ADD R3 R5 R0 R0 1111111111111111 IR 1 0 0 1 0 1 1 1 0 1 1 1 1 1 1 1 IR 0 0 0 1 0 1 1 1 0 1 0 0 0 0 0 0 R1 R1 R2 R2 R3 0101000011110000 R3 0000000000001000 R4 R4 Convention R5 1010111100001111 R5 0000000000001001 R6 16 R6 16 source R7 R7 destination 16 16 16 16 B A B A NOT ADD ALU ALU Note: DR and SR could be the same register CSE 240 5-7 CSE 240 5-8 2 ADD (Immediate) this one means “immediate mode” Using Operate Instructions: Subtraction 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 How do we subtract two numbers? ADD 0 0 0 1 DR SR1 1 imm5 Goal Register File ADD R3 R5 -1 R0 • R1 <- R2 - R3 (no such instruction!) IR 0 0 0 1 0 1 1 1 0 1 1 1 1 1 1 1 R1 5 R2 R3 0000000000001000 Idea (Use 2’s complement) SEXT R4 16 R5 0000000000001001 1. R1 <- NOT R3 R6 16 1111111111111111 R7 2. R1 <- R1 + 1 16 16 3. R1 <- R2 + R1 1 0 16 B A ADD ALU If 2nd operand is known and small, easy • R1 <- R2 + -3 CSE 240 5-9 CSE 240 5-10 Using Operate Instructions: OR Using Operate Instructions: Copying How do we OR two numbers? How do we copy a number from register to register? Goal Goal • R1 <- R2 OR R3 (no such instruction!) • R1 <- R2 (no such instruction!) Idea (Use DeMorgan’s Law) Idea (Use immediate) • A OR B = NOT(NOT(A) AND NOT(B)) • R1 <- R2 + 0 1. R4 <- NOT R2 2. R5 <- NOT R3 Could we use AND? 3. R1 <- R4 AND R5 4. R5 <- NOT R1 CSE 240 5-11 CSE 240 5-12 3 Using Operate Instructions: Clearing Data Movement Instructions How do we set a register to 0? Load: read data from memory to register • LD: PC-relative mode Goal • LDR: base+offset mode • LDI: indirect mode • R1 <- 0 (no such instruction!) Idea Store: write data from register to memory • R1 <- R1 AND 0 • ST: PC-relative mode • STR: base+offset mode • STI: indirect mode Could we use ADD? Load effective address • Compute address, save in register, do not access memory • LEA: immediate mode CSE 240 5-13 CSE 240 5-14 PC-Relative Addressing Mode LD (PC-Relative) Want to specify address directly in the instruction 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 • But an address is 16 bits, and so is an instruction! LD 0 0 1 0 DR PCoffset9 • After subtracting 4 bits for opcode and 3 bits for register, we have 9 bits available for address Register File LD R3 -81 R0 IR 0 0 0 1 0 1 1 1 1 0 1 0 1 1 1 1 R1 Observation 9 R2 • Needed data often near currently executing instruction R3 0000000000001001 PC 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 SEXT R4 16 R5 16 16 R6 Solution 1111111110101111 R7 • Add 9 bits in instruction (sign extended) to PC (of next instruction) to form address B A ADD ALU MAR MEMORY MDR Example: LD: R1 <- M[PC+SEXT(IR[8:0])] 16 Rd CSE 240 5-15 CSE 240 5-16 4 ST (PC-Relative) Base + Offset Addressing Mode 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Problem ST 0 0 1 1 SR PCoffset9 • With PC-relative mode, can only address words “near” the instruction • What about the rest of memory? Register File ST R3 -81 R0 IR 0 0 1 1 0 1 1 1 1 0 1 0 1 1 1 1 R1 Solution 9 R2 • Use a register to generate a full 16-bit address R3 0000000000001001 PC 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 SEXT R4 16 R5 16 Idea R6 16 1111111110101111 R7 • 4 bits for opcode, 3 for src/dest register, 3 bits for base register • Remaining 6 bits are used as a signed offset B A • Offset is sign-extended before adding to base register ADD ALU • I.e., Instead of adding offset to PC, add it to base register MAR MEMORY MDR 16 Wr Example: LDR: R1 <- M[R2+SEXT(IR[5:0])] CSE 240 5-17 CSE 240 5-18 LDR (Base+Offset) STR (Base+Offset) 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 LDR 0 1 1 0 DR BaseR offset6 STR 0 1 1 1 SR BaseR offset6 Register File Register File LDR R3 R5 -17 R0 STR R3 R5 -17 R0 IR 0 1 1 0 0 1 1 1 0 1 1 0 1 1 1 1 IR 0 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 R1 R1 6 R2 6 R2 R3 0000000000001001 R3 0000000000001001 SEXT R4 SEXT R4 16 R5 000000001000000 16 R5 000000001000000 R6 16 R6 16 1111111111101111 R7 1111111111101111 R7 16 16 B A B A ADD ADD ALU ALU MAR MEMORY MDR MAR MEMORY MDR 16 16 Rd Wr CSE 240 5-19 CSE 240 5-20 5 Indirect Addressing Mode LDI (Indirect) Another way to produce full 16-bit address 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 • Read address from memory location, then load/store to that address LDI 1 0 1 0 DR PCoffset9 Steps Register File • Address is generated from PC and PCoffset (just like PC-relative LDI R3 -17 R0 IR 1 0 1 0 0 1 1 1 0 1 1 0 1 1 1 1 addressing) R1 9 • Then content of that address is used as address for load/store R2 R3 0000000000001001 PC 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 SEXT R4 16 16 R5 Example: LDI: R1 <- M[M[PC+SEXT(IR([8:0])] 16 R6 1111111101101111 R7 Advantage • Doesn't consume a register for base address B A 16 ADD • Addresses are often stored in memory (i.e., useful) ALU MAR MEMORY MDR Disadvantage 16 Rd • Extra memory operation (and no offset) CSE 240 5-21 CSE 240 5-22 STI (Indirect) Load Effective Address 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Problem STI 1 0 1 1 SR PCoffset9 • How can we compute address without also LD/ST-ing to it? Register File STI R3 -17 R0 Solution IR 1 0 1 1 0 1 1 1 0 1 1 0 1 1 1 1 R1 9 R2 • Load Effective Address (LEA) instruction R3 0000000000001001 PC 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 SEXT R4 16 R5 16 Idea R6 16 1111111101101111 R7 • LEA computes address just like PC-relative LD/ST • Store address in destination register (not data at that address) B A 16 ADD • Does not access memory ALU MAR MEMORY MDR 16 Rd/Wr • Example: LEA: R1 <- PC + SEXT(IR[8:0])] (Rd) (Wr) CSE 240 5-23 CSE 240 5-24 6 0001 ADD Machine Language 0011 ST 0101 AND LEA Example 0111 STR 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 1010 LDI 1110 LEA LEA 1 1 1 0 DR PCoffset9 Address Instruction Comments x30F6 1 1 1 0 0 0 1 1 1 1 1 1 1 1 0 1 R1 ← PC-3 (x30F4) Register File LEA R3 -81 R0 x30F7 0 0 0 1 0 1 0 0 0 1 1 0 1 1 1 0 R2 ← R1 + 14 = x3102 IR 1 1 1 0 0 1 1 1 1 0 1 0 1 1 1 1 R1 9 R2 x30F8 0 0 1 1 0 1 0 1 1 1 1 1 1 0 1 1 M[PC-5(x30F4)] ← R2 R3 0011111110001000 PC 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 SEXT R4 x30F9 0 1 0 1 0 1 0 0 1 0 1 0 0 0 0 0 R2 ← 0 16 R5 16 16 R6 R2 R2 + 5 = 5 1111111110101111 R7 x30FA 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 ← M[R1+14] ← R2 B A x30FB 0 1 1 1 0 1 0 0 0 1 0 0 1 1 1 0 (M[x3102] ← 5) ADD ALU R3 ← M[M[x30F4]] x30FC 1 0 1 0 0 1 1 1 1 1 1 1 0 1 1 1 (R3 ← M[x3102]) (R3 ← 5) opcode CSE 240 5-25 CSE 240 5-26 Aside: Machine Language Programming Is Hard! Control Instructions Alter the sequence of instructions • Changing the Program Counter (PC) Conditional Branch • Branch taken if a specified condition is true New PC computed relative to current PC • Otherwise, branch not taken PC is unchanged (I.e., points to next sequential instruction) Unconditional Branch (or Jump) • Always changes the PC • Target address computed PC-relative or Base+Offset TRAP (Altair 8800, 1975) • Changes PC to start of OS “service routine” • When routine is done, execution resumes after TRAP CSE 240 5-27 CSE 240 5-28 7 Condition Codes Branch Instruction LC-3 has three 1-bit condition code registers Branch specifies one or more condition codes N -- negative If the specified condition code set, the branch is taken Z -- zero • PC is set to the address specified in the instruction P -- positive (greater than zero) • Like PC-relative mode addressing, target address is specified as offset from current PC (PC + SEXT(IR[8:0])) Set/cleared by instructions that store value to register • Note: Target must be “near” branch instruction • e.g., ADD, AND, NOT, LD, LDR, LDI, LEA, not ST If branch not taken, next instruction (PC+1) is executed.
Load more

Recommended publications
  • Instruction Set Architecture
    Instruction Set Architecture EE3376 1 –Adapted from notes from BYU ECE124 Topics to Cover… l MSP430 ISA l MSP430 Registers, ALU, Memory l Instruction Formats l Addressing Modes l Double Operand Instructions l Single Operand Instructions l Jump Instructions l Emulated Instructions – http://en.wikipedia.org/wiki/TI_MSP430 2 –Adapted from notes from BYU ECE124 Levels of Transformation –Problems –Algorithms – C Instructions –Language (Program) –Programmable –Assembly Language – MSP 430 ISA –Machine (ISA) Architecture –Computer Specific –Microarchitecture –Manufacturer Specific –Circuits –Devices 3 –Adapted from notes from BYU ECE124 Instruction Set Architecture l The computer ISA defines all of the programmer-visible components and operations of the computer – memory organization l address space -- how may locations can be addressed? l addressibility -- how many bits per location? – register set (a place to store a collection of bits) l how many? what size? how are they used? – instruction set l Opcodes (operation selection codes) l data types (data types: byte or word) l addressing modes (coding schemes to access data) l ISA provides all information needed for someone that wants to write a program in machine language (or translate 4 from a high-level language to machine language). –Adapted from notes from BYU ECE124 MSP430 Instruction Set Architecture l MSP430 CPU specifically designed to allow the use of modern programming techniques, such as: – the computation of jump addresses – data processing in tables – use of high-level languages such as C. l 64KB memory space with 16 16-bit registers that reduce fetches to memory. l Implements RISC architecture with 27 instructions and 7 addressing modes.
    [Show full text]
  • X86 Instruction Set 4.2 Why Learn Assembly
    4.1 CS356 Unit 4 Intro to x86 Instruction Set 4.2 Why Learn Assembly • To understand something of the limitation of the HW we are running on • Helpful to understand performance • To utilize certain HW options that high-level languages don't allow (e.g. operating systems, utilizing special HW features, etc.) • To understand possible security vulnerabilities or exploits • Can help debugging 4.3 Compilation Process CS:APP 3.2.2 void abs(int x, int* res) • Demo of assembler { if(x < 0) *res = -x; – $ g++ -Og -c -S file1.cpp else *res = x; • Demo of hexdump } Original Code – $ g++ -Og -c file1.cpp – $ hexdump -C file1.o | more Disassembly of section .text: 0000000000000000 <_Z3absiPi>: 0: 85 ff test %edi,%edi 2: 79 05 jns 9 <_Z3absiPi+0x9> • Demo of 4: f7 df neg %edi 6: 89 3e mov %edi,(%rsi) 8: c3 retq objdump/disassembler 9: 89 3e mov %edi,(%rsi) b: c3 retq – $ g++ -Og -c file1.cpp Compiler Output – $ objdump -d file1.o (Machine code & Assembly) Notice how each instruction is turned into binary (shown in hex) 4.4 Where Does It Live • Match (1-Processor / 2-Memory / 3-Disk Drive) where each item resides: – Source Code (.c/.java) = 3 – Running Program Code = 2 – Global Variables = 2 – Compiled Executable (Before It Executes) = 3 – Current Instruction Being Executed = 1 – Local Variables = 2 (1) Processor (2) Memory (3) Disk Drive 4.5 BASIC COMPUTER ORGANIZATION 4.6 Processor • Performs the same 3-step process over and over again – Fetch an instruction from Processor Arithmetic 3 Add the memory Circuitry specified values Decode 2 It’s an ADD – Decode the instruction Circuitry • Is it an ADD, SUB, etc.? 1 Fetch – Execute the instruction Instruction System Bus • Perform the specified operation • This process is known as the ADD SUB Instruction Cycle CMP Memory 4.7 Processor CS:APP 1.4 • 3 Primary Components inside a processor – ALU – Registers – Control Circuitry • Connects to memory and I/O via address, data, and control buses (bus = group of wires) Bus Processor Memory PC/IP 0 Addr Control 0 op.
    [Show full text]
  • V850e/Ms1 , V850e/Ms2
    User’s Manual V850E/MS1TM, V850E/MS2TM 32-Bit Single-Chip Microcontrollers Architecture V850E/MS1: V850E/MS2: µPD703100 µPD703130 µPD703100A µPD703101 µPD703101A µPD703102 µPD703102A µPD70F3102 µPD70F3102A Document No. U12197EJ6V0UM00 (6th edition) Date Published November 2002 N CP(K) 1996 Printed in Japan [MEMO] 2 User’s Manual U12197EJ6V0UM NOTES FOR CMOS DEVICES 1 PRECAUTION AGAINST ESD FOR SEMICONDUCTORS Note: Strong electric field, when exposed to a MOS device, can cause destruction of the gate oxide and ultimately degrade the device operation. Steps must be taken to stop generation of static electricity as much as possible, and quickly dissipate it once, when it has occurred. Environmental control must be adequate. When it is dry, humidifier should be used. It is recommended to avoid using insulators that easily build static electricity. Semiconductor devices must be stored and transported in an anti-static container, static shielding bag or conductive material. All test and measurement tools including work bench and floor should be grounded. The operator should be grounded using wrist strap. Semiconductor devices must not be touched with bare hands. Similar precautions need to be taken for PW boards with semiconductor devices on it. 2 HANDLING OF UNUSED INPUT PINS FOR CMOS Note: No connection for CMOS device inputs can be cause of malfunction. If no connection is provided to the input pins, it is possible that an internal input level may be generated due to noise, etc., hence causing malfunction. CMOS devices behave differently than Bipolar or NMOS devices. Input levels of CMOS devices must be fixed high or low by using a pull-up or pull-down circuitry.
    [Show full text]
  • UNIT 2 Q.1 Explain Addressing Modes of PIC Microcontroller. the PIC 18 Microcontroller Supports Following Addressing Modes. 1. Immediate Addressing Mode 2
    UNIT 2 Q.1 Explain addressing modes of PIC microcontroller. The PIC 18 microcontroller supports following addressing modes. 1. Immediate addressing mode 2. Direct addressing mode 3. Register addressing mode 4. Indexed ROM addressing mode 1. Immediate addressing mode: In immediate addressing mode, the immediate data is specified in the instruction. The immediate addressing mode is used to load the data into PIC registers and WREG register. However, it cannot use to load data into any of the file register. Example: 1. MOVLW 50H 2. ANDLW 40H 3. IORLW 60H 2. Direct addressing mode: In direct addressing mode, the 8- bit data in RAM memory location whose address is specified in the instruction. This mode is used for accessing the RAM file register. Example: 1. MOVWF 0X10 2. MOVFF PORTB, POTRC 3. MOVFF 0X30, PORTC 3. Register indirect addressing mode: Register indirect addressing mode is used for accessing data stored in the RAM part of file register. In this addressing mode a register is used as pointer to the memory location of the file register. Three file select registers are used. They are FSR0, FSR1 and FSR2. Example: 1. LFSR1,0X55 2. MOVWF INDF2 4. Indexed ROM addressing mode: This addressing mode is used for accessing the data from look up tables that reside in the PIC18 program ROM. Q.2 Explain following instructions: 1. ADDLW ADD literal to W Syntax: ADDLW k Operands: 0 ≤ k ≤ 255 Operation: (WREG) + k → WREG Status Affected: N, OV, C, DC, Z Description: The contents of WREG are added to the 8-bit literal ’k’ and the result is placed in WREG.
    [Show full text]
  • Addressing Modes of Computer - Ii
    ADDRESSING MODES OF COMPUTER - II INDEXING AND ARRAYS:- A different kind of flexibility for accessing operands is useful in dealing with lists and arrays. Index mode – the effective address of the operand is generated by adding a constant value to the contents of a register. The register use may be either a special register provided for this purpose, or, more commonly, it may be any one of a set of general-purpose registers in the processor. In either case, it is referred to as index register. We indicate the Index mode symbolically as X (Ri) Where X denotes the constant value contained in the instruction and Ri is the name of the register involved. The effective address of the operand is given by EA = X + [Rj] The contents of the index register are not changed in the process of generating the effective address. In an assembly language program, the constant X may be given either as an explicit number or as a symbolic name representing a numerical value. Fig a illustrates two ways of using the Index mode. In fig a, the index register, R1, contains the address of a memory location, and the value X defines an offset (also called a displacement) from this address to the location where the operand is found. An alternative use is illustrated in fig b. Here, the constant X corresponds to a memory address, and the contents of the index register define the offset to the operand. In either case, the effective address is the sum of two values; one is given explicitly in the instruction, and the other is stored in a register.
    [Show full text]
  • Module 1 Introduction
    MODULE 1 TOPICS COVERED:- 1. Introduction to the general concept of microprocessor 2. I/O subsystem , programming the system 3. ALU 4. Instruction execution, instruction word format 5. Addressing modes 6. Address/data/control bus 7. Tristate bus 8. Interfacing i/o device 9. Data transfer scheme 10. Architectural advancement of microprocessor 11. Evolution of processor INTRODUCTION A computer basically consists of the following parts:- 1. I/O devices 2. Memory 3. CPU The CPU is the brain of the computer irrespective of its size. The CPU normally consists of a large scale integrationcircuit called Microprocessor and works as central processing unit of a microcomputer. Input Devices give data or information as an input to the CPU and it processes the data or information given by the devices. Memory stores the data or information, Output Devices give the required data as output to the user. A digital component in which one microprocessor has been provided to act as a CPU is known as Microcomputer. Desktop computer, laptop computer, palm computer, notebook are the ones which contain only one microprocessor to act as a CPU. Microprocessor:- Definition- A microprocessor is a multipurpose programmable, clock driven, semiconductor device consisting of electronic logic circuit manufactured by using very large scale integration (VLSI) technique. • The Microprocessor is capable of performing various computing functions and making decisions to change the sequence of program executions. • The microprocessor application are classified primarily into two categories:- 1. Reprogrammable systems 2. Embedded System • Microprocessor can perform the following operations:- 1. Read data from memory 2. Write data into memory 3.
    [Show full text]
  • COSC 6385 Computer Architecture Instruction Set Architectures
    COSC 6385 Computer Architecture Instruction Set Architectures Edgar Gabriel Spring 2011 Edgar Gabriel Instruction Set Architecture (ISA) • Definition on Wikipedia: “Part of the Computer Architecture related to programming” • Defines – set of operations, – instruction format, – hardware supported data types, – named storage, – addressing modes, – sequencing • Includes a specification of the set of opcodes (machine language) - native commands implemented by a particular CPU design COSC 6385 – Computer Architecture Edgar Gabriel Instruction Set Architecture (II) • ISA to be distinguished from the micro-architecture – set of processor design techniques used to implement an ISA • Example: Intel Pentium and AMD Athlon support a nearly identical ISA, but have completely different micro-architecture COSC 6385 – Computer Architecture Edgar Gabriel ISA Specification • Relevant features for distinguishing ISA’s – Internal storage – Memory addressing – Type and size of operands – Operations – Instructions for Flow Control – Encoding of the IS COSC 6385 – Computer Architecture Edgar Gabriel Internal storage • Stack architecture: operands are implicitly on the top of the stack • Accumulator architecture: one operand is implicitly the accumulator • General purpose register architectures: operands have to be made available by explicit load operations – Dominant form in today’s systems COSC 6385 – Computer Architecture Edgar Gabriel Internal storage (II) • Example: C= A+B Stack: Accumulator: Load-Store: Push A Load A Load R1,A Push B Add B Load R2,B Add
    [Show full text]
  • Cpe 323 Instruction Set Architecture: an Introduction
    CPE 323 INSTRUCTION SET ARCHITECTURE: AN INTRODUCTION Aleksandar Milenkovic Computers cannot execute high-level language constructs like ones found in C. Rather they execute a relatively small set of machine instructions, such as addition, subtraction, Boolean operations, and data transfers. The statements from high-level language are translated into sequences of machine code instructions by a compiler. A machine code instruction is represented by a binary string which is hard to be read by humans. A human-readable form of the machine code is assembly language. However, assembly language may also include some constructs that serve only to help programmers write a better and more efficient code, faster. These constructs may translate into a sequence of machine code instructions. Instruction set architecture, or ISA for short, refers to a portion of a computer that is visible to low-level programmers, such as assembly language programmers or compiler writers. It is an abstract view of the computer describing what it does rather than how it does. Note: computer organization describes how the computer achieves the specified functionality is out of scope in this course. The ISA aspects include (a) class of ISA, (b) memory model, (c) addressing modes, (d) types and sizes of operands, (e) data processing and control flow operations supported by machine instructions, and (f) instruction encoding. Class of ISA. Virtually all recent instruction set architectures have a set of general- purpose registers visible to programmers. These architectures are known as general- purpose register architectures. Machine instructions in these architectures specify all operands in memory or general-purpose registers explicitly.
    [Show full text]
  • Addressing Mode
    Central Processing Unit Addressing modes Numerical example Immediate Mode Indirect Mode Indexing Mode Relative Mode The addressing mode specifies a rule for interpreting or modifying the address field of the instruction before the operand is actually executed. Computers use addressing mode techniques for the purpose of accommodating one of the following provisions: 1. To give programming versatilities to the user to be more flexible. 2. To reduce the number of bits in the addressing field of the instruction. In some some computers, the addressing mode of the instruction is specified with distinct binary code. Instruction format with mode field Opcode Mode Address 3 Other computers use a single binary for operation & Address mode. The mode field is used to locate the operand. Address field may designate a memory address or a processor register. There are 2 modes that need no address field at all (Implied & immediate modes). 4 The most well known addressing mode then are: Implied mode. Immediate mode Register mode Register Indirect mode Auto-increment or Auto-decrement mode Direct Mode Indirect Mode Relative Address Mode Index Addressing Mode 5 PC=200 R1=400 Address Memory XR=100 AC 200 Load to AC Mode 201 Address=500 202 Next Instruction Addressing mode eff. Add Content of AC ----------------------------------------------------------- 399 450 Direct Address 500 800 400 700 Immediate operand 201 500 Indirect Address 800 300 500 800 Relative Address 702 (PC=PC+2) 325 Indexes Address 600 (XR+500) 900 600 900 Register --- 400 702 325 Register Indirect 400 700 Auto-increment 400 700 800 300 Auto-decrement 399 450 Tabular list 6 Different ways in which the address of an operand in specified in an instruction is referred to as addressing modes.
    [Show full text]
  • VAX MACRO and Instruction Set Reference Manual
    VAX MACRO and Instruction Set Reference Manual Order Number: AA–PS6GD–TE April 2001 This document describes the features of the VAX MACRO instruction set and assembler. It includes a detailed description of MACRO directives and instructions, as well as information about MACRO source program syntax. Revision/Update Information: This manual supersedes the VAX MACRO and Instruction Set Reference Manual, Version 7.1 Software Version: OpenVMS VAX Version 7.3 Compaq Computer Corporation Houston, Texas © 2001 Compaq Computer Corporation Compaq, VAX, VMS, and the Compaq logo Registered in U.S. Patent and Trademark Office. OpenVMS is a trademark of Compaq Information Technologies Group, L.P. in the United States and other countries. All other product names mentioned herein may be trademarks of their respective companies. Confidential computer software. Valid license from Compaq required for possession, use, or copying. Consistent with FAR 12.211 and 12.212, Commercial Computer Software, Computer Software Documentation, and Technical Data for Commercial Items are licensed to the U.S. Government under vendor’s standard commercial license. Compaq shall not be liable for technical or editorial errors or omissions contained herein. The information in this document is provided "as is" without warranty of any kind and is subject to change without notice. The warranties for Compaq products are set forth in the express limited warranty statements accompanying such products. Nothing herein should be construed as constituting an additional warranty. ZK4515 The Compaq OpenVMS documentation set is available on CD-ROM. This document was prepared using DECdocument, Version 3.3-1b. Contents Preface ............................................................ xv VAX MACRO Language 1 Introduction 2 VAX MACRO Source Statement Format 2.1 Label Field .
    [Show full text]
  • Appendix E Another Alternative to RISC: the VAX Architecture
    E.1 Introduction E-2 E.2 VAX Operands and Addressing Modes E-2 E.3 Encoding VAX Instructions E-5 E.4 VAX Operations E-6 E.5 An Example to Put It All Together: swap E-10 E.6 A Longer Example: sort E-13 E.7 Fallacies and Pitfalls E-18 E.8 Concluding Remarks E-19 E.9 Historical Perspective and Further Reading E-20 Exercises E-21 E Another Alternative to RISC: The VAX Architecture In principle, there is no great challenge in designing a large virtual address minicomputer system. The real challenge lies in two areas: compatibility—very tangible and important; and simplicity— intangible but nonetheless important. William Strecker “VAX-11/780—A Virtual Address Extension to the PDP-11 Family,” AFIPS Proc., National Computer Conference, 1978. Entities should not be multiplied unnecessarily. William of Occam Quodlibeta Septem, 1320 (This quote is known as “Occam’s Razor.”) © 2003 Elsevier Science (USA). All rights reserved. E-2 I Appendix E Another Alternative to RISC: The VAX Architecture E.1 Introduction To enhance your understanding of instruction set architectures, we chose the VAX as the representative Complex Instruction Set Computers (CISC) because it is so different from MIPS and yet still easy to understand. By seeing two such divergent styles, we are confident that you will be able to learn other instruction sets on your own. At the time the VAX was designed, the prevailing philosophy was to create instruction sets that were close to programming languages in order to simplify compilers. For example, because programming languages had loops, instruction sets should have loop instructions.
    [Show full text]
  • Addressing Mode 1 Addressing Mode
    Addressing mode 1 Addressing mode Addressing modes are an aspect of the instruction set architecture in most central processing unit (CPU) designs. The various addressing modes that are defined in a given instruction set architecture define how machine language instructions in that architecture identify the operand (or operands) of each instruction. An addressing mode specifies how to calculate the effective memory address of an operand by using information held in registers and/or constants contained within a machine instruction or elsewhere. In computer programming, addressing modes are primarily of interest to compiler writers and to those who write code directly in assembly language. Caveats Note that there is no generally accepted way of naming the various addressing modes. In particular, different authors and computer manufacturers may give different names to the same addressing mode, or the same names to different addressing modes. Furthermore, an addressing mode which, in one given architecture, is treated as a single addressing mode may represent functionality that, in another architecture, is covered by two or more addressing modes. For example, some complex instruction set computer (CISC) computer architectures, such as the Digital Equipment Corporation (DEC) VAX, treat registers and literal/immediate constants as just another addressing mode. Others, such as the IBM System/390 and most reduced instruction set computer (RISC) designs, encode this information within the instruction. Thus, the latter machines have three distinct instruction codes for copying one register to another, copying a literal constant into a register, and copying the contents of a memory location into a register, while the VAX has only a single "MOV" instruction.
    [Show full text]