IT 252 Computer Organization and Architecture Introduction to the C Programming Language

IT 252 Computer Organization and Architecture Introduction to the C Programming Language Chia-Chi Teng

Administrivia : You have a question? Tips on getting an answer to your question: Ask a classmate Catch me after or before lecture Ask TA in lab or IM Ask me in lecture (if relevant to lecture) Send your TA email Send me email Office hours or by appointment

Administrivia Upcoming lectures HW x86 assembly HW1 due tonight midnight Both paper and electronic, check Learning Suite HW2 due next Thursday Reading Check class web site (lots, get started now!) Textbook practice problems!!! They help. Lab 1 due Friday midnight submit.pl Lab 2 write-up due Friday next week Submit on Learning Suite Quiz 1: address and pointers in x86 assembly Help sessions

IT in the Real World Infected Frames! Malware has been found in photo frames sold by Best Buy. This is not the first time this has happened in personal electronics (ipods, drives, MP3 players). Be careful! www.sfgate.com/cgi-bin/article.cgi?f=/c/a/2008/01/26/mne7uhooq.dtl

What is this?! ~2 min Attention over time! t

Number review... We represent things in computers as particular bit patterns: N bits 2 N Decimal for human calculations, binary for computers, hex to write binary more easily 1 s complement - mostly abandoned 00000 00001... 01111 10000... 11110 11111 2 s complement universal in computing: cannot avoid, so learn 00000 00001... 01111 10000... 11110 11111 Overflow: numbers ; computers finite,errors!

Basic Skills Linux Shell Text Editor: gedit, vi, emacs, Basic Shell Scripts Compiler: gcc, Visual C, Debugger: gdb, DDD, Eclipse, Useful tool: codepad.org

Background in C? Raise hands please Took CS 142 in C++ Used C in CS 124? Written > 500 lines C (or C++) source?

Introduction to C

Has there been an update to ANSI C? Yes! It s called the C99 or C9x std You need gcc -std=c99 to compile References http://en.wikipedia.org/wiki/c99 http://home.tiscalinet.ch/t_wolf/tw/c/c9x_changes.html Highlights Declarations anywhere, like Java Java-like // comments (to end of line) Variable-length non-global arrays <inttypes.h>: explicit integer types <stdbool.h> for boolean logic def s restrict keyword for optimizations

Disclaimer Important: You will not learn how to fully code in C in these lectures! You ll still need your C reference for this course. K&R is the basic reference Check online for more sources JAVA in a Nutshell, O Reilly. Chapter 2, How Java Differs from C

Compilation : Overview C compilers take C and convert it into an architecture specific machine code (string of 1s and 0s). Unlike Java which converts to architecture independent bytecode. Unlike JavaScript environments which interpret the code. These differ mainly in when your program is converted to machine instructions. For C, generally a 2 part process of compiling.c files to.o files, then linking the.o files into executables

Compilation : Advantages Great run-time performance: generally much faster than Java or JavaScript for comparable code (because it optimizes for a given architecture) OK compilation time: enhancements in compilation procedure (Makefile) allow only modified files to be recompiled

Compilation : Disadvantages All compiled files (including the executable) are architecture specific, depending on both the CPU type AND the operating system. Executable must be rebuilt on each new system. Called porting your code to a new architecture. The change compile run [repeat] iteration cycle is slow

Key C Topics Pass-by value/reference Pass-by ptr is efficient (esp large arrays)(slide 51, 52) Bugs (slide 36) Pointers: Contains an address Array variable v. similar to ptrs (char=array, \0) Arrays Size w. constant once (slide 32) Bounds unchecked-vulnerable (slide 33, 53) Ptrs know size to increment Ptr arith (slide 40, 41) Variable scoping

C Syntax: main To get the main function to accept arguments, use this: int main (int argc, char *argv[]) What does this mean? argc will contain the number of strings on the command line (the executable counts as one, plus one for each argument). Here argc is 2: unix% sort myfile argv is a pointer to an array containing the arguments as strings (more on pointers later).

C Syntax: Variable Declarations Very similar to Java, but with a few minor but important differences All variable declarations must go before they are used (at the beginning of the block)* A variable may be initialized in its declaration; if not, it holds garbage! Examples of declarations: correct: { int a = 0, b = 10;... Incorrect:* for (int i = 0; i < 10; i++) *C99 overcomes these limitations

Address vs. Value Consider memory to be a single huge array: Each cell of the array has an address associated with it. Each cell also stores some value. Do you think they use signed or unsigned numbers? Negative address?! Don t confuse the address referring to a memory location with the value stored in that location.... 101 102 103 104 105... 23 42...

Pointers An address refers to a particular memory location. In other words, it points to a memory location. Pointer: A variable that contains the address of a variable. Location (address) name... 101 102 103 104 105... 23 42 104... x y p

Pointers How to create a pointer: & operator: get address of a variable int *p, x; p? x? x = 23; p? x 23 p =&x; p x 23 How get a value pointed to? * dereference operator : get value pointed to printf( p points to %d\n,*p); Note the * gets used 2 different ways in this example. In the declaration to indicate that p is going to be a pointer, and in the printf to get the value pointed to by p. printf( address is %X or %X,p,&x);

Pointers How to change a variable pointed to? Use dereference * operator on left of = p x 23 *p = 5; p x 5

Pointers and Parameter Passing (1/4) Java and C pass parameters by value procedure/function/method gets a copy of the parameter, so changing the copy cannot change the original void addone (int x) { x = x + 1; } int y = 3; addone(y); // what is y? y is still = 3

Pointers and Parameter Passing (2/4) How to get a function to change a value? void addone (int *p) { *p = *p + 1; } int y = 3; addone(&y); // what is y? y is now = 4

Pointers and Parameter Passing (3/4) But what if what you want changed is a pointer? What gets printed? void IncrementPtr(int *p) { p = p + 1; } int A[3] = {50, 60, 70}; int *q = A; IncrementPtr( q); printf( *q = %d\n, *q); A q *q = 50 50 60 70

Pointers and Parameter Passing (4/4) Solution! Pass a pointer to a pointer, declared as **h Now what gets printed? void IncrementPtr(int **h) { *h = *h + 1; } int A[3] = {50, 60, 70}; int *q = A; IncrementPtr(&q); printf( *q = %d\n, *q); A q q *q = 60 50 60 70

Pointers Pointers are used to point to any data type (int, char, a struct, etc.). Normally a pointer can only point to one type (int, char, a struct, etc.). void * is a type that can point to anything (generic pointer) Use sparingly to help avoid program bugs and security issues and a lot of other bad things!

C Pointer Dangers Declaring a pointer just allocates space to hold the pointer it does not allocate something to be pointed to! Local variables in C are not initialized, they may contain anything. What does the following code do? void f() { int *ptr; *ptr = 5; }

Arrays (1/5) Declaration: int ar[2]; declares a 2-element integer array. An array is really just a block of memory. int ar[] = {795, 635}; declares and fills a 2-elt integer array. Accessing elements: ar[num] returns the num th element. What is ar[1]?

Arrays (2/5) Arrays are (almost) identical to pointers char *string and char string[] are nearly identical declarations They differ in very subtle ways: incrementing, declaration of filled arrays Key Concept: An array variable is a pointer to the first element.

Arrays (3/5) Consequences: ar is an array variable but looks like a pointer in many respects (though not all) ar[0] is the same as *ar ar[2] is the same as *(ar+2) We can use pointer arithmetic to access arrays more conveniently. Declared arrays are only allocated while the scope is valid char *foo() { char string[32];...; return string; } Is this correct? Why?

Arrays (4/5) Array size n; want to access from 0 to n-1, so you should use counter AND utilize a constant for declaration & incr Bad int i, ar[10]; for(i = 0; i < 10; i++){... } Good #define ARRAY_SIZE 10 int i, a[array_size]; for(i = 0; i < ARRAY_SIZE; i++){... } Why? SINGLE SOURCE OF TRUTH You re utilizing indirection and avoiding maintaining two copies of the number 10

Arrays (5/5) Pitfall: Unlike Java, an array in C does not know its own length, & bounds not checked! Consequence: We can accidentally access off the end of an array. Consequence: We must pass the array and its size to a procedure which is going to traverse it. Buffer overflow (internet worm) Segmentation faults and bus errors: These are difficult to find; be careful! (You ll learn how to debug these later on )

Pointer Arithmetic (1/2) Since a pointer is just a memory address, we can add to it to traverse an array. p+1 returns a ptr to the next array elemnt. *p++ vs (*p)++? x = *p++ x = *p ; p = p + 1; x = (*p)++ x = *p ; *p = *p + 1; What if we have an array of large structs (objects)? C takes care of it: In reality, p+1 doesn t add 1 to the memory address, it adds the size of the array element.

Pointer Arithmetic (2/2) C knows the size of the thing a pointer points to every addition or subtraction moves that many bytes. 1 byte for a char, 4 bytes for an int, etc. int* p;... p = 100; p++; // what is p now? So array[n]and *(array + n) are equivalent:

Pointers in C Why use pointers? If we want to pass a huge struct or array, it s easier to pass a pointer than the whole thing. In general, pointers allow cleaner, faster, more compact code. So what are the drawbacks? Pointers are probably the single largest source of bugs in C/C++ software, so be careful anytime you deal with them. Dangling reference (premature free) Memory leaks (tardy free)

C Strings A string in C is just an array of characters. char string[] = "abc"; How do you tell how long a string is? Last character is followed by a 0 byte (null terminator) int strlen(char s[]) { int n = 0; while (s[n]!= 0) n++; return n; }

Peer Instruction Question void main(); { int *p, x=5, y; // init y = *(p = &x) + 10; int z; flip-sign(p); printf("x=%d,y=%d,*p=%d\n",x,y,p); } flip-sign(int *n){*n = -(*n)} How many syntax/logic errors in this C99 code? #Errors 0 1 2 3 4 5 6 7

Peer Instruction Answer void main(); { int *p, x=5, y; // init y = *(p = &x) + 10; int z; flip-sign(p); printf("x=%d,y=%d,*p=%d\n",x,y,*p); } flip-sign(int *n){*n = -(*n);} How many syntax/logic errors? I get 5. (signed printing of pointer is logical error) #Errors 0 1 2 3 4 5 6 7

Pointer Arithmetic Peer Instruction Q How many of the following are invalid (logically)? I. pointer + integer II. integer + pointer III. pointer + pointer IV. pointer integer V. integer pointer VI. pointer pointer VII. compare pointer to pointer VIII. compare pointer to none-zero integer IX. compare pointer to 0 X. compare pointer to NULL #invalid 1 2 3 4 5 6 7 8 9 10

Pointer Arithmetic Peer Instruction Ans How many of the following are invalid? I. pointer + integer II. integer + pointer III. pointer + pointer IV. pointer integer V. integer pointer VI. pointer pointer VII. compare pointer to pointer VIII. compare pointer to integer IX. compare pointer to 0 X. compare pointer to NULL ptr + 1 1 + ptr ptr + ptr ptr - 1 1 - ptr ptr - ptr ptr1 == ptr2 ptr == 1 ptr == NULL ptr == NULL #invalid 1 2 3 4 5 6 7 8 9 10

Peer Instruction p int main(void){ int A[2] = {5,10}; int *p = A; } 5 10 A[0] A[1] printf( %u %d %d %d\n, p, *p, A[0], A[1]); p = p + 1; printf( %u %d %d %d\n, p, *p, A[0], A[1]); *p = *p + 1; printf( %u %d %d %d\n, p, *p, A[0], A[1]); If the first printf outputs 100 5 5 10, what will the other two printf output? 1: 101 10 5 10 then 101 11 5 11 2: 104 10 5 10 then 104 11 5 11 3: 101 11 5 10 then 101 11 6 11 4: 104 11 5 10 then 104 11 6 11 5: One of the two printfs causes an ERROR 6: I surrender!

Lifetime & Scope Every variable has scope Where can the variable be used? At run-time, every variable needs space When is the space allocated and deallocated? Global vs local variable

Variable scope (1/2) Global variables allocated before main, deallocated after main. Scope is entire program Usually bad style, similar to public static Java fields. Static global variables like global var but scope is just that file. Similar to private static Java fields. Related: static functions cannot be called from another file.

Variable scope (2/2) Static local variables like global variables, but scope is just that function. Local variables allocated when reached & deallocated after the block, scope is that block. So with recursion, multiple instances/spaces for same variable. One per function call (stack frame.) Like local variables in Java.

Code Block int f(int x) { int i = 0; if (x) { int i = 10 * x; // does this compile? } printf( %d %d, i, x); // what is i? return i; }

A typical file layout No rules on this order, but good conventional style // includes for functions, types defined elsewhere (just prototypes) #include <stdio.h> #include... // global variables (usually avoid them) int some_global; static int this_file_arr[7] = { 0, 2, 4, 5, 9, -4, 6 }; // function prototypes for forward-references (to get around // uses-follow-definition rule) void some_later_fun(char, int); // argument names optional // functions void f() {... } void some_later_fun(char x, int y) {...} int main(int argc, char**argv) {...}

Use Follows Definition No forward references A function must be defined or declared before it is used. Linker error if something is declared and used but not defined.

Misc Silly almost-obsolete ANSI C syntax restriction (not in Java/C99/C++): declarations only at the beginning of a block. Just create a block by adding { } Or use std=c99 gcc compiler option (Local or global) variables holding arrays must have a constant size So the compiler knows how much space to give So for arrays whose size depends on run-time information, dynamically allocate them in heap and point to them (more on this later)

Function Arguments Storage and scope of arguments is like for local variables. Initialized by caller ( copy the value) Modifying an argument has no affect on the caller. Use pointer if needed. void f() { int g(int x) { } int i=10; x=x+1; int j=g(i); return x; printf( %d %d, i,j); }

Function Arguments Storage and scope of arguments is like for local variables. Initialized by caller ( copy the value) Modifying an argument has no affect on the caller. Use pointer if needed. void f() { int g(int* x) { } int i=10; *x = *x + 1; int j=g(&i); printf( %d %d, i,j); } return *x;

Dangling Pointers int* f(int x) { // Where are the problems? int* p; if (x) { int y = 3; p = &y; // OK } y = 4; // this does not compile *p = 7; // p is invalid, could crash but probably not return p; // returning a bad pointer, but no crash yet } void g() { int* p = f(7); *p = 123; // hopefully you crash, but maybe not }

C Syntax: True or False? What evaluates to FALSE in C? 0 (integer) NULL (pointer: more on this later) no such thing as a Boolean* What evaluates to TRUE in C? everything else (same idea as in scheme: only #f is false, everything else is true!) *Boolean types provided by C99 s stdbool.h

C syntax : flow control Within a function, remarkably close to Java constructs in methods (shows its legacy) in terms of flow control if-else switch while and for do-while

And in conclusion All declarations go at the beginning of each function except if you use C99. Only 0 and NULL evaluate to FALSE. All data is in memory. Each memory location has an address to use to refer to it and a value stored in it. A pointer is a C version of the address. * follows a pointer to its value & gets the address of a value

Reference slides You ARE responsible for the material on these slides (they re just taken from the reading anyway) ; we ve moved them to the end and off-stage to give more breathing room to lecture!

C vs. Java Overview (1/2) Java Object-oriented (OOP) Methods Class libraries of data structures Automatic memory management C No built-in object abstraction. Data separate from methods. Functions C libraries are lower-level Manual memory management Pointers

C vs. Java Overview (2/2) Java High memory overhead from class libraries Relatively Slow Arrays initialize to zero Syntax: /* comment */ // comment System.out.print C Low memory overhead Relatively Fast Arrays initialize to garbage Syntax: * /* comment */ // comment printf * You need newer C compilers to allow Java style comments, or just use C99

Pointers & Allocation (1/2) After declaring a pointer: int *ptr; ptr doesn t actually point to anything yet (it actually points somewhere - but don t know where!). We can either: make it point to something that already exists, or allocate room in memory for something new that it will point to (next time)

Pointers & Allocation (2/2) Pointing to something that already exists: int *ptr, var1, var2; var1 = 5; ptr = &var1; var2 = *ptr; var1 and var2 have room implicitly allocated for them. ptr? var1? 5 var2? 5

Pointer Arithmetic So what s valid pointer arithmetic? Add an integer to a pointer. Subtract 2 pointers (in the same array). Compare pointers (<, <=, ==,!=, >, >=) Compare pointer to NULL (indicates that the pointer points to nothing). Everything else is illegal since it makes no sense: adding two pointers multiplying pointers subtract pointer from integer

Pointer Arithmetic to Copy memory We can use pointer arithmetic to walk through memory: void copy(int *from, int *to, int n) { int i; for (i=0; i<n; i++) { *to++ = *from++; } } Note we had to pass size (n) to copy

Arrays vs. Pointers An array name is a read-only pointer to the 0 th element of the array. An array parameter can be declared as an array or a pointer; an array argument can be passed as a pointer. int strlen(char s[]) { int n = 0; while (s[n]!= 0) n++; return n; } Could be written: while (s[n]) int strlen(char *s) { int n = 0; while (s[n]!= 0) n++; return n; }

Pointer Arithmetic Summary x = *(p+1)? x = *(p+1) ; x = *p+1? x = (*p) + 1 ; x = (*p)++? x = *p ; *p = *p + 1; x = *p++? (*p++)? *(p)++? *(p++)? x = *p ; p = p + 1; x = *++p? p = p + 1 ; x = *p ; Lesson? Using anything but the standard *p++, (*p)++ causes more problems than it solves!

Segmentation Fault vs Bus Error? http://www.hyperdictionary.com/ Bus Error A fatal failure in the execution of a machine language instruction resulting from the processor detecting an anomalous condition on its bus. Such conditions include invalid address alignment (accessing a multi-byte number at an odd address), accessing a physical address that does not correspond to any device, or some other device-specific hardware error. A bus error triggers a processor-level exception which Unix translates into a SIGBUS signal which, if not caught, will terminate the current process. Segmentation Fault An error in which a running Unix program attempts to access memory not allocated to it and terminates with a segmentation violation error and usually a core dump.

C Pointer Dangers Unlike Java, C lets you cast a value of any type to any other type without performing any checking. int x = 1000; int *p = x; /* invalid */ int *q = (int *) x; /* valid */ The first pointer declaration is invalid since the types do not match. The second declaration is valid C but is almost certainly wrong Is it ever correct?

C Strings Headaches One common mistake is to forget to allocate an extra byte for the null terminator. More generally, C requires the programmer to manage memory manually (unlike Java or C++). When creating a long string by concatenating several smaller strings, the programmer must insure there is enough space to store the full string! What if you don t know ahead of time how big your string will be? Buffer overrun security holes!

Common C Error There is a difference between assignment and equality a = b is assignment a == b is an equality test This is one of the most common errors for beginning C programmers! One solution (when comparing with constant) is to put the var on the right! If you happen to use =, it won t compile. if (3 == a) {...

C String Standard Functions int strlen(char *string); compute the length of string int strcmp(char *str1, char *str2); return 0 if str1 and str2 are identical (how is this different from str1 == str2?) char *strcpy(char *dst, char *src); copy the contents of string src to the memory at dst. The caller must ensure that dst has enough memory to hold the data to be copied.