Remove non product code files

Change-Id: Ib42630c94b0e0fbed2bd8c5939fde026af87a212
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/26055
Tested-by: FSP CI Jenkins
Reviewed-by: Wael El-Essawy <welessa@us.ibm.com>
Reviewed-by: William A. Bryan <wilbryan@us.ibm.com>

23 files changed, 2 insertions, 5230 deletions

diff --git a/src/lib/common/libcommonfiles.mk b/src/lib/common/libcommonfiles.mk
index 9fe7592..4a05fac 100644
--- a/src/lib/common/libcommonfiles.mk
+++ b/src/lib/common/libcommonfiles.mk
@@ -5,7 +5,7 @@
 #
 # OpenPOWER OnChipController Project
 #
-# Contributors Listed Below - COPYRIGHT 2015
+# Contributors Listed Below - COPYRIGHT 2015,2016
 # [+] International Business Machines Corp.
 #
 #
@@ -44,9 +44,7 @@
 C-SOURCES = \
     memcpy.c \
 	memset.c \
-	rand32.c \
 	string.c \
-	sync.c
 
 
 S-SOURCES =  
diff --git a/src/lib/common/rand.h b/src/lib/common/rand.h
deleted file mode 100644
index 369b8fd..0000000
--- a/src/lib/common/rand.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/common/rand.h $                                       */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __RAND_H__
-#define __RAND_H__
-
-// $Id$
-
-/// \file rand.h
-/// \brief Random number generation
-
-#include <stdint.h>
-
-// Error/Panic codes
-
-#define RAND64_UNIMPLEMENTED 0x00726301
-
-
-/// RAND32_ALL is used as the \a limit argument to rand32() and _rand32() to
-/// request the return of a full 32-bit random unsigned integer.
-
-#define RAND32_ALL 0
-
-extern uint32_t _seed32;
-
-uint32_t 
-_rand32(uint32_t *seed, uint32_t limit);
-
-uint32_t
-rand32(uint32_t limit);
-
-void
-srand32(uint32_t seed);
-
-
-/// RAND64_ALL is used as the \a limit argument to rand64() and _rand64() to
-/// request the return of a full 64-bit random unsigned integer.
-
-#define RAND64_ALL 0
-
-extern uint64_t _seed64;
-
-//void
-//davidmult64to128(uint64_t u, uint64_t v, uint64_t &h, uint64_t &l);
-
-uint64_t 
-_rand64(uint64_t *seed, uint64_t limit);
-
-uint64_t
-rand64(uint64_t limit);
-
-void
-srand64(uint64_t seed);
-
-
-/// A random weighting map for integer selections
-///
-/// See rand_map_int() for details.
-
-typedef struct {
-
-    /// The relative weight of this selection
-    ///
-    /// The final weight of the map array \e must be 0 to terminate the map.
-    unsigned weight;
-
-    /// The selection
-    int selection;
-
-} RandMapInt;
-
-
-/// A random weighting map for pointer selections
-///
-/// See rand_map_ptr() for details.
-
-typedef struct {
-
-    /// The relative weight of this selection
-    ///
-    /// The final weight of the map array \e must be 0 to terminate the map.
-    unsigned weight;
-
-    /// The selection
-    void *selection;
-
-} RandMapPtr;
-
-
-int
-_rand_map_int(uint32_t *seed, RandMapInt *map, int *index);
-
-int
-rand_map_int(RandMapInt *map);
-
-void *
-_rand_map_ptr(uint32_t *seed, RandMapPtr *map, int *index);
-
-void *
-rand_map_ptr(RandMapPtr *map);
-
-
-#endif	/* __RAND_H__ */
diff --git a/src/lib/common/rand32.c b/src/lib/common/rand32.c
deleted file mode 100644
index c75fc76..0000000
--- a/src/lib/common/rand32.c
+++ /dev/null
@@ -1,384 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/common/rand32.c $                                     */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file rand32.c
-/// \brief 32-bit unsigned pseudo-random number generation
-
-#include "rand.h"
-
-/// The default seed for rand32()
-
-uint32_t _seed32 = 405405405;
-
-
-/// Generate a random 32-bit unsigned integer from an explicit seed
-///
-/// \param seed A pointer to the random seed (updated by this routine).
-///
-/// \param limit The (exclusive) upper bound of the range of generated random
-/// integers.  The (inclusive) lower bound is always 0.
-///
-/// \retval A pseudo-random unsigned 32-bit integer uniformly selected from
-/// the range 0 to \a limit - 1 (inclusive). However if the \a limit parameter
-/// is \c RAND32_ALL (0), then the return value is a full 32-bit random bit
-/// vector. 
-///
-/// This is a 32-bit linear congruential generator, taken from the 'ranqd1'
-/// generator from "Numerical Recipes in C".  The authors' only praise for
-/// this generator is that it is "\e very fast"; the quality of random numbers
-/// is deemed "entirely adequate for many uses".
-///
-/// The initial 32 pseudo-random result is treated as a 32-bit binary fraction
-/// that is multipled by the limit to yield the final random 32-bit
-/// integer. If the limit is 0, then the full 32-bit result is returned. As
-/// with all LCG, do not count on the low-order bits to be particularly
-/// random.
-
-uint32_t
-_rand32(uint32_t *seed, uint32_t limit)
-{
-    uint64_t x;
-
-    *seed = (*seed * 1664525) + 1013904223;
-    if (limit == RAND32_ALL) {
-	return *seed;
-    } else {
-	x = (uint64_t)(*seed) * limit;
-	return x >> 32;
-    }
-}
-
-
-/// Generate a random 32-bit unsigned integer from a system-wide seed
-///
-/// \param limit The (exclusive) upper bound of the range of generated random
-/// integers. The (inclusive) lower bound is always 0.
-///
-/// \retval A pseudo-random unsigned 32-bit integer uniformly selected from
-/// the range 0 to \a limit - 1 (inclusive). However if the \a limit parameter
-/// is \c RAND32_ALL (0), then the return value is a full 32-bit random bit
-/// vector. 
-///
-/// rand32() is not thread safe.  There is a small possibility that multiple
-/// threads may observe the same random numbers, and it is also possible that
-/// the random sequence may appear to repeat due to thread interactions.  If
-/// these are concerns then the application should either call rand32() from
-/// within a critical section, or provide a unique seed to each thread or
-/// process and use the underlying _rand32() API explicitly.
-
-uint32_t
-rand32(uint32_t limit)
-{
-    return _rand32(&_seed32, limit);
-}
-
-
-/// Set the global random seed for rand32()
-
-void
-srand32(uint32_t seed)
-{
-    _seed32 = seed;
-}
-
-
-/// Select an integer from a weighted distribution using a specific seed
-///
-/// \param seed A 32-bit unsigned random seed (accumulator)
-///
-/// \param map An array of RandMapInt structures, the final element of which
-/// must have the \a weight field = 0.  This array will typically be allocated
-/// statically. 
-///
-/// \param index An optional pointer to an integer which will recieve the
-/// index of the item selected.  NULL \a index are ignored. This is provided
-/// for appplications that require statistics on selections.
-///
-/// \retval One of the \a selection from the array with a non-0 \a weight.  If
-/// the weight array is NULL (= {{0, \<dont care\>}}), then by convention the
-/// return value is 0, and the return index is -1.
-///
-/// This routine selects items from the \a map randomly, given the weighting
-/// implied by (map[i].weight / SUM(i = 0,...,N, map[i].weight)).  For
-/// example, the following two maps are equivalent in that they select 'a' and
-/// 'c' with 25% probability, and 'b' with 50% probability:
-///
-/// RandMapInt map0[] = {{1, 'a'}, {2, 'b'}, {1, 'c'}, {0, 0}};
-///
-/// RandMapInt map1[] = {{25, 'a'}, {50, 'b'}, {25, 'c'}, {0, 0}};
-///
-/// Note that several errors including negative weights, or the overflow of
-/// the sum of weights as an \a unsigned number are neither detected nor
-/// reported.
-///
-/// \todo We could probably merge the code for the integer and pointer versions
-/// somewhat.  This is a great example of where C++ would be nice, as we could
-/// easily cache the sum of weights when the map was constructed.
-
-int
-_rand_map_int(uint32_t *seed, RandMapInt *map, int *index)
-{
-    unsigned weight, sum;
-    RandMapInt *p;
-    uint32_t rand;
-    int i = -1;
-    int selection = 0;
-
-    sum = 0;
-    p = map;
-    while (p->weight != 0) {
-	sum += p->weight;
-	p++;
-    }
-
-    if (sum != 0) {
-
-	rand = _rand32(seed, sum);
-
-	weight = 0;
-	p = map;
-	i = 0;
-	while (p->weight != 0) {
-	    weight += p->weight;
-	    if (rand < weight) {
-		selection = p->selection;
-		break;
-	    }
-	    p++;
-	    i++;
-	}
-    }
-
-    if (index != 0) {
-	*index = i;
-    }
-
-    return selection;
-}
-
-    
-/// Select an integer from a weighted distribution using the system-side seed
-/// \a _seed32
-///
-/// See _rand_map_int() for documentation
-
-int
-rand_map_int(RandMapInt *map)
-{
-    return _rand_map_int(&_seed32, map, 0);
-}
-
-
-/// Select a pointer from a weighted distribution using a specific seed
-///
-/// \param seed A 32-bit unsigned random seed (accumulator)
-///
-/// \param map An array of RandMapPtr structures, the final element of which
-/// must have the \a weight field = 0.  This array will typically be allocated
-/// statically. 
-///
-/// \param index An optional pointer to an integer which will recieve the
-/// index of the item selected.  NULL \a index are ignored. This is provided
-/// for appplications that require statistics on selections.
-///
-/// \retval One of the \a selection from the array with a non-0 \a weight.  If
-/// the weight array is NULL (= {{0, \<dont care\>}}), then by convention the
-/// return value is 0, and the return index is -1;
-///
-/// This routine selects items from the \a map randomly, given the weighting
-/// implied by (map[i].weight / SUM(i = 0,...,N, map[i].weight)).  For
-/// example, the following two maps are equivalent in that they select &a and
-/// &c with 25% probability, and &b with 50% probability:
-///
-/// RandMapPtr map0[] = {{1, &a}, {2, &b}, {1, &c}, {0, 0}};
-///
-/// RandMapPtr map1[] = {{25, &a}, {50, &b}, {25, &c}, {0, 0}};
-///
-/// Note that several errors including negative weights, or the overflow of
-/// the sum of weights as an \a unsigned number are neither detected nor
-/// reported.
-
-
-void *
-_rand_map_ptr(uint32_t *seed, RandMapPtr *map, int *index)
-{
-    unsigned weight, sum;
-    RandMapPtr *p;
-    uint32_t rand;
-    int i = -1;
-    void *selection = 0;
-
-    sum = 0;
-    p = map;
-    while (p->weight != 0) {
-	sum += p->weight;
-	p++;
-    }
-
-    if (sum != 0) {
-
-	rand = _rand32(seed, sum);
-
-	weight = 0;
-	p = map;
-	i = 0;
-	while (p->weight != 0) {
-	    weight += p->weight;
-	    if (rand < weight) {
-		selection = p->selection;
-		break;
-	    }
-	    p++;
-	    i++;
-	}
-    }
-    
-    if (index != 0) {
-	*index = i;
-    }
-
-    return selection;
-}
-
-    
-/// Select a pointer from a weighted distribution using the system-side seed
-/// \a _seed32
-///
-/// See _rand_map_ptr() for documentation
-
-void *
-rand_map_ptr(RandMapPtr *map)
-{
-    return _rand_map_ptr(&_seed32, map, 0);
-}
-
-
-////////////////////////////////////////////////////////////////////////////
-
-#ifdef __TEST_RAND_C__
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef RANDOM_MAP
-
-// Weighted distribution testing
-
-int a, b, c;
-int aa, bb, cc;
-
-int x[3];
-
-RandMapPtr map0[] = {{1, &a}, {2, &b}, {1, &c}, {0, 0}};
-RandMapPtr map1[] = {{25, &aa}, {50, &bb}, {25, &cc}, {0, 0}};
-
-RandMapInt map2[] = {{25, 0}, {50, 1}, {25, 2}, {0, 0}};
-
-int
-main()
-{
-    int i, j;
-    int *p;
-
-    for (i = 0; i < 1000000; i++) {
-	p = (int *)(rand_map_ptr(map0));
-	*p = *p + 1;
-	p = (int *)(rand_map_ptr(map1));
-	*p = *p + 1;
-	j = rand_map_int(map2);
-	x[j]++;
-    }
-    
-    printf("%d %d %d\n", a, b, c);
-    printf("%d %d %d\n", aa, bb, cc);
-    printf("%d %d %d\n", x[0], x[1], x[2]);
-
-    return 0;
-}
-
-#endif	/* RANDOM_MAP */
-
-
-#ifdef BASIC_TEST
-
-// Simple self-checking uniform distrubution tests for rand32.
-
-void
-test(int *a, int size, int count, double max_error)
-{
-    int i;
-    double error;
-
-    for (i = 0; i < size; i++) {
-	a[i] = 0;
-    }
-
-    for (i = 0; i < size * count; i++) {
-	a[rand32(size)]++;
-    }
-
-    for (i = 0; i < size; i++) {
-	error = (a[i] / (double)count) - 1.0;
-	printf("a[%4d] : %10d %.5f\n", i, a[i], error);
-	if (abs(error) > max_error) {
-	    printf("Too much error\n");
-	    exit(1);
-	}
-    }
-}
-    
-#define MAX_SIZE 128
-
-int
-main()
-{
-    int a[MAX_SIZE];
-    int count = 1000000;
-    double max_error = .005;
-    int i;
-
-    for (i = 2; i <= MAX_SIZE; i *= 2) {
-	printf("\nTest %d\n\n", i);
-	test(a, i, count, max_error);
-    }
-
-    srand32(0);
-    for (i = 2; i <= MAX_SIZE; i *= 2) {
-	printf("\nTest %d\n\n", i);
-	test(a, i, count, max_error);
-    }
-
-    srand32(0xdeadbeef);
-    for (i = 2; i <= MAX_SIZE; i *= 2) {
-	printf("\nTest %d\n\n", i);
-	test(a, i, count, max_error);
-    }
-}
-    
-#endif	/* BASIC_TEST */
-
-#endif	/* __TEST_RAND_C__ */
-
diff --git a/src/lib/common/sync.c b/src/lib/common/sync.c
deleted file mode 100644
index a489be8..0000000
--- a/src/lib/common/sync.c
+++ /dev/null
@@ -1,294 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/common/sync.c $                                       */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file sync.c
-/// \brief A library of higher-level synchronization primitives based on
-/// low-level kernel services.
-///
-/// The APIs provided here are currently based on kernel services, but the
-/// specifications should allow applications to be ported to other
-/// environments if required.  Note that like  kernel services, data
-/// structures manipulated by this code are protected in KERN_NONCRITICAL
-/// critical sections. 
-
-#include "kernel.h"
-#include "sync.h"
-
-/// Create a Barrier
-///
-/// \param barrier A pointer to an uninitialized or currently unused Barrier
-///
-/// \param count The number of threads required to pend at the barrier before
-/// all threads are released again for execution.  Note that \a count values
-/// of 0 and 1 are treated as equivalent - threads will not pend at all in
-/// these cases.  Also note that if a watchdog thread is being used, the
-/// watchdog thread should not be included in the count.
-///
-/// \retval 0 Success
-///
-/// \retval -SYNC_INVALID_OBJECT The \a barrier is NULL (0)
-
-int
-barrier_create(Barrier *barrier, KERN_SEMAPHORE_COUNT count)
-{
-    if (KERN_ERROR_CHECK_API) {
-	KERN_ERROR_IF(barrier == 0, SYNC_INVALID_OBJECT);
-    }
-
-    barrier->entry_sem = &(barrier->sem[0]);
-    barrier->exit_sem = &(barrier->sem[1]);
-
-    KERN_SEMAPHORE_CREATE((KERN_SEMAPHORE *)(barrier->entry_sem), 0, 0);
-    KERN_SEMAPHORE_CREATE((KERN_SEMAPHORE *)(barrier->exit_sem), 0, 0);
-
-    barrier->entry_count = 0;
-    barrier->exit_count = 0;
-    barrier->target_count = count;
-
-    barrier->watchdog_pending = 0;
-    barrier->watchdog_entries = 0;
-
-    barrier->callback = 0;
-    barrier->arg = 0;
-    barrier->run_callback = 0;
-
-    return 0;
-}
-
-
-/// Install a barrier callback
-///
-/// \param barrier A pointer to an initialized Barrier object
-///
-/// \param callback A function taking a single (void *) argument, to be
-/// executed in the context of the first thread to exit the barrier when the
-/// barrier condition is met.
-///
-/// \param arg The argument of the \a callback.
-///
-/// The Barrier object supports an optional callback function.  The callback
-/// (with the customary single (void *) parameter) is made when the barrier
-/// condition is met, in the thread context of the first (highest priority)
-/// thread to exit the barrier. The callback is made inside the barrier_pend()
-/// call, but outside of a critical section. The specification of the callback
-/// is not part of the barrier_create() call, but is provided later by this
-/// API. Setting a NULL (0) callback disables the callback mechanism.
-///
-/// \retval 0 Success
-///
-/// \retval -SYNC_INVALID_OBJECT The \a barrier is NULL (0)
-
-int
-barrier_callback_set(Barrier *barrier, 
-		     BarrierCallback callback,
-		     void *arg)
-{
-    KERN_MACHINE_CONTEXT ctx;
-
-    if (KERN_ERROR_CHECK_API) {
-	KERN_ERROR_IF(barrier == 0, SYNC_INVALID_OBJECT);
-    }
-
-    KERN_CRITICAL_SECTION_ENTER(KERN_NONCRITICAL, &ctx);
-
-    barrier->callback = callback;
-    barrier->arg = arg;
-
-    KERN_CRITICAL_SECTION_EXIT(&ctx);
-
-    return 0;
-}
-    
-
-static int
-_barrier_pend(Barrier *barrier, int watchdog)
-{
-    KERN_MACHINE_CONTEXT ctx;
-    int rc = 0;
-    KERN_SEMAPHORE *temp_sem;
-    BarrierCallback callback = 0; /* Make GCC Happy */
-    void *arg = 0;		/* Make GCC Happy */
-    int run_callback;
-
-    if (KERN_ERROR_CHECK_API) {
-	KERN_ERROR_IF(barrier == 0, SYNC_INVALID_OBJECT);
-    }
-
-    KERN_CRITICAL_SECTION_ENTER(KERN_NONCRITICAL, &ctx);
-
-    // A normal thread will pend at the entry unless 1) the thread satisfies
-    // the barrier condition, or 2) a watchdog thread is pending here.  A
-    // watchdog thread only pends if no other threads are pending.
-
-    if (watchdog) {
-	barrier->watchdog_entries++;
-    }
-
-    barrier->entry_count++;
-    if (!barrier->watchdog_pending &&
-	((watchdog && (barrier->entry_count == 1)) ||
-	 (!watchdog && (barrier->entry_count < barrier->target_count)))) {
-
-	if (watchdog) {
-	    barrier->watchdog_pending = 1;
-	}
-
-	// The thread must pend here
-
-	rc = KERN_SEMAPHORE_PEND((KERN_SEMAPHORE *)(barrier->entry_sem), 
-				KERN_WAIT_FOREVER);
-	if (rc) {
-	    goto exit_critical;
-	}
-
-    } else {
-
-	// The barrier condition is met - or the watchdog thread is blocked
-	// here.  The entry and exit semaphores and counts are swapped. The
-	// callback is marked to be called.
-
-	// If the barrier is used incorrectly, or threads are deleted without
-	// adjusting the barrier target count then the following condition
-	// could become true, which could lead to bad behavior.
-
-	if (barrier->exit_count != 0) {
-	    KERN_PANIC(SYNC_BARRIER_INVARIANT);
-	}
-
-	barrier->entry_count--;	// Undo preincrement above
-	barrier->watchdog_pending = 0;
-
-	temp_sem = (KERN_SEMAPHORE *)(barrier->exit_sem);
-	barrier->exit_sem = barrier->entry_sem;
-	barrier->entry_sem = temp_sem;
-
-	barrier->exit_count = barrier->entry_count;
-	barrier->entry_count = 0;
-
-	barrier->run_callback = 1;
-    }
-
-    // This thread either continues to run or just woke up after having
-    // blocked at the barrier.  The current thread makes the next thread (if
-    // any) runnable as well.  Normally the current thread will be of a higher
-    // priority than any blocked threads, so no context switch will occur. The
-    // thread that satisfies the barrier condition \e will cause a context
-    // switch here, unless it just happens to be the highest priority thread
-    // in the barrier group.
-
-    if (barrier->exit_count != 0) {
-	barrier->exit_count--;
-	rc = KERN_SEMAPHORE_POST((KERN_SEMAPHORE *)(barrier->exit_sem));
-    }
-    
-exit_critical:
-
-    if (rc) {
-	KERN_CRITICAL_SECTION_EXIT(&ctx);
-	return rc;
-    }
-
-    // In the case of a satisfied barrier condition, the first thread to exit
-    // the critical section will be the higest priority thread blocked at the
-    // barrier.  This thread is tasked with executing the callback, outside of
-    // the critical section.
-
-    run_callback = barrier->run_callback;
-    barrier->run_callback = 0;
-    if (run_callback) {
-	callback = barrier->callback;
-	arg = (void *)(barrier->arg); /* Cast away 'volatile' */
-    }
-
-    KERN_CRITICAL_SECTION_EXIT(&ctx);
-
-    if (run_callback && callback) {
-	callback(arg);
-    }
-
-    return 0;
-}
-
-
-/// Pend at a Barrier
-///
-/// \param barrier An initialized barrier object
-///
-/// A thread will pend at a barrier until \a count number of threads (supplied
-/// in the call of barrier_create()) are pending.  If \a count is 0 or 1, the
-/// API always returns immediately. 
-///
-/// If barrier watchdog thread is being used (correctly), then the watchdog
-/// will cause thread pending on the barrier to be released whenever all
-/// threads in the group are blocked, regardless of whether some of the
-/// group's threads are blocked elesewhere.
-///
-/// \retval 0 Success
-///
-/// \retval -SYNC_INVALID_OBJECT The \a barrier is NULL (0)
-///
-/// Other errors may be returned by the embedded call of ssx_semephore_pend().
-/// In particular this API will fail if called outside of a thread context
-/// since it requires blocking indefinitely on a semaphore.
-///
-/// \bug The semaphore should be able to provide the number of pending threads
-/// - which we should really be using here instead of the barrier counts.  The
-/// current implementation can produce some strange behavior if threads are
-/// deleted.
-
-int
-barrier_pend(Barrier *barrier)
-{
-    return _barrier_pend(barrier, 0);
-}
-
-
-/// Barrier watchdog thread
-///
-/// \param arg A pointer to the Barrier object this thread should manage.
-///
-/// A barrier_watchdog() thread is attached to a Barrier object, and forces
-/// the barrier condition to be met whenever it runs.  This thread is designed
-/// to be mapped at a priority immediately below the priorities of a group of
-/// threads that pend on the barrier.  
-///
-/// In this way, should every thread in the group become blocked, the watchdog
-/// will allow any threads that are blocked on the barrier to run. If all the
-/// threads are blocked elsewhere, then the watchdog blocks on the barrier,
-/// and as soon as any thread pends again at the barrier the thread remains
-/// runnable and the watchdog becomes runnable.
-///
-/// The barrier_watchdog() thread is not required.  Without the watchdog,
-/// otherwise runnable threads in the barrier group will remain blocked on the
-/// barrier as long as any of their cohorts remain blocked elsewhere.
-
-void
-barrier_watchdog(void *arg)
-{
-    do {
-	_barrier_pend((Barrier *)arg, 1);
-    } while (1);
-}
diff --git a/src/lib/common/sync.h b/src/lib/common/sync.h
deleted file mode 100644
index 5657c78..0000000
--- a/src/lib/common/sync.h
+++ /dev/null
@@ -1,167 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/common/sync.h $                                       */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __SYNC_H__
-#define __SYNC_H__
-
-// $Id$
-
-/// \file sync.h
-/// \brief A library of higher-level synchronization primitives based on
-/// low-level kernel services.
-///
-/// The APIs provided here are currently based on SSX services, but the
-/// specifications should allow applications to be fairly easily ported to
-/// other environments if required.
-///
-/// \todo Consider implementing a subset of the POSIX pthreads standards
-/// instead of these non-standard synchronization primitives. Ideally all
-/// synchronization primitives would be part of the SSX kernel so that they
-/// would correctly handle thread suspension and deletion while pending.
-
-#include "kernel.h"
-
-// Error/panic codes
-
-#define SYNC_INVALID_OBJECT         0x00896201
-#define SYNC_INVALID_ARGUMENT       0x00896202
-#define SYNC_BARRIER_PEND_TIMED_OUT 0x00896203
-#define SYNC_BARRIER_OVERFLOW       0x00896204
-#define SYNC_BARRIER_UNDERFLOW      0x00896205
-#define SYNC_BARRIER_INVARIANT      0x00896206
-#define SYNC_SHARED_UNDERFLOW       0x00896207
-
-////////////////////////////////////////////////////////////////////////////
-// Barrier
-////////////////////////////////////////////////////////////////////////////
-
-typedef void (*BarrierCallback)(void *);
-
-/// A thread barrier object 
-///
-/// A Barrier allows multiple threads to pend until a group of threads are all
-/// pending at the barrier.  Once all threads are pending at the barrier, all
-/// threads are released again for execution.  The barrier guarantees that
-/// once released, lower-priority threads will have the chance to execute
-/// before the barrier condition is satisfied again.  Thus the Barrier can be
-/// used as a form of fair scheduling for a group of threads that execute in a
-/// loop of doing work followed by pending at the barrier.
-///
-/// Although the barrier guarantees fairness, it can not by itself guarantee
-/// progress. If several threads in a barrier group are
-/// pending at the barrier while other threads in the group are blocked away
-/// from the barrier, the threads at the barrier should be running (if allowed
-/// by the priority mappings etc.).  The only way to guarantee constant
-/// progress by any unblocked thread in a group is to created another,
-/// 'watchdog' thread that has lower priority than the other threads in the
-/// group.  The watchdog thread only executes when all threads in the group
-/// are blocked, and ensures progress.  This implementation provides a
-/// watchdog thread routine as barrier_watchdog().
-///
-/// Normally the threads in a barrier group will be assigned consecutive
-/// priorities - otherwise various forms of priority inversion can arise.  The
-/// watchdog thread, if any, will normally be assigned the priority
-/// immediately lower than the lowest priority thread in the group.
-///
-/// The Barrier object supports an optional callback function.  The callback
-/// (with the customary single (void *) parameter) is made when the barrier
-/// condition is met, in the thread context of the first (highest priority)
-/// thread to exit the barrier. The callback is made inside the barrier_pend()
-/// call, but outside of a critical section. The specification of the callback
-/// is not part of the barrier_create() call, but is provided later by the
-/// barrier_callback_set() call. A NULL (0) callback (the default) is ignored.
-///
-/// NB: All barrier APIs (other than barrier_create()) must be made from
-/// thread mode - they will fail if called from interrupt handlers or before
-/// threads have started.
-
-typedef struct Barrier {
-
-    /// Semaphore array; see \a entry_sem and \a exit_sem;
-    KERN_SEMAPHORE sem[2];
-
-    /// The entry semaphore.
-    ///
-    /// Threads pending at the barrier initially block here.  Once all of the
-    /// threads in the group are pending here, the entry and exit semaphores
-    /// are swapped and threads are released (in priority order) from the new
-    /// exit semaphore.
-    volatile KERN_SEMAPHORE *entry_sem;
-
-    /// The exit semaphore.
-    volatile KERN_SEMAPHORE *exit_sem;
-
-    /// The current count of threads pending at \a entry_sem.
-    volatile KERN_SEMAPHORE_COUNT entry_count;
-
-    /// The current count of threads pending at \a exit_sem.
-    volatile KERN_SEMAPHORE_COUNT exit_count;
-
-    /// The target number of threads required to release the barrier
-    volatile KERN_SEMAPHORE_COUNT target_count;
-
-    /// A flag - Is the watchdog thread pending at the barrier?
-    volatile int watchdog_pending;
-
-    /// Statistics - The number of times the watchdog has entered the barrier.
-    volatile uint32_t watchdog_entries;
-    
-    /// The barrier condition callback function 
-    volatile BarrierCallback callback;
-
-    /// The argument of the callback function
-    volatile void *arg;
-
-    /// This flag is set to tell the first thread to exit the barrier to
-    /// execute the callback (if any).
-    volatile int run_callback;
-
-} Barrier;
-
-int
-barrier_create(Barrier *barrier, KERN_SEMAPHORE_COUNT count);
-
-int
-barrier_callback_set(Barrier *barrier, 
-		     BarrierCallback callback,
-		     void *arg);
-
-int
-barrier_pend(Barrier *barrier);
-
-void
-barrier_watchdog(void *arg);
-
-
-#endif // __SYNC_H__
-
-
-
-
-
-
-
-
-    
- 
diff --git a/src/lib/ppc405lib/byte_pool.c b/src/lib/ppc405lib/byte_pool.c
deleted file mode 100644
index d382abc..0000000
--- a/src/lib/ppc405lib/byte_pool.c
+++ /dev/null
@@ -1,1442 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/byte_pool.c $                               */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file byte_pool.c
-/// \brief An implementation of a constant-time malloc() algorithm.
-///
-/// The 'byte-pool' API defined in this file is similar to ThreadX' byte-pool
-/// operations, with the major difference that here there is no concept of a
-/// thread blocking on memory allocation.  This is a concept that is difficult
-/// to implement correctly and efficiently, and several semantic options
-/// exist for how allocation and freeing memory should work in the presence of
-/// blocked threads. The application is always free to implement a blocking
-/// API using these APIs and SSX synchronization primitives.
-///
-/// For convenience this implementation also provides malloc() and calloc()
-/// calls.  These APIs depend on the application creating a byte pool and
-/// assigning it to the library variable \a _malloc_byte_pool.
-///
-/// \todo Consider separating the idea of creating a byte pool with a specific
-/// maximum-sized block, from the idea of adding memory to a byte pool. The
-/// idea is to allow pieces of memory required during initialization of the
-/// application to be added back to the pool at run time.  We could also
-/// simply add an API to allow memory to be added to a previously created
-/// pool, with the special case that if the block were 'too big' that it would
-/// be split into smaller chunks.
-///
-/// \todo Consider
-/// adding an option to store a pointer to the originating byte pool in the
-/// block header.  This would allow deallocation of any block with free()
-/// regardless of which pool it was allocated from, at a cost of 1 pointer per
-/// block.  This would simplify some of our validation test cases. We could
-/// also accomplish this by having each pool register ranges of addresses that
-/// it allocates from, but that would require a search every time we freed a
-/// block.
-
-#include "ssx.h"
-#include "byte_pool.h"
-
-// This is an implementation of the TLSF (Two-Level Segregate Fit) algorithm
-// described by M. Masmano, I. Ripoll and A Crespol,
-// http:/rtportal.upv.es/rtmalloc. A couple of their papers and presentations
-// are archived in /lib/doc/tlsf.  This is a 'clean-room' implementation of
-// their published ideas based solely on their papers and presentations.  No
-// part of their GPL implementation was used to create the byte-pool facility
-// implemented here. The algorithm as implemented here should port without
-// problem to either 32-bit or 64-bit implementations.
-//
-// TLSF has the nice property that it is a constant-time algorithm, both for
-// allocation and freeing allocated blocks.  This property is guaranteed by
-// always trading space for speed in the algorithm. This means that we can
-// (and do) run the allocation and freeing in a critical section. With all
-// error checking and statistics, a worst-case byte_bool_alloc() was
-// timed at 318 PowerPC instructions in the PgP OCC (PPC405) Simics
-// simulation.  A worst-case byte_pool_free() was timed at 368 PowerPC
-// instructions. These times are expected to equate to ~3us in OCC, a
-// reasonable value for a critical section. [The above times include all
-// error checking].
-//
-// An allocation unit requires two pointers of overhead - a pointer to the
-// previous block and a pointer to the next block (both in terms of linear
-// addresses). The minimum block size also includes the requirement for two
-// extra pointers used to link free blocks into their free lists. The final
-// size of the block (including user data) is simply computed as (next - self)
-// in terms of linear addresses.
-//
-// An allocated block is marked by setting the low-order bit of the 'previous'
-// pointer, which bit is otherwise guaranteed to be 0 due to alignment
-// restrictions. Whenever a block is freed it is immediately merged with the
-// previous and next blocks, if possible. Several places in the block
-// splitting and merging code take advantage of this invariant, and assume
-// that if a block is not already merged with its 'next' partner, then the
-// 'next' partner must be allocated.  Sentinel blocks are allocated at either
-// end of the managed area to avoid special checks for the first and last
-// memory blocks during merging.
-//
-// The 'Two-Level' in TLSF refers to the fact that there are multiple free
-// lists arranged in a 2-dimensional array.  Each free lists contains blocks
-// that fall into a particular size range.  The free list pointers and other
-// data structures described below are carved out of the initial free area
-// when a byte pool is initialized.
-//
-// The first dimension of the free list array is simply the floor(log2(size))
-// of the block. For the second dimension, a tuning parameter selects how many
-// columns each row in the table will contain. The number of columns must be
-// an even power-of-2. Each column represents a fixed power-of-2 size
-// increment of block sizes.  Given a block size, it is easy to compute the
-// row and column indices of a free list containing blocks of that size with
-// shifting and masking operation.
-//
-// It is assumed that the C type 'unsigned long' is the same size as a
-// pointer.  Therefore the number of rows in the table is less than or equal
-// to the number of bits in an unsigned long.  The number of columns is also
-// restricted to being in the range (1, 2, 4, ... number of bits in unsigned
-// long).
-//
-// The above restrictions make it very fast (and constant time) to find a free
-// list that contains a block that will satisfy the allocation request. The
-// byte pool structure maintains a 'row status' word that indicates whether
-// there are any blocks free in any of the free lists of the row.  Each row
-// also has an associated 'column status' word that indicates which free lists
-// have blocks free. A row status bit is set if and only if at least one bit
-// in the column status for that row is set.
-//
-// Note that although the 32-bit PowerPC implementation conceptually contains
-// a 32x32 array of free list pointers, only the free list pointers actually
-// required to hold the representable blocks are allocated. 
-//
-// The algorithm uses the GCC __builtin_clzl() function to count leading zeros
-// in the status words to find rows/columns that contain free blocks.  This
-// generates the 'cntlzw' instruction on 32-bit PowerPC and a similar
-// instruction on X86.  So the algorithm is also portable across machines -
-// which simplifies testing.
-//
-// A couple of final facts: When the application requests memory, the block
-// header overhead is added to the request and we look for a free list
-// guaranteed to contain blocks of the requested size. That means that the
-// request size must be rounded up to the next free list size, to avoid having
-// to search a list that might not contain a block of the proper size. This
-// leads to cases where allocation will fail, even though the requested memory
-// is actually available. That's just the price we have to pay for a
-// constant-time guarantee.
-//
-// This memory allocator will never be used in mission-mode for hard-real-time
-// applications, so the statistics are always kept up-to-date.  This adds some
-// overhead, but does not effect the constant-time behavior.
-// 
-// Given the above description, hopefuly the brief comments with the
-// implementation will make sense.
-
-
-/// The byte pool for use by malloc() and calloc().
-///
-/// The application must define a byte pool and assign it to _malloc_byte_pool
-/// in order for malloc() and calloc() to work.
-
-BytePool *_malloc_byte_pool = 0;
-
-
-// The byte pool memory block header.
-//
-// Each memory block requires 2 pointers of overhead - the pointers to the
-// previous and next (in terms of linear addresses) blocks. The low-order bit
-// of the \a previous pointer is used as the \e allocated flag, and is set
-// when a block is allocated.  The size of a block is computed simply as the
-// \a next - \a self. This header layout makes it very simple to merge blocks
-// when they are deallocated.
-
-typedef struct ByteBlock {
-
-    // Pointer to the previous (in terms of linear address) block.
-    //
-    // The low-order bit of the pointer is set to indicate a block that has
-    // been allocated.
-    struct ByteBlock *previous;
-
-    // Pointer to the next (in terms of linear address) block.
-    //
-    // The size of the block is computed simply as \a next - \a self.
-    struct ByteBlock *next;
-
-} ByteBlock;
-
-
-// A free byte-pool memory block
-//
-// Blocks stored in free lists require an additional 2 pointers of
-// overhead. The blocks are doubly-linked in the free lists to make deletion
-// a constant-time operation.  Note that the previous pointer is a pointer to
-// a pointer to a ByteBlock - it may be pointing to the free list
-// header. Since all blocks must be freeable, this structure defines the
-// minimum block size.
-
-typedef struct FreeByteBlock {
-
-    // The base object
-    ByteBlock block;
-
-    // Pointer to the next block in the free list
-    struct FreeByteBlock *next;
-
-    // Pointer to the \a next pointer of the previous element in the free
-    // list, or a pointer to the free list header.
-    struct FreeByteBlock **previous;
-
-} FreeByteBlock;
-
-
-// All blocks will be aligned to this size, so this size also defines the
-// minimum quantum of memory allocation.  The coice of 8 should give
-// good results for both 32-bit and 64-bit implementations.  
-//
-// NB : This implmentation assumes that the ByteBlock and FreeByteBLock are
-// aligned to this alignment - if this constant is ever changed from 8 then
-// the ByteBlock and FreeByteBlock may need to be padded to meet the alignment
-// assumptions, and the \a minimum_block_size may need to be adjusted.
-
-#define ALIGNMENT 8
-
-
-// An unsigned long, big-endian bit mask
-
-#define UL_BE_MASK(i) \
-    ((unsigned long)1 << (BITS_PER_UNSIGNED_LONG - (i) - 1))
-
-
-// Align a value to the alignment.  The direction is either positive or
-// negative to indicate alignment up or down.
-
-static inline unsigned long
-align(unsigned long x, int direction)
-{
-    if (x % ALIGNMENT) {
-	if (direction > 0) {
-	    return x + (ALIGNMENT - (x % ALIGNMENT));
-	} else {
-	    return x - (x % ALIGNMENT);
-	}	    
-    } else {
-	return x;
-    }
-}
-
-
-// Compute the floor(log2(x)) of x.  This is used to compute the row indices
-// of blocks based on the block size.
-
-static inline int
-floor_log2(unsigned long x)
-{
-    return BITS_PER_UNSIGNED_LONG - 1 - __builtin_clzl(x);
-}
-
-
-// In theory the tuning parameters might vary based on the amount of memory
-// being managed, but for now we simply use constants.  
-// 
-// The minimum block size includes both the size of the header, as well as the
-// requirement that the number of columns be <= the mimumum block size to make
-// the addressing uniform. For example, on PPC405 the minimum block size is 16
-// bytes (4 pointers) -- unless the number of columns is 32, in which case it
-// has to grow to 32 bytes.
-//
-// Note that no matter what, we may allocate free list pointers in the
-// lower-numbered rows that will never be populated due to alignment
-// constraints.
-
-#ifndef BYTE_POOL_TLSF_COLUMNS
-#define BYTE_POOL_TLSF_COLUMNS 8 /* 1,2,4, ... BITS_PER_UNSIGNED_LONG */
-#endif
-
-static void
-compute_tuning(BytePool *pool, size_t size, int columns)
-{
-    int log2_min_size;
-
-    pool->columns = columns;
-    pool->log2_columns = floor_log2(pool->columns);
-    pool->column_mask = (1 << pool->log2_columns) - 1;
-
-    log2_min_size = MAX(pool->log2_columns, floor_log2(sizeof(FreeByteBlock)));
-    pool->minimum_block_size = align(1 << log2_min_size, 1);
-}
-
-
-// Compute the size of a block
-
-static inline size_t
-block_size(ByteBlock *block)
-{
-    return (unsigned long)(block->next) - (unsigned long)block;
-}
-
-
-/// Return implementation information for a block
-///
-/// \param memory The memory block to query.  This pointer must have been
-/// returned by one of the byte_pool functions or derivitives, or may also be
-/// 0. 
-///
-/// \param actual_address : Returned as the address of the block header.
-///
-/// \param actual_size Returned as the size of the complete block, including
-/// the header.
-///
-/// \param useful_size : Returned as the actual amount of space available from
-/// \a memory to the end of the block. The \a useful_size may be useful to
-/// applications that allocate big blocks then carve them up into smaller
-/// structures.
-///
-/// Note that any of \a actual_address, \a actual_size and \a useful_size may
-/// be passed in as 0 if the caller does not require the information.
-
-void
-byte_pool_block_info(void* memory,
-                     void** actual_address, size_t* actual_size,
-                     size_t* useful_size)
-{
-    ByteBlock* block;
-
-    if (memory == 0) {
-
-        if (actual_address) *actual_address = 0;
-        if (actual_size) *actual_size = 0;
-        if (useful_size) *useful_size = 0;
-
-    } else {
-
-        // This implementation uses the convention that if the \a next pointer
-        // of the putative ByteBlock == 1, then this is actually an aligned
-        // allocation and the actual ByteBlock is located at the address
-        // contained in the \a previous field of the dummy header.
-
-        block = (ByteBlock *)(((unsigned long)memory) - sizeof(ByteBlock));
-        if ((int)(block->next) == 1) {
-            block = block->previous;
-        }
-
-        if (actual_address) *actual_address = block;
-        if (actual_size) *actual_size = block_size(block);
-        if (useful_size) 
-            *useful_size = 
-                (unsigned long)(block->next) - (unsigned long)memory;
-    }
-}
-
-
-// Mark a block as allocated by setting the low-order bit of the \a previous
-// pointer.
-
-static inline ByteBlock *
-allocated(ByteBlock *p)
-{
-    return (ByteBlock *)((unsigned long)p | 1ul);
-}
-
-
-static void
-mark_allocated(BytePool *pool, ByteBlock *block)
-{
-    size_t bytes = block_size(block);
-
-    pool->bytes_allocated += bytes;
-    pool->bytes_free -= bytes;
-    pool->blocks_allocated += 1;
-    pool->blocks_free -= 1;
-
-    block->previous = allocated(block->previous);
-}
-
-
-// Mark a block as free by clearing the low-order bit of the \a previous
-// pointer. 
-
-static inline ByteBlock *
-deallocated(ByteBlock *p)
-{
-    return (ByteBlock *)((unsigned long)p & ~1ul);
-}
-
-
-static void
-mark_free(BytePool *pool, ByteBlock *block)
-{
-    size_t bytes = block_size(block);
-
-    pool->bytes_allocated -= bytes;
-    pool->bytes_free += bytes;
-    pool->blocks_allocated -= 1;
-    pool->blocks_free += 1;
-
-    block->previous = deallocated(block->previous);
-}
-
-
-// Check for a block being free
-
-static inline int
-block_is_free(ByteBlock *block)
-{
-    return (((unsigned long)(block->previous)) & 1ul) == 0;
-}
-
-
-// Normalize a 'previous' pointer
-
-static inline ByteBlock *
-normalize_previous(ByteBlock *previous)
-{
-    return (ByteBlock *)((unsigned long)previous & ~1ul);
-}
-
-
-// Check for correct linkage.  This is such a critical check for application
-// memory corruption that it is always done.
-
-static int
-check_linkage(ByteBlock *block)
-{
-    if (normalize_previous(block->next->previous) != block) {
-        printk("byte_pool: Forward linkage error\n"
-               "    block                 : %p\n"
-               "    block->next           : %p\n"
-               "    block->next->previous : %p\n",
-               block,
-               block->next,
-               block->next->previous);
-        SSX_ERROR(BYTE_POOL_REVERSE_LINKAGE);
-    } else if (normalize_previous(block->previous)->next != block) {
-        printk("byte_pool:  linkage error\n"
-               "    block->previous       : %p\n"
-               "    block->pevious->next  : %p\n"
-               "    block                 : %p\n",
-               block->previous,
-               block->previous->next,
-               block);
-        SSX_ERROR(BYTE_POOL_FORWARD_LINKAGE);
-    } 
-    return 0;
-}
-
-
-// Mark a free list as empty
-
-static inline void
-mark_empty(BytePool *pool, int row, int column)
-{
-    pool->column_status[row] &= ~UL_BE_MASK(column);
-    if (pool->column_status[row] == 0) {
-	pool->row_status &= ~UL_BE_MASK(row);
-    }
-}
-
-
-// Mark a free list as non-empty
-
-static inline void
-mark_non_empty(BytePool *pool, int row, int column)
-{
-    pool->column_status[row] |= UL_BE_MASK(column);
-    pool->row_status |= UL_BE_MASK(row);
-}
-
-
-// Convert a size into row and column indices
-
-static inline void
-size2rc(BytePool *pool, size_t size, int *row, int *column)
-{
-    *row = floor_log2(size);
-    *column = (size >> (*row - pool->log2_columns)) & pool->column_mask;
-}    
-
-
-// Given a block size, find the free list that contains blocks of that size
-// (or greater, up to the next free list). When called during block freeing,
-// the block size is known to be valid.  When called during allocation, the
-// block size may be invalid (too big), in which case 0 is returned.
-
-static FreeByteBlock **
-find_free_list(BytePool *pool, size_t size, int *row, int *column)
-{
-    size2rc(pool, size, row, column);
-    if (*row > pool->last_row) {
-	return 0;
-    }
-    return &((pool->free[*row])[*column]);
-}
-
-
-// Remove an arbitrary block from its free list due to a merging operation.
-
-static void 
-unlink_free_block(BytePool *pool, ByteBlock *block)
-{
-    FreeByteBlock **free_list;
-    FreeByteBlock *free_block;
-    int row, column;
-
-    free_list = find_free_list(pool, block_size(block), &row, &column);
-
-    if (SSX_ERROR_CHECK_KERNEL) {
-	if (free_list == 0) {
-	    SSX_PANIC(BYTE_POOL_NULL_FREE_LIST);
-	}
-    }
-
-    // Unlink the block from the free list
-
-    free_block = (FreeByteBlock *)block;
-    *(free_block->previous) = free_block->next;
-    if (free_block->next) {
-	free_block->next->previous = free_block->previous;
-    }
-
-    // If the free list is now 0, mark the free list as empty.
-
-    if (*free_list == 0) {
-	mark_empty(pool, row, column);
-    }
-}
-
-
-// Link a block into the head of its free list due to freeing memory
-
-static void 
-link_free_block(BytePool *pool, ByteBlock *block)
-{
-    FreeByteBlock **free_list;
-    FreeByteBlock *free_block;
-    int row, column;
-
-    free_list = find_free_list(pool, block_size(block), &row, &column);
-
-    if (SSX_ERROR_CHECK_KERNEL) {
-	if (free_list == 0) {
-	    SSX_PANIC(BYTE_POOL_NULL_FREE_LIST);
-	}
-    }
-
-    // Link the block into the free list, and mark the free list as
-    // non-empty. 
-
-    free_block = (FreeByteBlock *)block;
-
-    free_block->next = *free_list;
-    if (*free_list) {
-	(*free_list)->previous = &(free_block->next);
-    }
-    *free_list = free_block;
-    free_block->previous = free_list;
-
-    mark_non_empty(pool, row, column);
-}
-
-
-// Round up the block size (if required) to the next column. Note that the
-// block_size input here is aligned, and remains aligned even after rounding.
-
-static size_t
-round_up_size(BytePool *pool, size_t block_size)
-{
-    size_t residue, column_span, column_mask;
-    int row = floor_log2(block_size);
-
-    column_span = 1 << (row - pool->log2_columns);
-    column_mask = column_span - 1;
-    residue = block_size & column_mask;
-
-    if (residue == 0) {
-    	return block_size;
-    } else {
-    	return block_size + (column_span - residue);
-    } 
-}
-
-
-// The implemenation of freeing a block of memory. When freed, a block is
-// immediately merged with its neighbors if possible, and the final merged
-// block is inserted into the proper free list.
-//
-// The linkage check is done here so that it can also protect internal uses of
-// this API (but only if SSX errors lead to panics, the expected default).
-
-static int
-byte_pool_free_block(BytePool *pool, ByteBlock *block)
-{
-    int rc;
-    SsxMachineContext ctx;
-
-    rc = check_linkage(block);
-    if (rc) return rc;
-
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    pool->free_calls++;
-
-    mark_free(pool, block);
-
-    if (block_is_free(block->next)) {
-
-	// Merge next block into current block
-
-	unlink_free_block(pool, block->next);
-
-	block->next = (ByteBlock *)((unsigned long)(block->next) +
-				    block_size(block->next));
-	block->next->previous = allocated(block);
-
-	pool->blocks_free--;
-    }
-
-    if (block_is_free(block->previous)) {
-
-	// Merge current block into previous block
-
-	unlink_free_block(pool, block->previous);
-
-	block->previous->next = 
-	    (ByteBlock *)((unsigned long)(block->previous->next) +
-			  block_size(block));
-	block = block->previous;
-	block->next->previous = allocated(block);
-
-	pool->blocks_free--;
-    }
-
-    // Finally, insert the block into the proper free list.
-
-    link_free_block(pool, block);
-
-    ssx_critical_section_exit(&ctx);
-
-    return 0;
-}
-
-
-/// Free a block of memory back to a byte pool
-///
-/// \param pool A pointer to the BytePool structure that allocated the memory.
-///
-/// \param memory A pointer to memory returned by byte_pool_alloc() or
-/// byte_pool_alloc_aligned() for the pool.  This pointer may be NULL (0), in
-/// which case the byte_pool_free() request succeeds immediately.
-///
-/// The part of this API that manipulates the \a pool runs as an
-/// SSX_NONCRITICAL critical section. byte_pool_free() uses a constant-time
-/// algorithm.
-///
-/// Return values other then SSX_OK (0) are errors; see \ref ssx_errors
-///
-/// \retval 0 Success
-///
-/// \retval -BYTE_POOL_INVALID_OBJECT The \a pool argument was NULL (0).
-///
-/// \retval -BYTE_POOL_INVALID_ARGUMENT The block is not marked as being
-/// allocated, or does not appear to have been allocated from this byte_pool.
-///
-/// \retval -BYTE_POOL_LINKAGE_ERROR The block being freed is not linked
-/// correctly with the other blocks managed by the pool, most likely
-/// indicating that the memory being freed was not allocated by
-/// byte_pool_alloc(), or that memory corruption has occured.
-
-// This implementation uses the convention that if the \a next pointer of the
-// putative ByteBlock == 1, then this is actually an aligned allocation and
-// the actual ByteBlock is located at the address contained in the \a previous
-// field of the dummy header.
-
-int
-byte_pool_free(BytePool *pool, void *memory)
-{
-    ByteBlock *block;
-
-    if (memory == 0) {
-	return 0;
-    }
-
-    block = (ByteBlock *)(((unsigned long)memory) - sizeof(ByteBlock));
-    if ((int)(block->next) == 1) {
-        if (0) {
-            printk("byte_pool_free(%p, %p) [%p] : Aligned\n",
-                   pool, memory, block);
-        }
-        block = block->previous;
-    }
-
-    if (0) {
-	printk("byte_pool_free(%p, %p) [%p] : %d %d %d\n",
-               pool, memory, block,
-               block_is_free(block), 
-               block < pool->first_block,
-               block > pool->last_block);
-    }
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(pool == 0, BYTE_POOL_INVALID_OBJECT);
-	SSX_ERROR_IF(block_is_free(block)        ||
-		     (block < pool->first_block) ||
-		     (block > pool->last_block), 
-		     BYTE_POOL_INVALID_ARGUMENT);
-    }
-
-    return byte_pool_free_block(pool, block);
-}
-
-
-/// Create a BytePool with explicit specification of tuning parameters
-///
-/// This routine is the real body of byte_pool_create(), however this
-/// underlying interface is provided for testing and experimentation and allows
-/// the specification of non-default tuning parameters.  
-///
-/// There is actually only one tuning parameter for TLSF - the number of
-/// columns.  The number of columns must be an even power of two no larger
-/// than the number of bits in an unsigned long.
-///
-/// Return values other then SSX_OK (0) are errors; see \ref ssx_errors
-///
-/// \retval -BYTE_POOL_INVALID_OBJECT The \a pool pointer was NULL (0).
-///
-/// \retval -BYTE_POOL_INVALID_ARGUMENT Either the \a memory pointer was NULL
-/// (0), the amount of memory was insufficient for the management overhead, or
-/// the parameterization was invalid.
-
-int
-byte_pool_create_tuned(BytePool *pool, void *memory, size_t size,
-		       int columns)
-{
-    size_t overhead, free_list_overhead;
-    unsigned long memory_ul, aligned_memory;
-    int i;
-    FreeByteBlock **free;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(pool == 0, BYTE_POOL_INVALID_OBJECT);
-	SSX_ERROR_IF((memory == 0) ||
-		     (columns < 1) ||
-		     ((columns & (columns - 1)) != 0) ||
-		     (floor_log2(columns) > floor_log2(BITS_PER_UNSIGNED_LONG)),
-		     BYTE_POOL_INVALID_ARGUMENT);
-    }
-
-    // Compute tuning parameters
-
-    compute_tuning(pool, size, columns);
-
-    // Clear free list vector pointers and column status
-    
-    for (i = 0; i < BITS_PER_UNSIGNED_LONG; i++) {
-	pool->free[i] = 0;
-	pool->column_status[i] = 0;
-    }
-
-    // Determine the first and last allocated rows. 
-
-    pool->first_row = floor_log2(pool->minimum_block_size);
-    pool->last_row = floor_log2(size);
-
-    // The dynamic overhead consists of aligment overhead, 2 sentinel nodes,
-    // the vectors of pointers to free lists, plus 2 alignments. There must
-    // also be enough room for at least 1 block to allocate.
-
-    memory_ul = (unsigned long)memory;
-    aligned_memory = align(memory_ul, 1);
-
-    free_list_overhead = 
-	(((pool->last_row - pool->first_row + 1) * pool->columns) * 
-	 sizeof(FreeByteBlock *));
-
-    overhead = 
-	(aligned_memory - memory_ul) +
-	(2 * sizeof(ByteBlock)) +
-	free_list_overhead +
-	(2 * ALIGNMENT) +
-	pool->minimum_block_size;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(overhead >= size, BYTE_POOL_INVALID_ARGUMENT);
-    }
-	
-    // Allocate the overhead items. The free list vectors and column status
-    // arrays are carved out and zeroed. For good measure we re-align after
-    // each of these operations. The sentinel blocks are carved off of either
-    // end of the remaining free space and marked allocated.  The remaining
-    // initial "big block" is also initialized (as if it were allocated).
-
-    size = size - (aligned_memory - memory_ul);
-    size = align(size, -1);
-    
-    pool->row_status = 0;
-
-    free = (FreeByteBlock **)aligned_memory;
-    memset((void *)free, 0, free_list_overhead);
-
-    aligned_memory += free_list_overhead;
-    size -= free_list_overhead;
-    aligned_memory = align(aligned_memory, 1);
-    size = align(size, -1);
-
-    for (i = pool->first_row; i <= pool->last_row; i++) {
-	pool->free[i] = free;
-	free += pool->columns;
-    }
-
-    pool->first_block = (ByteBlock *)aligned_memory;
-    aligned_memory += sizeof(ByteBlock);
-    size -= sizeof(ByteBlock);
-
-    pool->big_block = (ByteBlock *)aligned_memory;
-
-    pool->last_block = 
-	(ByteBlock *)(aligned_memory + size - sizeof(ByteBlock));
-    size -= sizeof(ByteBlock);
-
-    pool->first_block->next = pool->big_block;
-    pool->first_block->previous = 0;
-    mark_allocated(pool, pool->first_block);
-
-    pool->last_block->next = 0;
-    pool->last_block->previous = pool->big_block;
-    mark_allocated(pool, pool->last_block);
-
-    pool->big_block->previous = pool->first_block;
-    pool->big_block->next = pool->last_block;
-
-    // Initialize statistics
-
-    pool->bytes_allocated = 0;
-    pool->bytes_free = block_size(pool->big_block);
-    pool->initial_allocation = pool->bytes_free;
-    pool->blocks_allocated = 0;
-    pool->blocks_free = 1;
-    pool->alloc_calls = 0;
-    pool->free_calls = 0;
-
-    // Free the big block and we're ready to go.
-
-    mark_allocated(pool, pool->big_block);
-    byte_pool_free_block(pool, pool->big_block);
-
-    return 0;
-}
-
-
-/// Create a BytePool
-///
-/// \param pool A pointer to an uninitialized BytePool structure
-///
-/// \param memory A pointer to the memory to be managed by the BytePool
-///
-/// \param size The size of the managed area in bytes
-///
-/// byte_pool_create() sets up the \a memory area to be used as a memory pool
-/// for malloc()-style allocation using byte_pool_alloc() and
-/// byte_pool_free().  Note that the actual memory area available for
-/// allocation will be smaller than \a size due to alignment, and reservation
-/// of a portion of the area for management overhead.
-///
-/// Return values other then SSX_OK (0) are errors; see \ref ssx_errors
-///
-/// \retval -BYTE_POOL_INVALID_OBJECT The \a pool pointer was NULL (0).
-///
-/// \retval -BYTE_POOL_INVALID_ARGUMENT Either the \a memory pointer was NULL
-/// (0), the amount of memory was insufficient for the management overhead, or
-/// the parameterization was invalid.
-
-int
-byte_pool_create(BytePool *pool, void *memory, size_t size)
-{
-    return byte_pool_create_tuned(pool, memory, size, BYTE_POOL_TLSF_COLUMNS);
-}
-
-
-/// Allocate memory from a byte pool
-///
-/// \param pool A pointer to an initialized BytePool
-///
-/// \param memory An address to recieve a pointer to the allocated memory.
-/// This address will be set to NULL (0) if the allocation request can not be
-/// satisfied (or the \a size is 0).
-///
-/// \param size The number of bytes to allocate.
-///
-/// The part of this API that manipulates the \a pool runs as an
-/// SSX_NONCRITICAL critical section. byte_pool_alloc() uses a constant-time
-/// algorithm.
-///
-/// Return values other than 0 are not necessarily errors; see \ref
-/// ssx_errors.   
-///
-/// The following return codes are not considered errors:
-///
-/// \retval 0 Success
-///
-/// \retval -BYTE_POOL_NO_MEMORY The allocation request could not be
-/// satisfied.  The memory pointer will also be NULL (0) in this case.
-///
-/// The following return codes are considered errors:
-///
-/// \retval -BYTE_POOL_INVALID_OBJECT The \a pool argument was NULL (0).
-///
-/// \retval -BYTE_POOL_INVALID_ARGUMENT The \a memory argument is NULL (0).
-
-int
-byte_pool_alloc(BytePool *pool, void **memory, size_t size)
-{
-    SsxMachineContext ctx;
-    size_t request_size, actual_size;
-    int found, row, column;
-    unsigned long row_status, column_status;
-    FreeByteBlock **free_list;
-    FreeByteBlock *free_block;
-    ByteBlock *block;
-    ByteBlock *residue_block;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(pool == 0, BYTE_POOL_INVALID_OBJECT);
-	SSX_ERROR_IF(memory == 0, BYTE_POOL_INVALID_ARGUMENT);
-    }
-
-    // Quickly dispense with NULL requests
-
-    if (size == 0) {
-	*memory = 0;
-	return 0;
-    }
-
-    // Compute the requested block size (which includes the header).  If the
-    // size went down we overflowed due to a huge request (which can't be
-    // filled).  Otherwise if the request is small it is boosted up to the
-    // (aligned) minimum size.  To guarantee fast search, the requested size
-    // must then be rounded up to a size that is represented in the 2-D array
-    // of free list pointers.
-
-    request_size = align(size + sizeof(ByteBlock), 1);
-    if (request_size < size) {
-        *memory = 0;
-        return -BYTE_POOL_NO_MEMORY;
-    }
-
-    if (request_size < pool->minimum_block_size) {
-	request_size = pool->minimum_block_size;
-    }
-
-    request_size = round_up_size(pool, request_size);
-
-    // Up to this point, all accesses of the memory pool object have been to
-    // read only constants. Now we get serious.
-
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    pool->alloc_calls++;
-
-    // See if a block of the correct or larger size exists in the row.  The
-    // search is first via a single bit in the row_status. If that hits then
-    // we check for columns >= the target column.
-
-    found = 0;
-    size2rc(pool, request_size, &row, &column);
-
-    if (pool->row_status & UL_BE_MASK(row)) {
-
-	column_status = pool->column_status[row] &
-	    ((UL_BE_MASK(column) << 1) - 1);
-
-	if (column_status != 0) {
-	    column = __builtin_clzl(column_status);
-	    found = 1;
-	}
-    }
-
-    // If the block was not found in the 'optimum' row, look in all rows of
-    // larger size and take the first block that fits.
-
-    if (!found) {
-
-	row_status = pool->row_status & (UL_BE_MASK(row) - 1);
-
-	if (row_status != 0) {
-	    row = __builtin_clzl(row_status);
-	    column = __builtin_clzl(pool->column_status[row]);
-	    found = 1;
-	}
-    }
-
-    // Another out of memory case.
-
-    if (!found) {
-	ssx_critical_section_exit(&ctx);
-	*memory = 0;
-	return -BYTE_POOL_NO_MEMORY;
-    }
-
-    // Now we can get the pointer to the free list and take the block. 
-
-    free_list = &((pool->free[row])[column]);
-
-    if (SSX_ERROR_CHECK_KERNEL) {
-	if ((free_list == 0) || (*free_list == 0)) {
-	    SSX_PANIC(BYTE_POOL_INVALID_FREE_LIST);
-	}
-    }
-
-    free_block = *free_list;
-    *free_list = free_block->next;
-    if (free_block->next) {
-	free_block->next->previous = free_list;
-    } else {
-	mark_empty(pool, row, column);
-    }
-
-    // Mark the block as allocated
-
-    block = (ByteBlock *)free_block;
-    mark_allocated(pool, block);
-
-    // If there is enough residue, split the excess memory off of the end of
-    // the block.  This is a kind of dummy transaction for our statistical
-    // purposes.
-
-    actual_size = block_size(block);
-    if ((actual_size - request_size) >= pool->minimum_block_size) {
-
-	residue_block = (ByteBlock *)((unsigned long)block + request_size);
-
-	residue_block->next = block->next;
-	residue_block->previous = block;
-	residue_block->previous->next = residue_block;
-	residue_block->next->previous = allocated(residue_block);
-
-	pool->blocks_allocated++;
-	byte_pool_free_block(pool, residue_block);
-	pool->free_calls--;
-    }
-
-    // Set the memory pointer to the area to be used by the application and
-    // return.
-
-    *memory = (void *)((unsigned long)block + sizeof(ByteBlock));
-
-    ssx_critical_section_exit(&ctx);
-
-    if (0) {
-        ByteBlock* block = 
-            (ByteBlock*)((unsigned long)*memory - sizeof(ByteBlock));
-
-        printk("byte_pool_alloc(%p, -> %p, %zu)\n"
-               "    request_size = %u, Previous = %p, Next = %p\n",
-               pool, *memory, size,
-               request_size, block->previous, block->next);
-    }
-
-    return 0;
-}
-
-
-/// Allocate memory from a byte pool and clear
-///
-/// byte_pool_calloc() allocates memory using byte_pool_alloc() then clears
-/// the memory area using memset().  The arguments conform to the POSIX
-/// standard for calloc(). See byte_pool_alloc() for return codes and usage
-/// notes.
-
-int
-byte_pool_calloc(BytePool *pool, void **memory, size_t nmemb, size_t size)
-{
-    int rc;
-
-    rc = byte_pool_alloc(pool, memory, nmemb * size);
-    if (rc || (*memory == 0)) {
-	return rc;
-    }
-
-    memset(*memory, 0, nmemb * size);
-
-    return 0;
-}
-
-
-/// Allocate an aligned memory area
-///
-/// \param pool A pointer to an initialized BytePool
-///
-/// \param memory An address to recieve a pointer to the allocated memory.
-/// This address will be set to NULL (0) if the allocation request can not be
-/// satisfied (or the \a size is 0).
-///
-/// \param size The size of the memory area required (in bytes). This can be
-/// any size - it \e does \e not have to be a multiple of the aligned size (as
-/// is required by other common aligned memory allocators).
-///
-/// \param alignment The alignment constraint, specified as the base 2
-/// logarithm of the alignment.  For example, to align on a 128-byte boundary
-/// the \a alignment would be specified as 7.
-///
-/// byte_pool_alloc_aligned() is a convenience interface for allocating memory
-/// with a guaranteed alignment. The BytePool APIs do not normally do aligned
-/// allocation. byte_pool_alloc_aligned() first uses byte_pool_alloc() to
-/// allocate a block of memory large enough to satisfy the request and
-/// guarantee that a subset of the memory allocation will satisfy the
-/// alignment constraint plus the overhead of a dummy block header.  Note that
-/// it is space-inefficient to allocate many small aligned areas. If possble
-/// it would be better to allocate a single aligned area and then have the
-/// application partition the memory as required.
-///
-/// Memory areas allocated by byte_pool_alloc_aligned() can be freed with
-/// byte_pool_free(), just like any other dynamic memory allocation.
-///
-/// The part of this API that manipulates the \a pool runs as an
-/// SSX_NONCRITICAL critical section. The underlying call of byte_pool_alloc()
-/// uses a constant-time algorithm.
-///
-/// Return values other than 0 are not necessarily errors; see \ref
-/// ssx_errors.   
-///
-/// The following return codes are not considered errors:
-///
-/// \retval 0 Success
-///
-/// \retval -BYTE_POOL_NO_MEMORY The allocation request could not be
-/// satisfied.  The memory pointer will also be NULL (0) in this case.
-///
-/// The following return codes are considered errors:
-///
-/// \retval -BYTE_POOL_INVALID_OBJECT The \a pool argument was NULL (0).
-///
-/// \retval -BYTE_POOL_INVALID_ARGUMENT The \a memory argument is NULL (0), or
-/// the \a alignment argument is invalid.
-
-// The allocation must be big enough for the size requested + the alignment
-// amount (to guarantee alignment) + room for a dummy ByteBlock.  The dummy
-// ByteBlock is marked by setting the \a next pointer to 1 to indicate that
-// this is an aligned allocation.  In this case the \a previous pointer of the
-// dummy ByteBlock points to the ByteBlock of the original allocation.
-
-int
-byte_pool_alloc_aligned(BytePool *pool, void **memory, size_t size, 
-			int alignment)
-{
-    int rc;
-    unsigned long pow2_alignment, mask, aligned;
-    void *unaligned_memory;
-    ByteBlock *dummy_block, *unaligned_block;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF((alignment < 1) || (alignment >= BITS_PER_UNSIGNED_LONG),
-		     BYTE_POOL_INVALID_ARGUMENT);
-    }
-
-    pow2_alignment = (unsigned long)1 << (unsigned long)alignment;
-    mask = pow2_alignment - 1;
-
-    rc = byte_pool_alloc(pool, &unaligned_memory, 
-			 size + pow2_alignment + sizeof(ByteBlock));
-
-    if (rc || (unaligned_memory == 0)) {
-	*memory = 0;
-	return rc;
-    }
-    unaligned_block = (ByteBlock *)(((unsigned long)unaligned_memory) - 
-                                    sizeof(ByteBlock));
-
-    aligned = (unsigned long)unaligned_memory + sizeof(ByteBlock);
-    if (aligned & mask) {
-	aligned += (pow2_alignment - (aligned & mask));
-    }
-    *memory = (void *)aligned;
-    
-    dummy_block = (ByteBlock *)(aligned - sizeof(ByteBlock));
-    dummy_block->previous = unaligned_block;
-    dummy_block->next = (ByteBlock*)1;
-
-    if (0) {
-        printk("byte_pool_alloc_aligned(%p, -> %p, %zu, %d)\n",
-               pool, *memory, size, alignment);
-    }
-
-    return 0;
-}
-
-
-/// Allocate aligned memory from a byte pool and clear
-///
-/// byte_pool_calloc_alligned() allocates memory using
-/// byte_pool_alloc_aligned() then clears the memory area using memset().  The
-/// arguments conform to the POSIX standard for calloc(). See
-/// byte_pool_alloc_aligned() for return codes and usage notes. In particular
-/// note that this memory must be freed with byte_pool_free_aligned().
-
-int
-byte_pool_calloc_aligned(BytePool *pool, void **memory, 
-			 size_t nmemb, size_t size, int alignment)
-{
-    int rc;
-
-    rc = byte_pool_alloc_aligned(pool, memory, nmemb * size, alignment);
-    if (rc || (*memory == 0)) return rc;
-
-    memset(*memory, 0, nmemb * size);
-
-    return 0;
-}
-
-
-/// malloc() allocates \a size bytes and returns a pointer to the allocated
-/// memory.  The memory is not cleared. The value returned is a pointer to the
-/// allocated memory, which is suitably aligned for any kind of variable, or
-/// NULL if the requested \a size is 0 or the request fails.
-///
-/// NB: The aplication must create and assign a BytePool object to the
-/// library variable _malloc_byte_pool in order for malloc() to work.
-
-void *
-malloc(size_t size)
-{
-    void *memory;
-
-    if (byte_pool_alloc(_malloc_byte_pool, &memory, size)) {
-	memory = 0;
-    }
-    return memory;
-}
-
-
-/// calloc() allocates memory for an array of \a nmemb elements of \a size
-/// bytes each and returns a pointer to the allocated memory.  The memory is
-/// set to zero. The value returned is a pointer to the allocated and cleared
-/// memory, which is suitably aligned for any kind of variable, or NULL if the
-/// requested \a size is 0 or the request fails.
-///
-/// NB: The aplication must create and assign a BytePool object to the
-/// library variable _malloc_byte_pool in order for calloc() to work.
-
-void *
-calloc(size_t nmemb, size_t size)
-{
-    void *memory;
-
-    if (byte_pool_calloc(_malloc_byte_pool, &memory, nmemb, size)) {
-	return 0;
-    }
-    return memory;
-}
-
-
-/// free() frees the memory space pointed to by \a ptr, which must have been
-/// returned by a previous call to malloc(), posix_memalign, calloc() or
-/// realloc().  Otherwise, or if free(ptr) has already been called before,
-/// undefined behavior occurs.  If \a ptr is NULL, no operation is performed.
-///
-/// NB: The aplication must create and assign a BytePool object to the
-/// library variable _malloc_byte_pool in order for free() to work.
-
-void
-free(void *ptr)
-{
-    byte_pool_free(_malloc_byte_pool, ptr);
-}
-
-
-/// realloc() changes the size of the memory block pointed to by \a ptr to \a
-/// size bytes.  The contents will be unchanged to the minimum of the old and
-/// new sizes; newly allocated memory will be uninitialized.  If \a ptr is
-/// NULL, the call is equivalent to malloc(size); if \a size is equal to zero,
-/// the call is equivalent to free(ptr).  Unless \a ptr is NULL, it must have
-/// been returned by an earlier call to malloc(), calloc() or realloc().  If
-/// the area pointed to was moved, a free(ptr) is done.
-///
-/// realloc() returns a pointer to the newly allocated memory, which is
-/// suitably aligned for any kind of variable and may be different from \a
-/// ptr, or NULL if the request fails.  If \a size was equal to 0, either NULL
-/// or a pointer suitable to be passed to free() is returned.  If realloc()
-/// fails the original block is left untouched; it is not freed or moved.
-
-void*
-realloc(void *ptr, size_t size)
-{
-    void *memory;
-    size_t useful_size;
-
-    // Handle simple case
-
-    if (ptr == 0) {
-
-        memory = malloc(size);
-
-    } else if (size == 0) {
-
-        free(ptr);
-        memory = 0;
-
-    } else {
-
-        // Find out the useful size of the block. If we need more than this we
-        // need to allocate a new block and memcpy() the old data to the new
-        // block and free the old block. If we need less then this we also
-        // need to allocate a new block and move the head of the current
-        // data. If the new size is the same as the current size we do nothing.
-
-        byte_pool_block_info(ptr, 0, 0, &useful_size);
-
-        if (size == useful_size) {
-
-            memory = ptr;
-
-        } else {
-
-            memory = malloc(size);
-            if (memory != 0) {
-                memcpy(memory, ptr, (size > useful_size) ? useful_size : size);
-                free(ptr);
-            }
-        }
-    }
-    return memory;
-}
-
-
-/// The posix_memalign() function allocates \a size bytes aligned on a
-/// boundary specified by \a alignment, and returns a pointer to the allocated
-/// memory in \a memptr. The value of \a alignment shall be a multiple of
-/// sizeof(void*), that is also a power of two. Upon successful completion,
-/// the value pointed to by \a memptr will be a multiple of alignment.
-///
-/// Note that memory allocated with posix_memalign() can be freed with
-/// free(). 
-///
-/// In the event of errors, the contents of \a memptr will be returned as 0.
-///
-/// The following return codes are mandated by POSIX, and are always returned
-/// in the event of the specified condition. 
-///
-/// \retval 0 Success
-///
-/// \retval -EINVAL The value of the \a alignment parameter is not a power of
-/// two multiple of sizeof(void*).
-///
-/// \retval -ENOMEM There is insufficient memory available with the requested
-/// alignment.
-///
-/// The following return codes are implementation-specific and may be
-/// configured to cause a kernel panic.
-///
-/// \retval -BYTE_POOL_INVALID_OBJECT The \a _malloc_byte_pool is NULL (0).
-///
-/// \retval -BYTE_POOL_INVALID_ARGUMENT The \a memptr argument is NULL (0).
-
-int
-posix_memalign(void** memptr, size_t alignment, size_t size)
-{
-    int rc;
-
-    if (((alignment & (alignment - 1)) != 0) ||
-        (alignment < sizeof(void*))) {
-        rc = -EINVAL;
-    } else {
-        rc = byte_pool_alloc_aligned(_malloc_byte_pool, memptr, size,
-                                     floor_log2(alignment));
-        if (!rc && (*memptr == 0)) {
-            rc = -ENOMEM;
-        }
-    }
-    if (rc && memptr) {
-        *memptr = 0;
-    }
-    return rc;
-}
-
-
-/// Print a dump of a byte pool, including the header and allocation report
-///
-/// \param stream The stream to receive the dump
-///
-/// \param pool The BytePool object to dump
-///
-/// \bug This routine is not thread safe.
-
-void
-byte_pool_report(FILE* stream, BytePool* pool)
-{
-    ByteBlock* block;
-    uint8_t* p8;
-    uint32_t* p32;
-    int i;
-
-    fprintf(stream, ">>> Byte Pool Report for Pool %p <<<\n", pool);
-
-    fprintf(stream, ">>> BytePool Object Dump <<<\n");
-
-#define DUMPIT(x, fmt)                                  \
-    fprintf(stream, "%20s : " #fmt "\n", #x, pool->x)
-
-    DUMPIT(first_row, %d);
-    DUMPIT(last_row, %d);
-    DUMPIT(columns, %d);
-    DUMPIT(log2_columns, %d);
-    DUMPIT(column_mask, 0x%08x);
-    DUMPIT(minimum_block_size, %d);
-    DUMPIT(free, %p);
-    DUMPIT(column_status, %p);
-    DUMPIT(row_status, %lu);
-    DUMPIT(first_block, %p);
-    DUMPIT(big_block, %p);
-    DUMPIT(last_block, %p);
-    DUMPIT(initial_allocation, %d);
-    DUMPIT(bytes_allocated, %d);
-    DUMPIT(bytes_free, %d);
-    DUMPIT(blocks_allocated, %d);
-    DUMPIT(blocks_free, %d);
-    DUMPIT(alloc_calls, %d);
-    DUMPIT(free_calls, %d);
-
-    fprintf(stream, ">>> Byte Pool Allocation Report <<<\n");
-    fprintf(stream, 
-            ">>> status :   address  :  size  :      binary[0:7]      : ASCII[0:7] <<<\n");
-
-    for (block = pool->first_block->next; 
-         block != pool->last_block;
-         block = block->next) {
-
-        fprintf(stream, "      %c    : %p : %6zu : ",
-                (block_is_free(block) ? 'F' : 'A'),
-                block, block_size(block));
-
-        p8 = (uint8_t*)((unsigned long)block + sizeof(ByteBlock));
-        p32 = (uint32_t*)p8;
-
-        fprintf(stream, "0x%08x 0x%08x : ", p32[0], p32[1]);
-        for (i = 0; i < 8; i++) {
-            if (isprint(p8[i])) {
-                fputc(p8[i], stream);
-            } else {
-                fputc('.', stream);
-            }
-        }                
-        fputc('\n', stream);
-    }
-
-    fprintf(stream, ">>> End Report <<<\n");
-}
diff --git a/src/lib/ppc405lib/byte_pool.h b/src/lib/ppc405lib/byte_pool.h
deleted file mode 100644
index 8766745..0000000
--- a/src/lib/ppc405lib/byte_pool.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/byte_pool.h $                               */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __BYTE_POOL_H__
-#define __BYTE_POOL_H__
-
-// $Id$
-
-#ifndef __ASSEMBLER__
-
-#include "ssx_io.h"
-
-struct ByteBlock;
-struct FreeByteBlock;
-
-// A handy constant
-
-#define BITS_PER_UNSIGNED_LONG (8 * sizeof(unsigned long))
-
-
-/// A control structure for a byte pool. The application will never modify the
-/// structure fields directly, but some applications may be interested in
-/// reading the statistics.
-
-typedef struct {
-
-    // The index of the first allocated row of free list pointers
-    int first_row;
-
-    // The index of the last allocated row of free list pointers
-    int last_row;
-
-    // The number of columns in each row of free list pointers
-    int columns;
-
-    // The log2 of the number of columns in each row of free list pointers
-    int log2_columns;
-
-    // The shifted block size is ANDed with this mask to extract the column
-    // number. 
-    size_t column_mask;
-
-    // The minimum block size.
-    int minimum_block_size;
-
-    // The vectors of free list pointers
-    struct FreeByteBlock **free[BITS_PER_UNSIGNED_LONG];
-
-    // The array of column status bit masks
-    unsigned long column_status[BITS_PER_UNSIGNED_LONG];
-
-    // The row status bit mask
-    unsigned long row_status;
-
-    // A sentinel node - the first allocated block.  Kept for error checking
-    // purposes.
-    struct ByteBlock *first_block;
-
-    // The initial memory allocation. Kept here only for debugging purposes. 
-    struct ByteBlock *big_block;
-
-    // A sentinel node - the last allocated block.  Kept here for error
-    // checking purposes.
-    struct ByteBlock *last_block;
-
-    // The initial allocation. Kept here for debugging and statistics.
-    size_t initial_allocation;
-
-    // The total number of bytes currently allocated (excludes overhead)
-     size_t bytes_allocated;
-
-    // The total number of bytes currently free in the pool
-     size_t bytes_free;
-
-    // The total number of blocks allocated from the pool
-     size_t blocks_allocated;
-
-    // The total number of blocks free in the pool
-     size_t blocks_free;
-
-    // The number of calls to allocate memory
-     size_t alloc_calls;
-
-    // The number of calls to free memory
-     size_t free_calls;
-
-} BytePool;
-
-extern BytePool *_malloc_byte_pool;
-
-int
-byte_pool_create(BytePool *pool, void *memory, size_t size);
-
-int
-byte_pool_create_tuned(BytePool *pool, void *memory, size_t size,
-		       int columns);
-
-int
-byte_pool_alloc(BytePool *pool, void **memory, size_t size);
-
-int
-byte_pool_calloc(BytePool *pool, void **memory, size_t nmemb, size_t size);
-
-int
-byte_pool_free(BytePool *pool, void *memory);
-
-void
-byte_pool_block_info(void* memory,
-                     void** actual_address, size_t* actual_size,
-                     size_t* useful_size);
-
-int
-byte_pool_alloc_aligned(BytePool *pool, void **memory, size_t size, 
-			int alignment);
-
-void *
-malloc(size_t size);
-
-void *
-calloc(size_t nmemb, size_t size);
-
-void
-free(void *ptr);
-
-int
-posix_memalign(void** memptr, size_t alignment, size_t size);
-
-void
-byte_pool_report(FILE* stream, BytePool* pool);
-
-#endif	/* __ASSEMBLER__ */
-
-
-// Error/panic codes
-
-#define BYTE_POOL_INVALID_OBJECT    0x00b98e01
-#define BYTE_POOL_INVALID_ARGUMENT  0x00b98e02
-#define BYTE_POOL_REVERSE_LINKAGE   0x00b98e03
-#define BYTE_POOL_FORWARD_LINKAGE   0x00b98e04
-#define BYTE_POOL_NO_MEMORY         0x00b98e05
-
-#define BYTE_POOL_NULL_FREE_LIST    0x00b98e10
-#define BYTE_POOL_INVALID_FREE_LIST 0x00b98e11
-
-#endif	/* __BYTE_POOL_H__ */
diff --git a/src/lib/ppc405lib/initcall.c b/src/lib/ppc405lib/initcall.c
deleted file mode 100644
index 664fb6e..0000000
--- a/src/lib/ppc405lib/initcall.c
+++ /dev/null
@@ -1,70 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/initcall.c $                                */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file initcall.c
-/// \brief An anonymous early initialization facility for SSX applications
-
-#include "ssx.h"
-#include "initcall.h"
-
-// These linker symbols must be defined if the initcall facility is used.  The
-// special ELF section .data.initcall contains an array of Initcall structures
-// for all declared initcalls.
-
-extern InitCall        _INITCALL_SECTION_BASE[];
-extern SsxLinkerSymbol _INITCALL_SECTION_SIZE;
-
-void
-_initcall_run(InitCall* initcall)
-{
-    void (*f)(void* arg);
-
-    f = initcall->initcall;
-    if (f) {
-        initcall->initcall = 0;
-        f(initcall->arg);
-    }
-}
-
-
-void
-initcall_run_all()
-{
-    InitCall* initcall;
-    size_t nCalls;
-
-    initcall = _INITCALL_SECTION_BASE;
-    nCalls = (size_t)(&_INITCALL_SECTION_SIZE) / sizeof(InitCall);
-
-    for (; nCalls--; initcall++) {
-        _initcall_run(initcall);
-    }
-}
-
-
-
-    
-    
diff --git a/src/lib/ppc405lib/initcall.h b/src/lib/ppc405lib/initcall.h
deleted file mode 100644
index af8b53c..0000000
--- a/src/lib/ppc405lib/initcall.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/initcall.h $                                */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __INITCALL_H__
-#define __INITCALL_H__
-
-// $Id$
-
-/// \file initcall.h
-/// \brief An early initialization facility for SSX applications
-///
-/// The C language standard does not define a generic load-time initialization
-/// method, unlike C++ which supports load-time initialization of static
-/// objects.  The \e initcall facility implements a simple method for SSX
-/// applications to declare early initialization functions that are executed
-/// prior to or during the invocation of main().
-///
-/// An \e initcall can be any function with the prototype
-///
-/// \code
-///
-/// void (*initcall)(void* arg)
-///
-/// \endcode
-///
-/// Initcalls are declared with the INITCALL() macro. An initcall is
-/// represented by a named structure, and typically an initcall will be
-/// declared static to the compilation unit that implements the initcall:
-///
-/// \code
-///
-/// void (*init_fn)(void* arg);
-/// void* init_data = ...;
-/// static INITCALL(init_var, init_fn, init_data);
-///
-/// \endcode
-///
-/// All INITCALLS loaded in the executable image are executed by the
-/// initcall_run_all() API.  An SSX application will typically call
-/// initcall_run_all() in the function declared as the \a ssx_main_hook, or in
-/// the main() routine itself.
-///
-/// Initcalls are run in an arbitrary order. However if initcall \a b is
-/// dependent on initcall \a a, then initcall \a b can execute
-/// initcall_run(&a) to guarantee that initcall \a a runs before \a b.
-/// Regardless, every initcall is run exectly once by the initcall facility,
-/// even if initcall_run() or initcall_run_all() were to be used multiple
-/// times.
-///
-/// Behind the scenes, initcalls are implemented by a special ELF section,
-/// .data.initcall, that records all declared initcalls.  The
-/// initcall_run_all() API simply runs all initcalls declared in
-/// .data.initcall.
-
-/// The structure representing an initcall
-
-typedef struct {
-
-    /// The initialization function
-    ///
-    /// Prior to running the initcall, this field is zeroed.  This guarantess
-    /// that each initcall is run at most 1 time.
-    void (*initcall)(void* arg);
-
-    /// The argument to the initialization function
-    void* arg;
-
-} InitCall;
-
-
-/// Declare an initcall
-///
-/// This macro generates C code and global data so must be placed at file
-/// scope in a C file, not in a header file or inside a C function
-/// body. Unless the initcall needs to be referenced by another initcall (to
-/// guarantee ordering), this declaration will normally be prepended with
-/// 'static'.
-#define INITCALL(_var, _initcall, _arg)                                 \
-    InitCall _var __attribute__ ((used, section (".data.initcall"))) = \
-    {.initcall = _initcall, .arg = _arg};
-
-
-/// Run the initcall represented by an InitCall structure, assuming it has not
-/// already run.
-///
-/// \param[in] i_initcall The address of the initcall structure to run
-void
-initcall_run(InitCall* i_initcall);
-
-
-/// Run all initcalls
-void
-initcall_run_all();
-
-#endif // __INITCALL_H__
diff --git a/src/lib/ppc405lib/lfsr.c b/src/lib/ppc405lib/lfsr.c
deleted file mode 100644
index 21ddb93..0000000
--- a/src/lib/ppc405lib/lfsr.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/lfsr.c $                                    */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file lfsr.c
-/// \brief 
-
-#include <stdint.h>
-#include "lfsr.h"
-
-// Parity for 4-bit numbers
-static uint8_t S_parity4[16] = {
-    0, 1, 1, 0,
-    1, 0, 0, 1,
-    1, 0, 0, 1,
-    0, 1, 1, 0
-};
-
-// 64, 63, 61, 60 LFSR.  The routine is coded with the uint8_t casting to help
-// the compiler generate more efficient code.
-
-void
-_lfsr64(uint64_t* io_seed)
-{
-    *io_seed = (*io_seed << 1) |
-        S_parity4[(uint8_t)((*io_seed >> 59) & 0x3) | 
-                  (uint8_t)((*io_seed >> 60) & 0xc)];
-}
diff --git a/src/lib/ppc405lib/lfsr.h b/src/lib/ppc405lib/lfsr.h
deleted file mode 100644
index 951ec45..0000000
--- a/src/lib/ppc405lib/lfsr.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/lfsr.h $                                    */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __LFSR_H__
-#define __LFSR_H__
-
-/// \file lfsr.h
-/// \brief Linear-Feedback Shift Register Implementations
-///
-/// The 32- and 64-bit pseudo-random number generators in this library are of
-/// the linear-conguential type. These maximal-length LFSR pseudo-random
-/// sequence generators are also provided.
-
-/// 64-bit LFSR
-///
-/// \param[in,out] io_seed The input seed is converted in one step to the
-/// output seed.
-///
-/// This 64-bit LFSR uses taps 64, 63, 61, and 60. In big-endian numbering
-/// these are bits 0, 1, 3 and 4.  This LFSR is also implemented for the PORE
-/// engines in the file pore_rand.pS.
-void
-_lfsr64(uint64_t* io_seed);
-
-#endif // __LFSR_H__
diff --git a/src/lib/ppc405lib/libppc405files.mk b/src/lib/ppc405lib/libppc405files.mk
index 59aa7a0..b042616 100644
--- a/src/lib/ppc405lib/libppc405files.mk
+++ b/src/lib/ppc405lib/libppc405files.mk
@@ -5,7 +5,7 @@
 #
 # OpenPOWER OnChipController Project
 #
-# Contributors Listed Below - COPYRIGHT 2015
+# Contributors Listed Below - COPYRIGHT 2015,2016
 # [+] International Business Machines Corp.
 #
 #
@@ -43,19 +43,12 @@
 
 C-SOURCES = \
     assert.c \
-	byte_pool.c \
 	ctype.c \
 	ctype_table.c \
 	fgetc.c \
-	initcall.c \
-	lfsr.c \
-	mutex.c \
-	periodic_semaphore.c \
 	polling.c \
 	printf.c \
-	progress.c \
 	puts.c \
-	rtx_stdio.c \
 	simics_stdio.c \
 	sprintf.c \
 	ssx_dump.c \
@@ -66,7 +59,6 @@ C-SOURCES = \
 	string.c \
 	string_stream.c \
 	strtox.c \
-	sxlock.c \
 	time.c
 
 S-SOURCES =  
diff --git a/src/lib/ppc405lib/mutex.c b/src/lib/ppc405lib/mutex.c
deleted file mode 100644
index db57f54..0000000
--- a/src/lib/ppc405lib/mutex.c
+++ /dev/null
@@ -1,129 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/mutex.c $                                   */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file mutex.c
-/// \brief A ThreadX-style mutual exclusion object
-
-#include "mutex.h"
-
-int
-mutex_create(Mutex* i_mutex)
-{
-    int rc;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(i_mutex == 0, SSX_INVALID_OBJECT);
-    }
-
-    rc = ssx_semaphore_create(&(i_mutex->sem), 1, 1);
-    i_mutex->thread = 0;
-    i_mutex->count = 0;
-
-    return rc;
-}
-
-
-// If the current thread owns the Mutex we simply increment the count,
-// otherwise pend for the semaphore.
-//
-// Note: It's possible this doesn't need to be done in a critical section. The
-// fact that ssx_semaphore_pend() is atomic may be sufficient since it locks
-// the Mutex.
-
-int
-mutex_pend(Mutex* i_mutex, SsxInterval i_timeout)
-{
-    int rc;
-    SsxMachineContext ctx;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(i_mutex == 0, SSX_INVALID_OBJECT);
-        SSX_ERROR_UNLESS_THREAD_CONTEXT();
-    }
-
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    if (i_mutex->thread == ssx_current()) {
-
-        i_mutex->count++;
-        if (i_mutex->count == 0) {
-            rc = MUTEX_OVERFLOW;
-        } else {
-            rc = 0;
-        }
-
-    } else {
-
-        rc = ssx_semaphore_pend(&(i_mutex->sem), i_timeout);
-        if (rc == 0) {
-            i_mutex->thread = ssx_current();
-            i_mutex->count = 1;
-        }
-    }
-
-    ssx_critical_section_exit(&ctx);
-
-    return rc;
-}
-
-
-// If the current thread owns the Mutex we decrement the count and free the
-// object when the count goes to 0.
-//
-// Note: It's possible this doesn't need to be done in a critical section. The
-// fact that ssx_semaphore_pend() is atomic may be sufficient since it locks
-// the Mutex.
-
-int
-mutex_post(Mutex* i_mutex)
-{
-    int rc;
-    SsxMachineContext ctx;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(i_mutex == 0, SSX_INVALID_OBJECT);
-        SSX_ERROR_UNLESS_THREAD_CONTEXT();
-    }
-
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    SSX_ERROR_IF(i_mutex->thread != ssx_current(), MUTEX_NOT_OWNED);
-
-    if (--i_mutex->count == 0) {
-        i_mutex->thread = 0;
-        rc = ssx_semaphore_post(&(i_mutex->sem));
-    } else {
-        rc = 0;
-    }
-
-    ssx_critical_section_exit(&ctx);
-
-    return rc;
-}
-
-    
-
-    
diff --git a/src/lib/ppc405lib/mutex.h b/src/lib/ppc405lib/mutex.h
deleted file mode 100644
index 6d3a352..0000000
--- a/src/lib/ppc405lib/mutex.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/mutex.h $                                   */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __MUTEX_H__
-#define __MUTEX_H__
-
-// $Id$
-
-/// \file mutex.h
-/// \brief A ThreadX-style mutual exclusion object
-///
-/// A Mutex is a binary semaphore with the concept of thread ownership.  A
-/// thread first obtains the Mutex using the mutex_pend() API, which may block
-/// if the Mutex is currently owned by another thread.  Once a thread owns a
-/// Mutex, subsequent calls of mutex_pend() by the same thread simply
-/// increment an internal counter, but do not block. Once a thread has
-/// executed a matching mutex_post() call for every mutex_pend() call, the
-/// Mutex is free for another thread.
-///
-/// This type of mutual exclusion object is useful for example to control
-/// access to data structures that are manipulated by APIs with several common
-/// entry points. Each call of an API in the chain will 'lock' the data
-/// structure using mutex_pend()/mutex_post(). The Mutex semantics allows
-/// multiple "locks" by the same thread, but requires a corresponding "unlock"
-/// for every "lock".
-///
-/// The Mutex usage counter is a 32-bit unsigned integer. If a thread makes
-/// 2^32 calls to mutex_pend() without an intervening call of mutex_post(), an
-/// overflow is signalled. This error should be considered unrecoverable to
-/// the application.
-///
-/// Like the SSX semaphore, no record is kept in the thread of which Mutex
-/// objects are currently owned by the thread.  If a thread terminates or is
-/// deleted while holding a Mutex it is likely that the application will
-/// hang. Unlike the SSX semaphore, it is absolutely illegal to call
-/// mutex_pend() and mutex_post() from interrupt contexts. It is also illegal
-/// for a thread to call mutex_post() for a mutex it does not own.
-///
-/// Mutex objects are easily created with the static initialization macro
-/// MUTEX_INITIALIZATION as in the following example.
-///
-/// \code 
-///
-/// Mutex G_mutex = MUTEX_INITIALIZATION;
-///
-/// \endcode
-///
-/// The API mutex_create() is also provided for run-time initialization.
-
-#include "ssx.h"
-
-
-// Mutex error/panic codes
-
-#define MUTEX_OVERFLOW  0x00688901
-#define MUTEX_NOT_OWNED 0x00688902
-
-
-#ifndef __ASSEMBLER__
-
-/// Static initialization of a Mutex
-///
-/// For a full description of the Mutex please see the documentation fof the
-/// file mutex.h.
-#define MUTEX_INITIALIZATION {SSX_SEMAPHORE_INITIALIZATION(1, 1), 0, 0}
-
-
-/// The Mutex object
-
-typedef struct {
-
-    /// The binary semaphore
-    SsxSemaphore sem;
-
-    /// A pointer to the owning thread, or NULL (0)
-    SsxThread* thread;
-
-    /// The count of unmatched mutex_pend() calls made by the owning thread.
-    uint32_t count;
-
-} Mutex;
-
-
-/// Create (initialize) a Mutex
-///
-/// \param[in] i_mutex A pointer to the Mutex object to initialize.
-///
-/// For a full description of the Mutex please see the documentation for the
-/// file mutex.h.
-///
-/// \retval 0 Success
-///
-/// \retval 0 -SSX_INVALID_OBJECT The \a i_mutex is NULL (0).
-int
-mutex_create(Mutex* i_mutex);
-
-
-/// Pend on a Mutex with optional timeout
-///
-/// \param[in] i_mutex A pointer to the Mutex
-///
-/// \param[in] i_timeout Either the constant SSX_WAIT_FOREVER, or a timeout
-/// interval specification.
-///
-/// For a full description of the Mutex please see the documentation for the
-/// file mutex.h.
-///
-/// \retval 0 Success
-///
-/// \retval -SSX_INVALID_OBJECT The \a i_mutex is NULL (0).
-/// 
-/// \retval -SSX_ILLEGAL_CONTEXT The call was not made from a thread context.
-///
-/// \retval -SSX_SEMEPHORE_PEND_TIMED_OUT The thread was not able to obtain
-/// the Mutex before the timeout.
-///
-/// \retval -MUTEX_OVERFLOW The owning thread has made 2^32 unmatched calls of
-/// mutex_pend(). 
-int
-mutex_pend(Mutex* i_mutex, SsxInterval i_timeout);
-
-
-/// Post to a Mutex
-///
-/// \param[in] i_mutex A pointer to the Mutex
-///
-/// For a full description of the Mutex please see the documentation for the
-/// file mutex.h.
-///
-/// \retval 0 Success
-///
-/// \retval -SSX_INVALID_OBJECT The \a i_mutex is NULL (0).
-///
-/// \retval -SSX_ILLEGAL_CONTEXT The call was not made from a thread context.
-///
-/// \retval -MUTEX_NOT_OWNED The thread calling mutex_post() does not own the
-/// Mutex. 
-int
-mutex_post(Mutex* i_mutex);
-
-#endif // __ASSEMBLER__
-
-#endif // __MUTEX_H__
diff --git a/src/lib/ppc405lib/periodic_semaphore.c b/src/lib/ppc405lib/periodic_semaphore.c
deleted file mode 100644
index dec9ea2..0000000
--- a/src/lib/ppc405lib/periodic_semaphore.c
+++ /dev/null
@@ -1,114 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/periodic_semaphore.c $                      */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file perodic_semaphore.h
-/// \brief Periodic semphores
-
-#include "ssx.h"
-#include "periodic_semaphore.h"
-
-// The timer callback is created nonpreemptible, so noncritical interrupts are
-// disabled at entry.
-
-static void
-_periodic_semaphore_timeout(void* arg)
-{
-    PeriodicSemaphore* ps;
-
-    ps = (PeriodicSemaphore*)arg;
-
-    if (ps->sem.count != 1) {
-        ssx_semaphore_post(&(ps->sem));
-    }
-}
-
-
-int
-periodic_semaphore_create(PeriodicSemaphore* sem, SsxInterval period)
-{
-    int rc;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(sem == 0, SSX_INVALID_OBJECT);
-    }
-
-    do {
-        rc = ssx_semaphore_create(&(sem->sem), 0, 1);
-        if (rc) break;
-
-        rc = ssx_timer_create_nonpreemptible(&(sem->timer), 
-                                             _periodic_semaphore_timeout,
-                                             sem);
-        if (rc) break;
-
-        rc = ssx_timer_schedule(&(sem->timer),
-                                period,
-                                period);
-        if (rc) break;
-
-    } while (0);
-
-    return rc;
-}
-
-
-int
-periodic_semaphore_pend(PeriodicSemaphore* sem)
-{
-    int rc;
-    SsxMachineContext ctx;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(sem == 0, SSX_INVALID_OBJECT);
-    }
-
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    if (sem->sem.count == 0) {
-
-        rc = ssx_semaphore_pend(&(sem->sem), SSX_WAIT_FOREVER);
-        
-    } else {
-
-        sem->sem.count = 0;
-        rc = -PERIODIC_SEMAPHORE_OVERRUN;
-    }
-
-    ssx_critical_section_exit(&ctx);
-
-    return rc;
-}
-
-
-int
-periodic_semaphore_cancel(PeriodicSemaphore* sem)
-{
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(sem == 0, SSX_INVALID_OBJECT);
-    }
-
-    return ssx_timer_cancel(&(sem->timer));
-}
diff --git a/src/lib/ppc405lib/periodic_semaphore.h b/src/lib/ppc405lib/periodic_semaphore.h
deleted file mode 100644
index c3c2e53..0000000
--- a/src/lib/ppc405lib/periodic_semaphore.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/periodic_semaphore.h $                      */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __PERIODIC_SEMAPHORE_H__
-#define __PERIODIC_SEMAPHORE_H__
-
-// $Id$
-
-/// \file perodic_semaphore.h
-/// \brief Periodic semphores
-///
-/// The PeriodicSemphore is a simple abstraction introduced to simplify coding
-/// peridic threads. A periodic thread creates the PeriodicSemaphore after
-/// thread initialization, but prior to the entry to the periodic infinite
-/// loop. This creates the periodicSemaphore with a count of 0. Once thread
-/// processing is finished, the thread pends on the PeriodicSemaphore. A
-/// periodic timer posts to the PeriodicSemaphore on a fixed, absolute period
-/// to reschedule the thread.
-///
-/// If the thread pends on the PeriodicSemaphore and the timer has already
-/// posted to the semaphore, the call of periodic_semaphore_pend() clears the
-/// semaphore and terminates immediately with the return code
-/// -PERIODIC_SEMAPHORE_OVERRUN, indicating that the thread has overrun its
-/// period. The thread can choose the appropriate action upon obtaining this
-/// return code.
-///
-/// The PeriodicSemaphore can also be cancelled, which simply cancels the
-/// periodic timer posting to the semaphore. If the thread needs to
-/// re-initialize the PeriodicSemaphore for any reason (e.g, to resynchronize
-/// after an overrun) it must be cancelled first.
-
-// Error/Panic codes
-
-#define PERIODIC_SEMAPHORE_OVERRUN 0x0077e601
-
-
-/// A periodic semaphore
-
-typedef struct {
-
-    /// The semaphore
-    SsxSemaphore sem;
-
-    /// The timer
-    SsxTimer timer;
-
-} PeriodicSemaphore;
-
-
-/// Create (initialize) a PeriodicSemaphore
-///
-/// \param sem A pointer to an uninitialized or inactive
-/// PeriodicSemaphore.
-///
-/// \param period The semaphore period
-///
-/// This API creates the embedded semaphore as a binary semaphore with an
-/// initial value of 0, and schedules a periodic timer to post to the
-/// semaphore.
-///
-/// \retval 0 Success
-///
-/// \retval -SSX_INVALID_OBJECT The \a sem was NULL (0) or otherwise invalid.
-///
-/// Other return codes are possible from the embedded calls of SSX APIs.
-int
-periodic_semaphore_create(PeriodicSemaphore* sem, SsxInterval period);
-
-
-/// Pend on a PeriodicSemaphore
-///
-/// \param sem A pointer to an initialized PeriodicSemaphore
-///
-/// Pend on a PeriodicSemaphore.  It is considered a non-fatal error if the
-/// semaphore has a non-0 count as this may indicate that a periodic thread
-/// has missed a deadline.
-///
-/// Return values other than SSX_OK (0) are not necessarily errors; see \ref
-/// ssx_errors 
-///
-/// The following return codes are non-error codes:
-///
-/// \retval 0 Success. In particular, the semaphore count was 0 at entry.
-///
-/// \retval -PERIODIC_SEMAPHORE_OVERRUN This return code indicates that the
-/// semaphore count was 1 at entry. This code is always returned (never causes
-/// a panic). 
-///
-/// The following return codes are  error codes:
-///
-/// \retval -SSX_IVALID_OBJECT The \a sem was NULL () or otherwise invalid at
-/// entry.
-///
-/// Other error return codes are possible from embedded calls of SSX APIs.
-int
-periodic_semaphore_pend(PeriodicSemaphore* sem);
-
-
-/// Cancel a periodic semaphore
-///
-/// \param sem A pointer to an initialized PeriodicSemaphore
-///
-/// Cancel the PeriodicSemaphore timeout. This is a required step if the
-/// PeriodicSemaphore is to be reinitialized. This is also required if the
-/// PeriodicSemaphore is created on the thread stack and the thread
-/// terminates.  PeriodicSemaphore can be canceled at any time.  It is never
-/// an error to call periodic_semaphore_cancel() on a PeriodicSemaphore object
-/// after it is created.
-///
-/// Return values other than SSX_OK (0) are not necessarily errors; see \ref
-/// ssx_errors 
-///
-/// The following return codes are non-error codes:
-///
-/// \retval 0 Successful completion
-///
-/// \retval -SSX_TIMER_NOT_ACTIVE The embedded timer is not currently
-/// scheduled, meaning that the PeriodicSemaphore was previosly
-/// cancelled.
-///
-/// The following return codes are  error codes:
-///
-/// \retval -SSX_IVALID_OBJECT The \a sem was NULL () or otherwise invalid at
-/// entry.
-///
-/// Other error return codes are possible from embedded calls of SSX APIs.
-int
-periodic_semaphore_cancel(PeriodicSemaphore* sem);
-
-
-#endif // __PERIODIC_SEMAPHORE_H__
diff --git a/src/lib/ppc405lib/progress.c b/src/lib/ppc405lib/progress.c
deleted file mode 100644
index 8d2cd30..0000000
--- a/src/lib/ppc405lib/progress.c
+++ /dev/null
@@ -1,743 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/progress.c $                                */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id
-
-/// \file progress.c
-/// \brief Programmable progress (hang) checking
-///
-/// This is a simple implementation of a progress (hang) checking
-/// facility. The application provides an array of \e pass \e counts that are
-/// expected to update/count over time.  For simplicity and generality all
-/// pass counts are defined to be \c uint64_t types.  The
-/// progress_checker_create() API initializes the checker, and as a
-/// convenience clears the pass counts.
-///
-/// The checker can be created with an optional \a callback function, which
-/// has the prototype
-///
-/// \code
-/// typedef int (*ProgressCheckerCallback)(struct ProgressChecker *checker,
-/// 				           void* arg,
-/// 				           size_t failed)
-/// \endcode
-///
-/// The checker callback is called \e every time a check is made by
-/// progress_checker_check().  In addition to a private void* argument, the
-/// parameter list of the callback includes a count of the number of counters
-/// that failed to make progress - this count will be 0 if the check was
-/// successful. The return value of the callback is passed back as the return
-/// value of progress_checker_check().  If the callback is specified as NULL
-/// (0), then a successful check returns 0, and any failure causes a return
-/// code of -PROGRESS_CHECKER_FAILED.
-///
-/// The application can dynamically mark counters as either \e exempt or \e
-/// required.  By default all counts are required to have increased
-/// each time a check is made for progress.  Counters marked \e exempt when a
-/// progress check is made are not checked for progress.
-///
-/// The application can also use the progress_checker_schedule() API to
-/// schedule either one-shot or periodic checks.  The
-/// progress_checker_cancel() API can be used to cancel any scheduled
-/// checks. It is never an error to call this API, even if no checks are
-/// currently scheduled. Note that each call of progress_checker_schedule()
-/// also cancels any outstanding scheduled requests before (re-) scheduling
-/// the checker.  If using the built-in timer mechanism, any calls of
-/// progress_checker_check that return a non-0 value will cause a kernel panic.
-///
-/// If failures are detected and caught, the ProgressChecker provides a
-/// primitive iteration facility for the callback or the applicaton to
-/// determine which counters have failed to update. Calling
-/// progress_checker_next_failure() returns either the index of the next
-/// failing counter, or -1 to indicate no more failures. This iteration
-/// facility is reset every time a check is made by progress_checker_check()
-/// (including those made implcitly by the timer-based mechanism). There is no
-/// API to reset the iteration.
-///
-/// The implemetation provides 2 standard callback functions:
-/// progess_checker_printk() and progress_checker_printk_dump().  The former
-/// callback uses printk() to print a simple report of failed counters, and if
-/// there were any failures it then returns its argument as a return code.  If
-/// the return code is non-zero then the lack of progress will cause a kernel
-/// panic (test failure). The later callback first calls
-/// progress_checker_printk(). If progress_checker_printk() returns a non-0
-/// value then progress_checker_printk_dump() enters an SSX_CRITICAL crictal
-/// section and prints a full kernel state dump that may be useful to help
-/// diagnose the hang.
-///
-/// \note We do not make the kernel dump the default or only behavior because
-/// it could take 1ms or more to produce the large quantity of formatted
-/// output required, which could be a significant amount of wall time in a
-/// logic simulation environment.
-///
-/// The progress_checker_create() API could be used in a couple of ways as
-/// illustrated below:
-///
-/// \code 
-///
-/// ProgressChecker progress;
-/// uint64_t counter;
-///
-/// progress_checker_create(&progress, "progress", counter, 1, 
-///                         progress_checker_printk,
-///                         (void*)-PROGRESS_CHECKER_FAILED);
-///
-/// OR
-///
-/// progress_checker_create(&progress, "progress", counter, 1, 
-///                         progress_checker_printk, 0);
-///
-/// \endcode
-///
-/// The first usage prints a report and panics the test if lack of progress is
-/// detected.  The second form simply prints a report in the event of a lack
-/// or progress.  The second form may be useful to report on counters that
-/// only have a statistical probability of making progress, however be aware
-/// that the report is generated in an interrupt context and all thread
-/// activity will be blocked until the formatted I/O is complete.
-///
-/// Notes:
-/// 
-/// This implementation requires the \c byte_pool facility and malloc() to be
-/// set up as the ProgressChecker allocates dynamic storage during
-/// initialization to store the previous pass counts.
-///
-/// It is probably not a good idea to use a single ProgressChecker for both
-/// manual and timer-based checking, since there is no protection in the
-/// implementation for mutiple accesses to the ProgressChecker.
-
-#include "progress.h"
-#include "ssx_dump.h"
-
-// The built-in timer callback
-
-static void
-progress_callback(void *arg)
-{
-    ProgressChecker *checker = (ProgressChecker *)arg;
-
-    if (progress_checker_check(checker)){
-	if (0) {
-	    progress_checker_dump(checker);
-	}
-	SSX_PANIC(PROGRESS_CHECKER_FAILED);
-    }
-}
-
-
-// Bit-vector operations manage the array of bits using little-endian
-// protocols 
-
-static inline void
-bit_vector_set(uint8_t *vector, size_t bit)
-{
-    vector[bit / 8] |= (1 << (bit % 8));
-}
-
-
-static inline void
-bit_vector_clear(uint8_t *vector, size_t bit)
-{
-    vector[bit / 8] &= ~(1 << (bit % 8));
-}
-
-
-static inline int
-bit_vector_is_set(uint8_t *vector, size_t bit)
-{
-    return ((vector[bit / 8] & (1 << (bit % 8))) != 0);
-}
-
-
-// NB: We don't have a bit-vector object with a size included.  For this
-// application we can only call this API if we know that there is at least 1
-// bit set in the vector.
-
-static size_t
-bit_vector_find_first_set(uint8_t *vector)
-{
-    size_t byte = 0;
-    
-    while (vector[byte] == 0) {
-	byte++;
-    }
-
-    return (8 * byte) + __builtin_ffs(vector[byte]) - 1;
-}
-
-
-/// Create a progress checker
-///
-/// \param checker A pointer to an uninitialized or idle ProgressChecker
-///
-/// \param name An optional character string associated with the checker
-///
-/// \param pass_counts An array of pass counters - the array will be cleared
-/// by this API.
-///
-/// \param counters The number of counters in the array
-///
-/// \param callback This function is called \e every time a check is
-/// completed.  
-///
-/// \param arg The private argument of the callback function
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c
-///
-/// Return values other than 0 are errors; see \ref ssx_errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-///
-/// \retval -PROGRESS_CHECKER_INVALID_ARGUMENT A null (0) pointer was provided
-/// as the \a pass_counts argument, or the number of \a counters can not be
-/// represented as a signed integer.
-///
-/// \retval -PROGRESS_CHECKER_ALLOCATION_FAILED Memory allocation of dynamic
-/// memory failed.  This is treated as a fatal error here.
-///
-/// This API may also return or signal other errors from its implementation
-/// APIs. 
-
-int
-progress_checker_create(ProgressChecker *checker,
-			const char* name,
-			uint64_t *pass_counts,
-			size_t counters,
-			ProgressCheckerCallback callback,
-			void *arg)
-{
-    int rc, bytes;
-    void *memory;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF((checker == 0),
-		     PROGRESS_CHECKER_INVALID_OBJECT);
-	SSX_ERROR_IF((pass_counts == 0) ||
-		     (counters != (int)counters),
-		     PROGRESS_CHECKER_INVALID_ARGUMENT);
-    }
-
-    // Install and clear the counters
-
-    checker->pass_counts = pass_counts;
-    memset((void *)pass_counts, 0, counters * sizeof(uint64_t));
-    checker->counters = counters;
-
-    // Allocate and clear dynamic memory
-
-    memory = calloc(counters, sizeof(uint64_t));
-    checker->saved_counts = (uint64_t *)memory;
-
-    bytes = (counters / 8) + (counters % 8 ? 1 : 0);
-    checker->bit_vector_bytes = bytes;
-
-    memory = calloc(bytes, 1);
-    checker->exempt = (uint8_t *)memory;
-    
-    memory = calloc(bytes, 1);
-    checker->failure = (uint8_t *)memory;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF((counters != 0) && 
-		     ((checker->saved_counts == 0) ||
-		      (checker->exempt == 0) ||
-		      (checker->failure == 0)),
-		     PROGRESS_CHECKER_ALLOCATION_FAILED);
-    }
-
-    // Initialize other fields
-
-    checker->name = name;
-    checker->callback = callback;
-    checker->arg = arg;
-    checker->failed = 0;
-    checker->checks = 0;
-
-    // Initialize the timer structure.
-
-    rc = ssx_timer_create(&(checker->timer), 
-			  progress_callback, 
-			  (void *)checker);
-    if (rc) return rc;
-
-    return 0;
-}
-
-
-/// Exempt a pass count from progress checking
-///
-/// \param checker A pointer to an initialized ProgressChecker
-///
-/// \param counter The index of the counter to exempt
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c
-///
-/// Return values other than 0 are errors; see \ref ssx_errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-///
-/// \retval -PROGRESS_CHECKER_INVALID_ARGUMENT The \a counter argument is not
-/// valid.
-
-int
-progress_checker_exempt(ProgressChecker *checker,
-			size_t counter)
-{
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(checker == 0,
-		     PROGRESS_CHECKER_INVALID_OBJECT);
-	SSX_ERROR_IF(counter >= checker->counters,
-		     PROGRESS_CHECKER_INVALID_ARGUMENT);
-    }
-
-    bit_vector_set(checker->exempt, counter);
-
-    return 0;
-}
-
-
-/// Exempt all pass counts from progress checking
-///
-/// \param checker A pointer to an initialized ProgressChecker
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c
-///
-/// This API is provided to support applications where pass-count-updating
-/// processes are added dynamically. This API coule typically be called
-/// immediately after progress_checker_create(). Them, as each process was
-/// created it would call progress_checker_require() for the pass count.
-///
-/// Return values other than 0 are errors; see \ref ssx_errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-int
-progress_checker_exempt_all(ProgressChecker *checker)
-{
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(checker == 0,
-		     PROGRESS_CHECKER_INVALID_OBJECT);
-    }
-
-    memset(checker->exempt, -1, checker->bit_vector_bytes);
-
-    return 0;
-}
-
-
-/// Require a pass count to update for progress checking
-///
-/// \param checker A pointer to an initialized ProgressChecker
-///
-/// \param counter The index of the counter to require
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c
-///
-/// Return values other than 0 are errors; see \ref ssx_errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-///
-/// \retval -PROGRESS_CHECKER_INVALID_ARGUMENT The \a counter argument is not
-/// valid.
-
-int
-progress_checker_require(ProgressChecker *checker,
-			size_t counter)
-{
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(checker == 0,
-		     PROGRESS_CHECKER_INVALID_OBJECT);
-	SSX_ERROR_IF(counter >= checker->counters,
-		     PROGRESS_CHECKER_INVALID_ARGUMENT);
-    }
-
-    bit_vector_clear(checker->exempt, counter);
-
-    return 0;
-}
-
-
-/// Require a pass count to update for progress checking avoiding races
-///
-/// \param checker A pointer to an initialized ProgressChecker
-///
-/// \param counter The index of the counter to require
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c
-///
-/// If a pass counter is marked "exempt" but then later marked "required",
-/// there is a potential race between the update of the pass counter and the
-/// next check, particularly when the checker is scheduled periodically. This
-/// form of the progress_checker_require() marks the progress checker such
-/// that \e all checks are deferred on the next call of
-/// progress_checker_check() targeting the object in order to avoid the race.
-///
-/// Return values other than 0 are errors; see \ref ssx_errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-///
-/// \retval -PROGRESS_CHECKER_INVALID_ARGUMENT The \a counter argument is not
-/// valid.
-int
-progress_checker_require_defer(ProgressChecker *checker,
-                               size_t counter)
-{
-    int rc;
-    SsxMachineContext ctx;
-
-    ssx_critical_section_enter(SSX_CRITICAL, &ctx);
-
-    rc = progress_checker_require(checker, counter);
-    checker->defer = 1;
-
-    ssx_critical_section_exit(&ctx);
-
-    return rc;
-}
-
-
-/// Check for progress in every required pass counter.
-///
-/// \param checker A pointer to an initialized ProgressChecker
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c
-///
-/// Return values other than 0 are not necessarily errors; see \ref
-/// ssx_errors 
-///
-/// \retval various  Except for the error listed below,
-/// progress_checker_check() returns the code returned by the callback
-/// function. If no callback was provided when the checker was created, then 0
-/// is returned for success and -PROGRESS_CHECKER_FAILED is returned in the
-/// event of a lack of progress.
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-
-int
-progress_checker_check(ProgressChecker *checker)
-{
-    size_t i;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(checker == 0,
-		     PROGRESS_CHECKER_INVALID_OBJECT);
-    }
-
-    // Avoid doing this step unless necessary
-
-    if (checker->failed != 0) {
-	checker->failed = 0;
-	memset((void *)checker->failure, 0, checker->bit_vector_bytes);
-    }
-
-    // Check, unless checking has been deferred for 1 time by
-    // progress_checker_require_defer().
-
-    if (checker->defer) {
-
-        checker->defer = 0;
-
-    } else {
-
-        SSX_ATOMIC(SSX_CRITICAL, checker->start_check = ssx_timebase_get());
-
-        for (i = 0; i < checker->counters; i++) {
-	
-            if ((checker->pass_counts[i] <= checker->saved_counts[i]) && 
-                !(bit_vector_is_set(checker->exempt, i))) {
-
-                checker->failed++;
-                bit_vector_set(checker->failure, i);
-            }
-            checker->saved_counts[i] = checker->pass_counts[i];
-        }
-
-        SSX_ATOMIC(SSX_CRITICAL, checker->end_check = ssx_timebase_get());
-    }
-
-    checker->checks++;
-
-    if (checker->callback) {
-	return checker->callback(checker, checker->arg, checker->failed);
-    } else if (checker->failed != 0) {
-	return -PROGRESS_CHECKER_FAILED;
-    } else {
-	return 0;
-    }
-}
-
-
-/// Schedule progress checks (periodically) in the future.
-///
-/// \param checker A pointer to an initialized ProgressChecker
-///
-/// \param interval The relative time of the (first) check
-///
-/// \param period If non-zero, checks will be made periodically with this
-/// period. 
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c. See the SSX documentation for a discussion of
-/// timer scheduling in SSX.
-///
-/// Return values other than 0 errors; see \ref ssx_errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-///
-/// This API may also return or signal other errors from its implementation
-/// APIs. 
-
-
-int
-progress_checker_schedule(ProgressChecker *checker,
-			  SsxInterval interval,
-			  SsxInterval period)
-{
-    int rc;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(checker == 0,
-		     PROGRESS_CHECKER_INVALID_OBJECT);
-    }
-
-    rc = ssx_timer_cancel(&(checker->timer));
-    if (rc != -SSX_TIMER_NOT_ACTIVE) return rc;
-
-    rc = ssx_timer_schedule(&(checker->timer), interval, period);
-    if (rc) return rc;
-
-    return 0;
-}
-
-    
-/// Cancel all future (periodic) progress checks
-///
-/// \param checker A pointer to an initialized ProgressChecker
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c. See the SSX documentation for a discussion of
-/// timer scheduling in SSX.
-///
-/// Return values other than 0 errors; see \ref ssx_errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-///
-/// This API may also return or signal other errors from its implementation
-/// APIs. 
-
-int
-progress_checker_cancel(ProgressChecker *checker)
-{
-    int rc;
-
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(checker == 0,
-		     PROGRESS_CHECKER_INVALID_OBJECT);
-    }
-
-    rc = ssx_timer_cancel(&(checker->timer));
-    if (rc) return rc;
-
-    return 0;
-}
-
-    
-/// Iterate over progress check failures
-///
-/// \param checker A pointer to an initialized ProgressChecker
-///
-/// \param counter Will return the index of the next failing counter, or -1 to
-/// indicate no more failing counters.
-///
-/// For an overview of the ProgressChecker and its APIs, see the documentation
-/// for the file progress.c. 
-///
-/// Return values other than 0 errors; see \ref ssx_errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -PROGRESS_CHECKER_INVALID_OBJECT A null (0) pointer was provided
-/// as the \a checker argument.
-
-int
-progress_checker_next_failure(ProgressChecker *checker, int *counter)
-{
-    if (SSX_ERROR_CHECK_API) {
-	SSX_ERROR_IF(checker == 0,
-		     PROGRESS_CHECKER_INVALID_OBJECT);
-    }
-
-    if (checker->failed == 0) {
-	*counter = -1;
-	return 0;
-    }
-
-    *counter = bit_vector_find_first_set(checker->failure);
-    bit_vector_clear(checker->failure, *counter);
-    checker->failed--;
-
-    return 0;
-}
-
-
-/// A standard way to print the results of a progress check failure, suitable
-/// for use as a ProgressChecker callback.
-///
-/// \param checker The checker - which may or may not have failed. If the
-/// checker did fail, then a failure report is printed using printk().
-///
-/// \param arg The value to return in case of failure.  In case of
-/// success, 0 is returned.
-///
-/// \param failed - The number of failed checks
-
-int
-progress_checker_printk(ProgressChecker *checker,
-			void *arg,
-			size_t failed)
-{
-    int counter;
-
-    if (!failed) {
-	return 0;
-    }
-
-    printk("---------------------------------------------------------------\n");
-    printk("-- Progress check failed for \"%s\" (%p).\n", 
-	   checker->name, checker);
-    printk("-- Check %zu over interval 0x%016llx - 0x%016llx\n",
-           checker->checks, checker->start_check, checker->end_check);
-    printk("-- %zu failed counter%s listed below\n", 
-	   failed, failed > 1 ? "s are" : " is");
-    printk("---------------------------------------------------------------\n");
-
-    do {
-	progress_checker_next_failure(checker, &counter);
-	if (counter < 0) {
-	    break;
-	}
-	printk("%4d. 0x%016llx\n", counter, checker->pass_counts[counter]);
-    } while (1);
-
-    printk("---------------------------------------------------------------\n");
-
-    return (int)arg;
-}    
-
-
-/// Call progress_checker_printk(), then create a kernel dump on failure
-///
-/// \param checker The checker - which may or may not have failed. If the
-/// checker did fail, then a failure report is printed using
-/// progress_checker_printk().
-///
-/// \param arg The value to return in case of failure.  In case of
-/// success, 0 is returned.
-///
-/// \param failed - The number of failed checks
-///
-/// If progress_checker_printk() fails with a non-0 return code then this API
-/// prints a full SSX kernel dump after the progress_checker_printk() report.
-int
-progress_checker_printk_dump(ProgressChecker *checker,
-                             void *arg,
-                             size_t failed)
-{
-    int rc;
-    SsxMachineContext ctx;
-    
-    rc = progress_checker_printk(checker, arg, failed);
-    if (rc != 0) {
-        ssx_critical_section_enter(SSX_CRITICAL, &ctx);
-        ssx_dump(ssxout, 0);
-        ssx_critical_section_exit(&ctx);
-    }
-
-    return rc;
-}    
-
-
-/// Dump a progress checker structure using printk()
-
-void
-progress_checker_dump(ProgressChecker *checker)
-{
-    size_t i;
-
-    printk("Dump of progress checker \"%s\" (%p)\n"
-	   "  Counters = %zu\n"
-	   "  Checks   = %zu\n"
-	   "  Failed   = %zu\n"
-	   "  Callback = %p(%p)\n",
-	   checker->name, checker, checker->counters, checker->checks,
-	   checker->failed, checker->callback, checker->arg);
-    
-    printk("  Pass Counts (%p) :\n", checker->pass_counts);
-    for (i = 0; i < checker->counters; i++) {
-    	printk("    %9d%c 0x%016llx\n", 
-    	       i, 
-    	       bit_vector_is_set(checker->exempt, i) ? '*' : ' ',
-    	       checker->pass_counts[i]);
-    }
-    printk("  Saved Counts (%p) :\n", checker->saved_counts);
-    for (i = 0; i < checker->counters; i++) {
-    	printk("    %9d   0x%016llx\n", 
-    	       i, checker->saved_counts[i]);
-    }
-}
-
-    
-    
-	   
-
-
-    
-
diff --git a/src/lib/ppc405lib/progress.h b/src/lib/ppc405lib/progress.h
deleted file mode 100644
index 3454a0f..0000000
--- a/src/lib/ppc405lib/progress.h
+++ /dev/null
@@ -1,177 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/progress.h $                                */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __PROGRESS_H__
-#define __PROGRESS_H__
-
-// $Id$
-
-/// \file progress.h
-/// \brief Programmable progress (hang) checking
-
-#include <time.h>
-#include "ssx.h"
-#include "byte_pool.h"
-#include "ssx_io.h"
-
-#ifndef __ASSEMBLER__
-
-struct ProgressChecker;
-
-/// ProgressChecker callback type
-///
-/// \param checker The checker that has just been checked
-///
-/// \param arg The private argument provided when the checker was created
-///
-/// \param failed The number of failed pass counts - 0 indicates no failures
-
-typedef int (*ProgressCheckerCallback)(struct ProgressChecker* checker,
-				       void*  arg,
-				       size_t failed);
-
-
-/// A simple progress (hang) checker.  For API details see file progress.c
-
-typedef struct ProgressChecker {
-
-    /// The application provided pass-count array
-    uint64_t *pass_counts;
-
-    /// The number of pass-count counters in the array.
-    size_t counters;
-
-    /// The (optional) name of the checker for reporting purposes.
-    const char *name;
-
-    /// The (optional) checker callback.
-    ProgressCheckerCallback callback;
-
-    /// The checker callback private argument
-    void *arg;
-
-    /// The dynamically-allocated saved pass counts.
-    uint64_t *saved_counts;
-
-    /// The dynamically-allocated exemption bit-vector
-    ///
-    /// \todo Get or implement a generic unlimited-precision bit vector
-    uint8_t *exempt;
-
-    /// The dynamically-allocated failure bit-vector
-    uint8_t *failure;
-
-    /// The number of bytes in the bit vector
-    size_t bit_vector_bytes;
-
-    /// Defer all checking the next time progress_checker_check() is called.
-    ///
-    /// See progress_checker_require_defer()
-    int defer;
-
-    /// The number of failures present in the *failure vector 
-    size_t failed;
-
-    /// A timer object to support time-based checking.
-    SsxTimer timer;
-
-    /// The number of times progress_checker_check() has been called on the
-    /// object. 
-    size_t checks;
-
-    /// The time the last check started
-    SsxTimebase start_check;
-
-    /// The time the last check ended
-    SsxTimebase end_check;
-
-} ProgressChecker;
-
-
-int
-progress_checker_create(ProgressChecker *checker,
-			const char *name,
-			uint64_t *pass_counts,
-			size_t counters,
-			ProgressCheckerCallback callback,
-			void *arg);
-
-int
-progress_checker_exempt(ProgressChecker *checker,
-			size_t counter);
-
-int
-progress_checker_exempt_all(ProgressChecker *checker);
-
-int
-progress_checker_require(ProgressChecker *checker,
-			 size_t counter);
-
-int
-progress_checker_require_defer(ProgressChecker *checker,
-                               size_t counter);
-
-int
-progress_checker_check(ProgressChecker *checker);
-
-int
-progress_checker_schedule(ProgressChecker *checker,
-			  SsxInterval interval,
-			  SsxInterval period);
-
-int
-progress_checker_cancel(ProgressChecker *checker);
-
-int
-progress_checker_next_failure(ProgressChecker *checker, int *counter);
-
-int 
-progress_checker_delete(ProgressChecker *checker);
-
-int
-progress_checker_printk(ProgressChecker *checker,
-			void *arg,
-			size_t failed);
-
-int
-progress_checker_printk_dump(ProgressChecker *checker,
-                             void *arg,
-                             size_t failed);
-
-void
-progress_checker_dump(ProgressChecker *checker);
-
-
-#endif	/* __ASSEMBLER__ */
-
-// Error/Panic codes
-
-#define PROGRESS_CHECKER_INVALID_OBJECT    0x00776001
-#define PROGRESS_CHECKER_INVALID_ARGUMENT  0x00776002
-#define PROGRESS_CHECKER_FAILED            0x00776003
-#define PROGRESS_CHECKER_CALLBACK_PANIC    0x00776004
-#define PROGRESS_CHECKER_INVARIANT         0x00776005
-#define PROGRESS_CHECKER_ALLOCATION_FAILED 0x00776006
-
-#endif	/* __PROGRESS_H__ */
diff --git a/src/lib/ppc405lib/rtx_stdio.c b/src/lib/ppc405lib/rtx_stdio.c
deleted file mode 100644
index 4bb1a18..0000000
--- a/src/lib/ppc405lib/rtx_stdio.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/rtx_stdio.c $                               */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file rtx_stdio.c
-/// \brief SSX I/O drivers for RTX stdio streams
-///
-/// The RTX \a stdout and \a stderr components accept 1, 2 and 4-byte
-/// transactions on a 32-bit OCI address and write the data to the RTX
-/// job's \a stdout or \a stderr respectively.  The \a stdin device is not yet
-/// implemented.
-
-#include "ssx.h"
-#include "rtx_stdio.h"
-
-RtxStdio rtx_stdin;
-RtxStdio rtx_stdout;
-RtxStdio rtx_stderr;
-
-int
-rtx_stdio_sread(FILE *stream, void *buf, size_t count, size_t *read)
-{
-    SSX_PANIC(ENXIO);
-    return -ENXIO;
-}
-
-
-int
-rtx_stdio_swrite(FILE *stream, const void *buf,
-                    size_t count, size_t *written)
-{
-    RtxStdio *rtx = (RtxStdio *)stream;
-    size_t n;
-
-    n = count;
-    while (n) {
-        if (n >= 4) {
-            out32(rtx->address, *((uint32_t *)buf));
-            buf += 4;
-            n -= 4;
-        } else if (n >= 2) {
-            out16(rtx->address, *((uint16_t *)buf));
-            buf += 2;
-            n -= 2;
-        } else {
-            out8(rtx->address, *((uint8_t *)buf));
-            buf++;
-            n--;
-        }
-    }
-
-    if (written != 0) {
-        *written = count;
-    }
-
-    return 0;
-}
-
-
-ssize_t
-rtx_stdio_fflush(FILE *stream)
-{
-    RtxStdio *rtx = (RtxStdio *)stream;
-
-    out8(rtx->flush_address, 0);
-    return 0;
-}
-
-
-int
-rtx_stdin_create(RtxStdio *stream)
-{
-    FILE *base = (FILE *)stream;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(stream == 0, EBADF);
-    }
-
-    memset((void *)stream, 0, sizeof(RtxStdio));
-    base->sread = rtx_stdio_sread;
-
-    stream->address = RTX_STDIN;
-
-    return 0;
-}
-
-
-int
-rtx_stdout_create(RtxStdio *stream)
-{
-    FILE *base = (FILE *)stream;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(stream == 0, EBADF);
-    }
-
-    memset((void *)stream, 0, sizeof(RtxStdio));
-    base->swrite = rtx_stdio_swrite;
-    base->fflush = rtx_stdio_fflush;
-
-    stream->address = RTX_STDOUT;
-    stream->flush_address = RTX_STDOUT_FLUSH;
-
-    return 0;
-}
-
-
-int
-rtx_stderr_create(RtxStdio *stream)
-{
-    FILE *base = (FILE *)stream;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(stream == 0, ENXIO);
-    }
-
-    memset((void *)stream, 0, sizeof(RtxStdio));
-    base->swrite = rtx_stdio_swrite;
-    base->fflush = rtx_stdio_fflush;
-
-    stream->address = RTX_STDERR;
-    stream->flush_address = RTX_STDERR_FLUSH;
-
-    return 0;
-}
-
-
diff --git a/src/lib/ppc405lib/rtx_stdio.h b/src/lib/ppc405lib/rtx_stdio.h
deleted file mode 100644
index cd2a439..0000000
--- a/src/lib/ppc405lib/rtx_stdio.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/rtx_stdio.h $                               */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __RTX_STDIO_H__
-#define __RTX_STDIO_H__
-
-// $Id$
-
-/// \file rtx_stdio.h
-/// \brief SSX I/O implementations for RTX stdio streams
-
-#include "ssx_io.h"
-#include "rtx_stdio_addresses.h"
-
-/// A FILE structure for a RTX fake stdio stream
-
-typedef struct {
-
-    /// The base class
-    FILE stream;
-
-    /// The MMIO address of the RTX device for the stream
-    SsxAddress address;
-
-    /// The MMIO address of the RTX device for flushing the stream;
-    SsxAddress flush_address;
-
-} RtxStdio;
-
-extern RtxStdio rtx_stdin;
-extern RtxStdio rtx_stdout;
-extern RtxStdio rtx_stderr;
-
-int
-rtx_stdin_create(RtxStdio *stream);
-
-int
-rtx_stdout_create(RtxStdio *stream);
-
-int
-rtx_stderr_create(RtxStdio *stream);
-
-int
-rtx_stdio_sread(FILE *stream, void *buf, size_t count, size_t *read);
-
-int
-rtx_stdio_swrite(FILE *stream, const void *buf,
-                    size_t count, size_t *written);
-
-int
-rtx_stdio_sflush(FILE *stream);
-
-#endif /* __RTX_STDIO_H__ */
diff --git a/src/lib/ppc405lib/rtx_stdio_addresses.h b/src/lib/ppc405lib/rtx_stdio_addresses.h
deleted file mode 100644
index 5359f7f..0000000
--- a/src/lib/ppc405lib/rtx_stdio_addresses.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/rtx_stdio_addresses.h $                     */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __RTX_STDIO_ADDRESSES_H__
-#define __RTX_STDIO_ADDRESSES_H__
-
-// $Id$
-
-/// \file rtx_stdio_addresses.h
-/// \brief MMIO addresses and offsets of the rtx fake stdio model
-///
-/// The RTX stdio module appears as OCI device #7?  Reading 1 byte from the
-/// stdin offset returns that byte from stdin. Writing 1, 2 or 4 bytes to the
-/// stdout or stderr offsets causes output on that stream.  Writing any single
-/// byte to the 'flush' offsets flush the stdout or stderr streams.
-///
-/// -*- This header is maintained as part of the PMX RTX model.    -*-
-/// -*- Do not edit in the SSX library as your edits will be lost. -*-
-
-#define RTX_STDIO_BASE          0x40060000
-
-#define RTX_STDIN_OFFSET        0x00
-#define RTX_STDOUT_OFFSET       0x04
-#define RTX_STDOUT_FLUSH_OFFSET 0x08
-#define RTX_STDERR_OFFSET       0x0c
-#define RTX_STDERR_FLUSH_OFFSET 0x10
-
-#define RTX_STDIN        (RTX_STDIO_BASE + RTX_STDIN_OFFSET)
-#define RTX_STDOUT       (RTX_STDIO_BASE + RTX_STDOUT_OFFSET)
-#define RTX_STDOUT_FLUSH (RTX_STDIO_BASE + RTX_STDOUT_FLUSH_OFFSET)
-#define RTX_STDERR       (RTX_STDIO_BASE + RTX_STDERR_OFFSET)
-#define RTX_STDERR_FLUSH (RTX_STDIO_BASE + RTX_STDERR_FLUSH_OFFSET)
-
-#endif /* __RTX_STDIO_ADDRESSES_H__ */
diff --git a/src/lib/ppc405lib/sxlock.c b/src/lib/ppc405lib/sxlock.c
deleted file mode 100644
index 35f9698..0000000
--- a/src/lib/ppc405lib/sxlock.c
+++ /dev/null
@@ -1,494 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/sxlock.c $                                  */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id$
-
-/// \file sxlock.c
-/// \brief API for the SharedExclusiveLock
-///
-/// The APIs in this file implement a shared-exclusive lock for SSX
-/// applications.  This type of lock is also called a readers-writer lock. The
-/// lock is implemented in terms of SSX semaphores, so its use is limited to
-/// threads willing to block for access to a resource. 
-///
-/// The SharedExclusiveLock allows multiple threads shared access to a
-/// resource, while limiting exclusive access to a single thread. There are
-/// several ways that this type of lock might be specified. The specification
-/// implemented here is an "exclusive-biasing" lock. As long as the lock is
-/// held or requested in exclusive mode, all new shared-mode requests will
-/// block, and only exclusive accesses will be allowed. If multiple threads
-/// are blocked exclusive the requests are honored in priority order (as
-/// the underlying implementation is an SSX semaphore). Once the exclusive
-/// lock is cleared, any/all threads blocked for shared access are released
-/// simultaneously (using an SSX semaphore as a thread barrier).
-///
-/// The lock is created (initialized) by sxlock_create(), which allows
-/// specification of an initial value of the number of shared or exclusive
-/// accesses outstanding.  The lock/unlock APIs are as follows:
-///
-/// - sxlock_lock_shared(SharedExclusiveLock* sxlock, SsxInterval timeout)
-/// - sxlock_unlock_shared(SharedExclusiveLock* sxlock)
-/// - sxlock_lock_exclusive(SharedExclusiveLock* sxlock, SsxInterval timeout)
-/// - sxlock_unlock_exclusive(SharedExclusiveLock* sxlock)
-///
-/// Threads must always issue *_lock() and *_unlock() requests in matched
-/// pairs in order to avoid errors and deadlock. The *_lock() APIs allow
-/// specification of a timeout, which may be SSX_WAIT_FOREVER to indicate no
-/// timeout. The *_lock() APIs will return the code -SXLOCK_TIMED_OUT if the
-/// timeout occurs before the thread acquires the resource. If called from an
-/// interrupt context then the only legal timeout specification is
-/// SSX_NO_WAIT (0).  
-///
-/// If a *_lock() request times out then the thread \e has \e not acquired the
-/// resource and \e must \e not call *_unlock(). As with semaphores there is
-/// no record that a thread holds a lock, so if a thread completes or is
-/// deleted while holding a lock it is likely that the application will
-/// deadlock.
-
-#include "ssx.h"
-#include "sxlock.h"
-
-/// Create (initialize) a SharedExclusiveLock
-///
-/// \param sxlock A pointer to the SharedExclusiveLock object to
-/// initialize
-///
-/// \param shared The initial numbers of shared accesses
-///
-/// \param exclusive The initial numbers of exclusive accesses
-///
-/// Create (initialize) a SharedExclusiveLock and optionally specify an
-/// initial state. The initial number of shared or exclusive accesses can be
-/// specified, however at most one of \a nshared and \a exclusive can be
-/// non-0. If \a shared or \a exclusive are non-0 then eventually a
-/// thread(s) will need to issue unmatched *_unlock() call(s) to allow
-/// progress for other threads requiring the resource.
-///
-/// \retval 0 Success
-///
-/// \retval SXLOCK_INVALID_OBJECT The \a sxlock parameter is NULL (0) or
-/// otherwise invalid.
-///
-/// \retval SXLOCK_INVALID_ARGUMENT Both of the \a shared and \a exclusive
-/// parameters are non-0.
-///
-/// \retval others sxlock_create() may also return codes from
-/// ssx_semaphore_create(), which would indicate a serious bug.
-
-int
-sxlock_create(SharedExclusiveLock* sxlock, 
-              SsxSemaphoreCount shared, 
-              SsxSemaphoreCount exclusive)
-{
-    int rc;
-
-    rc = 0;
-    do {
-
-        if (SSX_ERROR_CHECK_API) {
-            SSX_ERROR_IF(sxlock == 0, 
-                         SXLOCK_INVALID_OBJECT);
-            SSX_ERROR_IF((shared != 0) && (exclusive != 0), 
-                         SXLOCK_INVALID_ARGUMENT);
-        }
-        
-        rc = ssx_semaphore_create(&(sxlock->shared_sem), 0, 0);
-        if (rc) break;
-
-        rc = ssx_semaphore_create(&(sxlock->exclusive_sem), 0, 0);
-        if (rc) break;
-
-        sxlock->running_shared = shared;
-        sxlock->running_exclusive = exclusive;
-        
-    } while (0);
-
-    return rc;
-}
-
-
-/// Lock a SharedExclusiveLock for shared access
-///
-/// \param sxlock A pointer to the SharedExclusiveLock object to lock
-///
-/// \param timeout The maximum amount of time to wait for access, or the
-/// constant SSX_WAIT_FOREVER to wait forever.
-///
-/// Acquire a SharedExclusiveLock for shared access, potentially blocking
-/// forever or until a specified timeout if access is not immediately
-/// granted. Access will be blocked as long as one or more threads request or
-/// control exclusive acesss to the resource. Once the access is granted, the
-/// thread maintains shared access to the resource until a subsequent call of
-/// sxlock_unlock_shared().
-///
-/// Return values other than SSX_OK (0) are not necessarily errors; see \ref
-/// ssx_errors 
-///
-/// The following return codes are non-error codes:
-///
-/// \retval 0 Successful completion
-///
-/// \retval -SXLOCK_TIMED_OUT Shared access was not acquired before the
-/// timeout expired.
-///
-/// The following return codes are error codes:
-///
-/// \retval -SXLOCK_INVALID_OBJECT The \a sxlock parameter was NULL (0) or
-/// otherwise invalid.
-///
-/// \retval -SSX_ILLEGAL_CONTEXT The API was called from a critical
-/// interrupt context.
-/// 
-/// \retval -SSX_SEMAPHORE_PEND_WOULD_BLOCK The call was made from an
-/// interrupt context (or before threads have been started), shared access was
-/// not immediately available and a non-zero timeout was specified.
-///
-/// \retval others This API may also return codes from SSX semaphore APIs,
-/// which should be considered as non-recoverable errors.
-
-
-int
-sxlock_lock_shared(SharedExclusiveLock* sxlock, SsxInterval timeout)
-{
-    SsxMachineContext ctx;
-    int rc, pending_exclusive;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(sxlock == 0, SXLOCK_INVALID_OBJECT);
-    }
-
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    rc = 0;
-    do {
-
-        // NB: This is the only way to correctly compute the number of threads
-        // pending exclusive, given that threads could be removed from the
-        // exclusive_sem by timeout.
-
-        rc = ssx_semaphore_info_get(&(sxlock->exclusive_sem),
-                                    0, &pending_exclusive);
-        if (rc) break;
-
-        if ((sxlock->running_exclusive == 0) && (pending_exclusive == 0)) {
-
-            // If no other thread has or is requesting exclusive access, the
-            // current thread gets immediate access.
-
-            sxlock->running_shared++;
-
-        } else {
-
-            // If threads are running or pending exclusive, this thread must
-            // pend shared. The thread will be unblocked by an exclusive
-            // unlock, which is responsible for adjusting
-            // sxlock->running_shared in this case.
-        
-            rc = ssx_semaphore_pend(&(sxlock->shared_sem), timeout);
-            if (rc == -SSX_SEMAPHORE_PEND_TIMED_OUT) {
-                rc = -SXLOCK_TIMED_OUT;
-            } 
-        }
-
-    } while (0);
-
-    ssx_critical_section_exit(&ctx);
-
-    return rc;
-}
-
-
-/// Relase a SharedExclusiveLock from shared access
-///
-/// \param sxlock A pointer to the SharedExclusiveLock object to unlock
-///
-/// Release a SharedExclusiveLock from shared access, signalling that the
-/// thread no longer requires or expects shared access to the resource.  It is
-/// an error for a thread to use this API if it has not previously locked
-/// shared access by a call of sxlock_pend_shared() (or the thread is
-/// unlocking a lock initialized in the shared-locked state).
-///
-/// Return values other than SSX_OK (0) are errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -SSX_ILLEGAL_CONTEXT The API was called from a critical interrupt
-/// context.
-///
-/// \retval -SXLOCK_INVALID_OBJECT The \a sxlock parameter was NULL (0) or
-/// otherwise invalid.
-///
-/// \retval -SXLOCK_SHARED_UNDERFLOW There was apparently no matched call of
-/// sxlock_lock_shared() prior to this call.
-///
-/// \retval others This API may also return codes from SSX semaphore APIs,
-/// which should be considered as non-recoverable errors.
-
-int
-sxlock_unlock_shared(SharedExclusiveLock* sxlock)
-{
-    SsxMachineContext ctx;
-    int rc, pending_exclusive;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF_CRITICAL_INTERRUPT_CONTEXT();
-        SSX_ERROR_IF(sxlock == 0, SXLOCK_INVALID_OBJECT);
-        SSX_ERROR_IF(sxlock->running_shared == 0, SXLOCK_SHARED_UNDERFLOW);
-    }
-
-    if (SSX_ERROR_CHECK_KERNEL) {
-        SSX_PANIC_IF(sxlock->running_exclusive != 0, 
-                     SXLOCK_SHARED_EXCLUSIVE_INVARIANT);
-    }
-
-    rc = 0;
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    do {
-
-        // If this is the last shared thread running, and a thread wants
-        // exclusive access, grant it. Note that there may be shared requests
-        // pending on the shared_sem but we always give preference to
-        // exclusive requests.
-
-        sxlock->running_shared--;
-        if (sxlock->running_shared == 0) {
-
-            // Wake any single thread pending exclusive
-
-            rc = ssx_semaphore_info_get(&(sxlock->exclusive_sem),
-                                        0, &pending_exclusive);
-            if (rc) break;
-
-            if (pending_exclusive != 0) {
-                
-                sxlock->running_exclusive = 1;
-                rc = ssx_semaphore_post(&(sxlock->exclusive_sem));
-                if (rc) break;
-            }
-        }
-
-    } while(0);
-
-    ssx_critical_section_exit(&ctx);
-    
-    return rc;
-}
-
-
-/// Lock a SharedExclusiveLock for exclusive access
-///
-/// \param sxlock A pointer to the SharedExclusiveLock object to lock
-///
-/// \param timeout The maximum amount of time to wait for access, or the
-/// constant SSX_WAIT_FOREVER to wait forever.
-///
-/// Acquire a SharedExclusiveLock for exclusive access, potentially blocking
-/// forever or until a specified timeout if access is not immediately
-/// granted. Access will be blocked as long as one or more threads control
-/// shared acesss to the resource, however once the thread requests exclusive
-/// access all new shared access requests will block. Once the access is
-/// granted, the thread maintains exclusive access to the resource until a
-/// subsequent call of sxlock_unlock_exclusive().
-///
-/// Return values other than SSX_OK (0) are not necessarily errors; see \ref
-/// ssx_errors 
-///
-/// The following return codes are non-error codes:
-///
-/// \retval 0 Successful completion
-///
-/// \retval -SXLOCK_TIMED_OUT Exclusive access was not acquired before the
-/// timeout expired.
-///
-/// The following return codes are error codes:
-///
-/// \retval -SXLOCK_INVALID_OBJECT The \a sxlock parameter was NULL (0) or
-/// otherwise invalid.
-///
-/// \retval -SSX_ILLEGAL_CONTEXT The API was called from a critical
-/// interrupt context.
-/// 
-/// \retval -SSX_SEMAPHORE_PEND_WOULD_BLOCK The call was made from an
-/// interrupt context (or before threads have been started), exclusive access
-/// was not immediately available and a non-zero timeout was specified.
-///
-/// \retval others This API may also return codes from SSX semaphore APIs,
-/// which shoudl be considered as non-recoverable errors.
-
-
-int
-sxlock_lock_exclusive(SharedExclusiveLock* sxlock, SsxInterval timeout)
-{
-    SsxMachineContext ctx;
-    int rc, pending_exclusive, pending_shared;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF(sxlock == 0, SXLOCK_INVALID_OBJECT);
-    }
-
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    rc = 0;
-    do {
-
-        if ((sxlock->running_shared == 0) &&
-            (sxlock->running_exclusive == 0)) {
-
-            // If no other thread has acquired the lock, this thread gets
-            // immediate access.
-
-            sxlock->running_exclusive = 1;
-
-        } else {
-
-            // Some other thread has acquired the lock.  This thread must pend
-            // exclusive. In this case the sxlock->running_exclusive must be
-            // set by the *_unlock() operation that unblocks the thread.
-        
-            rc = ssx_semaphore_pend(&(sxlock->exclusive_sem), timeout);
-            if (rc == -SSX_SEMAPHORE_PEND_TIMED_OUT) {
-
-                // This exclusive request timed out.  Since the request may
-                // have blocked shared requests, then if this is the only
-                // exclusive request or thread we need to unblock any pending
-                // shared requests.
-
-                if (sxlock->running_exclusive == 0) {
-
-                    rc = ssx_semaphore_info_get(&(sxlock->exclusive_sem),
-                                                0, &pending_exclusive);
-                    if (rc) break;
-
-                    if (pending_exclusive == 0) {
-
-                        rc = ssx_semaphore_info_get(&(sxlock->shared_sem),
-                                                    0, &pending_shared);
-                        if (rc) break;
-
-                        if (pending_shared != 0) {
-
-                            sxlock->running_shared += pending_shared;
-                            rc = ssx_semaphore_release_all(&(sxlock->shared_sem));
-                            if (rc) break;
-                        }
-                    }
-                }
-
-                rc = -SXLOCK_TIMED_OUT;
-            }
-        }
-
-    } while (0);
-
-    ssx_critical_section_exit(&ctx);
-
-    return rc;
-}
-
-
-/// Release a SharedExclusiveLock from exclusive access
-///
-/// \param sxlock A pointer to the SharedExclusiveLock object to unlock
-///
-/// Release a SharedExclusiveLock from exclusive access, signalling that the
-/// thread no longer requires or expects exclusive access to the resource.  It
-/// is an error for a thread to use this API if it has not previously locked
-/// exclusive access by a call of sxlock_lock_exclusive() (or the thread is
-/// unlocking a lock initialized in the exclusive-locked state).
-///
-/// Return values other than SSX_OK (0) are errors
-///
-/// \retval 0 Successful completion
-///
-/// \retval -SSX_ILLEGAL_CONTEXT The API was called from a critical interrupt
-/// context.
-///
-/// \retval -SXLOCK_INVALID_OBJECT The \a sxlock parameter was NULL (0) or
-/// otherwise invalid.
-///
-/// \retval -SXLOCK_EXCLUSIVE_UNDERFLOW There was apparently no matched call of
-/// sxlock_lock_exclusive() prior to this call.
-///
-/// \retval others This API may also return codes from SSX semaphore APIs,
-/// which should be considered as non-recoverable errors.
-
-int
-sxlock_unlock_exclusive(SharedExclusiveLock* sxlock)
-{
-    SsxMachineContext ctx;
-    int rc, pending_exclusive, pending_shared;
-
-    if (SSX_ERROR_CHECK_API) {
-        SSX_ERROR_IF_CRITICAL_INTERRUPT_CONTEXT();
-        SSX_ERROR_IF(sxlock == 0, SXLOCK_INVALID_OBJECT);
-        SSX_ERROR_IF(sxlock->running_exclusive != 1, SXLOCK_SHARED_UNDERFLOW);
-    }
-
-    if (SSX_ERROR_CHECK_KERNEL) {
-        SSX_PANIC_IF(sxlock->running_shared != 0, 
-                     SXLOCK_SHARED_EXCLUSIVE_INVARIANT);
-    }
-
-    rc = 0;
-    ssx_critical_section_enter(SSX_NONCRITICAL, &ctx);
-
-    do {
-
-        rc = ssx_semaphore_info_get(&(sxlock->exclusive_sem),
-                                    0, &pending_exclusive);
-        if (rc) break;
-
-        if (pending_exclusive != 0) {
-
-            // If there are other threads pending exclusive, make the
-            // highest-priority one of them
-            // runnable. sxlock->running_exclusive remains equal to 1.
-
-            rc = ssx_semaphore_post(&(sxlock->exclusive_sem));
-            if (rc) break;
-
-        } else {
-
-            // Otherwise unblock any/all threads pending shared
-
-            sxlock->running_exclusive = 0;
-
-            rc = ssx_semaphore_info_get(&(sxlock->shared_sem),
-                                        0, &pending_shared);
-            if (rc) break;
-
-            if (pending_shared != 0) {
-
-                sxlock->running_shared = pending_shared;
-                rc = ssx_semaphore_release_all(&(sxlock->shared_sem));
-                if (rc) break;
-            }
-        }
-    } while (0);
-
-    ssx_critical_section_exit(&ctx);
-    
-    return rc;
-}
diff --git a/src/lib/ppc405lib/sxlock.h b/src/lib/ppc405lib/sxlock.h
deleted file mode 100644
index e0fa196..0000000
--- a/src/lib/ppc405lib/sxlock.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/lib/ppc405lib/sxlock.h $                                  */
-/*                                                                        */
-/* OpenPOWER OnChipController Project                                     */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-#ifndef __SXLOCK_H__
-#define __SXLOCK_H__
-
-// $Id$
-
-/// \file sxlock.h
-/// \brief The implementation of a SharedExclusiveLock
-///
-/// The SharedExclusiveLock is documented in the comments for the file
-/// sxlock.c 
-
-// Error/panic codes
-
-#define SXLOCK_INVALID_OBJECT             0x00795501
-#define SXLOCK_INVALID_ARGUMENT           0x00795502
-#define SXLOCK_TIMED_OUT                  0x00795503
-#define SXLOCK_SHARED_UNDERFLOW           0x00795504
-#define SXLOCK_EXCLUSIVE_UNDERFLOW        0x00795505
-#define SXLOCK_SHARED_EXCLUSIVE_INVARIANT 0x00795506 
-
-/// A shared-exclusive lock object (also called a readers-write lock)
-///
-/// This facility is documented in the file sxlock.c
-
-typedef struct {
-
-    /// A semaphore for threads requesting shared access
-    SsxSemaphore shared_sem;
-
-    /// A semaphore for threads requesting exclusive access
-    SsxSemaphore exclusive_sem;
-
-    /// The number of threads running shared
-    SsxSemaphoreCount running_shared;
-
-    /// The number of threads running exclusive
-    SsxSemaphoreCount running_exclusive;
-
-} SharedExclusiveLock;
-
-
-/// Static initialization of a shared-exclusive lock object
-///
-/// \param[in] shared The number of threads running shared at static
-/// initialization
-///
-/// \param[in] exclusive The number of threads running exclusive at static
-/// initialization. 
-///
-/// Note that it is an error to specify both \a shared and \a exclusive as
-/// non-0.
-
-#define SXLOCK_INITIALIZATION(shared, exclusive)        \
-    {                                                   \
-        SSX_SEMAPHORE_INITIALIZATION(0, 0),             \
-            SSX_SEMAPHORE_INITIALIZATION(0, 0),         \
-            (shared), (exclusive)                       \
-            }
-
-/// Declare and initialize a shared-exclusive lock
-
-#define SXLOCK(sxlock, shared, exclusive)                               \
-    SharedExclusiveLock sxlock = SXLOCK_INITIALIZATION(shared, exclusive)
-
-
-
-int
-sxlock_create(SharedExclusiveLock* sxlock,
-              SsxSemaphoreCount shared,
-              SsxSemaphoreCount exclusive);
-
-int
-sxlock_lock_shared(SharedExclusiveLock* sxlock, SsxInterval timeout);
-
-int
-sxlock_unlock_shared(SharedExclusiveLock* sxlock);
-
-int
-sxlock_lock_exclusive(SharedExclusiveLock* sxlock, SsxInterval timeout);
-
-int
-sxlock_unlock_exclusive(SharedExclusiveLock* sxlock);
-
-#endif // __SXLOCK_H__