Low-Level C Programming

CSEE W4840
Prof. Stephen A. Edwards
Columbia University

Spring 2013

Goals

Function is correct
Source code is concise, readable, maintainable
Time-critical sections of program run fast enough
Object code is small and efficient
Optimize the use of three resources:

Execution time

Memory

Development/maintenance time

Like Writing English

You can say the same thing many different ways and
mean the same thing.
There are many different ways to say the same thing.
The same thing may be said different ways.
There is more than one way to say it.
Many sentences are equivalent.
Be succinct.

Arithmetic
Integer Arithmetic

Fastest

Floating-point arithmetic in hardware

Slower

Floating-point arithmetic in software

Very slow

slower

sqrt, sin, log, etc. y

+,

Simple benchmarks
for (i = 0 ; i < 10000 ; ++i)
/* arithmetic operation */
On a Pentium 4 with good hardware floating-point,
Operator
+ (int)
* (int)
/ (int)
<< (int)

Time

Operator

Time

1
5
12
2

+ (double)
* (double)
/ (double)
sqrt
sin
pow

5
5
10
28
48
275

Simple benchmarks

On a Zaurus SL 5600, a 400 MHz Intel PXA250 Xscale

(ARM) processor:
Operator
+ (int)
* (int)
/ (int)
<< (int)

Time

Operator

Time

1
1
7
1

+ (double)
* (double)
/ (double)
sqrt
sin
pow

140
110
220
500
3300
820

C Arithmetic Trivia

Operations on char, short, int, and long probably run

at the same speed (same ALU).
Same for unsigned variants
int or long slower when they exceed machines word
size.

Arithmetic Lessons

Try to use integer addition/subtraction

Avoid multiplication unless you have hardware
Avoid division
Avoid floating-point, unless you have hardware
Really avoid math library functions

Bit Manipulation

C has many bit-manipulation operators.

&
|

^
~
>>
<<

Bit-wise AND
Bit-wise OR
Bit-wise XOR
Negate (ones complement)
Right-shift
Left-shift

Plus assignment versions of each.

Bit-manipulation basics

a |= 0x4;

/* Set bit 2 */

b &= ~0x4;

/* Clear bit 2 */

c &= ~(1 << 3); /* Clear bit 3 */

d ^= (1 << 5);

/* Toggle bit 5 */

e >>= 2;

/* Divide e by 4 */

Advanced bit manipulation

/* Set b to the rightmost 1 in a */

b = a & (a ^ (a - 1));
/* Set d to the number
char c, d;
d = (c & 0x55) + ((c &
d = (d & 0x33) + ((d &
d = (d & 0x0f) + ((d &

of 1s in c */
0xaa) >> 1);
0xcc) >> 2);
0xf0) >> 4);

Faking Multiplication
Addition, subtraction, and shifting are fast. Can
sometimes supplant multiplication.
Like floating-point, not all processors have a dedicated
hardware multiplier.
Recall the multiplication algorithm from elementary
school, but think binary:

101011
1101
101011
= 43 + 43 << 2 + 43 << 3 = 559
10101100
+101011000
1000101111

Faking Multiplication
Even more clever if you include subtraction:
101011
1110
= 43 << 1 + 43 << 2 + 43 << 3
1010110
= 43 << 4 - 43 << 2
10101100
= 602
+101011000
1001011010
Only useful
for multiplication by a constant

for simple multiplicands

when hardware multiplier not available

Faking Division
Division is a much more complicated algorithm that
generally involves decisions.
However, division by a power of two is just a shift:
a / 2 = a >> 1
a / 4 = a >> 2
a / 8 = a >> 3
There is no general shift-and-add replacement for
division, but sometimes you can turn it into
multiplication:
a /
=
=
=

1.33333333
a * 0.75
a * 0.5 + a * 0.25
a >> 1 + a >> 2

Multi-way branches
if (a == 1)
foo();
else if (a ==
bar();
else if (a ==
baz();
else if (a ==
qux();
else if (a ==
quux();
else if (a ==
corge();

2)
3)
4)
5)
6)

switch (a) {
case 1:
foo(); break;
case 2:
bar(); break;
case 3:
baz(); break;
case 4:
qux(); break;
case 5:
quux(); break;
case 6:
corge(); break;
}

Nios code for if-then-else

ldw
cmpnei
bne
call
br
.L2:
ldw
cmpnei
bne
call
br
.L4:

r2, 0(fp)
r2, r2, 1
r2, zero, .L2
foo
.L3

#
#
#
#
#

Fetch a from stack

Compare with 1
If not 1, jump to L2
Call foo()
branch out

r2, 0(fp)
r2, r2, 2
r2, zero, .L4
bar
.L3

#
#
#
#
#

Fetch a from stack (again!)

Compare with 2
If not 1, jump to L4
Call bar()
branch out

Nios code for switch

.L9:
.L3:
.L4:
.L5:
.L6:
.L7:
.L8:
.L2:

ldw
r2, 0(fp)
# Fetch a
cmpgeui r2, r2, 7
# Compare with 7
bne
r2, zero, .L2
# Branch if greater or equal
ldw
r2, 0(fp)
# Fetch a
muli
r3, r2, 4
# Multiply by 4
movhi
r2, %hiadj(.L9) # Load address .L9
addi
r2, r2, %lo(.L9)
add
r2, r3, r2
# = a * 4 + .L9
ldw
r2, 0(r2)
# Fetch from jump table
jmp
r2
# Jump to label
.section .rodata
.align 2
# Jump table
.long
.L2, .L3, .L4, .L5, .L6, .L7, .L8
.section .text
call
foo
br
.L2
call
bar
br
.L2
call
baz
br
.L2
call
qux
br
.L2
call
quux
br
.L2
call
corge

Computing Discrete Functions

Ways to compute a random function:
/* OK, especially for sparse domain */
if (a == 0) x = 0;
else if (a == 1) x = 4;
else if (a == 2) x = 7;
else if (a == 3) x = 2;
else if (a == 4) x = 8;
else if (a == 5) x = 9;
/* Better for large, dense domains */
switch (a) {
case 0: x = 0; break;
case 1: x = 4; break;
case 2: x = 7; break;
case 3: x = 2; break;
case 4: x = 8; break;
case 5: x = 9; break;
}
/* Best: constant-time lookup table */
int f[] = {0, 4, 7, 2, 8, 9};
x = f[a]; /* assumes 0 <= a <= 5 */

Function calls
RISC processors strive to make calling cheap by passing
arguments in registers. Calling, entering, and returning:
int foo(int a,
int b) {
int c =
bar(b, a);
return c;
}

foo:
addi
stw
stw
mov
stw
stw

sp,
ra,
fp,
fp,
r4,
r5,

sp, -20
16(sp)
12(sp)
sp
0(fp)
4(fp)

#
#
#
#
#
#

Allocate space on stack

Store return address
Store frame pointer
Frame pointer is new SP
Save a on stack
Save b on stack

ldw
ldw
call
stw

r4, 4(fp)
r5, 0(fp)
bar
r2, 8(fp)

#
#
#
#

Fetch b
Fetch a
Call bar()
Store result in c

ldw
ldw
ldw
addi
ret

r2,
ra,
fp,
sp,

#
#
#
#
#

Return value in r2 = c
Restore return address
Restore frame pointer
Release stack space
Return from subroutine

8(fp)
16(sp)
12(sp)
sp, 20

Function calls
RISC processors strive to make calling cheap by passing
arguments in registers. Calling, entering, and returning:
int foo(int a,
int b) {
int c =
bar(b, a);
return c;
}

foo:
addi
stw
mov
mov
mov
call
ldw
addi
ret

sp,
ra,
r2,
r4,
r5,
bar
ra,
sp,

sp, -4
0(sp)
r4
r5
r2
0(sp)
sp, 4

(Optimized)

# Allocate stack space

# Store return address
# Swap arguments (r4, r5)
#
using r2 as temporary
#
#
#
#

Call bar() (return in r2)

Restore return address
Release stack space
Return from subroutine

Strength Reduction

Why multiply when you can add?

struct {
int a;
char b;
int c;
} foo[10];
int i;
for (i=0 ;
foo[i].a
foo[i].b
foo[i].c
}

struct {
int a;
char b;
int c;
} *fp, *fe, foo[10];
i<10 ; ++i) {
= 77;
= 88;
= 99;

fe = foo + 10;
for (fp = foo ; fp != fe ; ++fp) {
fp->a = 77;
fp->b = 88;
fp->c = 99;
}

Good optimizing compilers do this automatically.

Unoptimized array code (fragment)

.L2:
ldw
cmpgei
bne
movhi
addi
ldw
muli
add
movi
stw
movhi
addi
ldw
muli
add
addi
movi
stb

r2,
r2,
r2,
r3,
r3,
r2,
r2,
r3,
r2,
r2,
r3,
r3,
r2,
r2,
r2,
r3,
r2,
r2,

0(fp)
r2, 10
zero, .L1
%hiadj(foo)
r3, %lo(foo)
0(fp)
r2, 12
r2, r3
77
0(r3)
%hiadj(foo)
r3, %lo(foo)
0(fp)
r2, 12
r2, r3
r2, 4
88
0(r3)

#
#
#
#

Fetch i
i >= 10?
exit if true
Get address of foo array

# Fetch i
# i * 12
# foo[i]
# foo[i].a = 77

# compute &foo[i]
# offset for b field
# foo[i].b = 88

Unoptimized pointer code (fragment)

.L2:
ldw
ldw
beq
ldw
movi
stw
ldw
movi
stb
ldw
movi
stw
ldw
addi
stw
br

r3,
r2,
r3,
r3,
r2,
r2,
r3,
r2,
r2,
r3,
r2,
r2,
r2,
r2,
r2,
.L2

0(fp)
4(fp)
r2, .L1
0(fp)
77
0(r3)
0(fp)
88
4(r3)
0(fp)
99
8(r3)
0(fp)
r2, 12
0(fp)

# fp
# fe
# fp == fe?

# fp->a = 77

# fp->b = 88

# fp->c = 99

# ++fp

Optimized (O2) array code

movi
movi
movi
movhi
addi
movi
.L5:
addi
stw
stb
stw
addi
bne
ret

r6,
r5,
r4,
r2,
r2,
r3,

77
# Load constants
88
99
%hiadj(foo) # Load address of array
r2, %lo(foo)
10
# iteration count

r3,
r6,
r5,
r4,
r2,
r3,

r3, -1
0(r2)
4(r2)
8(r2)
r2, 12
zero, .L5

#
#
#
#
#
#

decrement iterations
foo[i].a = 77
foo[i].b = 88
foo[i].c = 99
go to next array element
if there are more to do

Optimized (O2) pointer code

movhi
addi
addi
movi
movi
movi
.L5:
stw
stb
stw
addi
bne
ret

r6,
r6,
r2,
r5,
r4,
r3,

%hiadj(foo+120)
r6, %lo(foo+120)
r6, -120
77
88
99

# fe = foo + 10

r5,
r4,
r3,
r2,
r2,

0(r2)
4(r2)
8(r2)
r2, 12
r6, .L5

#
#
#
#
#

# fp = foo
# Constants

fp->a
fp->b
fp->c
++fp
fp ==

= 77
= 88
= 99
fe?

How Rapid is Rapid?

How much time does the following loop take?
for ( i = 0 ; i < 1024 ; ++i) a += b[i];
Operation
Memory read
Addition
Loop overhead
Total

Cycles per iteration

2 or 7
1
4
612

The Nios runs at 50 MHz, one instruction per cycle,

6 1024

1
50MHz

= 0.12s or 12 1024

1
50MHz

= 0.24s

Double-checking

GCC generates good code with -O7:

movhi r4, %hiadj(b) # Load &b[0]
addi r4, r4, %lo(b)
movi r3, 1024
# Iteration count
.L5:
ldw
addi
addi
add
bne
mov
ret

r2,
r3,
r4,
r5,
r3,
r2,

0(r4)
r3, -1
r4, 4
r5, r2
zero, .L5
r5

#
#
#
#
#
#
#

Fetch b[i]
--i
next b element
a += b[i]
repeat if i > 0
result

cycles
2-7
1
1
1
3

Features in order of increasing cost

1. Integer arithmetic
2. Pointer access
3. Simple conditionals and loops
4. Static and automatic variable access
5. Array access
6. Floating-point with hardware support
7. Switch statements
8. Function calls
9. Floating-point emulation in software
10. Malloc() and free()
11. Library functions (sin, log, printf, etc.)
12. Operating system calls (open, sbrk, etc.)

Storage Classes in C
/* fixed address: visible to other files */
int global_static;
/* fixed address: only visible within file */
static int file_static;
/* parameters always stacked */
int foo(int auto_param)
{
/* fixed address: only visible to function */
static int func_static;
/* stacked: only visible to function */
int auto_i, auto_a[10];
/* array explicitly allocated on heap */
double *auto_d = malloc(sizeof(double)*5);
/* return value in register or stacked */
return auto_i;
}

Dynamic Storage Allocation

Dynamic Storage Allocation

free(

Dynamic Storage Allocation

free(

Dynamic Storage Allocation

free(

malloc(

Dynamic Storage Allocation

free(

malloc(

Dynamic Storage Allocation

Rules:
Each allocated block contiguous (no holes)
Blocks stay fixed once allocated
malloc()
Find an area large enough for requested block
Mark memory as allocated
free()
Mark the block as unallocated

Simple Dynamic Storage Allocation

Maintaining information about free memory

Simplest: Linked list
The algorithm for locating a suitable block
Simplest: First-fit
The algorithm for freeing an allocated block
Simplest: Coalesce adjacent free blocks

Simple Dynamic Storage Allocation

S N

S N

Simple Dynamic Storage Allocation

S N

S
malloc(

S N
)

Simple Dynamic Storage Allocation

S N

S
malloc(

S N

S N
)

S N

Simple Dynamic Storage Allocation

S N

S
malloc(

S N

S N
)

free( )

S N

Simple Dynamic Storage Allocation

S N

S
malloc(

S N

)
S

free( )
S

S N

S N

S N

Storage Classes Compared

On most processors, access to automatic (stacked) data
and globals is equally fast.
Automatic usually preferable since the memory is
reused when function terminates.
Danger of exhausting stack space with recursive
algorithms. Not used in most embedded systems.
The heap (malloc) should be avoided if possible:

Allocation/deallocation is unpredictably slow

Danger of exhausting memory

Danger of fragmentation

Best used sparingly in embedded systems

Memory-Mapped I/O

Magical memory locations that, when written or read,

send or receive data from hardware.
Hardware that looks like memory to the processor, i.e.,
addressable, bidirectional data transfer, read and write
operations.
Does not always behave like memory:

Act of reading or writing can be a trigger (data

irrelevant)

Often read- or write-only

Read data often different than last written

Memory-Mapped I/O Access in C

#define SWITCHES ((volatile char *) 0x1800)

#define LEDS ((volatile char *) 0x1810)
void main() {
for (;;) {
*LEDS = *SWITCHES;
}
}

Whats With the Volatile?

#define ADDRESS \
((char *) 0x1800)
#define VADDRESS \
((volatile char *) 0x1800)
char foo()
char a =
char b =
return a
}

{
*ADDRESS;
*ADDRESS;
+ b;

char bar()
char a =
char b =
return a
}

{
*VADDRESS;
*VADDRESS;
+ b;

Compiled with
optimization:
foo:
movi
ldbu
add
andi
ret

r2,
r2,
r2,
r2,

6144
0(r2)
r2, r2
r2, 0xff

bar:
movi
ldbu
ldbu
add
andi
ret

r3,
r2,
r3,
r2,
r2,

6144
0(r3)
0(r3)
r2, r3
r2, 0xff

Altera I/O
/* Definitions of alt_u8, etc. */
#include "alt_types.h"
/* IORD_ALTERA_AVALON... for the PIO device */
#include "altera_avalon_pio_regs.h"
/* Auto-generated addresses for all peripherals */
#include "system.h"
int main() {
alt_u8 sw;
for (;;) {
sw = IORD_ALTERA_AVALON_PIO_DATA(SWITCHES_BASE);
IOWR_ALTERA_AVALON_PIO_DATA(LEDS_BASE, sw);
}
}

(From the Nios II Software Developers Handbook)

HW/SW Communication Styles

Memory-mapped I/O puts the processor in charge: only
it may initiate communication.
Typical operation:

Check hardware conditions by reading status

registers

When ready, send next command by writing

control and data registers

Check status registers for completion, waiting if

necessary

Waiting for completion: polling

Are we there yet? No Are we there yet? No
Are we there yet? No Are we there yet? No

HW/SW Communication: Interrupts

Idea: have hardware initiate communication when it

wants attention.
Processor responds by immediately calling an interrupt
handling routine, suspending the currently-running
program.

Unix Signals
The Unix environment provides signals, which behave
like interrupts.
#include <stdio.h>
#include <signal.h>
void handleint() {
printf("Got an INT\n");
/* some variants require this */
signal(SIGINT, handleint);
}
int main() {
/* Register signal handler */
signal(SIGINT, handleint);
/* Do nothing forever */
for (;;) { }
return 0;
}

Interrupts under Altera (1)

#include "system.h"
#include "altera_avalon_pio_regs.h"
#include "alt_types.h"
static void button_isr(void* context, alt_u32 id)
{
/* Read and store the edge capture register */
*(volatile int *) context =
IORD_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE);
/* Write to the edge capture register to reset it */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE, 0);
/* Reset interrupt capability for the Button PIO */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE, 0xf);
}

Interrupts under Altera (2)

#include "sys/alt_irq.h"
#include "system.h"
volatile int captured_edges;
static void init_button_pio()
{
/* Enable all 4 button interrupts. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE, 0xf);
/* Reset the edge capture register. */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE, 0x0);
/* Register the ISR. */
alt_irq_register( BUTTON_PIO_IRQ,
(void *) &captured_edges,
button_isr );
}

Debugging Skills

The Edwards Way to Debug

1. Identify undesired behavior

2. Construct linear model for desired behavior
3. Pick a point along model
4. Form desired behavior hypothesis for point
5. Test
6. Move point toward failure if point working, away
otherwise
7. Repeat #4#6 until bug is found