1 //===--- XRayArgs.cpp - Arguments for XRay --------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 #include "clang/Driver/XRayArgs.h"
9 #include "ToolChains/CommonArgs.h"
10 #include "clang/Driver/Driver.h"
11 #include "clang/Driver/DriverDiagnostic.h"
12 #include "clang/Driver/Options.h"
13 #include "clang/Driver/ToolChain.h"
14 #include "llvm/ADT/StringExtras.h"
15 #include "llvm/ADT/StringSwitch.h"
16 #include "llvm/Support/Path.h"
17 #include "llvm/Support/ScopedPrinter.h"
18 #include "llvm/Support/SpecialCaseList.h"
19 #include "llvm/Support/VirtualFileSystem.h"
20 
21 using namespace clang;
22 using namespace clang::driver;
23 using namespace llvm::opt;
24 
25 namespace {
26 constexpr char XRayInstrumentOption[] = "-fxray-instrument";
27 constexpr char XRayInstructionThresholdOption[] =
28     "-fxray-instruction-threshold=";
29 constexpr const char *const XRaySupportedModes[] = {"xray-fdr", "xray-basic"};
30 } // namespace
31 
32 XRayArgs::XRayArgs(const ToolChain &TC, const ArgList &Args) {
33   const Driver &D = TC.getDriver();
34   const llvm::Triple &Triple = TC.getTriple();
35   if (!Args.hasFlag(options::OPT_fxray_instrument,
36                     options::OPT_fno_xray_instrument, false))
37     return;
38   if (Triple.getOS() == llvm::Triple::Linux) {
39     switch (Triple.getArch()) {
40     case llvm::Triple::x86_64:
41     case llvm::Triple::arm:
42     case llvm::Triple::aarch64:
43     case llvm::Triple::ppc64le:
44     case llvm::Triple::mips:
45     case llvm::Triple::mipsel:
46     case llvm::Triple::mips64:
47     case llvm::Triple::mips64el:
48       break;
49     default:
50       D.Diag(diag::err_drv_clang_unsupported)
51           << (std::string(XRayInstrumentOption) + " on " + Triple.str());
52     }
53   } else if (Triple.isOSFreeBSD() || Triple.isOSOpenBSD() ||
54              Triple.isOSNetBSD() || Triple.isMacOSX()) {
55     if (Triple.getArch() != llvm::Triple::x86_64) {
56       D.Diag(diag::err_drv_clang_unsupported)
57           << (std::string(XRayInstrumentOption) + " on " + Triple.str());
58     }
59   } else if (Triple.getOS() == llvm::Triple::Fuchsia) {
60     switch (Triple.getArch()) {
61     case llvm::Triple::x86_64:
62     case llvm::Triple::aarch64:
63       break;
64     default:
65       D.Diag(diag::err_drv_clang_unsupported)
66           << (std::string(XRayInstrumentOption) + " on " + Triple.str());
67     }
68   } else {
69     D.Diag(diag::err_drv_clang_unsupported)
70         << (std::string(XRayInstrumentOption) + " on " + Triple.str());
71   }
72 
73   // Both XRay and -fpatchable-function-entry use
74   // TargetOpcode::PATCHABLE_FUNCTION_ENTER.
75   if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ))
76     D.Diag(diag::err_drv_argument_not_allowed_with)
77         << "-fxray-instrument" << A->getSpelling();
78 
79   XRayInstrument = true;
80   if (const Arg *A =
81           Args.getLastArg(options::OPT_fxray_instruction_threshold_,
82                           options::OPT_fxray_instruction_threshold_EQ)) {
83     StringRef S = A->getValue();
84     if (S.getAsInteger(0, InstructionThreshold) || InstructionThreshold < 0)
85       D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
86   }
87 
88   // By default, the back-end will not emit the lowering for XRay customevent
89   // calls if the function is not instrumented. In the future we will change
90   // this default to be the reverse, but in the meantime we're going to
91   // introduce the new functionality behind a flag.
92   if (Args.hasFlag(options::OPT_fxray_always_emit_customevents,
93                    options::OPT_fno_xray_always_emit_customevents, false))
94     XRayAlwaysEmitCustomEvents = true;
95 
96   if (Args.hasFlag(options::OPT_fxray_always_emit_typedevents,
97                    options::OPT_fno_xray_always_emit_typedevents, false))
98     XRayAlwaysEmitTypedEvents = true;
99 
100   if (!Args.hasFlag(options::OPT_fxray_link_deps,
101                     options::OPT_fnoxray_link_deps, true))
102     XRayRT = false;
103 
104   if (Args.hasFlag(options::OPT_fxray_ignore_loops,
105                    options::OPT_fno_xray_ignore_loops, false))
106     XRayIgnoreLoops = true;
107 
108   XRayFunctionIndex = Args.hasFlag(options::OPT_fxray_function_index,
109                                    options::OPT_fno_xray_function_index, true);
110 
111   auto Bundles =
112       Args.getAllArgValues(options::OPT_fxray_instrumentation_bundle);
113   if (Bundles.empty())
114     InstrumentationBundle.Mask = XRayInstrKind::All;
115   else
116     for (const auto &B : Bundles) {
117       llvm::SmallVector<StringRef, 2> BundleParts;
118       llvm::SplitString(B, BundleParts, ",");
119       for (const auto &P : BundleParts) {
120         // TODO: Automate the generation of the string case table.
121         auto Valid = llvm::StringSwitch<bool>(P)
122                          .Cases("none", "all", "function", "function-entry",
123                                 "function-exit", "custom", true)
124                          .Default(false);
125 
126         if (!Valid) {
127           D.Diag(clang::diag::err_drv_invalid_value)
128               << "-fxray-instrumentation-bundle=" << P;
129           continue;
130         }
131 
132         auto Mask = parseXRayInstrValue(P);
133         if (Mask == XRayInstrKind::None) {
134           InstrumentationBundle.clear();
135           break;
136         }
137 
138         InstrumentationBundle.Mask |= Mask;
139       }
140     }
141 
142   // Validate the always/never attribute files. We also make sure that they
143   // are treated as actual dependencies.
144   for (const auto &Filename :
145        Args.getAllArgValues(options::OPT_fxray_always_instrument)) {
146     if (D.getVFS().exists(Filename)) {
147       AlwaysInstrumentFiles.push_back(Filename);
148       ExtraDeps.push_back(Filename);
149     } else
150       D.Diag(clang::diag::err_drv_no_such_file) << Filename;
151   }
152 
153   for (const auto &Filename :
154        Args.getAllArgValues(options::OPT_fxray_never_instrument)) {
155     if (D.getVFS().exists(Filename)) {
156       NeverInstrumentFiles.push_back(Filename);
157       ExtraDeps.push_back(Filename);
158     } else
159       D.Diag(clang::diag::err_drv_no_such_file) << Filename;
160   }
161 
162   for (const auto &Filename :
163        Args.getAllArgValues(options::OPT_fxray_attr_list)) {
164     if (D.getVFS().exists(Filename)) {
165       AttrListFiles.push_back(Filename);
166       ExtraDeps.push_back(Filename);
167     } else
168       D.Diag(clang::diag::err_drv_no_such_file) << Filename;
169   }
170 
171   // Get the list of modes we want to support.
172   auto SpecifiedModes = Args.getAllArgValues(options::OPT_fxray_modes);
173   if (SpecifiedModes.empty())
174     llvm::copy(XRaySupportedModes, std::back_inserter(Modes));
175   else
176     for (const auto &Arg : SpecifiedModes) {
177       // Parse CSV values for -fxray-modes=...
178       llvm::SmallVector<StringRef, 2> ModeParts;
179       llvm::SplitString(Arg, ModeParts, ",");
180       for (const auto &M : ModeParts)
181         if (M == "none")
182           Modes.clear();
183         else if (M == "all")
184           llvm::copy(XRaySupportedModes, std::back_inserter(Modes));
185         else
186           Modes.push_back(std::string(M));
187     }
188 
189   // Then we want to sort and unique the modes we've collected.
190   llvm::sort(Modes);
191   Modes.erase(std::unique(Modes.begin(), Modes.end()), Modes.end());
192 }
193 
194 void XRayArgs::addArgs(const ToolChain &TC, const ArgList &Args,
195                        ArgStringList &CmdArgs, types::ID InputType) const {
196   if (!XRayInstrument)
197     return;
198 
199   CmdArgs.push_back(XRayInstrumentOption);
200 
201   if (XRayAlwaysEmitCustomEvents)
202     CmdArgs.push_back("-fxray-always-emit-customevents");
203 
204   if (XRayAlwaysEmitTypedEvents)
205     CmdArgs.push_back("-fxray-always-emit-typedevents");
206 
207   if (XRayIgnoreLoops)
208     CmdArgs.push_back("-fxray-ignore-loops");
209 
210   if (!XRayFunctionIndex)
211     CmdArgs.push_back("-fno-xray-function-index");
212 
213   CmdArgs.push_back(Args.MakeArgString(Twine(XRayInstructionThresholdOption) +
214                                        Twine(InstructionThreshold)));
215 
216   for (const auto &Always : AlwaysInstrumentFiles) {
217     SmallString<64> AlwaysInstrumentOpt("-fxray-always-instrument=");
218     AlwaysInstrumentOpt += Always;
219     CmdArgs.push_back(Args.MakeArgString(AlwaysInstrumentOpt));
220   }
221 
222   for (const auto &Never : NeverInstrumentFiles) {
223     SmallString<64> NeverInstrumentOpt("-fxray-never-instrument=");
224     NeverInstrumentOpt += Never;
225     CmdArgs.push_back(Args.MakeArgString(NeverInstrumentOpt));
226   }
227 
228   for (const auto &AttrFile : AttrListFiles) {
229     SmallString<64> AttrListFileOpt("-fxray-attr-list=");
230     AttrListFileOpt += AttrFile;
231     CmdArgs.push_back(Args.MakeArgString(AttrListFileOpt));
232   }
233 
234   for (const auto &Dep : ExtraDeps) {
235     SmallString<64> ExtraDepOpt("-fdepfile-entry=");
236     ExtraDepOpt += Dep;
237     CmdArgs.push_back(Args.MakeArgString(ExtraDepOpt));
238   }
239 
240   for (const auto &Mode : Modes) {
241     SmallString<64> ModeOpt("-fxray-modes=");
242     ModeOpt += Mode;
243     CmdArgs.push_back(Args.MakeArgString(ModeOpt));
244   }
245 
246   SmallString<64> Bundle("-fxray-instrumentation-bundle=");
247   if (InstrumentationBundle.full()) {
248     Bundle += "all";
249   } else if (InstrumentationBundle.empty()) {
250     Bundle += "none";
251   } else {
252     if (InstrumentationBundle.has(XRayInstrKind::FunctionEntry) &&
253         InstrumentationBundle.has(XRayInstrKind::FunctionExit))
254       Bundle += "function";
255     else if (InstrumentationBundle.has(XRayInstrKind::FunctionEntry))
256       Bundle += "function-entry";
257     else if (InstrumentationBundle.has(XRayInstrKind::FunctionExit))
258       Bundle += "function-exit";
259 
260     if (InstrumentationBundle.has(XRayInstrKind::Custom))
261       Bundle += "custom";
262     if (InstrumentationBundle.has(XRayInstrKind::Typed))
263       Bundle += "typed";
264   }
265   CmdArgs.push_back(Args.MakeArgString(Bundle));
266 }
267