Fixed linker array sentinel on GCC, and added a test.

This change modifies the `UPB_LINKARR_DECLARE` macro to use inline assembly to create a weak anchor symbol within the linkarr section. This ensures that the `__start_linkarr_` and `__stop_linkarr_` symbols are always defined by the linker, even when no other objects are placed in that section. The previous sentinel mechanism was broken on GCC.

A new test, generated_registry_empty_test, is added to verify that the generated registry can be loaded successfully and is empty when no extensions are actually linked into the binary.

Also adds `upb_exttable_size` and `upb_ExtensionRegistry_Size` for testing purposes.

PiperOrigin-RevId: 904021133

Author: haberman

upb/BUILD

@@ -310,6 +310,7 @@ filegroup(
         "//src/google/protobuf:well_known_type_protos",
         "//upb/json:test_protos",
         "//upb/message:test_protos",
+        "//upb/mini_table:test_protos",
         "//upb/test:test_protos",
         "//upb/util:test_protos",
         "//upb/wire:test_protos",

upb/hash/common.c

@@ -718,6 +718,8 @@ const uint32_t* upb_exttable_remove(upb_exttable* t, const void* k,
   return NULL;
 }
 
+size_t upb_exttable_size(const upb_exttable* t) { return t->t.count; }
+
 /* upb_inttable ***************************************************************/
 
 /* For inttables we use a hybrid structure where small keys are kept in an

upb/hash/ext_table.h

@@ -55,6 +55,8 @@ const uint32_t* upb_exttable_lookup(const upb_exttable* t, const void* k,
 const uint32_t* upb_exttable_remove(upb_exttable* t, const void* k,
                                     uint32_t ext_number);
 
+size_t upb_exttable_size(const upb_exttable* t);
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

upb/mini_table/BUILD

@@ -154,6 +154,28 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "generated_registry_empty_test",
+    srcs = ["generated_registry_empty_test.cc"],
+    linkstatic = 1,
+    deps = [
+        ":generated_registry_empty_test_upb_minitable_proto",
+        ":mini_table",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
+proto_library(
+    name = "generated_registry_empty_test_proto",
+    srcs = ["generated_registry_empty_test.proto"],
+)
+
+upb_minitable_proto_library(
+    name = "generated_registry_empty_test_upb_minitable_proto",
+    deps = [":generated_registry_empty_test_proto"],
+)
+
 proto_library(
     name = "message_benchmark_proto",
     testonly = 1,
@@ -240,3 +262,13 @@ filegroup(
     ),
     visibility = ["//upb:__pkg__"],
 )
+
+filegroup(
+    name = "test_protos",
+    srcs = glob(
+        [
+            "**/*test.proto",
+        ],
+    ),
+    visibility = ["//upb:__pkg__"],
+)

upb/mini_table/extension_registry.c

@@ -84,3 +84,7 @@ const upb_MiniTableExtension* upb_ExtensionRegistry_Lookup(
   const uint32_t* v = upb_exttable_lookup(&r->exts, t, num);
   return (const upb_MiniTableExtension*)v;
 }
+
+size_t upb_ExtensionRegistry_Size(const upb_ExtensionRegistry* r) {
+  return upb_exttable_size(&r->exts);
+}

upb/mini_table/extension_registry.h

@@ -87,6 +87,9 @@ UPB_NODISCARD upb_ExtensionRegistryStatus upb_ExtensionRegistry_AddArray(
 UPB_API const upb_MiniTableExtension* upb_ExtensionRegistry_Lookup(
     const upb_ExtensionRegistry* r, const upb_MiniTable* t, uint32_t num);
 
+// Returns the number of extensions in the registry. For testing/debugging only.
+UPB_API size_t upb_ExtensionRegistry_Size(const upb_ExtensionRegistry* r);
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

upb/mini_table/generated_registry_empty_test.cc

@@ -0,0 +1,45 @@
+
+#include <gtest/gtest.h>
+#include "upb/mini_table/extension_registry.h"
+#include "upb/mini_table/generated_registry.h"
+#include "upb/mini_table/generated_registry_empty_test.upb_minitable.h"
+#include "upb/mini_table/message.h"
+
+namespace {
+
+// Tests that we can instantiate the registry even if no extensions are linked.
+// This ensures that the sentinel object in the linker array properly ensures
+// that the encapsulation symbols are defined (eg. __start_linkarr_exts,
+// __stop_linkarr_exts) even when no extensions were linked.
+TEST(GeneratedRegistryEmptyTest, Instantiate) {
+  // Strongly reference the generated MiniTable to ensure that the TU for
+  // generated_registry_empty_test.upb_minitable.c is pulled in.
+  const upb_MiniTable* volatile table =
+      &upb_0test_0empty_0registry__EmptyRegistryTestMessage_msg_init;
+  (void)table;
+
+  // Test that the registry can be loaded, even if no extensions are linked.
+  // If we did not have a sentinel in the linker array, we would get a linker
+  // error here like:
+  //
+  // ld: error: undefined symbol: __start_linkarr_upb_AllExts
+  // >>> referenced by generated_registry_empty_test.upb_minitable.c
+  // >>>
+  // generated_registry_empty_test.upb_minitable.pic.o:(upb_GeneratedRegistry_Constructor_dont_copy_me__upb_internal_use_only.entry)
+  // >>> the encapsulation symbol needs to be retained under --gc-sections
+  // properly; consider -z nostart-stop-gc (see
+  // https://lld.llvm.org/ELF/start-stop-gc)
+  //
+  // ld: error: undefined symbol: __stop_linkarr_upb_AllExts
+  // >>> referenced by generated_registry_empty_test.upb_minitable.c
+  // >>>
+  // generated_registry_empty_test.upb_minitable.pic.o:(upb_GeneratedRegistry_Constructor_dont_copy_me__upb_internal_use_only.entry)
+  const upb_GeneratedRegistryRef* ref = upb_GeneratedRegistry_Load();
+  EXPECT_NE(ref, nullptr);
+  const upb_ExtensionRegistry* reg = upb_GeneratedRegistry_Get(ref);
+  EXPECT_NE(reg, nullptr);
+
+  upb_GeneratedRegistry_Release(ref);
+}
+
+}  // namespace

upb/mini_table/generated_registry_empty_test.proto

@@ -0,0 +1,15 @@
+edition = "2024";
+
+package upb_test_empty_registry;
+
+// A message that is in the same file as the unused extension.
+message EmptyRegistryTestMessage {
+  extensions 1 to max;
+}
+
+// An extension that we will *not* reference. The existence of this extension
+// will cause us to emit the code to register all extensions, but since this
+// extension is never referenced, that list of extensions will be empty.
+extend EmptyRegistryTestMessage {
+  int32 unused_extension = 1;
+}

upb/port/def.inc

@@ -566,37 +566,59 @@ Error, UINTPTR_MAX is undefined
 //     }
 //   }
 
-#define UPB_LINKARR_ATTR
-
-#define UPB_LINKARR_SENTINEL UPB_RETAIN __attribute__((weak, used))
-
+#define UPB_LINKARR_SENTINEL
 #if defined(__ELF__) || defined(__wasm__)
 
 #define UPB_LINKARR_APPEND(name) \
-  __attribute__((                \
-      section("linkarr_" #name))) UPB_LINKARR_ATTR UPB_NO_SANITIZE_ADDRESS
-#define UPB_LINKARR_DECLARE(name, type) \
-  extern type __start_linkarr_##name;   \
-  extern type __stop_linkarr_##name;    \
-  UPB_LINKARR_APPEND(name)              \
-  UPB_LINKARR_SENTINEL type UPB_linkarr_internal_empty_##name[1]
+  __attribute__((section("linkarr_" #name))) UPB_NO_SANITIZE_ADDRESS
+#define UPB_LINKARR_DECLARE(name, type)                                      \
+  extern type __start_linkarr_##name;                                        \
+  extern type __stop_linkarr_##name;                                         \
+                                                                             \
+  /* This function defines a sentinel symbol that is used to ensure that the \
+   * linker symbols __start_linkarr_##name and __stop_linkarr_##name are     \
+   * defined even if no (real) elements are added to the linkarr.            \
+   *                                                                         \
+   * We unfortunately have to use inline assembly here because GCC will      \
+   * refuse to create multiple sections with the same name and different     \
+   * flags: https://github.com/protocolbuffers/protobuf/issues/26385         \
+   *                                                                         \
+   * We have to use a function wrapper in order to propagate `sizeof(type)`  \
+   * into the assembly (globally-scoped asm() blocks can't access values,    \
+   * even constant expressions).                                             \
+   */                                                                        \
+  /* clang-format off */                                                     \
+  static __attribute__((used)) void upb_linkarr_wrapper_##name(void) {       \
+    __asm__ volatile (                                                       \
+        ".pushsection linkarr_" #name ",\"awR\",@progbits,unique,1\n\t"      \
+        ".p2align 8\n\t"                                                     \
+        ".weak UPB_linkarr_internal_anchor_" #name "\n\t"                    \
+        ".type UPB_linkarr_internal_anchor_" #name ", @object\n\t"           \
+        "UPB_linkarr_internal_anchor_" #name ":\n\t"                         \
+        ".fill %c[size], 1, 0\n\t"                                           \
+        ".size UPB_linkarr_internal_anchor_" #name ", %c[size]\n\t"          \
+        ".popsection"                                                        \
+        :                                                                    \
+        : [size] "n" (sizeof(type))                                          \
+    );                                                                       \
+  }
+/* clang-format on */
 #define UPB_LINKARR_START(name) (&__start_linkarr_##name)
 #define UPB_LINKARR_STOP(name) (&__stop_linkarr_##name)
 
 #elif defined(__MACH__)
 
 /* As described in: https://stackoverflow.com/a/22366882 */
 #define UPB_LINKARR_APPEND(name) \
-  __attribute__((                \
-      section("__DATA,__la_" #name))) UPB_LINKARR_ATTR UPB_NO_SANITIZE_ADDRESS
+  __attribute__((section("__DATA,__la_" #name))) UPB_NO_SANITIZE_ADDRESS
 #define UPB_LINKARR_DECLARE(name, type)     \
   extern type __start_linkarr_##name __asm( \
       "section$start$__DATA$__la_" #name);  \
   extern type __stop_linkarr_##name __asm(  \
       "section$end$__DATA$"                 \
       "__la_" #name);                       \
   UPB_LINKARR_APPEND(name)                  \
-  UPB_LINKARR_SENTINEL type UPB_linkarr_internal_empty_##name[1]
+  __attribute__((weak, used)) type UPB_linkarr_internal_empty_##name[1]
 #define UPB_LINKARR_START(name) (&__start_linkarr_##name)
 #define UPB_LINKARR_STOP(name) (&__stop_linkarr_##name)