1 //===--- Targets.cpp - Implement target feature support -------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements construction of a TargetInfo object from a 11 // target triple. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "Targets.h" 16 17 #include "Targets/AArch64.h" 18 #include "Targets/AMDGPU.h" 19 #include "Targets/ARM.h" 20 #include "Targets/AVR.h" 21 #include "Targets/BPF.h" 22 #include "Targets/Hexagon.h" 23 #include "Targets/Lanai.h" 24 #include "Targets/Le64.h" 25 #include "Targets/MSP430.h" 26 #include "Targets/Mips.h" 27 #include "Targets/NVPTX.h" 28 #include "Targets/Nios2.h" 29 #include "Targets/OSTargets.h" 30 #include "Targets/PNaCl.h" 31 #include "Targets/PPC.h" 32 #include "Targets/SPIR.h" 33 #include "Targets/Sparc.h" 34 #include "Targets/SystemZ.h" 35 #include "Targets/TCE.h" 36 #include "Targets/WebAssembly.h" 37 #include "Targets/X86.h" 38 #include "Targets/XCore.h" 39 #include "clang/Basic/Diagnostic.h" 40 #include "llvm/ADT/Triple.h" 41 42 using namespace clang; 43 44 namespace clang { 45 namespace targets { 46 //===----------------------------------------------------------------------===// 47 // Common code shared among targets. 48 //===----------------------------------------------------------------------===// 49 50 /// DefineStd - Define a macro name and standard variants. For example if 51 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix" 52 /// when in GNU mode. 53 void DefineStd(MacroBuilder &Builder, StringRef MacroName, 54 const LangOptions &Opts) { 55 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace"); 56 57 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier 58 // in the user's namespace. 59 if (Opts.GNUMode) 60 Builder.defineMacro(MacroName); 61 62 // Define __unix. 63 Builder.defineMacro("__" + MacroName); 64 65 // Define __unix__. 66 Builder.defineMacro("__" + MacroName + "__"); 67 } 68 69 void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) { 70 Builder.defineMacro("__" + CPUName); 71 Builder.defineMacro("__" + CPUName + "__"); 72 if (Tuning) 73 Builder.defineMacro("__tune_" + CPUName + "__"); 74 } 75 76 void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) { 77 Builder.defineMacro("__MSVCRT__"); 78 Builder.defineMacro("__MINGW32__"); 79 addCygMingDefines(Opts, Builder); 80 } 81 82 //===----------------------------------------------------------------------===// 83 // Driver code 84 //===----------------------------------------------------------------------===// 85 86 TargetInfo *AllocateTarget(const llvm::Triple &Triple, 87 const TargetOptions &Opts) { 88 llvm::Triple::OSType os = Triple.getOS(); 89 90 switch (Triple.getArch()) { 91 default: 92 return nullptr; 93 94 case llvm::Triple::xcore: 95 return new XCoreTargetInfo(Triple, Opts); 96 97 case llvm::Triple::hexagon: 98 return new HexagonTargetInfo(Triple, Opts); 99 100 case llvm::Triple::lanai: 101 return new LanaiTargetInfo(Triple, Opts); 102 103 case llvm::Triple::aarch64: 104 if (Triple.isOSDarwin()) 105 return new DarwinAArch64TargetInfo(Triple, Opts); 106 107 switch (os) { 108 case llvm::Triple::CloudABI: 109 return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts); 110 case llvm::Triple::FreeBSD: 111 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 112 case llvm::Triple::Fuchsia: 113 return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts); 114 case llvm::Triple::Linux: 115 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts); 116 case llvm::Triple::NetBSD: 117 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 118 case llvm::Triple::OpenBSD: 119 return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 120 case llvm::Triple::Win32: 121 return new MicrosoftARM64TargetInfo(Triple, Opts); 122 default: 123 return new AArch64leTargetInfo(Triple, Opts); 124 } 125 126 case llvm::Triple::aarch64_be: 127 switch (os) { 128 case llvm::Triple::FreeBSD: 129 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts); 130 case llvm::Triple::Fuchsia: 131 return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts); 132 case llvm::Triple::Linux: 133 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts); 134 case llvm::Triple::NetBSD: 135 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts); 136 default: 137 return new AArch64beTargetInfo(Triple, Opts); 138 } 139 140 case llvm::Triple::arm: 141 case llvm::Triple::thumb: 142 if (Triple.isOSBinFormatMachO()) 143 return new DarwinARMTargetInfo(Triple, Opts); 144 145 switch (os) { 146 case llvm::Triple::CloudABI: 147 return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts); 148 case llvm::Triple::Linux: 149 return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts); 150 case llvm::Triple::FreeBSD: 151 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 152 case llvm::Triple::NetBSD: 153 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 154 case llvm::Triple::OpenBSD: 155 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 156 case llvm::Triple::RTEMS: 157 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts); 158 case llvm::Triple::NaCl: 159 return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts); 160 case llvm::Triple::Win32: 161 switch (Triple.getEnvironment()) { 162 case llvm::Triple::Cygnus: 163 return new CygwinARMTargetInfo(Triple, Opts); 164 case llvm::Triple::GNU: 165 return new MinGWARMTargetInfo(Triple, Opts); 166 case llvm::Triple::Itanium: 167 return new ItaniumWindowsARMleTargetInfo(Triple, Opts); 168 case llvm::Triple::MSVC: 169 default: // Assume MSVC for unknown environments 170 return new MicrosoftARMleTargetInfo(Triple, Opts); 171 } 172 default: 173 return new ARMleTargetInfo(Triple, Opts); 174 } 175 176 case llvm::Triple::armeb: 177 case llvm::Triple::thumbeb: 178 if (Triple.isOSDarwin()) 179 return new DarwinARMTargetInfo(Triple, Opts); 180 181 switch (os) { 182 case llvm::Triple::Linux: 183 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts); 184 case llvm::Triple::FreeBSD: 185 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 186 case llvm::Triple::NetBSD: 187 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 188 case llvm::Triple::OpenBSD: 189 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 190 case llvm::Triple::RTEMS: 191 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts); 192 case llvm::Triple::NaCl: 193 return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts); 194 default: 195 return new ARMbeTargetInfo(Triple, Opts); 196 } 197 198 case llvm::Triple::avr: 199 return new AVRTargetInfo(Triple, Opts); 200 case llvm::Triple::bpfeb: 201 case llvm::Triple::bpfel: 202 return new BPFTargetInfo(Triple, Opts); 203 204 case llvm::Triple::msp430: 205 return new MSP430TargetInfo(Triple, Opts); 206 207 case llvm::Triple::nios2: 208 return new LinuxTargetInfo<Nios2TargetInfo>(Triple, Opts); 209 210 case llvm::Triple::mips: 211 switch (os) { 212 case llvm::Triple::Linux: 213 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 214 case llvm::Triple::RTEMS: 215 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 216 case llvm::Triple::FreeBSD: 217 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 218 case llvm::Triple::NetBSD: 219 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 220 default: 221 return new MipsTargetInfo(Triple, Opts); 222 } 223 224 case llvm::Triple::mipsel: 225 switch (os) { 226 case llvm::Triple::Linux: 227 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 228 case llvm::Triple::RTEMS: 229 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 230 case llvm::Triple::FreeBSD: 231 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 232 case llvm::Triple::NetBSD: 233 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 234 case llvm::Triple::NaCl: 235 return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts); 236 default: 237 return new MipsTargetInfo(Triple, Opts); 238 } 239 240 case llvm::Triple::mips64: 241 switch (os) { 242 case llvm::Triple::Linux: 243 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 244 case llvm::Triple::RTEMS: 245 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 246 case llvm::Triple::FreeBSD: 247 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 248 case llvm::Triple::NetBSD: 249 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 250 case llvm::Triple::OpenBSD: 251 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 252 default: 253 return new MipsTargetInfo(Triple, Opts); 254 } 255 256 case llvm::Triple::mips64el: 257 switch (os) { 258 case llvm::Triple::Linux: 259 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 260 case llvm::Triple::RTEMS: 261 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 262 case llvm::Triple::FreeBSD: 263 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 264 case llvm::Triple::NetBSD: 265 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 266 case llvm::Triple::OpenBSD: 267 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 268 default: 269 return new MipsTargetInfo(Triple, Opts); 270 } 271 272 case llvm::Triple::le32: 273 switch (os) { 274 case llvm::Triple::NaCl: 275 return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts); 276 default: 277 return nullptr; 278 } 279 280 case llvm::Triple::le64: 281 return new Le64TargetInfo(Triple, Opts); 282 283 case llvm::Triple::ppc: 284 if (Triple.isOSDarwin()) 285 return new DarwinPPC32TargetInfo(Triple, Opts); 286 switch (os) { 287 case llvm::Triple::Linux: 288 return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts); 289 case llvm::Triple::FreeBSD: 290 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 291 case llvm::Triple::NetBSD: 292 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 293 case llvm::Triple::OpenBSD: 294 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 295 case llvm::Triple::RTEMS: 296 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts); 297 default: 298 return new PPC32TargetInfo(Triple, Opts); 299 } 300 301 case llvm::Triple::ppc64: 302 if (Triple.isOSDarwin()) 303 return new DarwinPPC64TargetInfo(Triple, Opts); 304 switch (os) { 305 case llvm::Triple::Linux: 306 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); 307 case llvm::Triple::Lv2: 308 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts); 309 case llvm::Triple::FreeBSD: 310 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 311 case llvm::Triple::NetBSD: 312 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 313 default: 314 return new PPC64TargetInfo(Triple, Opts); 315 } 316 317 case llvm::Triple::ppc64le: 318 switch (os) { 319 case llvm::Triple::Linux: 320 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); 321 case llvm::Triple::NetBSD: 322 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 323 default: 324 return new PPC64TargetInfo(Triple, Opts); 325 } 326 327 case llvm::Triple::nvptx: 328 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32); 329 case llvm::Triple::nvptx64: 330 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64); 331 332 case llvm::Triple::amdgcn: 333 case llvm::Triple::r600: 334 return new AMDGPUTargetInfo(Triple, Opts); 335 336 case llvm::Triple::sparc: 337 switch (os) { 338 case llvm::Triple::Linux: 339 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts); 340 case llvm::Triple::Solaris: 341 return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts); 342 case llvm::Triple::NetBSD: 343 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts); 344 case llvm::Triple::OpenBSD: 345 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts); 346 case llvm::Triple::RTEMS: 347 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts); 348 default: 349 return new SparcV8TargetInfo(Triple, Opts); 350 } 351 352 // The 'sparcel' architecture copies all the above cases except for Solaris. 353 case llvm::Triple::sparcel: 354 switch (os) { 355 case llvm::Triple::Linux: 356 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 357 case llvm::Triple::NetBSD: 358 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 359 case llvm::Triple::OpenBSD: 360 return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 361 case llvm::Triple::RTEMS: 362 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 363 default: 364 return new SparcV8elTargetInfo(Triple, Opts); 365 } 366 367 case llvm::Triple::sparcv9: 368 switch (os) { 369 case llvm::Triple::Linux: 370 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts); 371 case llvm::Triple::Solaris: 372 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts); 373 case llvm::Triple::NetBSD: 374 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 375 case llvm::Triple::OpenBSD: 376 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 377 case llvm::Triple::FreeBSD: 378 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 379 default: 380 return new SparcV9TargetInfo(Triple, Opts); 381 } 382 383 case llvm::Triple::systemz: 384 switch (os) { 385 case llvm::Triple::Linux: 386 return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts); 387 default: 388 return new SystemZTargetInfo(Triple, Opts); 389 } 390 391 case llvm::Triple::tce: 392 return new TCETargetInfo(Triple, Opts); 393 394 case llvm::Triple::tcele: 395 return new TCELETargetInfo(Triple, Opts); 396 397 case llvm::Triple::x86: 398 if (Triple.isOSDarwin()) 399 return new DarwinI386TargetInfo(Triple, Opts); 400 401 switch (os) { 402 case llvm::Triple::Ananas: 403 return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts); 404 case llvm::Triple::CloudABI: 405 return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts); 406 case llvm::Triple::Linux: { 407 switch (Triple.getEnvironment()) { 408 default: 409 return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts); 410 case llvm::Triple::Android: 411 return new AndroidX86_32TargetInfo(Triple, Opts); 412 } 413 } 414 case llvm::Triple::DragonFly: 415 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 416 case llvm::Triple::NetBSD: 417 return new NetBSDI386TargetInfo(Triple, Opts); 418 case llvm::Triple::OpenBSD: 419 return new OpenBSDI386TargetInfo(Triple, Opts); 420 case llvm::Triple::FreeBSD: 421 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 422 case llvm::Triple::KFreeBSD: 423 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 424 case llvm::Triple::Minix: 425 return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts); 426 case llvm::Triple::Solaris: 427 return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts); 428 case llvm::Triple::Win32: { 429 switch (Triple.getEnvironment()) { 430 case llvm::Triple::Cygnus: 431 return new CygwinX86_32TargetInfo(Triple, Opts); 432 case llvm::Triple::GNU: 433 return new MinGWX86_32TargetInfo(Triple, Opts); 434 case llvm::Triple::Itanium: 435 case llvm::Triple::MSVC: 436 default: // Assume MSVC for unknown environments 437 return new MicrosoftX86_32TargetInfo(Triple, Opts); 438 } 439 } 440 case llvm::Triple::Haiku: 441 return new HaikuX86_32TargetInfo(Triple, Opts); 442 case llvm::Triple::RTEMS: 443 return new RTEMSX86_32TargetInfo(Triple, Opts); 444 case llvm::Triple::NaCl: 445 return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts); 446 case llvm::Triple::ELFIAMCU: 447 return new MCUX86_32TargetInfo(Triple, Opts); 448 default: 449 return new X86_32TargetInfo(Triple, Opts); 450 } 451 452 case llvm::Triple::x86_64: 453 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) 454 return new DarwinX86_64TargetInfo(Triple, Opts); 455 456 switch (os) { 457 case llvm::Triple::Ananas: 458 return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts); 459 case llvm::Triple::CloudABI: 460 return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts); 461 case llvm::Triple::Linux: { 462 switch (Triple.getEnvironment()) { 463 default: 464 return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts); 465 case llvm::Triple::Android: 466 return new AndroidX86_64TargetInfo(Triple, Opts); 467 } 468 } 469 case llvm::Triple::DragonFly: 470 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 471 case llvm::Triple::NetBSD: 472 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 473 case llvm::Triple::OpenBSD: 474 return new OpenBSDX86_64TargetInfo(Triple, Opts); 475 case llvm::Triple::FreeBSD: 476 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 477 case llvm::Triple::Fuchsia: 478 return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts); 479 case llvm::Triple::KFreeBSD: 480 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 481 case llvm::Triple::Solaris: 482 return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts); 483 case llvm::Triple::Win32: { 484 switch (Triple.getEnvironment()) { 485 case llvm::Triple::Cygnus: 486 return new CygwinX86_64TargetInfo(Triple, Opts); 487 case llvm::Triple::GNU: 488 return new MinGWX86_64TargetInfo(Triple, Opts); 489 case llvm::Triple::MSVC: 490 default: // Assume MSVC for unknown environments 491 return new MicrosoftX86_64TargetInfo(Triple, Opts); 492 } 493 } 494 case llvm::Triple::Haiku: 495 return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts); 496 case llvm::Triple::NaCl: 497 return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts); 498 case llvm::Triple::PS4: 499 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts); 500 default: 501 return new X86_64TargetInfo(Triple, Opts); 502 } 503 504 case llvm::Triple::spir: { 505 if (Triple.getOS() != llvm::Triple::UnknownOS || 506 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 507 return nullptr; 508 return new SPIR32TargetInfo(Triple, Opts); 509 } 510 case llvm::Triple::spir64: { 511 if (Triple.getOS() != llvm::Triple::UnknownOS || 512 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 513 return nullptr; 514 return new SPIR64TargetInfo(Triple, Opts); 515 } 516 case llvm::Triple::wasm32: 517 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 518 Triple.getVendor() != llvm::Triple::UnknownVendor || 519 Triple.getOS() != llvm::Triple::UnknownOS || 520 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment || 521 !(Triple.isOSBinFormatELF() || Triple.isOSBinFormatWasm())) 522 return nullptr; 523 return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts); 524 case llvm::Triple::wasm64: 525 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 526 Triple.getVendor() != llvm::Triple::UnknownVendor || 527 Triple.getOS() != llvm::Triple::UnknownOS || 528 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment || 529 !(Triple.isOSBinFormatELF() || Triple.isOSBinFormatWasm())) 530 return nullptr; 531 return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts); 532 533 case llvm::Triple::renderscript32: 534 return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts); 535 case llvm::Triple::renderscript64: 536 return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts); 537 } 538 } 539 } // namespace targets 540 } // namespace clang 541 542 using namespace clang::targets; 543 /// CreateTargetInfo - Return the target info object for the specified target 544 /// options. 545 TargetInfo * 546 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, 547 const std::shared_ptr<TargetOptions> &Opts) { 548 llvm::Triple Triple(Opts->Triple); 549 550 // Construct the target 551 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts)); 552 if (!Target) { 553 Diags.Report(diag::err_target_unknown_triple) << Triple.str(); 554 return nullptr; 555 } 556 Target->TargetOpts = Opts; 557 558 // Set the target CPU if specified. 559 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) { 560 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; 561 return nullptr; 562 } 563 564 // Set the target ABI if specified. 565 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { 566 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; 567 return nullptr; 568 } 569 570 // Set the fp math unit. 571 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) { 572 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; 573 return nullptr; 574 } 575 576 // Compute the default target features, we need the target to handle this 577 // because features may have dependencies on one another. 578 llvm::StringMap<bool> Features; 579 if (!Target->initFeatureMap(Features, Diags, Opts->CPU, 580 Opts->FeaturesAsWritten)) 581 return nullptr; 582 583 // Add the features to the compile options. 584 Opts->Features.clear(); 585 for (const auto &F : Features) 586 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str()); 587 588 if (!Target->handleTargetFeatures(Opts->Features, Diags)) 589 return nullptr; 590 591 Target->setSupportedOpenCLOpts(); 592 Target->setOpenCLExtensionOpts(); 593 594 if (!Target->validateTarget(Diags)) 595 return nullptr; 596 597 return Target.release(); 598 } 599