diff --git a/www/comparison.html b/www/comparison.html
index f29c267..0bfff12 100644
--- a/www/comparison.html
+++ b/www/comparison.html
@@ -50,9 +50,9 @@
     <ul>
     <li>GCC supports languages that clang does not aim to, such as Java, Ada,
         FORTRAN, etc.</li>
-    <li>GCC front-ends are very mature and already support C/C++/ObjC and all
-        the variants we are interested in.  <a href="cxx_status.html">clang's 
-        support for C++</a> in particular is nowhere near what GCC supports.</li>
+    <li>GCC front-ends are very mature and already support C++.
+        <a href="cxx_status.html">clang's support for C++</a> is nowhere near 
+        what GCC supports.</li>
     <li>GCC supports more targets than LLVM.</li>
     <li>GCC is popular and widely adopted.</li>
     <li>GCC does not require a C++ compiler to build it.</li>
