blob: b70b06d706bdffdb4877734d1ee0cb84317d09b2 [file] [log] [blame]
//===- 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, std::optional<Format> RemarkFormat) {
if (!RemarkFormat) {
Expected<Format> ParserFormat = magicToFormat(Buffer);
if (!ParserFormat)
return ParserFormat.takeError();
RemarkFormat = *ParserFormat;
}
Expected<std::unique_ptr<RemarkParser>> MaybeParser =
createRemarkParserFromMeta(
*RemarkFormat, Buffer, /*StrTab=*/std::nullopt,
PrependPath ? std::optional<StringRef>(StringRef(*PrependPath))
: std::optional<StringRef>());
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,
std::optional<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, SerializerMode::Standalone, 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();
}