internal_gengo: generate a const string literal for the raw descriptor

Putting the raw descriptor into a const string literal has been
attempted before (go.dev/cl/638135), but that change has been reverted
(go.dev/cl/642857) because the generated string contained non-UTF-8
bytes.

This time we let the %q formatting verb handle the conversion of the
bytes into a UTF-8-conform string literal.

We also found an interesting way to split the bytes into multiple
"lines": We use the fact that FileDescriptorProto (and some
submessages) have a LEN encoded field (string) with field_number=1,
so splitting at 0x0a (incidentally a newline character in ascii)
we get a splitting that almost looks readable.

As expected, the const string literals are landing in .rodata.

    % (go test -c google.golang.org/protobuf/internal/reflection_test &&
       strings -tx reflection_test.test | grep -F '2&.goproto.proto.testeditions.ImportEnumB' &&
       readelf -SW reflection_test.test | grep -F .rodata)
     321b07 2&.goproto.proto.testeditions.ImportEnumB
       [ 2] .rodata           PROGBITS        000000000065a000 25a000 131fc1 00   A  0   0 32

Change-Id: I77aef7b5032e52c2c485cf662045c9028549fd94
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/657895
Commit-Queue: Michael Stapelberg <[email protected]>
Reviewed-by: Cassondra Foesch <[email protected]>
Reviewed-by: Nicolas Hillegeer <[email protected]>
Reviewed-by: Michael Stapelberg <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: chressie

cmd/protoc-gen-go/internal_gengo/reflect.go

@@ -5,6 +5,7 @@
 package internal_gengo
 
 import (
+	"bytes"
 	"fmt"
 	"math"
 	"strings"
@@ -242,22 +243,22 @@ func genFileDescriptor(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileI
 		return
 	}
 
-	g.P("var ", rawDescVarName(f), " = string([]byte{")
-	for len(b) > 0 {
-		n := 16
-		if n > len(b) {
-			n = len(b)
-		}
-
-		s := ""
-		for _, c := range b[:n] {
-			s += fmt.Sprintf("0x%02x,", c)
-		}
-		g.P(s)
-
-		b = b[n:]
+	// Generate the raw descriptor as a kind-of readable const string.
+	// To not generate a single potentially very long line, we use the 0x0a
+	// byte to split the string into multiple "lines" and concatenate
+	// them with "+".
+	// The 0x0a comes from the observation that the FileDescriptorProto,
+	// and many of the messages it includes (for example
+	// DescriptorProto, EnumDescriptorProto, etc.), define a string
+	// (which is LEN encoded) as field with field_number=1.
+	// That makes all these messages start with (1<<3 + 2[:LEN])=0x0a
+	// in the wire-format.
+	// See also https://protobuf.dev/programming-guides/encoding/#structure.
+	fmt.Fprint(g, "const ", rawDescVarName(f), `=""`)
+	for _, line := range bytes.SplitAfter(b, []byte{'\x0a'}) {
+		g.P("+")
+		fmt.Fprintf(g, "%q", line)
 	}
-	g.P("})")
 	g.P()
 
 	if f.needRawDesc {