clang: lib/Driver/ToolChains/OHOS.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
12#include "clang/Config/config.h"
18#include "llvm/Option/ArgList.h"
19#include "llvm/ProfileData/InstrProf.h"
20#include "llvm/Support/FileSystem.h"
21#include "llvm/Support/Path.h"
22#include "llvm/Support/VirtualFileSystem.h"
23#include "llvm/Support/ScopedPrinter.h"
24
28using namespace clang;
31
34
40
41
42
44 Multilib("/a7_soft", {}, {}, {"-mcpu=cortex-a7", "-mfloat-abi=soft"}));
45
47 Multilib("/a7_softfp_neon-vfpv4", {}, {},
48 {"-mcpu=cortex-a7", "-mfloat-abi=softfp", "-mfpu=neon-vfpv4"}));
49
51 Multilib("/a7_hard_neon-vfpv4", {}, {},
52 {"-mcpu=cortex-a7", "-mfloat-abi=hard", "-mfpu=neon-vfpv4"}));
53
54 if (Multilibs.select(D, Flags, Result.SelectedMultilibs)) {
55 Result.Multilibs = Multilibs;
56 return true;
57 }
58 return false;
59}
60
63 const llvm::Triple &TargetTriple,
64 StringRef Path, const ArgList &Args,
67 bool IsA7 = false;
68 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
69 IsA7 = A->getValue() == StringRef("cortex-a7");
71
72 bool IsMFPU = false;
73 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
74 IsMFPU = A->getValue() == StringRef("neon-vfpv4");
76
78 addMultilibFlag((ARMFloatABI == tools::arm::FloatABI::Soft),
79 "-mfloat-abi=soft", Flags);
80 addMultilibFlag((ARMFloatABI == tools::arm::FloatABI::SoftFP),
81 "-mfloat-abi=softfp", Flags);
82 addMultilibFlag((ARMFloatABI == tools::arm::FloatABI::Hard),
83 "-mfloat-abi=hard", Flags);
84
86}
87
89
90
91 switch (T.getArch()) {
92 default:
93 break;
94
95
96
97
98
99 case llvm::Triple::arm:
100 case llvm::Triple::thumb:
101 return T.isOSLiteOS() ? "arm-liteos-ohos" : "arm-linux-ohos";
102 case llvm::Triple::riscv32:
103 return "riscv32-linux-ohos";
104 case llvm::Triple::riscv64:
105 return "riscv64-linux-ohos";
106 case llvm::Triple::mipsel:
107 return "mipsel-linux-ohos";
108 case llvm::Triple::x86:
109 return "i686-linux-ohos";
110 case llvm::Triple::x86_64:
111 return "x86_64-linux-ohos";
112 case llvm::Triple::aarch64:
113 return "aarch64-linux-ohos";
114 }
115 return T.str();
116}
117
119 const llvm::Triple &TargetTriple,
120 StringRef SysRoot) const {
122}
123
124static std::string makePath(const std::initializer_liststd::string &IL) {
126 for (const auto &S : IL)
127 llvm::sys::path::append(P, S);
128 return static_caststd::string\(P.str());
129}
130
131
135
136
143 }
144
147 if (getVFS().exists(CandidateLibPath))
149
154
155
156
157
158
160 std::string SysRootLibPath = makePath({SysRoot, "usr", "lib"});
163 Paths);
165 makePath({D.Dir, "..", "lib", MultiarchTriple,
167 Paths);
168
170 D,
171 makePath({SysRootLibPath, MultiarchTriple, SelectedMultilib.gccSuffix()}),
172 Paths);
173}
174
176 const ArgList &Args) const {
177 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_rtlib_EQ)) {
178 StringRef Value = A->getValue();
179 if (Value != "compiler-rt")
180 getDriver().Diag(clang::diag::err_drv_invalid_rtlib_name)
181 << A->getAsString(Args);
182 }
183
185}
186
189 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
190 StringRef Value = A->getValue();
191 if (Value != "libc++")
192 getDriver().Diag(diag::err_drv_invalid_stdlib_name)
193 << A->getAsString(Args);
194 }
195
197}
198
200 ArgStringList &CC1Args) const {
202 const llvm::Triple &Triple = getTriple();
204
205 if (DriverArgs.hasArg(options::OPT_nostdinc))
206 return;
207
208 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
210 llvm::sys::path::append(P, "include");
212 }
213
214 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
215 return;
216
217
218 StringRef CIncludeDirs(C_INCLUDE_DIRS);
219 if (CIncludeDirs != "") {
221 CIncludeDirs.split(dirs, ":");
222 for (StringRef dir : dirs) {
223 StringRef Prefix =
224 llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) : "";
226 }
227 return;
228 }
229
231 SysRoot + "/usr/include/" +
235}
236
238 ArgStringList &CC1Args) const {
239 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
240 DriverArgs.hasArg(options::OPT_nostdincxx))
241 return;
242
246 std::string IncTargetPath =
248 if (getVFS().exists(IncTargetPath)) {
251 }
252 break;
253 }
254
255 default:
256 llvm_unreachable("invalid stdlib name");
257 }
258}
259
261 ArgStringList &CmdArgs) const {
264 CmdArgs.push_back("-lc++");
265 CmdArgs.push_back("-lc++abi");
266 CmdArgs.push_back("-lunwind");
267 break;
268
270 llvm_unreachable("invalid stdlib name");
271 }
272}
273
275 std::string SysRoot =
279 if (!llvm::sys::fs::exists(SysRoot))
280 return std::string();
281
283 return llvm::sys::fs::exists(ArchRoot) ? ArchRoot : SysRoot;
284}
285
290 const llvm::Triple &Triple = getTriple();
291
292
294 llvm::sys::path::append(P, "lib", D.getTargetTriple(), SelectedMultilib.gccSuffix());
295 Paths.push_back(P.c_str());
296
297
299 llvm::sys::path::append(P, "lib", Triple.str(), SelectedMultilib.gccSuffix());
300 Paths.push_back(P.c_str());
301
302
307 Paths.push_back(P.c_str());
308
309 return Paths;
310}
311
313 const llvm::Triple &Triple = getTriple();
314 const llvm::Triple::ArchType Arch = getArch();
315
316 assert(Triple.isMusl());
317 std::string ArchName;
318 bool IsArm = false;
319
320 switch (Arch) {
321 case llvm::Triple::arm:
322 case llvm::Triple::thumb:
323 ArchName = "arm";
324 IsArm = true;
325 break;
326 case llvm::Triple::armeb:
327 case llvm::Triple::thumbeb:
328 ArchName = "armeb";
329 IsArm = true;
330 break;
331 default:
332 ArchName = Triple.getArchName().str();
333 }
334 if (IsArm &&
336 ArchName += "hf";
337
338 return "/lib/ld-musl-" + ArchName + ".so.1";
339}
340
346 const char *Prefix =
348 const char *Suffix;
349 switch (Type) {
351 Suffix = ".o";
352 break;
354 Suffix = ".a";
355 break;
357 Suffix = ".so";
358 break;
359 }
360 llvm::sys::path::append(
361 Path, Prefix + Twine("clang_rt.") + Component + Suffix);
362 return static_caststd::string\(Path.str());
363}
364
366 CmdArgs.push_back("-z");
367 CmdArgs.push_back("now");
368 CmdArgs.push_back("-z");
369 CmdArgs.push_back("relro");
370 CmdArgs.push_back("-z");
371 CmdArgs.push_back("max-page-size=4096");
372
373 if (getArch() != llvm::Triple::mipsel)
374 CmdArgs.push_back("--hash-style=both");
375#ifdef ENABLE_LINKER_BUILD_ID
376 CmdArgs.push_back("--build-id");
377#endif
378 CmdArgs.push_back("--enable-new-dtags");
379}
380
383 Res |= SanitizerKind::Address;
384 Res |= SanitizerKind::PointerCompare;
385 Res |= SanitizerKind::PointerSubtract;
386 Res |= SanitizerKind::Fuzzer;
387 Res |= SanitizerKind::FuzzerNoLink;
388 Res |= SanitizerKind::Memory;
389 Res |= SanitizerKind::Vptr;
390 Res |= SanitizerKind::SafeStack;
391 Res |= SanitizerKind::Scudo;
392
393
394 return Res;
395}
396
397
399 llvm::opt::ArgStringList &CmdArgs) const {
400
401
403 CmdArgs.push_back(Args.MakeArgString(
404 Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
406}
407
410 llvm::Triple Triple = getTriple();
411 Paths.push_back(
413 return Paths;
414}
415
417 if (Args.getLastArg(options::OPT_unwindlib_EQ))
420}
static bool findOHOSMuslMultilibs(const Driver &D, const Multilib::flags_list &Flags, DetectedMultilibs &Result)
static std::string makePath(const std::initializer_list< std::string > &IL)
static bool findOHOSMultilibs(const Driver &D, const ToolChain &TC, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
The base class of the type hierarchy.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
std::string SysRoot
sysroot, if present
DiagnosticBuilder Diag(unsigned DiagID) const
std::string ResourceDir
The path to the compiler resource directory.
std::string Dir
The path the driver executable was in, as invoked from the command line.
See also MultilibSetBuilder for combining multilibs into a set.
bool select(const Driver &D, const Multilib::flags_list &Flags, llvm::SmallVectorImpl< Multilib > &, llvm::SmallVector< StringRef > *=nullptr) const
Select compatible variants,.
void push_back(const Multilib &M)
Add a completed Multilib to the set.
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
std::vector< std::string > flags_list
The JSON file list parser is used to communicate input to InstallAPI.
@ Result
The result type of a method or function.
const FunctionProtoType * T