Low-Level Programming in C

Transcription

1 Low-Level Programming in C

2 Menu C Programming Language Pointers in C Pointer Arithmetic Type checking in C 2

3 No support for: C Language Array bounds checking Null dereferences checking Data abstraction, subtyping, inheritance Exceptions Automatic memory management Program crashes (or worse) when something bad happens Lots of syntactically legal programs have undefined behavior 20 November 2003 CS 201J Fall

4 Primitive Data Types char short int long float double 8 bits 16 bits 32 bits 64 bits 32 bits 64 bits

5 Example C Program void test (int x) { while (x = 1) { printf ( I m an imbecile! ); x = x + 1; Weak type checking: In C, there is no boolean type. Any value can be the test expression. x = 1 assigns 1 to x, and has the value 1. I m an imbecile! I m an imbecile! I m an imbecile! I m an imbecile! In Java: void test (int x) { while (x = 1) { printf ( I m an imbecile! ); x = x + 1; > javac Test.java Test.java:21: incompatible types found : int required: boolean while (x = 1) { ^ 1 error 5

6 Type Checking isn t Enough void test (boolean x) { while (x = true) { printf ( I m an imbecile! ); x =!x; 6

7 C/C++ Bounds NonChecking # include <iostream.h> int main (void) { int x = 9; char s[4]; scanf( %s,s); printf("s is: \n,s); printf("x is: %d\n,x); > g++ -o bounds bounds.cc > bounds cs (User input) s is: cs x is: 9 > bounds cs s is: cs x is: 0 > bounds aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa s is: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa x is: Segmentation fault 7

8 So, why would anyone use C today? 8

9 Legacy Code Reasons to Use C Linux, most open source applications are in C Simple to write compiler Programming embedded systems, often only have a C compiler Performance Typically 50x faster than interpreted Java Smaller, simpler, lots of experience 9

10 User-Defined Structure Types Use struct to group data Dot (.) operator to access fields of a struct Fields are accessible everywhere (no way to make them private) typedef struct { char name[10]; int count; Tally; 10

11 What are those arrows really? Stack Heap sb hello 11

12 Pointers In Java, an object reference is really just an address in memory But Java doesn t let programmers manipulate addresses directly Stack Heap 0x80496f0 0x80496f4 sb 0x80496f8 0x80496f8 0x80496fb 0x hell o\0\0\0 0x x

13 Pointers in C Addresses in memory Programs can manipulate addresses directly &expr *expr Evaluates to the address of the location expr evaluates to Evaluates to the value stored in the address expr evaluates to 13

14 int f (void) { int s = 1; int t = 1; int *ps = &s; int **pps = &ps; int *pt = &t; **pps = 2; pt = ps; *pt = 3; t = s; s == 1, t == 1 s == 2, t == 1 s == 3, t == 1 s == 3, t == 3 14

15 Parameter Passing in C void swap (int a, int b) { int tmp = b; b = a; a = tmp; int main (void) { int i = 3; int j = 4; swap (i, j); The value of i (3) is passed, not its location! swap does nothing 15

16 Parameter Passing in C Can pass addresses around void swap (int *a, int *b) { int tmp = *b; *b = *a; *a = tmp; int main (void) { int i = 3; int j = 4; swap (&i, &j); The value of &i is passed, which is the address of i 16

17 Beware! int *value () { int i = 3; return &i; void callme () { int x = 35; int main () { int *ip; ip = value (); printf ( *ip == %d\n", *ip); callme (); printf ("*ip == %d\n", *ip); return 0; *ip == 3 *ip == 35 But it could really be anything! 17

18 Manipulating Addresses char s[6]; s[0] = h ; expr1[expr2] in C is just syntactic sugar for s[1] = e ; *(expr1 + expr2) s[2]= l ; s[3] = l ; s[4] = o ; s[5] = \0 ; printf ( s: %s\n, s); s: hello 18

19 Obfuscating C char s[6]; *s = h ; *(s + 1) = e ; 2[s] = l ; 3[s] = l ; *(s + 4) = o ; 5[s] = \0 ; printf ( s: %s\n, s); s: hello 19

20 Fun with Pointer Arithmetic int match (char *s, char *t) { int count = 0; while (*s == *t) { count++; s++; t++; return count; int main (void) { char s1[6] = "hello"; char s2[6] = "hohoh"; The \0 is invisible! printf ("match: %d\n", match (s1, s2)); printf ("match: %d\n", match (s2, s2 + 2)); printf ("match: %d\n", match (&s2[1], &s2[3])); &s2[1] &(*(s2 + 1)) s2 + 1 match: 1 match: 3 match: 2 20

21 Condensing match int match (char *s, char *t) { int count = 0; while (*s == *t) { count++; s++; t++; return count; int match (char *s, char *t) { char *os = s; while (*s++ == *t++); return s os - 1; s++ evaluates to s pre, but changes the value of s Hence, s++ has the same value as s, but has unpleasant side effects. 21

22 Type Checking in C Java: only allow programs the compiler can prove are type safe Exception: run-time type errors for downcasts and array element stores. C: trust the programmer. If she really wants to compare apples and oranges, let her. 22

23 Type Checking int main (void) { char *s = (char *) 3; printf ("s: %s", s); 23

24 In Praise of Type Checking int match (int *s, int *t) { int *os = s; while (*s++ == *t++); return s - os; int main (void) { char s1[6] = "hello"; char s2[6] = "hello"; printf ("match: %d\n", match (s1, s2)); match: 2 24

25 Unicode Format Description Escape Sequence Unicode Backspace \b \u0008 Tab \t \u0009 Linefeed \n \u000a Carriage return \r \u000d

26 Different Matching int different (int *s, int *t) { int *os = s; while (*s++!= *t++); return s - os; int main (void) { char s1[6] = "hello"; printf ("different: %d\n", different ((int *)s1, (int *)s1 + 1)); different: 29 26

27 int arr[8][3]; int *arrp[8]; int main(int argc,char **argv) { int i,j,tmp; for(i=0;i<8;i++) arrp[i]=(int*) malloc(sizeof(int)*3); for(i=0;i<8;i++) for(j=0;j<3;j++) { tmp=((int*)arr)[8]; arr[i][j]=i*3+j; arrp[i][j]=i*3+j; tmp=((int*)arrp) [12]; tmp=arr[3][-1]; tmp=arrp[2][5]; tmp= 8[((int*)arr)]; tmp= 13[((int*)arrP)]; Arrays C

28 What? 1. tmp = 8 2. tmp = 4 3. tmp = 8 4.? tmp = 10? 5. tmp = 8 6. tmp = 5

29 Structures Compound data: A date is an int month and an int day and an int year struct ADate { int month; int day; int year; ; struct ADate date; date.month = 1; date.day = 18; date.year = 2018; Unlike Java, C doesn t automatically define functions for initializing and printing 29

30 Structure Representation & Size sizeof(struct ) = sum of sizeof(field) + alignment padding Processor- and compiler-specific struct CharCharInt { char c1; char c2; int i; foo; foo.c1 = a ; foo.c2 = b ; foo.i = 0xDEADBEEF; c1 c2 i padding EF BE AD DE x86 uses little-endian representation 30

31 Typedef Mechanism for creating new type names New names are an alias for some other type May improve clarity and/or portability of the program typedef long int64_t; typedef struct ADate { int month; int day; int year; Date; Overload existing type names for clarity and portability Simplify complex type names int64_t i = ; Date d = { 1, 18, 2018 ; 31

32 Function Pointers Code that performs a specific task. This code has memory address. int foo(int *a,int *b){ return *a+*b; typedef int(*func)(int*,int*) Function declaration int main(){ Simplify complex type names int x = 10; func f = &foo; Function pointer f Printf( 2 times x) = %d,f(&x,&x)); return 0; 32

33 Constants Allow consistent use of the same constant throughout the program Improves clarity of the program Reduces likelihood of simple errors Easier to update constants in the program Constant names are capitalized by convention Preprocessor directive #define SIZE 10 int array[size]; Define once, use throughout the program for (i=0; i<size; i++) { 33

34 Arrays of Structures Array declaration Constant Date birthdays[nfriends]; bool check_birthday(date today) { int i; for (i = 0; i < NFRIENDS; i++) { if ((today.month == birthdays[i].month) && (today.day == birthdays[i].day)) return (true); Array index, then structure field return (false); 34

35 Pointers to Structures Date create_date1(int month, int day, int year) { Date d; d.month = month; d.day = day; d.year = year; Pass-by-reference void create_date2(date *d, int month, int day, int year) { d-month = month; d->day = day; d->year = year; return (d); Date today; Copies date today = create_date1(1, 18, 2018); create_date2(&today, 1, 18, 2018); 35

36 Pointers to Structures (cont.) void create_date2(date *d, int month, int day, int year) { d->month = month; d->day = day; d->year = year; 0x30A8 0x30A4 0x30A0 0x3098 year: 2018 day: 18 month: 1 d: 0x1000 void fun_with_dates(void) { 0x1008 0x1004 today.year: today.day: Date today; create_date2(&today, 1, 18, 2018); 0x1000 today.month: 1 36

37 Pointers to Structures (cont.) Date * create_date3(int month, int day, int year) { Date *d; What is d pointing to?!?! (more on this later) d->month = month; d->day = day; d->year = year; return (d); 37

38 Collections of Bools (Bit Vectors) Byte, word,... can represent many Booleans One per bit, e.g., = false, false, true,..., true Bit-wise operations: Bit-wise AND: & == Bit-wise OR: == Bit-wise NOT: ~ == Bit-wise XOR: ^ ==

39 Operations on Bit Vectors const unsigned int low_three_bits_mask = 0x7; unsigned int bit_vec = 0x15; A mask indicates which bit positions we are interested in Always use C s unsigned types for bit vectors Selecting bits: important_bits = bit_vec & low_three_bits_mask; == & Result =? 39

40 Operations on Bit Vectors const unsigned int low_three_bits_mask = 0x7; unsigned int bit_vec = 0x15; Setting bits: bit_vec = low_three_bits_mask; Result =? == Cox / Fagan Structures and Unions 40

41 Operations on Bit Vectors const unsigned int low_three_bits_mask = 0x7; unsigned int bit_vec = 0x15; Clearing bits: bit_vec &= ~low_three_bits_mask; Result =? == & ~

42 Bit-field Structures Special syntax packs structure values more tightly Similar to bit vectors, but arguably easier to read Nonetheless, bit vectors are more commonly used. Padded to be an integral number of words Placement is compilerspecific. struct Flags { int f1:3; unsigned int f2:1; unsigned int f3:2; my_flags; my_flags.f1 = -2; my_flags.f2 = 1; my_flags.f3 = 2; f1 f2 f

43 Operator Precedence var++, var-- +, - (Unary plus and minus), ++var,--var (type) Casting! (Not) *, /, % (Multiplication, division, and modulus) +, - (Binary addition and subtraction) <, <=, >, >= (Comparison) ==,!=; (Equality) & (Unconditional AND) ^ (Exclusive OR) (Unconditional OR) && (Conditional AND) Short-circuit AND (Conditional OR) Short-circuit OR =, +=, -=, *=, /=, %= (Assignment operator)

44 C Instructions 44