dnrops
/
clang
mirror of https://github.com/microsoft/clang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[XRay][llvm+clang] Consolidate attribute list files 

Summary:
This change consolidates the always/never lists that may be provided to
clang to externally control which functions should be XRay instrumented
by imbuing attributes. The files follow the same format as defined in
https://clang.llvm.org/docs/SanitizerSpecialCaseList.html for the
sanitizer blacklist.

We also deprecate the existing `-fxray-instrument-always=` and
`-fxray-instrument-never=` flags, in favour of `-fxray-attr-list=`.

This fixes http://llvm.org/PR34721.

Reviewers: echristo, vlad.tsyrklevich, eugenis

Reviewed By: vlad.tsyrklevich

Subscribers: llvm-commits, cfe-commits

Differential Revision: https://reviews.llvm.org/D45357

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@329543 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dean Michael Berris 2018-04-09 04:02:09 +00:00
parent f1010cd2b0
commit 46f5ec2ba7
12 changed files with 111 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/clang/Basic/LangOptions.h
View File

@ -148,13 +148,20 @@ public:
/// \brief Paths to the XRay "always instrument" files specifying which
/// objects (files, functions, variables) should be imbued with the XRay
/// "always instrument" attribute.
/// WARNING: This is a deprecated field and will go away in the future.
std::vector<std::string> XRayAlwaysInstrumentFiles;
/// \brief Paths to the XRay "never instrument" files specifying which
/// objects (files, functions, variables) should be imbued with the XRay
/// "never instrument" attribute.
/// WARNING: This is a deprecated field and will go away in the future.
std::vector<std::string> XRayNeverInstrumentFiles;
/// \brief Paths to the XRay attribute list files, specifying which objects
/// (files, functions, variables) should be imbued with the appropriate XRay
/// attribute(s).
std::vector<std::string> XRayAttrListFiles;
clang::ObjCRuntime ObjCRuntime;
std::string ObjCConstantStringClass;

3
include/clang/Basic/XRayLists.h
View File

@ -26,12 +26,13 @@ namespace clang {
class XRayFunctionFilter {
std::unique_ptr<llvm::SpecialCaseList> AlwaysInstrument;
std::unique_ptr<llvm::SpecialCaseList> NeverInstrument;
std::unique_ptr<llvm::SpecialCaseList> AttrList;
SourceManager &SM;
public:
XRayFunctionFilter(ArrayRef<std::string> AlwaysInstrumentPaths,
ArrayRef<std::string> NeverInstrumentPaths,
SourceManager &SM);
ArrayRef<std::string> AttrListPaths, SourceManager &SM);
enum class ImbueAttribute {
NONE,

8
include/clang/Driver/Options.td
View File

@ -1095,11 +1095,15 @@ def fxray_instruction_threshold_ :
def fxray_always_instrument :
JoinedOrSeparate<["-"], "fxray-always-instrument=">,
Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.">;
HelpText<"DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.">;
def fxray_never_instrument :
JoinedOrSeparate<["-"], "fxray-never-instrument=">,
Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.">;
HelpText<"DEPRECATED: Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.">;
def fxray_attr_list :
JoinedOrSeparate<["-"], "fxray-attr-list=">,
Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Filename defining the list of functions/types for imbuing XRay attributes.">;
def fxray_always_emit_customevents : Flag<["-"], "fxray-always-emit-customevents">, Group<f_Group>,
Flags<[CC1Option]>,

1
include/clang/Driver/XRayArgs.h
View File

@ -21,6 +21,7 @@ class ToolChain;
class XRayArgs {
std::vector<std::string> AlwaysInstrumentFiles;
std::vector<std::string> NeverInstrumentFiles;
std::vector<std::string> AttrListFiles;
std::vector<std::string> ExtraDeps;
bool XRayInstrument = false;
int InstructionThreshold = 200;

3
lib/AST/ASTContext.cpp
View File

@ -788,7 +788,8 @@ ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,
SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts),
SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
LangOpts.XRayNeverInstrumentFiles, SM)),
LangOpts.XRayNeverInstrumentFiles,
LangOpts.XRayAttrListFiles, SM)),
PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
CommentCommandTraits(BumpAlloc, LOpts.CommentOpts), LastSDM(nullptr, 0) {

24
lib/Basic/XRayLists.cpp
View File

@ -16,24 +16,32 @@ using namespace clang;
XRayFunctionFilter::XRayFunctionFilter(
ArrayRef<std::string> AlwaysInstrumentPaths,
ArrayRef<std::string> NeverInstrumentPaths, SourceManager &SM)
ArrayRef<std::string> NeverInstrumentPaths,
ArrayRef<std::string> AttrListPaths, SourceManager &SM)
: AlwaysInstrument(
llvm::SpecialCaseList::createOrDie(AlwaysInstrumentPaths)),
NeverInstrument(llvm::SpecialCaseList::createOrDie(NeverInstrumentPaths)),
SM(SM) {}
AttrList(llvm::SpecialCaseList::createOrDie(AttrListPaths)), SM(SM) {}
XRayFunctionFilter::ImbueAttribute
XRayFunctionFilter::shouldImbueFunction(StringRef FunctionName) const {
// First apply the always instrument list, than if it isn't an "always" see
// whether it's treated as a "never" instrument function.
// TODO: Remove these as they're deprecated; use the AttrList exclusively.
if (AlwaysInstrument->inSection("xray_always_instrument", "fun", FunctionName,
"arg1"))
"arg1") ||
AttrList->inSection("always", "fun", FunctionName, "arg1"))
return ImbueAttribute::ALWAYS_ARG1;
if (AlwaysInstrument->inSection("xray_always_instrument", "fun",
FunctionName))
FunctionName) ||
AttrList->inSection("always", "fun", FunctionName))
return ImbueAttribute::ALWAYS;
if (NeverInstrument->inSection("xray_never_instrument", "fun", FunctionName))
if (NeverInstrument->inSection("xray_never_instrument", "fun",
FunctionName) ||
AttrList->inSection("never", "fun", FunctionName))
return ImbueAttribute::NEVER;
return ImbueAttribute::NONE;
}
@ -41,10 +49,12 @@ XRayFunctionFilter::ImbueAttribute
XRayFunctionFilter::shouldImbueFunctionsInFile(StringRef Filename,
StringRef Category) const {
if (AlwaysInstrument->inSection("xray_always_instrument", "src", Filename,
Category))
Category) ||
AttrList->inSection("always", "src", Filename, Category))
return ImbueAttribute::ALWAYS;
if (NeverInstrument->inSection("xray_never_instrument", "src", Filename,
Category))
Category) ||
AttrList->inSection("never", "src", Filename, Category))
return ImbueAttribute::NEVER;
return ImbueAttribute::NONE;
}

15
lib/Driver/XRayArgs.cpp
View File

@ -99,6 +99,15 @@ XRayArgs::XRayArgs(const ToolChain &TC, const ArgList &Args) {
} else
D.Diag(clang::diag::err_drv_no_such_file) << Filename;
}
for (const auto &Filename :
Args.getAllArgValues(options::OPT_fxray_attr_list)) {
if (llvm::sys::fs::exists(Filename)) {
AttrListFiles.push_back(Filename);
ExtraDeps.push_back(Filename);
} else
D.Diag(clang::diag::err_drv_no_such_file) << Filename;
}
}
}
@ -127,6 +136,12 @@ void XRayArgs::addArgs(const ToolChain &TC, const ArgList &Args,
CmdArgs.push_back(Args.MakeArgString(NeverInstrumentOpt));
}
for (const auto&AttrFile : AttrListFiles) {
SmallString<64> AttrListFileOpt("-fxray-attr-list=");
AttrListFileOpt += AttrFile;
CmdArgs.push_back(Args.MakeArgString(AttrListFileOpt));
}
for (const auto &Dep : ExtraDeps) {
SmallString<64> ExtraDepOpt("-fdepfile-entry=");
ExtraDepOpt += Dep;

1
lib/Frontend/CompilerInvocation.cpp
View File

@ -2640,6 +2640,7 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
Args.getAllArgValues(OPT_fxray_always_instrument);
Opts.XRayNeverInstrumentFiles =
Args.getAllArgValues(OPT_fxray_never_instrument);
Opts.XRayAttrListFiles = Args.getAllArgValues(OPT_fxray_attr_list);
// -fallow-editor-placeholders
Opts.AllowEditorPlaceholders = Args.hasArg(OPT_fallow_editor_placeholders);

10
test/CodeGen/xray-always-instrument.cpp
View File

@ -1,6 +1,14 @@
// RUN: echo "fun:*foo*" > %t.always-instrument
// RUN: echo "src:*xray-always-instrument.cpp" >> %t.always-instrument
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 -fxray-always-instrument=%t.always-instrument -emit-llvm -o - %s -triple x86_64-unknown-linux-gnu | FileCheck %s
// RUN: echo "[always]" > %t.xray-attrlist
// RUN: echo "fun:*foo*" >> %t.xray-attrlist
// RUN: echo "src:*xray-always-instrument.cpp" >> %t.xray-attrlist
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 \
// RUN: -fxray-always-instrument=%t.always-instrument -emit-llvm -o - %s \
// RUN: -triple x86_64-unknown-linux-gnu | FileCheck %s
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 \
// RUN: -fxray-attr-list=%t.xray-attrlist -emit-llvm -o - %s \
// RUN: -triple x86_64-unknown-linux-gnu | FileCheck %s
void foo() {}

19
test/CodeGen/xray-attr-list.cpp Normal file
View File

@ -0,0 +1,19 @@
// RUN: echo "[always]" > %t.xray-attrlist
// RUN: echo "fun:*always*" >> %t.xray-attrlist
// RUN: echo "[never]" >> %t.xray-attrlist
// RUN: echo "fun:*never*" >> %t.xray-attrlist
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 \
// RUN: -fxray-attr-list=%t.xray-attrlist -emit-llvm -o - %s \
// RUN: -triple x86_64-unknown-linux-gnu | FileCheck %s
void always() {}
void never() {}
[[clang::xray_never_instrument]] void alwaysNever() {}
[[clang::xray_always_instrument]] void neverAlways() {}
// CHECK: define void @_Z6alwaysv() #[[ALWAYSATTR:[0-9]+]] {
// CHECK: define void @_Z5neverv() #[[NEVERATTR:[0-9]+]] {
// CHECK: define void @_Z11alwaysNeverv() #[[NEVERATTR]] {
// CHECK: define void @_Z11neverAlwaysv() #[[ALWAYSATTR]] {
// CHECK: attributes #[[ALWAYSATTR]] = {{.*}} "function-instrument"="xray-always" {{.*}}
// CHECK: attributes #[[NEVERATTR]] = {{.*}} "function-instrument"="xray-never" {{.*}}

9
test/CodeGen/xray-imbue-arg1.cpp
View File

@ -1,5 +1,12 @@
// RUN: echo "fun:*arg1*=arg1" >> %t.always-instrument
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 -fxray-always-instrument=%t.always-instrument -emit-llvm -o - %s -triple x86_64-unknown-linux-gnu | FileCheck %s
// RUN: echo "[always]" > %t.xray-attrlist
// RUN: echo "fun:*arg1*=arg1" >> %t.xray-attrlist
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 \
// RUN: -fxray-always-instrument=%t.always-instrument -emit-llvm -o - %s \
// RUN: -triple x86_64-unknown-linux-gnu | FileCheck %s
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 \
// RUN: -fxray-attr-list=%t.xray-attrlist -emit-llvm -o - %s \
// RUN: -triple x86_64-unknown-linux-gnu | FileCheck %s
void foo() {}

24
test/CodeGen/xray-never-instrument.cpp Normal file
View File

@ -0,0 +1,24 @@
// RUN: echo "fun:*foo*" > %t.never-instrument
// RUN: echo "src:*xray-never-instrument.cpp" >> %t.never-instrument
// RUN: echo "[never]" > %t.xray-attrlist
// RUN: echo "fun:*foo*" >> %t.xray-attrlist
// RUN: echo "src:*xray-never-instrument.cpp" >> %t.xray-attrlist
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 \
// RUN: -fxray-never-instrument=%t.never-instrument -emit-llvm -o - %s \
// RUN: -triple x86_64-unknown-linux-gnu | FileCheck %s
// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 \
// RUN: -fxray-attr-list=%t.xray-attrlist -emit-llvm -o - %s \
// RUN: -triple x86_64-unknown-linux-gnu | FileCheck %s
void foo() {}
[[clang::xray_always_instrument]] void bar() {}
void baz() {}
// CHECK: define void @_Z3foov() #[[NEVERATTR:[0-9]+]] {
// CHECK: define void @_Z3barv() #[[ALWAYSATTR:[0-9]+]] {
// CHECK: define void @_Z3bazv() #[[NEVERATTR:[0-9]+]] {
// CHECK: attributes #[[NEVERATTR]] = {{.*}} "function-instrument"="xray-never" {{.*}}
// CHECK: attributes #[[ALWAYSATTR]] = {{.*}} "function-instrument"="xray-always" {{.*}}