1 / 35

Assembly Language Sparc CPU Architecture Overview

Learn about the Sparc CPU architecture design by John von Neumann in 1949, with details on assembly language, machine organization, registers, instruction cycles, and basic instructions. Understand the key components and execution process of the architecture, including the role of ALU, data handling, and instruction execution cycles. Dive into Sparc's 32 registers, their organization, and specific functionalities for different operations. Explore the assembly language syntax, instruction formats, operand types, and program structure. Discover how Sparc assembly instructions operate in a load/store architecture.

kmoritz
Download Presentation

Assembly Language Sparc CPU Architecture Overview

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Sparc Architecture Overview Assembly Language

  2. Von Neumann Architecture • Designed by John von Neumann in 1949. • Machine = CPU + Memory • Program is stored in memory along with data. • CPU has Program Counter (PC) and Instruction Register (IR) • Use PC to keep the current location of instruction being executed. Assembly Language

  3. Von Neumann Architecture • Control unit fetches an instruction from memory (located by PC) and stores in IR. • Memory = Memory Address Register (MAR) + Memory Data Register (MDR) • CPU puts an address in MAR and load/store from/to MDR. Assembly Language

  4. Machine Organization Diagram Assembly Language

  5. Instruction Execution • Fetch-Decode-Execute cycles: • Fetch the next instruction from memory. • Change PC to point to next instruction. • Determine the type of the instruction fetched. • Find where the data being used by the instruction is kept. • Fetch the data, if required. • Execute the instruction. • Store the results in the appropriate place. • Go to step 1 and start all over again. Assembly Language

  6. Instruction Cycles pc = 0; do { ir := memory[pc]; { Fetch the instruction. } pc := pc + INSTR_SIZE; { Move PC to next instruction. } decode(ir); { Decode the instruction. } fetch(operands); { Fetch the operands. } execute; { Execute the instruction. } store(results); { store the results. } } while(ir != HALT); Assembly Language

  7. Sparc Architecture Overview • Load/Store architecture • ALU cannot access data from memory directly. • Data must be loaded into registers before computing. • RISC (Reduced Instruction Set Computer) architecture • All instructions are one word (32 bits). • 5-stage Pipelining CPU. Assembly Language

  8. Sparc Registers • There are 32 registers (%r0 - %r31). • Each register is 64-bit for UltraSparc (128-bit for UltraSparc III). • Registers are logically divided into 4 sets:global (%gx), in (%ix), local (%lx), and out (%ox). • All registers are equal, can perform any operations. • Special register: %g0 (%r0) - always discards writes and return zero. Assembly Language

  9. Global %g0 %r0 readonly / return zero %g1 %r1 %g2 %r2 %g3 %r3 %g4 %r4 %g5 %r5 %g6 %r6 %g7 %r7 Output %o0 %r8 %o1 %r9 %o2 %r10 %o3 %r11 %o4 %r12 %o5 %r13 %o6 %r14 %sp stack pointer %o7 %r15 called sub ret addr Sparc Registers Assembly Language

  10. Local %l0 %r16 %l1 %r17 %l2 %r18 %l3 %r19 %l4 %r20 %l5 %r21 %l6 %r22 %l7 %r23 Input %i0 %r24 %i1 %r25 %i2 %r26 %i3 %r27 %i4 %r28 %i5 %r29 %i6 %r30 %fp frame pointer %i7 %r31 sub return addr Sparc Registers Assembly Language

  11. Format of Instructions • Any instruction is made up of two parts: • Opcode (the name of the instruction) • Operands (the values or data manipulated by the instruction) -- can be omitted. L1: add %i2, 0x80, %o1 ! Add two numbers label opcode operands comment Assembly Language

  12. Label • Define the location of data or instruction. • Start with: letter (A-Z and a-z), _, $, or . • Followed by: letter (A-Z and a-z), number (0-9), _, $, or . • Must end with color (:). Assembly Language

  13. Operands • Most instructions have three operands: • three registersop reg, reg, regadd %g1, %i2, %g2 ! G2 is the destination. • two registers and a literal constantop reg, imm, regadd %o1, 30, %o2 ! O2 is the destination. • two registersop reg, regmov %o4, %l3 ! L3 is the destination. Assembly Language

  14. Operands • a constant and a registerop imm, regmov 453, %g1 ! G1 is the destination. • a registerop regclr %l2 • a constantop immcall myfunc • Notice: • Last one is usually the destination. Assembly Language

  15. Constant in Operand • Constant (imm) must be 13-bit signed number: -4096 <= imm < 4096 • Format of constant ??? Assembly Language

  16. Comment • Inline comment (!): • ignore to the end of line. ! Inline comment here. Ignore to end of line. • C-style comment (/* … */): • ignore anything between the comment markers. /* comment here and it can be multiple line. */ Assembly Language

  17. Our First Program • Let try some simple C program (but nothello world !). /* first.c -- not hello world ! as usual */ main() { int x, y; x = 9; y = (x - 2)*(x + 14)/(x + 1); printf(“x = %d, y = %d\n”, x, y); } Assembly Language

  18. printf Function var1 printf(“x = %d, y = %d\n”, x, y); • Display information formatted by the first string. • Format: %d = integer %s = string %f = floating point \n = newline format var2 Assembly Language

  19. gcc -S first.c generate first.s .file "first.c" gcc2_compiled.: .global .umul .global .div .section ".rodata" .align 8 .LLC0: .asciz "x = %d and y = %d\n" .section ".text" .align 4 .global main .type main,#function .proc 04 main: !#PROLOGUE# 0 save %sp, -120, %sp !#PROLOGUE# 1 mov 9, %o0 st %o0, [%fp-20] ld [%fp-20], %o1 add %o1, -2, %o0 ld [%fp-20], %o2 add %o2, 14, %o1 call .umul, 0 nop ld [%fp-20], %o2 add %o2, 1, %o1 call .div, 0 ... Our First Program Assembly Language

  20. Sparc Basic Assembly Instructions • Load/Store Operations mov 75, %o2 ! %o2 = 75 mov %o2, %i3 ! %i3 = %o2 clr %l4 ! %l4 = 0 • Arithmetics add %o1, %l2, %l3 ! %l3 = %o1 + %l2 add %o3, 19, %g4 ! %g4 = %o3 + 19 sub %i0, %g2, %o5 ! %o5 = %i0 + %g2 Assembly Language

  21. Sparc Basic Assembly Instructions • Multiply / Divide • To multiply: 24 * %i2 mov 24, %o0 ! First operand mov %i2, %o1 ! Second operand call .mul ! Result stored in %o0 nop ! Delay slot, discussed later ! %o0 := %o0 * %o1 • To divide: %o2 / %g3 mov %o2, %o0 ! First operand mov %g3, %o1 ! Second operand call .div ! Result stored in %o0 nop ! Delay slot, discussed later ! %o0 = %o0 / %o1 Assembly Language

  22. Our First Program (Revisited) /* first.m */ /* * This programs compute: * y = (x - 2) * (x + 14) / (x + 8) * for x = 9 */ /* use %l0 and %l1 to store x and y */ define(x_r, l0) define(y_r, l1) /* define constants */ define(c1, 2) Assembly Language

  23. Our First Program (Revisited) fmt: .asciz "x = %d and y = %d\n" .align 4 .global main main: save %sp, -64, %sp mov 9, %x_r ! x = 9 sub %x_r, c1, %o0 ! %o0 = x - 2 add %x_r, 14, %o1 ! %o1 = x + 14 call .mul ! %o0 = %o0 * %o1 nop add %x_r, 1, %o1 ! %o1 = x + 1 call .div ! %o0 = %o0 / %o1 nop mov %o0, %y_r ! store result in y Assembly Language

  24. Our First Program (Revisited) set fmt, %o0 ! first argument for printf mov %x_r, %o1 ! second argument for printf mov %y_r, %o2 ! third argument for printf call printf ! print them out nop mov 1, %g1 ! prepare to exit ta 0 ! normal exit Assembly Language

  25. Directives • Information for the assembler. • .global - tell the assembler the name of this function. • .asciz - define a string. • .align - align a location counter on a boundary. Assembly Language

  26. Creating Executable File • Use M4 macro-processor m4 < first.m > first.s (M4 produces first.s. Notice macro expansion.) • Compile first.s gcc -S first.s -o first (this produces an executable file “first”.) Assembly Language

  27. Running our First Program • Run first first x = 9 and y = 16 • Using printf to trace a program is not convenient. Assembly Language

  28. The gdb Debugger • To check the result, we will use a debugger. • Run: gdb <filename> gdb first (gdb) • Run your program: (gdb)r Starting program: /usr3/faculty/natawut/Class/Assembly/first ... Program exited with code 011. (gdb) Assembly Language

  29. Breakpoint • Set a breakpoint: (gdb) b main Breakpoint 1 at 0x105a4 (gdb) r Starting program: /usr3/faculty/natawut/Class/Assembly/first ... Breakpoint 1, 0x105a4 in main () (gdb) Assembly Language

  30. Print an Instruction (gdb) x/i $pc 0x105a4 <main+4>: mov 9, %l0 (gdb) 0x105a8 <main+8>: sub %l0, 2, %o0 (gdb) • We can examine memory by typing “x”. • Tell gdb to interpret the current memory as an instruction. • Use current location pointed by %pc. • Repeat last command by hitting enter key. Assembly Language

  31. Print the Entire Program (gdb) disassemble Dump of assembler code for function main: 0x105a0 <main>: save %sp, -64, %sp 0x105a4 <main+4>: mov 9, %l0 0x105a8 <main+8>: sub %l0, 2, %o0 0x105ac <main+12>: add %l0, 0xe, %o1 0x105b0 <main+16>: call 0x2069c <.mul> 0x105b4 <main+20>: nop ... 0x105d4 <main+52>: add %o7, %l7, %l7 End of assembler dump. (gdb) Assembly Language

  32. More Debugging Commands • Advance breakpoint: (gdb) b *& main+16 Breakpoint 3 at 0x105cc (gdb) c Continuing. Breakpoint 3, 0x105cc in main () (gdb) • We use “c” to continue execution after stopping at a breakpoint. Assembly Language

  33. More Debugging Commands • Print out the contents of a register: (gdb) p $l0 $1 = 9 (gdb) • Automatically print out contents: (gdb) display/i $pc 1: x/i $pc 0x105a4 <main+4>: mov 9, %l0 (gdb) r The program being debugged has been started already. Start it from the beginning? (y or n) y Starting program: /usr3/faculty/natawut/Class/Assembly/first Assembly Language

  34. More Debugging Commands Breakpoint 2, 0x105a4 in main () 1: x/i $pc 0x105a4 <main+4>: mov 9, %l0 (gdb) ni 0x105a8 in main () 1: x/i $pc 0x105a8 <main+8>: sub %l0, 2, %o0 (gdb) • We use “r” to restart execution from the beginning and “ni” to execute the next instruction. Assembly Language

  35. More Debugging Commands • For other commands, try: help • To exit from gdb: q Assembly Language

More Related