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