int gcd(int a[5], int b[5]) {
  int i, m, n, max;
  max = 0;
  for (i=0; i<5; i++) {
    m = a[i];
    n = b[i];
    while (m != n) {
      if (m > n) m = m - n;
      else n = n - m;
    }
    if (max < m) max = m;
  }
  return max;
}
int a[] = {26, 3,33,56,11};
int b[] = {87,12,23,45,17};
int main() {
  return gcd(a, b);
}

Schaumont, Listing 7.1 - A C program to find a maximum GCD

Schaumont, Figure 7.2 - Elements of an assembly program produced by gcc

Schaumont, Listing 7.2 - ARM assembly dump of Listing 7.1

data type representation is a good starting point, compilers are aware of differences in:

• memory size
• low-level implementation of operations

table 7.1 shows how C maps to the native data types supported by 32-bit processors

Schaumont, Table 7.1 - Compiler data types

Schaumont, Figure 7.7 (a) - Alignment of data types

word-based memory organization requires alignment to word boundaries, to perform a word transfer by a single memory access

• the compiler generates directives to this purpose

Schaumont, Figure 7.7 (b) - Little-endian and Big-endian storage order

byte ordering, in some cases even the bit-ordering, is relevant to hardware/software codesign

• in the transition of software to hardware and back

Schaumont, Figure 7.8 - Memory hierarchy

memory hierarchy is transparent to high-level programs, e.g. written in C, yet the low-level control affects performance; here is an example:

void accumulate(int *c, int a[10]) {
  int i;
  *c = 0;
  for (i=0; i<10; i++) *c += a[i];
}

/usr/local/arm/bin/arm-linux-gcc -O2 -c -S accumulate.c

generates the following code in accumulate.s :

in the example, the value of the accumulator variable travels up and down in the memory hierarchy

• in C a limited control is available through use of storage class specifiers and type qualifiers

function calls are the fundamental structure of behavioural hierarchy of programs; here is an example of their translation to machine language

int accumulate(int a[10]) {
  int i;
  int c = 0;
  for (i=0; i<10; i++)
    c += a[i];
  return c;
}
int a[10];
int one = 1;
int main() {
  return one + accumulate(a);
}

Schaumont, Listing 7.4 - Sample program

compiling this program without optimization shows the creation of the activation frame within the stack, that is dynamically associated to the function execution to host local variables and register saving

• in this case, the function parameter and return value are passed in register r0; when several parameters are to be passed, then the activation frame is made use of

the use of the frame pointer (FP) register enables call nesting and recursion

Schaumont, Listing 7.6 - Accumulate without compiler optimizations

Schaumont, Figure 7.9 - Stack frame construction

Schaumont, Figure 7.10 - Static and dynamic program layout