machine/assembler language putting it all together
DESCRIPTION
COMP 40: Machine Structure and Assembly Language Programming. Machine/Assembler Language Putting It All Together. Noah Mendelsohn Tufts University Email: [email protected] Web: http://www.cs.tufts.edu/~noah. Goals for today. Explore the compilation of realistic programs from C to ASM - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/1.jpg)
Machine/Assembler LanguagePutting It All Together
Noah MendelsohnTufts UniversityEmail: [email protected]: http://www.cs.tufts.edu/~noah
COMP 40: Machine Structure and
Assembly Language Programming – Fall 2015
![Page 2: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/2.jpg)
© 2010 Noah Mendelsohn
Goals for today
Explore the compilation of realistic programs from C to ASM Fill in a few more details on things like structure mapping
2
![Page 3: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/3.jpg)
© 2010 Noah Mendelsohn
Review
![Page 4: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/4.jpg)
© 2010 Noah Mendelsohn
X86-64 / AMD 64 / IA 64 General Purpose Registers
4
031
%eax
%ecx
%edx
%ebx
%esi
%edi
%esp
%ebp
%ah $al%ax
%ch $cl%cx
%dh $dl%dx
%bh $bl%bx
%si
%di
%sp
%bp
%rax
%rcx
%rdx
%rbx
%rsi
%rdi
%rsp
%rbp
63
%r8
%r9
%r10
%r11
%r12
%r13
%r14
%r15
063
![Page 5: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/5.jpg)
© 2010 Noah Mendelsohn
Machine code (typical)
Simple instructions – each does small unit of work Stored in memory Bitpacked into compact binary form Directly executed by transistor/hardware logic*
5
* We’ll show later that some machines execute user-provided machine code directly, some convert it to an even lower level machine code and execute that.
![Page 6: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/6.jpg)
© 2010 Noah Mendelsohn
A simple function in C
6
int times16(int i){
return i * 16;}
0: 89 f8 mov %edi,%eax 2: c1 e0 04 shl $0x4,%eax 5: c3 retq
REMEMBER: you can see the assembler code for any C program by running gcc with the –S flag. Do it!!
![Page 7: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/7.jpg)
© 2010 Noah Mendelsohn
Addressing modes
7
%rax // contents of rax is data(%rax) // data pointed to by rax$123,%rax // Copy 123 into %rax0x10(%rax) // get *(16 + rax)$0x4089a0(, %rax, 8) // Global array index // of 8-byte things(%ebx, %ecx, 2) // Add base and scaled index4(%ebx, %ecx, 2) // Add base and scaled // index plus offset 4
![Page 8: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/8.jpg)
© 2010 Noah Mendelsohn
movl and leal
8
%rax // contents of rax is data(%rax) // data pointed to by rax$123,%rax // Copy 123 into %rax0x10(%rax) // get *(16 + rax)$0x4089a0(, %rax, 8) // Global array index // of 8-byte things(%ebx, %ecx, 2) // Add base and scaled index4(%ebx, %ecx, 2) // Add base and scaled // index plus offset 4
movl (%ebx, %ecx, 1), %edx // edx <- *(ebx + (ecx * 1))leal (%ebx, %ecx, 1), %edx // edx <- (ebx + (ecx * 1))
![Page 9: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/9.jpg)
© 2010 Noah Mendelsohn
movl and leal
9
%rax // contents of rax is data(%rax) // data pointed to by rax$123,%rax // Copy 123 into %rax0x10(%rax) // get *(16 + rax)$0x4089a0(, %rax, 8) // Global array index // of 8-byte things(%ebx, %ecx, 2) // Add base and scaled index4(%ebx, %ecx, 2) // Add base and scaled // index plus offset 4
movl (%ebx, %ecx, 1), %edx // edx <- *(ebx + (ecx * 1))leal (%ebx, %ecx, 1), %edx // edx <- (ebx + (ecx * 1))
movl
Moves the data at the address:
similar to:
char *ebxp; char edx = ebxp[ecx]
![Page 10: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/10.jpg)
© 2010 Noah Mendelsohn
movl and leal
10
%rax // contents of rax is data(%rax) // data pointed to by rax$123,%rax // Copy 123 into %rax0x10(%rax) // get *(16 + rax)$0x4089a0(, %rax, 8) // Global array index // of 8-byte things(%ebx, %ecx, 2) // Add base and scaled index4(%ebx, %ecx, 2) // Add base and scaled // index plus offset 4
movl (%ebx, %ecx, 1), %edx // edx <- *(ebx + (ecx * 1))leal (%ebx, %ecx, 1), %edx // edx <- (ebx + (ecx * 1))
leal
Moves the address itself:
similar to:
char *ebxp; char *edxp = &(ebxp[ecx]);
![Page 11: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/11.jpg)
© 2010 Noah Mendelsohn
movl and leal
11
%rax // contents of rax is data(%rax) // data pointed to by rax$123,%rax // Copy 123 into %rax0x10(%rax) // get *(16 + rax)$0x4089a0(, %rax, 8) // Global array index // of 8-byte things(%ebx, %ecx, 2) // Add base and scaled index4(%ebx, %ecx, 2) // Add base and scaled // index plus offset 4
movl (%ebx, %ecx, 1), %edx // edx <- *(ebx + (ecx * 1))leal (%ebx, %ecx, 1), %edx // edx <- (ebx + (ecx * 1))movl (%ebx, %ecx, 4), %edx // edx <- *(ebx + (ecx * 4))leal (%ebx, %ecx, 4), %edx // edx <- (ebx + (ecx * 4))
scale factors support indexing larger types
similar to:
int *ebxp; int edxp = ebxp[ecx];
![Page 12: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/12.jpg)
© 2010 Noah Mendelsohn
Control flow: simple jumps
12
.L4:
…code here…
j .L4 // jump back to L4
![Page 13: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/13.jpg)
© 2010 Noah Mendelsohn
Conditional jumps
13
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4 // conditional: jump iff %r8 != %rdf
This technique is the key to compiling if statements, for loops, while loops, etc.
…code here…
![Page 14: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/14.jpg)
© 2010 Noah Mendelsohn
Challenge: how would this compile?
14
switch (exp) { case 0: SS0; case 1: SS1; case 2: SS2; case 3: SS3: default: SSd;}
static code *jump_table[4] = { L0, L1, L2, L3 };
t = exp;if ((unsigned)t < 4) { t = jump_table[t]; goto t;} else goto Ld;
L0: SS0;L1: SS1;L2: SS2;L3: SS3:Ld: SSd;Lend: ...
And break becomes goto Lend
![Page 15: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/15.jpg)
© 2010 Noah Mendelsohn
CallingFunctions(Review)
![Page 16: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/16.jpg)
© 2010 Noah Mendelsohn
Function calls on Linux/AMD 64 Caller “pushes” return address on stack Where practical, arguments passed in registers Exceptions:
– Structs, etc.– Too many– What can’t be passed in registers is at known offsets from stack pointer!
Return values– In register, typically %rax for integers and pointers– Exception: structures
Each function gets a stack frame– Leaf functions that make no calls may skip setting one up
16
![Page 17: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/17.jpg)
© 2010 Noah Mendelsohn
Arguments/return values in registers
17
Arguments and return values passed in registers when types are suitable and when there aren’t too many
Return values usually in %rax, %eax, etc.
Callee may change these and most other registers. However, callee must not change %rsp; %rbp, %rbx, %r12 − %r15!
MMX and FP 87 registers used for floating point
Read the specifications for full details!
Operand Size
Argument Number1 2 3 4 5 6
64 %rdi %rsi %rdx %rcx %r8 %r9
32 %edi %esi %edx %ecx %r8d %r9d
16 %di %si %dx %cx %r8w %r9w
8 %dil %sil %dl %cl %r8b %r9b
![Page 18: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/18.jpg)
© 2010 Noah Mendelsohn
The stack – general case
18
Before call
????%rsp
Arguments
Return address
After callq
%rsp
Arguments
%rsp
If callee needs frame
????Return address
Args to next call?
Callee vars
sub $0x{framesize},%rsp
Arguments
framesize
![Page 19: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/19.jpg)
© 2010 Noah Mendelsohn
A simple function
19
unsigned int times2(unsigned int a){
return a * 2;}
times2:leaq (%rdi,%rdi), %raxret
Double the argument
…and put it in return value register
![Page 20: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/20.jpg)
© 2010 Noah Mendelsohn
The stack – general case
20
Before call
????%rsp
Arguments
Return address
After callq
%rsp
Arguments
%rsp
If callee needs frame
????Return address
Args to next call?
Callee vars
sub $0x{framesize},%rsp
Arguments
framesize
Must be multiple of 16 when a function is
called!
But now it’s not a multiple of 16…
Here too!
![Page 21: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/21.jpg)
© 2010 Noah Mendelsohn
The stack – general case
21
Before call
????%rsp
Arguments
Return address
After callq
%rsp
Arguments
%rsp
If callee needs frame
????Return address
Waste 8 bytes
sub $8,%rsp
Arguments
If we’ll be calling other functions with no arguments, very common to see
sub $8,%rspto re-establish alignment
Must be multiple of 16 when a function is
called!
![Page 22: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/22.jpg)
© 2010 Noah Mendelsohn
Getting the details on function call “linkages”
Bryant and O’Halloran has excellent introduction– Watch for differences between 32 and 64 bit
The official specification:– System V Application Binary Interface: AMD64 Architecture Processor
Supplement– Find it at: http://www.cs.tufts.edu/comp/40/readings/amd64-abi.pdf – See especially sections 3.1 and 3.2– E.g., You’ll see that %rbp, %rbx, %r12 − %r15 are callee saves. All other
GPRs are caller saves. See also Figure 3.4.
22
![Page 23: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/23.jpg)
© 2010 Noah Mendelsohn
Factorial Revisited
23
int fact(int n){ if (n == 0) return 1; else return n * fact(n - 1);}
fact:.LFB2: pushq %rbx.LCFI0: movq %rdi, %rbx movl $1, %eax testq %rdi, %rdi je .L4 leaq -1(%rdi), %rdi call fact imulq %rbx, %rax.L4: popq %rbx ret
![Page 24: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/24.jpg)
© 2010 Noah Mendelsohn
An example that integrates what we’ve learned
![Page 25: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/25.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
25
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
![Page 26: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/26.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
26
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
![Page 27: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/27.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
27
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
![Page 28: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/28.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
28
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
Looks like sum will be in %eax/%rax
![Page 29: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/29.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
29
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
![Page 30: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/30.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
30
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
If length argument is zero, just leave
![Page 31: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/31.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
31
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
We’re testing the value of %rcx, but why???
![Page 32: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/32.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
32
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
We’re testing the value of %rcx, could that be our
arr[i] > 0 test? Yes!
![Page 33: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/33.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
33
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
Hmm. We’re conditionally updating our result (%rax) with $rsi…
![Page 34: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/34.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
34
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
Hmm. We’re conditionally updating our result (%rax) with $rsi……we must have
computed the sum there!
![Page 35: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/35.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
35
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
![Page 36: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/36.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
36
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
This is looking a lot like our for loop index increment & test.
![Page 37: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/37.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
37
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
But why are we adding 8 to the index variable???
![Page 38: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/38.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
38
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
Address just past array!! (unclear why compiler bothers to subtract one
and then add 8)
![Page 39: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/39.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
39
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
But…what is %rdx?
![Page 40: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/40.jpg)
© 2010 Noah Mendelsohn
Sum positive numbers in an array
40
unsigned long sum_positives(long arr[], unsigned int length){
unsigned long sum = 0;unsigned int i;
for (i = 0; i < length; i++) {if (arr[i] > 0)
sum += arr[i];}
return sum;
}
sum_positives:.LFB0:
movl $0, %eaxtestl %esi, %esije .L2subl $1, %esileaq 8(,%rsi,8), %r8movl $0, %edx
.L4:movq (%rdi,%rdx), %rcxleaq (%rax,%rcx), %rsitestq %rcx, %rcxcmovg %rsi, %raxaddq $8, %rdxcmpq %r8, %rdxjne .L4
.L2:repret
Offset to the next array element…we never actually compute
variable i!
![Page 41: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/41.jpg)
© 2010 Noah Mendelsohn
How C LanguageData is Represented
(Review)
![Page 42: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/42.jpg)
© 2010 Noah Mendelsohn
Sizes and alignments
C Type Width Alignmentchar 1 1
short 2 2
int 4 4
float 4 4
pointer, long, long long 8 8
double 8 8
long double 10 16
42
http://www.cs.tufts.edu/comp/40/readings/amd64-abi.pdf#page=13
![Page 43: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/43.jpg)
© 2010 Noah Mendelsohn
Why align to “natural sizes”?
Memory systems delivers aligned to cache blocks CPU loads aligned words or blocks from cache Data that spans boundaries needs two accesses! Naturally aligned data never unnecessarily crosses a
boundary Intel/AMD alignment rules
– Pre AMD 64: unaligned data allowed but slower– AMD 64: data must be aligned as shown on previous slides
43
http://www.cs.tufts.edu/comp/40/readings/amd64-abi.pdf#page=13
![Page 44: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/44.jpg)
© 2010 Noah Mendelsohn
Alignment of C Language Data
Structures– Wasted space used to “pad” between struct members if needed to maintain
alignment– Therefore: when practical, put big members of larger primitive types ahead of
smaller ones!– Structures sized for worst-case member– Arrays of structures will have properly aligned members
malloc return values always multiple of 16– structp = (struct s *)malloc(sizeof(struct s)) is always OK
Argument area on stack is 16 byte aligned– (%rsp - 8) is multiple of 16 on entry to functions– Extra space “wasted” in caller frame as needed– Therefore: called function knows how to maintain alignment
44
![Page 45: Machine/Assembler Language Putting It All Together](https://reader035.vdocuments.site/reader035/viewer/2022062501/5681665e550346895dd9e313/html5/thumbnails/45.jpg)
© 2010 Noah Mendelsohn
Summary
C code compiled to assembler Data moved to registers for manipulation Conditional and jump instructions for control flow Stack used for function calls Compilers play all sorts of tricks when compiling code Simple C data types map directly to properly aligned
machine types in memory and registers
45