Typo (dotnet/coreclr#18684)

* approrpriate -> appropriate

* allignment -> alignment

* aquire -> acquire

* aquisition -> acquisition

* arbitraty -> arbitrary

* arcance -> arcane

* archetecture -> architecture

* Archicture -> Architecture

* architecures -> architectures

* argmuent -> argument

Commit migrated from https://github.com/dotnet/coreclr/commit/1a34c72e9e719c9d3879c2a519bf70a05f42869c

diff --git a/src/coreclr/src/binder/assembly.cpp b/src/coreclr/src/binder/assembly.cpp
index 8fcc7cf54fa99a7327d338c28e664b4b7f9cc93f..5d3a674a55c8f4348dd2cce14388a5ce71fc470b 100644 (file)
--- a/src/coreclr/src/binder/assembly.cpp
+++ b/src/coreclr/src/binder/assembly.cpp
@@ -20,7 +20,7 @@ namespace BINDER_SPACE
 {
     namespace
     {
-        BOOL IsPlatformArchicture(PEKIND kArchitecture)
+        BOOL IsPlatformArchitecture(PEKIND kArchitecture)
         {
             return ((kArchitecture != peMSIL) && (kArchitecture != peNone));
         }
@@ -279,7 +279,7 @@ Exit:
     /* static */
     BOOL Assembly::IsValidArchitecture(PEKIND kArchitecture)
     {
-        if (!IsPlatformArchicture(kArchitecture))
+        if (!IsPlatformArchitecture(kArchitecture))
             return TRUE;
 
         return (kArchitecture == GetSystemArchitecture());

diff --git a/src/coreclr/src/debug/ee/debugger.cpp b/src/coreclr/src/debug/ee/debugger.cpp
index 7629d17a1e5d9c179c6bac48fa7467281cdd19a4..2ca8762f98e6dfa24e89c9cb5a275f8bfa333f87 100644 (file)
--- a/src/coreclr/src/debug/ee/debugger.cpp
+++ b/src/coreclr/src/debug/ee/debugger.cpp
@@ -331,7 +331,7 @@ void Debugger::DoNotCallDirectlyPrivateLock(void)
 {
     WRAPPER_NO_CONTRACT;
 
-    LOG((LF_CORDB,LL_INFO10000, "D::Lock aquire attempt by 0x%x\n",
+    LOG((LF_CORDB,LL_INFO10000, "D::Lock acquire attempt by 0x%x\n",
         GetCurrentThreadId()));
 
     // Debugger lock is larger than both Controller & debugger-data locks.
@@ -426,7 +426,7 @@ void Debugger::DoNotCallDirectlyPrivateLock(void)
 
     if (m_mutexCount == 1)
     {
-        LOG((LF_CORDB,LL_INFO10000, "D::Lock aquired by 0x%x\n", m_mutexOwner));
+        LOG((LF_CORDB,LL_INFO10000, "D::Lock acquired by 0x%x\n", m_mutexOwner));
     }
 #endif
 
@@ -4990,7 +4990,7 @@ HRESULT Debugger::MapAndBindFunctionPatches(DebuggerJitInfo *djiNew,
             // The DJI gets deleted as part of the Unbind/Rebind process in MovedCode.
             // This is to signal that we should not skip here.
             // <NICE> under exactly what scenarios (EnC, code pitching etc.) will this apply?... </NICE>
-            // <NICE> can't we be a little clearer about why we don't want to bind the patch in this arcance situation?</NICE>
+            // <NICE> can't we be a little clearer about why we don't want to bind the patch in this arcane situation?</NICE>
             if (dcp->HasDJI() && !dcp->IsBreakpointPatch() &&  !dcp->IsStepperPatch())
             {
                 LOG((LF_CORDB, LL_INFO10000, "Neither stepper nor BP but we have valid a DJI (i.e. the DJI hasn't been deleted as part of the Unbind/MovedCode/Rebind mess)! - getting next patch!\n"));

diff --git a/src/coreclr/src/jit/lclvars.cpp b/src/coreclr/src/jit/lclvars.cpp
index eb6545f8e9443111ab2f0ef6011a0089bdc89303..4b31bd6a669010d5d145a2e81753b72446f54dba 100644 (file)
--- a/src/coreclr/src/jit/lclvars.cpp
+++ b/src/coreclr/src/jit/lclvars.cpp
@@ -5238,7 +5238,7 @@ int Compiler::lvaAssignVirtualFrameOffsetToArg(unsigned lclNum,
             if (varDsc->lvType == TYP_STRUCT && varDsc->lvOtherArgReg >= MAX_REG_ARG && varDsc->lvOtherArgReg != REG_NA)
             {
                 // This is a split struct. It will account for an extra (8 bytes)
-                // of allignment.
+                // of alignment.
                 varDsc->lvStkOffs += TARGET_POINTER_SIZE;
                 argOffs += TARGET_POINTER_SIZE;
             }

diff --git a/src/coreclr/src/jit/morph.cpp b/src/coreclr/src/jit/morph.cpp
index 6778de6dbb87af62a5103ba32f946ee4f4b88c2c..384298a916126f33c1f821ac58b10b0bf8ff2f7a 100644 (file)
--- a/src/coreclr/src/jit/morph.cpp
+++ b/src/coreclr/src/jit/morph.cpp
@@ -4626,7 +4626,7 @@ GenTree* Compiler::fgMorphMultiregStructArg(GenTree* arg, fgArgTabEntry* fgEntry
         {
             assert(arg->OperGet() == GT_LCL_VAR);
 
-            // We need to construct a `GT_OBJ` node for the argmuent,
+            // We need to construct a `GT_OBJ` node for the argument,
             // so we need to get the address of the lclVar.
             lcl = arg->AsLclVarCommon();
         }

diff --git a/src/coreclr/src/pal/src/map/map.cpp b/src/coreclr/src/pal/src/map/map.cpp
index 228b48bfca1ae33bc6f251a4b4f4e3bb4026a9db..7f389abc49dd70c7580ed620803c87d84b016f0f 100644 (file)
--- a/src/coreclr/src/pal/src/map/map.cpp
+++ b/src/coreclr/src/pal/src/map/map.cpp
@@ -1661,7 +1661,7 @@ static INT MAPFileMapToMmapFlags( DWORD flags )
     else if ( FILE_MAP_WRITE == flags )
     {
         TRACE( "FILE_MAP_WRITE\n" );
-        /* The limitation of x86 archetecture
+        /* The limitation of x86 architecture
         means you cant have writable but not readable
         page. In Windows maps of FILE_MAP_WRITE can still be
         read from. */

diff --git a/src/coreclr/src/vm/gccover.cpp b/src/coreclr/src/vm/gccover.cpp
index ed7b037d921b267ef5b613ec9bc1af42ae8e1d4b..2ba76d379169dab388fd3fd29e6c61ce119c1db8 100644 (file)
--- a/src/coreclr/src/vm/gccover.cpp
+++ b/src/coreclr/src/vm/gccover.cpp
@@ -913,7 +913,7 @@ bool replaceInterruptibleRangesWithGcStressInstr (UINT32 startOffset, UINT32 sto
 // We cannot insert GCStress instruction at this call
 // For arm64 & arm (R2R) call to jithelpers happens via a stub.
 // For other architectures call does not happen via stub.
-// For other architecures we can get the target directly by calling getTargetOfCall().
+// For other architectures we can get the target directly by calling getTargetOfCall().
 // This is not the case for arm64/arm so need to decode the stub
 // instruction to find the actual jithelper target. 
 // For other architecture we detect call to JIT_RareDisableHelper 

diff --git a/src/coreclr/src/vm/methodtablebuilder.cpp b/src/coreclr/src/vm/methodtablebuilder.cpp
index e45b2b917503b36c45a84e94bb5add9898b083b7..27e51e6c094737989d95df5db678fbaea37ddddd 100644 (file)
--- a/src/coreclr/src/vm/methodtablebuilder.cpp
+++ b/src/coreclr/src/vm/methodtablebuilder.cpp
@@ -7451,7 +7451,7 @@ MethodTableBuilder::PlaceInterfaceMethods()
                 else
                 {
                     // Iterate through the methods on the interface, and if they have a slot which was filled in
-                    // on an equivalent interface inherited from the parent fill in the approrpriate slot.
+                    // on an equivalent interface inherited from the parent fill in the appropriate slot.
                     // This code path is only used when there is an implicit implementation of an interface
                     // that was not implemented on a parent type, but there was an equivalent interface implemented
                     // on a parent type.

diff --git a/src/coreclr/src/vm/reflectioninvocation.cpp b/src/coreclr/src/vm/reflectioninvocation.cpp
index 6dea9b760c46b2b558285f650c7201311cd06a95..742a26e7a4f671cb95a738b00d755f415e2b01dc 100644 (file)
--- a/src/coreclr/src/vm/reflectioninvocation.cpp
+++ b/src/coreclr/src/vm/reflectioninvocation.cpp
@@ -2272,7 +2272,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 occurred 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 arbitrary 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/coreclr/src/vm/threads.cpp b/src/coreclr/src/vm/threads.cpp
index a354d54b0a755365f05f9725bf4c07bd28e8ed4b..ddf31f4f5b52b70a13ca81c4f76b0c046518d698 100644 (file)
--- a/src/coreclr/src/vm/threads.cpp
+++ b/src/coreclr/src/vm/threads.cpp
@@ -6777,7 +6777,7 @@ HRESULT Thread::CLRSetThreadStackGuarantee(SetThreadStackGuaranteeScope fScope)
         //
         // -plus we might need some more for debugger EH dispatch, Watson, etc...
         // -also need to take into account that we can lose up to 1 page of the guard region
-        // -additionally, we need to provide some region to hosts to allow for lock aquisition in a hosted scenario
+        // -additionally, we need to provide some region to hosts to allow for lock acquisition in a hosted scenario
         //
         EXTRA_PAGES = 3;
         INDEBUG(EXTRA_PAGES += 1);