pch: Fix streaming of strings with embedded null bytes

When a GTY'ed struct is streamed to PCH, any plain char* pointers it contains
(whether they live in GC-controlled memory or not) will be marked for PCH
output by the routine gt_pch_note_object in ggc-common.cc. This routine
special-cases plain char* strings, and in particular it uses strlen() to get
their length. Thus it does not handle strings with embedded null bytes, but it
is possible for something PCH cares about (such as a string literal token in a
macro definition) to contain such embedded nulls. To fix that up, add a new
GTY option "string_length" so that gt_pch_note_object can be informed the
actual length it ought to use, and use it in the relevant libcpp structs
(cpp_string and ht_identifier) accordingly.

gcc/ChangeLog:

	* gengtype.cc (output_escaped_param): Add missing const.
	(get_string_option): Add missing check for option type.
	(walk_type): Support new "string_length" GTY option.
	(write_types_process_field): Likewise.
	* ggc-common.cc (gt_pch_note_object): Add optional length argument.
	* ggc.h (gt_pch_note_object): Adjust prototype for new argument.
	(gt_pch_n_S2): Declare...
	* stringpool.cc (gt_pch_n_S2): ...new function.
	* doc/gty.texi: Document new GTY((string_length)) option.

libcpp/ChangeLog:

	* include/cpplib.h (struct cpp_string): Use new "string_length" GTY.
	* include/symtab.h (struct ht_identifier): Likewise.

gcc/testsuite/ChangeLog:

	* g++.dg/pch/pch-string-nulls.C: New test.
	* g++.dg/pch/pch-string-nulls.Hs: New test.

diff --git a/gcc/doc/gty.texi b/gcc/doc/gty.texi
index 81aafd11ce3e32a7386704b7ea7f1a2437833632..4f791b300ba44c82b88686edee33bffeac946f9e 100644 (file)
--- a/gcc/doc/gty.texi
+++ b/gcc/doc/gty.texi
@@ -196,7 +196,26 @@ static GTY((length("reg_known_value_size"))) rtx *reg_known_value;
 Note that the @code{length} option is only meant for use with arrays of
 non-atomic objects, that is, objects that contain pointers pointing to
 other GTY-managed objects.  For other GC-allocated arrays and strings
-you should use @code{atomic}.
+you should use @code{atomic} or @code{string_length}.
+
+@findex string_length
+@item string_length ("@var{expression}")
+
+In order to simplify production of PCH, a structure member that is a plain
+array of bytes (an optionally @code{const} and/or @code{unsigned} @code{char
+*}) is treated specially by the infrastructure. Even if such an array has not
+been allocated in GC-controlled memory, it will still be written properly into
+a PCH.  The machinery responsible for this needs to know the length of the
+data; by default, the length is determined by calling @code{strlen} on the
+pointer.  The @code{string_length} option specifies an alternate way to
+determine the length, such as by inspecting another struct member:
+
+@smallexample
+struct GTY(()) non_terminated_string @{
+  size_t sz;
+  const char * GTY((string_length ("%h.sz"))) data;
+@};
+@end smallexample
 
 @findex skip
 @item skip

diff --git a/gcc/gengtype.cc b/gcc/gengtype.cc
index 42363439bd8bd73ad5215b12145d1b44eedc9cca..28bf05e9c57fa6afbc19992f8de66717b1f96d88 100644 (file)
--- a/gcc/gengtype.cc
+++ b/gcc/gengtype.cc
@@ -2403,7 +2403,7 @@ struct write_types_data
   enum write_types_kinds kind;
 };
 
-static void output_escaped_param (struct walk_type_data *d,
+static void output_escaped_param (const struct walk_type_data *d,
                                  const char *, const char *);
 static void output_mangled_typename (outf_p, const_type_p);
 static void walk_type (type_p t, struct walk_type_data *d);
@@ -2537,7 +2537,7 @@ output_mangled_typename (outf_p of, const_type_p t)
    print error messages.  */
 
 static void
-output_escaped_param (struct walk_type_data *d, const char *param,
+output_escaped_param (const struct walk_type_data *d, const char *param,
                      const char *oname)
 {
   const char *p;
@@ -2576,7 +2576,7 @@ const char *
 get_string_option (options_p opt, const char *key)
 {
   for (; opt; opt = opt->next)
-    if (strcmp (opt->name, key) == 0)
+    if (opt->kind == OPTION_STRING && strcmp (opt->name, key) == 0)
       return opt->info.string;
   return NULL;
 }
@@ -2700,6 +2700,8 @@ walk_type (type_p t, struct walk_type_data *d)
       ;
     else if (strcmp (oo->name, "callback") == 0)
       ;
+    else if (strcmp (oo->name, "string_length") == 0)
+      ;
     else
       error_at_line (d->line, "unknown option `%s'\n", oo->name);
 
@@ -3251,7 +3253,22 @@ write_types_process_field (type_p f, const struct walk_type_data *d)
        {
          oprintf (d->of, "%*sgt_%s_", d->indent, "", wtd->prefix);
          output_mangled_typename (d->of, f);
-         oprintf (d->of, " (%s%s);\n", cast, d->val);
+
+         /* Check if we need to call the special pch note version
+            for strings that takes an explicit length.  */
+         const auto length_override
+           = (f->kind == TYPE_STRING && !strcmp (wtd->prefix, "pch_n")
+              ? get_string_option (d->opt, "string_length")
+              : nullptr);
+         if (length_override)
+           {
+             oprintf (d->of, "2 (%s%s, ", cast, d->val);
+             output_escaped_param (d, length_override, "string_length");
+           }
+         else
+           oprintf (d->of, " (%s%s", cast, d->val);
+
+         oprintf (d->of, ");\n");
          if (d->reorder_fn && wtd->reorder_note_routine)
            oprintf (d->of, "%*s%s (%s%s, %s%s, %s);\n", d->indent, "",
                     wtd->reorder_note_routine, cast, d->val, cast, d->val,

diff --git a/gcc/ggc-common.cc b/gcc/ggc-common.cc
index 8b3389e8760e9c32ed4032e623b03a9fec85c376..62da09d66a7372c6a79c0d4005f7a5740b1f2eb6 100644 (file)
--- a/gcc/ggc-common.cc
+++ b/gcc/ggc-common.cc
@@ -253,7 +253,8 @@ static vec<void *> reloc_addrs_vec;
 
 int
 gt_pch_note_object (void *obj, void *note_ptr_cookie,
-                   gt_note_pointers note_ptr_fn)
+                   gt_note_pointers note_ptr_fn,
+                   size_t length_override)
 {
   struct ptr_data **slot;
 
@@ -273,7 +274,9 @@ gt_pch_note_object (void *obj, void *note_ptr_cookie,
   (*slot)->obj = obj;
   (*slot)->note_ptr_fn = note_ptr_fn;
   (*slot)->note_ptr_cookie = note_ptr_cookie;
-  if (note_ptr_fn == gt_pch_p_S)
+  if (length_override != (size_t)-1)
+    (*slot)->size = length_override;
+  else if (note_ptr_fn == gt_pch_p_S)
     (*slot)->size = strlen ((const char *)obj) + 1;
   else
     (*slot)->size = ggc_get_size (obj);

diff --git a/gcc/ggc.h b/gcc/ggc.h
index aeec1bafb9b3fbb24dc1f7d9e55fb2efa3d5b466..7bc74ec82b530f3d8ffca6fd81aa7f38d151abdf 100644 (file)
--- a/gcc/ggc.h
+++ b/gcc/ggc.h
@@ -44,7 +44,8 @@ typedef void (*gt_handle_reorder) (void *, void *, gt_pointer_operator,
                                   void *);
 
 /* Used by the gt_pch_n_* routines.  Register an object in the hash table.  */
-extern int gt_pch_note_object (void *, void *, gt_note_pointers);
+extern int gt_pch_note_object (void *, void *, gt_note_pointers,
+                              size_t length_override = (size_t)-1);
 
 /* Used by the gt_pch_p_* routines.  Register address of a callback
    pointer.  */
@@ -101,6 +102,7 @@ extern int ggc_marked_p     (const void *);
 
 /* PCH and GGC handling for strings, mostly trivial.  */
 extern void gt_pch_n_S (const void *);
+extern void gt_pch_n_S2 (const void *, size_t);
 extern void gt_ggc_m_S (const void *);
 
 /* End of GTY machinery API.  */

diff --git a/gcc/stringpool.cc b/gcc/stringpool.cc
index 57509d58e15ccff6b3a64a7a732ab4af031dea7e..20dbef5580c79558b1e386962d0e9a550f0214bb 100644 (file)
--- a/gcc/stringpool.cc
+++ b/gcc/stringpool.cc
@@ -196,6 +196,13 @@ gt_pch_n_S (const void *x)
                      &gt_pch_p_S);
 }
 
+void
+gt_pch_n_S2 (const void *x, size_t string_len)
+{
+  gt_pch_note_object (CONST_CAST (void *, x), CONST_CAST (void *, x),
+                     &gt_pch_p_S, string_len);
+}
+
 
 /* User-callable entry point for marking string X.  */
 

diff --git a/gcc/testsuite/g++.dg/pch/pch-string-nulls.C b/gcc/testsuite/g++.dg/pch/pch-string-nulls.C
new file mode 100644 (file)
index 0000000..dfeb21a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pch/pch-string-nulls.C
@@ -0,0 +1,3 @@
+// { dg-do compile { target c++11 } }
+#include "pch-string-nulls.H"
+static_assert (X[4] == '[' && X[5] == '!' && X[6] == ']', "error");

diff --git a/gcc/testsuite/g++.dg/pch/pch-string-nulls.Hs b/gcc/testsuite/g++.dg/pch/pch-string-nulls.Hs
new file mode 100644 (file)
index 0000000..02f4317
Binary files /dev/null and b/gcc/testsuite/g++.dg/pch/pch-string-nulls.Hs differ

diff --git a/libcpp/include/cpplib.h b/libcpp/include/cpplib.h
index d5ef12a30ead7cf13045cee0b911f94e9c62ec26..1d34c00669fca653c11c094cb6af6569a9945dd7 100644 (file)
--- a/libcpp/include/cpplib.h
+++ b/libcpp/include/cpplib.h
@@ -179,7 +179,11 @@ enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11, CLK_GNUC17, CLK_GNUC2X,
 /* Payload of a NUMBER, STRING, CHAR or COMMENT token.  */
 struct GTY(()) cpp_string {
   unsigned int len;
-  const unsigned char *text;
+
+  /* TEXT is always null terminated (terminator not included in len); but this
+     GTY markup arranges that PCH streaming works properly even if there is a
+     null byte in the middle of the string.  */
+  const unsigned char * GTY((string_length ("1 + %h.len"))) text;
 };
 
 /* Flags for the cpp_token structure.  */

diff --git a/libcpp/include/symtab.h b/libcpp/include/symtab.h
index 53efe6c3943aee70352a93ce2de3b931565f2345..8b45fd5c2ceb94d18c6547a97935991f951cade6 100644 (file)
--- a/libcpp/include/symtab.h
+++ b/libcpp/include/symtab.h
@@ -29,7 +29,10 @@ along with this program; see the file COPYING3.  If not see
 typedef struct ht_identifier ht_identifier;
 typedef struct ht_identifier *ht_identifier_ptr;
 struct GTY(()) ht_identifier {
-  const unsigned char *str;
+  /* This GTY markup arranges that the null-terminated identifier would still
+     stream to PCH correctly, if a null byte were to make its way into an
+     identifier somehow.  */
+  const unsigned char * GTY((string_length ("1 + %h.len"))) str;
   unsigned int len;
   unsigned int hash_value;
 };