Lecture 04: Instruction Set Principles

1. Lecture 04: Instruction SetPrinciples Kai Bu kaibu@zju.edu.cn http://list.zju.edu.cn/kaibu/comparch2016

2. Appendix A.1-A.9

3. Preview • What’s instruction set architecture? • How do instructions operate? • How do instructions find operands? • How do programs turn to instructions? • How do hardware understand instructions?

4. What’s ISA?(Instruction Set Architecture)

5. ISA: Instruction Set Architecture Programmer-visible instruction set

6. ISA: Instruction Set Architecture Programmer-visible instruction set not what’s underneath

7. What types of ISA?

8. ISA Classification Basis • the type of internal storage: stack accumulator register

9. ISA Classes • stack architecture • accumulator architecture • general-purpose register architecture (GPR)

10. ISA Classes:Stack Architecture • implicit operands on the Top Of the Stack (TOS) • C = A + B Push A Push B Add Pop C First operand removed from stack Second op replaced by the result memory

11. ISA Classes:Accumulator Architecture • one implicit operand: the accumulator one explicit operand: mem location • C = A + B Load A Add B Store C accumulator is both an implicit input operand and a result memory

12. ISA Classes:General-Purpose Register Arch • Only explicit operands registers memory locations • Operand access: direct memory access loaded into temporary storage first

13. ISA Classes:General-Purpose Register Arch Two Classes: • register-memory architecture any instruction can access memory • load-store architecture only load and store instructions can access memory

14. GPR: Register-Memory Arch • register-memory architecture any instruction can access mem • C = A + B Load R1, A Add R3, R1, B Store R3, C R3 A R1 B memory

15. GPR: Load-Store Architecture • load-store architecture only load and store instructions can access memory • C = A + B Load R1, A Load R2, B Add R3, R1, R2 Store R3, C A+B R3 B R2 A R1 memory

16. GPR Classification • ALU instruction has 2 or 3 operands? 2 = 1 result&source op + 1 source op 3 = 1 result op + 2 source op • ALU instruction has 0, 1, 2, or 3 operands of memory address?

17. GPR Classification • Three major classes Register-register

18. GPR Classification

19. Where to find operands?

20. Interpret Memory Address • Byte addressing byte – 8 bits half word – 16 bits words – 32 bits double word – 64 bits

21. Operand Type and Size

22. Interpret Memory Address • Byte ordering in memory: 0x12345678 Little Endian: store least significant byte in the smallest address 78 | 56 | 34 | 12 Big Endian: store most significant byte in the smallest address 12 | 34 | 56 | 78

23. Interpret Memory Address • Address alignment object width: s bytes address: A aligned if A mod s = 0

24. Interpret Memory Address • Address alignment object width: s bytes address: A aligned if A mod s = 0 Why to align addresses?

25. Each misaligned object requires two memory accesses

26. Addressing Modes • How instructions specify addresses of objects to access • Types constant register memory location – effective address

27. frequently used tricky one Addressing Modes

28. How to operate operands?

29. Operations

30. Simple Operationsare the most widely executed

31. Control Flow Instructions • Four types of control flow change: Conditional branches – most frequent Jumps Procedure calls Procedure returns

32. Control Flow: Addressing • Explicitly specified destination address (exception: procedure return as target is not known at compile time) • PC-relative destination addr = PC + displacement • Dynamic address: for returns and indirect jumps with unknown target at compile time e.g., name a register that contains the target address

33. Conditional Branch Options http://www.ece.mtu.edu/ee/faculty/cchigan/EE3170/EE%203170%20Lecture%207-Branches.pdf

34. Procedure Invocation Options • Control transfer + State saving • Return address must be saved in a special link register or just a GPR How to save registers?

35. Procedure Invocation Options:Save Registers • Caller Saving the calling procedure saves the registers that it wants preserved for access after the call • Callee Saving the called procedure saves the registers it wants to use

36. How do hardware understand instructions?

37. Encoding an ISA • Opcode for specifying operations • Address Specifier for specifying the addressing mode to access operands

38. Encoding an ISA • Fixed length: ARM, MIPS – 32 bits • Variable length: 80x86 – 1~18 bytes http://en.wikipedia.org/wiki/MIPS_architecture Start with a 6-bit opcodethat specifies the operation.R-type: three registers, a shift amount field, and a function field; I-type: two registers,a 16-bit immediate value; J-type: a 26-bit jump target.

39. Encoding an ISA • Balance several competing forces for encoding: 1. desire to have more registers and addressing modes; 2. impact of the size of register and addressing mode fields on the average instruction/program size 3. desire to encode instructions into lengths easy for pipelining

40. Encoding an ISA Variable allows all addressing modes to be with all operations Fixed combines the operation and addressing mode into the opcode Hybrid reduces the variability in size and work of the variable arch but provides multiple instruction lengths to reduce code size

41. How do programsturn to instructions?

42. Program Compiler Instructions

43. The Role of Compilers • compile desktop and server apps programmed in high-level languages; • Output instructions that can be executed by hardware; • significantly affect the performance of a computer;

44. Compiler Structure

45. Compiler Goals • Correctness all valid programs must be compiled correctly • Speed of the compiled code • Others fast compilation debugging support interoperability among languages

46. Compiler Optimizations • High-level optimizations are done on the source with output fed to later optimization passes • Local optimizations optimize code only within a straight-line code fragment (basic block) • Global optimizations optimize across branches and transform for optimizing loops • Register allocation associates registers with operands • Processor-dependent optimizations leverage specific architectural knowledge

47. Compiler Optimizations: Examples

48. Data/Register Allocation Where high-level languages allocate data • Stack: for local variable • Global data area: statically declared objects, e.g., global variable, constant • Heap: for dynamic objects Register allocation is much more effective for stack-allocated objects for global variables; Register allocation is essentially impossible for heap-allocated objects because they are accessed with pointers;

49. Compiler Writer’s Principles • Make the frequent cases fast and the rare case correct • Driven by instruction set properties

50. Compiler Writer’s Principles • Provide regularity keep primary components of an instruction set (operations, data types, addressing modes) orthogonal/independent • Provide primitives, not solutions • Simplify trade-offs among alternatives instruction size, total code size, register allocation (in register-memory arch, how many times a variable should be referenced before it is cheaper to load it into a register) • Provide instructions that bind the quantities known at compile time as constants instead of processor interpreting at runtime a value that was known at compile time