dfbd76bda0
Currently there are two serialization modes for bitstream Remarks: standalone and separate. The separate mode splits remark metadata (e.g. the string table) from actual remark data. The metadata is written into the object file by the AsmPrinter, while the remark data is stored in a separate remarks file. This means we can't use bitstream remarks with tools like opt that don't generate an object file. Also, it is confusing to post-process bitstream remarks files, because only the standalone files can be read by llvm-remarkutil. We always need to use dsymutil to convert the separate files to standalone files, which only works for MachO. It is not possible for clang/opt to directly emit bitstream remark files in standalone mode, because the string table can only be serialized after all remarks were emitted. Therefore, this change completely removes the separate serialization mode. Instead, the remark string table is now always written to the end of the remarks file. This requires us to tell the serializer when to finalize remark serialization. This automatically happens when the serializer goes out of scope. However, often the remark file goes out of scope before the serializer is destroyed. To diagnose this, I have added an assert to alert users that they need to explicitly call finalizeLLVMOptimizationRemarks. This change paves the way for further improvements to the remark infrastructure, including more tooling (e.g. #159784), size optimizations for bitstream remarks, and more. Pull Request: https://github.com/llvm/llvm-project/pull/156715
123 lines
3.7 KiB
C++
123 lines
3.7 KiB
C++
//===- RemarkLinker.cpp ---------------------------------------------------===//
|
|
//
|
|
// 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 provides an implementation of the remark linker.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Remarks/RemarkLinker.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Object/ObjectFile.h"
|
|
#include "llvm/Object/SymbolicFile.h"
|
|
#include "llvm/Remarks/RemarkParser.h"
|
|
#include "llvm/Remarks/RemarkSerializer.h"
|
|
#include "llvm/Support/Error.h"
|
|
#include <optional>
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::remarks;
|
|
|
|
namespace llvm {
|
|
class raw_ostream;
|
|
}
|
|
|
|
static Expected<StringRef>
|
|
getRemarksSectionName(const object::ObjectFile &Obj) {
|
|
if (Obj.isMachO())
|
|
return StringRef("__remarks");
|
|
// ELF -> .remarks, but there is no ELF support at this point.
|
|
return createStringError(std::errc::illegal_byte_sequence,
|
|
"Unsupported file format.");
|
|
}
|
|
|
|
Expected<std::optional<StringRef>>
|
|
llvm::remarks::getRemarksSectionContents(const object::ObjectFile &Obj) {
|
|
Expected<StringRef> SectionName = getRemarksSectionName(Obj);
|
|
if (!SectionName)
|
|
return SectionName.takeError();
|
|
|
|
for (const object::SectionRef &Section : Obj.sections()) {
|
|
Expected<StringRef> MaybeName = Section.getName();
|
|
if (!MaybeName)
|
|
return MaybeName.takeError();
|
|
if (*MaybeName != *SectionName)
|
|
continue;
|
|
|
|
if (Expected<StringRef> Contents = Section.getContents())
|
|
return *Contents;
|
|
else
|
|
return Contents.takeError();
|
|
}
|
|
return std::optional<StringRef>{};
|
|
}
|
|
|
|
Remark &RemarkLinker::keep(std::unique_ptr<Remark> Remark) {
|
|
StrTab.internalize(*Remark);
|
|
auto Inserted = Remarks.insert(std::move(Remark));
|
|
return **Inserted.first;
|
|
}
|
|
|
|
void RemarkLinker::setExternalFilePrependPath(StringRef PrependPathIn) {
|
|
PrependPath = std::string(PrependPathIn);
|
|
}
|
|
|
|
Error RemarkLinker::link(StringRef Buffer, Format RemarkFormat) {
|
|
Expected<std::unique_ptr<RemarkParser>> MaybeParser =
|
|
createRemarkParserFromMeta(
|
|
RemarkFormat, Buffer,
|
|
PrependPath ? std::make_optional<StringRef>(*PrependPath)
|
|
: std::nullopt);
|
|
if (!MaybeParser)
|
|
return MaybeParser.takeError();
|
|
|
|
RemarkParser &Parser = **MaybeParser;
|
|
|
|
while (true) {
|
|
Expected<std::unique_ptr<Remark>> Next = Parser.next();
|
|
if (Error E = Next.takeError()) {
|
|
if (E.isA<EndOfFileError>()) {
|
|
consumeError(std::move(E));
|
|
break;
|
|
}
|
|
return E;
|
|
}
|
|
|
|
assert(*Next != nullptr);
|
|
|
|
if (shouldKeepRemark(**Next))
|
|
keep(std::move(*Next));
|
|
}
|
|
return Error::success();
|
|
}
|
|
|
|
Error RemarkLinker::link(const object::ObjectFile &Obj, Format RemarkFormat) {
|
|
Expected<std::optional<StringRef>> SectionOrErr =
|
|
getRemarksSectionContents(Obj);
|
|
if (!SectionOrErr)
|
|
return SectionOrErr.takeError();
|
|
|
|
if (std::optional<StringRef> Section = *SectionOrErr)
|
|
return link(*Section, RemarkFormat);
|
|
return Error::success();
|
|
}
|
|
|
|
Error RemarkLinker::serialize(raw_ostream &OS, Format RemarksFormat) const {
|
|
Expected<std::unique_ptr<RemarkSerializer>> MaybeSerializer =
|
|
createRemarkSerializer(RemarksFormat, OS,
|
|
std::move(const_cast<StringTable &>(StrTab)));
|
|
if (!MaybeSerializer)
|
|
return MaybeSerializer.takeError();
|
|
|
|
std::unique_ptr<remarks::RemarkSerializer> Serializer =
|
|
std::move(*MaybeSerializer);
|
|
|
|
for (const Remark &R : remarks())
|
|
Serializer->emit(R);
|
|
return Error::success();
|
|
}
|