Demonstrate and fix SIGBUS problems on sparc64

[petterreinholdtsen]

The self test of yosys exercising abc currently crash with SIGBUS on sparc64. This is most likely caused by incorrect memory alignment accesses. The added test was lifted from yosys to make it easy to trigger the crash, and the modified ABC_MEMALIGN handling move the alignment selection out of the makefile and into the C++ code where it is needed.
The code still crashes, but now in a different location for a different reason.

[petterreinholdtsen]

It now get SIGBUS in this code:

#0  0x0000010000757424 in abc::Mem_FixedEntryFetch (p=0x10001222ba0) at
  src/misc/mem/mem.c:202
  202             for ( i = 1; i < p->nChunkSize; i++ )
  (gdb) l
  197             }
  198             p->pEntriesFree = ABC_ALLOC( char, p->nEntrySize *
  p->nChunkSize );
  199             p->nMemoryAlloc += p->nEntrySize * p->nChunkSize;
  200             // transform these entries into a linked list
  201             pTemp = p->pEntriesFree;
  202             for ( i = 1; i < p->nChunkSize; i++ )
  203             {
  204                 *((char **)pTemp) = pTemp + p->nEntrySize;
  205                 pTemp += p->nEntrySize;
  206             }

I am completely perplexed, as gdb as far as I can tell, report that both p and p->pEntriesFree are pointers with 8 byte alignment, which as far as I could tell is the most sparc64 can demand.

I tried with the following patch, slowly growing as my confusion grew:

diff --git a/abc/src/misc/mem/mem.c b/abc/src/misc/mem/mem.c
index 347d0130..75935b7b 100644
--- a/abc/src/misc/mem/mem.c
+++ b/abc/src/misc/mem/mem.c
@@ -199,6 +199,11 @@ char * Mem_FixedEntryFetch( Mem_Fixed_t * p )
      p->nMemoryAlloc += p->nEntrySize * p->nChunkSize;
       // transform these entries into a linked list
       pTemp = p->pEntriesFree;
+       assert(0 == p % 8);
+       printf("&p=%p %x\n", &p, &p);
+       printf("p=%p %x\n", p, p);
+       printf("p->nChunkSize=%d\n", p->nChunkSize);
+       printf("pTemp=%p %x\n", pTemp, pTemp);
       for ( i = 1; i < p->nChunkSize; i++ )
       {
	   *((char **)pTemp) = pTemp + p->nEntrySize;

It crashes when reading p, when fetching the address of p, and of course when trying to fetch p->nChunkSize. I believe I am going to need help with this one, and that it was time to report it here.

[petterreinholdtsen]

Further tries to pinpoint the crash locate it just after a call to calloc():

--- a/abc/src/misc/mem/mem.c
+++ b/abc/src/misc/mem/mem.c
@@ -186,19 +186,28 @@ char * Mem_FixedEntryFetch( Mem_Fixed_t * p )
     char * pTemp;
     int i;
 
+    assert(0 == p % 8);
     // check if there are still free entries
     if ( p->nEntriesUsed == p->nEntriesAlloc )
     { // need to allocate more entries
+       assert(0 == p % 8);
         assert( p->pEntriesFree == NULL );
         if ( p->nChunks == p->nChunksAlloc )
         {
             p->nChunksAlloc *= 2;
             p->pChunks = ABC_REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
         }
-        p->pEntriesFree = ABC_ALLOC( char, p->nEntrySize * p->nChunkSize );
+       assert(0 == p % 8);
+        p->pEntriesFree = calloc( char, p->nEntrySize * p->nChunkSize );
+       assert(0 == p % 8); // This crashes with SIGBUS on sparc64
         p->nMemoryAlloc += p->nEntrySize * p->nChunkSize;
         // transform these entries into a linked list
         pTemp = p->pEntriesFree;
+       assert(0 == p % 8);
+       printf("&p=%p %x\n", &p, &p);
+       printf("p=%p %x\n", p, p);
+       printf("p->nChunkSize=%d\n", p->nChunkSize);
+       printf("pTemp=%p %x\n", pTemp, pTemp);
         for ( i = 1; i < p->nChunkSize; i++ )
         {
             *((char **)pTemp) = pTemp + p->nEntrySize;

I do not understand how changing the content of the struct can make the pointer to the struct invalid.

[petterreinholdtsen]

I was able to figure out what caused my confusion. The build dependencies were not working as expected, and editing the source did not cause a full rebuild, so I was looking at new source with a crash in the old build.

With that out of the way I managed to fix more alignment issues, but in the end ran out of time and decided to put the issue aside for now. The provided patches fixes some crashes, but not all of them. I suspect the misaligned memory accesses causes slowdown on more forgiving architectures like x86, and that fixing the alignment issues could speed up the process. I noticed the self testing failed because of timeout after 10000 seconds on ppc64el and hope that fixing alignment issues might get the tests to complete a bit quicker.

Perhaps someone with more spare time than me can pick up where I left.