diff options
Diffstat (limited to 'vendor/ar_archive_writer')
| -rw-r--r-- | vendor/ar_archive_writer/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/Cargo.toml | 32 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/LICENSE.txt | 219 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/Readme.md | 14 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/src/Alignment.h | 314 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/src/Archive.h | 426 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/src/ArchiveWriter.cpp | 872 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/src/ArchiveWriter.h | 57 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/src/alignment.rs | 23 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/src/archive.rs | 71 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/src/archive_writer.rs | 831 | ||||
| -rw-r--r-- | vendor/ar_archive_writer/src/lib.rs | 6 |
12 files changed, 2866 insertions, 0 deletions
diff --git a/vendor/ar_archive_writer/.cargo-checksum.json b/vendor/ar_archive_writer/.cargo-checksum.json new file mode 100644 index 000000000..da8ef71d3 --- /dev/null +++ b/vendor/ar_archive_writer/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"d77e4458f855c3eb93853cd1c88103eeaae424400d5d0ea22432b6ebb5d7a5d8","LICENSE.txt":"f72b120d1385408e9e380acc020756eb6ba1b461d66c328ea67327ba08d7dcfd","Readme.md":"8c0cff5a6a4a4b9d0809de3551f80dd8b5badfaef57f8bb1a8de1595fd04b61b","src/Alignment.h":"f3d4503c7e6486a0b438ac485d1dde82eb6ae8c2b8139fc4bb84cd15c9b72373","src/Archive.h":"925a5cf40a176059a5305de9ab560f4f5d3ff88fd5625ce2f368f70c0f0521ba","src/ArchiveWriter.cpp":"f52ee7968a2e0066eda1d0e622b769a7e704758e12d4514a7095d12b6733fe1f","src/ArchiveWriter.h":"4b4f5e761656f2f521b27c10d7830f7f4754ef3f24671875857beda1bd768d6c","src/alignment.rs":"01d0581fc5125b004b466302a545419d816015b146f30e43482f2183b2cdd9a1","src/archive.rs":"24b987e9878518d72de98057446f95e0bd2060b6e4321361573813bec3108ea5","src/archive_writer.rs":"9711d78417afdd468e2c655f1eec7333fc7ec31ed6d4d50ac6b6053dbe897a1c","src/lib.rs":"24fb03b1d2f801794b95f72a65a5e3eaccac201594431e8f7de3d5252cdb49bc"},"package":"276881980556fdadeb88aa1ffc667e4d2e8fe72531dfabcb7a82bb3c9ea9ba31"}
\ No newline at end of file diff --git a/vendor/ar_archive_writer/Cargo.toml b/vendor/ar_archive_writer/Cargo.toml new file mode 100644 index 000000000..20ed646c5 --- /dev/null +++ b/vendor/ar_archive_writer/Cargo.toml @@ -0,0 +1,32 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +name = "ar_archive_writer" +version = "0.1.1" +description = "A writer for object file ar archives" +readme = "Readme.md" +keywords = [ + "ar", + "archive", +] +license = "Apache-2.0 WITH LLVM-exception" +repository = "https://github.com/rust-lang/ar_archive_writer" +resolver = "2" + +[dependencies.object] +version = "0.29.0" +features = [ + "std", + "read", +] +default-features = false diff --git a/vendor/ar_archive_writer/LICENSE.txt b/vendor/ar_archive_writer/LICENSE.txt new file mode 100644 index 000000000..f9dc50615 --- /dev/null +++ b/vendor/ar_archive_writer/LICENSE.txt @@ -0,0 +1,219 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +--- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. + diff --git a/vendor/ar_archive_writer/Readme.md b/vendor/ar_archive_writer/Readme.md new file mode 100644 index 000000000..cee3ffe3e --- /dev/null +++ b/vendor/ar_archive_writer/Readme.md @@ -0,0 +1,14 @@ +# A writer for object file ar archives + +This is based on commit [8ef3e895a](https://github.com/llvm/llvm-project/tree/3d3ef9d073e1e27ea57480b371b7f5a9f5642ed2) (15.0.0-rc3) of LLVM's archive writer. + +## License + +Licensed under Apache License v2.0 with LLVM Exceptions +([LICENSE.txt](LICENSE.txt) or https://llvm.org/LICENSE.txt) + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in the work by you shall be dual licensed as above, without any +additional terms or conditions. diff --git a/vendor/ar_archive_writer/src/Alignment.h b/vendor/ar_archive_writer/src/Alignment.h new file mode 100644 index 000000000..7075dca68 --- /dev/null +++ b/vendor/ar_archive_writer/src/Alignment.h @@ -0,0 +1,314 @@ +// Copied from https://github.com/llvm/llvm-project/blob/3d3ef9d073e1e27ea57480b371b7f5a9f5642ed2/llvm/include/llvm/Support/Alignment.h + +//===-- llvm/Support/Alignment.h - Useful alignment functions ---*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains types to represent alignments. +// They are instrumented to guarantee some invariants are preserved and prevent +// invalid manipulations. +// +// - Align represents an alignment in bytes, it is always set and always a valid +// power of two, its minimum value is 1 which means no alignment requirements. +// +// - MaybeAlign is an optional type, it may be undefined or set. When it's set +// you can get the underlying Align type by using the getValue() method. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_SUPPORT_ALIGNMENT_H_ +#define LLVM_SUPPORT_ALIGNMENT_H_ + +#include "llvm/ADT/Optional.h" +#include "llvm/Support/MathExtras.h" +#include <cassert> +#ifndef NDEBUG +#include <string> +#endif // NDEBUG + +namespace llvm { + +#define ALIGN_CHECK_ISPOSITIVE(decl) \ + assert(decl > 0 && (#decl " should be defined")) + +/// This struct is a compact representation of a valid (non-zero power of two) +/// alignment. +/// It is suitable for use as static global constants. +struct Align { +private: + uint8_t ShiftValue = 0; /// The log2 of the required alignment. + /// ShiftValue is less than 64 by construction. + + friend struct MaybeAlign; + friend unsigned Log2(Align); + friend bool operator==(Align Lhs, Align Rhs); + friend bool operator!=(Align Lhs, Align Rhs); + friend bool operator<=(Align Lhs, Align Rhs); + friend bool operator>=(Align Lhs, Align Rhs); + friend bool operator<(Align Lhs, Align Rhs); + friend bool operator>(Align Lhs, Align Rhs); + friend unsigned encode(struct MaybeAlign A); + friend struct MaybeAlign decodeMaybeAlign(unsigned Value); + + /// A trivial type to allow construction of constexpr Align. + /// This is currently needed to workaround a bug in GCC 5.3 which prevents + /// definition of constexpr assign operators. + /// https://stackoverflow.com/questions/46756288/explicitly-defaulted-function-cannot-be-declared-as-constexpr-because-the-implic + /// FIXME: Remove this, make all assign operators constexpr and introduce user + /// defined literals when we don't have to support GCC 5.3 anymore. + /// https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain + struct LogValue { + uint8_t Log; + }; + +public: + /// Default is byte-aligned. + constexpr Align() = default; + /// Do not perform checks in case of copy/move construct/assign, because the + /// checks have been performed when building `Other`. + constexpr Align(const Align &Other) = default; + constexpr Align(Align &&Other) = default; + Align &operator=(const Align &Other) = default; + Align &operator=(Align &&Other) = default; + + explicit Align(uint64_t Value) { + assert(Value > 0 && "Value must not be 0"); + assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2"); + ShiftValue = Log2_64(Value); + assert(ShiftValue < 64 && "Broken invariant"); + } + + /// This is a hole in the type system and should not be abused. + /// Needed to interact with C for instance. + uint64_t value() const { return uint64_t(1) << ShiftValue; } + + // Returns the previous alignment. + Align previous() const { + assert(ShiftValue != 0 && "Undefined operation"); + Align Out; + Out.ShiftValue = ShiftValue - 1; + return Out; + } + + /// Allow constructions of constexpr Align. + template <size_t kValue> constexpr static LogValue Constant() { + return LogValue{static_cast<uint8_t>(CTLog2<kValue>())}; + } + + /// Allow constructions of constexpr Align from types. + /// Compile time equivalent to Align(alignof(T)). + template <typename T> constexpr static LogValue Of() { + return Constant<std::alignment_of<T>::value>(); + } + + /// Constexpr constructor from LogValue type. + constexpr Align(LogValue CA) : ShiftValue(CA.Log) {} +}; + +/// Treats the value 0 as a 1, so Align is always at least 1. +inline Align assumeAligned(uint64_t Value) { + return Value ? Align(Value) : Align(); +} + +/// This struct is a compact representation of a valid (power of two) or +/// undefined (0) alignment. +struct MaybeAlign : public llvm::Optional<Align> { +private: + using UP = llvm::Optional<Align>; + +public: + /// Default is undefined. + MaybeAlign() = default; + /// Do not perform checks in case of copy/move construct/assign, because the + /// checks have been performed when building `Other`. + MaybeAlign(const MaybeAlign &Other) = default; + MaybeAlign &operator=(const MaybeAlign &Other) = default; + MaybeAlign(MaybeAlign &&Other) = default; + MaybeAlign &operator=(MaybeAlign &&Other) = default; + + /// Use llvm::Optional<Align> constructor. + using UP::UP; + + explicit MaybeAlign(uint64_t Value) { + assert((Value == 0 || llvm::isPowerOf2_64(Value)) && + "Alignment is neither 0 nor a power of 2"); + if (Value) + emplace(Value); + } + + /// For convenience, returns a valid alignment or 1 if undefined. + Align valueOrOne() const { return value_or(Align()); } +}; + +/// Checks that SizeInBytes is a multiple of the alignment. +inline bool isAligned(Align Lhs, uint64_t SizeInBytes) { + return SizeInBytes % Lhs.value() == 0; +} + +/// Checks that Addr is a multiple of the alignment. +inline bool isAddrAligned(Align Lhs, const void *Addr) { + return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr)); +} + +/// Returns a multiple of A needed to store `Size` bytes. +inline uint64_t alignTo(uint64_t Size, Align A) { + const uint64_t Value = A.value(); + // The following line is equivalent to `(Size + Value - 1) / Value * Value`. + + // The division followed by a multiplication can be thought of as a right + // shift followed by a left shift which zeros out the extra bits produced in + // the bump; `~(Value - 1)` is a mask where all those bits being zeroed out + // are just zero. + + // Most compilers can generate this code but the pattern may be missed when + // multiple functions gets inlined. + return (Size + Value - 1) & ~(Value - 1U); +} + +/// If non-zero \p Skew is specified, the return value will be a minimal integer +/// that is greater than or equal to \p Size and equal to \p A * N + \p Skew for +/// some integer N. If \p Skew is larger than \p A, its value is adjusted to '\p +/// Skew mod \p A'. +/// +/// Examples: +/// \code +/// alignTo(5, Align(8), 7) = 7 +/// alignTo(17, Align(8), 1) = 17 +/// alignTo(~0LL, Align(8), 3) = 3 +/// \endcode +inline uint64_t alignTo(uint64_t Size, Align A, uint64_t Skew) { + const uint64_t Value = A.value(); + Skew %= Value; + return alignTo(Size - Skew, A) + Skew; +} + +/// Aligns `Addr` to `Alignment` bytes, rounding up. +inline uintptr_t alignAddr(const void *Addr, Align Alignment) { + uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr); + assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >= + ArithAddr && + "Overflow"); + return alignTo(ArithAddr, Alignment); +} + +/// Returns the offset to the next integer (mod 2**64) that is greater than +/// or equal to \p Value and is a multiple of \p Align. +inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) { + return alignTo(Value, Alignment) - Value; +} + +/// Returns the necessary adjustment for aligning `Addr` to `Alignment` +/// bytes, rounding up. +inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) { + return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment); +} + +/// Returns the log2 of the alignment. +inline unsigned Log2(Align A) { return A.ShiftValue; } + +/// Returns the alignment that satisfies both alignments. +/// Same semantic as MinAlign. +inline Align commonAlignment(Align A, uint64_t Offset) { + return Align(MinAlign(A.value(), Offset)); +} + +/// Returns a representation of the alignment that encodes undefined as 0. +inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; } + +/// Dual operation of the encode function above. +inline MaybeAlign decodeMaybeAlign(unsigned Value) { + if (Value == 0) + return MaybeAlign(); + Align Out; + Out.ShiftValue = Value - 1; + return Out; +} + +/// Returns a representation of the alignment, the encoded value is positive by +/// definition. +inline unsigned encode(Align A) { return encode(MaybeAlign(A)); } + +/// Comparisons between Align and scalars. Rhs must be positive. +inline bool operator==(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() == Rhs; +} +inline bool operator!=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() != Rhs; +} +inline bool operator<=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() <= Rhs; +} +inline bool operator>=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() >= Rhs; +} +inline bool operator<(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() < Rhs; +} +inline bool operator>(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() > Rhs; +} + +/// Comparisons operators between Align. +inline bool operator==(Align Lhs, Align Rhs) { + return Lhs.ShiftValue == Rhs.ShiftValue; +} +inline bool operator!=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue != Rhs.ShiftValue; +} +inline bool operator<=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue <= Rhs.ShiftValue; +} +inline bool operator>=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue >= Rhs.ShiftValue; +} +inline bool operator<(Align Lhs, Align Rhs) { + return Lhs.ShiftValue < Rhs.ShiftValue; +} +inline bool operator>(Align Lhs, Align Rhs) { + return Lhs.ShiftValue > Rhs.ShiftValue; +} + +// Don't allow relational comparisons with MaybeAlign. +bool operator<=(Align Lhs, MaybeAlign Rhs) = delete; +bool operator>=(Align Lhs, MaybeAlign Rhs) = delete; +bool operator<(Align Lhs, MaybeAlign Rhs) = delete; +bool operator>(Align Lhs, MaybeAlign Rhs) = delete; + +bool operator<=(MaybeAlign Lhs, Align Rhs) = delete; +bool operator>=(MaybeAlign Lhs, Align Rhs) = delete; +bool operator<(MaybeAlign Lhs, Align Rhs) = delete; +bool operator>(MaybeAlign Lhs, Align Rhs) = delete; + +bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete; +bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete; +bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete; +bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete; + +#ifndef NDEBUG +// For usage in LLVM_DEBUG macros. +inline std::string DebugStr(const Align &A) { + return std::to_string(A.value()); +} +// For usage in LLVM_DEBUG macros. +inline std::string DebugStr(const MaybeAlign &MA) { + if (MA) + return std::to_string(MA->value()); + return "None"; +} +#endif // NDEBUG + +#undef ALIGN_CHECK_ISPOSITIVE + +} // namespace llvm + +#endif // LLVM_SUPPORT_ALIGNMENT_H_ diff --git a/vendor/ar_archive_writer/src/Archive.h b/vendor/ar_archive_writer/src/Archive.h new file mode 100644 index 000000000..929839750 --- /dev/null +++ b/vendor/ar_archive_writer/src/Archive.h @@ -0,0 +1,426 @@ +// Copied from https://github.com/llvm/llvm-project/blob/3d3ef9d073e1e27ea57480b371b7f5a9f5642ed2/llvm/include/llvm/Object/Archive.h + +//===- Archive.h - ar archive file format -----------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file declares the ar archive file format class. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_OBJECT_ARCHIVE_H +#define LLVM_OBJECT_ARCHIVE_H + +#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/fallible_iterator.h" +#include "llvm/ADT/iterator_range.h" +#include "llvm/Object/Binary.h" +#include "llvm/Support/Chrono.h" +#include "llvm/Support/Error.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/MemoryBuffer.h" +#include <cassert> +#include <cstdint> +#include <memory> +#include <string> +#include <vector> + +namespace llvm { + +template <typename T> class Optional; + +namespace object { + +const char ArchiveMagic[] = "!<arch>\n"; +const char ThinArchiveMagic[] = "!<thin>\n"; +const char BigArchiveMagic[] = "<bigaf>\n"; + +class Archive; + +class AbstractArchiveMemberHeader { +protected: + AbstractArchiveMemberHeader(const Archive *Parent) : Parent(Parent){}; + +public: + friend class Archive; + virtual std::unique_ptr<AbstractArchiveMemberHeader> clone() const = 0; + virtual ~AbstractArchiveMemberHeader() = default; + + /// Get the name without looking up long names. + virtual Expected<StringRef> getRawName() const = 0; + virtual StringRef getRawAccessMode() const = 0; + virtual StringRef getRawLastModified() const = 0; + virtual StringRef getRawUID() const = 0; + virtual StringRef getRawGID() const = 0; + + /// Get the name looking up long names. + virtual Expected<StringRef> getName(uint64_t Size) const = 0; + virtual Expected<uint64_t> getSize() const = 0; + virtual uint64_t getOffset() const = 0; + + /// Get next file member location. + virtual Expected<const char *> getNextChildLoc() const = 0; + virtual Expected<bool> isThin() const = 0; + + Expected<sys::fs::perms> getAccessMode() const; + Expected<sys::TimePoint<std::chrono::seconds>> getLastModified() const; + Expected<unsigned> getUID() const; + Expected<unsigned> getGID() const; + + /// Returns the size in bytes of the format-defined member header of the + /// concrete archive type. + virtual uint64_t getSizeOf() const = 0; + + const Archive *Parent; +}; + +template <typename T> +class CommonArchiveMemberHeader : public AbstractArchiveMemberHeader { +public: + CommonArchiveMemberHeader(const Archive *Parent, const T *RawHeaderPtr) + : AbstractArchiveMemberHeader(Parent), ArMemHdr(RawHeaderPtr){}; + StringRef getRawAccessMode() const override; + StringRef getRawLastModified() const override; + StringRef getRawUID() const override; + StringRef getRawGID() const override; + + uint64_t getOffset() const override; + uint64_t getSizeOf() const override { return sizeof(T); } + + T const *ArMemHdr; +}; + +struct UnixArMemHdrType { + char Name[16]; + char LastModified[12]; + char UID[6]; + char GID[6]; + char AccessMode[8]; + char Size[10]; ///< Size of data, not including header or padding. + char Terminator[2]; +}; + +class ArchiveMemberHeader : public CommonArchiveMemberHeader<UnixArMemHdrType> { +public: + ArchiveMemberHeader(const Archive *Parent, const char *RawHeaderPtr, + uint64_t Size, Error *Err); + + std::unique_ptr<AbstractArchiveMemberHeader> clone() const override { + return std::make_unique<ArchiveMemberHeader>(*this); + } + + Expected<StringRef> getRawName() const override; + + Expected<StringRef> getName(uint64_t Size) const override; + Expected<uint64_t> getSize() const override; + Expected<const char *> getNextChildLoc() const override; + Expected<bool> isThin() const override; +}; + +// File Member Header +struct BigArMemHdrType { + char Size[20]; // File member size in decimal + char NextOffset[20]; // Next member offset in decimal + char PrevOffset[20]; // Previous member offset in decimal + char LastModified[12]; + char UID[12]; + char GID[12]; + char AccessMode[12]; + char NameLen[4]; // File member name length in decimal + union { + char Name[2]; // Start of member name + char Terminator[2]; + }; +}; + +// Define file member header of AIX big archive. +class BigArchiveMemberHeader + : public CommonArchiveMemberHeader<BigArMemHdrType> { + +public: + BigArchiveMemberHeader(Archive const *Parent, const char *RawHeaderPtr, + uint64_t Size, Error *Err); + std::unique_ptr<AbstractArchiveMemberHeader> clone() const override { + return std::make_unique<BigArchiveMemberHeader>(*this); + } + + Expected<StringRef> getRawName() const override; + Expected<uint64_t> getRawNameSize() const; + + Expected<StringRef> getName(uint64_t Size) const override; + Expected<uint64_t> getSize() const override; + Expected<const char *> getNextChildLoc() const override; + Expected<uint64_t> getNextOffset() const; + Expected<bool> isThin() const override { return false; } +}; + +class Archive : public Binary { + virtual void anchor(); + +public: + class Child { + friend Archive; + friend AbstractArchiveMemberHeader; + + const Archive *Parent; + std::unique_ptr<AbstractArchiveMemberHeader> Header; + /// Includes header but not padding byte. + StringRef Data; + /// Offset from Data to the start of the file. + uint16_t StartOfFile; + + Expected<bool> isThinMember() const; + + public: + Child(const Archive *Parent, const char *Start, Error *Err); + Child(const Archive *Parent, StringRef Data, uint16_t StartOfFile); + + Child(const Child &C) + : Parent(C.Parent), Data(C.Data), StartOfFile(C.StartOfFile) { + if (C.Header) + Header = C.Header->clone(); + } + + Child(Child &&C) { + Parent = std::move(C.Parent); + Header = std::move(C.Header); + Data = C.Data; + StartOfFile = C.StartOfFile; + } + + Child &operator=(Child &&C) noexcept { + if (&C == this) + return *this; + + Parent = std::move(C.Parent); + Header = std::move(C.Header); + Data = C.Data; + StartOfFile = C.StartOfFile; + + return *this; + } + + Child &operator=(const Child &C) { + if (&C == this) + return *this; + + Parent = C.Parent; + if (C.Header) + Header = C.Header->clone(); + Data = C.Data; + StartOfFile = C.StartOfFile; + + return *this; + } + + bool operator==(const Child &other) const { + assert(!Parent || !other.Parent || Parent == other.Parent); + return Data.begin() == other.Data.begin(); + } + + const Archive *getParent() const { return Parent; } + Expected<Child> getNext() const; + + Expected<StringRef> getName() const; + Expected<std::string> getFullName() const; + Expected<StringRef> getRawName() const { return Header->getRawName(); } + + Expected<sys::TimePoint<std::chrono::seconds>> getLastModified() const { + return Header->getLastModified(); + } + + StringRef getRawLastModified() const { + return Header->getRawLastModified(); + } + + Expected<unsigned> getUID() const { return Header->getUID(); } + Expected<unsigned> getGID() const { return Header->getGID(); } + + Expected<sys::fs::perms> getAccessMode() const { + return Header->getAccessMode(); + } + + /// \return the size of the archive member without the header or padding. + Expected<uint64_t> getSize() const; + /// \return the size in the archive header for this member. + Expected<uint64_t> getRawSize() const; + + Expected<StringRef> getBuffer() const; + uint64_t getChildOffset() const; + uint64_t getDataOffset() const { return getChildOffset() + StartOfFile; } + + Expected<MemoryBufferRef> getMemoryBufferRef() const; + + Expected<std::unique_ptr<Binary>> + getAsBinary(LLVMContext *Context = nullptr) const; + }; + + class ChildFallibleIterator { + Child C; + + public: + ChildFallibleIterator() : C(Child(nullptr, nullptr, nullptr)) {} + ChildFallibleIterator(const Child &C) : C(C) {} + + const Child *operator->() const { return &C; } + const Child &operator*() const { return C; } + + bool operator==(const ChildFallibleIterator &other) const { + // Ignore errors here: If an error occurred during increment then getNext + // will have been set to child_end(), and the following comparison should + // do the right thing. + return C == other.C; + } + + bool operator!=(const ChildFallibleIterator &other) const { + return !(*this == other); + } + + Error inc() { + auto NextChild = C.getNext(); + if (!NextChild) + return NextChild.takeError(); + C = std::move(*NextChild); + return Error::success(); + } + }; + + using child_iterator = fallible_iterator<ChildFallibleIterator>; + + class Symbol { + const Archive *Parent; + uint32_t SymbolIndex; + uint32_t StringIndex; // Extra index to the string. + + public: + Symbol(const Archive *p, uint32_t symi, uint32_t stri) + : Parent(p), SymbolIndex(symi), StringIndex(stri) {} + + bool operator==(const Symbol &other) const { + return (Parent == other.Parent) && (SymbolIndex == other.SymbolIndex); + } + + StringRef getName() const; + Expected<Child> getMember() const; + Symbol getNext() const; + }; + + class symbol_iterator { + Symbol symbol; + + public: + symbol_iterator(const Symbol &s) : symbol(s) {} + + const Symbol *operator->() const { return &symbol; } + const Symbol &operator*() const { return symbol; } + + bool operator==(const symbol_iterator &other) const { + return symbol == other.symbol; + } + + bool operator!=(const symbol_iterator &other) const { + return !(*this == other); + } + + symbol_iterator &operator++() { // Preincrement + symbol = symbol.getNext(); + return *this; + } + }; + + Archive(MemoryBufferRef Source, Error &Err); + static Expected<std::unique_ptr<Archive>> create(MemoryBufferRef Source); + + /// Size field is 10 decimal digits long + static const uint64_t MaxMemberSize = 9999999999; + + enum Kind { K_GNU, K_GNU64, K_BSD, K_DARWIN, K_DARWIN64, K_COFF, K_AIXBIG }; + + Kind kind() const { return (Kind)Format; } + bool isThin() const { return IsThin; } + static object::Archive::Kind getDefaultKindForHost(); + + child_iterator child_begin(Error &Err, bool SkipInternal = true) const; + child_iterator child_end() const; + iterator_range<child_iterator> children(Error &Err, + bool SkipInternal = true) const { + return make_range(child_begin(Err, SkipInternal), child_end()); + } + + symbol_iterator symbol_begin() const; + symbol_iterator symbol_end() const; + iterator_range<symbol_iterator> symbols() const { + return make_range(symbol_begin(), symbol_end()); + } + + static bool classof(Binary const *v) { return v->isArchive(); } + + // check if a symbol is in the archive + Expected<Optional<Child>> findSym(StringRef name) const; + + virtual bool isEmpty() const; + bool hasSymbolTable() const; + StringRef getSymbolTable() const { return SymbolTable; } + StringRef getStringTable() const { return StringTable; } + uint32_t getNumberOfSymbols() const; + virtual uint64_t getFirstChildOffset() const { return getArchiveMagicLen(); } + + std::vector<std::unique_ptr<MemoryBuffer>> takeThinBuffers() { + return std::move(ThinBuffers); + } + + std::unique_ptr<AbstractArchiveMemberHeader> + createArchiveMemberHeader(const char *RawHeaderPtr, uint64_t Size, + Error *Err) const; + +protected: + uint64_t getArchiveMagicLen() const; + void setFirstRegular(const Child &C); + + StringRef SymbolTable; + StringRef StringTable; + +private: + StringRef FirstRegularData; + uint16_t FirstRegularStartOfFile = -1; + + unsigned Format : 3; + unsigned IsThin : 1; + mutable std::vector<std::unique_ptr<MemoryBuffer>> ThinBuffers; +}; + +class BigArchive : public Archive { +public: + /// Fixed-Length Header. + struct FixLenHdr { + char Magic[sizeof(BigArchiveMagic) - 1]; ///< Big archive magic string. + char MemOffset[20]; ///< Offset to member table. + char GlobSymOffset[20]; ///< Offset to global symbol table. + char + GlobSym64Offset[20]; ///< Offset global symbol table for 64-bit objects. + char FirstChildOffset[20]; ///< Offset to first archive member. + char LastChildOffset[20]; ///< Offset to last archive member. + char FreeOffset[20]; ///< Offset to first mem on free list. + }; + + const FixLenHdr *ArFixLenHdr; + uint64_t FirstChildOffset = 0; + uint64_t LastChildOffset = 0; + +public: + BigArchive(MemoryBufferRef Source, Error &Err); + uint64_t getFirstChildOffset() const override { return FirstChildOffset; } + uint64_t getLastChildOffset() const { return LastChildOffset; } + bool isEmpty() const override { + return Data.getBufferSize() == sizeof(FixLenHdr); + }; +}; + +} // end namespace object +} // end namespace llvm + +#endif // LLVM_OBJECT_ARCHIVE_H diff --git a/vendor/ar_archive_writer/src/ArchiveWriter.cpp b/vendor/ar_archive_writer/src/ArchiveWriter.cpp new file mode 100644 index 000000000..341f1e96f --- /dev/null +++ b/vendor/ar_archive_writer/src/ArchiveWriter.cpp @@ -0,0 +1,872 @@ +// Copied from https://github.com/llvm/llvm-project/blob/3d3ef9d073e1e27ea57480b371b7f5a9f5642ed2/llvm/lib/Object/ArchiveWriter.cpp + +//===- ArchiveWriter.cpp - ar File Format implementation --------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the writeArchive function. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Object/ArchiveWriter.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/BinaryFormat/Magic.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/Object/Archive.h" +#include "llvm/Object/Error.h" +#include "llvm/Object/IRObjectFile.h" +#include "llvm/Object/MachO.h" +#include "llvm/Object/ObjectFile.h" +#include "llvm/Object/SymbolicFile.h" +#include "llvm/Object/XCOFFObjectFile.h" +#include "llvm/Support/Alignment.h" +#include "llvm/Support/EndianStream.h" +#include "llvm/Support/Errc.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/Format.h" +#include "llvm/Support/MathExtras.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/SmallVectorMemoryBuffer.h" +#include "llvm/Support/raw_ostream.h" + +#include <map> + +#if !defined(_MSC_VER) && !defined(__MINGW32__) +#include <unistd.h> +#else +#include <io.h> +#endif + +using namespace llvm; + +NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef) + : Buf(MemoryBuffer::getMemBuffer(BufRef, false)), + MemberName(BufRef.getBufferIdentifier()) {} + +object::Archive::Kind NewArchiveMember::detectKindFromObject() const { + auto MemBufferRef = this->Buf->getMemBufferRef(); + Expected<std::unique_ptr<object::ObjectFile>> OptionalObject = + object::ObjectFile::createObjectFile(MemBufferRef); + + if (OptionalObject) + return isa<object::MachOObjectFile>(**OptionalObject) + ? object::Archive::K_DARWIN + : (isa<object::XCOFFObjectFile>(**OptionalObject) + ? object::Archive::K_AIXBIG + : object::Archive::K_GNU); + + // Squelch the error in case we had a non-object file. + consumeError(OptionalObject.takeError()); + + // If we're adding a bitcode file to the archive, detect the Archive kind + // based on the target triple. + LLVMContext Context; + if (identify_magic(MemBufferRef.getBuffer()) == file_magic::bitcode) { + if (auto ObjOrErr = object::SymbolicFile::createSymbolicFile( + MemBufferRef, file_magic::bitcode, &Context)) { + auto &IRObject = cast<object::IRObjectFile>(**ObjOrErr); + return Triple(IRObject.getTargetTriple()).isOSDarwin() + ? object::Archive::K_DARWIN + : object::Archive::K_GNU; + } else { + // Squelch the error in case this was not a SymbolicFile. + consumeError(ObjOrErr.takeError()); + } + } + + return object::Archive::getDefaultKindForHost(); +} + +Expected<NewArchiveMember> +NewArchiveMember::getOldMember(const object::Archive::Child &OldMember, + bool Deterministic) { + Expected<llvm::MemoryBufferRef> BufOrErr = OldMember.getMemoryBufferRef(); + if (!BufOrErr) + return BufOrErr.takeError(); + + NewArchiveMember M; + M.Buf = MemoryBuffer::getMemBuffer(*BufOrErr, false); + M.MemberName = M.Buf->getBufferIdentifier(); + if (!Deterministic) { + auto ModTimeOrErr = OldMember.getLastModified(); + if (!ModTimeOrErr) + return ModTimeOrErr.takeError(); + M.ModTime = ModTimeOrErr.get(); + Expected<unsigned> UIDOrErr = OldMember.getUID(); + if (!UIDOrErr) + return UIDOrErr.takeError(); + M.UID = UIDOrErr.get(); + Expected<unsigned> GIDOrErr = OldMember.getGID(); + if (!GIDOrErr) + return GIDOrErr.takeError(); + M.GID = GIDOrErr.get(); + Expected<sys::fs::perms> AccessModeOrErr = OldMember.getAccessMode(); + if (!AccessModeOrErr) + return AccessModeOrErr.takeError(); + M.Perms = AccessModeOrErr.get(); + } + return std::move(M); +} + +Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName, + bool Deterministic) { + sys::fs::file_status Status; + auto FDOrErr = sys::fs::openNativeFileForRead(FileName); + if (!FDOrErr) + return FDOrErr.takeError(); + sys::fs::file_t FD = *FDOrErr; + assert(FD != sys::fs::kInvalidFile); + + if (auto EC = sys::fs::status(FD, Status)) + return errorCodeToError(EC); + + // Opening a directory doesn't make sense. Let it fail. + // Linux cannot open directories with open(2), although + // cygwin and *bsd can. + if (Status.type() == sys::fs::file_type::directory_file) + return errorCodeToError(make_error_code(errc::is_a_directory)); + + ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr = + MemoryBuffer::getOpenFile(FD, FileName, Status.getSize(), false); + if (!MemberBufferOrErr) + return errorCodeToError(MemberBufferOrErr.getError()); + + if (auto EC = sys::fs::closeFile(FD)) + return errorCodeToError(EC); + + NewArchiveMember M; + M.Buf = std::move(*MemberBufferOrErr); + M.MemberName = M.Buf->getBufferIdentifier(); + if (!Deterministic) { + M.ModTime = std::chrono::time_point_cast<std::chrono::seconds>( + Status.getLastModificationTime()); + M.UID = Status.getUser(); + M.GID = Status.getGroup(); + M.Perms = Status.permissions(); + } + return std::move(M); +} + +template <typename T> +static void printWithSpacePadding(raw_ostream &OS, T Data, unsigned Size) { + uint64_t OldPos = OS.tell(); + OS << Data; + unsigned SizeSoFar = OS.tell() - OldPos; + assert(SizeSoFar <= Size && "Data doesn't fit in Size"); + OS.indent(Size - SizeSoFar); +} + +static bool isDarwin(object::Archive::Kind Kind) { + return Kind == object::Archive::K_DARWIN || + Kind == object::Archive::K_DARWIN64; +} + +static bool isAIXBigArchive(object::Archive::Kind Kind) { + return Kind == object::Archive::K_AIXBIG; +} + +static bool isBSDLike(object::Archive::Kind Kind) { + switch (Kind) { + case object::Archive::K_GNU: + case object::Archive::K_GNU64: + case object::Archive::K_AIXBIG: + return false; + case object::Archive::K_BSD: + case object::Archive::K_DARWIN: + case object::Archive::K_DARWIN64: + return true; + case object::Archive::K_COFF: + break; + } + llvm_unreachable("not supported for writting"); +} + +template <class T> +static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val) { + support::endian::write(Out, Val, + isBSDLike(Kind) ? support::little : support::big); +} + +static void printRestOfMemberHeader( + raw_ostream &Out, const sys::TimePoint<std::chrono::seconds> &ModTime, + unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) { + printWithSpacePadding(Out, sys::toTimeT(ModTime), 12); + + // The format has only 6 chars for uid and gid. Truncate if the provided + // values don't fit. + printWithSpacePadding(Out, UID % 1000000, 6); + printWithSpacePadding(Out, GID % 1000000, 6); + + printWithSpacePadding(Out, format("%o", Perms), 8); + printWithSpacePadding(Out, Size, 10); + Out << "`\n"; +} + +static void +printGNUSmallMemberHeader(raw_ostream &Out, StringRef Name, + const sys::TimePoint<std::chrono::seconds> &ModTime, + unsigned UID, unsigned GID, unsigned Perms, + uint64_t Size) { + printWithSpacePadding(Out, Twine(Name) + "/", 16); + printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size); +} + +static void +printBSDMemberHeader(raw_ostream &Out, uint64_t Pos, StringRef Name, + const sys::TimePoint<std::chrono::seconds> &ModTime, + unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) { + uint64_t PosAfterHeader = Pos + 60 + Name.size(); + // Pad so that even 64 bit object files are aligned. + unsigned Pad = offsetToAlignment(PosAfterHeader, Align(8)); + unsigned NameWithPadding = Name.size() + Pad; + printWithSpacePadding(Out, Twine("#1/") + Twine(NameWithPadding), 16); + printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, + NameWithPadding + Size); + Out << Name; + while (Pad--) + Out.write(uint8_t(0)); +} + +static void +printBigArchiveMemberHeader(raw_ostream &Out, StringRef Name, + const sys::TimePoint<std::chrono::seconds> &ModTime, + unsigned UID, unsigned GID, unsigned Perms, + uint64_t Size, unsigned PrevOffset, + unsigned NextOffset) { + unsigned NameLen = Name.size(); + + printWithSpacePadding(Out, Size, 20); // File member size + printWithSpacePadding(Out, NextOffset, 20); // Next member header offset + printWithSpacePadding(Out, PrevOffset, 20); // Previous member header offset + printWithSpacePadding(Out, sys::toTimeT(ModTime), 12); // File member date + // The big archive format has 12 chars for uid and gid. + printWithSpacePadding(Out, UID % 1000000000000, 12); // UID + printWithSpacePadding(Out, GID % 1000000000000, 12); // GID + printWithSpacePadding(Out, format("%o", Perms), 12); // Permission + printWithSpacePadding(Out, NameLen, 4); // Name length + if (NameLen) { + printWithSpacePadding(Out, Name, NameLen); // Name + if (NameLen % 2) + Out.write(uint8_t(0)); // Null byte padding + } + Out << "`\n"; // Terminator +} + +static bool useStringTable(bool Thin, StringRef Name) { + return Thin || Name.size() >= 16 || Name.contains('/'); +} + +static bool is64BitKind(object::Archive::Kind Kind) { + switch (Kind) { + case object::Archive::K_GNU: + case object::Archive::K_BSD: + case object::Archive::K_DARWIN: + case object::Archive::K_COFF: + return false; + case object::Archive::K_AIXBIG: + case object::Archive::K_DARWIN64: + case object::Archive::K_GNU64: + return true; + } + llvm_unreachable("not supported for writting"); +} + +static void +printMemberHeader(raw_ostream &Out, uint64_t Pos, raw_ostream &StringTable, + StringMap<uint64_t> &MemberNames, object::Archive::Kind Kind, + bool Thin, const NewArchiveMember &M, + sys::TimePoint<std::chrono::seconds> ModTime, uint64_t Size) { + if (isBSDLike(Kind)) + return printBSDMemberHeader(Out, Pos, M.MemberName, ModTime, M.UID, M.GID, + M.Perms, Size); + if (!useStringTable(Thin, M.MemberName)) + return printGNUSmallMemberHeader(Out, M.MemberName, ModTime, M.UID, M.GID, + M.Perms, Size); + Out << '/'; + uint64_t NamePos; + if (Thin) { + NamePos = StringTable.tell(); + StringTable << M.MemberName << "/\n"; + } else { + auto Insertion = MemberNames.insert({M.MemberName, uint64_t(0)}); + if (Insertion.second) { + Insertion.first->second = StringTable.tell(); + StringTable << M.MemberName << "/\n"; + } + NamePos = Insertion.first->second; + } + printWithSpacePadding(Out, NamePos, 15); + printRestOfMemberHeader(Out, ModTime, M.UID, M.GID, M.Perms, Size); +} + +namespace { +struct MemberData { + std::vector<unsigned> Symbols; + std::string Header; + StringRef Data; + StringRef Padding; +}; +} // namespace + +static MemberData computeStringTable(StringRef Names) { + unsigned Size = Names.size(); + unsigned Pad = offsetToAlignment(Size, Align(2)); + std::string Header; + raw_string_ostream Out(Header); + printWithSpacePadding(Out, "//", 48); + printWithSpacePadding(Out, Size + Pad, 10); + Out << "`\n"; + Out.flush(); + return {{}, std::move(Header), Names, Pad ? "\n" : ""}; +} + +static sys::TimePoint<std::chrono::seconds> now(bool Deterministic) { + using namespace std::chrono; + + if (!Deterministic) + return time_point_cast<seconds>(system_clock::now()); + return sys::TimePoint<seconds>(); +} + +static bool isArchiveSymbol(const object::BasicSymbolRef &S) { + Expected<uint32_t> SymFlagsOrErr = S.getFlags(); + if (!SymFlagsOrErr) + // TODO: Actually report errors helpfully. + report_fatal_error(SymFlagsOrErr.takeError()); + if (*SymFlagsOrErr & object::SymbolRef::SF_FormatSpecific) + return false; + if (!(*SymFlagsOrErr & object::SymbolRef::SF_Global)) + return false; + if (*SymFlagsOrErr & object::SymbolRef::SF_Undefined) + return false; + return true; +} + +static void printNBits(raw_ostream &Out, object::Archive::Kind Kind, + uint64_t Val) { + if (is64BitKind(Kind)) + print<uint64_t>(Out, Kind, Val); + else + print<uint32_t>(Out, Kind, Val); +} + +static uint64_t computeSymbolTableSize(object::Archive::Kind Kind, + uint64_t NumSyms, uint64_t OffsetSize, + StringRef StringTable, + uint32_t *Padding = nullptr) { + assert((OffsetSize == 4 || OffsetSize == 8) && "Unsupported OffsetSize"); + uint64_t Size = OffsetSize; // Number of entries + if (isBSDLike(Kind)) + Size += NumSyms * OffsetSize * 2; // Table + else + Size += NumSyms * OffsetSize; // Table + if (isBSDLike(Kind)) + Size += OffsetSize; // byte count + Size += StringTable.size(); + // ld64 expects the members to be 8-byte aligned for 64-bit content and at + // least 4-byte aligned for 32-bit content. Opt for the larger encoding + // uniformly. + // We do this for all bsd formats because it simplifies aligning members. + // For the big archive format, the symbol table is the last member, so there + // is no need to align. + uint32_t Pad = isAIXBigArchive(Kind) + ? 0 + : offsetToAlignment(Size, Align(isBSDLike(Kind) ? 8 : 2)); + Size += Pad; + if (Padding) + *Padding = Pad; + return Size; +} + +static void writeSymbolTableHeader(raw_ostream &Out, object::Archive::Kind Kind, + bool Deterministic, uint64_t Size, + uint64_t PrevMemberOffset = 0) { + if (isBSDLike(Kind)) { + const char *Name = is64BitKind(Kind) ? "__.SYMDEF_64" : "__.SYMDEF"; + printBSDMemberHeader(Out, Out.tell(), Name, now(Deterministic), 0, 0, 0, + Size); + } else if (isAIXBigArchive(Kind)) { + printBigArchiveMemberHeader(Out, "", now(Deterministic), 0, 0, + 0, Size, PrevMemberOffset, 0); + } else { + const char *Name = is64BitKind(Kind) ? "/SYM64" : ""; + printGNUSmallMemberHeader(Out, Name, now(Deterministic), 0, 0, 0, Size); + } +} + +static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind, + bool Deterministic, ArrayRef<MemberData> Members, + StringRef StringTable, + uint64_t PrevMemberOffset = 0) { + // We don't write a symbol table on an archive with no members -- except on + // Darwin, where the linker will abort unless the archive has a symbol table. + if (StringTable.empty() && !isDarwin(Kind)) + return; + + unsigned NumSyms = 0; + for (const MemberData &M : Members) + NumSyms += M.Symbols.size(); + + uint64_t OffsetSize = is64BitKind(Kind) ? 8 : 4; + uint32_t Pad; + uint64_t Size = computeSymbolTableSize(Kind, NumSyms, OffsetSize, StringTable, &Pad); + writeSymbolTableHeader(Out, Kind, Deterministic, Size, PrevMemberOffset); + + uint64_t Pos = isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr) + : Out.tell() + Size; + + if (isBSDLike(Kind)) + printNBits(Out, Kind, NumSyms * 2 * OffsetSize); + else + printNBits(Out, Kind, NumSyms); + + for (const MemberData &M : Members) { + for (unsigned StringOffset : M.Symbols) { + if (isBSDLike(Kind)) + printNBits(Out, Kind, StringOffset); + printNBits(Out, Kind, Pos); // member offset + } + Pos += M.Header.size() + M.Data.size() + M.Padding.size(); + } + + if (isBSDLike(Kind)) + // byte count of the string table + printNBits(Out, Kind, StringTable.size()); + Out << StringTable; + + while (Pad--) + Out.write(uint8_t(0)); +} + +static Expected<std::vector<unsigned>> +getSymbols(MemoryBufferRef Buf, raw_ostream &SymNames, bool &HasObject) { + std::vector<unsigned> Ret; + + // In the scenario when LLVMContext is populated SymbolicFile will contain a + // reference to it, thus SymbolicFile should be destroyed first. + LLVMContext Context; + std::unique_ptr<object::SymbolicFile> Obj; + + const file_magic Type = identify_magic(Buf.getBuffer()); + // Treat unsupported file types as having no symbols. + if (!object::SymbolicFile::isSymbolicFile(Type, &Context)) + return Ret; + if (Type == file_magic::bitcode) { + auto ObjOrErr = object::SymbolicFile::createSymbolicFile( + Buf, file_magic::bitcode, &Context); + if (!ObjOrErr) + return ObjOrErr.takeError(); + Obj = std::move(*ObjOrErr); + } else { + auto ObjOrErr = object::SymbolicFile::createSymbolicFile(Buf); + if (!ObjOrErr) + return ObjOrErr.takeError(); + Obj = std::move(*ObjOrErr); + } + + HasObject = true; + for (const object::BasicSymbolRef &S : Obj->symbols()) { + if (!isArchiveSymbol(S)) + continue; + Ret.push_back(SymNames.tell()); + if (Error E = S.printName(SymNames)) + return std::move(E); + SymNames << '\0'; + } + return Ret; +} + +static Expected<std::vector<MemberData>> +computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames, + object::Archive::Kind Kind, bool Thin, bool Deterministic, + bool NeedSymbols, ArrayRef<NewArchiveMember> NewMembers) { + static char PaddingData[8] = {'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'}; + + uint64_t Pos = + isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr) : 0; + + std::vector<MemberData> Ret; + bool HasObject = false; + + // Deduplicate long member names in the string table and reuse earlier name + // offsets. This especially saves space for COFF Import libraries where all + // members have the same name. + StringMap<uint64_t> MemberNames; + + // UniqueTimestamps is a special case to improve debugging on Darwin: + // + // The Darwin linker does not link debug info into the final + // binary. Instead, it emits entries of type N_OSO in in the output + // binary's symbol table, containing references to the linked-in + // object files. Using that reference, the debugger can read the + // debug data directly from the object files. Alternatively, an + // invocation of 'dsymutil' will link the debug data from the object + // files into a dSYM bundle, which can be loaded by the debugger, + // instead of the object files. + // + // For an object file, the N_OSO entries contain the absolute path + // path to the file, and the file's timestamp. For an object + // included in an archive, the path is formatted like + // "/absolute/path/to/archive.a(member.o)", and the timestamp is the + // archive member's timestamp, rather than the archive's timestamp. + // + // However, this doesn't always uniquely identify an object within + // an archive -- an archive file can have multiple entries with the + // same filename. (This will happen commonly if the original object + // files started in different directories.) The only way they get + // distinguished, then, is via the timestamp. But this process is + // unable to find the correct object file in the archive when there + // are two files of the same name and timestamp. + // + // Additionally, timestamp==0 is treated specially, and causes the + // timestamp to be ignored as a match criteria. + // + // That will "usually" work out okay when creating an archive not in + // deterministic timestamp mode, because the objects will probably + // have been created at different timestamps. + // + // To ameliorate this problem, in deterministic archive mode (which + // is the default), on Darwin we will emit a unique non-zero + // timestamp for each entry with a duplicated name. This is still + // deterministic: the only thing affecting that timestamp is the + // order of the files in the resultant archive. + // + // See also the functions that handle the lookup: + // in lldb: ObjectContainerBSDArchive::Archive::FindObject() + // in llvm/tools/dsymutil: BinaryHolder::GetArchiveMemberBuffers(). + bool UniqueTimestamps = Deterministic && isDarwin(Kind); + std::map<StringRef, unsigned> FilenameCount; + if (UniqueTimestamps) { + for (const NewArchiveMember &M : NewMembers) + FilenameCount[M.MemberName]++; + for (auto &Entry : FilenameCount) + Entry.second = Entry.second > 1 ? 1 : 0; + } + + // The big archive format needs to know the offset of the previous member + // header. + unsigned PrevOffset = 0; + for (const NewArchiveMember &M : NewMembers) { + std::string Header; + raw_string_ostream Out(Header); + + MemoryBufferRef Buf = M.Buf->getMemBufferRef(); + StringRef Data = Thin ? "" : Buf.getBuffer(); + + // ld64 expects the members to be 8-byte aligned for 64-bit content and at + // least 4-byte aligned for 32-bit content. Opt for the larger encoding + // uniformly. This matches the behaviour with cctools and ensures that ld64 + // is happy with archives that we generate. + unsigned MemberPadding = + isDarwin(Kind) ? offsetToAlignment(Data.size(), Align(8)) : 0; + unsigned TailPadding = + offsetToAlignment(Data.size() + MemberPadding, Align(2)); + StringRef Padding = StringRef(PaddingData, MemberPadding + TailPadding); + + sys::TimePoint<std::chrono::seconds> ModTime; + if (UniqueTimestamps) + // Increment timestamp for each file of a given name. + ModTime = sys::toTimePoint(FilenameCount[M.MemberName]++); + else + ModTime = M.ModTime; + + uint64_t Size = Buf.getBufferSize() + MemberPadding; + if (Size > object::Archive::MaxMemberSize) { + std::string StringMsg = + "File " + M.MemberName.str() + " exceeds size limit"; + return make_error<object::GenericBinaryError>( + std::move(StringMsg), object::object_error::parse_failed); + } + + if (isAIXBigArchive(Kind)) { + unsigned NextOffset = Pos + sizeof(object::BigArMemHdrType) + + alignTo(M.MemberName.size(), 2) + alignTo(Size, 2); + printBigArchiveMemberHeader(Out, M.MemberName, ModTime, M.UID, M.GID, + M.Perms, Size, PrevOffset, NextOffset); + PrevOffset = Pos; + } else { + printMemberHeader(Out, Pos, StringTable, MemberNames, Kind, Thin, M, + ModTime, Size); + } + Out.flush(); + + std::vector<unsigned> Symbols; + if (NeedSymbols) { + Expected<std::vector<unsigned>> SymbolsOrErr = + getSymbols(Buf, SymNames, HasObject); + if (auto E = SymbolsOrErr.takeError()) + return std::move(E); + Symbols = std::move(*SymbolsOrErr); + } + + Pos += Header.size() + Data.size() + Padding.size(); + Ret.push_back({std::move(Symbols), std::move(Header), Data, Padding}); + } + // If there are no symbols, emit an empty symbol table, to satisfy Solaris + // tools, older versions of which expect a symbol table in a non-empty + // archive, regardless of whether there are any symbols in it. + if (HasObject && SymNames.tell() == 0) + SymNames << '\0' << '\0' << '\0'; + return Ret; +} + +namespace llvm { + +static ErrorOr<SmallString<128>> canonicalizePath(StringRef P) { + SmallString<128> Ret = P; + std::error_code Err = sys::fs::make_absolute(Ret); + if (Err) + return Err; + sys::path::remove_dots(Ret, /*removedotdot*/ true); + return Ret; +} + +// Compute the relative path from From to To. +Expected<std::string> computeArchiveRelativePath(StringRef From, StringRef To) { + ErrorOr<SmallString<128>> PathToOrErr = canonicalizePath(To); + ErrorOr<SmallString<128>> DirFromOrErr = canonicalizePath(From); + if (!PathToOrErr || !DirFromOrErr) + return errorCodeToError(std::error_code(errno, std::generic_category())); + + const SmallString<128> &PathTo = *PathToOrErr; + const SmallString<128> &DirFrom = sys::path::parent_path(*DirFromOrErr); + + // Can't construct a relative path between different roots + if (sys::path::root_name(PathTo) != sys::path::root_name(DirFrom)) + return sys::path::convert_to_slash(PathTo); + + // Skip common prefixes + auto FromTo = + std::mismatch(sys::path::begin(DirFrom), sys::path::end(DirFrom), + sys::path::begin(PathTo)); + auto FromI = FromTo.first; + auto ToI = FromTo.second; + + // Construct relative path + SmallString<128> Relative; + for (auto FromE = sys::path::end(DirFrom); FromI != FromE; ++FromI) + sys::path::append(Relative, sys::path::Style::posix, ".."); + + for (auto ToE = sys::path::end(PathTo); ToI != ToE; ++ToI) + sys::path::append(Relative, sys::path::Style::posix, *ToI); + + return std::string(Relative.str()); +} + +static Error writeArchiveToStream(raw_ostream &Out, + ArrayRef<NewArchiveMember> NewMembers, + bool WriteSymtab, object::Archive::Kind Kind, + bool Deterministic, bool Thin) { + assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode"); + + SmallString<0> SymNamesBuf; + raw_svector_ostream SymNames(SymNamesBuf); + SmallString<0> StringTableBuf; + raw_svector_ostream StringTable(StringTableBuf); + + Expected<std::vector<MemberData>> DataOrErr = + computeMemberData(StringTable, SymNames, Kind, Thin, Deterministic, + WriteSymtab, NewMembers); + if (Error E = DataOrErr.takeError()) + return E; + std::vector<MemberData> &Data = *DataOrErr; + + if (!StringTableBuf.empty() && !isAIXBigArchive(Kind)) + Data.insert(Data.begin(), computeStringTable(StringTableBuf)); + + // We would like to detect if we need to switch to a 64-bit symbol table. + uint64_t LastMemberEndOffset = + isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr) : 8; + uint64_t LastMemberHeaderOffset = LastMemberEndOffset; + uint64_t NumSyms = 0; + for (const auto &M : Data) { + // Record the start of the member's offset + LastMemberHeaderOffset = LastMemberEndOffset; + // Account for the size of each part associated with the member. + LastMemberEndOffset += M.Header.size() + M.Data.size() + M.Padding.size(); + NumSyms += M.Symbols.size(); + } + + // The symbol table is put at the end of the big archive file. The symbol + // table is at the start of the archive file for other archive formats. + if (WriteSymtab && !isAIXBigArchive(Kind)) { + // We assume 32-bit offsets to see if 32-bit symbols are possible or not. + uint64_t SymtabSize = computeSymbolTableSize(Kind, NumSyms, 4, SymNamesBuf); + auto computeSymbolTableHeaderSize = + [=] { + SmallString<0> TmpBuf; + raw_svector_ostream Tmp(TmpBuf); + writeSymbolTableHeader(Tmp, Kind, Deterministic, SymtabSize); + return TmpBuf.size(); + }; + LastMemberHeaderOffset += computeSymbolTableHeaderSize() + SymtabSize; + + // The SYM64 format is used when an archive's member offsets are larger than + // 32-bits can hold. The need for this shift in format is detected by + // writeArchive. To test this we need to generate a file with a member that + // has an offset larger than 32-bits but this demands a very slow test. To + // speed the test up we use this environment variable to pretend like the + // cutoff happens before 32-bits and instead happens at some much smaller + // value. + uint64_t Sym64Threshold = 1ULL << 32; + const char *Sym64Env = std::getenv("SYM64_THRESHOLD"); + if (Sym64Env) + StringRef(Sym64Env).getAsInteger(10, Sym64Threshold); + + // If LastMemberHeaderOffset isn't going to fit in a 32-bit varible we need + // to switch to 64-bit. Note that the file can be larger than 4GB as long as + // the last member starts before the 4GB offset. + if (LastMemberHeaderOffset >= Sym64Threshold) { + if (Kind == object::Archive::K_DARWIN) + Kind = object::Archive::K_DARWIN64; + else + Kind = object::Archive::K_GNU64; + } + } + + if (Thin) + Out << "!<thin>\n"; + else if (isAIXBigArchive(Kind)) + Out << "<bigaf>\n"; + else + Out << "!<arch>\n"; + + if (!isAIXBigArchive(Kind)) { + if (WriteSymtab) + writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf); + for (const MemberData &M : Data) + Out << M.Header << M.Data << M.Padding; + } else { + // For the big archive (AIX) format, compute a table of member names and + // offsets, used in the member table. + uint64_t MemberTableNameStrTblSize = 0; + std::vector<size_t> MemberOffsets; + std::vector<StringRef> MemberNames; + // Loop across object to find offset and names. + uint64_t MemberEndOffset = sizeof(object::BigArchive::FixLenHdr); + for (size_t I = 0, Size = NewMembers.size(); I != Size; ++I) { + const NewArchiveMember &Member = NewMembers[I]; + MemberTableNameStrTblSize += Member.MemberName.size() + 1; + MemberOffsets.push_back(MemberEndOffset); + MemberNames.push_back(Member.MemberName); + // File member name ended with "`\n". The length is included in + // BigArMemHdrType. + MemberEndOffset += sizeof(object::BigArMemHdrType) + + alignTo(Data[I].Data.size(), 2) + + alignTo(Member.MemberName.size(), 2); + } + + // AIX member table size. + unsigned MemberTableSize = 20 + // Number of members field + 20 * MemberOffsets.size() + + MemberTableNameStrTblSize; + + unsigned GlobalSymbolOffset = + (WriteSymtab && NumSyms > 0) + ? LastMemberEndOffset + + alignTo(sizeof(object::BigArMemHdrType) + MemberTableSize, 2) + : 0; + + // Fixed Sized Header. + printWithSpacePadding(Out, NewMembers.size() ? LastMemberEndOffset : 0, + 20); // Offset to member table + // If there are no file members in the archive, there will be no global + // symbol table. + printWithSpacePadding(Out, NewMembers.size() ? GlobalSymbolOffset : 0, 20); + printWithSpacePadding( + Out, 0, + 20); // Offset to 64 bits global symbol table - Not supported yet + printWithSpacePadding( + Out, NewMembers.size() ? sizeof(object::BigArchive::FixLenHdr) : 0, + 20); // Offset to first archive member + printWithSpacePadding(Out, NewMembers.size() ? LastMemberHeaderOffset : 0, + 20); // Offset to last archive member + printWithSpacePadding( + Out, 0, + 20); // Offset to first member of free list - Not supported yet + + for (const MemberData &M : Data) { + Out << M.Header << M.Data; + if (M.Data.size() % 2) + Out << '\0'; + } + + if (NewMembers.size()) { + // Member table. + printBigArchiveMemberHeader(Out, "", sys::toTimePoint(0), 0, 0, 0, + MemberTableSize, LastMemberHeaderOffset, + GlobalSymbolOffset); + printWithSpacePadding(Out, MemberOffsets.size(), 20); // Number of members + for (uint64_t MemberOffset : MemberOffsets) + printWithSpacePadding(Out, MemberOffset, + 20); // Offset to member file header. + for (StringRef MemberName : MemberNames) + Out << MemberName << '\0'; // Member file name, null byte padding. + + if (MemberTableNameStrTblSize % 2) + Out << '\0'; // Name table must be tail padded to an even number of + // bytes. + + if (WriteSymtab && NumSyms > 0) + writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf, + LastMemberEndOffset); + } + } + Out.flush(); + return Error::success(); +} + +Error writeArchive(StringRef ArcName, ArrayRef<NewArchiveMember> NewMembers, + bool WriteSymtab, object::Archive::Kind Kind, + bool Deterministic, bool Thin, + std::unique_ptr<MemoryBuffer> OldArchiveBuf) { + Expected<sys::fs::TempFile> Temp = + sys::fs::TempFile::create(ArcName + ".temp-archive-%%%%%%%.a"); + if (!Temp) + return Temp.takeError(); + raw_fd_ostream Out(Temp->FD, false); + + if (Error E = writeArchiveToStream(Out, NewMembers, WriteSymtab, Kind, + Deterministic, Thin)) { + if (Error DiscardError = Temp->discard()) + return joinErrors(std::move(E), std::move(DiscardError)); + return E; + } + + // At this point, we no longer need whatever backing memory + // was used to generate the NewMembers. On Windows, this buffer + // could be a mapped view of the file we want to replace (if + // we're updating an existing archive, say). In that case, the + // rename would still succeed, but it would leave behind a + // temporary file (actually the original file renamed) because + // a file cannot be deleted while there's a handle open on it, + // only renamed. So by freeing this buffer, this ensures that + // the last open handle on the destination file, if any, is + // closed before we attempt to rename. + OldArchiveBuf.reset(); + + return Temp->keep(ArcName); +} + +Expected<std::unique_ptr<MemoryBuffer>> +writeArchiveToBuffer(ArrayRef<NewArchiveMember> NewMembers, bool WriteSymtab, + object::Archive::Kind Kind, bool Deterministic, + bool Thin) { + SmallVector<char, 0> ArchiveBufferVector; + raw_svector_ostream ArchiveStream(ArchiveBufferVector); + + if (Error E = writeArchiveToStream(ArchiveStream, NewMembers, WriteSymtab, + Kind, Deterministic, Thin)) + return std::move(E); + + return std::make_unique<SmallVectorMemoryBuffer>( + std::move(ArchiveBufferVector), /*RequiresNullTerminator=*/false); +} + +} // namespace llvm diff --git a/vendor/ar_archive_writer/src/ArchiveWriter.h b/vendor/ar_archive_writer/src/ArchiveWriter.h new file mode 100644 index 000000000..0595d4888 --- /dev/null +++ b/vendor/ar_archive_writer/src/ArchiveWriter.h @@ -0,0 +1,57 @@ +// Copied from https://github.com/llvm/llvm-project/blob/3d3ef9d073e1e27ea57480b371b7f5a9f5642ed2/llvm/include/llvm/Object/ArchiveWriter.h + +//===- ArchiveWriter.h - ar archive file format writer ----------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// Declares the writeArchive function for writing an archive file. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_OBJECT_ARCHIVEWRITER_H +#define LLVM_OBJECT_ARCHIVEWRITER_H + +#include "llvm/Object/Archive.h" + +namespace llvm { + +struct NewArchiveMember { + std::unique_ptr<MemoryBuffer> Buf; + StringRef MemberName; + sys::TimePoint<std::chrono::seconds> ModTime; + unsigned UID = 0, GID = 0, Perms = 0644; + + NewArchiveMember() = default; + NewArchiveMember(MemoryBufferRef BufRef); + + // Detect the archive format from the object or bitcode file. This helps + // assume the archive format when creating or editing archives in the case + // one isn't explicitly set. + object::Archive::Kind detectKindFromObject() const; + + static Expected<NewArchiveMember> + getOldMember(const object::Archive::Child &OldMember, bool Deterministic); + + static Expected<NewArchiveMember> getFile(StringRef FileName, + bool Deterministic); +}; + +Expected<std::string> computeArchiveRelativePath(StringRef From, StringRef To); + +Error writeArchive(StringRef ArcName, ArrayRef<NewArchiveMember> NewMembers, + bool WriteSymtab, object::Archive::Kind Kind, + bool Deterministic, bool Thin, + std::unique_ptr<MemoryBuffer> OldArchiveBuf = nullptr); + +// writeArchiveToBuffer is similar to writeArchive but returns the Archive in a +// buffer instead of writing it out to a file. +Expected<std::unique_ptr<MemoryBuffer>> +writeArchiveToBuffer(ArrayRef<NewArchiveMember> NewMembers, bool WriteSymtab, + object::Archive::Kind Kind, bool Deterministic, bool Thin); +} + +#endif diff --git a/vendor/ar_archive_writer/src/alignment.rs b/vendor/ar_archive_writer/src/alignment.rs new file mode 100644 index 000000000..816538b49 --- /dev/null +++ b/vendor/ar_archive_writer/src/alignment.rs @@ -0,0 +1,23 @@ +// Derived from code in LLVM, which is: +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +// Derived from https://github.com/llvm/llvm-project/blob/8ef3e895ad8ab1724e2b87cabad1dacdc7a397a3/llvm/include/llvm/Support/Alignment.h + +/// Returns a multiple of `align` needed to store `size` bytes. +pub(crate) fn align_to(size: u64, align: u64) -> u64 { + (size + align - 1) & !(align - 1) +} + +/* +/// Returns the offset to the next integer (mod 2**64) that is greater than +/// or equal to \p Value and is a multiple of \p Align. +inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) { + return alignTo(Value, Alignment) - Value; +} +*/ + +pub(crate) fn offset_to_alignment(value: u64, alignment: u64) -> u64 { + align_to(value, alignment) - value +} diff --git a/vendor/ar_archive_writer/src/archive.rs b/vendor/ar_archive_writer/src/archive.rs new file mode 100644 index 000000000..0bc4111c6 --- /dev/null +++ b/vendor/ar_archive_writer/src/archive.rs @@ -0,0 +1,71 @@ +// Derived from code in LLVM, which is: +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +// Derived from https://github.com/llvm/llvm-project/blob/8ef3e895ad8ab1724e2b87cabad1dacdc7a397a3/llvm/include/llvm/Object/Archive.h + +/// Size field is 10 decimal digits long +pub(crate) const MAX_MEMBER_SIZE: u64 = 9999999999; + +#[derive(Copy, Clone, Debug, PartialEq)] +pub enum ArchiveKind { + Gnu, + Gnu64, + Bsd, + Darwin, + Darwin64, + Coff, + AixBig, +} + +pub(crate) mod big_archive { + #[repr(C)] + pub(crate) struct BigArMemHdrType { + /// File member size in decimal + size: [u8; 20], + + /// Next member offset in decimal + next_offset: [u8; 20], + + /// Previous member offset in decimal + prev_offset: [u8; 20], + + last_modified: [u8; 12], + + uid: [u8; 12], + gid: [u8; 12], + + access_mode: [u8; 12], + + /// File member name length in decimal + name_len: [u8; 4], + + terminator: [u8; 2], + } + + /// Fixed-Length Header. + #[repr(C)] + pub(crate) struct FixLenHdr { + /// Big archive magic string. + magic: [u8; 8], + + /// Offset to member table. + mem_offset: [u8; 20], + + /// Offset to global symbol table. + glob_sym_offset: [u8; 20], + + /// Offset global symbol table for 64-bit objects. + glob_sym64_offset: [u8; 20], + + /// Offset to first archive member. + first_child_offset: [u8; 20], + + /// Offset to last archive member. + last_child_offset: [u8; 20], + + /// Offset to first mem on free list. + free_offset: [u8; 20], + } +} diff --git a/vendor/ar_archive_writer/src/archive_writer.rs b/vendor/ar_archive_writer/src/archive_writer.rs new file mode 100644 index 000000000..24dcc3cfc --- /dev/null +++ b/vendor/ar_archive_writer/src/archive_writer.rs @@ -0,0 +1,831 @@ +#![allow(rustc::default_hash_types, rustc::potential_query_instability)] + +// Derived from code in LLVM, which is: +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +// Derived from: +// * https://github.com/llvm/llvm-project/blob/8ef3e895ad8ab1724e2b87cabad1dacdc7a397a3/llvm/include/llvm/Object/ArchiveWriter.h +// * https://github.com/llvm/llvm-project/blob/8ef3e895ad8ab1724e2b87cabad1dacdc7a397a3/llvm/lib/Object/ArchiveWriter.cpp + +use std::collections::HashMap; +use std::io::{self, Cursor, Seek, Write}; + +use object::{Object, ObjectSymbol}; + +use crate::alignment::*; +use crate::archive::*; + +pub struct NewArchiveMember<'a> { + pub buf: Box<dyn AsRef<[u8]> + 'a>, + pub get_symbols: fn(buf: &[u8], f: &mut dyn FnMut(&[u8]) -> io::Result<()>) -> io::Result<bool>, + pub member_name: String, + pub mtime: u64, + pub uid: u32, + pub gid: u32, + pub perms: u32, +} + +fn is_darwin(kind: ArchiveKind) -> bool { + matches!(kind, ArchiveKind::Darwin | ArchiveKind::Darwin64) +} + +fn is_aix_big_archive(kind: ArchiveKind) -> bool { + kind == ArchiveKind::AixBig +} + +fn is_bsd_like(kind: ArchiveKind) -> bool { + match kind { + ArchiveKind::Gnu | ArchiveKind::Gnu64 | ArchiveKind::AixBig => false, + ArchiveKind::Bsd | ArchiveKind::Darwin | ArchiveKind::Darwin64 => true, + ArchiveKind::Coff => panic!("not supported for writing"), + } +} + +fn print_rest_of_member_header<W: Write>( + w: &mut W, + mtime: u64, + uid: u32, + gid: u32, + perms: u32, + size: u64, +) -> io::Result<()> { + // The format has only 6 chars for uid and gid. Truncate if the provided + // values don't fit. + write!( + w, + "{:<12}{:<6}{:<6}{:<8o}{:<10}`\n", + mtime, + uid % 1000000, + gid % 1000000, + perms, + size + ) +} + +fn print_gnu_small_member_header<W: Write>( + w: &mut W, + name: String, + mtime: u64, + uid: u32, + gid: u32, + perms: u32, + size: u64, +) -> io::Result<()> { + write!(w, "{:<16}", name + "/")?; + print_rest_of_member_header(w, mtime, uid, gid, perms, size) +} + +fn print_bsd_member_header<W: Write>( + w: &mut W, + pos: u64, + name: &str, + mtime: u64, + uid: u32, + gid: u32, + perms: u32, + size: u64, +) -> io::Result<()> { + let pos_after_header = pos + 60 + u64::try_from(name.len()).unwrap(); + // Pad so that even 64 bit object files are aligned. + let pad = offset_to_alignment(pos_after_header, 8); + let name_with_padding = u64::try_from(name.len()).unwrap() + pad; + write!(w, "#1/{:<13}", name_with_padding)?; + print_rest_of_member_header(w, mtime, uid, gid, perms, name_with_padding + size)?; + write!(w, "{}", name)?; + write!( + w, + "{nil:\0<pad$}", + nil = "", + pad = usize::try_from(pad).unwrap() + ) +} + +fn print_big_archive_member_header<W: Write>( + w: &mut W, + name: &str, + mtime: u64, + uid: u32, + gid: u32, + perms: u32, + size: u64, + prev_offset: u64, + next_offset: u64, +) -> io::Result<()> { + write!( + w, + "{:<20}{:<20}{:<20}{:<12}{:<12}{:<12}{:<12o}{:<4}", + size, + next_offset, + prev_offset, + mtime, + u64::from(uid) % 1000000000000u64, + u64::from(gid) % 1000000000000u64, + perms, + name.len(), + )?; + + if !name.is_empty() { + write!(w, "{}", name)?; + + if name.len() % 2 != 0 { + write!(w, "\0")?; + } + } + + write!(w, "`\n")?; + + Ok(()) +} + +fn use_string_table(thin: bool, name: &str) -> bool { + thin || name.len() >= 16 || name.contains('/') +} + +fn is_64bit_kind(kind: ArchiveKind) -> bool { + match kind { + ArchiveKind::Gnu | ArchiveKind::Bsd | ArchiveKind::Darwin | ArchiveKind::Coff => false, + ArchiveKind::AixBig | ArchiveKind::Darwin64 | ArchiveKind::Gnu64 => true, + } +} + +fn print_member_header<'m, W: Write, T: Write + Seek>( + w: &mut W, + pos: u64, + string_table: &mut T, + member_names: &mut HashMap<&'m str, u64>, + kind: ArchiveKind, + thin: bool, + m: &'m NewArchiveMember<'m>, + mtime: u64, + size: u64, +) -> io::Result<()> { + if is_bsd_like(kind) { + return print_bsd_member_header(w, pos, &m.member_name, mtime, m.uid, m.gid, m.perms, size); + } + + if !use_string_table(thin, &m.member_name) { + return print_gnu_small_member_header( + w, + m.member_name.clone(), + mtime, + m.uid, + m.gid, + m.perms, + size, + ); + } + + write!(w, "/")?; + let name_pos; + if thin { + name_pos = string_table.stream_position()?; + write!(string_table, "{}/\n", m.member_name)?; + } else { + if let Some(&pos) = member_names.get(&*m.member_name) { + name_pos = pos; + } else { + name_pos = string_table.stream_position()?; + member_names.insert(&m.member_name, name_pos); + write!(string_table, "{}/\n", m.member_name)?; + } + } + write!(w, "{:<15}", name_pos)?; + print_rest_of_member_header(w, mtime, m.uid, m.gid, m.perms, size) +} + +struct MemberData<'a> { + symbols: Vec<u64>, + header: Vec<u8>, + data: &'a [u8], + padding: &'static [u8], +} + +fn compute_string_table(names: &[u8]) -> MemberData<'_> { + let size = u64::try_from(names.len()).unwrap(); + let pad = offset_to_alignment(size, 2); + let mut header = Vec::new(); + write!(header, "{:<48}", "//").unwrap(); + write!(header, "{:<10}", size + pad).unwrap(); + write!(header, "`\n").unwrap(); + MemberData { + symbols: vec![], + header, + data: names, + padding: if pad != 0 { b"\n" } else { b"" }, + } +} + +fn now(deterministic: bool) -> u64 { + if !deterministic { + todo!("non deterministic mode is not yet supported"); // FIXME + } + 0 +} + +fn is_archive_symbol(sym: &object::read::Symbol<'_, '_>) -> bool { + // FIXME Use a better equivalent of LLVM's SymbolRef::SF_FormatSpecific + if sym.kind() == object::SymbolKind::Null + || sym.kind() == object::SymbolKind::File + || sym.kind() == object::SymbolKind::Section + { + return false; + } + if !sym.is_global() { + return false; + } + if sym.is_undefined() { + return false; + } + true +} + +fn print_n_bits<W: Write>(w: &mut W, kind: ArchiveKind, val: u64) -> io::Result<()> { + if is_64bit_kind(kind) { + w.write_all(&if is_bsd_like(kind) { + u64::to_le_bytes(val) + } else { + u64::to_be_bytes(val) + }) + } else { + w.write_all(&if is_bsd_like(kind) { + u32::to_le_bytes(u32::try_from(val).unwrap()) + } else { + u32::to_be_bytes(u32::try_from(val).unwrap()) + }) + } +} + +fn compute_symbol_table_size_and_pad( + kind: ArchiveKind, + num_syms: u64, + offset_size: u64, + string_table: &[u8], +) -> (u64, u64) { + assert!( + offset_size == 4 || offset_size == 8, + "Unsupported offset_size" + ); + let mut size = offset_size; // Number of entries + if is_bsd_like(kind) { + size += num_syms * offset_size * 2; // Table + } else { + size += num_syms * offset_size; // Table + } + if is_bsd_like(kind) { + size += offset_size; // byte count; + } + size += u64::try_from(string_table.len()).unwrap(); + // ld64 expects the members to be 8-byte aligned for 64-bit content and at + // least 4-byte aligned for 32-bit content. Opt for the larger encoding + // uniformly. + // We do this for all bsd formats because it simplifies aligning members. + let pad = if is_aix_big_archive(kind) { + 0 + } else { + offset_to_alignment(size, if is_bsd_like(kind) { 8 } else { 2 }) + }; + size += pad; + (size, pad) +} + +fn write_symbol_table_header<W: Write + Seek>( + w: &mut W, + kind: ArchiveKind, + deterministic: bool, + size: u64, + prev_member_offset: u64, +) -> io::Result<()> { + if is_bsd_like(kind) { + let name = if is_64bit_kind(kind) { + "__.SYMDEF_64" + } else { + "__.SYMDEF" + }; + let pos = w.stream_position()?; + print_bsd_member_header(w, pos, name, now(deterministic), 0, 0, 0, size) + } else if is_aix_big_archive(kind) { + print_big_archive_member_header( + w, + "", + now(deterministic), + 0, + 0, + 0, + size, + prev_member_offset, + 0, + ) + } else { + let name = if is_64bit_kind(kind) { "/SYM64" } else { "" }; + print_gnu_small_member_header(w, name.to_string(), now(deterministic), 0, 0, 0, size) + } +} + +fn write_symbol_table<W: Write + Seek>( + w: &mut W, + kind: ArchiveKind, + deterministic: bool, + members: &[MemberData<'_>], + string_table: &[u8], + prev_member_offset: u64, +) -> io::Result<()> { + // We don't write a symbol table on an archive with no members -- except on + // Darwin, where the linker will abort unless the archive has a symbol table. + if string_table.is_empty() && !is_darwin(kind) { + return Ok(()); + } + + let num_syms = u64::try_from(members.iter().map(|m| m.symbols.len()).sum::<usize>()).unwrap(); + + let offset_size = if is_64bit_kind(kind) { 8 } else { 4 }; + let (size, pad) = compute_symbol_table_size_and_pad(kind, num_syms, offset_size, string_table); + write_symbol_table_header(w, kind, deterministic, size, prev_member_offset)?; + + let mut pos = if is_aix_big_archive(kind) { + u64::try_from(std::mem::size_of::<big_archive::FixLenHdr>()).unwrap() + } else { + w.stream_position()? + size + }; + + if is_bsd_like(kind) { + print_n_bits(w, kind, num_syms * 2 * offset_size)?; + } else { + print_n_bits(w, kind, num_syms)?; + } + + for m in members { + for &string_offset in &m.symbols { + if is_bsd_like(kind) { + print_n_bits(w, kind, string_offset)?; + } + print_n_bits(w, kind, pos)?; // member offset + } + pos += u64::try_from(m.header.len() + m.data.len() + m.padding.len()).unwrap(); + } + + if is_bsd_like(kind) { + // byte count of the string table + print_n_bits(w, kind, u64::try_from(string_table.len()).unwrap())?; + } + + w.write_all(string_table)?; + + write!( + w, + "{nil:\0<pad$}", + nil = "", + pad = usize::try_from(pad).unwrap() + ) +} + +pub fn get_native_object_symbols( + buf: &[u8], + f: &mut dyn FnMut(&[u8]) -> io::Result<()>, +) -> io::Result<bool> { + // FIXME match what LLVM does + + match object::File::parse(buf) { + Ok(file) => { + for sym in file.symbols() { + if !is_archive_symbol(&sym) { + continue; + } + f(sym.name_bytes().expect("FIXME"))?; + } + Ok(true) + } + Err(_) => Ok(false), + } +} + +// NOTE: LLVM calls this getSymbols and has the get_native_symbols function inlined +fn write_symbols( + buf: &[u8], + get_symbols: fn(buf: &[u8], f: &mut dyn FnMut(&[u8]) -> io::Result<()>) -> io::Result<bool>, + sym_names: &mut Cursor<Vec<u8>>, + has_object: &mut bool, +) -> io::Result<Vec<u64>> { + let mut ret = vec![]; + *has_object = get_symbols(buf, &mut |sym| { + ret.push(sym_names.stream_position()?); + sym_names.write_all(sym)?; + sym_names.write_all(&[0])?; + Ok(()) + })?; + Ok(ret) +} + +fn compute_member_data<'a, S: Write + Seek>( + string_table: &mut S, + sym_names: &mut Cursor<Vec<u8>>, + kind: ArchiveKind, + thin: bool, + deterministic: bool, + need_symbols: bool, + new_members: &'a [NewArchiveMember<'a>], +) -> io::Result<Vec<MemberData<'a>>> { + const PADDING_DATA: &[u8; 8] = &[b'\n'; 8]; + + // This ignores the symbol table, but we only need the value mod 8 and the + // symbol table is aligned to be a multiple of 8 bytes + let mut pos = if is_aix_big_archive(kind) { + u64::try_from(std::mem::size_of::<big_archive::FixLenHdr>()).unwrap() + } else { + 0 + }; + + let mut ret = vec![]; + let mut has_object = false; + + // Deduplicate long member names in the string table and reuse earlier name + // offsets. This especially saves space for COFF Import libraries where all + // members have the same name. + let mut member_names = HashMap::<&str, u64>::new(); + + // UniqueTimestamps is a special case to improve debugging on Darwin: + // + // The Darwin linker does not link debug info into the final + // binary. Instead, it emits entries of type N_OSO in in the output + // binary's symbol table, containing references to the linked-in + // object files. Using that reference, the debugger can read the + // debug data directly from the object files. Alternatively, an + // invocation of 'dsymutil' will link the debug data from the object + // files into a dSYM bundle, which can be loaded by the debugger, + // instead of the object files. + // + // For an object file, the N_OSO entries contain the absolute path + // path to the file, and the file's timestamp. For an object + // included in an archive, the path is formatted like + // "/absolute/path/to/archive.a(member.o)", and the timestamp is the + // archive member's timestamp, rather than the archive's timestamp. + // + // However, this doesn't always uniquely identify an object within + // an archive -- an archive file can have multiple entries with the + // same filename. (This will happen commonly if the original object + // files started in different directories.) The only way they get + // distinguished, then, is via the timestamp. But this process is + // unable to find the correct object file in the archive when there + // are two files of the same name and timestamp. + // + // Additionally, timestamp==0 is treated specially, and causes the + // timestamp to be ignored as a match criteria. + // + // That will "usually" work out okay when creating an archive not in + // deterministic timestamp mode, because the objects will probably + // have been created at different timestamps. + // + // To ameliorate this problem, in deterministic archive mode (which + // is the default), on Darwin we will emit a unique non-zero + // timestamp for each entry with a duplicated name. This is still + // deterministic: the only thing affecting that timestamp is the + // order of the files in the resultant archive. + // + // See also the functions that handle the lookup: + // in lldb: ObjectContainerBSDArchive::Archive::FindObject() + // in llvm/tools/dsymutil: BinaryHolder::GetArchiveMemberBuffers(). + let unique_timestamps = deterministic && is_darwin(kind); + let mut filename_count = HashMap::new(); + if unique_timestamps { + for m in new_members { + *filename_count.entry(&*m.member_name).or_insert(0) += 1; + } + for (_name, count) in filename_count.iter_mut() { + if *count > 1 { + *count = 1; + } + } + } + + // The big archive format needs to know the offset of the previous member + // header. + let mut prev_offset = 0; + for m in new_members { + let mut header = Vec::new(); + + let data: &[u8] = if thin { &[][..] } else { (*m.buf).as_ref() }; + + // ld64 expects the members to be 8-byte aligned for 64-bit content and at + // least 4-byte aligned for 32-bit content. Opt for the larger encoding + // uniformly. This matches the behaviour with cctools and ensures that ld64 + // is happy with archives that we generate. + let member_padding = if is_darwin(kind) { + offset_to_alignment(u64::try_from(data.len()).unwrap(), 8) + } else { + 0 + }; + let tail_padding = + offset_to_alignment(u64::try_from(data.len()).unwrap() + member_padding, 2); + let padding = &PADDING_DATA[..usize::try_from(member_padding + tail_padding).unwrap()]; + + let mtime = if unique_timestamps { + // Increment timestamp for each file of a given name. + *filename_count.get_mut(&*m.member_name).unwrap() += 1; + filename_count[&*m.member_name] - 1 + } else { + m.mtime + }; + + let size = u64::try_from(data.len()).unwrap() + member_padding; + if size > MAX_MEMBER_SIZE { + return Err(io::Error::new( + io::ErrorKind::Other, + format!("Archive member {} is too big", m.member_name), + )); + } + + if is_aix_big_archive(kind) { + let next_offset = pos + + u64::try_from(std::mem::size_of::<big_archive::BigArMemHdrType>()).unwrap() + + align_to(u64::try_from(m.member_name.len()).unwrap(), 2) + + align_to(size, 2); + print_big_archive_member_header( + &mut header, + &m.member_name, + mtime, + m.uid, + m.gid, + m.perms, + size, + prev_offset, + next_offset, + )?; + prev_offset = pos; + } else { + print_member_header( + &mut header, + pos, + string_table, + &mut member_names, + kind, + thin, + m, + mtime, + size, + )?; + } + + let symbols = if need_symbols { + write_symbols(data, m.get_symbols, sym_names, &mut has_object)? + } else { + vec![] + }; + + pos += u64::try_from(header.len() + data.len() + padding.len()).unwrap(); + ret.push(MemberData { + symbols, + header, + data, + padding, + }) + } + + // If there are no symbols, emit an empty symbol table, to satisfy Solaris + // tools, older versions of which expect a symbol table in a non-empty + // archive, regardless of whether there are any symbols in it. + if has_object && sym_names.stream_position()? == 0 { + write!(sym_names, "\0\0\0")?; + } + + Ok(ret) +} + +pub fn write_archive_to_stream<W: Write + Seek>( + w: &mut W, + new_members: &[NewArchiveMember<'_>], + write_symtab: bool, + mut kind: ArchiveKind, + deterministic: bool, + thin: bool, +) -> io::Result<()> { + assert!( + !thin || !is_bsd_like(kind), + "Only the gnu format has a thin mode" + ); + + let mut sym_names = Cursor::new(Vec::new()); + let mut string_table = Cursor::new(Vec::new()); + + let mut data = compute_member_data( + &mut string_table, + &mut sym_names, + kind, + thin, + deterministic, + write_symtab, + new_members, + )?; + + let sym_names = sym_names.into_inner(); + + let string_table = string_table.into_inner(); + if !string_table.is_empty() && !is_aix_big_archive(kind) { + data.insert(0, compute_string_table(&string_table)); + } + + // We would like to detect if we need to switch to a 64-bit symbol table. + let mut last_member_end_offset = if is_aix_big_archive(kind) { + u64::try_from(std::mem::size_of::<big_archive::FixLenHdr>()).unwrap() + } else { + 8 + }; + let mut last_member_header_offset = last_member_end_offset; + let mut num_syms = 0; + for m in &data { + // Record the start of the member's offset + last_member_header_offset = last_member_end_offset; + // Account for the size of each part associated with the member. + last_member_end_offset += + u64::try_from(m.header.len() + m.data.len() + m.padding.len()).unwrap(); + num_syms += u64::try_from(m.symbols.len()).unwrap(); + } + + // The symbol table is put at the end of the big archive file. The symbol + // table is at the start of the archive file for other archive formats. + if write_symtab && !is_aix_big_archive(kind) { + // We assume 32-bit offsets to see if 32-bit symbols are possible or not. + let (symtab_size, _pad) = compute_symbol_table_size_and_pad(kind, num_syms, 4, &sym_names); + last_member_header_offset += { + // FIXME avoid allocating memory here + let mut tmp = Cursor::new(vec![]); + write_symbol_table_header(&mut tmp, kind, deterministic, symtab_size, 0).unwrap(); + u64::try_from(tmp.into_inner().len()).unwrap() + } + symtab_size; + + // The SYM64 format is used when an archive's member offsets are larger than + // 32-bits can hold. The need for this shift in format is detected by + // writeArchive. To test this we need to generate a file with a member that + // has an offset larger than 32-bits but this demands a very slow test. To + // speed the test up we use this environment variable to pretend like the + // cutoff happens before 32-bits and instead happens at some much smaller + // value. + // FIXME allow lowering the threshold for tests + const SYM64_THRESHOLD: u64 = 1 << 32; + + // If LastMemberHeaderOffset isn't going to fit in a 32-bit varible we need + // to switch to 64-bit. Note that the file can be larger than 4GB as long as + // the last member starts before the 4GB offset. + if last_member_header_offset >= SYM64_THRESHOLD { + if kind == ArchiveKind::Darwin { + kind = ArchiveKind::Darwin64; + } else { + kind = ArchiveKind::Gnu64; + } + } + } + + if thin { + write!(w, "!<thin>\n")?; + } else if is_aix_big_archive(kind) { + write!(w, "<bigaf>\n")?; + } else { + write!(w, "!<arch>\n")?; + } + + if !is_aix_big_archive(kind) { + if write_symtab { + write_symbol_table(w, kind, deterministic, &data, &sym_names, 0)?; + } + + for m in data { + w.write_all(&m.header)?; + w.write_all(m.data)?; + w.write_all(m.padding)?; + } + } else { + // For the big archive (AIX) format, compute a table of member names and + // offsets, used in the member table. + let mut member_table_name_str_tbl_size = 0; + let mut member_offsets = vec![]; + let mut member_names = vec![]; + + // Loop across object to find offset and names. + let mut member_end_offset = + u64::try_from(std::mem::size_of::<big_archive::FixLenHdr>()).unwrap(); + for i in 0..new_members.len() { + let member = &new_members[i]; + member_table_name_str_tbl_size += member.member_name.len() + 1; + member_offsets.push(member_end_offset); + member_names.push(&member.member_name); + // File member name ended with "`\n". The length is included in + // BigArMemHdrType. + member_end_offset += u64::try_from(std::mem::size_of::<big_archive::BigArMemHdrType>()) + .unwrap() + + align_to(u64::try_from(data[i].data.len()).unwrap(), 2) + + align_to(u64::try_from(member.member_name.len()).unwrap(), 2); + } + + // AIX member table size. + let member_table_size = + u64::try_from(20 + 20 * member_offsets.len() + member_table_name_str_tbl_size).unwrap(); + + let global_symbol_offset = if write_symtab && num_syms > 0 { + last_member_end_offset + + align_to( + u64::try_from(std::mem::size_of::<big_archive::BigArMemHdrType>()).unwrap() + + member_table_size, + 2, + ) + } else { + 0 + }; + + // Fixed Sized Header. + // Offset to member table + write!( + w, + "{:<20}", + if !new_members.is_empty() { + last_member_end_offset + } else { + 0 + } + )?; + // If there are no file members in the archive, there will be no global + // symbol table. + write!( + w, + "{:<20}", + if !new_members.is_empty() { + global_symbol_offset + } else { + 0 + } + )?; + // Offset to 64 bits global symbol table - Not supported yet + write!(w, "{:<20}", 0)?; + // Offset to first archive member + write!( + w, + "{:<20}", + if !new_members.is_empty() { + u64::try_from(std::mem::size_of::<big_archive::FixLenHdr>()).unwrap() + } else { + 0 + } + )?; + // Offset to last archive member + write!( + w, + "{:<20}", + if !new_members.is_empty() { + last_member_header_offset + } else { + 0 + } + )?; + // Offset to first member of free list - Not supported yet + write!(w, "{:<20}", 0)?; + + for m in &data { + w.write_all(&m.header)?; + w.write_all(m.data)?; + if m.data.len() % 2 != 0 { + w.write_all(&[0])?; + } + } + + if !new_members.is_empty() { + // Member table. + print_big_archive_member_header( + w, + "", + 0, + 0, + 0, + 0, + member_table_size, + last_member_header_offset, + global_symbol_offset, + )?; + write!(w, "{:<20}", member_offsets.len())?; // Number of members + for member_offset in member_offsets { + write!(w, "{:<20}", member_offset)?; + } + for member_name in member_names { + w.write_all(member_name.as_bytes())?; + w.write_all(&[0])?; + } + + if member_table_name_str_tbl_size % 2 != 0 { + // Name table must be tail padded to an even number of + // bytes. + w.write_all(&[0])?; + } + + if write_symtab && num_syms > 0 { + write_symbol_table( + w, + kind, + deterministic, + &data, + &sym_names, + last_member_end_offset, + )?; + } + } + } + + w.flush() +} diff --git a/vendor/ar_archive_writer/src/lib.rs b/vendor/ar_archive_writer/src/lib.rs new file mode 100644 index 000000000..ab2db2f88 --- /dev/null +++ b/vendor/ar_archive_writer/src/lib.rs @@ -0,0 +1,6 @@ +mod alignment; +mod archive; +mod archive_writer; + +pub use archive::ArchiveKind; +pub use archive_writer::{get_native_object_symbols, write_archive_to_stream, NewArchiveMember}; |