Assembly+Language/wizardcode4.pdf.txt

Wizard Code
A View on Low-Level Programming DRAFT VERSION 4

Tuomo Petteri Venäläinen

November 27, 2016

2

Ramblings on hacking low-level and other kinds of code.

Copyright (C) 2008-2012 Tuomo Petteri Venäläinen

Part I

Table of Contents

3

Contents

I Table of Contents

II

Ideas

III Preface

1 Forewords

.

.

.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

1.1 First Things .

Preface .
.

.
1.1.1 Thank You .
.
.
1.1.2
.
1.1.3 Goals .
.
1.1.4 Rationale .
.
1.1.5 C Language .

. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
Software Development . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .

1.1.5.1 Overview . .
1.1.5.2 History .
Future .
1.1.5.3
.

1.1.6 KISS Principle .
1.1.7
1.1.8 Conclusions .
1.2 Suggested Reading .

.
. .
.

. . . . .

.
.

.
.

.
.

2 Overview

IV Notes on C

3 C Types

3.1 Base Types
.
3.2 Size-Specific Types .

.

.

.

.

.
.

.
.

.
.

.

.

.

.

Fast Types

3.2.1 Explicit-Size Types .
3.2.2
.
3.2.3 Least-Width Types .
.

3.3 Other Types .
.
3.4 Wide-Character Types
.
3.5 Aggregate Types
.

.
Structures .
3.5.1.1

.
.
.
.
.
.
Examples

3.5.1

.
.
.
.

.

.

.

. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . .
.

3

13

17

21
21
21
22
22
22
23
23
23
24
24
25
25
26

27

29

31
31
32
32
32
33
33
34
34
34
35

5

6

CONTENTS

.

.

.

.

. .

3.8

3.7

. . .

. . .

. . .

3.6 Arrays .

. . .
. . . .
. .
. . . .

3.5.2 Unions
3.5.3 Bitfields .
.

.
3.6.1 Example
.
.
.
typedef
3.7.1 Examples . .
sizeof
.
.
.
.
3.8.1 Example
.
offsetof
3.9.1 Example

. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
3.10 Qualifiers and Storage Class Specifiers . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .

. . . .
3.10.1 const
. . . .
3.10.2 static
3.10.3 extern . . . .
3.10.4 volatile . . .
. . .
3.10.5 register
. . . .
.

. . . .
. .
. . . .
. .

. . .
. . .
. . .
. . .
. . .

3.11 Type Casts .

. . .

. . .

3.9

.

.

.

.

void Pointers

4 Pointers
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1
.
. . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Pointer Basics .
. . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
4.3 Pointer Arithmetics . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . .
4.4 Object Size .

.

5 Logical Operations
5.1 C Operators .

.

5.1.1 AND . . . .
5.1.2 OR .
. . . .
5.1.3 XOR . . . .
5.1.4 NOT . . . .
5.1.5 Complement

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .

. . .
. . .
. . .
. . .
.

. . .

6 Memory

6.1 Alignment .
6.2 Word Access

.

. . .
. . .

. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .

7 System Interface
7.1 Signals .
.
7.2 Dynamic Memory .

. .

.

.

7.2.1 Heap . . . .
. . .
7.2.2 Mapped Memory .

. . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .

8 C Analogous to Assembly

8.1

’Pseudo-Assembly’ . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pseudo Instructions . . . . . . . . . . . . . . . . . . . . . . .
8.1.1
8.2 Addressing Memory . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3 C to Assembly/Machine Translation . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .

. . .
. . .
if - else if - else
. . .
switch .

8.3.1 Branches

8.3.1.1
8.3.1.2

35
36
36
36
37
37
38
38
38
38
39
39
39
40
41
41
41

43
43
43
44
44

47
47
47
47
48
48
48

49
49
49

51
51
52
54
54

55
55
55
56
56
56
56
57

CONTENTS

.

.
.

.
.
for

.
8.3.2 Loops .
8.3.2.1
.
8.3.2.2 while .
8.3.2.3
Function Calls

8.3.3

do-while . .
.

.

.

.
. .
.

. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .

. . . . .

.
.
.

9 C Run Model

.

.

.

.

.

.
.

.
.

9.1.1

9.1 Code Execution .

9.1.2 TEXT Segment .
.
9.1.3 RODATA Segment
.
9.1.4 DATA Segment .
.
.
9.1.5 BSS Segment .
.
9.1.6 DYN Segment
.
.
STACK Segment
9.1.7
.
.
.
.
9.2 C Interface
Stack .
.
.
.
9.2.1
9.2.1.1
Frame Pointer .
.
Program Counter aka Instruction Pointer

.
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
Program Segments .
9.1.1.1 Minimum Segmentation . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . .
. .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
.
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
.
.
. . . . . . . . . . . . . . . . . . . . . .
.
Stack Pointer . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
Function Arguments . . . . . . . . . . . . . . . . .
Return Value . . . . . . . . . . . . . . . . . . . . .
i386 Function Calls . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
Interface
. . . . . . . . . . . . . . . . . . . . .
9.3.1.1
. . . . . . . . . . . . . . . . . . . . . .
Implementation .
IA-32 implementation . . . . . . . . . . . . . . . .
9.3.2.1
9.3.2.2 X86-64 Implementation . . . . . . . . . . . . . . .
9.3.2.3 ARM Implementation . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
setjmp.c .

9.2.2
9.2.3
9.2.4 Automatic Variables
.
Stack Frame
9.2.5
.
Function Calls
9.2.6
9.2.6.1
9.2.6.2
9.2.6.3

9.3 Nonlocal Goto; setjmp() and longjmp()

9.3.1

9.3.2

9.3.3

.
.
<setjmp.h> .

.
.

.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

V Computer Basics

.
.

.
.

.
.

.
.

.
.

10 Basic Architecture
.
10.1 Control Bus .
10.2 Memory Bus
.
10.3 Von Neumann Machine .
.
.
.
.

.
10.3.1 CPU .
10.3.2 Memory .
.
10.3.3 I/O .
.
10.4 Conclusions .

.
.
.
.

.
.
.
.

.
.
.
.

.
.

.

.
.
.
.
.
.
.

. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
.
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .

7

58
58
59
59
60

63
64
64
64
64
64
65
65
65
65
66
66
66
66
66
66
67
67
68
68
69
71
72
72
72
73
74
77
79

81

85
85
85
85
86
86
86
86

CONTENTS

8

VI Numeric Values

11 Machine Dependencies
. . .
. . .

11.1 Word Size .
11.2 Byte Order

.
.

12 Unsigned Values

. . .
. . .

. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .

. . .

. . . . . . . . . . . . . . . . . . . . . . . . . .
12.1 Binary Presentation .
. . . . . . . . . . . . . . . . . . . . . . . .
12.2 Decimal Presentation . .
12.3 Hexadecimal Presentation . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
12.4 Octal Presentation .
. . . . . . . . . . . . . . . . . . . . . . . . .
12.5 A Bit on Characters . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
12.6 Zero Extension . . .
. . . . . . . . . . . . . . . . . . . . . . . .
12.7 Limits .
. . . . . . . . . . . . . . . . . . . . . . . .
12.8 Pitfalls .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .

.
.
12.8.1 Underflow . .
12.8.2 Overflow . .

. . .
. . .

. . .
. . .

.
.

.
.

13 Signed Values

13.1 Positive Values
. . .
13.2 Negative Values . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
13.2.1 2’s Complement
13.2.2 Limits . .
. . . . . . . . . . . . . . . . . . . . . . .
13.2.3 Sign Extension . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
13.2.4 Pitfalls
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .

13.2.4.1 Underflow . . . . .
. . . . .
13.2.4.2 Overflow .

. . . . .

. . . . .

. .

. .

14 Floating Point Numeric Presentation
.

. . .

. .

.

.

. .
. .

. . . . . . . . . . . . . . . . . . . . . . . . .
14.1 Basics .
14.2 IEEE Floating Point Presentation . . . . . . . . . . . . . . . . . . . .
14.2.1 Significand; ’Mantissa’ . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
14.2.2 Exponent
. . . . . . . . . . . . . . . . . . . . . . . . . .
14.2.3 Bit Level
14.2.4 Single Precision . . . . . . . . . . . . . . . . . . . . . . . .
14.2.4.1 Zero Significand .
. . . . . . . . . . . . . . . . . .
14.2.4.2 Non-Zero Significand . . . . . . . . . . . . . . . .
14.2.5 Double Precision . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. .
. . . . . . . . . . . . . . . . . . . . . .
14.2.6.1 80-Bit Presentation . . . . . . . . . . . . . . . . .
14.3 i387 Assembly Examples . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .

14.3.1 i387 Header .
14.3.2 i387 Source . . . . .

14.2.6 Extended Precision .

14.2.5.1 Special Cases

VII Machine Level Programming

15 Machine Interface

15.1 Compiler Specification .

. . . . . . . . . . . . . . . . . . . . . . . .

89

93
93
94

97
97
97
98
99
99
99
100
100
100
100

103
103
103
103
104
104
104
104
104

105
105
106
106
106
106
107
107
107
108
108
108
108
109
109
109

115

117
117

CONTENTS

15.1.1 <cdecl.h> .

.
15.2 Machine Definition .
.

15.2.1 <mach.h> .

.
.
.

.
.
.

16 IA-32 Register Set

16.1 General Purpose Registers
.
16.2 Special Registers
.
.
16.3 Control Registers .

.
.

.
.

17 Assembly

.
.
.

.
.

. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.

. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .

17.1 AT&T vs. Intel Syntax .

.

. . . . . . . . . . . . . . . . . . . . . . .
17.1.1 Syntax Differences .
. . . . . . . . . . . . . . . . . . . . . .
17.1.2 First Linux Example . . . . . . . . . . . . . . . . . . . . . .
17.1.3 Second Linux Example . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .

17.1.3.1 Stack Usage .

18 Inline Assembly
.
18.1 Syntax .

18.2 Constraints

.

.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
18.1.1 rdtsc() .
.

. . . . . . . . . . . . . . . . . . . . . . .
.
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . . .
.
.
. . . . . . . . . . . . . . . . . . . . . .
.
18.2.1 IA-32 Constraints .
. . . . . . . . . . . . . . . . . . . . . .
18.2.2 Memory Constraint .
18.2.3 Register Constraints
. . . . . . . . . . . . . . . . . . . . . .
18.2.4 Matching Constraints . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
18.2.5 Other Constraints .
. . . . . . . . . . . . . . . . . . . . . .
18.2.6 Constraint Modifiers . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.

.
18.3.1 Memory Barrier

18.2.4.1 Example; incl

.
.

.

.

18.3 Clobber Statements .

19 Interfacing with Assembly
.

19.1 alloca()

.

.

.

.
.
.
19.1.1 Implementation .
.
19.1.2 Example Use .

.

.

.
.
.

. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.

VIII Code Style

.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.
.

20 A View on Style
.
20.1 Concerns
20.2 Thoughts
.
20.3 Conventions .

.
.
.
.
.
.
20.3.1 Macro Names .
.
20.3.2 Underscore Prefixes
.
20.3.3 Function Names
.
20.3.4 Variable Names .
.
.
20.3.5 Abbreviations .
.
.
20.4 Naming Conventions .
.
.
.
20.5 Other Conventions

.

. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
.
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .

9

117
118
118

119
119
119
119

121
121
122
122
123
124

127
127
127
129
129
129
129
129
129
130
130
130
130

131
131
132
133

135

137
137
138
139
139
140
140
140
141
143
144

CONTENTS

147

10

IX Code Optimisation

21 Execution Environment

21.1 CPU Internals . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .
21.1.1 Prefetch Queue . . . . . . . . . . . . . . . . . . . . . . . . .
21.1.2 Pipelines
. . . . . . . . . . . . . . . . . . . . . . . . . .
21.1.3 Branch Prediction . . . . . . . . . . . . . . . . . . . . . . . .

. .

22 Optimisation Techniques

22.6 Bit Operations . .

22.7 Small Techniques . .

22.8 Memory Access . . .
.

22.1 Data Dependencies . . .
22.2 Recursion Removal
22.3 Code Inlining . . .
22.4 Unrolling Loops . . .

.
. . .

22.5 Branches

.

. . .

. . .

. . . . .

22.4.1 Basic Idea .

22.5.3 Jump Tables

22.5.2.1 Duff’s Device . .

.
.
22.5.1 if - else if - else . . .
. . . . .
22.5.2 switch . . .

. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
22.6.1 Karnaugh Maps . . . . . . . . . . . . . . . . . . . . . . . . .
22.6.2 Techniques and Tricks . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
22.7.1 Constant Folding . . . . . . . . . . . . . . . . . . . . . . . .
22.7.2 Code Hoisting . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
22.8.3.1 Cache Prewarming . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
22.10.4.1 Example Implementation . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
22.11.2 Fade In/Out Effects . . . . . . . . . . . . . . . . . . . . . . .

22.10.1 Bit Flags
22.10.2 Lookup Tables
22.10.3 Hash Tables . . . . .
22.10.4 The V-Tree . . . . .

22.8.1 Alignment
22.8.2 Access Size . . . . .
22.8.2.1 Alignment
. . . . .

22.9.1.1 Algorithms . . . .
22.9.1.2 Statistics . . . .
. . .
.

22.11.1.1 C Routines . . .
22.11.1.2 MMX Routines
22.11.1.3 Cross-Fading Images

22.11.1 Alpha Blending . . .

22.8.3 Cache . . .

. . .
.

. . . . .

. . . . .

. . .

. . .

.

22.9 Code Examples .
22.9.1 pagezero()

22.11Graphics Examples . .

22.10Data Examples

149
149
149
149
149

151
151
152
153
154
154
155
155
155
155
157
158
159
159
160
160
160
161
161
161
161
162
162
162
162
163
169
179
179
179
180
180
180
189
190
191
195
197
197

CONTENTS

X Code Examples

23 Zen Timer

23.1 Implementation .

. . . . . . . . . . . . . . . . . . . . . . .
23.1.1 Generic Version; gettimeofday() . . . . . . . . . . . . . . . .
23.1.2 IA32 Version; RDTSC . . . . . . . . . . . . . . . . . . . . .

.

.

.

.

.

24 C Library Allocator
.

24.1 Design .

.

.

.

.

.

.
24.2 Implementation .

.
.
24.1.1 Buffer Layers .
.
24.1.2 Details
.

.
.
.
.
24.2.1 UNIX Interface .
.
24.2.2 Source Code .

.
.

.
.

.
.
.
.
.
.

. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
.
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.

A Cheat Sheets

A.1 C Operator Precedence and Associativity . . . . . . . . . . . . . . .

B A Bag of Tricks

C Managing Builds with Tup
.
.

C.1 Overview .
C.2 Using Tup .

.
.

.
.

.
.

.
.

.
.
C.2.1 Tuprules.tup .
.
C.2.2 Tup Syntax .
.
.
.
C.2.3 Variables
.
.
.
.
C.2.4 Rules .
.
.
.
C.2.5 Macros .
.
.
C.2.6 Flags
.
.
.
.
C.2.7 Directives .

.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. .
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.
. . . . . . . . . . . . . . . . . . . . . .
.

11

201

203
203
203
204

205
205
205
206
207
207
209

247
248

249

259
259
260
260
260
260
261
262
262
262

12

CONTENTS

Part II

Ideas

13

15

I think this book should take a closer look on ARM assembly; ARM processors are very
common in systems such as smart phones, and provide a power- and budget-friendly
way to get into computing for people such as our children. One page to check out is

http://www.raspberrypi.org/;

the Raspberry Pi seems to be a quite useful, ultra-low cost computer with USB ports,
Ethernet, and other modern features. I would strongly recommend it for projects such
as learning assembly programming. A big thank you for Jeremy Sturdivant for pro-
viding me a Raspi. :D

16

Part III

Preface

17

19

Draft 4

Draft number 4 contains fixes in implementation of the C library nonlocal goto interface
with setjmp() and longjmp() functions. The assembly statements are now declared
__volatile__ and as single assembly statement to keep them safer from enemies such as
compiler optimisations as suggested by the GNU C Compiler info page as well as some
friendly folks on IRC on Freenode. :) In other words the code should be more robust
and reliable now. Notice how elegant the ARM implementation is; ARM assembly is so
cool it makes me want to program in assembly, something rare to nonexistent on most
PC architectures. I wonder if Intel and friends should release stripped-down versions
of their instruction sets in new CPU modules and back the plan up with support from
C compilers and other software. Books such as the Write Great Code series by Randall
Hyde,

see: http://www.writegreatcode.com/

could have suggestions for minimal versions of the wide-spread X86 instruction sets;
I’d look into using mostly IA-32 and X86-64 operations. As per competition, I’d give
everything I have for access to 64-bit ARM workstations; hopefully some shall pop
up in the market in due time...

Draft 2

This draft, version 2, has some rewordings, fixes typos and mistakes, and cleans a few
small things up. I found some mistakes in the code snippets as well.

20

Chapter 1

Forewords

This book started as a somewhat-exhaustive paper on computer presentation of integral
numeric values. As time went on, I started combining the text with my older and new
ideas of how to teach people to know C a bit deeper. I’m in the hopes this will make
many of the readers more fluent and capable C programmers.

1.1 First Things

Dedicated to my friends who have put up with me through the times of good and bad
and all those great minds behind good software such as classic operating systems and
computer games.

Be strong in the spirit,
the heart be thy guide,
Love be thy force,
life be thy hack.

1.1.1 Thank You

Big thanks to everyone who’s helped me with this book in the form of comments and
suggestions; if you feel I have forgotten to include your name here, please point it out...
As I unfortnately forgot to write some names down when getting nice feedback on IRC,
I want to thank the IRC people on Freenode collectively for helping me make the book
better.

(cid:15) Dale ’swishy’ Anderson
(cid:15) Craig ’craig’ Butcher
(cid:15) Ioannis Georgilakis
(cid:15) Matthew ’kinetik’ Gregan
(cid:15) Hisham ’CodeWarrior’ Mardam Bey

21

22

CHAPTER 1. FOREWORDS

(cid:15) Dennis ’dmal’ Micheelsen
(cid:15) Andrew ’Deimos’ Moenk
(cid:15) Michael ’doomrobo’ Rosenberg
(cid:15) Martin ’bluet’ Stensgård
(cid:15) Jeremy ’jercos’ Sturdivant
(cid:15) Vincent ’vtorri’ Torri
(cid:15) Andrew ’awilcox’ Wilcox
(cid:15) Timo Yletyinen

1.1.2 Preface

Wizard Code

Wizard Code is intended to provide a close look on low-level programming using the
ISO C and sometimes machine-dependent assembly languages. The idea is to gather
together information it took me years to come by into a single book. I have also in-
cluded some examples on other types of programming. This book is GNU- and UNIX-
friendly.

1.1.3 Goals

One of the goals of this book is to teach not only how to optimise code but mostly how
to write fast code to start with. This shows as chapters dedicated to optimisation topics
as well as performance measurements and statistics for some of the code in this book.

I hope this book satisfies both budding young programmers and experienced ones.
Have fun and keep the curious spirit alive.

1.1.4 Rationale

Why C?

One of the reasons I chose C as the language of preference is that it’s getting hard
to find good information on it; most new books seem to concentrate on higher-level
languages such as Java, Perl, Python, Ruby, and so on - even new books on C++ don’t
seem to be many these days. Another reason for this book is that I have yet to see a
book on the low-level aspects of C as a close-to-machine language.

Know the Machine

I think every programmer will still benefit from knowing how the machine works at the
lowest level. As a matter of fact, I consider this knowledge crucial for writing high-
performance applications, including but not limited to operating system kernels and
system libraries.

GNU & UNIX

1.1. FIRST THINGS

23

Where relevant, the example programs and other topics are UNIX- centric. This is
because, even though things are getting a bit awkward in the real world, UNIX is, deep
in its heart, a system of notable elegance and simplicity.

As they’re practically de facto standards today, I chose to use the GNU C Compiler
and other GNU tools for relevant parts of this book. For the record, Linux has been my
kernel of choice for one and a half decades. Some of the freely available programming
tools such as Valgrind are things you learn to rely on using Linux.

1.1.5 C Language

1.1.5.1 Overview

Personal View

I consider the C language the biggest contribution to software ever.

C is Low-Level

C is a low-level programming language. It was designed to have an efficient memory
abstraction - memory addresses are represented as pointers. Basic C operations map
to common machine instructions practically one-to-one. More complex operations are
consistently implemented in the standard library and system libraries. The runtime
requirements are very small. There exists a minimalistic but efficient standard library
that is a required part of C implementations. I think it’s good to say it shares much of
the elegance of early versions of UNIX.

C is Simple

C is a simple language. It doesn’t take long to learn the base for the whole language,
but it takes a long while to master it; assuming mastering it is a possibility.

C is Powerful

C is a powerful language. Pretty much no other language, short of assembly and C++,
lets you do everything C does - for the good and bad.

If you can’t do it in C, do it in assembly.

“If you can’t do it in assembly, it’s not worth doing.” C has long been the language of
choice for programmers of operating system kernels, scientific applications, computer
games, graphical applications, and many other kinds of software. There are plenty of
new languages and a bit of everything for everyone around, but C has kept its place as
what I call the number one language in the history of computer programming. What-
ever it is that you do, you have almost total control of the machine. Mixed with a bit
of inline and very rarely - unless you want to - raw assembly lets you do practically
everything you can with a microprocessor.

1.1.5.2 History

The Roots

24

CHAPTER 1. FOREWORDS

The roots of the C language lead to the legendary AT&T Bell Laboratories around the
turn of the 1960’s and 1970’s. Dennis Ritchie and other system hackers, most notably
Ken Thompson, needed a relatively machine-independent language to make it easier to
implement their new operating system, UNIX, in a more portable way.

Legend has it that UNIX actually started from a project whose purpose was to create
a computer game for an old PDP machine. I guess games aren’t all bad for inspira-
tion; another story tells that FreeBSD’s Linux emulation started as an attempt to make
’Frisbee’ run Linux versions of Doom.

1.1.5.3 Future

System Language

C is a traditional system language, and will very likely - even hopefully - continue
its existence as the language of choice for low-level programmers. Operating system
kernels can be implemented as stand-alone programs, but still require some assem-
bly programming. Most if not all common compilers allow relatively easy mixing of
assembly-language statements with C code; with a bit of care, you can command the
machine with its native instructions from C code quite easily and seamlessly.

Minimalistic Approach

With its minimalistic runtime requirements, machine-friendly data and code presenta-
tion, and relative ease of implementing custom libraries, C makes a great language for
development on embedded systems. Even though C is a great language for program-
ming high-speed applications for the desktop, the crazy amount of CPU horsepower
in modern PCs often makes other, higher-level languages more desirable for desktop
application development. However, typical embedded devices such as mobile phones
have more dire requirements for code speed and size. Hence, I predict a long and pros-
perous life for the C language, which many of us love - and sometimes hate - with
passion. :)

Code Speed

On the desktop, C still has its place in development of multimedia and other appli-
cations with extreme speed requirements. C excels at things such as direct hardware
access.

System Language

As a system language, C is and, in my opinion, should be an obvious choice for devel-
oping operating system kernels and other system software with.

1.1.6 KISS Principle

Simplicity

The KISS principle - Keep It Simple, Silly/Stupid - states that simplicity is a key goal
and that complexity should be avoided; in this case, particularly in computer software
development. Perhaps it also hints, in this context, at the ease of creating programs no
one else can understand.

1.1. FIRST THINGS

Elegance

25

It’s not necessarily obvious how much work it takes to find the essence of problems
being solved. Software developers had better not be judged in terms of how many
code lines they can produce - a much better measure would be how few lines they can
solve problems with. What the number of code lines doesn’t reveal is how many dead
ends and mediocre solutions it required to come up with a hopefully elegant and clean
solution.

Do What You Need to

To summarize the KISS principle for software development, do what you need to and
only what you need to. The simpler and fewer your operations, the faster the code. The
fewer lines of code, the fewer bugs.

1.1.7 Software Development

One-Man Projects

There are as many ways to develop software as there are software developers. I’m keen
on one-man projects, perhaps mostly because I’m still learning. In fact, I think one
of the really cool things about software development is that you never run out of new
things to learn. The field of software is relatively new and still taking form. New ways
to solve problems are being invented all the time.

The good things about one-man projects include no communication overhead and the
possibility for one person to know the whole system inside-out. Implementation and
design can be done simultaneously and mistakes fixed as they emerge.

Philosophy

For software development, as well as all creative work, I suggest following the way of
the empty mind. Close out all unnecessary distractions, become one with what you do,
think it, feel it, do it. Find total concentration with nothing but the task at hand in your
mind.

Art

Software is written expression, information, knowledge - software is art.

1.1.8 Conclusions

Essence

To develop great software, look for the essence of things. Keep your data structures
and code simple. Experiment with solutions, learn from the bad ones, try new ones.
Even though there may be no perfection, it’s still a good thing to reach for.

Statement

C is alive and a-rockin’!

26

CHAPTER 1. FOREWORDS

1.2 Suggested Reading

Books

Author(s)
Booth, Rick

Hyde, Randall

Hyde, Randall

Lamothe, Andre

Lions, John

Maxfield, Clyde

Book & ISBN
Inner Loops
0-201-47960-5
WRITE GREAT CODE, Volume 1: Understanding the Machine
1-59327-003-8
WRITE GREAT CODE, Volume. 2: Thinking Low-Level, Writing High-Level
1-59327-003-8
Black Art of 3D Game Programming
1-57169-004-2
Lions’ Commentary on UNIX 6th Edition with Source Code
1-57398-013-7
The Definitive Guide to How Computers do Math
0-471-73278-8

Warren, Henry S. Hacker’s Delight

0-201-91465-4

Chapter 2

Overview

A Look at C

This books starts with a look at the C programming language. It’s not written to be
the first course on C, but instead for programmers with some knowledge of the lan-
guage. The readers will get a grasp of some aspects of the ’new’ version of the lan-
guage (’C99’, ISO/IEC 9899) as well as other language basics. You will gain in-depth
knowledge of C’s stack-based execution, i.e. how code operates at machine level.
There is a bit of information about using C for system programming (signals, mem-
ory model) too, including a reasonably good standard library (malloc-style) dynamic
memory allocator. Pointers have their own chapter.

Compiler Optimisations

For most code in this book, the GCC flag -O is the best optimisation level to use.
At times, the code may run slower if you use -O2 and beyond. Where specific opti-
misations need to be enabled or disabled, I try to hint you at it. In particular, some
routines depend on ’standard’ use of frame pointer, hence it’s necessary to give GCC
the -fno-omit-frame-pointer flag for building correct code.

Basic Computer Architecture

Next we shall move on to basic computer architecture, followed by chapters describing
how computers represent numerical data internally. I will cover things such as integer
overflows and underflows; hopefully this could make spotting some of the more exotic
bugs easier. We are going to take a somewhat-quick look at how IEEE standard floating
point values are represented as well.

C and Assembly

The book continues with lower-level programming. We will see examples of special
compiler attributes (e.g. __packed__, __aligned__) that give us more control on our
code’s behavior. There’s a chapter on i386 machine architecture. We’ll learn a bit about
i386 assembly in general and using it with GCC and the other GNU tools in particular.
We will take a look at inline assembly and learn how to implement the setjmp() and
longjmp() standard library functions; these are one of the trickiest parts to implement
in a standard library in some ways.

27

28

Code Style

CHAPTER 2. OVERVIEW

There is a part in this book dedicated to code style to emphasize it’s an important aspect
of software development.

Code Optimisation

Code optimisation, as one of the things I’m keen on about programming, has a dedi-
cated set of chapters. We will first take a quick look at some machine features and then
roll our sleeves and start looking at how to write fast code. The Examples section has
a couple of pretty neat graphics algorithms. We implement simple tools to measure the
speed of our code in the section Zen Timer; the name Zen timer originally came from
Michael Abrash who has worked on such classic pieces of software as Quake.

A Bag of Tricks

As an easter egg to those of you who enjoy coding tricks, there’s a chapter called A Bag
of Tricks. There we take a look at some often quite-creative small techniques gathered
from sources such as the legendary MIT HAKMEM, the book Hacker’s Delight by
Henry S. Warren of IBM, as well as other books and the Internet. The implementations
are by myself and it would be nice to get comments on them.

The i386

Next in this book, we shall get deeper into the world of the i386 as well as take a look
at its details from the perspective of kernel programmers.

Author’s Comments

All in all, I have written about things I learnt during the course of the last decade or
so. Instead of being highly theoretical, I tried to write a book which concentrates on
’practical’ things, shows some interesting tricks, and perhaps gives you deeper insight
to the world of computers. I hope this book makes some of you better programmers.

With that being said, let’s start rockin’ and a-rollin’! :)

Part IV

Notes on C

29

Chapter 3

C Types

This section doesn’t attempt to be a primer on C types; instead, I cover aspects I con-
sider to be of importance for low-level programming.

3.1 Base Types

The system-specific limits for these types are defined in <limits.h>.

It is noteworthy that you cannot use sizeof() at preprocessing time. Therefore, system
software that depends on type sizes should use explicit-size types or machine/compiler-
dependent declarations for type sizes, whichever strategy is feasible for the situation.

TODO: different data models (LP64, LLP64, ...)

Type
char
short
int
long
long long

Typical Size Origin
8 bits
C89
16 bits
C89
C89
32 bits
32 or 64 bits C89
64 bits

C99; used widely before

Common Assumptions

Please note that the typical sizes are by no means carved in stone, even though such
assumptions are made in too many places. The day someone decides to break these
assumptions will be judgment day in the software world.

Native Words

Note that the typical size for long tends to be 32 bits on machines with 32-bit [max-
imum] native word size, 64 bits on 64-bit architectures. Also note that the i386 CPU
and later 32-bit CPUs in the Intel-based architectures do support a way to present 64-
bit values using two registers. One particular source of problems when porting from
32-bit to 64-bit platforms is the type int. It was originally designed to be a ’fast word’,
but people have used it as ’machine word’ for ages; the reason for so many trouble

31

32

CHAPTER 3. C TYPES

is that it tends to be 32-bit on 64-bit architectures (as well as 32-bit). Luckily, that’s
mostly old news; you can use specified-size types introduced in C99.

Char Signedness

The signedness of char is compiler-dependent; it’s usually a good idea to use unsigned
char explicitly. These types can be declared signed or unsigned, as in unsigned char,
to request the desired type more explicitly. The type long long existed before C99 in
many compilers, but was only standardised in C99. One problem of the old days was
code that wasn’t ’8-bit clean’ because it represented text as [signed] chars. Non-ASCII
text presentations caused problems with their character values greater than 127 (0x7f
hexadecimal).

3.2 Size-Specific Types

Fewer Assumptions

One of the great things about C99 is that it makes it easier, or, should I say, realistically
possible, to work when you have to know sizes of entities. In the low-level world, you
basically do this all the time.

3.2.1 Explicit-Size Types

The types listed here are defined in <stdint.h>.

The advent of C99 brought us types with explicit widths. The types are named uintW_t
for unsigned, and intW_t for signed types, where W indicates the width of the types
in bits. These types are optional.

Unsigned
uint8_t
uint16_t
uint32_t
uint64_t

Signed
int8_t
int16_t
int32_t
int64_t

These types are declared in <stdint.h>. There are also macros to declare 32-bit and 64-
bit constants; INT32_C(), UINT32_C(), INT64_C() and UINT64_C(). These macros
postfix integral values properly, e.g. typically with ULL or UL for 64-bit words.

3.2.2 Fast Types

The types listed here are defined in <stdint.h>

The C99 standard states these types to be specified for the fastest machine-types capa-
ble of presenting given-size values. The types below are optional.

3.3. OTHER TYPES

33

Unsigned
uint_fast8_t
uint_fast16_t
uint_fast32_t
uint_fast64_t

Signed
int_fast8_t
int_fast16_t
int_fast32_t
int_fast64_t

The numbers in the type names express the desired width of values to be represented
in bits.

3.2.3 Least-Width Types

The types listed here are defined in <stdint.h>

The C99 standard states these types to be specified for the minimum- size types capable
of presenting given-size values. These types are optional.

Unsigned
uint_least8_t
uint_least16_t
uint_least32_t
uint_least64_t

Signed
int_least8_t
int_least16_t
int_least32_t
int_least64_t

The numbers in the type names express the desired width of values to be represented
in bits.

3.3 Other Types

This section introduces common types; some of them are not parts of any C standards,
but it might still help to know about them.

Memory-Related

size_t is used to specify sizes of memory objects in bytes. Note that some older systems
are said to define this to be a signed type, which may lead to erroneous behavior.

ssize_t is a signed type used to represent object sizes; it’s typically the return type for
read() and write().

ptrdiff_t is defined to be capable of storing the difference of two pointer values.

intptr_t and uintptr_t are, respectively, signed and unsigned integral types defined
to be capable of storing numeric pointer values. These types are handy if you do
arithmetics beyond addition and subtraction on pointer values.

File Offsets

off_t is used to store and pass around file-offset arguments. The type is signed to allow
returning negative values to indicate errors. Traditionally, off_t was 32-bit, which lead
to trouble with large files (of 231 or more bytes). As salvation, most systems let you
activate 64-bit off_t if it’s not the default; following is a list of a few possible macros
to do it at compile-time.

34

CHAPTER 3. C TYPES

#define _FILE_OFFSET_BITS 64
#define _LARGEFILE_SOURCE 1
1
#define _LARGE_FILES

Alternatively, with the GNU C Compiler, you could compile with something like

gcc -D_FILE_OFFSET_BITS=64 -o proggy proggy.c

3.4 Wide-Character Types

/* TODO: write on these */

(cid:15) wchar_t

(cid:15) wint_t

3.5 Aggregate Types

struct and union

Structures and unions are called aggregates. Note that even though it’s possible to de-
clare functions that return aggregates, it often involves copying memory and therefore,
should usually be avoided; if this is the case, use pointers instead. Some systems pass
small structures by loading all member values into registers; here it might be faster to
call pass by value with structures. This is reportedly true for 64-bit PC computers.

Aggregates nest; it’s possible to have structs and unions inside structs.

To avoid making your structs unnecessarily big, it’s often a good idea to group bitfields
together instead of scattering them all over the place. It might also be good to organise
the biggest-size members first, paying attention to keeping related data fields together;
this way, there’s a bigger chance of fetching several ones from memory in a single
[cacheline] read operation. This also lets possible alignment requirements lead to using
fewer padding bytes.

Compilers such as the GNU C Compiler - GCC - allow one to specify structures to be
packed. Pay attention to how you group items; try to align each to a boundary of its
own size to speed read and write operations up. This alignment is a necessity on many
systems and not following it may have critical impact on runtime on systems which
don’t require it.

Use of global variables is often a bad idea, but when you do need them, it’s a good idea
to group them inside structs; this way, you will have fewer identifier names polluting
the name space.

3.5.1 Structures

struct is used to declare combinations of related members.

3.5. AGGREGATE TYPES

35

3.5.1.1 Examples

struct Example

struct list {

struct listitem *head;
struct listitem *tail;

};

declares a structure with 2 pointers, whereas

Second Example

struct listitem {
unsigned long
struct listitem *prev;
struct listitem *next;

val;

};

declares a structure with two [pointer] members and a value member; these could be
useful for [bidirectional] linked-list implementations.

Structure members are accessed with the operators . and -> in the following way:

struct list

list;

/* assign something to list members */

/* list is struct */
struct listitem *item = list.head;
struct listitem *next;

while (item) {

next = item->next; /* item is pointer */

}

3.5.2 Unions

union Example

union is used to declare aggregates capable of holding one of the specified members at
a time. For example,

union {

long lval;
ival;
int

};

can have ival set, but setting lval may erase its value. The . and -> operators apply for
unions and union-pointers just like they do for structures and structure-pointers.

36

3.5.3 Bitfields

Bitfield Example

CHAPTER 3. C TYPES

Bitfields can be used to specify bitmasks of desired widths. For example,

struct bitfield {

unsigned mask1 : 15;
unsigned mask2 : 17;

}

declares a bitfield with 15- and 17-bit members. Padding bits may be added in-between
mask1 and mask2 to make things align in memory suitably for the platform. Use your
compiler’s pack-attribute to avoid this behavior.

Portability

Note that bitfields used to be a portability issue (not present or good on all systems).
They still pose issues if not used with care; if you communicate bitfields across plat-
forms or in files, be prepared to deal with bit- and byte-order considerations.

3.6 Arrays

Let’s take a very quick look on how to declare arrays. As this is really basic C, I will
only explain a 3-dimensional array in terms of how its members are located in memory.

3.6.1 Example

3-Dimensional Example

int tab[8][4][2];
would declare an array which is, in practice, a flat memory region of 8(cid:3)4(cid:3)2(cid:3)sizeo f (int);
64 ints, that is. Now

tab[0][0][0]

would point to the very first int in that table,

tab[0][0][1]

to the int value right next to it (address-wise),

tab[7][1][0]

to the int at offset
(7 (cid:3) 4 (cid:3) 2 + 1 (cid:3) 4 + 0 (cid:3) 2) = 60, i.e. the 59th int in the table.

Here is a very little example program to initialise a table with linearly growing values.

#include <stdio.h>

int
main(int argc, char *argv[])

3.7. TYPEDEF

37

{

}

int tab[8][4][2];
int i, j, k, ndx = 0;

for (i = 0 ; i < 8 ; i++) {

for (j = 0 ; j < 4 ; j++) {

for (k = 0 ; k < 2 ; k++) {

tab[i][j][k] = ndx++;

}

}

}

One thing to notice here is that using index (or rindex) as an identifier name is a bad
idea because many UNIX systems define them as macros; I use ndx instead of index.

3.7

typedef

C lets one define aliases for new types in terms of existing ones.

3.7.1 Examples

typedef Example

Note that whereas I am using an uninitialised value of w, which is undefined, the value
doesn’t matter as any value’s logical XOR with itself is zero. This is theoretically faster
than explicit assignment of 0; the instruction XOR doesn’t need to pack a zero-word
into the instruction, and therefore the CPU can prefetch more adjacent bytes for better
pipeline parallelism.

typedef long word_t; /* define word_t to long */

word_t w;

w ^= w; /* set w to 0 (zero). */

would define word_t to be analogous to long. This could be useful, for example, when
implementing a C standard library. Given that LONG_SIZE is defined somewhere, one
could do something like

#if (LONG_SIZE == 4)
typedef long uint32_t;
#elif (LONG_SIZE == 8)
typedef long uint64_t;
#else
#error LONG_SIZE not set.
#endif

There would be other declarations for <stdint.h>, but those are beyond the scope of
this section.

38

3.8 sizeof

CHAPTER 3. C TYPES

The sizeof operator lets you compute object sizes at compile-time, except for variable-
length arrays.

3.8.1 Example

Zeroing Memory

You can initialise a structure to all zero-bits with

#include <stat.h>

struct stat statbuf = { 0 };

Note that sizeof returns object sizes in bytes.

3.9

offsetof

C99 Operator

ISO C99 added a handy new operator, offsetof. You can use it to compute offsets of
members in structs and unions at compile-time.

3.9.1 Example

offsetof Example

Consider the following piece of code

#include <stat.h>

size_t szofs;

struct stat statbuf;

szofs = offsetof(statbuf, st_size);

This most likely useless bit of code computes the offset of the st_size field from the
beginning of the struct statbuf. Chances are you don’t need this kind of information
unless you’re playing with C library internals.

3.10. QUALIFIERS AND STORAGE CLASS SPECIFIERS

39

3.10 Qualifiers and Storage Class Specifiers

3.10.1 const

The const qualifier is used to declare read-only data, which cannot be changed using
the identifier given. For example, the prototype of strncpy()

const Example

char *strncpy(char *dest, const char *src, size_t n);

states that src is a pointer to a string whose data strncpy() is not allowed to change.

On the other hand, the declaration

Another Example

char *const str;

means that str is a constant pointer to a character, whereas

char const *str;

would be a pointer to a constant character.

It may help you to better understand constant qualifiers by reading them right to left.

3.10.2 static

File Scope

Global identfiers (functions and variables) declared with the static specifier are only
visible within a file they are declared in. This may let the compiler optimise the code
better as it knows there will be no access to the entities from other files.

Function Scope

The static qualifier, when used with automatic (internal to a function) variables, means
that the value is saved across calls, i.e. allocated somewhere other than the stack.
In practice, you probably want to initialise such variables when declaring them. For
example,

static Example

#define INIT_SUCCESS 0

#include <pthread.h>

pthread_mutex_t initmtx = PTHREAD_MUTEX_INITIALIZER;

void
proginit(int argc, char *argv[])
{

static volatile int initialised = 0;

40

CHAPTER 3. C TYPES

/* only run once */
pthread_mutex_lock(&initmtx);
if (initialised) {

pthread_mutex_unlock(&initmtx);

return;

}

/* critical region begins */
if (!initialised) {

/* initialise program state */

initialised = 1;

}
/* critical region ends */
pthread_mutex_unlock(&initmtx);

return;

}

Comments

The listing shows a bit more than the use of the static qualifier; it includes a critical
region, for which we guarantee single-thread-at-once access by protecting access to
the code with a mutex (mutual exclusion lock).

3.10.3

extern

The extern specifier let’s you introduce entities in other files. It’s often a good idea
to avoid totally-global functions and variables; instead of putting the prototypes into
global header files, if you declare

#include <stdint.h>

uintptr_t baseadr = 0xfe000000;

void
kmapvirt(uintptr_t phys, size_t nbphys)
{

/* FUNCTION BODY HERE */

}

in a source file and don’t want to make baseadr (if you need to use it from other files,
it might be better if not) and kmapvirt() global, you can do this in other files

#include <stdint.h>

extern uintptr_t baseadr;

extern void kmapvirt(uintptr_t, size_t);

3.11. TYPE CASTS

41

Note that you don’t need argument names for function prototypes; the types are neces-
sary for compiler checks (even though it may not be required).

3.10.4 volatile

Usage

You should declare variables that may be accessed from signal handlers or several
threads with the volatile specifier to make the compiler check the value every time it is
used (and eliminate assumptions by the optimiser that might break such code).

3.10.5 register

Usage

The register storage specifier is used to make the compiler reserve a register for a
variable for its whole scope. Usually, it’s better to trust the compiler’s register allocator
for managing registers

3.11 Type Casts

Possible Bottleneck

With integral types, casts are mostly necessary when casting a value to a smaller-width
type. If you’re concerned about code speed, pay attention to what you’re doing; prac-
tice has shown that almost-innocent looking typecasts may cause quite hefty perfor-
mance bottlenecks, especially in those tight inner loops. Sometimes, when making
size assumptions on type, casts may actually break your code.

Sometimes it’s necessary to cast pointers to different ones. For example,

((uintptr_t)u8ptr - (uintptr_t)u32ptr)

would evaluate to the distance between *u8ptr and *u32ptr in bytes. Note that the
example assumes that

(uintptr_t)u8ptr > (uintptr_t)u32ptr

More on pointers and pointer arithmetics in the following chapter.

42

CHAPTER 3. C TYPES

Chapter 4

Pointers

In practice, C pointers are memory addresses. One of the interesting things about C is
that it allows access to pointers as numeric values, which lets one do quite ’creative’
things with them. Note that when used as values, arrays decay to pointers to their first
element; arrays are by no means identical to pointers.

4.1 void Pointers

void * vs. char *

ISO C defines void pointers, void *, to be able to assign any pointer to and from without
explicit typecasts. Therefore, they make a good type for function arguments. Older C
programs typically use char * as a generic pointer type.

It’s worth mentioning that one cannot do arithmetic operations on void pointers directly.

4.2 Pointer Basics

Basic Examples

As an example, a pointer to values of type int is declared like

int *iptr;

You can access the value at the address iptr like

i = *iptr;

and the two consecutive integers right after the address iptr like

i1 = iptr[1];
i2 = iptr[2];

To make iptr point to iptr[1], do

iptr++;

43

44

or

iptr = &iptr[1];

CHAPTER 4. POINTERS

4.3 Pointer Arithmetics

The C Language supports scaled addition and subtraction of pointer values.

To make iptr point to iptr[1], you can do

iptr++; // point to next item; scaled addition

or

iptr += 1;

Similarly, e.g. to scan an array backwards, you can do

iptr--;

to make iptr point to iptr[-1], i.e. the value right before the address iptr.

To compute the distance [in given-type units] between the two pointer addresses iptr1
and iptr2, you can do

diff = iptr2 - iptr1;

Note that the result is scaled so that you get the distance in given units instead of what

(intptr_t)iptr2 - (intptr_t)iptr1;

would result to. The latter is mostly useful in advanced programming to compute the
difference of the pointers in bytes.

If you don’t absolutely need negative values, it is better to use

(uintptr_t)iptr2 - (uintptr_t)iptr1; // iptr2 > iptr1

or things will get weird once you get a negative result (it is going to end up equivalent to
a big positive value, but more on this in the sections discussing numerical presentation
of integral values. Note, though, that this kind of use of the C language may hurt
the maintainability and readability of code, which may be an issue especially on team
projects.

It is noteworthy that C pointer arithmetics works on table and aggregate (struct and
union) pointers as well. It’s the compiler (and sometimes CPU) who scale the arith-
metics of operations such as ++ to work properly.

4.4 Object Size

Memory

Pointer types indicate the size of memory objects they point to. For example,

uint32_t u32 = *ptr32;

4.4. OBJECT SIZE

45

reads a 32-bit [unsigned] value at address ptr32 in memory and assigns it to u32.

Results of arithmetic operations on pointers are scaled to take object size in account.
Therefore, it’s crucial to use proper pointer types [or cast to proper types] when access-
ing memory.

uint32_t *u32ptr1 = &u32;
uint32_t *u32ptr2 = u32ptr1 + 1;

makes u32ptr2 point to the uint32_t value right next to u32 in memory.

In C, any pointer [value] can be assigned to and from void * without having to do
type-casts. For example,

*ptr = &u32;

void
uint8_t *u8ptr = ptr;
uint8_t

u8 = 0xff;

u8ptr[0] = u8ptr[1] = u8ptr[2] = u8ptr[3] = u8;

would set all bytes in u32 to 0xff (255). Note that doing it this way is better than

size_t

n = sizeof(uint32_t);

while (n--) {

*u8ptr++ = u8;

}

both because it avoids loop overhead and data-dependencies on the value of u8ptr, i.e.
the [address of] next memory address doesn’t depend on the previous operation on the
pointer.

46

CHAPTER 4. POINTERS

Chapter 5

Logical Operations

5.1 C Operators

TODO - had some LaTeX-messups, will fix later. :)

5.1.1 AND

Truth Table

The logical function AND is true when both of its arguments are. The truth table
becomes

Bit #1 Bit #2 AND
0
0
1
1

0
1
0
1

0
0
0
1

5.1.2 OR

Truth Table

The logical function OR is true when one or both of its arguments are. Some people
suggest OR should rather be called inclusive OR.

The truth table for OR is represented as

Bit #1 Bit #2 OR
0
0
1
0
0
1
1
1

0
1
1
1

47

48

5.1.3 XOR

Truth Table

CHAPTER 5. LOGICAL OPERATIONS

The logical function XOR, exclusive OR, is true when exactly one of its arguments is
true (1).

The truth table of XOR is

Bit #1 Bit #2 XOR
0
0
1
1

0
1
1
0

0
1
0
1

5.1.4 NOT

Truth Table

The logical function NOT is true when its argument is false.

Bit NOT
1
0
0
1

5.1.5 Complement

Complementing a value means turning its 0-bits to ones and 1-bits to zeroes; ’reversing’
them.

Bit Complement
0
1

1
0

Chapter 6

Memory

Table of Bytes

C language has a thin memory abstraction. Put short, you can think of memory as a flat
table/series of bytes which appears linear thanks to operating system virtual memory.

6.1 Alignment

Many processors will raise an exception if you try to access unaligned memory ad-
dresses [using pointers], and even on the ones which allow it, it tends to be much
slower than aligned access. The address addr is said to be aligned to n-byte boundary
if

(adr % n) == 0 /* modulus with n is zero, */

i.e. when adr is a multiple of n.

It’s worth mentioning that if you need to make sure the pointer ptr is aligned to a
boundary of p2, where p2 is a power of two, it’s faster to check that

/* low bits zero. */
#define aligned(ptr, p2) \

(!((uintptr_t)ptr & ((p2) - 1)))

The type uintptr_t is defined to one capable of holding a pointer value in the ISO/ANSI
C99 standard header <stdint.h>.

6.2 Word Access

Whereas the most trivial/obvious implementations of many tasks would access memory
a byte at a time, for example

nleft = n >> 2;
n -= nleft << 2;

49

50

CHAPTER 6. MEMORY

/* unroll loop by 4; set 4 bytes per iteration. */
while (nleft--) {

*u8ptr++ = u8;
*u8ptr++ = u8;
*u8ptr++ = u8;
*u8ptr++ = u8;

}
/* set the rest of bytes one by one */
while (n--) {

*u8ptr++ = u8;

}

it’s better to do something like

/* u8 */

/* n / 4 */

n32 = n >> 2;
u32 = u8;
u32 |= u32 << 8;
u32 |= u32 << 16; /* (u8 << 24) | (u8 << 16) | (u8 << 8) | u8 */
/* set 32 bits at a time. */
while (n32--) {

/* (u8 << 8) | u8 */

*u32ptr++ = u32;

}

or even

/* n / 16 */

n32 = n >> 4;
u32 = u8;
u32 |= u32 << 8;
u32 |= u32 << 16; /* (u8 << 24) | (u8 << 16) | (u8 << 8) | u8 */
/*

/* (u8 << 8) | u8 */

/* u8 */

* NOTE: x86 probably packs the indices as 8-bit immediates
* - eliminates data dependency on previous pointer value
*
*/

present when *u32ptr++ is used

for (i = 0 ; i < n32 ; i++) {

u32ptr[0] = u32;
u32ptr[1] = u32;
u32ptr[2] = u32;
u32ptr[3] = u32;
u32ptr += 4;

}

in order to access memory a [32-bit] word at a time. On a typical CPU, this would
be much faster than byte-access! Note, though, that this example is simplified; it’s
assumed that u32ptr is aligned to 4-byte/32-bit boundary and that n is a multiple of 4.
We’ll see how to solve this using Duff’s device later on in this book.

The point of this section was just to demonstrate [the importance of] word-size mem-
ory access; the interesting thing is that this is not the whole story about implementing
fast memset() in C; in fact, there’s a bunch of more tricks, some with bigger gains than
others, to it. We shall explore these in the part Code Optimisation of this book.

Chapter 7

System Interface

7.1 Signals

Brief

Signals are a simple form of IPC (Inter-Process Communications). They are asyn-
chronous events used to notify processes of conditions such as arithmetic (SIGFPE,
zero-division) and memory access (SIGSEGV, SIGBUS) errors during program execu-
tion. Asynchronous means signals may be triggered at any point during the execution of
a process. On a typical system, two signals exist for user-defined behavior; SIGUSR1
and SIGUSR2. These can be used as a rough form of communications between pro-
cesses.

System

Most signal-handling is specific to the host operating system, but due to its widespread
use, I will demonstrate UNIX/POSIX signals as well as some simple macro techniques
by representing a partial implementation of <signal.h>. I will not touch the differences
of older signal() and sigaction() here; that belongs to system programming books. As
such a book, Advanced Programming in the UNIX Environment by late Richard
W. Stevens is a good text on the topic.

Asynchronosity

It is noteworthy that signal handlers can be triggered at any time; take care to declare
variables accessed from them volatile and/or protect them with lock-mechanisms such
as mutexes. C has a standard type, sig_atomic_t, for variables whose values can be
changed in one machine instruction (atomically).

Critical Regions

I will touch the concept of critical regions quickly. A critical region is a piece of code
which may be accessed several times at once from different locations (signal handlers
or multiple threads). Need arises to protect the program’s data structures not to corrupt
them by conflicting manipulation (such as linked lists having their head point to wrong
item). At this point, it’s beyond our interest to discuss how to protect critical regions

51

52

CHAPTER 7. SYSTEM INTERFACE

beyond using mutexes that are locked when the region is entered, unlocked when left
(so as to serialise access to those regions).

Signal Stack

On many UNIX systems, you can set signals to be handled on a separate stack, typically
with sigaltstack().

SIGCLD is not SIGCHLD

There is a bit of variation in how signals work on different systems, mostly about which
signals are available. This seems mostly irrelevant today, but I’ll make one note; the old
System V SIGCLD has semantics different from SIGCHLD, so don’t mix them (one
sometimes sees people redefine SIGCLD as SIGCHLD which should not be done).

7.2 Dynamic Memory

malloc() and Friends

Standard C Library provides a way to manage dynamic memory with the functions
malloc(), calloc(), realloc() and free(). As we are going to see in our allocator source
code, there’s a bunch of other related functions people have developed during the last
couple of decades, but I will not get deeper into that here.

Dynamic allocation is a way to ask the system for memory for a given task; say you
want to read in a file (for the sake of simplicity, the whole contents of the file). Here’s
a possible way to do it on a typical UNIX system.

readfile()

#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

void *
readfile(char *filename, size_t *sizeret)
{

void
struct stat
size_t
size_t
int

*buf = NULL;

statbuf;
nread;
nleft;
fd;

if (sizeret) {

*sizeret = 0;

}
if (stat(filename, &statbuf) < 0) {

return NULL;

7.2. DYNAMIC MEMORY

53

}
if (!S_ISREG(statbuf.st_mode)) {

return NULL;

}
fd = open(name, O_RDONLY);
if (fd < 0) {

return NULL;

}
nread = 0;
nleft = statbuf.st_size;
if (nleft) {

buf = malloc(nleft);
if (buf) {

while (nleft) {

nread = read(fd, buf, nleft);
if (nread < 0) {

if (errno == EINTR) {

continue;

} else {

free(buf);

return NULL;

}
} else {

nleft -= nread;

}

}
if (sizeret) {

*sizeret = statbuf.st_size;

}

}

}
close(fd);

return buf;

}

EINTR

to read the file into the just-allocated buffer. Notice how we deal with UNIX-style
interrupted system calls by checking the value of errno against EINTR; should it occur
that a read system call is interrupted, we’ll just continue the loop to read more.

An implementation of malloc() and other related functions is presented later in this
book.

54

7.2.1 Heap

sbrk() and brk()

CHAPTER 7. SYSTEM INTERFACE

Heap segment is where the traditional albeit POSIX-undefined brk() (kernel) and sbrk()
(C library) dynamic memory interface operates. Note that sbrk() is merely a wrapper
to a [simple] brk system call.

sbrk() not in POSIX

Back in the old days, dynamic memory was implemented with the brk() system call
(often using the sbrk() standard library wrapper). All it really does is adjust the offset
of the top of the heap. This seems to be recognised as a somewhat too rudimentary or
dated hack by POSIX; they have deliberately excluded sbrk() from their standard. Note
that this doesn’t mean sbrk() would not be available on your system; it most likely is.

sbrk() + mmap()

In reality, malloc-allocators today use only mmap() or a mix of mmap() and sbrk(). It’s
a compromise between speed and ease of use, mostly (the kernel does the book-keeping
for mmap() and it tends to be thread-safe, i.e. reentrant, too).

7.2.2 Mapped Memory

Files

Modern allocators use mmap() + munmap() [from POSIX] to manage some of their
allocations. The C library provides an interface for this as a special case of mapping
files; files can be memory-mapped, giving us a fast way to write and read data to and
from file-systems. The special case is to allocate zeroed regions not belonging to files.

Anonymous Maps

As a detail, mmap() can often be used to allocate anonymous (zeroed) memory. I know
of two strategies to how to implement this; map /dev/zero or use the MAP_ANON flag.

Chapter 8

C Analogous to Assembly

8.1 ’Pseudo-Assembly’

Some of us call C pseudo-assembly. C is very close to the machine and most if not all
machine language dialects have a bunch of instructions to facilitate fast implementation
of C code execution. This is probably not a coincidence.

In this chapter, I shall try to explain the elegant simplicity of C as well as its close rela-
tionship with the machine; keep in mind assembly is just symbolic machine language.
Hence assembly makes a great tool for explaining how C code utilises the machine.

Here is a simple mapping of common C operations to pseudo-machine instructions.

8.1.1 Pseudo Instructions

Hypothetical Instructions

C Operation Mnemonic
&
|
^
˜
++
–
+
-
*
/
%

AND
OR
XOR
NOT
INC
DEC
ADD
SUB
MUL, IMUL
DIV, IDIV
MOD

Conditional Jumps

55

56

CHAPTER 8. C ANALOGOUS TO ASSEMBLY

C Comparison
N/A
!
(x)
<
<=
>
>=

Test
JMP
JZ
JNZ
JLT
JLTE
JGT
JGTE

Brief
Jump Unconditionally
Jump if Zero
Jump if Not Zero
Jump if Less Than
Jump if Less Than or Equal
Jump if Greater Than
Jump if Greater Than or Equal

8.2 Addressing Memory

Pointer Operations

C Syntax
*
&
[]
.
->
variable
array
constant

Function
dereference pointer
get object address/pointer
access member of array or bitfield using index
access member of struct or union
access member of struct or union using pointer
value in register or memory
contiguous region of memory
register or immediate (in-opcode) values

8.3 C to Assembly/Machine Translation

Here we shall take a look at how C code is translated to assembly by a hypothetical
compiler. I will also make notes on some things one can do to speed code up.

Note that in this section, I mix variable names and register names in the pseudo-
assembly code; in real life, this would mean memory locations and registers, but better
code would be based purely on using registers. I chose this convention for the sake of
readability. Some examples actually do use registers only for a bit closer touch to the
real machine.

8.3.1 Branches

8.3.1.1 if - else if - else

It pays to put the most likely test cases first. CPUs do have branch prediction logic, but
they still need to fetch code and jump around in it, which defeits their internal execution
pipelines and consumes cache memory.

Let’s see what’s going on in a piece of C code; I will use pseudo-code in a form similar
to C and assembly to explain how this code could be translated at machine level.

C Code

8.3. C TO ASSEMBLY/MACHINE TRANSLATION

57

#1: if (a < b) {
;

#2: } else if (b < c && b > d) {

;

#3: } else if (c > a || d <= a) {

;

#4: } else {

;

#5: }

Now let’s look at what’s going on under the hood.

Pseudo Code

CMP a, b
JGE step2

; line #1
; branch to step2 if !(a < b)

/* code between #1 and #2 */

JMP done
step2:
CMP b, c
JGE step3
CMP b, d
JLE step3

; line #2
; branch to step3 if !(b < c)
; line #2
; branch to step3 if !(b > d)

/* code between #2 and #3 */

JMP done
step3:
CMP c, a
JLT step4
CMP d, a
JGT step4

; line #3
; branch to step4 if !(c > a)
; #line 3
; brach to step4 if !(d <= a)

/* code between #3 and #4 */

JMP done
step4:

/* code between #4 and #5 */

done:

; done

8.3.1.2 switch

One useful way to replace switch statements with relatively small sets of integral keys
is to use function pointer tables indexed with key values. The construct

switch (a) {

case 0:

58

CHAPTER 8. C ANALOGOUS TO ASSEMBLY

a++;

break;

case 1:

a += b;

break;

default:

break;

}

could be translated to

TEST a
JZ label0
CMP a, $1
JE label1
JMP done
label0:
INC a
JMP done
label1:
ADD b, a
done:

; set flags
; branch to label0 if (a == 0)
; compare a and 1
; branch to label1 if equal
; default; jump over switch

; a++;
; done

; a += b;
; done

This should often be faster than if- else if - else with several test conditionals. With
suitable case values (small integrals), a good compiler might know how to convert this
construct to a jump table; check the value of a and jump to a location indexed by it.

8.3.2 Loops

8.3.2.1 for

The C snippet

long *tab = dest;

for (i = 0 ; i < n ; i++) {

tab[i] = 0;

}

could be translated as

done

MOV $0, %EAX
loop:
CMP %EAX,n
JE
MOV $0, %EAX(tab, 4)
INC %EAX
JMP loop
done:

; i = 0;

; compare i and n
; done if (i == n)
; tab[i] = 0; scale i by 4
; i++;
; iterate

8.3. C TO ASSEMBLY/MACHINE TRANSLATION

59

Note that I used a register for loop counter to speed things up, even though I have
mixed variables and registers in the pseudo-code freely. This is more likely what a
real compiler would do. Some architectures also have prethought looping instructions
which might use a specified register for the loop counter, for example. IA-32 has REP-
functionality.

Indexed Scaled Addressing

The line

MOV $0, %EAX(tab, 4); tab[i] = 0;

means “move 0 to the location at tab + %EAX * 4, i.e. i (%EAX) is scaled by 4, i.e.
sizeof(long) on 32-bit architecture.

8.3.2.2 while

The C loop construct

int i = NBPG >> 2;
long *tab = dest;

while (i--) {

*tab++ = 0;

}

Could work (with 4-byte longs) as

MOV tab, %EAX

; move address to register

MOV $NBPG, %EBX ; move NBPG to register (i)
SHR $2, %EBX ; shift NBPG right by 2

loop:
TEST %EBX
JZ done
DEC %EBX
MOV $0, *%EAX
ADD $4, %EAX
JMP loop
done:

In this example, I used registers to contain the memory address and loop counter to
speed the code up.

8.3.2.3 do-while

The difference between while and do-while is that do-while always iterates the body of
the loop at least once.

The C code

int i = NBPG >> 2;
long *tab = dest;

60

CHAPTER 8. C ANALOGOUS TO ASSEMBLY

do {

*tab++ = 0;

} while (--i);

can be thought of as

MOV tab, %EAX
MOV NBPG, %EBX

SHR $2, %EBX

loop:
$0, *%EAX
MOV
$4, %EAX
ADD
DEC
%EBX
TEST %EBX
JNZ
loop
done:

In this example, I allocated registers for all variables like a good compiler should do.

8.3.3 Function Calls

Function call mechanisms used by C are explained in detail in the chapter C Run
Model in this book.

For now, suffice it to illustrate the i386 calling convention quickly.

A function call of

foo(1, 2, 3);

int foo(int arg1, int arg2, int arg3) {

return (arg1 + arg2 + arg3);

}

Can be thought of as

Pseudo Code

; push arguments in reverse order

/* function call prologue */
PUSH $3
PUSH $2
PUSH $1
PUSH %EIP
PUSH %EBP
MOV
JMP

%EBP, %ESP ; set stack pointer
foo

; push instruction pointer
; current frame pointer

/* stack
* -----
* arg3
* arg2
* arg1
* retadr

8.3. C TO ASSEMBLY/MACHINE TRANSLATION

61

* prevfp; <- %ESP and %EBP point here
*/

foo:
MOV
MOV
MOV
ADD
ADD
MOV

8(%ESP), %EAX
12(%ESP), %EBX
16(%ESP, %ECX
%EBX, %EAX
%ECX, %EAX ; return value in EAX
%EBP, %ESP ; return frame

/* return from function */
POP
POP
MOV
JMP

%EBP
%EBX
%EBP, %ESP ; set stack pointer to old frame
; jump back to caller
*%EBX

; pop old frame pointer
; pop old EIP value

Notes

foo() doesn’t have internal variables, so we don’t need to adjust stack pointer [or push
values] on entry to and at leaving the function.

Call Conventions

Usually, CPUs have specific instructions to construct call frames as well as return from
functions. It was done here by hand to demonstrate the actions involved.

62

CHAPTER 8. C ANALOGOUS TO ASSEMBLY

Chapter 9

C Run Model

C is a low-level language. As such, it doesn’t assume much from the host operating
system and other support software. The language and its run model are elegant and
simple. C is powerful for low-level software development; situations where you really
have to write assembly-code are rare and few, yet C gives one a close interface to low-
level machine facilities with reasonable portability to different hardware platforms.

Stack, Memory, Registers

In short, C code execution is typically based on values stored on the stack, elsewhere
in memory, and machine registers. Note, however, that stack as well as heaps are not
language features, but rather details of [typical] implementations.

Stack is allocated from process virtual memory and from physical memory as dictated
by the kernel and page-daemon. Other than move data to registers, there’s little you
can do to affect stack operation with your code.

Memory is anything from the lowest-level (closest-to-CPU) cache to main physical
memory. Utilising caches well tends to pay back in code speed. For one thing, it’s
good to keep related data on as few cachelines [and pages] as possible.

Registers are the fastest-access way to store and move data around in a computer. All
critical variables such as loop counters should have registers allocated for them. It’s
noteworthy to avoid the C keyword register, as that is said to allocate a register for the
whole lifetime/scope of the function and is therefore to be considered wasteful. Note,
however, that as per C99, the specifier register is only a suggestion “that access to the
obejct should be as fast as possible.”

Use of the register-specifier may be helpful in situations where few or no compiler op-
timisations are in effect; on the other hand, it is noteworthy that compiler optimisations
often make debugging hard if not impossible.

63

64

CHAPTER 9. C RUN MODEL

9.1 Code Execution

9.1.1 Program Segments

Code and Data

I will provide a somewhat-simplified, generalised view to how UNIX systems organise
program execution into a few segments.

STACK
execution data, function interface
DYN
mapped regions
BSS
runtime data; allocated; zeroed; heap
DATA
initialised data
RODATA read-only data
TEXT
program code

9.1.1.1 Minimum Segmentation

Here I describe a minimal set of i386 memory segments

Flat Memory Model

(cid:15) Use one text segment (can be the same for TEXT and RODATA).

(cid:15) Use one read-write data segment (for DATA, BSS, and DYN segments.

(cid:15) Use one read-write, expand-down data segment for STACK segment.

This flat model is useful for, e.g., kernel development. Most other programmers don’t
need to be concerned about segmentation.

9.1.2 TEXT Segment

Program Code

The TEXT segment contains program code and should most of the time be set to read-
only operation to avoid code mutations as well as tampering with process code (for
exploits and other malware as an example).

9.1.3 RODATA Segment

Read-Only Data

Storage for items such as initialised constant variables and perhaps string literals (better
not try to overwrite them). Read-only data segment.

9.1. CODE EXECUTION

9.1.4 DATA Segment

Initialised Data

65

Storage mostly for initialised global entities and probably static variables. Can be both
read and written.

9.1.5 BSS Segment

Allocated Data

The name of the BSS Segment originates from PDP-assembly and stood for Block
Started by Symbol. This is where runtime-allocated data structures i.e. uninitialised
global structures [outside C functions] are reserved. This is also where dynamic mem-
ory allocation (malloc(), calloc()) takes place if you use the traditional system library
wrapper sbrk() to set so-called program break. In practice, the break is a pointer to the
byte right after the current top of heap. This segment should be filled with zero bytes
at program load time.

Zeroed Memory

Note that when new physical pages are mapped to virtual space of user processes, it
needs to be zeroed not to accidentally slip confidential data such as, in one of the worst
cases, uncrypted passwords. This task is frequently done to freed/unmapped pages by
system kernels.

9.1.6 DYN Segment

Mapped Regions

The implementation details vary system to system, but this segment’s purpose here is
to emphasize the usage of mmap() to map zeroed memory. This could be facilitated by
having the heap (BSS) live low in memory and DYN far above it to minimalise the risk
of the segments overrunning each other. I plan to try to put this segment right below
stack and make it start mapping memory from the top in my kernel project.

9.1.7 STACK Segment

Routines & Variables

The stack is a region of memory, usually in the high part of the virtual address space
(high memory addresses). Conventionally, the segment ’grows down’, i.e. values are
pushed into memory and the stack pointer decremented instead of the common linear
order memory access where pointers are incremented and dereferenced with linearly
growing addresses. This allows the stack to be located high and work in concert with
dynamic memory segments lower in address space (the heap grows upwards, address-
wise; mapped regions may be located under the stack).

The stack exists to implement function call interface, automatic variables and other
aspects of C’s run model.

66

CHAPTER 9. C RUN MODEL

9.2 C Interface

9.2.1 Stack

9.2.1.1 Stack Pointer

Stack pointer is a [register] pointer to the current item on the stack. On i386-based
machine architecture, the stack pointer is stored in the ESP-register. When a value is
popped from the stack, it is first taken from the address in the stack pointer, and then the
stack pointer is incremented by 4 bytes; ESP points to the current location on the stack.
Pushing values works by decrementing the stack pointer to point to the next location,
then storing the value at the address pointed to by the stack pointer. I’ll clarify this by
describing the operations in C-like code

#define pop()
#define push(val) (*(--sp) = (val))

(*(sp++))

9.2.2 Frame Pointer

Frame pointer points to the stack frame of the current function. This is where the frame
pointer value for the caller, the return address for the proper instruction in it, and the
arguments the current function was called with are located. On i386, the frame pointer
is stored in the EBP-register. Many compilers provide an optimisation to omit using
the frame pointer; beware that this optimisation can break code that explicitly relies on
the frame pointer.

9.2.3 Program Counter aka Instruction Pointer

Program Counter is a traditional term for instruction pointer [register]. This is the
address register used to find the next instruction in memory. On i386, this pointer is
stored in the EIP- register (and cannot be manipulated without a bit of trickery). At
machine level, when exceptions/interrupts such as zero-division occur, EIP may point
to the instruction that caused the exception or the instruction right after it in memory
(to allow the program to be restarted after handling the interrupt.

9.2.4 Automatic Variables

Variables within function bodies are called automatic because the compiler takes care
of their allocation on the stack.

It is noteworthy that unless you initialise (set) these variables to given values, they con-
tain whatever is in that location in [stack] memory and so unlogical program behavior
may happen if you use automatic variables without initialising them first. Luckily,
compilers can be configured to warn you about use of uninitialised variables if they
don’t do it by default.

9.2. C INTERFACE

9.2.5 Stack Frame

67

On the i386, a stack frame looks like (I show the location of function parameters for
completeness’ sake).

/* IA32. */
struct frame {

/* internal variables */

int32_t ebp; /* ’top’ */
int32_t eip; /* return address */

/*

* function call arguments in
* reverse order
*/

};

Note that in structures, the lower-address members come first; the instruction pointer
is stored before (push) and so above the previous frame pointer.

9.2.6 Function Calls

A function call in typical C implementations consists roughly of the following parts. If
you need details, please study your particular implementation.

(cid:15) push function arguments to stack in reverse order (right to left) of declaration.

(cid:15) store the instruction pointer value for the next instruction to stack.

(cid:15) push the current value of the frame pointer to stack.

(cid:15) set frame pointer to value of stack pointer

(cid:15) adjust stack pointer to reserve space for automatic variables on stack.

In pseudo-code:

push(arg3)
push(arg2)
push(arg1)
push(EIP)
push(EBP)
mov(ESP, EBP)
add(sizeof(autovars), ESP) // adjust stack

// return address
// callee frame

// set frame pointer

A hypothetical call

foo(1, 2, 3);

would then leave the bottom of the stack look something like this:

68

Value
3
2
1
eip
ebp
val1
val2
val3

Explanation
argument #3
argument #2
argument #1
return address to caller
frame pointer for caller
first automatic variable on stack

CHAPTER 9. C RUN MODEL

Notes

next instruction after return
EBP points here

ESP points here

It’s noteworthy than unless you explicitly initialise them, the values on stack (v1, v2,
and v3) contain ’garbage’, i.e. any data that has or has not been written to memory
addresses after system bootstrap.

9.2.6.1 Function Arguments

TODO: distinction between function arguments and parameters

Stack or Registers

Function arguments can be variables either on the stack or in registers.

As an example, let’s take a quick look at how FreeBSD implements system calls.

The first possibility is to push the function arguments [in reverse order] to the call stack.
Then one would load the EAX-register with the system call number, and finally trigger
INT 80H to make the kernel do its magic.

Alternatively, in addition to EAX being loaded with the system call number, arguments
can be passed in EBX, ECX, EDX, ESI, EDI, and EBP.

9.2.6.2 Return Value

EAX:EDX

The traditional i386 register for return values is EAX; 64-bit return values can be im-
plementing by loading EDX with the high 32 bits of the value. FreeBSD is said to
store the return value for SYS_fork in EDX; perhaps this is to facilitate the special
’two return-values’ nature of fork() without interfering with other use of registers in C
libraries and so on.

C-language error indicator, errno, can be implemented by returning the proper number
in EAX and using other kinds of error indications to tell the C library that an error
occurred. The FreeBSD convention is to set the carry flag (the CF-bit in EFLAGS).
Linux returns signed values in EAX to indicate errors.

32-bit words are getting small today. Notably, this shows as several versions of seek();
these days, disks and files are large and you may need weird schemes to deal with
offsets of more than 31 or 32 bits. Therefore, off_t is 64-bit signed to allow bigger file
offsets and sizes. Linux llseek() passes the seek offset (off_t) in two registers on 32-bit
systems.

9.2. C INTERFACE

69

9.2.6.3 i386 Function Calls

i386 Details

Let’s take a look at how C function calls are implemented on the i386.

To make your function accessible from assembly code, tell GCC to give it ’external
linkage’ by using stack (not registers) to pass arguments.

#include <stdio.h>
#include <stdlib.h>

#define ALINK __attribute__ ((regparm(0)))

ALINK
void
hello(char *who, char *prog, int num1, int num2)
{

int32_t res;

res = num1 + num2;

printf("hello %s\n", who);
printf("%s here\n", prog);
printf("%d + %d is equal to %d\n",\

num1, num2, res);

return;

}

int
main(int argc, char *argv[])
{

hello(argv[1], argv[0], 1, 2);

exit(0);

}

This program takes a single command-line argument, your name, and uses the conven-
tion that the first argument (argv[0] is name of executable (including the supplied path)
and the second argument argv[1] is the first command line argument (the rest would
follow if used, but they are ignored as useless).

When hello() is called, before entry to it, GCC arranges equivalent of

push num2
push num1
push argv[0]
push argv[1]

Note that the arguments are pushed in ’reverse order’. It makes sense thinking of the
fact that now you can pop them in ’right’ order.

70

CHAPTER 9. C RUN MODEL

At this stage, the address of the machine instruction right before the system call is
stored; in pseudo-code,

pushl %retadr

Next, the compiler arranges a stack frame.

pushl %ebp # frame pointer
movl %ebp, %esp # new stack frame

Note that EBP stores the frame pointer needed to return from the function so it’s gen-
erally not a good idea to use EBP in your code.

Now it is time to allocate automatic variables, i.e. variables internal to a function
that are not declared static. The compiler may have done the stack adjustment in the
previous listing and this allocation with the ENTER machine instruction, but if not so,
it adds a constant to the stack pointer here, for example

addl $0x08, %esp # 2 automatic variables

Note that the stacks operates in 32-bit mode, so for two automatic (stack) variables, the
adjustment becomes 8.

This may be somewhat hairy to grasp, so I will illustrated it C-style.

You can think of the frame as looking like this at this point.

/*

* EBP points to oldfp.
* ESP is &avar[-2].
*/

struct cframe {

int32_t avar[0]; // empty; not allocated
int32_t oldfp; // frame of caller
int32_t retadr; // return address
int32_t args[0]; // empty

}

Empty Tables

Note the empty tables (size 0), which C99 actually forbids. These are used as place
holders (don’t use up any room in the struct); they are useful to pass stack addresses in
this case.

Illustration

Finally, I will show you how the stack looks like in plain English. Note that in this
illustration, memory addresses grow upwards.

Stack
num2
num1
argv[1]
argv[0]
retadr
oldfp
res

Value
0x00000002
0x00000001
pointer
pointer
return address
caller frame
undefined

Explanation
value 2
value 1
second argument
first argument
address of next instruction after return
EBP points here
automatic variable

9.3. NONLOCAL GOTO; SETJMP() AND LONGJMP()

71

Return Address

If you should need the return address in your code, you can read it from the stack at
address EBP + 4. In C and a bit of (this time, truly necessary) assembly, this could be
done like this.

struct _stkframe {

int32_t oldfp; // frame of caller
int32_t retadr; // return address

};

void
dummy(void)
{

struct _stkframe *frm;

__asm__ ("movl %%ebp, %0" : "=rm" (frm));
fprintf(stderr, "retadr is %x\n", frm->retadr);

return;

}

Note that on return from functions the compiler arranges, in addition to the other magic,
something like this.

popl %ebp
movl %ebp, %esp
ret

Callee-Save Registers

By convention, the following registers are ’callee-save’, i.e. saved before entry to
functions (so you don’t need to restore their values by hand).

Registers
EBX
EDI
ESI
EBP
DS
ES
SS

9.3 Nonlocal Goto; setjmp() and longjmp()

In C, <setjmp.h> defines the far-jump interface. You declare a buffer of the type
jmp_buf

jmp_buf jbuf;

This buffer is initialised to state information needed for returning to the current location
in code (the instruction right after the call to setjmp()) like this:

72

CHAPTER 9. C RUN MODEL

if (!setjmp(jbuf)) {

dostuff();

}
/* continue here after longjmp() */

Then, to jump back to call dostuff(), you would just

longjmp(jbuf, val);

9.3.1

Interface

9.3.1.1 <setjmp.h>

Here’s our C library header file <setjmp.h>

#ifndef __SETJMP_H__
#define __SETJMP_H__

#if defined(__x86_64__) || defined(__amd64__)
#include <x86-64/setjmp.h>
#elif defined(__arm__)
#include <arm/setjmp.h>
#elif defined(__i386__)
#include <ia32/setjmp.h>
#endif

typedef struct _jmpbuf jmp_buf[1];

/* ISO C prototypes. */
int
void longjmp(jmp_buf env, int val);

setjmp(jmp_buf env);

/* Unix prototypes. */
int
void _longjmp(jmp_buf env, int val);

_setjmp(jmp_buf env);

#endif /* __SETJMP_H__ */

9.3.2

Implementation

Note that you need to disable some optimisations in order for setjmp() and longjmp()
to build and operate correctly. With the GNU C Compiler, this is achieved by using the
-fno-omit-frame-pointer compiler flag.

9.3. NONLOCAL GOTO; SETJMP() AND LONGJMP()

73

9.3.2.1 IA-32 implementation

Following is an implementation of the setjmp() and longjmp() interface functions for
the IA-32 architecture. Note that the behavior of non-volatile automatic variables
within the caller function of setjmp() may be somewhat hazy and undefined.

ia32/setjmp.h

#ifndef __IA32_SETJMP_H__
#define __IA32_SETJMP_H__

#include <stddef.h>
#include <stdint.h>
#include <signal.h>

#include <zero/cdecl.h>

struct _jmpbuf {
int32_t
int32_t
int32_t
int32_t
int32_t
int32_t

ebx;
esi;
edi;
ebp;
esp;
eip;

#if (_POSIX_SOURCE)

sigset_t sigmask;

#elif (_BSD_SOURCE)

int

sigmask;

#endif
} PACK();

struct _jmpframe {

int32_t ebp;
int32_t eip;
uint8_t args[EMPTY];

} PACK();

/*

* callee-save registers: ebx, edi, esi, ebp, ds, es, ss.
*/

#define __setjmp(env)

__asm__ __volatile__ ("movl %0, %%eax\n"

"movl %%ebx, %c1(%%eax)\n"
"movl %%esi, %c2(%%eax)\n"
"movl %%edi, %c3(%%eax)\n"
"movl %c4(%%ebp), %%edx\n"
"movl %%edx, %c5(%%eax)\n"
"movl %c6(%%ebp), %%ecx\n"
"movl %%ecx, %c7(%%eax)\n"

\
\
\
\
\
\
\
\
\

74

CHAPTER 9. C RUN MODEL

"leal %c8(%%ebp), %%edx\n"
"movl %%edx, %c9(%%eax)\n"
:
: "m" (env),
"i" (offsetof(struct _jmpbuf, ebx)),

"i" (offsetof(struct _jmpbuf, esi)),
"i" (offsetof(struct _jmpbuf, edi)),
"i" (offsetof(struct _jmpframe, ebp)),
"i" (offsetof(struct _jmpbuf, ebp)),
"i" (offsetof(struct _jmpframe, eip)),
"i" (offsetof(struct _jmpbuf, eip)),
"i" (offsetof(struct _jmpframe, args)),
"i" (offsetof(struct _jmpbuf, esp))

: "eax", "ecx", "edx")

#define __longjmp(env, val)

__asm__ __volatile__ ("movl %0, %%ecx\n"
"movl %1, %%eax\n"
"cmp $0, %eax\n"
"jne 0f\n"
"movl $1, %eax\n"
"0:\n"
"movl %c2(%%ecx), %%ebx"
"movl %c3(%%ecx), %%esi"
"movl %c4(%%ecx), %%edi"
"movl %c5(%%ecx), %%ebp"
"movl %c6(%%ecx), %%esp"
"movl %c7(%%ecx), %%edx"
"jmpl *%edx\n"
:
: "m" (env),
"m" (val),
"i" (offsetof(struct _jmpbuf, ebx)),
"i" (offsetof(struct _jmpbuf, esi)),
"i" (offsetof(struct _jmpbuf, edi)),
"i" (offsetof(struct _jmpbuf, ebp)),
"i" (offsetof(struct _jmpbuf, esp)),
"i" (offsetof(struct _jmpbuf, eip))

: "eax", "ebx", "ecx", "edx",
"esi", "edi", "ebp", "esp")

#endif /* __IA32_SETJMP_H__ */

9.3.2.2 X86-64 Implementation

x86-64/setjmp.h

\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

9.3. NONLOCAL GOTO; SETJMP() AND LONGJMP()

75

/*

* THANKS
* ------
* - Henry ’froggey’ Harrington for amd64-fixes
* - Jester01 and fizzie from ##c on Freenode
*/

#ifndef __X86_64_SETJMP_H__
#define __X86_64_SETJMP_H__

#include <stddef.h>
#include <stdint.h>
//#include <signal.h>
#include <zero/cdecl.h>

//#include <mach/abi.h>

struct _jmpbuf {
int64_t
int64_t
int64_t
int64_t
int64_t
int64_t
int64_t
int64_t

rbx;
r12;
r13;
r14;
r15;
rbp;
rsp;
rip;

sigset_t sigmask;

#if (_POSIX_SOURCE)
//
#elif (_BSD_SOURCE)
//
#endif
} PACK();

int

sigmask;

struct _jmpframe {

int64_t rbp;
int64_t rip;
uint8_t args[EMPTY];

} PACK();

/*

* callee-save registers: rbp, rbx, r12...r15
*/

#define __setjmp(env)

__asm__ __volatile__ ("movq %0, %%rax\n"

"movq %%rbx, %c1(%%rax)\n"
"movq %%r12, %c2(%%rax)\n"
"movq %%r13, %c3(%%rax)\n"
"movq %%r14, %c4(%%rax)\n"

\
\
\
\
\
\

76

CHAPTER 9. C RUN MODEL

"movq %%r15, %c5(%%rax)\n"
"movq %c6(%%rbp), %%rdx\n"
"movq %%rdx, %c7(%%rax)\n"
"movq %c8(%%rbp), %%rcx\n"
"movq %%rcx, %c9(%%rax)\n"
"leaq %c10(%%rbp), %%rdx\n"
"movq %%rdx, %c11(%%rax)\n"
:
: "m" (env),

"i" (offsetof(struct _jmpbuf, rbx)),
"i" (offsetof(struct _jmpbuf, r12)),
"i" (offsetof(struct _jmpbuf, r13)),
"i" (offsetof(struct _jmpbuf, r14)),
"i" (offsetof(struct _jmpbuf, r15)),
"i" (offsetof(struct _jmpframe, rbp)),
"i" (offsetof(struct _jmpbuf, rbp)),
"i" (offsetof(struct _jmpframe, rip)),
"i" (offsetof(struct _jmpbuf, rip)),
"i" (offsetof(struct _jmpframe, args)),
"i" (offsetof(struct _jmpbuf, rsp))

: "rax", "rcx", "rdx")

#define __longjmp(env, val)

__asm__ __volatile__ ("movq %0, %%rcx\n"
"movq %1, %%rax\n"
"movq %c2(%%rcx), %%rbx\n"
"movq %c3(%%rcx), %%r12\n"
"movq %c4(%%rcx), %%r13\n"
"movq %c5(%%rcx), %%r14\n"
"movq %c6(%%rcx), %%r15\n"
"movq %c7(%%rcx), %%rbp\n"
"movq %c8(%%rcx), %%rsp\n"
"movq %c9(%%rcx), %%rdx\n"
"jmpq *%%rdx\n"
:
: "m" (env),
"m" (val),
"i" (offsetof(struct _jmpbuf, rbx)),
"i" (offsetof(struct _jmpbuf, r12)),
"i" (offsetof(struct _jmpbuf, r13)),
"i" (offsetof(struct _jmpbuf, r14)),
"i" (offsetof(struct _jmpbuf, r15)),
"i" (offsetof(struct _jmpbuf, rbp)),
"i" (offsetof(struct _jmpbuf, rsp)),
"i" (offsetof(struct _jmpbuf, rip))

: "rax", "rbx", "rcx", "rdx",
"r12", "r13", "r14", "r15",
"rsp")

#endif /* __X86_64_SETJMP_H__ */

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\
\

\

\
\
\
\
\
\
\
\
\
\
\
\
\

9.3. NONLOCAL GOTO; SETJMP() AND LONGJMP()

77

9.3.2.3 ARM Implementation

arm/setjmp.h

#ifndef __ARM_SETJMP_H__
#define __ARM_SETJMP_H__

#include <stddef.h>
#include <stdint.h>
#include <signal.h>

#include <zero/cdecl.h>

#if 0 /* ARMv6-M */

/* THANKS to Kazu Hirata for putting this code online :) */

struct _jmpbuf {

int32_t r4;
int32_t r5;
int32_t r6;
int32_t r7;
int32_t r8;
int32_t r9;
int32_t r10;
int32_t fp;
int32_t sp;
int32_t lr;
#if (_POSIX_SOURCE)

sigset_t sigmask;

#elif (_BSD_SOURCE)

int

sigmask;

#endif
} PACK();

#define __setjmp(env)

__asm__ __volatile__ ("mov r0, %0\n" : : "r" (env));
__asm__ __volatile__ ("stmia r0!, { r4 - r7 }\n");
__asm__ __volatile__ ("mov r1, r8\n");
__asm__ __volatile__ ("mov r2, r9\n");
__asm__ __volatile__ ("mov r3, r10\n");
__asm__ __volatile__ ("mov r4, fp\n");
__asm__ __volatile__ ("mov r5, sp\n");
__asm__ __volatile__ ("mov r6, lr\n");
__asm__ __volatile__ ("stmia r0!, { r1 - r6 }\n");
__asm__ __volatile__ ("sub r0, r0, #40\n");
__asm__ __volatile__ ("ldmia r0!, { r4, r5, r6, r7 }\n");

\
\
\
\
\
\
\
\
\
\
\
\

78

CHAPTER 9. C RUN MODEL

__asm__ __volatile__ ("mov r0, #0\n");
__asm__ __volatile__ ("bx lr\n")

#define __longjmp(env, val)

__asm__ __volatile__ ("mov r0, %0\n" : : "r" (env));
__asm__ __volatile__ ("mov r1, %0\n" : : "r" (val));
__asm__ __volatile__ ("add r0, r0, #16\n");
__asm__ __volatile__ ("ldmia r0!, { r2 - r6 }\n");
__asm__ __volatile__ ("mov r8, r2\n");
__asm__ __volatile__ ("mov r9, r3\n");
__asm__ __volatile__ ("mov r10, r4\n");
__asm__ __volatile__ ("mov fp, r5\n");
__asm__ __volatile__ ("mov sp, r6\n");
__asm__ __volatile__ ("ldmia r0!, { r3 }\n");
__asm__ __volatile__ ("sub r0, r0, #40\n");
__asm__ __volatile__ ("ldmia r0!, { r4 - r7 }\n");
__asm__ __volatile__ ("mov r0, r1\n");
__asm__ __volatile__ ("moveq r0, #1\n");
__asm__ __volatile__ ("bx r3\n")

#endif /* 0 */

struct _jmpbuf {

int32_t r4;
int32_t r5;
int32_t r6;
int32_t r7;
int32_t r8;
int32_t r9;
int32_t r10;
int32_t fp;
int32_t sp;
int32_t lr;
sigset_t sigmask;

} PACK();

#define __setjmp(env)

__asm__ __volatile__ ("movs r0, %0\n"

"stmia r0!, { r4-r10, fp, sp, lr }\n"
"movs r0, #0\n"
:
: "r" (env))

#define __longjmp(env, val)

__asm__ __volatile__ ("movs r0, %0\n"
"movs r1, %1\n"
"ldmia r0!, { r4-r10, fp, sp, lr }\n"
"movs r0, r1\n"
"moveq r0, #1\n"
"bx lr\n"

\

\

\
\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\

\
\
\
\
\
\
\

9.3. NONLOCAL GOTO; SETJMP() AND LONGJMP()

79

:
: "r" (env), "r" (val))

\

#endif /* __ARM_SETJMP_H__ */

9.3.3

setjmp.c

#include <signal.h>
#include <setjmp.h>
#include <zero/cdecl.h>

#if defined(ASMLINK)
ASMLINK
#endif
int
setjmp(jmp_buf env)
{

__setjmp(env);
_savesigmask(&env->sigmask);

return 0;

}

#if defined(ASMLINK)
ASMLINK
#endif
void
longjmp(jmp_buf env,

int val)

{

}

_loadsigmask(&env->sigmask);
__longjmp(env, val);

/* NOTREACHED */

#if defined(ASMLINK)
ASMLINK
#endif
int
_setjmp(jmp_buf env)
{

__setjmp(env);

return 0;

}

80

CHAPTER 9. C RUN MODEL

#if defined(ASMLINK)
ASMLINK
#endif
void
_longjmp(jmp_buf env,

int val)

{

}

__longjmp(env, val);

/* NOTREACHED */

Part V

Computer Basics

81

It is time to take a quick look at basic computer architecture.

83

84

Chapter 10

Basic Architecture

10.1 Control Bus

For our purposes, we can think of control bus as two signals; RESET and CLOCK.

(cid:15) RESET is used to trigger system initialisation to a known state to start running

the operating system.

(cid:15) CLOCK is a synchronisation signal that keeps the CPU and its external [memory

and I/O] devices in synchronisation.

10.2 Memory Bus

Address Bus

Basically, address bus is where addresses for memory and I/O access are delivered. To
simplify things, you might push a memory address on the address bus, perhaps modify
it with an index register, and then fetch a value from or store a value to memory.

Data Bus

Data bus works in concert with the address bus; this is where actual data is delivered
between the CPU and memory as well as I/O devices.

10.3 Von Neumann Machine

Essentially, von Neumann machines consist of CPU, memory, and I/O (input and
output) facilities. Other similar architecture names such as Harvard exist for versions
with extended memory subsystems, mostly, but as that is beyond our scope, I chose the
’original’ name.

85

86

CHAPTER 10. BASIC ARCHITECTURE

10.3.1 CPU

A CPU, central processing unit, is the heart of a computer. Without mystifying and
obscuring things too much, let’s think about it as a somewhat complex programmable
calculator.

For a CPU, the fastest storage form is a register. A typical register set has dedicated
registers for integer and floating point numbers; to make life easier, these are just bit-
patterns representing values (integer) or approximations of values (floating-point) in
some specified formats.

A notable quite-recent trend in CPUs are multicore chips; these have more than one
execution unit inside them in order to execute several threads in parallel.

10.3.2 Memory

Memory is a non-persistent facility to store code and data used by the CPU. Whereas
the register set tends to be fixed for a given CPU, memory can usually be added to
computer systems. From a programmer’s point of view, memory is still several times
slower than registers; this problem is dealt with [fast] cache memory; most commonly,
level 1 (L1) cache is on-chip and L2 cache external to the CPU.

As a rule of thumb, fast code should avoid unnecessary memory access and organize
it so that most fetches would be served from cache memory. In general, let’s, for now,
say that you should learn to think about things in terms of words, cachelines, and pages
- more on this fundamental topic later on.

10.3.3

I/O

I/O, input and output, is used for storing and retrieving external data. I/O devices tend
to be orders of magnitude slower than memory; a notable feature, though, is that they
can be persistent. For example, data written on a disk will survive electric outages
instead of being wiped like most common types of memory would.

In addition to disks, networks have become a more-and-more visible form of I/O. In
fact, whereas disks used to be faster than [most] networks, high-speed networks are
fighting hard for the speed king status.

10.4 Conclusions

Simplified a bit, as a programmer it’s often safe to think about storage like this; fastest
first:

(cid:15) registers
(cid:15) memory
(cid:15) disks
(cid:15) network

10.4. CONCLUSIONS

(cid:15) removable media

Note, though, that high-speed networks may be faster than your disks.

87

88

CHAPTER 10. BASIC ARCHITECTURE

Part VI

Numeric Values

89

In this part, we take a look at computer presentation of numeric values. Deep within,
computer programming is about moving numeric values between memory, registers,
and I/O devices, as well as doing mathematical operations on them.

91

92

Chapter 11

Machine Dependencies

11.1 Word Size

Before the advent of C99 explicit-size types such as int8_t and uint8_t, programmers
had to ’rely on’ sizes of certain C types. I will list [most of] the assumptions made here,
not only as a historic relic, but also to aid people dealing with older code with figuring
it out.

Note that the sizes are listed in bytes.

may be signed; unsigned char for 8-bit clean code

Type
char
short
int
long
long long
float
double
long double

Typical Size Notes
8-bit
16-bit
32-bit
32- or 64-bit
64
32
64
80 or 128

’fast integer’; typically 32-bit
typically machine word
standardised in ISO C99
single-precision floating point
double precision floating point
extended precision floating point

One could try to check for these types with either GNU Autoconf (the configure scripts
present in most open source projects these days use this strategy) or perhaps with some-
thing like

#include <limits.h>

#if (CHAR_MAX == 0x7f)
#define CHAR_SIGNED
#define CHAR_SIZE 1
#elif (CHAR_MAX == 0xff)
#define CHAR_UNSIGNED
#define CHAR_SIZE 1
#endif

#if (SHRT_MAX == 0x7fff)

93

94

CHAPTER 11. MACHINE DEPENDENCIES

#define SHORT_SIZE 2
#endif

#if (INT_MAX == 0x7fffffff)
#define INT_SIZE 4
#endif

#if (LONG_MAX == 0x7fffffff)
#define LONG_SIZE 4
#elif (LONG_MAX == 0x7fffffffffffffffULL)
#define LONG_SIZE 8
#endif

Notes

This code snippets is just an example, not totally portable.

Note that in this listing, sizes are defined in octets (i.e., 8-bit bytes). It’s also noteworthy
that sizeof cannot be used with preprocessor directives such as #if; therefore, when
you have to deal with type sizes, you need to use some other scheme to check for and
declare them.

11.2 Byte Order

Most of the time, when working on the local platform, the programmer does not need
to care about byte order; the concern kicks in when you start communicating with other
computers using storage and network devices.

Byte order is machine-dependent; so-called little endian machines have the lowest byte
at the lowest memory address, and big endian machines vice versa. For example, the
i386 is little endian (lowest byte first), and PowerPC CPUs are big endian.

Typical UNIX-like systems have <endian.h> or <sys/endian.h> to indicate their byte
order. Here’s an example of how one might use it; I define a structure to extract the
8-bit components from a 32-bit ARGB-format pixel value.

#include <stdio.h>
#include <stdint.h>
#include <endian.h> /* <sys/endian.h> on some systems (BSD) */

#if (_BYTE_ORDER == _LITTLE_ENDIAN)
struct _argb {
uint8_t b;
uint8_t g;
uint8_t r;
uint8_t a;

};
#elif (_BYTE_ORDER == _BIG_ENDIAN)
struct _argb {
uint8_t a;
uint8_t r;

95

11.2. BYTE ORDER

uint8_t g;
uint8_t b;

};
#endif
#define aval(u32p) (((struct _argb *)(u32p))->a)
#define rval(u32p) (((struct _argb *)(u32p))->r)
#define gval(u32p) (((struct _argb *)(u32p))->g)
#define bval(u32p) (((struct _argb *)(u32p))->b)

96

CHAPTER 11. MACHINE DEPENDENCIES

Chapter 12

Unsigned Values

With the concepts of word size and byte order visited briefly, let’s dive into how com-
puters represent numerical values internally. Let us make our lives a little easier by
stating that voltages, logic gates, and so on are beyond the scope of this book and just
rely on the bits 0 and 1 to be magically present.

12.1 Binary Presentation

Unsigned numbers are presented as binary values. Each bit corresponds to the power
of two its position indicates, for example

01010101

is, from right to left,

\(1 * 2^0 + 0 * 2^1 + 1 * 2^2 + 0 * 2^3 + 1 * 2^4 + 0 * 2^5 + 1 * 2^6 + 0 * 2^7\)

which, in decimal, is

\(1 + 0 + 4 + 0 + 16 + 0 + 64 + 0 == 85\).

Note that C doesn’t allow one to specify constants in binary form directly; if you really
want to present the number above in binary, you can do something like

#define BINVAL ((1 << 6) | (1 << 4) | (1 << 2) | (1 << 0))

As was pointed to me, the GNU C Compiler (GCC) supports, as an extension to the C
language, writing binary constants like

uint32_t val = 0b01010101; /* binary value 01010101. */

12.2 Decimal Presentation

Decimal presentation of numeric values is what we human beings are used to. In C,
decimal values are presented just like we do everywhere else, i.e.

97

98

CHAPTER 12. UNSIGNED VALUES

int x = 165; /* assign decimal 165. */

12.3 Hexadecimal Presentation

Hexadecimal presentation is based on powers of 16, with the digits 0..9 representing,
naturally, values 0 through 9, and the letters a..f representing values 10 through 15.

For example, the [8-bit] unsigned hexadecimal value

0xff

corresponds, left to right, to the decimal value

\(15 * 16^1 + 15 * 16^0 == 240 + 15 == 255\).

A useful thing to notice about hexadecimal values is that each digit represents 4 bits. As
machine types tend to be multiples of 4 bytes in size, it’s often convenient to represent
their numeric values in hexadecimal. For example, whereas

4294967295

doesn’t reveal it intuitively, it’s easy to see from its hexadecimal presentation that

0xffffffff

is the maximum [unsigned] value a 32-bit type can hold, i.e. all 1-bits.

A useful technique is to represent flag-bits in hexadecimal, so like

#define BIT0
#define BIT1
#define BIT2
#define BIT3
#define BIT4
#define BIT5
/* BIT6..BIT30 not shown */
#define BIT31 0x80000000

0x00000001
0x00000002
0x00000004
0x00000008
0x00000010
0x00000020

where a good thing is that you can see the [required] size of the flag-type easier than
with

#define BIT0
#define BIT1
/* BIT2..BIT30 not shown */
#define BIT31 (1U << 31)

(1U << 0)
(1U << 1)

Hexadecimal Character Constants

Hexadecimal notation can be used to represent character constants by prefixing them
with
x within single quotes, e.g. ’\xff’

12.4. OCTAL PRESENTATION

99

12.4 Octal Presentation

Octal presentation is based on powers of 8. Each digit corresponds to 3 bits to represent
values 0..7. Constant values are prefixed with a ’0’ (zero), e.g.

01234 /* octal 1234 */

Octal Character Constants

One typical use of octal values is to represent numerical values of 7- or 8-bit characters,
of which some have special syntax. In C, octal integer character constants are enclosed
within a pair of single quotes “”’ and prefixed with a backslash “\”.

A char can consist of up to three octal digits; for example ’\1’, ’\01’, and ’\001’ would
be equal.

For some examples in ASCII:

Char
NUL
BEL
BS
SPACE
A
B
a
b
\

Octal C
0’
000’
a’
007’
b’
010’
’ ’
040’
’A’
101
’B’
102
’a’
141
’b’
142
’\\’
134

Notes
string terminator
bell
backspace
space/empty
upper case letter A
upper case letter B
lower case letter a
lower case letter b
escaped with another backslash

12.5 A Bit on Characters

A noteworthy difference between DOS-, Mac- and UNIX-text files in ASCII is that
whereas UNIX terminates lines with a linefeed ’\n’, DOS uses a carriage return +
linefeed pair "\r\n", and Mac (in non-CLI mode) uses ’\r’. Mac in CLI-mode uses ’\n’
just like UNIX.

Implementations of C supporting character sets other than the standard 7-/8-bit let you
use a special notation for characters that cannot be represented in the char-type:

L’x’ /* ’x’ as a wide character (wchar_t) */

12.6 Zero Extension

Zero extension just means filling high bits with 0 (zero). For example, to convert a
32-bit unsigned integral value to 64 bits, you would just fill the high 32 bits 32..63 with
zeroes, and the low 32 bits with the original value.

100

CHAPTER 12. UNSIGNED VALUES

12.7 Limits

The minimum 32-bit unsigned number in C is, naturally,

#define UINT32_MIN 0x00000000U /* all zero-bits. */

The maximum for 32-bit unsigned number is

#define UINT32_MAX 0xffffffffU /* all 1-bits */

12.8 Pitfalls

12.8.1 Underflow

Note that with unsigned types, subtractions with negative results lead to big values. For
example, with 32-bit unsigned types,

uint32_t u32 = 0;

--u32; /* u32 becomes 0xffffffff == UINT32_MAX! */

Therefore, if u32 can be zero, never do something like this:

while (--u32) {

/* do stuff. */

}

Instead, do

if (u32) {

while (--u32) {

/* do stuff. */

}

}

or

do {

/* do stuff. */

} while (u32-- > 0);

12.8.2 Overflow

With unsigned types, additions with results bigger than maximum value lead to small
values. For example, with 32-bit unsigned types,

uint32_t u32 = 0xffffffff; /* maximum value */

++u32; /* u32 becomes 0! */

One hazard here is constructs such as

12.8. PITFALLS

uint16_t u16;

101

for (u16 = 0 ; u16 <= UINT16_MAX ; u16++) {

/* do stuff. */

}

because adding to the maximum value causes an overflow and wraps the value to zero,
the loop would never terminate.

102

CHAPTER 12. UNSIGNED VALUES

Chapter 13

Signed Values

By introducing the sign [highest] bit, we can represent negative values to make life
more interesting.

13.1 Positive Values

Positive values 0..M, where M is the maximum value of a signed type, are represented
just like in unsigned presentation.

13.2 Negative Values

Let us see what is going on with negative [signed] values.

13.2.1

2’s Complement

This section discusses the dominant 2’s complement presentation of negative signed
integral values.

For signed types, negative values are represented with the highest bit (the sign-bit) set
to 1.

The rest of the bits in a negative signed value are defined so that the signed n-bit nu-
meric value i is presented as

\(2^n - 1\)

Note that 0 (zero) is presented as an unsigned value (sign-bit zero).

As an example, 32-bit -1, -2, and -3 would be represented like this:

0xffffffff
#define MINUS_ONE
#define MINUS_TWO
0xfffffffe
#define MINUS_THREE 0xfffffffd

103

104

CHAPTER 13. SIGNED VALUES

To negate a 2’s complement value, you can use this algorithm:

(cid:15) invert all bits
(cid:15) add one, ignoring any overflow

13.2.2 Limits

The minimum 32-bit signed number is

#define INT32_MIN (-0x7fffffff - 1)

whereas the maximum 32-bit signed number is

#define INT32_MAX 0x7fffffff

13.2.3 Sign Extension

Sign extension means filling high bits with the sign-bit. For example, a 32-bit signed
value would be converted to a 64-bit one by filling the high 32 bits 32..63 with the
sign-bit of the 32-bit value, and the low 32 bits with the original value.

13.2.4 Pitfalls

Note that you can’t negate the smallest negative value. Therefore, the result of abs(type_max),
i.e. absolute value, is undefined.

13.2.4.1 Underflow

On 2’s complement systems, the values of subtractions with results smaller than the
type-minimum are undefined.

13.2.4.2 Overflow

On 2’s complement systems, the values of additions with results greater than the type-
maximum are undefined.

Chapter 14

Floating Point Numeric
Presentation

TODO: comparison

http://docs.sun.com/source/806-3568/ncg_goldberg.html

http://randomascii.wordpress.com/2012/09/09/game-developer-magazine-floating-point

This chapter explains the IEEE 754 Standard for floating point values.

14.1 Basics

Floating-point numbers consist of two parts; significand and exponent.

As a typical scientific constant, the speed of light can be represented, in decimal base,
as

299792.458 meters/second

or equivalently

\(2.99792458 x 10^5\).

In C notation, the latter form would be

2.99792458e5 /* speed of light. */

Here the mantissa is 2.99792458 and the exponent in base 10 is 5.

The new versions of the C Language, starting from C99, i.e.
introduced hexadecimal presentation of floating point literals. For example,

ISO/IEC 9899:1999,

0x12345e5

would be equal to

\((1 * 16^4 + 2 * 16^3 + 3 * 16^2 + 4 * 16^1 + 5 * 16^0) * 16^5\)

which would be equal to

105

106

CHAPTER 14. FLOATING POINT NUMERIC PRESENTATION

\((1 * 65536 + 2 * 4096 + 3 * 256 + 4 * 16 + 5 * 1) * 1048576\)

= \((65536 + 8192 + 768 + 64 + 5) * 1048576\)

= \(74565 * 1048576\)

= \(7.818706 * 10^{10}\)

in decimal notation. This is more convenient to write than

78187060000.

14.2

IEEE Floating Point Presentation

The IEEE 754 Standard is the most common representation for floating point values.

14.2.1 Significand; ’Mantissa’

Significand and coefficient are synonymous to [the erroneously used term] mantissa.

The significand in IEEE 754 floating-point presentation doesn’t have an explicit radix
point; instead, it is implicitly assumed to always lie in a certain position within the
significand. The length of the significand determines the precision of numeric presen-
tation.

Note that using the term mantissa for significand is not exactly correct; when using
logarithm tables, mantissa actually means the logarithm of the significand.

14.2.2 Exponent

Scale and characteristic are synonymous to exponent.

It should be sufficient to mention that a floating point value is formed from its presen-
tation with the formula

\(f = significand * base^{exponent}\)

14.2.3 Bit Level

IEEE 754 Floating Point Presentation, at bit-level, works like this

(cid:15) The highest bit is the sign bit; value 1 indicates a negative value.
(cid:15) The next highest bits, the number of which depends on precision, store the expo-

nent.

(cid:15) The low bits, called fraction bits, store the significand.

Let’s illustrate this simply (in most significant bit first) as

(SIGN)|(EXPONENT)|(FRACTION).

14.2. IEEE FLOATING POINT PRESENTATION

107

(cid:15) The sign bit determines the sign of the number, i.e. the sign of the the significand.

(cid:15) The exponent bits encode the exponent; this will be explained in the next, precision-

specific sections.

(cid:15) Wpart is used to denote the width of part in bits.
(cid:15) Conversion equations are given in a mix of mathematical and C notation, most

notably I use the asterisk (’*’) to denote multiplication.

TODO: CONVERSIONS TO AND FROM DECIMAL?

14.2.4 Single Precision

Wvalue is 32,

of which

Wsign is 1
Wexponent is 8
Wsigni f icand is 23.

To get the true exponent, presented in ’offset binary representation’, the value 0x7f
(127) needs to be subtracted from the stored exponent. Therefore, the value 0x7f is
used to store actual zero exponent and the minimum efficient exponent is -126 (stored
as 0x01).

14.2.4.1 Zero Significand

Exponent 0x00 is used to represent 0.0 (zero).

In this case, the relatively uninteresting conversion equation to convert to decimal
(base-10) value is

\((-1)^{sign} * 2^{-126} * 0.significand\).

Exponents 0x01 through 0xfe are used to represent ’normalised values’, i.e. the equa-
tion becomes

\((-1)^{sign} * 2^{exponent - 127} * 1.significand\).

Exponent 0xff is used to represent [signed] infinite values.

14.2.4.2 Non-Zero Significand

(cid:15) Exponent 0x00 is used to represent subnormal values.

(cid:15) Exponents 0x01 through 0xfe represent normalised values, just like with the sig-

nificand of zero.

(cid:15) Exponent 0xff is used to represent special Not-a-Number (NaN) values.

108

CHAPTER 14. FLOATING POINT NUMERIC PRESENTATION

14.2.5 Double Precision

Wvalue is 64,

of which

Wsign is 1
Wexponent is 11
Wsigni f icand is 52.

To get the true exponent, presented in ’offset binary representation’, the value 0x2ff
(1023) needs to be subtracted from the stored exponent.

14.2.5.1 Special Cases

0 (zero) is represented by having both the exponent and fraction all zero-bits.

The exponent 0x7ff is used to present positive and negative infinite values (depending
on the sign bit) when the fraction is zero, and NaNs when it is not.

With these special cases left out, the conversion to decimal becomes

\((-1)^{sign} * 2^{exponent - 1023} x 1.significand\).

14.2.6 Extended Precision

The most common extended precision format is the 80-bit format that originated in the
Intel i8087 mathematics coprocessor. It has been standardised by IEEE.

This extended precision type is usually supported by the C compilers via the long
double type. These values should be aligned to 96-bit boundaries, which doesn’t make
them behave very nicely when 64-bit wide memory access is used; therefore, you may
want to look into using 128-bit long doubles. The Gnu C Compiler (GCC) does allow
this with the

-m128bit-long-double

compiler flag.

Intel SIMD-architectures starting from SSE support the MOVDQA machine instruc-
tion to move aligned 128-bit words between SSE-registers and memory. I tell this as
something interesting to look at for those of you who might be wishing to write, for
example, fast memory copy routines.

14.2.6.1 80-Bit Presentation

Wvalue is 80,

of which

Wsign is 1
Wexponent is 15
Wsigni f icand is 64.

14.3. I387 ASSEMBLY EXAMPLES

109

14.3 i387 Assembly Examples

14.3.1 i387 Header

#ifndef __I387_MATH_H__
#define __I387_MATH_H__

#define getnan(d)

\

(dsetexp(d, 0x7ff), dsetmant(d, 0x000fffffffffffff), (d))

#define getsnan(d) \

(dsetsign(d), dsetexp(d, 0x7ff), dsetmant(d, 0x000fffffffffffff), (d))

#define getnanf(f)

(fsetexp(f, 0x7ff), fsetmant(f, 0x007fffff), (f))

#define getsnanf(f)

(fsetsign(f), fsetexp(f, 0x7ff), fsetmant(f, 0x007fffff), (f))

#define getnanl(ld)

\

\

\

(ldsetexp(f, 0x7fff), ldsetmant(ld, 0xffffffffffffffff), (ld))

#define getsnanl(ld) \

(ldsetsign(ld), ldsetexp(ld, 0x7fff), ldsetmant(ld, 0xffffffffffffffff), (ld))

#endif /* __I387_MATH_H__ */

14.3.2 i387 Source

#include <features.h>
#include <fenv.h>
#include <errno.h>
#include <math.h>
#include <i387/math.h>
#include <zero/trix.h>

__inline__ double
sqrt(double x)
{

double retval;

if (isnan(x) || fpclassify(x) == FP_ZERO) {

retval = x;

} else if (!dgetsign(x) && fpclassify(x) == FP_INFINITE) {

retval = dsetexp(retval, 0x7ff);

} else if (x < -0.0) {
errno = EDOM;
feraiseexcept(FE_INVALID);
if (dgetsign(x)) {

retval = getsnan(x);

} else {

retval = getnan(x);

110

CHAPTER 14. FLOATING POINT NUMERIC PRESENTATION

}
} else {

__asm__ __volatile__ ("fldl %0\n" : : "m" (x));
__asm__ __volatile__ ("fsqrt\n");
__asm__ __volatile__ ("fstpl %0\n"

"fwait\n"
: "=m" (retval));

}

return retval;

}

__inline__ double
sin(double x)
{

double retval;

if (isnan(x)) {
retval = x;

} else if (fpclassify(x) == FP_INFINITE) {

errno = EDOM;
feraiseexcept(FE_INVALID);
if (dgetsign(x)) {

retval = getsnan(x);

} else {

retval = getnan(x);

}
} else {

__asm__ __volatile__ ("fldl %0\n" : : "m" (x));
__asm__ __volatile__ ("fsin\n");
__asm__ __volatile__ ("fstpl %0\n"

"fwait\n"
: "=m" (retval));

}

return retval;

}

__inline__ double
cos(double x)
{

double retval;

__asm__ __volatile__ ("fldl %0\n" : : "m" (x));
__asm__ __volatile__ ("fcos\n");
__asm__ __volatile__ ("fstpl %0\n"

"fwait\n"
: "=m" (retval));

return retval;

14.3. I387 ASSEMBLY EXAMPLES

111

}

__inline__ double
tan(double x)
{

double tmp;
double retval;

if (isnan(x)) {
retval = x;

} else if (fpclassify(x) == FP_INFINITE) {

errno = EDOM;
feraiseexcept(FE_INVALID);
if (dgetsign(x)) {

retval = getsnan(x);

} else {

retval = getnan(x);

}
} else {

__asm__ __volatile__ ("fldl %0\n" : : "m" (x));
__asm__ __volatile__ ("fptan\n");
__asm__ __volatile__ ("fstpl %0\n" : "=m" (tmp));
__asm__ __volatile__ ("fstpl %0\n"

"fwait\n"
: "=m" (retval));

if (dgetsign(retval) && isnan(retval)) {

retval = 0.0;

}

}

return retval;

}

#if ((_BSD_SOURCE) || (_SVID_SOURCE) || _XOPEN_SOURCE >= 600

\

|| (_ISOC99_SOURCE) || _POSIX_C_SOURCE >= 200112L)

__inline__ float
sinf(float x)
{

float retval;

__asm__ __volatile__ ("flds %0\n" : : "m" (x));
__asm__ __volatile__ ("fsin\n");
__asm__ __volatile__ ("fstps %0\n"

"fwait\n"
: "=m" (retval));

return retval;

}

112

CHAPTER 14. FLOATING POINT NUMERIC PRESENTATION

__inline__ float
cosf(float x)
{

float retval;

__asm__ __volatile__ ("flds %0\n" : : "m" (x));
__asm__ __volatile__ ("fcos\n");
__asm__ __volatile__ ("fstps %0\n"

"fwait\n"
: "=m" (retval));

return retval;

}

__inline__ float
tanf(float x)
{

float tmp;
float retval;

if (isnan(x) || fpclassify(x) == FP_ZERO) {

retval = x;

} else if (fpclassify(x) == FP_INFINITE) {

if (dgetsign(x)) {

retval = -M_PI * 0.5;

} else {

retval = M_PI * 0.5;

}
} else {

__asm__ __volatile__ ("flds %0\n" : : "m" (x));
__asm__ __volatile__ ("fptan\n");
__asm__ __volatile__ ("fstps %0\n" : "=m" (tmp));
__asm__ __volatile__ ("fstps %0\n"

"fwait\n"
: "=m" (retval));

if (fgetsign(retval) && isnan(retval)) {

retval = 0.0;

}

}

return retval;

}

__inline__ long double
sinl(long double x)
{

long double retval;

__asm__ __volatile__ ("fldt %0\n" : : "m" (x));
__asm__ __volatile__ ("fsin\n");
__asm__ __volatile__ ("fstpt %0\n"

14.3. I387 ASSEMBLY EXAMPLES

113

"fwait\n"
: "=m" (retval));

return retval;

}

__inline__ long double
cosl(long double x)
{

long double retval;

__asm__ __volatile__ ("fldt %0\n" : : "m" (x));
__asm__ __volatile__ ("fcos\n");
__asm__ __volatile__ ("fstpt %0\n"

"fwait\n"
: "=m" (retval));

return retval;

}

#endif

#if (_GNU_SOURCE)
void
sincos(double x, double *sin, double *cos)
{

__asm__ __volatile__ ("fldl %0\n" : : "m" (x));
__asm__ __volatile__ ("fsincos\n");
__asm__ __volatile__ ("fstpl %0\n"

__asm__ __volatile__ ("fstpl %0\n"

"fwait\n"
: "=m" (*cos));

"fwait\n"
: "=m" (*sin));

return;

}

void
sincosf(float x, float *sin, float *cos)
{

__asm__ __volatile__ ("flds %0\n" : : "m" (x));
__asm__ __volatile__ ("fsincos\n");
__asm__ __volatile__ ("fstps %0\n"

__asm__ __volatile__ ("fstps %0\n"

"fwait\n"
: "=m" (*cos));

"fwait\n"
: "=m" (*sin));

CHAPTER 14. FLOATING POINT NUMERIC PRESENTATION

114

}

return;

void
sincosl(long double x, long double *sin, long double *cos)
{

__asm__ __volatile__ ("fldt %0\n" : : "m" (x));
__asm__ __volatile__ ("fsincos\n");
__asm__ __volatile__ ("fstpt %0\n"

__asm__ __volatile__ ("fstpt %0\n"

"fwait\n"
: "=m" (*cos));

"fwait\n"
: "=m" (*sin));

return;

}
#endif

Part VII

Machine Level Programming

115

Chapter 15

Machine Interface

15.1 Compiler Specification

15.1.1 <cdecl.h>

#ifndef __CDECL_H__
#define __CDECL_H__

/*

- used to define 0-byte placeholder tables a’la

* EMPTY
*
* int tab[EMPTY];
*/

define EMPTY

#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
#
#else
#
#endif

define EMPTY

0

/*

* ALIGN(a)
* PACK
* REGARGS(n)
* ASMLINK
* FASTCALL
*
*/

- align to boundary of a.

- pack structures, i.e. don’t pad for alignment (DIY).

- call with n register arguments.

- external linkage; pass arguments on stack, not registers

- use as many register arguments as feasible

(for system calls).

__attribute__ ((__aligned__(a)))
#define ALIGN(a)
#define PACK
__attribute__ ((__packed__))
#define REGARGS(n) __attribute__ ((regparm(n)))
#define ASMLINK
__attribute__ ((regparm(0)))
#if defined(__i386__)
#define FASTCALL

REGARGS(3)

117

CHAPTER 15. MACHINE INTERFACE

118

#endif

#endif /* __CDECL_H__ */

15.2 Machine Definition

15.2.1 <mach.h>

#ifndef __MACH_H__
#define __MACH_H__

#include <stdint.h>

#define NBWORD
#define NBCL
#define NBPAGE
#define NADDRBIT 32

/* native CPU word size */
/* cacheline size */

4
32
4096 /* page size */

/* number of significant address bits in pointers */

#include "cdecl.h"

/* call frame used by the compiler */
struct m_cframe {

uint8_t avar[EMPTY]; /* automatic variables */
int32_t ebp;
int32_t eip;
uint8_t args[EMPTY]; /* placeholder for function arguments */

/* frame pointer to caller */
/* return address to caller */

} _PACK;

/* stack structure used for interrupt returns (or other use of IRET) */
struct m_iret {

int32_t eip;
int32_t cs;
int32_t eflags;
int32_t esp;
int32_t ss;

};

#endif /* __MACH_H__ */

Chapter 16

IA-32 Register Set

Note that EBP and ESP are usually considered general purpose registers; I deliberately
chose to put them under Special Registers as I feel that’s a better way to think of them.

16.1 General Purpose Registers

Register
EAX
EBX
ECX
EDX
ESI
EDI

Special Use
32-bit return value
data pointer
string and loop counter
I/O pointer, high bits of 64-bit return value
data pointer, string destination
stack data pointer

16.2 Special Registers

Register
EBP
ESP
EIP
EFLAGS machine status flags

Purpose
frame pointer
stack pointer
instruction pointer

16.3 Control Registers

Register
CR3

Purpose
PDBR (page directory page register)

119

120

CHAPTER 16. IA-32 REGISTER SET

Chapter 17

Assembly

17.1 AT&T vs. Intel Syntax

The very first thing to notice for Intel-based platform assembly programmers is that the
Intel syntax

MNEMONIC dest, src

is not valid using the GNU tools GCC and GNU Assembler;

instead, you need to use AT&T syntax, i.e.

MNEMONIC src, dest

to me, as I’m not an old school assembly programmer, this latter syntax makes more
sense. Your mileage may vary. Either way, as it turns out, C is so flexible and fast
that we actually have to resort to assembly very rarely; mostly we need it for certain
machine specific, usually kernel-level, operations as well as in the extreme case, for
code speedups.

Registers are named starting with a ’%’, e.g.

%eax.

When mixing register names with other arguments which need the ’%’ prefix, you need
to make the register names start with ’%%’.

In AT&T syntax, immediate operands are prefixed with $, e.g.

$0x0fc0

would represent the hexadecimal value that would be 0fc0h in Intel syntax; note that
the h suffix is replaced with the C-style 0x prefix.

One more thing to notice is that AT&T syntax assembly encodes the operand size as a
prefix into the opcode, so instead of

mov al, byte ptr val

you need to write

121

CHAPTER 17. ASSEMBLY

122

movb val, %al

so the

byte ptr, word ptr, and dword ptr

memory operands change to opcode postfixes

’b’, ’w’, and ’l’.

For some quadword (64-bit) operations you’d use ’q’ and in some rare cases, for 128-
bit double quadword operations, ’dq’.

For memory addressing using base register, Intel syntax uses

’[’ and ’]’

to enclose the register name; AT&T syntax uses

’(’ and ’)’.

so the Intel syntax for indirect memory references, which would be

[base + index * scale + displacement]

becomes

displacement(base, index, scale)

in the AT&T syntax.

Now this may all be so confusing that I’d better sum it up with a few examples of the
difference of the Intel and AT&T syntaxes.

17.1.1 Syntax Differences

Intel
mov eax, 8
mov ebx, abh
int 80h
mov eax, ebx
mov eax, [ebx]
mov eax, [ebx + 5]
mov eax, [ecx + 40h]
add eax, [ebx + ecx * 4h]
lea eax, [ebx + edx]
add eax, [ebx + edx * 8h - 40h]

AT&T
movl $8, %eax
movl $0xab, %ebx
int $0x80
movl %ebx, %eax
movl (%ebx), %eax
movl 5(%ebx), %eax
movl 0x40(%ecx), %eax
addl (%ebx, %ecx, 0x4), %eax
leal (%ebx, %edx), %eax
addl -0x40(%ebx, %edx, 0x8), %eax

Now let’s take a look at what assembly programs look like.

17.1.2 First Linux Example

This example demonstrates function calls and how to exit a process on Linux using the
exit() system call.

Source Code

17.1. AT&T VS. INTEL SYNTAX

123

# simple example program
# - implements exit(0)

.text

.globl main

main:

call
call

func
linexit

# dummy function to demonstrate stack interaction of C programs

func:

# compiler and CALL set up return stack frame
pushl
movl

%esp, %ebp

%ebp

# DO YOUR THING HERE

leave
ret

# simple function to make an exit() function call on Linux.

linexit:

movl
movl
int

$0x00, %ebx
$0x01, %eax

$0x80

# exit code
# system call number (sys_exit)

# trigger system call

17.1.3 Second Linux Example

Here I implement false in assembly using the exit() system call in a bit different fashion
than in the previous example.

Source Code

# simple educational implementation of false
# - implements exit(1) using the Linux EXIT system call

.text

.globl main

main:

movl
movl
call

$0x01, %eax
%eax, sysnum
lindosys

lindosys:

pushl

%ebp

124

CHAPTER 17. ASSEMBLY

movl

movl
popl
popl
popl
pop
int

leave
ret

.data

sysframe:
_exitval:

.long
.long
.long

.long

sysnum:

%esp, %ebp

$sysframe, %esp
%ebx
%ecx
%edx

%eax
$0x80

0x00000001
0x00000000
0x00000000

# %ebx
# %ecx
# %edx

0x00000001

# linux system call number

17.1.3.1 Stack Usage

Let us take a closer look at how the code above uses the stack.

There’s a label called sysframe in the DATA segment. As the comments suggest, this
contains the register arguments for triggering a Linux system call with. The actual
system call is triggered with

int \$0x80

In this example, the system call number of 0x01 (sys_exit) is passed in sysnum; this
use is equivalent to assigning a global variable in C code.

Our function lindosys starts with the typical prologue for a function with no automatic
(internal/stack) variables, i.e.

pushl %ebp # push frame pointer
movl %esp, %ebp # save stack pointer

After that, it sets the stack pointer to point to sysframe, pops 3 system calls arguments
into the EBX, ECX and EDX registers, copies the system call number from sysnum
into EAX and finally fires the system call by generating an interrupt.

After this, in case of system calls other than exit, it would return to the calling function
with the standard

leave
ret

Function prologue. First, leave sets the stack pointer ESP to the current value of the
frame pointer EBP, then pops the earlier value of frame pointer for the calling function.

17.1. AT&T VS. INTEL SYNTAX

125

After this, ret pops the return address and returns.

Note that the _exitval label is used as an alias to store the first system call argument to
be popped from the stack.

TODO: FINISH... REF: http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html

126

CHAPTER 17. ASSEMBLY

Chapter 18

Inline Assembly

18.1 Syntax

GNU Inline assembly uses the following format

__asm__ (TEMPLATE : OUTPUT : INPUT : CLOBBERED);

TEMPLATE contains the instructions and refers to the optional operands in the OUT-
PUT and INPUT fields. CLOBBERED lists the registers whose values are affected by
executing the instruction in TEMPLATE. As we are going to see a bit later, you can
specify "memory" as a special case in the CLOBBERED field. Also, if the instruc-
tions in TEMPLATE can chance condition code registers, you need to include "cc" in
the CLOBBERED list. Note also that if the code affects memory locations not listed in
the constraints you need to declare your assembly volatile like

__asm__ __volatile__ ("cli\n"); // disable interrupts

/* insert code here */

__asm__ __volatile__ ("sti\n");

the volatile attribute also helps you in the way that the compiler will not try to move
your instructions to try and optimise/reschedule them.

18.1.1 rdtsc()

Let’s see how we can read the timestamp [clock-cycle] counter using the rdtsc assembly
instruction.

#include <stdint.h>

union _rdtsc {

uint32_t u32[2];
uint64_t u64;

};

127

128

CHAPTER 18. INLINE ASSEMBLY

typedef union _rdtsc rdtsc_t;

static __inline__ uint64_t
rdtsc(void)
{

rdtsc_t tsval;

__asm__ ("rdtsc\n"

"movl %%eax, %0\n"
"movl %%edx, %1\n"
: "=m" (tsval.u32[0]),
"=m" (tsval.u32[1])
: /* no INPUT field */
: "eax", "edx");

return tsval.u64;

}

We try to inline this in-header function not visible to other files (declared static). In-
lining has its own section in part Code Optimisation of this book.

In the listing above, the INPUT field consists of the RDTSC instruction, which takes no
operands, and two movl operations. RDTSC returns the low 32 bits of its 64-bit return
value in EAX and the high 32 bits in EDX. We use a trick with the union to make the
compiler return the combination of these two 32-bit values as a 64-bit one. Chances
are it uses the same two registers and can optimise what our code may seem to do.

Notice how the OUTPUT field uses "=m"; output operands are prefixed with ’=’ to de-
note they are assigned/written. The ’m’ means these have to be memory operands (IA-
32 has no 64-bit integer registers). The ’=’ means this an output (write-only) operand.

The CLOBBERED field says we pollute the registers EAX and EDX. All fields except
TEMPLATE are optional. Every optional field that lists more than one operand uses
commas to separate them.

18.2. CONSTRAINTS

18.2 Constraints

18.2.1 IA-32 Constraints

129

Identifier
a
b
c
d
S
D
q
I
J
K
L
M
N
f
t
u
A

Possible Registers or Values
%eax, %ax, %al
%ebx, %bx, %bl
%ecx, %cx, %cl
%edx, %dx, %dl
%esi, %si
%edi, %di
registers a, b, c, or d
constant between 0 and 31 (32-bit shift count)
constant between 0 and 63 (64-bit shift count)
0xff
0xffff
constant between 0 and 3 (lea instruction shift count)
constant between 0 and 255 (out instruction output value)
floating point register
first floating point register (top of stack)
second floating point register
register a or d; 64-bit return values with high bits in d and low bits in a

18.2.2 Memory Constraint

The example above used the memory constraint "=m" for output. You would use "m"
for input operands.

18.2.3 Register Constraints

If you want to let the compiler pick a register to use, use "r" (input) or "=r" (output).
As an example, if you don’t care if a register or memory is used, you can use the
combination of "rm" or "=rm" for input and output operands, respectively. The ’r’ in
them might speed the operation up, but leave it out if you want a memory location to
be updated.

18.2.4 Matching Constraints

Sometimes, a single variable serves both as input and output. You can do this by
specifying matching (digit) constraints.

18.2.4.1 Example; incl

__asm__ ("incl %0" : "=a" (reg) : "0" (reg));

130

CHAPTER 18. INLINE ASSEMBLY

18.2.5 Other Constraints

Constraint Rules
m
o
V
i
n
g

memory operand with any kind of address
offsettable memory operand; adding a small offset gives valid address
memory operand which is not offsettable
immediate integer operand (a constant), including a symbolic constant
immediate integer operand with a known numeric value
any general register, memory or immediate integer operand

Use ’n’ instead of ’i’ for operands less than a word wide if the system cannot support
them as assembly-time constants.

18.2.6 Constraint Modifiers

Constraint Meaning
=
&

write only; replaced by output data
early-clobber operand; modified before instruction finished; cannot be use elsewhere

18.3 Clobber Statements

It is to be considered good form to list registers you clobber in the clobber statement.
Sometimes, you may need to add ¨memory¨ to your clobber statement. Use of the
__volatile__ keyword and making assembly operations single statements is often nec-
essary to keep the compiler [optimiser] from doing hazardous things such as reordering
instructions for you.

18.3.1 Memory Barrier

Where memory access needs to be serialised, you can use memory barriers like this

#define membar() \

__asm__ __volatile__ ("" : : : "memory")

Chapter 19

Interfacing with Assembly

19.1 alloca()

alloca() is used to allocate space within the stack frame of the current function. Whereas
this operation is known to be potentially unsafe, I use it to demonstrate how to interface
with assembly code from our C programs.

131

132

CHAPTER 19. INTERFACING WITH ASSEMBLY

19.1.1

Implementation

Here is our header file to declare alloca().

<alloca.h>

#ifndef __ALLOCA_H__
#define __ALLOCA_H__

#include <stddef.h>

#if defined(__GNUC__)
#define alloca(size) __builtin_alloca(size)
#else
void * alloca(size_t size);
#endif

#endif /* __ALLOCA_H__ */

Let us take a look at the x86-64 version of the alloca() routine.

alloca.S

#if defined(__x86_64__) || defined(__amd64__) && !defined(__GNUC__)

.globl alloca

.text 64

/*

- size argument

* registers at call time
* ----------------------
* rdi
*
* stack at call time
* ------------------
* return address <- stack pointer
*/

alloca:

subq
movq
subq
ret

$8, %rdi
%rsp, %rax
%rdi, %rax

// adjust for popped return address

// copy stack pointer
// reserve space; return value is in RAX

// return

#endif

Notes

(cid:15) After linking with assembled alloca object, alloca can be triggered from C code

just like typical C code by calling alloca().

19.1. ALLOCA()

133

(cid:15) Our alloca() function is disabled with the GNU C Compiler in favor of __builtin_alloca().

19.1.2 Example Use

The code snippet below demonstrates calling alloca() from C code.

#include <string.h>
#include <alloca.h>

#define STUFFSIZE 128

int
dostuff(long cmd)
{

retval;

int
void *ptr;

/* allocate and initialise stack space */
ptr = alloca(STUFFSIZE);
memset(ptr, 0, STUFFSIZE);
/* process cmd */
retval = stuff(cmd, ptr);

return retval;

}

134

CHAPTER 19. INTERFACING WITH ASSEMBLY

Part VIII

Code Style

135

Chapter 20

A View on Style

20.1 Concerns

Readability

Good code should document what it does reasonably well. Comments should not con-
centrate on how something is done (unless it’s obscure), but rather on what is being
done. Good code is easy to read and understand to a point. It is good to hide the more
obscure things; for example, clever macro tricks should be put in header files not to
pollute the code with hard-to-read parts. It’s highly recommended to have style guides
to keep code from several programmers as consistent as possible.

Maintainability

Good code is easy to modify; for example, to add new features to. Although the C
preprocessor is sometimes considered a bit of a curse, macros (and, of course, functions
for bigger code pieces) are good to avoid code repetition. Try to recognise code patterns
and not repeat them; this way, it’s easier to fix possible bugs as they are only in one
place.

Reusability

Good code should be commented and documented otherwise. Good and precise design
specifications help especially team projects. I suggest splitting projects into logical
parts, defining the interfaces between them, and then implementing the modules. This
kind of approach is called divide and conquer by some. There are also top-down
aspects with this approach (you try to see the big picture and start working towards the
details), but the programmers working on the modules may just as well use bottom-up
at lower level. It’s the end-result, the produced code and its quality, that counts. Keep
in mind software development is art and everyone has their own style which is good to
respect as long as it doesn’t interfere with other parts of projects.

137

138

CHAPTER 20. A VIEW ON STYLE

20.2 Thoughts

To Each Their Own

I feel the need to point out that this section is a personal view on things. Team projects
may have style guides and policies very different from these; individual programmers
tend to have their own preferences. To each their own - consider this section food for
thought.

Simplicity

Good code should be as self-documenting as possible. Readability, clarity, intuitivity,
logicality, and such factors contribute to the quality of code. Simplicity makes things
easy to test, debug, and fix. Errare humanum est; the fewer lines of code you have, the
fewer bugs you are likely to find.

Brevity

To make code faster to type, read, and hopefully grasp, I suggest using relatively brief
identifier names.

Here is a somewhat extreme example

/* ’bad’ code commented out */
#if 0
#define pager_get_page_offset(adr) ((uintptr_t)(adr) & 0xfff)
#endif

/* clarified version */
#define pageofs(adr) ((uintptr_t)(adr) & 0xfff)

Note how much easier it is to read the latter one and how little if any information we
hid from the programmers exploring the code.

Mixed Case

As a personal protest at mixing case, let me point out a couple of observations.

Here’s a few different ways for naming a macro like above

It is faster to type and easier to read

pageofs(ptr);

than

page_ofs(ptr);

or

PageOffset(ptr);

or

pageOffset(ptr);

or even

PageOfs(ptr);

20.3. CONVENTIONS

139

You don’t need to hold the shift key for the first one, plus it seems both the most
compact and clearest version to read to me.

As a rule of thumb, the smaller the scope of your variables and functions, the shorter
the names can be.

Consistency

Style is, well, a matter of taste. What ever kind of style you choose, be uniform and
consistent about it. A bit of thought and cleverness will take your code forward a long
way in terms of readability; it’s good for both modifiability and maintainability.

Uniformity

Bigger projects, especially those with several people working on them, benefit mirac-
ulously if all programmers use uniform style. Should you be starting such a project, I
suggest you look into writing a style guide one of the very first things.

20.3 Conventions

K & R

This chapter lists some basic conventions I’m used to follow. Many of these originate
from sources such as Kernighan & Ritchie (the creators of the C language), old UNIX
hackers, and so forth.

20.3.1 Macro Names

Constant Values

One often sees macros named in all uppercase; the C language and UNIX themselves
use this convention repeatedly; SIGABRT, SIGSEGV, SIGILL, EILSEQ, EINTR, EA-
GAIN, etc. all fit my convention of naming constant value macros in all upper case.

Even though I have done so, I tend not to name function-like macros (those with ar-
guments evaluating to a non-constant value) in upper case; instead, I do things such
as

#define SIGMSK
#define SIGRTMSK 0x50 // realtime signals; above 31

0x3f // signals 0 through 63

/* u is unsigned; 0 is not a valid signal number */
#define _sigvalid(u) ((u) && !((u) & ~_SIGMSK))

Note that it’s good form to document what you have done using macros because you
can’t take pointers to macros (could be resolved with wrapper functions).

Comments

Right these days, I’m adopting to the convention of using ’C++ style’ comments (start-
ing with "//") introduced to C in the 1999 ISO standard for end-of-line comments and
comments enclosed between ’/*’ and ’*/’ for comment-only lines. A multiline com-
ment I write like

140

/*

CHAPTER 20. A VIEW ON STYLE

* HAZARD: dirty programming trick below.
*/

#define ptrisaln(ptr, p2) \

(!((uintptr_t)(ptr) & ((p2) - 1)))

Many nice editors such as Emacs can do code highlights, so for example on my setup,
comments show as red text. Such highlight features can also help you debug code;
think of an unclosed comment making a long piece of text red and how easy it makes
to spot the missing comment closure.

20.3.2 Underscore Prefixes

Note that C reserves identifiers whose name begin with an underscore (’_’) for system
use. Read on, though.

An old convention is to prefix names of identifiers with narrow scope (not visible to all
files) with underscores. It’s negotiable if one should use a single underscore or two - or
use them at all. Chances are you should introduce such identifiers within the file or in
a header used in relatively few places. A seasoned hacker may barf on you if you make
them globally visible. =)

20.3.3 Function Names

Even though I’m not a big fan of all object-oriented naming schemes, I do attest seeing
the name of the module (file) where a function is implemented from its name is a good
thing. Whether you should or should not use underscores as word delimiters depends
on what you feel is the best way. ;) However, my vote still goes for brevity; remember
my earlier rant about why I would use pageofs as a macro name over a few alternatives.

20.3.4 Variable Names

I will tell you a few examples of how I’m planning to name variables in my ongoing
kernel project.

(cid:15) As always, try to be brief and descriptive.

(cid:15) Leave the shortest names, such as ’x’, ’y’, ’z’, to automatic variables or, when
there’s little risk of being misunderstood, aggregate fields to avoid namespace
collisions.

(cid:15) Use parameter names for function prototypes in header files.

(cid:15) Use longer and more descriptive names for global variables (if you need to use

them) and function arguments, again to avoid polluting the name space.

(cid:15) Use names starting with ’u’ for unsigned types to make it easier to predict vari-
able behavior, especially when doing more creative arithmetics (e.g., dealing
with overflows by hand) on them.

20.3. CONVENTIONS

20.3.5 Abbreviations

141

I am of the opinion that abbreviations are a good thing when used with care; uniformly
and consistently. However, naming schemes for them vary so much that I thought a bit
of documentation on them would be good.

Examples

142

CHAPTER 20. A VIEW ON STYLE

Abbreviation
adr
arg
atr
aln
auth
blk
buf
cbrt
cl
con
cpu
ctx
cur
decr
fp
fpu
frm
func
gpu
lst
mem
mod
nam
num
hst
htab
hw
id
incr
intr
lg
mtx
ndx
num
nod
pc
perm
phys
pnt
ppu
proc
prot
proto
pt
ptr
rbt
reg
ret
rtn
sem
shm
sp
sqrt
stk
str
tab
thr
tmp
val
virt

vm

Explanation
address; numerical pointer value
argument
attribute
alignment; addresses
authentication; authorisation
block; I/O
buffer; I/O
cubic root
cache line
console
central processor unit
context
current [item]
decrement
frame pointer
floating point unit
frame
function; function pointers
graphics processor unit
list
memory
module
name
number; numerical identication
host
hash table
hardware
[possibly numerical] identification
increment
interrupt
logarithm
mutex (mutual exclusion lock)
index
number; numerical ID
node
program counter; instruction pointer
permission
physical; address
point
physics processor unit
process; processor
protection
protocol
part; point
pointer
red-black tree
register
return
routine
semaphore
shared memory
stack pointer
square root
stack
string
table; array
thread
temporary variable
[probably numerical] value
virtual; address

virtual memory

20.4. NAMING CONVENTIONS

143

I suggest the laziness of not thinking beyond names such as xyzzy, foo, bar, foobar,
etc. for only the very quickest [personal] hacks. There it can be lots of fun though, and
it may be humorous to people with similar hacker mindset. =D

20.4 Naming Conventions

(cid:15) prefix machine-specific names with m_ (machine dependent), for example struct

m_iret

(cid:15) prefix floating point variable names with f
(cid:15) name loop iteration counts like i (int) or l (long); for nested loops, use successive

single-letter names (j, k, etc. or m, n and so forth

(cid:15) use mathematical symbols such as x, y, and z where relevant
(cid:15) n for count variables; alone or as a prefix
(cid:15) name functions and function-like macros descriptively like pagemap(), pagezero()
(cid:15) prefix file-global entities (ones outside functions) with module (file) or other
logical names; for example, a global page map in mem.c could be memphysmap
or membufmap

(cid:15) prefix names of program globals (such as structs) with program or some other

conventional name such as k or kern in a kernel

(cid:15) name constant-value macros with all upper case like the C language often does

(e.g. EILSEQ)

(cid:15) brevity over complexity; why name a function kernel_alloc_memory when
kmalloc works just as well; is easier to read and actually C-library style/con-
ventional

Here is an example. TODO: better/bigger example

#include "mem.h"

/* initialise i386 virtual address space */
pageinit(uint32_t *map, uint32_t base, uint32_t size);

#define KVMBASE 0xc0000000 // virtual memory base
#define NPDE

1024

uint32_t mempagedir[NPDE];

Globals

Note that use of globals entities (those beyond file scope), should generally be avoided.
When you have to do it, consider using file-scope structures which you put members
into and passing pointers them to your functions. This will keep the namespace cleaner
and confusions fewer.

This code snippet reflects how I tend to, to a point, organise things in files. The order
is usually something like described below.

CHAPTER 20. A VIEW ON STYLE

144

Source Files

(cid:15) #include statements
(cid:15) globals
(cid:15) function implementations

Header Files

(cid:15) #include statements
(cid:15) typedef statements
(cid:15) function prototypes
(cid:15) function-like macros
(cid:15) constant macros
(cid:15) aggregate type (struct and union) declarations

20.5 Other Conventions

(cid:15) use comments to tell what the code does without getting too detailed
(cid:15) use narrow scope; use static for local scope (used within a file) identifiers; try
to stick close to one file per module (or perhaps a source file + header), e.g.
mem.c and mem.h for memory management

(cid:15) use macros; hiding peculiar things such as creative bit operations makes them
easier to reuse (and if put into header files, keeps them from hurting your eyes
when reading the actual code) :)

(cid:15) avoid ’magic numbers’; define macros for constants in code for better maintain-

ability

(cid:15) use typedef sparingly; keep things easier to grasp at first sight
(cid:15) avoid code repetition and deep nesting; use macros; pay attention to program

flow

(cid:15) use parentheses around macro arguments in macro bodies to avoid hard-to-find

mistakes with macro evaluation

(cid:15) enclose macros which use if inside do /* macro body */ while (0) to avoid

unexpected behavior with else and else if

do ... while (0)

To illustrate the last convention, it is good to use

#define mymacro(x) \
do { \

if (x) printf("cool\n") else printf("bah\n"); \

} while (0)

or, perhaps better still

20.5. OTHER CONVENTIONS

145

#define mymacro(x) \
do { \

if (x) { \

printf("cool\n"); \

} else { \

printf("bah\n"); \

}

} while (0)

instead of

#define mymacro(x) \
if (x) printf("cool\n") else printf("bah\n")

146

CHAPTER 20. A VIEW ON STYLE

Part IX

Code Optimisation

147

Chapter 21

Execution Environment

21.1 CPU Internals

In this section, we shall take a quick look on some hardware-level optimisation tech-
niques which processors use commonly.

21.1.1 Prefetch Queue

Prefetch queues are used to read chunks of instruction data at a time. It’s a good idea
not to use many branching constructs, i.e. jump around in code, to keep the CPU
from not having to flush its prefetch queue often.

21.1.2 Pipelines

Processor units use pipelining to execute several operations in parallel. These oper-
ations, micro-ops, are parts of actual machine instructions. A common technique to
make code ’pipeline’ better, i.e. run faster, is to avoid data dependencies in adjacent
operations. This means that the target operands should not be source operands for
the next instruction (or operation at ’high’ level such as C code). Ordering operations
properly reduces pipeline stalls (having to wait for other operations to complete to
continue), therefore making code execute more in parallel and faster.

21.1.3 Branch Prediction

TODO

149

150

CHAPTER 21. EXECUTION ENVIRONMENT

Chapter 22

Optimisation Techniques

Even though careful coding will let you avoid having to apply some of these techniques,
it is still good to know about them for the cases where you deal with code either written
by other people or by yourself earlier; one learns and becomes better all the time by
doing; in this case, a better programmer by programming.

22.1 Data Dependencies

A Few Words on Memory

Note that memory has traditionally been, and still is to a point, much slower to access
than registers. Proper memory access works word by word within alignment require-
ments. Memory traversal such as zeroing pages should benefit from

Removing Data Dependency on Pointer

while (i--) {

ptr[0] = 0;
ptr[1] = 0;
ptr[2] = 0;
ptr[3] = 0;

ptr += 4;
}

over

while (i--) {

*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;

}

because the next memory transfer does not depend on a new pointer value. It often
pays to organise memory access in code, just like it’s good to organise instructions so

151

152

CHAPTER 22. OPTIMISATION TECHNIQUES

as to do something creative before using the last computation’s results. This technique
is called data dependency elimination.

22.2 Recursion Removal

Here is the modified first example program for a hypothetical programming game we
are developing codenamed Cyberhack. :)

void
start(void)
{

run(rnd(memsz));

}

void
run(unsigned int adr)
{

int myid = 0x04200420;
int *ptr = (int *)adr;

ptr[0] = myid;
ptr[1] = myid;
ptr[2] = myid;
ptr[3] = myid;

run(rnd(memsz));

}

As the experienced eye should see, this would lead to quite a bit of stack usage; run()
calls itself tail-recursively (recursion at end). Every call will generate a new stack
frame, which leads to indefinitely growing stack.

Stack Bloat After N Calls to run()

return address to caller
caller’s frame pointer

retadr
prevfp
> ... <
retadr Nth stack frame
prevfp Nth stack frame

You should, instead, use something like

void
start(void)
{

for ( ; ; ) {

run(rnd(memsz));

}

}

void

22.3. CODE INLINING

153

run(unsigned int adr)
{

int myid = 0x04200420;
int *ptr = (int *)adr;

ptr[0] = myid;
ptr[1] = myid;
ptr[2] = myid;
ptr[3] = myid;

return;

}

22.3 Code Inlining

inline-keyword

C99 introduced (and systems widely used it before) the keyword inline. This is a hint
to the compiler to consider inlining functions.

Let’s look at the example of C in the end of the previous chapter. We call run() once
per loop iteration from start(). Instead, it’s a good idea to use

void
run(void)
{

int myid = 0x04200420;

for ( ; ; ) {

int *ptr = (int *)rnd(memsz);

ptr[0] = myid;
ptr[1] = myid;
ptr[2] = myid;
ptr[3] = myid;

}

}

In this final example, we get by with only one stack frame for run().

Inlining Code

The idea of inlining code is to avoid function calls, especially for small operations and
ones that are done often (say, from inside loops).

Macros can be used for extreme portability, but __inline__ and related attributes have
been around for so long already (not in C89) that they are often a better bet; macros are
next to impossible to debug.

Here is a GCC example. rdtsc() was first introduced in the chapter Inline Assembly
elsewhere in this book. This is an example that uses inline in concert with static in
header files, so the declaration is only visible in one file at a time.

154

CHAPTER 22. OPTIMISATION TECHNIQUES

static __inline__ uint64_t
rdtsc(void)
{

rdtsc_t tsval;

__asm__ ("rdtsc\n"

"movl %%eax, %0\n"
"movl %%edx, %1\n"
: "=m" (tsval.u32[0]),
"=m" (tsval->u32[1])
: /* no INPUT field */
: "eax", "edx");

return tsval.u64;

}

Here is the same code changed to a macro. This one works even with compilers not
supporting the use of keywords such as inline or __inline__.

/* write RDTSC to address tp in memory */
#define rdtsc(tp)

\

__asm__ ("rdtsc\n"

\

\

"movl %%eax, %0\n
"movl %%edx, %1\n"
\
: "=m" ((tp)->u32[0]) \
"=m" ((tp)->u32[1])
\
: /* no INPUT field */ \
: "eax", "edx")

22.4 Unrolling Loops

This section describes a technique which good compilers utilise extensively.

Chances are you don’t need to unroll by hand, but I think it’s good to see how to do it
and even a good compiler might not do it when you want to.

This section represents use of so-called Duff’s device.

22.4.1 Basic Idea

The idea of loop unrolling is to run the code for several loop iterations during one.
This is to avoid loop-overhead, mostly of checking if the loop is to be reiterated, and
perhaps, with modern CPUs, to utilise pipeline-parallelism better.

I will illustrate loop unrolling with a simplified piece of code to set memory to zero
(a common operation to initialise global data structures as well as those one gets from
malloc(); the latter can be asked to be zeroed explicitly by using calloc()). This one
assumes sizeof(long); for a better version, see section Duff’s Device below.

Source Code

22.5. BRANCHES

155

void
pagezero(void *addr, size_t len)
{

long *ptr = addr;
long val = 0;
long incr = 4;

len >>= 4;
while (len--) {

ptr[0] = val;
ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
ptr += incr;

}

}

22.5 Branches

As a rule of thumb, if and when you have to use branches, order them so that the most
likely ones are listed first. This way, you will do fewer checks for branches not to be
taken.

22.5.1 if - else if - else

It pays to put the most likely branches (choices) to be taken as far up in the flow as
possible.

22.5.2 switch

Switch is useful, e.g. for implementing Duff’s devices.

22.5.2.1 Duff’s Device

Duff’s Device

Duff’s device can best be demonstrated by how to use it. Here is a version of our
function pagezero() above programmed using one. Pay attention to how the switch
falls through when not using break to terminate it. This example also attempts to
figure out sizeof(long) at compile-time by consulting compiler implementation’s type
limits.

Source Code

156

CHAPTER 22. OPTIMISATION TECHNIQUES

/* don’t compile */

/* use Duff’s device for unrolling loop */

#include <stdint.h>
#include <limits.h>

/* determine size of long */
#if (ULONG_MAX == 0xffffffffUL)
#define LONGBITS 32
#elif (ULONG_MAX == 0xffffffffffffffffUL)
#define LONGBITS 64
#else
#error pagezero not supported for your word-size
#endif

void
pagezero(void *addr, size_t len)
{

long *ptr = addr;
long val = 0;
long incr = 4;

#if (LONGBITS == 32)

long mask = 0x0000000fL;

#elif (LONGBITS == 64)

long mask = UINT64_C(0x00000000000000ffL);

#endif

#if (LONGBITS == 32)

len >>= 4;

#elif (LONGBITS == 64)

len >>= 5;

#endif

while (len) {

/* Duff’s device */
switch (len & mask) {

case 0:

ptr[3] = val;

case 1:

ptr[2] = val;

case 2:

ptr[1] = val;

case 3:

ptr[0] = val;

}
ptr += incr;
len--;

}

}

22.5. BRANCHES

22.5.3 Jump Tables

157

Sometimes there’s a way to get around branching with if - elseif - else or switch state-
ments by making close observations on the values you decide branch targets on.

As an example, I’ll show you how to optimise event loops, which practically all X11
clients (application programs) use.

Here, the thing to notice is that instead of the possibly worst case of doing something
like

XEvent ev;

XNextEvent(disp, &event);
if (ev.type == Expose) {

/* handle Expose events */

} else if (ev.type == ButtonPress) {

/* handle ButtonPress events */
} else if (ev.type == ButtonRelease) {

/* handle ButtonRelease events */

} /* and so forth. */

which can easily grow into a dozen else if branches or more,

one could do something like

/* ... */
switch (ev.type) {

case Expose:

/* handle Expose events */

break;

case ButtonPress:

/* handle ButtonPress events */

break;

case ButtonRelease:

/* handle ButtonRelease events */

break;
/* and so on */
default:

break;

}

which a good compiler might find a way to optimise to a jump table, it’s worth one’s
attention to take a look at event number definitions in <X11/X.h>

/* excerpts from <X11/X.h> */
/* ... */
#define ButtonPress 4
#define ButtonPress 5

158

CHAPTER 22. OPTIMISATION TECHNIQUES

/* ... */
#define Expose
/* ... */
#define LASTEvent

12

36 /* must be bigger than any event # */

As we can see, not only are event numbers small integral constants greater than 0 (0
and 1 are reserved for protocol errors and replies), but an upper limit for them is also
defined. Therefore, it is possible, for standard (i.e. non-extension) Xlib events, to do
something like

#include <X11/X.h>
/* event handlers take event pointer argument */
typedef void evfunc_t(XEvent *);

evftab[LASTEvent]; /* zeroed at startup */

evfunc_t
evfunc_t *evfptr;
XEvent ev;

XNextEvent(disp, &ev);
evfptr = evftab[ev->type]
if (evfptr) {

evfptr(&ev);

}

Function Pointers

In short, we typedef (for convenience) a new type for event handler function pointers
and use event numbers to index a table of them. In case we find a non-zero (non-NULL)
pointer, there is a handler set for the event type and we will call it, passing a pointer to
our just-read event to it. Not only is the code faster than the earlier versions, but it is
also cleaner and more elegant if you ask me.

Dynamic Approach

It is also possible to extend this scheme to handle extension events if you allocate the
handler function pointer table dynamically at run time.

22.6 Bit Operations

In these examples, the following conventions are used

Notes
one 1-bit, the rest are zero

Variable Requirements
p2
power of two
l2
base-2 logarithm
w
integral value

w ^ w equals 0.

w ^ 0xffffffff equals ~w.

if l2 raised by 2 is p2 and w is unsigned,

22.6. BIT OPERATIONS

159

w >> l2 is equal to w / p2 and

w << l2 is equal to w * l2.

if and only if p2 is power of two,

p2 % (p2 - 1) equals 0.

~0x00000000L equals 0xffffffffL [equals (-1L)].

Notes

(cid:15) ISO C standard states results of right shifts of negative values are undefined.
The C standard also doesn’t specify whether right shifts are logical (fill with
zero) or arithmetic (fill high bits with sign).

22.6.1 Karnaugh Maps

TODO: show how to use Karnaugh maps to optimise Boolean stuff.

22.6.2 Techniques and Tricks

I will start this section with what seems a somewhat rarely used trick.

A double-linked list item typically has two pointers in each item; prev and next, which
point to the previous and next item in a list, respectively. With a little bit magic and
knowing one of the pointers at access time, we can pack two pointers into one integral
value (probably of the standard type uintptr_t).

pval = (uintptr_t)ptr1 ^ (uintptr_t)ptr2;

/* do something here */

/* pval properties */
p1 = (void *)(pval ^ (uintptr_t)ptr2);
p2 = (void *)(pval ^ (uintptr_t)ptr1);

We can also remove one of the value by XORing the value of their XOR with the other
one, so

op1 = (void *)(pval ^ p2); // op1 == ptr1
op2 = (void *)(pval ^ p1); // op2 == ptr2

would give us the original values of ptr1 and ptr2.

In other words, the XOR logical function is used so that XORing the packed value with
one pointer evaluates to the integral value of the second one.

Note that you can’t remove items from the middle of a list implemented using this
technique if you don’t know the address of either the previous or next item. Hence,
you should only use it for lists when you operate by traversing them in order. This
could be useful for a kernel pager LRU queues; the list would allow us to add (push)

160

CHAPTER 22. OPTIMISATION TECHNIQUES

page item just allocated or paged in front of the queue and remove (dequeue) pages to
be written out from the back. The structure would then serve as a stack as well as a
simplified two-end list.

This looks fruitful; a trivial structure for implementing such a list would look like

struct page {
uintptr_t
struct page *prev;
struct page *next;

adr;

};

This would be changed to

struct page {

uintptr_t adr;
uintptr_t xptr; // XOR of prev and next.

};

If we have a table of such structures, we may not even need the address field; the
address space is linear and if there is a structure for every page starting from the address
zero and pagetab is a pointer to the table, we can do

#define PTRPGBITS 12 // i386

/* calculate page address from structure offset */
#define pageadr(pp) \

((uintptr_t)((pp) - (pagetab)) << PTRPGBITS)

/* minimal page structure */
struct page {

uintptr_t xptr; // XOR of prev and next.

};

The i386 has virtual address space of 1024 * 1024 pages, so the savings compared
to the first version are (1024 * 1024 * 64 bits) which is 8 megabytes; we’d only use
4 megabytes instead of 12 for the page structure table, and even the second version
would use 8.

22.7 Small Techniques

22.7.1 Constant Folding

22.7.2 Code Hoisting

Loop invariant motion

Taking everything unnecessary out of loops, especially inner ones, can pay back nicely.
A good compiler should know to do this, but it’s still good to know what is going on.

do {

*ptr++ = 0;

22.8. MEMORY ACCESS

161

} while (ptr < (char *)dest + nb);

We can hoist the addition out of the loop continuation test.

char *lim = (char *)dest + nb;

do {

*ptr++ = 0;
} while (ptr < lim);

22.8 Memory Access

C programmers see memory as flat table of bytes. It is good to access memory in as
big units as you can; this is about words, cachelines, and ultimately pages.

22.8.1 Alignment

As a rule of thumb, align to the size of the item aligned; e.g.

Alignment Common Types
1-byte
2-byte
4-byte
8-byte
16-byte

int8_t, uint8_t, char, unsigned char
int16_t, uint16_t, short
int32_t, uint32_t, int, long for 32-bit
int64_t, uint64_t, long on 64-bit, long long
long double if 128-bit

Assumed Type Sizes

The table above lists sized-types (recommended), but also common assumptions to
make it easier for you to read existing code or write code for older pre-C99 compilers.

22.8.2 Access Size

Try to keep memory access sizes aligned to word, cacheline, and page boundaries.
Keep closely-related data close in memory not to use too many cachelines. Access
memory in words rather than bytes where possible (alignment!).

22.8.2.1 Alignment

Many systems raise a signal on unaligned word access of memory, and even the ones
that don’t will need to read two words and combine the result. Therefore, keep your
word access aligned to word boundaries at all times.

if p2 is power of two, a pointer is
aligned to p2-boundary if

((uintptr_t)ptr & ((p2) - 1)) == 0

This leads to the macro

162

CHAPTER 22. OPTIMISATION TECHNIQUES

#define aligned(p, p2) \

(((uintptr_t)(p) & ((p2) - 1)) == 0)

Which can also be written as

#define aligned(p, p2) \

(!((uintptr_t)(p) & ((p2) - 1)))

Which one of these two forms is more readable is a matter of taste.

22.8.3 Cache

Typical microprocessors have 2-3 levels of cache memory running at different speeds.
The L1 (on-die) cache is the fastest. Memory is read into cache a cacheline or stride
at a time; on a typical IA-32 architecture, the cacheline is 32 bytes, i.e. 256 bits. By
using local cache parameters and word-access wisely, you can have good wins in code
run speeds.

22.8.3.1 Cache Prewarming

Pentium Writeback Trick

Interestingly, it looks like some Pentium-class systems such as my AMD Athlon XP,
seem to write cachelines faster if they read the first item of the cacheline to be written
into a register first. For example, see the sections on pagezero() below. The trick is to
make sure the cacheline is in cache memory to avoid writing to main memory directly
with the Pentium writeback semantics. It depends on the application whether this usage
of the cache speeds things up.

22.9 Code Examples

22.9.1 pagezero()

Here I make a few assumptions to simplify things. This could be used verbatim at
kernel-level as the name of the function, pagezero, suggests.

The requirements (which make all but the trivial version unuseful as implementations
of memset(), an implementation of which is found elsewhere in this book), for this
function are

TODO: fix item #3

(cid:15) The region to be zeroed must be aligned to a boundary of long, i.e. its address is

an even multiple of sizeof(long).

(cid:15) The size of the region is a multiple of sizeof(long).

(cid:15) In the unrolled versions, the size of the region must be a multiple of 4 * sizeof(long).

22.9. CODE EXAMPLES

163

Note that even though some of these implementations may seem silly, I have seen most
if not all of them reading code. Everyone makes mistakes and has to end improving
things if, say, deadlines are to be met. After all, computer programming is an ongoing
learning process which is one of the reasons it can be so satisfactory. It also seems
good to look at slower code to see how it can be improved.

22.9.1.1 Algorithms

pagezero1()

In short, we set memory to 0 a long at a time. This is the trivial and slowest version.

Source Code

/* we assume sizeof(long) is 4 */

void
pagezero1(void *adr, size_t len)
{

long *ptr = adr;

len >>= 2;
while (len--) {
*ptr++ = 0;

}

}

pagezero2()

Let us unroll the loop to make the code run faster.

Source Code

void
pagezero2(void *adr, size_t len)
{

long *ptr = adr;

len >>= 2;
while (len) {

*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;
len -= 4;

}

}

pagezero3()

Let us, without thinking of it twice, replace the subtraction of 4 from len because INC

164

CHAPTER 22. OPTIMISATION TECHNIQUES

(decrement by one) might be a faster machine instruction than SUB (generic subtrac-
tion).

Source Code

void
pagezero3(void *adr, size_t len)
{

long *ptr = adr;

len >>= 4;
while (len--) {
*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;

}

}

As DIV (division) tends to be a very slow operation and 4 is a power of two, I also used

len >> 4;

instead of

len /= 16;

or, better

len /= 4 * sizeof(long);

which a good compiler should do as well.

This may be a bit better, but still quite pathetic.

pagezero4()

There’s a data dependency on ptr, whose value changes right after we use it and so
right before we use it again. Fortunately, it is easy to eliminate this speed issue.

Let’s try

Source Code

void
pagezero4(void *adr, size_t len)
{

long *ptr = adr;
size_t ofs = 0;

len >>= 4;
while (len--) {

ptr[ofs] = 0;
ptr[ofs + 1] = 0;
ptr[ofs + 2] = 0;
ptr[ofs + 3] = 0;

22.9. CODE EXAMPLES

165

ptr += 4;

}

}

pagezero5()

Again, this looks better. However, as you can see, we are doing unnecessary calcula-
tions adding constants to ofs. Time to change the code again. As it turns out, we don’t
need the variable ofs at all.

Source Code

void
pagezero5(void *adr, size_t len)
{

long *ptr = adr;

len >>= 4;
while (len--) {
ptr[0] = 0;
ptr[1] = 0;
ptr[2] = 0;
ptr[3] = 0;
ptr += 4;

}

}

There’s at least one more reason why this should be better than the previous version in
addition to the fact that we eliminated a variable and a bunch of addition operations;
IA-32 supports indexed addressing with immediate 8-bit index constants (embedded to
machine instructions), and a good compiler should make this version use 8-bit imme-
diate indices.

pagezero6()

There is still one more thing a good compiler should do that I will show for the sake
of your knowledge. Let us eliminate the possibility of a non-optimising compiler (or
optimising one running with the optimisations turned off, which is common practice
when compiling code to be debuggable) doing the memory writes by replicating a
MOV with the constant zero as immediate operand.

Source Code

void
pagezero6(void *adr, size_t len)
{

long *ptr = adr;
long val = 0;

len >>= 4;
while (len--) {

ptr[0] = val;

166

CHAPTER 22. OPTIMISATION TECHNIQUES

ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
ptr += 4;

}

}

Now, with a bit of luck, val is assigned a register, the instructions [without the imme-
diate operands] shorter and so the loop more likely to use less code cache to reduce
’trashing’ it, and last but not least, the size of the compiled binary should be smaller.

pagezero7()

As one more change, let’s try replacing the increment constant 4 within the loop with a
variable (hopefully register). Note that most of the time, the register keyword should
not be used because it forces compilers to allocate a register for the whole runtime
of the function, therefore making the set of available registers for other computations
smaller.

Source Code

void
pagezero7(void *adr, size_t len)
{

long *ptr = adr;
long val = 0;
long incr = 4;

len >>= 4;
while (len--) {

ptr[0] = val;
ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
ptr += incr;

}

}

pagezero8()

This version of the routine adds a bit of portability. Note that you can’t use sizeof(long)
to define LONGBITS; this makes the code need to be modified for different systems;
not a hard thing to port.

pagezero8() also moves the loop counter decrement [by one] operation to the end of
the loop; it doesn’t need to be executed right after checking it in the beginning.

Source Code

#define LONGBITS 32
void
pagezero8(void *adr, size_t len)
{

22.9. CODE EXAMPLES

167

long *ptr = adr;
long val = 0;
long incr = 4;

#if (LONGBITS == 32)

len >>= 4;

#elif (LONGBITS == 64)

len >>= 5;

#endif

while (len) {

ptr[0] = val;
ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
len--;
ptr += incr;

}

}

pagezero9() and test

I read the good book Inner Loops by Rick Booth to learn what my old friend Eric
B. Mitchell calls cache warming; Rick explains how Pentiums use writeback cache
in a way that they write directly to main memory if the cacheline being written is
not in cache. This is probably the reason a cacheline read before writing the cacheline
dropped pagezero()’s runtime from 12 microseconds for pagezero8() to 9 for pagezero9()
on the system I tested them on. A worthy speedup. Note also how I let memory access
settle for a bit by moving other operations in between reading memory and writing it.
As a Pentium-detail, the beast has 8 data buses to cache, one for each 4-byte entity of
the cacheline, so writes here should use all 8 buses and work fast. With the Pentium
parameters of 32-byte cache lines and 32-bit long words, this loop writes a single cache
line of zeroes each loop iteration.

Some of the header files, such as zen.h needed to build the examples in this book are
represented in the part Code Examples.

Source Code

#include <stdio.h>
#include <stdlib.h>
#include "cdecl.h"
#include "zen.h"

/* we assume sizeof(long) is 4 */
#define LONGBITS 32

uint8_t pagetab[1024 * 1024] __attribute__((__aligned__(4096)));

unsigned long
profzen(void (*routine)(void *, size_t), char *str)
{

168

CHAPTER 22. OPTIMISATION TECHNIQUES

clk;

zenclk_t
unsigned long nusec;
unsigned long mintime;
long

l;

memset(pagetab, 0xff, sizeof(pagetab));
sleep(1);
for (l = 0 ; l < 1024 ; l++) {

zenstartclk(clk);
routine(pagetab, 65536);
zenstopclk(clk);
nusec = zenclkdiff(clk);
if (nusec < mintime) {

mintime = nusec;

}

}
fprintf(stderr, "%s took %lu microseconds\n", str, mintime);

return nusec;

}

void
pagezero9(void *adr, size_t len)
{

long *next = adr;
long *ptr;
long val = 0;
long incr = 8;
long tmp;

#if (LONGBITS == 32)

len >>= 5;

#elif (LONGBITS == 64)

len >>= 6;

#endif

while (len) {

tmp = *next;
len--;
ptr = next;
ptr[0] = val;
ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
next += incr;
ptr[4] = val;
ptr[5] = val;
ptr[6] = val;
ptr[7] = val;

}

}

22.9. CODE EXAMPLES

169

int
main(int argc, char *argv[])
{

profzen(pagezero9, "pagezero9");

exit(0);

}

22.9.1.2 Statistics

Let’s take a look at the speed of our different versions of the pagezero routine and look
at how to measure execution timer using the Zen timer represented in its own chapter
elsewhere in this book.

Here is a test program; I have included the routines to let you not have to skim this
book back and forth to see how they work, therefore making it easy to compare the
impact of the changes on the run speed.

Note that the tests are run on a multitasking system (without not much other activity,
though). I take the minimum of 1024 runs so I can eliminate the impact of the process
possibly getting scheduled out, i.e. put to sleep, in the middle of the tests. I also try
to avoid this by sleeping (to let the kernel schedule us out, then back in) before I start
running the routine to be tested.

Source Code

TODO: include stats for pagezero8() and pagezero9()

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "cdecl.h"
#include "zen.h"
#include "zenia32.h"

#define LONGSIZE
4
#define LONGSIZELOG2 2

void
pagezero0(void *adr, size_t len)
{

char *ptr = adr;

while (len--) {
*ptr++ = 0;

}

}

void

170

CHAPTER 22. OPTIMISATION TECHNIQUES

pagezero1(void *adr, size_t len)
{

long *ptr = adr;

len >>= LONGSIZELOG2;
while (len--) {
*ptr++ = 0;

}

}

void
pagezero2(void *adr, size_t len)
{

long *ptr = adr;

len >>= LONGSIZELOG2;
while (len) {

*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;
len -= 4;

}

}

void
pagezero3(void *adr, size_t len)
{

long *ptr = adr;

len >>= 2 + LONGSIZELOG2;
while (len--) {
*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;
*ptr++ = 0;

}

}

void
pagezero4(void *adr, size_t len)
{

long *ptr = adr;
size_t ofs = 0;

len >>= 2 + LONGSIZELOG2;
while (len--) {

ptr[ofs] = 0;
ptr[ofs + 1] = 0;
ptr[ofs + 2] = 0;

22.9. CODE EXAMPLES

171

ptr[ofs + 3] = 0;
ptr += 4;

}

}

void
pagezero5(void *adr, size_t len)
{

long *ptr = adr;

len >>= 2 + LONGSIZELOG2;
while (len--) {
ptr[0] = 0;
ptr[1] = 0;
ptr[2] = 0;
ptr[3] = 0;
ptr += 4;

}

}

void
pagezero6(void *adr, size_t len)
{

long *ptr = adr;
long val = 0;

len >>= 2 + LONGSIZELOG2;
while (len--) {

ptr[0] = val;
ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
ptr += 4;

}

}

void
pagezero7(void *adr, size_t len)
{

long *ptr = adr;
long val = 0;
long incr = 4;

len >>= 2 + LONGSIZELOG2;
while (len--) {

ptr[0] = val;
ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
ptr += incr;

172

}

}

CHAPTER 22. OPTIMISATION TECHNIQUES

//uint8_t pagetab[4096] __attribute__((__aligned__(4096)));
uint8_t *pagetab[128];

unsigned long
profzen(void (*routine)(void *, size_t), char *str)
{
#if (PROFCLK)

zenclk_t
clk;
unsigned long cnt;
unsigned long mintime = 0;
long

l;

#elif (PROFTICK)
zentick_t

tick;

#if (LONGSIZE == 8)

long
long

#else

cnt;
mintime = 0x7fffffffffffffffL;

long long
long long

cnt;
mintime = 0x7fffffffffffffffLL;

#endif

long

#endif

l;

sleep(1);
for (l = 0 ; l < 128 ; l++) {

pagetab[l] = malloc(4096);

#if (PROFCLK)

zenstartclk(clk);

#elif (PROFTICK)

zenstarttick(tick);

#endif

routine(pagetab[l], 4096);

#if (PROFCLK)

zenstopclk(clk);
cnt = zenclkdiff(clk);

#elif (PROFTICK)

zenstoptick(tick);
cnt = zentickdiff(tick);

#endif

if (cnt < mintime) {

mintime = cnt;

}

}
for (l = 0 ; l < 128 ; l++) {

free(pagetab[l]);

}

#if (PROFCLK)

22.9. CODE EXAMPLES

173

fprintf(stderr, "%s took %lu microseconds\n", str, mintime);

#elif (PROFTICK)

fprintf(stderr, "%s took %lld cycles\n", str, mintime);

#endif

return cnt;

}

void
pagezero8(void *adr, size_t len)
{

long *ptr = adr;
long val = 0;
long incr = 4;

len >>= 2 + LONGSIZELOG2;
while (len) {

ptr[0] = val;
ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
ptr += incr;
len--;

}

}

void
pagezero9(void *adr, size_t len)
{

long *next = adr;
long *ptr;
long val = 0;
long incr = 8;
long tmp;

len >>= 3 + LONGSIZELOG2;
while (len) {

tmp = *next;
len--;
ptr = next;
ptr[0] = val;
ptr[1] = val;
ptr[2] = val;
ptr[3] = val;
next += incr;
ptr[4] = val;
ptr[5] = val;
ptr[6] = val;
ptr[7] = val;

}

174

}

CHAPTER 22. OPTIMISATION TECHNIQUES

void
pagezero10(void *adr, size_t len)
{

long *next1 = adr;
long *next2 = (long *)((uint8_t *)adr + (len >> 1));
long *ptr1;
long *ptr2;
long val = 0;
long incr = 8;
long tmp1;
long tmp2;

len >>= 4 + LONGSIZELOG2;
while (len) {

__builtin_prefetch(next1);
__builtin_prefetch(next2);

//
//

tmp1 = *next1;
tmp2 = *next2;

len--;
ptr1 = next1;
ptr2 = next2;
ptr1[0] = val;
ptr2[0] = val;
ptr1[1] = val;
ptr2[1] = val;
ptr1[2] = val;
ptr2[2] = val;
ptr1[3] = val;
ptr2[3] = val;
next1 += incr;
next2 += incr;
ptr1[4] = val;
ptr2[4] = val;
ptr1[5] = val;
ptr2[5] = val;
ptr1[6] = val;
ptr2[6] = val;
ptr1[7] = val;
ptr2[7] = val;

}

}

void
pagezero11(void *adr, size_t len)
{

long *next1 = adr;
long *next2 = (long *)((uint8_t *)adr + 2048);
long *next3 = (long *)((uint8_t *)adr + 8 * sizeof(long));

22.9. CODE EXAMPLES

175

long *next4 = (long *)((uint8_t *)adr + 2048 + 8 * sizeof(long));
long *ptr1;
long *ptr2;
long val = 0;
long incr = 8;

len >>= 4 + LONGSIZELOG2;
while (--len) {

__builtin_prefetch(next1);
__builtin_prefetch(next2);
__builtin_prefetch(next3);
__builtin_prefetch(next4);
ptr1 = next1;
ptr2 = next2;
ptr1[0] = val;
ptr2[0] = val;
ptr1[1] = val;
ptr2[1] = val;
ptr1[2] = val;
ptr2[2] = val;
ptr1[3] = val;
ptr2[3] = val;
next1 += incr;
next2 += incr;
next3 += incr;
next4 += incr;
ptr1[4] = val;
ptr2[4] = val;
ptr1[5] = val;
ptr2[5] = val;
ptr1[6] = val;
ptr2[6] = val;
ptr1[7] = val;
ptr2[7] = val;

}
ptr1 = next1;
ptr2 = next2;
ptr1[0] = val;
ptr2[0] = val;
ptr1[1] = val;
ptr2[1] = val;
ptr1[2] = val;
ptr2[2] = val;
ptr1[3] = val;
ptr2[3] = val;
ptr1[4] = val;
ptr2[4] = val;
ptr1[5] = val;
ptr2[5] = val;
ptr1[6] = val;

CHAPTER 22. OPTIMISATION TECHNIQUES

176

}

ptr2[6] = val;
ptr1[7] = val;
ptr2[7] = val;

void
pagezero12(void *adr, size_t len)
{

long *next1 = adr;
long *next2 = (long *)((uint8_t *)adr + 2048);
long *next3 = (long *)((uint8_t *)adr + 8 * sizeof(long));
long *next4 = (long *)((uint8_t *)adr + 2048 + 8 * sizeof(long));
long *ptr1;
long *ptr2;
long val = 0;
long incr = 8;

len >>= 4 + LONGSIZELOG2;
while (--len) {

__builtin_prefetch(next1);
ptr1 = next1;
ptr2 = next2;
__builtin_prefetch(next2);
ptr1[0] = val;
ptr2[0] = val;
ptr1[1] = val;
ptr2[1] = val;
__builtin_prefetch(next3);
ptr1[2] = val;
ptr2[2] = val;
ptr1[3] = val;
ptr2[3] = val;
__builtin_prefetch(next4);
next1 += incr;
next2 += incr;
next3 += incr;
next4 += incr;
ptr1[4] = val;
ptr2[4] = val;
ptr1[5] = val;
ptr2[5] = val;
ptr1[6] = val;
ptr2[6] = val;
ptr1[7] = val;
ptr2[7] = val;

}
ptr1 = next1;
ptr2 = next2;
ptr1[0] = val;
ptr2[0] = val;

22.9. CODE EXAMPLES

177

ptr1[1] = val;
ptr2[1] = val;
ptr1[2] = val;
ptr2[2] = val;
ptr1[3] = val;
ptr2[3] = val;
ptr1[4] = val;
ptr2[4] = val;
ptr1[5] = val;
ptr2[5] = val;
ptr1[6] = val;
ptr2[6] = val;
ptr1[7] = val;
ptr2[7] = val;

}

#if 0 /* BROKEN CODE */
void
pagezero13(void *adr, size_t len)
{

long *next1 = adr;
long *next2 = (long *)((uint8_t *)adr + 4096);
long *next3 = (long *)((uint8_t *)adr + 8 * sizeof(long));
long *next4 = (long *)((uint8_t *)adr + 4096 + 8 * sizeof(long));
long *ptr1;
long *ptr2;
long val = 0;
long incr = 8;

len >>= 4 + LONGSIZELOG2;
while (--len) {

__builtin_prefetch(next1);
ptr1 = next1;
ptr2 = next2;
__builtin_prefetch(next2);
ptr1[0] = val;
ptr2[0] = val;
ptr1[1] = val;
ptr2[1] = val;
__builtin_prefetch(next3);
ptr1[2] = val;
ptr2[2] = val;
ptr1[3] = val;
ptr2[3] = val;
__builtin_prefetch(next4);
next1 += incr;
next2 += incr;
next3 += incr;
next4 += incr;
ptr1[4] = val;

178

CHAPTER 22. OPTIMISATION TECHNIQUES

ptr2[4] = val;
ptr1[5] = val;
ptr2[5] = val;
ptr1[6] = val;
ptr2[6] = val;
ptr1[7] = val;
ptr2[7] = val;

}
ptr1 = next1;
ptr2 = next2;
ptr1[0] = val;
ptr2[0] = val;
ptr1[1] = val;
ptr2[1] = val;
ptr1[2] = val;
ptr2[2] = val;
ptr1[3] = val;
ptr2[3] = val;
ptr1[4] = val;
ptr2[4] = val;
ptr1[5] = val;
ptr2[5] = val;
ptr1[6] = val;
ptr2[6] = val;
ptr1[7] = val;
ptr2[7] = val;

}

#endif /* BROKEN CODE */

int
main(int argc, char *argv[])
{

profzen(pagezero0, "pagezero0");
profzen(pagezero1, "pagezero1");
profzen(pagezero2, "pagezero2");
profzen(pagezero3, "pagezero3");
profzen(pagezero4, "pagezero4");
profzen(pagezero5, "pagezero5");
profzen(pagezero6, "pagezero6");
profzen(pagezero7, "pagezero7");
profzen(pagezero8, "pagezero8");
profzen(pagezero9, "pagezero9");
profzen(pagezero10, "pagezero10");
profzen(pagezero11, "pagezero11");
profzen(pagezero12, "pagezero12");

//

profzen(pagezero13, "pagezero13");

exit(0);

}

22.10. DATA EXAMPLES

179

Here are the minimum run times (those are the ones that count here) I saw running
the test several times. They seem consistent; I ran the tests several times. These times
came from the program compiled with compiler optimisations on (-O flag with GCC).

pagezero1 took 32 microseconds
pagezero2 took 11 microseconds
pagezero3 took 11 microseconds
pagezero4 took 14 microseconds
pagezero5 took 11 microseconds
pagezero6 took 11 microseconds
pagezero7 took 12 microseconds

This shows that setting words instead of bytes pays back in a marvelous way. Let’s look
at the times without compiler optimisations to see if anything else made difference;
compilers may do things such as unroll loops themselves.

pagezero1 took 110 microseconds
pagezero2 took 102 microseconds
pagezero3 took 102 microseconds
pagezero4 took 81 microseconds
pagezero5 took 63 microseconds
pagezero6 took 63 microseconds
pagezero7 took 63 microseconds

The results are interesting - note how big the impact of compiler optimisations is. The
changes we applied have gained a bit of speed, but it really becomes noticeable only
after we compile with the GCC -O flag. The latter statistics do show, though, that what
we did was somewhat fruitful. The big speedups were word-size access to memory
and unrolling the loop. As you can see, you should turn optimisations off or lower if
you really want to measure your own code’s execution times in a way to be somewhat
trustworthy.

22.10 Data Examples

22.10.1 Bit Flags

TODO: bitset(), setbit(), clrbit(), getbits(), tagged pointers, examples.

22.10.2 Lookup Tables

Sometimes it’s good to cache (relatively small) sets of computed values into tables and
fetch them based on the operands of such computation. This technique is used later in
this chapter; look at the section Fade In/Out Effects.

TODO: packing character attribute bit flags into tables.

180

CHAPTER 22. OPTIMISATION TECHNIQUES

22.10.3 Hash Tables

TODO

22.10.4 The V-Tree

Here is a hybrid data structure I came up with when investigating van Emde Boas
trees. Even though it is not suitable for sparsely scattered key values (it would eat all
memory in the universe), it’s interesting for what it can be used; the plan is to look into
using it to drive kernel buffer cache. Its main use would be relatively linear key spaces
with no key collisions.

Highlights of this data structure in comparison with hash tables are:

(cid:15) Not counting the (relatively rare) table allocations of this dynamic data structure,
INSERT, FIND, and DELETE operations work in ’constant’/predictable time.
The biggest interference with run-time are occasional allocations and dealloca-
tions of internal tables.

(cid:15) The structure can be iterated in key order.
(cid:15) It is relatively easy to implement lookups for the next and previous valued keys.

22.10.4.1 Example Implementation

The listing below has embedded tests to make it easier to explore.

The example implementation below shows using 2-level trees (of tables) and demon-
strates using bitmaps to speed implementations of FINDNEXT and FINDPREV up; it
is noteworthy that with 8-bit level indices, a 256-bit lookup bitmap will fit a single i386
cacheline. It then takes 8 32-bit zero comparisons to spot an empty subtree, which is
much faster than 256 32-bit [pointer] comparisons.

Source Code

/*

* Copyright (C) 2008-2010 Tuomo Petteri Ven(cid:228)l(cid:228)inen. All rights reserved.
*/

#define NTESTKEY (64 * 1024)

#define TEST
#define CHK
#define PROF

1
0
1

#include <stdint.h>
#include <stdlib.h>
#include <limits.h> /* CHAR_BIT */
#include <string.h>
#if (PROF)
#include <unistd.h>

22.10. DATA EXAMPLES

181

#include "cdecl.h"
#include "zen.h"
#endif

#define bitset(p, b) (((uint8_t *)(p))[(b) >> 3] & (1U << ((b) & 0x07)))
#define setbit(p, b) (((uint8_t *)(p))[(b) >> 3] |= (1U << ((b) & 0x07)))
#define clrbit(p, b) (((uint8_t *)(p))[(b) >> 3] &= ~(1U << ((b) & 0x07)))

#if (TEST)
#include <stdio.h>
#endif

#define VAL_SIZE
#define KEY_SIZE

2
2

#if (VAL_SIZE <= 4)
typedef uint32_t vtval_t;
#elif (VAL_SIZE <= 8)
typedef uint64_t vtval_t;
#endif
#if (KEY_SIZE <= 4)
typedef uint32_t vtkey_t;
#elif (KEY_SIZE <= 8)
typedef uint64_t vtkey_t;
#endif
typedef vtval_t _VAL_T;

#define _NKEY
#define _NBIT
#define _NLVLBIT
#define _EMPTYBYTE
#define _EMPTYVAL
#define _EMPTYKEY

(1U << _NBIT)
(KEY_SIZE * CHAR_BIT)
(_NBIT >> 1)
0xff
(~(vtval_t)0)
(~(vtkey_t)0)

((k) >> (n))
((k) & ((1U << (n)) - 1))
calloc(1 << (n), sizeof(t))
malloc((1 << (n)) * sizeof(t))

#define _hi(k, n)
#define _lo(k, n)
#define _calloc(n, t)
#define _alloc(n, t)
#if (PROF)
#define _memset(p, b, n) do { *(p)++ = (b); } while (--(n))
#define _flush(p, n)
#endif
#define _clrtab(p, n)

memset(p, _EMPTYBYTE,

_memset(p, 0xff, n);

(((1) << (n)) * sizeof(_VAL_T)))

struct

_item {

_VAL_T
vtkey_t
vtkey_t
uint32_t

*tab;

minkey;
maxkey;
bmap[1U << (_NLVLBIT - 5)];

\

CHAPTER 22. OPTIMISATION TECHNIQUES

182

} PACK;

struct _tree {

struct _item *tab;
vtval_t
vtkey_t
uint32_t

*reftab;
nbit;
himap[1U << (_NLVLBIT - 5)];

};

static vtval_t vtins(struct _tree *tree, vtkey_t key, vtval_t val);
static vtval_t vtdel(struct _tree *tree, vtkey_t key);
static vtval_t vtfind(struct _tree *tree, vtkey_t key);
static vtval_t vtprev(struct _tree *tree, vtkey_t key);
static vtval_t vtnext(struct _tree *tree, vtkey_t key);

struct _tree *
mkveb(int nkeybit)
{

struct _tree
vtkey_t
unsigned long
unsigned long
size_t
void
struct _item

if (tree) {

*tree = malloc(sizeof(struct _tree));

nbit = nkeybit >> 1;
n = 1U << nbit;
ndx = 0;
tabsz;

*ptr;
*item;

tree->nbit = nbit;
tabsz = n * sizeof(struct _item);
ptr = malloc(tabsz);
if (ptr) {

tree->tab = ptr;
item = ptr;
memset(ptr, _EMPTYBYTE, tabsz);
ptr = NULL;
while (ndx < n) {

item->tab = ptr;
ndx++;
item++;

}
tabsz = n * sizeof(vtval_t);
ptr = calloc(1, tabsz);
if (ptr) {

tree->reftab = ptr;

} else {

free(tree->tab);
free(tree);
tree = NULL;

}
} else {

22.10. DATA EXAMPLES

183

free(tree);
tree = NULL;

}

}

return tree;

}

static vtval_t
vtins(struct _tree *tree, vtkey_t key, vtval_t val)
{

nbit = tree->nbit;
hi = _hi(key, nbit);
lo = _lo(key, nbit);

vtkey_t
vtkey_t
vtkey_t
struct _item *treep = &tree->tab[hi];
_VAL_T
vtkey_t
vtval_t

*tabp = treep->tab;
tkey = _EMPTYKEY;
retval = _EMPTYVAL;

if (!tabp) {

treep->minkey = treep->maxkey = tkey;
treep->tab = tabp = _alloc(nbit, _VAL_T);

#if (_EMPTYBYTE != 0)

_clrtab(tabp, nbit);

#endif

}
setbit(tree->himap, hi);
setbit(treep->bmap, lo);
if (tabp) {

tree->reftab[hi]++;
if (lo < treep->minkey || treep->minkey == tkey) {

treep->minkey = lo;

}
if (lo > treep->maxkey || treep->maxkey == tkey) {

treep->maxkey = lo;

}
tabp[lo] = val;
retval = val;

}

return retval;

}

static vtval_t
vtdel(struct _tree *tree, vtkey_t key)
{

vtkey_t
vtkey_t
vtkey_t
struct _item *treep = &tree->tab[hi];

nbit = tree->nbit;
hi = _hi(key, nbit);
lo = _lo(key, nbit);

184

CHAPTER 22. OPTIMISATION TECHNIQUES

_VAL_T
_VAL_T
vtval_t
vtkey_t
vtkey_t
vtval_t
vtval_t

*tabp = treep->tab;
*valp;

tval = _EMPTYVAL;
tkey = _EMPTYKEY;
lim = 1U << nbit;
retval = tval;
val;

if (tabp) {

clrbit(treep->bmap, lo);
if (tabp) {

valp = &tabp[lo];
retval = *valp;
if (retval != tval) {

if (!--tree->reftab[hi]) {

clrbit(tree->himap, hi);
free(tabp);
treep->tab = NULL;
treep->minkey = treep->maxkey = tkey;

} else {

*valp = tval;
if (lo == treep->minkey) {

val = _EMPTYVAL;
do {

;

} while ((++lo < lim)

&& ((val = valp[lo]) == _EMPTYVAL));

if (valp[lo] == _EMPTYVAL) {
treep->minkey = tkey;

} else {

treep->minkey = lo;

}

}
if (lo == treep->maxkey) {

val = _EMPTYVAL;
do {

;

} while ((lo--)

&& ((val = valp[lo]) == _EMPTYVAL));

if (val == _EMPTYVAL) {

treep->maxkey = tkey;

} else {

treep->maxkey = lo;

}

}

}

}

}

}

22.10. DATA EXAMPLES

185

return retval;

}

static vtval_t
vtfind(struct _tree *tree, vtkey_t key)
{

nbit = tree->nbit;
hi = _hi(key, nbit);
lo = _lo(key, nbit);

vtkey_t
vtkey_t
vtkey_t
struct _item *treep = &tree->tab[hi];
_VAL_T
vtval_t

retval = _EMPTYVAL;

*tabp = treep->tab;

if (!tabp) {

return retval;

}
retval = tabp[lo];

return retval;

}

static vtval_t
vtprev(struct _tree *tree, vtkey_t key)
{

nbit = tree->nbit;
hi = _hi(key, nbit);
lo = _lo(key, nbit);

vtkey_t
vtkey_t
vtkey_t
struct _item *treep = &tree->tab[hi];
_VAL_T
_VAL_T
vtkey_t
vtval_t
vtval_t
uint32_t
uint32_t

*tabp = treep->tab;
*valp;
kval;
tval = _EMPTYVAL;
retval = tval;

*himap = tree->himap;
*lomap = (treep) ? treep->bmap : NULL;

if (!tabp || treep->minkey == _EMPTYKEY) {

return retval;

}
if (lo > treep->minkey) {

valp = tabp;
do {

;

} while (lo-- > 0 && !bitset(lomap, lo));
retval = valp[lo];

} else {
do {

;

186

CHAPTER 22. OPTIMISATION TECHNIQUES

} while (hi-- > 0 && !bitset(himap, hi));
treep = &tree->tab[hi];
kval = treep->maxkey;
tabp = treep->tab;
retval = tabp[kval];

}

return retval;

}

static vtval_t
vtnext(struct _tree *tree, vtkey_t key)
{

nbit = tree->nbit;
hi = _hi(key, nbit);
lo = _lo(key, nbit);
lim = 1U << nbit;

vtkey_t
vtkey_t
vtkey_t
vtkey_t
struct _item *treep = &tree->tab[hi];
_VAL_T
_VAL_T
vtkey_t
vtval_t
vtval_t
uint32_t
uint32_t

*tabp = treep->tab;
*valp;
kval;
tval = _EMPTYVAL;
retval = tval;

*himap = tree->himap;
*lomap = (treep) ? treep->bmap : NULL;

if (!tabp || treep->maxkey == _EMPTYKEY) {

return retval;

}
if (lo < treep->maxkey) {

valp = tabp;
do {

;

} while (++lo < lim && !bitset(lomap, lo));
retval = valp[lo];

} else {
do {

;

} while (++hi < lim && !bitset(himap, hi));
treep = &tree->tab[hi];
kval = treep->minkey;
tabp = treep->tab;
retval = tabp[kval];

}

return retval;

}

#if (TEST)

22.10. DATA EXAMPLES

187

#if (PROF)
static uint8_t _mtab[2 * 1048576]; // TODO: fix PAGEALIGN;
#define START_PROF(id) sleep(1); p = _mtab, n = 2 * 1048576; _flush(p, n); zenstartclk(id)
#define STOP_PROF(id, str)

zenstopclk(id); fprintf(stderr, "%s\t%lu usecs\n", \

str, zenclkdiff(id))

#else
#define START_PROF(id)
#define STOP_PROF(id, str)
#endif

void
test(void)
{

*sysheap = (uint8_t *)sbrk(0);

uint8_t
struct _tree *tree = mkveb(_NBIT);
uint8_t
*curheap;
int val;
int i;
#if (PROF)

uint8_t *p;
int n;
zenclk_t clock;

#endif

START_PROF(clock);
for (i = 0 ; i < NTESTKEY - 1 ; i++) {

val = vtins(tree, i, i);

#if (CHK)

if (val != i) {

fprintf(stderr, "insert(1) failed - %d should be %d\n", val, i);

abort();

}

#endif

}
STOP_PROF(clock, "insert\t");

START_PROF(clock);
for (i = 0 ; i < NTESTKEY - 1 ; i++) {

val = vtfind(tree, i);

#if (CHK)

if (val != i) {

fprintf(stderr, "lookup(1) failed - %d should be %d\n", val, i);

abort();

}

#endif

}
STOP_PROF(clock, "lookup\t");

188

CHAPTER 22. OPTIMISATION TECHNIQUES

START_PROF(clock);
for (i = 1 ; i < NTESTKEY - 1 ; i++) {

if (i) {

val = vtprev(tree, i);

#if (CHK)

if (val != i - 1) {

fprintf(stderr, "vtprev(%x) failed (%x)\n", i, val);

abort();

}

#endif

}

}
STOP_PROF(clock, "findprev");

START_PROF(clock);
for (i = 0 ; i < NTESTKEY - 2 ; i++) {

val = vtnext(tree, i);

#if (CHK)

if (val != i + 1) {

fprintf(stderr, "vtnext(%x) failed (%x)\n", i, val);

abort();

}

#endif

}
STOP_PROF(clock, "findnext");

START_PROF(clock);
for (i = 0 ; i < NTESTKEY - 1 ; i++) {

val = vtdel(tree, i);

#if (CHK)

if (val != i) {

fprintf(stderr, "vtdel(%x) failed (%x)\n", i, val);

abort();

}

#endif

}
STOP_PROF(clock, "delete\t");

curheap = (uint8_t *)sbrk(0);
fprintf(stderr, "HEAP:\t\t%u bytes\n", curheap - sysheap);
fprintf(stderr, "RANGE:\t\t%x..%x\n", 0, NTESTKEY - 1);

for (i = 0 ; i < NTESTKEY - 1 ; i++) {

val = vtfind(tree, i);
if (val != _EMPTYVAL) {

fprintf(stderr, "lookup(2) failed\n");

22.11. GRAPHICS EXAMPLES

189

abort();

}

}

return;

}

int
main(int argc,

char *argv[])

{

}

test();

exit(0);

#endif /* TEST */

22.11 Graphics Examples

In this section we shall look at some simple graphical operations.

First, some basic pixel definitions for ARGB32. We use the de facto standard ARGB32
pixel format (32-bit, 8 bits for each of ALPHA, RED, GREEN, and BLUE).

Bytefields

One thing to notice in the following listing is the difference of alphaval() and al-
phaval_p(). The first one is used when you have a pixel packed into a 32-bit word; the
second one lets you fetch individual component bytes from memory to avoid fetching
a whole pixel and doing bitshifts. I decided to call struct argb32 a bytefield. Note that
you have to ask the compiler not to try and align struct argb32 better with some kind
of an attribute; we use PACK, which is defined for GCC in <cc.h>.

Source Code

#include "cc.h"

#define ALPHAOFS 24
16
#define REDOFS
#define GREENOFS 8
#define BLUEOFS 0

typedef int32_t argb32_t;

struct argb32 {

uint8_t bval;

CHAPTER 22. OPTIMISATION TECHNIQUES

190

};

uint8_t gval;
uint8_t rval;
uint8_t aval;

/* pix is 32-bit word */
#define alphaval(pix) ((pix) >> ALPHAOFS)
#define redval(pix)
#define greenval(pix) (((pix) >> GREENOFS) & 0xff)
#define blueval(pix)

(((pix) >> BLUEOFS) & 0xff)

(((pix) >> REDOFS) & 0xff)

// alpha component

// red component

// green component

// blue component

/* pointer version; faster byte-fetches from memory */
#define alphaval_p(p) (((struct argb32 *)(p))->aval)
#define redval_p(p)
(((struct argb32 *)(p))->rval)
#define greenval_p(p) (((struct argb32 *)(p))->gval)
(((struct argb32 *)(p))->bval)
#define blueval_p(p)

/* approximation for c / 0xff */
#define div255(c)

((((c) << 8) + (c) + 256) >> 16)
/* simple division per 256 by bitshift */
#define div256(c)
((c) >> 8)

#define alphablendc(src, dest, a)

((dest) + div255(((src) - (dest)) * (a)))

#define alphablendc2(src, dest, a)

((dest) + div256(((src) - (dest)) * (a)))

#define alphablendcf(src, dest, a)

((dest) + (((src) - (dest)) * (a)) / 255.0)

/* compose pixel value from components */
#define mkpix(a, r, g, b)

\

\

\

\

\

\

(((a) << ALPHAOFS) | ((r) << REDOFS) | ((g) << GREENOFS) | ((b) << BLUEOFS))

#define setpix_p(p, a, r, g, b)

(((struct argb32 *)(p))->aval = (a),
((struct argb32 *)(p))->rval = (r),
((struct argb32 *)(p))->gval = (g),
((struct argb32 *)(p))->bval = (b))

22.11.1 Alpha Blending

\
\
\
\

Alpha blending is a technique to combine two pixel values so that the source pixel is
drawn on top of the destination pixel using the alpha value (translucency level) from
the source. This is how modern desktop software implements ’translucent’ windows
and such.

We are going to see some serious bit-twiddling acrobacy; I got the algorithm from
Carsten ’Rasterman’ Haitzler, but all I know of its origins is that it came from some
fellow hacker called Jose.

22.11. GRAPHICS EXAMPLES

191

Note that these routines were implemented as macros to make it easy to drop them into
loops without using (slow) function calls every iteration.

Performance-wise, Jose’s algorithm seems to be the fastest. It took about 3.3 seconds
for a crossfade operation of two 1024x768 images using the first alpha blend routine.
The second one took about 2.9 seconds to execute. Jose’s took about 2.6 seconds. For
the record, the initial floating point routine took a bit over 6 seconds to run.

Towards the end of this section, we take a closer look at how alpha blending works as
well as examine vector programming by developing a couple of MMX versions of our
routines.

22.11.1.1 C Routines

Pixels are alpha blended a component, i.e. one of RED, GREEN or BLUE, at a time.
The formula for computing blended components is

DEST = DEST + (((SRC (cid:0) DEST ) (cid:3) ALPHA)=255)

where DEST, SRC, and ALPHA are 8-bit component values in the range 0 to 255.
One thing to notice is the divide operation; this tends to be slow for microprocessors
to accomplish, but luckily we have ways around it; note though, that those ways aren’t
100 percent accurate so chances are you don’t want to use them for professional quality
publications and such applications. In this book, we concentrate on their use on on-
screen graphics/images.

Here is an exact floating point algorithm. Note that it uses a divide operation, which
tends to be slow. This one takes about double the time to run in comparison to the
integer routines.

Source Code

#include "pix.h"
#include "blend.h"

#define alphablendf(src, dest, aval)

do {

float _a = (aval);
float _sr = redval_p(src);
float _sg = greenval_p(src);
float _sb = blueval_p(src);
float _dr = redval_p(dest);
float _dg = greenval_p(dest);
float _db = blueval_p(dest);

_dr = alphablendcf(_sr, _dr, _a);
_dg = alphablendcf(_sg, _dg, _a);
_db = alphablendcf(_sb, _db, _a);
setpix_p((dest), 0, (uint8_t)_dr, (uint8_t)_dg, (uint8_t)_db);

} while (FALSE)

\

\
\
\
\
\
\
\
\
\
\
\
\
\

192

CHAPTER 22. OPTIMISATION TECHNIQUES

Eliminating the divide operation, the runtime drops by around 25 percent for my test
runs. Still quite a bit slower than the integer routines, but may give more exact output.

Source Code

/* t is table of 256 floats (0 / 0xff through 255.0 / 0xff) */
#define alphablendcf2(src, dest, a, t)

((dest) + (((src) - (dest)) * (a)) * (t)[(a)])

#define alphablendf2(src, dest, aval)

do {

argb32_t _a = (aval);
float
float
float
float
float
float

_sr = redval_p(src);
_sg = greenval_p(src);
_sb = blueval_p(src);
_dr = redval_p(dest);
_dg = greenval_p(dest);
_db = blueval_p(dest);

_dr = alphablendcf2(_sr, _dr, _a);
_dg = alphablendcf2(_sg, _dg, _a);
_db = alphablendcf2(_sb, _db, _a);
setpix_p((dest), 0, (uint8_t)_dr, (uint8_t)_dg, (uint8_t)_db);

} while (FALSE)

Here is the first integer algorithm. This one should be reasonably good in terms of
output quality. Notice how the macros hide the somewhat tedious pixel component
calculations and make the code easier to digest.

Source Code

#include "pix.h"
#include "blend.h"

#define alphablendhiq(src, dest, aval)

do {

argb32_t _a = (aval);
argb32_t _sr = redval(src);
argb32_t _sg = greenval(src);
argb32_t _sb = blueval(src);
argb32_t _dr = redval(dest);
argb32_t _dg = greenval(dest);
argb32_t _db = blueval(dest);

_dr = alphablendc(_sr, _dr, _a);
_dg = alphablendc(_sg, _dg, _a);
_db = alphablendc(_sb, _db, _a);
(dest) = mkpix(0, _dr, _dg, _db);

} while (FALSE)

#define alphablendhiq_p(src, dest, aval)

\

\
\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\
\
\
\
\

\

22.11. GRAPHICS EXAMPLES

193

do {

argb32_t _a = (aval);
argb32_t _sr = redval_p(src);
argb32_t _sg = greenval_p(src);
argb32_t _sb = blueval_p(src);
argb32_t _dr = redval_p(dest);
argb32_t _dg = greenval_p(dest);
argb32_t _db = blueval_p(dest);

_dr = alphablendc(_sr, _dr, _a);
_dg = alphablendc(_sg, _dg, _a);
_db = alphablendc(_sb, _db, _a);
setpix_p((dest), 0, _dr, _dg, _db);

} while (FALSE)

The next listing is the previous routine modified to use a faster approximation for
It would seem
divide-by-0xff operations; we simply divide by 256 doing bitshifts.
to cut a bit over 10 percent off the runtime of our code under some tests.

Source Code

#include "pix.h"
#include "blend.h"

#define alphablendloq(src, dest, aval)

do {

argb32_t _a = (aval);
argb32_t _sr = redval(src);
argb32_t _sg = greenval(src);
argb32_t _sb = blueval(src);
argb32_t _dr = redval(dest);
argb32_t _dg = greenval(dest);
argb32_t _db = blueval(dest);

_dr = alphablendc2(_sr, _dr, _a);
_dg = alphablendc2(_sg, _dg, _a);
_db = alphablendc2(_sb, _db, _a);
(dest) = mkpix(0, _dr, _dg, _db);

} while (FALSE)

#define alphablendloq_p(src, dest, aval)

do {

argb32_t _a = (aval);
argb32_t _sr = redval_p(src);
argb32_t _sg = greenval_p(src);
argb32_t _sb = blueval_p(src);
argb32_t _dr = redval_p(dest);
argb32_t _dg = greenval_p(dest);
argb32_t _db = blueval_p(dest);

\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\

194

CHAPTER 22. OPTIMISATION TECHNIQUES

_dr = alphablendc2(_sr, _dr, _a);
_dg = alphablendc2(_sg, _dg, _a);
_db = alphablendc2(_sb, _db, _a);
*(dest) = mkpix(0, _dr, _dg, _db);

} while (FALSE)

\
\
\
\

The algorithm I told about above; the one that came from Jose. This is about 10 percent
faster than the bitshifting version.

Source Code

#include "pix.h"
#include "blend.h"

/* Jose’s fast alphablend-algorithm */

#define alphablendpix(c0, c1, a)

\
((((((((c0) >> 8) & 0xff00ff) - (((c1) >> 8) & 0xff00ff)) * (aval)) \
\
\

+ (((((((c0) & 0xff00ff) - ((c1) & 0xff00ff)) * (aval)) >> 8)

+ ((c1) & 0xff00ff00)) & 0xff00ff00)

+ ((c1) & 0xff00ff)) & 0xff00ff))

#define alphablendfast(src, dest, aval)

do {

uint64_t _rbmask = 0x00ff00ff00ff00ffULL;
argb32_t _gamask = 0xff00ff00ff00ff00ULL;
argb32_t _srcrb;
argb32_t _destrb;
argb32_t _destag;
argb32_t _val1;
argb32_t _val2;

_srcrb = (src);
_destrb = (dest);
_destag = (dest);
_srcrb &= _rbmask;
_destrb &= _rbmask;
_destag &= _gamask;
_val1 = (src);
_val2 = _destag;
_val1 >>= 8;
_val2 >>= 8;
_val1 &= _rbmask;
_srcrb -= _destrb;
_val1 -= _val2;
_srcrb *= (aval);
_val1 *= (aval);
_srcrb >>= 8;
_val1 += _destag;
_srcrb += _destrb;

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

22.11. GRAPHICS EXAMPLES

195

_val1 &= _gamask;
_srcrb &= _rbmask;
_val1 += _srcrb;
(dest) = _val1;

} while (0)

22.11.1.2 MMX Routines

The basic idea of vectorisation is to work on multiple data operands in parallel; the
term SIMD (Single Instruction, Multiple Data) is commonly used for this.

Remember that alpha blending works by doing computations on pixel components.
These components are 8 bits each. We did find ways to get around the division, but
we still need to do multiplications, which means we can’t do our calculations in 8-bit
registers; there will be overflows. The way MMX comes to the rescue is that we can
represent the 4 components of a pixel as 16-bit values in a 64-bit register (technically,
the alpha component wouldn’t be needed) and effectively do the substraction, multipli-
cation, and addition operations on all those components (as 16-bit subcomponents) in
parallel. We’ll get away with fewer machine operations.

The first listing uses Intel compiler intrinsics for MMX as a way to avoid assembly. As
the intrinsics at the time of writing this don’t cover everything we need (64-bit move
using the MOVQ machine instruction for) and this is a book on low level programming,
we shall next rewrite the routine using inline assembly.

It is noteworthy that one needs to exit MMX mode with the assembly instruction emms
to make the floating-point unit (i387) work correctly. Therefore, every time you stop
using MMX instructions, do something like

__asm__ __volatile__ ("emms\n");

Here is the intrinsics version of our second integer alpha blending routine.

Source Code

#include <mmintrin.h>

/* MMX compiler intrinsics */

#include "pix.h"
#include "blend.h"

/* NOTE: leaves destination ALPHA undefined */
#define alphablendloq_mmx(src, dest, aval)

do {

__m64 _mzero;
__m64 _msrc;
__m64 _mdest;
__m64 _malpha;
__m64 _mtmp;

\
\
\
\

\
\
\
\
\
\
\
\

_mzero = _mm_cvtsi32_si64(0);
_malpha = _mm_cvtsi32_si64(aval);

/* 0000000000000000 */ \
/* 00000000000000AA */ \

196

CHAPTER 22. OPTIMISATION TECHNIQUES

/* 0000000000AA0000 */ \
_mtmp = _mm_slli_si64(_malpha, 16);
/* 0000000000AA00AA */ \
_malpha = _mm_or_si64(_mtmp, _malpha);
/* 00AA00AA00000000 */ \
_mtmp = _mm_slli_si64(_malpha, 32);
/* 00AA00AA00AA00AA */ \
_malpha = _mm_or_si64(_malpha, _mtmp);
/* S:00000000AARRGGBB */ \
_msrc = _mm_cvtsi32_si64(src);
/* D:00000000AARRGGBB */ \
_mdest = _mm_cvtsi32_si64(dest);
_msrc = _mm_unpacklo_pi8(_msrc, _mzero);
/* S:00AA00RR00GG00BB */ \
_mdest = _mm_unpacklo_pi8(_mdest, _mzero); /* D:00AA00RR00GG00BB */ \
_msrc = _mm_sub_pi16(_msrc, _mdest);
_msrc = _mm_mullo_pi16(_msrc, _malpha);
_msrc = _mm_srli_pi16(_msrc, 8);
_mdest = _mm_add_pi8(_msrc, _mdest);
_mdest = _mm_packs_pu16(_mdest, _mzero);
(dest) = _mm_cvtsi64_si32(_mdest);

/* S - D */
/* T = (S - D) * A */ \
/* T >> 8 */
/* D = D + T */
/* D:00000000??RRGGBB */ \
/* DEST = D */

\

\

\

\

} while (FALSE)

In tests, this routine turned out to run about 10 percent faster than the C versions. It is
noteworthy though that Jose’s C algorithm runs faster - good work! :)

Now let’s rewrite this using inline assembly.

Source Code

#include "pix.h"
#include "blend.h"

#define alphablendloq_mmx_asm(src, dest, aval)

do {

__asm__ ("pxor %mm0, %mm0\n");
__asm__ ("movd %0, %%mm1\n" : : "rm" (src));
__asm__ ("movd %0, %%mm2\n" : : "rm" (dest));
__asm__ ("movd %0, %%mm3\n" : : "rm" (aval));
__asm__ ("punpcklbw %mm0, %mm1\n");
__asm__ ("movq %mm3, %mm5\n");
__asm__ ("punpcklbw %mm0, %mm2\n");
__asm__ ("psllq $16, %mm5\n");
__asm__ ("pxor %mm5, %mm3\n");
__asm__ ("movq %mm3, %mm5\n");
__asm__ ("psllq $32, %mm5\n");
__asm__ ("pxor %mm5, %mm3\n");
__asm__ ("psubw %mm2, %mm1\n");
__asm__ ("movq %mm1, %mm4\n");
__asm__ ("pmullw %mm3, %mm4\n");
__asm__ ("psrlw $8, %mm4\n");
__asm__ ("paddb %mm4, %mm2\n");
__asm__ ("packuswb %mm0, %mm2\n");
__asm__ __volatile__ ("movd %%mm2, %0\n" : "=rm" (dest));

} while (FALSE)

This version turned out to be a very little bit faster than Jose’s algorithm implemented

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

22.11. GRAPHICS EXAMPLES

197

in C. What’s more interesting, though, is that it cut the runtime of the intrinsics version
down from about 2.8 seconds to 2.6 under a crossfade test of about 100 alphablend
operations of 1024x768 resolution images. Notice that the final MOVD operation must
be declared __volatile__. Also beware that it’s not a good idea to mix use of regular
variables/registers with MMX code.

22.11.1.3 Cross-Fading Images

As an easter egg to those of you who have kept reading, I will show how to crossfade
an image to another one (fade the first one out and gradually expose the second one on
top of it) using the alphablend routines we have implemented.

In real life, you most likely need to synchronise graphics display after each step; the
details of this are platform-dependent.

#include "pix.h"

#define STEP 0x0f

/* cross-fade from src1 to src2; dest is on-screen data */
void
crossfade(argb32_ *src1, argb32_t *src2, argb32_t *dest,

size_t len)

argb32_t val;
size_t

nleft;

nleft = len;
while (nleft--) {

for (val = 0 ; val <= 0xff ; val += STEP) {
alphablendfast(src1, dest, 0xff - val);

alphablendfast(src2, dest, val);

}
/* synchronise screen here */

}
/* copy second image intact */

memcpy(dest, src2, len * sizeof(argb32_t));

{

}

22.11.2 Fade In/Out Effects

Here is a simple way to implement graphical fade in and fade out effects. To use this,
you would loop over graphical data with the val argument to the macros ranging from
0 to 0xff similarly to what we did in the previous code snippet.

I will use the chance of demonstrating a couple of simple optimisation techniques for
this routine. First, it has a division operation and those tend to be slow. That can be
emulated by introducing a table of 256 floats to look the desired value up from. This
made my test run time drop from about 19000 microseconds to around 17000.

198

CHAPTER 22. OPTIMISATION TECHNIQUES

Another way to cut a little bit of the runtime off is to eliminate the (floating point)
multiplication operations as well as the casts between float and argb32_t. both _fmul
and pixel/color component values are 8-bit and so can have 256 different values. This
gives us a table of 256 * 256 values of the type uint8_t (no need for full pixel values),
that is 65536 values. This table uses 64 kilobytes of memory (8-bit values). Chances
are you don’t want to do this at all; I don’t see you needing this routine in games
or other such programs which need the very last bit of performance torn out of the
machine, but you may have other uses for lookup tables so I’ll show you how to do it.

Source Code

#include "pix.h"

/* basic version */
#define fadein1(src, dest, val)

do {

argb32_t _rval;
argb32_t _gval;
argb32_t _bval;
_ftor;
float

_ftor = (float)val / 0xff;
_rval = (argb32_t)(_ftor * _gfx_red_val(src));
_gval = (argb32_t)(_ftor * _gfx_green_val(src));
_bval = (argb32_t)(_ftor * _gfx_blue_val(src));
mkpix(dest, 0, _rval, _gval, _bval);

} while (FALSE)

#define fadeout1(src, dest, val)

do {

argb32_t _rval;
argb32_t _gval;
argb32_t _bval;
_ftor;
float

_ftor = (float)(0xff - val) / 0xff;
_rval = (argb32_t)(_ftor * _gfx_red_val(src));
_gval = (argb32_t)(_ftor * _gfx_green_val(src));
_bval = (argb32_t)(_ftor * _gfx_blue_val(src));
mkpix(dest, 0, _rval, _gval, _bval);

} while (FALSE)

\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\
\
\

/* use lookup table to eliminate division _and_ multiplication + typecasts */

/*

* initialise lookup table
* u8p64k points to 65536 uint8_t values like in
* uint8_t fadetab[256][256];
*/

#define initfade1(u8p64k)

do {

\
\

22.11. GRAPHICS EXAMPLES

199

_l, _m;

long
float _f;
for (_l = 0 ; _l <= 0xff ; _l++) {

f = (float)val / 0xff;
for (_m = 0 ; _m <= 0xff ; _m++) {

(u8p64k)[_l][_m] = (uint8_t)(_f * _m);

}

}

} while (0)

#define fadein2(src, dest, val, tab)

do {

_rval = (tab)[val][redval(src)];
_gval = (tab)[val][greenval(src)];
_bval = (tab)[val][blueval(src)];
mkpix(dest, 0, _rval, _gval, _bval);

} while (FALSE)

#define fadeout(src, dest, val)

do {

val = 0xff - val;
_rval = (tab)[val][redval(src)];
_gval = (tab)[val][greenval(src)];
_bval = (tab)[val][blueval(src)];
mkpix(dest, 0, _rval, _gval, _bval);

} while (FALSE)

\
\
\
\
\
\
\
\

\
\
\
\
\
\

\
\
\
\
\
\
\

200

CHAPTER 22. OPTIMISATION TECHNIQUES

Part X

Code Examples

201

Chapter 23

Zen Timer

First of all, greetings to Michael Abrash; ’sorry’ for stealing the name Zen timer, I
just thought it sounded good and wanted to pay you respect. ;)

Zen Timer implements timers for measuring code execution in microseconds as well
as, currently for IA-32 machines, clock cycles.

23.1 Implementation

23.1.1 Generic Version; gettimeofday()

/*

* Copyright (C) 2005-2010 Tuomo Petteri Ven(cid:228)l(cid:228)inen. All rights reserved.
*/

#ifndef __ZEN_H__
#define __ZEN_H__

#include <stdint.h>
#include <sys/time.h>

typedef volatile struct timeval zenclk_t[2];

#define _tvdiff(tv1, tv2)

\
(((tv2)->tv_sec - (tv1)->tv_sec) * 1000000 \

+ ((tv2)->tv_usec - (tv1)->tv_usec))

#define zenzeroclk(id)

memset(id, 0, sizeof(id))

#define zenstartclk(id)

gettimeofday(&id[0], NULL)

#define zenstopclk(id)

gettimeofday(&id[1], NULL)

203

\

\

\

204

CHAPTER 23. ZEN TIMER

#define zenclkdiff(id)

_tvdiff(&id[0], &id[1])

#endif /* __ZEN_H__ */

\

23.1.2

IA32 Version; RDTSC

/*

* Copyright (C) 2005-2010 Tuomo Petteri Ven(cid:228)l(cid:228)inen. All rights reserved.
*/

#ifndef __ZENIA32_H__
#define __ZENIA32_H__

#include <stdint.h>

union _tickcnt {

uint64_t u64val;
uint32_t u32vals[2];

};

typedef volatile union _tickcnt zentick_t[2];

#define _rdtsc(ptr)

__asm__ __volatile__("rdtsc\n"

"movl %%eax, %0\n"
"movl %%edx, %1\n"
: "=m" ((ptr)->u32vals[0]), "=m" ((ptr)->u32vals[1]) \
:
: "eax", "edx");

\

\
\
\
\

#define zenzerotick(id)

memset(id, 0, sizeof(id))

#define zenstarttick(id)

_rdtsc(&id[0])
#define zenstoptick(id)
_rdtsc(&id[1])
#define zentickdiff(id)

(id[1].u64val - id[0].u64val)

#endif /* __ZENIA32_H__ */

\

\

\

\

Chapter 24

C Library Allocator

malloc() et al

This section shows a sample implementation of a decent, somewhat scalable, thread-
safe standard library allocator.

POSIX Threads

The allocator in this listing demonstrates simple thread-techniques; one thing to pay
attention to is the use of __thread to declare thread-local storage (TLS), i.e. data that is
only visible to a single thread. This is used to store thread IDs to allow multiple ones to
access the allocator at the same time with less lock contention. pthread_key_create()
is used to specify a function to reclaim arenas when threads terminate; an arena is
reclaimed when there are no more threads attached to it.

For this piece of code, I want to thank Dale Anderson and Matthew Gregan for their
input and Matthew’s nice stress-test routines for the allocator. Cheers New Zealand
boys! :) There are a few other thank yous in the code comments, too.

The allocator should be relatively fast, thread-safe, and scale nicely. It has not been
discontinued, so chances are a thing or a few will change. My main interest is in the
runtime-tuning of allocator behavior which has been started in a simple way (see the
macro TUNEBUF).

24.1 Design

24.1.1 Buffer Layers

205

206

Diagram

CHAPTER 24. C LIBRARY ALLOCATOR

The following is a simple ASCII diagram borrowed from allocator source.

/*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

malloc buffer layers
--------------------

--------
|
| mag
--------
|
--------
| slab |
--------

--------
|
| heap |--|
--------

|
-------
|---| map |
-------

mag
---
- magazine cache with allocation stack of pointers into the slab

- LIFO to reuse freed blocks of virtual memory

slab
----
- slab allocator bottom layer
- power-of-two size slab allocations

- supports both heap and mapped regions

heap
----
- process heap segment

- sbrk() interface; needs global lock

map
---
- process map segment

- mmap() interface; thread-safe

24.1.2 Details

Magazines

The allocator uses a so-called ’Bonwick-style’ buffer (’magazine’) layer on top of a
traditional slab allocator. The magazine layer implements allocation stacks [of point-
ers] for sub-slab regions.

Slabs are power-of-two-size regions. To reduce the number of system calls made, allo-
cations are buffered in magazines. Using pointer stacks for allocations makes reuse of

24.2. IMPLEMENTATION

allocated blocks more likely.

TODO: analyse cache behavior here - with Valgrind?

sbrk() and mmap()

207

The Zero allocator uses sbrk() to expand process heap for smaller allocations, whereas
mmap() is used to allocate bigger chunks of [zeroed] memory. Traditionally, sbrk()
is not thread-safe, so a global lock is necessary to protect global data structures; one
reason to avoid too many calls to sbrk() (which triggers the ’brk’ system call on usual
Unix systems). On the other hand, mmap() is thread safe, so we can use a bit finer-
grained locking with it.

Thread Safety

Zero allocator uses mutexes to guarantee thread-safety; threads running simultaneously
are not allowed to modify global data structures without locking them.

Scalability

The allocator has [currently a fixed number of] arenas. Every thread is given an arena
ID to facilitate running several threads doing allocation without lower likeliness of
lock contention, i.e. without not having to wait for other threads all the time. Mul-
tiprocessor machines are very common today, so this scalability should be good on
many, possibly most new systems. Indeed the allocator has shown good performance
with multithreaded tests; notably faster than more traditional slab allocators. Kudos to
Bonwick et al from Sun Microsystems for inventing the magazine layer. :)

24.2 Implementation

24.2.1 UNIX Interface

POSIX/UNIX

On systems that support it, you can activate POSIX system interface with

#define _POSIX_SOURCE
#define _POSIX_C_SOURCE 199506L

1

In addition to these, you need the -pthread compiler/linker option to build POSIX-
compliant multithread-capable source code.

Header File

Here is a header file I use to compile the allocator - it lists some other feature macros
found on UNIX-like systems.

/*

* Copyright (C) 2007-2008 Tuomo Petteri Ven(cid:228)l(cid:228)inen. All rights reserved.
*/

#ifndef __ZERO_UNIX_H__
#define __ZERO_UNIX_H__

208

CHAPTER 24. C LIBRARY ALLOCATOR

#if 0
/* system feature macros. */
#if !defined(_ISOC9X_SOURCE)
#define _ISOC9X_SOURCE
#endif

1

#if !defined(_POSIX_SOURCE)
#define _POSIX_SOURCE
#endif
#if !defined(_POSIX_C_SOURCE)
#define _POSIX_C_SOURCE
#endif

1

199506L

1

#if !defined(_LARGEFILE_SOURCE)
#define _LARGEFILE_SOURCE
#endif
#if !defined(_FILE_OFFSET_BITS)
#define _FILE_OFFSET_BITS
#endif
#if !defined(_LARGE_FILES)
#define _LARGE_FILES
#endif
#if !defined(_LARGEFILE64_SOURCE)
#define _LARGEFILE64_SOURCE 1
#endif
#endif /* 0 */

64

1

#include <stdint.h>
#include <signal.h>

/* posix standard header. */
#include <unistd.h>

/* i/o headers. */
#include <fcntl.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <sys/mman.h>

#define _SBRK_FAILED

((void *)-1L)

#define _MMAP_DEV_ZERO

0 /* set mmap to use /dev/zero. */

/* some systems may need MAP_FILE with MAP_ANON. */
#ifndef MAP_FILE
#define MAP_FILE
#endif
#if !defined(MAP_FAILED)
#define MAP_FAILED

((void *)-1L)

0

24.2. IMPLEMENTATION

209

#endif
#if (defined(MMAP_DEV_ZERO) && MMAP_DEV_ZERO)
#define mapanon(fd, size)

\
mmap(NULL, size, PROT_READ | PROT_WRITE, \
\
\

MAP_PRIVATE | MAP_FILE,
fd,
0)

\
\
\
\
\
\

\

#else
#define mapanon(fd, size)

mmap(NULL,
size,
PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON | MAP_FILE,
fd,
0)

#endif
#define unmapanon(ptr, size)

munmap(ptr, size)

#define growheap(ofs) sbrk(ofs)

#endif /* __ZERO_UNIX_H__ */

24.2.2 Source Code

Allocator Source

/*

* Copyright (C) 2008-2012 Tuomo Petteri Ven(cid:228)l(cid:228)inen. All rights reserved.
*
* See the file LICENSE for more information about using this software.
*/

/*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

malloc buffer layers
--------------------

--------
| mag
|
--------
|
--------
| slab |
--------

|
--------
| heap |--|
--------

-------
|
|---| map |
-------

210

CHAPTER 24. C LIBRARY ALLOCATOR

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

mag
---
- magazine cache with allocation stack of pointers into the slab

- LIFO to reuse freed blocks of virtual memory

slab
----
- slab allocator bottom layer
- power-of-two size slab allocations

- supports both heap and mapped regions

heap
----
- process heap segment

- sbrk() interface; needs global lock

map
---
- process map segment

- mmap() interface; thread-safe

#define INTSTAT 0
#define HACKS
0
#define ZEROMTX 1
0
#define STAT

0

#define SPINLK
/* NOT sure if FreeBSD still needs spinlocks */
#if defined(__FreeBSD__)
#undef SPINLK
#define SPINLK
#endif

1

#ifdef _REENTRANT
#ifndef MTSAFE
#define MTSAFE
#endif

1

/*

* TODO
* ----
* - tune nmbuf() and other behavior
* - implement mallopt()
* - improve fault handling
*/

/*

* THANKS
* ------

24.2. IMPLEMENTATION

211

helping me find some bottlenecks.

find more of them, and all the constructive criticism etc.

* - Matthew ’kinetik’ Gregan for pointing out bugs, giving me cool routines to
*
* - Thomas ’Freaky’ Hurst for patience with early crashes, 64-bit hints, and
*
* - Henry ’froggey’ Harrington for helping me fix issues on AMD64.
* - Dale ’swishy’ Anderson for the enthusiasism, encouragement, and everything
*
* - Martin ’bluet’ Stensg(cid:229)rd for an account on an AMD64 system for testing
*
*/

earlier versions.

else.

#include <features.h>
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>

#define SBRK_FAILED ((void *)-1L)

initmall(void);
relarn(void *arg);

static void
static void
static void * getmem(size_t size, size_t align, long zero);
static void
static void * _realloc(void *ptr, size_t size, long rel);

putmem(void *ptr);

\
\
\

/* red-zones haven’t been implemented completely yet... some bugs. */
#define RZSZ
#define markred(p) (*(uint64_t *)(p) = UINT64_C(0xb4b4b4b4b4b4b4b4))
#define chkred(p)

0

((*(uint64_t *)(p) == UINT64_C(0xb4b4b4b4b4b4b4b4))

? 0
: 1)

0
#define LKDBG
#define SYSDBG
0
#define VALGRIND 0

#include <string.h>
#if (MTSAFE)
#define PTHREAD 1
#include <pthread.h>
#endif
#endif
#if (ZEROMTX)
#include <zero/mtx.h>
typedef long
#elif (SPINLK)
#include <zero/spin.h>
typedef long

LK_T;

LK_T;

212

CHAPTER 24. C LIBRARY ALLOCATOR

#elif (PTHREAD)
typedef pthread_mutex_t LK_T;
#endif
#if (VALGRIND)
#include <valgrind/valgrind.h>
#endif
#include <zero/param.h>
#include <zero/cdecl.h>
//#include <mach/mach.h>
#include <zero/trix.h>
#include <zero/unix.h>
//#include <mach/param.h>

#define TUNEBUF 0
/* experimental */
#if (PTRBITS > 32)
#define TUNEBUF 1
#endif

/* minimum-size allocation */

16 /* small-size block */
19 /* base size for heap allocations */
21
22

/* minimum-size allocation */

16 /* small-size block */
20 /* base size for heap allocations */
22

5

5

/* basic allocator parameters */
#if (HACKS)
#define BLKMINLOG2
#define SLABTEENYLOG2 12 /* little block */
#define SLABTINYLOG2
#define SLABLOG2
#define MAPMIDLOG2
#define MAPBIGLOG2
#else
#define BLKMINLOG2
#define SLABTEENYLOG2 12 /* little block */
#define SLABTINYLOG2
#define SLABLOG2
#define MAPMIDLOG2
#endif
#define MINSZ
#define HQMAX
#define NBKT
#if (MTSAFE)
#define NARN
#else
#define NARN
#endif

(1UL << BLKMINLOG2)
SLABLOG2
(8 * PTRSIZE)

1

8

/* lookup tree of tables */

#if (PTRBITS > 32)

#define NL1KEY
#define NL2KEY
#define NL3KEY

(1UL << NL1BIT)
(1UL << NL2BIT)
(1UL << NL3BIT)

24.2. IMPLEMENTATION

213

#define L1NDX
#define L2NDX
#define L3NDX
#define NL1BIT

(L2NDX + NL2BIT)
(L3NDX + NL3BIT)
SLABLOG2
16

#if (PTRBITS > 48)

#define NL2BIT
#define NL3BIT
#else

16
(PTRBITS - SLABLOG2 - NL1BIT - NL2BIT)

#define NL2BIT
#define NL3BIT

(PTRBITS - SLABLOG2 - NL1BIT)
0

#endif /* PTRBITS > 48 */

#endif /* PTRBITS <= 32 */

/* macros */

((bid) <= 24)

#if (TUNEBUF)
#define isbufbkt(bid)
#define nmagslablog2(bid) (_nslabtab[(bid)])
#else
#define isbufbkt(bid)
#define nmagslablog2(bid) (ismapbkt(bid) ? nmaplog2(bid) : nslablog2(bid))
#define nslablog2(bid)
#define nmaplog2(bid)
#define nslablog2(bid)
#define nmaplog2(bid)
#endif

0
0
0
0

0

#if (TUNEBUF)
/* adjust how much is buffered based on current use */
#define nmagslablog2up(m, v, t)

do {

if (t >= (v)) {

for (t = 0 ; t < NBKT ; t++) {
_nslabtab[(t)] = m(t);

}

}

} while (0)

#if (HACKS)
#define nmagslablog2init(bid) 0
#define nmagslablog2m64(bid)

((ismapbkt(bid))

? (((bid) <= MAPBIGLOG2)

? 2
: 1)

: (((bid) <= SLABTEENYLOG2)

\
\
\
\
\
\
\

\
\
\
\
\
\

214

CHAPTER 24. C LIBRARY ALLOCATOR

? 0
: (((bid) <= SLABTINYLOG2)

? 1
: 2)))
#define nmagslablog2m128(bid)

((ismapbkt(bid))

? (((bid) <= MAPBIGLOG2)

? 2
: 1)

: (((bid) <= SLABTEENYLOG2)

? 0
: (((bid) <= SLABTINYLOG2)

? 0
: 1)))
#define nmagslablog2m256(bid)

((ismapbkt(bid))

? (((bid) <= MAPBIGLOG2)

? 2
: 1)

: (((bid) <= SLABTEENYLOG2)

? 0
: (((bid) <= SLABTINYLOG2)

? 0
: 0)))
#define nmagslablog2m512(bid)

((ismapbkt(bid))

? (((bid) <= MAPBIGLOG2)

? 1
: 0)

: (((bid) <= SLABTEENYLOG2)

? 0
: 0))

#else
#define nmagslablog2init(bid)

((ismapbkt(bid))

? (((bid) <= 23)

? 2
: 1)

: (((bid) <= SLABTEENYLOG2)

? 1
: (((bid) <= SLABTINYLOG2)

? 1
: 2)))
#define nmagslablog2m64(bid)

((ismapbkt(bid))

? 0
: (((bid) <= SLABTEENYLOG2)

? 0
: (((bid) <= SLABTINYLOG2)

? 1

\
\
\

\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\

\
\
\

24.2. IMPLEMENTATION

215

: 2)))
#define nmagslablog2m128(bid)

((ismapbkt(bid))

? (((bid) <= 23)

? 1
: 0)

: (((bid) <= SLABTEENYLOG2)

? 1
: (((bid) <= SLABTINYLOG2)

? 1
: 2)))
#define nmagslablog2m256(bid)

((ismapbkt(bid))

? (((bid) <= 24)

? 1
: 0)

: (((bid) <= SLABTEENYLOG2)

? 1
: (((bid) <= SLABTINYLOG2)

? 1
: 2)))
#define nmagslablog2m512(bid)

((ismapbkt(bid))

? (((bid) <= 24)

? 1
: 0)

: (((bid) <= SLABTEENYLOG2)

? 0
: (((bid) <= SLABTINYLOG2)

? 1
: 2)))

#endif
#endif
#define nblklog2(bid)

((!(ismapbkt(bid))

? (SLABLOG2 - (bid))
: nmagslablog2(bid)))

#define nblk(bid)
#define NBSLAB
#define nbmap(bid)
#define nbmag(bid)

#if (PTRBITS <= 32)
#define NSLAB
#define slabid(ptr)
#endif
#define nbhdr()
#define NBUFHDR

(1UL << nblklog2(bid))
(1UL << SLABLOG2)
(1UL << (nmagslablog2(bid) + (bid)))
(1UL << (nmagslablog2(bid) + SLABLOG2))

(1UL << (PTRBITS - SLABLOG2))
((uintptr_t)(ptr) >> SLABLOG2)

PAGESIZE
16

#define thrid()

((_aid >= 0) ? _aid : (_aid = getaid()))

216

CHAPTER 24. C LIBRARY ALLOCATOR

#define blksz(bid)
#define usrsz(bid)
#define ismapbkt(bid)
#define magfull(mag)
#define magempty(mag)
#if (ALNSTK)
#define nbstk(bid)
#define nbalnstk(bid)
#else
#define nbstk(bid)
#endif
#define mapstk(n)
#define unmapstk(mag)
#define putblk(mag, ptr)

((gt2(mag->max, 1)

(1UL << (bid))
(blksz(bid) - RZSZ)
(bid > HQMAX)
(!(mag)->cur)
((mag)->cur == (mag)->max)

max(nblk(bid) * sizeof(void *), PAGESIZE)
nbstk(bid)

max((nblk(bid) << 1) * sizeof(void *), PAGESIZE)

mapanon(_mapfd, ((n) << 1) * sizeof(void *))
unmapanon((mag)->bptr, mag->max * sizeof(void *))

? (((void **)(mag)->bptr)[--(mag)->cur] = (ptr))
: ((mag)->cur = 0, (mag)->adr = (ptr))))

#define getblk(mag)

((gt2(mag->max, 1)

? (((void **)(mag)->bptr)[(mag)->cur++])
: ((mag)->cur = 1, ((mag)->adr))))

#define NPFBIT BLKMINLOG2
#define BPMASK (~((1UL << NPFBIT) - 1))
#define BDIRTY 0x01UL
#define BALIGN 0x02UL
#define clrptr(ptr)
#define setflg(ptr, flg)
#define chkflg(ptr, flg)
#define blkid(mag, ptr)

((void *)((uintptr_t)(ptr) & BPMASK))
((void *)((uintptr_t)(ptr) | (flg)))
((uintptr_t)(ptr) & (flg))

\
\
\

\
\
\

\

((mag)->max + (((uintptr_t)(ptr) - (uintptr_t)(mag)->adr) >> (mag)->bid))

#define putptr(mag, ptr1, ptr2)

((gt2((mag)->max, 1))

? (((void **)(mag)->bptr)[blkid(mag, ptr1)] = (ptr2))
: ((mag)->bptr = (ptr2)))

#define getptr(mag, ptr)

((gt2((mag)->max, 1))

? (((void **)(mag)->bptr)[blkid(mag, ptr)])
: ((mag)->bptr))

\
\
\

\
\
\

#if (STAT)
#include <stdio.h>
#endif

/* synchonisation */

#if (ZEROMTX)
#define mlk(mp)
#define munlk(mp)
#define mtylk(mp)
#elif (SPINLK)

mtxlk(mp, _aid + 1)
mtxunlk(mp, _aid + 1)
mtxtrylk(mp, _aid + 1)

217

24.2. IMPLEMENTATION

#define mlk(sp)
#define munlk(sp)
#define mtrylk(sp)
#elif (MTSAFE)
#if (PTHREAD)
#define mlk(sp)
#define munlk(sp)
#define mtrylk(sp)
#else
#define mlk(sp)
#define munlk(sp)
#define mtrylk(sp)
#endif
#else
#define mlk(sp)
#define munlk(sp)
#define mtrylk(sp)
#endif
#define mlkspin(sp)
#define munlkspin(sp)
#define mtrylkspin(sp)

/* configuration */

spinlk(sp)
spinunlk(sp)
spintrylk(sp)

pthread_mutex_lock(sp)
pthread_mutex_unlock(sp)
pthread_mutex_trylock(sp)

spinlk(sp)
spinunlk(sp)
spintrylk(sp)

spinlk(sp)
spinunlk(sp)
spintry(sp)

#define CONF_INIT 0x00000001
#define VIS_INIT 0x00000002
struct mconf {

long
#if (MTSAFE)
LK_T
LK_T
LK_T

#endif

long
long
long

};

flags;

initlk;
arnlk;
heaplk;

scur;
acur;
narn;

#define istk(bid)

((nblk(bid) << 1) * sizeof(void *) <= PAGESIZE)

\

struct mag {
long
cur;
long
max;
long
aid;
long
bid;
void
*adr;
*bptr;
void
struct mag *prev;
struct mag *next;
struct mag *stk[EMPTY];

218

};

CHAPTER 24. C LIBRARY ALLOCATOR

#define nbarn() (blksz(bktid(sizeof(struct arn))))
struct arn {

*btab[NBKT];
*ftab[NBKT];

struct mag
struct mag
nref;
long
hcur;
long
nhdr;
long
struct mag **htab;
scur;
long
lktab[NBKT];
LK_T

};

struct mtree {
#if (MTSAFE)
LK_T

#endif

lk;

struct mag **tab;
long

nblk;

};

/* globals */

_nheapreq[NBKT] ALIGNED(PAGESIZE);
_nmapreq[NBKT];

nalloc[NARN][NBKT];
nhdrbytes[NARN];
nstkbytes[NARN];
nmapbytes[NARN];
nheapbytes[NARN];

#if (INTSTAT)
static uint64_t
static long
static long
static long
static long
#endif
#if (STAT)
static unsigned long
static unsigned long
#endif
#if (TUNEBUF)
static long
#endif
#if (MTSAFE)
static LK_T
#endif
static struct mag
#if (HACKS)
static long
#endif
static void
static struct arn
static struct mconf
#if (MTSAFE) && (PTHREAD)
static pthread_key_t

**_mdir;
**_atab;
_conf;

_akey;

_nslabtab[NBKT];

_flktab[NBKT];

*_ftab[NBKT];

_fcnt[NBKT];

24.2. IMPLEMENTATION

219

static __thread long
#else
static long
#endif
#if (TUNEBUF)
static int64_t
static int64_t
#endif
static int

_aid = -1;

_aid = 0;

_nbheap;
_nbmap;

_mapfd = -1;

/* utility functions */

static __inline__ long
ceil2(size_t size)
{

size--;
size |= size >> 1;
size |= size >> 2;
size |= size >> 4;
size |= size >> 8;
size |= size >> 16;

#if (LONGSIZE == 8)

size |= size >> 32;

#endif

size++;

return size;

}

static __inline__ long
bktid(size_t size)
{

long tmp = ceil2(size);
long bid;

#if (LONGSIZE == 4)

tzero32(tmp, bid);

#elif (LONGSIZE == 8)

tzero64(tmp, bid);

#endif

return bid;

}

#if (MTSAFE)
static long
getaid(void)
{

long

aid;

220

CHAPTER 24. C LIBRARY ALLOCATOR

mlk(&_conf.arnlk);
aid = _conf.acur++;
_conf.acur &= NARN - 1;
pthread_setspecific(_akey, _atab[aid]);
munlk(&_conf.arnlk);

return aid;

}
#endif

static __inline__ void
zeroblk(void *ptr,

size_t size)

{

unsigned long *ulptr = ptr;
unsigned long
long
long

zero = 0UL;
small = (size < (LONGSIZE << 3));
n = ((small)

? (size >> LONGSIZELOG2)
: (size >> (LONGSIZELOG2 + 3)));

long

nl = 8;

if (small) {

while (n--) {

*ulptr++ = zero;

}
} else {

while (n--) {

ulptr[0] = zero;
ulptr[1] = zero;
ulptr[2] = zero;
ulptr[3] = zero;
ulptr[4] = zero;
ulptr[5] = zero;
ulptr[6] = zero;
ulptr[7] = zero;
ulptr += nl;

}

}

return;

}

/* fork() management */

#if (MTSAFE)

static void
prefork(void)
{

24.2. IMPLEMENTATION

221

aid;
long
long
bid;
struct arn *arn;

mlk(&_conf.initlk);
mlk(&_conf.arnlk);
mlk(&_conf.heaplk);
aid = _conf.narn;
while (aid--) {

arn = _atab[aid];
for (bid = 0 ; bid < NBKT ; bid++) {

mlk(&arn->lktab[bid]);

}

}

return;

}

static void
postfork(void)
{

aid;
long
long
bid;
struct arn *arn;

aid = _conf.narn;
while (aid--) {

arn = _atab[aid];
for (bid = 0 ; bid < NBKT ; bid++) {

munlk(&arn->lktab[bid]);

}

}
munlk(&_conf.heaplk);
munlk(&_conf.arnlk);
munlk(&_conf.initlk);

return;

}

static void
relarn(void *arg)
{

struct arn *arn = arg;

#if (HACKS)
long

#endif

n = 0;

nref;
long
long
bid;
struct mag *mag;
struct mag *head;

222

CHAPTER 24. C LIBRARY ALLOCATOR

nref = --arn->nref;
if (!nref) {

bid = NBKT;
while (bid--) {

mlk(&arn->lktab[bid]);
head = arn->ftab[bid];
if (head) {

#if (HACKS)

#endif

n++;

mag = head;
while (mag->next) {

#if (HACKS)

#endif

n++;

mag = mag->next;

}
mlk(&_flktab[bid]);
mag->next = _ftab[bid];
_ftab[bid] = head;

_fcnt[bid] += n;

munlk(&_flktab[bid]);
arn->ftab[bid] = NULL;

}
munlk(&arn->lktab[bid]);

#if (HACKS)

#endif

}

}

return;

}

#endif /* MTSAFE */

/* statistics */

#if (STAT)
void
printstat(void)
{

long l;

for (l = 0 ; l < NBKT ; l++) {

fprintf(stderr, "%ld\t%lu\t%lu\n", l, _nheapreq[l], _nmapreq[l]);

}

exit(0);

}

24.2. IMPLEMENTATION

223

#elif (INTSTAT)
void
printintstat(void)
{

long aid;
long bkt;
long nbhdr = 0;
long nbstk = 0;
long nbheap = 0;
long nbmap = 0;

for (aid = 0 ; aid < NARN ; aid++) {

nbhdr += nhdrbytes[aid];
nbstk += nstkbytes[aid];
nbheap += nheapbytes[aid];
nbmap += nmapbytes[aid];
fprintf(stderr, "%lx: hdr: %ld\n", aid, nhdrbytes[aid] >> 10);
fprintf(stderr, "%lx: stk: %ld\n", aid, nstkbytes[aid] >> 10);
fprintf(stderr, "%lx: heap: %ld\n", aid, nheapbytes[aid] >> 10);
fprintf(stderr, "%lx: map: %ld\n", aid, nmapbytes[aid] >> 10);
for (bkt = 0 ; bkt < NBKT ; bkt++) {

fprintf(stderr, "NALLOC[%lx][%lx]: %lld\n",
aid, bkt, nalloc[aid][bkt]);

}

}
fprintf(stderr, "TOTAL: hdr: %ld, stk: %ld, heap: %ld, map: %ld\n",

nbhdr, nbstk, nbheap, nbmap);

}
#endif

#if (X11VIS)
#include <X11/Xlibint.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/Xmd.h>
#include <X11/Xlocale.h>
#include <X11/cursorfont.h>
#include <X11/keysym.h>
#include <X11/Xlib.h>

static LK_T
#if 0
static LK_T
#endif
long
Display
Window
Pixmap
GC
GC

x11visinitlk;

x11vislk;

x11visinit = 0;

*x11visdisp = NULL;
x11viswin = None;
x11vispmap = None;
x11visinitgc = None;
x11visfreedgc = None;

224

GC
GC

CHAPTER 24. C LIBRARY ALLOCATOR

x11visusedgc = None;
x11visresgc = None;

#define x11vismarkfreed(ptr)

do {

if (x11visinit) {

int y = ((uintptr_t)(ptr) >> (BLKMINLOG2 + 10)) & 0x3ff;
int x = ((uintptr_t)(ptr) >> BLKMINLOG2) & 0x3ff;
XDrawPoint(x11visdisp, x11vispmap, x11visfreedgc, x, y);

}

} while (0)
#define x11vismarkres(ptr)

do {

if (x11visinit) {

int y = ((uintptr_t)(ptr) >> (BLKMINLOG2 + 10)) & 0x3ff;
int x = ((uintptr_t)(ptr) >> BLKMINLOG2) & 0x3ff;
XDrawPoint(x11visdisp, x11vispmap, x11visresgc, x, y);

}

} while (0)

#define x11vismarkused(ptr)

do {

if (x11visinit) {

int y = ((uintptr_t)(ptr) >> (BLKMINLOG2 + 10)) & 0x3ff;
int x = ((uintptr_t)(ptr) >> BLKMINLOG2) & 0x3ff;
XDrawPoint(x11visdisp, x11vispmap, x11visusedgc, x, y);

}

} while (0)

void
initx11vis(void)
{

XColor col;
XGCValues gcval;

//

mlk(&x11vislk);
mlk(&x11visinitlk);
if (x11visinit) {

munlk(&x11visinitlk);

\
\
\
\
\
\
\

\
\
\
\
\
\
\

\
\
\
\
\
\
\

return;

}
XInitThreads();
x11visdisp = XOpenDisplay(NULL);
if (x11visdisp) {

x11viswin = XCreateSimpleWindow(x11visdisp,

DefaultRootWindow(x11visdisp),
0, 0,
1024, 1024, 0,
BlackPixel(x11visdisp,

DefaultScreen(x11visdisp)),

24.2. IMPLEMENTATION

225

WhitePixel(x11visdisp,

DefaultScreen(x11visdisp)));

if (x11viswin) {

XEvent ev;

x11vispmap = XCreatePixmap(x11visdisp,

x11viswin,
1024, 1024,
DefaultDepth(x11visdisp,

DefaultScreen(x11visdisp)));

gcval.foreground = WhitePixel(x11visdisp,

DefaultScreen(x11visdisp));

x11visinitgc = XCreateGC(x11visdisp,

x11viswin,
GCForeground,
&gcval);

XFillRectangle(x11visdisp,
x11vispmap,
x11visinitgc,
0, 0,
1024, 1024);

col.red = 0x0000;
col.green = 0x0000;
col.blue = 0xffff;
if (!XAllocColor(x11visdisp,

DefaultColormap(x11visdisp,

DefaultScreen(x11visdisp)),

&col)) {

return;

}
gcval.foreground = col.pixel;
x11visfreedgc = XCreateGC(x11visdisp,

x11viswin,
GCForeground,
&gcval);

col.red = 0xffff;
col.green = 0x0000;
col.blue = 0x0000;
if (!XAllocColor(x11visdisp,

DefaultColormap(x11visdisp,

DefaultScreen(x11visdisp)),

&col)) {

return;

}

226

CHAPTER 24. C LIBRARY ALLOCATOR

gcval.foreground = col.pixel;
x11visusedgc = XCreateGC(x11visdisp,

x11viswin,
GCForeground,
&gcval);

col.red = 0x0000;
col.green = 0xffff;
col.blue = 0x0000;
if (!XAllocColor(x11visdisp,

DefaultColormap(x11visdisp,

DefaultScreen(x11visdisp)),

&col)) {

return;

}
gcval.foreground = col.pixel;
x11visresgc = XCreateGC(x11visdisp,

x11viswin,
GCForeground,
&gcval);

XSelectInput(x11visdisp, x11viswin, ExposureMask);
XMapRaised(x11visdisp, x11viswin);
do {

XNextEvent(x11visdisp, &ev);

} while (ev.type != Expose);
XSelectInput(x11visdisp, x11viswin, NoEventMask);

}

}
x11visinit = 1;
munlk(&x11visinitlk);
munlk(&x11vislk);

//
}
#endif

static void
initmall(void)
{

long
long
long
uint8_t

bid = NBKT;
aid = NARN;
ofs;
*ptr;

mlk(&_conf.initlk);
if (_conf.flags & CONF_INIT) {
munlk(&_conf.initlk);

return;

}

24.2. IMPLEMENTATION

227

#if (STAT)

atexit(printstat);

#elif (INTSTAT)

atexit(printintstat);

#endif
#if (_MMAP_DEV_ZERO)

_mapfd = open("/dev/zero", O_RDWR);

#endif
#if (MTSAFE)

mlk(&_conf.arnlk);
_atab = mapanon(_mapfd, NARN * sizeof(struct arn **));
ptr = mapanon(_mapfd, NARN * nbarn());
aid = NARN;
while (aid--) {

_atab[aid] = (struct arn *)ptr;
ptr += nbarn();

}
aid = NARN;
while (aid--) {

for (bid = 0 ; bid < NBKT ; bid++) {

#if (ZEROMTX)

mtxinit(&_atab[aid]->lktab[bid]);

#elif (PTHREAD) && !SPINLK

pthread_mutex_init(&_atab[aid]->lktab[bid], NULL);

#endif

}
_atab[aid]->hcur = NBUFHDR;

}
_conf.narn = NARN;
pthread_key_create(&_akey, relarn);
munlk(&_conf.arnlk);

#endif
#if (PTHREAD)

pthread_atfork(prefork, postfork, postfork);

#endif
#if (PTHREAD)

while (bid--) {

#if (ZEROMTX)

mtxinit(&_flktab[bid]);

#elif (PTHREAD) && !SPINLK

pthread_mutex_init(&_flktab[bid], NULL);

#endif

}

#endif

mlk(&_conf.heaplk);
ofs = NBSLAB - ((long)growheap(0) & (NBSLAB - 1));
if (ofs != NBSLAB) {

growheap(ofs);

}
munlk(&_conf.heaplk);

228

CHAPTER 24. C LIBRARY ALLOCATOR

#if (PTRBITS <= 32)

_mdir = mapanon(_mapfd, NSLAB * sizeof(void *));

#else

_mdir = mapanon(_mapfd, NL1KEY * sizeof(void *));

#endif
#if (TUNEBUF)

for (bid = 0 ; bid < NBKT ; bid++) {

_nslabtab[bid] = nmagslablog2init(bid);

}

#endif

_conf.flags |= CONF_INIT;
munlk(&_conf.initlk);

#if (X11VIS)

initx11vis();

#endif

return;

}

#if (MTSAFE)
#if (PTRBITS > 32)
#define l1ndx(ptr) getbits((uintptr_t)ptr, L1NDX, NL1BIT)
#define l2ndx(ptr) getbits((uintptr_t)ptr, L2NDX, NL2BIT)
#define l3ndx(ptr) getbits((uintptr_t)ptr, L3NDX, NL3BIT)
#if (PTRBITS > 48)
static struct mag *
findmag(void *ptr)
{

uintptr_t
uintptr_t
uintptr_t
void
void
struct mag *mag = NULL;

l1 = l1ndx(ptr);
l2 = l2ndx(ptr);
l3 = l3ndx(ptr);
*ptr1;
*ptr2;

ptr1 = _mdir[l1];
if (ptr1) {

ptr2 = ((void **)ptr1)[l2];
if (ptr2) {

mag = ((struct mag **)ptr2)[l3];

}

}

return mag;

}

static void
addblk(void *ptr,

struct mag *mag)

{

24.2. IMPLEMENTATION

229

l1 = l1ndx(ptr);
l2 = l2ndx(ptr);
l3 = l3ndx(ptr);

uintptr_t
uintptr_t
uintptr_t
*ptr1;
void
*ptr2;
void
void
**pptr;
struct mag **item;

ptr1 = _mdir[l1];
if (!ptr1) {

_mdir[l1] = ptr1 = mapanon(_mapfd, NL2KEY * sizeof(void *));
if (ptr1 == MAP_FAILED) {

#ifdef ENOMEM

errno = ENOMEM;

#endif

exit(1);

}

}
pptr = ptr1;
ptr2 = pptr[l2];
if (!ptr2) {

pptr[l2] = ptr2 = mapanon(_mapfd, NL3KEY * sizeof(struct mag *));
if (ptr2 == MAP_FAILED) {

#ifdef ENOMEM

errno = ENOMEM;

#endif

exit(1);

}

}
item = &((struct mag **)ptr2)[l3];
*item = mag;

return;

}
#else
static struct mag *
findmag(void *ptr)
{

l1 = l1ndx(ptr);
l2 = l2ndx(ptr);

uintptr_t
uintptr_t
void
struct mag *mag = NULL;

*ptr1;

ptr1 = _mdir[l1];
if (ptr1) {

mag = ((struct mag **)ptr1)[l2];

}

CHAPTER 24. C LIBRARY ALLOCATOR

230

}

return mag;

static void
addblk(void *ptr,

struct mag *mag)

{

l1 = l1ndx(ptr);
l2 = l2ndx(ptr);

uintptr_t
uintptr_t
void
*ptr1;
struct mag **item;

ptr1 = _mdir[l1];
if (!ptr1) {

_mdir[l1] = ptr1 = mapanon(_mapfd, NL2KEY * sizeof(struct mag *));
if (ptr1 == MAP_FAILED) {

#ifdef ENOMEM

errno = ENOMEM;

#endif

exit(1);

}

}
item = &((struct mag **)ptr1)[l2];
*item = mag;

return;

}
#endif
#else
#define findmag(ptr)
#define addblk(ptr, mag) (_mdir[slabid(ptr)] = (mag))
#endif
#endif

(_mdir[slabid(ptr)])

static struct mag *
gethdr(long aid)
{

*arn;
cur;

struct arn
long
struct mag **hbuf;
struct mag
uint8_t

*mag = NULL;
*ptr;

arn = _atab[aid];
hbuf = arn->htab;
if (!arn->nhdr) {

hbuf = mapanon(_mapfd, roundup2(NBUFHDR * sizeof(void *), PAGESIZE));
if (hbuf != MAP_FAILED) {

#if (INTSTAT)

24.2. IMPLEMENTATION

231

nhdrbytes[aid] += roundup2(NBUFHDR * sizeof(void *), PAGESIZE);

#endif

arn->htab = hbuf;
arn->hcur = NBUFHDR;
arn->nhdr = NBUFHDR;

}

}
cur = arn->hcur;
if (gte2(cur, NBUFHDR)) {

mag = mapanon(_mapfd, roundup2(NBUFHDR * nbhdr(), PAGESIZE));
if (mag == MAP_FAILED) {

#ifdef ENOMEM

errno = ENOMEM;

#endif

return NULL;

} else {

#if (VALGRIND)

if (RUNNING_ON_VALGRIND) {

VALGRIND_MALLOCLIKE_BLOCK(mag, PAGESIZE, 0, 0);

}

#endif

}
ptr = (uint8_t *)mag;
while (cur) {

mag = (struct mag *)ptr;
*hbuf++ = mag;
mag->bptr = mag->stk;
cur--;
ptr += nbhdr();

}

}
hbuf = arn->htab;

#if (SYSDBG)

_nhbuf++;

#endif

mag = hbuf[cur++];
arn->hcur = cur;

return mag;

}

#if (TUNEBUF)
static void
tunebuf(long val)
{

static long tunesz = 0;
long

nb = _nbheap + _nbmap;

return;

232

CHAPTER 24. C LIBRARY ALLOCATOR

if (!tunesz) {

tunesz = val;

}
if (val == 64 && nb >= 64 * 1024) {

nmagslablog2up(nmagslablog2m64, val, nb);

} else if (val == 128 && nb >= 128 * 1024) {

nmagslablog2up(nmagslablog2m128, val, nb);

} else if (val == 256 && nb >= 256 * 1024) {

nmagslablog2up(nmagslablog2m256, val, nb);

} else if (val == 512 && nb >= 512 * 1024) {

nmagslablog2up(nmagslablog2m512, val, nb);

}

return;

}
#endif

static void *
getslab(long aid,
long bid)

{

uint8_t
long
#if (TUNEBUF)

*ptr = NULL;

nb = nbmag(bid);

unsigned long tmp;
static long tunesz = 0;

#endif

if (!ismapbkt(bid)) {

mlk(&_conf.heaplk);
ptr = growheap(nb);
munlk(&_conf.heaplk);
if (ptr != SBRK_FAILED) {

#if (INTSTAT)

nheapbytes[aid] += nb;

#endif
#if (TUNEBUF)

_nbheap += nb;

_nheapreq[bid]++;

#if (STAT)

#endif
#endif

}
} else {

ptr = mapanon(_mapfd, nbmap(bid));
if (ptr != MAP_FAILED) {

#if (INTSTAT)

nmapbytes[aid] += nbmap(bid);

#endif

24.2. IMPLEMENTATION

233

#if (STAT)

_nmapreq[bid]++;

#endif

}

}

#if (TUNEBUF)

if (ptr != MAP_FAILED && ptr != SBRK_FAILED) {

tmp = _nbmap + _nbheap;
if (!tunesz) {

tunesz = 64;

}
if ((tmp >> 10) >= tunesz) {

tunebuf(tunesz);

}

}

#endif

return ptr;

}

static void
freemap(struct mag *mag)
{

struct arn
long
long
long
long
long
struct mag **hbuf;

*arn;
cur;
aid = mag->aid;
bid = mag->bid;
bsz = blksz(bid);
max = mag->max;

arn = _atab[aid];
mlk(&arn->lktab[bid]);
cur = arn->hcur;
hbuf = arn->htab;

//#if (HACKS)
//
//#else

if (!cur || _fcnt[bid] < 4) {

if (!cur) {

//#endif

mag->prev = NULL;
mlk(&_flktab[bid]);
mag->next = _ftab[bid];
_ftab[bid] = mag;

#if (HACKS)

_fcnt[bid]++;

#endif

munlk(&_flktab[bid]);

} else {

if (!unmapanon(clrptr(mag->adr), max * bsz)) {

234

CHAPTER 24. C LIBRARY ALLOCATOR

#if (VALGRIND)

if (RUNNING_ON_VALGRIND) {

VALGRIND_FREELIKE_BLOCK(clrptr(mag->adr), 0);

}

#endif
#if (INTSTAT)

nmapbytes[aid] -= max * bsz;

#endif
#if (TUNEBUF)

#endif

_nbmap -= max * bsz;

if (gt2(max, 1)) {

if (!istk(bid)) {

#if (INTSTAT)

#endif

#if (VALGRIND)

nstkbytes[aid] -= (mag->max << 1) << sizeof(void *);

unmapstk(mag);
mag->bptr = NULL;

if (RUNNING_ON_VALGRIND) {

VALGRIND_FREELIKE_BLOCK(mag, 0);

#endif

}

}

}
mag->adr = NULL;
hbuf[--cur] = mag;
arn->hcur = cur;

}

}
munlk(&arn->lktab[bid]);

return;

}

#define blkalnsz(sz, aln)
(((aln) <= MINSZ)
? max(sz, aln)
: (sz) + (aln))

static void *
getmem(size_t size,

size_t align,
long zero)

{

struct arn
long
long
long
uint8_t
long

*arn;
aid;
sz = blkalnsz(max(size, MINSZ), align);
bid = bktid(sz);

*retptr = NULL;

bsz = blksz(bid);

\
\
\

24.2. IMPLEMENTATION

235

uint8_t
long
struct mag
void
long
long
long

*ptr = NULL;

max = nblk(bid);

*mag = NULL;

**stk;
l;
n;
get = 0;

if (!(_conf.flags & CONF_INIT)) {

initmall();

}

aid = thrid();
arn = _atab[aid];
mlk(&arn->lktab[bid]);
mag = arn->btab[bid];
if (!mag) {

mag = arn->ftab[bid];

}
if (!mag) {

mlk(&_flktab[bid]);
mag = _ftab[bid];
if (mag) {

mag->aid = aid;
_ftab[bid] = mag->next;
mag->next = NULL;

#if (HACKS)

#endif

_fcnt[bid]--;

}
munlk(&_flktab[bid]);
if (mag) {

if (gt2(max, 1)) {

mag->next = arn->btab[bid];
if (mag->next) {

mag->next->prev = mag;

}
arn->btab[bid] = mag;

}

}

} else if (mag->cur == mag->max - 1) {

if (mag->next) {

mag->next->prev = NULL;

}
arn->btab[bid] = mag->next;
mag->next = NULL;

}
if (!mag) {

get = 1;
if (!ismapbkt(bid)) {

236

CHAPTER 24. C LIBRARY ALLOCATOR

ptr = getslab(aid, bid);
if (ptr == (void *)-1L) {

ptr = NULL;

}
} else {

ptr = mapanon(_mapfd, nbmap(bid));
if (ptr == MAP_FAILED) {

ptr = NULL;

}
#if (INTSTAT)

else {

nmapbytes[aid] += nbmap(bid);

}

#endif

}
mag = gethdr(aid);
if (mag) {

mag->aid = aid;
mag->cur = 0;
mag->max = max;
mag->bid = bid;
mag->adr = ptr;
if (ptr) {

if (gt2(max, 1)) {

if (istk(bid)) {

stk = (void **)mag->stk;

} else {

stk = mapstk(max);

}
mag->bptr = stk;
if (stk != MAP_FAILED) {

#if (INTSTAT)

#endif
#if (VALGRIND)

nstkbytes[aid] += (max << 1) << sizeof(void *);

if (RUNNING_ON_VALGRIND) {

VALGRIND_MALLOCLIKE_BLOCK(stk, max * sizeof(void *), 0, 0);

#endif

}

n = max << nmagslablog2(bid);
for (l = 0 ; l < n ; l++) {

stk[l] = ptr;
ptr += bsz;

}
mag->prev = NULL;
if (ismapbkt(bid)) {

mlk(&_flktab[bid]);
mag->next = _ftab[bid];
_ftab[bid] = mag;

#if (HACKS)

24.2. IMPLEMENTATION

237

#endif

_fcnt[bid]++;

} else {

mag->next = arn->btab[bid];
if (mag->next) {

mag->next->prev = mag;

}
arn->btab[bid] = mag;

}

}

}

}

}

}
if (mag) {

ptr = getblk(mag);
retptr = clrptr(ptr);

#if (VALGRIND)

if (RUNNING_ON_VALGRIND) {

if (retptr) {

VALGRIND_MALLOCLIKE_BLOCK(retptr, bsz, 0, 0);

}

}

#endif

if ((zero) && chkflg(ptr, BDIRTY)) {

zeroblk(retptr, bsz);

}
ptr = retptr;

#if (RZSZ)

markred(ptr);
markred(ptr + RZSZ + size);

#endif

if (retptr) {

#if (RZSZ)

#endif

retptr = ptr + RZSZ;

if (align) {

if ((uintptr_t)(retptr) & (align - 1)) {

retptr = (uint8_t *)roundup2((uintptr_t)ptr, align);

}
ptr = setflg(retptr, BALIGN);

}
putptr(mag, retptr, ptr);
addblk(retptr, mag);

}

}
if ((get) && ismapbkt(bid)) {
munlk(&_flktab[bid]);

}
munlk(&arn->lktab[bid]);

238

CHAPTER 24. C LIBRARY ALLOCATOR

#if (X11VIS)
//

mlk(&x11vislk);
if (x11visinit) {

//

ptr = clrptr(ptr);

ptr = retptr;
if (ptr) {

long
uint8_t *vptr = ptr;

l = blksz(bid) >> BLKMINLOG2;

while (l--) {

x11vismarkres(vptr);
vptr += MINSZ;

}

}
if (retptr) {
long
uint8_t *vptr = retptr;

l = sz >> BLKMINLOG2;

while (l--) {

x11vismarkused(ptr);
vptr += MINSZ;

}

}
XSetWindowBackgroundPixmap(x11visdisp,

x11viswin,
x11vispmap);

XClearWindow(x11visdisp,
x11viswin);

XFlush(x11visdisp);

}

munlk(&x11vislk);

//
#endif
#ifdef ENOMEM

if (!retptr) {

errno = ENOMEM;
fprintf(stderr, "%lx failed to allocate %ld bytes\n", aid, 1UL << bid);

abort();

}

#if (INTSTAT)
else {

nalloc[aid][bid]++;

}

#endif
#endif

return retptr;

}

static void

24.2. IMPLEMENTATION

239

putmem(void *ptr)
{
#if (RZSZ)

uint8_t

*u8p = ptr;

#endif

*mptr;

struct arn *arn;
void
struct mag *mag = (ptr) ? findmag(ptr) : NULL;
long
long
long
long
long
long

aid = -1;
tid = thrid();
bid = -1;
max;
glob = 0;
freed = 0;

if (mag) {
#if (VALGRIND)

if (RUNNING_ON_VALGRIND) {

VALGRIND_FREELIKE_BLOCK(ptr, 0);

}

#endif

aid = mag->aid;
if (aid < 0) {
glob++;
mag->aid = aid = tid;

}
bid = mag->bid;
max = mag->max;
arn = _atab[aid];
mlk(&arn->lktab[bid]);
if (gt2(max, 1) && magempty(mag)) {
mag->next = arn->btab[bid];
if (mag->next) {

mag->next->prev = mag;

}
arn->btab[bid] = mag;

}
mptr = getptr(mag, ptr);

#if (RZSZ)

if (!chkflg(mptr, BALIGN)) {

u8p = mptr - RZSZ;
if (chkred(u8p) || chkred(u8p + blksz(bid) - RZSZ)) {

fprintf(stderr, "red-zone violation\n");

}
ptr = clrptr(mptr);

}

#endif

if (mptr) {

putptr(mag, ptr, NULL);
mptr = setflg(mptr, BDIRTY);

240

CHAPTER 24. C LIBRARY ALLOCATOR

putblk(mag, mptr);
if (magfull(mag)) {

if (gt2(max, 1)) {

if (mag->prev) {

mag->prev->next = mag->next;

} else {

arn->btab[bid] = mag->next;

}
if (mag->next) {

mag->next->prev = mag->prev;

}

}
if (!isbufbkt(bid) && ismapbkt(bid)) {

freed = 1;

} else {

mag->prev = mag->next = NULL;
mlk(&_flktab[bid]);
mag->next = _ftab[bid];
_ftab[bid] = mag;

#if (HACKS)

#endif

_fcnt[bid]++;

munlk(&_flktab[bid]);

}

}

}
munlk(&arn->lktab[bid]);
if (freed) {

freemap(mag);

}

#if (X11VIS)
//

mlk(&x11vislk);

if (x11visinit) {

ptr = mptr;
if (ptr) {

if (freed) {
long
uint8_t *vptr = ptr;

l = nbmap(bid) >> BLKMINLOG2;

while (l--) {

x11vismarkfreed(vptr);
vptr += MINSZ;

}
} else {
long
uint8_t *vptr = ptr;

l = blksz(bid) >> BLKMINLOG2;

while (l--) {

x11vismarkfreed(vptr);
vptr += MINSZ;

24.2. IMPLEMENTATION

241

}

}

}
XSetWindowBackgroundPixmap(x11visdisp,

x11viswin,

x11vispmap);

XClearWindow(x11visdisp,
x11viswin);

XFlush(x11visdisp);

}

munlk(&x11vislk);

//
#endif

}

return;

}

/* STD: ISO/POSIX */

void *
malloc(size_t size)
{

void *ptr = getmem(size, 0, 0);

return ptr;

}

void *
calloc(size_t n, size_t size)
{

size_t
void

sz = n * (size + (RZSZ << 1));

*ptr = getmem(sz, 0, 1);

return ptr;

}

void *
_realloc(void *ptr,

size_t size,
long rel)

{

sz = blkalnsz(max(size + (RZSZ << 1), MINSZ), 0);

*retptr = ptr;

void
long
struct mag *mag = (ptr) ? findmag(ptr) : NULL;
long
uintptr_t

bid = bktid(sz);
bsz = (mag) ? blksz(mag->bid) : 0;

if (!ptr) {

retptr = getmem(size, 0, 0);

} else if ((mag) && mag->bid != bid) {

242

CHAPTER 24. C LIBRARY ALLOCATOR

retptr = getmem(size, 0, 0);
if (retptr) {

memcpy(retptr, ptr, min(sz, bsz));
putmem(ptr);
ptr = NULL;

}

}
if ((rel) && (ptr)) {
putmem(ptr);

}

return retptr;

}

void *
realloc(void *ptr,

size_t size)

{

}

void *retptr = _realloc(ptr, size, 0);

return retptr;

void
free(void *ptr)
{

if (ptr) {

putmem(ptr);

}

return;

}

#if (_ISOC11_SOURCE)
void *
aligned_alloc(size_t align,

size_t size)

{

}

void *ptr = NULL;
if (!powerof2(align) || (size % align)) {

errno = EINVAL;

} else {

ptr = getmem(size, align, 0);

}

return ptr;

#endif

24.2. IMPLEMENTATION

243

#if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600)
int
posix_memalign(void **ret,

size_t align,
size_t size)

{

void *ptr = getmem(size, align, 0);
int

retval = -1;

if (!powerof2(align) || (size % sizeof(void *))) {

errno = EINVAL;

} else {

ptr = getmem(size, align, 0);
if (ptr) {

retval ^= retval;

}

}

*ret = ptr;

return retval;

}
#endif

/* STD: UNIX */

#if ((_BSD_SOURCE)

\

|| (_XOPEN_SOURCE >= 500 || ((_XOPEN_SOURCE) && (_XOPEN_SOURCE_EXTENDED))) \
&& !(_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600))

void *
valloc(size_t size)
{

void *ptr = getmem(size, PAGESIZE, 0);

return ptr;

}
#endif

void *
memalign(size_t align,

size_t size)

{

void *ptr = NULL;

if (!powerof2(align)) {
errno = EINVAL;

} else {

ptr = getmem(size, align, 0);

}

CHAPTER 24. C LIBRARY ALLOCATOR

244

}

return ptr;

#if (_BSD_SOURCE)
void *
reallocf(void *ptr,

size_t size)

{

void *retptr = _realloc(ptr, size, 1);

return retptr;

}
#endif

#if (_GNU_SOURCE)
void *
pvalloc(size_t size)
{

size_t
void

sz = roundup2(size, PAGESIZE);
*ptr = getmem(sz, PAGESIZE, 0);

return ptr;

}
#endif

void
cfree(void *ptr)
{

if (ptr) {

free(ptr);

}

return;

}

size_t
malloc_usable_size(void *ptr)
{

struct mag *mag = findmag(ptr);
size_t

sz = usrsz(mag->bid);

return sz;

}

size_t
malloc_good_size(size_t size)
{

size_t rzsz = RZSZ;
size_t sz = usrsz(bktid(size)) - (rzsz << 1);

24.2. IMPLEMENTATION

245

return sz;

}

size_t
malloc_size(void *ptr)
{

struct mag *mag = findmag(ptr);
size_t

sz = (mag) ? blksz(mag->bid) : 0;

return sz;

}

246

CHAPTER 24. C LIBRARY ALLOCATOR

Appendix A

Cheat Sheets

247

248

APPENDIX A. CHEAT SHEETS

A.1 C Operator Precedence and Associativity

Precedence

The table below lists operators in descending order of evaluation (precedence).

Operators
() [] -> .
! ˜ + + - - + - * (cast) sizeof
* / %
+ -
<< >>
< <= > >=
== !=
&
^
|
&&
?:
= += -= *= /= %= &= ^= |= <<= >>=
,

Associativity
left to right
right to left
left to right
left to right
left to right
left to right
left to right
left to right
left to right
left to right
left to right
right to left
right to left
left to right

Notes

(cid:15) Unary (single operand) +, -, and * have higher precedence than the binary ones

TODO: (ARM?) assembly, Dijkstra’s Shunting yard, cdecl

Appendix B

A Bag of Tricks

trix.h

#ifndef __ZERO_TRIX_H__
#define __ZERO_TRIX_H__

/*

* this file contains tricks I’ve gathered together from sources such as MIT
* HAKMEM and the book Hacker’s Delight
*/

#define ZEROABS 1

#include <stdint.h>
#include <limits.h>
#include <zero/param.h>

#if (LONGSIZE == 4)
#define tzerol(u, r) tzero32(u, r)
#define lzerol(u, r) lzero32(u, r)
#elif (LONGSIZE == 8)
#define tzerol(u, r) tzero64(u, r)
#define lzerol(u, r) lzero64(u, r)
#endif

/* get the lowest 1-bit in a */
#define lo1bit(a)
((a) & -(a))
/* get n lowest and highest bits of i */
#define lobits(i, n)
#define hibits(i, n)
/* get n bits starting from index j */
#define getbits(i, j, n)
/* set n bits starting from index j to value b */
#define setbits(i, j, n, b) ((i) |= (((b) << (j)) & ~(((1U << (n)) << (j)) - 0x01)))
#define bitset(p, b)

((i) & ((1U << (n)) - 0x01))
((i) & ~((1U << (sizeof(i) * CHAR_BIT - (n))) - 0x01))

(((uint8_t *)(p))[(b) >> 3] & (1U << ((b) & 0x07)))

(lobits((i) >> (j), (n)))

249

250

APPENDIX B. A BAG OF TRICKS

(((uint8_t *)(p))[(b) >> 3] |= (1U << ((b) & 0x07)))

/* set bit # b in *p */
#define setbit(p, b)
/* clear bit # b in *p */
#define clrbit(p, b)
/* m - mask of bits to be taken from b. */
#define mergebits(a, b, m)
/* m - mask of bits to be copied from a. 1 -> copy, 0 -> leave alone. */
#define copybits(a, b, m) (((a) | (m)) | ((b) & ~(m)))

((a) ^ (((a) ^ (b)) & (m)))

(((uint8_t *)(p))[(b) >> 3] &= ~(1U << ((b) & 0x07)))

/* compute minimum and maximum of a and b without branching */
#define min(a, b)

((b) + (((a) - (b)) & -((a) < (b))))

#define max(a, b)

((a) - (((a) - (b)) & -((a) < (b))))

/* compare with power-of-two p2 */
#define gt2(u, p2)

/* true if u > p2 */

((u) & ~(p2))

#define gte2(u, p2) /* true if u >= p2 */

((u) & -(p2))

\

\

\

\

/* swap a and b without a temporary variable */
#define swap(a, b)
/* compute absolute value of integer without branching; PATENTED in USA :( */
#if (ZEROABS)
#define zeroabs(a)

((a) ^= (b), (b) ^= (a), (a) ^= (b))

\
\

(((a) ^ (((a) >> (CHAR_BIT * sizeof(a) - 1))))

- ((a) >> (CHAR_BIT * sizeof(a) - 1)))

#define abs(a)
#define labs(a)
#define llabs(a)
#endif

zeroabs(a)
zeroabs(a)
zeroabs(a)

/* true if x is a power of two */
#define powerof2(x)
/* align a to boundary of (the power of two) b2. */
//#define align(a, b2)
//#define align(a, b2)
#define mod2(a, b2)

((a) & -(b2))
((a) & ((b2) - 1))

(!((x) & ((x) - 1)))

((a) & ~((b2) - 1))

/* round a up to the next multiple of (the power of two) b2. */
//#define roundup2a(a, b2) (((a) + ((b2) - 0x01)) & ~((b2) + 0x01))
#define roundup2(a, b2) (((a) + ((b2) - 0x01)) & -(b2))

/* round down to the previous multiple of (the power of two) b2 */
#define rounddown2(a, b2) ((a) & ~((b2) - 0x01))

/* compute the average of a and b without division */
#define uavg(a, b)

(((a) & (b)) + (((a) ^ (b)) >> 1))

#define divceil(a, b)
#define divround(a, b) (((a) + ((b) / 2)) / (b))

(((a) + (b) - 1) / (b))

251

#define haszero_2(a)
#define haszero_32(a)

(~(a))
(((a) - 0x01010101) & ~(a) & 0x80808080)

#define onebits_32(u32, r)

((r) = (u32),

(r) -= ((r) >> 1) & 0x55555555,
(r) = (((r) >> 2) & 0x33333333) + ((r) & 0x33333333),
(r) = ((((r) >> 4) + (r)) & 0x0f0f0f0f),
(r) += ((r) >> 8),
(r) += ((r) >> 16),
(r) &= 0x3f)

#define onebits_32b(u32, r)

((r) = (u32),

(r) -= ((r) >> 1) & 0x55555555,
(r) = (((r) >> 2) & 0x33333333) + ((r) & 0x33333333),
(r) = (((((r) >> 4) + (r)) & 0x0f0f0f0f) * 0x01010101) >> 24)

#define bytepar(b, r)

do {

unsigned long _tmp1;

_tmp1 = (b);
_tmp1 ^= (b) >> 4;
(r) = (0x6996 >> (_tmp1 & 0x0f)) & 0x01;

} while (0)

#define bytepar2(b, r)

do {

unsigned long _tmp1;
unsigned long _tmp2;

_tmp1 = _tmp2 = (b);
_tmp2 >>= 4;
_tmp1 ^= _tmp2;
_tmp2 = 0x6996;
(r) = (_tmp2 >> (_tmp1 & 0x0f)) & 0x01;

} while (0)

#define bytepar3(b) ((0x6996 >> (((b) ^ ((b) >> 4)) & 0x0f)) & 0x01)

/* count number of trailing zero-bits in u32 */
#define tzero32(u32, r)

do {

uint32_t __tmp;
uint32_t __mask;

(r) = 0;
__tmp = (u32);
__mask = 0x01;
if (!(__tmp & __mask)) {
__mask = 0xffff;

\
\
\
\
\
\
\

\
\
\
\

\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\

252

APPENDIX B. A BAG OF TRICKS

if (!(__tmp & __mask)) {

__tmp >>= 16;
(r) += 16;

}
__mask >>= 8;
if (!(__tmp & __mask)) {

__tmp >>= 8;
(r) += 8;

}
__mask >>= 4;
if (!(__tmp & __mask)) {

__tmp >>= 4;
(r) += 4;

}
__mask >>= 2;
if (!(__tmp & __mask)) {

__tmp >>= 2;
(r) += 2;

}
__mask >>= 1;
if (!(__tmp & __mask)) {

(r) += 1;

}

}

} while (0)

/*

* count number of leading zero-bits in u32
*/
#if 0
#define lzero32(u32, r)

((u32) |= ((u32) >> 1),
(u32) |= ((u32) >> 2),
(u32) |= ((u32) >> 4),
(u32) |= ((u32) >> 8),
(u32) |= ((u32) >> 16),
CHAR_BIT * sizeof(u32) - onebits_32(u32, r))

#endif
#define lzero32(u32, r)

do {

uint32_t __tmp;
uint32_t __mask;

\

\

(r) = 0;
__tmp = (u32);
__mask = 0x01;
__mask <<= CHAR_BIT * sizeof(uint32_t) - 1;
if (!(__tmp & __mask)) {
__mask = 0xffffffff;
__mask <<= 16;

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\

\
\
\
\

\
\
\
\
\
\

if (!(__tmp & __mask)) {

__tmp <<= 16;
(r) += 16;

}
__mask <<= 8;
if (!(__tmp & __mask)) {

__tmp <<= 8;
(r) += 8;

}
__mask <<= 4;
if (!(__tmp & __mask)) {

__tmp <<= 4;
(r) += 4;

}
__mask <<= 2;
if (!(__tmp & __mask)) {

__tmp <<= 2;
(r) += 2;

}
__mask <<= 1;
if (!(__tmp & __mask)) {

(r)++;

}

}

} while (0)

/* 64-bit versions */

#define tzero64(u64, r)

do {

uint64_t __tmp;
uint64_t __mask;

(r) = 0;
__tmp = (u64);
__mask = 0x01;
if (!(__tmp & __mask)) {
__mask = 0xffffffff;
if (!(__tmp & __mask)) {

__tmp >>= 32;
(r) += 32;

}
__mask >>= 16;
if (!(__tmp & __mask)) {

__tmp >>= 16;
(r) += 16;

}
__mask >>= 8;
if (!(__tmp & __mask)) {

__tmp >>= 8;

253

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

254

APPENDIX B. A BAG OF TRICKS

(r) += 8;

}
__mask >>= 4;
if (!(__tmp & __mask)) {

__tmp >>= 4;
(r) += 4;

}
__mask >>= 2;
if (!(__tmp & __mask)) {

__tmp >>= 2;
(r) += 2;

}
__mask >>= 1;
if (!(__tmp & __mask)) {

(r) += 1;

}

}

} while (0)

#define lzero64(u64, r)

do {

uint64_t __tmp;
uint64_t __mask;

\

\

(r) = 0;
__tmp = (u64);
__mask = 0x01;
__mask <<= CHAR_BIT * sizeof(uint64_t) - 1;
if (!(__tmp & __mask)) {
__mask = 0xffffffff;
__mask <<= 32;
if (!(__tmp & __mask)) {

__tmp <<= 32;
(r) += 32;

}
__mask <<= 16;
if (!(__tmp & __mask)) {

__tmp <<= 16;
(r) += 16;

}
__mask <<= 8;
if (!(__tmp & __mask)) {

__tmp <<= 8;
(r) += 8;

}
__mask <<= 4;
if (!(__tmp & __mask)) {

__tmp <<= 4;
(r) += 4;

}

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

255

\
\
\
\
\
\
\
\
\
\

__mask <<= 2;
if (!(__tmp & __mask)) {

__tmp <<= 2;
(r) += 2;

}
__mask <<= 1;
if (!(__tmp & __mask)) {

(r)++;

}

}

} while (0)

static __inline__ uint32_t
ceil2_32(uint64_t x)
{

x--;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
x++;

return x;

}

static __inline__ uint64_t
ceil2_64(uint64_t x)
{

x--;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
x |= x >> 32;
x++;

return x;

}

/* internal macros. */
#define _ftoi32(f)
#define _ftou32(f)
#define _dtoi64(d)
#define _dtou64(d)
/* FIXME: little-endian. */
#define _dtohi32(d)
/*

* IEEE 32-bit

(*((int32_t *)&(f)))
(*((uint32_t *)&(f)))
(*((int64_t *)&(d)))
(*((uint64_t *)&(d)))

(*(((uint32_t *)&(d)) + 1))

256

APPENDIX B. A BAG OF TRICKS

- mantissa
* 0..22
* 23..30 - exponent
* 31
*/

- sign

/* convert elements of float to integer. */
#define fgetmant(f)
#define fgetexp(f)
#define fgetsign(f)
#define fsetmant(f, mant) (_ftou32(f) |= (mant) & 0x007fffff)
#define fsetexp(f, exp)
#define fsetsign(f)
/*

(_ftou32(f) & 0x007fffff)
((_ftou32(f) >> 23) & 0xff)
(_ftou32(f) >> 31)

(_ftou32(f) |= ((exp) & 0xff) << 23)
(_ftou32(f) | 0x80000000)

* IEEE 64-bit
* 0..51
- mantissa
* 52..62 - exponent
* 63
*/

- sign

/* convert elements of double to integer. */
#define dgetmant(d)
#define dgetexp(d)
#define dgetsign(d)
#define dsetmant(d, mant)

(_dtou64(d) & UINT64_C(0x000fffffffffffff))
((_dtohi32(d) >> 20) & 0x7ff)
(_dtohi32(d) >> 31)

\

(*((uint64_t *)&(d)) |= (uint64_t)(mant) | UINT64_C(0x000fffffffffffff))

#define dsetexp(d, exp)

(*((uint64_t *)&(d)) |= (((uint64_t)((exp) & 0x7ff)) << 52))

#define dsetsign(d)

(*((uint64_t *)&(d)) |= UINT64_C(0x8000000000000000))

/*

* IEEE 80-bit
* 0..63
- mantissa
* 64..78 - exponent
* 79
*/

- sign

#define ldgetmant(ld)
#define ldgetexp(ld)
#define ldgetsign(ld)
#define ldsetmant(ld, mant) (*((uint64_t *)&ld = (mant)))
#define ldsetexp(ld, exp)
#define ldsetsign(ld)

(*((uint64_t *)&ld))
(*((uint32_t *)&ld + 2) & 0x7fff)
(*((uint32_t *)&ld + 3) & 0x8000)

(*((uint32_t *)&ld + 2) |= (exp) & 0x7fff)
(*((uint32_t *)&ld + 3) |= 0x80000000)

/* sign bit 0x8000000000000000. */
#define ifabs(d)

(_dtou64(d) & UINT64_C(0x7fffffffffffffff))

#define fabs2(d, t64)

(*((uint64_t *)&(t64)) = ifabs(d))

/* sign bit 0x80000000. */
#define ifabsf(f)

(_ftou32(f) & 0x7fffffff)

\

\

\

\

\

/* TODO: test the stuff below. */

/* (a < b) ? v1 : v2; */
#define condltset(a, b, v1, v2)

257

\

(((((a) - (b)) >> (CHAR_BIT * sizeof(a) - 1)) & ((v1) ^ (v2))) ^ (v2))

/* c - conditional, f - flag, u - word */
#define condsetf(c, f, u) ((u) ^ ((-(u) ^ (u)) & (f)))

#define nextp2(a)

(((a)

| ((a) >> 1)
| ((a) >> 2)
| ((a) >> 4)
| ((a) >> 8)
| ((a) >> 16)) + 1)

/* (a < b) ? v1 : v2; */
#define condset(a, b, v1, v2)

\
\
\
\
\
\

\

(((((a) - (b)) >> (CHAR_BIT * sizeof(a) - 1)) & ((v1) ^ (v2))) ^ (v2))

/* c - conditional, f - flag, u - word */
#define condsetf(c, f, u) ((u) ^ ((-(u) ^ (u)) & (f)))

#define sat8(x)

((x) | (!((x) >> 8) - 1))

#define sat8b(x)

condset(x, 0xff, x, 0xff)

#define haszero(a) (~(a))
#if 0
#define haszero_32(a)

(~(((((a) & 0x7f7f7f7f) + 0x7f7f7f7f) | (a)) | 0x7f7f7f7f))

#endif

/* calculate modulus u % 10 */
#define modu10(u)

((u) - ((((u) * 6554U) >> 16) * 10))

/* TODO: change modulus calculations to something faster */
#define leapyear(x)

(!((x) & 0x03) && ((((x) % 100)) || !((x) % 400)))

#endif /* __ZERO_TRIX_H__ */

\

\

\

\

\

258

APPENDIX B. A BAG OF TRICKS

Appendix C

Managing Builds with Tup

Rationale

This chapter is not meant to be a be-all manual for Tup; instead, I give a somewhat-
quick overview in the hopes the readers will be able to get a jump-start for using Tup
for their projects.

Why Tup?

There are many tools around to manage the task of building software projects. Whereas
I have quite a bunch of experience with GNU Auto-tools and have been suggested
learning to use Cmake, I was recently pointed to Tup; it was basically love at first
sight.

C.1 Overview

Tup Initialisation

Initializing a source-code tree to be used with Tup is extremely simple. Just execute

tup init

in the top-level directory and you will be set.

Upwards Recursion

What makes Tup perhaps unique in its approach is that it recursively manages the whole
build tree (or, optionally, smaller parts of it) by scanning the tree upwards. This means
that when you execute

tup upd

the tree is scanned upwards for configuration files, and all directories with Tupfile are
processed to be on-synch. You may alternatively choose to run

tup upd .

to limit the synchronisation (build) to the current working directory.

259

260

APPENDIX C. MANAGING BUILDS WITH TUP

C.2 Using Tup

C.2.1 Tuprules.tup

It’s a good idea to have a top-level Tuprules.tup file to set up things such as aliases
for build commands. Here is a simple rules file which I use for my operating system
project (additions to come in later).

Tuprules.tup

CC = gcc
LD = ld
CFLAGS = -g -Wall -O

!cc = |> ^ CC %f^ $(CC) $(CFLAGS) $(CFLAGS_%B) -c %f -o %o |> %B.o
!ld = |> ^ LD %f^ $(LD) $(LDFLAGS) $(LDFLAGS_%B) -o %o %f |>

Notes

(cid:15) Environment variables are used much like in Unix shell scripts; here, I set CC (C
compiler) to point to gcc, LD (linker) to point to ld, and CFLAGS (C compiler
flags) to a useful default of -g -Wall -O; produce debugger output, turn on many
warnings, and do basic optimisations.

(cid:15) Aliases start with ’!’; I set aliases for C compiler and linker (!cc and !ld, respec-

tively).

C.2.2 Tup Syntax

C.2.3 Variables

Environment Variables

Tup lets us assign environment variables much like Unix shells do; e.g., to assign the
value gcc to the variable CC, you would use the syntax

CC = gcc

or

CC := gcc

You can then refer to this variable like

$(CC)

in your Tup script files.

Conventional Environment Variables

Here comes a list of some commonly used environment variables and their purposes.

C.2. USING TUP

261

CC
LD
AS
CFLAGS
LDFLAGS
ASFLAGS

C compiler command
linker command
assembler command
C compiler flags
linker flags
assembler flags

Predefined @-Variables

TUP_CWD
TUP_ARCH
TUP_PLATFORM target operating system

path relative to the current Tupfile being parsed
target-architecture for building objects

Notes

(cid:15) @-variables can be specified in tup.config-files. For example, if you specify
CONFIG_PROJECT in tup.config, you can refer to it as @(PROJECT) in
Tupfile.

(cid:15) @-variables differ from environment variables in two ways; they are read-only,
and they are treated as dependencies; note that exported environment variables
are dependencies as well.

Example tup.config

# tup.config for the zero project

CONFIG_PROJECT=zero
CONFIG_RELEASE=0.0.1

It is possible to set CONFIG_-varibles to the value ’n’ by having comments like

# CONFIG_RELEASE is not set

C.2.4 Rules

Tup rules take the following syntax

: [foreach] [inputs] [ | order-only inputs] |> command |> [outputs] [ | extra outputs]
[{bin}]

Notes

(cid:15) ’[’ and ’]’ are used to denote optional fields.
(cid:15) ’|’ is used to separate fields.
(cid:15) foreach is used to run one command per input file; if omitted, all input files are

used as arguments for a single command.

(cid:15) inputs-field lists filenames; shell-style wildcards ’?’ and ’*’ are supported.
(cid:15) order-only inputs are used as inputs but the filenames are not present in %-
flags. This is useful e.g. for specifying dependencies on files such as headers
generated elsewhere; Tup shall know to generate those files first without execut-
ing the command.

262

APPENDIX C. MANAGING BUILDS WITH TUP

(cid:15) outputs specifies the names of the files to be written by command.

(cid:15) extra outputs are additional output files whose names do not appear in the

%o-flag.

(cid:15) {bin} can be used to group outputs into bins; later rules can use "{bin}" as an
input to use all filenames in the bin. As an example, the foreach rule will put all
output files into the objs bin.

C.2.5 Macros

The following is an example macro to specify the C compiler and default flags to be
used with it.

!cc = |> ˆCC %fˆ$(CC) $(CFLAGS) $(CFLAGS_%B) -c %f -o %o |> %B.o

Notes

(cid:15) Macros take ’!’ as their prefix, in contrast with rules being prefixed with ’:’.

(cid:15) ˆCC %fˆ controls what is echoed to the user when the command is run; note
that the space after the first ’ˆ’ is required; the letters immediately following the
ˆwould be flags.

(cid:15) %B evalutes to the name of the current file without the extension; similarly, %f
is the name of the current input file, and %o is the name of the current output
file.

C.2.6 Flags

ˆ-flags

(cid:15) the ’c’ flag causes the command to run inside a chroot-environment (currently
under Linux and OSX), so that the effective working directory of the subprocess
is different from the current working directory.

%-flags

the current filename from the inputs section
the basename (path stripped) of the current input file
like %b, but strips the filename extension
the extension of current file with foreach
the name(s) of output file(s) in the cammand section

%f
%b
%B
%e
%o
%O like %o, but without the extension
%d

the name of the lowest-level directory in path

C.2.7 Directives

ifeq (val1,val2)

C.2. USING TUP

263

The ifeq-directive tells Tup to do the things before the next endif or else in case val1
is found to be equal to val2. Note that any spaces included within the parentheses are
processed verbatim. All $- and @-variables are substituted within val1 and val2.

ifneq (val1,val2)

The ifneq-directive inverts the logic of ifeq; the following things are done if val1 is not
equal with val2.

ifdef VARIABLE

The things before the next endif shall be done if the @-variable is defined at all in
tup.config.

ifndef VARIABLE

ifndef inverts the logic of ifdef.

else

else toggles the logical truth value of the previous ifeq/ifneq/ifdef/ifndef statement.

endif

Ends the previous ifeq/ifneq/ifdef/ifndef statement.

include file

Reads a regular file and continues parsing the current Tupfile.

include_rules

Scans the directory tree up for the first Tuprules.tup file and then reads all Tuprules.tup
files from it down to the one possibly in the current directory. Usually specified as the
first line in Tupfile.

run ./script args

Run an external script with the given arguments to generate :-rules. The script is
expected to write the :-rules to standard output (stdout). The script cannot create $-
variables or !-macros, but it can output :-rules that use those features.

preload directory

By default, run-scripts can only use wild-cards for files in the current directory. To
specify other wild-card directories to be scanne, you can use preload.

export VARIABLE

Adds the environment variable VARIABLE to be used by future :-rules and run-scripts.
VARIABLE comes from environment, not the Tupfile, so you can control the contents
using your shell. On Unix-systems, only PATH is exported by default.

.gitignore

Tells Tup to automatically generate a .gitignore file with a list of Tup-generated output
files.

#

# at the beginning of a line marks the line as a comment.