IMP-692: SNOW-713: Global objects in libllcommon duplicated in plugins

See http://jira.secondlife.com/browse/SNOW-713

This patch makes llcommon shared. It contains the following snowglobe
(SVN) changesets: 3478, 3479, 3480, 3481, 3482, 3485, 3496, 3498, 3500,
3519 and 3531, plus the fix for all rejects. Note that changes
to scripts/automated_build_scripts/opensrc-build.sh (changesets 3500
and 3625) were ignored as we don't have scripts/automated_build_scripts.

69 files changed, 362 insertions, 324 deletions

diff --git a/linden/indra/llcommon/CMakeLists.txt b/linden/indra/llcommon/CMakeLists.txt
index 7d001ae..5d590a9 100644
--- a/linden/indra/llcommon/CMakeLists.txt
+++ b/linden/indra/llcommon/CMakeLists.txt
@@ -4,6 +4,7 @@ project(llcommon)
 
 include(00-Common)
 include(LLCommon)
+include(Linking)
 
 include_directories(
     ${EXPAT_INCLUDE_DIRS}
@@ -192,31 +193,13 @@ set_source_files_properties(${llcommon_HEADER_FILES}
 
 list(APPEND llcommon_SOURCE_FILES ${llcommon_HEADER_FILES})
 
-add_library (llcommon ${llcommon_SOURCE_FILES})
+add_library (llcommon SHARED ${llcommon_SOURCE_FILES})
 target_link_libraries(
     llcommon
     ${APRUTIL_LIBRARIES}
     ${APR_LIBRARIES}
     ${EXPAT_LIBRARIES}
     ${ZLIB_LIBRARIES}
+    ${WINDOWS_LIBRARIES}
     )
 
-if(HAVE_64_BIT)
-        add_library (llcommonPIC ${llcommon_SOURCE_FILES})
-        add_dependencies(llcommonPIC prepare)
-
-        if(WINDOWS)
-                add_definitions(/FIXED:NO)
-        else(WINDOWS) # not windows therefore gcc LINUX and DARWIN
-                add_definitions(-fPIC)
-        endif(WINDOWS)
-        
-        target_link_libraries(
-                llcommonPIC
-                ${APRUTIL_LIBRARIES}
-                ${APR_LIBRARIES}
-                ${EXPAT_LIBRARIES}
-                ${ZLIB_LIBRARIES}
-                )
-endif(HAVE_64_BIT)
-
diff --git a/linden/indra/llcommon/imageids.h b/linden/indra/llcommon/imageids.h
index 7bae496..dc726dc 100644
--- a/linden/indra/llcommon/imageids.h
+++ b/linden/indra/llcommon/imageids.h
@@ -41,35 +41,35 @@
 
 class LLUUID;
 
-extern const LLUUID IMG_SMOKE;
+LL_COMMON_API extern const LLUUID IMG_SMOKE;
 
-extern const LLUUID IMG_DEFAULT;
+LL_COMMON_API extern const LLUUID IMG_DEFAULT;
 
-extern const LLUUID IMG_SUN;
-extern const LLUUID IMG_MOON;
-extern const LLUUID IMG_CLOUD_POOF;
-extern const LLUUID IMG_SHOT;
-extern const LLUUID IMG_SPARK;
-extern const LLUUID IMG_FIRE;
-extern const LLUUID IMG_FACE_SELECT;
-extern const LLUUID IMG_DEFAULT_AVATAR;
-extern const LLUUID IMG_INVISIBLE;
+LL_COMMON_API extern const LLUUID IMG_SUN;
+LL_COMMON_API extern const LLUUID IMG_MOON;
+LL_COMMON_API extern const LLUUID IMG_CLOUD_POOF;
+LL_COMMON_API extern const LLUUID IMG_SHOT;
+LL_COMMON_API extern const LLUUID IMG_SPARK;
+LL_COMMON_API extern const LLUUID IMG_FIRE;
+LL_COMMON_API extern const LLUUID IMG_FACE_SELECT;
+LL_COMMON_API extern const LLUUID IMG_DEFAULT_AVATAR;
+LL_COMMON_API extern const LLUUID IMG_INVISIBLE;
 
-extern const LLUUID IMG_EXPLOSION;
-extern const LLUUID IMG_EXPLOSION_2;
-extern const LLUUID IMG_EXPLOSION_3;
-extern const LLUUID IMG_EXPLOSION_4;
-extern const LLUUID IMG_SMOKE_POOF;
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION;
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_2;
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_3;
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_4;
+LL_COMMON_API extern const LLUUID IMG_SMOKE_POOF;
 
-extern const LLUUID IMG_BIG_EXPLOSION_1;
-extern const LLUUID IMG_BIG_EXPLOSION_2;
+LL_COMMON_API extern const LLUUID IMG_BIG_EXPLOSION_1;
+LL_COMMON_API extern const LLUUID IMG_BIG_EXPLOSION_2;
 
-extern const LLUUID IMG_BLOOM1;
-extern const LLUUID TERRAIN_DIRT_DETAIL;
-extern const LLUUID TERRAIN_GRASS_DETAIL;
-extern const LLUUID TERRAIN_MOUNTAIN_DETAIL;
-extern const LLUUID TERRAIN_ROCK_DETAIL;
+LL_COMMON_API extern const LLUUID IMG_BLOOM1;
+LL_COMMON_API extern const LLUUID TERRAIN_DIRT_DETAIL;
+LL_COMMON_API extern const LLUUID TERRAIN_GRASS_DETAIL;
+LL_COMMON_API extern const LLUUID TERRAIN_MOUNTAIN_DETAIL;
+LL_COMMON_API extern const LLUUID TERRAIN_ROCK_DETAIL;
 
-extern const LLUUID DEFAULT_WATER_NORMAL;
+LL_COMMON_API extern const LLUUID DEFAULT_WATER_NORMAL;
 
 #endif
diff --git a/linden/indra/llcommon/indra_constants.h b/linden/indra/llcommon/indra_constants.h
index 34d1538..279d280 100644
--- a/linden/indra/llcommon/indra_constants.h
+++ b/linden/indra/llcommon/indra_constants.h
@@ -263,15 +263,15 @@ const U8 GOD_LIKE = 1;
 const U8 GOD_NOT = 0;
 
 // "agent id" for things that should be done to ALL agents
-extern const LLUUID LL_UUID_ALL_AGENTS;
+LL_COMMON_API extern const LLUUID LL_UUID_ALL_AGENTS;
 
 // inventory library owner
-extern const LLUUID ALEXANDRIA_LINDEN_ID;
+LL_COMMON_API extern const LLUUID ALEXANDRIA_LINDEN_ID;
 
-extern const LLUUID GOVERNOR_LINDEN_ID;
-extern const LLUUID REALESTATE_LINDEN_ID;
+LL_COMMON_API extern const LLUUID GOVERNOR_LINDEN_ID;
+LL_COMMON_API extern const LLUUID REALESTATE_LINDEN_ID;
 // Maintenance's group id.
-extern const LLUUID MAINTENANCE_GROUP_ID;
+LL_COMMON_API extern const LLUUID MAINTENANCE_GROUP_ID;
 
 // Flags for kick message
 const U32 KICK_FLAGS_DEFAULT    = 0x0;
diff --git a/linden/indra/llcommon/linden_common.h b/linden/indra/llcommon/linden_common.h
index 25dd629..bf844b9 100644
--- a/linden/indra/llcommon/linden_common.h
+++ b/linden/indra/llcommon/linden_common.h
@@ -51,16 +51,16 @@
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
-#include <iostream>
-#include <fstream>
+#include <iosfwd>
 
-// Work Microsoft compiler warnings
+// Work around Microsoft compiler warnings in STL headers
 #ifdef LL_WINDOWS
 #pragma warning (disable : 4702) // unreachable code
 #pragma warning (disable : 4244) // conversion from time_t to S32
 #endif  //      LL_WINDOWS
 
-#include <algorithm>
+// *TODO: Eliminate these, most library .cpp files don't need them.
+// Add them to llviewerprecompiledheaders.h if necessary.
 #include <list>
 #include <map>
 #include <vector>
@@ -76,18 +76,21 @@
 #pragma warning (disable : 4512) // assignment operator could not be generated
 #pragma warning (disable : 4706) // assignment within conditional (even if((x = y)) )
 #pragma warning (disable : 4265) // boost 1.36.0, non-virtual destructor in boost::exception_detail::*
+
+// Reenable warnings we disabled above
+#pragma warning (3 : 4702) // unreachable code, we like level 3, not 4
+// moved msvc warnings to llpreprocessor.h  *TODO - delete this comment after merge conflicts are unlikely -brad
 #endif  //      LL_WINDOWS
 
 // Linden only libs in alpha-order other than stdtypes.h
+// *NOTE: Please keep includes here to a minimum, see above.
 #include "stdtypes.h"
 #include "lldefs.h"
 #include "llerror.h"
 #include "llextendedstatus.h"
-#include "llfasttimer.h"
+// Don't do this, adds 15K lines of header code to every library file.
+//#include "llfasttimer.h"
 #include "llfile.h"
 #include "llformat.h"
-#include "llstring.h"
-#include "llsys.h"
-#include "lltimer.h"
 
 #endif
diff --git a/linden/indra/llcommon/llapp.cpp b/linden/indra/llcommon/llapp.cpp
index 199315f..e269f59 100644
--- a/linden/indra/llcommon/llapp.cpp
+++ b/linden/indra/llcommon/llapp.cpp
@@ -420,7 +420,7 @@ void LLApp::incSigChildCount()
 int LLApp::getPid()
 {
 #if LL_WINDOWS
-        return 0;
+        return GetCurrentProcessId();
 #else
         return getpid();
 #endif
diff --git a/linden/indra/llcommon/llapp.h b/linden/indra/llcommon/llapp.h
index f8a593c..96112c9 100644
--- a/linden/indra/llcommon/llapp.h
+++ b/linden/indra/llcommon/llapp.h
@@ -34,14 +34,17 @@
 #define LL_LLAPP_H
 
 #include <map>
-#include "llapr.h"
 #include "llrun.h"
 #include "llsd.h"
 
 // Forward declarations
+template <typename Type> class LLAtomic32;
+typedef LLAtomic32<U32> LLAtomicU32;
 class LLErrorThread;
-class LLApp;
-
+class LLLiveFile;
+#if LL_LINUX
+typedef struct siginfo siginfo_t;
+#endif
 
 typedef void (*LLAppErrorHandler)();
 typedef void (*LLAppChildCallback)(int pid, bool exited, int status);
@@ -62,7 +65,7 @@ public:
 };
 #endif
 
-class LLApp
+class LL_COMMON_API LLApp
 {
         friend class LLErrorThread;
 public:
@@ -189,8 +192,6 @@ public:
 #if !LL_WINDOWS
         static U32  getSigChildCount();
         static void incSigChildCount();
-#else
-#define getpid GetCurrentProcessId
 #endif
         static int getPid();
 
diff --git a/linden/indra/llcommon/llapr.h b/linden/indra/llcommon/llapr.h
index 7f770b0..2aed515 100644
--- a/linden/indra/llcommon/llapr.h
+++ b/linden/indra/llcommon/llapr.h
@@ -48,25 +48,24 @@
 #include "apr_atomic.h"
 #include "llstring.h"
 
-extern apr_thread_mutex_t* gLogMutexp;
-extern apr_thread_mutex_t* gCallStacksLogMutexp;
+extern LL_COMMON_API apr_thread_mutex_t* gLogMutexp;
 
 /** 
  * @brief initialize the common apr constructs -- apr itself, the
  * global pool, and a mutex.
  */
-void ll_init_apr();
+void LL_COMMON_API ll_init_apr();
 
 /** 
  * @brief Cleanup those common apr constructs.
  */
-void ll_cleanup_apr();
+void LL_COMMON_API ll_cleanup_apr();
 
 //
 //LL apr_pool
 //manage apr_pool_t, destroy allocated apr_pool in the destruction function.
 //
-class LLAPRPool
+class LL_COMMON_API LLAPRPool
 {
 public:
         LLAPRPool(apr_pool_t *parent = NULL, apr_size_t size = 0, BOOL releasePoolFlag = TRUE) ;
@@ -92,7 +91,7 @@ protected:
 //which clears memory automatically.
 //so it can not hold static data or data after memory is cleared
 //
-class LLVolatileAPRPool : protected LLAPRPool
+class LL_COMMON_API LLVolatileAPRPool : protected LLAPRPool
 {
 public:
         LLVolatileAPRPool(apr_pool_t *parent = NULL, apr_size_t size = 0, BOOL releasePoolFlag = TRUE);
@@ -126,7 +125,7 @@ private:
  * destructor handles the unlock. Instances of this class are
  * <b>not</b> thread safe.
  */
-class LLScopedLock : private boost::noncopyable
+class LL_COMMON_API LLScopedLock : private boost::noncopyable
 {
 public:
         /**
@@ -201,7 +200,7 @@ typedef LLAtomic32<S32> LLAtomicS32;
 //      2, a global pool.
 //
 
-class LLAPRFile : boost::noncopyable
+class LL_COMMON_API LLAPRFile : boost::noncopyable
 {
         // make this non copyable since a copy closes the file
 private:
@@ -257,10 +256,10 @@ public:
  * APR_SUCCESS.
  * @return Returns <code>true</code> if status is an error condition.
  */
-bool ll_apr_warn_status(apr_status_t status);
+bool LL_COMMON_API ll_apr_warn_status(apr_status_t status);
 
-void ll_apr_assert_status(apr_status_t status);
+void LL_COMMON_API ll_apr_assert_status(apr_status_t status);
 
-extern "C" apr_pool_t* gAPRPoolp; // Global APR memory pool
+extern "C" LL_COMMON_API apr_pool_t* gAPRPoolp; // Global APR memory pool
 
 #endif // LL_LLAPR_H
diff --git a/linden/indra/llcommon/llassettype.h b/linden/indra/llcommon/llassettype.h
index 4077b8d..9f611ae 100644
--- a/linden/indra/llcommon/llassettype.h
+++ b/linden/indra/llcommon/llassettype.h
@@ -37,7 +37,7 @@
 
 #include "stdenums.h"   // for EDragAndDropType
 
-class LLAssetType
+class LL_COMMON_API LLAssetType
 {
 public:
         enum EType
diff --git a/linden/indra/llcommon/llbase32.h b/linden/indra/llcommon/llbase32.h
index 63a93e1..47cd893 100644
--- a/linden/indra/llcommon/llbase32.h
+++ b/linden/indra/llcommon/llbase32.h
@@ -34,7 +34,7 @@
 #ifndef LLBASE32_H
 #define LLBASE32_h
 
-class LLBase32
+class LL_COMMON_API LLBase32
 {
 public:
         static std::string encode(const U8* input, size_t input_size);
diff --git a/linden/indra/llcommon/llbase64.h b/linden/indra/llcommon/llbase64.h
index 58414bb..15b27a6 100644
--- a/linden/indra/llcommon/llbase64.h
+++ b/linden/indra/llcommon/llbase64.h
@@ -34,7 +34,7 @@
 #ifndef LLBASE64_H
 #define LLBASE64_h
 
-class LLBase64
+class LL_COMMON_API LLBase64
 {
 public:
         static std::string encode(const U8* input, size_t input_size);
diff --git a/linden/indra/llcommon/llcommon.h b/linden/indra/llcommon/llcommon.h
index 5f77988..851d4ac 100644
--- a/linden/indra/llcommon/llcommon.h
+++ b/linden/indra/llcommon/llcommon.h
@@ -38,7 +38,7 @@
 #include "lltimer.h"
 #include "llfile.h"
 
-class LLCommon
+class LL_COMMON_API LLCommon
 {
 public:
         static void initClass();
diff --git a/linden/indra/llcommon/llcrc.h b/linden/indra/llcommon/llcrc.h
index 27fae7d..7436906 100644
--- a/linden/indra/llcommon/llcrc.h
+++ b/linden/indra/llcommon/llcrc.h
@@ -50,7 +50,7 @@
 //  llinfos << "File crc: " << crc.getCRC() << llendl;
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-class LLCRC
+class LL_COMMON_API LLCRC
 {
 protected:
         U32 mCurrent;
diff --git a/linden/indra/llcommon/llcriticaldamp.h b/linden/indra/llcommon/llcriticaldamp.h
index ad98284..13e37d8 100644
--- a/linden/indra/llcommon/llcriticaldamp.h
+++ b/linden/indra/llcommon/llcriticaldamp.h
@@ -38,7 +38,7 @@
 
 #include "llframetimer.h"
 
-class LLCriticalDamp 
+class LL_COMMON_API LLCriticalDamp
 {
 public:
         LLCriticalDamp();
diff --git a/linden/indra/llcommon/llcursortypes.h b/linden/indra/llcommon/llcursortypes.h
index bea7035..836ecc3 100644
--- a/linden/indra/llcommon/llcursortypes.h
+++ b/linden/indra/llcommon/llcursortypes.h
@@ -77,6 +77,6 @@ enum ECursorType {
         UI_CURSOR_COUNT                 // Number of elements in this enum (NOT a cursor)
 };
 
-ECursorType getCursorFromString(const std::string& cursor_string);
+LL_COMMON_API ECursorType getCursorFromString(const std::string& cursor_string);
 
 #endif // LL_LLCURSORTYPES_H
diff --git a/linden/indra/llcommon/lldate.h b/linden/indra/llcommon/lldate.h
index 5e1a491..d27da79 100644
--- a/linden/indra/llcommon/lldate.h
+++ b/linden/indra/llcommon/lldate.h
@@ -46,7 +46,7 @@
  *
  * The date class represents a point in time after epoch - 1970-01-01.
  */
-class LLDate
+class LL_COMMON_API LLDate
 {
 public:
         /** 
@@ -153,9 +153,9 @@ private:
 };
 
 // Helper function to stream out a date
-std::ostream& operator<<(std::ostream& s, const LLDate& date);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLDate& date);
 
 // Helper function to stream in a date
-std::istream& operator>>(std::istream& s, LLDate& date);
+LL_COMMON_API std::istream& operator>>(std::istream& s, LLDate& date);
 
 #endif // LL_LLDATE_H
diff --git a/linden/indra/llcommon/llerror.cpp b/linden/indra/llcommon/llerror.cpp
index 30b61a9..edc570f 100644
--- a/linden/indra/llcommon/llerror.cpp
+++ b/linden/indra/llcommon/llerror.cpp
@@ -58,7 +58,9 @@
 #include "llsd.h"
 #include "llsdserialize.h"
 #include "llstl.h"
+#include "lltimer.h"
 
+extern apr_thread_mutex_t* gCallStacksLogMutexp;
 
 namespace {
 #if !LL_WINDOWS
diff --git a/linden/indra/llcommon/llerror.h b/linden/indra/llcommon/llerror.h
index 37e922d..5a4c644 100644
--- a/linden/indra/llcommon/llerror.h
+++ b/linden/indra/llcommon/llerror.h
@@ -131,7 +131,7 @@ namespace LLError
         
         class CallSite;
         
-        class Log
+        class LL_COMMON_API Log
         {
         public:
                 static bool shouldLog(CallSite&);
@@ -140,7 +140,7 @@ namespace LLError
                 static void flush(std::ostringstream*, const CallSite&);
         };
         
-        class CallSite
+        class LL_COMMON_API CallSite
         {
                 // Represents a specific place in the code where a message is logged
                 // This is public because it is used by the macros below.  It is not
@@ -189,7 +189,7 @@ namespace LLError
         //LLCallStacks is designed not to be thread-safe.
    //so try not to use it in multiple parallel threads at same time.
    //Used in a single thread at a time is fine.
-   class LLCallStacks
+   class LL_COMMON_API LLCallStacks
    {
    private:
        static char**  sBuffer ;
diff --git a/linden/indra/llcommon/llerrorcontrol.h b/linden/indra/llcommon/llerrorcontrol.h
index fae7547..54138b2 100644
--- a/linden/indra/llcommon/llerrorcontrol.h
+++ b/linden/indra/llcommon/llerrorcontrol.h
@@ -52,12 +52,12 @@ class LLSD;
 
 namespace LLError
 {
-        void initForServer(const std::string& identity);
+        LL_COMMON_API void initForServer(const std::string& identity);
                 // resets all logging settings to defaults needed by server processes
                 // logs to stderr, syslog, and windows debug log
                 // the identity string is used for in the syslog
 
-        void initForApplication(const std::string& dir);
+        LL_COMMON_API void initForApplication(const std::string& dir);
                 // resets all logging settings to defaults needed by applicaitons
                 // logs to stderr and windows debug log
                 // sets up log configuration from the file logcontrol.xml in dir
@@ -68,14 +68,14 @@ namespace LLError
                 Setting a level means log messages at that level or above.
         */
         
-        void setPrintLocation(bool);
-        void setDefaultLevel(LLError::ELevel);
-        void setFunctionLevel(const std::string& function_name, LLError::ELevel);
-        void setClassLevel(const std::string& class_name, LLError::ELevel);
-        void setFileLevel(const std::string& file_name, LLError::ELevel);
-        void setTagLevel(const std::string& file_name, LLError::ELevel);
+        LL_COMMON_API void setPrintLocation(bool);
+        LL_COMMON_API void setDefaultLevel(LLError::ELevel);
+        LL_COMMON_API void setFunctionLevel(const std::string& function_name, LLError::ELevel);
+        LL_COMMON_API void setClassLevel(const std::string& class_name, LLError::ELevel);
+        LL_COMMON_API void setFileLevel(const std::string& file_name, LLError::ELevel);
+        LL_COMMON_API void setTagLevel(const std::string& file_name, LLError::ELevel);
         
-        void configure(const LLSD&);
+        LL_COMMON_API void configure(const LLSD&);
                 // the LLSD can configure all of the settings
                 // usually read automatically from the live errorlog.xml file
 
@@ -85,25 +85,25 @@ namespace LLError
         */
 
         typedef void(*FatalFunction)(const std::string& message);
-        void crashAndLoop(const std::string& message);
+        LL_COMMON_API void crashAndLoop(const std::string& message);
                 // Default fatal funtion: access null pointer and loops forever
 
-        void setFatalFunction(FatalFunction);
+        LL_COMMON_API void setFatalFunction(FatalFunction);
                 // The fatal function will be called when an message of LEVEL_ERROR
                 // is logged.  Note: supressing a LEVEL_ERROR message from being logged
                 // (by, for example, setting a class level to LEVEL_NONE), will keep
                 // the that message from causing the fatal funciton to be invoked.
                 
         typedef std::string (*TimeFunction)();
-        std::string utcTime();
+        LL_COMMON_API std::string utcTime();
         
-        void setTimeFunction(TimeFunction);
+        LL_COMMON_API void setTimeFunction(TimeFunction);
                 // The function is use to return the current time, formatted for
                 // display by those error recorders that want the time included.
 
 
 
-        class Recorder
+        class LL_COMMON_API Recorder
         {
                 // An object that handles the actual output or error messages.
         public:
@@ -117,17 +117,17 @@ namespace LLError
                         // included in the text of the message
         };
         
-        void addRecorder(Recorder*);
-        void removeRecorder(Recorder*);
+        LL_COMMON_API void addRecorder(Recorder*);
+        LL_COMMON_API void removeRecorder(Recorder*);
                 // each error message is passed to each recorder via recordMessage()
         
-        void logToFile(const std::string& filename);
-        void logToFixedBuffer(LLFixedBuffer*);
+        LL_COMMON_API void logToFile(const std::string& filename);
+        LL_COMMON_API void logToFixedBuffer(LLFixedBuffer*);
                 // Utilities to add recorders for logging to a file or a fixed buffer
                 // A second call to the same function will remove the logger added
                 // with the first.
                 // Passing the empty string or NULL to just removes any prior.
-        std::string logFileName();
+        LL_COMMON_API std::string logFileName();
                 // returns name of current logging file, empty string if none
 
 
@@ -136,11 +136,11 @@ namespace LLError
         */
 
         class Settings;
-        Settings* saveAndResetSettings();
-        void restoreSettings(Settings *);
+        LL_COMMON_API Settings* saveAndResetSettings();
+        LL_COMMON_API void restoreSettings(Settings *);
                 
-        std::string abbreviateFile(const std::string& filePath);
-        int shouldLogCallCount();
+        LL_COMMON_API std::string abbreviateFile(const std::string& filePath);
+        LL_COMMON_API int shouldLogCallCount();
         
 };
 
diff --git a/linden/indra/llcommon/llerrorthread.cpp b/linden/indra/llcommon/llerrorthread.cpp
index 4c779c5..e2b106a 100644
--- a/linden/indra/llcommon/llerrorthread.cpp
+++ b/linden/indra/llcommon/llerrorthread.cpp
@@ -32,6 +32,7 @@
 #include "linden_common.h"
 #include "llerrorthread.h"
 #include "llapp.h"
+#include "lltimer.h"
 
 LLErrorThread::LLErrorThread()
         : LLThread("Error"),
diff --git a/linden/indra/llcommon/llerrorthread.h b/linden/indra/llcommon/llerrorthread.h
index f1d6ffc..3121d29 100644
--- a/linden/indra/llcommon/llerrorthread.h
+++ b/linden/indra/llcommon/llerrorthread.h
@@ -35,7 +35,7 @@
 
 #include "llthread.h"
 
-class LLErrorThread : public LLThread
+class LL_COMMON_API LLErrorThread : public LLThread
 {
 public:
         LLErrorThread();
diff --git a/linden/indra/llcommon/llevent.h b/linden/indra/llcommon/llevent.h
index 60887a0..6b223a8 100644
--- a/linden/indra/llcommon/llevent.h
+++ b/linden/indra/llcommon/llevent.h
@@ -44,7 +44,7 @@ class LLEventDispatcher;
 class LLObservable;
 
 // Abstract event. All events derive from LLEvent
-class LLEvent : public LLThreadSafeRefCount
+class LL_COMMON_API LLEvent : public LLThreadSafeRefCount
 {
 protected:
         virtual ~LLEvent();
@@ -72,7 +72,7 @@ private:
 };
 
 // Abstract listener. All listeners derive from LLEventListener
-class LLEventListener : public LLThreadSafeRefCount
+class LL_COMMON_API LLEventListener : public LLThreadSafeRefCount
 {
 protected:
         virtual ~LLEventListener();
@@ -89,7 +89,7 @@ public:
 };
 
 // A listener which tracks references to it and cleans up when it's deallocated
-class LLSimpleListener : public LLEventListener
+class LL_COMMON_API LLSimpleListener : public LLEventListener
 {
 public:
         void clearDispatchers();
@@ -114,7 +114,7 @@ struct LLListenerEntry
 // Base class for a dispatcher - an object which listens
 // to events being fired and relays them to their
 // appropriate destinations.
-class LLEventDispatcher : public LLThreadSafeRefCount
+class LL_COMMON_API LLEventDispatcher : public LLThreadSafeRefCount
 {
 protected:
         virtual ~LLEventDispatcher();
@@ -157,7 +157,7 @@ private:
 // In order for this class to work properly, it needs
 // an instance of an LLEventDispatcher to route events to their
 // listeners.
-class LLObservable
+class LL_COMMON_API LLObservable
 {
 public:
         // Initialize with the default Dispatcher
diff --git a/linden/indra/llcommon/llfasttimer.cpp b/linden/indra/llcommon/llfasttimer.cpp
index 4aa23bb..5f091d5 100644
--- a/linden/indra/llcommon/llfasttimer.cpp
+++ b/linden/indra/llcommon/llfasttimer.cpp
@@ -42,6 +42,7 @@
 #include <sched.h>
 #elif LL_DARWIN
 #include <sys/time.h>
+#include "lltimer.h"    // get_clock_count()
 #else 
 #error "architecture not supported"
 #endif
diff --git a/linden/indra/llcommon/llfasttimer.h b/linden/indra/llcommon/llfasttimer.h
index 8c1cf47..602a2f7 100644
--- a/linden/indra/llcommon/llfasttimer.h
+++ b/linden/indra/llcommon/llfasttimer.h
@@ -35,9 +35,9 @@
 
 #define FAST_TIMER_ON 1
 
-U64 get_cpu_clock_count();
+LL_COMMON_API U64 get_cpu_clock_count();
 
-class LLFastTimer
+class LL_COMMON_API LLFastTimer
 {
 public:
         enum EFastTimerType
diff --git a/linden/indra/llcommon/llfile.h b/linden/indra/llcommon/llfile.h
index c6092f7..ee37605 100644
--- a/linden/indra/llcommon/llfile.h
+++ b/linden/indra/llcommon/llfile.h
@@ -70,7 +70,7 @@ typedef struct stat		llstat;
 
 #include "llstring.h" // safe char* -> std::string conversion
 
-class   LLFile
+class LL_COMMON_API LLFile
 {
 public:
         // All these functions take UTF8 path/filenames.
@@ -95,7 +95,7 @@ public:
 
 #if USE_LLFILESTREAMS
 
-class   llifstream      :       public  std::basic_istream < char , std::char_traits < char > >
+class LL_COMMON_API llifstream  :       public  std::basic_istream < char , std::char_traits < char > >
 {
         // input stream associated with a C stream
 public:
@@ -136,7 +136,7 @@ private:
 };
 
 
-class   llofstream      :       public  std::basic_ostream< char , std::char_traits < char > >
+class LL_COMMON_API llofstream  :       public  std::basic_ostream< char , std::char_traits < char > >
 {
 public:
         typedef std::basic_ostream< char , std::char_traits < char > > _Myt;
@@ -185,7 +185,7 @@ private:
 //#define       llifstream      std::ifstream
 //#define       llofstream      std::ofstream
 
-class   llifstream      :       public  std::ifstream
+class LL_COMMON_API llifstream  :       public  std::ifstream
 {
 public:
         llifstream() : std::ifstream()
@@ -203,7 +203,7 @@ public:
 };
 
 
-class   llofstream      :       public  std::ofstream
+class LL_COMMON_API llofstream  :       public  std::ofstream
 {
 public:
         llofstream() : std::ofstream()
diff --git a/linden/indra/llcommon/llfindlocale.h b/linden/indra/llcommon/llfindlocale.h
index f17c774..b812a06 100644
--- a/linden/indra/llcommon/llfindlocale.h
+++ b/linden/indra/llcommon/llfindlocale.h
@@ -59,8 +59,8 @@ typedef enum {
 /* This allocates/fills in a FL_Locale structure with pointers to
    strings (which should be treated as static), or NULL for inappropriate /
    undetected fields. */
-FL_Success FL_FindLocale(FL_Locale **locale, FL_Domain domain);
+LL_COMMON_API FL_Success FL_FindLocale(FL_Locale **locale, FL_Domain domain);
 /* This should be used to free the struct written by FL_FindLocale */
-void FL_FreeLocale(FL_Locale **locale);
+LL_COMMON_API void FL_FreeLocale(FL_Locale **locale);
 
 #endif /*__findlocale_h_*/
diff --git a/linden/indra/llcommon/llfixedbuffer.h b/linden/indra/llcommon/llfixedbuffer.h
index 992a024..51d0701 100644
--- a/linden/indra/llcommon/llfixedbuffer.h
+++ b/linden/indra/llcommon/llfixedbuffer.h
@@ -41,7 +41,7 @@
 
 // Fixed size buffer for console output and other things.
 
-class LLFixedBuffer
+class LL_COMMON_API LLFixedBuffer
 {
 public:
         LLFixedBuffer(const U32 max_lines = 20);
diff --git a/linden/indra/llcommon/llformat.h b/linden/indra/llcommon/llformat.h
index 44c62d9..ad30d4f 100644
--- a/linden/indra/llcommon/llformat.h
+++ b/linden/indra/llcommon/llformat.h
@@ -40,6 +40,6 @@
 // *NOTE: buffer limited to 1024, (but vsnprintf prevents overrun)
 // should perhaps be replaced with boost::format.
 
-std::string llformat(const char *fmt, ...);
+LL_COMMON_API std::string llformat(const char *fmt, ...);
 
 #endif // LL_LLFORMAT_H
diff --git a/linden/indra/llcommon/llframetimer.h b/linden/indra/llcommon/llframetimer.h
index 8f51272..f4775a9 100644
--- a/linden/indra/llcommon/llframetimer.h
+++ b/linden/indra/llcommon/llframetimer.h
@@ -43,7 +43,7 @@
 #include "lltimer.h"
 #include "timing.h"
 
-class LLFrameTimer 
+class LL_COMMON_API LLFrameTimer
 {
 public:
         LLFrameTimer() : mStartTime( sFrameTime ), mExpiry(0), mStarted(TRUE) {}
diff --git a/linden/indra/llcommon/llheartbeat.h b/linden/indra/llcommon/llheartbeat.h
index fecb5b1..6f70269 100644
--- a/linden/indra/llcommon/llheartbeat.h
+++ b/linden/indra/llcommon/llheartbeat.h
@@ -40,7 +40,7 @@
 // Note: Win32 does not support the heartbeat/smackdown system;
 //   heartbeat-delivery turns into a no-op there.
 
-class LLHeartbeat
+class LL_COMMON_API LLHeartbeat
 {
 public:
         // secs_between_heartbeat: after a heartbeat is successfully delivered,
diff --git a/linden/indra/llcommon/llliveappconfig.h b/linden/indra/llcommon/llliveappconfig.h
index 55d84a4..3251a7c 100644
--- a/linden/indra/llcommon/llliveappconfig.h
+++ b/linden/indra/llcommon/llliveappconfig.h
@@ -37,7 +37,7 @@
 
 class LLApp;
 
-class LLLiveAppConfig : public LLLiveFile
+class LL_COMMON_API LLLiveAppConfig : public LLLiveFile
 {
 public:
         // To use this, instantiate a LLLiveAppConfig object inside your main loop.
diff --git a/linden/indra/llcommon/lllivefile.h b/linden/indra/llcommon/lllivefile.h
index fddf006..72f16fd 100644
--- a/linden/indra/llcommon/lllivefile.h
+++ b/linden/indra/llcommon/lllivefile.h
@@ -36,7 +36,7 @@
 const F32 configFileRefreshRate = 5.0; // seconds
 
 
-class LLLiveFile
+class LL_COMMON_API LLLiveFile
 {
 public:
         LLLiveFile(const std::string &filename, const F32 refresh_period = 5.f);
diff --git a/linden/indra/llcommon/lllog.h b/linden/indra/llcommon/lllog.h
index 7ac6c8a..4b6777b 100644
--- a/linden/indra/llcommon/lllog.h
+++ b/linden/indra/llcommon/lllog.h
@@ -41,7 +41,7 @@ class LLLogImpl;
 class LLApp;
 class LLSD;
 
-class LLLog
+class LL_COMMON_API LLLog
 {
 public:
         LLLog(LLApp* app);
diff --git a/linden/indra/llcommon/llmd5.cpp b/linden/indra/llcommon/llmd5.cpp
index 14b4f9f..887979b 100644
--- a/linden/indra/llcommon/llmd5.cpp
+++ b/linden/indra/llcommon/llmd5.cpp
@@ -83,6 +83,7 @@ documentation and/or software.
 #include "llmd5.h"
 
 #include <cassert>
+#include <iostream>
 
 // how many bytes to grab at a time when checking files
 const int LLMD5::BLOCK_LEN = 4096;
diff --git a/linden/indra/llcommon/llmd5.h b/linden/indra/llcommon/llmd5.h
index d8bca03..df9d732 100644
--- a/linden/indra/llcommon/llmd5.h
+++ b/linden/indra/llcommon/llmd5.h
@@ -80,7 +80,7 @@ const int MD5RAW_BYTES = 16;
 const int MD5HEX_STR_SIZE = 33;  // char hex[MD5HEX_STR_SIZE]; with null
 const int MD5HEX_STR_BYTES = 32; // message system fixed size
 
-class LLMD5 {
+class LL_COMMON_API LLMD5 {
 // first, some types:
   typedef unsigned       int uint4; // assumes integer is 4 words long
   typedef unsigned short int uint2; // assumes short integer is 2 words long
diff --git a/linden/indra/llcommon/llmemory.cpp b/linden/indra/llcommon/llmemory.cpp
index a6de3d2..74004b0 100644
--- a/linden/indra/llcommon/llmemory.cpp
+++ b/linden/indra/llcommon/llmemory.cpp
@@ -283,6 +283,11 @@ LLRefCount::LLRefCount() :
 {
 }
 
+LLRefCount::LLRefCount(const LLRefCount& other)
+:   mRef(0)
+{
+}
+
 LLRefCount::~LLRefCount()
 { 
         if (mRef != 0)
@@ -290,7 +295,13 @@ LLRefCount::~LLRefCount()
                 llerrs << "deleting non-zero reference" << llendl;
         }
 }
-        
+
+LLRefCount& LLRefCount::operator=(const LLRefCount&)
+{
+        // do nothing, since ref count is specific to *this* reference
+        return *this;
+}
+
 //----------------------------------------------------------------------------
 
 #if defined(LL_WINDOWS)
diff --git a/linden/indra/llcommon/llmemory.h b/linden/indra/llcommon/llmemory.h
index b5c0711..9aa4b85 100644
--- a/linden/indra/llcommon/llmemory.h
+++ b/linden/indra/llcommon/llmemory.h
@@ -45,7 +45,7 @@ const U32 LLREFCOUNT_SENTINEL_VALUE = 0xAAAAAAAA;
 
 //----------------------------------------------------------------------------
 
-class LLMemory
+class LL_COMMON_API LLMemory
 {
 public:
         static void initClass();
@@ -68,12 +68,12 @@ private:
 
 //----------------------------------------------------------------------------
 
-class LLRefCount
+class LL_COMMON_API LLRefCount
 {
 protected:
-        LLRefCount(const LLRefCount&); // not implemented
+        LLRefCount(const LLRefCount&);
 private:
-        LLRefCount&operator=(const LLRefCount&); // not implemented
+        LLRefCount&operator=(const LLRefCount&);
 
 protected:
         virtual ~LLRefCount(); // use unref()
@@ -467,6 +467,6 @@ private:
 
 // Return the resident set size of the current process, in bytes.
 // Return value is zero if not known.
-U64 getCurrentRSS();
+LL_COMMON_API U64 getCurrentRSS();
 
 #endif
diff --git a/linden/indra/llcommon/llmemorystream.h b/linden/indra/llcommon/llmemorystream.h
index f348632..fa0f5d2 100644
--- a/linden/indra/llcommon/llmemorystream.h
+++ b/linden/indra/llcommon/llmemorystream.h
@@ -52,7 +52,7 @@
  * be careful to always pass in a valid memory location that exists
  * for at least as long as this streambuf.
  */
-class LLMemoryStreamBuf : public std::streambuf
+class LL_COMMON_API LLMemoryStreamBuf : public std::streambuf
 {
 public:
         LLMemoryStreamBuf(const U8* start, S32 length);
@@ -74,7 +74,7 @@ protected:
  * be careful to always pass in a valid memory location that exists
  * for at least as long as this streambuf.
  */
-class LLMemoryStream : public std::istream
+class LL_COMMON_API LLMemoryStream : public std::istream
 {
 public:
         LLMemoryStream(const U8* start, S32 length);
diff --git a/linden/indra/llcommon/llmemtype.h b/linden/indra/llcommon/llmemtype.h
index a9ebc20..d4cc67e 100644
--- a/linden/indra/llcommon/llmemtype.h
+++ b/linden/indra/llcommon/llmemtype.h
@@ -57,7 +57,7 @@ static void  operator delete(void* p) { ll_release(p); }
 
 //----------------------------------------------------------------------------
 
-class LLMemType
+class LL_COMMON_API LLMemType
 {
 public:
         // Also update sTypeDesc in llmemory.cpp
diff --git a/linden/indra/llcommon/llmetrics.h b/linden/indra/llcommon/llmetrics.h
index 1d91e8c..f6f49eb 100644
--- a/linden/indra/llcommon/llmetrics.h
+++ b/linden/indra/llcommon/llmetrics.h
@@ -38,7 +38,7 @@
 class LLMetricsImpl;
 class LLSD;
 
-class LLMetrics
+class LL_COMMON_API LLMetrics
 {
 public:
         LLMetrics();
diff --git a/linden/indra/llcommon/llmortician.h b/linden/indra/llcommon/llmortician.h
index 247632f..55a101a 100644
--- a/linden/indra/llcommon/llmortician.h
+++ b/linden/indra/llcommon/llmortician.h
@@ -35,7 +35,7 @@
 
 #include "stdtypes.h"
 
-class LLMortician 
+class LL_COMMON_API LLMortician
 {
 public:
         LLMortician() { mIsDead = FALSE; }
diff --git a/linden/indra/llcommon/llpreprocessor.h b/linden/indra/llcommon/llpreprocessor.h
index 2e4fd47..6886e3a 100644
--- a/linden/indra/llcommon/llpreprocessor.h
+++ b/linden/indra/llcommon/llpreprocessor.h
@@ -92,47 +92,63 @@
 
 #endif
 
-
 // Deal with the differeneces on Windows
-#if LL_MSVC
-namespace snprintf_hack
-{
-        int snprintf(char *str, size_t size, const char *format, ...);
-}
-
-// #define snprintf safe_snprintf               /* Flawfinder: ignore */
-using snprintf_hack::snprintf;
-#endif  // LL_MSVC
-
-// Static linking with apr on windows needs to be declared.
-#ifdef LL_WINDOWS
-#ifndef APR_DECLARE_STATIC
-#define APR_DECLARE_STATIC // For APR on Windows
-#endif
-#ifndef APU_DECLARE_STATIC
-#define APU_DECLARE_STATIC // For APR util on Windows
-#endif
-#endif
-
 #if defined(LL_WINDOWS)
 #define BOOST_REGEX_NO_LIB 1
 #define CURL_STATICLIB 1
 #define XML_STATIC
 #endif  //      LL_WINDOWS
 
-
 // Deal with VC6 problems
 #if LL_MSVC
 #pragma warning( 3           : 4701 )   // "local variable used without being initialized"  Treat this as level 3, not level 4.
 #pragma warning( 3           : 4702 )   // "unreachable code"  Treat this as level 3, not level 4.
 #pragma warning( 3           : 4189 )   // "local variable initialized but not referenced"  Treat this as level 3, not level 4.
 //#pragma warning( 3    : 4018 )        // "signed/unsigned mismatch"  Treat this as level 3, not level 4.
+#pragma warning( 3      :  4263 )       // 'function' : member function does not override any base class virtual member function
+#pragma warning( 3      :  4264 )       // "'virtual_function' : no override available for virtual member function from base 'class'; function is hidden"
 #pragma warning( 3       : 4265 )       // "class has virtual functions, but destructor is not virtual"
-#pragma warning( disable : 4786 )       // silly MS warning deep inside their <map> include file
+//#pragma warning( disable : 4265 )     // boost 1.36.0, non-virtual destructor in boost::exception_detail::*
+#pragma warning( 3      :  4266 )       // 'function' : no override available for virtual member function from base 'type'; function is hidden
+#pragma warning (disable : 4180)        // qualifier applied to function type has no meaning; ignored
 #pragma warning( disable : 4284 )       // silly MS warning deep inside their <map> include file
 #pragma warning( disable : 4503 )       // 'decorated name length exceeded, name was truncated'. Does not seem to affect compilation.
 #pragma warning( disable : 4800 )       // 'BOOL' : forcing value to bool 'true' or 'false' (performance warning)
 #pragma warning( disable : 4996 )       // warning: deprecated
+
+// Linker optimization with "extern template" generates these warnings
+#pragma warning( disable : 4231 )       // nonstandard extension used : 'extern' before template explicit instantiation
+#pragma warning( disable : 4506 )   // no definition for inline function
+
+// level 4 warnings that we need to disable:
+#pragma warning (disable : 4100) // unreferenced formal parameter
+#pragma warning (disable : 4127) // conditional expression is constant (e.g. while(1) )
+#pragma warning (disable : 4244) // possible loss of data on conversions
+#pragma warning (disable : 4396) // the inline specifier cannot be used when a friend declaration refers to a specialization of a function template
+#pragma warning (disable : 4512) // assignment operator could not be generated
+#pragma warning (disable : 4706) // assignment within conditional (even if((x = y)) )
+
+#pragma warning (disable : 4251) // member needs to have dll-interface to be used by clients of class
+#pragma warning (disable : 4275) // non dll-interface class used as base for dll-interface class
 #endif  //      LL_MSVC
 
+#if LL_WINDOWS
+#define LL_DLLEXPORT __declspec(dllexport)
+#define LL_DLLIMPORT __declspec(dllimport)
+#elif LL_LINUX
+#define LL_DLLEXPORT __attribute__ ((visibility("default")))
+#define LL_DLLIMPORT
+#else
+#define LL_DLLEXPORT
+#define LL_DLLIMPORT
+#endif // LL_WINDOWS
+
+#ifdef llcommon_EXPORTS
+// Compiling llcommon (shared)
+#define LL_COMMON_API LL_DLLEXPORT
+#else // llcommon_EXPORTS
+// Using llcommon (shared)
+#define LL_COMMON_API LL_DLLIMPORT
+#endif // llcommon_EXPORTS
+
 #endif  //      not LL_LINDEN_PREPROCESSOR_H
diff --git a/linden/indra/llcommon/llprocesslauncher.h b/linden/indra/llcommon/llprocesslauncher.h
index 9cdb0f6..b72be27 100644
--- a/linden/indra/llcommon/llprocesslauncher.h
+++ b/linden/indra/llcommon/llprocesslauncher.h
@@ -43,7 +43,7 @@
         It also keeps track of whether the process is still running, and can kill it if required.
 */
 
-class LLProcessLauncher
+class LL_COMMON_API LLProcessLauncher
 {
         LOG_CLASS(LLProcessLauncher);
 public:
diff --git a/linden/indra/llcommon/llqueuedthread.cpp b/linden/indra/llcommon/llqueuedthread.cpp
index caf4c2a..bee95be 100644
--- a/linden/indra/llcommon/llqueuedthread.cpp
+++ b/linden/indra/llcommon/llqueuedthread.cpp
@@ -32,6 +32,7 @@
 #include "linden_common.h"
 #include "llqueuedthread.h"
 #include "llstl.h"
+#include "lltimer.h"
 
 //============================================================================
 
diff --git a/linden/indra/llcommon/llqueuedthread.h b/linden/indra/llcommon/llqueuedthread.h
index aa7c6e4..e0e0f1b 100644
--- a/linden/indra/llcommon/llqueuedthread.h
+++ b/linden/indra/llcommon/llqueuedthread.h
@@ -47,7 +47,7 @@
 // Note: ~LLQueuedThread is O(N) N=# of queued threads, assumed to be small
 //   It is assumed that LLQueuedThreads are rarely created/destroyed.
 
-class LLQueuedThread : public LLThread
+class LL_COMMON_API LLQueuedThread : public LLThread
 {
         //------------------------------------------------------------------------
 public:
@@ -80,7 +80,7 @@ public:
         //------------------------------------------------------------------------
 public:
 
-        class QueuedRequest : public LLSimpleHashEntry<handle_t>
+        class LL_COMMON_API QueuedRequest : public LLSimpleHashEntry<handle_t>
         {
                 friend class LLQueuedThread;
                 
diff --git a/linden/indra/llcommon/llrand.h b/linden/indra/llcommon/llrand.h
index d12597b..73ea179 100644
--- a/linden/indra/llcommon/llrand.h
+++ b/linden/indra/llcommon/llrand.h
@@ -65,32 +65,32 @@
 /**
  *@brief Generate a float from [0, RAND_MAX).
  */
-S32 ll_rand();
+LL_COMMON_API S32 ll_rand();
 
 /**
  *@brief Generate a float from [0, val) or (val, 0].
  */
-S32 ll_rand(S32 val);
+LL_COMMON_API S32 ll_rand(S32 val);
 
 /**
  *@brief Generate a float from [0, 1.0).
  */
-F32 ll_frand();
+LL_COMMON_API F32 ll_frand();
 
 /**
  *@brief Generate a float from [0, val) or (val, 0].
  */
-F32 ll_frand(F32 val);
+LL_COMMON_API F32 ll_frand(F32 val);
 
 /**
  *@brief Generate a double from [0, 1.0).
  */
-F64 ll_drand();
+LL_COMMON_API F64 ll_drand();
 
 /**
  *@brief Generate a double from [0, val) or (val, 0].
  */
-F64 ll_drand(F64 val);
+LL_COMMON_API F64 ll_drand(F64 val);
 
 /**
  * @brief typedefs for good boost lagged fibonacci.
diff --git a/linden/indra/llcommon/llrun.h b/linden/indra/llcommon/llrun.h
index 77b23d9..0f8d51d 100644
--- a/linden/indra/llcommon/llrun.h
+++ b/linden/indra/llcommon/llrun.h
@@ -38,6 +38,8 @@
 #include <vector>
 #include <boost/shared_ptr.hpp>
 
+#include "llpreprocessor.h"
+
 class LLRunnable;
 
 /** 
@@ -48,7 +50,7 @@ class LLRunnable;
  * which are scheduled to run on a repeating or one time basis.
  * @see LLRunnable
  */
-class LLRunner
+class LL_COMMON_API LLRunner
 {
 public:
         /**
@@ -149,7 +151,7 @@ protected:
  * something useful.
  * @see LLRunner
  */
-class LLRunnable
+class LL_COMMON_API LLRunnable
 {
 public:
         LLRunnable();
diff --git a/linden/indra/llcommon/llsd.cpp b/linden/indra/llcommon/llsd.cpp
index 2cc94c2..be40bb6 100644
--- a/linden/indra/llcommon/llsd.cpp
+++ b/linden/indra/llcommon/llsd.cpp
@@ -75,7 +75,7 @@ protected:
                 ///< This constructor is used for static objects and causes the
                 //   suppresses adjusting the debugging counters when they are
                 //       finally initialized.
-                
+
         virtual ~Impl();
         
         bool shared() const                                                     { return mUseCount > 1; }
@@ -162,6 +162,7 @@ namespace
                 
                 virtual LLSD::Type type() const { return T; }
 
+                using LLSD::Impl::assign;
                 virtual void assign(LLSD::Impl*& var, DataRef value) {
                         if (shared())
                         {
@@ -348,6 +349,10 @@ namespace
 
                 virtual LLSD::Boolean asBoolean() const { return !mData.empty(); }
 
+                using LLSD::Impl::get; // Unhiding get(LLSD::Integer)
+                using LLSD::Impl::erase; // Unhiding erase(LLSD::Integer)
+                using LLSD::Impl::ref; // Unhiding ref(LLSD::Integer)
+
                 virtual bool has(const LLSD::String&) const; 
                 virtual LLSD get(const LLSD::String&) const; 
                         LLSD& insert(const LLSD::String& k, const LLSD& v);
@@ -440,6 +445,11 @@ namespace
                 virtual LLSD::Boolean asBoolean() const { return !mData.empty(); }
 
                 virtual int size() const; 
+
+                using LLSD::Impl::get; // Unhiding get(LLSD::Integer)
+                using LLSD::Impl::erase; // Unhiding erase(LLSD::Integer)
+                using LLSD::Impl::ref; // Unhiding ref(LLSD::Integer)
+
                 virtual LLSD get(LLSD::Integer) const;
                         void set(LLSD::Integer, const LLSD&);
                         LLSD& insert(LLSD::Integer, const LLSD&);
diff --git a/linden/indra/llcommon/llsd.h b/linden/indra/llcommon/llsd.h
index d2845a3..552bb57 100644
--- a/linden/indra/llcommon/llsd.h
+++ b/linden/indra/llcommon/llsd.h
@@ -89,7 +89,7 @@
         @nosubgrouping
 */
 
-class LLSD
+class LL_COMMON_API LLSD
 {
 public:
                 LLSD();         ///< initially Undefined
@@ -387,7 +387,7 @@ struct llsd_select_string : public std::unary_function<LLSD, LLSD::String>
         }
 };
 
-std::ostream& operator<<(std::ostream& s, const LLSD& llsd);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLSD& llsd);
 
 /** QUESTIONS & TO DOS
         - Would Binary be more convenient as usigned char* buffer semantics?
diff --git a/linden/indra/llcommon/llsdserialize.h b/linden/indra/llcommon/llsdserialize.h
index f7cd91b..a01b6dc 100644
--- a/linden/indra/llcommon/llsdserialize.h
+++ b/linden/indra/llcommon/llsdserialize.h
@@ -43,7 +43,7 @@
  * @class LLSDParser
  * @brief Abstract base class for LLSD parsers.
  */
-class LLSDParser : public LLRefCount
+class LL_COMMON_API LLSDParser : public LLRefCount
 {
 protected:
         /** 
@@ -220,7 +220,7 @@ protected:
  * @class LLSDNotationParser
  * @brief Parser which handles the original notation format for LLSD.
  */
-class LLSDNotationParser : public LLSDParser
+class LL_COMMON_API LLSDNotationParser : public LLSDParser
 {
 protected:
         /** 
@@ -293,7 +293,7 @@ private:
  * @class LLSDXMLParser
  * @brief Parser which handles XML format LLSD.
  */
-class LLSDXMLParser : public LLSDParser
+class LL_COMMON_API LLSDXMLParser : public LLSDParser
 {
 protected:
         /** 
@@ -341,7 +341,7 @@ private:
  * @class LLSDBinaryParser
  * @brief Parser which handles binary formatted LLSD.
  */
-class LLSDBinaryParser : public LLSDParser
+class LL_COMMON_API LLSDBinaryParser : public LLSDParser
 {
 protected:
         /** 
@@ -406,7 +406,7 @@ private:
  * @class LLSDFormatter
  * @brief Abstract base class for formatting LLSD.
  */
-class LLSDFormatter : public LLRefCount
+class LL_COMMON_API LLSDFormatter : public LLRefCount
 {
 protected:
         /** 
@@ -478,7 +478,7 @@ protected:
  * @class LLSDNotationFormatter
  * @brief Formatter which outputs the original notation format for LLSD.
  */
-class LLSDNotationFormatter : public LLSDFormatter
+class LL_COMMON_API LLSDNotationFormatter : public LLSDFormatter
 {
 protected:
         /** 
@@ -519,7 +519,7 @@ public:
  * @class LLSDXMLFormatter
  * @brief Formatter which outputs the LLSD as XML.
  */
-class LLSDXMLFormatter : public LLSDFormatter
+class LL_COMMON_API LLSDXMLFormatter : public LLSDFormatter
 {
 protected:
         /** 
@@ -587,7 +587,7 @@ protected:
  * Map: '{' + 4 byte integer size  every(key + value) + '}'<br>
  *  map keys are serialized as 'k' + 4 byte integer size + string
  */
-class LLSDBinaryFormatter : public LLSDFormatter
+class LL_COMMON_API LLSDBinaryFormatter : public LLSDFormatter
 {
 protected:
         /** 
@@ -676,7 +676,7 @@ typedef LLSDOStreamer<LLSDXMLFormatter>			LLSDXMLStreamer;
  * @class LLSDSerialize
  * @brief Serializer / deserializer for the various LLSD formats
  */
-class LLSDSerialize
+class LL_COMMON_API LLSDSerialize
 {
 public:
         enum ELLSD_Serialize
diff --git a/linden/indra/llcommon/llsdserialize_xml.cpp b/linden/indra/llcommon/llsdserialize_xml.cpp
index c12ca35..33206b4 100644
--- a/linden/indra/llcommon/llsdserialize_xml.cpp
+++ b/linden/indra/llcommon/llsdserialize_xml.cpp
@@ -562,7 +562,7 @@ void LLSDXMLParser::Impl::parsePart(const char* buf, int len)
 
 #ifdef XML_PARSER_PERFORMANCE_TESTS
 
-extern U64 totalTime();
+extern LL_COMMON_API U64 totalTime();
 U64     readElementTime = 0;
 U64 startElementTime = 0;
 U64 endElementTime = 0;
diff --git a/linden/indra/llcommon/llsdutil.h b/linden/indra/llcommon/llsdutil.h
index b67ad52..4740a30 100644
--- a/linden/indra/llcommon/llsdutil.h
+++ b/linden/indra/llcommon/llsdutil.h
@@ -68,28 +68,28 @@ LLSD ll_sd_from_color4(const LLColor4& c);
 LLColor4 ll_color4_from_sd(const LLSD& sd);
 
 // U32
-LLSD ll_sd_from_U32(const U32);
-U32 ll_U32_from_sd(const LLSD& sd);
+LL_COMMON_API LLSD ll_sd_from_U32(const U32);
+LL_COMMON_API U32 ll_U32_from_sd(const LLSD& sd);
 
 // U64
-LLSD ll_sd_from_U64(const U64);
-U64 ll_U64_from_sd(const LLSD& sd);
+LL_COMMON_API LLSD ll_sd_from_U64(const U64);
+LL_COMMON_API U64 ll_U64_from_sd(const LLSD& sd);
 
 // IP Address
-LLSD ll_sd_from_ipaddr(const U32);
-U32 ll_ipaddr_from_sd(const LLSD& sd);
+LL_COMMON_API LLSD ll_sd_from_ipaddr(const U32);
+LL_COMMON_API U32 ll_ipaddr_from_sd(const LLSD& sd);
 
 // Binary to string
-LLSD ll_string_from_binary(const LLSD& sd);
+LL_COMMON_API LLSD ll_string_from_binary(const LLSD& sd);
 
 //String to binary
-LLSD ll_binary_from_string(const LLSD& sd);
+LL_COMMON_API LLSD ll_binary_from_string(const LLSD& sd);
 
 // Serializes sd to static buffer and returns pointer, useful for gdb debugging.
-char* ll_print_sd(const LLSD& sd);
+LL_COMMON_API char* ll_print_sd(const LLSD& sd);
 
 // Serializes sd to static buffer and returns pointer, using "pretty printing" mode.
-char* ll_pretty_print_sd(const LLSD& sd);
+LL_COMMON_API char* ll_pretty_print_sd(const LLSD& sd);
 
 //compares the structure of an LLSD to a template LLSD and stores the
 //"valid" values in a 3rd LLSD. Default values
@@ -98,7 +98,7 @@ char* ll_pretty_print_sd(const LLSD& sd);
 //Returns false if the test is of same type but values differ in type
 //Otherwise, returns true
 
-BOOL compare_llsd_with_template(
+LL_COMMON_API BOOL compare_llsd_with_template(
         const LLSD& llsd_to_test,
         const LLSD& template_llsd,
         LLSD& resultant_llsd);
diff --git a/linden/indra/llcommon/llsecondlifeurls.h b/linden/indra/llcommon/llsecondlifeurls.h
index 9c64b57..e3932d0 100644
--- a/linden/indra/llcommon/llsecondlifeurls.h
+++ b/linden/indra/llcommon/llsecondlifeurls.h
@@ -34,14 +34,14 @@
 #define LL_LLSECONDLIFEURLS_H
 
 
-extern const std::string AUCTION_URL; 
+LL_COMMON_API extern const std::string AUCTION_URL; 
 
-extern const std::string EVENTS_URL;
+LL_COMMON_API extern const std::string EVENTS_URL;
 
 // Currency page
-extern const std::string BUY_CURRENCY_URL;
+LL_COMMON_API extern const std::string BUY_CURRENCY_URL;
 
 // Release Notes Redirect URL for Server and Viewer
-extern const std::string RELEASE_NOTES_BASE_URL;
+LL_COMMON_API extern const std::string RELEASE_NOTES_BASE_URL;
 
 #endif
diff --git a/linden/indra/llcommon/llsimplehash.h b/linden/indra/llcommon/llsimplehash.h
index 0ba2a30..5df93b6 100644
--- a/linden/indra/llcommon/llsimplehash.h
+++ b/linden/indra/llcommon/llsimplehash.h
@@ -64,7 +64,7 @@ public:
 };
 
 template <typename HASH_KEY_TYPE, int TABLE_SIZE>
-class LLSimpleHash
+class LL_COMMON_API LLSimpleHash
 {
 public:
         LLSimpleHash()
diff --git a/linden/indra/llcommon/llstat.h b/linden/indra/llcommon/llstat.h
index 66521a3..951091b 100644
--- a/linden/indra/llcommon/llstat.h
+++ b/linden/indra/llcommon/llstat.h
@@ -52,7 +52,7 @@ class	LLSD;
 // amounts of time with very low memory cost.
 //
 
-class LLStatAccum
+class LL_COMMON_API LLStatAccum
 {
 protected:
         LLStatAccum(bool use_frame_timer);
@@ -109,7 +109,7 @@ public:
         F64     mLastSampleValue;
 };
 
-class LLStatMeasure : public LLStatAccum
+class LL_COMMON_API LLStatMeasure : public LLStatAccum
         // gathers statistics about things that are measured
         // ex.: tempature, time dilation
 {
@@ -124,7 +124,7 @@ public:
 };
 
 
-class LLStatRate : public LLStatAccum
+class LL_COMMON_API LLStatRate : public LLStatAccum
         // gathers statistics about things that can be counted over time
         // ex.: LSL instructions executed, messages sent, simulator frames completed
         // renders it in terms of rate of thing per second
@@ -140,7 +140,7 @@ public:
 };
 
 
-class LLStatTime : public LLStatAccum
+class LL_COMMON_API LLStatTime : public LLStatAccum
         // gathers statistics about time spent in a block of code
         // measure average duration per second in the block
 {
@@ -171,7 +171,7 @@ private:
 
 
 // Use this class on the stack to record statistics about an area of code
-class LLPerfBlock
+class LL_COMMON_API LLPerfBlock
 {
 public:
     struct StatEntry
@@ -213,7 +213,7 @@ private:
 
 // ----------------------------------------------------------------------------
 
-class LLPerfStats
+class LL_COMMON_API LLPerfStats
 {
 public:
     LLPerfStats(const std::string& process_name = "unknown", S32 process_pid = 0);
@@ -249,7 +249,7 @@ private:
 };
 
 // ----------------------------------------------------------------------------
-class LLStat
+class LL_COMMON_API LLStat
 {
 public:
         LLStat(const U32 num_bins = 32, BOOL use_frame_timer = FALSE);
diff --git a/linden/indra/llcommon/llstreamtools.h b/linden/indra/llcommon/llstreamtools.h
index a6dc4d5..371fac5 100644
--- a/linden/indra/llcommon/llstreamtools.h
+++ b/linden/indra/llcommon/llstreamtools.h
@@ -39,23 +39,23 @@
 // unless specifed otherwise these all return input_stream.good()
 
 // skips spaces and tabs
-bool skip_whitespace(std::istream& input_stream);
+LL_COMMON_API bool skip_whitespace(std::istream& input_stream);
 
 // skips whitespace and newlines
-bool skip_emptyspace(std::istream& input_stream);
+LL_COMMON_API bool skip_emptyspace(std::istream& input_stream);
 
 // skips emptyspace and lines that start with a #
-bool skip_comments_and_emptyspace(std::istream& input_stream);
+LL_COMMON_API bool skip_comments_and_emptyspace(std::istream& input_stream);
 
 // skips to character after next newline
-bool skip_line(std::istream& input_stream);
+LL_COMMON_API bool skip_line(std::istream& input_stream);
 
 // skips to beginning of next non-emptyspace
-bool skip_to_next_word(std::istream& input_stream);
+LL_COMMON_API bool skip_to_next_word(std::istream& input_stream);
 
 // skips to character after the end of next keyword 
 // a 'keyword' is defined as the first word on a line
-bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream);
+LL_COMMON_API bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream);
 
 // skip_to_start_of_next_keyword() is disabled -- might tickle corruption bug 
 // in windows iostream
@@ -65,14 +65,14 @@ bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream
 
 // characters are pulled out of input_stream and appended to output_string
 // returns result of input_stream.good() after characters are pulled
-bool get_word(std::string& output_string, std::istream& input_stream);
-bool get_line(std::string& output_string, std::istream& input_stream);
+LL_COMMON_API bool get_word(std::string& output_string, std::istream& input_stream);
+LL_COMMON_API bool get_line(std::string& output_string, std::istream& input_stream);
 
 // characters are pulled out of input_stream (up to a max of 'n')
 // and appended to output_string 
 // returns result of input_stream.good() after characters are pulled
-bool get_word(std::string& output_string, std::istream& input_stream, int n);
-bool get_line(std::string& output_string, std::istream& input_stream, int n);
+LL_COMMON_API bool get_word(std::string& output_string, std::istream& input_stream, int n);
+LL_COMMON_API bool get_line(std::string& output_string, std::istream& input_stream, int n);
 
 // unget_line() is disabled -- might tickle corruption bug in windows iostream
 //// backs up the input_stream by line_size + 1 characters
@@ -82,28 +82,28 @@ bool get_line(std::string& output_string, std::istream& input_stream, int n);
 
 // removes the last char in 'line' if it matches 'c'
 // returns true if removed last char
-bool remove_last_char(char c, std::string& line);
+LL_COMMON_API bool remove_last_char(char c, std::string& line);
 
 // replaces escaped characters with the correct characters from left to right
 // "\\" ---> '\\' 
 // "\n" ---> '\n' 
-void unescape_string(std::string& line);
+LL_COMMON_API void unescape_string(std::string& line);
 
 // replaces unescaped characters with expanded equivalents from left to right
 // '\\' ---> "\\" 
 // '\n' ---> "\n" 
-void escape_string(std::string& line);
+LL_COMMON_API void escape_string(std::string& line);
 
 // replaces each '\n' character with ' '
-void replace_newlines_with_whitespace(std::string& line);
+LL_COMMON_API void replace_newlines_with_whitespace(std::string& line);
 
 // erases any double-quote characters in line
-void remove_double_quotes(std::string& line);
+LL_COMMON_API void remove_double_quotes(std::string& line);
 
 // the 'keyword' is defined as the first word on a line
 // the 'value' is everything after the keyword on the same line
 // starting at the first non-whitespace and ending right before the newline
-void get_keyword_and_value(std::string& keyword, 
+LL_COMMON_API void get_keyword_and_value(std::string& keyword,
                                                    std::string& value, 
                                                    const std::string& line);
 
@@ -111,13 +111,13 @@ void get_keyword_and_value(std::string& keyword,
 // read anymore or until we hit the count.  Some istream
 // implimentations have a max that they will read.
 // Returns the number of bytes read.
-std::streamsize fullread(
+LL_COMMON_API std::streamsize fullread(
         std::istream& istr,
         char* buf,
         std::streamsize requested);
 
 
-std::istream& operator>>(std::istream& str, const char *tocheck);
+LL_COMMON_API std::istream& operator>>(std::istream& str, const char *tocheck);
 
 #endif
 
diff --git a/linden/indra/llcommon/llstring.h b/linden/indra/llcommon/llstring.h
index bab89b1..3f2c8d8 100644
--- a/linden/indra/llcommon/llstring.h
+++ b/linden/indra/llcommon/llstring.h
@@ -144,7 +144,7 @@ struct char_traits<U16>
 };
 #endif
 
-class LLStringOps
+class LL_COMMON_API LLStringOps
 {
 public:
         static char toUpper(char elem) { return toupper((unsigned char)elem); }
@@ -179,8 +179,8 @@ public:
  * @brief Return a string constructed from in without crashing if the
  * pointer is NULL.
  */
-std::string ll_safe_string(const char* in);
-std::string ll_safe_string(const char* in, S32 maxlen);
+std::string LL_COMMON_API ll_safe_string(const char* in);
+std::string LL_COMMON_API ll_safe_string(const char* in, S32 maxlen);
 
 
 // Allowing assignments from non-strings into format_map_t is apparently
@@ -349,7 +349,7 @@ inline std::string chop_tail_copy(
  * @brief This translates a nybble stored as a hex value from 0-f back
  * to a nybble in the low order bits of the return byte.
  */
-U8 hex_as_nybble(char hex);
+LL_COMMON_API U8 hex_as_nybble(char hex);
 
 /**
  * @brief read the contents of a file into a string.
@@ -360,7 +360,7 @@ U8 hex_as_nybble(char hex);
  * @param filename The full name of the file to read.
  * @return Returns true on success. If false, str is unmodified.
  */
-bool _read_file_into_string(std::string& str, const std::string& filename);
+LL_COMMON_API bool _read_file_into_string(std::string& str, const std::string& filename);
 
 /**
  * Unicode support
@@ -369,52 +369,52 @@ bool _read_file_into_string(std::string& str, const std::string& filename);
 // Make the incoming string a utf8 string. Replaces any unknown glyph
 // with the UNKOWN_CHARACTER. Once any unknown glph is found, the rest
 // of the data may not be recovered.
-std::string rawstr_to_utf8(const std::string& raw);
+LL_COMMON_API std::string rawstr_to_utf8(const std::string& raw);
 
 //
 // We should never use UTF16 except when communicating with Win32!
 //
 typedef std::basic_string<U16> llutf16string;
 
-LLWString utf16str_to_wstring(const llutf16string &utf16str, S32 len);
-LLWString utf16str_to_wstring(const llutf16string &utf16str);
+LL_COMMON_API LLWString utf16str_to_wstring(const llutf16string &utf16str, S32 len);
+LL_COMMON_API LLWString utf16str_to_wstring(const llutf16string &utf16str);
 
-llutf16string wstring_to_utf16str(const LLWString &utf32str, S32 len);
-llutf16string wstring_to_utf16str(const LLWString &utf32str);
+LL_COMMON_API llutf16string wstring_to_utf16str(const LLWString &utf32str, S32 len);
+LL_COMMON_API llutf16string wstring_to_utf16str(const LLWString &utf32str);
 
-llutf16string utf8str_to_utf16str ( const std::string& utf8str, S32 len);
-llutf16string utf8str_to_utf16str ( const std::string& utf8str );
+LL_COMMON_API llutf16string utf8str_to_utf16str ( const std::string& utf8str, S32 len);
+LL_COMMON_API llutf16string utf8str_to_utf16str ( const std::string& utf8str );
 
-LLWString utf8str_to_wstring(const std::string &utf8str, S32 len);
-LLWString utf8str_to_wstring(const std::string &utf8str);
+LL_COMMON_API LLWString utf8str_to_wstring(const std::string &utf8str, S32 len);
+LL_COMMON_API LLWString utf8str_to_wstring(const std::string &utf8str);
 // Same function, better name. JC
 inline LLWString utf8string_to_wstring(const std::string& utf8_string) { return utf8str_to_wstring(utf8_string); }
 
 //
-S32 wchar_to_utf8chars(llwchar inchar, char* outchars);
+LL_COMMON_API S32 wchar_to_utf8chars(llwchar inchar, char* outchars);
 
-std::string wstring_to_utf8str(const LLWString &utf32str, S32 len);
-std::string wstring_to_utf8str(const LLWString &utf32str);
+LL_COMMON_API std::string wstring_to_utf8str(const LLWString &utf32str, S32 len);
+LL_COMMON_API std::string wstring_to_utf8str(const LLWString &utf32str);
 
-std::string utf16str_to_utf8str(const llutf16string &utf16str, S32 len);
-std::string utf16str_to_utf8str(const llutf16string &utf16str);
+LL_COMMON_API std::string utf16str_to_utf8str(const llutf16string &utf16str, S32 len);
+LL_COMMON_API std::string utf16str_to_utf8str(const llutf16string &utf16str);
 
 // Length of this UTF32 string in bytes when transformed to UTF8
-S32 wstring_utf8_length(const LLWString& wstr); 
+LL_COMMON_API S32 wstring_utf8_length(const LLWString& wstr);
 
 // Length in bytes of this wide char in a UTF8 string
-S32 wchar_utf8_length(const llwchar wc); 
+LL_COMMON_API S32 wchar_utf8_length(const llwchar wc);
 
-std::string utf8str_tolower(const std::string& utf8str);
+LL_COMMON_API std::string utf8str_tolower(const std::string& utf8str);
 
 // Length in llwchar (UTF-32) of the first len units (16 bits) of the given UTF-16 string.
-S32 utf16str_wstring_length(const llutf16string &utf16str, S32 len);
+LL_COMMON_API S32 utf16str_wstring_length(const llutf16string &utf16str, S32 len);
 
 // Length in utf16string (UTF-16) of wlen wchars beginning at woffset.
-S32 wstring_utf16_length(const LLWString & wstr, S32 woffset, S32 wlen);
+LL_COMMON_API S32 wstring_utf16_length(const LLWString & wstr, S32 woffset, S32 wlen);
 
 // Length in wstring (i.e., llwchar count) of a part of a wstring specified by utf16 length (i.e., utf16 units.)
-S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, S32 woffset, S32 utf16_length, BOOL *unaligned = NULL);
+LL_COMMON_API S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, S32 woffset, S32 utf16_length, BOOL *unaligned = NULL);
 
 /**
  * @brief Properly truncate a utf8 string to a maximum byte count.
@@ -426,11 +426,11 @@ S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, S32 woffset
  * @param max_len The maximum number of bytes in the return value.
  * @return Returns a valid utf8 string with byte count <= max_len.
  */
-std::string utf8str_truncate(const std::string& utf8str, const S32 max_len);
+LL_COMMON_API std::string utf8str_truncate(const std::string& utf8str, const S32 max_len);
 
-std::string utf8str_trim(const std::string& utf8str);
+LL_COMMON_API std::string utf8str_trim(const std::string& utf8str);
 
-S32 utf8str_compare_insensitive(
+LL_COMMON_API S32 utf8str_compare_insensitive(
         const std::string& lhs,
         const std::string& rhs);
 
@@ -441,17 +441,17 @@ S32 utf8str_compare_insensitive(
  * @param target_char The wchar to be replaced
  * @param replace_char The wchar which is written on replace
  */
-std::string utf8str_substChar(
+LL_COMMON_API std::string utf8str_substChar(
         const std::string& utf8str,
         const llwchar target_char,
         const llwchar replace_char);
 
-std::string utf8str_makeASCII(const std::string& utf8str);
+LL_COMMON_API std::string utf8str_makeASCII(const std::string& utf8str);
 
 // Hack - used for evil notecards.
-std::string mbcsstring_makeASCII(const std::string& str); 
+LL_COMMON_API std::string mbcsstring_makeASCII(const std::string& str);
 
-std::string utf8str_removeCRLF(const std::string& utf8str);
+LL_COMMON_API std::string utf8str_removeCRLF(const std::string& utf8str);
 
 
 #if LL_WINDOWS
@@ -476,14 +476,21 @@ std::string utf8str_removeCRLF(const std::string& utf8str);
  * formatted string.
  *
  */
-int safe_snprintf(char* str, size_t size, const char* format, ...);
+
+// Deal with the differeneces on Windows
+namespace snprintf_hack
+{
+    LL_COMMON_API int snprintf(char *str, size_t size, const char *format, ...);
+}
+
+using snprintf_hack::snprintf;
 
 /**
  * @brief Convert a wide string to std::string
  *
  * This replaces the unsafe W2A macro from ATL.
  */
-std::string ll_convert_wide_to_string(const wchar_t* in);
+LL_COMMON_API std::string ll_convert_wide_to_string(const wchar_t* in);
 
 //@}
 #endif // LL_WINDOWS
@@ -506,7 +513,7 @@ namespace LLStringFn
          * with zero non-printable characters.
          * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
          */
-        void replace_nonprintable_in_ascii(
+        LL_COMMON_API void replace_nonprintable_in_ascii(
                 std::basic_string<char>& string,
                 char replacement);
 
@@ -520,7 +527,7 @@ namespace LLStringFn
          * with zero non-printable characters and zero pipe characters.
          * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
          */
-        void replace_nonprintable_and_pipe_in_ascii(std::basic_string<char>& str,
+        LL_COMMON_API void replace_nonprintable_and_pipe_in_ascii(std::basic_string<char>& str,
                                                                            char replacement);
 
 
@@ -529,7 +536,7 @@ namespace LLStringFn
          * Returns a copy of the string with those characters removed.
          * Works with US ASCII and UTF-8 encoded strings.  JC
          */
-        std::string strip_invalid_xml(const std::string& input);
+        LL_COMMON_API std::string strip_invalid_xml(const std::string& input);
 
 
         /**
@@ -540,7 +547,7 @@ namespace LLStringFn
          * with zero non-printable characters.
          * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
          */
-        void replace_ascii_controlchars(
+        LL_COMMON_API void replace_ascii_controlchars(
                 std::basic_string<char>& string,
                 char replacement);
 }
diff --git a/linden/indra/llcommon/llstringtable.h b/linden/indra/llcommon/llstringtable.h
index 4492063..b13b016 100644
--- a/linden/indra/llcommon/llstringtable.h
+++ b/linden/indra/llcommon/llstringtable.h
@@ -56,7 +56,7 @@
 
 const U32 MAX_STRINGS_LENGTH = 256;
 
-class LLStringTableEntry
+class LL_COMMON_API LLStringTableEntry
 {
 public:
         LLStringTableEntry(const char *str)
@@ -81,7 +81,7 @@ public:
         S32  mCount;
 };
 
-class LLStringTable
+class LL_COMMON_API LLStringTable
 {
 public:
         LLStringTable(int tablesize);
@@ -115,7 +115,7 @@ public:
 #endif  
 };
 
-extern LLStringTable gStringTable;
+extern LL_COMMON_API LLStringTable gStringTable;
 
 //============================================================================
 
@@ -125,7 +125,7 @@ extern LLStringTable gStringTable;
 
 typedef const std::string* LLStdStringHandle;
 
-class LLStdStringTable
+class LL_COMMON_API LLStdStringTable
 {
 public:
         LLStdStringTable(S32 tablesize = 0)
diff --git a/linden/indra/llcommon/llsys.h b/linden/indra/llcommon/llsys.h
index 03f48ca..d5575b2 100644
--- a/linden/indra/llcommon/llsys.h
+++ b/linden/indra/llcommon/llsys.h
@@ -45,7 +45,7 @@
 #include <iosfwd>
 #include <string>
 
-class LLOSInfo
+class LL_COMMON_API LLOSInfo
 {
 public:
         LLOSInfo();
@@ -70,7 +70,7 @@ private:
 };
 
 
-class LLCPUInfo
+class LL_COMMON_API LLCPUInfo
 {
 public:
         LLCPUInfo();    
@@ -99,7 +99,7 @@ private:
 //
 //      CLASS           LLMemoryInfo
 
-class LLMemoryInfo
+class LL_COMMON_API LLMemoryInfo
 
 /*!     @brief          Class to query the memory subsystem
 
@@ -123,15 +123,15 @@ public:
 };
 
 
-std::ostream& operator<<(std::ostream& s, const LLOSInfo& info);
-std::ostream& operator<<(std::ostream& s, const LLCPUInfo& info);
-std::ostream& operator<<(std::ostream& s, const LLMemoryInfo& info);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLOSInfo& info);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLCPUInfo& info);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLMemoryInfo& info);
 
 // gunzip srcfile into dstfile.  Returns FALSE on error.
-BOOL gunzip_file(const std::string& srcfile, const std::string& dstfile);
+LL_COMMON_API BOOL gunzip_file(const std::string& srcfile, const std::string& dstfile);
 // gzip srcfile into dstfile.  Returns FALSE on error.
-BOOL gzip_file(const std::string& srcfile, const std::string& dstfile);
+LL_COMMON_API BOOL gzip_file(const std::string& srcfile, const std::string& dstfile);
 
-extern LLCPUInfo gSysCPU;
+LL_COMMON_API extern LLCPUInfo gSysCPU;
 
 #endif // LL_LLSYS_H
diff --git a/linden/indra/llcommon/llthread.h b/linden/indra/llcommon/llthread.h
index ed76a3b..98d64ef 100644
--- a/linden/indra/llcommon/llthread.h
+++ b/linden/indra/llcommon/llthread.h
@@ -43,7 +43,7 @@ class LLThread;
 class LLMutex;
 class LLCondition;
 
-class LLThread
+class LL_COMMON_API LLThread
 {
 public:
         typedef enum e_thread_status
@@ -125,7 +125,7 @@ protected:
 
 //============================================================================
 
-class LLMutex
+class LL_COMMON_API LLMutex
 {
 public:
         LLMutex(apr_pool_t *apr_poolp); // NULL pool constructs a new pool for the mutex
@@ -145,7 +145,7 @@ protected:
 };
 
 // Actually a condition/mutex pair (since each condition needs to be associated with a mutex).
-class LLCondition : public LLMutex
+class LL_COMMON_API LLCondition : public LLMutex
 {
 public:
         LLCondition(apr_pool_t *apr_poolp); // Defaults to global pool, could use the thread pool as well.
@@ -159,7 +159,7 @@ protected:
         apr_thread_cond_t *mAPRCondp;
 };
 
-class LLMutexLock
+class LL_COMMON_API LLMutexLock
 {
 public:
         LLMutexLock(LLMutex* mutex)
@@ -192,7 +192,7 @@ void LLThread::unlockData()
 
 // see llmemory.h for LLPointer<> definition
 
-class LLThreadSafeRefCount
+class LL_COMMON_API LLThreadSafeRefCount
 {
 public:
         static void initThreadSafeRefCount(); // creates sMutex
@@ -244,7 +244,7 @@ private:
 
 // Simple responder for self destructing callbacks
 // Pure virtual class
-class LLResponder : public LLThreadSafeRefCount
+class LL_COMMON_API LLResponder : public LLThreadSafeRefCount
 {
 protected:
         virtual ~LLResponder();
diff --git a/linden/indra/llcommon/lltimer.cpp b/linden/indra/llcommon/lltimer.cpp
index fb3e1ef..2d283ec 100644
--- a/linden/indra/llcommon/lltimer.cpp
+++ b/linden/indra/llcommon/lltimer.cpp
@@ -33,6 +33,7 @@
 #include "linden_common.h"
 
 #include "lltimer.h"
+#include "timing.h"     // totalTime prototype.
 
 #include "u64.h"
 
@@ -51,9 +52,6 @@
 //
 // Locally used constants
 //
-const U32 SEC_PER_DAY = 86400;
-const F64 SEC_TO_MICROSEC = 1000000.f;
-const U64 SEC_TO_MICROSEC_U64 = 1000000;
 const F64 USEC_TO_SEC_F64 = 0.000001;
 
 
diff --git a/linden/indra/llcommon/lltimer.h b/linden/indra/llcommon/lltimer.h
index a653233..8590328 100644
--- a/linden/indra/llcommon/lltimer.h
+++ b/linden/indra/llcommon/lltimer.h
@@ -39,6 +39,7 @@
 #include <limits.h>
 
 #include "stdtypes.h"
+#include "llpreprocessor.h"
 #include "lldate.h"
 
 #include <string>
@@ -54,7 +55,7 @@ const U32	USEC_PER_HOUR	= USEC_PER_MIN * MIN_PER_HOUR;
 const U32       SEC_PER_HOUR    = SEC_PER_MIN * MIN_PER_HOUR;
 const F64       SEC_PER_USEC    = 1.0 / (F64) USEC_PER_SEC;
 
-class LLTimer 
+class LL_COMMON_API LLTimer
 {
 public:
         static LLTimer *sTimer;                         // global timer
@@ -113,17 +114,17 @@ public:
 //
 // Various functions for initializing/accessing clock and timing stuff.  Don't use these without REALLY knowing how they work.
 //
-U64 get_clock_count();
-F64 calc_clock_frequency(U32 msecs);
-void update_clock_frequencies();
+LL_COMMON_API U64 get_clock_count();
+LL_COMMON_API F64 calc_clock_frequency(U32 msecs);
+LL_COMMON_API void update_clock_frequencies();
 
 // Sleep for milliseconds
-void ms_sleep(U32 ms);
-U32 micro_sleep(U64 us, U32 max_yields = 0xFFFFFFFF);
+LL_COMMON_API void ms_sleep(U32 ms);
+LL_COMMON_API U32 micro_sleep(U64 us, U32 max_yields = 0xFFFFFFFF);
 
 // Returns the correct UTC time in seconds, like time(NULL).
 // Useful on the viewer, which may have its local clock set wrong.
-time_t time_corrected();
+LL_COMMON_API time_t time_corrected();
 
 static inline time_t time_min()
 {
@@ -154,25 +155,25 @@ static inline time_t time_max()
 }
 
 // Correction factor used by time_corrected() above.
-extern S32 gUTCOffset;
+LL_COMMON_API extern S32 gUTCOffset;
 
 // Is the current computer (in its current time zone)
 // observing daylight savings time?
-BOOL is_daylight_savings();
+LL_COMMON_API BOOL is_daylight_savings();
 
 // Converts internal "struct tm" time buffer to Pacific Standard/Daylight Time
 // Usage:
 // S32 utc_time;
 // utc_time = time_corrected();
 // struct tm* internal_time = utc_to_pacific_time(utc_time, gDaylight);
-struct tm* utc_to_pacific_time(time_t utc_time, BOOL pacific_daylight_time);
-struct tm* utc_to_offset_time(time_t utc_time, S32 offset, BOOL DST);
+LL_COMMON_API struct tm* utc_to_pacific_time(time_t utc_time, BOOL pacific_daylight_time);
+LL_COMMON_API struct tm* utc_to_offset_time(time_t utc_time, S32 offset, BOOL DST);
 
-void microsecondsToTimecodeString(U64 current_time, std::string& tcstring);
-void secondsToTimecodeString(F32 current_time, std::string& tcstring);
+LL_COMMON_API void microsecondsToTimecodeString(U64 current_time, std::string& tcstring);
+LL_COMMON_API void secondsToTimecodeString(F32 current_time, std::string& tcstring);
 
 // class for scheduling a function to be called at a given frequency (approximate, inprecise)
-class LLEventTimer 
+class LL_COMMON_API LLEventTimer 
 {
 public:
         LLEventTimer(F32 period);       // period is the amount of time between each call to tick() in seconds
diff --git a/linden/indra/llcommon/lluri.h b/linden/indra/llcommon/lluri.h
index 156d80b..57bbedf 100644
--- a/linden/indra/llcommon/lluri.h
+++ b/linden/indra/llcommon/lluri.h
@@ -47,7 +47,7 @@ class LLApp;
  * See: http://www.ietf.org/rfc/rfc3986.txt
  *
  */
-class LLURI
+class LL_COMMON_API LLURI
 {
 public:
   LLURI();
@@ -189,6 +189,6 @@ private:
 };
 
 // this operator required for tut
-bool operator!=(const LLURI& first, const LLURI& second);
+LL_COMMON_API bool operator!=(const LLURI& first, const LLURI& second);
 
 #endif // LL_LLURI_H
diff --git a/linden/indra/llcommon/lluuid.h b/linden/indra/llcommon/lluuid.h
index 4b32138..c78fb12 100644
--- a/linden/indra/llcommon/lluuid.h
+++ b/linden/indra/llcommon/lluuid.h
@@ -35,6 +35,7 @@
 #include <iostream>
 #include <set>
 #include "stdtypes.h"
+#include "llpreprocessor.h"
 
 const S32 UUID_BYTES = 16;
 const S32 UUID_WORDS = 4;
@@ -47,7 +48,7 @@ struct uuid_time_t {
         U32 low;
                 };
 
-class LLUUID
+class LL_COMMON_API LLUUID
 {
 public:
         //
@@ -106,8 +107,8 @@ public:
         LLUUID combine(const LLUUID& other) const;
         void combine(const LLUUID& other, LLUUID& result) const;  
 
-        friend std::ostream&     operator<<(std::ostream& s, const LLUUID &uuid);
-        friend std::istream&     operator>>(std::istream& s, LLUUID &uuid);
+        friend LL_COMMON_API std::ostream&       operator<<(std::ostream& s, const LLUUID &uuid);
+        friend LL_COMMON_API std::istream&       operator>>(std::istream& s, LLUUID &uuid);
 
         void toString(char *out) const;         // Does not allocate memory, needs 36 characters (including \0)
         void toString(std::string& out) const;
@@ -323,7 +324,7 @@ typedef std::set<LLUUID, lluuid_less> uuid_list_t;
  */
 typedef LLUUID LLAssetID;
 
-class LLTransactionID : public LLUUID
+class LL_COMMON_API LLTransactionID : public LLUUID
 {
 public:
         LLTransactionID() : LLUUID() { }
diff --git a/linden/indra/llcommon/llworkerthread.h b/linden/indra/llcommon/llworkerthread.h
index 708d812..33d4c40 100644
--- a/linden/indra/llcommon/llworkerthread.h
+++ b/linden/indra/llcommon/llworkerthread.h
@@ -50,7 +50,7 @@ class LLWorkerClass;
 // Note: ~LLWorkerThread is O(N) N=# of worker threads, assumed to be small
 //   It is assumed that LLWorkerThreads are rarely created/destroyed.
 
-class LLWorkerThread : public LLQueuedThread
+class LL_COMMON_API LLWorkerThread : public LLQueuedThread
 {
         friend class LLWorkerClass;
 public:
@@ -114,7 +114,7 @@ public:
 // Only one background task can be active at a time (per instance).
 //  i.e. don't call addWork() if haveWork() returns true
 
-class LLWorkerClass
+class LL_COMMON_API LLWorkerClass
 {
         friend class LLWorkerThread;
         friend class LLWorkerThread::WorkRequest;
diff --git a/linden/indra/llcommon/metaclass.h b/linden/indra/llcommon/metaclass.h
index cc10f16..f38bcd2 100644
--- a/linden/indra/llcommon/metaclass.h
+++ b/linden/indra/llcommon/metaclass.h
@@ -43,7 +43,7 @@
 class LLReflective;
 class LLMetaProperty;
 class LLMetaMethod;
-class LLMetaClass
+class LL_COMMON_API LLMetaClass
 {
 public:
 
diff --git a/linden/indra/llcommon/metaproperty.h b/linden/indra/llcommon/metaproperty.h
index e5ac359..6c016c5 100644
--- a/linden/indra/llcommon/metaproperty.h
+++ b/linden/indra/llcommon/metaproperty.h
@@ -41,7 +41,7 @@
 
 class LLMetaClass;
 class LLReflective;
-class LLMetaProperty
+class LL_COMMON_API LLMetaProperty
 {
 public:
         LLMetaProperty(const std::string& name, const LLMetaClass& object_class);
diff --git a/linden/indra/llcommon/reflective.h b/linden/indra/llcommon/reflective.h
index e2c18eb..a135376 100644
--- a/linden/indra/llcommon/reflective.h
+++ b/linden/indra/llcommon/reflective.h
@@ -36,7 +36,7 @@
 #define LL_REFLECTIVE_H
 
 class LLMetaClass;
-class LLReflective
+class LL_COMMON_API LLReflective
 {
 public:
         LLReflective();
diff --git a/linden/indra/llcommon/timing.h b/linden/indra/llcommon/timing.h
index 2b9f60a..cfc637e 100644
--- a/linden/indra/llcommon/timing.h
+++ b/linden/indra/llcommon/timing.h
@@ -44,6 +44,6 @@ const U64 SEC_TO_MICROSEC_U64 = 1000000;
 const U32 SEC_PER_DAY = 86400;
 
 // This is just a stub, implementation in lltimer.cpp.  This file will be deprecated in the future.
-U64 totalTime();                                        // Returns current system time in microseconds
+LL_COMMON_API U64 totalTime();                                  // Returns current system time in microseconds
 
 #endif
diff --git a/linden/indra/llcommon/u64.h b/linden/indra/llcommon/u64.h
index 09a6b3e..eb51131 100644
--- a/linden/indra/llcommon/u64.h
+++ b/linden/indra/llcommon/u64.h
@@ -39,14 +39,14 @@
  * @param str The string to parse.
  * @return Returns the first U64 value found in the string or 0 on failure.
  */
-U64 str_to_U64(const std::string& str);
+LL_COMMON_API U64 str_to_U64(const std::string& str);
 
 /**
  * @brief Given a U64 value, return a printable representation.
  * @param value The U64 to turn into a printable character array.
  * @return Returns the result string.
  */
-std::string U64_to_str(U64 value);
+LL_COMMON_API std::string U64_to_str(U64 value);
 
 /**
  * @brief Given a U64 value, return a printable representation.
@@ -65,16 +65,16 @@ std::string U64_to_str(U64 value);
  * @param result_size The size of the buffer allocated. Use U64_BUF.
  * @return Returns the result pointer.
  */
-char* U64_to_str(U64 value, char* result, S32 result_size);
+LL_COMMON_API char* U64_to_str(U64 value, char* result, S32 result_size);
 
 /**
  * @brief Convert a U64 to the closest F64 value.
  */
-F64 U64_to_F64(const U64 value);
+LL_COMMON_API F64 U64_to_F64(const U64 value);
 
 /**
  * @brief Helper function to wrap strtoull() which is not available on windows.
  */
-U64 llstrtou64(const char* str, char** end, S32 base);
+LL_COMMON_API U64 llstrtou64(const char* str, char** end, S32 base);
 
 #endif