75a1797044
Fat LTO objects contain both LTO compatible IR, as well as generated object code. This allows users to defer the choice of whether to use LTO or not to link-time. This is a feature available in GCC for some time, and makes the existing -ffat-lto-objects flag functional in the same way as GCC's. Within LLVM, we add a new EmbedBitcodePass that serializes the module to the object file, and expose a new pass pipeline for compiling fat objects. The new pipeline initially clones the module and runs the selected (Thin)LTOPrelink pipeline, after which it will serialize the module into a `.llvm.lto` section of an ELF file. When compiling for (Thin)LTO, this normally the point at which the compiler would emit a object file containing the bitcode and metadata. After that point we compile the original module using the PerModuleDefaultPipeline used for non-LTO compilation. We generate standard object files at the end of this pipeline, which contain machine code and the new `.llvm.lto` section containing bitcode. Since the two pipelines operate on different copies of the module, we can be sure that the bitcode in the `.llvm.lto` section and object code in `.text` are congruent with the existing output produced by the default and LTO pipelines. Original RFC: https://discourse.llvm.org/t/rfc-ffat-lto-objects-support/63977 Earlier versions of this patch were missing REQUIRES lines for llc related tests in Transforms/EmbedBitcode. Those tests are now under CodeGen/X86, which should avoid running the check on unsupported platforms. The EmbedbBitcodePass also returned PreservedAnalyses::all when adding a metadata section, which failed expensive checks, since it modified the module. This is now corrected. Reviewed By: tejohnson, MaskRay, nikic Differential Revision: https://reviews.llvm.org/D146776
93 lines
2.5 KiB
C++
93 lines
2.5 KiB
C++
//===-- StructuralHash.cpp - IR Hashing -------------------------*- 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/IR/StructuralHash.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/GlobalVariable.h"
|
|
#include "llvm/IR/Module.h"
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
|
|
// Basic hashing mechanism to detect structural change to the IR, used to verify
|
|
// pass return status consistency with actual change. Loosely copied from
|
|
// llvm/lib/Transforms/Utils/FunctionComparator.cpp
|
|
|
|
class StructuralHashImpl {
|
|
hash_code Hash;
|
|
|
|
template <typename T> void hash(const T &V) { Hash = hash_combine(Hash, V); }
|
|
|
|
public:
|
|
StructuralHashImpl() : Hash(4) {}
|
|
|
|
void update(const Function &F) {
|
|
// Declarations don't affect analyses.
|
|
if (F.isDeclaration())
|
|
return;
|
|
|
|
hash(12345); // Function header
|
|
|
|
hash(F.isVarArg());
|
|
hash(F.arg_size());
|
|
|
|
SmallVector<const BasicBlock *, 8> BBs;
|
|
SmallPtrSet<const BasicBlock *, 16> VisitedBBs;
|
|
|
|
BBs.push_back(&F.getEntryBlock());
|
|
VisitedBBs.insert(BBs[0]);
|
|
while (!BBs.empty()) {
|
|
const BasicBlock *BB = BBs.pop_back_val();
|
|
hash(45798); // Block header
|
|
for (auto &Inst : *BB)
|
|
hash(Inst.getOpcode());
|
|
|
|
const Instruction *Term = BB->getTerminator();
|
|
for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) {
|
|
if (!VisitedBBs.insert(Term->getSuccessor(i)).second)
|
|
continue;
|
|
BBs.push_back(Term->getSuccessor(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
void update(const GlobalVariable &GV) {
|
|
// used/compiler.used don't affect analyses.
|
|
// Same for llvm.embedded.object, which is always a metadata section.
|
|
if (GV.getName() == "llvm.compiler.used" || GV.getName() == "llvm.used" ||
|
|
GV.getName() == "llvm.embedded.object")
|
|
return;
|
|
hash(23456); // Global header
|
|
hash(GV.getValueType()->getTypeID());
|
|
}
|
|
|
|
void update(const Module &M) {
|
|
for (const GlobalVariable &GV : M.globals())
|
|
update(GV);
|
|
for (const Function &F : M)
|
|
update(F);
|
|
}
|
|
|
|
uint64_t getHash() const { return Hash; }
|
|
};
|
|
|
|
} // namespace
|
|
|
|
uint64_t llvm::StructuralHash(const Function &F) {
|
|
StructuralHashImpl H;
|
|
H.update(F);
|
|
return H.getHash();
|
|
}
|
|
|
|
uint64_t llvm::StructuralHash(const Module &M) {
|
|
StructuralHashImpl H;
|
|
H.update(M);
|
|
return H.getHash();
|
|
}
|