How-To Find the Source of "Unaligned Access"

 

 

How-To Find the Source of "Unaligned Access"

---

The memory bus on a computer varies in width based on the memory architeture of the computer. A 32-bit computer has a bus that is wide enough for 32 bits to be read from the bus at once. A 64-bit computer has a bus wide enough for 64 bits. The computer wants values to be stored in memory to make the most efficient use of the memory bus, which means that it should require the smallest number of read operations to pull a value (or series of values) off of the bus.

To satisfy this goal, an int should be aligned along a 4-byte boundary, so that one can be read from the bus with one read on a 32-bit system or two can be read from the bus on a 64-bit system. Shorts should be aligned along 2-byte boundaries. Chars can show up anywhere. And pointers should be aligned along the boundary indicated by the width of the memory bus (a 4-byte boundary for a 32-bit system and 8-byte for a 64-bit system).

The compiler will structure your program in memory as necessary to ensure that variables are properly aligned. However, a programming error can still result in a variable becoming misaligned. The two most common causes of this are using invalid pointer values (e.g. dereferencing an uninitialized pointer) and casting a pointer into a pointer of a larger type (e.g. casting a char pointer into an int pointer).

Here is some code that intentionally casts pointers in order to generate unaligned access errors:

    #include 

    int main ( )
    {
        char *data;
        short *sp1, *sp2;
        int *ip;
        data = (char *)malloc(16);;
        sp1 = (short*)(data+3);
        sp2 = (short*)(data+5);
        ip = (int*)(data+7);
        *sp1=10;
        *sp2=20;
        *ip=30;
        fprintf(stderr, "%d %d %d/n", *sp1, *sp2, *ip);
        return 0;
    }

When this program is compiled with the system compiler on ice (a 64-bit alpha system), running it will produce a series of unaligned access error messages.

    $ cc -g -o test_unaligned test_unaligned.c
    $ ./test_unaligned
    Unaligned access pid=16238  va=0x140002101 pc=0x1200011c4 ra=0x120001190 inst=0xa1060000
    Unaligned access pid=16238  va=0x140002101 pc=0x1200011d4 ra=0x120001190 inst=0xb1060000
    Unaligned access pid=16238  va=0x140002105 pc=0x1200011e8 ra=0x120001190 inst=0xa2b30000
    Unaligned access pid=16238  va=0x140002105 pc=0x1200011f8 ra=0x120001190 inst=0xb2b30000
    Unaligned access pid=16238  va=0x140002107 pc=0x120001204 ra=0x120001190 inst=0xb2f80000
    Unaligned access pid=16238  va=0x140002101 pc=0x12000121c ra=0x2 inst=0xa77b0000
    Unaligned access pid=16238  va=0x140002101 pc=0x120001238 ra=0x4 inst=0xa4210000
    Unaligned access pid=16238  va=0x140002107 pc=0x120001250 ra=0x4 inst=0xa2940000
    10 20 30

The pc value in the unaligned access error line indicates the address of the program code that generated the error. Using gdb, it is possible to figure out which line of code the pc address is associated with (assuming that the program was compiled with the -g flag, as in the example).

    $ gdb test_unaligned
    GNU gdb 4.17
    Copyright 1998 Free Software Foundation, Inc.
    GDB is free software, covered by the GNU General Public License, and you are
    welcome to change it and/or distribute copies of it under certain conditions.
    Type "show copying" to see the conditions.
    There is absolutely no warranty for GDB.  Type "show warranty" for details.
    This GDB was configured as "alphaev56-dec-osf4.0d"...
    (gdb) info line *0x1200011c4
    Line 12 of "test_unaligned.c" starts at address 0x1200011b4 
       and ends at 0x1200011d8 .
    (gdb) 

So, using gdb and the error output, we see that the first unaligned access error resulted from code on line 12 of test_unaligned.c.