last time Exam Review on the homework on office hour locations hardware description language programming language that compiles to circuits

Transcription

1 last time Exam Review hardware description language programming language that compiles to circuits stages as conceptual division not the order things happen easier to figure out wiring stage-by-stage? 1 2 on office hour locations on the homework can use multiple statements and temporary variables only arithmetic shifts available 3 4

2 on this week s quiz 5 6 layers of abstraction interlude: powers of two x += y add %rbx, %rax SIXTEEN Higher-level language: C Assembly: X6-64 Machine code: Y6??? Gates / Transistors / Wires / Registers K (or Ki) M (or Mi) G (or Gi)

3 processors and memory endianness processor memory Images: Single core Opteron xx die: Dg2fer at the German language Wikipedia, via Wikimedia Commons SDRAM by Arnaud 25, via Wikimedia Commons 7 address FFFFFFF FFFFFFE FFFFFFD 0x x x x x x x x00041FFF 0x00041FFE 0x x x value 0x14 0x45 0xDE 0x06 0x05 0x04 0x03 0x02 0x01 0x00 0x03 0x60 E 0xE0 0xA0 int *x = (int*)0x42000; cout << *x << endl; endianness endianness address FFFFFFF FFFFFFE FFFFFFD 0x x x x x x x x00041FFF 0x00041FFE 0x x x value 0x14 0x45 0xDE 0x06 0x05 0x04 0x03 0x02 0x01 0x00 0x03 0x60 E 0xE0 0xA0 int *x = (int*)0x42000; cout << *x << endl; address FFFFFFF FFFFFFE FFFFFFD 0x x x x x x x x00041FFF 0x00041FFE 0x x x value 0x14 0x45 0xDE 0x06 0x05 0x04 0x03 0x02 0x01 0x00 0x03 0x60 E 0xE0 0xA0 int *x = (int*)0x42000; cout << *x << endl; 0x = x = 66051

4 endianness endianness address FFFFFFF FFFFFFE FFFFFFD 0x x x x x x x x00041FFF 0x00041FFE 0x x x value 0x14 0x45 0xDE 0x06 0x05 0x04 0x03 0x02 0x01 0x00 0x03 0x60 E 0xE0 0xA0 int *x = (int*)0x42000; cout << *x << endl; 0x = little endian (least significant byte has lowest address) 0x = big endian (most significant byte has lowest address) address FFFFFFF FFFFFFE FFFFFFD 0x x x x x x x x00041FFF 0x00041FFE 0x x x value 0x14 0x45 0xDE 0x06 0x05 0x04 0x03 0x02 0x01 0x00 0x03 0x60 E 0xE0 0xA0 int *x = (int*)0x42000; cout << *x << endl; 0x = little endian (least significant byte has lowest address) 0x = big endian (most significant byte has lowest address) what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9 what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9

5 what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9 what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9 what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9 what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9

6 what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9 what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9 what s in those files? hello.c #include <stdio.h> int main(void) { puts("hello, World!"); urn 0; hello.o text (code) segment: 4 3 EC 0 BF E C0 4 3 C4 0 C3 data segment: C 6C 6F 2C F 72 6C 00 relocations: take 0s at and replace with text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symbol table: main text byte 0 hello.s.text main: sub $, mov $.Lstr, %rdi call puts xor %eax, %eax add $,.data.lstr:.string "Hello, World!" + stdio.o hello.exe (actually binary, but shown as hexadecimal) 4 3 EC 0 BF A E 0 4A C0 4 3 C4 0 C3 (code from stdio.o) C 6C 6F 2C F 72 6C 00 (data from stdio.o) 9 hello.s.lc0: main:.section.string "Hello, World!".text.globl main subq movl call movl addq $, $.LC0, %edi puts $0, %eax $,.rodata.str1.1,"ams",@progbi 10

7 hello.o hello.o: file format elf64-x6-64 pointer arithmetic read-only data 'H''e''l''l''o'' ''W''o''r''l''d''!''\0' SYMBOL TABLE: g F.text mai *UND* put RELOCATION RECORDS FOR [.text]: OFFSET TYPE VALUE R_X6_64_32.rodata.str a R_X6_64_32 puts-0x hello + 0 0x4005C0 hello + 5 0x4005C5 * (hello + 0) is 'H' *(hello + 5) is ' ' hello[0] is 'H' hello[5] is ' ' Contents of section.text: ec0 bf e b00 H c40c3 H pointer arithmetic read-only data 'H''e''l''l''o'' ''W''o''r''l''d''!''\0' pointer arithmetic read-only data 'H''e''l''l''o'' ''W''o''r''l''d''!''\0' hello + 0 hello + 5 hello + 0 hello + 5 0x4005C0 0x4005C5 0x4005C0 0x4005C5 * (hello + 0) is 'H' *(hello + 5) is ' ' hello[0] is 'H' hello[5] is ' ' * (hello + 0) is 'H' *(hello + 5) is ' ' hello[0] is 'H' hello[5] is ' ' 12 12

8 some lists short sentinel = -9999; short *x; x = malloc(sizeof(short)*4); x[3] = sentinel; x x[0] x[1] x[2] x[3] some lists short sentinel = -9999; short *x; x = malloc(sizeof(short)*4); x[3] = sentinel; on stack or regs x on heap x[0] x[1] x[2] x[3] typedef struct range_t { unsigned int length; short *ptr; range; range x; x.length = 3; x.ptr = malloc(sizeof(short)*3); x len: 3 ptr: typedef struct range_t { unsigned int length; short *ptr; range; range x; x.length = 3; x.ptr = malloc(sizeof(short)*3); x len: 3 ptr: typedef struct node_t { short payload; list *next; node; node *x; x = malloc(sizeof(node_t)); x *x payload: 1 ptr: typedef struct node_t { short payload; list *next; node; node *x; x = malloc(sizeof(node_t)); x *x payload: 1 ptr: AT&T syntax in one slide AT&T syntax example (1) destination last () means value in memory disp(base, index, scale) same as memory[disp + base + index * scale] omit disp (defaults to 0) and/or omit base (defaults to 0) and/or scale (defualts to 1) $ means constant plain number/label means value in memory movq $42, (%rbx) // memory[rbx] 42 destination last ()s represent value in memory constants start with $ registers start with % q ( quad ) indicates length ( bytes) l: 4; w: 2; b: 1 sometimes can be omitted 14 15

9 AT&T syntax example (1) AT&T syntax example (1) movq $42, (%rbx) // memory[rbx] 42 destination last ()s represent value in memory constants start with $ registers start with % q ( quad ) indicates length ( bytes) l: 4; w: 2; b: 1 sometimes can be omitted 15 movq $42, (%rbx) // memory[rbx] 42 destination last ()s represent value in memory constants start with $ registers start with % q ( quad ) indicates length ( bytes) l: 4; w: 2; b: 1 sometimes can be omitted 15 AT&T syntax example (1) AT&T syntax example (1) movq $42, (%rbx) // memory[rbx] 42 destination last ()s represent value in memory constants start with $ registers start with % q ( quad ) indicates length ( bytes) l: 4; w: 2; b: 1 sometimes can be omitted 15 movq $42, (%rbx) // memory[rbx] 42 destination last ()s represent value in memory constants start with $ registers start with % q ( quad ) indicates length ( bytes) l: 4; w: 2; b: 1 sometimes can be omitted 15

10 closer look: condition codes (2) closer look: condition codes (3) // 2**63-1 movq $0x7FFFFFFFFFFFFFFF, %rax // 2**63 (unsigned); -2**63 (signed) movq $0x , %rbx cmpq %rax, %rbx // result = %rbx - %rax movq $ 1, %rax addq $ 2, %rax // result = -3 as signed: 1 + ( 2) = 3 as signed: 2 63 ( ) = (overflow) as unsigned: (2 64 1) + (2 64 2) = (overflow) as unsigned: 2 63 ( ) = 1 ZF = 0 (false) not zero rax and rbx not equal SF = 0 (false) not negative rax <= rbx (if correct) OF = 1 (true) overflow as signed incorrect for signed CF = 0 (false) no overflow as unsigned correct for unsigned 16 ZF = 0 (false) not zero result not zero SF = 1 (true) negative result is negative OF = 0 (false) no overflow as signed correct for signed CF = 1 (true) overflow as unsigned incorrect for unsigned 17 compiling switches (1) compiling switches (2) switch (a) { case 1: ; break; case 2: ; break; default: // same as if statement? cmpq $1, %rax je code_for_1 cmpq $2, %rax je code_for_2 cmpq $3, %rax je code_for_3 jmp code_for_default 1 switch (a) { case 1: ; break; case 2: ; break; case 100: ; break; default: // binary search cmpq $50, %rax jl code_for_less_than_50 cmpq $75, %rax jl code_for_50_to_75 code_for_less_than_50: cmpq $25, %rax jl less_than_25_cases 19

11 compiling switches (3) computed jumps switch (a) { case 1: ; break; case 2: ; break; case 100: ; break; default: // jump table cmpq $100, %rax jg code_for_default cmpq $1, %rax jl code_for_default jmp * table(,%rax,) table: // not instructions //.quad = 64-bit (4 x 16) constant.quad code_for_1.quad code_for_2.quad code_for_3.quad code_for_4 20 cmpq $100, %rax jg code_for_default cmpq $1, %rax jl code_for_default // jump to memory[table + rax * ] // table of pointers to instructions jmp * table(,%rax,) // intel: jmp QWORD PTR[rax* + table] table:.quad code_for_1.quad code_for_2.quad code_for_3 21 push/pop Y6-64 instruction formats pushq %rbx memory[] %rbx popq %rbx %rbx memory[] + stack growth. memory[ + 16] byte: halt 0 0 nop 1 0 rrmovq/cmovcc ra, rb 2 cc ra rb irmovq V, rb 3 0 F rb V rmmovq ra, D(rB) 4 0 ra rb D mrmovq D(rB), ra 5 0 ra rb D OPq ra, rb 6 fn ra rb jcc Dest 7 cc Dest memory[ + ] call Dest 0 Dest value to pop memory[] 9 0 where to push memory[ - ] memory[ - 16] pushq ra A 0 ra F popq ra B 0 ra F 22 23

12 Secondary opcodes: OPq Registers: ra, rb byte: halt 0 0 nop 1 0 rrmovq/cmovcc ra, rb 2 cc ra rb irmovq V, rb 3 0 F rb rmmovq ra, D(rB) 4 0 ra rb mrmovq D(rB), ra 5 0 ra rb OPq ra, rb 6 fn ra rb jcc Dest 7 cc call Dest pushq ra A 0 ra F popq ra B 0 ra F 0 add 1 sub Dest 2 and Dest 3 xor V D D byte: halt 0 0 nop 1 0 rrmovq/cmovcc ra, rb 2 cc ra rb irmovq V, rb 3 0 F rb rmmovq ra, D(rB) 4 0 ra rb mrmovq D(rB), ra 5 0 ra rb OPq ra, rb 6 fn ra rb jcc Dest 7 cc call Dest pushq ra A 0 ra F popq ra B 0 ra F 0 %rax %r 1 %rcx 9 %r9 2 %rdx A %r10 V 3 %rbx B %r11 D 4 D C %r12 5 %rbp D %r13 Dest 6 %rsi Dest E %r14 7 %rdi F none Immediates: V, D, Dest Immediates: V, D, Dest byte: byte: halt 0 0 halt 0 0 nop 1 0 nop 1 0 rrmovq/cmovcc ra, rb 2 cc ra rb irmovq V, rb 3 0 F rb rmmovq ra, D(rB) 4 0 ra rb mrmovq D(rB), ra 5 0 ra rb V D D rrmovq/cmovcc ra, rb 2 cc ra rb irmovq V, rb 3 0 F rb rmmovq ra, D(rB) 4 0 ra rb mrmovq D(rB), ra 5 0 ra rb V D D OPq ra, rb 6 fn ra rb jcc Dest 7 cc call Dest 0 Dest Dest OPq ra, rb 6 fn ra rb jcc Dest 7 cc call Dest 0 Dest Dest pushq ra A 0 ra F pushq ra A 0 ra F popq ra B 0 ra F popq ra B 0 ra F 26 26

13 bitwise strategies shift left use paper, find subproblems, etc. mask and shift (x & 0) >> 4 factor/distribute (x & 1) (y & 1) == (x y) & 1 x6 instruction: shl shift left shl $amount, %reg (or variable: shr %cl, %reg) %reg (initial value) divide and conquer common subexpression elimination urn ((!!x) & y) ((!x) & z) becomes d =!x; urn ((-!d) & y) ((-d) & z) %reg (final value) shift left x6 instruction: shl shift left shl $amount, %reg (or variable: shr %cl, %reg) %reg (initial value) left shift in math 1 << 0 == << 1 == << 2 == << 0 == << 1 == << 2 == %reg (final value)

14 left shift in math 1 << 0 == << 1 == << 2 == << 0 == << 1 == << 2 == logical right shift x6 instruction: shr logical shift right shr $amount, %reg (or variable: shr %cl, %reg) %reg (initial value) x << y = x 2 y %reg (final value) logical right shift logical right shift x6 instruction: shr logical shift right shr $amount, %reg (or variable: shr %cl, %reg) %reg (initial value) x6 instruction: shr logical shift right shr $amount, %reg (or variable: shr %cl, %reg) %reg (initial value) ???? %reg (final value) %reg (final value)

15 arithmetic right shift arithmetic right shift x6 instruction: sar arithmetic shift right sar $amount, %reg (or variable: sar %cl, %reg) x6 instruction: sar arithmetic shift right sar $amount, %reg (or variable: sar %cl, %reg) %reg (initial value) %reg (initial value) %reg (final value) %reg (final value) right shift in C registers int shift_signed(int x) { urn x >> 5; // arithmetic; fill w/ copies of unsigned shift_unsigned(unsigned x) { urn x >> 5; // logical; fill with zeroes shift_signed: movl %edi, %eax sarl $5, %eax shift_unsigned: movl %edi, %eax shrl $5, eax updates every clock cycle register output register input 32 33

16 state in Y6-64 state in Y6-64 l o g i c l o g i c logic R[] next R[] logic (with ALU) Data Stat l o g i c to to reg logic R[] next R[] logic (with ALU) Data Stat l o g i c to to reg state in Y6-64 state in Y6-64 l o g i c l o g i c logic R[] next R[] logic (with ALU) Data Stat l o g i c to to reg logic R[] next R[] logic (with ALU) Data Stat l o g i c to to reg 34 34

17 state in Y6-64 memories l o g i c address data logic R[] next R[] logic (with ALU) Data Stat l o g i c to to reg address input data output time memories memories address data input to write address write enable? Data data output read enable? address data input to write address write enable? Data data output read enable? address input data output time address input data output time address input input to write value in memory 35 35

18 read reg #s reg values read reg #s reg values write reg #s data to write %rax, %rdx, write reg #s data to write %rax, %rdx, register number input register value output time read reg #s reg values read reg #s reg values write reg #s data to write %rax, %rdx, write reg #s write register #15: write is ignoredread register #15: value is alway data to write %rax, %rdx, register number input register value output time register number input data input value in register register number input register value output time register number input data input value in register 36 36

19 ALUs SEQ circuit A B ALU operation select A OP B Operations needed: add addq, addresses sub subq xor xorq and andq more? valp + instr. length ra rb valc R[] next R[] ALU alua vale alub add/sub xor/and (function of instr.) Data in Data out Addr in write? function of opcode Stat 37 3 circuit: setting MUXes circuit: setting MUXes valc + 10 valc M[+2] instr. length ra rb R[] next R[] MUXes,,, alua, alub, dmemin Exercise: what do they select when running addq %r, %r9? 0 ALU alua vale alub add/sub xor/and (function of instr.) Data in Data out Addr in write? function of opcode M[+1] +2 + instr. length ra rb 9 ra= rb=9 next R[] R[] R[] R[9] 0 MUXes,,, alua, alub, dmemin Exercise: what do they select when running addq %r, %r9? ALU alua vale alub add/sub xor/and add (function of instr.) alua + alub Data in Data out Addr in write? function of opcode 39 39

20 circuit: setting MUXes circuit: setting MUXes valc M[+2] + 10 valc M[+2] + 10 M[+1] +2 + instr. length ra rb 9 ra= rb=9 next R[] R[] R[] R[9] 0 MUXes,,, alua, alub, dmemin Exercise: what do they select when running addq %r, %r9? ALU alua vale alub add/sub xor/and add (function of instr.) alua + alub Data in Data out Addr in write? function of opcode M[+1] +2 + instr. length ra rb 9 ra= rb=9 next R[] R[] R[] R[9] 0 ALU alua vale alub add/sub xor/and add (function of instr.) alua + alub Data in Data out Addr in write? function of opcode circuit: setting MUXes circuit: setting MUXes valc + 10 valc instr. length ra rb MUXes,,, alua, alub, dmemin Exercise: what do they select for rmmovq? R[] next R[] 0 ALU alua vale alub add/sub xor/and (function of instr.) Data in Data out Addr in write? function of opcode + instr. length MUXes,,, alua, alub, dmemin Exercise: what do they select for rmmovq? ra rb R[] next R[] 0 ALU alua vale alub add/sub xor/and (function of instr.) Data in Data out Addr in write? function of opcode 39 39

21 circuit: setting MUXes valc instr. length MUXes,,, alua, alub, dmemin Exercise: what do they select for call? ra rb R[] next R[] 0 ALU alua vale alub add/sub xor/and (function of instr.) Data in Data out Addr in write? function of opcode 39