diff --git a/docs/ReleaseNotes.html b/docs/ReleaseNotes.html
index 50cd906..5cd248c 100644
--- a/docs/ReleaseNotes.html
+++ b/docs/ReleaseNotes.html
@@ -576,14 +576,13 @@
 
 <div>
 
-<p>If you're already an LLVM user or developer with out-of-tree changes based
-on LLVM 2.9, this section lists some "gotchas" that you may run into upgrading
-from the previous release.</p>
+<p>If you're already an LLVM user or developer with out-of-tree changes based on
+   LLVM 2.9, this section lists some "gotchas" that you may run into upgrading
+   from the previous release.</p>
 
 <ul>
-<!--
-<li></li>
--->
+  <li>The <code>LowerSetJmp</code> wasn't used effectively by any of the
+      targets and was removed.</li>
 </ul>
 
 </div>
@@ -667,6 +666,9 @@
     isn't used by the current front-ends. So this was removed during the
     exception handling rewrite.</li>
 
+<li>The <code>LLVMAddLowerSetJmpPass</code> function from the C API was removed
+    because the <code>LowerSetJmp</code> pass was removed.</li>
+
 </ul>
 </div>
 
