Lecture 4
Programming in C and Assembler
Ingo Sander ingo@kth.se
Outline
Programming in C ! Programming with the HAL Library
!
IL2206 Embedded Systems
Programming in C
The programming language C
C has been developed as a systems programming language around 1970 ! C is a sequential imperative language ! C is often viewed as a macro-assembler , since most C-statements can efficiently be mapped on the instruction set of a von Neumann processor ! Java has inherited the large parts of the Csyntax, but is a more abstract language
!
IL2206 Embedded Systems 4
The programming language C
!
C has been designed with respect to an efficient implementation, unnecessary features have been left out
!
! !
There is no Boolean variable, integers are used instead of True and False (0 is False, all other integers correspond to True) There is no garbage collection Programmer can access memory locations that are not declared ...
IL2206 Embedded Systems 5
The programming language C
The C-programmer has a huge responsibility! ! C-code can be very fast ! BUT it is easy to produce bugs, which are not caught by the compiler
!
! ! ! !
Memory leaks Accessing wrong memory locations Assignment instead of comparison ...
IL2206 Embedded Systems 6
Be extremely careful, when you program with C!
Many C-books in the library!
!
If you do not feel very comfortable with C!
There are many books on C in the library! ! The course page gives recommendations
!
IL2206 Embedded Systems
Data Structures in Memory
!
In order to design an efficient program it is often important to know how data structures are located in memory
!
Number of cache misses can often be reduced
IL2206 Embedded Systems
Arryas in memory
An array is located as a sequence in the memory int x = 5; int y = 6; int a[5];
!
0x80 0x84 0x88 0x8C 0x90 0x94 0x98 5 6 x y a[0] a[1] a[2] a[3] a[4]
IL2206 Embedded Systems
Pointers
!
A pointer holds an address in the memory
!
0x80 0x84 0x88 0x8C 0x90 0x94 0x98
5 6
x y a[0] a[1] a[2] a[3] a[4]
A pointer points to a variable
int int int int
x = 5; y = 6; a[5]; *intpointer;
intpointer
10
IL2206 Embedded Systems
Pointers
/* Point to x */ intpointer = &x; /* Set x to 0 */ *intpointer = 0;
0x80 0x84 0x88 0x8C 0x90 0x94 0x98 0 6 x y a[0] a[1] a[2] a[3] a[4]
0x80
IL2206 Embedded Systems
intpointer
11
Pointers and Arrays
An array is located as a sequence in the memory ! Pointers can be used to access array elements /* Point to first array element */ intpointer = a;
!
0x80 0x84 0x88 0x8C 0x90 0x94 0x98
0 6
x y a[0] a[1] a[2] a[3] a[4]
0x88
IL2206 Embedded Systems
intpointer
12
Pointers and Arrays
intpointer = a; is equivalent to intpointer = &a[0]; intpointer = a + 1; is equivalent to intpointer = &a[1];
!
0x80 0x84 0x88 0x8C 0x90 0x94 0x98
0 6
x y a[0] a[1] a[2] a[3] a[4]
Pointer is incremented the size of its datatype (here one word)
0x88
IL2206 Embedded Systems
intpointer
13
Pointers and Arrays
Multidimensional arrays are stored as a sequence of elements, where the rightmost subject (here the column) varies fastest #define ROW 2 #define COL 3 int a[ROW][COL]; ! Pointers can be used to access the array intpointer = a + 4; *intpointer = 27;
!
0x80 0x84 0x88 0x8C 0x90 0x94 0x98 27
a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2]
0x90
intpointer
14
IL2206 Embedded Systems
Refreshing C Bitwise Operators
! ! ! ! !
Bitwise complement (~) Bitwise and (&) Bitwise exclusive or (^) Bitwise inclusive or (|) Left shift (<<)
!
0s are shifted in for unsigned data types 0s are shifted in for signed data types the sign bit is shifted in
IL2206 Embedded Systems 15
Right shift (>>)
! !
Refreshing C
Relational, Equality and Logical Operators
Relational and Equality
! ! !
Logical
! ! !
! !
Less than (<) Greater than (>) Less than or equal (<=) Greater than or equal (>=) Equal to (==) Not equal to (!=)
Negation (!) Logical and (&&) Logical or (||)
IL2206 Embedded Systems
16
Storage Classes
!
A variable in C has two attributes:
! !
type (int, char, float, double, !) storage class (auto, extern, register, static)
IL2206 Embedded Systems
17
Storage Class auto
! !
Default storage class for variables declared in a function An automatic variable is only visible in the block it is declared in
!
System allocates memory when entering the block System releases the memory when leaving the block
!
Variable value is lost when leaving the block
int x; /* storage class extern */ int f(int x) { /* both a and b are */ /* of storage class auto */ int a; auto int b; /* a, b are visible here */ /* x is visible here */ } /* a, b are not visible here */ /* x is visible here */
18
IL2206 Embedded Systems
Storage Class extern
!
Default storage class for variables declared outside a function An extern variable is visible in the whole file after its declaration (global variable)
!
System allocates permanent storage for the variable
int x; /* storage class extern */ int f(int x) { /* both a and b are */ /* of storage class auto */ int a; auto int b; /* a, b are visible here */ /* x is visible here */ } /* a, b are not visible here */ /* x is visible here */
19
IL2206 Embedded Systems
The keyword extern
!
The keyword extern is used to tell the compiler to look for the variable or function elsewhere
! !
File1.c int a; File2.c int f(int x) { /* look for a outside */ /* this function */ extern int a; x = a; }
20
in another file in the same file (seldomly used)
Linkers task to combine the different object files to one executable
IL2206 Embedded Systems
Storage Class register
!
register storage class may only be declared inside functions Behaves in the same way as auto, but gives an additional recommendation to compiler that variable should be placed in register Compiler does not have to follow this advice
!
int f() { register int i; for(i=0; i < 1000; i++) a[i] = i; }
Number of registers is limited in CPU
IL2206 Embedded Systems
21
Storage Class static
!
In contrast to auto variables, static variables retain their values
!
permanent storage is assigned to the variable
int counter(void) { static int i = 0; i++; return i; }
IL2206 Embedded Systems
22
The type qualifier volatile
!
The type qualifier volatile indicates that a variable can be changed by other parts of the hardware in the system
!
Variable should not be put in register Variable can still be put in register or cache! Other directives (HAL functions) have to be used to avoid cache coherence problem
IL2206 Embedded Systems 23
Compiler may ignore volatile declaration
! !
More discussion in lecture on acceleration
If memory size is a constraint
!
Several small variables can be packed into a single variable
! ! !
Set of masks Bit-fields Unions
IL2206 Embedded Systems
24
If memory size is a constraint
Set of Masks #define FLAG1 1 #define FLAG2 2 #define FLAG3 4 char flags; /* contains all flags */ if ((flags & (FLAG1 | FLAG3)) == 0) /* True if both flags are 0 */
!
IL2206 Embedded Systems 25
If memory size is a constraint
!
A bit-field is a packed representation, where several small variables are integrated into one variable
struct myfield { unsigned var1 : 4; /* values from 0 to 15 */ int var2 : 3; /* values from -4 to 3 */ } x; x.var1 = 6;
Implementation of bit-field is machine dependent!
IL2206 Embedded Systems 26
If memory size is a constraint
! !
A union defines a set of alternative values that can be stored in the same portion of memory Programmer has responsibility to keep track of the data type stored in a union The size of the union corresponds to the largest data type
union int_or_float { int i; float f; } u;
IL2206 Embedded Systems
27
If memory size is a constraint
int main(void) { u.i = 0; printf("i: %10d f: %16.10e\n", u.i, u.f); u.i = 11; printf("i: %10d f: %16.10e\n", u.i, u.f); u.f = 11; printf("i: %10d f: %16.10e\n", u.i, u.f); return 0; } Output i: 0 f: 0.0000000000e+00 i: 11 f: 1.5414283108e-44 i: 1093664768 f: 1.1000000000e+01
IL2206 Embedded Systems 28
The sizeof operator
As discussed earlier the sizes of C-datatypes are not standardized ! The sizeof operator can be used to print the sizes of each type
!
printf("Size int*:%3u\n, sizeof(int*));
IL2206 Embedded Systems
29
The sizeof operator
!
Sizes of data types on teachers Linux machine
! ! ! ! ! ! !
char : 1 short : 2 int : 4 long : 8 float : 4 double: 8 int*: 8
(64 bit address space!)
IL2206 Embedded Systems
30
Many C-books in the library!
!
If you do not feel very comfortable with C! There are many books on C in the library!
IL2206 Embedded Systems
31
Nios II Programming with the HAL library
Busy Wait I/O
!
Busy Wait I/O is the most basic way to communicate with an I/O-device The processor wait until the I/ O-device has completed its current task Disadvantage: Processor cannot be used for other tasks during the waiting period! This method is also often called polling!
Example: Sending string via serial link
!
Busy Wait I/O Pseudo Code:
Characters = String; While not all characters sent Send next character; While Sender = Busy Wait; Done!
IL2206 Embedded Systems
33
C-Programming Testing of Bits
In order to test specific bits, it is needed to mask the other bits Example: ! Busy Flag: Busy = 1; Non-Busy = 0
!
7 0x1000 0x1001
IL2206 Embedded Systems
5 BF
0 Status Sender Sender Buffer
34
C-Programming Testing of Bits
define Status 0x1000 define Sender 0x1001 char *myString = Hello World; char *current_char;
7 0x1000 0x1001
IL2206 Embedded Systems
5 BF
0 Status Sender Sender Buffer
35
Accessing Memory Locations in C
Symbolic names can be defined for memory locations #define MEM_LOCATION 0x18 ! Functions can be defined to access memory
!
peek can be used to read a memory location (byte) char peek(char *location) {return *location;} ! poke can be used to write to a memory location (byte) void poke(char *location, char newval) {*location = newval;}
!
IL2206 Embedded Systems 36
Accessing Memory Locations in C
Symbolic names can be defined for memory locations #define MEM_LOCATION 0x18 ! Functions can be defined to access memory
!
!
peek can be used to read a memory location (byte) char peek(char *location) Altera provides the {return *location;} HAL library that abstracts from the underlying location (byte) ! poke can be used to write to a memoryhardware! void poke(char *location, char newval) {*location = newval;}
IL2206 Embedded Systems 37
Dont do this!
C-Programming Testing of Bits
Here you should use HAL functions!
while (current_char != \0) { poke(Sender, *current_char++); while ((peek(Status) & 0x20) != 0) ; } /* Mask needed, since other bits */ /* in status register may not be zero */
7 0x1000 0x1001
IL2206 Embedded Systems
5 BF
0 Status Sender Sender Buffer
38
Memory Locations shouldnt be accessed directly!
!
Software shall be flexible
!
Hardware could change
Programmers may make mistakes that the compiler would not do (e.g. memory alignment) HAL (Hardware Abstraction Layer) offers optimized device drivers to access peripheral devices and memory
IL2206 Embedded Systems 39
Customizing a Nios II Core The Tool SOPC Builder
!
Designer can select and configure
! !
CPU(s) peripherals
SOPC builder creates core that can be instantiated on FPGA
Symbolic names are accessible for software designers!
IL2206 Embedded Systems
40
The role of the HAL in a Nios II project
Your program uses the symbolic addresses and values specified in SOPC builder
Reference: Nios II Software Developers Handbook, Chapter 6
IL2206 Embedded Systems 41
The role of the HAL in a Nios II project
Your program uses the symbolic addresses and values specified in SOPC builder
Reference: Nios II Software Developers Handbook, Chapter 6
IL2206 Embedded Systems 42
The system.h file
The system.h file provides a complete software description of the Nios II system hardware ! The system.h file reflects the actual Nios II hardware, which is given by the *.ptf file. ! A new core means a new *.ptf file and a new system.h file
!
IL2206 Embedded Systems
43
The system.h file
!
The system.h file describes each peripheral and provides the following details:
! ! ! !
The hardware configuration of the peripheral The base address The IRQ (interrupt request) priority A symbolic name for the peripheral
If the hardware changes, the source code is still valid, since it uses another correct system.h file
NEVER edit the system.h file!!!
IL2206 Embedded Systems 44
Example of a system.h file
/* * system configuration * */ #define #define #define #define #define #define #define #define #define #define ALT_SYSTEM_NAME "std_2s60ES" ALT_CPU_NAME "cpu" ALT_CPU_ARCHITECTURE "altera_nios2" ALT_DEVICE_FAMILY "STRATIXII" ALTERA_NIOS_DEV_BOARD_STRATIX_2S60_ES ALT_STDIN "/dev/jtag_uart" ALT_STDOUT "/dev/jtag_uart" ALT_STDERR "/dev/jtag_uart" ALT_CPU_FREQ 50000000 ALT_IRQ_BASE NULL
IL2206 Embedded Systems 45
Example of a system.h file
/* * processor configuration * */ #define NIOS2_CPU_IMPLEMENTATION "fast" #define NIOS2_ICACHE_SIZE 4096 #define NIOS2_DCACHE_SIZE 2048 #define NIOS2_ICACHE_LINE_SIZE 32 #define NIOS2_ICACHE_LINE_SIZE_LOG2 5 #define NIOS2_DCACHE_LINE_SIZE 4 #define NIOS2_DCACHE_LINE_SIZE_LOG2 2 #define NIOS2_FLUSHDA_SUPPORTED #define NIOS2_EXCEPTION_ADDR 0x01000020 #define NIOS2_RESET_ADDR 0x00000000 #define NIOS2_HAS_DEBUG_STUB #define NIOS2_CPU_ID_SIZE 1 #define NIOS2_CPU_ID_VALUE 0
IL2206 Embedded Systems 46
Example of a system.h file
/* * uart1 configuration * */ #define #define #define #define #define #define #define #define #define #define #define #define #define #define UART1_NAME "/dev/uart1" UART1_TYPE "altera_avalon_uart" UART1_BASE 0x02120840 UART1_IRQ 4 UART1_BAUD 115200 UART1_DATA_BITS 8 UART1_FIXED_BAUD 1 UART1_PARITY 'N' UART1_STOP_BITS 1 UART1_USE_CTS_RTS 0 UART1_USE_EOP_REGISTER 0 UART1_SIM_TRUE_BAUD 0 UART1_SIM_CHAR_STREAM "" UART1_FREQ 50000000
IL2206 Embedded Systems 47
Example of a system.h file
/* * button_pio configuration * */ #define #define #define #define #define #define #define #define #define #define #define #define #define BUTTON_PIO_NAME "/dev/button_pio" BUTTON_PIO_TYPE "altera_avalon_pio" BUTTON_PIO_BASE 0x02120860 BUTTON_PIO_IRQ 2 BUTTON_PIO_HAS_TRI 0 BUTTON_PIO_HAS_OUT 0 BUTTON_PIO_HAS_IN 1 BUTTON_PIO_CAPTURE 1 BUTTON_PIO_EDGE_TYPE "ANY" BUTTON_PIO_IRQ_TYPE "EDGE" BUTTON_PIO_DO_TEST_BENCH_WIRING 1 BUTTON_PIO_DRIVEN_SIM_VALUE 0x000F BUTTON_PIO_FREQ 50000000
IL2206 Embedded Systems 48
Example: Using the HAL
!
The Parallel I/O devices can be accessed by functions that are defined in altera_avalon_pio_regs. These functions use only symbolic addresses!
#include "system.h" #include "altera_avalon_pio_regs.h" int buttons_pressed(void) { return IORD_ALTERA_AVALON_PIO_DATA(BUTTON_PIO_BASE); } void show_number_on_leds(int x) { IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE, x); }
IL2206 Embedded Systems 49
C-Programming Testing of Bits (revisited)
HAL functions used
while (current_char != \0) { IOWR_ALTERA_AVALON_PIO_DATA(SEND_BUF_BASE, current_char); while (IORD_ALTERA_AVALON_PIO_DATA(SEND_STATUS_BASE) & 0x20) != 0) ; } /* Mask needed, since other bits */ /* in status register may not be zero */
7 0x1000 0x1001
5 BF
0 Status Sender Sender Buffer
IL2206 Embedded Systems
50
Programming Interrupt
Foreground Program
Do something! Interrupt Event
!
Interrupt Handler
! ! ! ! !
Save Registers Handle Interrupt Restore Registers Restore PC Clear interrupt disable flag
Interrupt Vector
!
Branch to Interrupt Handler
IL2206 Embedded Systems 51
Registering an ISR with alt_irq_register()
The HAL registers this function pointer in a lookup table. When a specific IRQ occurs, the HAL looks up the IRQ in the lookup table and dispatches the registered ISR. ! The prototype for alt_irq_register() is:
!
int alt_irq_register (alt_u32 id, void* context, void (*isr)(void*, alt_u32));
Read the Altera documentation: Nios II Software Developers Handbook
IL2206 Embedded Systems 52
Registering an ISR with alt_irq_register()
!
The prototype has the following parameters: ! id is the hardware interrupt number for the device, as defined in system.h. Interrupt priority corresponds inversely to the IRQ number. Therefore, IRQ 0 represents the highest priority interrupt and IRQ 31 is the lowest. ! context is a pointer used to pass context-specific information to the ISR, and can point to any sort of ISR-specific information. The context value is opaque to the HAL; it is provided entirely for the benefit of the user-defined ISR ! isr is the function that is called in response to IRQ number id. The two input arguments provided to this function are the context pointer and id. Registering a null pointer for isr results in the interrupt being disabled ! If your ISR is successfully registered, the associated interrupt (as defined by id) is enabled on return from alt_irq_register()
IL2206 Embedded Systems 53
An ISR to service a Button PIO IRQ
#include "system.h" #include "altera_avalon_pio_regs.h" #include "alt_types.h" static void handle_button_interrupts(void* context, alt_u32 id) { /* cast the context pointer to an integer pointer. */ volatile int* edge_capture_ptr = (volatile int*) context; /* * Read the edge capture register on the button PIO. * Store value. */ *edge_capture_ptr = 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); }
IL2206 Embedded Systems 54
Registering the Button PIO ISR with the HAL
#include "sys/alt_irq.h" #include "system.h" ... /* Declare a global variable to hold the edge capture value. */ volatile int edge_capture; ... /* Register the interrupt handler. */ alt_irq_register(BUTTON_PIO_IRQ, (void*) &edge_capture, handle_button_interrupts);
IL2206 Embedded Systems
55
What happens?
!
1. 2.
Based on this code, the following execution flow is possible:
Button is pressed, generating an IRQ. The HAL exception handler is invoked and dispatches the handle_button_interrupts () ISR. handle_button_interrupts() services the interrupt and returns. Normal program operation continues with an updated value of edge_capture.
IL2206 Embedded Systems 56
3. 4.
Application Binary Interface
!
The Application Binary Interface describes
! ! !
How data is arranged in memory Behavior and structure of the stack Function calling conventions
The ABI is very important when C/C++ and Assembler interact
Reference: Nios II Processor Handbook, Chapter 7
IL2206 Embedded Systems
57
Representation of Data Types
IL2206 Embedded Systems
58
HAL Standard C Data Types
! !
To increase portability the following HAL standard data types are defined There is no defined size for C-data types in ANSI C
!
An int reflect usually the natural size of integers on the host machine (Kernighan and Ritchie, 1988)
IL2206 Embedded Systems
59
Minimizing Code Size
!
Minimize the design costs
!
have always the hardware implementation in mind
! !
an int requires 4 bytes, a char only 1 byte if only values between 0 and 10 are needed use a char (or even better the corresponding Altera type)
Think Hardware!
IL2206 Embedded Systems 60
Memory Alignment
!
Contents in memory are aligned as follows:
! !
! !
A function must be aligned to a minimum of 32-bit boundary. The minimum alignment of a data element is its natural size. A data element larger than 32-bits need only be aligned to a 32-bit boundary. Structures, unions, and strings must be aligned to a minimum of 32 bits. Bit-fields inside structures are always 32-bit aligned.
IL2206 Embedded Systems 61
Memory Alignment
0x00 0x04 0x08 0x0C 0x10 0x14
Byte Byte Short Short int int Byte Byte Short Short Byte
IL2206 Embedded Systems
62
Register Usage
!
The ABI defines how the C compiler uses registers. If C and Assembler shall work together the ABI must be followed:
IL2206 Embedded Systems
63
Register Usage
!
It is the responsibility of the calling function to save the following registers, the called function may freely use these registers without saving them on the stack:
IL2206 Embedded Systems
64
Register Usage
!
If the called function wants to use the following registers, it has to save them on the stack first
IL2206 Embedded Systems
65
Register Usage
!
There are many other important registers, like the stack pointer, and the return address
IL2206 Embedded Systems
66
Register Usage Stack
! ! !
The stack grows downwards (i.e. to lower addresses) The stack pointer points to the last used slot The frame pointer points usually to the same location as the stack pointer
IL2206 Embedded Systems
67
Writing an assembler function called from C
!
The following has to be written in an assembler function that is called from C
Save stack & framepointer on stack Save return address (r31) on stack Save callee-saved registers that are used in the function Save stack-space for temporary variable ... Move return value into return registers (r2 and r3) Restore callee-saved registers Restore return address (r31) Restore stack and frame pointer
This applies for functions with not more than four 32-bit arguments
IL2206 Embedded Systems 68
C and Assembler A small example (Main.c)
#include <stdio.h> extern int addSub(int, int, int); int main() { int mode, a, b, result; while(1 < 2) { printf("Enter Mode (0 = Sub, 1 = Plus): "); scanf("%d", &mode); printf("Enter two numbers: "); scanf("%d %d", &a, &b); result = addSub(mode, a, b); if(mode == 0) printf("The difference is %d\n", result); else printf("The sum is %d\n", result); } return 0; }
IL2206 Embedded Systems 69
Message to the Linker: External Function
C and Assembler A small example (AddSub.s)
.global addSub .text addSub:
addSub shall be visible outside this function
# # # # # # # # # # Parameter r2: Return Value r4: Mode r5: a r6: b if mode is 0 -> Plus result = a - b goto end of subroutine result = a + b return from subroutine
beq sub br Plus: add Back: ret
!
r4, r0, Plus r2, r5, r6 Back r2, r5, r6
Note: No need to save stack pointer or callee-saved registers (not used) or return address (leaf function, it does not call other functions)
IL2206 Embedded Systems
70
Summary
Good understanding of underlying hardware is critical for design of efficient software ! HAL library provides abstraction from hardware and allows fast adaptation to changes in hardware ! Application Binary Interface defines a standard for communication between C- and Assembler parts
!
IL2206 Embedded Systems 71
