correct word spelling

20 files changed, 47 insertions, 47 deletions

diff --git a/src/vm/appdomain.cpp b/src/vm/appdomain.cpp
index aed588c61d..8327adf243 100644
--- a/src/vm/appdomain.cpp
+++ b/src/vm/appdomain.cpp
@@ -8014,7 +8014,7 @@ BOOL AppDomain::AddAssemblyToCache(AssemblySpec* pSpec, DomainAssembly *pAssembl
     // check for context propagation
     if (bRetVal && pSpec->GetParentLoadContext() == LOADCTX_TYPE_LOADFROM && pAssembly->GetFile()->GetLoadContext() == LOADCTX_TYPE_DEFAULT)
     {
-        // LoadFrom propagation occured, store it in a way reachable by Load() (the "post-policy" one)
+        // LoadFrom propagation occurred, store it in a way reachable by Load() (the "post-policy" one)
         AssemblySpec loadSpec;
         loadSpec.CopyFrom(pSpec);
         loadSpec.SetParentAssembly(NULL);
diff --git a/src/vm/clsload.cpp b/src/vm/clsload.cpp
index 2798ce2c77..145da42e6e 100644
--- a/src/vm/clsload.cpp
+++ b/src/vm/clsload.cpp
@@ -5078,7 +5078,7 @@ void AccessCheckOptions::ThrowAccessException(
         // If the caller and target method are non-null and the same, then this means that we're checking to see
         // if the method has access to itself in order to validate that it has access to its parameter types,
         // containing type, and return type.  In this case, throw a more informative TypeAccessException to
-        // describe the error that occured (for instance, "this method doesn't have access to one of its
+        // describe the error that occurred (for instance, "this method doesn't have access to one of its
         // parameter types", rather than "this method doesn't have access to itself").
         // We only want to do this if we know the exact type that caused the problem, otherwise fall back to
         // throwing the standard MethodAccessException.
diff --git a/src/vm/domainfile.h b/src/vm/domainfile.h
index f55f9fa009..c6e4cdd473 100644
--- a/src/vm/domainfile.h
+++ b/src/vm/domainfile.h
@@ -254,7 +254,7 @@ class DomainFile
     // Throws if a load error has occurred
     void ThrowIfError(FileLoadLevel targetLevel) DAC_EMPTY();
 
-    // Checks that a load error has not occured before the given level
+    // Checks that a load error has not occurred before the given level
     CHECK CheckNoError(FileLoadLevel targetLevel) DAC_EMPTY_RET(CHECK::OK());
 
     // IsNotified means that the profiler API notification has been delivered
diff --git a/src/vm/dwreport.cpp b/src/vm/dwreport.cpp
index 9fe8ca76be..115b422952 100644
--- a/src/vm/dwreport.cpp
+++ b/src/vm/dwreport.cpp
@@ -1873,7 +1873,7 @@ HRESULT GetManagedBucketParametersForIp(
         // probably inside of mscorwks
         //
         // Note that while there may be an actual managed exception that
-        // occured, we can live without the managed bucket parameters. For
+        // occurred, we can live without the managed bucket parameters. For
         // exceptions coming from within mscorwks.dll, the native bucket
         // parameters will do just fine.
 
diff --git a/src/vm/excep.cpp b/src/vm/excep.cpp
index 2bad8d7729..5847fc45ef 100644
--- a/src/vm/excep.cpp
+++ b/src/vm/excep.cpp
@@ -105,11 +105,11 @@ BOOL IsExceptionFromManagedCode(const EXCEPTION_RECORD * pExceptionRecord)
     UINT_PTR address = reinterpret_cast<UINT_PTR>(pExceptionRecord->ExceptionAddress);
 
     // An exception code of EXCEPTION_COMPLUS indicates a managed exception
-    // has occured (most likely due to executing a "throw" instruction).
+    // has occurred (most likely due to executing a "throw" instruction).
     //
     // Also, a hardware level exception may not have an exception code of
     // EXCEPTION_COMPLUS. In this case, an exception address that resides in
-    // managed code indicates a managed exception has occured.
+    // managed code indicates a managed exception has occurred.
     return (IsComPlusException(pExceptionRecord) ||
             (ExecutionManager::IsManagedCode((PCODE)address)));
 }
@@ -5206,7 +5206,7 @@ LONG InternalUnhandledExceptionFilter_Worker(
     //
     // This needs to be done before the check for TSNC_ProcessedUnhandledException because it is perfectly
     // legitimate (though rare) for the debugger to be inspecting exceptions which are nested in finally
-    // clauses that run after an unhandled exception has already occured on the thread
+    // clauses that run after an unhandled exception has already occurred on the thread
     if ((pThread != NULL) && pThread->IsExceptionInProgress())
     {
         LOG((LF_EH, LL_INFO1000, "InternalUnhandledExceptionFilter_Worker: Set unhandled exception flag at %p\n",
@@ -7054,7 +7054,7 @@ LONG FilterAccessViolation(PEXCEPTION_POINTERS pExceptionPointers, LPVOID lpvPar
  * Returns whether this is an exception the EE knows how to intercept and continue from.
  *
  * Parameters:
- *   pThread - The thread the exception occured on.
+ *   pThread - The thread the exception occurred on.
  *
  * Returns:
  *   TRUE if the exception on the thread is interceptable or not.
@@ -7182,7 +7182,7 @@ IsDebuggerFault(EXCEPTION_RECORD *pExceptionRecord,
     // to fixup the state before any other part of the system uses it (we do it here since only the debugger
     // uses single step functionality).
 
-    // First ask the emulation itself whether this exception occured while single stepping was enabled. If so
+    // First ask the emulation itself whether this exception occurred while single stepping was enabled. If so
     // it will fix up the context to be consistent again and return true. If so and the exception was
     // EXCEPTION_BREAKPOINT then we translate it to EXCEPTION_SINGLE_STEP (otherwise we leave it be, e.g. the
     // instruction stepped caused an access violation).  since this is called from our VEH there might not
@@ -7704,7 +7704,7 @@ LONG WINAPI CLRVectoredExceptionHandler(PEXCEPTION_POINTERS pExceptionInfo)
     // not already have one allocated.  Thus, if we OOM during the setting up of the
     // thread, the log buffer will not be allocated and this will try to do so.  Thus,
     // all STRESS_LOGs in here need to be after you have guaranteed the allocation has
-    // already occured.
+    // already occurred.
     //
 
     Thread *pThread;
@@ -7808,7 +7808,7 @@ LONG WINAPI CLRVectoredExceptionHandlerPhase2(PEXCEPTION_POINTERS pExceptionInfo
     // not already have one allocated.  Thus, if we OOM during the setting up of the
     // thread, the log buffer will not be allocated and this will try to do so.  Thus,
     // all STRESS_LOGs in here need to be after you have guaranteed the allocation has
-    // already occured.
+    // already occurred.
     //
 
     PEXCEPTION_RECORD pExceptionRecord  = pExceptionInfo->ExceptionRecord;
@@ -7989,7 +7989,7 @@ VEH_ACTION WINAPI CLRVectoredExceptionHandlerPhase3(PEXCEPTION_POINTERS pExcepti
     // not already have one allocated.  Thus, if we OOM during the setting up of the
     // thread, the log buffer will not be allocated and this will try to do so.  Thus,
     // all STRESS_LOGs in here need to be after you have guaranteed the allocation has
-    // already occured.
+    // already occurred.
     //
 
     // Handle special cases which are common amongst all filters.
@@ -13828,7 +13828,7 @@ VOID DECLSPEC_NORETURN RealCOMPlusThrowSO()
 
     if (breakOnSO != 0)
     {
-        _ASSERTE(!"SO occured");
+        _ASSERTE(!"SO occurred");
     }
 #endif
 
diff --git a/src/vm/exceptionhandling.cpp b/src/vm/exceptionhandling.cpp
index 42f5fa582c..4818fe27ae 100644
--- a/src/vm/exceptionhandling.cpp
+++ b/src/vm/exceptionhandling.cpp
@@ -788,7 +788,7 @@ ProcessCLRException(IN     PEXCEPTION_RECORD   pExceptionRecord
     // relies on transition frame, we still cannot let an exception be handled
     // by an unprotected managed frame.
     //
-    // This code below checks to see if a SO has occured outside of managed code.
+    // This code below checks to see if a SO has occurred outside of managed code.
     // If it has, and if we don't have a transition frame higher up the stack, then
     // we don't handle the SO.
     if (!(dwExceptionFlags & EXCEPTION_UNWINDING))
diff --git a/src/vm/exinfo.h b/src/vm/exinfo.h
index 73f8c1205c..328a3d7e3a 100644
--- a/src/vm/exinfo.h
+++ b/src/vm/exinfo.h
@@ -57,7 +57,7 @@ public:
     // Reference to the topmost handler we saw during an SO that goes past us
     PTR_EXCEPTION_REGISTRATION_RECORD m_pTopMostHandlerDuringSO; 
 
-    LPVOID              m_dEsp;             // Esp when  fault occured, OR esp to restore on endcatch
+    LPVOID              m_dEsp;             // Esp when  fault occurred, OR esp to restore on endcatch
 
     StackTraceInfo      m_StackTraceInfo;
 
diff --git a/src/vm/frames.h b/src/vm/frames.h
index dcaa4403ff..32bd3188af 100644
--- a/src/vm/frames.h
+++ b/src/vm/frames.h
@@ -431,7 +431,7 @@ public:
         FRAME_ATTR_OUT_OF_LINE = 2,         // The exception out of line (IP of the frame is not correct)
         FRAME_ATTR_FAULTED = 4,             // Exception caused by Win32 fault
         FRAME_ATTR_RESUMABLE = 8,           // We may resume from this frame
-        FRAME_ATTR_CAPTURE_DEPTH_2 = 0x10,  // This is a helperMethodFrame and the capture occured at depth 2
+        FRAME_ATTR_CAPTURE_DEPTH_2 = 0x10,  // This is a helperMethodFrame and the capture occurred at depth 2
         FRAME_ATTR_EXACT_DEPTH = 0x20,      // This is a helperMethodFrame and a jit helper, but only crawl to the given depth
         FRAME_ATTR_NO_THREAD_ABORT = 0x40,  // This is a helperMethodFrame that should not trigger thread aborts on entry
     };
diff --git a/src/vm/i386/excepx86.cpp b/src/vm/i386/excepx86.cpp
index 7de7b43e0d..cda353c62f 100644
--- a/src/vm/i386/excepx86.cpp
+++ b/src/vm/i386/excepx86.cpp
@@ -322,7 +322,7 @@ void VerifyValidTransitionFromManagedCode(Thread *pThread, CrawlFrame *pCF)
                             "setting up the proper exception handling.\n\n"
                             "Get a good unmanaged stack trace for this thread. All FS:0 records are on the stack, "
                             "so you can see who installed the last handler. Somewhere between that function and "
-                            "where the thread is now is where the bad transition occured.\n\n"
+                            "where the thread is now is where the bad transition occurred.\n\n"
                             "A little extra info: FS:0 = 0x%p, pEHR->Handler = 0x%p\n",
                             GetRegdisplaySP(pCF->GetRegisterSet()),
                             pFunction ->m_pszDebugClassName,
@@ -1375,7 +1375,7 @@ CPFH_FirstPassHandler(EXCEPTION_RECORD *pExceptionRecord,
     {
         // If we ever get here in preemptive mode, we're in trouble.  We've
         // changed the thread's IP to point at a little function that throws ... if
-        // the thread were to be in preemptive mode and a GC occured, the stack
+        // the thread were to be in preemptive mode and a GC occurred, the stack
         // crawl would have been all messed up (becuase we have no frame that points
         // us back to the right place in managed code).
         _ASSERTE(disabled);
diff --git a/src/vm/interoputil.cpp b/src/vm/interoputil.cpp
index 4d198a5c0f..945707f27f 100644
--- a/src/vm/interoputil.cpp
+++ b/src/vm/interoputil.cpp
@@ -1446,7 +1446,7 @@ void SafeRelease_OnException(IUnknown* pUnk, RCW* pRCW
 #endif  // MDA_SUPPORTED
 
 #ifdef FEATURE_COMINTEROP
-    LogInterop(W("An exception occured during release"));
+    LogInterop(W("An exception occurred during release"));
     LogInteropLeak(pUnk);
 #endif // FEATURE_COMINTEROP
 
diff --git a/src/vm/jitinterface.cpp b/src/vm/jitinterface.cpp
index 6c6692e6fe..fae4cce8f8 100644
--- a/src/vm/jitinterface.cpp
+++ b/src/vm/jitinterface.cpp
@@ -10231,7 +10231,7 @@ int CEEInfo::FilterException(struct _EXCEPTION_POINTERS *pExceptionPointers)
         {
             _ASSERTE(!"Access violation while Jitting!");
             // If you set the debugger to catch access violations and 'go'
-            // you will get back to the point at which the access violation occured
+            // you will get back to the point at which the access violation occurred
             result = EXCEPTION_CONTINUE_EXECUTION;
         }
         else
diff --git a/src/vm/mdaBoilerplate.exe.mda.config b/src/vm/mdaBoilerplate.exe.mda.config
index 2906d788dd..1cbd20037e 100644
--- a/src/vm/mdaBoilerplate.exe.mda.config
+++ b/src/vm/mdaBoilerplate.exe.mda.config
@@ -739,7 +739,7 @@ ACTIVATION\REPORTING SCENARIOS:
                 in SafeHandle cleanup.
                 
                 CAUSE:
-                An unexpected error occured while cleaning up temporary structures.  Review all SafeHandle destructor / finalizer implementations and 
+                An unexpected error occurred while cleaning up temporary structures.  Review all SafeHandle destructor / finalizer implementations and 
                 custom-marshaler implementations for errors.
                 
             OUTPUT:
diff --git a/src/vm/object.cpp b/src/vm/object.cpp
index 648cbf99b5..3b07a12543 100644
--- a/src/vm/object.cpp
+++ b/src/vm/object.cpp
@@ -2681,7 +2681,7 @@ int OBJECTREF::operator==(const OBJECTREF &objref) const
         _ASSERTE(Thread::IsObjRefValid(&objref));
         VALIDATEOBJECT(m_asObj);
         // If this assert fires, you probably did not protect
-        // your OBJECTREF and a GC might have occured.  To
+        // your OBJECTREF and a GC might have occurred.  To
         // where the possible GC was, set a breakpoint in Thread::TriggersGC 
         _ASSERTE(Thread::IsObjRefValid(this));
 
@@ -2719,7 +2719,7 @@ int OBJECTREF::operator!=(const OBJECTREF &objref) const
         _ASSERTE(Thread::IsObjRefValid(&objref));
         VALIDATEOBJECT(m_asObj);
         // If this assert fires, you probably did not protect
-        // your OBJECTREF and a GC might have occured.  To
+        // your OBJECTREF and a GC might have occurred.  To
         // where the possible GC was, set a breakpoint in Thread::TriggersGC 
         _ASSERTE(Thread::IsObjRefValid(this));
 
@@ -2743,7 +2743,7 @@ Object* OBJECTREF::operator->()
 
     VALIDATEOBJECT(m_asObj);
         // If this assert fires, you probably did not protect
-        // your OBJECTREF and a GC might have occured.  To
+        // your OBJECTREF and a GC might have occurred.  To
         // where the possible GC was, set a breakpoint in Thread::TriggersGC 
     _ASSERTE(Thread::IsObjRefValid(this));
 
@@ -2768,7 +2768,7 @@ const Object* OBJECTREF::operator->() const
 
     VALIDATEOBJECT(m_asObj);
         // If this assert fires, you probably did not protect
-        // your OBJECTREF and a GC might have occured.  To
+        // your OBJECTREF and a GC might have occurred.  To
         // where the possible GC was, set a breakpoint in Thread::TriggersGC 
     _ASSERTE(Thread::IsObjRefValid(this));
 
diff --git a/src/vm/objectclone.cpp b/src/vm/objectclone.cpp
index 43ce79f497..51a7308215 100644
--- a/src/vm/objectclone.cpp
+++ b/src/vm/objectclone.cpp
@@ -2190,7 +2190,7 @@ DWORD ObjectClone::CloneField(FieldDesc *pSrcField, FieldDesc *pDstField)
 
                 STRINGREF refStr = (STRINGREF) *pSrc;
                 refStr = m_cbInterface->AllocateString(refStr);
-                // Get dest addr again, as a GC might have occured
+                // Get dest addr again, as a GC might have occurred
                 pDest = (OBJECTREF *)(m_newObject->GetData() + dstOffset);
                 _ASSERTE(GetAppDomain()==m_toDomain);
                 SetObjectReference(pDest, refStr, GetAppDomain());
diff --git a/src/vm/reflectioninvocation.cpp b/src/vm/reflectioninvocation.cpp
index da0f51c7ce..777b120ad4 100644
--- a/src/vm/reflectioninvocation.cpp
+++ b/src/vm/reflectioninvocation.cpp
@@ -2732,7 +2732,7 @@ LONG SODetectionFilter(EXCEPTION_POINTERS *ep, void* pv)
         return EXCEPTION_CONTINUE_EXECUTION;
     }
 
-    // Record the fact that an exception occured while running the try code.
+    // Record the fact that an exception occurred while running the try code.
     ECWGC_Param *pParam= (ECWGC_Param *)pv;
     pParam->fExceptionThrownInTryCode = TRUE;
 
@@ -2832,7 +2832,7 @@ void ExecuteCodeWithGuaranteedCleanupHelper (ECWGC_GC *gc)
 // ExecuteCodeWithGuaranteedCleanup ensures that we will call the backout code delegate even if an SO occurs. We do this by calling the 
 // try delegate from within an EX_TRY/EX_CATCH block that will catch any thrown exceptions and thus cause the stack to be unwound. This 
 // guarantees that the backout delegate is called with at least DEFAULT_ENTRY_PROBE_SIZE pages of stack. After the backout delegate is called, 
-// we re-raise any exceptions that occured inside the try delegate. Note that any CER that uses large or arbitraty amounts of stack in 
+// we re-raise any exceptions that occurred inside the try delegate. Note that any CER that uses large or arbitraty amounts of stack in 
 // it's try block must use ExecuteCodeWithGuaranteedCleanup. 
 //
 // ExecuteCodeWithGuaranteedCleanup also guarantees that the backount code will be run before any filters higher up on the stack. This
diff --git a/src/vm/rejit.cpp b/src/vm/rejit.cpp
index 0233da062e..0e2a0d3495 100644
--- a/src/vm/rejit.cpp
+++ b/src/vm/rejit.cpp
@@ -607,7 +607,7 @@ HRESULT ReJitManager::RequestReJIT(
     // later when the runtime is suspended.
     //
     //BUGBUG: Its not clear to me why it is safe to hold ReJitInfo* lists
-    // outside the table locks. If an AppDomain unload occured I don't see anything
+    // outside the table locks. If an AppDomain unload occurred I don't see anything
     // that prevents them from being deleted. If this is a bug it is a pre-existing
     // condition and nobody has reported it as an issue yet. AppDomainExit probably
     // needs to synchronize with something.
@@ -2991,7 +2991,7 @@ HRESULT ReJitManager::GetReJITIDs(PTR_MethodDesc pMD, ULONG cReJitIds, ULONG * p
 //      * methodDef - The MethodDef in the module/MethodDef identifier pair for the method which
 //                  had an error during rejit
 //      * pMD - If available, the specific method instance which had an error during rejit
-//      * hrStatus - HRESULT for the rejit error that occured
+//      * hrStatus - HRESULT for the rejit error that occurred
 //      * pErrors - the list of error records that this method will append to
 //
 // Return Value:
@@ -3028,7 +3028,7 @@ HRESULT ReJitManager::AddReJITError(Module* pModule, mdMethodDef methodDef, Meth
 //
 // Arguments:
 //      * pReJitInfo - The method which had an error during rejit
-//      * hrStatus - HRESULT for the rejit error that occured
+//      * hrStatus - HRESULT for the rejit error that occurred
 //      * pErrors - the list of error records that this method will append to
 //
 // Return Value:
@@ -3863,7 +3863,7 @@ ReJitPublishMethodHolder::~ReJitPublishMethodHolder()
     // This method can't have a contract because leaving the table lock
     // below decrements GCNoTrigger count. Contracts always revert these changes
     // at the end of the method but we need the decremented count to flow out of the
-    // method. The balancing increment occured in the constructor.
+    // method. The balancing increment occurred in the constructor.
     STATIC_CONTRACT_NOTHROW;
     STATIC_CONTRACT_GC_TRIGGERS; // NOTRIGGER until we leave the lock
     STATIC_CONTRACT_CAN_TAKE_LOCK;
@@ -3932,7 +3932,7 @@ ReJitPublishMethodTableHolder::~ReJitPublishMethodTableHolder()
     // This method can't have a contract because leaving the table lock
     // below decrements GCNoTrigger count. Contracts always revert these changes
     // at the end of the method but we need the decremented count to flow out of the
-    // method. The balancing increment occured in the constructor.
+    // method. The balancing increment occurred in the constructor.
     STATIC_CONTRACT_NOTHROW; 
     STATIC_CONTRACT_GC_TRIGGERS; // NOTRIGGER until we leave the lock
     STATIC_CONTRACT_CAN_TAKE_LOCK;
diff --git a/src/vm/stackingallocator.cpp b/src/vm/stackingallocator.cpp
index 24b8763262..ba23c51464 100644
--- a/src/vm/stackingallocator.cpp
+++ b/src/vm/stackingallocator.cpp
@@ -334,7 +334,7 @@ void * __cdecl operator new[](size_t n, StackingAllocator * alloc)
     // size_t's too big on 64-bit platforms so we check for overflow
     if(n > (size_t)(1<<31)) ThrowOutOfMemory();
 #else
-    if(n == (size_t)-1) ThrowOutOfMemory();    // overflow occured 
+    if(n == (size_t)-1) ThrowOutOfMemory();    // overflow occurred 
 #endif
 
     void *retval = alloc->UnsafeAllocNoThrow((unsigned)n);
@@ -368,7 +368,7 @@ void * __cdecl operator new[](size_t n, StackingAllocator * alloc, const NoThrow
     // size_t's too big on 64-bit platforms so we check for overflow
     if(n > (size_t)(1<<31)) return NULL;
 #else
-    if(n == (size_t)-1) return NULL;    // overflow occured 
+    if(n == (size_t)-1) return NULL;    // overflow occurred 
 #endif
 
     return alloc->UnsafeAllocNoThrow((unsigned)n);
diff --git a/src/vm/stackprobe.cpp b/src/vm/stackprobe.cpp
index 201c12c855..8e16963689 100644
--- a/src/vm/stackprobe.cpp
+++ b/src/vm/stackprobe.cpp
@@ -150,7 +150,7 @@ void ReportStackOverflow()
 
         // We should only ever get in this situation on a probe from managed code.  From within the EE,
         // we will never let our probe point get this close.  Either way, we'd rip the process if a hard
-        // SO occured.
+        // SO occurred.
 
         UINT_PTR stackGuarantee = pThread->GetStackGuarantee();
 
@@ -1005,8 +1005,8 @@ BOOL BaseStackGuard::RequiresNStackPagesInternal(unsigned int n, BOOL fThrowOnSO
 
     BOOL fRet;
 
-    // Temporarily initialize the exception occured flag
-    m_exceptionOccured = FALSE;
+    // Temporarily initialize the exception occurred flag
+    m_exceptionOccurred = FALSE;
 
     // Code below checks if there's a Thread, and exits immediately if not.
     // So the rest of the function rightly assumes there is a Thread
@@ -1181,8 +1181,8 @@ BOOL BaseStackGuard::DoProbe(unsigned int n, BOOL fThrowOnSO)
     // Mark that we're initialized (and didn't get interupted from an exception)
     m_eInitialized = cInit;
 
-    // Initialize the exception occured flag
-    m_exceptionOccured = TRUE;
+    // Initialize the exception occurred flag
+    m_exceptionOccurred = TRUE;
 
     // setup flag to tell if we're unwinding due to an exception
     m_fEHInProgress = FALSE;
@@ -1269,7 +1269,7 @@ void BaseStackGuard::CheckStack()
 
     // if we aren't being unwound during EH, then we shouldn't have our EHInProgress bit set.  That
     // means we caught the exception in the EE and didn't call RestoreGuard or we missed a SO-tolerant
-    // transition out of the EE and the exception occured above us.
+    // transition out of the EE and the exception occurred above us.
     _ASSERTE(m_fEHInProgress == FALSE);
 
     // we should only ever be popping ourselves if we are not on the EH unwind path
@@ -1617,7 +1617,7 @@ DEBUG_NOINLINE void BoundaryStackGuard::Push()
     m_eInitialized = cInit;
 
     // setup flag to tell if we're unwinding due to an exception
-    m_exceptionOccured = TRUE;
+    m_exceptionOccurred = TRUE;
 
     SetCurrentGuard(this);
 }
@@ -1699,7 +1699,7 @@ BOOL IsBackoutCalledForEH(BYTE *origSP,
     // Caveats:
     //
     // 1) If there is less than a context on the stack on the EH path, we will miss the fact that
-    //     an exception occured
+    //     an exception occurred
     //
     // 2) If the CRT uses near the size of a context before calling the destructor in the normal case,
     //     we will assume we've got an exception and ASSERT.
@@ -1746,7 +1746,7 @@ DebugSOIntolerantTransitionHandlerBeginOnly::~DebugSOIntolerantTransitionHandler
     // Caveats:
     //
     // 1) If there is less than a context on the stack on the EH path, we will miss the fact that
-    //     an exception occured
+    //     an exception occurred
     //
     // 2) If the CRT uses near the size of a context before calling the destructor in the normal case,
     //     we will assume we've got an exception and ASSERT.
diff --git a/src/vm/threads.cpp b/src/vm/threads.cpp
index e90a220c64..065c396929 100644
--- a/src/vm/threads.cpp
+++ b/src/vm/threads.cpp
@@ -4903,7 +4903,7 @@ BOOL Thread::Block(INT32 timeOut, PendingSync *syncState)
 }
 
 
-// Return whether or not a timeout occured.  TRUE=>we waited successfully
+// Return whether or not a timeout occurred.  TRUE=>we waited successfully
 DWORD Thread::Wait(HANDLE *objs, int cntObjs, INT32 timeOut, PendingSync *syncInfo)
 {
     WRAPPER_NO_CONTRACT;
@@ -4928,7 +4928,7 @@ DWORD Thread::Wait(HANDLE *objs, int cntObjs, INT32 timeOut, PendingSync *syncIn
     return dwResult;
 }
 
-// Return whether or not a timeout occured.  TRUE=>we waited successfully
+// Return whether or not a timeout occurred.  TRUE=>we waited successfully
 DWORD Thread::Wait(CLREvent *pEvent, INT32 timeOut, PendingSync *syncInfo)
 {
     WRAPPER_NO_CONTRACT;
diff --git a/src/vm/util.hpp b/src/vm/util.hpp
index 0b5cf5fe85..b444357124 100644
--- a/src/vm/util.hpp
+++ b/src/vm/util.hpp
@@ -357,7 +357,7 @@ HRESULT VMPostError(                    // Returned error.
     ...);                               // Error arguments.
     
 //=====================================================================
-// Displays the messaage box or logs the message, corresponding to the last COM+ error occured
+// Displays the messaage box or logs the message, corresponding to the last COM+ error occurred
 void VMDumpCOMErrors(HRESULT hrErr);
 HRESULT LoadMscorsn();