【CSS422】Programming Language Design

本文介绍: •••••#include#include// signal#include// alarm#include// printfintalarmed;voidintsignum) {voidintsignum) {intmain( ) {charstringA[40] =;charstringB[40];printf(“%sn”

CSS422 Final Project

Thumb-2 Implementation Work of Memory/Time-Related C Standard Library Functions.

1. Objective

You’ll understand the following concepts at the ARM assembly language level through this final project

that implements memory/time-related C standard library functions in Thumb-2.

•
CPU operating modes: user and supervisor modes

•
System-call and interrupt handling procedures

•
C to assembler argument passing (APCS: ARM Procedure Call Standard)

•
Stack operations to implement recursions at the assembly language level

•
Buddy memory allocation

This document is quite dense. Please read it as soon as the final project spec. becomes available to you.

2. Project Overview

Using the Thumb-2 assembly language, you will implement several functions of the C standard library that

will be invoked from a C program named driver.c. See Table 1. These functions must be code in the Thumb-

2 assembly language. Some of them can be implemented in stdlib.s running in the unprivileged thread mode

(=user mode), whereas the others need to be implemented as supervisor calls, (i.e., in the handler mode =

supervisor mode). For more details, log in one of the CSS Linux servers and type from the Linux shell:

man 3 function

where function is either bezro, strncpy, malloc, free, signal, or alarm

The driver.c we use is shown in listing 1. It tests all the above six stdlib functions. Please note that printf()

in the code will be removed when you test your assembly implementation, because we won’t implement

the printf( ) standard function.

Listing 1: driver.c program to test your implementation

#include
<strings.h>
// bzero, strncpy

#include
<stdlib.h>
// malloc, free

#include
<signal.h>
// signal

#include
<unistd.h>
// alarm

#include
<stdio.h>
// printf

int
*
alarmed
;

void
sig_handler1
(
int
signum
) {

*alarmed = 2;

}

void
sig_handler2
(
int
signum
) {

*alarmed = 3;

}

int
main
( ) {

char
stringA
[40] =
“0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabc”
;

char
stringB
[40];

bzero( stringB, 40 );

strncpy( stringB, stringA, 40 );

bzero( stringA, 40 );

printf(
“%sn”
, stringA );

printf(
“%sn”
, stringB );

void
*
mem1
= malloc( 1024 );

void
*
mem2
= malloc( 1024 );

void
*
mem3
= malloc( 8192 );

void
*
mem4
= malloc( 4096 );

void
*
mem5
= malloc( 512 );

void
*
mem6
= malloc( 1024 );

void
*
mem7
= malloc( 512 );

free( mem6 );

free( mem5 );

free( mem1 );

free( mem7 );

free( mem2 );

void
*
mem8
= malloc( 4096 );

free( mem4 );

free( mem3 );

free( mem8 );

alarmed = (
int
*)malloc( 4 );

*alarmed = 1;

printf(
“%dn”
, *alarmed);

signal( SIGALRM, sig_handler1 );

alarm( 2 );

while
( *alarmed != 2 ) {

void
*
mem9
= malloc( 4 );

free( mem9 );

}

printf(
“%dn”
, *alarmed);

signal( SIGALRM, sig_handler2 );

alarm( 3 );

while
( *alarmed != 3 ) {

void
*
mem9
= malloc( 4 );

free( mem9 );

}

printf(
“%dn”
, *alarmed);

return
0;

}

This driver program repeats allocating and deallocating memory space and thereafter sets the sig_handler1(

) function to be called upon receiving the first timer interrupt (in 2 seconds) and sig_ahndler2( ) function to

be called upon the second timer interrupt (in 3 seconds).

3. System Overview and Execution Sequence

3.1. Memory overview

This project maps all code to 0x0000.0000 – 0x1FFF.FFFF in the ARM’s usual ROM space (as the Keil C

compiler/ARM assembler does) and defines a heap space; user and SVC stacks; memory control block

(MCB) to manage the heap space; and all the SVC-related parameters over 0x2000.1000 – 0x2000.7FFF

in the ARM’s usual SRAM space. See table 2.

Listing 2: The memory space definition in Thumb-2

Heap_Size

EQU 0x00005000

AREA HEAP, NOINIT, READWRITE, ALIGN=3

__heap_base

Heap_Mem

SPACE Heap_Size

__heap_limit

Handler_Stack_Size

EQU

0x00000800

Thread_Stack_Size

EQU

0x00000800

AREA

STACK, NOINIT, READWRITE, ALIGN=3

Thread_Stack_Mem

SPACE Thread_Stack_Size

__initial_user_sp

Handler_Stack_Mem

SPACE Handler_Stack_Size

__initial_sp

3.2. Initialization, system call, and interrupt sequences

(1)
Initialization:
the ARM processor reads the first 8 bytes to set MSP and the next 8 bytes to jump

to the Reset_Handler routine (as you studied in the class). You don’t have to change the original

vector table. Reset_Handler initializes all the data structures you’ve developed and finally calls

__main with listing 3.

Listing 3: The last two instructions in Reset_Handler (startup_TM4C129.s)

LDR R0, =__main

BX R0

These last two statements are from the original startup_TM4C129.s. Then, the main( ) function in

driver.c is invoked.

(2)
System calls:
whenever main( ) calls any of stdlib functions including bzero, strncpy, malloc, free,

signal, and alarm, the control needs to move to strlib.s. In other words, you need to define these

function protocols in strlib.s, as shown in listing 4:

Listing 4: The framework of stdlib.s

AREA

|.text|, CODE, READONLY, ALIGN=2

THUMB

EXPORT _bzero

_bzero

; Implement the body of bzero( )

MOV