2017-03-03 09:07:34 +08:00
|
|
|
//===- InstrProf.cpp - Instrumented profiling format support --------------===//
|
2014-03-22 01:24:48 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains support for clang's instrumentation based PGO and
|
|
|
|
// coverage.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2016-01-05 05:31:09 +08:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/ADT/StringRef.h"
|
2016-07-22 04:50:02 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/IR/Constant.h"
|
2015-11-09 08:01:22 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/Function.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/IR/GlobalValue.h"
|
2015-11-09 08:01:22 +08:00
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/IR/Instruction.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2016-02-05 03:11:43 +08:00
|
|
|
#include "llvm/IR/MDBuilder.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/IR/Metadata.h"
|
2015-12-31 15:57:16 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/IR/Type.h"
|
|
|
|
#include "llvm/ProfileData/InstrProf.h"
|
|
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
#include "llvm/Support/Compiler.h"
|
2015-12-31 15:57:16 +08:00
|
|
|
#include "llvm/Support/Compression.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/Support/Endian.h"
|
|
|
|
#include "llvm/Support/Error.h"
|
2014-03-22 01:24:48 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2015-12-31 15:57:16 +08:00
|
|
|
#include "llvm/Support/LEB128.h"
|
2014-09-20 07:19:24 +08:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2016-07-13 01:14:51 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2017-03-03 09:07:34 +08:00
|
|
|
#include "llvm/Support/SwapByteOrder.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <cassert>
|
|
|
|
#include <cstddef>
|
|
|
|
#include <cstring>
|
|
|
|
#include <cstdint>
|
|
|
|
#include <memory>
|
|
|
|
#include <string>
|
|
|
|
#include <system_error>
|
|
|
|
#include <utility>
|
|
|
|
#include <vector>
|
2014-03-22 01:24:48 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
2016-07-13 01:14:51 +08:00
|
|
|
static cl::opt<bool> StaticFuncFullModulePrefix(
|
2017-02-25 08:00:36 +08:00
|
|
|
"static-func-full-module-prefix", cl::init(true),
|
2016-07-13 01:14:51 +08:00
|
|
|
cl::desc("Use full module build paths in the profile counter names for "
|
|
|
|
"static functions."));
|
|
|
|
|
2017-02-25 08:00:36 +08:00
|
|
|
// This option is tailored to users that have different top-level directory in
|
|
|
|
// profile-gen and profile-use compilation. Users need to specific the number
|
|
|
|
// of levels to strip. A value larger than the number of directories in the
|
|
|
|
// source file will strip all the directory names and only leave the basename.
|
|
|
|
//
|
2017-02-28 01:59:01 +08:00
|
|
|
// Note current ThinLTO module importing for the indirect-calls assumes
|
2017-02-25 08:00:36 +08:00
|
|
|
// the source directory name not being stripped. A non-zero option value here
|
|
|
|
// can potentially prevent some inter-module indirect-call-promotions.
|
|
|
|
static cl::opt<unsigned> StaticFuncStripDirNamePrefix(
|
|
|
|
"static-func-strip-dirname-prefix", cl::init(0),
|
|
|
|
cl::desc("Strip specified level of directory name from source path in "
|
|
|
|
"the profile counter name for static functions."));
|
|
|
|
|
2017-03-03 09:07:34 +08:00
|
|
|
static std::string getInstrProfErrString(instrprof_error Err) {
|
2016-05-19 11:54:45 +08:00
|
|
|
switch (Err) {
|
|
|
|
case instrprof_error::success:
|
|
|
|
return "Success";
|
|
|
|
case instrprof_error::eof:
|
|
|
|
return "End of File";
|
|
|
|
case instrprof_error::unrecognized_format:
|
|
|
|
return "Unrecognized instrumentation profile encoding format";
|
|
|
|
case instrprof_error::bad_magic:
|
|
|
|
return "Invalid instrumentation profile data (bad magic)";
|
|
|
|
case instrprof_error::bad_header:
|
|
|
|
return "Invalid instrumentation profile data (file header is corrupt)";
|
|
|
|
case instrprof_error::unsupported_version:
|
|
|
|
return "Unsupported instrumentation profile format version";
|
|
|
|
case instrprof_error::unsupported_hash_type:
|
|
|
|
return "Unsupported instrumentation profile hash type";
|
|
|
|
case instrprof_error::too_large:
|
|
|
|
return "Too much profile data";
|
|
|
|
case instrprof_error::truncated:
|
|
|
|
return "Truncated profile data";
|
|
|
|
case instrprof_error::malformed:
|
|
|
|
return "Malformed instrumentation profile data";
|
|
|
|
case instrprof_error::unknown_function:
|
|
|
|
return "No profile data available for function";
|
|
|
|
case instrprof_error::hash_mismatch:
|
|
|
|
return "Function control flow change detected (hash mismatch)";
|
|
|
|
case instrprof_error::count_mismatch:
|
|
|
|
return "Function basic block count change detected (counter mismatch)";
|
|
|
|
case instrprof_error::counter_overflow:
|
|
|
|
return "Counter overflow";
|
|
|
|
case instrprof_error::value_site_count_mismatch:
|
|
|
|
return "Function value site count change detected (counter mismatch)";
|
|
|
|
case instrprof_error::compress_failed:
|
|
|
|
return "Failed to compress data (zlib)";
|
|
|
|
case instrprof_error::uncompress_failed:
|
|
|
|
return "Failed to uncompress data (zlib)";
|
2016-10-20 06:51:17 +08:00
|
|
|
case instrprof_error::empty_raw_profile:
|
|
|
|
return "Empty raw profile file";
|
2016-05-19 11:54:45 +08:00
|
|
|
}
|
|
|
|
llvm_unreachable("A value of instrprof_error has no message.");
|
|
|
|
}
|
|
|
|
|
2017-03-03 09:07:34 +08:00
|
|
|
namespace {
|
|
|
|
|
2016-05-25 04:13:46 +08:00
|
|
|
// FIXME: This class is only here to support the transition to llvm::Error. It
|
|
|
|
// will be removed once this transition is complete. Clients should prefer to
|
|
|
|
// deal with the Error value directly, rather than converting to error_code.
|
2014-06-12 09:45:43 +08:00
|
|
|
class InstrProfErrorCategoryType : public std::error_category {
|
2016-10-20 07:52:38 +08:00
|
|
|
const char *name() const noexcept override { return "llvm.instrprof"; }
|
2017-03-03 09:07:34 +08:00
|
|
|
|
2014-03-22 01:24:48 +08:00
|
|
|
std::string message(int IE) const override {
|
2016-05-19 11:54:45 +08:00
|
|
|
return getInstrProfErrString(static_cast<instrprof_error>(IE));
|
2014-03-22 01:24:48 +08:00
|
|
|
}
|
|
|
|
};
|
2017-03-03 09:07:34 +08:00
|
|
|
|
2016-01-27 02:48:36 +08:00
|
|
|
} // end anonymous namespace
|
2014-03-22 01:24:48 +08:00
|
|
|
|
2014-09-20 07:19:24 +08:00
|
|
|
static ManagedStatic<InstrProfErrorCategoryType> ErrorCategory;
|
|
|
|
|
2014-06-12 09:45:43 +08:00
|
|
|
const std::error_category &llvm::instrprof_category() {
|
2014-09-20 07:19:24 +08:00
|
|
|
return *ErrorCategory;
|
2014-03-22 01:24:48 +08:00
|
|
|
}
|
2015-11-09 08:01:22 +08:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
2016-05-12 03:42:19 +08:00
|
|
|
void SoftInstrProfErrors::addError(instrprof_error IE) {
|
|
|
|
if (IE == instrprof_error::success)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (FirstError == instrprof_error::success)
|
|
|
|
FirstError = IE;
|
|
|
|
|
|
|
|
switch (IE) {
|
|
|
|
case instrprof_error::hash_mismatch:
|
|
|
|
++NumHashMismatches;
|
|
|
|
break;
|
|
|
|
case instrprof_error::count_mismatch:
|
|
|
|
++NumCountMismatches;
|
|
|
|
break;
|
|
|
|
case instrprof_error::counter_overflow:
|
|
|
|
++NumCounterOverflows;
|
|
|
|
break;
|
|
|
|
case instrprof_error::value_site_count_mismatch:
|
|
|
|
++NumValueSiteCountMismatches;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Not a soft error");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
std::string InstrProfError::message() const {
|
|
|
|
return getInstrProfErrString(Err);
|
|
|
|
}
|
|
|
|
|
|
|
|
char InstrProfError::ID = 0;
|
|
|
|
|
2015-11-09 08:01:22 +08:00
|
|
|
std::string getPGOFuncName(StringRef RawFuncName,
|
|
|
|
GlobalValue::LinkageTypes Linkage,
|
2015-12-12 04:23:22 +08:00
|
|
|
StringRef FileName,
|
|
|
|
uint64_t Version LLVM_ATTRIBUTE_UNUSED) {
|
2016-03-15 10:13:19 +08:00
|
|
|
return GlobalValue::getGlobalIdentifier(RawFuncName, Linkage, FileName);
|
2015-11-09 08:01:22 +08:00
|
|
|
}
|
|
|
|
|
2017-02-25 08:00:36 +08:00
|
|
|
// Strip NumPrefix level of directory name from PathNameStr. If the number of
|
|
|
|
// directory separators is less than NumPrefix, strip all the directories and
|
|
|
|
// leave base file name only.
|
|
|
|
static StringRef stripDirPrefix(StringRef PathNameStr, uint32_t NumPrefix) {
|
|
|
|
uint32_t Count = NumPrefix;
|
|
|
|
uint32_t Pos = 0, LastPos = 0;
|
|
|
|
for (auto & CI : PathNameStr) {
|
|
|
|
++Pos;
|
|
|
|
if (llvm::sys::path::is_separator(CI)) {
|
|
|
|
LastPos = Pos;
|
|
|
|
--Count;
|
|
|
|
}
|
|
|
|
if (Count == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return PathNameStr.substr(LastPos);
|
|
|
|
}
|
|
|
|
|
2016-03-31 02:37:52 +08:00
|
|
|
// Return the PGOFuncName. This function has some special handling when called
|
|
|
|
// in LTO optimization. The following only applies when calling in LTO passes
|
|
|
|
// (when \c InLTO is true): LTO's internalization privatizes many global linkage
|
|
|
|
// symbols. This happens after value profile annotation, but those internal
|
|
|
|
// linkage functions should not have a source prefix.
|
2016-08-30 06:46:56 +08:00
|
|
|
// Additionally, for ThinLTO mode, exported internal functions are promoted
|
|
|
|
// and renamed. We need to ensure that the original internal PGO name is
|
|
|
|
// used when computing the GUID that is compared against the profiled GUIDs.
|
2016-03-31 02:37:52 +08:00
|
|
|
// To differentiate compiler generated internal symbols from original ones,
|
|
|
|
// PGOFuncName meta data are created and attached to the original internal
|
|
|
|
// symbols in the value profile annotation step
|
|
|
|
// (PGOUseFunc::annotateIndirectCallSites). If a symbol does not have the meta
|
|
|
|
// data, its original linkage must be non-internal.
|
|
|
|
std::string getPGOFuncName(const Function &F, bool InLTO, uint64_t Version) {
|
2016-07-13 01:14:51 +08:00
|
|
|
if (!InLTO) {
|
|
|
|
StringRef FileName = (StaticFuncFullModulePrefix
|
|
|
|
? F.getParent()->getName()
|
|
|
|
: sys::path::filename(F.getParent()->getName()));
|
2017-02-25 08:00:36 +08:00
|
|
|
if (StaticFuncFullModulePrefix && StaticFuncStripDirNamePrefix != 0)
|
|
|
|
FileName = stripDirPrefix(FileName, StaticFuncStripDirNamePrefix);
|
2016-07-13 01:14:51 +08:00
|
|
|
return getPGOFuncName(F.getName(), F.getLinkage(), FileName, Version);
|
|
|
|
}
|
2016-03-31 02:37:52 +08:00
|
|
|
|
2016-04-02 00:43:30 +08:00
|
|
|
// In LTO mode (when InLTO is true), first check if there is a meta data.
|
|
|
|
if (MDNode *MD = getPGOFuncNameMetadata(F)) {
|
2016-03-31 02:37:52 +08:00
|
|
|
StringRef S = cast<MDString>(MD->getOperand(0))->getString();
|
|
|
|
return S.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there is no meta data, the function must be a global before the value
|
|
|
|
// profile annotation pass. Its current linkage may be internal if it is
|
|
|
|
// internalized in LTO mode.
|
2016-04-02 00:43:30 +08:00
|
|
|
return getPGOFuncName(F.getName(), GlobalValue::ExternalLinkage, "");
|
2015-11-09 08:01:22 +08:00
|
|
|
}
|
|
|
|
|
2015-12-16 03:44:45 +08:00
|
|
|
StringRef getFuncNameWithoutPrefix(StringRef PGOFuncName, StringRef FileName) {
|
|
|
|
if (FileName.empty())
|
2016-03-28 23:49:08 +08:00
|
|
|
return PGOFuncName;
|
2015-12-16 03:44:45 +08:00
|
|
|
// Drop the file name including ':'. See also getPGOFuncName.
|
|
|
|
if (PGOFuncName.startswith(FileName))
|
|
|
|
PGOFuncName = PGOFuncName.drop_front(FileName.size() + 1);
|
|
|
|
return PGOFuncName;
|
|
|
|
}
|
|
|
|
|
2015-12-13 01:28:03 +08:00
|
|
|
// \p FuncName is the string used as profile lookup key for the function. A
|
|
|
|
// symbol is created to hold the name. Return the legalized symbol name.
|
2016-03-17 04:49:26 +08:00
|
|
|
std::string getPGOFuncNameVarName(StringRef FuncName,
|
|
|
|
GlobalValue::LinkageTypes Linkage) {
|
2015-12-13 01:28:03 +08:00
|
|
|
std::string VarName = getInstrProfNameVarPrefix();
|
|
|
|
VarName += FuncName;
|
|
|
|
|
|
|
|
if (!GlobalValue::isLocalLinkage(Linkage))
|
|
|
|
return VarName;
|
|
|
|
|
|
|
|
// Now fix up illegal chars in local VarName that may upset the assembler.
|
2016-06-10 14:32:26 +08:00
|
|
|
const char *InvalidChars = "-:<>/\"'";
|
2015-12-13 01:28:03 +08:00
|
|
|
size_t found = VarName.find_first_of(InvalidChars);
|
|
|
|
while (found != std::string::npos) {
|
|
|
|
VarName[found] = '_';
|
|
|
|
found = VarName.find_first_of(InvalidChars, found + 1);
|
|
|
|
}
|
|
|
|
return VarName;
|
|
|
|
}
|
|
|
|
|
2015-11-09 08:01:22 +08:00
|
|
|
GlobalVariable *createPGOFuncNameVar(Module &M,
|
|
|
|
GlobalValue::LinkageTypes Linkage,
|
2016-03-17 06:13:41 +08:00
|
|
|
StringRef PGOFuncName) {
|
2015-11-09 08:01:22 +08:00
|
|
|
// We generally want to match the function's linkage, but available_externally
|
|
|
|
// and extern_weak both have the wrong semantics, and anything that doesn't
|
|
|
|
// need to link across compilation units doesn't need to be visible at all.
|
|
|
|
if (Linkage == GlobalValue::ExternalWeakLinkage)
|
|
|
|
Linkage = GlobalValue::LinkOnceAnyLinkage;
|
|
|
|
else if (Linkage == GlobalValue::AvailableExternallyLinkage)
|
|
|
|
Linkage = GlobalValue::LinkOnceODRLinkage;
|
|
|
|
else if (Linkage == GlobalValue::InternalLinkage ||
|
|
|
|
Linkage == GlobalValue::ExternalLinkage)
|
|
|
|
Linkage = GlobalValue::PrivateLinkage;
|
|
|
|
|
2016-03-17 06:13:41 +08:00
|
|
|
auto *Value =
|
|
|
|
ConstantDataArray::getString(M.getContext(), PGOFuncName, false);
|
2015-11-09 08:01:22 +08:00
|
|
|
auto FuncNameVar =
|
|
|
|
new GlobalVariable(M, Value->getType(), true, Linkage, Value,
|
2016-03-17 06:13:41 +08:00
|
|
|
getPGOFuncNameVarName(PGOFuncName, Linkage));
|
2015-11-09 08:01:22 +08:00
|
|
|
|
|
|
|
// Hide the symbol so that we correctly get a copy for each executable.
|
|
|
|
if (!GlobalValue::isLocalLinkage(FuncNameVar->getLinkage()))
|
|
|
|
FuncNameVar->setVisibility(GlobalValue::HiddenVisibility);
|
|
|
|
|
|
|
|
return FuncNameVar;
|
|
|
|
}
|
|
|
|
|
2016-03-17 06:13:41 +08:00
|
|
|
GlobalVariable *createPGOFuncNameVar(Function &F, StringRef PGOFuncName) {
|
|
|
|
return createPGOFuncNameVar(*F.getParent(), F.getLinkage(), PGOFuncName);
|
2015-11-09 08:01:22 +08:00
|
|
|
}
|
2015-11-10 08:24:45 +08:00
|
|
|
|
2016-03-31 02:37:52 +08:00
|
|
|
void InstrProfSymtab::create(Module &M, bool InLTO) {
|
|
|
|
for (Function &F : M) {
|
|
|
|
// Function may not have a name: like using asm("") to overwrite the name.
|
|
|
|
// Ignore in this case.
|
|
|
|
if (!F.hasName())
|
|
|
|
continue;
|
|
|
|
const std::string &PGOFuncName = getPGOFuncName(F, InLTO);
|
|
|
|
addFuncName(PGOFuncName);
|
2016-04-01 01:39:33 +08:00
|
|
|
MD5FuncMap.emplace_back(Function::getGUID(PGOFuncName), &F);
|
SamplePGO ThinLTO ICP fix for local functions.
Summary:
In SamplePGO, if the profile is collected from non-LTO binary, and used to drive ThinLTO, the indirect call promotion may fail because ThinLTO adjusts local function names to avoid conflicts. There are two places of where the mismatch can happen:
1. thin-link prepends SourceFileName to front of FuncName to build the GUID (GlobalValue::getGlobalIdentifier). Unlike instrumentation FDO, SamplePGO does not use the PGOFuncName scheme and therefore the indirect call target profile data contains a hash of the OriginalName.
2. backend compiler promotes some local functions to global and appends .llvm.{$ModuleHash} to the end of the FuncName to derive PromotedFunctionName
This patch tries at the best effort to find the GUID from the original local function name (in profile), and use that in ICP promotion, and in SamplePGO matching that happens in the backend after importing/inlining:
1. in thin-link, it builds the map from OriginalName to GUID so that when thin-link reads in indirect call target profile (represented by OriginalName), it knows which GUID to import.
2. in backend compiler, if sample profile reader cannot find a profile match for PromotedFunctionName, it will try to find if there is a match for OriginalFunctionName.
3. in backend compiler, we build symbol table entry for OriginalFunctionName and pointer to the same symbol of PromotedFunctionName, so that ICP can find the correct target to promote.
Reviewers: mehdi_amini, tejohnson
Reviewed By: tejohnson
Subscribers: llvm-commits, Prazek
Differential Revision: https://reviews.llvm.org/D30754
llvm-svn: 297757
2017-03-15 01:33:01 +08:00
|
|
|
// In ThinLTO, local function may have been promoted to global and have
|
|
|
|
// suffix added to the function name. We need to add the stripped function
|
|
|
|
// name to the symbol table so that we can find a match from profile.
|
|
|
|
if (InLTO) {
|
|
|
|
auto pos = PGOFuncName.find('.');
|
|
|
|
if (pos != std::string::npos) {
|
|
|
|
const std::string &OtherFuncName = PGOFuncName.substr(0, pos);
|
|
|
|
addFuncName(OtherFuncName);
|
|
|
|
MD5FuncMap.emplace_back(Function::getGUID(OtherFuncName), &F);
|
|
|
|
}
|
|
|
|
}
|
2016-03-31 02:37:52 +08:00
|
|
|
}
|
2016-01-20 09:26:34 +08:00
|
|
|
|
|
|
|
finalizeSymtab();
|
|
|
|
}
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
Error collectPGOFuncNameStrings(const std::vector<std::string> &NameStrs,
|
|
|
|
bool doCompression, std::string &Result) {
|
2017-03-03 09:07:34 +08:00
|
|
|
assert(!NameStrs.empty() && "No name data to emit");
|
2016-03-29 05:06:42 +08:00
|
|
|
|
2015-12-31 15:57:16 +08:00
|
|
|
uint8_t Header[16], *P = Header;
|
2016-01-05 05:31:09 +08:00
|
|
|
std::string UncompressedNameStrings =
|
2016-03-29 05:06:42 +08:00
|
|
|
join(NameStrs.begin(), NameStrs.end(), getInstrProfNameSeparator());
|
|
|
|
|
|
|
|
assert(StringRef(UncompressedNameStrings)
|
|
|
|
.count(getInstrProfNameSeparator()) == (NameStrs.size() - 1) &&
|
|
|
|
"PGO name is invalid (contains separator token)");
|
2016-01-05 04:26:05 +08:00
|
|
|
|
2015-12-31 15:57:16 +08:00
|
|
|
unsigned EncLen = encodeULEB128(UncompressedNameStrings.length(), P);
|
|
|
|
P += EncLen;
|
2016-01-05 06:01:02 +08:00
|
|
|
|
2016-05-29 18:31:00 +08:00
|
|
|
auto WriteStringToResult = [&](size_t CompressedLen, StringRef InputStr) {
|
2016-01-05 06:01:02 +08:00
|
|
|
EncLen = encodeULEB128(CompressedLen, P);
|
2015-12-31 15:57:16 +08:00
|
|
|
P += EncLen;
|
2016-01-05 06:01:02 +08:00
|
|
|
char *HeaderStr = reinterpret_cast<char *>(&Header[0]);
|
|
|
|
unsigned HeaderLen = P - &Header[0];
|
|
|
|
Result.append(HeaderStr, HeaderLen);
|
|
|
|
Result += InputStr;
|
2016-05-19 11:54:45 +08:00
|
|
|
return Error::success();
|
2016-01-05 06:01:02 +08:00
|
|
|
};
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
if (!doCompression) {
|
2016-01-05 06:01:02 +08:00
|
|
|
return WriteStringToResult(0, UncompressedNameStrings);
|
2016-05-19 11:54:45 +08:00
|
|
|
}
|
2016-01-05 06:01:02 +08:00
|
|
|
|
2016-05-29 18:31:00 +08:00
|
|
|
SmallString<128> CompressedNameStrings;
|
2017-01-17 23:45:07 +08:00
|
|
|
Error E = zlib::compress(StringRef(UncompressedNameStrings),
|
|
|
|
CompressedNameStrings, zlib::BestSizeCompression);
|
|
|
|
if (E) {
|
|
|
|
consumeError(std::move(E));
|
2016-05-19 11:54:45 +08:00
|
|
|
return make_error<InstrProfError>(instrprof_error::compress_failed);
|
2017-01-17 23:45:07 +08:00
|
|
|
}
|
2016-01-05 06:01:02 +08:00
|
|
|
|
2016-05-29 18:31:00 +08:00
|
|
|
return WriteStringToResult(CompressedNameStrings.size(),
|
|
|
|
CompressedNameStrings);
|
2015-12-31 15:57:16 +08:00
|
|
|
}
|
|
|
|
|
2016-02-05 07:59:09 +08:00
|
|
|
StringRef getPGOFuncNameVarInitializer(GlobalVariable *NameVar) {
|
2016-01-03 12:38:13 +08:00
|
|
|
auto *Arr = cast<ConstantDataArray>(NameVar->getInitializer());
|
|
|
|
StringRef NameStr =
|
|
|
|
Arr->isCString() ? Arr->getAsCString() : Arr->getAsString();
|
|
|
|
return NameStr;
|
|
|
|
}
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
Error collectPGOFuncNameStrings(const std::vector<GlobalVariable *> &NameVars,
|
|
|
|
std::string &Result, bool doCompression) {
|
2015-12-31 15:57:16 +08:00
|
|
|
std::vector<std::string> NameStrs;
|
|
|
|
for (auto *NameVar : NameVars) {
|
2016-02-05 07:59:09 +08:00
|
|
|
NameStrs.push_back(getPGOFuncNameVarInitializer(NameVar));
|
2015-12-31 15:57:16 +08:00
|
|
|
}
|
2016-01-27 07:13:00 +08:00
|
|
|
return collectPGOFuncNameStrings(
|
|
|
|
NameStrs, zlib::isAvailable() && doCompression, Result);
|
2015-12-31 15:57:16 +08:00
|
|
|
}
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
Error readPGOFuncNameStrings(StringRef NameStrings, InstrProfSymtab &Symtab) {
|
2015-12-31 15:57:16 +08:00
|
|
|
const uint8_t *P = reinterpret_cast<const uint8_t *>(NameStrings.data());
|
|
|
|
const uint8_t *EndP = reinterpret_cast<const uint8_t *>(NameStrings.data() +
|
|
|
|
NameStrings.size());
|
|
|
|
while (P < EndP) {
|
|
|
|
uint32_t N;
|
|
|
|
uint64_t UncompressedSize = decodeULEB128(P, &N);
|
|
|
|
P += N;
|
|
|
|
uint64_t CompressedSize = decodeULEB128(P, &N);
|
|
|
|
P += N;
|
|
|
|
bool isCompressed = (CompressedSize != 0);
|
|
|
|
SmallString<128> UncompressedNameStrings;
|
|
|
|
StringRef NameStrings;
|
|
|
|
if (isCompressed) {
|
|
|
|
StringRef CompressedNameStrings(reinterpret_cast<const char *>(P),
|
|
|
|
CompressedSize);
|
2017-01-17 23:45:07 +08:00
|
|
|
if (Error E =
|
|
|
|
zlib::uncompress(CompressedNameStrings, UncompressedNameStrings,
|
|
|
|
UncompressedSize)) {
|
|
|
|
consumeError(std::move(E));
|
2016-05-19 11:54:45 +08:00
|
|
|
return make_error<InstrProfError>(instrprof_error::uncompress_failed);
|
2017-01-17 23:45:07 +08:00
|
|
|
}
|
2015-12-31 15:57:16 +08:00
|
|
|
P += CompressedSize;
|
|
|
|
NameStrings = StringRef(UncompressedNameStrings.data(),
|
|
|
|
UncompressedNameStrings.size());
|
|
|
|
} else {
|
|
|
|
NameStrings =
|
|
|
|
StringRef(reinterpret_cast<const char *>(P), UncompressedSize);
|
|
|
|
P += UncompressedSize;
|
|
|
|
}
|
|
|
|
// Now parse the name strings.
|
2016-01-05 06:09:26 +08:00
|
|
|
SmallVector<StringRef, 0> Names;
|
2016-03-29 05:06:42 +08:00
|
|
|
NameStrings.split(Names, getInstrProfNameSeparator());
|
2016-01-05 06:09:26 +08:00
|
|
|
for (StringRef &Name : Names)
|
2015-12-31 15:57:16 +08:00
|
|
|
Symtab.addFuncName(Name);
|
|
|
|
|
|
|
|
while (P < EndP && *P == 0)
|
|
|
|
P++;
|
|
|
|
}
|
|
|
|
Symtab.finalizeSymtab();
|
2016-05-19 11:54:45 +08:00
|
|
|
return Error::success();
|
2015-12-31 15:57:16 +08:00
|
|
|
}
|
|
|
|
|
2016-05-12 03:42:19 +08:00
|
|
|
void InstrProfValueSiteRecord::merge(SoftInstrProfErrors &SIPE,
|
|
|
|
InstrProfValueSiteRecord &Input,
|
|
|
|
uint64_t Weight) {
|
2015-12-20 13:15:45 +08:00
|
|
|
this->sortByTargetValues();
|
|
|
|
Input.sortByTargetValues();
|
|
|
|
auto I = ValueData.begin();
|
|
|
|
auto IE = ValueData.end();
|
|
|
|
for (auto J = Input.ValueData.begin(), JE = Input.ValueData.end(); J != JE;
|
|
|
|
++J) {
|
|
|
|
while (I != IE && I->Value < J->Value)
|
|
|
|
++I;
|
|
|
|
if (I != IE && I->Value == J->Value) {
|
|
|
|
bool Overflowed;
|
2016-01-13 06:34:00 +08:00
|
|
|
I->Count = SaturatingMultiplyAdd(J->Count, Weight, I->Count, &Overflowed);
|
2015-12-20 13:15:45 +08:00
|
|
|
if (Overflowed)
|
2016-05-12 03:42:19 +08:00
|
|
|
SIPE.addError(instrprof_error::counter_overflow);
|
2015-12-20 13:15:45 +08:00
|
|
|
++I;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
ValueData.insert(I, *J);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-12 03:42:19 +08:00
|
|
|
void InstrProfValueSiteRecord::scale(SoftInstrProfErrors &SIPE,
|
|
|
|
uint64_t Weight) {
|
2016-01-08 11:49:59 +08:00
|
|
|
for (auto I = ValueData.begin(), IE = ValueData.end(); I != IE; ++I) {
|
|
|
|
bool Overflowed;
|
|
|
|
I->Count = SaturatingMultiply(I->Count, Weight, &Overflowed);
|
|
|
|
if (Overflowed)
|
2016-05-12 03:42:19 +08:00
|
|
|
SIPE.addError(instrprof_error::counter_overflow);
|
2016-01-08 11:49:59 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-19 07:06:37 +08:00
|
|
|
// Merge Value Profile data from Src record to this record for ValueKind.
|
|
|
|
// Scale merged value counts by \p Weight.
|
2016-05-12 03:42:19 +08:00
|
|
|
void InstrProfRecord::mergeValueProfData(uint32_t ValueKind,
|
|
|
|
InstrProfRecord &Src,
|
|
|
|
uint64_t Weight) {
|
2015-12-19 07:06:37 +08:00
|
|
|
uint32_t ThisNumValueSites = getNumValueSites(ValueKind);
|
|
|
|
uint32_t OtherNumValueSites = Src.getNumValueSites(ValueKind);
|
2016-05-12 03:42:19 +08:00
|
|
|
if (ThisNumValueSites != OtherNumValueSites) {
|
|
|
|
SIPE.addError(instrprof_error::value_site_count_mismatch);
|
|
|
|
return;
|
|
|
|
}
|
2015-12-19 07:06:37 +08:00
|
|
|
std::vector<InstrProfValueSiteRecord> &ThisSiteRecords =
|
|
|
|
getValueSitesForKind(ValueKind);
|
|
|
|
std::vector<InstrProfValueSiteRecord> &OtherSiteRecords =
|
|
|
|
Src.getValueSitesForKind(ValueKind);
|
|
|
|
for (uint32_t I = 0; I < ThisNumValueSites; I++)
|
2016-05-12 03:42:19 +08:00
|
|
|
ThisSiteRecords[I].merge(SIPE, OtherSiteRecords[I], Weight);
|
2015-12-19 07:06:37 +08:00
|
|
|
}
|
|
|
|
|
2016-05-12 03:42:19 +08:00
|
|
|
void InstrProfRecord::merge(InstrProfRecord &Other, uint64_t Weight) {
|
2015-12-19 07:06:37 +08:00
|
|
|
// If the number of counters doesn't match we either have bad data
|
|
|
|
// or a hash collision.
|
2016-05-12 03:42:19 +08:00
|
|
|
if (Counts.size() != Other.Counts.size()) {
|
|
|
|
SIPE.addError(instrprof_error::count_mismatch);
|
|
|
|
return;
|
|
|
|
}
|
2015-12-19 07:06:37 +08:00
|
|
|
|
|
|
|
for (size_t I = 0, E = Other.Counts.size(); I < E; ++I) {
|
|
|
|
bool Overflowed;
|
2016-01-13 06:34:00 +08:00
|
|
|
Counts[I] =
|
|
|
|
SaturatingMultiplyAdd(Other.Counts[I], Weight, Counts[I], &Overflowed);
|
2015-12-19 07:06:37 +08:00
|
|
|
if (Overflowed)
|
2016-05-12 03:42:19 +08:00
|
|
|
SIPE.addError(instrprof_error::counter_overflow);
|
2015-12-19 07:06:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
|
2016-05-12 03:42:19 +08:00
|
|
|
mergeValueProfData(Kind, Other, Weight);
|
2015-12-19 07:06:37 +08:00
|
|
|
}
|
2015-12-20 14:22:13 +08:00
|
|
|
|
2016-05-12 03:42:19 +08:00
|
|
|
void InstrProfRecord::scaleValueProfData(uint32_t ValueKind, uint64_t Weight) {
|
2016-01-08 11:49:59 +08:00
|
|
|
uint32_t ThisNumValueSites = getNumValueSites(ValueKind);
|
|
|
|
std::vector<InstrProfValueSiteRecord> &ThisSiteRecords =
|
|
|
|
getValueSitesForKind(ValueKind);
|
|
|
|
for (uint32_t I = 0; I < ThisNumValueSites; I++)
|
2016-05-12 03:42:19 +08:00
|
|
|
ThisSiteRecords[I].scale(SIPE, Weight);
|
2016-01-08 11:49:59 +08:00
|
|
|
}
|
|
|
|
|
2016-05-12 03:42:19 +08:00
|
|
|
void InstrProfRecord::scale(uint64_t Weight) {
|
2016-01-08 11:49:59 +08:00
|
|
|
for (auto &Count : this->Counts) {
|
|
|
|
bool Overflowed;
|
|
|
|
Count = SaturatingMultiply(Count, Weight, &Overflowed);
|
2016-05-12 03:42:19 +08:00
|
|
|
if (Overflowed)
|
|
|
|
SIPE.addError(instrprof_error::counter_overflow);
|
2016-01-08 11:49:59 +08:00
|
|
|
}
|
|
|
|
for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
|
2016-05-12 03:42:19 +08:00
|
|
|
scaleValueProfData(Kind, Weight);
|
2016-01-08 11:49:59 +08:00
|
|
|
}
|
|
|
|
|
2015-12-19 07:06:37 +08:00
|
|
|
// Map indirect call target name hash to name string.
|
|
|
|
uint64_t InstrProfRecord::remapValue(uint64_t Value, uint32_t ValueKind,
|
2015-12-20 14:22:13 +08:00
|
|
|
ValueMapType *ValueMap) {
|
|
|
|
if (!ValueMap)
|
2015-12-19 07:06:37 +08:00
|
|
|
return Value;
|
|
|
|
switch (ValueKind) {
|
|
|
|
case IPVK_IndirectCallTarget: {
|
|
|
|
auto Result =
|
2015-12-20 14:22:13 +08:00
|
|
|
std::lower_bound(ValueMap->begin(), ValueMap->end(), Value,
|
|
|
|
[](const std::pair<uint64_t, uint64_t> &LHS,
|
2015-12-19 07:06:37 +08:00
|
|
|
uint64_t RHS) { return LHS.first < RHS; });
|
2016-04-12 01:13:08 +08:00
|
|
|
// Raw function pointer collected by value profiler may be from
|
|
|
|
// external functions that are not instrumented. They won't have
|
|
|
|
// mapping data to be used by the deserializer. Force the value to
|
|
|
|
// be 0 in this case.
|
2016-04-10 11:32:02 +08:00
|
|
|
if (Result != ValueMap->end() && Result->first == Value)
|
2015-12-19 07:06:37 +08:00
|
|
|
Value = (uint64_t)Result->second;
|
2016-04-10 11:32:02 +08:00
|
|
|
else
|
|
|
|
Value = 0;
|
2015-12-19 07:06:37 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InstrProfRecord::addValueData(uint32_t ValueKind, uint32_t Site,
|
|
|
|
InstrProfValueData *VData, uint32_t N,
|
2015-12-20 14:22:13 +08:00
|
|
|
ValueMapType *ValueMap) {
|
2015-12-19 07:06:37 +08:00
|
|
|
for (uint32_t I = 0; I < N; I++) {
|
2015-12-20 14:22:13 +08:00
|
|
|
VData[I].Value = remapValue(VData[I].Value, ValueKind, ValueMap);
|
2015-12-19 07:06:37 +08:00
|
|
|
}
|
|
|
|
std::vector<InstrProfValueSiteRecord> &ValueSites =
|
|
|
|
getValueSitesForKind(ValueKind);
|
|
|
|
if (N == 0)
|
2016-05-12 00:03:02 +08:00
|
|
|
ValueSites.emplace_back();
|
2015-12-19 07:06:37 +08:00
|
|
|
else
|
|
|
|
ValueSites.emplace_back(VData, VData + N);
|
|
|
|
}
|
|
|
|
|
2015-11-29 03:07:09 +08:00
|
|
|
#define INSTR_PROF_COMMON_API_IMPL
|
|
|
|
#include "llvm/ProfileData/InstrProfData.inc"
|
2015-11-10 08:24:45 +08:00
|
|
|
|
2015-12-19 07:06:37 +08:00
|
|
|
/*!
|
2015-11-29 03:07:09 +08:00
|
|
|
* \brief ValueProfRecordClosure Interface implementation for InstrProfRecord
|
2015-11-26 07:31:18 +08:00
|
|
|
* class. These C wrappers are used as adaptors so that C++ code can be
|
|
|
|
* invoked as callbacks.
|
|
|
|
*/
|
2015-11-25 14:23:38 +08:00
|
|
|
uint32_t getNumValueKindsInstrProf(const void *Record) {
|
|
|
|
return reinterpret_cast<const InstrProfRecord *>(Record)->getNumValueKinds();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t getNumValueSitesInstrProf(const void *Record, uint32_t VKind) {
|
|
|
|
return reinterpret_cast<const InstrProfRecord *>(Record)
|
|
|
|
->getNumValueSites(VKind);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t getNumValueDataInstrProf(const void *Record, uint32_t VKind) {
|
|
|
|
return reinterpret_cast<const InstrProfRecord *>(Record)
|
|
|
|
->getNumValueData(VKind);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t getNumValueDataForSiteInstrProf(const void *R, uint32_t VK,
|
|
|
|
uint32_t S) {
|
|
|
|
return reinterpret_cast<const InstrProfRecord *>(R)
|
|
|
|
->getNumValueDataForSite(VK, S);
|
|
|
|
}
|
|
|
|
|
|
|
|
void getValueForSiteInstrProf(const void *R, InstrProfValueData *Dst,
|
2016-02-04 13:29:51 +08:00
|
|
|
uint32_t K, uint32_t S) {
|
|
|
|
reinterpret_cast<const InstrProfRecord *>(R)->getValueForSite(Dst, K, S);
|
2015-11-26 03:13:00 +08:00
|
|
|
}
|
|
|
|
|
2015-11-25 14:23:38 +08:00
|
|
|
ValueProfData *allocValueProfDataInstrProf(size_t TotalSizeInBytes) {
|
2015-12-16 05:57:08 +08:00
|
|
|
ValueProfData *VD =
|
|
|
|
(ValueProfData *)(new (::operator new(TotalSizeInBytes)) ValueProfData());
|
|
|
|
memset(VD, 0, TotalSizeInBytes);
|
|
|
|
return VD;
|
2015-11-25 14:23:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static ValueProfRecordClosure InstrProfRecordClosure = {
|
2016-01-27 02:48:36 +08:00
|
|
|
nullptr,
|
2015-11-25 14:23:38 +08:00
|
|
|
getNumValueKindsInstrProf,
|
|
|
|
getNumValueSitesInstrProf,
|
|
|
|
getNumValueDataInstrProf,
|
|
|
|
getNumValueDataForSiteInstrProf,
|
2016-01-27 02:48:36 +08:00
|
|
|
nullptr,
|
2015-11-25 14:23:38 +08:00
|
|
|
getValueForSiteInstrProf,
|
2015-12-16 05:57:08 +08:00
|
|
|
allocValueProfDataInstrProf};
|
2015-11-25 14:23:38 +08:00
|
|
|
|
2015-11-26 03:13:00 +08:00
|
|
|
// Wrapper implementation using the closure mechanism.
|
2015-11-25 14:23:38 +08:00
|
|
|
uint32_t ValueProfData::getSize(const InstrProfRecord &Record) {
|
|
|
|
InstrProfRecordClosure.Record = &Record;
|
|
|
|
return getValueProfDataSize(&InstrProfRecordClosure);
|
|
|
|
}
|
|
|
|
|
2015-11-26 03:13:00 +08:00
|
|
|
// Wrapper implementation using the closure mechanism.
|
2015-11-25 14:23:38 +08:00
|
|
|
std::unique_ptr<ValueProfData>
|
|
|
|
ValueProfData::serializeFrom(const InstrProfRecord &Record) {
|
|
|
|
InstrProfRecordClosure.Record = &Record;
|
|
|
|
|
|
|
|
std::unique_ptr<ValueProfData> VPD(
|
2015-12-02 03:47:32 +08:00
|
|
|
serializeValueProfDataFrom(&InstrProfRecordClosure, nullptr));
|
2015-11-25 14:23:38 +08:00
|
|
|
return VPD;
|
|
|
|
}
|
|
|
|
|
2015-11-26 03:13:00 +08:00
|
|
|
void ValueProfRecord::deserializeTo(InstrProfRecord &Record,
|
|
|
|
InstrProfRecord::ValueMapType *VMap) {
|
|
|
|
Record.reserveSites(Kind, NumValueSites);
|
|
|
|
|
|
|
|
InstrProfValueData *ValueData = getValueProfRecordValueData(this);
|
|
|
|
for (uint64_t VSite = 0; VSite < NumValueSites; ++VSite) {
|
|
|
|
uint8_t ValueDataCount = this->SiteCountArray[VSite];
|
|
|
|
Record.addValueData(Kind, VSite, ValueData, ValueDataCount, VMap);
|
|
|
|
ValueData += ValueDataCount;
|
|
|
|
}
|
|
|
|
}
|
2015-11-26 07:31:18 +08:00
|
|
|
|
2015-11-26 03:13:00 +08:00
|
|
|
// For writing/serializing, Old is the host endianness, and New is
|
|
|
|
// byte order intended on disk. For Reading/deserialization, Old
|
|
|
|
// is the on-disk source endianness, and New is the host endianness.
|
|
|
|
void ValueProfRecord::swapBytes(support::endianness Old,
|
|
|
|
support::endianness New) {
|
|
|
|
using namespace support;
|
2017-03-03 09:07:34 +08:00
|
|
|
|
2015-11-26 03:13:00 +08:00
|
|
|
if (Old == New)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (getHostEndianness() != Old) {
|
|
|
|
sys::swapByteOrder<uint32_t>(NumValueSites);
|
|
|
|
sys::swapByteOrder<uint32_t>(Kind);
|
|
|
|
}
|
|
|
|
uint32_t ND = getValueProfRecordNumValueData(this);
|
|
|
|
InstrProfValueData *VD = getValueProfRecordValueData(this);
|
|
|
|
|
|
|
|
// No need to swap byte array: SiteCountArrray.
|
|
|
|
for (uint32_t I = 0; I < ND; I++) {
|
|
|
|
sys::swapByteOrder<uint64_t>(VD[I].Value);
|
|
|
|
sys::swapByteOrder<uint64_t>(VD[I].Count);
|
|
|
|
}
|
|
|
|
if (getHostEndianness() == Old) {
|
|
|
|
sys::swapByteOrder<uint32_t>(NumValueSites);
|
|
|
|
sys::swapByteOrder<uint32_t>(Kind);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ValueProfData::deserializeTo(InstrProfRecord &Record,
|
|
|
|
InstrProfRecord::ValueMapType *VMap) {
|
|
|
|
if (NumValueKinds == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ValueProfRecord *VR = getFirstValueProfRecord(this);
|
|
|
|
for (uint32_t K = 0; K < NumValueKinds; K++) {
|
|
|
|
VR->deserializeTo(Record, VMap);
|
|
|
|
VR = getValueProfRecordNext(VR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
static T swapToHostOrder(const unsigned char *&D, support::endianness Orig) {
|
|
|
|
using namespace support;
|
2017-03-03 09:07:34 +08:00
|
|
|
|
2015-11-26 03:13:00 +08:00
|
|
|
if (Orig == little)
|
|
|
|
return endian::readNext<T, little, unaligned>(D);
|
|
|
|
else
|
|
|
|
return endian::readNext<T, big, unaligned>(D);
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::unique_ptr<ValueProfData> allocValueProfData(uint32_t TotalSize) {
|
|
|
|
return std::unique_ptr<ValueProfData>(new (::operator new(TotalSize))
|
|
|
|
ValueProfData());
|
|
|
|
}
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
Error ValueProfData::checkIntegrity() {
|
2015-11-28 12:56:07 +08:00
|
|
|
if (NumValueKinds > IPVK_Last + 1)
|
2016-05-19 11:54:45 +08:00
|
|
|
return make_error<InstrProfError>(instrprof_error::malformed);
|
2015-11-28 12:56:07 +08:00
|
|
|
// Total size needs to be mulltiple of quadword size.
|
|
|
|
if (TotalSize % sizeof(uint64_t))
|
2016-05-19 11:54:45 +08:00
|
|
|
return make_error<InstrProfError>(instrprof_error::malformed);
|
2015-11-28 12:56:07 +08:00
|
|
|
|
|
|
|
ValueProfRecord *VR = getFirstValueProfRecord(this);
|
|
|
|
for (uint32_t K = 0; K < this->NumValueKinds; K++) {
|
|
|
|
if (VR->Kind > IPVK_Last)
|
2016-05-19 11:54:45 +08:00
|
|
|
return make_error<InstrProfError>(instrprof_error::malformed);
|
2015-11-28 12:56:07 +08:00
|
|
|
VR = getValueProfRecordNext(VR);
|
|
|
|
if ((char *)VR - (char *)this > (ptrdiff_t)TotalSize)
|
2016-05-19 11:54:45 +08:00
|
|
|
return make_error<InstrProfError>(instrprof_error::malformed);
|
2015-11-28 12:56:07 +08:00
|
|
|
}
|
2016-05-19 11:54:45 +08:00
|
|
|
return Error::success();
|
2015-11-28 12:56:07 +08:00
|
|
|
}
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
Expected<std::unique_ptr<ValueProfData>>
|
2015-11-10 08:24:45 +08:00
|
|
|
ValueProfData::getValueProfData(const unsigned char *D,
|
|
|
|
const unsigned char *const BufferEnd,
|
|
|
|
support::endianness Endianness) {
|
|
|
|
using namespace support;
|
2017-03-03 09:07:34 +08:00
|
|
|
|
2015-11-10 08:24:45 +08:00
|
|
|
if (D + sizeof(ValueProfData) > BufferEnd)
|
2016-05-19 11:54:45 +08:00
|
|
|
return make_error<InstrProfError>(instrprof_error::truncated);
|
2015-11-10 08:24:45 +08:00
|
|
|
|
2015-11-17 11:47:21 +08:00
|
|
|
const unsigned char *Header = D;
|
|
|
|
uint32_t TotalSize = swapToHostOrder<uint32_t>(Header, Endianness);
|
2015-11-10 08:24:45 +08:00
|
|
|
if (D + TotalSize > BufferEnd)
|
2016-05-19 11:54:45 +08:00
|
|
|
return make_error<InstrProfError>(instrprof_error::too_large);
|
2015-11-10 08:24:45 +08:00
|
|
|
|
2015-11-25 14:23:38 +08:00
|
|
|
std::unique_ptr<ValueProfData> VPD = allocValueProfData(TotalSize);
|
2015-11-10 08:24:45 +08:00
|
|
|
memcpy(VPD.get(), D, TotalSize);
|
|
|
|
// Byte swap.
|
|
|
|
VPD->swapBytesToHost(Endianness);
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
Error E = VPD->checkIntegrity();
|
|
|
|
if (E)
|
|
|
|
return std::move(E);
|
2015-11-10 08:24:45 +08:00
|
|
|
|
|
|
|
return std::move(VPD);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ValueProfData::swapBytesToHost(support::endianness Endianness) {
|
|
|
|
using namespace support;
|
2017-03-03 09:07:34 +08:00
|
|
|
|
2015-11-10 08:24:45 +08:00
|
|
|
if (Endianness == getHostEndianness())
|
|
|
|
return;
|
|
|
|
|
|
|
|
sys::swapByteOrder<uint32_t>(TotalSize);
|
|
|
|
sys::swapByteOrder<uint32_t>(NumValueKinds);
|
|
|
|
|
2015-11-25 14:23:38 +08:00
|
|
|
ValueProfRecord *VR = getFirstValueProfRecord(this);
|
2015-11-10 08:24:45 +08:00
|
|
|
for (uint32_t K = 0; K < NumValueKinds; K++) {
|
|
|
|
VR->swapBytes(Endianness, getHostEndianness());
|
2015-11-25 12:29:24 +08:00
|
|
|
VR = getValueProfRecordNext(VR);
|
2015-11-10 08:24:45 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ValueProfData::swapBytesFromHost(support::endianness Endianness) {
|
|
|
|
using namespace support;
|
2017-03-03 09:07:34 +08:00
|
|
|
|
2015-11-10 08:24:45 +08:00
|
|
|
if (Endianness == getHostEndianness())
|
|
|
|
return;
|
|
|
|
|
2015-11-25 14:23:38 +08:00
|
|
|
ValueProfRecord *VR = getFirstValueProfRecord(this);
|
2015-11-10 08:24:45 +08:00
|
|
|
for (uint32_t K = 0; K < NumValueKinds; K++) {
|
2015-11-25 12:29:24 +08:00
|
|
|
ValueProfRecord *NVR = getValueProfRecordNext(VR);
|
2015-11-10 08:24:45 +08:00
|
|
|
VR->swapBytes(getHostEndianness(), Endianness);
|
|
|
|
VR = NVR;
|
|
|
|
}
|
|
|
|
sys::swapByteOrder<uint32_t>(TotalSize);
|
|
|
|
sys::swapByteOrder<uint32_t>(NumValueKinds);
|
|
|
|
}
|
2015-11-26 03:13:00 +08:00
|
|
|
|
2016-02-05 03:11:43 +08:00
|
|
|
void annotateValueSite(Module &M, Instruction &Inst,
|
|
|
|
const InstrProfRecord &InstrProfR,
|
2016-02-11 06:19:43 +08:00
|
|
|
InstrProfValueKind ValueKind, uint32_t SiteIdx,
|
|
|
|
uint32_t MaxMDCount) {
|
2016-02-05 03:11:43 +08:00
|
|
|
uint32_t NV = InstrProfR.getNumValueDataForSite(ValueKind, SiteIdx);
|
2016-04-15 00:25:45 +08:00
|
|
|
if (!NV)
|
|
|
|
return;
|
2016-02-05 03:11:43 +08:00
|
|
|
|
|
|
|
uint64_t Sum = 0;
|
|
|
|
std::unique_ptr<InstrProfValueData[]> VD =
|
|
|
|
InstrProfR.getValueForSite(ValueKind, SiteIdx, &Sum);
|
|
|
|
|
2016-03-31 00:56:31 +08:00
|
|
|
ArrayRef<InstrProfValueData> VDs(VD.get(), NV);
|
|
|
|
annotateValueSite(M, Inst, VDs, Sum, ValueKind, MaxMDCount);
|
2016-02-13 05:36:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void annotateValueSite(Module &M, Instruction &Inst,
|
2016-03-31 00:56:31 +08:00
|
|
|
ArrayRef<InstrProfValueData> VDs,
|
2016-02-13 05:36:17 +08:00
|
|
|
uint64_t Sum, InstrProfValueKind ValueKind,
|
|
|
|
uint32_t MaxMDCount) {
|
2016-02-05 03:11:43 +08:00
|
|
|
LLVMContext &Ctx = M.getContext();
|
|
|
|
MDBuilder MDHelper(Ctx);
|
|
|
|
SmallVector<Metadata *, 3> Vals;
|
|
|
|
// Tag
|
|
|
|
Vals.push_back(MDHelper.createString("VP"));
|
|
|
|
// Value Kind
|
|
|
|
Vals.push_back(MDHelper.createConstant(
|
|
|
|
ConstantInt::get(Type::getInt32Ty(Ctx), ValueKind)));
|
|
|
|
// Total Count
|
|
|
|
Vals.push_back(
|
|
|
|
MDHelper.createConstant(ConstantInt::get(Type::getInt64Ty(Ctx), Sum)));
|
|
|
|
|
|
|
|
// Value Profile Data
|
2016-02-11 06:19:43 +08:00
|
|
|
uint32_t MDCount = MaxMDCount;
|
2016-03-31 00:56:31 +08:00
|
|
|
for (auto &VD : VDs) {
|
2016-02-05 03:11:43 +08:00
|
|
|
Vals.push_back(MDHelper.createConstant(
|
2016-03-31 00:56:31 +08:00
|
|
|
ConstantInt::get(Type::getInt64Ty(Ctx), VD.Value)));
|
2016-02-05 03:11:43 +08:00
|
|
|
Vals.push_back(MDHelper.createConstant(
|
2016-03-31 00:56:31 +08:00
|
|
|
ConstantInt::get(Type::getInt64Ty(Ctx), VD.Count)));
|
2016-02-05 03:11:43 +08:00
|
|
|
if (--MDCount == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
Inst.setMetadata(LLVMContext::MD_prof, MDNode::get(Ctx, Vals));
|
|
|
|
}
|
|
|
|
|
|
|
|
bool getValueProfDataFromInst(const Instruction &Inst,
|
|
|
|
InstrProfValueKind ValueKind,
|
|
|
|
uint32_t MaxNumValueData,
|
|
|
|
InstrProfValueData ValueData[],
|
|
|
|
uint32_t &ActualNumValueData, uint64_t &TotalC) {
|
|
|
|
MDNode *MD = Inst.getMetadata(LLVMContext::MD_prof);
|
|
|
|
if (!MD)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned NOps = MD->getNumOperands();
|
|
|
|
|
|
|
|
if (NOps < 5)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Operand 0 is a string tag "VP":
|
|
|
|
MDString *Tag = cast<MDString>(MD->getOperand(0));
|
|
|
|
if (!Tag)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!Tag->getString().equals("VP"))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Now check kind:
|
|
|
|
ConstantInt *KindInt = mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
|
|
|
|
if (!KindInt)
|
|
|
|
return false;
|
|
|
|
if (KindInt->getZExtValue() != ValueKind)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Get total count
|
|
|
|
ConstantInt *TotalCInt = mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
|
|
|
|
if (!TotalCInt)
|
|
|
|
return false;
|
|
|
|
TotalC = TotalCInt->getZExtValue();
|
|
|
|
|
|
|
|
ActualNumValueData = 0;
|
|
|
|
|
|
|
|
for (unsigned I = 3; I < NOps; I += 2) {
|
|
|
|
if (ActualNumValueData >= MaxNumValueData)
|
|
|
|
break;
|
|
|
|
ConstantInt *Value = mdconst::dyn_extract<ConstantInt>(MD->getOperand(I));
|
|
|
|
ConstantInt *Count =
|
|
|
|
mdconst::dyn_extract<ConstantInt>(MD->getOperand(I + 1));
|
|
|
|
if (!Value || !Count)
|
|
|
|
return false;
|
|
|
|
ValueData[ActualNumValueData].Value = Value->getZExtValue();
|
|
|
|
ValueData[ActualNumValueData].Count = Count->getZExtValue();
|
|
|
|
ActualNumValueData++;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2016-04-02 00:43:30 +08:00
|
|
|
|
2016-04-02 04:15:04 +08:00
|
|
|
MDNode *getPGOFuncNameMetadata(const Function &F) {
|
|
|
|
return F.getMetadata(getPGOFuncNameMetadataName());
|
|
|
|
}
|
|
|
|
|
2016-05-29 18:31:00 +08:00
|
|
|
void createPGOFuncNameMetadata(Function &F, StringRef PGOFuncName) {
|
2016-04-23 05:00:17 +08:00
|
|
|
// Only for internal linkage functions.
|
|
|
|
if (PGOFuncName == F.getName())
|
|
|
|
return;
|
|
|
|
// Don't create duplicated meta-data.
|
|
|
|
if (getPGOFuncNameMetadata(F))
|
2016-04-02 00:43:30 +08:00
|
|
|
return;
|
|
|
|
LLVMContext &C = F.getContext();
|
2016-05-29 18:31:00 +08:00
|
|
|
MDNode *N = MDNode::get(C, MDString::get(C, PGOFuncName));
|
2016-04-02 00:43:30 +08:00
|
|
|
F.setMetadata(getPGOFuncNameMetadataName(), N);
|
|
|
|
}
|
|
|
|
|
2016-07-22 04:50:02 +08:00
|
|
|
bool needsComdatForCounter(const Function &F, const Module &M) {
|
|
|
|
if (F.hasComdat())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Triple TT(M.getTargetTriple());
|
2017-01-18 04:34:09 +08:00
|
|
|
if (!TT.isOSBinFormatELF() && !TT.isOSBinFormatWasm())
|
2016-07-22 04:50:02 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// See createPGOFuncNameVar for more details. To avoid link errors, profile
|
|
|
|
// counters for function with available_externally linkage needs to be changed
|
|
|
|
// to linkonce linkage. On ELF based systems, this leads to weak symbols to be
|
|
|
|
// created. Without using comdat, duplicate entries won't be removed by the
|
|
|
|
// linker leading to increased data segement size and raw profile size. Even
|
|
|
|
// worse, since the referenced counter from profile per-function data object
|
|
|
|
// will be resolved to the common strong definition, the profile counts for
|
|
|
|
// available_externally functions will end up being duplicated in raw profile
|
|
|
|
// data. This can result in distorted profile as the counts of those dups
|
|
|
|
// will be accumulated by the profile merger.
|
|
|
|
GlobalValue::LinkageTypes Linkage = F.getLinkage();
|
|
|
|
if (Linkage != GlobalValue::ExternalWeakLinkage &&
|
|
|
|
Linkage != GlobalValue::AvailableExternallyLinkage)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2017-01-12 04:19:41 +08:00
|
|
|
|
|
|
|
// Check if INSTR_PROF_RAW_VERSION_VAR is defined.
|
|
|
|
bool isIRPGOFlagSet(const Module *M) {
|
|
|
|
auto IRInstrVar =
|
|
|
|
M->getNamedGlobal(INSTR_PROF_QUOTE(INSTR_PROF_RAW_VERSION_VAR));
|
|
|
|
if (!IRInstrVar || IRInstrVar->isDeclaration() ||
|
|
|
|
IRInstrVar->hasLocalLinkage())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check if the flag is set.
|
|
|
|
if (!IRInstrVar->hasInitializer())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const Constant *InitVal = IRInstrVar->getInitializer();
|
|
|
|
if (!InitVal)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return (dyn_cast<ConstantInt>(InitVal)->getZExtValue() &
|
|
|
|
VARIANT_MASK_IR_PROF) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if we can safely rename this Comdat function.
|
|
|
|
bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken) {
|
|
|
|
if (F.getName().empty())
|
|
|
|
return false;
|
|
|
|
if (!needsComdatForCounter(F, *(F.getParent())))
|
|
|
|
return false;
|
|
|
|
// Unsafe to rename the address-taken function (which can be used in
|
|
|
|
// function comparison).
|
|
|
|
if (CheckAddressTaken && F.hasAddressTaken())
|
|
|
|
return false;
|
|
|
|
// Only safe to do if this function may be discarded if it is not used
|
|
|
|
// in the compilation unit.
|
|
|
|
if (!GlobalValue::isDiscardableIfUnused(F.getLinkage()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// For AvailableExternallyLinkage functions.
|
|
|
|
if (!F.hasComdat()) {
|
|
|
|
assert(F.getLinkage() == GlobalValue::AvailableExternallyLinkage);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2017-03-03 09:07:34 +08:00
|
|
|
|
2016-01-27 02:48:36 +08:00
|
|
|
} // end namespace llvm
|