Tools of the Trade The C Language Laboration 04. Outline. 1 Tools of the Trade. 2 The C Language. 3 Laboration 04

Size: px

Start display at page:

Download "Tools of the Trade The C Language Laboration 04. Outline. 1 Tools of the Trade. 2 The C Language. 3 Laboration 04"

Piers Mosley
5 years ago
Views:

1 Outline 1 2 3

2 GNU Project GNU Project - Free Software(?) Licensed under GPL(v2 v3) - GNU Public Licence. Freedom to modify, bound to distribute source (if you distribute it!). Effort initiated (announced) by Richard Stallman in (Recursive acronym GNU s Not Unix)

3 Toolchain from MIPS Technologies (GNU-based) Tool Input Output sde-gcc C asm sde-as asm object sde-ld object executable sde-objdump (object executable) text make text n/a Called toolchain for the obvious reason, i.e. tools are chained to produce an executable: sde-gcc sde-as sde-ld.

4 GNU Compiler Collection Supported languages (front-ends) gcc C g++ C++ gfortran Fortran gcj Java gobjc Objective-C gobjc++ Objective-C++ gnat Ada

5 gcc (from GNU Compiler Collection) Why gcc? De facto standard compiler for UNIX-like systems. Very good support for both C89 and C99 (ANSI- and ISO-standards). Produces fairly optimized code (better for some targets, worse for others). Supports a large number of targets Approx. 20 in mainline (IA-32, IA-64, MIPS, ARM, etc.). At least 20 in branches (MSP430, PIC24, PDP-10, etc.). Why the C language? We will get back to this question later (when introducing the C language).

6 Toolchain from MIPS Technologies (GNU-based) Tool Input Output sde-gcc C asm sde-as asm object sde-ld object executable sde-objdump (object executable) text make text n/a Called toolchain for the obvious reason, i.e. tools are chained to produce an executable: sde-gcc sde-as sde-ld.

7 GNU Binutils Tools as Assembler ld Linker objdump Diplays information about object/executable files. (Many more but we will not discuss them today... ) Supported languages/targets IA-32, IA-64, MIPS, ARM, MSP430, etc. Why binutils? Straightforward translation from asm to binary format, no real reason to re-invent the wheel...

8 Toolchain from MIPS Technologies (GNU-based) Tool Input Output sde-gcc C asm sde-as asm object sde-ld object executable sde-objdump (object executable) text make text n/a Called toolchain for the obvious reason, i.e. tools are chained to produce an executable: sde-gcc sde-as sde-ld.

9 GNU Make make features Resolving build-dependencies Parallel compilation Scriptable (not always intuitive) Why make? Again, de facto standard on Unix-like systems. Is not tied to any specific language, hence you can use it for anything!

10 Toolchain from MIPS Technologies (GNU-based) Tool Input Output sde-gcc C asm sde-as asm object sde-ld object executable sde-objdump (object executable) text make text n/a Called toolchain for the obvious reason, i.e. tools are chained to produce an executable: sde-gcc sde-as sde-ld.

11 Putting it all together... make lib0.c lib0.s lib0.o lib.a lib1.c lib1.s lib1.o app.c app.s app.o app gcc as ld

12 Brief History Initially developed between 69 and 73 by Dennis Ritchie. Language for developing system software (operating systems). First standard in 78, The C Programming Language (or K&R). ANSI standard in 89, referred to as C89 (or ANSI-C). ISO standard in 90 (called C90) equivalent to C89. Second ISO standard in 99 (called C99) extends C89. Third ISO standard C1X is work in progress...

13 Features/Strengths/Weaknesses Low-level access to memory, and manual memory management. Straightforward compilation process (easy to write compilers). Designed to map efficiently to machine-specific instructions. Basic type-system, extendable with user-defined types. Higher abstraction level than assembly, but still low-level enough to replace assembly. Despite the low-level nature of the language, it s still used to write portable code. If there is a processor X, then there exists a C compiler Y for that processor (probably).

14 Numeric types char Integer, smallest a integer type. short Integer, larger or equal to char. int Integer, larger or equal to short (native type). long Integer, larger or equal to int. float Single-precision floating point number. double Double-precision floating point number. a Size is defined as number of bits.

15 Signedness of Integer Types All integer types can be prefixed with either signed or unsigned. char is either signed or unsigned (implementation defined), all other numeric types default to signed. Implementation-defined Behavior Allows the compiler-writer some leeway when implementing a feature of the language. However, the compiler-writer must document how implementation-defined features are implemented. Undefiend Behavior There is no definition of how the resulting program should behave when the source contains undefined behavior.

16 Implementation-defined Behavior Matters! Right-shifting in C is denoted by the >> operator (e.g., -1 >> 4). Is the right-shift operator arithmetic or logic? Implementation-defined, but as a rule-of-thumb: arithmetic if the processor has an arithmetic right-shift instruction.

17 Pointers Constructed using the address-of operator & (e.g., &value). The value that a pointer points to is obtained using the * operator (e.g., *pointer), a.k.a dereferencing. Either has a known type (e.g., int *, float *) or an unknown type void (i.e., void *). Increasing or decreasing a pointer value will automatically add the correct value (derived from the size of type). Pointer is invalid if equivalent to the NULL-pointer. The Second Commandment for C Programmers Thou shalt not follow the NULL pointer, for chaos and madness await thee at its end.

18 Arrays Elements of an array have the same type (e.g., char string[4]). Arrays are (in essence) a continuous chunk of memory. Arrays are indexed using the [] operator (e.g., array[4]). Arrays elements are indexed from 0 (i.e., 0 is the first element). Accessing an element outside the array is undefined behavior (and no compiler will stop you!).

19 Arrays and Pointers It is very hard to distinguish between pointer and array variables just by looking at their usage (syntax). Compiler implicitly converts between pointers and arrays. Assuming that a variable is a pointer when it is an array can be fatal!

20 Reversing a String in C 1 #define STRING LENGTH 12 2 const char * const string in = Hello World! ; 3 char string out[string LENGTH+1] = {0}; 4 5 void rev(const char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[string LENGTH-1], STRING LENGTH); 10 } void rev(const char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

21 Reversing a String in C 1 #define STRING LENGTH 12 2 const char * const string in = Hello World! ; 3 char string out[string LENGTH+1] = {0}; 4 5 void rev(const char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[string LENGTH-1], STRING LENGTH); 10 } void rev(const char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

22 Reversing a String in C 1 #define STRING LENGTH 12 2 const char * const string in = Hello World! ; 3 char string out[string LENGTH+1] = {0}; 4 5 void rev(const char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[string LENGTH-1], STRING LENGTH); 10 } void rev(const char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

23 Reversing a String in C 1 2 const char * const string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(const char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[11], 12); 10 } void rev(const char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

24 Reversing a String in C 1 2 const char * const string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(const char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[11], 12); 10 } void rev(const char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

25 Reversing a String in C 1 2 const char * const string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(const char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[11], 12); 10 } void rev(const char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

26 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[11], 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

27 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[11], 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

28 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[11], 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

29 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[11], 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

30 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, &string out[11], 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

31 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, string out+11, 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

32 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, string out+11, 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

33 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, string out+11, 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

34 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, string out+11, 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

35 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, string out+11, 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

36 Reversing a String in C 1 2 char *string in = Hello World! ; 3 char string out[13] = {0}; 4 5 void rev(char *, char *, int); 6 7 int main(void) 8 { 9 rev(string in, string out+11, 12); 10 } void rev(char *from, char *to, int copy) 13 { 14 if (copy!= 0) { 15 rev(from+1, to-1, copy-1); 16 *to = *from; 17 } 18 }

37 The Compiled Result (of function rev, compiled with -O1) : 27 bdffe0 addiu sp, sp, : afbf0018 sw ra, 24( sp ) : afb10014 sw s1, 20( sp ) c : afb00010 sw s0, 16( sp ) : move s0, a : 10 c00007 beqz a2, <rev+0x34> : 00 a08821 move s1, a c : addiu a0, a0, : 24 a 5 f f f f a d d i u a1, a1, : 0c j a l <rev> : 24 c 6 f f f f a d d i u a2, a2, c : l b u v0, 0 ( s0 ) : a sb v0, 0 ( s1 ) : 8 fbf0018 lw ra, 24( sp ) : 8 fb10014 lw s1, 20( sp ) c : 8 fb00010 lw s0, 16( sp ) : 03 e00008 j r ra : 27 bd0020 a d d i u sp, sp,32

38 What is the lab about? Implementing lab1b in C. Analyzing the resulting assembly-code of codgen at different optimization levels: -O0, -O1, -O2, and -O3. Try to reverse-engineer the compiler, what kind of optimizations does it perform? The gcc manual can be of great help here, just make sure you have the manual from the correct version (v3.4.4).

CS 110 Computer Architecture. Lecture 2: Introduction to C, Part I. Instructor: Sören Schwertfeger.

CS 110 Computer Architecture. Lecture 2: Introduction to C, Part I. Instructor: Sören Schwertfeger. CS 110 Computer Architecture Lecture 2: Introduction to C, Part I Instructor: Sören Schwertfeger http://shtech.org/courses/ca/ School of Information Science and Technology SIST ShanghaiTech University