904 lines · cpp
1//===--- Targets.cpp - Implement target feature support -------------------===//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-exception6//7//===----------------------------------------------------------------------===//8//9// This file implements construction of a TargetInfo object from a10// target triple.11//12//===----------------------------------------------------------------------===//13 14#include "Targets.h"15 16#include "Targets/AArch64.h"17#include "Targets/AMDGPU.h"18#include "Targets/ARC.h"19#include "Targets/ARM.h"20#include "Targets/AVR.h"21#include "Targets/BPF.h"22#include "Targets/CSKY.h"23#include "Targets/DirectX.h"24#include "Targets/Hexagon.h"25#include "Targets/Lanai.h"26#include "Targets/LoongArch.h"27#include "Targets/M68k.h"28#include "Targets/MSP430.h"29#include "Targets/Mips.h"30#include "Targets/NVPTX.h"31#include "Targets/OSTargets.h"32#include "Targets/PPC.h"33#include "Targets/RISCV.h"34#include "Targets/SPIR.h"35#include "Targets/Sparc.h"36#include "Targets/SystemZ.h"37#include "Targets/TCE.h"38#include "Targets/VE.h"39#include "Targets/WebAssembly.h"40#include "Targets/X86.h"41#include "Targets/XCore.h"42#include "Targets/Xtensa.h"43#include "clang/Basic/Diagnostic.h"44#include "clang/Basic/DiagnosticFrontend.h"45#include "llvm/ADT/StringExtras.h"46#include "llvm/TargetParser/Triple.h"47 48using namespace clang;49 50namespace clang {51namespace targets {52//===----------------------------------------------------------------------===//53// Common code shared among targets.54//===----------------------------------------------------------------------===//55 56/// DefineStd - Define a macro name and standard variants. For example if57/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"58/// when in GNU mode.59void DefineStd(MacroBuilder &Builder, StringRef MacroName,60 const LangOptions &Opts) {61 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");62 63 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier64 // in the user's namespace.65 if (Opts.GNUMode)66 Builder.defineMacro(MacroName);67 68 // Define __unix.69 Builder.defineMacro("__" + MacroName);70 71 // Define __unix__.72 Builder.defineMacro("__" + MacroName + "__");73}74 75void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) {76 Builder.defineMacro("__" + CPUName);77 Builder.defineMacro("__" + CPUName + "__");78 if (Tuning)79 Builder.defineMacro("__tune_" + CPUName + "__");80}81 82void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {83 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang84 // supports __declspec natively under -fdeclspec (also enabled with85 // -fms-extensions), but we define a no-op __declspec macro anyway for86 // pre-processor compatibility.87 if (Opts.DeclSpecKeyword)88 Builder.defineMacro("__declspec", "__declspec");89 else90 Builder.defineMacro("__declspec(a)", "__attribute__((a))");91 92 if (!Opts.MicrosoftExt) {93 // Provide macros for all the calling convention keywords. Provide both94 // single and double underscore prefixed variants. These are available on95 // x64 as well as x86, even though they have no effect.96 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};97 for (const char *CC : CCs) {98 std::string GCCSpelling = "__attribute__((__";99 GCCSpelling += CC;100 GCCSpelling += "__))";101 Builder.defineMacro(Twine("_") + CC, GCCSpelling);102 Builder.defineMacro(Twine("__") + CC, GCCSpelling);103 }104 }105}106 107//===----------------------------------------------------------------------===//108// Driver code109//===----------------------------------------------------------------------===//110 111std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,112 const TargetOptions &Opts) {113 llvm::Triple::OSType os = Triple.getOS();114 115 switch (Triple.getArch()) {116 default:117 return nullptr;118 119 case llvm::Triple::arc:120 return std::make_unique<ARCTargetInfo>(Triple, Opts);121 122 case llvm::Triple::xcore:123 return std::make_unique<XCoreTargetInfo>(Triple, Opts);124 125 case llvm::Triple::hexagon:126 if (os == llvm::Triple::Linux &&127 Triple.getEnvironment() == llvm::Triple::Musl)128 return std::make_unique<LinuxTargetInfo<HexagonTargetInfo>>(Triple, Opts);129 return std::make_unique<HexagonTargetInfo>(Triple, Opts);130 131 case llvm::Triple::lanai:132 return std::make_unique<LanaiTargetInfo>(Triple, Opts);133 134 case llvm::Triple::aarch64_32:135 if (Triple.isOSDarwin())136 return std::make_unique<DarwinAArch64TargetInfo>(Triple, Opts);137 else if (Triple.isAppleMachO())138 return std::make_unique<AppleMachOAArch64TargetInfo>(Triple, Opts);139 140 return nullptr;141 case llvm::Triple::aarch64:142 if (Triple.isOSDarwin())143 return std::make_unique<DarwinAArch64TargetInfo>(Triple, Opts);144 else if (Triple.isAppleMachO())145 return std::make_unique<AppleMachOAArch64TargetInfo>(Triple, Opts);146 147 switch (os) {148 case llvm::Triple::FreeBSD:149 return std::make_unique<FreeBSDTargetInfo<AArch64leTargetInfo>>(Triple,150 Opts);151 case llvm::Triple::Fuchsia:152 return std::make_unique<FuchsiaTargetInfo<AArch64leTargetInfo>>(Triple,153 Opts);154 case llvm::Triple::Haiku:155 return std::make_unique<HaikuTargetInfo<AArch64leTargetInfo>>(Triple,156 Opts);157 case llvm::Triple::Linux:158 switch (Triple.getEnvironment()) {159 default:160 return std::make_unique<LinuxTargetInfo<AArch64leTargetInfo>>(Triple,161 Opts);162 case llvm::Triple::OpenHOS:163 return std::make_unique<OHOSTargetInfo<AArch64leTargetInfo>>(Triple,164 Opts);165 }166 case llvm::Triple::Managarm:167 return std::make_unique<ManagarmTargetInfo<AArch64leTargetInfo>>(Triple,168 Opts);169 case llvm::Triple::NetBSD:170 return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(Triple,171 Opts);172 case llvm::Triple::OpenBSD:173 return std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(Triple,174 Opts);175 case llvm::Triple::Hurd:176 return std::make_unique<HurdTargetInfo<AArch64leTargetInfo>>(Triple,177 Opts);178 case llvm::Triple::Win32:179 switch (Triple.getEnvironment()) {180 case llvm::Triple::GNU:181 return std::make_unique<MinGWARM64TargetInfo>(Triple, Opts);182 case llvm::Triple::MSVC:183 default: // Assume MSVC for unknown environments184 return std::make_unique<MicrosoftARM64TargetInfo>(Triple, Opts);185 }186 default:187 return std::make_unique<AArch64leTargetInfo>(Triple, Opts);188 }189 190 case llvm::Triple::aarch64_be:191 switch (os) {192 case llvm::Triple::FreeBSD:193 return std::make_unique<FreeBSDTargetInfo<AArch64beTargetInfo>>(Triple,194 Opts);195 case llvm::Triple::Fuchsia:196 return std::make_unique<FuchsiaTargetInfo<AArch64beTargetInfo>>(Triple,197 Opts);198 case llvm::Triple::Linux:199 return std::make_unique<LinuxTargetInfo<AArch64beTargetInfo>>(Triple,200 Opts);201 case llvm::Triple::NetBSD:202 return std::make_unique<NetBSDTargetInfo<AArch64beTargetInfo>>(Triple,203 Opts);204 default:205 return std::make_unique<AArch64beTargetInfo>(Triple, Opts);206 }207 208 case llvm::Triple::arm:209 case llvm::Triple::thumb:210 if (Triple.isOSBinFormatMachO())211 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts);212 213 switch (os) {214 case llvm::Triple::Linux:215 switch (Triple.getEnvironment()) {216 default:217 return std::make_unique<LinuxTargetInfo<ARMleTargetInfo>>(Triple, Opts);218 case llvm::Triple::OpenHOS:219 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts);220 }221 case llvm::Triple::LiteOS:222 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts);223 case llvm::Triple::FreeBSD:224 return std::make_unique<FreeBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);225 case llvm::Triple::Fuchsia:226 return std::make_unique<FuchsiaTargetInfo<ARMleTargetInfo>>(Triple, Opts);227 case llvm::Triple::NetBSD:228 return std::make_unique<NetBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);229 case llvm::Triple::OpenBSD:230 return std::make_unique<OpenBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);231 case llvm::Triple::RTEMS:232 return std::make_unique<RTEMSTargetInfo<ARMleTargetInfo>>(Triple, Opts);233 case llvm::Triple::Haiku:234 return std::make_unique<HaikuTargetInfo<ARMleTargetInfo>>(Triple, Opts);235 case llvm::Triple::Win32:236 switch (Triple.getEnvironment()) {237 case llvm::Triple::Cygnus:238 return std::make_unique<CygwinARMTargetInfo>(Triple, Opts);239 case llvm::Triple::GNU:240 return std::make_unique<MinGWARMTargetInfo>(Triple, Opts);241 case llvm::Triple::Itanium:242 return std::make_unique<ItaniumWindowsARMleTargetInfo>(Triple, Opts);243 case llvm::Triple::MSVC:244 default: // Assume MSVC for unknown environments245 return std::make_unique<MicrosoftARMleTargetInfo>(Triple, Opts);246 }247 default:248 return std::make_unique<ARMleTargetInfo>(Triple, Opts);249 }250 251 case llvm::Triple::armeb:252 case llvm::Triple::thumbeb:253 if (Triple.isOSDarwin())254 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts);255 else if (Triple.isAppleMachO())256 return std::make_unique<AppleMachOARMTargetInfo>(Triple, Opts);257 258 switch (os) {259 case llvm::Triple::Fuchsia:260 return std::make_unique<FuchsiaTargetInfo<ARMbeTargetInfo>>(Triple, Opts);261 case llvm::Triple::Linux:262 return std::make_unique<LinuxTargetInfo<ARMbeTargetInfo>>(Triple, Opts);263 case llvm::Triple::NetBSD:264 return std::make_unique<NetBSDTargetInfo<ARMbeTargetInfo>>(Triple, Opts);265 case llvm::Triple::RTEMS:266 return std::make_unique<RTEMSTargetInfo<ARMbeTargetInfo>>(Triple, Opts);267 default:268 return std::make_unique<ARMbeTargetInfo>(Triple, Opts);269 }270 271 case llvm::Triple::avr:272 return std::make_unique<AVRTargetInfo>(Triple, Opts);273 case llvm::Triple::bpfeb:274 case llvm::Triple::bpfel:275 return std::make_unique<BPFTargetInfo>(Triple, Opts);276 277 case llvm::Triple::msp430:278 return std::make_unique<MSP430TargetInfo>(Triple, Opts);279 280 case llvm::Triple::mips:281 switch (os) {282 case llvm::Triple::Linux:283 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);284 case llvm::Triple::RTEMS:285 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);286 case llvm::Triple::FreeBSD:287 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);288 case llvm::Triple::NetBSD:289 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);290 default:291 return std::make_unique<MipsTargetInfo>(Triple, Opts);292 }293 294 case llvm::Triple::mipsel:295 switch (os) {296 case llvm::Triple::Linux:297 switch (Triple.getEnvironment()) {298 default:299 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);300 case llvm::Triple::OpenHOS:301 return std::make_unique<OHOSTargetInfo<MipsTargetInfo>>(Triple, Opts);302 }303 case llvm::Triple::RTEMS:304 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);305 case llvm::Triple::FreeBSD:306 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);307 case llvm::Triple::NetBSD:308 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);309 case llvm::Triple::Win32:310 switch (Triple.getEnvironment()) {311 case llvm::Triple::GNU:312 return std::make_unique<MinGWMipsTargetInfo>(Triple, Opts);313 case llvm::Triple::MSVC:314 default: // Assume MSVC for unknown environments315 return std::make_unique<MicrosoftMipsTargetInfo>(Triple, Opts);316 }317 default:318 return std::make_unique<MipsTargetInfo>(Triple, Opts);319 }320 321 case llvm::Triple::mips64:322 switch (os) {323 case llvm::Triple::Linux:324 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);325 case llvm::Triple::RTEMS:326 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);327 case llvm::Triple::FreeBSD:328 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);329 case llvm::Triple::NetBSD:330 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);331 case llvm::Triple::OpenBSD:332 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);333 default:334 return std::make_unique<MipsTargetInfo>(Triple, Opts);335 }336 337 case llvm::Triple::mips64el:338 switch (os) {339 case llvm::Triple::Linux:340 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);341 case llvm::Triple::RTEMS:342 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);343 case llvm::Triple::FreeBSD:344 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);345 case llvm::Triple::NetBSD:346 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);347 case llvm::Triple::OpenBSD:348 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);349 default:350 return std::make_unique<MipsTargetInfo>(Triple, Opts);351 }352 353 case llvm::Triple::m68k:354 switch (os) {355 case llvm::Triple::Linux:356 return std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(Triple, Opts);357 case llvm::Triple::NetBSD:358 return std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(Triple, Opts);359 default:360 return std::make_unique<M68kTargetInfo>(Triple, Opts);361 }362 363 case llvm::Triple::ppc:364 switch (os) {365 case llvm::Triple::Linux:366 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);367 case llvm::Triple::FreeBSD:368 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);369 case llvm::Triple::NetBSD:370 return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);371 case llvm::Triple::OpenBSD:372 return std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);373 case llvm::Triple::RTEMS:374 return std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(Triple, Opts);375 case llvm::Triple::AIX:376 return std::make_unique<AIXPPC32TargetInfo>(Triple, Opts);377 default:378 return std::make_unique<PPC32TargetInfo>(Triple, Opts);379 }380 381 case llvm::Triple::ppcle:382 switch (os) {383 case llvm::Triple::Linux:384 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);385 case llvm::Triple::FreeBSD:386 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);387 default:388 return std::make_unique<PPC32TargetInfo>(Triple, Opts);389 }390 391 case llvm::Triple::ppc64:392 switch (os) {393 case llvm::Triple::Linux:394 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);395 case llvm::Triple::Lv2:396 return std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(Triple, Opts);397 case llvm::Triple::FreeBSD:398 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);399 case llvm::Triple::NetBSD:400 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);401 case llvm::Triple::OpenBSD:402 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);403 case llvm::Triple::AIX:404 return std::make_unique<AIXPPC64TargetInfo>(Triple, Opts);405 default:406 return std::make_unique<PPC64TargetInfo>(Triple, Opts);407 }408 409 case llvm::Triple::ppc64le:410 switch (os) {411 case llvm::Triple::Linux:412 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);413 case llvm::Triple::FreeBSD:414 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);415 case llvm::Triple::NetBSD:416 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);417 case llvm::Triple::OpenBSD:418 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);419 default:420 return std::make_unique<PPC64TargetInfo>(Triple, Opts);421 }422 423 case llvm::Triple::nvptx:424 return std::make_unique<NVPTXTargetInfo>(Triple, Opts,425 /*TargetPointerWidth=*/32);426 case llvm::Triple::nvptx64:427 return std::make_unique<NVPTXTargetInfo>(Triple, Opts,428 /*TargetPointerWidth=*/64);429 430 case llvm::Triple::amdgcn:431 case llvm::Triple::r600:432 return std::make_unique<AMDGPUTargetInfo>(Triple, Opts);433 434 case llvm::Triple::riscv32:435 switch (os) {436 case llvm::Triple::NetBSD:437 return std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(Triple,438 Opts);439 case llvm::Triple::Linux:440 return std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(Triple, Opts);441 default:442 return std::make_unique<RISCV32TargetInfo>(Triple, Opts);443 }444 445 case llvm::Triple::riscv64:446 switch (os) {447 case llvm::Triple::FreeBSD:448 return std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(Triple,449 Opts);450 case llvm::Triple::NetBSD:451 return std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(Triple,452 Opts);453 case llvm::Triple::OpenBSD:454 return std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(Triple,455 Opts);456 case llvm::Triple::Fuchsia:457 return std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(Triple,458 Opts);459 case llvm::Triple::Haiku:460 return std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(Triple,461 Opts);462 case llvm::Triple::Linux:463 switch (Triple.getEnvironment()) {464 default:465 return std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(Triple,466 Opts);467 case llvm::Triple::OpenHOS:468 return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(Triple,469 Opts);470 }471 case llvm::Triple::Managarm:472 return std::make_unique<ManagarmTargetInfo<RISCV64TargetInfo>>(Triple,473 Opts);474 case llvm::Triple::Hurd:475 return std::make_unique<HurdTargetInfo<RISCV64TargetInfo>>(Triple, Opts);476 default:477 return std::make_unique<RISCV64TargetInfo>(Triple, Opts);478 }479 480 case llvm::Triple::sparc:481 switch (os) {482 case llvm::Triple::Linux:483 return std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(Triple, Opts);484 case llvm::Triple::Solaris:485 return std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(Triple,486 Opts);487 case llvm::Triple::NetBSD:488 return std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(Triple,489 Opts);490 case llvm::Triple::RTEMS:491 return std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(Triple, Opts);492 default:493 return std::make_unique<SparcV8TargetInfo>(Triple, Opts);494 }495 496 case llvm::Triple::sparcel:497 switch (os) {498 case llvm::Triple::Linux:499 return std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(Triple,500 Opts);501 case llvm::Triple::RTEMS:502 return std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(Triple,503 Opts);504 default:505 return std::make_unique<SparcV8elTargetInfo>(Triple, Opts);506 }507 508 case llvm::Triple::sparcv9:509 switch (os) {510 case llvm::Triple::Linux:511 return std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(Triple, Opts);512 case llvm::Triple::Solaris:513 return std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(Triple,514 Opts);515 case llvm::Triple::NetBSD:516 return std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(Triple,517 Opts);518 case llvm::Triple::OpenBSD:519 return std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(Triple,520 Opts);521 case llvm::Triple::FreeBSD:522 return std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(Triple,523 Opts);524 default:525 return std::make_unique<SparcV9TargetInfo>(Triple, Opts);526 }527 528 case llvm::Triple::systemz:529 switch (os) {530 case llvm::Triple::Linux:531 return std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(Triple, Opts);532 case llvm::Triple::ZOS:533 return std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(Triple, Opts);534 default:535 return std::make_unique<SystemZTargetInfo>(Triple, Opts);536 }537 538 case llvm::Triple::tce:539 return std::make_unique<TCETargetInfo>(Triple, Opts);540 541 case llvm::Triple::tcele:542 return std::make_unique<TCELETargetInfo>(Triple, Opts);543 544 case llvm::Triple::x86:545 if (Triple.isOSDarwin())546 return std::make_unique<DarwinI386TargetInfo>(Triple, Opts);547 else if (Triple.isAppleMachO())548 return std::make_unique<AppleMachOI386TargetInfo>(Triple, Opts);549 550 switch (os) {551 case llvm::Triple::Linux: {552 switch (Triple.getEnvironment()) {553 default:554 return std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(Triple,555 Opts);556 case llvm::Triple::Android:557 return std::make_unique<AndroidX86_32TargetInfo>(Triple, Opts);558 }559 }560 case llvm::Triple::DragonFly:561 return std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(Triple,562 Opts);563 case llvm::Triple::NetBSD:564 return std::make_unique<NetBSDI386TargetInfo>(Triple, Opts);565 case llvm::Triple::OpenBSD:566 return std::make_unique<OpenBSDI386TargetInfo>(Triple, Opts);567 case llvm::Triple::FreeBSD:568 return std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(Triple,569 Opts);570 case llvm::Triple::Fuchsia:571 return std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(Triple,572 Opts);573 case llvm::Triple::KFreeBSD:574 return std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(Triple,575 Opts);576 case llvm::Triple::Solaris:577 return std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(Triple,578 Opts);579 case llvm::Triple::Win32: {580 switch (Triple.getEnvironment()) {581 case llvm::Triple::Cygnus:582 return std::make_unique<CygwinX86_32TargetInfo>(Triple, Opts);583 case llvm::Triple::GNU:584 return std::make_unique<MinGWX86_32TargetInfo>(Triple, Opts);585 case llvm::Triple::Itanium:586 case llvm::Triple::MSVC:587 default: // Assume MSVC for unknown environments588 return std::make_unique<MicrosoftX86_32TargetInfo>(Triple, Opts);589 }590 }591 case llvm::Triple::Haiku:592 return std::make_unique<HaikuX86_32TargetInfo>(Triple, Opts);593 case llvm::Triple::RTEMS:594 return std::make_unique<RTEMSX86_32TargetInfo>(Triple, Opts);595 case llvm::Triple::ELFIAMCU:596 return std::make_unique<MCUX86_32TargetInfo>(Triple, Opts);597 case llvm::Triple::Hurd:598 return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(Triple, Opts);599 default:600 return std::make_unique<X86_32TargetInfo>(Triple, Opts);601 }602 603 case llvm::Triple::x86_64:604 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())605 return std::make_unique<DarwinX86_64TargetInfo>(Triple, Opts);606 607 switch (os) {608 case llvm::Triple::Linux: {609 switch (Triple.getEnvironment()) {610 default:611 return std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(Triple,612 Opts);613 case llvm::Triple::Android:614 return std::make_unique<AndroidX86_64TargetInfo>(Triple, Opts);615 case llvm::Triple::OpenHOS:616 return std::make_unique<OHOSX86_64TargetInfo>(Triple, Opts);617 }618 }619 case llvm::Triple::DragonFly:620 return std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(Triple,621 Opts);622 case llvm::Triple::NetBSD:623 return std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(Triple, Opts);624 case llvm::Triple::OpenBSD:625 return std::make_unique<OpenBSDX86_64TargetInfo>(Triple, Opts);626 case llvm::Triple::FreeBSD:627 return std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(Triple,628 Opts);629 case llvm::Triple::Fuchsia:630 return std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(Triple,631 Opts);632 case llvm::Triple::KFreeBSD:633 return std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(Triple,634 Opts);635 case llvm::Triple::Solaris:636 return std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(Triple,637 Opts);638 case llvm::Triple::UEFI:639 return std::make_unique<UEFIX86_64TargetInfo>(Triple, Opts);640 641 case llvm::Triple::Win32: {642 switch (Triple.getEnvironment()) {643 case llvm::Triple::Cygnus:644 return std::make_unique<CygwinX86_64TargetInfo>(Triple, Opts);645 case llvm::Triple::GNU:646 return std::make_unique<MinGWX86_64TargetInfo>(Triple, Opts);647 case llvm::Triple::MSVC:648 default: // Assume MSVC for unknown environments649 return std::make_unique<MicrosoftX86_64TargetInfo>(Triple, Opts);650 }651 }652 case llvm::Triple::Haiku:653 return std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(Triple, Opts);654 case llvm::Triple::PS4:655 return std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);656 case llvm::Triple::PS5:657 return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);658 case llvm::Triple::Hurd:659 return std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(Triple, Opts);660 case llvm::Triple::Managarm:661 return std::make_unique<ManagarmTargetInfo<X86_64TargetInfo>>(Triple,662 Opts);663 default:664 return std::make_unique<X86_64TargetInfo>(Triple, Opts);665 }666 667 case llvm::Triple::spir: {668 if (os != llvm::Triple::UnknownOS ||669 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)670 return nullptr;671 return std::make_unique<SPIR32TargetInfo>(Triple, Opts);672 }673 case llvm::Triple::spir64: {674 if (os != llvm::Triple::UnknownOS ||675 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)676 return nullptr;677 return std::make_unique<SPIR64TargetInfo>(Triple, Opts);678 }679 case llvm::Triple::spirv: {680 return std::make_unique<SPIRVTargetInfo>(Triple, Opts);681 }682 case llvm::Triple::spirv32: {683 if (os != llvm::Triple::UnknownOS ||684 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)685 return nullptr;686 return std::make_unique<SPIRV32TargetInfo>(Triple, Opts);687 }688 case llvm::Triple::spirv64: {689 if (os != llvm::Triple::UnknownOS ||690 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) {691 if (os == llvm::Triple::OSType::AMDHSA)692 return std::make_unique<SPIRV64AMDGCNTargetInfo>(Triple, Opts);693 return nullptr;694 }695 if (Triple.getVendor() == llvm::Triple::Intel)696 return std::make_unique<SPIRV64IntelTargetInfo>(Triple, Opts);697 return std::make_unique<SPIRV64TargetInfo>(Triple, Opts);698 }699 case llvm::Triple::wasm32:700 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||701 Triple.getVendor() != llvm::Triple::UnknownVendor ||702 !Triple.isOSBinFormatWasm())703 return nullptr;704 switch (os) {705 case llvm::Triple::WASI:706 return std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(Triple,707 Opts);708 case llvm::Triple::Emscripten:709 return std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>(710 Triple, Opts);711 712 case llvm::Triple::Linux:713 return std::make_unique<WALITargetInfo<WebAssembly32TargetInfo>>(Triple,714 Opts);715 case llvm::Triple::UnknownOS:716 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>(717 Triple, Opts);718 default:719 return nullptr;720 }721 case llvm::Triple::wasm64:722 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||723 Triple.getVendor() != llvm::Triple::UnknownVendor ||724 !Triple.isOSBinFormatWasm())725 return nullptr;726 switch (os) {727 case llvm::Triple::WASI:728 return std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(Triple,729 Opts);730 case llvm::Triple::Emscripten:731 return std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>(732 Triple, Opts);733 case llvm::Triple::UnknownOS:734 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>(735 Triple, Opts);736 default:737 return nullptr;738 }739 740 case llvm::Triple::dxil:741 return std::make_unique<DirectXTargetInfo>(Triple, Opts);742 743 case llvm::Triple::ve:744 return std::make_unique<LinuxTargetInfo<VETargetInfo>>(Triple, Opts);745 746 case llvm::Triple::csky:747 switch (os) {748 case llvm::Triple::Linux:749 return std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(Triple, Opts);750 default:751 return std::make_unique<CSKYTargetInfo>(Triple, Opts);752 }753 case llvm::Triple::loongarch32:754 switch (os) {755 case llvm::Triple::Linux:756 return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(Triple,757 Opts);758 default:759 return std::make_unique<LoongArch32TargetInfo>(Triple, Opts);760 }761 case llvm::Triple::loongarch64:762 switch (os) {763 case llvm::Triple::Linux:764 switch (Triple.getEnvironment()) {765 default:766 return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(Triple,767 Opts);768 case llvm::Triple::OpenHOS:769 return std::make_unique<OHOSTargetInfo<LoongArch64TargetInfo>>(Triple,770 Opts);771 }772 case llvm::Triple::FreeBSD:773 return std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(Triple,774 Opts);775 case llvm::Triple::OpenBSD:776 return std::make_unique<OpenBSDTargetInfo<LoongArch64TargetInfo>>(Triple,777 Opts);778 default:779 return std::make_unique<LoongArch64TargetInfo>(Triple, Opts);780 }781 782 case llvm::Triple::xtensa:783 return std::make_unique<XtensaTargetInfo>(Triple, Opts);784 }785}786} // namespace targets787} // namespace clang788 789using namespace clang::targets;790/// CreateTargetInfo - Return the target info object for the specified target791/// options.792TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,793 TargetOptions &OptsRef) {794 TargetOptions *Opts = &OptsRef;795 796 llvm::Triple Triple(llvm::Triple::normalize(Opts->Triple));797 798 // Construct the target799 std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, *Opts);800 if (!Target) {801 Diags.Report(diag::err_target_unknown_triple) << Triple.str();802 return nullptr;803 }804 Target->TargetOpts = Opts;805 806 // Set the target CPU if specified.807 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {808 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;809 SmallVector<StringRef, 32> ValidList;810 Target->fillValidCPUList(ValidList);811 if (!ValidList.empty())812 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");813 return nullptr;814 }815 816 // Check the TuneCPU name if specified.817 if (!Opts->TuneCPU.empty() &&818 !Target->isValidTuneCPUName(Opts->TuneCPU)) {819 Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU;820 SmallVector<StringRef, 32> ValidList;821 Target->fillValidTuneCPUList(ValidList);822 if (!ValidList.empty())823 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");824 return nullptr;825 }826 827 // Set the target ABI if specified.828 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {829 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;830 return nullptr;831 }832 833 // Set the fp math unit.834 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {835 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;836 return nullptr;837 }838 839 // Compute the default target features, we need the target to handle this840 // because features may have dependencies on one another.841 llvm::erase_if(Opts->FeaturesAsWritten, [&](StringRef Name) {842 if (Target->isReadOnlyFeature(Name.substr(1))) {843 Diags.Report(diag::warn_fe_backend_readonly_feature_flag) << Name;844 return true;845 }846 return false;847 });848 if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU,849 Opts->FeaturesAsWritten))850 return nullptr;851 852 // Add the features to the compile options.853 Opts->Features.clear();854 for (const auto &F : Opts->FeatureMap)855 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());856 // Sort here, so we handle the features in a predictable order. (This matters857 // when we're dealing with features that overlap.)858 llvm::sort(Opts->Features);859 860 if (!Target->handleTargetFeatures(Opts->Features, Diags))861 return nullptr;862 863 Target->setSupportedOpenCLOpts();864 Target->setCommandLineOpenCLOpts();865 Target->setDependentOpenCLOpts();866 Target->setMaxAtomicWidth();867 868 if (!Opts->DarwinTargetVariantTriple.empty())869 Target->DarwinTargetVariantTriple =870 llvm::Triple(Opts->DarwinTargetVariantTriple);871 872 if (!Target->validateTarget(Diags))873 return nullptr;874 875 Target->CheckFixedPointBits();876 877 return Target.release();878}879/// validateOpenCLTarget - Check that OpenCL target has valid880/// options setting based on OpenCL version.881bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts,882 DiagnosticsEngine &Diags) const {883 const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts();884 885 auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {886 if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) &&887 !hasFeatureEnabled(OpenCLFeaturesMap, Name))888 Diags.Report(diag::warn_opencl_unsupported_core_feature)889 << Name << Opts.OpenCLCPlusPlus890 << Opts.getOpenCLVersionTuple().getAsString();891 };892#define OPENCL_GENERIC_EXTENSION(Ext, ...) \893 diagnoseNotSupportedCore(#Ext, __VA_ARGS__);894#include "clang/Basic/OpenCLExtensions.def"895 896 // Validate that feature macros are set properly for OpenCL C 3.0.897 // In other cases assume that target is always valid.898 if (Opts.getOpenCLCompatibleVersion() < 300)899 return true;900 901 return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(*this, Diags) &&902 OpenCLOptions::diagnoseFeatureExtensionDifferences(*this, Diags);903}904