diff --git a/src/mongo/bson/bsonelement.h b/src/mongo/bson/bsonelement.h
index c24e684..811c3f7 100644
--- a/src/mongo/bson/bsonelement.h
+++ b/src/mongo/bson/bsonelement.h
@@ -184,7 +184,7 @@ namespace mongo {
         bool isNumber() const;
 
         /** Return double value for this field. MUST be NumberDouble type. */
-        double _numberDouble() const {return *reinterpret_cast< const double* >( value() ); }
+        double _numberDouble() const {return (reinterpret_cast< const struct packed_double* >( value() ))->d; }
         /** Return int value for this field. MUST be NumberInt type. */
         int _numberInt() const {return *reinterpret_cast< const int* >( value() ); }
         /** Return long long value for this field. MUST be NumberLong type. */
@@ -490,7 +490,7 @@ namespace mongo {
         case NumberLong:
             return *reinterpret_cast< const long long* >( value() ) != 0;
         case NumberDouble:
-            return *reinterpret_cast< const double* >( value() ) != 0;
+            return (reinterpret_cast < const struct packed_double * >(value ()))->d != 0;
         case NumberInt:
             return *reinterpret_cast< const int* >( value() ) != 0;
         case mongo::Bool:
diff --git a/src/mongo/bson/util/builder.h b/src/mongo/bson/util/builder.h
index 97aacd3..e644064 100644
--- a/src/mongo/bson/util/builder.h
+++ b/src/mongo/bson/util/builder.h
@@ -27,6 +27,13 @@
 #include "../stringdata.h"
 
 namespace mongo {
+    /* Accessing unaligned doubles on ARM/Linux results in SIGBUS.
+       Wrapping in a packed struct forces gcc to generate code that works with unaligned value as well.
+    */
+    struct packed_double {
+        double d;
+    } __attribute__((packed));
+
 
     /* Note the limit here is rather arbitrary and is simply a standard. generally the code works
        with any object that fits in ram.
@@ -158,7 +165,7 @@ namespace mongo {
             *((bool*)grow(sizeof(bool))) = j;
         }
         void appendNum(double j) {
-            *((double*)grow(sizeof(double))) = j;
+            ((struct packed_double*)grow(sizeof(double)))->d = j;
         }
         void appendNum(long long j) {
             *((long long*)grow(sizeof(long long))) = j;
diff --git a/src/mongo/db/key.cpp b/src/mongo/db/key.cpp
index f7deb79..bf4fce1 100644
--- a/src/mongo/db/key.cpp
+++ b/src/mongo/db/key.cpp
@@ -19,6 +19,7 @@
 #include "pch.h"
 #include "key.h"
 #include "../util/unittest.h"
+#include "../bson/util/builder.h"
 
 namespace mongo {
 
@@ -405,11 +406,11 @@ namespace mongo {
                     p += sizeof(double);
                     break;
                 case cint:
-                    b.append("", (int) ((double&) *p));
+                    b.append("", (int) ((struct packed_double&) *p).d);
                     p += sizeof(double);
                     break;
                 case clong:
-                    b.append("", (long long) ((double&) *p));
+                    b.append("", (long long) ((struct packed_double&) *p).d);
                     p += sizeof(double);
                     break;
                 default:
@@ -435,8 +436,8 @@ namespace mongo {
         switch( lt ) { 
         case cdouble:
             {
-                double L = *((double *) l);
-                double R = *((double *) r);
+                double L = ((struct packed_double *) l)->d;
+                double R = ((struct packed_double *) r)->d;
                 if( L < R )
                     return -1;
                 if( L != R )
@@ -624,7 +625,7 @@ namespace mongo {
                 l += 8; r += 8;
                 break;
             case cdouble:
-                if( *((double *) l) != *((double *) r) )
+                if( ((struct packed_double *) l)->d != ((struct packed_double *) r)->d )
                     return false;
                 l += 8; r += 8;
                 break;
diff --git a/src/mongo/db/stats/counters.cpp b/src/mongo/db/stats/counters.cpp
index 889e8a8..da39823 100644
--- a/src/mongo/db/stats/counters.cpp
+++ b/src/mongo/db/stats/counters.cpp
@@ -34,12 +34,12 @@ namespace mongo {
         b.append( "command" , zero );
         _obj = b.obj();
 
-        _insert = (AtomicUInt*)_obj["insert"].value();
-        _query = (AtomicUInt*)_obj["query"].value();
-        _update = (AtomicUInt*)_obj["update"].value();
-        _delete = (AtomicUInt*)_obj["delete"].value();
-        _getmore = (AtomicUInt*)_obj["getmore"].value();
-        _command = (AtomicUInt*)_obj["command"].value();
+        _insert = (unsigned int*)_obj["insert"].value();
+        _query = (unsigned int*)_obj["query"].value();
+        _update = (unsigned int*)_obj["update"].value();
+        _delete = (unsigned int*)_obj["delete"].value();
+        _getmore = (unsigned int*)_obj["getmore"].value();
+        _command = (unsigned int*)_obj["command"].value();
     }
 
     void OpCounters::gotOp( int op , bool isCommand ) {
@@ -67,20 +67,20 @@ namespace mongo {
         const unsigned MAX = 1 << 30;
         RARELY {
             bool wrap =
-            _insert->get() > MAX ||
-            _query->get() > MAX ||
-            _update->get() > MAX ||
-            _delete->get() > MAX ||
-            _getmore->get() > MAX ||
-            _command->get() > MAX;
+            *_insert > MAX ||
+            *_query > MAX ||
+            *_update > MAX ||
+            *_delete > MAX ||
+            *_getmore > MAX ||
+            *_command > MAX;
 
             if ( wrap ) {
-                _insert->zero();
-                _query->zero();
-                _update->zero();
-                _delete->zero();
-                _getmore->zero();
-                _command->zero();
+               * _insert=0;
+               * _query=0;
+               * _update=0;
+               * _delete=0;
+               * _getmore=0;
+               * _command=0;
             }
 
         }
diff --git a/src/mongo/db/stats/counters.h b/src/mongo/db/stats/counters.h
index 0cb29aa..705ea32 100644
--- a/src/mongo/db/stats/counters.h
+++ b/src/mongo/db/stats/counters.h
@@ -34,14 +34,14 @@ namespace mongo {
 
         OpCounters();
 
-        AtomicUInt * getInsert() { return _insert; }
-        AtomicUInt * getQuery() { return _query; }
-        AtomicUInt * getUpdate() { return _update; }
-        AtomicUInt * getDelete() { return _delete; }
-        AtomicUInt * getGetMore() { return _getmore; }
-        AtomicUInt * getCommand() { return _command; }
-
-        void incInsertInWriteLock(int n) { _insert->x += n; }
+        unsigned int * getInsert() { return _insert; }
+        unsigned int * getQuery() { return _query; }
+        unsigned int * getUpdate() { return _update; }
+        unsigned int * getDelete() { return _delete; }
+        unsigned int * getGetMore() { return _getmore; }
+        unsigned int * getCommand() { return _command; }
+
+        void incInsertInWriteLock(int n) { *_insert += n; }
         void gotInsert() { _insert[0]++; }
         void gotQuery() { _query[0]++; }
         void gotUpdate() { _update[0]++; }
@@ -58,12 +58,12 @@ namespace mongo {
 
         // todo: there will be a lot of cache line contention on these.  need to do something 
         //       else eventually.
-        AtomicUInt * _insert;
-        AtomicUInt * _query;
-        AtomicUInt * _update;
-        AtomicUInt * _delete;
-        AtomicUInt * _getmore;
-        AtomicUInt * _command;
+        unsigned int * _insert;
+        unsigned int * _query;
+        unsigned int * _update;
+        unsigned int * _delete;
+        unsigned int * _getmore;
+        unsigned int * _command;
     };
 
     extern OpCounters globalOpCounters;
diff --git a/src/mongo/util/concurrency/spin_lock.cpp b/src/mongo/util/concurrency/spin_lock.cpp
index cbf517b..fffeebc 100644
--- a/src/mongo/util/concurrency/spin_lock.cpp
+++ b/src/mongo/util/concurrency/spin_lock.cpp
@@ -54,7 +54,7 @@ namespace mongo {
         for ( int i=0; i<1000; i++ ) {            
             if ( pthread_spin_trylock( &_lock ) == 0 )
                 return;
-            asm volatile ( "pause" ) ; // maybe trylock does this; just in case.
+            //asm volatile ( "pause" ) ; // maybe trylock does this; just in case.
         }
 
         for ( int i=0; i<1000; i++ ) {
