This patch documents various improvements in GCC 8 for our website.
There are lots of examples of colorized output from GCC (generated
using ansi2html); the patch uses the ansi2html.css from the previous
patch for styling them.
Caveat: I don't have the toolchain working for building the site, so
I was only able to test the CSS by manually hacking the <head> during
testing. The patch adds the CSS there. I hope this works.
Successfully checked as XHTML 1.0 Transitional.
---
htdocs/gcc-8/changes.html | 264 +++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 263 insertions(+), 1 deletion(-)
diff --git a/htdocs/gcc-8/changes.html b/htdocs/gcc-8/changes.html
index 7b76e34..122d02d 100644
--- a/htdocs/gcc-8/changes.html
+++ b/htdocs/gcc-8/changes.html
@@ -1,6 +1,7 @@
<html>
<head>
+ <link rel="stylesheet" type="text/css" href="../ansi2html.css" />
<title>GCC 8 Release Series — Changes, New Features, and Fixes</title>
</head>
@@ -120,11 +121,243 @@ a work-in-progress.</h2>
default at all optimization levels. Using
<code>-fsanitize=signed-integer-overflow</code> is now the preferred
way to audit code, <code>-Wstrict-overflow</code> is deprecated.</li>
+ <li>When reporting mismatching argument types at a function call, the
+ C and C++ compilers now underline both the argument and the pertinent
+ parameter in the declaration.
+<pre class="f9 b9">
+$ gcc arg-type-mismatch.cc
+<span class="bold">arg-type-mismatch.cc:</span> In function '<span
class="bold">int caller(int, int, float)</span>':
+<span class="bold">arg-type-mismatch.cc:5:24:</span> <span class="bold"><span
class="f1">error: </span></span>invalid conversion from '<span
class="bold">int</span>' to '<span class="bold">const char*</span>' [<span
class="bold"><span class="f1">-fpermissive</span></span>]
+ return callee(first, <span class="bold"><span
class="f1">second</span></span>, third);
+ <span class="bold"><span
class="f1">^~~~~~</span></span>
+<span class="bold">arg-type-mismatch.cc:1:40:</span> <span class="bold"><span
class="f6">note: </span></span> initializing argument 2 of '<span
class="bold">int callee(int, const char*, float)</span>'
+ extern int callee(int one, <span class="bold"><span class="f6">const char
*two</span></span>, float three);
+ <span class="bold"><span
class="f6">~~~~~~~~~~~~^~~</span></span>
+</pre>
+
+ </li>
+ <li>When reporting on unrecognized identifiers, the C and C++ compilers
+ will now emit fix-it hints suggesting <code>#include</code> directives
+ for various headers in the C and C++ standard libraries.
+<pre class="f9 b9">
+$ gcc incomplete.c
+<span class="bold">incomplete.c:</span> In function '<span
class="bold">test</span>':
+<span class="bold">incomplete.c:3:10:</span> <span class="bold"><span
class="f1">error: </span></span>'<span class="bold">NULL</span>' undeclared
(first use in this function)
+ return <span class="bold"><span class="f1">NULL</span></span>;
+ <span class="bold"><span class="f1">^~~~</span></span>
+<span class="bold">incomplete.c:3:10:</span> <span class="bold"><span
class="f6">note: </span></span>'<span class="bold">NULL</span>' is defined in
header '<span class="bold"><stddef.h></span>'; did you forget to '<span
class="bold">#include <stddef.h></span>'?
+<span class="bold">incomplete.c:1:1:</span>
++<span class="f2">#include <stddef.h></span>
+ const char *test(void)
+<span class="bold">incomplete.c:3:10:</span>
+ return <span class="bold"><span class="f6">NULL</span></span>;
+ <span class="bold"><span class="f6">^~~~</span></span>
+<span class="bold">incomplete.c:3:10:</span> <span class="bold"><span
class="f6">note: </span></span>each undeclared identifier is reported only once
for each function it appears in
+</pre>
+
+<pre class="f9 b9">
+$ gcc incomplete.cc
+<span class="bold">incomplete.cc:1:6:</span> <span class="bold"><span
class="f1">error: </span></span>'<span class="bold">string</span>' in namespace
'<span class="bold">std</span>' does not name a type
+ std::<span class="bold"><span class="f1">string</span></span> s("hello
world");
+ <span class="bold"><span class="f1">^~~~~~</span></span>
+<span class="bold">incomplete.cc:1:1:</span> <span class="bold"><span
class="f6">note: </span></span>'<span class="bold">std::string</span>' is
defined in header '<span class="bold"><string></span>'; did you forget to
'<span class="bold">#include <string></span>'?
++<span class="f2">#include <string></span>
+ <span class="bold"><span class="f6">std</span></span>::string s("hello
world");
+ <span class="bold"><span class="f6">^~~</span></span>
+</pre>
+
+ </li>
+ <li>The C and C++ compilers now use more intuitive locations when
+ reporting on missing semicolons, and offer fix-it hints:
+<pre class="f9 b9">
+$ gcc t.c
+<span class="bold">t.c:</span> In function '<span class="bold">test</span>':
+<span class="bold">t.c:3:12:</span> <span class="bold"><span class="f1">error:
</span></span>expected '<span class="bold">;</span>' before '<span
class="bold">}</span>' token
+ return 42
+ <span class="bold"><span class="f1">^</span></span>
+ <span class="f2">;</span>
+ <span class="f2">}</span>
+ <span class="f2">~</span>
+</pre>
+
+ </li>
+ <li>When reporting on missing '}' and ')' tokens, the C and C++
+ compilers will now highlight the corresponding '{' and '(' token,
+ issuing a 'note' if it's on a separate line:
+<pre class="f9 b9">
+$ gcc unclosed.c
+<span class="bold">unclosed.c:</span> In function '<span
class="bold">log_when_out_of_range</span>':
+<span class="bold">unclosed.c:12:50:</span> <span class="bold"><span
class="f1">error: </span></span>expected '<span class="bold">)</span>' before
'<span class="bold">{</span>' token
+ && (temperature < MIN || temperature > MAX)<span
class="bold"><span class="f1"> </span></span><span class="f2">{</span>
+ <span class="bold"><span
class="f1">^</span></span><span class="f2">~</span>
+ <span class="f2">)</span>
+<span class="bold">unclosed.c:11:6:</span> <span class="bold"><span
class="f6">note: </span></span>to match this '<span class="bold">(</span>'
+ if <span class="bold"><span class="f6">(</span></span>logging_enabled
&& check_range ()
+ <span class="bold"><span class="f6">^</span></span>
+</pre>
+ or highlighting it directly if it's on the same line:
+<pre class="f9 b9">
+$ gcc unclosed-2.c
+<span class="bold">unclosed-2.c:</span> In function '<span
class="bold">test</span>':
+<span class="bold">unclosed-2.c:8:45:</span> <span class="bold"><span
class="f1">error: </span></span>expected '<span class="bold">)</span>' before
'<span class="bold">{</span>' token
+ if <span class="f4">(</span>temperature < MIN || temperature >
MAX<span class="bold"><span class="f1"> </span></span><span class="f2">{</span>
+ <span class="f4">~</span> <span
class="bold"><span class="f1">^</span></span><span class="f2">~</span>
+ <span class="f2">)</span>
+</pre>
+ They will also emit fix-it hints.
+ </li>
</ul>
<h3 id="cxx">C++</h3>
<ul>
- <li></li>
+ <li>When reporting on attempts to access private fields of a class or
+ struct, the C++ compiler will now offer fix-it hints showing how to
+ use an accessor function to get at the field in question, if one exists.
+<pre class="f9 b9">
+$ gcc accessor.cc
+<span class="bold">accessor.cc:</span> In function '<span class="bold">void
test(foo*)</span>':
+<span class="bold">accessor.cc:12:12:</span> <span class="bold"><span
class="f1">error: </span></span>'<span class="bold">double foo::m_ratio</span>'
is private within this context
+ if (ptr-><span class="bold"><span class="f1">m_ratio</span></span> >=
0.5)
+ <span class="bold"><span class="f1">^~~~~~~</span></span>
+<span class="bold">accessor.cc:7:10:</span> <span class="bold"><span
class="f6">note: </span></span>declared private here
+ double <span class="bold"><span class="f6">m_ratio</span></span>;
+ <span class="bold"><span class="f6">^~~~~~~</span></span>
+<span class="bold">accessor.cc:12:12:</span> <span class="bold"><span
class="f6">note: </span></span>field '<span class="bold">double
foo::m_ratio</span>' can be accessed via '<span class="bold">double
foo::get_ratio() const</span>'
+ if (ptr-><span class="bold"><span class="f6">m_ratio</span></span> >=
0.5)
+ <span class="bold"><span class="f6">^~~~~~~</span></span>
+ <span class="f2">get_ratio()</span>
+</pre>
+
+ </li>
+ <li>The C++ compiler can now give you a hint if you use a macro before it
+ was defined (e.g. if you mess up the order of your <code>#include</code>
+ directives):
+<pre class="f9 b9">
+$ gcc ordering.cc
+<span class="bold">ordering.cc:2:24:</span> <span class="bold"><span
class="f1">error: </span></span>expected '<span class="bold">;</span>' at end
of member declaration
+ virtual void clone() <span class="bold"><span
class="f1">const</span></span> OVERRIDE { }
+ <span class="bold"><span class="f1">^~~~~</span></span>
+ <span class="f2">;</span>
+<span class="bold">ordering.cc:2:30:</span> <span class="bold"><span
class="f1">error: </span></span>'<span class="bold">OVERRIDE</span>' does not
name a type
+ virtual void clone() const <span class="bold"><span
class="f1">OVERRIDE</span></span> { }
+ <span class="bold"><span
class="f1">^~~~~~~~</span></span>
+<span class="bold">ordering.cc:2:30:</span> <span class="bold"><span
class="f6">note: </span></span>the macro '<span class="bold">OVERRIDE</span>'
had not yet been defined
+In file included from <span class="bold">ordering.cc:5</span>:
+<span class="bold">c++11-compat.h:2:</span> <span class="bold"><span
class="f6">note: </span></span>it was later defined here
+ #define OVERRIDE override
+
+</pre>
+
+ </li>
+ <li>The <code>-Wold-style-cast</code> diagnostic can now emit fix-it hints
+ telling you when you can use a <code>static_cast</code>,
+ <code>const_cast</code>, or <code>reinterpret_cast</code>.
+<pre class="f9 b9">
+$ gcc -c old-style-cast-fixits.cc -Wold-style-cast
+<span class="bold">old-style-cast-fixits.cc:</span> In function '<span
class="bold">void test(void*)</span>':
+<span class="bold">old-style-cast-fixits.cc:5:19:</span> <span
class="bold"><span class="f5">warning: </span></span>use of old-style cast to
'<span class="bold">struct foo*</span>' [<span class="bold"><span
class="f5">-Wold-style-cast</span></span>]
+ foo *f = (foo *)<span class="bold"><span class="f5">ptr</span></span>;
+ <span class="bold"><span class="f5">^~~</span></span>
+ <span class="f1">----------</span>
+ <span class="f2">static_cast<foo *> (ptr)</span>
+</pre>
+
+ </li>
+ <li>When reporting on problems within <code>extern "C"</code> linkage
+ specifications, the C++ compiler will now display the location of the
+ start of the <code>extern "C"</code>.
+<pre class="f9 b9">
+$ gcc -c extern-c.cc
+<span class="bold">extern-c.cc:3:1:</span> <span class="bold"><span
class="f1">error: </span></span>template with C linkage
+ <span class="bold"><span class="f1">template</span></span> <typename T>
void test (void);
+ <span class="bold"><span class="f1">^~~~~~~~</span></span>
+In file included from <span class="bold">extern-c.cc:1</span>:
+<span class="bold">unclosed.h:1:1:</span> <span class="bold"><span
class="f6">note: </span></span>'<span class="bold">extern "C"</span>'
linkage started here
+ <span class="bold"><span class="f6">extern "C"</span></span> {
+ <span class="bold"><span class="f6">^~~~~~~~~~</span></span>
+<span class="bold">extern-c.cc:3:39:</span> <span class="bold"><span
class="f1">error: </span></span>expected '<span class="bold">}</span>' at end
of input
+ template <typename T> void test (void)<span class="bold"><span
class="f1">;</span></span>
+ <span class="bold"><span
class="f1">^</span></span>
+In file included from <span class="bold">extern-c.cc:1</span>:
+<span class="bold">unclosed.h:1:12:</span> <span class="bold"><span
class="f6">note: </span></span>to match this '<span class="bold">{</span>'
+ extern "C" <span class="bold"><span class="f6">{</span></span>
+ <span class="bold"><span class="f6">^</span></span>
+</pre>
+
+ </li>
+ <li>When reporting on mismatching template types, the C++ compiler will
+ now use color to highlight the mismatching parts of the template, and will
+ elide the parameters that are common between two mismatching templates,
+ printing <code>[...]</code> instead:
+<pre class="f9 b9">
+$ gcc templates.cc
+<span class="bold">templates.cc:</span> In function '<span class="bold">void
test()</span>':
+<span class="bold">templates.cc:9:8:</span> <span class="bold"><span
class="f1">error: </span></span>could not convert '<span
class="bold">vector<double>()</span>' from '<span
class="bold">vector<<span class="bold"><span
class="f2">double</span></span></span>>' to '<span
class="bold">vector<<span class="bold"><span
class="f2">int</span></span></span>>'
+ fn_1(<span class="bold"><span class="f1">vector<double>
()</span></span>);
+ <span class="bold"><span class="f1">^~~~~~~~~~~~~~~~~</span></span>
+<span class="bold">templates.cc:10:8:</span> <span class="bold"><span
class="f1">error: </span></span>could not convert '<span
class="bold">map<int, double>()</span>' from '<span
class="bold">map<[...],<span class="bold"><span
class="f2">double</span></span></span>>' to '<span
class="bold">map<[...],<span class="bold"><span
class="f2">int</span></span></span>>'
+ fn_2(<span class="bold"><span class="f1">map<int,
double>()</span></span>);
+ <span class="bold"><span class="f1">^~~~~~~~~~~~~~~~~~</span></span>
+</pre>
+
+ Those <code>[...]</code> elided parameters can be seen using
+ <code>-fno-elide-type</code>:
+<pre class="f9 b9">
+$ gcc templates.cc -fno-elide-type
+<span class="bold">templates.cc:</span> In function '<span class="bold">void
test()</span>':
+<span class="bold">templates.cc:9:8:</span> <span class="bold"><span
class="f1">error: </span></span>could not convert '<span
class="bold">vector<double>()</span>' from '<span
class="bold">vector<<span class="bold"><span
class="f2">double</span></span></span>>' to '<span
class="bold">vector<<span class="bold"><span
class="f2">int</span></span></span>>'
+ fn_1(<span class="bold"><span class="f1">vector<double>
()</span></span>);
+ <span class="bold"><span class="f1">^~~~~~~~~~~~~~~~~</span></span>
+<span class="bold">templates.cc:10:8:</span> <span class="bold"><span
class="f1">error: </span></span>could not convert '<span
class="bold">map<int, double>()</span>' from '<span
class="bold">map<int,<span class="bold"><span
class="f2">double</span></span></span>>' to '<span
class="bold">map<int,<span class="bold"><span
class="f2">int</span></span></span>>'
+ fn_2(<span class="bold"><span class="f1">map<int,
double>()</span></span>);
+ <span class="bold"><span class="f1">^~~~~~~~~~~~~~~~~~</span></span>
+</pre>
+
+ The C++ compiler has also gained an option
+ <code>-fdiagnostics-show-template-tree</code> which visualizes such
+ mismatching templates in a hierarchical form:
+<pre class="f9 b9">
+$ gcc templates-2.cc -fdiagnostics-show-template-tree
+<span class="bold">templates-2.cc:</span> In function '<span class="bold">void
test()</span>':
+<span class="bold">templates-2.cc:9:8:</span> <span class="bold"><span
class="f1">error: </span></span>could not convert '<span
class="bold">vector<double>()</span>' from '<span
class="bold">vector<<span class="bold"><span
class="f2">double</span></span></span>>' to '<span
class="bold">vector<<span class="bold"><span
class="f2">int</span></span></span>>'
+ vector<
+ [<span class="bold"><span class="f2">double</span></span> != <span
class="bold"><span class="f2">int</span></span>]>
+ fn_1(<span class="bold"><span class="f1">vector<double>
()</span></span>);
+ <span class="bold"><span class="f1">^~~~~~~~~~~~~~~~~</span></span>
+<span class="bold">templates-2.cc:10:8:</span> <span class="bold"><span
class="f1">error: </span></span>could not convert '<span
class="bold">map<map<int, vector<double> >, vector<double>
>()</span>' from '<span class="bold">map<map<[...],vector<<span
class="bold"><span
class="f2">double</span></span></span>>>,vector<<span
class="bold"><span class="f2">double</span></span>>>' to '<span
class="bold">map<map<[...],vector<<span class="bold"><span
class="f2">float</span></span></span>>>,vector<<span
class="bold"><span class="f2">float</span></span>>>'
+ map<
+ map<
+ [...],
+ vector<
+ [<span class="bold"><span class="f2">double</span></span> != <span
class="bold"><span class="f2">float</span></span>]>>,
+ vector<
+ [<span class="bold"><span class="f2">double</span></span> != <span
class="bold"><span class="f2">float</span></span>]>>
+ fn_2(<span class="bold"><span class="f1">map<map<int,
vector<double>>, vector<double>> ()</span></span>);
+ <span class="bold"><span
class="f1">^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~</span></span>
+</pre>
+
+ which again works with <code>-fno-elide-type</code>:
+<pre class="f9 b9">
+$ gcc templates-2.cc -fdiagnostics-show-template-tree -fno-elide-type
+<span class="bold">templates-2.cc:</span> In function '<span class="bold">void
test()</span>':
+<span class="bold">templates-2.cc:9:8:</span> <span class="bold"><span
class="f1">error: </span></span>could not convert '<span
class="bold">vector<double>()</span>' from '<span
class="bold">vector<<span class="bold"><span
class="f2">double</span></span></span>>' to '<span
class="bold">vector<<span class="bold"><span
class="f2">int</span></span></span>>'
+ vector<
+ [<span class="bold"><span class="f2">double</span></span> != <span
class="bold"><span class="f2">int</span></span>]>
+ fn_1(<span class="bold"><span class="f1">vector<double>
()</span></span>);
+ <span class="bold"><span class="f1">^~~~~~~~~~~~~~~~~</span></span>
+<span class="bold">templates-2.cc:10:8:</span> <span class="bold"><span
class="f1">error: </span></span>could not convert '<span
class="bold">map<map<int, vector<double> >, vector<double>
>()</span>' from '<span class="bold">map<map<int,vector<<span
class="bold"><span
class="f2">double</span></span></span>>>,vector<<span
class="bold"><span class="f2">double</span></span>>>' to '<span
class="bold">map<map<int,vector<<span class="bold"><span
class="f2">float</span></span></span>>>,vector<<span
class="bold"><span class="f2">float</span></span>>>'
+ map<
+ map<
+ int,
+ vector<
+ [<span class="bold"><span class="f2">double</span></span> != <span
class="bold"><span class="f2">float</span></span>]>>,
+ vector<
+ [<span class="bold"><span class="f2">double</span></span> != <span
class="bold"><span class="f2">float</span></span>]>>
+ fn_2(<span class="bold"><span class="f1">map<map<int,
vector<double>>, vector<double>> ()</span></span>);
+ <span class="bold"><span
class="f1">^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~</span></span>
+</pre>
+
+ </li>
</ul>
<h3 id="fortran">Fortran</h3>
@@ -207,6 +440,19 @@ a work-in-progress.</h2>
<!-- .................................................................. -->
<h2 id="jit">libgccjit</h2>
+<p>The libgccjit API gained four new entrypoints:</p>
+<ul>
+ <li><a
href="https://gcc.gnu.org/onlinedocs/jit/topics/types.html#gcc_jit_type_get_vector";>gcc_jit_type_get_vector</a>
+ and
+ </li>
+ <li><a
href="https://gcc.gnu.org/onlinedocs/jit/topics/expressions.html#gcc_jit_context_new_rvalue_from_vector";>gcc_jit_context_new_rvalue_from_vector</a>
for working with vectors,
+ </li>
+ <li><a
href="https://gcc.gnu.org/onlinedocs/jit/topics/types.html#gcc_jit_type_get_aligned";>gcc_jit_type_get_aligned</a></li>
+ <li><a
href="https://gcc.gnu.org/onlinedocs/jit/topics/function-pointers.html#gcc_jit_function_get_address";>gcc_jit_function_get_address</a></li>
+</ul>
+<p>The C code generated by
+<a
href="https://gcc.gnu.org/onlinedocs/jit/topics/contexts.html#gcc_jit_context_dump_reproducer_to_file";>gcc_jit_context_dump_reproducer_to_file</a>
+is now easier-to-read.</p>
<!-- .................................................................. -->
<h2 id="targets">New Targets and Target Specific Improvements</h2>
@@ -569,6 +815,22 @@ a work-in-progress.</h2>
<!-- .................................................................. -->
+<h2 id="plugins">Improvements for plugin authors</h2>
+<ul>
+ <li>Plugins can now register a callback hook for when comments are
+ encountered by the C and C++ compiler, allowing e.g. for plugins
+ to handle documentation markup in code comments.
+ </li>
+ <li>The gdbinit support script for debugging gcc now has a
+ <code>break-on-diagnostic</code> command, providing an easy way
+ to trigger a breakpoint whenever a diagnostic is emitted.
+ </li>
+ <li>The API for creating fix-it hints now supports newlines, and for
+ emitting mutually-incompatible fix-it hints for one diagnostic.
+ </li>
+</ul>
+
+<!-- .................................................................. -->
<h2>Other significant improvements</h2>
<ul>
<li></li>
--
1.8.5.3
