diff --git a/docs/LinkTimeOptimization.html b/docs/LinkTimeOptimization.html
index b3bc4814fdc..52ab119707c 100644
--- a/docs/LinkTimeOptimization.html
+++ b/docs/LinkTimeOptimization.html
@@ -79,7 +79,7 @@ conservative escape analysis.
   <p>The following example illustrates the advantages of LTO's integrated
   approach and clean interface. This example requires a system linker which
   supports LTO through the interface described in this document.  Here,
-  llvm-gcc transparently invokes system linker. </p>
+  clang transparently invokes system linker. </p>
   <ul>
     <li> Input source file <tt>a.c</tt> is compiled into LLVM bitcode form.
     <li> Input source file <tt>main.c</tt> is compiled into native object code.
@@ -89,27 +89,29 @@ conservative escape analysis.
 extern int foo1(void);
 extern void foo2(void);
 extern void foo4(void);
+
 --- a.c ---
 #include "a.h"
 
 static signed int i = 0;
 
 void foo2(void) {
- i = -1;
+  i = -1;
 }
 
 static int foo3() {
-foo4();
-return 10;
+  foo4();
+  return 10;
 }
 
 int foo1(void) {
-int data = 0;
+  int data = 0;
 
-if (i &lt; 0) { data = foo3(); }
+  if (i &lt; 0) 
+    data = foo3();
 
-data = data + 42;
-return data;
+  data = data + 42;
+  return data;
 }
 
 --- main.c ---
@@ -117,30 +119,35 @@ return data;
 #include "a.h"
 
 void foo4(void) {
- printf ("Hi\n");
+  printf("Hi\n");
 }
 
 int main() {
- return foo1();
+  return foo1();
 }
 
 --- command lines ---
-$ llvm-gcc --emit-llvm -c a.c -o a.o  # &lt;-- a.o is LLVM bitcode file
-$ llvm-gcc -c main.c -o main.o # &lt;-- main.o is native object file
-$ llvm-gcc a.o main.o -o main # &lt;-- standard link command without any modifications
+$ clang -emit-llvm -c a.c -o a.o   # &lt;-- a.o is LLVM bitcode file
+$ clang -c main.c -o main.o        # &lt;-- main.o is native object file
+$ clang a.o main.o -o main         # &lt;-- standard link command without any modifications
 </pre>
-  <p>In this example, the linker recognizes that <tt>foo2()</tt> is an 
-  externally visible symbol defined in LLVM bitcode file. The linker completes 
-  its usual symbol resolution 
-  pass and finds that <tt>foo2()</tt> is not used anywhere. This information 
-  is used by the LLVM optimizer and it removes <tt>foo2()</tt>. As soon as 
-  <tt>foo2()</tt> is removed, the optimizer recognizes that condition 
-  <tt>i &lt; 0</tt> is always false, which means <tt>foo3()</tt> is never 
-  used. Hence, the optimizer removes <tt>foo3()</tt>, also.  And this in turn, 
-  enables linker to remove <tt>foo4()</tt>.  This example illustrates the 
-  advantage of tight integration with the linker. Here, the optimizer can not 
-  remove <tt>foo3()</tt> without the linker's input.
-  </p>
+
+<ul>
+  <li>In this example, the linker recognizes that <tt>foo2()</tt> is an
+      externally visible symbol defined in LLVM bitcode file. The linker
+      completes its usual symbol resolution pass and finds that <tt>foo2()</tt>
+      is not used anywhere. This information is used by the LLVM optimizer and
+      it removes <tt>foo2()</tt>.</li>
+  <li>As soon as <tt>foo2()</tt> is removed, the optimizer recognizes that condition 
+      <tt>i &lt; 0</tt> is always false, which means <tt>foo3()</tt> is never 
+      used. Hence, the optimizer also removes <tt>foo3()</tt>.</li>
+  <li>And this in turn, enables linker to remove <tt>foo4()</tt>.</li>
+</ul>
+
+<p>This example illustrates the advantage of tight integration with the
+   linker. Here, the optimizer can not remove <tt>foo3()</tt> without the
+   linker's input.</p>
+
 </div>
 
 <!-- ======================================================================= -->