|
|
|
|
# Copyright (c) 2009-2021, Google LLC
|
|
|
|
|
# All rights reserved.
|
|
|
|
|
#
|
|
|
|
|
# Use of this source code is governed by a BSD-style
|
|
|
|
|
# license that can be found in the LICENSE file or at
|
|
|
|
|
# https://developers.google.com/open-source/licenses/bsd
|
|
|
|
|
|
|
|
|
|
load("@rules_python//python:defs.bzl", "py_binary")
|
|
|
|
|
load("@bazel_skylib//rules:common_settings.bzl", "bool_flag")
|
|
|
|
|
load("//bazel:build_defs.bzl", "UPB_DEFAULT_COPTS")
|
|
|
|
|
load("//bazel:upb_minitable_proto_library.bzl", "upb_minitable_proto_library")
|
|
|
|
|
load("//bazel:upb_proto_library.bzl", "upb_proto_reflection_library")
|
|
|
|
|
load("//bazel:upb_proto_library_internal/copts.bzl", "upb_proto_library_copts")
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
load(
|
|
|
|
|
"//upb_generator:bootstrap_compiler.bzl",
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
"bootstrap_cc_library",
|
|
|
|
|
"bootstrap_upb_proto_library",
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# begin:google_only
|
|
|
|
|
# load("//tools/build_defs/kotlin/native:rules.bzl", "kt_native_interop_hint")
|
|
|
|
|
# load("//tools/build_defs/license:license.bzl", "license")
|
|
|
|
|
# end:google_only
|
|
|
|
|
|
|
|
|
|
# begin:github_only
|
|
|
|
|
load(
|
|
|
|
|
"//bazel:amalgamation.bzl",
|
|
|
|
|
"upb_amalgamation",
|
|
|
|
|
)
|
|
|
|
|
# end:github_only
|
|
|
|
|
|
|
|
|
|
# begin:google_only
|
|
|
|
|
# package(default_applicable_licenses = ["//upb:license"])
|
|
|
|
|
#
|
|
|
|
|
# license(
|
|
|
|
|
# name = "license",
|
|
|
|
|
# package_name = "upb",
|
|
|
|
|
# )
|
|
|
|
|
# end:google_only
|
|
|
|
|
|
|
|
|
|
licenses(["notice"])
|
|
|
|
|
|
|
|
|
|
exports_files(["LICENSE"])
|
|
|
|
|
|
|
|
|
|
exports_files(
|
|
|
|
|
[
|
|
|
|
|
"BUILD",
|
|
|
|
|
"WORKSPACE",
|
|
|
|
|
],
|
|
|
|
|
visibility = ["//upb/cmake:__pkg__"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
config_setting(
|
|
|
|
|
name = "windows",
|
|
|
|
|
constraint_values = ["@platforms//os:windows"],
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
bool_flag(
|
Added a codegen parameter for whether fasttables are generated or not.
Example:
$ CC=clang bazel build -c opt --copt=-g benchmarks:benchmark --//:fasttable_enabled=false
INFO: Build option --//:fasttable_enabled has changed, discarding analysis cache.
INFO: Analyzed target //benchmarks:benchmark (0 packages loaded, 913 targets configured).
INFO: Found 1 target...
Target //benchmarks:benchmark up-to-date:
bazel-bin/benchmarks/benchmark
INFO: Elapsed time: 0.760s, Critical Path: 0.58s
INFO: 7 processes: 1 internal, 6 linux-sandbox.
INFO: Build completed successfully, 7 total actions
$ bazel-bin/benchmarks/benchmark --benchmark_filter=BM_Parse_Upb
------------------------------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------------------------------
BM_Parse_Upb_FileDesc_WithArena 10985 ns 10984 ns 63567 651.857MB/s
BM_Parse_Upb_FileDesc_WithInitialBlock 10556 ns 10554 ns 66138 678.458MB/s
$ CC=clang bazel build -c opt --copt=-g benchmarks:benchmark --//:fasttable_enabled=true
INFO: Build option --//:fasttable_enabled has changed, discarding analysis cache.
INFO: Analyzed target //benchmarks:benchmark (0 packages loaded, 913 targets configured).
INFO: Found 1 target...
Target //benchmarks:benchmark up-to-date:
bazel-bin/benchmarks/benchmark
INFO: Elapsed time: 0.744s, Critical Path: 0.58s
INFO: 7 processes: 1 internal, 6 linux-sandbox.
INFO: Build completed successfully, 7 total actions
$ bazel-bin/benchmarks/benchmark --benchmark_filter=BM_Parse_Upb
------------------------------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------------------------------
BM_Parse_Upb_FileDesc_WithArena 3284 ns 3284 ns 213495 2.1293GB/s
BM_Parse_Upb_FileDesc_WithInitialBlock 2882 ns 2882 ns 243069 2.4262GB/s
Biggest unknown is whether this parameter should default to true or false.
4 years ago
|
|
|
name = "fasttable_enabled",
|
|
|
|
|
build_setting_default = False,
|
Added a codegen parameter for whether fasttables are generated or not.
Example:
$ CC=clang bazel build -c opt --copt=-g benchmarks:benchmark --//:fasttable_enabled=false
INFO: Build option --//:fasttable_enabled has changed, discarding analysis cache.
INFO: Analyzed target //benchmarks:benchmark (0 packages loaded, 913 targets configured).
INFO: Found 1 target...
Target //benchmarks:benchmark up-to-date:
bazel-bin/benchmarks/benchmark
INFO: Elapsed time: 0.760s, Critical Path: 0.58s
INFO: 7 processes: 1 internal, 6 linux-sandbox.
INFO: Build completed successfully, 7 total actions
$ bazel-bin/benchmarks/benchmark --benchmark_filter=BM_Parse_Upb
------------------------------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------------------------------
BM_Parse_Upb_FileDesc_WithArena 10985 ns 10984 ns 63567 651.857MB/s
BM_Parse_Upb_FileDesc_WithInitialBlock 10556 ns 10554 ns 66138 678.458MB/s
$ CC=clang bazel build -c opt --copt=-g benchmarks:benchmark --//:fasttable_enabled=true
INFO: Build option --//:fasttable_enabled has changed, discarding analysis cache.
INFO: Analyzed target //benchmarks:benchmark (0 packages loaded, 913 targets configured).
INFO: Found 1 target...
Target //benchmarks:benchmark up-to-date:
bazel-bin/benchmarks/benchmark
INFO: Elapsed time: 0.744s, Critical Path: 0.58s
INFO: 7 processes: 1 internal, 6 linux-sandbox.
INFO: Build completed successfully, 7 total actions
$ bazel-bin/benchmarks/benchmark --benchmark_filter=BM_Parse_Upb
------------------------------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------------------------------
BM_Parse_Upb_FileDesc_WithArena 3284 ns 3284 ns 213495 2.1293GB/s
BM_Parse_Upb_FileDesc_WithInitialBlock 2882 ns 2882 ns 243069 2.4262GB/s
Biggest unknown is whether this parameter should default to true or false.
4 years ago
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
config_setting(
|
|
|
|
|
name = "fasttable_enabled_setting",
|
|
|
|
|
flag_values = {"//upb:fasttable_enabled": "true"},
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
upb_proto_library_copts(
|
|
|
|
|
name = "upb_proto_library_copts__for_generated_code_only_do_not_use",
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Please update copy.bara.sky target = ":friends" if
|
|
|
|
|
# you make changes to this list.
|
|
|
|
|
package_group(
|
|
|
|
|
name = "friends",
|
|
|
|
|
packages = ["//..."],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# This is a stub library to keep gRPC happy. Do not use it for any reason,
|
|
|
|
|
# use the smaller targets below instead.
|
|
|
|
|
cc_library(
|
|
|
|
|
name = "upb",
|
|
|
|
|
hdrs = [
|
|
|
|
|
"upb.hpp",
|
|
|
|
|
],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
deps = [
|
|
|
|
|
":base",
|
|
|
|
|
":mem",
|
|
|
|
|
],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Common support routines used by generated code. This library has no
|
|
|
|
|
# implementation, but depends on :upb and exposes a few more hdrs.
|
|
|
|
|
#
|
|
|
|
|
# This is public only because we have no way of visibility-limiting it to
|
|
|
|
|
# upb_proto_library() only. This interface is not stable and by using it you
|
|
|
|
|
# give up any backward compatibility guarantees.
|
|
|
|
|
cc_library(
|
|
|
|
|
name = "generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me",
|
|
|
|
|
hdrs = ["generated_code_support.h"],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
textual_hdrs = [
|
|
|
|
|
"//upb/port:inc",
|
|
|
|
|
],
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
deps = [
|
|
|
|
|
":base",
|
|
|
|
|
":collections",
|
|
|
|
|
":collections_internal",
|
|
|
|
|
":mem",
|
|
|
|
|
":message",
|
|
|
|
|
":message_accessors",
|
|
|
|
|
":message_accessors_internal",
|
|
|
|
|
":message_internal",
|
|
|
|
|
":mini_descriptor",
|
|
|
|
|
":mini_table",
|
|
|
|
|
":wire",
|
|
|
|
|
":wire_internal",
|
|
|
|
|
],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Common support code for C++ generated code.
|
|
|
|
|
cc_library(
|
|
|
|
|
name = "generated_cpp_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me",
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
textual_hdrs = [
|
|
|
|
|
"//upb/port:inc",
|
|
|
|
|
],
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
cc_library(
|
|
|
|
|
name = "generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me",
|
|
|
|
|
hdrs = [
|
|
|
|
|
"reflection/def.h",
|
|
|
|
|
"reflection/internal/def_pool.h",
|
|
|
|
|
],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
textual_hdrs = [
|
|
|
|
|
"//upb/port:inc",
|
|
|
|
|
],
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
deps = [
|
|
|
|
|
":mem",
|
|
|
|
|
":mini_descriptor",
|
|
|
|
|
":reflection_internal",
|
|
|
|
|
],
|
|
|
|
|
)
|
|
|
|
|
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
bootstrap_upb_proto_library(
|
|
|
|
|
name = "descriptor_upb_proto",
|
|
|
|
|
base_dir = "reflection/",
|
|
|
|
|
# TODO: Export 'net/proto2/proto/descriptor.upb.h' and remove "-layering_check".
|
|
|
|
|
features = ["-layering_check"],
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
google3_src_files = ["net/proto2/proto/descriptor.proto"],
|
|
|
|
|
google3_src_rules = ["//net/proto2/proto:descriptor_proto_source"],
|
|
|
|
|
oss_src_files = ["google/protobuf/descriptor.proto"],
|
|
|
|
|
oss_src_rules = ["//:descriptor_proto_srcs"],
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
oss_strip_prefix = "third_party/protobuf/github/bootstrap/src",
|
|
|
|
|
proto_lib_deps = ["//:descriptor_proto"],
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
upb_proto_reflection_library(
|
|
|
|
|
name = "descriptor_upb_proto_reflection",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
deps = ["//:descriptor_proto"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
upb_minitable_proto_library(
|
|
|
|
|
name = "descriptor_upb_minitable_proto",
|
|
|
|
|
visibility = [
|
|
|
|
|
"//upb:__subpackages__",
|
|
|
|
|
# begin:github_only
|
|
|
|
|
"//python:__subpackages__",
|
|
|
|
|
# end:github_only
|
|
|
|
|
],
|
|
|
|
|
deps = ["//:descriptor_proto"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# TODO: Once we can delete the deprecated forwarding headers
|
|
|
|
|
# (= everything in upb/) we can move this build target down into reflection/
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
bootstrap_cc_library(
|
|
|
|
|
name = "reflection",
|
|
|
|
|
hdrs = [
|
|
|
|
|
"reflection/def.h",
|
|
|
|
|
"reflection/def.hpp",
|
|
|
|
|
"reflection/message.h",
|
|
|
|
|
"reflection/message.hpp",
|
|
|
|
|
],
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
bootstrap_deps = [":reflection_internal"],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
deps = [
|
|
|
|
|
":base",
|
|
|
|
|
":collections",
|
|
|
|
|
":mem",
|
|
|
|
|
":message_types",
|
|
|
|
|
":message_value",
|
|
|
|
|
":port",
|
|
|
|
|
],
|
|
|
|
|
)
|
|
|
|
|
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
bootstrap_cc_library(
|
|
|
|
|
name = "reflection_internal",
|
|
|
|
|
srcs = [
|
|
|
|
|
"reflection/def_pool.c",
|
|
|
|
|
"reflection/def_type.c",
|
|
|
|
|
"reflection/desc_state.c",
|
|
|
|
|
"reflection/enum_def.c",
|
|
|
|
|
"reflection/enum_reserved_range.c",
|
|
|
|
|
"reflection/enum_value_def.c",
|
|
|
|
|
"reflection/extension_range.c",
|
|
|
|
|
"reflection/field_def.c",
|
|
|
|
|
"reflection/file_def.c",
|
|
|
|
|
"reflection/internal/def_builder.c",
|
|
|
|
|
"reflection/internal/def_builder.h",
|
|
|
|
|
"reflection/internal/strdup2.c",
|
|
|
|
|
"reflection/internal/strdup2.h",
|
|
|
|
|
"reflection/message.c",
|
|
|
|
|
"reflection/message_def.c",
|
|
|
|
|
"reflection/message_reserved_range.c",
|
|
|
|
|
"reflection/method_def.c",
|
|
|
|
|
"reflection/oneof_def.c",
|
|
|
|
|
"reflection/service_def.c",
|
|
|
|
|
],
|
|
|
|
|
hdrs = [
|
|
|
|
|
"reflection/common.h",
|
|
|
|
|
"reflection/def.h",
|
|
|
|
|
"reflection/def.hpp",
|
|
|
|
|
"reflection/def_pool.h",
|
|
|
|
|
"reflection/def_type.h",
|
|
|
|
|
"reflection/enum_def.h",
|
|
|
|
|
"reflection/enum_reserved_range.h",
|
|
|
|
|
"reflection/enum_value_def.h",
|
|
|
|
|
"reflection/extension_range.h",
|
|
|
|
|
"reflection/field_def.h",
|
|
|
|
|
"reflection/file_def.h",
|
|
|
|
|
"reflection/internal/def_pool.h",
|
|
|
|
|
"reflection/internal/desc_state.h",
|
|
|
|
|
"reflection/internal/enum_def.h",
|
|
|
|
|
"reflection/internal/enum_reserved_range.h",
|
|
|
|
|
"reflection/internal/enum_value_def.h",
|
|
|
|
|
"reflection/internal/extension_range.h",
|
|
|
|
|
"reflection/internal/field_def.h",
|
|
|
|
|
"reflection/internal/file_def.h",
|
|
|
|
|
"reflection/internal/message_def.h",
|
|
|
|
|
"reflection/internal/message_reserved_range.h",
|
|
|
|
|
"reflection/internal/method_def.h",
|
|
|
|
|
"reflection/internal/oneof_def.h",
|
|
|
|
|
"reflection/internal/service_def.h",
|
|
|
|
|
"reflection/message.h",
|
|
|
|
|
"reflection/message.hpp",
|
|
|
|
|
"reflection/message_def.h",
|
|
|
|
|
"reflection/message_reserved_range.h",
|
|
|
|
|
"reflection/method_def.h",
|
|
|
|
|
"reflection/oneof_def.h",
|
|
|
|
|
"reflection/service_def.h",
|
|
|
|
|
],
|
upb is self-hosting!
This CL changes the upb compiler to no longer depend on C++ protobuf libraries. upb now uses its own reflection libraries to implement its code generator.
# Key Benefits
1. upb can now use its own reflection libraries throughout the compiler. This makes upb more consistent and principled, and gives us more chances to dogfood our own C++ reflection API. This highlighted several parts of the C++ reflection API that were incomplete.
2. This CL removes code duplication that previously existed in the compiler. The upb reflection library has code to build MiniDescriptors and MiniTables out of descriptors, but prior to this CL the upb compiler could not use it. The upb compiler had a separate copy of this logic, and the compiler's copy of this logic was especially tricky and hard to maintain. This CL removes the separate copy of that logic.
3. This CL (mostly) removes upb's dependency on the C++ protobuf library. We still depend on `protoc` (the binary), but the runtime and compiler no longer link against C++'s libraries. This opens up the possibility of speeding up some builds significantly if we can use a prebuilt `protoc` binary.
# Bootstrap Stages
To bootstrap, we check in a copy of our generated code for `descriptor.proto` and `plugin.proto`. This allows the compiler to depend on the generated code for these two protos without creating a circular dependency. This code is checked in to the `stage0` directory.
The bootstrapping process is divided into a few stages. All `cc_library()`, `upb_proto_library()`, and `cc_binary()` targets that would otherwise be circular participate in this staging process. That currently includes:
* `//third_party/upb:descriptor_upb_proto`
* `//third_party/upb:plugin_upb_proto`
* `//third_party/upb:reflection`
* `//third_party/upb:reflection_internal`
* `//third_party/upbc:common`
* `//third_party/upbc:file_layout`
* `//third_party/upbc:plugin`
* `//third_party/upbc:protoc-gen-upb`
For each of these targets, we produce a rule for each stage (the logic for this is nicely encapsulated in Blaze/Bazel macros like `bootstrap_cc_library()` and `bootstrap_upb_proto_library()`, so the `BUILD` file remains readable). For example:
* `//third_party/upb:descriptor_upb_proto_stage0`
* `//third_party/upb:descriptor_upb_proto_stage1`
* `//third_party/upb:descriptor_upb_proto`
The stages are:
1. `stage0`: This uses the checked-in version of the generated code. The stage0 compiler is correct and outputs the same code as all other compilers, but it is unnecessarily slow because its protos were compiled in bootstrap mode. The stage0 compiler is used to generate protos for stage1.
2. `stage1`: The stage1 compiler is correct and fast, and therefore we use it in almost all cases (eg. `upb_proto_library()`). However its own protos were not generated using `upb_proto_library()`, so its `cc_library()` targets cannot be safely mixed with `upb_proto_library()`, as this would lead to duplicate symbols.
3. final (no stage): The final compiler is identical to the `stage1` compiler. The only difference is that its protos were built with `upb_proto_library()`. This doesn't matter very much for the compiler binary, but for the `cc_library()` targets like `//third_party/upb:reflection`, only the final targets can be safely linked in by other applications.
# "Bootstrap Mode" Protos
The checked-in generated code is generated in a special "bootstrap" mode that is a bit different than normal generated code. Bootstrap mode avoids depending on the internal representation of MiniTables or the messages, at the cost of slower runtime performance.
Bootstrap mode only interacts with MiniTables and messages using public APIs such as `upb_MiniTable_Build()`, `upb_Message_GetInt32()`, etc. This is very important as it allows us to change the internal representation without needing to regenerate our bootstrap protos. This will make it far easier to write CLs that change the internal representation, because it avoids the awkward dance of trying to regenerate the bootstrap protos when the compiler itself is broken due to bootstrap protos being out of date.
The bootstrap generated code does have two downsides:
1. The accessors are less efficient, because they look up MiniTable fields by number instead of hard-coding the MiniTableField into the generated code.
2. It requires runtime initialization of the MiniTables, which costs CPU cycles at startup, and also allocates memory which is never freed. Per google3 rules this is not really a leak, since this memory is still reachable via static variables, but it is undesirable in many contexts. We could fix this part by introducing the equivalent of `google::protobuf::ShutdownProtobufLibrary()`).
These downsides are fine for the bootstrapping process, but they are reason enough not to enable bootstrap mode in general for all protos.
# Bootstrapping Always Uses OSS Protos
To enable smooth syncing between Google3 and OSS, we always use an OSS version of the checked in generated code for `stage0`, even in google3.
This requires that the google3 code can be switched to reference the OSS proto names using a preprocessor define. We introduce the `UPB_DESC(xyz)` macro for this, which will expand into either `proto2_xyz` or `google_protobuf_xyz`. Any libraries used in `stage0` must use `UPB_DESC(xyz)` rather than refer to the symbol names directly.
PiperOrigin-RevId: 501458451
2 years ago
|
|
|
bootstrap_deps = [":descriptor_upb_proto"],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
deps = [
|
|
|
|
|
":base",
|
|
|
|
|
":collections",
|
|
|
|
|
":hash",
|
|
|
|
|
":mem",
|
|
|
|
|
":message",
|
|
|
|
|
":message_accessors",
|
|
|
|
|
":message_types",
|
|
|
|
|
":message_value",
|
|
|
|
|
":mini_descriptor",
|
|
|
|
|
":mini_descriptor_internal",
|
|
|
|
|
":mini_table",
|
|
|
|
|
":port",
|
|
|
|
|
],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Aliases ######################################################################
|
|
|
|
|
# TODO: Remove these.
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "base",
|
|
|
|
|
actual = "//upb/base",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "base_internal",
|
|
|
|
|
actual = "//upb/base:internal",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "collections",
|
|
|
|
|
actual = "//upb/collections",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "collections_internal",
|
|
|
|
|
actual = "//upb/collections:internal",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "collections_split64",
|
|
|
|
|
actual = "//upb/collections:split64",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "hash",
|
|
|
|
|
actual = "//upb/hash",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "json",
|
|
|
|
|
actual = "//upb/json",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "lex",
|
|
|
|
|
actual = "//upb/lex",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "mem",
|
|
|
|
|
actual = "//upb/mem",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "mem_internal",
|
|
|
|
|
actual = "//upb/mem:internal",
|
|
|
|
|
visibility = ["//upb:__subpackages__"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message",
|
|
|
|
|
actual = "//upb/message",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_accessors",
|
|
|
|
|
actual = "//upb/message:accessors",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_accessors_internal",
|
|
|
|
|
actual = "//upb/message:accessors_internal",
|
|
|
|
|
visibility = ["//upb:friends"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_copy",
|
|
|
|
|
actual = "//upb/message:copy",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_internal",
|
|
|
|
|
actual = "//upb/message:internal",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_internal_types",
|
|
|
|
|
actual = "//upb/message:internal_types",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_promote",
|
|
|
|
|
actual = "//upb/message:promote",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_split64",
|
|
|
|
|
actual = "//upb/message:split64",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_tagged_ptr",
|
|
|
|
|
actual = "//upb/message:tagged_ptr",
|
|
|
|
|
visibility = ["//upb:friends"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_types",
|
|
|
|
|
actual = "//upb/message:types",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "message_value",
|
|
|
|
|
actual = "//upb/message:value",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "mini_descriptor",
|
|
|
|
|
actual = "//upb/mini_descriptor",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "mini_descriptor_internal",
|
|
|
|
|
actual = "//upb/mini_descriptor:internal",
|
|
|
|
|
visibility = ["//upb:__subpackages__"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "mini_table",
|
|
|
|
|
actual = "//upb/mini_table",
|
|
|
|
|
visibility = ["//upb:friends"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "mini_table_compat",
|
|
|
|
|
actual = "//upb/mini_table:compat",
|
|
|
|
|
visibility = ["//upb:friends"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "mini_table_internal",
|
|
|
|
|
actual = "//upb/mini_table:internal",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "port",
|
|
|
|
|
actual = "//upb/port",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "text",
|
|
|
|
|
actual = "//upb/text",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "wire",
|
|
|
|
|
actual = "//upb/wire",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "wire_internal",
|
|
|
|
|
actual = "//upb/wire:internal",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "wire_reader",
|
|
|
|
|
actual = "//upb/wire:reader",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "wire_types",
|
|
|
|
|
actual = "//upb/wire:types",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
alias(
|
|
|
|
|
name = "eps_copy_input_stream",
|
|
|
|
|
actual = "//upb/wire:eps_copy_input_stream",
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Tests ########################################################################
|
|
|
|
|
|
|
|
|
|
cc_test(
|
|
|
|
|
name = "def_builder_test",
|
|
|
|
|
srcs = [
|
|
|
|
|
"reflection/common.h",
|
|
|
|
|
"reflection/def_type.h",
|
|
|
|
|
"reflection/internal/def_builder.h",
|
|
|
|
|
"reflection/internal/def_builder_test.cc",
|
|
|
|
|
],
|
|
|
|
|
deps = [
|
|
|
|
|
":descriptor_upb_proto",
|
|
|
|
|
":hash",
|
|
|
|
|
":mem",
|
|
|
|
|
":port",
|
|
|
|
|
":reflection",
|
|
|
|
|
":reflection_internal",
|
|
|
|
|
"@com_google_googletest//:gtest_main",
|
|
|
|
|
"@com_google_absl//absl/strings",
|
|
|
|
|
],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Internal C/C++ libraries #####################################################
|
|
|
|
|
|
|
|
|
|
cc_binary(
|
|
|
|
|
name = "libupb.so",
|
|
|
|
|
srcs = ["upb_so.c"],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS + ["-DUPB_BUILD_API"],
|
|
|
|
|
linkshared = 1,
|
|
|
|
|
linkstatic = 1,
|
|
|
|
|
visibility = ["//visibility:public"],
|
|
|
|
|
deps = [
|
|
|
|
|
":collections",
|
|
|
|
|
":collections_split64",
|
|
|
|
|
":mem",
|
|
|
|
|
":message",
|
|
|
|
|
":message_accessors",
|
|
|
|
|
":message_split64",
|
|
|
|
|
":mini_descriptor",
|
|
|
|
|
":mini_table",
|
|
|
|
|
":port",
|
|
|
|
|
],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Amalgamation #################################################################
|
|
|
|
|
|
|
|
|
|
# begin:github_only
|
|
|
|
|
|
|
|
|
|
upb_amalgamation(
|
|
|
|
|
name = "gen_amalgamation",
|
|
|
|
|
outs = [
|
|
|
|
|
"upb.c",
|
|
|
|
|
"upb.h",
|
|
|
|
|
],
|
|
|
|
|
libs = [
|
|
|
|
|
":base",
|
|
|
|
|
":base_internal",
|
|
|
|
|
":collections",
|
|
|
|
|
":collections_internal",
|
|
|
|
|
":descriptor_upb_minitable_proto",
|
|
|
|
|
":descriptor_upb_proto",
|
|
|
|
|
":eps_copy_input_stream",
|
|
|
|
|
":generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me",
|
|
|
|
|
":hash",
|
|
|
|
|
":lex",
|
|
|
|
|
":mem",
|
|
|
|
|
":mem_internal",
|
|
|
|
|
":message",
|
|
|
|
|
":message_accessors",
|
|
|
|
|
":message_internal",
|
|
|
|
|
":message_internal_types",
|
|
|
|
|
":message_tagged_ptr",
|
|
|
|
|
":message_types",
|
|
|
|
|
":message_value",
|
|
|
|
|
":mini_descriptor",
|
|
|
|
|
":mini_descriptor_internal",
|
|
|
|
|
":mini_table",
|
|
|
|
|
":mini_table_compat",
|
|
|
|
|
":mini_table_internal",
|
|
|
|
|
":port",
|
|
|
|
|
":reflection",
|
|
|
|
|
":reflection_internal",
|
|
|
|
|
":wire",
|
|
|
|
|
":wire_internal",
|
|
|
|
|
":wire_reader",
|
|
|
|
|
":wire_types",
|
|
|
|
|
],
|
|
|
|
|
strip_import_prefix = ["src"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
cc_library(
|
|
|
|
|
name = "amalgamation",
|
|
|
|
|
srcs = ["upb.c"],
|
|
|
|
|
hdrs = ["upb.h"],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
deps = ["@utf8_range"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
upb_amalgamation(
|
|
|
|
|
name = "gen_php_amalgamation",
|
|
|
|
|
outs = [
|
|
|
|
|
"php-upb.c",
|
|
|
|
|
"php-upb.h",
|
|
|
|
|
],
|
|
|
|
|
libs = [
|
|
|
|
|
":base",
|
|
|
|
|
":base_internal",
|
|
|
|
|
":collections",
|
|
|
|
|
":collections_internal",
|
|
|
|
|
":descriptor_upb_minitable_proto",
|
|
|
|
|
":descriptor_upb_proto_reflection",
|
|
|
|
|
":descriptor_upb_proto",
|
|
|
|
|
":eps_copy_input_stream",
|
|
|
|
|
":generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me",
|
|
|
|
|
":hash",
|
|
|
|
|
":json",
|
|
|
|
|
":lex",
|
|
|
|
|
":mem",
|
|
|
|
|
":mem_internal",
|
|
|
|
|
":message",
|
|
|
|
|
":message_accessors",
|
|
|
|
|
":message_internal",
|
|
|
|
|
":message_internal_types",
|
|
|
|
|
":message_tagged_ptr",
|
|
|
|
|
":message_types",
|
|
|
|
|
":message_value",
|
|
|
|
|
":mini_descriptor",
|
|
|
|
|
":mini_descriptor_internal",
|
|
|
|
|
":mini_table",
|
|
|
|
|
":mini_table_internal",
|
|
|
|
|
":port",
|
|
|
|
|
":reflection",
|
|
|
|
|
":reflection_internal",
|
|
|
|
|
":wire",
|
|
|
|
|
":wire_internal",
|
|
|
|
|
":wire_reader",
|
|
|
|
|
":wire_types",
|
|
|
|
|
],
|
|
|
|
|
prefix = "php-",
|
|
|
|
|
strip_import_prefix = ["src"],
|
|
|
|
|
visibility = ["@com_google_protobuf//php:__subpackages__"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
cc_library(
|
|
|
|
|
name = "php_amalgamation",
|
|
|
|
|
srcs = ["php-upb.c"],
|
|
|
|
|
hdrs = ["php-upb.h"],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
deps = ["@utf8_range"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
upb_amalgamation(
|
|
|
|
|
name = "gen_ruby_amalgamation",
|
|
|
|
|
outs = [
|
|
|
|
|
"ruby-upb.c",
|
|
|
|
|
"ruby-upb.h",
|
|
|
|
|
],
|
|
|
|
|
libs = [
|
|
|
|
|
":base",
|
|
|
|
|
":base_internal",
|
|
|
|
|
":collections",
|
|
|
|
|
":collections_internal",
|
|
|
|
|
":descriptor_upb_minitable_proto",
|
|
|
|
|
":descriptor_upb_proto",
|
|
|
|
|
":eps_copy_input_stream",
|
|
|
|
|
":generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me",
|
|
|
|
|
":hash",
|
|
|
|
|
":json",
|
|
|
|
|
":lex",
|
|
|
|
|
":mem",
|
|
|
|
|
":mem_internal",
|
|
|
|
|
":message",
|
|
|
|
|
":message_accessors",
|
|
|
|
|
":message_internal",
|
|
|
|
|
":message_internal_types",
|
|
|
|
|
":message_tagged_ptr",
|
|
|
|
|
":message_types",
|
|
|
|
|
":message_value",
|
|
|
|
|
":mini_descriptor",
|
|
|
|
|
":mini_descriptor_internal",
|
|
|
|
|
":mini_table",
|
|
|
|
|
":mini_table_internal",
|
|
|
|
|
":port",
|
|
|
|
|
":reflection",
|
|
|
|
|
":reflection_internal",
|
|
|
|
|
":wire",
|
|
|
|
|
":wire_internal",
|
|
|
|
|
":wire_reader",
|
|
|
|
|
":wire_types",
|
|
|
|
|
],
|
|
|
|
|
prefix = "ruby-",
|
|
|
|
|
strip_import_prefix = ["src"],
|
|
|
|
|
visibility = ["@com_google_protobuf//ruby:__subpackages__"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
cc_library(
|
|
|
|
|
name = "ruby_amalgamation",
|
|
|
|
|
srcs = ["ruby-upb.c"],
|
|
|
|
|
hdrs = ["ruby-upb.h"],
|
|
|
|
|
copts = UPB_DEFAULT_COPTS,
|
|
|
|
|
deps = ["@utf8_range"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
exports_files(
|
|
|
|
|
[
|
|
|
|
|
"third_party/lunit/console.lua",
|
|
|
|
|
"third_party/lunit/lunit.lua",
|
|
|
|
|
],
|
|
|
|
|
visibility = ["//lua:__pkg__"],
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
filegroup(
|
|
|
|
|
name = "source_files",
|
|
|
|
|
srcs = glob(
|
|
|
|
|
[
|
|
|
|
|
"**/*.c",
|
|
|
|
|
"**/*.h",
|
|
|
|
|
"**/*.hpp",
|
|
|
|
|
],
|
|
|
|
|
exclude = [
|
|
|
|
|
"**/conformance_upb.c",
|
|
|
|
|
"reflection/stage0/**/*",
|
|
|
|
|
],
|
|
|
|
|
),
|
|
|
|
|
visibility = [
|
|
|
|
|
"//upb/cmake:__pkg__",
|
|
|
|
|
"//python/dist:__pkg__",
|
|
|
|
|
]
|
|
|
|
|
)
|
|
|
|
|
# end:github_only
|
|
|
|
|
|
|
|
|
|
# begin:google_only
|
|
|
|
|
#
|
|
|
|
|
# py_binary(
|
|
|
|
|
# name = "update_check_runs",
|
|
|
|
|
# srcs = ["update_check_runs.py"],
|
|
|
|
|
# main = "update_check_runs.py",
|
|
|
|
|
# deps = [
|
|
|
|
|
# "//third_party/py/absl:app",
|
|
|
|
|
# "//third_party/py/absl/flags",
|
|
|
|
|
# ],
|
|
|
|
|
# )
|
|
|
|
|
#
|
|
|
|
|
# kt_native_interop_hint(
|
|
|
|
|
# name = "upb_kotlin_native_hint",
|
|
|
|
|
# compatible_with = ["//buildenv/target:non_prod"],
|
|
|
|
|
# headers_to_exclude = glob([
|
|
|
|
|
# "**/*.hpp",
|
|
|
|
|
# ]),
|
|
|
|
|
# kotlin_package = "upb",
|
|
|
|
|
# no_string_conversion = ["_upb_MiniTable_Build"],
|
|
|
|
|
# strict_enums = [
|
|
|
|
|
# "upb_CType",
|
|
|
|
|
# "upb_DecodeStatus",
|
|
|
|
|
# "upb_EncodeStatus",
|
|
|
|
|
# "upb_FieldType",
|
|
|
|
|
# "upb_FindUnknown_Status",
|
|
|
|
|
# "upb_GetExtension_Status",
|
|
|
|
|
# "upb_GetExtensionAsBytes_Status",
|
|
|
|
|
# "upb_Label",
|
|
|
|
|
# "upb_MapInsertStatus",
|
|
|
|
|
# "upb_UnknownToMessage_Status",
|
|
|
|
|
# "upb_WireType",
|
|
|
|
|
# ],
|
|
|
|
|
# visibility = ["//upb:__subpackages__"],
|
|
|
|
|
# )
|
|
|
|
|
#
|
|
|
|
|
# end:google_only
|
