C from hello world to 010101

By : BELLAJ BADR
Fouder of Raspberry pi Moroccan community

*C in Raspberry Pi
*How a C program is executed
*Hellow world in assembly
*Build your own OS « Hello world OS »
*

** in 1971-73 Dennis M. Ritchie turned
the B language into the C language,
keeping most of the language B syntax
while adding data-types and many
other changes

*
the most famous example program from the book is its "hello,
world" program, which just prints out the text "hello, world" to
the terminal, as an illustration of a minimal working C
program. Numerous texts since then have followed that
convention for introducing a programming language.
*in 1978 the publication of ”The C Programming
Language” by Kernighan & Ritchie caused a revolution
in the computing world.

*
#include <stdio.h>
int main(void){
printf("My first C programn");
return 0;
}

*
*Compiled language
*Interpreted language
*P-code language

*
*gcc hello.c
=>your code has been compiled into a separate
executable file which by default is named
as a.out
*To execute program first, enter: ./first

*
*The compilation is performed in four sequential phases
by the compilation system (a collection of four
programs preprocessor,compiler, assembler, and
linker).
* we could use the commands as (assembler), ld (link
loader), and gdb (GNU debugger) from GCC(GNU
Compiler Collection) .
*C code=> assembly code=>object file=>executable

*To get the assembly code from our C code we
use the « Gcc –s » command :
1
2
3
# gcc -S hello.c -o hello.s
# cat hello.s

*
1
2
3
# gcc -c hello.s -o hello.o
# file hello.o
hello.o: ELF 32-bit ,,,,,,,,,,,,
1
2
8 # readelf -a hello.o
We can see that the hello.o is the object file that is actually an ELF 32-bit
executable, which is not linked yet. If we want to run the executable, it will
fail as noted below:
We can read the contents of the object file with the readelf program
as follows

*
*# chmod +x hello.o
*# ./hello.o
*bash: ./hello.o: cannot execute binary file =>
we need to link it

*
*Generic ELF File Layout : A simple Executable
ARM ELF file has the conceptual layout shown
in the diagram on the right.

*
we want to build object code for the ARM processor at the heart of the
Raspberry Pi, we need a cross-compiler and its associated tools, which
is usually called a "toolchain". Here we are using "crosstool-ng" to build
such tool chain.
arm - non e - eabi - gcc

*To understand the C compilation let’s look at
the ARM assembly language

*
In this lab, you will learn to write ARM assembly language
programs and test them on a Raspberry Pi, featuring the BCM2835
microprocessor
Rpi < 2 only support armv6 instructions
While RPI 2 support armv7 instructions

*all ARM instructions are 32 bits long. Here is a
typical one:
*10101011100101010010100111101011
*Fortunately, we don't have to write ARM
programs using such codes. Instead we use
assembly language

http://goo.gl/EVrLl0

*
Registres particuliers
r13 alias sp : stack pointer pointeur sur pile de
donnees
● r14 alias lr : lr stands for link register and it
is the address of the instruction following the
instruction that called us(return)
● r15 alias pc : program counter contains the
address of the next instruction going to be
executed
When the ARM processor
executes an instruction,
two things may happen at
the end of its execution. If
the instruction does not
modify pc (and most
instructions do not), pc is
just incremented by 4 (like
if we did add pc, pc, #4).
Why 4? Because in
ARM, instructions are 32
bit wide, so there are 4
bytes between every
instruction. If the
instruction modifies pc
then the new value for pc
is used
Once the processor has fully executed an instruction then it
uses the value in the pc as the address for the next instruction
to execute,This process of changing the value of pc is called
branching. In ARM this done using branch instructions.

cpsr (for Current Program Status
Register) keeps some values that can be read and updated
when executing an instruction
cmp r1, r2 /* updates cpsr doing "r1 ‐ r2", but r1 and r2
are not modified */
EQ (equal) When Z is enabled (Z is 1)
NEQ (not equal). When Z is disabled. (Z is 0)
[r1, +#12] => an offset of 12
(4 bytes * 3 items
skipped).

*
*Exemple d'instruction : addition
ADD r0,r1,r2 @ r0<-r1+r2
ADD r0,r0,#4 @ r0<-r0+4
SUB,
*L'instruction de ''mouvement'' de donnee
MOV rd,<Oprnd2> @ rd <- Oprnd2
*load : Memory =>registre
*store : registre=>memory
*.INCLUDE "fichier.s"

*Le format des instructions ARM est fixe :
*Une instruction fait 4 octets (32 bits)

*Exemple de codage d'une instruction :
*MOV r5,#7 @ Instruction Assembleur
*0b11100011101000000101000000000111
*=0xE3A05007 ( code langage machine)

*
*MOV r5,#7
*● Execution inconditionnelles : Always
->1110
*● Puis specification de famille d'operation
*( Data-processing : MOV, ADD, CMP ...)
->111000
*● Puis indicateur d'operande immediat (I)
->1110001

MOV r5,#7
*● C'est une operation Move =>Opcode
*->11100011101
*● Puis indicateur ''pas de mise a jour
*des codes conditions'' (pas de S en suffixe)
*->111000111010
*● MOV : pas de 1er operande (Rn a 0)
*->1110001110100000
*● Registre destination R5 (Rd code pour 5)
*->11100011101000000101
*Format immediat : constante 8 bits et rotation
*constante = 0b00000111(binaire)=7décimal
*● Pas besoin de deplacer la constante 8 bits
*pour obtenir la valeur immediate (rotation 0)
*->111000111010000001010000
*● Constante 8 bits
*->11100011101000000101000000000111

*
*MOV r5,#7
*0b1110001110100000010
1000000000111
*=0xE3A05007

.data
msg:
.ascii "Hello, Piday!n"
len = . ‐ msg
.text
.globl _start
_start:
/* syscall write(int fd, const void *buf, size_t count) needs 3 argument*/
mov %r0, $1 /* fd ‐> stdout standard output*/
ldr %r1, =msg /* buf ‐> msg */
ldr %r2, =len /* count ‐> len(msg) */
mov %r7, $4 /* write is syscall #4 */
swi $0 /* invoke syscall */
/* syscall exit(int status) */
mov %r0, $0 /* status ‐> 0 */
mov %r7, $1 /* exit is syscall #1 */
swi $0 /* invoke syscall */
The C function s, including the ISO C
standard ones, are widely used by
programs, and are regarded as if they
were not only an implementation of
something in the C language, but also
de fact o part of the operating system
interface.=> glibc
Making call using C lib
it is rather unusual to perform system calls directly.
It is almost always preferable to call the C library
instead.
*

*To terminate a program
*MOV R7, #1
*SVC 0 6 of 23
*The number 1 placed in Register 7 tells the operating system
to terminate this program. The instruction “SVC 0” is the
system call, that transfers the program execution to the
operating system. If you place a different number in R7, the
operating system will perform a difference service.
on ARM, the system call identifier is put in register R7, arguments are passed in
R0R6 (respecting “EABI arrangement” where appropriate,i.e. 64bit arguments),
and the kernel is called with the ‘SWI 0’ instruction.

Now, coming to Raspberry Pi, which is a Broadcom SOC,BCM 2835,based on ARM
Processor. Every System Call is Index in the System Call Table. The Index is an
Integer value which is passed to the Register R7, in case Platform. The
registers, R0, R1 and R2 are used to pass the arguments of the System Call. The
instruction, SWI, now being used as SVC, which is a Supervisor Call, used to
jump to the Privileged Mode, to invoke the Kernel. The embedded with SVC
#num, is used to refer to the Handler.
svc #0
Hence, as an example, say, we want to invoke a System Call to print "Hello
Worldn". The System Call Index 'Write' is #4. Thus, the code will be something
like,

*
In Linux ARM we can perform a system call by using the
instruction swi. This instruction means software
interruption and its sole purpose is to make a system
call to the operating system.
Linux we will always use swi #0 to perform a system call.
No system call in Linux receives
more than 7 arguments and the arguments
are passed in registers r0 to r6. If the
system call returns some value it will be
returned in register r0.

Hello world, the system call way
As a simple illustration of calling the operating system we
will write the archetypical “Hello world” program using
system calls. In this case we will call the function write.
Write receives three parameters: a file descriptor where we
will write some data, a pointer to the data that will be
written and the size of such data. Of these three, the most
obscure may be now the file descriptor. Without entering
into much details, it is just a number that identifies a file
assigned to the process. Processes usually start with three
preassigned files: the standard input, with the number 0,
the standard output, with the number 1, and the standard
error, with the number 2. We will write our messages to the
standard output, so we will use the file descriptor 1.

.arch armv6
.section .rodata
.align 2
.data
HelloWorldString:
.ascii "Hello Worldn"
.LC0:
.text
.align 2
.global main
.type main, %function
main:
mov r7, #4
mov r0, #1
ldr r1,=HelloWorldString
mov r2, #12
svc #0
@ Need to exit the program
mov r7, #1
mov r0, #0
svc #0
.L3:
.align 3
.L2:
.size main, .main
.ident "GCC: (Debian 4.6.314+
rpi1) 4.6.3"
.section .note.GNUstack,"",%
progbits
Compile and run , ./program
Now, check 'dmesg' using,
#dmesg | tail

Write assembly in .s file
As ‐o hello.o hello.S (output object file from
assembly file)
Ld ‐s ‐o hello hello.o (output exeutable file) gcc ‐o hello hello.o
*Linker: Finally, the linker ﴾ld/ld.exe﴿ links the object code with the
library code to produce an executable file « hello/hello.exe".
*> ld ‐o hello.exe hello.o ...libraries...

*
"ldd" Utility ‐ List Dynamic‐Link Libraries
The utility "ldd" examines an executable and displays a list of the
shared libraries that it needs. For example,
> ldd hello.exe
ntdll.dll => /cygdrive/c/Windows/SYSTEM32/ntdll.dll (0x77bd0000)
kernel32.dll => /cygdrive/c/Windows/system32/kernel32.dll
(0x77600000)
KERNELBASE.dll => /cygdrive/c/Windows/system32/KERNELBASE.dll
(0x75fa0000)

Gdb Debugger
>> gdb hello
>> gdb start
>> gdb disassemble
*Debugging :
* as gstabs o filename.o filename.s =>get assambly
* If you want to use gdb, you need to invoke the
assembler with some additional options.
* When gdb starts, we need to set a breakpoint.
* The execution of the program will stop there and
we can step forwards one instruction at a time
from
* that point. Here, I am setting the breakpoint
* at the _start label.
* (gdb) break *_start
* (gdb) run
* (gdb) info rgisters
* GDB has the ability of disassembling the machine
code back to assembly instructions. The command
is “disassemble”.
Gdb layout asm
Gdb si (stepinto)
* To start the program, use command “run”*

*
*Install Code::Blocks IDE
*To install Code::Blocks IDE, use the following
command at the command prompt and all the
required software will be installed.
*$ sudo apt-get install codeblocks

*The assembly code generated from the C code
is different from the basic Assembly code.s
A compiler has to produce working machine code for
the infinite number of programs that can be
written in the language it compiles. It is impossible
to ensure that all possible highlevel Instructions are
translated in the optimum way;
Call assembly into C

*
How a Raspberr y-Pi processor boots. The BCM2385 includes a GPU
and this GPU includes a
bootloader . The bootloader is capabable of reading the contents of
a FAT32 partition on an SD card and booting fr om
the kernel .img file contained on it. This kernel.img file is an ARM
executable, and is generally the linux kernel . All we need to do is
generate our executable and replace the kernel .img file on the SD
card with our file to execute it.
The first thing we will need to setup is the GPIO controller.
There are no drivers we can rely on as there is no OS
running, all the bootloader has done is boot the processor
into a working state, ready to start loading the OS.

*Now that you have extracted the template, create a new file
in the 'source' directory called 'main.s'. This file will contain
the code for this operating system. To be explicit, the folder
structure should look like:
*build/ (empty)
* source/
main.s
*kernel.ld
*LICENSE
*Makefile
Open 'main.s' in a text editor so that we
can begin typing assembly code. The
Raspberry Pi uses a variety of assembly
code called ARMv6, so that is what we'll
need to write in.
Copy in these first commands.
.section .init
.globl _start
_start:
*

*This will turn on
the LED and blink
To install your operating system, first of all get a Raspberry PI SD
card which has an operating system installed already. If you browse
the files in the SD card, you should see one called kernel.img.
Rename this file to something else, such as kernel_linux.img. Then,
copy the file kernel.img that make generated onto the SD Card.
You've just replaced the existing operating system with your own. To
switch back, simply delete your kernel.img file, and rename the
other one back to kernel.img. I find it is always helpful to keep a
backup of you original Raspberry Pi operating system, in case you
need it again.

BareMetal OS, a 64-bit operating system written entirely in
assembly.
APOTHEMEOS A Small Assembly Opensource Os.

*
*Cambridge tutorials by lighting the OK LED
on the Raspberry-Pi board.
*Any request : Bellaj1@gmail.com

C from hello world to 010101

More Related Content

What's hot (20)

Similar to C from hello world to 010101 (20)

More from Bellaj Badr (14)

Recently uploaded (20)

C from hello world to 010101

Editor's Notes