blob: 506661a377d621415319f9f771bce3819c4ac1ef [file] [log] [blame]
/*
* Copyright (C) 2021 The Android Open Source Project
*
* 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.
*/
#include "android-base/logging.h"
#include "base/os.h"
#include "base/unix_file/fd_file.h"
#include "elf/elf_builder.h"
#include "elf/elf_debug_reader.h"
#include "elf/xz_utils.h"
#include "stream/file_output_stream.h"
#include "stream/vector_output_stream.h"
#include <algorithm>
#include <deque>
#include <map>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
namespace art {
static constexpr size_t kBlockSize = 32 * KB;
constexpr const char kSortedSymbolName[] = "$android.symtab.sorted";
template<typename ElfTypes>
static void WriteMinidebugInfo(const std::vector<uint8_t>& input, std::vector<uint8_t>* output) {
using Elf_Addr = typename ElfTypes::Addr;
using Elf_Shdr = typename ElfTypes::Shdr;
using Elf_Sym = typename ElfTypes::Sym;
using Elf_Word = typename ElfTypes::Word;
using CIE = typename ElfDebugReader<ElfTypes>::CIE;
using FDE = typename ElfDebugReader<ElfTypes>::FDE;
ElfDebugReader<ElfTypes> reader(input);
std::vector<uint8_t> output_elf_data;
VectorOutputStream output_stream("Output ELF", &output_elf_data);
InstructionSet isa = ElfBuilder<ElfTypes>::GetIsaFromHeader(*reader.GetHeader());
std::unique_ptr<ElfBuilder<ElfTypes>> builder(new ElfBuilder<ElfTypes>(isa, &output_stream));
builder->Start(/*write_program_headers=*/ false);
auto* text = builder->GetText();
const Elf_Shdr* original_text = reader.GetSection(".text");
CHECK(original_text != nullptr);
text->AllocateVirtualMemory(original_text->sh_addr, original_text->sh_size);
auto* strtab = builder->GetStrTab();
auto* symtab = builder->GetSymTab();
strtab->Start();
{
std::multimap<std::string_view, Elf_Sym> syms;
reader.VisitFunctionSymbols([&](Elf_Sym sym, const char* name) {
// Exclude non-function or empty symbols.
if (ELF32_ST_TYPE(sym.st_info) == STT_FUNC && sym.st_size != 0) {
syms.emplace(name, sym);
}
});
reader.VisitDynamicSymbols([&](Elf_Sym sym, const char* name) {
// Exclude symbols which will be preserved in the dynamic table anyway.
auto it = syms.find(name);
if (it != syms.end() && it->second.st_value == sym.st_value) {
syms.erase(it);
}
});
if (!syms.empty()) {
symtab->Add(strtab->Write(kSortedSymbolName), nullptr, 0, 0, STB_GLOBAL, STT_NOTYPE);
}
for (auto& entry : syms) {
std::string_view name = entry.first;
const Elf_Sym& sym = entry.second;
Elf_Word name_idx = strtab->Write(name);
symtab->Add(name_idx, text, sym.st_value, sym.st_size, STB_GLOBAL, STT_FUNC);
}
}
strtab->End();
symtab->WriteCachedSection();
auto* debug_frame = builder->GetDebugFrame();
debug_frame->Start();
{
std::map<std::basic_string_view<uint8_t>, Elf_Addr> cie_dedup;
std::unordered_map<const CIE*, Elf_Addr> new_cie_offset;
std::deque<std::pair<const FDE*, const CIE*>> entries;
// Read, de-duplicate and write CIE entries. Read FDE entries.
reader.VisitDebugFrame(
[&](const CIE* cie) {
std::basic_string_view<uint8_t> key(cie->data(), cie->size());
auto it = cie_dedup.emplace(key, debug_frame->GetPosition());
if (/* inserted */ it.second) {
debug_frame->WriteFully(cie->data(), cie->size());
}
new_cie_offset[cie] = it.first->second;
},
[&](const FDE* fde, const CIE* cie) {
entries.emplace_back(std::make_pair(fde, cie));
});
// Sort FDE entries by opcodes to improve locality for compression (saves ~25%).
std::stable_sort(entries.begin(), entries.end(), [](const auto& lhs, const auto& rhs) {
constexpr size_t opcode_offset = sizeof(FDE);
return std::lexicographical_compare(
lhs.first->data() + opcode_offset, lhs.first->data() + lhs.first->size(),
rhs.first->data() + opcode_offset, rhs.first->data() + rhs.first->size());
});
// Write all FDE entries while adjusting the CIE offsets to the new locations.
for (const auto& entry : entries) {
const FDE* fde = entry.first;
const CIE* cie = entry.second;
FDE new_header = *fde;
new_header.cie_pointer = new_cie_offset[cie];
debug_frame->WriteFully(&new_header, sizeof(FDE));
debug_frame->WriteFully(fde->data() + sizeof(FDE), fde->size() - sizeof(FDE));
}
}
debug_frame->End();
builder->End();
CHECK(builder->Good());
XzCompress(ArrayRef<const uint8_t>(output_elf_data), output, 9 /*size*/, kBlockSize);
}
static int Main(int argc, char** argv) {
// Check command like arguments.
if (argc != 3) {
printf("Usage: create_minidebuginfo ELF_FILE OUT_FILE\n");
printf(" ELF_FILE: The path to an ELF file with full symbols (before being stripped).\n");
printf(" OUT_FILE: The path for the generated mini-debug-info data (not an elf file).\n");
return 1;
}
const char* input_filename = argv[1];
const char* output_filename = argv[2];
// Read input file.
std::unique_ptr<File> input_file(OS::OpenFileForReading(input_filename));
CHECK(input_file.get() != nullptr) << "Failed to open input file";
std::vector<uint8_t> elf(input_file->GetLength());
CHECK(input_file->ReadFully(elf.data(), elf.size())) << "Failed to read input file";
// Write output file.
std::vector<uint8_t> output;
if (ElfDebugReader<ElfTypes32>::IsValidElfHeader(elf)) {
WriteMinidebugInfo<ElfTypes32>(elf, &output);
} else if (ElfDebugReader<ElfTypes64>::IsValidElfHeader(elf)) {
WriteMinidebugInfo<ElfTypes64>(elf, &output);
} else {
LOG(FATAL) << "Invalid ELF file header " << input_filename;
}
std::unique_ptr<File> output_file(OS::CreateEmptyFile(output_filename));
if (!output_file->WriteFully(output.data(), output.size()) || output_file->FlushClose() != 0) {
LOG(FATAL) << "Failed to write " << output_filename;
}
return 0;
}
} // namespace art
int main(int argc, char** argv) {
return art::Main(argc, argv);
}