diff --git a/docs/xml/quick-start-guide.xml b/docs/xml/quick-start-guide.xml
index 4c68516..b40952b 100644
--- a/docs/xml/quick-start-guide.xml
+++ b/docs/xml/quick-start-guide.xml
@@ -34,14 +34,16 @@
 to Valgrind version 2.4.0;  some of the information is not quite right for
 earlier versions.</para>
 
-<sect1>
+<sect1 id="quick-start.prepare" 
+       xreflabel="Preparing your program">
 <title>Preparing your program</title>
 <para>Compile your program with <computeroutput>-g</computeroutput> to include
 debugging information so that Memcheck's error messages include exact line
 numbers.</para>
 </sect1>
 
-<sect1>
+<sect1 id="quick-start.mcrun" 
+       xreflabel="Running your program under Memcheck">
 <title>Running your program under Memcheck</title>
 <para>If you normally run your program like this:
 
@@ -64,7 +66,8 @@
 and leaks that it detects.</para>
 </sect1>
 
-<sect1>
+<sect1 id="quick-start.interpret" 
+       xreflabel="Interpreting Memcheck's output">
 <title>Interpreting Memcheck's output</title>
 <para>Here's an example C program with a memory error and a memory leak.
 
@@ -170,7 +173,7 @@
 examples of all the error messages Memcheck produces.</para>
 </sect1>
 
-<sect1>
+<sect1 id="quick-start.caveats" xreflabel="Caveats">
 <title>Caveats</title>
 <para>Memcheck is not perfect;  it occasionally produces false positives,
 and there are mechanisms for suppressing these (see
@@ -184,7 +187,7 @@
 allocated statically or on the stack.</para>
 </sect1>
 
-<sect1>
+<sect1 id="quick-start.info" xreflabel="More Information">
 <title>More information</title>
 <para>Please consult the <xref linkend="FAQ"/> and the
 <xref linkend="manual"/>, which have much more information.  Note that the
diff --git a/memcheck/docs/mc-manual.xml b/memcheck/docs/mc-manual.xml
index c7fdaa5..8c963d0 100644
--- a/memcheck/docs/mc-manual.xml
+++ b/memcheck/docs/mc-manual.xml
@@ -396,16 +396,7 @@
 before the pointer actually returned.  This implies a
 variable-sized overhead in what's returned by
 <computeroutput>new</computeroutput> or
-<computeroutput>new[]</computeroutput>.  It rather surprising how
-compilers
-<footnote>
-  <para>[Ed: runtime-support libraries ?]</para>
-</footnote>
-are robust to mismatch in <computeroutput>new</computeroutput> /
-<computeroutput>delete</computeroutput>
-<computeroutput>new[]</computeroutput> /
-<computeroutput>delete[]</computeroutput>.</para>
-
+<computeroutput>new[]</computeroutput>.
 </sect2>
 
 
diff --git a/memcheck/docs/mc-tech-docs.xml b/memcheck/docs/mc-tech-docs.xml
index be1b852..2819330 100644
--- a/memcheck/docs/mc-tech-docs.xml
+++ b/memcheck/docs/mc-tech-docs.xml
@@ -1534,7 +1534,7 @@
 
 
 
-<sect2 id="mc-manual.trans" xreflabel="Translation into UCode">
+<sect2 id="mc-tech-docs.trans" xreflabel="Translation into UCode">
 <title>Translation into UCode</title>
 
 <para><computeroutput>VG_(disBB)</computeroutput> allocates a new
