[GR-54633] Update Native Image static linking guide.

PullRequest: graal/18253

Author: olyagpl

docs/reference-manual/native-image/guides/build-static-and-mostly-static-executable.md

@@ -12,16 +12,14 @@ GraalVM Native Image by default builds dynamically linked binaries: at build tim
 
 However, you can create a statically linked or mostly-statically linked native executable, depending on your needs.
 
-**A static native executable** is a statically linked binary that can be used without any additional library dependencies.
+**A static native executable** is a statically linked binary that you can use without any additional library dependencies.
 A static native executable is easy to distribute and deploy on a slim or distroless container (a scratch container).
 You can create a static native executable by statically linking it against [musl-libc](https://musl.libc.org/), a lightweight, fast and simple `libc` implementation.
 
-**A mostly-static native executable** is a binary that links everything (`zlib`, JDK-shared static libraries) except the standard C library, `libc`. This is an alternative option to statically linking everything. Also, depending on the user's code, it may link `libstdc+` and `libgcc`.
+**A mostly-static native executable** is a binary that links all the shared libraries on which the native executable relies (`zlib`, JDK-shared static libraries) except the standard C library, `libc`. This is an alternative option to statically linking everything. Also, depending on the user's code, it may link `libstdc+` and `libgcc`.
 This approach is useful for deployment on a distroless container image.
 
-> Note: This currently only works when linked against `libc`.
-
-This guide shows how you can take advantage of Native Image linking options including fully dynamic, fully static, and mostly static (except `libc`) to generate an executable ideal for your deployment scenario.
+This guide shows how you can take advantage of Native Image linking options including fully dynamic, fully static, and mostly-static (except `libc`) to generate an executable ideal for your deployment scenario.
 
 ## Prerequisites and Preparation
 
@@ -33,7 +31,7 @@ This guide shows how you can take advantage of Native Image linking options incl
 The easiest way to install GraalVM is with [SDKMAN!](https://sdkman.io/jdks#graal).
 For other installation options, visit the [Downloads section](https://www.graalvm.org/downloads/).
 
-To be able to create static native applications with Native Image, a `musl` toolchain with the `zlib` library are required on the system.
+To create statically linked applications with Native Image, you require a `musl` toolchain with the `zlib` library.
 For the best compatibility, use [musl-1.2.4](https://musl.libc.org/releases/musl-1.2.4.tar.gz) or later.
 We recommend building `musl` from [source](https://musl.libc.org/) as shown below:
 
@@ -102,7 +100,13 @@ With the requirements set up, create the demo.
     native-image --static --libc=musl EnvMap
     ```
     This produces a native executable with statically linked system libraries.
-    You can pass other arguments before a class or JAR file. Run it with `./envmap`.
+    Run it with `./envmap`.
+
+    You can confirm the application is fully statically linked using the `ldd` command:
+    ```shell
+    ldd EnvMap
+    ```
+    The output should be "not a dynamic executable".
 
 ## Build a Mostly-Static Native Executable
 
@@ -128,8 +132,8 @@ One way to check what dynamic libraries your application depends on is to run `l
 
 #### What is the recommended base container image for deploying a static or mostly-static native executable?
 
-A fully static native executable gives you the most flexibility to choose a base container image—it can run on anything including a `FROM scratch` image.
-A mostly-static native executable requires a container image that provides `libc`, but has no additional requirements.
+A fully static native executable gives you the most flexibility to choose a base container image—it can even run on a `scratch` image.
+A mostly-static native executable requires a container image that provides `libc`, specifically `glibc`, but has no additional requirements.
 In both cases, choosing the base container image generally depends on your native executable's specific requirements.
 
 ### Related Documentation