Fixed typos

40 files changed, 88 insertions, 88 deletions

diff --git a/src/binder/assemblybinder.cpp b/src/binder/assemblybinder.cpp
index 9863ae27a7..308e1229df 100644
--- a/src/binder/assemblybinder.cpp
+++ b/src/binder/assemblybinder.cpp
@@ -722,7 +722,7 @@ namespace BINDER_SPACE
             if (hr == S_FALSE)
             {
                 // Another bind interfered. We need to retry the entire bind.
-                // This by design loops as long as needed because by constuction we eventually
+                // This by design loops as long as needed because by construction we eventually
                 // will succeed or fail the bind.
                 bindResult.Reset();
                 goto Retry;
@@ -962,7 +962,7 @@ namespace BINDER_SPACE
             if (hr == S_FALSE)
             {
                 // Another bind interfered. We need to retry entire bind.
-                // This by design loops as long as needed because by constuction we eventually
+                // This by design loops as long as needed because by construction we eventually
                 // will succeed or fail the bind.
                 bindResult.Reset();
                 goto Retry;
@@ -2060,7 +2060,7 @@ Retry:
         if (hr == S_FALSE)
         {
             // Another bind interfered. We need to retry entire bind.
-            // This by design loops as long as needed because by constuction we eventually
+            // This by design loops as long as needed because by construction we eventually
             // will succeed or fail the bind.
             bindResult.Reset();
             goto Retry;
diff --git a/src/classlibnative/bcltype/number.cpp b/src/classlibnative/bcltype/number.cpp
index 6df0010699..75094f166e 100644
--- a/src/classlibnative/bcltype/number.cpp
+++ b/src/classlibnative/bcltype/number.cpp
@@ -2208,9 +2208,9 @@ ParseSection:
         }
         else {
             thousandsSepPos = (INT32 *)thousands.AllocThrows(bufferLen2 * sizeof(INT32));
-            // We need this array to figure out where to insert the thousands seperator. We would have to traverse the string
-            // backwords. PIC formatting always traverses forwards. These indices are precomputed to tell us where to insert
-            // the thousands seperator so we can get away with traversing forwards. Note we only have to compute upto digPos.
+            // We need this array to figure out where to insert the thousands separator. We would have to traverse the string
+            // backwards. PIC formatting always traverses forwards. These indices are precomputed to tell us where to insert
+            // the thousands separator so we can get away with traversing forwards. Note we only have to compute up to digPos.
             // The max is not bound since you can have formatting strings of the form "000,000..", and this
             // should handle that case too.
 
@@ -2251,14 +2251,14 @@ ParseSection:
 
     // Allocate temp buffer - gotta deal with Schertz' 500 MB strings.
     // Some computations like when you specify Int32.MaxValue-2 %'s and each percent is setup to be Int32.MaxValue in length
-    // will generate a result that will be larget than an unsigned int can hold. This is to protect against overflow.
+    // will generate a result that will be largest than an unsigned int can hold. This is to protect against overflow.
     UINT64 tempLen = str->GetStringLength() + maxStrIncLen + 10;  // Include a healthy amount of temp space.
     if (tempLen > 0x7FFFFFFF)
         COMPlusThrowOM(); // if we overflow
 
     unsigned int bufferLen = (UINT)tempLen;
     if (bufferLen < 250) // Stay under 512 bytes
-        bufferLen = 250; // This is to prevent unneccessary calls to resize
+        bufferLen = 250; // This is to prevent unnecessary calls to resize
     buffer = (wchar *) buf.AllocThrows(bufferLen* sizeof(WCHAR));
     dst = buffer;
 
@@ -2326,7 +2326,7 @@ ParseSection:
         case '.':
             {
                 if (digPos != 0 || decimalWritten) {
-                    // For compatability, don't echo repeated decimals
+                    // For compatibility, don't echo repeated decimals
                     break;
                 }
                 // If the format has trailing zeros or the format has a decimal and digits remain
diff --git a/src/classlibnative/cryptography/cryptography.cpp b/src/classlibnative/cryptography/cryptography.cpp
index cacea14812..95d46ea33a 100644
--- a/src/classlibnative/cryptography/cryptography.cpp
+++ b/src/classlibnative/cryptography/cryptography.cpp
@@ -2247,7 +2247,7 @@ FCIMPLEND
 #endif
 
 //
-// We implicitely assume these methods are not going to do a LoadLibrary
+// We implicitly assume these methods are not going to do a LoadLibrary
 //
 
 
diff --git a/src/classlibnative/nls/nlsinfo.cpp b/src/classlibnative/nls/nlsinfo.cpp
index 5b457840bd..d2a4f02a7f 100644
--- a/src/classlibnative/nls/nlsinfo.cpp
+++ b/src/classlibnative/nls/nlsinfo.cpp
@@ -2600,7 +2600,7 @@ INT32 QCALLTYPE COMNlsInfo::InternalCompareStringOrdinalIgnoreCase(
 
 /**
  * This function returns a pointer to this table that we use in System.Globalization.EncodingTable.
- * No error checking of any sort is performed.  Range checking is entirely the responsiblity of the managed
+ * No error checking of any sort is performed.  Range checking is entirely the responsibility of the managed
  * code.
  */
 FCIMPL0(EncodingDataItem *, COMNlsInfo::nativeGetEncodingTableDataPointer)
@@ -2614,7 +2614,7 @@ FCIMPLEND
 
 /**
  * This function returns a pointer to this table that we use in System.Globalization.EncodingTable.
- * No error checking of any sort is performed.  Range checking is entirely the responsiblity of the managed
+ * No error checking of any sort is performed.  Range checking is entirely the responsibility of the managed
  * code.
  */
 FCIMPL0(CodePageDataItem *, COMNlsInfo::nativeGetCodePageTableDataPointer)
diff --git a/src/coreclr/applydefines.pl b/src/coreclr/applydefines.pl
index 566cfd3f5b..b4d1ca4d01 100644
--- a/src/coreclr/applydefines.pl
+++ b/src/coreclr/applydefines.pl
@@ -55,7 +55,7 @@ while (@ARGV)
     }
     else
     {
-        print "Unknonw argument '$nextArg'\n";
+        print "Unknown argument '$nextArg'\n";
         Usage();
     }
 }
@@ -110,7 +110,7 @@ sub Usage()
 {
     print "Usage: applydefines [options]\n";
     print "\t-s <file>\t: the source file to process\n";
-    print "\t-f <file>\t: the file contatining #define setings\n";
+    print "\t-f <file>\t: the file containing #define settings\n";
     print "\t-o <file>\t: the output file\n";
     print "\t-d <name>=<Value>\t: additional define\n";
     
diff --git a/src/coreclr/hosts/coreconsole/coreconsole.cpp b/src/coreclr/hosts/coreconsole/coreconsole.cpp
index 03ab5e54fa..0b6a912c5f 100644
--- a/src/coreclr/hosts/coreconsole/coreconsole.cpp
+++ b/src/coreclr/hosts/coreconsole/coreconsole.cpp
@@ -438,7 +438,7 @@ bool TryRun(const int argc, const wchar_t* argv[], Logger &log, const bool verbo
     //  CORECLR_HOST_AUTHENTICATION_KEY_NONGEN  
     hr = host->Authenticate(CORECLR_HOST_AUTHENTICATION_KEY); 
     if (FAILED(hr)) {
-        log << W("Failed autenticate. ") << hr << Logger::endl;
+        log << W("Failed authenticate. ") << hr << Logger::endl;
         return false;
     }
 
diff --git a/src/coreclr/hosts/corerun/corerun.cpp b/src/coreclr/hosts/corerun/corerun.cpp
index c96070edc9..42f2773b41 100644
--- a/src/coreclr/hosts/corerun/corerun.cpp
+++ b/src/coreclr/hosts/corerun/corerun.cpp
@@ -480,7 +480,7 @@ bool TryRun(const int argc, const wchar_t* argv[], Logger &log, const bool verbo
     //  CORECLR_HOST_AUTHENTICATION_KEY_NONGEN  
     hr = host->Authenticate(CORECLR_HOST_AUTHENTICATION_KEY); 
     if (FAILED(hr)) {
-        log << W("Failed autenticate. ") << hr << Logger::endl;
+        log << W("Failed authenticate. ") << hr << Logger::endl;
         return false;
     }
 
diff --git a/src/debug/daccess/daccess.cpp b/src/debug/daccess/daccess.cpp
index 3bc08d3d9b..9af15c6031 100644
--- a/src/debug/daccess/daccess.cpp
+++ b/src/debug/daccess/daccess.cpp
@@ -3119,9 +3119,9 @@ ClrDataAccess::ClrDataAccess(ICorDebugDataTarget * pTarget, ICLRDataTarget * pLe
     }
 
     /* 
-     * If we have a legacy target, it means we're providing compatability for code that used
+     * If we have a legacy target, it means we're providing compatibility for code that used
      * the old ICLRDataTarget interfaces.  There are still a few things (like metadata location,
-     * GetImageBase, and VirtualAlloc) that the implementation may use which we haven't superceded 
+     * GetImageBase, and VirtualAlloc) that the implementation may use which we haven't superseded
      * in ICorDebugDataTarget, so we still need access to the old target interfaces.
      * Any functionality that does exist in ICorDebugDataTarget is accessed from that interface
      * using the DataTargetAdapter on top of the legacy interface (to unify the calling code).
@@ -6926,7 +6926,7 @@ void ClrDataAccess::SetTargetConsistencyChecks(bool fEnableAsserts)
 //     The implementation of ASSERT accesses this via code:DacTargetConsistencyAssertsEnabled
 //     
 //     By default, this is disabled, unless COMPLUS_DbgDACEnableAssert is set (see code:ClrDataAccess::ClrDataAccess).
-//     This is necessary for compatability.  For example, SOS expects to be able to scan for
+//     This is necessary for compatibility.  For example, SOS expects to be able to scan for
 //     valid MethodTables etc. (which may cause ASSERTs), and also doesn't want ASSERTs when working
 //     with targets with corrupted memory.
 //     
diff --git a/src/debug/daccess/dacfn.cpp b/src/debug/daccess/dacfn.cpp
index 485c9e7ba8..1ad5b20ab0 100644
--- a/src/debug/daccess/dacfn.cpp
+++ b/src/debug/daccess/dacfn.cpp
@@ -1258,7 +1258,7 @@ DacGetIlMethod(TADDR methAddr)
     ULONG32 methodSize = static_cast<ULONG32>(PEDecoder::ComputeILMethodSize(methAddr));
 
     // Sometimes when reading from dumps and inspect NGEN images, but we end up reading metadata from IL image
-    // the method RVA could not match and we could read from a random address that will translate in inconsistend
+    // the method RVA could not match and we could read from a random address that will translate in inconsistent
     // IL code header. If we see the size of the code bigger than 64 Megs we are probably reading a bad IL code header.
     // For details see issue DevDiv 273199.
     if (methodSize > 0x4000000)
diff --git a/src/debug/di/process.cpp b/src/debug/di/process.cpp
index cc3ba62958..4bb0013c65 100644
--- a/src/debug/di/process.cpp
+++ b/src/debug/di/process.cpp
@@ -4487,7 +4487,7 @@ protected:
 //    Eg., if we used std::map, we could have efficient lookups and ordered 
 //    enumerations.  However, we do need to be careful about exposing new invariants
 //    through ICorDebug that customers may depend on, which could place a long-term
-//    compatability burden on us.  We could have a simple generic data structure 
+//    compatibility burden on us.  We could have a simple generic data structure
 //    (eg. built on std::hash_map and std::list) which provided efficient look-up
 //    and both in-order and random enumeration.
 //    
diff --git a/src/debug/di/rsappdomain.cpp b/src/debug/di/rsappdomain.cpp
index 29486d522b..ecd6c6dabf 100644
--- a/src/debug/di/rsappdomain.cpp
+++ b/src/debug/di/rsappdomain.cpp
@@ -656,7 +656,7 @@ HRESULT CordbAppDomain::EnumerateSteppers(ICorDebugStepperEnum **ppSteppers)
 //    Prior to V3, we used to keep track of a per-appdomain attached status.
 //    Debuggers were required to explicitly attach to every AppDomain, so this
 //    did not provide any actual functionality.  In V3, there is no longer any
-//    concept of per-AppDomain attach/detach.  This API is provided for compatability.
+//    concept of per-AppDomain attach/detach.  This API is provided for compatibility.
 //
 
 HRESULT CordbAppDomain::IsAttached(BOOL *pfAttached)
@@ -685,7 +685,7 @@ HRESULT CordbAppDomain::IsAttached(BOOL *pfAttached)
 //    Prior to V3, we used to keep track of a per-appdomain attached status.
 //    Debuggers were required to explicitly attach to every AppDomain, so this
 //    did not provide any actual functionality.  In V3, there is no longer any
-//    concept of per-AppDomain attach/detach.  This API is provided for compatability.
+//    concept of per-AppDomain attach/detach.  This API is provided for compatibility.
 //
 
 HRESULT CordbAppDomain::Attach()
diff --git a/src/debug/di/rsassembly.cpp b/src/debug/di/rsassembly.cpp
index 2fb53b8f5a..508e1f31e2 100644
--- a/src/debug/di/rsassembly.cpp
+++ b/src/debug/di/rsassembly.cpp
@@ -228,7 +228,7 @@ HRESULT CordbAssembly::GetCodeBase(ULONG32 cchName,
 //   not happen unless the target is corrupt.
 //
 // Notes:
-//   In-memory assemblies do not have a filename.  In that case, for compatability
+//   In-memory assemblies do not have a filename.  In that case, for compatibility
 //   this returns success and the string "<unknown>".  We may want to change this
 //   behavior in the future.
 //
diff --git a/src/debug/di/rsfunction.cpp b/src/debug/di/rsfunction.cpp
index 6d3abbf107..3d282b208f 100644
--- a/src/debug/di/rsfunction.cpp
+++ b/src/debug/di/rsfunction.cpp
@@ -668,7 +668,7 @@ HRESULT CordbFunction::GetILCodeAndSigToken()
 
                 // In the dump case we may not have the backing memory for this. In such a case
                 // we construct an empty ILCode object and leave the signatureToken as mdSignatureNil.
-                // It may also be the case that the memory we read from the dump be inconsistend (huge method size)
+                // It may also be the case that the memory we read from the dump be inconsistent (huge method size)
                 // and we also fallback on creating an empty ILCode object.
                 // See issue DD 273199 for cases where IL and NGEN metadata mismatch (different RVAs).
                 ALLOW_DATATARGET_MISSING_OR_INCONSISTENT_MEMORY(
diff --git a/src/debug/di/rspriv.h b/src/debug/di/rspriv.h
index fbe8798021..c9f1bbca6d 100644
--- a/src/debug/di/rspriv.h
+++ b/src/debug/di/rspriv.h
@@ -1282,35 +1282,35 @@ public:
         Member function behavior of a neutered COM object:
 
              1. AddRef(), Release(), QueryInterface() work as normal.
-                 a. This gives folks who are responsable for pairing a Release() with
-                    an AddRef() a chance to dereferance thier pointer and call Release()
+                 a. This gives folks who are responsible for pairing a Release() with
+                    an AddRef() a chance to dereference their pointer and call Release()
                     when they are informed, explicitly or implicitly, that the object is neutered.
 
              2. Any other member function will return an error code unless documented.
-                 a. If a member fuction returns information when the COM object is
+                 a. If a member function returns information when the COM object is
                     neutered then the semantics of that function need to be documented.
-                    (ie. If an AppDomain is unloaded and you have a referance to the COM
+                    (ie. If an AppDomain is unloaded and you have a reference to the COM
                     object representing the AppDomain, how _should_ it behave? That behavior
                     should be documented)
 
 
         Postcondions of Neuter():
 
-             1. All circular referances (aka back-pointers) are "broken". They are broken
-                by calling Release() on all "Weak Referances" to the object. If you're a purist,
+             1. All circular references (aka back-pointers) are "broken". They are broken
+                by calling Release() on all "Weak References" to the object. If you're a purist,
                 these pointers should also be NULLed out.
-                 a. Weak Referances/Strong Referances:
+                 a. Weak References/Strong References:
                      i. If any objects are not "reachable" from the root (ie. stack or from global pointers)
                          they should be reclaimed. If they are not, they are leaked and there is an issue.
                      ii. There must be a partial order on the objects such that if A < B then:
-                         1. A has a referance to B. This referance is a "strong referance"
+                         1. A has a reference to B. This reference is a "strong reference"
                          2. A, and thus B, is reachable from the root
-                     iii. If a referance belongs in the partial order then it is a "strong referance" else
-                         it is a weak referance.
+                     iii. If a reference belongs in the partial order then it is a "strong reference" else
+                         it is a weak reference.
          *** 2. Sufficient conditions to ensure no COM objects are leaked: ***
                 a. When Neuter() is invoked:
-                     i. Calles Release on all its weak referances.
-                     ii. Then, for each strong referance:
+                     i. Calles Release on all its weak references.
+                     ii. Then, for each strong reference:
                          1. invoke Neuter()
                          2. invoke Release()
                      iii. If it's derived from a CordbXXX class, call Neuter() on the base class.
@@ -1319,7 +1319,7 @@ public:
                  a. Members of IUknown, AddRef(), Release(), QueryInterfac()
                  b. Those documented to have functionality when the object is neutered.
                      i. Neuter() still works w/o error. If it is invoke a second time it will have already
-                        released all its strong and weak referances so it could just return.
+                        released all its strong and weak references so it could just return.
 
 
         Alternate design ideas:
@@ -1330,7 +1330,7 @@ public:
                          Which one should call Release()? For now we have CordbFunction call Release() on CordbCode.
 
              DESIGN: It is not a necessary condition in that Neuter() invoke Release() on all
-                     it's strong referances. Instead, it would be sufficent to ensure all object are released, that
+                     it's strong references. Instead, it would be sufficient to ensure all object are released, that
                      each object call Release() on all its strong pointers in its destructor.
                       1. This might be done if its necessary for some member to return "tombstone"
                          information after the object has been netuered() which involves the siblings (wrt poset)
@@ -1345,18 +1345,18 @@ public:
                              1. Assert that it's done after NeuterStrongPointers()
                      2. That would introduce a bunch of functions... but it would be clear.
 
-             DESIGN: CordbBase could provide a function to register strong and weak referances. That way CordbBase
+             DESIGN: CordbBase could provide a function to register strong and weak references. That way CordbBase
                      could implement a general version of ReleaseWeak/ReleaseStrong/NeuterStrongPointers(). This
                      would provide a very error resistant framework for extending the object model plus it would
                      be very explicit about what is going on.
                          One thing that might trip this is idea up is that if an object has two parents,
-                         like the CordbCode might, then either both objects call Neuter or one is referance
+                         like the CordbCode might, then either both objects call Neuter or one is reference
                          is made weak.
 
 
         Our implementation:
 
-           The graph fromed by the strong referances must remain acyclic.
+           The graph formed by the strong references must remain acyclic.
            It's up to the developer (YOU!) to ensure that each Neuter
            function maintains that invariant.
 
@@ -1371,7 +1371,7 @@ public:
                       CordbModule
                           CordbClass
                           CordbFunction
-                              CordbCode (Can we assert a thread will not referance
+                              CordbCode (Can we assert a thread will not reference
                                           the same CordbCode as a CordbFunction?)
                  CordbThread
                      CordbChains
@@ -1381,7 +1381,7 @@ public:
 
             <TODO>TODO: Some Neuter functions have not yet been implemented due to time restrictions.</TODO>
 
-            <TODO>TODO: Some weak referances never have AddRef() called on them. If that's cool then
+            <TODO>TODO: Some weak references never have AddRef() called on them. If that's cool then
                   it should be stated in the documentation. Else it should be changed.</TODO>
 */
 
@@ -1572,7 +1572,7 @@ _____Neuter_Status_Already_Marked = 0; \
 //    - this also means we absolutely can't send IPC events (since that requires a CordbProcess)
 // 3) The only safe data are blittalbe embedded fields (eg, a pid or stack range) 
 //
-// Any usage of this macro should clearly specificy why this is safe.
+// Any usage of this macro should clearly specify why this is safe.
 #define OK_IF_NEUTERED(pThis) \
 int _____Neuter_Status_Already_Marked; \
 _____Neuter_Status_Already_Marked = 0;
diff --git a/src/debug/di/rsthread.cpp b/src/debug/di/rsthread.cpp
index 8966b7675b..82103699cf 100644
--- a/src/debug/di/rsthread.cpp
+++ b/src/debug/di/rsthread.cpp
@@ -1309,7 +1309,7 @@ void CordbThread::CleanupStack()
     // Neuter outstanding CordbChainEnums, CordbFrameEnums, some CordbTypeEnums, and some CordbValueEnums.
     m_RefreshStackNeuterList.NeuterAndClear(GetProcess());
 
-    m_fContextFresh = false;            // invalide the cached active CONTEXT
+    m_fContextFresh = false;            // invalidate the cached active CONTEXT
     m_vmLeftSideContext = VMPTR_CONTEXT::NullPtr(); // set the LS pointer to the active CONTEXT to NULL
     m_fFramesFresh = false;             // invalidate the cached stack trace (frames & chains)
     m_userState = kInvalidUserState;                // clear the cached user state
diff --git a/src/debug/ee/debugger.cpp b/src/debug/ee/debugger.cpp
index 723c662b18..7ccf26f9e8 100644
--- a/src/debug/ee/debugger.cpp
+++ b/src/debug/ee/debugger.cpp
@@ -9876,7 +9876,7 @@ void Debugger::SendRawUpdateModuleSymsEvent(Module *pRuntimeModule, AppDomain *p
 
     // This event is used to trigger the ICorDebugManagedCallback::UpdateModuleSymbols 
     // callback.  That callback is defined to pass a PDB stream, and so we still use this
-    // only for legacy compatability reasons when we've actually got PDB symbols.  
+    // only for legacy compatibility reasons when we've actually got PDB symbols.
     // New clients know they must request a new symbol reader after ClassLoad events.
     if (pRuntimeModule->GetInMemorySymbolStreamFormat() != eSymbolFormatPDB)
         return; // Non-PDB symbols
diff --git a/src/debug/inc/dacdbiinterface.h b/src/debug/inc/dacdbiinterface.h
index 1e62a643d9..0442c28f09 100644
--- a/src/debug/inc/dacdbiinterface.h
+++ b/src/debug/inc/dacdbiinterface.h
@@ -663,7 +663,7 @@ public:
     //
     // Notes:
     //    This is taken exactly from the IXClrData definition.     
-    //    This is provided for V3 compatability to support Interop-debugging. 
+    //    This is provided for V3 compatibility to support Interop-debugging.
     //    This should eventually be deprecated.
     //
     virtual 
@@ -678,7 +678,7 @@ public:
     //   
     //
     // Return Value:
-    //    true if the adddress is a CLR stub.    
+    //    true if the address is a CLR stub.
     //
     // Notes:
     //    This is used to implement ICorDebugProcess::IsTransitionStub
@@ -1320,7 +1320,7 @@ public:
                                                OUT SequencePoints *  pSequencePoints) = 0;
 
     //
-    // Return the filter CONTEXT on the LS.  Once we move entirely over to the new managed pipepline 
+    // Return the filter CONTEXT on the LS.  Once we move entirely over to the new managed pipeline
     // built on top of the Win32 debugging API, this won't be necessary.
     //
     // Arguments:
@@ -2259,7 +2259,7 @@ public:
     // Notes:
     //     This will produce a VMPTR_OBJECTHANDLE regardless of whether handle is 
     //     valid.     
-    //     Ideally we'd be using only strongly-typed variables on the RS, and then this would be unnecessary 
+    //     Ideally we'd be using only strongly-typed variables on the RS, and then this would be unnecessary
     virtual
     VMPTR_OBJECTHANDLE GetVmObjectHandle(CORDB_ADDRESS handleAddress) = 0;
 
diff --git a/src/debug/inc/dbgipcevents.h b/src/debug/inc/dbgipcevents.h
index 33d9bdbcaa..d902884f1c 100644
--- a/src/debug/inc/dbgipcevents.h
+++ b/src/debug/inc/dbgipcevents.h
@@ -221,7 +221,7 @@ struct MSLAYOUT DebuggerIPCControlBlock
 
 #if defined(DBG_TARGET_WIN64)
     // 64-bit needs this padding to make the handles after this aligned.
-    // But x86 can't have this padding b/c it breaks binary compatability between v1.1 and v2.0.
+    // But x86 can't have this padding b/c it breaks binary compatibility between v1.1 and v2.0.
     ULONG padding4;
 #endif // DBG_TARGET_WIN64
 
@@ -229,7 +229,7 @@ struct MSLAYOUT DebuggerIPCControlBlock
     RemoteHANDLE               m_rightSideEventAvailable;
     RemoteHANDLE               m_rightSideEventRead;
 
-    // @dbgtodo  inspection - this is where LSEA and LSER used to be. We need to the padding to maintain binary compatability.
+    // @dbgtodo  inspection - this is where LSEA and LSER used to be. We need to the padding to maintain binary compatibility.
     // Eventually, we expect to remove this whole block.
     RemoteHANDLE               m_paddingObsoleteLSEA;
     RemoteHANDLE               m_paddingObsoleteLSER;
@@ -321,7 +321,7 @@ struct MSLAYOUT DebuggerIPCControlBlockTransport
 
 #if defined(DBG_TARGET_WIN64)
     // 64-bit needs this padding to make the handles after this aligned.
-    // But x86 can't have this padding b/c it breaks binary compatability between v1.1 and v2.0.
+    // But x86 can't have this padding b/c it breaks binary compatibility between v1.1 and v2.0.
     ULONG padding4;
 #endif // DBG_TARGET_WIN64
 
@@ -895,7 +895,7 @@ template <int nMaxLengthIncludingNull>
 class MSLAYOUT EmbeddedIPCString
 {
 public:
-    // Set, caller responsiblity that wcslen(pData) < nMaxLengthIncludingNull
+    // Set, caller responsibility that wcslen(pData) < nMaxLengthIncludingNull
     void SetString(const WCHAR * pData)
     {
         // If the string doesn't fit into the buffer, that's an issue (and so this is a real
diff --git a/src/inc/corerror.xml b/src/inc/corerror.xml
index 87658dce56..e4ddd973b0 100644
--- a/src/inc/corerror.xml
+++ b/src/inc/corerror.xml
@@ -3326,7 +3326,7 @@
 <HRESULT NumericValue="0x80131346">
 	<SymbolicName>CORDBG_E_DEBUGGING_NOT_POSSIBLE</SymbolicName>
 	<Message>"Debugging is not possible due to an incompatibility within the CLR implementation."</Message>
-	<Comment> Debugging isn't possible due to an incompatability within the CLR implementation. </Comment>
+	<Comment> Debugging isn't possible due to an incompatibility within the CLR implementation. </Comment>
 </HRESULT>
 
 <HRESULT NumericValue="0x80131347">
diff --git a/src/inc/corprof.idl b/src/inc/corprof.idl
index e9e098c0f5..bb96b03ef0 100644
--- a/src/inc/corprof.idl
+++ b/src/inc/corprof.idl
@@ -74,7 +74,7 @@ typedef struct _COR_IL_MAP
 {
     ULONG32 oldOffset;        // Old IL offset relative to beginning of function
     ULONG32 newOffset;        // New IL offset relative to beginning of function
-    BOOL    fAccurate; //put here for compatability with the Debugger structure.
+    BOOL    fAccurate; //put here for compatibility with the Debugger structure.
 } COR_IL_MAP;
 
 cpp_quote("#endif //_COR_IL_MAP")
diff --git a/src/jit/importer.cpp b/src/jit/importer.cpp
index 0be7dfa7cc..2be6ec5099 100644
--- a/src/jit/importer.cpp
+++ b/src/jit/importer.cpp
@@ -3723,7 +3723,7 @@ bool           Compiler::verCheckTailCallConstraint (OPCODE                  opc
         }
         else
         {
-            // Check type compatability of the this argument
+            // Check type compatibility of the this argument
             typeInfo tiDeclaredThis = verMakeTypeInfo(methodClassHnd);
             if (tiDeclaredThis.IsValueClass())
                 tiDeclaredThis.MakeByRef();
@@ -3960,12 +3960,12 @@ DONE_ARGS:
         popCount++;
                 
         // If it is null, we assume we can access it (since it will AV shortly)
-        // If it is anything but a refernce class, there is no hierarchy, so
+        // If it is anything but a reference class, there is no hierarchy, so
         // again, we don't need the precise instance class to compute 'protected' access
         if (tiThis.IsType(TI_REF))
             instanceClassHnd = tiThis.GetClassHandleForObjRef();
         
-        // Check type compatability of the this argument
+        // Check type compatibility of the this argument
         typeInfo tiDeclaredThis = verMakeTypeInfo(pResolvedToken->hClass);
         if (tiDeclaredThis.IsValueClass())
             tiDeclaredThis.MakeByRef();
diff --git a/src/md/compiler/import.cpp b/src/md/compiler/import.cpp
index 31e5d7fff1..264a513db4 100644
--- a/src/md/compiler/import.cpp
+++ b/src/md/compiler/import.cpp
@@ -1932,7 +1932,7 @@ RegMeta::GetRVA(
     if (TypeFromToken(tk) == mdtMethodDef)
     {
         if (tk == mdMethodDefNil)
-        {   // Backward compatability with CLR 2.0 implementation
+        {   // Backward compatibility with CLR 2.0 implementation
             if (pulCodeRVA != NULL)
                 *pulCodeRVA = 0;
             if (pdwImplFlags != NULL)
diff --git a/src/md/compiler/regmeta_import.cpp b/src/md/compiler/regmeta_import.cpp
index 912198f1ac..cb5d28879c 100644
--- a/src/md/compiler/regmeta_import.cpp
+++ b/src/md/compiler/regmeta_import.cpp
@@ -862,7 +862,7 @@ RegMeta::GetTypeDefProps(
         goto ErrExit;
     }
     if (td == mdTypeDefNil)
-    {   // Backward compatability with CLR 2.0 implementation
+    {   // Backward compatibility with CLR 2.0 implementation
         if (pdwTypeDefFlags != NULL)
             *pdwTypeDefFlags = 0;
         if (ptkExtends != NULL)
@@ -1013,7 +1013,7 @@ RegMeta::GetTypeRefProps(
         goto ErrExit;
     }
     if (tr == mdTypeRefNil)
-    {   // Backward compatability with CLR 2.0 implementation
+    {   // Backward compatibility with CLR 2.0 implementation
         if (ptkResolutionScope != NULL)
             *ptkResolutionScope = mdTokenNil;
         if (pchTypeRef != NULL)
diff --git a/src/mscorlib/src/System/Activator.cs b/src/mscorlib/src/System/Activator.cs
index 3e1ede2906..f2a95cdfcb 100644
--- a/src/mscorlib/src/System/Activator.cs
+++ b/src/mscorlib/src/System/Activator.cs
@@ -209,7 +209,7 @@ namespace System {
             // type in Assembly A upon A's request:
             //      TypeInAssemblyA.DoWork() { AssemblyB.Create<InternalTypeInAssemblyA>();}
             //      TypeInAssemblyB.Create<T>() {return new T();}
-            // This violates type safety but we saw multiple user apps that have put a dependency on it. So for compatability we allow this if
+            // This violates type safety but we saw multiple user apps that have put a dependency on it. So for compatibility we allow this if
             // the SL app was built against SL2/3.
             // Note that in SL2/3 it is possible for app code to instantiate public transparent types with public critical default constructors.
             // Fortunately we don't have such types in out platform assemblies.
diff --git a/src/mscorlib/src/System/DateTime.cs b/src/mscorlib/src/System/DateTime.cs
index 3e9f149d76..78240a48b8 100644
--- a/src/mscorlib/src/System/DateTime.cs
+++ b/src/mscorlib/src/System/DateTime.cs
@@ -41,7 +41,7 @@ namespace System {
     // effectively hidden from most users, who just see the 3-state DateTimeKind
     // enumeration.
     //
-    // For compatability, DateTime does not serialize the Kind data when used in
+    // For compatibility, DateTime does not serialize the Kind data when used in
     // binary serialization.
     // 
     // For a description of various calendar issues, look at
@@ -299,7 +299,7 @@ namespace System {
                         foundDateData = true;
                         break;
                     default:
-                        // Ignore other fields for forward compatability.
+                        // Ignore other fields for forward compatibility.
                         break;
                 }
             }
@@ -645,7 +645,7 @@ namespace System {
         }        
 
         // A version of ToBinary that uses the real representation and does not adjust local times. This is needed for
-        // scenarios where the serialized data must maintain compatability
+        // scenarios where the serialized data must maintain compatibility
         internal static DateTime FromBinaryRaw(Int64 dateData) {        
             Int64 ticks = dateData & (Int64)TicksMask;
             if (ticks < MinTicks || ticks > MaxTicks)
@@ -729,7 +729,7 @@ namespace System {
         }        
 
         // Return the underlying data, without adjust local times to the right time zone. Needed if performance
-        // or compatability are important.
+        // or compatibility are important.
         internal Int64 ToBinaryRaw() {
             return (Int64)dateData;
         }        
diff --git a/src/mscorlib/src/System/DateTimeOffset.cs b/src/mscorlib/src/System/DateTimeOffset.cs
index 26702f054a..7db5c4ca8e 100644
--- a/src/mscorlib/src/System/DateTimeOffset.cs
+++ b/src/mscorlib/src/System/DateTimeOffset.cs
@@ -776,7 +776,7 @@ namespace System {
             }
 
             Contract.EndContractBlock();
-            // RoundtripKind does not make sense for DateTimeOffset; ignore this flag for backward compatability with DateTime
+            // RoundtripKind does not make sense for DateTimeOffset; ignore this flag for backward compatibility with DateTime
             style &= ~DateTimeStyles.RoundtripKind; 
         
             // AssumeLocal is also ignored as that is what we do by default with DateTimeOffset.Parse             
diff --git a/src/mscorlib/src/System/Globalization/CultureData.cs b/src/mscorlib/src/System/Globalization/CultureData.cs
index c7e091b257..9911ef35cf 100644
--- a/src/mscorlib/src/System/Globalization/CultureData.cs
+++ b/src/mscorlib/src/System/Globalization/CultureData.cs
@@ -690,7 +690,7 @@ namespace System.Globalization
                 return false;
             }
 
-            // For V2 compatability, handle deprecated alternate sorts
+            // For V2 compatibility, handle deprecated alternate sorts
             string cultureName = this.sRealName;
 
             switch (AnsiToLower(cultureName))
@@ -976,7 +976,7 @@ namespace System.Globalization
             // CHANGE FROM Whidbey
             //
             // We have deprecated CultureTypes.FrameworkCultures.
-            // When this enum is used, we will enumerate Whidbey framework cultures (for compatability).
+            // When this enum is used, we will enumerate Whidbey framework cultures (for compatibility).
             //
 
             // We have deprecated CultureTypes.WindowsOnlyCultures.
@@ -993,7 +993,7 @@ namespace System.Globalization
             // Call nativeEnumCultureNames() to get a string array of culture names based on the specified
             // enumeration type.
             //
-            // nativeEnumCulturNames is a QCall.  We need to use a reference to return the string array
+            // nativeEnumCultureNames is a QCall.  We need to use a reference to return the string array
             // allocated from the QCall.  That ref has to be wrapped as object handle.
             // See vm\qcall.h for details in QCall.
             //
diff --git a/src/mscorlib/src/System/Globalization/DateTimeParse.cs b/src/mscorlib/src/System/Globalization/DateTimeParse.cs
index 2f636b8af6..1af84a44f6 100644
--- a/src/mscorlib/src/System/Globalization/DateTimeParse.cs
+++ b/src/mscorlib/src/System/Globalization/DateTimeParse.cs
@@ -1737,7 +1737,7 @@ new DS[] { DS.ERROR, DS.TX_NNN,  DS.TX_NNN,  DS.TX_NNN,  DS.ERROR,   DS.ERROR,
             int n2 = raw.GetNumber(1);
             String pattern = dtfi.ShortDatePattern;
 
-            // For compatability, don't throw if we can't determine the order, but default to YMD instead
+            // For compatibility, don't throw if we can't determine the order, but default to YMD instead
             int order;
             if (GetYearMonthDayOrder(pattern, dtfi, out order) && order == ORDER_YDM) {
                 if (SetDateYMD(ref result, raw.year, n2, n1)) {
diff --git a/src/mscorlib/src/System/Globalization/NumberFormatInfo.cs b/src/mscorlib/src/System/Globalization/NumberFormatInfo.cs
index 00110a030e..3aa9b5e0d6 100644
--- a/src/mscorlib/src/System/Globalization/NumberFormatInfo.cs
+++ b/src/mscorlib/src/System/Globalization/NumberFormatInfo.cs
@@ -113,7 +113,7 @@ namespace System.Globalization {
 #if !FEATURE_CORECLR
         // Check if NumberFormatInfo was not set up ambiguously for parsing as number and currency
         // eg. if the NumberDecimalSeparator and the NumberGroupSeparator were the same. This check
-        // is solely for backwards compatability / version tolerant serialization
+        // is solely for backwards compatibility / version tolerant serialization
         [OptionalField(VersionAdded = 1)]
         internal bool validForParseAsNumber = true;     // NEVER USED, DO NOT USE THIS! (Serialized in Whidbey/Everett)
         [OptionalField(VersionAdded = 1)]
diff --git a/src/mscorlib/src/System/Number.cs b/src/mscorlib/src/System/Number.cs
index 462d72b092..f6a7cff6b5 100644
--- a/src/mscorlib/src/System/Number.cs
+++ b/src/mscorlib/src/System/Number.cs
@@ -1027,7 +1027,7 @@ namespace System {
         }
         
         private static Boolean TrailingZeros(String s, Int32 index) {
-            // For compatability, we need to allow trailing zeros at the end of a number string
+            // For compatibility, we need to allow trailing zeros at the end of a number string
             for (int i = index; i < s.Length; i++) {
                 if (s[i] != '\0') {
                     return false;
diff --git a/src/mscorlib/src/System/Security/Util/URLString.cs b/src/mscorlib/src/System/Security/Util/URLString.cs
index 981f3b3000..bad84c973a 100644
--- a/src/mscorlib/src/System/Security/Util/URLString.cs
+++ b/src/mscorlib/src/System/Security/Util/URLString.cs
@@ -46,7 +46,7 @@ namespace System.Security.Util {
         [OptionalField(VersionAdded = 3)]
         private bool m_isUncShare;
 
-        // legacy field from v1.x, not used in v2 and beyond. Retained purely for serialization compatability.
+        // legacy field from v1.x, not used in v2 and beyond. Retained purely for serialization compatibility.
         private String m_fullurl;
 
 
diff --git a/src/mscorlib/src/System/Text/StringBuilder.cs b/src/mscorlib/src/System/Text/StringBuilder.cs
index bd6a547116..4cdf224eb7 100644
--- a/src/mscorlib/src/System/Text/StringBuilder.cs
+++ b/src/mscorlib/src/System/Text/StringBuilder.cs
@@ -199,7 +199,7 @@ namespace System.Text {
                         capacityPresent = true;
                         break;
                     default:
-                        // Ignore other fields for forward compatability.
+                        // Ignore other fields for forward compatibility.
                         break;
                 }
 
diff --git a/src/utilcode/util.cpp b/src/utilcode/util.cpp
index 600dd2b123..6caf1c2df0 100644
--- a/src/utilcode/util.cpp
+++ b/src/utilcode/util.cpp
@@ -3474,7 +3474,7 @@ lDone: ;
 #include "corexcep.h"
 
 // These functions provide limited support for corrupting exceptions
-// outside the VM folder. Its limited since we dont have access to the
+// outside the VM folder. Its limited since we don't have access to the
 // throwable.
 //
 // These functions are also wrapped by the corresponding CEHelper 
@@ -4061,7 +4061,7 @@ namespace Win32
             wszPathName,
             &wszFileName);
 
-        // Calculate the index while the buffer is open and the string poiner is stable.
+        // Calculate the index while the buffer is open and the string pointer is stable.
         if (dwLengthWritten != 0 && dwLengthWritten < dwLengthRequired && pdwFilePartIdx != NULL)
             *pdwFilePartIdx = static_cast<DWORD>(wszFileName - wszPathName);
 
diff --git a/src/vm/ceeload.cpp b/src/vm/ceeload.cpp
index 4fd1fdf009..4b8cc4276f 100644
--- a/src/vm/ceeload.cpp
+++ b/src/vm/ceeload.cpp
@@ -7413,7 +7413,7 @@ void Module::UpdateDynamicMetadataIfNeeded()
 //    
 // Notes:
 //    This fetches PDBs from the host and caches them so that they are available for when the debugger attaches.
-//    This lets Arrowhead tools run against Whidbey hosts in a compatability mode. 
+//    This lets Arrowhead tools run against Whidbey hosts in a compatibility mode.
 //    We expect to add a hosting knob that will allow a host to disable this eager fetching and not run in
 //    compat mode.
 void Module::FetchPdbsFromHost()
diff --git a/src/vm/ceemain.cpp b/src/vm/ceemain.cpp
index cf4bc29840..3cab5b2ccc 100644
--- a/src/vm/ceemain.cpp
+++ b/src/vm/ceemain.cpp
@@ -3486,7 +3486,7 @@ HRESULT PrepareExecuteDLLForThunk(HINSTANCE hInst,
 //*****************************************************************************
 // This is the call point to make a DLL that is already loaded into our address
 // space run. There will be other code to actually have us load a DLL due to a
-// class referance.
+// class reference.
 //*****************************************************************************
 BOOL STDMETHODCALLTYPE ExecuteDLL(HINSTANCE hInst,
                                   DWORD dwReason,
diff --git a/src/vm/classcompat.h b/src/vm/classcompat.h
index 79815c286b..e1de0b169d 100644
--- a/src/vm/classcompat.h
+++ b/src/vm/classcompat.h
@@ -213,7 +213,7 @@ public:
     }
 public:
 
-    // This method is purely for backward compatability of COM Interop, and its
+    // This method is purely for backward compatibility of COM Interop, and its
     // implementation can be found in ClassCompat.cpp
     InteropMethodTableData *BuildInteropVTable(AllocMemTracker *pamTracker);
     InteropMethodTableData *BuildInteropVTableForArray(AllocMemTracker *pamTracker);
diff --git a/src/vm/excep.cpp b/src/vm/excep.cpp
index 0c0f66c280..c66d3a839b 100644
--- a/src/vm/excep.cpp
+++ b/src/vm/excep.cpp
@@ -13335,7 +13335,7 @@ VOID DECLSPEC_NORETURN RealCOMPlusThrowWin32(HRESULT hr)
 }
     CONTRACTL_END;
 
-    // Force to ApplicationException for compatability with previous versions.  We would
+    // Force to ApplicationException for compatibility with previous versions.  We would
     //  prefer a "Win32Exception" here.
     EX_THROW(EEMessageException, (kApplicationException, hr, 0 /* resid*/,
                                  NULL /* szArg1 */, NULL /* szArg2 */, NULL /* szArg3 */, NULL /* szArg4 */, 
diff --git a/src/vm/fieldmarshaler.cpp b/src/vm/fieldmarshaler.cpp
index 4bd9388b90..fab5ab4bd5 100644
--- a/src/vm/fieldmarshaler.cpp
+++ b/src/vm/fieldmarshaler.cpp
@@ -1349,7 +1349,7 @@ VOID EEClassLayoutInfo::CollectLayoutFieldMetadataThrowing(
         // Treat base class as an initial member.
         cbAdjustedParentLayoutNativeSize = pParentLayoutInfo->GetNativeSize();
         // If the parent was originally a zero-sized explicit type but
-        // got bumped up to a size of 1 for compatability reasons, then
+        // got bumped up to a size of 1 for compatibility reasons, then
         // we need to remove the padding, but ONLY for inheritance situations.
         if (pParentLayoutInfo->IsZeroSized()) {
             CONSISTENCY_CHECK(cbAdjustedParentLayoutNativeSize == 1);
diff --git a/src/vm/proftoeeinterfaceimpl.cpp b/src/vm/proftoeeinterfaceimpl.cpp
index ea32a0dfa8..9d2469f236 100644
--- a/src/vm/proftoeeinterfaceimpl.cpp
+++ b/src/vm/proftoeeinterfaceimpl.cpp
@@ -5404,16 +5404,16 @@ HRESULT ProfToEEInterfaceImpl::GetClassFromTokenAndTypeArgs(ModuleID moduleID,
             // try to load a type, so that type system will not try to test type 
             // loadability in the current AppDomain.  However, 
             // ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE does not prevent callers from 
-            // loading a type.   It is profiler's responsiblity not to attempt to load 
+            // loading a type.   It is profiler's responsibility not to attempt to load
             // a type in unsupported ways (e.g. from a non-EE thread).  It doesn't 
             // impact retail builds, in which contracts are not available. 
             ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();
 
             // ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE also defines FAULT_FORBID, which 
             // causes Scanruntime to flag a fault violation in AssemblySpec::InitializeSpec,
-            // which is defined as FAULTS.   It only happneds in a type-loading path, which
+            // which is defined as FAULTS.   It only happens in a type-loading path, which
             // is not supported on a non-EE thread.  Suppressing a contract violation in an
-            // unsupported execution path is more preferable than casuing AV when calling
+            // unsupported execution path is more preferable than causing AV when calling
             // GetClassFromTokenAndTypeArgs on a non-EE thread in a check build.  See Dev10 
             // 682526 for more details.
             FAULT_NOT_FATAL();
diff --git a/src/zap/zapinnerptr.h b/src/zap/zapinnerptr.h
index 5a88948342..929557721d 100644
--- a/src/zap/zapinnerptr.h
+++ b/src/zap/zapinnerptr.h
@@ -8,7 +8,7 @@
 
 //
 // ZapNode that points into middle of other ZapNode. It is used to create
-// pointers into datastructures that are not convinient to split into smaller zap nodes.
+// pointers into datastructures that are not convenient to split into smaller zap nodes.
 // 
 // ======================================================================================