Fix typos in Markdown files

Clean up misspellings via codespell.

compiler/docs/Debugging.md

@@ -78,7 +78,7 @@ obtained with `-XX:+JVMCIPrintProperties`.
 The compiler supports metrics in the form of counters, timers and memory trackers.
 Each metric has a unique name. Metrics are collected per-compilation.
 At shutdown, they are aggregated across all compilations and reported to the console.
-This ouput can be redirected to a file via the `-Djdk.graal.AggregatedMetricsFile` option.
+This output can be redirected to a file via the `-Djdk.graal.AggregatedMetricsFile` option.
 
 To list the per-compilation metrics, use the `-Djdk.graal.MetricsFile` option. If not specified,
 per-compilation metrics are not reported.

docs/graalvm-as-a-platform/implement-language.md

@@ -136,7 +136,7 @@ gu -L install /path/to/sl-component.jar
 A language built with Truffle can be AOT compiled using [Native Image](../reference-manual/native-image/README.md).
 Running `mvn package` in the SimpleLanguage directory also builds a `slnative` executable in the `native` directory.
 This executable is the full SimpleLanguage implementation as a single native application, and has no need for GraalVM in order to execute SimpleLanguage code.
-Besides this, a big advantage of using the native executable when compared to running on GraalVM is the greatly faster startup time as shown bellow:
+Besides this, a big advantage of using the native executable when compared to running on GraalVM is the greatly faster startup time as shown below:
 ```shell
 time ./sl language/tests/HelloWorld.sl
 == running on org.graalvm.polyglot.Engine@2db0f6b2

docs/reference-manual/llvm/Compiling.md

@@ -7,7 +7,7 @@ permalink: /reference-manual/llvm/Compiling/
 # Compiling to LLVM Bitcode
 
 GraalVM can execute C/C++, Rust, and other languages that can be compiled to LLVM bitcode.
-As the first step, you have to compile a program to LLVM bitcode using some LLVM compiler front end, for example, `clang` for C and C++, `rust` for the Rust programing language, etc.
+As the first step, you have to compile a program to LLVM bitcode using some LLVM compiler front end, for example, `clang` for C and C++, `rust` for the Rust programming language, etc.
 
 ## File Format
 

docs/reference-manual/native-image/DebugInfo.md

@@ -833,7 +833,7 @@ inlined compiled method code as well as mappings from code addresses
 to the corresponding source files and lines.
 `perf` and `valgrind` are able to use this information for some of
 their recording and reporting operations.
-For example, `perf report` is able to associate code adresses sampled
+For example, `perf report` is able to associate code addresses sampled
 during a `perf record` session with Java methods and print the
 DWARF-derived method name for the method in its output histogram.
 

docs/tools/insight/Insight-Manual.md

@@ -672,7 +672,7 @@ The `returnValue` function is always available on the provided `ctx` object, but
 
 If you ask whether GraalVM Insight causes any performance overhead when the scripts are applied, the answer is "No" or "Minimal".
 The overhead depends on what your scripts do.
-When they add and spread complex computations all around your code base, then the price for the computation will be payed.
+When they add and spread complex computations all around your code base, then the price for the computation will be paid.
 However, that would be overhead of your code, not of the instrumentation.
 Using a simple _function-count.js_ script, measure overhead.
 

docs/tools/insight/README.md

@@ -210,7 +210,7 @@ That provides ultimate insights into execution and behavior of one's application
 
 To continue learning and deep dive into GraalVM Insight, proceed to the [Insight Manual](Insight-Manual.md) which starts with an obligatory _HelloWorld_ example and then demonstrates more challenging tasks.
 
-### Embeddeding GraalVM Insight into Applications
+### Embedding GraalVM Insight into Applications
 
 GraalVM languages (languages implemented with the Truffle framework) can be embedded into custom applications via [Polyglot Context API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/Context.html).
 GraalVM Insight can also be controlled via the same API.

espresso/docs/continuations.md

@@ -122,7 +122,7 @@ There are special situations in which a call to `suspend` may fail with `Illegal
 - If in between the call to `resume` and `suspend` any of the following holds:
     - A lock is held (this may be an object monitor through the `MONITORENTER` bytecode, or even
       a `java.util.concurrent.locks.ReentrantLock`).
-    - There is a non-java frame on the stack (this could be a `native` method, or even a VM instrinsic).
+    - There is a non-java frame on the stack (this could be a `native` method, or even a VM intrinsic).
 
 Furthermore, there is currently no support for continuation-in-continuation.
 

espresso/docs/how-espresso-works.md

@@ -177,7 +177,7 @@ a series of slots stored on the host stack, or when _materialized_, the frame is
 languages these slots are strongly typed and correspond to the base Java type system with ints, booleans, longs and
 object references etc. Espresso however uses Truffle's _static slots_, which are (somewhat confusingly) both typed and
 untyped at the same time. The Truffle `Frame` interface has an API for reading and writing to static slots which
-distinguishes betwen primitive types (`get/setObjectStatic`, `get/setLongStatic` etc), but the actual primitive type of
+distinguishes between primitive types (`get/setObjectStatic`, `get/setLongStatic` etc), but the actual primitive type of
 a static slot is tracked only when assertions are enabled i.e. in debug mode. You can see some of this code in Truffle's
 `FrameWithoutBoxing` class. In normal execution the slot types are marked only as being "static". This is OK because
 Java bytecode implicitly types stack slots. The types aren't recorded in the bytecode itself, but can be recovered using

sdk/CHANGELOG.md

@@ -128,7 +128,7 @@ the close operation throws a [`PolyglotException`](https://www.graalvm.org/sdk/j
 
 ## Version 22.0.0
 * (GR-31170) Native Image API: Added `WINDOWS_AARCH64` Platform.
-* (GR-33657) Native Image API: Added `CEntryPoint#include` attribute which can be used to controll if the entry point should be automatically added to the shared library.
+* (GR-33657) Native Image API: Added `CEntryPoint#include` attribute which can be used to control if the entry point should be automatically added to the shared library.
 * (GR-22699)(EE-only) Added the ability to spawn a native-image isolate for a each `Engine` or `Context` by calling `Context.Builder.option("engine.SpawnIsolate", "true")`.  This enables heap isolation between the host and guest applications. Using isolates improves security, startup and warmup time of polyglot languages. In this mode, calls between host and guest are more costly as they need to cross a native boundary. It is recommended to use the `HostAccess.SCOPED` policy with this mode to avoid strong cyclic references between host and guest. This mode is experimental in this release and only supported for a limited set of languages. 
 
 ## Version 21.3.0

sdk/mx.sdk/vm/windows.md

@@ -58,7 +58,7 @@ to work.
 ## Testing
 
 A primitive way to test the windows script is to copy the template to a file
-named `test.cmd`, and make a couple temporary adjustements:
+named `test.cmd`, and make a couple temporary adjustments:
 
 - Prefix the final command invocation with `echo`.
 - Escape all substitution tags that live within strings with `^`. e.g.

substratevm/CHANGELOG.md

@@ -26,7 +26,7 @@ At runtime, premain runtime options are set along with main class' arguments in
 * (GR-47832) Experimental support for upcalls from foreign code and other improvements to our implementation of the [Foreign Function & Memory API](https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/ForeignInterface.md) (part of "Project Panama", [JEP 454](https://openjdk.org/jeps/454)) on AMD64. Must be enabled with `-H:+ForeignAPISupport` (requiring `-H:+UnlockExperimentalVMOptions`).
 * (GR-52314) `-XX:MissingRegistrationReportingMode` can now be used on program invocation instead of as a build option, to avoid a rebuild when debugging missing registration errors.
 * (GR-51086) Introduce a new `--static-nolibc` API option as a replacement for the experimental `-H:±StaticExecutableWithDynamicLibC` option.
-* (GR-52732) Introduce a new `ReduceImplicitExceptionStackTraceInformation` hosted option that reduces image size by reducing the runtime metadata for implicit exceptions, at the cost of stack trace precision. The option is diabled by default, but enabled with optimization level 3 and profile guided optimizations.
+* (GR-52732) Introduce a new `ReduceImplicitExceptionStackTraceInformation` hosted option that reduces image size by reducing the runtime metadata for implicit exceptions, at the cost of stack trace precision. The option is disabled by default, but enabled with optimization level 3 and profile guided optimizations.
 * (GR-52534) Change the digest (used e.g. for symbol names) from SHA-1 encoded as a hex string (40 bytes) to 128-bit Murmur3 as a Base-62 string (22 bytes).
 * (GR-52578) Print information about embedded resources into `embedded-resources.json` using the `-H:+GenerateEmbeddedResourcesFile` option.
 * (GR-51172) Add support to catch OutOfMemoryError exceptions on native image if there is no memory left.

substratevm/docs/module-system/ModuleSystemSupportRuntime.md

@@ -17,7 +17,7 @@ The purpose of the runtime module support:
 - `com.oracle.svm.core.jdk.Target_java_lang_ModuleLayer`:
     - `boot()` - replaces the hosted boot module layer with our own
 
-Some data structures also need to be substituted/resetted as to not pull in hosted modules (see runtime module synthesizing):
+Some data structures also need to be substituted/reset as to not pull in hosted modules (see runtime module synthesizing):
 - `com.oracle.svm.core.jdk.Target_java_lang_Module_ReflectionData`
 
 

sulong/docs/contributor/INTEROP.md

@@ -111,7 +111,7 @@ a native pointer pointing to the type returned by the `getNativeType` message.
 The value returned by `getNativeType` should be a `polyglot_typeid` as returned
 by a `polyglot_*_typeid` function (see `graalvm/llvm/polyglot.h`).
 
-The foreing object will then behave as if it was cast by `polyglot_as_typed(type, ...)`
+The foreign object will then behave as if it was cast by `polyglot_as_typed(type, ...)`
 to that type.
 
 ### `isPointer`/`asPointer`

tools/CHANGELOG.md

@@ -36,7 +36,7 @@ This changelog summarizes major changes between Truffle Tools versions.
 * Reimplemented CPUSampler to use the Truffle language safepoints thus deprecating several API functions.
 * Added new option `--cpusampler.SampleContextInitialization` which includes code executed during context initialization in the general sampling profile instead of grouping it into a single entry.
 * Default CLI output of CPUSampler was simplified to not include compiled times.
-* CPUSampler APIs to distingish compiled from interpreted samples were replaced by a more general API that supports an arbitrary number of compilation tiers.
+* CPUSampler APIs to distinguish compiled from interpreted samples were replaced by a more general API that supports an arbitrary number of compilation tiers.
 * Added the --cpusampler.ShowTiers option that shows time spend in each optimization tier.
 * Support for hash interoperability in Insight - no need to use `Truffle::Interop.hash_keys_as_members` anymore
 * [Cooperative heap dumping](https://www.graalvm.org/tools/javadoc/org/graalvm/tools/insight/heap/package-summary.html) when embedding Insight into Java applications

tools/docs/Insight.md

@@ -52,7 +52,7 @@ That provides ultimate insights into execution and behavior of one's application
 
 Consult the [Insight Manual](../../docs/tools/insight/Insight-Manual.md) to get started with an obligatory HelloWorld example and other challenging tasks.
 
-## Embeddeding Insight into Applications
+## Embedding Insight into Applications
 
 GraalVM languages (languages implemented with the Truffle framework) can be embedded into custom applications via [Polyglot Context API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/Context.html). GraalVM Insight can also be controlled via the same API.