Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 1 | // Copyright 2016 Google Inc. All rights reserved. |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
| 15 | package cc |
| 16 | |
| 17 | import ( |
Jiyong Park | f119435 | 2019-02-25 11:05:47 +0900 | [diff] [blame] | 18 | "path/filepath" |
| 19 | |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 20 | "github.com/google/blueprint" |
Liz Kammer | 12615db | 2021-09-28 09:19:17 -0400 | [diff] [blame] | 21 | "github.com/google/blueprint/proptools" |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 22 | |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 23 | "android/soong/android" |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 24 | "android/soong/bazel" |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 25 | ) |
| 26 | |
| 27 | type BinaryLinkerProperties struct { |
| 28 | // compile executable with -static |
| 29 | Static_executable *bool `android:"arch_variant"` |
| 30 | |
| 31 | // set the name of the output |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 32 | Stem *string `android:"arch_variant"` |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 33 | |
| 34 | // append to the name of the output |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 35 | Suffix *string `android:"arch_variant"` |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 36 | |
| 37 | // if set, add an extra objcopy --prefix-symbols= step |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 38 | Prefix_symbols *string |
Colin Cross | 1e7d370 | 2016-08-24 15:25:47 -0700 | [diff] [blame] | 39 | |
| 40 | // if set, install a symlink to the preferred architecture |
Roland Levillain | d9bf9be | 2019-06-05 19:20:33 +0100 | [diff] [blame] | 41 | Symlink_preferred_arch *bool `android:"arch_variant"` |
Colin Cross | 522e373 | 2016-09-07 13:14:06 -0700 | [diff] [blame] | 42 | |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 43 | // install symlinks to the binary. Symlink names will have the suffix and the binary |
| 44 | // extension (if any) appended |
| 45 | Symlinks []string `android:"arch_variant"` |
| 46 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 47 | // override the dynamic linker |
Colin Cross | 522e373 | 2016-09-07 13:14:06 -0700 | [diff] [blame] | 48 | DynamicLinker string `blueprint:"mutated"` |
Yifan Hong | 946e32e | 2018-04-03 13:22:50 -0700 | [diff] [blame] | 49 | |
| 50 | // Names of modules to be overridden. Listed modules can only be other binaries |
| 51 | // (in Make or Soong). |
| 52 | // This does not completely prevent installation of the overridden binaries, but if both |
| 53 | // binaries would be installed by default (in PRODUCT_PACKAGES) the other binary will be removed |
| 54 | // from PRODUCT_PACKAGES. |
| 55 | Overrides []string |
Colin Cross | d7227f9 | 2019-09-05 14:26:33 -0700 | [diff] [blame] | 56 | |
| 57 | // Inject boringssl hash into the shared library. This is only intended for use by external/boringssl. |
| 58 | Inject_bssl_hash *bool `android:"arch_variant"` |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | func init() { |
Paul Duffin | 2ee6979 | 2020-01-16 12:14:42 +0000 | [diff] [blame] | 62 | RegisterBinaryBuildComponents(android.InitRegistrationContext) |
| 63 | } |
| 64 | |
| 65 | func RegisterBinaryBuildComponents(ctx android.RegistrationContext) { |
| 66 | ctx.RegisterModuleType("cc_binary", BinaryFactory) |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 67 | ctx.RegisterModuleType("cc_binary_host", BinaryHostFactory) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 68 | } |
| 69 | |
Patrice Arruda | c249c71 | 2019-03-19 17:00:29 -0700 | [diff] [blame] | 70 | // cc_binary produces a binary that is runnable on a device. |
Jiyong Park | 16e91a0 | 2018-12-20 18:18:08 +0900 | [diff] [blame] | 71 | func BinaryFactory() android.Module { |
Liz Kammer | be46fcc | 2021-11-01 15:32:43 -0400 | [diff] [blame] | 72 | module, _ := newBinary(android.HostAndDeviceSupported, true) |
Yu Liu | 7f3605f | 2022-02-08 14:15:12 -0800 | [diff] [blame^] | 73 | module.bazelHandler = &ccBinaryBazelHandler{module: module} |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 74 | return module.Init() |
| 75 | } |
| 76 | |
Patrice Arruda | c249c71 | 2019-03-19 17:00:29 -0700 | [diff] [blame] | 77 | // cc_binary_host produces a binary that is runnable on a host. |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 78 | func BinaryHostFactory() android.Module { |
Liz Kammer | be46fcc | 2021-11-01 15:32:43 -0400 | [diff] [blame] | 79 | module, _ := newBinary(android.HostSupported, true) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 80 | return module.Init() |
| 81 | } |
| 82 | |
| 83 | // |
| 84 | // Executables |
| 85 | // |
| 86 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 87 | // binaryDecorator is a decorator containing information for C++ binary modules. |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 88 | type binaryDecorator struct { |
| 89 | *baseLinker |
Colin Cross | 1e7d370 | 2016-08-24 15:25:47 -0700 | [diff] [blame] | 90 | *baseInstaller |
ThiƩbaud Weksteen | d458745 | 2020-08-19 14:53:01 +0200 | [diff] [blame] | 91 | stripper Stripper |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 92 | |
| 93 | Properties BinaryLinkerProperties |
| 94 | |
Dan Willemsen | 4aa75ca | 2016-09-28 16:18:03 -0700 | [diff] [blame] | 95 | toolPath android.OptionalPath |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 96 | |
Colin Cross | b60190a | 2018-09-04 16:28:17 -0700 | [diff] [blame] | 97 | // Location of the linked, unstripped binary |
| 98 | unstrippedOutputFile android.Path |
| 99 | |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 100 | // Names of symlinks to be installed for use in LOCAL_MODULE_SYMLINKS |
| 101 | symlinks []string |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 102 | |
Colin Cross | a615901 | 2020-11-12 12:14:36 -0800 | [diff] [blame] | 103 | // If the module has symlink_preferred_arch set, the name of the symlink to the |
| 104 | // binary for the preferred arch. |
| 105 | preferredArchSymlink string |
| 106 | |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 107 | // Output archive of gcno coverage information |
| 108 | coverageOutputFile android.OptionalPath |
Dan Willemsen | 569edc5 | 2018-11-19 09:33:29 -0800 | [diff] [blame] | 109 | |
Jingwen Chen | 40fd90a | 2020-06-15 05:24:19 +0000 | [diff] [blame] | 110 | // Location of the files that should be copied to dist dir when requested |
| 111 | distFiles android.TaggedDistFiles |
Jiyong Park | f119435 | 2019-02-25 11:05:47 +0900 | [diff] [blame] | 112 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 113 | // Action command lines to run directly after the binary is installed. For example, |
| 114 | // may be used to symlink runtime dependencies (such as bionic) alongside installation. |
Jaewoong Jung | 18aefc1 | 2020-12-21 09:11:10 -0800 | [diff] [blame] | 115 | postInstallCmds []string |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 116 | } |
| 117 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 118 | var _ linker = (*binaryDecorator)(nil) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 119 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 120 | // linkerProps returns the list of individual properties objects relevant |
| 121 | // for this binary. |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 122 | func (binary *binaryDecorator) linkerProps() []interface{} { |
Colin Cross | 42742b8 | 2016-08-01 13:20:05 -0700 | [diff] [blame] | 123 | return append(binary.baseLinker.linkerProps(), |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 124 | &binary.Properties, |
| 125 | &binary.stripper.StripProperties) |
| 126 | |
| 127 | } |
| 128 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 129 | // getStemWithoutSuffix returns the main section of the name to use for the symlink of |
| 130 | // the main output file of this binary module. This may be derived from the module name |
| 131 | // or other property overrides. |
| 132 | // For the full symlink name, the `Suffix` property of a binary module must be appended. |
Roland Levillain | 9efb8c7 | 2019-06-05 13:31:31 +0100 | [diff] [blame] | 133 | func (binary *binaryDecorator) getStemWithoutSuffix(ctx BaseModuleContext) string { |
Colin Cross | ce75d2c | 2016-10-06 16:12:58 -0700 | [diff] [blame] | 134 | stem := ctx.baseModuleName() |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 135 | if String(binary.Properties.Stem) != "" { |
| 136 | stem = String(binary.Properties.Stem) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 137 | } |
| 138 | |
Roland Levillain | 9efb8c7 | 2019-06-05 13:31:31 +0100 | [diff] [blame] | 139 | return stem |
| 140 | } |
| 141 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 142 | // getStem returns the full name to use for the symlink of the main output file of this binary |
| 143 | // module. This may be derived from the module name and/or other property overrides. |
Roland Levillain | 9efb8c7 | 2019-06-05 13:31:31 +0100 | [diff] [blame] | 144 | func (binary *binaryDecorator) getStem(ctx BaseModuleContext) string { |
| 145 | return binary.getStemWithoutSuffix(ctx) + String(binary.Properties.Suffix) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 146 | } |
| 147 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 148 | // linkerDeps augments and returns the given `deps` to contain dependencies on |
| 149 | // modules common to most binaries, such as bionic libraries. |
Colin Cross | 37047f1 | 2016-12-13 17:06:13 -0800 | [diff] [blame] | 150 | func (binary *binaryDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps { |
Colin Cross | 42742b8 | 2016-08-01 13:20:05 -0700 | [diff] [blame] | 151 | deps = binary.baseLinker.linkerDeps(ctx, deps) |
Colin Cross | d1a2813 | 2021-06-21 17:34:47 -0700 | [diff] [blame] | 152 | if !Bool(binary.baseLinker.Properties.Nocrt) { |
| 153 | if binary.static() { |
| 154 | deps.CrtBegin = ctx.toolchain().CrtBeginStaticBinary() |
| 155 | deps.CrtEnd = ctx.toolchain().CrtEndStaticBinary() |
| 156 | } else { |
| 157 | deps.CrtBegin = ctx.toolchain().CrtBeginSharedBinary() |
| 158 | deps.CrtEnd = ctx.toolchain().CrtEndSharedBinary() |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 159 | } |
Colin Cross | d1a2813 | 2021-06-21 17:34:47 -0700 | [diff] [blame] | 160 | } |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 161 | |
Colin Cross | 450744e | 2021-08-18 13:52:09 -0700 | [diff] [blame] | 162 | if binary.static() { |
| 163 | deps.StaticLibs = append(deps.StaticLibs, deps.SystemSharedLibs...) |
| 164 | } |
| 165 | |
Colin Cross | d1a2813 | 2021-06-21 17:34:47 -0700 | [diff] [blame] | 166 | if ctx.toolchain().Bionic() { |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 167 | if binary.static() { |
Dan Albert | dc2597d | 2017-01-26 17:44:26 -0800 | [diff] [blame] | 168 | if ctx.selectedStl() == "libc++_static" { |
Ryan Prichard | b49fe1b | 2019-10-11 15:03:34 -0700 | [diff] [blame] | 169 | deps.StaticLibs = append(deps.StaticLibs, "libm", "libc") |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 170 | } |
| 171 | // static libraries libcompiler_rt, libc and libc_nomalloc need to be linked with |
| 172 | // --start-group/--end-group along with libgcc. If they are in deps.StaticLibs, |
| 173 | // move them to the beginning of deps.LateStaticLibs |
| 174 | var groupLibs []string |
| 175 | deps.StaticLibs, groupLibs = filterList(deps.StaticLibs, |
| 176 | []string{"libc", "libc_nomalloc", "libcompiler_rt"}) |
| 177 | deps.LateStaticLibs = append(groupLibs, deps.LateStaticLibs...) |
| 178 | } |
Dan Willemsen | c77a0b3 | 2017-09-18 23:19:12 -0700 | [diff] [blame] | 179 | |
| 180 | if ctx.Os() == android.LinuxBionic && !binary.static() { |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 181 | deps.DynamicLinker = "linker" |
Dan Willemsen | c77a0b3 | 2017-09-18 23:19:12 -0700 | [diff] [blame] | 182 | } |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 183 | } |
| 184 | |
Liz Kammer | 356f7d4 | 2021-01-26 09:18:53 -0500 | [diff] [blame] | 185 | if !binary.static() && inList("libc", deps.StaticLibs) && !ctx.BazelConversionMode() { |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 186 | ctx.ModuleErrorf("statically linking libc to dynamic executable, please remove libc\n" + |
| 187 | "from static libs or set static_executable: true") |
| 188 | } |
Colin Cross | 2383f3b | 2018-02-06 14:40:13 -0800 | [diff] [blame] | 189 | |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 190 | return deps |
| 191 | } |
| 192 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 193 | // NewBinary builds and returns a new Module corresponding to a C++ binary. |
| 194 | // Individual module implementations which comprise a C++ binary should call this function, |
| 195 | // set some fields on the result, and then call the Init function. |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 196 | func NewBinary(hod android.HostOrDeviceSupported) (*Module, *binaryDecorator) { |
Liz Kammer | be46fcc | 2021-11-01 15:32:43 -0400 | [diff] [blame] | 197 | return newBinary(hod, true) |
| 198 | } |
| 199 | |
| 200 | func newBinary(hod android.HostOrDeviceSupported, bazelable bool) (*Module, *binaryDecorator) { |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 201 | module := newModule(hod, android.MultilibFirst) |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 202 | binary := &binaryDecorator{ |
Dan Albert | 61f3212 | 2018-07-26 14:00:24 -0700 | [diff] [blame] | 203 | baseLinker: NewBaseLinker(module.sanitize), |
Colin Cross | 1e7d370 | 2016-08-24 15:25:47 -0700 | [diff] [blame] | 204 | baseInstaller: NewBaseInstaller("bin", "", InstallInSystem), |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 205 | } |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 206 | module.compiler = NewBaseCompiler() |
| 207 | module.linker = binary |
Colin Cross | 1e7d370 | 2016-08-24 15:25:47 -0700 | [diff] [blame] | 208 | module.installer = binary |
Liz Kammer | be46fcc | 2021-11-01 15:32:43 -0400 | [diff] [blame] | 209 | module.bazelable = bazelable |
Paul Duffin | 25ce04b | 2020-01-16 11:47:25 +0000 | [diff] [blame] | 210 | |
| 211 | // Allow module to be added as member of an sdk/module_exports. |
| 212 | module.sdkMemberTypes = []android.SdkMemberType{ |
| 213 | ccBinarySdkMemberType, |
| 214 | } |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 215 | return module, binary |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 216 | } |
| 217 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 218 | // linkerInit initializes dynamic properties of the linker (such as runpath) based |
| 219 | // on properties of this binary. |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 220 | func (binary *binaryDecorator) linkerInit(ctx BaseModuleContext) { |
Colin Cross | 42742b8 | 2016-08-01 13:20:05 -0700 | [diff] [blame] | 221 | binary.baseLinker.linkerInit(ctx) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 222 | |
Colin Cross | a793db3 | 2021-08-18 13:53:58 -0700 | [diff] [blame] | 223 | if !ctx.toolchain().Bionic() && !ctx.toolchain().Musl() { |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 224 | if ctx.Os() == android.Linux { |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 225 | // Unless explicitly specified otherwise, host static binaries are built with -static |
| 226 | // if HostStaticBinaries is true for the product configuration. |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 227 | if binary.Properties.Static_executable == nil && ctx.Config().HostStaticBinaries() { |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 228 | binary.Properties.Static_executable = BoolPtr(true) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 229 | } |
Colin Cross | cb0ac95 | 2021-07-20 13:17:15 -0700 | [diff] [blame] | 230 | } else { |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 231 | // Static executables are not supported on Darwin or Windows |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 232 | binary.Properties.Static_executable = nil |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 233 | } |
| 234 | } |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 235 | } |
| 236 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 237 | func (binary *binaryDecorator) static() bool { |
| 238 | return Bool(binary.Properties.Static_executable) |
| 239 | } |
| 240 | |
| 241 | func (binary *binaryDecorator) staticBinary() bool { |
| 242 | return binary.static() |
| 243 | } |
| 244 | |
Inseob Kim | 7f283f4 | 2020-06-01 21:53:49 +0900 | [diff] [blame] | 245 | func (binary *binaryDecorator) binary() bool { |
| 246 | return true |
| 247 | } |
| 248 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 249 | // linkerFlags returns a Flags object containing linker flags that are defined |
| 250 | // by this binary, or that are implied by attributes of this binary. These flags are |
| 251 | // combined with the given flags. |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 252 | func (binary *binaryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags { |
Colin Cross | 42742b8 | 2016-08-01 13:20:05 -0700 | [diff] [blame] | 253 | flags = binary.baseLinker.linkerFlags(ctx, flags) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 254 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 255 | // Passing -pie to clang for Windows binaries causes a warning that -pie is unused. |
Colin Cross | 446c666 | 2018-09-14 16:00:16 -0700 | [diff] [blame] | 256 | if ctx.Host() && !ctx.Windows() && !binary.static() { |
Colin Cross | 6510f91 | 2017-11-29 00:27:14 -0800 | [diff] [blame] | 257 | if !ctx.Config().IsEnvTrue("DISABLE_HOST_PIE") { |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 258 | flags.Global.LdFlags = append(flags.Global.LdFlags, "-pie") |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 259 | } |
| 260 | } |
| 261 | |
| 262 | // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because |
| 263 | // all code is position independent, and then those warnings get promoted to |
| 264 | // errors. |
Colin Cross | 3edeee1 | 2017-04-04 12:59:48 -0700 | [diff] [blame] | 265 | if !ctx.Windows() { |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 266 | flags.Global.CFlags = append(flags.Global.CFlags, "-fPIE") |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 267 | } |
| 268 | |
Dan Willemsen | 2e47b34 | 2016-11-17 01:02:25 -0800 | [diff] [blame] | 269 | if ctx.toolchain().Bionic() { |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 270 | if binary.static() { |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 271 | // Clang driver needs -static to create static executable. |
| 272 | // However, bionic/linker uses -shared to overwrite. |
| 273 | // Linker for x86 targets does not allow coexistance of -static and -shared, |
| 274 | // so we add -static only if -shared is not used. |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 275 | if !inList("-shared", flags.Local.LdFlags) { |
| 276 | flags.Global.LdFlags = append(flags.Global.LdFlags, "-static") |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 277 | } |
| 278 | |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 279 | flags.Global.LdFlags = append(flags.Global.LdFlags, |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 280 | "-nostdlib", |
| 281 | "-Bstatic", |
| 282 | "-Wl,--gc-sections", |
| 283 | ) |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 284 | } else { // not static |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 285 | if flags.DynamicLinker == "" { |
Colin Cross | 522e373 | 2016-09-07 13:14:06 -0700 | [diff] [blame] | 286 | if binary.Properties.DynamicLinker != "" { |
| 287 | flags.DynamicLinker = binary.Properties.DynamicLinker |
| 288 | } else { |
Dan Willemsen | 01a405a | 2016-06-13 17:19:03 -0700 | [diff] [blame] | 289 | switch ctx.Os() { |
| 290 | case android.Android: |
Yifan Hong | 60e0cfb | 2020-10-21 15:17:56 -0700 | [diff] [blame] | 291 | if ctx.bootstrap() && !ctx.inRecovery() && !ctx.inRamdisk() && !ctx.inVendorRamdisk() { |
Jiyong Park | a4b9dd0 | 2019-01-16 22:53:13 +0900 | [diff] [blame] | 292 | flags.DynamicLinker = "/system/bin/bootstrap/linker" |
| 293 | } else { |
| 294 | flags.DynamicLinker = "/system/bin/linker" |
| 295 | } |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 296 | if flags.Toolchain.Is64Bit() { |
| 297 | flags.DynamicLinker += "64" |
| 298 | } |
Dan Willemsen | 01a405a | 2016-06-13 17:19:03 -0700 | [diff] [blame] | 299 | case android.LinuxBionic: |
Dan Willemsen | c77a0b3 | 2017-09-18 23:19:12 -0700 | [diff] [blame] | 300 | flags.DynamicLinker = "" |
Dan Willemsen | 01a405a | 2016-06-13 17:19:03 -0700 | [diff] [blame] | 301 | default: |
| 302 | ctx.ModuleErrorf("unknown dynamic linker") |
| 303 | } |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | if ctx.Os() == android.LinuxBionic { |
| 307 | // Use the dlwrap entry point, but keep _start around so |
| 308 | // that it can be used by host_bionic_inject |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 309 | flags.Global.LdFlags = append(flags.Global.LdFlags, |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 310 | "-Wl,--entry=__dlwrap__start", |
| 311 | "-Wl,--undefined=_start", |
| 312 | ) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 313 | } |
| 314 | } |
| 315 | |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 316 | flags.Global.LdFlags = append(flags.Global.LdFlags, |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 317 | "-pie", |
| 318 | "-nostdlib", |
| 319 | "-Bdynamic", |
| 320 | "-Wl,--gc-sections", |
| 321 | "-Wl,-z,nocopyreloc", |
| 322 | ) |
| 323 | } |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 324 | } else { // not bionic |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 325 | if binary.static() { |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 326 | flags.Global.LdFlags = append(flags.Global.LdFlags, "-static") |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 327 | } |
| 328 | if ctx.Darwin() { |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 329 | flags.Global.LdFlags = append(flags.Global.LdFlags, "-Wl,-headerpad_max_install_names") |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 330 | } |
| 331 | } |
| 332 | |
| 333 | return flags |
| 334 | } |
| 335 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 336 | // link registers actions to link this binary, and sets various fields |
| 337 | // on this binary to reflect information that should be exported up the build |
| 338 | // tree (for example, exported flags and include paths). |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 339 | func (binary *binaryDecorator) link(ctx ModuleContext, |
Dan Willemsen | 5cb580f | 2016-09-26 17:33:01 -0700 | [diff] [blame] | 340 | flags Flags, deps PathDeps, objs Objects) android.Path { |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 341 | |
| 342 | fileName := binary.getStem(ctx) + flags.Toolchain.ExecutableSuffix() |
| 343 | outputFile := android.PathForModuleOut(ctx, fileName) |
| 344 | ret := outputFile |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 345 | |
| 346 | var linkerDeps android.Paths |
| 347 | |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 348 | if flags.DynamicLinker != "" { |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 349 | flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-dynamic-linker,"+flags.DynamicLinker) |
Colin Cross | 528d67e | 2021-07-23 22:23:07 +0000 | [diff] [blame] | 350 | } else if (ctx.toolchain().Bionic() || ctx.toolchain().Musl()) && !binary.static() { |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 351 | flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--no-dynamic-linker") |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 352 | } |
| 353 | |
Dan Willemsen | 4745007 | 2021-10-19 20:24:49 -0700 | [diff] [blame] | 354 | if ctx.Darwin() && deps.DarwinSecondArchOutput.Valid() { |
| 355 | fatOutputFile := outputFile |
| 356 | outputFile = android.PathForModuleOut(ctx, "pre-fat", fileName) |
| 357 | transformDarwinUniversalBinary(ctx, fatOutputFile, outputFile, deps.DarwinSecondArchOutput.Path()) |
| 358 | } |
| 359 | |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 360 | builderFlags := flagsToBuilderFlags(flags) |
ThiƩbaud Weksteen | d458745 | 2020-08-19 14:53:01 +0200 | [diff] [blame] | 361 | stripFlags := flagsToStripFlags(flags) |
| 362 | if binary.stripper.NeedsStrip(ctx) { |
Yi Kong | b5c34d7 | 2018-11-07 16:28:49 -0800 | [diff] [blame] | 363 | if ctx.Darwin() { |
ThiƩbaud Weksteen | d458745 | 2020-08-19 14:53:01 +0200 | [diff] [blame] | 364 | stripFlags.StripUseGnuStrip = true |
Yi Kong | b5c34d7 | 2018-11-07 16:28:49 -0800 | [diff] [blame] | 365 | } |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 366 | strippedOutputFile := outputFile |
| 367 | outputFile = android.PathForModuleOut(ctx, "unstripped", fileName) |
ThiƩbaud Weksteen | d458745 | 2020-08-19 14:53:01 +0200 | [diff] [blame] | 368 | binary.stripper.StripExecutableOrSharedLib(ctx, outputFile, strippedOutputFile, stripFlags) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 369 | } |
| 370 | |
Colin Cross | b60190a | 2018-09-04 16:28:17 -0700 | [diff] [blame] | 371 | binary.unstrippedOutputFile = outputFile |
| 372 | |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 373 | if String(binary.Properties.Prefix_symbols) != "" { |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 374 | afterPrefixSymbols := outputFile |
| 375 | outputFile = android.PathForModuleOut(ctx, "unprefixed", fileName) |
Chris Parsons | bf4f55f | 2020-11-23 17:02:44 -0500 | [diff] [blame] | 376 | transformBinaryPrefixSymbols(ctx, String(binary.Properties.Prefix_symbols), outputFile, |
ThiƩbaud Weksteen | d458745 | 2020-08-19 14:53:01 +0200 | [diff] [blame] | 377 | builderFlags, afterPrefixSymbols) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 378 | } |
| 379 | |
Colin Cross | d7227f9 | 2019-09-05 14:26:33 -0700 | [diff] [blame] | 380 | outputFile = maybeInjectBoringSSLHash(ctx, outputFile, binary.Properties.Inject_bssl_hash, fileName) |
| 381 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 382 | // If use_version_lib is true, make an android::build::GetBuildNumber() function available. |
Dan Willemsen | 569edc5 | 2018-11-19 09:33:29 -0800 | [diff] [blame] | 383 | if Bool(binary.baseLinker.Properties.Use_version_lib) { |
| 384 | if ctx.Host() { |
| 385 | versionedOutputFile := outputFile |
| 386 | outputFile = android.PathForModuleOut(ctx, "unversioned", fileName) |
| 387 | binary.injectVersionSymbol(ctx, outputFile, versionedOutputFile) |
| 388 | } else { |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 389 | // When dist'ing a library or binary that has use_version_lib set, always |
| 390 | // distribute the stamped version, even for the device. |
Dan Willemsen | 569edc5 | 2018-11-19 09:33:29 -0800 | [diff] [blame] | 391 | versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName) |
Jingwen Chen | 40fd90a | 2020-06-15 05:24:19 +0000 | [diff] [blame] | 392 | binary.distFiles = android.MakeDefaultDistFiles(versionedOutputFile) |
Dan Willemsen | 569edc5 | 2018-11-19 09:33:29 -0800 | [diff] [blame] | 393 | |
ThiƩbaud Weksteen | d458745 | 2020-08-19 14:53:01 +0200 | [diff] [blame] | 394 | if binary.stripper.NeedsStrip(ctx) { |
Dan Willemsen | 569edc5 | 2018-11-19 09:33:29 -0800 | [diff] [blame] | 395 | out := android.PathForModuleOut(ctx, "versioned-stripped", fileName) |
Jingwen Chen | 40fd90a | 2020-06-15 05:24:19 +0000 | [diff] [blame] | 396 | binary.distFiles = android.MakeDefaultDistFiles(out) |
ThiƩbaud Weksteen | d458745 | 2020-08-19 14:53:01 +0200 | [diff] [blame] | 397 | binary.stripper.StripExecutableOrSharedLib(ctx, versionedOutputFile, out, stripFlags) |
Dan Willemsen | 569edc5 | 2018-11-19 09:33:29 -0800 | [diff] [blame] | 398 | } |
| 399 | |
| 400 | binary.injectVersionSymbol(ctx, outputFile, versionedOutputFile) |
| 401 | } |
Colin Cross | 86803cf | 2018-02-15 14:12:26 -0800 | [diff] [blame] | 402 | } |
| 403 | |
Chih-Hung Hsieh | 8078377 | 2021-10-11 16:46:56 -0700 | [diff] [blame] | 404 | var validations android.Paths |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 405 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 406 | // Handle host bionic linker symbols. |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 407 | if ctx.Os() == android.LinuxBionic && !binary.static() { |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 408 | verifyFile := android.PathForModuleOut(ctx, "host_bionic_verify.stamp") |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 409 | |
| 410 | if !deps.DynamicLinker.Valid() { |
| 411 | panic("Non-static host bionic modules must have a dynamic linker") |
| 412 | } |
| 413 | |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 414 | binary.verifyHostBionicLinker(ctx, outputFile, deps.DynamicLinker.Path(), verifyFile) |
| 415 | validations = append(validations, verifyFile) |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 416 | } |
| 417 | |
Jaewoong Jung | 232c07c | 2018-12-18 11:08:25 -0800 | [diff] [blame] | 418 | var sharedLibs android.Paths |
| 419 | // Ignore shared libs for static executables. |
| 420 | if !binary.static() { |
Jiyong Park | 64a44f2 | 2019-01-18 14:37:08 +0900 | [diff] [blame] | 421 | sharedLibs = deps.EarlySharedLibs |
| 422 | sharedLibs = append(sharedLibs, deps.SharedLibs...) |
Jaewoong Jung | 232c07c | 2018-12-18 11:08:25 -0800 | [diff] [blame] | 423 | sharedLibs = append(sharedLibs, deps.LateSharedLibs...) |
Jiyong Park | 64a44f2 | 2019-01-18 14:37:08 +0900 | [diff] [blame] | 424 | linkerDeps = append(linkerDeps, deps.EarlySharedLibsDeps...) |
Jaewoong Jung | 232c07c | 2018-12-18 11:08:25 -0800 | [diff] [blame] | 425 | linkerDeps = append(linkerDeps, deps.SharedLibsDeps...) |
| 426 | linkerDeps = append(linkerDeps, deps.LateSharedLibsDeps...) |
Chih-Hung Hsieh | f6ca1b9 | 2021-12-05 18:02:50 -0800 | [diff] [blame] | 427 | linkerDeps = append(linkerDeps, ndkSharedLibDeps(ctx)...) |
Jaewoong Jung | 232c07c | 2018-12-18 11:08:25 -0800 | [diff] [blame] | 428 | } |
| 429 | |
Chih-Hung Hsieh | 7540a78 | 2022-01-08 19:56:09 -0800 | [diff] [blame] | 430 | validations = append(validations, objs.tidyDepFiles...) |
Pirama Arumuga Nainar | ada83ec | 2017-08-31 23:38:27 -0700 | [diff] [blame] | 431 | linkerDeps = append(linkerDeps, flags.LdFlagsDeps...) |
Colin Cross | 26c34ed | 2016-09-30 17:10:16 -0700 | [diff] [blame] | 432 | |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 433 | // Register link action. |
Chris Parsons | bf4f55f | 2020-11-23 17:02:44 -0500 | [diff] [blame] | 434 | transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs, deps.StaticLibs, |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 435 | deps.LateStaticLibs, deps.WholeStaticLibs, linkerDeps, deps.CrtBegin, deps.CrtEnd, true, |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 436 | builderFlags, outputFile, nil, validations) |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 437 | |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 438 | objs.coverageFiles = append(objs.coverageFiles, deps.StaticLibObjs.coverageFiles...) |
| 439 | objs.coverageFiles = append(objs.coverageFiles, deps.WholeStaticLibObjs.coverageFiles...) |
Chris Parsons | bf4f55f | 2020-11-23 17:02:44 -0500 | [diff] [blame] | 440 | binary.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, binary.getStem(ctx)) |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 441 | |
Alex Light | 3d67359 | 2019-01-18 14:37:31 -0800 | [diff] [blame] | 442 | // Need to determine symlinks early since some targets (ie APEX) need this |
| 443 | // information but will not call 'install' |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 444 | for _, symlink := range binary.Properties.Symlinks { |
| 445 | binary.symlinks = append(binary.symlinks, |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 446 | symlink+String(binary.Properties.Suffix)+ctx.toolchain().ExecutableSuffix()) |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 447 | } |
| 448 | |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 449 | if Bool(binary.Properties.Symlink_preferred_arch) { |
Roland Levillain | 9efb8c7 | 2019-06-05 13:31:31 +0100 | [diff] [blame] | 450 | if String(binary.Properties.Suffix) == "" { |
| 451 | ctx.PropertyErrorf("symlink_preferred_arch", "must also specify suffix") |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 452 | } |
| 453 | if ctx.TargetPrimary() { |
Chris Parsons | e0f2ab3 | 2020-11-20 17:27:25 -0500 | [diff] [blame] | 454 | // Install a symlink to the preferred architecture |
Colin Cross | a615901 | 2020-11-12 12:14:36 -0800 | [diff] [blame] | 455 | symlinkName := binary.getStemWithoutSuffix(ctx) |
| 456 | binary.symlinks = append(binary.symlinks, symlinkName) |
| 457 | binary.preferredArchSymlink = symlinkName |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 458 | } |
| 459 | } |
| 460 | |
Alex Light | 3d67359 | 2019-01-18 14:37:31 -0800 | [diff] [blame] | 461 | return ret |
| 462 | } |
| 463 | |
Jiyong Park | af6d895 | 2019-01-31 12:21:23 +0900 | [diff] [blame] | 464 | func (binary *binaryDecorator) unstrippedOutputFilePath() android.Path { |
| 465 | return binary.unstrippedOutputFile |
| 466 | } |
| 467 | |
Alex Light | 3d67359 | 2019-01-18 14:37:31 -0800 | [diff] [blame] | 468 | func (binary *binaryDecorator) symlinkList() []string { |
| 469 | return binary.symlinks |
| 470 | } |
| 471 | |
Pirama Arumuga Nainar | 65c95ff | 2019-03-25 10:21:31 -0700 | [diff] [blame] | 472 | func (binary *binaryDecorator) nativeCoverage() bool { |
| 473 | return true |
| 474 | } |
| 475 | |
Jiyong Park | ee9a98d | 2019-08-09 14:44:36 +0900 | [diff] [blame] | 476 | func (binary *binaryDecorator) coverageOutputFilePath() android.OptionalPath { |
| 477 | return binary.coverageOutputFile |
| 478 | } |
| 479 | |
Jiyong Park | f119435 | 2019-02-25 11:05:47 +0900 | [diff] [blame] | 480 | // /system/bin/linker -> /apex/com.android.runtime/bin/linker |
| 481 | func (binary *binaryDecorator) installSymlinkToRuntimeApex(ctx ModuleContext, file android.Path) { |
| 482 | dir := binary.baseInstaller.installDir(ctx) |
| 483 | dirOnDevice := android.InstallPathToOnDevicePath(ctx, dir) |
| 484 | target := "/" + filepath.Join("apex", "com.android.runtime", dir.Base(), file.Base()) |
| 485 | |
| 486 | ctx.InstallAbsoluteSymlink(dir, file.Base(), target) |
Jaewoong Jung | 18aefc1 | 2020-12-21 09:11:10 -0800 | [diff] [blame] | 487 | binary.postInstallCmds = append(binary.postInstallCmds, makeSymlinkCmd(dirOnDevice, file.Base(), target)) |
Jiyong Park | f119435 | 2019-02-25 11:05:47 +0900 | [diff] [blame] | 488 | |
| 489 | for _, symlink := range binary.symlinks { |
| 490 | ctx.InstallAbsoluteSymlink(dir, symlink, target) |
Jaewoong Jung | 18aefc1 | 2020-12-21 09:11:10 -0800 | [diff] [blame] | 491 | binary.postInstallCmds = append(binary.postInstallCmds, makeSymlinkCmd(dirOnDevice, symlink, target)) |
Jiyong Park | f119435 | 2019-02-25 11:05:47 +0900 | [diff] [blame] | 492 | } |
| 493 | } |
| 494 | |
Alex Light | 3d67359 | 2019-01-18 14:37:31 -0800 | [diff] [blame] | 495 | func (binary *binaryDecorator) install(ctx ModuleContext, file android.Path) { |
Jiyong Park | f119435 | 2019-02-25 11:05:47 +0900 | [diff] [blame] | 496 | // Bionic binaries (e.g. linker) is installed to the bootstrap subdirectory. |
| 497 | // The original path becomes a symlink to the corresponding file in the |
| 498 | // runtime APEX. |
Colin Cross | 3b19f5d | 2019-09-17 14:45:31 -0700 | [diff] [blame] | 499 | translatedArch := ctx.Target().NativeBridge == android.NativeBridgeEnabled |
Colin Cross | 56a8321 | 2020-09-15 18:30:11 -0700 | [diff] [blame] | 500 | if InstallToBootstrap(ctx.baseModuleName(), ctx.Config()) && !ctx.Host() && ctx.directlyInAnyApex() && |
Yifan Hong | 60e0cfb | 2020-10-21 15:17:56 -0700 | [diff] [blame] | 501 | !translatedArch && ctx.apexVariationName() == "" && !ctx.inRamdisk() && !ctx.inRecovery() && |
| 502 | !ctx.inVendorRamdisk() { |
Colin Cross | 56a8321 | 2020-09-15 18:30:11 -0700 | [diff] [blame] | 503 | |
Peter Collingbourne | 3478bb2 | 2019-04-24 14:41:12 -0700 | [diff] [blame] | 504 | if ctx.Device() && isBionic(ctx.baseModuleName()) { |
Jiyong Park | c3e2c86 | 2019-03-16 01:10:08 +0900 | [diff] [blame] | 505 | binary.installSymlinkToRuntimeApex(ctx, file) |
| 506 | } |
Jiyong Park | f119435 | 2019-02-25 11:05:47 +0900 | [diff] [blame] | 507 | binary.baseInstaller.subDir = "bootstrap" |
| 508 | } |
Alex Light | 3d67359 | 2019-01-18 14:37:31 -0800 | [diff] [blame] | 509 | binary.baseInstaller.install(ctx, file) |
Colin Cross | a615901 | 2020-11-12 12:14:36 -0800 | [diff] [blame] | 510 | |
| 511 | var preferredArchSymlinkPath android.OptionalPath |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 512 | for _, symlink := range binary.symlinks { |
Colin Cross | a615901 | 2020-11-12 12:14:36 -0800 | [diff] [blame] | 513 | installedSymlink := ctx.InstallSymlink(binary.baseInstaller.installDir(ctx), symlink, |
| 514 | binary.baseInstaller.path) |
| 515 | if symlink == binary.preferredArchSymlink { |
| 516 | // If this is the preferred arch symlink, save the installed path for use as the |
| 517 | // tool path. |
| 518 | preferredArchSymlinkPath = android.OptionalPathForPath(installedSymlink) |
| 519 | } |
Colin Cross | 9b09f24 | 2016-12-07 13:37:42 -0800 | [diff] [blame] | 520 | } |
| 521 | |
Dan Willemsen | 4aa75ca | 2016-09-28 16:18:03 -0700 | [diff] [blame] | 522 | if ctx.Os().Class == android.Host { |
Colin Cross | a615901 | 2020-11-12 12:14:36 -0800 | [diff] [blame] | 523 | // If the binary is multilib with a symlink to the preferred architecture, use the |
| 524 | // symlink instead of the binary because that's the more "canonical" name. |
| 525 | if preferredArchSymlinkPath.Valid() { |
| 526 | binary.toolPath = preferredArchSymlinkPath |
| 527 | } else { |
| 528 | binary.toolPath = android.OptionalPathForPath(binary.baseInstaller.path) |
| 529 | } |
Dan Willemsen | 4aa75ca | 2016-09-28 16:18:03 -0700 | [diff] [blame] | 530 | } |
| 531 | } |
| 532 | |
| 533 | func (binary *binaryDecorator) hostToolPath() android.OptionalPath { |
| 534 | return binary.toolPath |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 535 | } |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 536 | |
| 537 | func init() { |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 538 | pctx.HostBinToolVariable("verifyHostBionicCmd", "host_bionic_verify") |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 539 | } |
| 540 | |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 541 | var verifyHostBionic = pctx.AndroidStaticRule("verifyHostBionic", |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 542 | blueprint.RuleParams{ |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 543 | Command: "$verifyHostBionicCmd -i $in -l $linker && touch $out", |
| 544 | CommandDeps: []string{"$verifyHostBionicCmd"}, |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 545 | }, "linker") |
| 546 | |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 547 | func (binary *binaryDecorator) verifyHostBionicLinker(ctx ModuleContext, in, linker android.Path, out android.WritablePath) { |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 548 | ctx.Build(pctx, android.BuildParams{ |
Colin Cross | f04eb99 | 2021-06-11 15:22:41 -0700 | [diff] [blame] | 549 | Rule: verifyHostBionic, |
| 550 | Description: "verify host bionic", |
Dan Willemsen | a0790e3 | 2018-10-12 00:24:23 -0700 | [diff] [blame] | 551 | Input: in, |
| 552 | Implicit: linker, |
| 553 | Output: out, |
| 554 | Args: map[string]string{ |
| 555 | "linker": linker.String(), |
| 556 | }, |
| 557 | }) |
| 558 | } |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 559 | |
Yu Liu | 7f3605f | 2022-02-08 14:15:12 -0800 | [diff] [blame^] | 560 | type ccBinaryBazelHandler struct { |
| 561 | android.BazelHandler |
| 562 | |
| 563 | module *Module |
| 564 | } |
| 565 | |
| 566 | func (handler *ccBinaryBazelHandler) GenerateBazelBuildActions(ctx android.ModuleContext, label string) bool { |
| 567 | bazelCtx := ctx.Config().BazelContext |
| 568 | filePaths, ok := bazelCtx.GetOutputFiles(label, android.GetConfigKey(ctx)) |
| 569 | if ok { |
| 570 | if len(filePaths) != 1 { |
| 571 | ctx.ModuleErrorf("expected exactly one output file for '%s', but got %s", label, filePaths) |
| 572 | return false |
| 573 | } |
| 574 | outputFilePath := android.PathForBazelOut(ctx, filePaths[0]) |
| 575 | handler.module.outputFile = android.OptionalPathForPath(outputFilePath) |
| 576 | // TODO(b/220164721): We need to decide if we should return the stripped as the unstripped. |
| 577 | handler.module.linker.(*binaryDecorator).unstrippedOutputFile = outputFilePath |
| 578 | } |
| 579 | return ok |
| 580 | } |
| 581 | |
Liz Kammer | be46fcc | 2021-11-01 15:32:43 -0400 | [diff] [blame] | 582 | func binaryBp2build(ctx android.TopDownMutatorContext, m *Module, typ string) { |
Liz Kammer | e658348 | 2021-10-19 13:56:10 -0400 | [diff] [blame] | 583 | baseAttrs := bp2BuildParseBaseProps(ctx, m) |
Liz Kammer | 12615db | 2021-09-28 09:19:17 -0400 | [diff] [blame] | 584 | binaryLinkerAttrs := bp2buildBinaryLinkerProps(ctx, m) |
| 585 | |
| 586 | if proptools.BoolDefault(binaryLinkerAttrs.Linkshared, true) { |
| 587 | baseAttrs.implementationDynamicDeps.Add(baseAttrs.protoDependency) |
| 588 | } else { |
| 589 | baseAttrs.implementationDeps.Add(baseAttrs.protoDependency) |
| 590 | } |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 591 | |
| 592 | attrs := &binaryAttributes{ |
Liz Kammer | 12615db | 2021-09-28 09:19:17 -0400 | [diff] [blame] | 593 | binaryLinkerAttrs: binaryLinkerAttrs, |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 594 | |
Liz Kammer | e658348 | 2021-10-19 13:56:10 -0400 | [diff] [blame] | 595 | Srcs: baseAttrs.srcs, |
| 596 | Srcs_c: baseAttrs.cSrcs, |
| 597 | Srcs_as: baseAttrs.asSrcs, |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 598 | |
Liz Kammer | e658348 | 2021-10-19 13:56:10 -0400 | [diff] [blame] | 599 | Copts: baseAttrs.copts, |
| 600 | Cppflags: baseAttrs.cppFlags, |
| 601 | Conlyflags: baseAttrs.conlyFlags, |
| 602 | Asflags: baseAttrs.asFlags, |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 603 | |
Liz Kammer | e658348 | 2021-10-19 13:56:10 -0400 | [diff] [blame] | 604 | Deps: baseAttrs.implementationDeps, |
| 605 | Dynamic_deps: baseAttrs.implementationDynamicDeps, |
| 606 | Whole_archive_deps: baseAttrs.wholeArchiveDeps, |
| 607 | System_deps: baseAttrs.systemDynamicDeps, |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 608 | |
Liz Kammer | e658348 | 2021-10-19 13:56:10 -0400 | [diff] [blame] | 609 | Local_includes: baseAttrs.localIncludes, |
| 610 | Absolute_includes: baseAttrs.absoluteIncludes, |
| 611 | Linkopts: baseAttrs.linkopts, |
| 612 | Link_crt: baseAttrs.linkCrt, |
| 613 | Use_libcrt: baseAttrs.useLibcrt, |
| 614 | Rtti: baseAttrs.rtti, |
| 615 | Stl: baseAttrs.stl, |
| 616 | Cpp_std: baseAttrs.cppStd, |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 617 | |
Liz Kammer | e658348 | 2021-10-19 13:56:10 -0400 | [diff] [blame] | 618 | Additional_linker_inputs: baseAttrs.additionalLinkerInputs, |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 619 | |
| 620 | Strip: stripAttributes{ |
Liz Kammer | e658348 | 2021-10-19 13:56:10 -0400 | [diff] [blame] | 621 | Keep_symbols: baseAttrs.stripKeepSymbols, |
| 622 | Keep_symbols_and_debug_frame: baseAttrs.stripKeepSymbolsAndDebugFrame, |
| 623 | Keep_symbols_list: baseAttrs.stripKeepSymbolsList, |
| 624 | All: baseAttrs.stripAll, |
| 625 | None: baseAttrs.stripNone, |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 626 | }, |
| 627 | |
Chris Parsons | 58852a0 | 2021-12-09 18:10:18 -0500 | [diff] [blame] | 628 | Features: baseAttrs.features, |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 629 | } |
| 630 | |
Sam Delmerico | 75539d6 | 2022-01-31 14:37:29 +0000 | [diff] [blame] | 631 | ctx.CreateBazelTargetModule(bazel.BazelTargetModuleProperties{ |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 632 | Rule_class: "cc_binary", |
Liz Kammer | 2b376bc | 2022-01-12 12:00:49 -0500 | [diff] [blame] | 633 | Bzl_load_location: "//build/bazel/rules/cc:cc_binary.bzl", |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 634 | }, |
| 635 | android.CommonAttributes{Name: m.Name()}, |
Sam Delmerico | 75539d6 | 2022-01-31 14:37:29 +0000 | [diff] [blame] | 636 | attrs) |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 637 | } |
| 638 | |
| 639 | // binaryAttributes contains Bazel attributes corresponding to a cc binary |
| 640 | type binaryAttributes struct { |
| 641 | binaryLinkerAttrs |
| 642 | Srcs bazel.LabelListAttribute |
| 643 | Srcs_c bazel.LabelListAttribute |
| 644 | Srcs_as bazel.LabelListAttribute |
| 645 | |
| 646 | Copts bazel.StringListAttribute |
| 647 | Cppflags bazel.StringListAttribute |
| 648 | Conlyflags bazel.StringListAttribute |
| 649 | Asflags bazel.StringListAttribute |
| 650 | |
| 651 | Deps bazel.LabelListAttribute |
| 652 | Dynamic_deps bazel.LabelListAttribute |
| 653 | Whole_archive_deps bazel.LabelListAttribute |
| 654 | System_deps bazel.LabelListAttribute |
| 655 | |
| 656 | Local_includes bazel.StringListAttribute |
| 657 | Absolute_includes bazel.StringListAttribute |
| 658 | |
| 659 | Linkopts bazel.StringListAttribute |
| 660 | Additional_linker_inputs bazel.LabelListAttribute |
| 661 | |
| 662 | Link_crt bazel.BoolAttribute |
| 663 | Use_libcrt bazel.BoolAttribute |
| 664 | |
| 665 | Rtti bazel.BoolAttribute |
| 666 | Stl *string |
| 667 | Cpp_std *string |
| 668 | |
| 669 | Strip stripAttributes |
| 670 | |
| 671 | Features bazel.StringListAttribute |
Liz Kammer | 2b8004b | 2021-10-04 13:55:44 -0400 | [diff] [blame] | 672 | } |