RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/BareMetal_8cpp_source.html below:

clang: lib/Driver/ToolChains/BareMetal.cpp Source File

22#include "llvm/ADT/StringExtras.h" 23#include "llvm/Option/ArgList.h" 24#include "llvm/Support/Path.h" 25#include "llvm/Support/VirtualFileSystem.h" 26#include "llvm/Support/raw_ostream.h" 31using namespace clang

;

37 const

llvm::Triple &TargetTriple,

43 if

(TargetTriple.isRISCV64()) {

47

flag

(

"-march=rv64imafdc"

)

48

flag

(

"-mabi=lp64d"

);

52

(Arch ==

"rv64imafdc"

) || (Arch ==

"rv64gc"

);

61 return

Result.Multilibs.select(

, Flags, Result.SelectedMultilibs);

63 if

(TargetTriple.isRISCV32()) {

67

flag

(

"-march=rv32i"

)

68

flag

(

"-mabi=ilp32"

);

70

flag

(

"-march=rv32im"

)

71

flag

(

"-mabi=ilp32"

);

73

flag

(

"-march=rv32iac"

)

74

flag

(

"-mabi=ilp32"

);

76

flag

(

"-march=rv32imafc"

)

77

flag

(

"-mabi=ilp32f"

);

80 bool

UseI = (Arch ==

"rv32i"

) || (Arch ==

"rv32ic"

);

81 bool

UseIm = (Arch ==

"rv32im"

) || (Arch ==

"rv32imc"

);

82 bool

UseImafc = (Arch ==

"rv32imafc"

) || (Arch ==

"rv32imafdc"

) ||

95 return

Result.Multilibs.select(

, Flags, Result.SelectedMultilibs);

101 if

.SysRoot.empty())

105

llvm::sys::path::append(SysRootDir,

".."

"lib"

"clang-runtimes"

);

108

llvm::sys::path::append(SysRootDir,

.getTargetTriple());

110 return

std::string(SysRootDir);

121 if

(!SysRoot.empty()) {

122 for

(

const Multilib

&M : getOrderedMultilibs()) {

124

llvm::sys::path::append(Dir, M.osSuffix(),

"lib"

);

133 if

(Triple.getArch() != llvm::Triple::aarch64 &&

134

Triple.getArch() != llvm::Triple::aarch64_be)

137 if

(Triple.getVendor() != llvm::Triple::UnknownVendor)

140 if

(Triple.getOS() != llvm::Triple::UnknownOS)

143 return

Triple.getEnvironmentName() ==

"elf"

;

147 if

(!Triple.isRISCV())

150 if

(Triple.getVendor() != llvm::Triple::UnknownVendor)

153 if

(Triple.getOS() != llvm::Triple::UnknownOS)

156 return

Triple.getEnvironmentName() ==

"elf"

;

161 return

Triple.isPPC() && Triple.getOS() == llvm::Triple::UnknownOS &&

162

Triple.getEnvironment() == llvm::Triple::EABI;

167

StringRef MultilibPath,

const

ArgList &Args,

170

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB =

171 D

.getVFS().getBufferForFile(MultilibPath);

175

llvm::ErrorOr<MultilibSet> ErrorOrMultilibSet =

177 if

(ErrorOrMultilibSet.getError())

179 Result

.Multilibs = ErrorOrMultilibSet.get();

180 if

(

Result

.Multilibs.select(

, Flags,

Result

.SelectedMultilibs,

181

&CustomFlagsMacroDefines))

183 D

.Diag(clang::diag::warn_drv_missing_multilib) << llvm::join(Flags,

" "

);

184

std::stringstream ss;

191 D

.Diag(clang::diag::note_drv_available_multilibs) << ss.str();

200 D

.Diag(clang::diag::err_drv_multilib_custom_error)

205 Result

.SelectedMultilibs.clear();

210static

std::optional<llvm::SmallString<128>>

212 const

ArgList &Args) {

214 if

(Arg *ConfigFileArg = Args.getLastArg(options::OPT_multi_lib_config)) {

215

MultilibPath = ConfigFileArg->getValue();

216 if

.getVFS().exists(MultilibPath)) {

217 D

.Diag(clang::diag::err_drv_no_such_file) << MultilibPath.str();

228 const

ArgList &Args) {

232

std::optional<llvm::SmallString<128>> MultilibPath =

236 if

(

.getVFS().exists(*MultilibPath)) {

242

CustomFlagMacroDefines);

245

MultilibMacroDefines.append(CustomFlagMacroDefines.begin(),

246

CustomFlagMacroDefines.end());

270

BareMetal::OrderedMultilibs BareMetal::getOrderedMultilibs()

const

{

277 return

llvm::reverse(

Default

);

281

ArgStringList &CC1Args)

const

{

282 if

(DriverArgs.hasArg(options::OPT_nostdinc))

285 if

(!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

287

llvm::sys::path::append(Dir,

"include"

);

291 if

(DriverArgs.hasArg(options::OPT_nostdlibinc))

298 if

(!SysRoot.empty()) {

299 for

(

const Multilib

&M : getOrderedMultilibs()) {

301

llvm::sys::path::append(Dir, M.includeSuffix());

302

llvm::sys::path::append(Dir,

"include"

);

309

ArgStringList &CC1Args,

311

CC1Args.push_back(

"-nostdsysteminc"

);

315

ArgStringList &CC1Args)

const

{

316 if

(DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,

317

options::OPT_nostdincxx))

323 auto

AddCXXIncludePath = [&](StringRef

Path

) {

331

llvm::sys::path::append(TargetDir,

Target

"c++"

, Version);

338

llvm::sys::path::append(Dir,

"c++"

, Version);

346

llvm::sys::path::append(

".."

"include"

);

347

AddCXXIncludePath(

);

359 for

(

const Multilib

&M : getOrderedMultilibs()) {

361

llvm::sys::path::append(Dir, M.gccSuffix());

366

llvm::sys::path::append(TargetDir,

"usr"

"include"

"c++"

"v1"

);

367 if

(

.getVFS().exists(TargetDir)) {

372

llvm::sys::path::append(Dir,

"include"

"c++"

"v1"

);

377

llvm::sys::path::append(Dir,

"include"

"c++"

);

381 for

(llvm::vfs::directory_iterator

382

LI =

.getVFS().dir_begin(Dir.str(), EC),

384

!EC && LI != LE; LI = LI.increment(EC)) {

385

StringRef VersionText = llvm::sys::path::filename(LI->path());

387 if

(CandidateVersion.Major == -1)

389 if

(CandidateVersion <= Version)

391

Version = CandidateVersion;

393 if

(Version.

Major

!= -1) {

394

llvm::sys::path::append(Dir, Version.

Text

);

407 const char

*LinkingOutput)

const

{

408 const Driver

= getToolChain().getDriver();

411

Args.ClaimAllArgs(options::OPT_g_Group);

413

Args.ClaimAllArgs(options::OPT_emit_llvm);

416

Args.ClaimAllArgs(options::OPT_w);

418

Args.ClaimAllArgs(options::OPT_stdlib_EQ);

421

ArgStringList CmdArgs;

423

CmdArgs.push_back(

"rcsD"

);

426 for

(

const auto

&II : Inputs) {

427 if

(II.isFilename()) {

428

CmdArgs.push_back(II.getFilename());

434 const char

*OutputFileName = Output.

getFilename

();

435 if

(Output.

isFilename

() && llvm::sys::fs::exists(OutputFileName)) {

436 if

(std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {

437 D

.Diag(diag::err_drv_unable_to_remove_file) << EC.message();

442 const char

*Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());

443 C

.addCommand(std::make_unique<Command>(JA, *

this

445

Exec, CmdArgs, Inputs, Output));

452 const char

*LinkingOutput)

const

{

453

ArgStringList CmdArgs;

456 const Driver

= getToolChain().getDriver();

457 const

llvm::Triple::ArchType Arch = TC.getArch();

458 const

llvm::Triple &Triple = getToolChain().getEffectiveTriple();

462

CmdArgs.push_back(

"-Bstatic"

);

464 if

(TC.getTriple().isRISCV() && Args.hasArg(options::OPT_mno_relax))

465

CmdArgs.push_back(

"--no-relax"

);

467 if

(Triple.isARM() || Triple.isThumb()) {

471

CmdArgs.push_back(IsBigEndian ?

"-EB"

"-EL"

);

472

}

else if

(Triple.isAArch64()) {

473

CmdArgs.push_back(Arch == llvm::Triple::aarch64_be ?

"-EB"

"-EL"

);

476 if

(!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,

478

CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath(

"crt0.o"

)));

481

Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,

482

options::OPT_s, options::OPT_t, options::OPT_r});

484

TC.AddFilePathLibArgs(Args, CmdArgs);

486 for

(

const auto

&LibPath : TC.getLibraryPaths())

487

CmdArgs.push_back(Args.MakeArgString(llvm::Twine(

"-L"

, LibPath)));

489 if

(TC.ShouldLinkCXXStdlib(Args)) {

490 bool

OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&

491

!Args.hasArg(options::OPT_static);

492 if

(OnlyLibstdcxxStatic)

493

CmdArgs.push_back(

"-Bstatic"

);

494

TC.AddCXXStdlibLibArgs(Args, CmdArgs);

495 if

(OnlyLibstdcxxStatic)

496

CmdArgs.push_back(

"-Bdynamic"

);

497

CmdArgs.push_back(

"-lm"

);

500 if

(!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {

503

CmdArgs.push_back(

"-lc"

);

506 if

(

.isUsingLTO()) {

507

assert(!Inputs.empty() &&

"Must have at least one input."

);

509 auto

Input = llvm::find_if(

511 if

(Input == Inputs.end())

514

Input = Inputs.begin();

519 if

(TC.getTriple().isRISCV())

520

CmdArgs.push_back(

"-X"

);

526

CmdArgs.push_back(

"--target2=rel"

);

528

CmdArgs.push_back(

"-o"

);

531 C

.addCommand(std::make_unique<Command>(

533

Args.MakeArgString(TC.GetLinkerPath()), CmdArgs, Inputs, Output));

540 const bool

IsX86_64 =

getTriple

().getArch() == llvm::Triple::x86_64;

541 const bool

IsAArch64 =

getTriple

().getArch() == llvm::Triple::aarch64 ||

542 getTriple

().getArch() == llvm::Triple::aarch64_be;

543 const bool

IsRISCV64 =

getTriple

().getArch() == llvm::Triple::riscv64;

545

Res |= SanitizerKind::Address;

546

Res |= SanitizerKind::KernelAddress;

547

Res |= SanitizerKind::PointerCompare;

548

Res |= SanitizerKind::PointerSubtract;

549

Res |= SanitizerKind::Fuzzer;

550

Res |= SanitizerKind::FuzzerNoLink;

551

Res |= SanitizerKind::Vptr;

552

Res |= SanitizerKind::SafeStack;

553

Res |= SanitizerKind::Thread;

554

Res |= SanitizerKind::Scudo;

555 if

(IsX86_64 || IsAArch64 || IsRISCV64) {

556

Res |= SanitizerKind::HWAddress;

557

Res |= SanitizerKind::KernelHWAddress;

564 return

MultilibMacroDefines;

llvm::MachO::Target Target

Compilation - A set of tasks to perform for a single driver invocation.

Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...

InputInfo - Wrapper for information about an input source.

const char * getFilename() const

This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag.

MultilibBuilder & flag(StringRef Flag, bool Disallow=false)

Add a flag to the flags list Flag must be a flag accepted by the driver.

This class can be used to create a MultilibSet, and contains helper functions to add combinations of ...

MultilibSetBuilder & Either(const MultilibBuilder &M1, const MultilibBuilder &M2)

Add a set of mutually incompatible Multilib segments.

MultilibSet makeMultilibSet() const

static llvm::ErrorOr< MultilibSet > parseYaml(llvm::MemoryBufferRef, llvm::SourceMgr::DiagHandlerTy=nullptr, void *DiagHandlerCtxt=nullptr)

This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.

const std::string & getErrorMessage() const

const flags_list & flags() const

Get the flags that indicate or contraindicate this multilib's use All elements begin with either '-' ...

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.

static constexpr ResponseFileSupport AtFileCurCP()

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4