Merge branch 'DRTVWR-559' into DRTVWR-583

65 files changed, 655 insertions, 610 deletions

diff --git a/indra/llcommon/llallocator_heap_profile.cpp b/indra/llcommon/llallocator_heap_profile.cpp
index b2eafde1aa..c6d9542b42 100644
--- a/indra/llcommon/llallocator_heap_profile.cpp
+++ b/indra/llcommon/llallocator_heap_profile.cpp
@@ -130,15 +130,13 @@ void LLAllocatorHeapProfile::parse(std::string const & prof_text)
 
 void LLAllocatorHeapProfile::dump(std::ostream & out) const
 {
-    lines_t::const_iterator i;
-    for(i = mLines.begin(); i != mLines.end(); ++i)
+	for (const LLAllocatorHeapProfile::line& line : mLines)
     {
-        out << i->mLiveCount << ": " << i->mLiveSize << '[' << i->mTotalCount << ": " << i->mTotalSize << "] @";
+        out << line.mLiveCount << ": " << line.mLiveSize << '[' << line.mTotalCount << ": " << line.mTotalSize << "] @";
 
-        stack_trace::const_iterator j;
-        for(j = i->mTrace.begin(); j != i->mTrace.end(); ++j)
+		for (const stack_marker marker : line.mTrace)
         {
-            out << ' ' << *j;
+            out << ' ' << marker;
         }
         out << '\n';
     }
diff --git a/indra/llcommon/llapp.cpp b/indra/llcommon/llapp.cpp
index 3ff8d16bbb..d839b19c99 100644
--- a/indra/llcommon/llapp.cpp
+++ b/indra/llcommon/llapp.cpp
@@ -862,14 +862,14 @@ bool unix_post_minidump_callback(const char *dump_dir,
 	// heap allocations in a crash handler.
 	
 	// path format: <dump_dir>/<minidump_id>.dmp
-	int dirPathLength = strlen(dump_dir);
-	int idLength = strlen(minidump_id);
+	auto dirPathLength = strlen(dump_dir);
+	auto idLength = strlen(minidump_id);
 	
 	// The path must not be truncated.
 	llassert((dirPathLength + idLength + 5) <= LLApp::MAX_MINDUMP_PATH_LENGTH);
 	
 	char * path = LLApp::instance()->getMiniDumpFilename();
-	S32 remaining = LLApp::MAX_MINDUMP_PATH_LENGTH;
+	auto remaining = LLApp::MAX_MINDUMP_PATH_LENGTH;
 	strncpy(path, dump_dir, remaining);
 	remaining -= dirPathLength;
 	path += dirPathLength;
diff --git a/indra/llcommon/llassettype.cpp b/indra/llcommon/llassettype.cpp
index f08cc18036..6492d888c1 100644
--- a/indra/llcommon/llassettype.cpp
+++ b/indra/llcommon/llassettype.cpp
@@ -151,14 +151,12 @@ LLAssetType::EType LLAssetType::lookup(const char* name)
 LLAssetType::EType LLAssetType::lookup(const std::string& type_name)
 {
 	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
-	for (LLAssetDictionary::const_iterator iter = dict->begin();
-		 iter != dict->end();
-		 iter++)
+	for (const LLAssetDictionary::value_type& pair : *dict)
 	{
-		const AssetEntry *entry = iter->second;
+		const AssetEntry *entry = pair.second;
 		if (type_name == entry->mTypeName)
 		{
-			return iter->first;
+			return pair.first;
 		}
 	}
 	return AT_UNKNOWN;
@@ -189,14 +187,12 @@ LLAssetType::EType LLAssetType::lookupHumanReadable(const char* name)
 LLAssetType::EType LLAssetType::lookupHumanReadable(const std::string& readable_name)
 {
 	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
-	for (LLAssetDictionary::const_iterator iter = dict->begin();
-		 iter != dict->end();
-		 iter++)
+	for (const LLAssetDictionary::value_type& pair : *dict)
 	{
-		const AssetEntry *entry = iter->second;
+		const AssetEntry *entry = pair.second;
 		if (entry->mHumanName && (readable_name == entry->mHumanName))
 		{
-			return iter->first;
+			return pair.first;
 		}
 	}
 	return AT_NONE;
diff --git a/indra/llcommon/llbase64.cpp b/indra/llcommon/llbase64.cpp
index 4e82cf7f20..bb85fe32a3 100644
--- a/indra/llcommon/llbase64.cpp
+++ b/indra/llcommon/llbase64.cpp
@@ -42,7 +42,7 @@ std::string LLBase64::encode(const U8* input, size_t input_size)
 		&& input_size > 0)
 	{
 		// Yes, it returns int.
-		int b64_buffer_length = apr_base64_encode_len(input_size);
+		int b64_buffer_length = apr_base64_encode_len(narrow(input_size));
 		char* b64_buffer = new char[b64_buffer_length];
 		
 		// This is faster than apr_base64_encode() if you know
@@ -52,7 +52,7 @@ std::string LLBase64::encode(const U8* input, size_t input_size)
 		b64_buffer_length = apr_base64_encode_binary(
 			b64_buffer,
 			input,
-			input_size);
+			narrow(input_size));
 		output.assign(b64_buffer);
 		delete[] b64_buffer;
 	}
diff --git a/indra/llcommon/llcallbacklist.cpp b/indra/llcommon/llcallbacklist.cpp
index 541ff75ee4..93d0a035da 100644
--- a/indra/llcommon/llcallbacklist.cpp
+++ b/indra/llcommon/llcallbacklist.cpp
@@ -109,7 +109,7 @@ void LLCallbackList::deleteAllFunctions()
 
 void LLCallbackList::callFunctions()
 {
-	for (callback_list_t::iterator iter = mCallbackList.begin(); iter != mCallbackList.end();  )
+	for (callback_list_t::iterator iter = mCallbackList.begin(); iter != mCallbackList.end(); )
 	{
 		callback_list_t::iterator curiter = iter++;
 		curiter->first(curiter->second);
diff --git a/indra/llcommon/llcallstack.cpp b/indra/llcommon/llcallstack.cpp
index 8db291eed1..83d5ae2a63 100644
--- a/indra/llcommon/llcallstack.cpp
+++ b/indra/llcommon/llcallstack.cpp
@@ -91,10 +91,9 @@ LLCallStack::LLCallStack(S32 skip_count, bool verbose):
 
 bool LLCallStack::contains(const std::string& str)
 {
-    for (std::vector<std::string>::const_iterator it = m_strings.begin();
-         it != m_strings.end(); ++it)
+	for (const std::string& src_str : m_strings)
     {
-        if (it->find(str) != std::string::npos)
+        if (src_str.find(str) != std::string::npos)
         {
             return true;
         }
@@ -105,10 +104,9 @@ bool LLCallStack::contains(const std::string& str)
 std::ostream& operator<<(std::ostream& s, const LLCallStack& call_stack)
 {
 #ifndef LL_RELEASE_FOR_DOWNLOAD
-    std::vector<std::string>::const_iterator it;
-    for (it=call_stack.m_strings.begin(); it!=call_stack.m_strings.end(); ++it)
+	for (const std::string& str : call_stack.m_strings)
     {
-        s << *it;
+        s << str;
     }
 #else
     s << "UNAVAILABLE IN RELEASE";
@@ -156,9 +154,9 @@ bool LLContextStrings::contains(const std::string& str)
 {
     const std::map<std::string,S32>& strings =
         LLThreadLocalSingletonPointer<LLContextStrings>::getInstance()->m_contextStrings;
-    for (std::map<std::string,S32>::const_iterator it = strings.begin(); it!=strings.end(); ++it)
+    for (const std::map<std::string,S32>::value_type& str_pair : strings)
     {
-        if (it->first.find(str) != std::string::npos)
+        if (str_pair.first.find(str) != std::string::npos)
         {
             return true;
         }
@@ -171,9 +169,9 @@ void LLContextStrings::output(std::ostream& os)
 {
     const std::map<std::string,S32>& strings =
         LLThreadLocalSingletonPointer<LLContextStrings>::getInstance()->m_contextStrings;
-    for (std::map<std::string,S32>::const_iterator it = strings.begin(); it!=strings.end(); ++it)
+    for (const std::map<std::string,S32>::value_type& str_pair : strings)
     {
-        os << it->first << "[" << it->second << "]" << "\n";
+        os << str_pair.first << "[" << str_pair.second << "]" << "\n";
     }
 }
 
diff --git a/indra/llcommon/lldefs.h b/indra/llcommon/lldefs.h
index 5a4b8325f4..5c46f6a796 100644
--- a/indra/llcommon/lldefs.h
+++ b/indra/llcommon/lldefs.h
@@ -28,6 +28,7 @@
 #define LL_LLDEFS_H
 
 #include "stdtypes.h"
+#include <type_traits>
 
 // Often used array indices
 const U32	VX			= 0;
@@ -168,80 +169,79 @@ const U32	MAXADDRSTR		= 17;		// 123.567.901.345 = 15 chars + \0 + 1 for good luc
 //   llclampb(a)     // clamps a to [0 .. 255]
 //   				   
 
-template <class LLDATATYPE> 
-inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2)
+template <typename T1, typename T2> 
+inline auto llmax(T1 d1, T2 d2)
 {
 	return (d1 > d2) ? d1 : d2;
 }
 
-template <class LLDATATYPE> 
-inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3)
+template <typename T1, typename T2, typename T3> 
+inline auto llmax(T1 d1, T2 d2, T3 d3)
 {
-	LLDATATYPE r = llmax(d1,d2);
+	auto r = llmax(d1,d2);
 	return llmax(r, d3);
 }
 
-template <class LLDATATYPE> 
-inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3, const LLDATATYPE& d4)
+template <typename T1, typename T2, typename T3, typename T4> 
+inline auto llmax(T1 d1, T2 d2, T3 d3, T4 d4)
 {
-	LLDATATYPE r1 = llmax(d1,d2);
-	LLDATATYPE r2 = llmax(d3,d4);
+	auto r1 = llmax(d1,d2);
+	auto r2 = llmax(d3,d4);
 	return llmax(r1, r2);
 }
 
-template <class LLDATATYPE> 
-inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2)
+template <typename T1, typename T2> 
+inline auto llmin(T1 d1, T2 d2)
 {
 	return (d1 < d2) ? d1 : d2;
 }
 
-template <class LLDATATYPE> 
-inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3)
+template <typename T1, typename T2, typename T3> 
+inline auto llmin(T1 d1, T2 d2, T3 d3)
 {
-	LLDATATYPE r = llmin(d1,d2);
+	auto r = llmin(d1,d2);
 	return (r < d3 ? r : d3);
 }
 
-template <class LLDATATYPE> 
-inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3, const LLDATATYPE& d4)
+template <typename T1, typename T2, typename T3, typename T4> 
+inline auto llmin(T1 d1, T2 d2, T3 d3, T4 d4)
 {
-	LLDATATYPE r1 = llmin(d1,d2);
-	LLDATATYPE r2 = llmin(d3,d4);
+	auto r1 = llmin(d1,d2);
+	auto r2 = llmin(d3,d4);
 	return llmin(r1, r2);
 }
 
-template <class LLDATATYPE> 
-inline LLDATATYPE llclamp(const LLDATATYPE& a, const LLDATATYPE& minval, const LLDATATYPE& maxval)
+template <typename A, typename MIN, typename MAX> 
+inline A llclamp(A a, MIN minval, MAX maxval)
 {
-	if ( a < minval )
+	A aminval{ static_cast<A>(minval) }, amaxval{ static_cast<A>(maxval) };
+	if ( a < aminval )
 	{
-		return minval;
+		return aminval;
 	}
-	else if ( a > maxval )
+	else if ( a > amaxval )
 	{
-		return maxval;
+		return amaxval;
 	}
 	return a;
 }
 
 template <class LLDATATYPE> 
-inline LLDATATYPE llclampf(const LLDATATYPE& a)
+inline LLDATATYPE llclampf(LLDATATYPE a)
 {
-	return llmin(llmax(a, (LLDATATYPE)0), (LLDATATYPE)1);
+	return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(1));
 }
 
 template <class LLDATATYPE> 
-inline LLDATATYPE llclampb(const LLDATATYPE& a)
+inline LLDATATYPE llclampb(LLDATATYPE a)
 {
-	return llmin(llmax(a, (LLDATATYPE)0), (LLDATATYPE)255);
+	return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(255));
 }
 
 template <class LLDATATYPE> 
 inline void llswap(LLDATATYPE& lhs, LLDATATYPE& rhs)
 {
-	LLDATATYPE tmp = lhs;
-	lhs = rhs;
-	rhs = tmp;
+	std::swap(lhs, rhs);
 }
 
 #endif // LL_LLDEFS_H
diff --git a/indra/llcommon/lldependencies.cpp b/indra/llcommon/lldependencies.cpp
index 0d5757effd..db546c5c3b 100644
--- a/indra/llcommon/lldependencies.cpp
+++ b/indra/llcommon/lldependencies.cpp
@@ -42,7 +42,7 @@
 // other Linden headers
 #include "llexception.h"
 
-LLDependenciesBase::VertexList LLDependenciesBase::topo_sort(int vertices, const EdgeList& edges) const
+LLDependenciesBase::VertexList LLDependenciesBase::topo_sort(size_t vertices, const EdgeList& edges) const
 {
     // Construct a Boost Graph Library graph according to the constraints
     // we've collected. It seems as though we ought to be able to capture
diff --git a/indra/llcommon/lldependencies.h b/indra/llcommon/lldependencies.h
index db2bbab8b0..950af4a4ad 100644
--- a/indra/llcommon/lldependencies.h
+++ b/indra/llcommon/lldependencies.h
@@ -126,7 +126,7 @@ public:
 protected:
     typedef std::vector< std::pair<std::size_t, std::size_t> > EdgeList;
     typedef std::vector<std::size_t> VertexList;
-    VertexList topo_sort(int vertices, const EdgeList& edges) const;
+    VertexList topo_sort(size_t vertices, const EdgeList& edges) const;
 
     /**
      * refpair is specifically intended to capture a pair of references. This
@@ -539,7 +539,7 @@ public:
                 for (typename DepNodeMap::const_iterator nmi = mNodes.begin(), nmend = mNodes.end();
                      nmi != nmend; ++nmi)
                 {
-                    int thisnode = vmap[nmi->first];
+                    auto thisnode = vmap[nmi->first];
                     // after dependencies: build edges from the named node to this one
                     for (typename DepNode::dep_set::const_iterator ai = nmi->second.after.begin(),
                                                                    aend = nmi->second.after.end();
diff --git a/indra/llcommon/llerror.cpp b/indra/llcommon/llerror.cpp
index 5aa8558878..eaf1be60f2 100644
--- a/indra/llcommon/llerror.cpp
+++ b/indra/llcommon/llerror.cpp
@@ -586,11 +586,9 @@ namespace
 	
 	void Globals::invalidateCallSites()
 	{
-		for (CallSiteVector::const_iterator i = callSites.begin();
-			 i != callSites.end();
-			 ++i)
+		for (LLError::CallSite* site : callSites)
 		{
-            (*i)->invalidate();
+            site->invalidate();
 		}
 		
 		callSites.clear();
@@ -1224,12 +1222,8 @@ namespace
         std::string escaped_message;
 
         LLMutexLock lock(&s->mRecorderMutex);
-		for (Recorders::const_iterator i = s->mRecorders.begin();
-			i != s->mRecorders.end();
-			++i)
+		for (LLError::RecorderPtr& r : s->mRecorders)
 		{
-			LLError::RecorderPtr r = *i;
-
             if (!r->enabled())
             {
                 continue;
@@ -1514,7 +1508,7 @@ namespace LLError
 		const size_t BUF_SIZE = 64;
 		char time_str[BUF_SIZE];	/* Flawfinder: ignore */
 		
-		int chars = strftime(time_str, BUF_SIZE, 
+		auto chars = strftime(time_str, BUF_SIZE, 
 								  "%Y-%m-%dT%H:%M:%SZ",
 								  gmtime(&now));
 
diff --git a/indra/llcommon/llevent.cpp b/indra/llcommon/llevent.cpp
index 633df01588..501d06e3cd 100644
--- a/indra/llcommon/llevent.cpp
+++ b/indra/llcommon/llevent.cpp
@@ -203,10 +203,9 @@ void LLSimpleDispatcher::removeListener(LLEventListener* listener)
 std::vector<LLListenerEntry> LLSimpleDispatcher::getListeners() const
 {
 	std::vector<LLListenerEntry> ret;
-	std::vector<LLListenerEntry>::const_iterator itor;
-	for (itor=mListeners.begin(); itor!=mListeners.end(); ++itor)
+	for (const LLListenerEntry& entry : mListeners)
 	{
-		ret.push_back(*itor);
+		ret.push_back(entry);
 	}
 	
 	return ret;
@@ -215,14 +214,12 @@ std::vector<LLListenerEntry> LLSimpleDispatcher::getListeners() const
 // virtual
 bool LLSimpleDispatcher::fireEvent(LLPointer<LLEvent> event, LLSD filter)
 {
-	std::vector<LLListenerEntry>::iterator itor;
 	std::string filter_string = filter.asString();
-	for (itor=mListeners.begin(); itor!=mListeners.end(); ++itor)
+	for (LLListenerEntry& entry : mListeners)
 	{
-		LLListenerEntry& entry = *itor;
 		if (filter_string == "" || entry.filter.asString() == filter_string)
 		{
-			(entry.listener)->handleEvent(event, (*itor).userdata);
+			(entry.listener)->handleEvent(event, entry.userdata);
 		}
 	}
 	return true;
@@ -276,10 +273,9 @@ void LLSimpleListener::clearDispatchers()
 bool LLSimpleListener::handleAttach(LLEventDispatcher *dispatcher)
 {
 	// Add dispatcher if it doesn't already exist
-	std::vector<LLEventDispatcher *>::iterator itor;
-	for (itor = mDispatchers.begin(); itor != mDispatchers.end(); ++itor)
+	for (LLEventDispatcher* disp : mDispatchers)
 	{
-		if ((*itor) == dispatcher) return true;
+		if (disp == dispatcher) return true;
 	}
 	mDispatchers.push_back(dispatcher);
 	return true;
diff --git a/indra/llcommon/lleventdispatcher.cpp b/indra/llcommon/lleventdispatcher.cpp
index 5b6d4efbe9..cd0ab6bc29 100644
--- a/indra/llcommon/lleventdispatcher.cpp
+++ b/indra/llcommon/lleventdispatcher.cpp
@@ -178,7 +178,7 @@ private:
     // store it as a map from name string to position index. Of course that's
     // easy to generate from the incoming names array, but why do it more than
     // once?
-    typedef std::map<LLSD::String, LLSD::Integer> IndexMap;
+    typedef std::map<LLSD::String, size_t> IndexMap;
     IndexMap _indexes;
     // Generated array of default values, aligned with the array of param names.
     LLSD _defaults;
@@ -197,9 +197,9 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
     {
         LL_ERRS("LLSDArgsMapper") << function << " names must be an array, not " << names << LL_ENDL;
     }
-    LLSD::Integer nparams(_names.size());
+    auto nparams(_names.size());
     // From _names generate _indexes.
-    for (LLSD::Integer ni = 0, nend = _names.size(); ni < nend; ++ni)
+    for (size_t ni = 0, nend = _names.size(); ni < nend; ++ni)
     {
         _indexes[_names[ni]] = ni;
     }
@@ -214,7 +214,7 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
 
     if (defaults.isUndefined() || defaults.isArray())
     {
-        LLSD::Integer ndefaults = defaults.size();
+        auto ndefaults = defaults.size();
         // defaults is a (possibly empty) array. Right-align it with names.
         if (ndefaults > nparams)
         {
@@ -224,10 +224,10 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
 
         // Offset by which we slide defaults array right to right-align with
         // _names array
-        LLSD::Integer offset = nparams - ndefaults;
+        auto offset = nparams - ndefaults;
         // Fill rightmost _defaults entries from defaults, and mark them as
         // filled
-        for (LLSD::Integer i = 0, iend = ndefaults; i < iend; ++i)
+        for (size_t i = 0, iend = ndefaults; i < iend; ++i)
         {
             _defaults[i + offset] = defaults[i];
             _has_dft[i + offset] = 1;
@@ -247,7 +247,7 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
                 continue;
             }
 
-            LLSD::Integer pos = ixit->second;
+            auto pos = ixit->second;
             // Store default value at that position in the _defaults array.
             _defaults[pos] = mi->second;
             // Don't forget to record the fact that we've filled this
@@ -301,7 +301,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
     {
         // Fill args from array. If there are too many args in passed array,
         // ignore the rest.
-        LLSD::Integer size(argsmap.size());
+        auto size(argsmap.size());
         if (size > args.size())
         {
             // We don't just use std::min() because we want to sneak in this
@@ -338,7 +338,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
                                             << mi->first << "=" << mi->second << LL_ENDL;
                 continue;
             }
-            LLSD::Integer pos = ixit->second;
+            auto pos = ixit->second;
             // Store the value at that position in the args array.
             args[pos] = mi->second;
             // Don't forget to record the fact that we've filled this
@@ -349,7 +349,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
 
     // Fill any remaining holes from _defaults.
     LLSD unfilled(LLSD::emptyArray());
-    for (LLSD::Integer i = 0, iend = args.size(); i < iend; ++i)
+    for (size_t i = 0, iend = args.size(); i < iend; ++i)
     {
         if (! filled[i])
         {
@@ -503,9 +503,9 @@ struct LLEventDispatcher::MapParamsDispatchEntry: public LLEventDispatcher::Para
         if (defaults.isArray() || defaults.isUndefined())
         {
             // Right-align the params and defaults arrays.
-            LLSD::Integer offset = params.size() - defaults.size();
+            auto offset = params.size() - defaults.size();
             // Now the name of every defaults[i] is at params[i + offset].
-            for (LLSD::Integer i(0), iend(defaults.size()); i < iend; ++i)
+            for (size_t i(0), iend(defaults.size()); i < iend; ++i)
             {
                 // Erase this optional param from mRequired.
                 mRequired.erase(params[i + offset].asString());
diff --git a/indra/llcommon/llheteromap.cpp b/indra/llcommon/llheteromap.cpp
index 7c19196e0c..c84e49d085 100644
--- a/indra/llcommon/llheteromap.cpp
+++ b/indra/llcommon/llheteromap.cpp
@@ -22,11 +22,11 @@ LLHeteroMap::~LLHeteroMap()
 {
     // For each entry in our map, we must call its deleter, which is the only
     // record we have of its original type.
-    for (TypeMap::iterator mi(mMap.begin()), me(mMap.end()); mi != me; ++mi)
+	for (TypeMap::value_type& pair : mMap)
     {
-        // mi->second is the std::pair; mi->second.first is the void*;
-        // mi->second.second points to the deleter function
-        (mi->second.second)(mi->second.first);
-        mi->second.first = NULL;
+        // pair.second is the std::pair; pair.second.first is the void*;
+        // pair.second.second points to the deleter function
+        (pair.second.second)(pair.second.first);
+        pair.second.first = NULL;
     }
 }
diff --git a/indra/llcommon/llinitdestroyclass.cpp b/indra/llcommon/llinitdestroyclass.cpp
index e6382a7924..e3b9e6d099 100644
--- a/indra/llcommon/llinitdestroyclass.cpp
+++ b/indra/llcommon/llinitdestroyclass.cpp
@@ -21,10 +21,9 @@
 
 void LLCallbackRegistry::fireCallbacks() const
 {
-	for (FuncList::const_iterator fi = mCallbacks.begin(), fe = mCallbacks.end();
-		 fi != fe; ++fi)
+	for (FuncList::value_type pair : mCallbacks)
 	{
-		LL_INFOS("LLInitDestroyClass") << "calling " << fi->first << "()" << LL_ENDL;
-		fi->second();
+		LL_INFOS("LLInitDestroyClass") << "calling " << pair.first << "()" << LL_ENDL;
+		pair.second();
 	}
 }
diff --git a/indra/llcommon/llinitparam.cpp b/indra/llcommon/llinitparam.cpp
index aa2f4eb289..d15bd2f619 100644
--- a/indra/llcommon/llinitparam.cpp
+++ b/indra/llcommon/llinitparam.cpp
@@ -207,10 +207,10 @@ namespace LLInitParam
 		if (!mValidated)
 		{
 		const BlockDescriptor& block_data = mostDerivedBlockDescriptor();
-		for (BlockDescriptor::param_validation_list_t::const_iterator it = block_data.mValidationList.begin(); it != block_data.mValidationList.end(); ++it)
+		for (const BlockDescriptor::param_validation_list_t::value_type& pair : block_data.mValidationList)
 		{
-			const Param* param = getParamFromHandle(it->first);
-			if (!it->second(param))
+			const Param* param = getParamFromHandle(pair.first);
+			if (!pair.second(param))
 			{
 				if (emit_errors)
 				{
@@ -235,13 +235,11 @@ namespace LLInitParam
 		// unnamed param is like LLView::Params::rect - implicit
 		const BlockDescriptor& block_data = mostDerivedBlockDescriptor();
 
-		for (BlockDescriptor::param_list_t::const_iterator it = block_data.mUnnamedParams.begin(); 
-			it != block_data.mUnnamedParams.end(); 
-			++it)
+		for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams)
 		{
-			param_handle_t param_handle = (*it)->mParamHandle;
+			param_handle_t param_handle = ptr->mParamHandle;
 			const Param* param = getParamFromHandle(param_handle);
-			ParamDescriptor::serialize_func_t serialize_func = (*it)->mSerializeFunc;
+			ParamDescriptor::serialize_func_t serialize_func = ptr->mSerializeFunc;
 			if (serialize_func && predicate_rule.check(ll_make_predicate(PROVIDED, param->anyProvided())))
 			{
 				const Param* diff_param = diff_block ? diff_block->getParamFromHandle(param_handle) : NULL;
@@ -249,23 +247,19 @@ namespace LLInitParam
 			}
 		}
 
-		for(BlockDescriptor::param_map_t::const_iterator it = block_data.mNamedParams.begin();
-			it != block_data.mNamedParams.end();
-			++it)
+		for (const BlockDescriptor::param_map_t::value_type& pair : block_data.mNamedParams)
 		{
-			param_handle_t param_handle = it->second->mParamHandle;
+			param_handle_t param_handle = pair.second->mParamHandle;
 			const Param* param = getParamFromHandle(param_handle);
-			ParamDescriptor::serialize_func_t serialize_func = it->second->mSerializeFunc;
+			ParamDescriptor::serialize_func_t serialize_func = pair.second->mSerializeFunc;
 			if (serialize_func && predicate_rule.check(ll_make_predicate(PROVIDED, param->anyProvided())))
 			{
 				// Ensure this param has not already been serialized
 				// Prevents <rect> from being serialized as its own tag.
 				bool duplicate = false;
-				for (BlockDescriptor::param_list_t::const_iterator it2 = block_data.mUnnamedParams.begin(); 
-					it2 != block_data.mUnnamedParams.end(); 
-					++it2)
+				for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams)
 				{
-					if (param_handle == (*it2)->mParamHandle)
+					if (param_handle == ptr->mParamHandle)
 					{
 						duplicate = true;
 						break;
@@ -279,7 +273,7 @@ namespace LLInitParam
 					continue;
 				}
 
-				name_stack.push_back(std::make_pair(it->first, !duplicate));
+				name_stack.push_back(std::make_pair(pair.first, !duplicate));
 				const Param* diff_param = diff_block ? diff_block->getParamFromHandle(param_handle) : NULL;
 				serialized |= serialize_func(*param, parser, name_stack, predicate_rule, diff_param);
 				name_stack.pop_back();
@@ -300,45 +294,39 @@ namespace LLInitParam
 		// unnamed param is like LLView::Params::rect - implicit
 		const BlockDescriptor& block_data = mostDerivedBlockDescriptor();
 
-		for (BlockDescriptor::param_list_t::const_iterator it = block_data.mUnnamedParams.begin(); 
-			it != block_data.mUnnamedParams.end(); 
-			++it)
+		for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams)
 		{
-			param_handle_t param_handle = (*it)->mParamHandle;
+			param_handle_t param_handle = ptr->mParamHandle;
 			const Param* param = getParamFromHandle(param_handle);
-			ParamDescriptor::inspect_func_t inspect_func = (*it)->mInspectFunc;
+			ParamDescriptor::inspect_func_t inspect_func = ptr->mInspectFunc;
 			if (inspect_func)
 			{
 				name_stack.push_back(std::make_pair("", true));
-				inspect_func(*param, parser, name_stack, (*it)->mMinCount, (*it)->mMaxCount);
+				inspect_func(*param, parser, name_stack, ptr->mMinCount, ptr->mMaxCount);
 				name_stack.pop_back();
 			}
 		}
 
-		for(BlockDescriptor::param_map_t::const_iterator it = block_data.mNamedParams.begin();
-			it != block_data.mNamedParams.end();
-			++it)
+		for(const BlockDescriptor::param_map_t::value_type& pair : block_data.mNamedParams)
 		{
-			param_handle_t param_handle = it->second->mParamHandle;
+			param_handle_t param_handle = pair.second->mParamHandle;
 			const Param* param = getParamFromHandle(param_handle);
-			ParamDescriptor::inspect_func_t inspect_func = it->second->mInspectFunc;
+			ParamDescriptor::inspect_func_t inspect_func = pair.second->mInspectFunc;
 			if (inspect_func)
 			{
 				// Ensure this param has not already been inspected
 				bool duplicate = false;
-				for (BlockDescriptor::param_list_t::const_iterator it2 = block_data.mUnnamedParams.begin(); 
-					it2 != block_data.mUnnamedParams.end(); 
-					++it2)
+                for (const ParamDescriptorPtr &ptr : block_data.mUnnamedParams)
 				{
-					if (param_handle == (*it2)->mParamHandle)
+					if (param_handle == ptr->mParamHandle)
 					{
 						duplicate = true;
 						break;
 					}
 				}
 
-				name_stack.push_back(std::make_pair(it->first, !duplicate));
-				inspect_func(*param, parser, name_stack, it->second->mMinCount, it->second->mMaxCount);
+				name_stack.push_back(std::make_pair(pair.first, !duplicate));
+				inspect_func(*param, parser, name_stack, pair.second->mMinCount, pair.second->mMaxCount);
 				name_stack.pop_back();
 			}
 		}
@@ -382,12 +370,10 @@ namespace LLInitParam
 		}
 
 		// try to parse unnamed parameters, in declaration order
-		for ( BlockDescriptor::param_list_t::iterator it = block_data.mUnnamedParams.begin(); 
-			it != block_data.mUnnamedParams.end(); 
-			++it)
+		for (ParamDescriptorPtr& ptr : block_data.mUnnamedParams)
 		{
-			Param* paramp = getParamFromHandle((*it)->mParamHandle);
-			ParamDescriptor::deserialize_func_t deserialize_func = (*it)->mDeserializeFunc;
+			Param* paramp = getParamFromHandle(ptr->mParamHandle);
+			ParamDescriptor::deserialize_func_t deserialize_func = ptr->mDeserializeFunc;
 
 			if (deserialize_func && deserialize_func(*paramp, p, name_stack_range, new_name))
 			{
@@ -453,12 +439,9 @@ namespace LLInitParam
 	{
 		param_handle_t handle = getHandleFromParam(&param);
 		BlockDescriptor& descriptor = mostDerivedBlockDescriptor();
-		BlockDescriptor::all_params_list_t::iterator end_it = descriptor.mAllParams.end();
-		for (BlockDescriptor::all_params_list_t::iterator it = descriptor.mAllParams.begin();
-			it != end_it;
-			++it)
+		for (ParamDescriptorPtr& ptr : descriptor.mAllParams)
 		{
-			if ((*it)->mParamHandle == handle) return *it;
+			if (ptr->mParamHandle == handle) return ptr;
 		}
 		return ParamDescriptorPtr();
 	}
@@ -468,17 +451,14 @@ namespace LLInitParam
 	bool BaseBlock::mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite)
 	{
 		bool some_param_changed = false;
-		BlockDescriptor::all_params_list_t::const_iterator end_it = block_data.mAllParams.end();
-		for (BlockDescriptor::all_params_list_t::const_iterator it = block_data.mAllParams.begin();
-			it != end_it;
-			++it)
+		for (const ParamDescriptorPtr& ptr : block_data.mAllParams)
 		{
-			const Param* other_paramp = other.getParamFromHandle((*it)->mParamHandle);
-			ParamDescriptor::merge_func_t merge_func = (*it)->mMergeFunc;
+			const Param* other_paramp = other.getParamFromHandle(ptr->mParamHandle);
+			ParamDescriptor::merge_func_t merge_func = ptr->mMergeFunc;
 			if (merge_func)
 			{
-				Param* paramp = getParamFromHandle((*it)->mParamHandle);
-				llassert(paramp->getEnclosingBlockOffset() == (*it)->mParamHandle);
+				Param* paramp = getParamFromHandle(ptr->mParamHandle);
+				llassert(paramp->getEnclosingBlockOffset() == ptr->mParamHandle);
 				some_param_changed |= merge_func(*paramp, *other_paramp, overwrite);
 			}
 		}
diff --git a/indra/llcommon/llinitparam.h b/indra/llcommon/llinitparam.h
index 7f5b9b4ac2..9edc7e40f3 100644
--- a/indra/llcommon/llinitparam.h
+++ b/indra/llcommon/llinitparam.h
@@ -325,13 +325,11 @@ namespace LLInitParam
 		std::string calcValueName(const value_t& value) const
 		{
 			value_name_map_t* map = getValueNames();
-			for (typename value_name_map_t::iterator it = map->begin(), end_it = map->end();
-				it != end_it;
-				++it)
+			for (typename value_name_map_t::value_type& map_pair : *map)
 			{
-				if (ParamCompare<T>::equals(it->second, value))
+				if (ParamCompare<T>::equals(map_pair.second, value))
 				{
-					return it->first;
+					return map_pair.first;
 				}
 			}
 
@@ -376,11 +374,9 @@ namespace LLInitParam
 			static std::vector<std::string> sValues;
 
 			value_name_map_t* map = getValueNames();
-			for (typename value_name_map_t::iterator it = map->begin(), end_it = map->end();
-				 it != end_it;
-				 ++it)
+			for (typename value_name_map_t::value_type& map_pair : *map)
 			{
-				sValues.push_back(it->first);
+				sValues.push_back(map_pair.first);
 			}
 			return &sValues;
 		}
diff --git a/indra/llcommon/llinstancetracker.h b/indra/llcommon/llinstancetracker.h
index 97f7817e74..27422e1266 100644
--- a/indra/llcommon/llinstancetracker.h
+++ b/indra/llcommon/llinstancetracker.h
@@ -99,7 +99,7 @@ public:
         return mSelf;
     }
 
-    static S32 instanceCount() 
+    static size_t instanceCount() 
     { 
         return LockStatic()->mMap.size(); 
     }
@@ -374,7 +374,7 @@ public:
         return mSelf;
     }
     
-    static S32 instanceCount()
+    static size_t instanceCount()
     {
         return LockStatic()->mSet.size();
     }
diff --git a/indra/llcommon/llkeybind.cpp b/indra/llcommon/llkeybind.cpp
index 38696c2258..b89160cc55 100644
--- a/indra/llcommon/llkeybind.cpp
+++ b/indra/llcommon/llkeybind.cpp
@@ -30,6 +30,7 @@
 
 #include "llsd.h"
 #include "llsdutil.h"
+#include <algorithm>
 
 LLKeyData::LLKeyData()
     :
@@ -180,10 +181,10 @@ LLKeyBind::LLKeyBind(const LLSD &key_bind)
 
 bool LLKeyBind::operator==(const LLKeyBind& rhs)
 {
-    U32 size = mData.size();
+    auto size = mData.size();
     if (size != rhs.mData.size()) return false;
 
-    for (U32 i = 0; i < size; i++)
+    for (size_t i = 0; i < size; i++)
     {
         if (mData[i] != rhs.mData[i]) return false;
     }
@@ -193,7 +194,7 @@ bool LLKeyBind::operator==(const LLKeyBind& rhs)
 
 bool LLKeyBind::operator!=(const LLKeyBind& rhs)
 {
-    U32 size = mData.size();
+    auto size = mData.size();
     if (size != rhs.mData.size()) return true;
 
     for (U32 i = 0; i < size; i++)
@@ -206,26 +207,29 @@ bool LLKeyBind::operator!=(const LLKeyBind& rhs)
 
 bool LLKeyBind::isEmpty() const
 {
-    for (data_vector_t::const_iterator iter = mData.begin(); iter != mData.end(); iter++)
+	for (const LLKeyData& key_data : mData)
     {
-        if (!iter->isEmpty()) return false;
+        if (!key_data.isEmpty()) return false;
     }
     return true;
 }
 
-LLSD LLKeyBind::asLLSD() const
+LLKeyBind::data_vector_t::const_iterator LLKeyBind::endNonEmpty() const
 {
-    S32 last = mData.size() - 1;
-    while (mData[last].empty())
-    {
-        last--;
-    }
+    // search backwards for last non-empty entry, then turn back into forwards
+    // iterator (.base() call)
+    return std::find_if_not(mData.rbegin(), mData.rend(),
+                            [](const auto& kdata){ return kdata.empty(); }).base();
+}
 
+LLSD LLKeyBind::asLLSD() const
+{
     LLSD data;
-    for (S32 i = 0; i <= last; ++i)
+	for (const LLKeyData& key_data : mData)
     {
-        // append even if empty to not affect visual representation
-        data.append(mData[i].asLLSD());
+        // append intermediate entries even if empty to not affect visual
+        // representation
+        data.append(key_data.asLLSD());
     }
     return data;
 }
@@ -238,9 +242,9 @@ bool LLKeyBind::canHandle(EMouseClickType mouse, KEY key, MASK mask) const
         return false;
     }
 
-    for (data_vector_t::const_iterator iter = mData.begin(); iter != mData.end(); iter++)
+	for (const LLKeyData& key_data : mData)
     {
-        if (iter->canHandle(mouse, key, mask))
+        if (key_data.canHandle(mouse, key, mask))
         {
             return true;
         }
@@ -262,12 +266,12 @@ bool LLKeyBind::hasKeyData(EMouseClickType mouse, KEY key, MASK mask, bool ignor
 {
     if (mouse != CLICK_NONE || key != KEY_NONE)
     {
-        for (data_vector_t::const_iterator iter = mData.begin(); iter != mData.end(); iter++)
+		for (const LLKeyData& key_data : mData)
         {
-            if (iter->mKey == key
-                && iter->mMask == mask
-                && iter->mMouse == mouse
-                && iter->mIgnoreMasks == ignore)
+            if (key_data.mKey == key
+                && key_data.mMask == mask
+                && key_data.mMouse == mouse
+                && key_data.mIgnoreMasks == ignore)
             {
                 return true;
             }
@@ -349,16 +353,16 @@ void LLKeyBind::replaceKeyData(const LLKeyData& data, U32 index)
     {
         // if both click and key are none (isEmpty()), we are inserting a placeholder, we don't want to reset anything
         // otherwise reset identical key
-        for (data_vector_t::iterator iter = mData.begin(); iter != mData.end(); iter++)
+		for (LLKeyData& key_data : mData)
         {
-            if (iter->mKey == data.mKey
-                && iter->mMouse == data.mMouse
-                && iter->mIgnoreMasks == data.mIgnoreMasks
-                && iter->mMask == data.mMask)
+            if (key_data.mKey == data.mKey
+                && key_data.mMouse == data.mMouse
+                && key_data.mIgnoreMasks == data.mIgnoreMasks
+                && key_data.mMask == data.mMask)
             {
                 // Replacing only fully equal combinations even in case 'ignore' is set
                 // Reason: Simplicity and user might decide to do a 'move' command as W and Shift+Ctrl+W, and 'run' as Shift+W
-                iter->reset();
+                key_data.reset();
                 break;
             }
         }
@@ -380,16 +384,10 @@ void LLKeyBind::resetKeyData(S32 index)
 
 void LLKeyBind::trimEmpty()
 {
-    S32 last = mData.size() - 1;
-    while (last >= 0 && mData[last].empty())
-    {
-        mData.erase(mData.begin() + last);
-        last--;
-    }
+    mData.erase(endNonEmpty(), mData.end());
 }
 
-U32 LLKeyBind::getDataCount()
+size_t LLKeyBind::getDataCount()
 {
     return mData.size();
 }
-
diff --git a/indra/llcommon/llkeybind.h b/indra/llcommon/llkeybind.h
index c6b4bd970f..488f509411 100644
--- a/indra/llcommon/llkeybind.h
+++ b/indra/llcommon/llkeybind.h
@@ -95,11 +95,13 @@ public:
     void clear() { mData.clear(); }
     // if there any empty LLKeyData in the end of the array, remove them
     void trimEmpty();
-    U32 getDataCount();
+    size_t getDataCount();
 
 private:
     typedef std::vector<LLKeyData> data_vector_t;
     data_vector_t mData;
+
+    data_vector_t::const_iterator endNonEmpty() const;
 };
 
 
diff --git a/indra/llcommon/llleap.cpp b/indra/llcommon/llleap.cpp
index 2704f8b6de..c87c0758fe 100644
--- a/indra/llcommon/llleap.cpp
+++ b/indra/llcommon/llleap.cpp
@@ -231,7 +231,8 @@ public:
         }
 |*==========================================================================*/
 
-        LL_DEBUGS("EventHost") << "Sending: " << buffer.tellp() << ':';
+        LL_DEBUGS("EventHost") << "Sending: "
+                               << static_cast<U64>(buffer.tellp()) << ':';
         std::string::size_type truncate(80);
         if (buffer.tellp() <= truncate)
         {
@@ -244,7 +245,8 @@ public:
         LL_CONT << LL_ENDL;
 
         LLProcess::WritePipe& childin(mChild->getWritePipe(LLProcess::STDIN));
-        childin.get_ostream() << buffer.tellp() << ':' << buffer.str() << std::flush;
+        childin.get_ostream() << static_cast<U64>(buffer.tellp())
+                              << ':' << buffer.str() << std::flush;
         return false;
     }
 
diff --git a/indra/llcommon/llmd5.cpp b/indra/llcommon/llmd5.cpp
index f942a976b7..9b2a2bab60 100644
--- a/indra/llcommon/llmd5.cpp
+++ b/indra/llcommon/llmd5.cpp
@@ -96,10 +96,10 @@ LLMD5::LLMD5()
 // operation, processing another message block, and updating the
 // context.
 
-void LLMD5::update (const uint1 *input, const uint4 input_length) {
+void LLMD5::update (const uint1 *input, const size_t input_length) {
 
-  uint4 input_index, buffer_index;
-  uint4 buffer_space;                // how much space is left in buffer
+  size_t input_index, buffer_index;
+  size_t buffer_space;                // how much space is left in buffer
 
   if (finalized){  // so we can't update!
 	  std::cerr << "LLMD5::update:  Can't update a finalized digest!" << std::endl;
@@ -107,14 +107,10 @@ void LLMD5::update (const uint1 *input, const uint4 input_length) {
   }
 
   // Compute number of bytes mod 64
-  buffer_index = (unsigned int)((count[0] >> 3) & 0x3F);
+  buffer_index = size_t((count >> 3) & 0x3F);
 
   // Update number of bits
-  if (  (count[0] += ((uint4) input_length << 3))<((uint4) input_length << 3) )
-    count[1]++;
-
-  count[1] += ((uint4)input_length >> 29);
-
+  count += input_length << 3;
 
   buffer_space = 64 - buffer_index;  // how much space is left in buffer
 
@@ -192,7 +188,7 @@ void  LLMD5::update(const std::string& s)
 void LLMD5::finalize (){
 
   unsigned char bits[8];		/* Flawfinder: ignore */
-  unsigned int index, padLen;
+  size_t index, padLen;
   static uint1 PADDING[64]={
     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -204,11 +200,12 @@ void LLMD5::finalize (){
     return;
   }
 
-  // Save number of bits
-  encode (bits, count, 8);
+  // Save number of bits.
+  // Treat count, a uint64_t, as uint4[2].
+  encode (bits, reinterpret_cast<uint4*>(&count), 8);
 
   // Pad out to 56 mod 64.
-  index = (uint4) ((count[0] >> 3) & 0x3f);
+  index = size_t((count >> 3) & 0x3f);
   padLen = (index < 56) ? (56 - index) : (120 - index);
   update (PADDING, padLen);
 
@@ -340,8 +337,7 @@ void LLMD5::init(){
   finalized=0;  // we just started!
 
   // Nothing counted, so count=0
-  count[0] = 0;
-  count[1] = 0;
+  count = 0;
 
   // Load magic initialization constants.
   state[0] = 0x67452301;
@@ -508,9 +504,9 @@ void LLMD5::transform (const U8 block[64]){
 
 // Encodes input (UINT4) into output (unsigned char). Assumes len is
 // a multiple of 4.
-void LLMD5::encode (uint1 *output, const uint4 *input, const uint4 len) {
+void LLMD5::encode (uint1 *output, const uint4 *input, const size_t len) {
 
-  unsigned int i, j;
+  size_t i, j;
 
   for (i = 0, j = 0; j < len; i++, j += 4) {
     output[j]   = (uint1)  (input[i] & 0xff);
@@ -525,9 +521,9 @@ void LLMD5::encode (uint1 *output, const uint4 *input, const uint4 len) {
 
 // Decodes input (unsigned char) into output (UINT4). Assumes len is
 // a multiple of 4.
-void LLMD5::decode (uint4 *output, const uint1 *input, const uint4 len){
+void LLMD5::decode (uint4 *output, const uint1 *input, const size_t len){
 
-  unsigned int i, j;
+  size_t i, j;
 
   for (i = 0, j = 0; j < len; i++, j += 4)
     output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
diff --git a/indra/llcommon/llmd5.h b/indra/llcommon/llmd5.h
index 1526e6ac3c..8530dc0389 100644
--- a/indra/llcommon/llmd5.h
+++ b/indra/llcommon/llmd5.h
@@ -86,7 +86,7 @@ class LL_COMMON_API LLMD5 {
 public:
 // methods for controlled operation:
   LLMD5              ();  // simple initializer
-  void  update     (const uint1 *input, const uint4 input_length);
+  void  update     (const uint1 *input, const size_t input_length);
   void  update     (std::istream& stream);
   void  update     (FILE *file);
   void  update     (const std::string& str);
@@ -110,7 +110,7 @@ private:
 
 // next, the private data:
   uint4 state[4];
-  uint4 count[2];     // number of *bits*, mod 2^64
+  uint64_t count;     // number of *bits*, mod 2^64
   uint1 buffer[64];   // input buffer
   uint1 digest[16];
   uint1 finalized;
@@ -120,8 +120,8 @@ private:
   void transform        (const uint1 *buffer);  // does the real update work.  Note 
                                           // that length is implied to be 64.
 
-  static void encode    (uint1 *dest, const uint4 *src, const uint4 length);
-  static void decode    (uint4 *dest, const uint1 *src, const uint4 length);
+  static void encode    (uint1 *dest, const uint4 *src, const size_t length);
+  static void decode    (uint4 *dest, const uint1 *src, const size_t length);
 
 };
 
diff --git a/indra/llcommon/llmetricperformancetester.cpp b/indra/llcommon/llmetricperformancetester.cpp
index 100eb57555..ab509b46eb 100644
--- a/indra/llcommon/llmetricperformancetester.cpp
+++ b/indra/llcommon/llmetricperformancetester.cpp
@@ -42,9 +42,9 @@ LLMetricPerformanceTesterBasic::name_tester_map_t LLMetricPerformanceTesterBasic
 /*static*/ 
 void LLMetricPerformanceTesterBasic::cleanupClass() 
 {
-	for (name_tester_map_t::iterator iter = sTesterMap.begin() ; iter != sTesterMap.end() ; ++iter)
+	for (name_tester_map_t::value_type& pair : sTesterMap)
 	{
-		delete iter->second ;
+		delete pair.second;
 	}
 	sTesterMap.clear() ;
 }
@@ -111,8 +111,8 @@ LLSD LLMetricPerformanceTesterBasic::analyzeMetricPerformanceLog(std::istream& i
 			{
 				ret[label]["Name"] = iter->second["Name"] ;
 				
-				S32 num_of_metrics = tester->getNumberOfMetrics() ;
-				for(S32 index = 0 ; index < num_of_metrics ; index++)
+				auto num_of_metrics = tester->getNumberOfMetrics() ;
+				for(size_t index = 0 ; index < num_of_metrics ; index++)
 				{
 					ret[label][ tester->getMetricName(index) ] = iter->second[ tester->getMetricName(index) ] ;
 				}
@@ -154,10 +154,9 @@ void LLMetricPerformanceTesterBasic::doAnalysisMetrics(std::string baseline, std
 	llofstream os(output.c_str());
 	
 	os << "Label, Metric, Base(B), Target(T), Diff(T-B), Percentage(100*T/B)\n"; 
-	for(LLMetricPerformanceTesterBasic::name_tester_map_t::iterator iter = LLMetricPerformanceTesterBasic::sTesterMap.begin() ; 
-		iter != LLMetricPerformanceTesterBasic::sTesterMap.end() ; ++iter)
+	for (LLMetricPerformanceTesterBasic::name_tester_map_t::value_type& pair : LLMetricPerformanceTesterBasic::sTesterMap)
 	{
-		LLMetricPerformanceTesterBasic* tester = ((LLMetricPerformanceTesterBasic*)iter->second) ;	
+		LLMetricPerformanceTesterBasic* tester = ((LLMetricPerformanceTesterBasic*)pair.second);
 		tester->analyzePerformance(&os, &base, &current) ;
 	}
 	
diff --git a/indra/llcommon/llmetricperformancetester.h b/indra/llcommon/llmetricperformancetester.h
index 2e99ed979d..6561a78f03 100644
--- a/indra/llcommon/llmetricperformancetester.h
+++ b/indra/llcommon/llmetricperformancetester.h
@@ -67,12 +67,12 @@ public:
 	/**
 	 * @return Returns the number of the test metrics in this tester instance.
 	 */
-	S32 getNumberOfMetrics() const { return mMetricStrings.size() ;}
+	auto getNumberOfMetrics() const { return mMetricStrings.size() ;}
 	/**
 	 * @return Returns the metric name at index
 	 * @param[in] index - Index on the list of metrics managed by this tester instance.
 	 */
-	std::string getMetricName(S32 index) const { return mMetricStrings[index] ;}
+	std::string getMetricName(size_t index) const { return mMetricStrings[index] ;}
 
 protected:
 	/**
diff --git a/indra/llcommon/llmortician.cpp b/indra/llcommon/llmortician.cpp
index 93c7d520f2..b6ad40c2af 100644
--- a/indra/llcommon/llmortician.cpp
+++ b/indra/llcommon/llmortician.cpp
@@ -37,9 +37,9 @@ LLMortician::~LLMortician()
 	sGraveyard.remove(this);
 }
 
-U32 LLMortician::logClass(std::stringstream &str)
+size_t LLMortician::logClass(std::stringstream &str)
 {
-    U32 size = sGraveyard.size();
+    auto size = sGraveyard.size();
     str << "Mortician graveyard count: " << size;
     str << " Zealous: " << (sDestroyImmediate ? "True" : "False");
     if (size == 0)
diff --git a/indra/llcommon/llmortician.h b/indra/llcommon/llmortician.h
index 41cb49fab1..f92c5a11db 100644
--- a/indra/llcommon/llmortician.h
+++ b/indra/llcommon/llmortician.h
@@ -34,8 +34,8 @@ class LL_COMMON_API LLMortician
 {
 public:
 	LLMortician() { mIsDead = FALSE; }
-	static U32 graveyardCount() { return sGraveyard.size(); };
-	static U32 logClass(std::stringstream &str);
+	static auto graveyardCount() { return sGraveyard.size(); };
+	static size_t logClass(std::stringstream &str);
 	static void updateClass();
 	virtual ~LLMortician();
 	void die();
diff --git a/indra/llcommon/llnametable.h b/indra/llcommon/llnametable.h
index d3283543f3..2c8e71263e 100644
--- a/indra/llcommon/llnametable.h
+++ b/indra/llcommon/llnametable.h
@@ -86,12 +86,10 @@ public:
 	// O(N)! (currently only used in one place... (newsim/llstate.cpp))
 	const char *resolveData(const DATA &data) const
 	{
-		const_iter_t iter = mNameMap.begin();
-		const_iter_t end = mNameMap.end();
-		for (; iter != end; ++iter)
+		for (const name_map_t::value_type& pair : mNameMap)
 		{
-			if (iter->second == data)
-				return iter->first;
+			if (pair.second == data)
+				return pair.first;
 		}
    		return NULL;
 	}		
diff --git a/indra/llcommon/llpriqueuemap.h b/indra/llcommon/llpriqueuemap.h
index d8d3edd48a..030e2e0f21 100644
--- a/indra/llcommon/llpriqueuemap.h
+++ b/indra/llcommon/llpriqueuemap.h
@@ -115,9 +115,9 @@ public:
 			LL_WARNS() << "Data not on priority queue!" << LL_ENDL;
 			// OK, try iterating through all of the data and seeing if we just screwed up the priority
 			// somehow.
-			for (iter = mMap.begin(); iter != mMap.end(); iter++)
+			for (pqm_pair pair : mMap)
 			{
-				if ((*(iter)).second == data)
+				if (pair.second == data)
 				{
 					LL_ERRS() << "Data on priority queue but priority not matched!" << LL_ENDL;
 				}
diff --git a/indra/llcommon/llqueuedthread.cpp b/indra/llcommon/llqueuedthread.cpp
index 7da7c1e026..394212ee0d 100644
--- a/indra/llcommon/llqueuedthread.cpp
+++ b/indra/llcommon/llqueuedthread.cpp
@@ -123,7 +123,7 @@ void LLQueuedThread::shutdown()
 
 // MAIN THREAD
 // virtual
-S32 LLQueuedThread::update(F32 max_time_ms)
+size_t LLQueuedThread::update(F32 max_time_ms)
 {
     LL_PROFILE_ZONE_SCOPED;
 	if (!mStarted)
@@ -137,7 +137,7 @@ S32 LLQueuedThread::update(F32 max_time_ms)
 	return updateQueue(max_time_ms);
 }
 
-S32 LLQueuedThread::updateQueue(F32 max_time_ms)
+size_t LLQueuedThread::updateQueue(F32 max_time_ms)
 {
     LL_PROFILE_ZONE_SCOPED;
 	// Frame Update
@@ -183,9 +183,9 @@ void LLQueuedThread::incQueue()
 
 //virtual
 // May be called from any thread
-S32 LLQueuedThread::getPending()
+size_t LLQueuedThread::getPending()
 {
-	return mRequestQueue.size();
+    return mRequestQueue.size();
 }
 
 // MAIN thread
@@ -526,7 +526,7 @@ void LLQueuedThread::run()
 
 		threadedUpdate();
 		
-		int pending_work = processNextRequest();
+		auto pending_work = processNextRequest();
 
 		if (pending_work == 0)
 		{
diff --git a/indra/llcommon/llqueuedthread.h b/indra/llcommon/llqueuedthread.h
index 6b82ccc434..814dbc4c38 100644
--- a/indra/llcommon/llqueuedthread.h
+++ b/indra/llcommon/llqueuedthread.h
@@ -137,13 +137,13 @@ protected:
 public:
 	bool waitForResult(handle_t handle, bool auto_complete = true);
 
-	virtual S32 update(F32 max_time_ms);
-	S32 updateQueue(F32 max_time_ms);
-	
+	virtual size_t update(F32 max_time_ms);
+	size_t updateQueue(F32 max_time_ms);
+
 	void waitOnPending();
 	void printQueueStats();
 
-	virtual S32 getPending();
+	virtual size_t getPending();
 	bool getThreaded() { return mThreaded ? true : false; }
 
 	// Request accessors
diff --git a/indra/llcommon/llregistry.h b/indra/llcommon/llregistry.h
index 750fe9fdc8..e272d7a9b8 100644
--- a/indra/llcommon/llregistry.h
+++ b/indra/llcommon/llregistry.h
@@ -141,11 +141,9 @@ public:
 
 	ptr_value_t getValue(ref_const_key_t key)
 	{
-		for(scope_list_iterator_t it = mActiveScopes.begin();
-			it != mActiveScopes.end();
-			++it)
+		for(Registrar* scope : mActiveScopes)
 		{
-			ptr_value_t valuep = (*it)->getValue(key);
+			ptr_value_t valuep = scope->getValue(key);
 			if (valuep != NULL) return valuep;
 		}
 		return mDefaultRegistrar.getValue(key);
@@ -153,11 +151,9 @@ public:
 
 	ptr_const_value_t getValue(ref_const_key_t key) const
 	{
-		for(scope_list_const_iterator_t it = mActiveScopes.begin();
-			it != mActiveScopes.end();
-			++it)
+		for(const Registrar* scope : mActiveScopes)
 		{
-			ptr_value_t valuep = (*it)->getValue(key);
+			ptr_const_value_t valuep = scope->getValue(key);
 			if (valuep != NULL) return valuep;
 		}
 		return mDefaultRegistrar.getValue(key);
@@ -165,11 +161,9 @@ public:
 
 	bool exists(ref_const_key_t key) const
 	{
-		for(scope_list_const_iterator_t it = mActiveScopes.begin();
-			it != mActiveScopes.end();
-			++it)
+		for(const Registrar* scope : mActiveScopes)
 		{
-			if ((*it)->exists(key)) return true;
+			if (scope->exists(key)) return true;
 		}
 
 		return mDefaultRegistrar.exists(key);
@@ -177,11 +171,9 @@ public:
 
 	bool empty() const
 	{
-		for(scope_list_const_iterator_t it = mActiveScopes.begin();
-			it != mActiveScopes.end();
-			++it)
+		for(const Registrar* scope : mActiveScopes)
 		{
-			if (!(*it)->empty()) return false;
+			if (!scope->empty()) return false;
 		}
 
 		return mDefaultRegistrar.empty();
diff --git a/indra/llcommon/llrun.cpp b/indra/llcommon/llrun.cpp
index f5d3f302fa..a3b3fccf4b 100644
--- a/indra/llcommon/llrun.cpp
+++ b/indra/llcommon/llrun.cpp
@@ -47,7 +47,7 @@ LLRunner::~LLRunner()
 	mRunEvery.clear();
 }
 
-S32 LLRunner::run()
+size_t LLRunner::run()
 {
 	// We collect all of the runnables which should be run. Since the
 	// runnables are allowed to adjust the run list, we need to copy
diff --git a/indra/llcommon/llrun.h b/indra/llcommon/llrun.h
index a117405366..d610f86234 100644
--- a/indra/llcommon/llrun.h
+++ b/indra/llcommon/llrun.h
@@ -85,7 +85,7 @@ public:
 	 *
 	 * @return Returns the number of runnables run.
 	 */
-	S32 run();
+	size_t run();
 
 	/** 
 	 * @brief Add a runnable to the run list.
diff --git a/indra/llcommon/llsd.cpp b/indra/llcommon/llsd.cpp
index 807b3d13f8..590915e9d2 100644
--- a/indra/llcommon/llsd.cpp
+++ b/indra/llcommon/llsd.cpp
@@ -36,6 +36,18 @@
 #include "llsdserialize.h"
 #include "stringize.h"
 
+#include <limits>
+
+// Defend against a caller forcibly passing a negative number into an unsigned
+// size_t index param
+inline
+bool was_negative(size_t i)
+{
+    return (i > std::numeric_limits<int>::max());
+}
+#define NEGATIVE_EXIT(i) if (was_negative(i)) return
+#define NEGATIVE_RETURN(i, result) NEGATIVE_EXIT(i) (result)
+
 #ifndef LL_RELEASE_FOR_DOWNLOAD
 #define NAME_UNNAMED_NAMESPACE
 #endif
@@ -136,10 +148,10 @@ public:
 	virtual void erase(const String&)			{ }
 	virtual const LLSD& ref(const String&) const{ return undef(); }
 	
-	virtual int size() const					{ return 0; }
-	virtual LLSD get(Integer) const				{ return LLSD(); }
-	virtual void erase(Integer)					{ }
-	virtual const LLSD& ref(Integer) const		{ return undef(); }
+	virtual size_t size() const					{ return 0; }
+	virtual LLSD get(size_t) const				{ return LLSD(); }
+	virtual void erase(size_t)					{ }
+	virtual const LLSD& ref(size_t) const		{ return undef(); }
 
 	virtual LLSD::map_const_iterator beginMap() const { return endMap(); }
 	virtual LLSD::map_const_iterator endMap() const { static const std::map<String, LLSD> empty; return empty.end(); }
@@ -272,7 +284,7 @@ namespace
 		virtual LLSD::UUID		asUUID() const	{ return LLUUID(mValue); }
 		virtual LLSD::Date		asDate() const	{ return LLDate(mValue); }
 		virtual LLSD::URI		asURI() const	{ return LLURI(mValue); }
-		virtual int				size() const	{ return mValue.size(); }
+		virtual size_t			size() const	{ return mValue.size(); }
 		virtual const LLSD::String&	asStringRef() const { return mValue; }
 	};
 	
@@ -377,9 +389,9 @@ namespace
 
 		virtual bool has(const LLSD::String&) 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)
+		using LLSD::Impl::get; // Unhiding get(size_t)
+		using LLSD::Impl::erase; // Unhiding erase(size_t)
+		using LLSD::Impl::ref; // Unhiding ref(size_t)
 		virtual LLSD get(const LLSD::String&) const; 
 		virtual LLSD getKeys() const; 
 		        void insert(const LLSD::String& k, const LLSD& v);
@@ -387,7 +399,7 @@ namespace
 		              LLSD& ref(const LLSD::String&);
 		virtual const LLSD& ref(const LLSD::String&) const;
 
-		virtual int size() const { return mData.size(); }
+		virtual size_t size() const { return mData.size(); }
 
 		LLSD::map_iterator beginMap() { return mData.begin(); }
 		LLSD::map_iterator endMap() { return mData.end(); }
@@ -518,14 +530,14 @@ namespace
 		using LLSD::Impl::get; // Unhiding get(LLSD::String)
 		using LLSD::Impl::erase; // Unhiding erase(LLSD::String)
 		using LLSD::Impl::ref; // Unhiding ref(LLSD::String)
-		virtual int size() const; 
-		virtual LLSD get(LLSD::Integer) const;
-		        void set(LLSD::Integer, const LLSD&);
-		        void insert(LLSD::Integer, const LLSD&);
+		virtual size_t size() const; 
+		virtual LLSD get(size_t) const;
+		        void set(size_t, const LLSD&);
+		        void insert(size_t, const LLSD&);
 		        LLSD& append(const LLSD&);
-		virtual void erase(LLSD::Integer);
-		              LLSD& ref(LLSD::Integer);
-		virtual const LLSD& ref(LLSD::Integer) const; 
+		virtual void erase(size_t);
+		              LLSD& ref(size_t);
+		virtual const LLSD& ref(size_t) const; 
 
 		LLSD::array_iterator beginArray() { return mData.begin(); }
 		LLSD::array_iterator endArray() { return mData.end(); }
@@ -550,85 +562,82 @@ namespace
 			return *this;
 		}
 	}
-	
-	int ImplArray::size() const		{ return mData.size(); }
-	
-	LLSD ImplArray::get(LLSD::Integer i) const
+
+	size_t ImplArray::size() const		{ return mData.size(); }
+
+	LLSD ImplArray::get(size_t i) const
 	{
-		if (i < 0) { return LLSD(); }
+		NEGATIVE_RETURN(i, LLSD());
 		DataVector::size_type index = i;
-		
+
 		return (index < mData.size()) ? mData[index] : LLSD();
 	}
-	
-	void ImplArray::set(LLSD::Integer i, const LLSD& v)
+
+	void ImplArray::set(size_t i, const LLSD& v)
 	{
-		if (i < 0) { return; }
+		NEGATIVE_EXIT(i);
 		DataVector::size_type index = i;
-		
+
 		if (index >= mData.size())
 		{
 			mData.resize(index + 1);
 		}
-		
+
 		mData[index] = v;
 	}
-	
-	void ImplArray::insert(LLSD::Integer i, const LLSD& v)
+
+	void ImplArray::insert(size_t i, const LLSD& v)
 	{
-		if (i < 0) 
-		{
-			return;
-		}
+		NEGATIVE_EXIT(i);
 		DataVector::size_type index = i;
-		
+
 		if (index >= mData.size())	// tbd - sanity check limit for index ?
 		{
 			mData.resize(index + 1);
 		}
-		
+
 		mData.insert(mData.begin() + index, v);
 	}
-	
+
 	LLSD& ImplArray::append(const LLSD& v)
 	{
 		mData.push_back(v);
 		return mData.back();
 	}
-	
-	void ImplArray::erase(LLSD::Integer i)
+
+	void ImplArray::erase(size_t i)
 	{
-		if (i < 0) { return; }
+		NEGATIVE_EXIT(i);
 		DataVector::size_type index = i;
-		
+
 		if (index < mData.size())
 		{
 			mData.erase(mData.begin() + index);
 		}
 	}
-	
-	LLSD& ImplArray::ref(LLSD::Integer i)
+
+	LLSD& ImplArray::ref(size_t i)
 	{
-		DataVector::size_type index = i >= 0 ? i : 0;
-		
+		DataVector::size_type index = was_negative(i)? 0 : i;
+
 		if (index >= mData.size())
 		{
-			mData.resize(i + 1);
+			mData.resize(index + 1);
 		}
-		
+
 		return mData[index];
 	}
 
-	const LLSD& ImplArray::ref(LLSD::Integer i) const
+	const LLSD& ImplArray::ref(size_t i) const
 	{
-		if (i < 0) { return undef(); }
+		NEGATIVE_RETURN(i, undef());
 		DataVector::size_type index = i;
-		
+
 		if (index >= mData.size())
 		{
 			return undef();
 		}
-		
+
 		return mData[index];
 	}
 
@@ -841,9 +850,6 @@ LLSD::LLSD(const Date& v) : impl(0)		{ ALLOC_LLSD_OBJECT;	assign(v); }
 LLSD::LLSD(const URI& v) : impl(0)		{ ALLOC_LLSD_OBJECT;	assign(v); }
 LLSD::LLSD(const Binary& v) : impl(0)	{ ALLOC_LLSD_OBJECT;	assign(v); }
 
-// Convenience Constructors
-LLSD::LLSD(F32 v) : impl(0)				{ ALLOC_LLSD_OBJECT;	assign((Real)v); }
-
 // Scalar Assignment
 void LLSD::assign(Boolean v)			{ safe(impl).assign(impl, v); }
 void LLSD::assign(Integer v)			{ safe(impl).assign(impl, v); }
@@ -912,7 +918,7 @@ LLSD LLSD::emptyArray()
 	return v;
 }
 
-int LLSD::size() const					{ return safe(impl).size(); }
+size_t LLSD::size() const				{ return safe(impl).size(); }
  
 LLSD LLSD::get(Integer i) const			{ return safe(impl).get(i); } 
 void LLSD::set(Integer i, const LLSD& v){ makeArray(impl).set(i, v); }
@@ -926,12 +932,12 @@ LLSD& LLSD::with(Integer i, const LLSD& v)
 LLSD& LLSD::append(const LLSD& v)		{ return makeArray(impl).append(v); }
 void LLSD::erase(Integer i)				{ makeArray(impl).erase(i); }
 
-LLSD& LLSD::operator[](Integer i)
+LLSD& LLSD::operator[](size_t i)
 { 
     LL_PROFILE_ZONE_SCOPED_CATEGORY_LLSD;
     return makeArray(impl).ref(i); 
 }
-const LLSD& LLSD::operator[](Integer i) const
+const LLSD& LLSD::operator[](size_t i) const
 { 
     LL_PROFILE_ZONE_SCOPED_CATEGORY_LLSD;
     return safe(impl).ref(i);
@@ -956,7 +962,7 @@ static const char *llsd_dump(const LLSD &llsd, bool useXMLFormat)
 			out << LLSDNotationStreamer(llsd);
 		out_string = out.str();
 	}
-	int len = out_string.length();
+	auto len = out_string.length();
 	sStorage = new char[len + 1];
 	memcpy(sStorage, out_string.c_str(), len);
 	sStorage[len] = '\0';
diff --git a/indra/llcommon/llsd.h b/indra/llcommon/llsd.h
index 3daaef44fc..cdb9a7ed8a 100644
--- a/indra/llcommon/llsd.h
+++ b/indra/llcommon/llsd.h
@@ -192,7 +192,17 @@ public:
 
 	/** @name Convenience Constructors */
 	//@{
-		LLSD(F32); // F32 -> Real
+		// support construction from size_t et al.
+		template <typename VALUE,
+				  typename std::enable_if<std::is_integral<VALUE>::value &&
+										  ! std::is_same<VALUE, Boolean>::value,
+										  bool>::type = true>
+		LLSD(VALUE v): LLSD(Integer(narrow(v))) {}
+		// support construction from F32 et al.
+		template <typename VALUE,
+				  typename std::enable_if<std::is_floating_point<VALUE>::value,
+										  bool>::type = true>
+		LLSD(VALUE v): LLSD(Real(narrow(v))) {}
 	//@}
 	
 	/** @name Scalar Assignment */
@@ -275,7 +285,7 @@ public:
 	//@{
 		LLSD(const char*);
 		void assign(const char*);
-		LLSD& operator=(const char* v)	{ assign(v); return *this; }
+		LLSD& operator=(const char* v) { assign(v); return *this; }
 	//@}
 	
 	/** @name Map Values */
@@ -313,14 +323,24 @@ public:
 		LLSD& append(const LLSD&);
 		void erase(Integer);
 		LLSD& with(Integer, const LLSD&);
-		
-		const LLSD& operator[](Integer) const;
-		LLSD& operator[](Integer);
+
+		// accept size_t so we can index relative to size()
+		const LLSD& operator[](size_t) const;
+		LLSD& operator[](size_t);
+		// template overloads to support int literals, U32 et al.
+		template <typename IDX,
+				  typename std::enable_if<std::is_convertible<IDX, size_t>::value,
+										  bool>::type = true>
+		const LLSD& operator[](IDX i) const { return (*this)[size_t(i)]; }
+		template <typename IDX,
+				  typename std::enable_if<std::is_convertible<IDX, size_t>::value,
+										  bool>::type = true>
+		LLSD& operator[](IDX i) { return (*this)[size_t(i)]; }
 	//@}
 
 	/** @name Iterators */
 	//@{
-		int size() const;
+		size_t size() const;
 
 		typedef std::map<String, LLSD>::iterator		map_iterator;
 		typedef std::map<String, LLSD>::const_iterator	map_const_iterator;
diff --git a/indra/llcommon/llsdparam.cpp b/indra/llcommon/llsdparam.cpp
index af4ccf25fd..30f49b27ea 100644
--- a/indra/llcommon/llsdparam.cpp
+++ b/indra/llcommon/llsdparam.cpp
@@ -113,11 +113,9 @@ void LLParamSDParser::writeSDImpl(LLSD& sd, const LLInitParam::BaseBlock& block,
 /*virtual*/ std::string LLParamSDParser::getCurrentElementName()
 {
 	std::string full_name = "sd";
-	for (name_stack_t::iterator it = mNameStack.begin();	
-		it != mNameStack.end();
-		++it)
+	for (name_stack_t::value_type& stack_pair : mNameStack)
 	{
-		full_name += llformat("[%s]", it->first.c_str());
+		full_name += llformat("[%s]", stack_pair.first.c_str());
 	}
 
 	return full_name;
diff --git a/indra/llcommon/llsdserialize.cpp b/indra/llcommon/llsdserialize.cpp
index a510b73096..b7e316da10 100644
--- a/indra/llcommon/llsdserialize.cpp
+++ b/indra/llcommon/llsdserialize.cpp
@@ -53,7 +53,7 @@
 #include "lluri.h"
 
 // File constants
-static const int MAX_HDR_LEN = 20;
+static const size_t MAX_HDR_LEN = 20;
 static const S32 UNZIP_LLSD_MAX_DEPTH = 96;
 static const char LEGACY_NON_HEADER[] = "<llsd>";
 const std::string LLSD_BINARY_HEADER("LLSD/Binary");
@@ -102,7 +102,7 @@ void LLSDSerialize::serialize(const LLSD& sd, std::ostream& str, ELLSD_Serialize
 }
 
 // static
-bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, S32 max_bytes)
+bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, llssize max_bytes)
 {
 	LLPointer<LLSDParser> p = NULL;
 	char hdr_buf[MAX_HDR_LEN + 1] = ""; /* Flawfinder: ignore */
@@ -255,7 +255,7 @@ F64 ll_ntohd(F64 netdouble)
  * @return Returns number of bytes read off of the stream. Returns
  * PARSE_FAILURE (-1) on failure.
  */
-int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes);
+llssize deserialize_string(std::istream& istr, std::string& value, llssize max_bytes);
 
 /**
  * @brief Parse a delimited string. 
@@ -266,7 +266,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes);
  * @return Returns number of bytes read off of the stream. Returns
  * PARSE_FAILURE (-1) on failure.
  */
-int deserialize_string_delim(std::istream& istr, std::string& value, char d);
+llssize deserialize_string_delim(std::istream& istr, std::string& value, char d);
 
 /**
  * @brief Read a raw string off the stream.
@@ -280,10 +280,10 @@ int deserialize_string_delim(std::istream& istr, std::string& value, char d);
  * @return Returns number of bytes read off of the stream. Returns
  * PARSE_FAILURE (-1) on failure.
  */
-int deserialize_string_raw(
+llssize deserialize_string_raw(
 	std::istream& istr,
 	std::string& value,
-	S32 max_bytes);
+	llssize max_bytes);
 
 /**
  * @brief helper method for dealing with the different notation boolean format.
@@ -295,7 +295,7 @@ int deserialize_string_raw(
  * @return Returns number of bytes read off of the stream. Returns
  * PARSE_FAILURE (-1) on failure.
  */
-int deserialize_boolean(
+llssize deserialize_boolean(
 	std::istream& istr,
 	LLSD& data,
 	const std::string& compare,
@@ -332,7 +332,7 @@ LLSDParser::LLSDParser()
 LLSDParser::~LLSDParser()
 { }
 
-S32 LLSDParser::parse(std::istream& istr, LLSD& data, S32 max_bytes, S32 max_depth)
+S32 LLSDParser::parse(std::istream& istr, LLSD& data, llssize max_bytes, S32 max_depth)
 {
 	mCheckLimits = (LLSDSerialize::SIZE_UNLIMITED == max_bytes) ? false : true;
 	mMaxBytesLeft = max_bytes;
@@ -362,7 +362,7 @@ std::istream& LLSDParser::get(
 	char delim) const
 {
 	istr.get(s, n, delim);
-	if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
+	if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
 	return istr;
 }
 
@@ -372,7 +372,7 @@ std::istream& LLSDParser::get(
 		char delim) const		
 {
 	istr.get(sb, delim);
-	if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
+	if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
 	return istr;
 }
 
@@ -396,11 +396,11 @@ std::istream& LLSDParser::read(
 	std::streamsize n) const
 {
 	istr.read(s, n);
-	if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
+	if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
 	return istr;
 }
 
-void LLSDParser::account(S32 bytes) const
+void LLSDParser::account(llssize bytes) const
 {
 	if(mCheckLimits) mMaxBytesLeft -= bytes;
 }
@@ -505,7 +505,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
 		c = istr.peek();
 		if(isalpha(c))
 		{
-			int cnt = deserialize_boolean(
+			auto cnt = deserialize_boolean(
 				istr,
 				data,
 				NOTATION_FALSE_SERIAL,
@@ -535,7 +535,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
 		c = istr.peek();
 		if(isalpha(c))
 		{
-			int cnt = deserialize_boolean(istr,data,NOTATION_TRUE_SERIAL,true);
+			auto cnt = deserialize_boolean(istr,data,NOTATION_TRUE_SERIAL,true);
 			if(PARSE_FAILURE == cnt) parse_count = cnt;
 			else account(cnt);
 		}
@@ -611,7 +611,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
 		c = get(istr); // pop the 'l'
 		c = get(istr); // pop the delimiter
 		std::string str;
-		int cnt = deserialize_string_delim(istr, str, c);
+		auto cnt = deserialize_string_delim(istr, str, c);
 		if(PARSE_FAILURE == cnt)
 		{
 			parse_count = PARSE_FAILURE;
@@ -634,7 +634,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
 		c = get(istr); // pop the 'd'
 		c = get(istr); // pop the delimiter
 		std::string str;
-		int cnt = deserialize_string_delim(istr, str, c);
+		auto cnt = deserialize_string_delim(istr, str, c);
 		if(PARSE_FAILURE == cnt)
 		{
 			parse_count = PARSE_FAILURE;
@@ -666,7 +666,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
 
 	default:
 		parse_count = PARSE_FAILURE;
-		LL_INFOS() << "Unrecognized character while parsing: int(" << (int)c
+		LL_INFOS() << "Unrecognized character while parsing: int(" << int(c)
 			<< ")" << LL_ENDL;
 		break;
 	}
@@ -697,7 +697,7 @@ S32 LLSDNotationParser::parseMap(std::istream& istr, LLSD& map, S32 max_depth) c
 				{
 					putback(istr, c);
 					found_name = true;
-					int count = deserialize_string(istr, name, mMaxBytesLeft);
+					auto count = deserialize_string(istr, name, mMaxBytesLeft);
 					if(PARSE_FAILURE == count) return PARSE_FAILURE;
 					account(count);
 				}
@@ -779,7 +779,7 @@ S32 LLSDNotationParser::parseArray(std::istream& istr, LLSD& array, S32 max_dept
 bool LLSDNotationParser::parseString(std::istream& istr, LLSD& data) const
 {
 	std::string value;
-	int count = deserialize_string(istr, value, mMaxBytesLeft);
+	auto count = deserialize_string(istr, value, mMaxBytesLeft);
 	if(PARSE_FAILURE == count) return false;
 	account(count);
 	data = value;
@@ -806,13 +806,13 @@ bool LLSDNotationParser::parseBinary(std::istream& istr, LLSD& data) const
 	{
 		// We probably have a valid raw binary stream. determine
 		// the size, and read it.
-		S32 len = strtol(buf + 2, NULL, 0);
+		auto len = strtol(buf + 2, NULL, 0);
 		if(mCheckLimits && (len > mMaxBytesLeft)) return false;
 		std::vector<U8> value;
 		if(len)
 		{
 			value.resize(len);
-			account((int)fullread(istr, (char *)&value[0], len));
+			account(fullread(istr, (char *)&value[0], len));
 		}
 		c = get(istr); // strip off the trailing double-quote
 		data = value;
@@ -1009,7 +1009,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
 	case '"':
 	{
 		std::string value;
-		int cnt = deserialize_string_delim(istr, value, c);
+		auto cnt = deserialize_string_delim(istr, value, c);
 		if(PARSE_FAILURE == cnt)
 		{
 			parse_count = PARSE_FAILURE;
@@ -1096,7 +1096,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
 			if(size > 0)
 			{
 				value.resize(size);
-				account((int)fullread(istr, (char*)&value[0], size));
+				account(fullread(istr, (char*)&value[0], size));
 			}
 			data = value;
 		}
@@ -1110,7 +1110,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
 
 	default:
 		parse_count = PARSE_FAILURE;
-		LL_INFOS() << "Unrecognized character while parsing: int(" << (int)c
+		LL_INFOS() << "Unrecognized character while parsing: int(" << int(c)
 			<< ")" << LL_ENDL;
 		break;
 	}
@@ -1144,7 +1144,7 @@ S32 LLSDBinaryParser::parseMap(std::istream& istr, LLSD& map, S32 max_depth) con
 		case '\'':
 		case '"':
 		{
-			int cnt = deserialize_string_delim(istr, name, c);
+			auto cnt = deserialize_string_delim(istr, name, c);
 			if(PARSE_FAILURE == cnt) return PARSE_FAILURE;
 			account(cnt);
 			break;
@@ -1228,7 +1228,7 @@ bool LLSDBinaryParser::parseString(
 	if(size)
 	{
 		buf.resize(size);
-		account((int)fullread(istr, &buf[0], size));
+		account(fullread(istr, &buf[0], size));
 		value.assign(buf.begin(), buf.end());
 	}
 	return true;
@@ -1432,7 +1432,7 @@ S32 LLSDNotationFormatter::format_impl(const LLSD& data, std::ostream& ostr,
 				ostr << std::uppercase;
 				auto oldfill(ostr.fill('0'));
 				auto oldwidth(ostr.width());
-				for (int i = 0; i < buffer.size(); i++)
+				for (size_t i = 0; i < buffer.size(); i++)
 				{
 					// have to restate setw() before every conversion
 					ostr << std::setw(2) << (int) buffer[i];
@@ -1595,7 +1595,7 @@ void LLSDBinaryFormatter::formatString(
 /**
  * local functions
  */
-int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
+llssize deserialize_string(std::istream& istr, std::string& value, llssize max_bytes)
 {
 	int c = istr.get();
 	if(istr.fail())
@@ -1605,7 +1605,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
 		return LLSDParser::PARSE_FAILURE;
 	}
 
-	int rv = LLSDParser::PARSE_FAILURE;
+	llssize rv = LLSDParser::PARSE_FAILURE;
 	switch(c)
 	{
 	case '\'':
@@ -1625,7 +1625,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
 	return rv + 1; // account for the character grabbed at the top.
 }
 
-int deserialize_string_delim(
+llssize deserialize_string_delim(
 	std::istream& istr,
 	std::string& value,
 	char delim)
@@ -1635,7 +1635,7 @@ int deserialize_string_delim(
 	bool found_hex = false;
 	bool found_digit = false;
 	U8 byte = 0;
-	int count = 0;
+	llssize count = 0;
 
 	while (true)
 	{
@@ -1650,7 +1650,7 @@ int deserialize_string_delim(
 		}
 
 		char next_char = (char)next_byte; // Now that we know it's not EOF
-		
+
 		if(found_escape)
 		{
 			// next character(s) is a special sequence.
@@ -1728,16 +1728,16 @@ int deserialize_string_delim(
 	return count;
 }
 
-int deserialize_string_raw(
+llssize deserialize_string_raw(
 	std::istream& istr,
 	std::string& value,
-	S32 max_bytes)
+	llssize max_bytes)
 {
-	int count = 0;
+	llssize count = 0;
 	const S32 BUF_LEN = 20;
 	char buf[BUF_LEN];		/* Flawfinder: ignore */
 	istr.get(buf, BUF_LEN - 1, ')');
-	count += (int)istr.gcount();
+	count += istr.gcount();
 	int c = istr.get();
 	c = istr.get();
 	count += 2;
@@ -1746,13 +1746,13 @@ int deserialize_string_raw(
 		// We probably have a valid raw string. determine
 		// the size, and read it.
 		// *FIX: This is memory inefficient.
-		S32 len = strtol(buf + 1, NULL, 0);
+		auto len = strtol(buf + 1, NULL, 0);
 		if((max_bytes>0)&&(len>max_bytes)) return LLSDParser::PARSE_FAILURE;
 		std::vector<char> buf;
 		if(len)
 		{
 			buf.resize(len);
-			count += (int)fullread(istr, (char *)&buf[0], len);
+			count += fullread(istr, (char *)&buf[0], len);
 			value.assign(buf.begin(), buf.end());
 		}
 		c = istr.get();
@@ -2041,7 +2041,7 @@ void serialize_string(const std::string& value, std::ostream& str)
 	}
 }
 
-int deserialize_boolean(
+llssize deserialize_boolean(
 	std::istream& istr,
 	LLSD& data,
 	const std::string& compare,
@@ -2058,7 +2058,7 @@ int deserialize_boolean(
 	//  * set data to LLSD::null
 	//  * return LLSDParser::PARSE_FAILURE (-1)
 	//
-	int bytes_read = 0;
+	llssize bytes_read = 0;
 	std::string::size_type ii = 0;
 	char c = istr.peek();
 	while((++ii < compare.size())
@@ -2113,7 +2113,7 @@ std::string zip_llsd(LLSD& data)
 
 	U8 out[CHUNK];
 
-	strm.avail_in = source.size();
+	strm.avail_in = narrow(source.size());
 	strm.next_in = (U8*) source.data();
 	U8* output = NULL;
 
@@ -2287,7 +2287,7 @@ LLUZipHelper::EZipRresult LLUZipHelper::unzip_llsd(LLSD& data, const U8* in, S32
 //This unzip function will only work with a gzip header and trailer - while the contents
 //of the actual compressed data is the same for either format (gzip vs zlib ), the headers
 //and trailers are different for the formats.
-U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize, std::istream& is, S32 size )
+U8* unzip_llsdNavMesh( bool& valid, size_t& outsize, std::istream& is, S32 size )
 {
 	if (size == 0)
 	{
diff --git a/indra/llcommon/llsdserialize.h b/indra/llcommon/llsdserialize.h
index d33d2b6f34..2f12c6d1ff 100644
--- a/indra/llcommon/llsdserialize.h
+++ b/indra/llcommon/llsdserialize.h
@@ -77,7 +77,7 @@ public:
 	 * @return Returns the number of LLSD objects parsed into
 	 * data. Returns PARSE_FAILURE (-1) on parse failure.
 	 */
-	S32 parse(std::istream& istr, LLSD& data, S32 max_bytes, S32 max_depth = -1);
+	S32 parse(std::istream& istr, LLSD& data, llssize max_bytes, S32 max_depth = -1);
 
 	/** Like parse(), but uses a different call (istream.getline()) to read by lines
 	 *  This API is better suited for XML, where the parse cannot tell
@@ -194,7 +194,7 @@ protected:
 	 * Conceptually const since it only modifies mutable members.
 	 * @param bytes The number of bytes read.
 	 */
-	void account(S32 bytes) const;
+	void account(llssize bytes) const;
 
 protected:
 	/**
@@ -205,7 +205,7 @@ protected:
 	/**
 	 * @brief The maximum number of bytes left to be parsed.
 	 */
-	mutable S32 mMaxBytesLeft;
+	mutable llssize mMaxBytesLeft;
 	
 	/**
 	 * @brief Use line-based reading to get text
@@ -336,7 +336,7 @@ private:
 	class Impl;
 	Impl& impl;
 
-	void parsePart(const char* buf, int len);
+	void parsePart(const char* buf, llssize len);
 	friend class LLSDSerialize;
 };
 
@@ -756,7 +756,7 @@ public:
 	 * @param max_bytes the maximum number of bytes to parse
 	 * @return Returns true if the stream appears to contain valid data
 	 */
-	static bool deserialize(LLSD& sd, std::istream& str, S32 max_bytes);
+	static bool deserialize(LLSD& sd, std::istream& str, llssize max_bytes);
 
 	/*
 	 * Notation Methods
@@ -778,12 +778,12 @@ public:
 						 LLSDFormatter::EFormatterOptions(LLSDFormatter::OPTIONS_PRETTY | 
 														  LLSDFormatter::OPTIONS_PRETTY_BINARY));
 	}
-	static S32 fromNotation(LLSD& sd, std::istream& str, S32 max_bytes)
+	static S32 fromNotation(LLSD& sd, std::istream& str, llssize max_bytes)
 	{
 		LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
 		return p->parse(str, sd, max_bytes);
 	}
-	static LLSD fromNotation(std::istream& str, S32 max_bytes)
+	static LLSD fromNotation(std::istream& str, llssize max_bytes)
 	{
 		LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
 		LLSD sd;
@@ -834,12 +834,12 @@ public:
 		LLPointer<LLSDBinaryFormatter> f = new LLSDBinaryFormatter;
 		return f->format(sd, str, LLSDFormatter::OPTIONS_NONE);
 	}
-	static S32 fromBinary(LLSD& sd, std::istream& str, S32 max_bytes, S32 max_depth = -1)
+	static S32 fromBinary(LLSD& sd, std::istream& str, llssize max_bytes, S32 max_depth = -1)
 	{
 		LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
 		return p->parse(str, sd, max_bytes, max_depth);
 	}
-	static LLSD fromBinary(std::istream& str, S32 max_bytes, S32 max_depth = -1)
+	static LLSD fromBinary(std::istream& str, llssize max_bytes, S32 max_depth = -1)
 	{
 		LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
 		LLSD sd;
@@ -870,7 +870,7 @@ public:
 LL_COMMON_API std::string zip_llsd(LLSD& data);
 
 
-LL_COMMON_API U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize,std::istream& is, S32 size);
+LL_COMMON_API U8* unzip_llsdNavMesh( bool& valid, size_t& outsize,std::istream& is, S32 size);
 
 // returns a pointer to the array or past the array if the deprecated header exists
 LL_COMMON_API char* strip_deprecated_header(char* in, U32& cur_size, U32* header_size = nullptr);
diff --git a/indra/llcommon/llsdserialize_xml.cpp b/indra/llcommon/llsdserialize_xml.cpp
index 0da824d694..ac128c9f86 100644
--- a/indra/llcommon/llsdserialize_xml.cpp
+++ b/indra/llcommon/llsdserialize_xml.cpp
@@ -196,12 +196,12 @@ S32 LLSDXMLFormatter::format_impl(const LLSD& data, std::ostream& ostr,
 			// *FIX: memory inefficient.
 			// *TODO: convert to use LLBase64
 			ostr << pre << "<binary encoding=\"base64\">";
-			int b64_buffer_length = apr_base64_encode_len(buffer.size());
+			int b64_buffer_length = apr_base64_encode_len(narrow(buffer.size()));
 			char* b64_buffer = new char[b64_buffer_length];
 			b64_buffer_length = apr_base64_encode_binary(
 				b64_buffer,
 				&buffer[0],
-				buffer.size());
+				narrow(buffer.size()));
 			ostr.write(b64_buffer, b64_buffer_length - 1);
 			delete[] b64_buffer;
 			ostr << "</binary>" << post;
@@ -260,7 +260,7 @@ public:
 	S32 parse(std::istream& input, LLSD& data);
 	S32 parseLines(std::istream& input, LLSD& data);
 
-	void parsePart(const char *buf, int len);
+	void parsePart(const char *buf, llssize len);
 	
 	void reset();
 
@@ -542,7 +542,7 @@ LLSDXMLParser::Impl::findAttribute(const XML_Char* name, const XML_Char** pairs)
 	return NULL;
 }
 
-void LLSDXMLParser::Impl::parsePart(const char* buf, int len)
+void LLSDXMLParser::Impl::parsePart(const char* buf, llssize len)
 {
 	if ( buf != NULL 
 		&& len > 0 )
@@ -915,7 +915,7 @@ LLSDXMLParser::~LLSDXMLParser()
 	delete &impl;
 }
 
-void LLSDXMLParser::parsePart(const char *buf, int len)
+void LLSDXMLParser::parsePart(const char *buf, llssize len)
 {
 	impl.parsePart(buf, len);
 }
diff --git a/indra/llcommon/llsdutil.cpp b/indra/llcommon/llsdutil.cpp
index 8e90d1e8b8..f70bee9903 100644
--- a/indra/llcommon/llsdutil.cpp
+++ b/indra/llcommon/llsdutil.cpp
@@ -148,10 +148,9 @@ LLSD ll_binary_from_string(const LLSD& sd)
 	std::vector<U8> binary_value;
 
 	std::string string_value = sd.asString();
-	for (std::string::iterator iter = string_value.begin();
-		 iter != string_value.end(); ++iter)
+	for (const U8 c : string_value)
 	{
-		binary_value.push_back(*iter);
+		binary_value.push_back(c);
 	}
 
 	binary_value.push_back('\0');
diff --git a/indra/llcommon/llstreamtools.cpp b/indra/llcommon/llstreamtools.cpp
index d7a6f47932..1ff15fcf89 100644
--- a/indra/llcommon/llstreamtools.cpp
+++ b/indra/llcommon/llstreamtools.cpp
@@ -118,7 +118,7 @@ bool skip_to_next_word(std::istream& input_stream)
 
 bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream)
 {
-	int key_length = strlen(keyword);	 /*Flawfinder: ignore*/
+	auto key_length = strlen(keyword);	 /*Flawfinder: ignore*/
 	if (0 == key_length)
 	{
 		return false;
@@ -315,7 +315,7 @@ bool unget_line(const std::string& line, std::istream& input_stream)
 // returns true if removed last char
 bool remove_last_char(char c, std::string& line)
 {
-	int line_size = line.size();
+	auto line_size = line.size();
 	if (line_size > 1
 		&& c == line[line_size - 1])
 	{
@@ -330,9 +330,8 @@ bool remove_last_char(char c, std::string& line)
 // "\\n" ---> '\n' (backslash n becomes carriage return)
 void unescape_string(std::string& line)
 {
-	int line_size = line.size();
-	int index = 0;
-	while (index < line_size - 1)
+	auto line_size = line.size();
+	for (size_t index = 0; line_size >= 1 && index < line_size - 1; ++index)
 	{
 		if ('\\' == line[index])
 		{
@@ -347,7 +346,6 @@ void unescape_string(std::string& line)
 				line_size--;
 			}
 		}
-		index++;
 	}
 }
 
@@ -356,9 +354,8 @@ void unescape_string(std::string& line)
 // '\n' ---> "\\n"  (carriage return becomes backslash n)
 void escape_string(std::string& line)
 {
-	int line_size = line.size();
-	int index = 0;
-	while (index < line_size)
+	auto line_size = line.size();
+	for (size_t index = 0; index < line_size; ++index)
 	{
 		if ('\\' == line[index])
 		{
@@ -372,31 +369,27 @@ void escape_string(std::string& line)
 			line_size++;
 			index++;
 		}
-		index++;
 	}
 }
 
 // removes '\n' characters
 void replace_newlines_with_whitespace(std::string& line)
 {
-	int line_size = line.size();
-	int index = 0;
-	while (index < line_size)
+	auto line_size = line.size();
+	for (size_t index = 0; index < line_size; ++index)
 	{
 		if ('\n' == line[index])
 		{
 			line.replace(index, 1, " ");
 		}
-		index++;
 	}
 }
 
 // erases any double-quote characters in 'line'
 void remove_double_quotes(std::string& line)
 {
-	int index = 0;
-	int line_size = line.size();
-	while (index < line_size)
+	auto line_size = line.size();
+	for (size_t index = 0; index < line_size; )
 	{
 		if ('"' == line[index])
 		{
@@ -424,22 +417,21 @@ void get_keyword_and_value(std::string& keyword,
 						   const std::string& line)
 {
 	// skip initial whitespace
-	int line_size = line.size();
-	int line_index = 0;
+	auto line_size = line.size();
+	size_t line_index = 0;
 	char c;
-	while (line_index < line_size)
+	for ( ; line_index < line_size; ++line_index)
 	{
 		c = line[line_index];
 		if (!LLStringOps::isSpace(c))
 		{
 			break;
 		}
-		line_index++;
 	}
 
 	// get the keyword
 	keyword.clear();
-	while (line_index < line_size)
+	for ( ; line_index < line_size; ++line_index)
 	{
 		c = line[line_index];
 		if (LLStringOps::isSpace(c) || '\r' == c || '\n' == c)
@@ -447,7 +439,6 @@ void get_keyword_and_value(std::string& keyword,
 			break;
 		}
 		keyword += c;
-		line_index++;
 	}
 
 	// get the value
@@ -465,7 +456,7 @@ void get_keyword_and_value(std::string& keyword,
 			line_index++;
 		}
 
-		while (line_index < line_size)
+		for ( ; line_index < line_size; ++line_index)
 		{
 			c = line[line_index];
 			if ('\r' == c || '\n' == c)
@@ -473,7 +464,6 @@ void get_keyword_and_value(std::string& keyword,
 				break;
 			}
 			value += c;
-			line_index++;
 		}
 	}
 }
diff --git a/indra/llcommon/llstring.cpp b/indra/llcommon/llstring.cpp
index 7f501f2e77..f6629803ee 100644
--- a/indra/llcommon/llstring.cpp
+++ b/indra/llcommon/llstring.cpp
@@ -141,7 +141,7 @@ std::string rawstr_to_utf8(const std::string& raw)
 	return wstring_to_utf8str(wstr);
 }
 
-S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
+std::ptrdiff_t wchar_to_utf8chars(llwchar in_char, char* outchars)
 {
 	U32 cur_char = (U32)in_char;
 	char* base = outchars;
@@ -192,7 +192,7 @@ S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
 	return outchars - base;
 }	
 
-S32 utf16chars_to_wchar(const U16* inchars, llwchar* outchar)
+auto utf16chars_to_wchar(const U16* inchars, llwchar* outchar)
 {
 	const U16* base = inchars;
 	U16 cur_char = *inchars++;
@@ -310,7 +310,7 @@ S32 wstring_utf16_length(const LLWString &wstr, const S32 woffset, const S32 wle
 // and whose equivalent utf-16 string does not exceeds the given utf16_length.
 S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, const S32 woffset, const S32 utf16_length, BOOL *unaligned)
 {
-	const S32 end = wstr.length();
+	const auto end = wstr.length();
 	BOOL u = FALSE;
 	S32 n = woffset + utf16_length;
 	S32 i = woffset;
@@ -426,7 +426,7 @@ LLWString utf8str_to_wstring(const char* utf8str, size_t len)
 			}
 
 			// Check that this character doesn't go past the end of the string
-			S32 end = (len < (i + cont_bytes)) ? len : (i + cont_bytes);
+			auto end = (len < (i + cont_bytes)) ? len : (i + cont_bytes);
 			do
 			{
 				++i;
@@ -471,7 +471,7 @@ std::string wstring_to_utf8str(const llwchar* utf32str, size_t len)
 	while (i < len)
 	{
 		char tchars[8];		/* Flawfinder: ignore */
-		S32 n = wchar_to_utf8chars(utf32str[i], tchars);
+		auto n = wchar_to_utf8chars(utf32str[i], tchars);
 		tchars[n] = 0;
 		out += tchars;
 		i++;
diff --git a/indra/llcommon/llstring.h b/indra/llcommon/llstring.h
index d94f549480..1fd6cac14a 100644
--- a/indra/llcommon/llstring.h
+++ b/indra/llcommon/llstring.h
@@ -664,7 +664,7 @@ ll_convert_forms(ll_convert_alias,     LLWString,     std::string,   utf8str_to_
 // Same function, better name. JC
 inline LLWString utf8string_to_wstring(const std::string& utf8_string) { return utf8str_to_wstring(utf8_string); }
 
-LL_COMMON_API S32 wchar_to_utf8chars(llwchar inchar, char* outchars);
+LL_COMMON_API std::ptrdiff_t wchar_to_utf8chars(llwchar inchar, char* outchars);
 
 ll_convert_forms(ll_convert_alias,     std::string, LLWString,     wstring_to_utf8str);
 ll_convert_forms(ll_convert_u16_alias, std::string, llutf16string, utf16str_to_utf8str);
diff --git a/indra/llcommon/llstringtable.cpp b/indra/llcommon/llstringtable.cpp
index f288999964..92a5e777a6 100644
--- a/indra/llcommon/llstringtable.cpp
+++ b/indra/llcommon/llstringtable.cpp
@@ -89,9 +89,8 @@ LLStringTable::~LLStringTable()
 		{
 			if (mStringList[i])
 			{
-				string_list_t::iterator iter;
-				for (iter = mStringList[i]->begin(); iter != mStringList[i]->end(); iter++)
-					delete *iter; // *iter = (LLStringTableEntry*)
+				for (LLStringTableEntry* entry : *mStringList[i])
+					delete entry;
 			}
 			delete mStringList[i];
 		}
@@ -156,9 +155,9 @@ LLStringTableEntry* LLStringTable::checkStringEntry(const char *str)
 	if (str)
 	{
 		char *ret_val;
-		LLStringTableEntry	*entry;
 		U32					hash_value = hash_my_string(str, mMaxEntries);
 #if STRING_TABLE_HASH_MAP
+		LLStringTableEntry	*entry;
 #if 1 // Microsoft
 		string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
 		string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
@@ -180,10 +179,8 @@ LLStringTableEntry* LLStringTable::checkStringEntry(const char *str)
 		string_list_t		*strlist = mStringList[hash_value];
 		if (strlist)
 		{
-			string_list_t::iterator iter;
-			for (iter = strlist->begin(); iter != strlist->end(); iter++)
+			for (LLStringTableEntry* entry : *strlist)
 			{
-				entry = *iter;
 				ret_val = entry->mString;
 				if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
 				{
@@ -226,9 +223,9 @@ LLStringTableEntry* LLStringTable::addStringEntry(const char *str)
 	if (str)
 	{
 		char *ret_val = NULL;
-		LLStringTableEntry	*entry;
 		U32					hash_value = hash_my_string(str, mMaxEntries);
 #if STRING_TABLE_HASH_MAP
+		LLStringTableEntry	*entry;
 #if 1 // Microsoft
 		string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
 		string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
@@ -257,10 +254,8 @@ LLStringTableEntry* LLStringTable::addStringEntry(const char *str)
 
 		if (strlist)
 		{
-			string_list_t::iterator iter;
-			for (iter = strlist->begin(); iter != strlist->end(); iter++)
+			for (LLStringTableEntry* entry : *strlist)
 			{
-				entry = *iter;
 				ret_val = entry->mString;
 				if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
 				{
@@ -294,10 +289,10 @@ void LLStringTable::removeString(const char *str)
 	if (str)
 	{
 		char *ret_val;
-		LLStringTableEntry	*entry;
 		U32					hash_value = hash_my_string(str, mMaxEntries);
 #if STRING_TABLE_HASH_MAP
 		{
+			LLStringTableEntry	*entry;
 #if 1 // Microsoft
 			string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
 			string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
@@ -331,10 +326,8 @@ void LLStringTable::removeString(const char *str)
 
 		if (strlist)
 		{
-			string_list_t::iterator iter;
-			for (iter = strlist->begin(); iter != strlist->end(); iter++)
+			for (LLStringTableEntry* entry : *strlist)
 			{
-				entry = *iter;
 				ret_val = entry->mString;
 				if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
 				{
diff --git a/indra/llcommon/llstringtable.h b/indra/llcommon/llstringtable.h
index ff09e71677..0a292c8bac 100644
--- a/indra/llcommon/llstringtable.h
+++ b/indra/llcommon/llstringtable.h
@@ -136,9 +136,9 @@ public:
 		for (S32 i = 0; i<mTableSize; i++)
 		{
 			string_set_t& stringset = mStringList[i];
-			for (string_set_t::iterator iter = stringset.begin(); iter != stringset.end(); iter++)
+			for (LLStdStringHandle str : stringset)
 			{
-				delete *iter;
+				delete str;
 			}
 			stringset.clear();
 		}
diff --git a/indra/llcommon/llsys.cpp b/indra/llcommon/llsys.cpp
index aeb8c530f4..938685bae6 100644
--- a/indra/llcommon/llsys.cpp
+++ b/indra/llcommon/llsys.cpp
@@ -273,7 +273,7 @@ LLOSInfo::LLOSInfo() :
 	{
 		const char * DARWIN_PRODUCT_NAME = "Mac OS X";
 		
-		S32 major_version, minor_version, bugfix_version = 0;
+		int64_t major_version, minor_version, bugfix_version = 0;
 
 		if (LLGetDarwinOSInfo(major_version, minor_version, bugfix_version))
 		{
@@ -454,14 +454,14 @@ LLOSInfo::LLOSInfo() :
 
 #ifndef LL_WINDOWS
 // static
-S32 LLOSInfo::getMaxOpenFiles()
+long LLOSInfo::getMaxOpenFiles()
 {
-	const S32 OPEN_MAX_GUESS = 256;
+	const long OPEN_MAX_GUESS = 256;
 
 #ifdef	OPEN_MAX
-	static S32 open_max = OPEN_MAX;
+	static long open_max = OPEN_MAX;
 #else
-	static S32 open_max = 0;
+	static long open_max = 0;
 #endif
 
 	if (0 == open_max)
@@ -917,7 +917,7 @@ void LLMemoryInfo::stream(std::ostream& s) const
 	// Now stream stats
 	BOOST_FOREACH(const MapEntry& pair, inMap(mStatsMap))
 	{
-		s << pfx << std::setw(key_width+1) << (pair.first + ':') << ' ';
+		s << pfx << std::setw(narrow(key_width+1)) << (pair.first + ':') << ' ';
 		LLSD value(pair.second);
 		if (value.isInteger())
 			s << std::setw(12) << value.asInteger();
@@ -1288,7 +1288,7 @@ public:
                     << " seconds ";
         }
 
-	S32 precision = LL_CONT.precision();
+	auto precision = LL_CONT.precision();
 
         LL_CONT << std::fixed << std::setprecision(1) << framerate << '\n'
                 << LLMemoryInfo();
diff --git a/indra/llcommon/llsys.h b/indra/llcommon/llsys.h
index 0f768938cb..08d4abffa2 100644
--- a/indra/llcommon/llsys.h
+++ b/indra/llcommon/llsys.h
@@ -59,7 +59,7 @@ public:
 	S32 mBuild;
 
 #ifndef LL_WINDOWS
-	static S32 getMaxOpenFiles();
+	static long getMaxOpenFiles();
 #endif
 	static bool is64Bit();
 
diff --git a/indra/llcommon/llsys_objc.h b/indra/llcommon/llsys_objc.h
index 35599a574b..b48ff97bdb 100644
--- a/indra/llcommon/llsys_objc.h
+++ b/indra/llcommon/llsys_objc.h
@@ -27,7 +27,11 @@
 #ifndef LL_LLSYS_OBJC_H
 #define LL_LLSYS_OBJC_H
 
-bool LLGetDarwinOSInfo(int &major, int &minor, int &patch);
+#include <cstdint>
+
+// C++ land doesn't define NSInteger, and we don't want to introduce that for
+// this one case, so use int64_t instead (which is equivalent).
+bool LLGetDarwinOSInfo(int64_t &major, int64_t &minor, int64_t &patch);
 
 
 #endif // LL_LLSYS_OBJC_H
diff --git a/indra/llcommon/llsys_objc.mm b/indra/llcommon/llsys_objc.mm
index cdb1e320d5..3fd85fb1c9 100644
--- a/indra/llcommon/llsys_objc.mm
+++ b/indra/llcommon/llsys_objc.mm
@@ -27,12 +27,12 @@
 #import "llsys_objc.h"
 #import <AppKit/AppKit.h>
 
-static int intAtStringIndex(NSArray *array, int index)
+static auto intAtStringIndex(NSArray *array, int index)
 {
     return [(NSString *)[array objectAtIndex:index] integerValue];
 }
 
-bool LLGetDarwinOSInfo(int &major, int &minor, int &patch)
+bool LLGetDarwinOSInfo(int64_t &major, int64_t &minor, int64_t &patch)
 {
     if (NSAppKitVersionNumber > NSAppKitVersionNumber10_8)
     {
diff --git a/indra/llcommon/llthreadsafequeue.h b/indra/llcommon/llthreadsafequeue.h
index 68d79cdd12..f396a71e6f 100644
--- a/indra/llcommon/llthreadsafequeue.h
+++ b/indra/llcommon/llthreadsafequeue.h
@@ -82,7 +82,7 @@ public:
 
 	// Limiting the number of pending items prevents unbounded growth of the
 	// underlying queue.
-	LLThreadSafeQueue(U32 capacity = 1024);
+	LLThreadSafeQueue(size_t capacity = 1024);
 	virtual ~LLThreadSafeQueue() {}
 
 	// Add an element to the queue (will block if the queue has reached
@@ -179,7 +179,7 @@ public:
 protected:
 	typedef QueueT queue_type;
 	QueueT mStorage;
-	U32 mCapacity;
+	size_t mCapacity;
 	bool mClosed;
 
 	boost::fibers::timed_mutex mLock;
@@ -262,7 +262,7 @@ namespace LL
 *   LLThreadSafeQueue implementation
 *****************************************************************************/
 template<typename ElementT, typename QueueT>
-LLThreadSafeQueue<ElementT, QueueT>::LLThreadSafeQueue(U32 capacity) :
+LLThreadSafeQueue<ElementT, QueueT>::LLThreadSafeQueue(size_t capacity) :
     mCapacity(capacity),
     mClosed(false)
 {
diff --git a/indra/llcommon/lltimer.cpp b/indra/llcommon/lltimer.cpp
index 24eaa4c1a9..1a99ac2886 100644
--- a/indra/llcommon/lltimer.cpp
+++ b/indra/llcommon/lltimer.cpp
@@ -162,9 +162,14 @@ U32 micro_sleep(U64 us, U32 max_yields)
     U64 start = get_clock_count();
     // This is kernel dependent.  Currently, our kernel generates software clock
     // interrupts at 250 Hz (every 4,000 microseconds).
-    const U64 KERNEL_SLEEP_INTERVAL_US = 4000;
-
-    S32 num_sleep_intervals = (us - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;
+    const S64 KERNEL_SLEEP_INTERVAL_US = 4000;
+
+    // Use signed arithmetic to discover whether a sleep is even necessary. If
+    // either 'us' or KERNEL_SLEEP_INTERVAL_US is unsigned, the compiler
+    // promotes the difference to unsigned. If 'us' is less than half
+    // KERNEL_SLEEP_INTERVAL_US, the unsigned difference will be hugely
+    // positive, resulting in a crazy long wait.
+    auto num_sleep_intervals = (S64(us) - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;
     if (num_sleep_intervals > 0)
     {
         U64 sleep_time = (num_sleep_intervals * KERNEL_SLEEP_INTERVAL_US) - (KERNEL_SLEEP_INTERVAL_US >> 1);
diff --git a/indra/llcommon/lltrace.cpp b/indra/llcommon/lltrace.cpp
index acdda5fe1e..ff671a8370 100644
--- a/indra/llcommon/lltrace.cpp
+++ b/indra/llcommon/lltrace.cpp
@@ -65,7 +65,7 @@ void TimeBlockTreeNode::setParent( BlockTimerStatHandle* parent )
 	llassert_always(parent != mBlock);
 	llassert_always(parent != NULL);
 
-	TimeBlockTreeNode* parent_tree_node = get_thread_recorder()->getTimeBlockTreeNode(parent->getIndex());
+	TimeBlockTreeNode* parent_tree_node = get_thread_recorder()->getTimeBlockTreeNode(narrow(parent->getIndex()));
 	if (!parent_tree_node) return;
 
 	if (mParent)
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index fcd8753f75..580cf0a5fd 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -340,7 +340,7 @@ inline void claim_alloc(MemStatHandle& measurement, const T& value)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 #if LL_TRACE_ENABLED
-	S32 size = MeasureMem<T>::measureFootprint(value);
+	auto size = MeasureMem<T>::measureFootprint(value);
 	if(size == 0) return;
 	MemAccumulator& accumulator = measurement.getCurrentAccumulator();
 	accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
@@ -353,7 +353,7 @@ inline void disclaim_alloc(MemStatHandle& measurement, const T& value)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 #if LL_TRACE_ENABLED
-	S32 size = MeasureMem<T>::measureFootprint(value);
+	auto size = MeasureMem<T>::measureFootprint(value);
 	if(size == 0) return;
 	MemAccumulator& accumulator = measurement.getCurrentAccumulator();
 	accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
diff --git a/indra/llcommon/lltraceaccumulators.cpp b/indra/llcommon/lltraceaccumulators.cpp
index fe447d5319..6bd886ae98 100644
--- a/indra/llcommon/lltraceaccumulators.cpp
+++ b/indra/llcommon/lltraceaccumulators.cpp
@@ -96,9 +96,9 @@ void AccumulatorBufferGroup::makeCurrent()
 	ThreadRecorder* thread_recorder = get_thread_recorder();
 	AccumulatorBuffer<TimeBlockAccumulator>& timer_accumulator_buffer = mStackTimers;
 	// update stacktimer parent pointers
-	for (S32 i = 0, end_i = mStackTimers.size(); i < end_i; i++)
+	for (size_t i = 0, end_i = mStackTimers.size(); i < end_i; i++)
 	{
-		TimeBlockTreeNode* tree_node = thread_recorder->getTimeBlockTreeNode(i);
+		TimeBlockTreeNode* tree_node = thread_recorder->getTimeBlockTreeNode(narrow(i));
 		if (tree_node)
 		{
 			timer_accumulator_buffer[i].mParent = tree_node->mParent;
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index 8cbb0db135..a8dcc5226a 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -606,7 +606,8 @@ void PeriodicRecording::nextPeriod()
 	mCurPeriod = (mCurPeriod + 1) % mRecordingPeriods.size();
 	old_recording.splitTo(getCurRecording());
 
-	mNumRecordedPeriods = llmin((S32)mRecordingPeriods.size() - 1, mNumRecordedPeriods + 1);
+	mNumRecordedPeriods = mRecordingPeriods.empty()? 0 :
+		llmin(mRecordingPeriods.size() - 1, mNumRecordedPeriods + 1);
 }
 
 void PeriodicRecording::appendRecording(Recording& recording)
@@ -625,21 +626,21 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
 	getCurRecording().update();
 	other.getCurRecording().update();
 	
-	const S32 other_recording_slots = other.mRecordingPeriods.size();
-	const S32 other_num_recordings = other.getNumRecordedPeriods();
-	const S32 other_current_recording_index = other.mCurPeriod;
-	const S32 other_oldest_recording_index = (other_current_recording_index + other_recording_slots - other_num_recordings) % other_recording_slots;
+	const auto other_recording_slots = other.mRecordingPeriods.size();
+	const auto other_num_recordings = other.getNumRecordedPeriods();
+	const auto other_current_recording_index = other.mCurPeriod;
+	const auto other_oldest_recording_index = (other_current_recording_index + other_recording_slots - other_num_recordings) % other_recording_slots;
 
 	// append first recording into our current slot
 	getCurRecording().appendRecording(other.mRecordingPeriods[other_oldest_recording_index]);
 
 	// from now on, add new recordings for everything after the first
-	S32 other_index = (other_oldest_recording_index + 1) % other_recording_slots;
+	auto other_index = (other_oldest_recording_index + 1) % other_recording_slots;
 
 	if (mAutoResize)
 	{
 		// push back recordings for everything in the middle
-		S32 other_index = (other_oldest_recording_index + 1) % other_recording_slots;
+		auto other_index = (other_oldest_recording_index + 1) % other_recording_slots;
 		while (other_index != other_current_recording_index)
 		{
 			mRecordingPeriods.push_back(other.mRecordingPeriods[other_index]);
@@ -652,8 +653,8 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
 			mRecordingPeriods.push_back(other.mRecordingPeriods[other_current_recording_index]);
 		}
 
-		mCurPeriod = mRecordingPeriods.size() - 1;
-		mNumRecordedPeriods = mRecordingPeriods.size() - 1;
+		mCurPeriod = mRecordingPeriods.empty()? 0 : mRecordingPeriods.size() - 1;
+		mNumRecordedPeriods = mCurPeriod;
 	}
 	else
 	{
@@ -682,7 +683,7 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
 		llassert(num_to_copy >= 1);
 		// advance to last recording period copied, and make that our current period
 		mCurPeriod = (mCurPeriod + num_to_copy - 1) % mRecordingPeriods.size();
-		mNumRecordedPeriods = llmin((S32)mRecordingPeriods.size() - 1, mNumRecordedPeriods + num_to_copy - 1);
+		mNumRecordedPeriods = llmin(mRecordingPeriods.size() - 1, mNumRecordedPeriods + num_to_copy - 1);
 	}
 
 	// end with fresh period, otherwise next appendPeriodicRecording() will merge the first
@@ -695,10 +696,10 @@ F64Seconds PeriodicRecording::getDuration() const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	F64Seconds duration;
-	S32 num_periods = mRecordingPeriods.size();
-	for (S32 i = 1; i <= num_periods; i++)
+	auto num_periods = mRecordingPeriods.size();
+	for (size_t i = 1; i <= num_periods; i++)
 	{
-		S32 index = (mCurPeriod + num_periods - i) % num_periods;
+		auto index = (mCurPeriod + num_periods - i) % num_periods;
 		duration += mRecordingPeriods[index].getDuration();
 	}
 	return duration;
@@ -734,16 +735,16 @@ const Recording& PeriodicRecording::getCurRecording() const
 	return mRecordingPeriods[mCurPeriod];
 }
 
-Recording& PeriodicRecording::getPrevRecording( S32 offset )
+Recording& PeriodicRecording::getPrevRecording( size_t offset )
 {
-	S32 num_periods = mRecordingPeriods.size();
+	auto num_periods = mRecordingPeriods.size();
 	offset = llclamp(offset, 0, num_periods - 1);
 	return mRecordingPeriods[(mCurPeriod + num_periods - offset) % num_periods];
 }
 
-const Recording& PeriodicRecording::getPrevRecording( S32 offset ) const
+const Recording& PeriodicRecording::getPrevRecording( size_t offset ) const
 {
-	S32 num_periods = mRecordingPeriods.size();
+	auto num_periods = mRecordingPeriods.size();
 	offset = llclamp(offset, 0, num_periods - 1);
 	return mRecordingPeriods[(mCurPeriod + num_periods - offset) % num_periods];
 }
@@ -772,11 +773,9 @@ void PeriodicRecording::handleReset()
 	}
 	else
 	{
-		for (std::vector<Recording>::iterator it = mRecordingPeriods.begin(), end_it = mRecordingPeriods.end();
-			it != end_it;
-			++it)
+		for (Recording& rec : mRecordingPeriods)
 		{
-			it->reset();
+			rec.reset();
 		}
 	}
 	mCurPeriod = 0;
@@ -790,7 +789,7 @@ void PeriodicRecording::handleSplitTo(PeriodicRecording& other)
 	getCurRecording().splitTo(other.getCurRecording());
 }
 
-F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -812,7 +811,7 @@ F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, S32
 			: NaN;
 }
 
-F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -835,7 +834,7 @@ F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, S32
 }
 
 // calculates means using aggregates per period
-F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -858,7 +857,7 @@ F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, S3
 			: NaN;
 }
 
-F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -883,7 +882,7 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulat
 			: NaN;
 }
 
-F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -905,7 +904,7 @@ F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, S3
 			: NaN;
 }
 
-F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/)
+F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -928,7 +927,7 @@ F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, S32
 }
 
 
-F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -951,7 +950,7 @@ F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, S
 			: NaN;
 }
 
-F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -977,7 +976,7 @@ F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat,
 	return F64((buf.size() % 2 == 0) ? (buf[buf.size() / 2 - 1] + buf[buf.size() / 2]) / 2 : buf[buf.size() / 2]);
 }
 
-F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -1003,7 +1002,7 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumula
 }
 
 
-F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -1018,12 +1017,12 @@ F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& st
 	return min_val;
 }
 
-F64Kilobytes PeriodicRecording::getPeriodMin(const MemStatHandle& stat, S32 num_periods)
+F64Kilobytes PeriodicRecording::getPeriodMin(const MemStatHandle& stat, size_t num_periods)
 {
 	return getPeriodMin(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
 }
 
-F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/)
+F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -1038,12 +1037,12 @@ F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& sta
 	return max_val;
 }
 
-F64Kilobytes PeriodicRecording::getPeriodMax(const MemStatHandle& stat, S32 num_periods)
+F64Kilobytes PeriodicRecording::getPeriodMax(const MemStatHandle& stat, size_t num_periods)
 {
 	return getPeriodMax(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
 }
 
-F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -1059,12 +1058,12 @@ F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& s
 	return mean / F64(num_periods);
 }
 
-F64Kilobytes PeriodicRecording::getPeriodMean(const MemStatHandle& stat, S32 num_periods)
+F64Kilobytes PeriodicRecording::getPeriodMean(const MemStatHandle& stat, size_t num_periods)
 {
 	return getPeriodMean(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
 }
 
-F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
+F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 	num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -1089,7 +1088,7 @@ F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAc
 			: NaN);
 }
 
-F64Kilobytes PeriodicRecording::getPeriodStandardDeviation(const MemStatHandle& stat, S32 num_periods)
+F64Kilobytes PeriodicRecording::getPeriodStandardDeviation(const MemStatHandle& stat, size_t num_periods)
 {
 	return getPeriodStandardDeviation(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
 }
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index 556b7470cf..8b56721f42 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -334,7 +334,7 @@ namespace LLTrace
 		~PeriodicRecording();
 
 		void nextPeriod();
-		S32 getNumRecordedPeriods() 
+		auto getNumRecordedPeriods() 
 		{ 
 			// current period counts if not active
 			return mNumRecordedPeriods + (isStarted() ? 0 : 1); 
@@ -348,24 +348,24 @@ namespace LLTrace
 		const Recording& getLastRecording() const;
 		Recording& getCurRecording();
 		const Recording& getCurRecording() const;
-		Recording& getPrevRecording(S32 offset);
-		const Recording& getPrevRecording(S32 offset) const;
+		Recording& getPrevRecording(size_t offset);
+		const Recording& getPrevRecording(size_t offset) const;
 		Recording snapshotCurRecording() const;
 
 		template <typename T>
-		S32 getSampleCount(const StatType<T>& stat, S32 num_periods = S32_MAX)
-        {
-            LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
+		auto getSampleCount(const StatType<T>& stat, size_t num_periods = S32_MAX)
+		{
+			LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			num_periods = llmin(num_periods, getNumRecordedPeriods());
 
-            S32 num_samples = 0;
-			for (S32 i = 1; i <= num_periods; i++)
+			size_t num_samples = 0;
+			for (size_t i = 1; i <= num_periods; i++)
 			{
 				Recording& recording = getPrevRecording(i);
 				num_samples += recording.getSampleCount(stat);
 			}
 			return num_samples;
-        }
+		}
         
 		//
 		// PERIODIC MIN
@@ -373,7 +373,7 @@ namespace LLTrace
 
 		// catch all for stats that have a defined sum
 		template <typename T>
-		typename T::value_t getPeriodMin(const StatType<T>& stat, S32 num_periods = S32_MAX)
+		typename T::value_t getPeriodMin(const StatType<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -396,33 +396,33 @@ namespace LLTrace
 		}
 
 		template<typename T>
-		T getPeriodMin(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		T getPeriodMin(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return T(getPeriodMin(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
 		}
 
-		F64 getPeriodMin(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
+		F64 getPeriodMin(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
 		template<typename T>
-		T getPeriodMin(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		T getPeriodMin(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return T(getPeriodMin(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
 		}
 
-		F64 getPeriodMin(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
+		F64 getPeriodMin(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
 		template<typename T>
-		T getPeriodMin(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		T getPeriodMin(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return T(getPeriodMin(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
 		}
 
-		F64Kilobytes getPeriodMin(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
-		F64Kilobytes getPeriodMin(const MemStatHandle& stat, S32 num_periods = S32_MAX);
+		F64Kilobytes getPeriodMin(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
+		F64Kilobytes getPeriodMin(const MemStatHandle& stat, size_t num_periods = S32_MAX);
 
 		template <typename T>
-		typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -437,7 +437,7 @@ namespace LLTrace
 		}
 
 		template<typename T>
-		typename RelatedTypes<T>::fractional_t getPeriodMinPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<T>::fractional_t getPeriodMinPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return typename RelatedTypes<T>::fractional_t(getPeriodMinPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
@@ -449,7 +449,7 @@ namespace LLTrace
 
 		// catch all for stats that have a defined sum
 		template <typename T>
-		typename T::value_t getPeriodMax(const StatType<T>& stat, S32 num_periods = S32_MAX)
+		typename T::value_t getPeriodMax(const StatType<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -472,33 +472,33 @@ namespace LLTrace
 		}
 
 		template<typename T>
-		T getPeriodMax(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		T getPeriodMax(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return T(getPeriodMax(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
 		}
 
-		F64 getPeriodMax(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
+		F64 getPeriodMax(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
 		template<typename T>
-		T getPeriodMax(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		T getPeriodMax(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return T(getPeriodMax(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
 		}
 
-		F64 getPeriodMax(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
+		F64 getPeriodMax(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
 		template<typename T>
-		T getPeriodMax(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		T getPeriodMax(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return T(getPeriodMax(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
 		}
 
-		F64Kilobytes getPeriodMax(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
-		F64Kilobytes getPeriodMax(const MemStatHandle& stat, S32 num_periods = S32_MAX);
+		F64Kilobytes getPeriodMax(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
+		F64Kilobytes getPeriodMax(const MemStatHandle& stat, size_t num_periods = S32_MAX);
 
 		template <typename T>
-		typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -513,7 +513,7 @@ namespace LLTrace
 		}
 
 		template<typename T>
-		typename RelatedTypes<T>::fractional_t getPeriodMaxPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<T>::fractional_t getPeriodMaxPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return typename RelatedTypes<T>::fractional_t(getPeriodMaxPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
@@ -525,7 +525,7 @@ namespace LLTrace
 
 		// catch all for stats that have a defined sum
 		template <typename T>
-		typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMean(const StatType<T >& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMean(const StatType<T >& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -546,32 +546,32 @@ namespace LLTrace
 		}
 
 		template<typename T>
-		typename RelatedTypes<T>::fractional_t getPeriodMean(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<T>::fractional_t getPeriodMean(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
 		}
-		F64 getPeriodMean(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
+		F64 getPeriodMean(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
 		template<typename T> 
-		typename RelatedTypes<T>::fractional_t getPeriodMean(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<T>::fractional_t getPeriodMean(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
 		}
 
-		F64 getPeriodMean(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
+		F64 getPeriodMean(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
 		template<typename T>
-		typename RelatedTypes<T>::fractional_t getPeriodMean(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<T>::fractional_t getPeriodMean(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
 		}
 
-		F64Kilobytes getPeriodMean(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
-		F64Kilobytes getPeriodMean(const MemStatHandle& stat, S32 num_periods = S32_MAX);
+		F64Kilobytes getPeriodMean(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
+		F64Kilobytes getPeriodMean(const MemStatHandle& stat, size_t num_periods = S32_MAX);
 		
 		template <typename T>
-		typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -593,16 +593,16 @@ namespace LLTrace
 		}
 
 		template<typename T>
-		typename RelatedTypes<T>::fractional_t getPeriodMeanPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<T>::fractional_t getPeriodMeanPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return typename RelatedTypes<T>::fractional_t(getPeriodMeanPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
 		}
 
-        F64 getPeriodMedian( const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
+        F64 getPeriodMedian( const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
 
         template <typename T>
-        typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMedianPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
+        typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMedianPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
         {
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
             num_periods = llmin(num_periods, getNumRecordedPeriods());
@@ -622,7 +622,7 @@ namespace LLTrace
         }
 
         template<typename T>
-        typename RelatedTypes<T>::fractional_t getPeriodMedianPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
+        typename RelatedTypes<T>::fractional_t getPeriodMedianPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
         {
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
             return typename RelatedTypes<T>::fractional_t(getPeriodMedianPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
@@ -632,25 +632,25 @@ namespace LLTrace
 		// PERIODIC STANDARD DEVIATION
 		//
 
-		F64 getPeriodStandardDeviation(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
+		F64 getPeriodStandardDeviation(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
 
 		template<typename T> 
-		typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
 		}
 
-		F64 getPeriodStandardDeviation(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
+		F64 getPeriodStandardDeviation(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
 		template<typename T>
-		typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
+		typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
 		{
             LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
 			return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
 		}
 
-		F64Kilobytes getPeriodStandardDeviation(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
-		F64Kilobytes getPeriodStandardDeviation(const MemStatHandle& stat, S32 num_periods = S32_MAX);
+		F64Kilobytes getPeriodStandardDeviation(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
+		F64Kilobytes getPeriodStandardDeviation(const MemStatHandle& stat, size_t num_periods = S32_MAX);
 
 	private:
 		// implementation for LLStopWatchControlsMixin
@@ -662,8 +662,8 @@ namespace LLTrace
 	private:
 		std::vector<Recording>	mRecordingPeriods;
 		const bool				mAutoResize;
-		S32						mCurPeriod;
-		S32						mNumRecordedPeriods;
+		size_t					mCurPeriod;
+		size_t					mNumRecordedPeriods;
 	};
 
 	PeriodicRecording& get_frame_recording();
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index 26db15eaa0..282c454a2a 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -125,7 +125,7 @@ ThreadRecorder::~ThreadRecorder()
 #endif
 }
 
-TimeBlockTreeNode* ThreadRecorder::getTimeBlockTreeNode( S32 index )
+TimeBlockTreeNode* ThreadRecorder::getTimeBlockTreeNode( size_t index )
 {
 #if LL_TRACE_ENABLED
 	if (0 <= index && index < mNumTimeBlockTreeNodes)
@@ -284,13 +284,11 @@ void ThreadRecorder::pullFromChildren()
 
 		AccumulatorBufferGroup& target_recording_buffers = mActiveRecordings.back()->mPartialRecording;
 		target_recording_buffers.sync();
-		for (child_thread_recorder_list_t::iterator it = mChildThreadRecorders.begin(), end_it = mChildThreadRecorders.end();
-			it != end_it;
-			++it)
-		{ LLMutexLock lock(&(*it)->mSharedRecordingMutex);
+		for (LLTrace::ThreadRecorder* rec : mChildThreadRecorders)
+		{ LLMutexLock lock(&(rec->mSharedRecordingMutex));
 
-			target_recording_buffers.merge((*it)->mSharedRecordingBuffers);
-			(*it)->mSharedRecordingBuffers.reset();
+			target_recording_buffers.merge(rec->mSharedRecordingBuffers);
+			rec->mSharedRecordingBuffers.reset();
 		}
 	}
 #endif
diff --git a/indra/llcommon/lltracethreadrecorder.h b/indra/llcommon/lltracethreadrecorder.h
index 8fd1e5ef58..8ee6729ac6 100644
--- a/indra/llcommon/lltracethreadrecorder.h
+++ b/indra/llcommon/lltracethreadrecorder.h
@@ -57,7 +57,7 @@ namespace LLTrace
 		void pullFromChildren();
 		void pushToParent();
 
-		TimeBlockTreeNode* getTimeBlockTreeNode(S32 index);
+		TimeBlockTreeNode* getTimeBlockTreeNode(size_t index);
 
 	protected:
 		void init();
diff --git a/indra/llcommon/lluri.cpp b/indra/llcommon/lluri.cpp
index 22711a83d2..4fb92a8f3e 100644
--- a/indra/llcommon/lluri.cpp
+++ b/indra/llcommon/lluri.cpp
@@ -663,9 +663,9 @@ LLSD LLURI::pathArray() const
 	tokenizer::iterator end = tokens.end();
 
 	LLSD params;
-	for ( ; it != end; ++it)
+	for (const std::string& str : tokens)
 	{
-		params.append(*it);
+		params.append(str);
 	}
 	return params;
 }
diff --git a/indra/llcommon/lluuid.cpp b/indra/llcommon/lluuid.cpp
index 3619a64ea9..7105c4502d 100644
--- a/indra/llcommon/lluuid.cpp
+++ b/indra/llcommon/lluuid.cpp
@@ -40,11 +40,12 @@
 #include "lluuid.h"
 #include "llerror.h"
 #include "llrand.h"
-#include "llmd5.h"
 #include "llstring.h"
 #include "lltimer.h"
 #include "llthread.h"
 #include "llmutex.h"
+#include "llmd5.h"
+#include "hbxxh.h"
 
 const LLUUID LLUUID::null;
 const LLTransactionID LLTransactionID::tnull;
@@ -400,6 +401,9 @@ LLUUID LLUUID::operator^(const LLUUID& rhs) const
     return id;
 }
 
+// WARNING: this algorithm SHALL NOT be changed. It is also used by the server
+// and plays a role in some assets validation (e.g. clothing items). Changing
+// it would cause invalid assets.
 void LLUUID::combine(const LLUUID& other, LLUUID& result) const
 {
     LLMD5 md5_uuid;
@@ -858,17 +862,12 @@ void LLUUID::generate()
     tmp >>= 8;
     mData[8] = (unsigned char)tmp;
 
-    LLMD5 md5_uuid;
-
-    md5_uuid.update(mData, 16);
-    md5_uuid.finalize();
-    md5_uuid.raw_digest(mData);
+    HBXXH128::digest(*this, (const void*)mData, 16);
 }
 
 void LLUUID::generate(const std::string& hash_string)
 {
-    LLMD5 md5_uuid((U8*)hash_string.c_str());
-    md5_uuid.raw_digest(mData);
+    HBXXH128::digest(*this, hash_string);
 }
 
 U32 LLUUID::getRandomSeed()
@@ -886,13 +885,8 @@ U32 LLUUID::getRandomSeed()
     seed[7] = (unsigned char)(pid);
     getSystemTime((uuid_time_t*)(&seed[8]));
 
-    LLMD5 md5_seed;
-
-    md5_seed.update(seed, 16);
-    md5_seed.finalize();
-    md5_seed.raw_digest(seed);
-
-    return(*(U32*)seed);
+   U64 seed64 = HBXXH64((const void*)seed, 16).digest();
+   return U32(seed64) ^ U32(seed64 >> 32);
 }
 
 BOOL LLUUID::parseUUID(const std::string& buf, LLUUID* value)
diff --git a/indra/llcommon/llworkerthread.cpp b/indra/llcommon/llworkerthread.cpp
index cd4d587752..06c74bdba0 100644
--- a/indra/llcommon/llworkerthread.cpp
+++ b/indra/llcommon/llworkerthread.cpp
@@ -69,12 +69,12 @@ void LLWorkerThread::clearDeleteList()
 				<< " entries in delete list." << LL_ENDL;
 
 		mDeleteMutex->lock();
-		for (delete_list_t::iterator iter = mDeleteList.begin(); iter != mDeleteList.end(); ++iter)
+		for (LLWorkerClass* worker : mDeleteList)
 		{
-			(*iter)->mRequestHandle = LLWorkerThread::nullHandle();
-			(*iter)->clearFlags(LLWorkerClass::WCF_HAVE_WORK);
-            (*iter)->clearFlags(LLWorkerClass::WCF_WORKING);
-			delete *iter ;
+			worker->mRequestHandle = LLWorkerThread::nullHandle();
+			worker->clearFlags(LLWorkerClass::WCF_HAVE_WORK);
+			worker->clearFlags(LLWorkerClass::WCF_WORKING);
+			delete worker;
 		}
 		mDeleteList.clear() ;
 		mDeleteMutex->unlock() ;
@@ -82,9 +82,9 @@ void LLWorkerThread::clearDeleteList()
 }
 
 // virtual
-S32 LLWorkerThread::update(F32 max_time_ms)
+size_t LLWorkerThread::update(F32 max_time_ms)
 {
-	S32 res = LLQueuedThread::update(max_time_ms);
+	auto res = LLQueuedThread::update(max_time_ms);
 	// Delete scheduled workers
 	std::vector<LLWorkerClass*> delete_list;
 	std::vector<LLWorkerClass*> abort_list;
@@ -110,15 +110,12 @@ S32 LLWorkerThread::update(F32 max_time_ms)
 	}
 	mDeleteMutex->unlock();	
 	// abort and delete after releasing mutex
-	for (std::vector<LLWorkerClass*>::iterator iter = abort_list.begin();
-		 iter != abort_list.end(); ++iter)
+	for (LLWorkerClass* worker : abort_list)
 	{
-		(*iter)->abortWork(false);
+		worker->abortWork(false);
 	}
-	for (std::vector<LLWorkerClass*>::iterator iter = delete_list.begin();
-		 iter != delete_list.end(); ++iter)
+	for (LLWorkerClass* worker : delete_list)
 	{
-		LLWorkerClass* worker = *iter;
 		if (worker->mRequestHandle)
 		{
 			// Finished but not completed
@@ -126,7 +123,7 @@ S32 LLWorkerThread::update(F32 max_time_ms)
 			worker->mRequestHandle = LLWorkerThread::nullHandle();
 			worker->clearFlags(LLWorkerClass::WCF_HAVE_WORK);
 		}
-		delete *iter;
+		delete worker;
 	}
 	// delete and aborted entries mean there's still work to do
 	res += delete_list.size() + abort_list.size();
diff --git a/indra/llcommon/llworkerthread.h b/indra/llcommon/llworkerthread.h
index 06bbb7369e..bf94c84090 100644
--- a/indra/llcommon/llworkerthread.h
+++ b/indra/llcommon/llworkerthread.h
@@ -88,7 +88,7 @@ public:
 	LLWorkerThread(const std::string& name, bool threaded = true, bool should_pause = false);
 	~LLWorkerThread();
 
-	/*virtual*/ S32 update(F32 max_time_ms);
+	/*virtual*/ size_t update(F32 max_time_ms);
 	
 	handle_t addWorkRequest(LLWorkerClass* workerclass, S32 param);
 	
diff --git a/indra/llcommon/stdtypes.h b/indra/llcommon/stdtypes.h
index b07805b628..da8512169c 100644
--- a/indra/llcommon/stdtypes.h
+++ b/indra/llcommon/stdtypes.h
@@ -26,16 +26,23 @@
 #ifndef LL_STDTYPES_H
 #define LL_STDTYPES_H
 
+#include <cassert>
 #include <cfloat>
 #include <climits>
+#include <limits>
+#include <type_traits>
 
-typedef signed char			S8;
+typedef signed char				S8;
 typedef unsigned char			U8;
 typedef signed short			S16;
 typedef unsigned short			U16;
-typedef signed int			S32;
+typedef signed int				S32;
 typedef unsigned int			U32;
 
+// to express an index that might go negative
+// (ssize_t is provided by SOME compilers, don't collide)
+typedef typename std::make_signed<size_t>::type llssize;
+
 #if LL_WINDOWS
 // https://docs.microsoft.com/en-us/cpp/build/reference/zc-wchar-t-wchar-t-is-native-type
 // https://docs.microsoft.com/en-us/cpp/cpp/fundamental-types-cpp
@@ -45,7 +52,7 @@ typedef unsigned int			U32;
 // The version of clang available with VS 2019 also defines wchar_t as __wchar_t
 // which is also 16 bits.
 // In any case, llwchar should be a UTF-32 type.
-typedef U32				llwchar;
+typedef U32					llwchar;
 #else
 typedef wchar_t				llwchar;
 // What we'd actually want is a simple module-scope 'if constexpr' to test
@@ -76,7 +83,7 @@ typedef double				F64;
 typedef S32				BOOL;
 typedef U8				KEY;
 typedef U32				MASK;
-typedef U32             		TPACKETID;
+typedef U32				TPACKETID;
 
 // Use #define instead of consts to avoid conversion headaches
 #define S8_MAX		(SCHAR_MAX)
@@ -118,4 +125,95 @@ typedef U8 LLPCode;
 typedef int intptr_t;
 #endif
 
+/*****************************************************************************
+*   Narrowing
+*****************************************************************************/
+/**
+ * narrow() is used to cast a wider type to a narrower type with validation.
+ *
+ * In many cases we take the size() of a container and try to pass it to an
+ * S32 or a U32 parameter. We used to be able to assume that the size of
+ * anything we could fit into memory could be expressed as a 32-bit int. With
+ * 64-bit viewers, though, size_t as returned by size() and length() and so
+ * forth is 64 bits, and the compiler is unhappy about stuffing such values
+ * into 32-bit types.
+ *
+ * It works to force the compiler to truncate, e.g. static_cast<S32>(len) or
+ * S32(len) or (S32)len, but we can do better.
+ *
+ * For:
+ * @code
+ * std::vector<Object> container;
+ * void somefunc(S32 size);
+ * @endcode
+ * call:
+ * @code
+ * somefunc(narrow(container.size()));
+ * @endcode
+ *
+ * narrow() truncates but, in RelWithDebInfo builds, it validates (using
+ * assert()) that the passed value can validly be expressed by the destination
+ * type.
+ */
+// narrow_holder is a struct that accepts the passed value as its original
+// type and provides templated conversion functions to other types. Once we're
+// building with compilers that support Class Template Argument Deduction, we
+// can rename this class template 'narrow' and eliminate the narrow() factory
+// function below.
+template <typename FROM>
+class narrow_holder
+{
+private:
+    FROM mValue;
+
+public:
+    narrow_holder(FROM value): mValue(value) {}
+
+    /*---------------------- Narrowing unsigned to signed ----------------------*/
+    template <typename TO,
+              typename std::enable_if<std::is_unsigned<FROM>::value &&
+                                      std::is_signed<TO>::value,
+                                      bool>::type = true>
+    inline
+    operator TO() const
+    {
+        // The reason we skip the
+        // assert(value >= std::numeric_limits<TO>::lowest());
+        // like the overload below is that to perform the above comparison,
+        // the compiler promotes the signed lowest() to the unsigned FROM
+        // type, making it hugely positive -- so a reasonable 'value' will
+        // always fail the assert().
+        assert(mValue <= std::numeric_limits<TO>::max());
+        return static_cast<TO>(mValue);
+    }
+
+    /*----------------------- Narrowing all other cases ------------------------*/
+    template <typename TO,
+              typename std::enable_if<! (std::is_unsigned<FROM>::value &&
+                                         std::is_signed<TO>::value),
+                                      bool>::type = true>
+    inline
+    operator TO() const
+    {
+        // two different assert()s so we can tell which condition failed
+        assert(mValue <= std::numeric_limits<TO>::max());
+        // Funny, with floating point types min() is "positive epsilon" rather
+        // than "largest negative" -- that's lowest().
+        assert(mValue >= std::numeric_limits<TO>::lowest());
+        // Do we really expect to use this with floating point types?
+        // If so, does it matter if a very small value truncates to zero?
+        //assert(fabs(mValue) >= std::numeric_limits<TO>::min());
+        return static_cast<TO>(mValue);
+    }
+};
+
+/// narrow() factory function returns a narrow_holder<FROM>(), which can be
+/// implicitly converted to the target type.
+template <typename FROM>
+inline
+narrow_holder<FROM> narrow(FROM value)
+{
+    return { value };
+}
+
 #endif
diff --git a/indra/llcommon/tests/lleventdispatcher_test.cpp b/indra/llcommon/tests/lleventdispatcher_test.cpp
index 991ec4819f..466f11f52a 100644
--- a/indra/llcommon/tests/lleventdispatcher_test.cpp
+++ b/indra/llcommon/tests/lleventdispatcher_test.cpp
@@ -335,7 +335,7 @@ namespace tut
         // Full, partial defaults arrays for params for freena(), freenb()
         LLSD dft_array_full, dft_array_partial;
         // Start index of partial defaults arrays
-        const LLSD::Integer partial_offset;
+        const size_t partial_offset;
         // Full, partial defaults maps for params for freena(), freenb()
         LLSD dft_map_full, dft_map_partial;
         // Most of the above are indexed by "a" or "b". Useful to have an
diff --git a/indra/llcommon/threadsafeschedule.h b/indra/llcommon/threadsafeschedule.h
index 0c3a541196..92bc7da940 100644
--- a/indra/llcommon/threadsafeschedule.h
+++ b/indra/llcommon/threadsafeschedule.h
@@ -82,7 +82,7 @@ namespace LL
         using TimePoint = ThreadSafeSchedulePrivate::TimePoint;
         using Clock = TimePoint::clock;
 
-        ThreadSafeSchedule(U32 capacity=1024):
+        ThreadSafeSchedule(size_t capacity=1024):
             super(capacity)
         {}