NaCl documentation: improve building documentation

native_client_sdk/doc_generated/devguide/devcycle/building.html

 {{+bindTo:partials.standard_nacl_article}}
 
 <section id="building">
 <span id="devcycle-building"></span><h1 id="building"><span id="devcycle-building"></span>Building</h1>
 <div class="contents local" id="table-of-contents" style="display: none">
 <p class="topic-title first">Table Of Contents</p>
 <ul class="small-gap">
 <li><p class="first"><a class="reference internal" href="#introduction" id="id4">Introduction</a></p>
 <ul class="small-gap">
 <li><a class="reference internal" href="#target-architectures" id="id5">Target architectures</a></li>
@@ skipping 37 matching lines @@
 developers who have experience writing, compiling, and linking C and C++ code.
 If you haven&#8217;t read the Native Client <a class="reference internal" href="/native-client/overview.html"><em>Technical Overview</em></a> and <a class="reference internal" href="/native-client/devguide/tutorial/index.html"><em>Tutorial</em></a>, we recommend starting
 with those.</p>
 <section id="target-architectures">
 <span id="id1"></span><h3 id="target-architectures"><span id="id1"></span>Target architectures</h3>
 <p>Portable Native Client (PNaCl) modules are written in C or C++ and compiled
 into an executable file ending in a <strong>.pexe</strong> extension using the PNaCl
 toolchain in the Native Client SDK. Chrome can load <strong>pexe</strong> files
 embedded in web pages and execute them as part of a web application.</p>
 <p>As explained in the Technical Overview, PNaCl modules are
-operating-system-independent <strong>and</strong> processor-independent. The same
-<strong>pexe</strong>  will run on Windows, Mac, Linux, and ChromeOS and it will run on
-any processor, e.g., x86-32, x86-64, and ARM.</p>
+operating-system-independent <strong>and</strong> processor-independent. The same <strong>pexe</strong>
+will run on Windows, Mac OS X, Linux, and ChromeOS and it will run on processor
+such as x86-32, x86-64, ARM and MIPS.</p>
 <p>Native Client also supports architecture-specific <strong>nexe</strong> files.
 These <strong>nexe</strong> files are <strong>also</strong> operating-system-independent,
 but they are <strong>not</strong> processor-independent. To support a wide variety of
 devices you must compile separate versions of your Native Client module
 for different processors on end-user machines. A
 <a class="reference internal" href="/native-client/overview.html#application-files"><em>manifest file</em></a> will then specify which version
 of the module to load based on the end-user&#8217;s architecture. The SDK
 includes a script&#8212;<code>create_nmf.py</code> (in the <code>tools/</code> directory)&#8212;to
 generate manifest files. For examples of how to compile modules
 for multiple target architectures and how to generate manifest files, see the
 Makefiles included with the SDK examples.</p>
 <p>This section will mostly cover PNaCl, but also describes how to build
-nexe applications.</p>
+<strong>nexe</strong> applications.</p>
 </section><section id="c-libraries">
 <h3 id="c-libraries">C libraries</h3>
 <p>The PNaCl SDK has a single choice of C library: <a class="reference external" href="http://sourceware.org/newlib/">newlib</a>.</p>
 <p>The Native Client SDK also has a GCC-based toolchain for building
 <strong>nexes</strong>. The GCC-based toolchain has support for two C libraries:
 <a class="reference external" href="http://sourceware.org/newlib/">newlib</a> and <a class="reference external" href="http://www.gnu.org/software/libc/">glibc</a>.  See <a class="reference internal" href="/native-client/devguide/devcycle/dynamic-loading.html"><em>Dynamic Linking &amp; Loading with glibc</em></a> for information about these libraries, including factors to
 help you decide which to use.</p>
 </section><section id="c-standard-libraries">
 <span id="building-cpp-libraries"></span><h3 id="c-standard-libraries"><span id="building-cpp-libraries"></span>C++ standard libraries</h3>
 <p>The PNaCl SDK can use either LLVM&#8217;s <a class="reference external" href="http://libcxx.llvm.org/">libc++</a>
 (the current default) or GCC&#8217;s <a class="reference external" href="http://gcc.gnu.org/libstdc++">libstdc++</a> (deprecated). The
 <code>-stdlib=[libc++|libstdc++]</code> command line argument can be used to
 choose which standard library to use.</p>
 <p>The GCC-based Native Client SDK only has support for GCC&#8217;s <a class="reference external" href="http://gcc.gnu.org/libstdc++">libstdc++</a>.</p>
 <p>C++11 library support is only complete in libc++ but other non-library
 language features should work regardless of which standard library is
 used. The <code>-std=[c++98|c++11]</code> command line argument can be used to
 indicate which C++ language standard to use (or <code>-std=gnu++11</code> to
-access non-standard extensions).</p>
+access non-standard extensions which newlib often relies on).</p>
 </section><section id="sdk-toolchains">
 <h3 id="sdk-toolchains">SDK toolchains</h3>
 <p>The Native Client SDK includes multiple toolchains. It has one PNaCl toolchain
 and it has multiple GCC-based toolchains that are differentiated by target
 architectures and C libraries. The single PNaCl toolchain is located
 in a directory named <code>toolchain/&lt;OS_platform&gt;_pnacl</code>, and the GCC-based
 toolchains are located in directories named
 <code>toolchain/&lt;OS_platform&gt;_&lt;architecture&gt;_&lt;library&gt;</code>, where:</p>
 <ul class="small-gap">
-<li><em>&lt;platform&gt;</em> is the platform of your development machine (win, mac, or linux)</li>
-<li><em>&lt;architecture&gt;</em> is your target architecture (x86 or arm)</li>
-<li><em>&lt;library&gt;</em> is the C library you are compiling with (newlib or glibc)</li>
+<li><dl class="first docutils">
+<dt><em>&lt;platform&gt;</em> is the platform of your development machine (<em>win</em>, <em>mac</em>, or</dt>
+<dd><em>linux</em>)</dd>
+</dl>
+</li>
+<li><em>&lt;architecture&gt;</em> is your target architecture (<em>x86</em> or <em>arm</em>)</li>
+<li><em>&lt;library&gt;</em> is the C library you are compiling with (<em>newlib</em> or <em>glibc</em>)</li>
 </ul>
 <p>The compilers, linkers, and other tools are located in the <code>bin/</code>
 subdirectory in each toolchain. For example, the tools in the Windows SDK
 for PNaCl has a C++ compiler in <code>toolchain/win_pnacl/bin/pnacl-clang++</code>.
-As another example, the GCC-based C++ compiler that targets the x86 and uses the
+As another example, the GCC-based C++ compiler that targets x86 and uses the
 newlib library, is located at <code>toolchain/win_x86_newlib/bin/x86_64-nacl-g++</code>.</p>
 <aside class="note">
 The SDK toolchains descend from the <code>toolchain/</code> directory. The SDK also
 has a <code>tools/</code> directory; this directory contains utilities that are not
 properly part of the toolchains but that you may find helpful in building and
 testing your application (e.g., the <code>create_nmf.py</code> script, which you can
 use to create a manifest file).
 </aside>
 </section><section id="sdk-toolchains-versus-your-hosted-toolchain">
 <h3 id="sdk-toolchains-versus-your-hosted-toolchain">SDK toolchains versus your hosted toolchain</h3>
@@ skipping 19 matching lines @@
 modules written in other programming languages, such as C#. But this
 document covers only compiling C and C++ code, using the toolchains
 provided in the SDK.
 </aside>
 </section></section><section id="the-pnacl-toolchain">
 <h2 id="the-pnacl-toolchain">The PNaCl toolchain</h2>
 <p>The PNaCl toolchain contains modified versions of the tools in the
 LLVM toolchain, as well as linkers and other tools from binutils.
 To determine which version of LLVM or binutils the tools are based upon,
 run the tool with the <code>--version</code> command line flag. These tools
-are used to compile and link applications into .pexe files. The toolchain
-also contains a tool to translate a .pexe file into a
-architecture-specific .nexe (e.g., for debugging purposes).</p>
+are used to compile and link applications into <strong>.pexe</strong> files. The toolchain
+also contains a tool to translate a <strong>pexe</strong> file into a
+architecture-specific <strong>.nexe</strong> (e.g., for debugging purposes).</p>
 <p>Each tool&#8217;s name is preceded by the prefix &#8220;pnacl-&#8221;. Some of the useful
 tools include:</p>
 <dl class="docutils">
 <dt>pnacl-abicheck</dt>
 <dd>Check that the <strong>pexe</strong> follows the PNaCl ABI rules.</dd>
 <dt>pnacl-ar</dt>
 <dd>Creates archives (i.e., static libraries)</dd>
 <dt>pnacl-clang</dt>
 <dd>C compiler and compiler driver</dd>
 <dt>pnacl-clang++</dt>
@@ skipping 54 matching lines @@
 rather than continue the build process and link together the
 full application.</dd>
 <dt><code>-o &lt;output_file&gt;</code></dt>
 <dd>indicates the <strong>output</strong> filename.</dd>
 <dt><code>-g</code></dt>
 <dd>tells the compiler to include debug information in the result.
 This debug information can be used during development, and then <strong>stripped</strong>
 before actually deploying the application to keep the application&#8217;s
 download size small.</dd>
 <dt><code>-On</code></dt>
-<dd><p class="first">sets the optimization level to n. Use 0 when debugging, and -O2 or -O3
-for profiling and deployment.</p>
-<p class="last">The main difference between -O2 and -O3 is whether the compiler performs
-optimizations that involve a space-speed tradeoff. It could be the case that
-<code>-O3</code> optimizations are not desirable due to increased <strong>pexe</strong>
+<dd><p class="first">sets the optimization level to n. Use <code>-O0</code> when debugging, and <code>-O2</code> or
+<code>-O3</code> for profiling and deployment.</p>
+<p class="last">The main difference between <code>-O2</code> and <code>-O3</code> is whether the compiler
+performs optimizations that involve a space-speed tradeoff. It could be the
+case that <code>-O3</code> optimizations are not desirable due to increased <strong>pexe</strong>
 download size; you should make your own performance measurements to determine
-which level of optimization is right for you. When looking at code size,
-note that what you generally care about is not the size of the pexe
-produced by pnacl-clang, but the size of the compressed pexe that you upload
-your application to the server or to the Chrome Web Store.
-Optimizations that increase the size of a pexe may not increase the size of
-the compressed pexe that much.</p>
+which level of optimization is right for you. When looking at code size, note
+that what you generally care about is not the size of the <strong>pexe</strong> produced by
+<code>pnacl-clang</code>, but the size of the compressed <strong>pexe</strong> that you upload your
+application to the server or to the Chrome Web Store. Optimizations that
+increase the size of a <strong>pexe</strong> may not increase the size of the compressed
+<strong>pexe</strong> that much.</p>
 </dd>
 <dt><code>-I&lt;directory&gt;</code></dt>
 <dd>adds a directory to the search path for <strong>include</strong> files. The SDK has
 Pepper (PPAPI) headers located at <code>&lt;NACL_SDK_ROOT&gt;/include</code>, so add
 that directory when compiling to be able to include the headers.</dd>
+<dt><code>-mllvm -inline-threshold=5</code></dt>
+<dd>change how much inlining is performed by LLVM. The right number to choose is
+often application-specific, you&#8217;ll therefore want to experiment with the value
+that you pass in: you&#8217;ll be trading off potential performance with <strong>pexe</strong>
+size and on-device translation speed.</dd>
 </dl>
 </section><section id="create-a-static-library">
 <h3 id="create-a-static-library">Create a static library</h3>
 <p>The <code>pnacl-ar</code> and <code>pnacl-ranlib</code> tools allow you to create a
 <strong>static</strong> library from a set of bitcode files, which can later be linked
 into the full application.</p>
 <pre>
 &lt;NACL_SDK_ROOT&gt;/toolchain/win_pnacl/bin/pnacl-ar cr libfoo.a ^
   foo1.o foo2.o foo3.o
 
 &lt;NACL_SDK_ROOT&gt;/toolchain/win_pnacl/bin/pnacl-ranlib libfoo.a
 </pre>
 </section><section id="link-the-application">
 <h3 id="link-the-application">Link the application</h3>
 <p>The <code>pnacl-clang++</code> tool is used to compile applications, but it can
 also be used link together compiled bitcode and libraries into a
 full application.</p>
 <pre>
 &lt;NACL_SDK_ROOT&gt;/toolchain/win_pnacl/bin/pnacl-clang++ -o hello_world.pexe ^
   hello_world.o -L&lt;NACL_SDK_ROOT&gt;/lib/pnacl/Debug -lfoo -lppapi_cpp -lppapi
 </pre>
 <p>This links the hello world bitcode with the <code>foo</code> library in the example
 as well as the <em>Debug</em> version of the Pepper libraries which are located
 in <code>&lt;NACL_SDK_ROOT&gt;/lib/pnacl/Debug</code>. If you wish to link against the
 <em>Release</em> version of the Pepper libraries, change the
 <code>-L&lt;NACL_SDK_ROOT&gt;/lib/pnacl/Debug</code> to
 <code>-L&lt;NACL_SDK_ROOT&gt;/lib/pnacl/Release</code>.</p>
+<p>In a release build you&#8217;ll want to pass <code>-O2</code> to the compiler <em>as well as to
+the linker</em> to enable link-time optimizations. This reduces the size and
+increases the performance of the final <strong>pexe</strong>, and leads to faster downloads
+and on-device translation.</p>
+<p>By default the link step will turn all C++ exceptions into calls to <code>abort()</code>
+to reduce the size of the final <strong>pexe</strong> as well as making it translate and run
+faster. If you want to use C++ exceptions you should use the
+<code>--pnacl-exceptions=sjlj</code> linker flag as explained in the <a class="reference internal" href="/native-client/reference/pnacl-c-cpp-language-support.html#exception-handling"><em>exception
+handling</em></a> section of the C++ language support reference.</p>
 </section><section id="finalizing-the-pexe-for-deployment">
 <h3 id="finalizing-the-pexe-for-deployment">Finalizing the <strong>pexe</strong> for deployment</h3>
-<p>Typically you would run the application to test it and debug it if needed
-before deploying. See the <a class="reference internal" href="/native-client/devguide/devcycle/running.html"><em>running</em></a> documentation for how
-to run a PNaCl application, and see the <a class="reference internal" href="/native-client/devguide/devcycle/debugging.html"><em>debugging</em></a>
-documentation for debugging techniques and workflow. After testing a PNaCl
-application, you must <strong>&#8220;finalize&#8221;</strong> it. The <code>pnacl-finalize</code>
-tool handles this.</p>
+<p>Typically you would run the application to test it and debug it if needed before
+deploying. See the <a class="reference internal" href="/native-client/devguide/devcycle/running.html"><em>running</em></a> documentation for how to run a PNaCl
+application, and see the <a class="reference internal" href="/native-client/devguide/devcycle/debugging.html"><em>debugging</em></a> documentation for
+debugging techniques and workflow. After testing a PNaCl application, you must
+<strong>finalize</strong> it. The <code>pnacl-finalize</code> tool handles this.</p>
 <pre>
 &lt;NACL_SDK_ROOT&gt;/toolchain/win_pnacl/bin/pnacl-finalize ^
   hello_world.pexe -o hello_world.final.pexe
 </pre>
 <p>Prior to finalization, the application <strong>pexe</strong> is stored in a binary
 format that is subject to change.  After finalization, the application
-pexe is <strong>rewritten</strong> into a different binary format that is <strong>stable</strong>
+<strong>pexe</strong> is <strong>rewritten</strong> into a different binary format that is <strong>stable</strong>
 and will be supported by future versions of PNaCl. The finalization step
 also helps minimize the size of your application for distribution by
 stripping out debug information and other metadata.</p>
 <p>Once the application is finalized, be sure to adjust the manifest file to
 refer to the final version of the application before deployment.
 The <code>create_nmf.py</code> tool helps generate an <code>.nmf</code> file, but <code>.nmf</code>
 files can also be written by hand.</p>
 </section><section id="compressing-the-pexe-for-deployment">
 <span id="pnacl-compress"></span><h3 id="compressing-the-pexe-for-deployment"><span id="pnacl-compress"></span>Compressing the <strong>pexe</strong> for deployment</h3>
 <p>Size compression is an optional step for deployment, and reduces the
-size of the pexe file that must be transmitted over the wire. The tool
+size of the <strong>pexe</strong> file that must be transmitted over the wire. The tool
 <code>pnacl-compress</code> applies compression strategies that are already built
-into the <strong>stable</strong> binary format of a pexe application. As such,
-compressed pexe files do not need any extra time to be decompressed on
+into the <strong>stable</strong> binary format of a <strong>pexe</strong> application. As such,
+compressed <strong>pexe</strong> files do not need any extra time to be decompressed on
 the client&#8217;s side. All costs are upfront when you call <code>pnacl-compress</code>.</p>
-<p>Currently, this tool will compress pexe files by about 25%. However,
+<p>Currently, this tool will compress <strong>pexe</strong> files by about 25%. However,
 it is somewhat slow (can take from seconds to minutes on large
 appications). Hence, this step is optional.</p>
 <pre>
 &lt;NACL_SDK_ROOT&gt;/toolchain/win_pnacl/bin/pnacl-compress ^
   hello_world.final.pexe
 </pre>
-<p>Tool <code>pnacl-compress</code> must be called after a pexe file has been finalized
+<p>Tool <code>pnacl-compress</code> must be called after a <strong>pexe</strong> file has been finalized
 for deployment (via <code>pnacl-finalize</code>). Alternatively, you can apply this
 step as part of the finalizing step by adding the <code>--compress</code> flag
-to the pnacl-finalize command line.</p>
-<p>Note that this compression step doesn&#8217;t replace gzip. This compression
-step is in addition to gzipping a file for deployment. One should note
-that while the gzipped version of a compressed pexe file is still
-smaller than the corresponding uncompressed pexe file, the gains is
-somewhat smaller after being gzipped. Expected reduction in size
-(after being gzipped) is more like 7.5% to 10%.</p>
+to the <code>pnacl-finalize</code> command line.</p>
+<p>Note that this compression step doesn&#8217;t replace the gzip compression performed
+by most web servers as part of HTTP compression. This compression step is in
+addition to gzipping a file for deployment. One should note that while the
+gzipped version of a compressed <strong>pexe</strong> file is still smaller than the
+corresponding uncompressed <strong>pexe</strong> file, the gains is somewhat smaller after
+being gzipped. Expected reduction in size (after being gzipped) is closer to
+7.5% to 10%.</p>
 </section></section><section id="the-gnu-based-toolchains">
 <h2 id="the-gnu-based-toolchains">The GNU-based toolchains</h2>
 <p>Besides the PNaCl toolchain, the Native Client SDK also includes modified
 versions of the tools in the standard GNU toolchain, including the GCC
 compilers and the linkers and other tools from binutils. These tools only
 support building <strong>nexe</strong> files. Run the tool with the <code>--version</code>
 command line flag to determine the current version of the tools.</p>
 <p>Each tool in the toolchain is prefixed with the name of the target
 architecture. In the toolchain for the ARM target architecture, each
 tool&#8217;s name is preceded by the prefix &#8220;arm-nacl-&#8221;. In the toolchains for
 the x86 target architecture, there are actually two versions of each
 tool&#8212;one to build Native Client modules for the x86-32
 target architecture, and one to build modules for the x86-64 target
 architecture. &#8220;i686-nacl-&#8221; is the prefix for tools used to build
-32-bit .nexes, and &#8220;x86_64-nacl-&#8221; is the prefix for tools used to
-build 64-bit .nexes</p>
+32-bit <strong>.nexes</strong>, and &#8220;x86_64-nacl-&#8221; is the prefix for tools used to
+build 64-bit <strong>.nexes</strong>.</p>
 <p>These prefixes conform to gcc naming standards and make it easy to use tools
 like autoconf. As an example, you can use <code>i686-nacl-gcc</code> to compile 32-bit
-.nexes, and <code>x86_64-nacl-gcc</code> to compile 64-bit .nexes. Note that you can
-typically override a tool&#8217;s default target architecture with command line
+<strong>.nexes</strong>, and <code>x86_64-nacl-gcc</code> to compile 64-bit <strong>.nexes</strong>. Note that you
+can typically override a tool&#8217;s default target architecture with command line
 flags, e.g., you can specify <code>x86_64-nacl-gcc -m32</code> to compile a 32-bit
-.nexe.</p>
+<strong>.nexe</strong>.</p>
 <p>The GNU-based SDK toolchains include the following tools:</p>
 <ul class="small-gap">
 <li>&lt;prefix&gt;addr2line</li>
 <li>&lt;prefix&gt;ar</li>
 <li>&lt;prefix&gt;as</li>
 <li>&lt;prefix&gt;c++</li>
 <li>&lt;prefix&gt;c++filt</li>
 <li>&lt;prefix&gt;cpp</li>
 <li>&lt;prefix&gt;g++</li>
 <li>&lt;prefix&gt;gcc</li>
@@ skipping 10 matching lines @@
 <li>&lt;prefix&gt;size</li>
 <li>&lt;prefix&gt;strings</li>
 <li>&lt;prefix&gt;strip</li>
 </ul>
 <section id="compiling">
 <h3 id="compiling">Compiling</h3>
 <p>Compiling files with the GNU-based toolchain is similar to compiling
 files with the PNaCl-based toolchain, except that the output is
 architecture specific.</p>
 <p>For example, assuming you&#8217;re developing on a Windows machine, targeting the x86
-architecture, and using the newlib library, you can compile a 32-bit .nexe for
-the hello_world example with the following command:</p>
+architecture, and using the newlib library, you can compile a 32-bit <strong>.nexe</strong>
+for the hello_world example with the following command:</p>
 <pre>
 &lt;NACL_SDK_ROOT&gt;/toolchain/win_x86_newlib/bin/i686-nacl-gcc hello_world.c ^
   -I&lt;NACL_SDK_ROOT&gt;/include -L&lt;NACL_SDK_ROOT&gt;/lib/newlib/Release ^
   -o hello_world_x86_32.nexe -m32 -g -O2 -lppapi
 </pre>
-<p>To compile a 64-bit .nexe, you can run the same command but use -m64 instead of
--m32. Alternatively, you could also use the version of the compiler that
+<p>To compile a 64-bit <strong>.nexe</strong>, you can run the same command but use -m64 instead
+of -m32. Alternatively, you could also use the version of the compiler that
 targets the x86-64 architecture, i.e., <code>x86_64-nacl-gcc</code>.</p>
 <p>You should name executable modules with a <strong>.nexe</strong> filename extension,
 regardless of what platform you&#8217;re using.</p>
 </section><section id="creating-libraries-and-linking">
 <h3 id="creating-libraries-and-linking">Creating libraries and Linking</h3>
 <p>Creating libraries and linking with the GNU-based toolchain is similar
 to doing the same with the PNaCl toolchain.  The relevant tools
 for creating <strong>static</strong> libraries are <code>&lt;prefix&gt;ar</code> and <code>&lt;prefix&gt;ranlib</code>.
 Linking can be done with <code>&lt;prefix&gt;g++</code>. See the
 <a class="reference internal" href="/native-client/devguide/devcycle/dynamic-loading.html"><em>Dynamic Linking &amp; Loading with glibc</em></a>
 section on how to create <strong>shared</strong> libraries.</p>
 </section><section id="finalizing-a-nexe-for-deployment">
 <h3 id="finalizing-a-nexe-for-deployment">Finalizing a <strong>nexe</strong> for deployment</h3>
 <p>Unlike the PNaCl toolchain, no separate finalization step is required
-for <strong>nexe</strong> files. The nexe files are always in a <strong>stable</strong> format.
-However, the nexe file may contain debug information and symbol information
-which may make the nexe file larger than needed for distribution.
+for <strong>nexe</strong> files. The <strong>nexe</strong> files are always in a <strong>stable</strong> format.
+However, the <strong>nexe</strong> file may contain debug information and symbol information
+which may make the <strong>nexe</strong> file larger than needed for distribution.
 To minimize the size of the distributed file, you can run the
 <code>&lt;prefix&gt;strip</code> tool to strip out debug information.</p>
 </section></section><section id="using-make">
 <h2 id="using-make">Using make</h2>
 <p>This document doesn&#8217;t cover how to use <code>make</code>, but if you want to use
 <code>make</code> to build your Native Client module, you can base your Makefile on the
 ones in the SDK examples.</p>
 <p>The Makefiles for the SDK examples build most of the examples in multiple
 configurations (using PNaCl vs NaCl, using different C libraries,
 targeting different architectures, and using different levels of optimization).
 To select a specific toolchain, set the <strong>environment variable</strong>
 <code>TOOLCHAIN</code> to either <code>pnacl</code>, <code>newlib</code>, <code>glibc</code>, or <code>host</code>.
 To select a specific level of optimization set the <strong>environment
 variable</strong> <code>CONFIG</code> to either <code>Debug</code>, or <code>Release</code>. Running
 <code>make</code> in each example&#8217;s directory does <strong>one</strong> of the following,
 depending on the setting of the environment variables.</p>
 <ul class="small-gap">
 <li><p class="first">If <code>TOOLCHAIN=pnacl</code> creates a subdirectory called <code>pnacl</code>;</p>
 <ul class="small-gap">
-<li>builds a .pexe (architecture-independent Native Client executable) using
+<li>builds a <strong>.pexe</strong> (architecture-independent Native Client executable) using
 the newlib library</li>
 <li>generates a Native Client manifest (.nmf) file for the pnacl version of the
 example</li>
 </ul>
 </li>
 <li><p class="first">If <code>TOOLCHAIN=newlib</code> creates a subdirectory called <code>newlib</code>;</p>
 <ul class="small-gap">
-<li>builds .nexes for the x86-32, x86-64, and ARM architectures using the
+<li>builds <strong>.nexes</strong> for the x86-32, x86-64, and ARM architectures using the
 newlib library</li>
 <li>generates a Native Client manifest (.nmf) file for the newlib version of
 the example</li>
 </ul>
 </li>
 <li><p class="first">If <code>TOOLCHAIN=glibc</code> creates a subdirectory called <code>glibc</code>;</p>
 <ul class="small-gap">
-<li>builds .nexes for the x86-32 and x86-64 architectures using the glibc
+<li>builds <strong>.nexes</strong> for the x86-32 and x86-64 architectures using the glibc
 library</li>
 <li>generates a Native Client manifest (.nmf) file for the glibc version of the
 example</li>
 </ul>
 </li>
 <li><p class="first">If <code>TOOLCHAIN=host</code> creates a subdirectory called <code>windows</code>, <code>linux</code>,
 or <code>mac</code> (depending on your development machine);</p>
 <ul class="small-gap">
 <li>builds a Pepper plugin (.dll for Windows, .so for Linux/Mac) using the
 hosted toolchain on your development machine</li>
@@ skipping 148 matching lines @@
 Function foo has disallowed type: i128 (i128)
 LLVM ERROR: PNaCl ABI verification failed
 </pre>
 <p>When faced with a PNaCl ABI verification error, check the list of features
 that are <a class="reference internal" href="/native-client/nacl-and-pnacl.html#when-to-use-nacl"><em>not supported by PNaCl</em></a>.
 If the problem you face is not listed as restricted,
 <a class="reference internal" href="/native-client/help.html#help"><em>let us know</em></a>!</p>
 </section></section></section>
 
 {{/partials.standard_nacl_article}}