Understand more about C

2016

issue.hsu@gmail.com

2

An Example

• What will happen if you try to compile, link and run this program?

int main(){ int a = 42; printf(“%d\n”, a);}

You must #include , add a return 0 and then it will compile and link. When executed it will print the value 42 on the screen.

3

An Example

• What will happen if you try to compile, link and run this program?

int main(){ int a = 42; printf(“%d\n”, a);}

You probably want to #include which has an explicit declaration of printf(). The program will compile, link and run, and it will write the number 42 followed by a newline to the standard output stream.

A proper C compiler will create an implicit declaration for the function printf(), compile this code into an object file.

And when linked with a standard library, it will find a definition of printf()that accidentally will match the implicit declaration.

So the program above will actually compile, link and run.

4

An Example

• What will happen if you try to compile, link and run this program?

int main(){ int a = 42; printf(“%d\n”, a);}

If this is C99, the exit value is defined to indicate success to the runtime environment, just like in C++98, but for older versions of C, like ANSI C and K&R, the exit value from this program will be some undefined garbage value.

But since return values are often passed in a register I would not be surprised if the garbage value happens to be 3... since printf() will return 3, the number of characters written to standard out.

5

An Example

• What will happen if you try to compile, link and run this program?

int main(){ int a = 42; printf(“%d\n”, a);}

And talking about C standards... if you want to show that you care about C programming, you should use int main(void) as your entry point - since the standard says so.

Using void to indicate no parameters is essential for declarations in C, eg a declaration ‘int f();’, says there is a function f that takes any number of arguments. While you probably meant to say ‘int f(void);’. Being explicit by using void also for function definitions does not hurt.

6

An Example

• Here is what I get when compiling, linking and running the above program on my machine

$ gcc -std=c89 hello1.c$ ./a.out42$ echo $?3

$ gcc -std=c99 hello1.c$ ./a.out42$ echo $?0

#include <stdio.h>int main(void){ int a = 42; printf(“%d\n”, a);}

The default mode for C is now -std=gnu11 instead of -std=gnu89 in GCC-5

7

Would it be useful if most of your colleagues have a deep understanding of the C programming language they are using?

https://algoritmaveprogramlama.files.wordpress.com/2013/10/c_pic.png

8

More C examples

• What is the result of following C code?

#include <stdio.h>void foo(void){

int a = 3;++a;printf("%d\

n", a);}int main(void){

foo();foo();foo();

}

9

More C examples

• What is the result of following C code?

#include <stdio.h>void foo(void){

static int a = 3;

++a;printf("%d\

n", a);}int main(void){

foo();foo();foo();

}

10

More C examples

• What is the result of following C code?

#include <stdio.h>void foo(void){

static int a;++a;printf("%d\

n", a);}int main(void){

foo();foo();foo();

}

11

More C examples

• What is the result of following C code?

#include <stdio.h>void foo(void){

int a;++a;printf("%d\

n", a);}int main(void){

foo();foo();foo();

}

12

More C examples

• What is the result of following C code?

#include <stdio.h>static int a;void foo(void){

++a;printf("%d\

n", a);}int main(void){

foo();foo();foo();

}

13

More C examples

• What is the result of following C code?

#include <stdio.h>int a;void foo(void){

++a;printf("%d\

n", a);}int main(void){

foo();foo();foo();

}

14

More C examples

• Can you explain this behavior?

#include <stdio.h>void foo(void){ int a; printf("%d\n", a);}void bar(void){ int a = 42;}int main(void){ bar(); foo();}

$ gcc hello3.c && ./a.out42

$ gcc –O2 hello3.c && ./a.out0

15

More C examples

• What about this code snippet?

#include <stdio.h>void foo(void){ int a = 41; a = a++; printf("%d\n", a);}int main(void){ foo();}

16

More C examples

• What about this code snippet?

#include <stdio.h>

int b(void) { puts(“3”); return 3; }int c(void) { puts(“4”); return 4; }

int main(void){ int a = b() + c(); printf(“%d\n”, a);}

17

More C examples

• What do these code snippets print?

int a=41; a++; printf("%d\n", a);

int a=41; a++ & printf("%d\n", a);

int a=41; a++ && printf("%d\n", a);

int a=41; if (a++ < 42) printf("%d\n", a);

int a=41; a = a++; printf("%d\n", a);

18

SEQUENCE POINT

19

Sequence point

• Sequence point– https://en.wikipedia.org/wiki/Sequence_point– A sequence point is a point in the program's execution sequence where all

previous side-effects shall have taken place and where all subsequent side-effects shall not have taken place

– A lot of developers think C has many sequence points

– The reality is that C has very few sequence points

– This helps to maximize optimization opportunities for the compiler

20

Sequence point

– Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression.

– Furthermore, the prior value shall be read only to determine the value to be stored.

21

Sequence point

• In C and C++, sequence points occur in the following places– Between evaluation of the left and right operands of the && (logical AND), ||

(logical OR) (as part of short-circuit evaluation), and comma operators.• For example, in the expression *p++ != 0 && *q++ != 0, all side effects of the sub-

expression *p++ != 0 are completed before any attempt to access q.– Between the evaluation of the first operand of the ternary "question-mark"

operator and the second or third operand.• For example, in the expression a = (*p++) ? (*p++) : 0 there is a sequence point after the

first *p++, meaning it has already been incremented by the time the second instance is executed.

– At the end of a full expression.• This category includes expression statements (such as the assignment a=b;), return

statements, the controlling expressions of if, switch, while, or do-while statements, and all three expressions in a for statement.

22

Sequence point

• In C and C++, sequence points occur in the following places– Before a function is entered in a function call.

• The order in which the arguments are evaluated is not specified, but this sequence point means that all of their side effects are complete before the function is entered.

• In the expression f(i++) + g(j++) + h(k++), f is called with a parameter of the original value of i, but i is incremented before entering the body of f. Similarly, j and k are updated before entering g and h respectively.

• However, it is not specified in which order f(), g(), h() are executed, nor in which order i, j, k are incremented. Variables j and k in the body of f may or may not have been already incremented. Note that a function call f(a,b,c) is not a use of the comma operator and the order of evaluation for a, b, and c is unspecified.

23

Sequence point

• In C and C++, sequence points occur in the following places– At a function return, after the return value is copied into the calling

context. (This sequence point is only specified in the C++ standard; it is present only implicitly in C)

– At the end of an initializer• for example, after the evaluation of 5 in the declaration int a = 5;.

– Between each declarator in each declarator sequence• for example, between the two evaluations of a++ in int x = a++, y = a++.

– Aftei the action associated with input/output conversion format specifier• For example, in the expression printf(“foo %n %d”, &a, 42), there is a sequence

point after the %n is evaluated before printing 42

24

POINTERS

25

Pointers vs. Arrays

• What is the output of following code?

#include <stdio.h>#include <string.h>int main(){ char *p = "hello"; char q[] = "hello"; printf("%zu\n", sizeof(p)); printf("%zu\n", sizeof(q)); printf("%zu\n", strlen(p)); printf("%zu\n", strlen(q));

return 0;}

26

Pointers vs. Arrays

• What is the output of following code?

#include <stdio.h>#include <string.h>int main(){ char *p = "hello"; char q[] = "hello"; printf("%zu\n", sizeof(p)); printf("%zu\n", sizeof(q)); printf("%zu\n", strlen(p)); printf("%zu\n", strlen(q));

return 0;}

• the sizeof operator• sizeof(array) returns the amount of

memory used by all elements in array• sizeof(pointer) only returns the amount of

memory used by the pointer variable itself• the & operator

• &array is an alias for &array[0] and returns the address of the first element in array

• &pointer returns the address of pointer

27

Pointers vs. Arrays

• What is the output of following code?

#include <stdio.h>#include <string.h>int main(){ char *p = "hello"; char q[] = "hello"; printf("%zu\n", sizeof(p)); printf("%zu\n", sizeof(q)); printf("%zu\n", strlen(p)); printf("%zu\n", strlen(q));

return 0;}

• a string literal initialization of a character array• char array[] = “abc” sets the first four

elements in array to ‘a’, ‘b’, ‘c’, and ‘\0′• char *pointer = “abc” sets pointer to the

address of the “abc” string (which may be stored in read-only memory and thus unchangeable)

28

Pointers vs. Arrays

• What is the output of following code?

#include <stdio.h>#include <string.h>int main(){ char *p = "hello"; char q[] = "hello"; printf("%zu\n", sizeof(p)); printf("%zu\n", sizeof(q)); printf("%zu\n", strlen(p)); printf("%zu\n", strlen(q));

return 0;}

• pointer variable can be assigned a value whereas array variable cannot be

• arithmetic on pointer variable is allowed whereas array variable is not

29

Pointers vs. Arrays

• What is the output of following code?

#include <stdio.h>#include <string.h>void foo(char *p) { printf("%zu\n", sizeof(p)); printf("%zu\n", strlen(p));}void bar(char q[]) { printf("%zu\n", sizeof(q)); printf("%zu\n", strlen(q));}int main() { foo("hello"); bar("hello"); return 0;}

* arrays passed to functions are converted to pointers

30

SIZEOF

31

Example of sizeof

• What about this code snippet?

#include <stdio.h>struct X { int a; char b; int c; };

int main(void){ printf("%zu\n", sizeof(int)); printf("%zu\n", sizeof(char)); printf("%zu\n", sizeof(struct X));}

It all depends on the platform and the compile time options provided. The only thing we know for sure is that sizeof char is 1

4112

with -fpack-struct option419

It is very expensive to work on subword data types, so the compiler will optimize the code by making sure that c is on a word boundary by adding some padding.

Suppose the program is on a 64-bit machine running in 32-bit compatibility mode

32

Example of sizeof

• What about this code snippet?

#include <stdio.h>struct X { int a; char b; int c; char d; };

int main(void){ printf("%zu\n", sizeof(int)); printf("%zu\n", sizeof(char)); printf("%zu\n", sizeof(struct X));}

4116

with -fpack-struct option4110

33

Example of sizeof

• What about this code snippet?

#include <stdio.h>struct X { int a; char b; int c; char *d; };

int main(void){ printf("%zu\n", sizeof(int)); printf("%zu\n", sizeof(char)); printf("%zu\n", sizeof(struct X));}

4124

with -fpack-struct option4117

Suppose the program is on a 64-bit machine running in 64-bit mode

c

b

a

d

24

16

12

8

4

0

34

ALIGNMENT

35

Alignment issue

The legacy code snip is working well in X86 CISC machine where instructions are available to directly access unaligned data in memory.

When porting this legacy code from a CISC architecture to ARM RISC machine, it will have some issues.

• The most common unaligned access code

#include <stdio.h>struct X { int a; char b; int c; char *d;} __attribute((packed));

int main(void) { struct X ss; ss.c = 10; return ss.c;}

http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0472h/BABFDBCJ.html

36

Alignment issue

The ARM compiler generates assembly language code that reads the word using an LDR instruction.

If the address is not a multiple of four, the LDR instruction returns a rotated result rather than performing a true unaligned word load.

#include <stdio.h>struct X { int a; char b; int c; char *d;} __attribute((packed));

int main(void) { struct X ss; ss.c = 10; return ss.c;}

0 1 2 3 4 5 6 7 8

Generally, this rotation is not what the programmer expects.

• The most common unaligned access code

37

Alignment issue

X86 asm:.loc 1 11 0 movl $10, -27(%rbp).loc 1 12 0 movl -27(%rbp), %eax

ARMv5 asm:.loc 1 11 0 ldr r3, [fp, #-16] and r3, r3, #255 orr r3, r3, #2560 str r3, [fp, #-16] mov r3, #0 strb r3, [fp, #-12].loc 1 12 0 ldr r3, [fp, #-16] mov r3, r3, lsr #8 ldrb r2, [fp, #-12] @ zero_extendqisi2 mov r2, r2, asl #24 orr r3, r2, r3 mov r0, r3

#include <stdio.h>struct X { int a; char b; int c; char *d;} __attribute((packed));

int main(void) { struct X ss; ss.c = 10; return ss.c;}

b

a

d

161514131211109876543210

c

• The most common unaligned access code

38

Alignment issue

ARMv7 asm:.loc 1 11 0 ldr r3, [fp, #-16] uxtb r3, r3 orr r3, r3, #2560 str r3, [fp, #-16] mov r3, #0 strb r3, [fp, #-12].loc 1 12 0 ldr r3, [fp, #-15] @ unaligned mov r0, r3

ARMv5 asm:.loc 1 11 0 ldr r3, [fp, #-16] and r3, r3, #255 orr r3, r3, #2560 str r3, [fp, #-16] mov r3, #0 strb r3, [fp, #-12].loc 1 12 0 ldr r3, [fp, #-16] mov r3, r3, lsr #8 ldrb r2, [fp, #-12] @ zero_extendqisi2 mov r2, r2, asl #24 orr r3, r2, r3 mov r0, r3

#include <stdio.h>struct X { int a; char b; int c; char *d;} __attribute((packed));

int main(void) { struct X ss; ss.c = 10; return ss.c;}

On ARMv6 and later architectures, unaligned access is fully supported.

-munaligned-access-mno-unaligned-accessEnables (or disables) reading and writing of 16- and 32- bit values from addresses that are not 16- or 32- bit aligned. By default unaligned access is disabled for all pre-ARMv6 and all ARMv6-M architectures, and enabled for all other architectures.https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html

b

a

d

161514131211109876543210

c

• The most common unaligned access code

39

Alignment issue

#include <stdio.h>struct X { int a; char b; int c; char *d;} __attribute((packed));

int main(void) { struct X ss; ss.c = 10; return ss.c;}

http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0333h/Cdfcgggi.html

• A==1:• unaligned access causes an Alignment fault Data Abort

exception• U==0 and A==0:

• if unaligned access, the LDR instruction returns a rotated result rather than performing a true unaligned word load

• U==1 and A==0:• unaligned access support for loads and stores of single 16-bit

half-words and 32-bit words

Table L-1 SCTLR.U bit values for different architecture versions in ARM architecture reference manual

• The most common unaligned access code

40

INLINE FUNCTION

41

Inline function

• gcc inlinea.c inlineb.c– inlineb.c: multiple definition of 'max'

• gcc inlinea.c inlineb.c -O1– inlineb.c: multiple definition of 'max'

• gcc inlinea.c inlineb.c -std=c99– inlinea.c: undefined reference to 'max' – inlineb.c: undefined reference to 'max'

• gcc inlinea.c inlineb.c -std=c99 -O1– compiled successfully

/* inline.h header file */inline int max(int a, int b) { return a > b ? a : b;}

/* inlinea.c source file */#include "inline.h“extern int foo(int a, int b);

int main(void) { int a; a = foo(10,20); a = max(a,30); return a;}

/* inlineb.c source file */#include "inline.h“

int foo(int a, int b) { int c; c = max(a,b); return c;}

42

Inline function

• gcc inlinea.c inlineb.c– inlinea.c: undefined reference to 'max' – inlineb.c: undefined reference to 'max'

• gcc inlinea.c inlineb.c -O1– compiled successfully

• gcc inlinea.c inlineb.c -std=c99– inlineb.c: multiple definition of 'max'

• gcc inlinea.c inlineb.c -std=c99 -O1– inlineb.c: multiple definition of 'max'

/* inline.h header file */extern inline int max(int a, int b) { return a > b ? a : b;}

/* inlinea.c source file */#include "inline.h“extern int foo(int a, int b);

int main(void) { int a; a = foo(10,20); a = max(a,30); return a;}

/* inlineb.c source file */#include "inline.h“

int foo(int a, int b) { int c; c = max(a,b); return c;}

43

Inline function

• static inline– The definition is equal in GNU89 and C99.– The function will be used in the same translation units. If the function is inlined, the

stand-alone object code is never emitted.– If the function is not inlined, the stand-alone object code will be emitted, but it can

not be used by other translation units.

• Inline– In GNU89, no matter the function is inlined, the stand-alone object code will be

emitted, and can be used by other translation units.– In C99, no matter the function is inlined, the stand-alone object code will not be

emitted.

• extern inline– In GNU89, no matter the function is inlined, the stand-alone object code will not be

emitted.– In C99, no matter the function is inlined, the stand-alone object code will be

emitted, and can be used by other translation units.

44

Inline function – Portable model

• gcc inlinea.c inlineb.c– compiled successfully

• gcc inlinea.c inlineb.c -std=c99– compiled successfully

• gcc inlinea.c inlineb.c -O1– compiled successfully

• gcc inlinea.c inlineb.c -std=c99 -O1– compiled successfully

/* inline.h header file */static inline int max(int a, int b) { return a > b ? a : b;}

/* inlinea.c source file */#include "inline.h"extern int foo(int a, int b);

int main(void) { int a; a = foo(10,20); a = max(a,30); return a;}

/* inlineb.c source file */#include "inline.h"

int foo(int a, int b) { int c; c = max(a,b); return c;}

inlinea.o: U foo T main t max

inlineb.o: T foo t max

inlinea.o: U foo T main

inlineb.o: T foo

45

Inline function –GNU89 model

• gcc inlinea.c inlineb.c– compiled successfully

• gcc inlinea.c inlineb.c -O1– compiled successfully

/* inline.h header file */extern inline int max(int a, int b) { return a > b ? a : b;}

/* inlinea.c source file */#include "inline.h"extern int foo(int a, int b);

int main(void) { int a; a = foo(10,20); a = max(a,30); return a;}

/* inlineb.c source file */#include "inline.h"int max(int a, int b);

int foo(int a, int b) { int c; c = max(a,b); return c;}

inlinea.o: U foo T main

inlinea.o: U foo T main U max

inlineb.o: T foo T max

inlineb.o: T foo T max

46

Inline function –C99 model

• gcc inlinea.c inlineb.c -std=c99– compiled successfully

• gcc inlinea.c inlineb.c -std=c99 -O1– compiled successfully

/* inline.h header file */inline int max(int a, int b) { return a > b ? a : b;}

/* inlinea.c source file */#include "inline.h"extern int foo(int a, int b);

int main(void) { int a; a = foo(10,20); a = max(a,30); return a;}

/* inlineb.c source file */#include "inline.h"extern int max(int a, int b);

int foo(int a, int b) { int c; c = max(a,b); return c;}

inlinea.o: U foo T main U max

inlinea.o: U foo T main

inlineb.o: T foo T max

inlineb.o: T foo T max

References:http://www.greenend.org.uk/rjk/tech/inline.htmlhttps://gustedt.wordpress.com/2010/11/29/myth-and-reality-about-inline-in-c99/http://www.drdobbs.com/the-new-c-inline-functions/184401540https://gcc.gnu.org/onlinedocs/gcc/Inline.html

47

ADD-ON

48

Volatile type qualifier

• Two functions each executed in a separate thread with the same pointer as a parameter

void add( int *i) { while (1) { *i = 0; for (int a=0; a<10; a++) (*i)++; }}

void check( int *i) { while (*i != 5) ;}

void add(volatile int *i) { while (1) { *i = 0; for (int a=0; a<10; a++) (*i)++; }}

void check( int *i) { while (*i != 5) ;}

C99 support

Referenceshttps://en.wikipedia.org/wiki/Volatile_%28computer_programming%29https://gcc.gnu.org/onlinedocs/gcc/Volatiles.html

49

Variable length argument

• http://blog.aaronballman.com/2012/06/how-variable-argument-lists-work-in-c/

#include <stdarg.h>void foo( int bar, ... ){ va_list args; va_start( args, bar );

for (;;) { some_type t = va_arg( args, some_type ); /* Do something with t */ } va_end( args );}

50

Nested function

#include <stdio.h>typedef int (*func_t)(int);static func_t foo(int arg){ int nested(int nested_arg) { return (arg + nested_arg); } return &nested;}int main(){ func_t g = foo(100); printf("%d\n", (*g)(20)); return 0;}

nested: access foo frame by ip register mov r0, #result bx lr

foo: load .LTRAMP0 into stack store the @frame to TRAMP0[2] store the @nested to TRAMP0[3] flush cache mov r0, @TRAMP0 bx lr

main: bl foo blx r0 bl printf bx lr

.word TRAMP0

.word nested

TRAMP0: ldr ip, [pc, #0] ldr pc, [pc, #0] .word 0 .word 0 trampoline

Referenceshttps://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.htmlhttps://gcc.gnu.org/onlinedocs/gccint/Trampolines.htmlhttp://blog.linux.org.tw/~jserv/archives/2010/07/gcc_nested_func.html

51

Arrays of length zero

• Arrays of Length Zero

#include <stdio.h>struct X { int a; char b; int c; char d[0];};

int main(void) { printf("%zu\n", sizeof(struct X)); return 0;}

#include <stdio.h>struct X { int a; char b; int c; char d[];};

int main(void) { printf("%zu\n", sizeof(struct X)); return 0;}

A real case in linux kernel: http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/romfs_fs.h

C99: flexible array memberGNU C supportC90 should have length 1

C99: array of a variable sized[length], length is runtime define

https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html

52

Restricted pointers (C99)

• What is the issue of the following code?

• Solution:

void copy( char *s1, char *s2, int n){ while (n--) *s1++ = *s2++;}

void copy ( char restrict *s1, char restrict *s2, int n){ while (n--) *s1++ = *s2++;}

53

APPENDIX

54

More about new standard

• C99– https://en.wikipedia.org/wiki/C99

• C11– https://en.wikipedia.org/wiki/C11_%28C_standard_revision%29– http://blog.smartbear.com/codereviewer/c11-a-new-c-standard-ai

ming-at-safer-programming/

55

References

• 「你所不知道的 C 語言」系列講座• Deep C• Are pointers and arrays equivalent in C?• Lesser known C features