contrib/llvm-project/clang/lib/Basic/Targets.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-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements construction of a TargetInfo object from a
  10 // 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/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/OSTargets.h"
  29 #include "Targets/PNaCl.h"
  30 #include "Targets/PPC.h"
  31 #include "Targets/RISCV.h"
  32 #include "Targets/SPIR.h"
  33 #include "Targets/Sparc.h"
  34 #include "Targets/SystemZ.h"
  35 #include "Targets/TCE.h"
  36 #include "Targets/VE.h"
  37 #include "Targets/WebAssembly.h"
  38 #include "Targets/X86.h"
  39 #include "Targets/XCore.h"
  40 #include "clang/Basic/Diagnostic.h"
  41 #include "llvm/ADT/StringExtras.h"
  42 #include "llvm/ADT/Triple.h"
  43
  44 using namespace clang;
  45
  46 namespace clang {
  47 namespace targets {
  48 //===----------------------------------------------------------------------===//
  49 //  Common code shared among targets.
  50 //===----------------------------------------------------------------------===//
  51
  52 /// DefineStd - Define a macro name and standard variants.  For example if
  53 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
  54 /// when in GNU mode.
  55 void DefineStd(MacroBuilder &Builder, StringRef MacroName,
  56                const LangOptions &Opts) {
  57   assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
  58
  59   // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
  60   // in the user's namespace.
  61   if (Opts.GNUMode)
  62     Builder.defineMacro(MacroName);
  63
  64   // Define __unix.
  65   Builder.defineMacro("__" + MacroName);
  66
  67   // Define __unix__.
  68   Builder.defineMacro("__" + MacroName + "__");
  69 }
  70
  71 void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) {
  72   Builder.defineMacro("__" + CPUName);
  73   Builder.defineMacro("__" + CPUName + "__");
  74   if (Tuning)
  75     Builder.defineMacro("__tune_" + CPUName + "__");
  76 }
  77
  78 void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
  79   // Mingw and cygwin define __declspec(a) to __attribute__((a)).  Clang
  80   // supports __declspec natively under -fms-extensions, but we define a no-op
  81   // __declspec macro anyway for pre-processor compatibility.
  82   if (Opts.MicrosoftExt)
  83     Builder.defineMacro("__declspec", "__declspec");
  84   else
  85     Builder.defineMacro("__declspec(a)", "__attribute__((a))");
  86
  87   if (!Opts.MicrosoftExt) {
  88     // Provide macros for all the calling convention keywords.  Provide both
  89     // single and double underscore prefixed variants.  These are available on
  90     // x64 as well as x86, even though they have no effect.
  91     const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
  92     for (const char *CC : CCs) {
  93       std::string GCCSpelling = "__attribute__((__";
  94       GCCSpelling += CC;
  95       GCCSpelling += "__))";
  96       Builder.defineMacro(Twine("_") + CC, GCCSpelling);
  97       Builder.defineMacro(Twine("__") + CC, GCCSpelling);
  98     }
  99   }
 100 }
 101
 102 //===----------------------------------------------------------------------===//
 103 // Driver code
 104 //===----------------------------------------------------------------------===//
 105
 106 TargetInfo *AllocateTarget(const llvm::Triple &Triple,
 107                            const TargetOptions &Opts) {
 108   llvm::Triple::OSType os = Triple.getOS();
 109
 110   switch (Triple.getArch()) {
 111   default:
 112     return nullptr;
 113
 114   case llvm::Triple::arc:
 115     return new ARCTargetInfo(Triple, Opts);
 116
 117   case llvm::Triple::xcore:
 118     return new XCoreTargetInfo(Triple, Opts);
 119
 120   case llvm::Triple::hexagon:
 121     if (os == llvm::Triple::Linux &&
 122         Triple.getEnvironment() == llvm::Triple::Musl)
 123       return new LinuxTargetInfo<HexagonTargetInfo>(Triple, Opts);
 124     return new HexagonTargetInfo(Triple, Opts);
 125
 126   case llvm::Triple::lanai:
 127     return new LanaiTargetInfo(Triple, Opts);
 128
 129   case llvm::Triple::aarch64_32:
 130     if (Triple.isOSDarwin())
 131       return new DarwinAArch64TargetInfo(Triple, Opts);
 132
 133     return nullptr;
 134   case llvm::Triple::aarch64:
 135     if (Triple.isOSDarwin())
 136       return new DarwinAArch64TargetInfo(Triple, Opts);
 137
 138     switch (os) {
 139     case llvm::Triple::CloudABI:
 140       return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
 141     case llvm::Triple::FreeBSD:
 142       return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
 143     case llvm::Triple::Fuchsia:
 144       return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts);
 145     case llvm::Triple::Linux:
 146       return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts);
 147     case llvm::Triple::NetBSD:
 148       return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
 149     case llvm::Triple::OpenBSD:
 150       return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
 151     case llvm::Triple::Win32:
 152       switch (Triple.getEnvironment()) {
 153       case llvm::Triple::GNU:
 154         return new MinGWARM64TargetInfo(Triple, Opts);
 155       case llvm::Triple::MSVC:
 156       default: // Assume MSVC for unknown environments
 157         return new MicrosoftARM64TargetInfo(Triple, Opts);
 158       }
 159     default:
 160       return new AArch64leTargetInfo(Triple, Opts);
 161     }
 162
 163   case llvm::Triple::aarch64_be:
 164     switch (os) {
 165     case llvm::Triple::FreeBSD:
 166       return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
 167     case llvm::Triple::Fuchsia:
 168       return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts);
 169     case llvm::Triple::Linux:
 170       return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts);
 171     case llvm::Triple::NetBSD:
 172       return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
 173     default:
 174       return new AArch64beTargetInfo(Triple, Opts);
 175     }
 176
 177   case llvm::Triple::arm:
 178   case llvm::Triple::thumb:
 179     if (Triple.isOSBinFormatMachO())
 180       return new DarwinARMTargetInfo(Triple, Opts);
 181
 182     switch (os) {
 183     case llvm::Triple::CloudABI:
 184       return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
 185     case llvm::Triple::Linux:
 186       return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts);
 187     case llvm::Triple::FreeBSD:
 188       return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
 189     case llvm::Triple::NetBSD:
 190       return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
 191     case llvm::Triple::OpenBSD:
 192       return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
 193     case llvm::Triple::RTEMS:
 194       return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts);
 195     case llvm::Triple::NaCl:
 196       return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts);
 197     case llvm::Triple::Win32:
 198       switch (Triple.getEnvironment()) {
 199       case llvm::Triple::Cygnus:
 200         return new CygwinARMTargetInfo(Triple, Opts);
 201       case llvm::Triple::GNU:
 202         return new MinGWARMTargetInfo(Triple, Opts);
 203       case llvm::Triple::Itanium:
 204         return new ItaniumWindowsARMleTargetInfo(Triple, Opts);
 205       case llvm::Triple::MSVC:
 206       default: // Assume MSVC for unknown environments
 207         return new MicrosoftARMleTargetInfo(Triple, Opts);
 208       }
 209     default:
 210       return new ARMleTargetInfo(Triple, Opts);
 211     }
 212
 213   case llvm::Triple::armeb:
 214   case llvm::Triple::thumbeb:
 215     if (Triple.isOSDarwin())
 216       return new DarwinARMTargetInfo(Triple, Opts);
 217
 218     switch (os) {
 219     case llvm::Triple::Linux:
 220       return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
 221     case llvm::Triple::FreeBSD:
 222       return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
 223     case llvm::Triple::NetBSD:
 224       return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
 225     case llvm::Triple::OpenBSD:
 226       return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
 227     case llvm::Triple::RTEMS:
 228       return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
 229     case llvm::Triple::NaCl:
 230       return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts);
 231     default:
 232       return new ARMbeTargetInfo(Triple, Opts);
 233     }
 234
 235   case llvm::Triple::avr:
 236     return new AVRTargetInfo(Triple, Opts);
 237   case llvm::Triple::bpfeb:
 238   case llvm::Triple::bpfel:
 239     return new BPFTargetInfo(Triple, Opts);
 240
 241   case llvm::Triple::msp430:
 242     return new MSP430TargetInfo(Triple, Opts);
 243
 244   case llvm::Triple::mips:
 245     switch (os) {
 246     case llvm::Triple::Linux:
 247       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
 248     case llvm::Triple::RTEMS:
 249       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
 250     case llvm::Triple::FreeBSD:
 251       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 252     case llvm::Triple::NetBSD:
 253       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 254     default:
 255       return new MipsTargetInfo(Triple, Opts);
 256     }
 257
 258   case llvm::Triple::mipsel:
 259     switch (os) {
 260     case llvm::Triple::Linux:
 261       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
 262     case llvm::Triple::RTEMS:
 263       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
 264     case llvm::Triple::FreeBSD:
 265       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 266     case llvm::Triple::NetBSD:
 267       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 268     case llvm::Triple::NaCl:
 269       return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts);
 270     default:
 271       return new MipsTargetInfo(Triple, Opts);
 272     }
 273
 274   case llvm::Triple::mips64:
 275     switch (os) {
 276     case llvm::Triple::Linux:
 277       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
 278     case llvm::Triple::RTEMS:
 279       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
 280     case llvm::Triple::FreeBSD:
 281       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 282     case llvm::Triple::NetBSD:
 283       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 284     case llvm::Triple::OpenBSD:
 285       return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 286     default:
 287       return new MipsTargetInfo(Triple, Opts);
 288     }
 289
 290   case llvm::Triple::mips64el:
 291     switch (os) {
 292     case llvm::Triple::Linux:
 293       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
 294     case llvm::Triple::RTEMS:
 295       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
 296     case llvm::Triple::FreeBSD:
 297       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 298     case llvm::Triple::NetBSD:
 299       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 300     case llvm::Triple::OpenBSD:
 301       return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
 302     default:
 303       return new MipsTargetInfo(Triple, Opts);
 304     }
 305
 306   case llvm::Triple::le32:
 307     switch (os) {
 308     case llvm::Triple::NaCl:
 309       return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts);
 310     default:
 311       return nullptr;
 312     }
 313
 314   case llvm::Triple::le64:
 315     return new Le64TargetInfo(Triple, Opts);
 316
 317   case llvm::Triple::ppc:
 318     if (Triple.isOSDarwin())
 319       return new DarwinPPC32TargetInfo(Triple, Opts);
 320     switch (os) {
 321     case llvm::Triple::Linux:
 322       return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
 323     case llvm::Triple::FreeBSD:
 324       return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
 325     case llvm::Triple::NetBSD:
 326       return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
 327     case llvm::Triple::OpenBSD:
 328       return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
 329     case llvm::Triple::RTEMS:
 330       return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts);
 331     case llvm::Triple::AIX:
 332       return new AIXPPC32TargetInfo(Triple, Opts);
 333     default:
 334       return new PPC32TargetInfo(Triple, Opts);
 335     }
 336
 337   case llvm::Triple::ppc64:
 338     if (Triple.isOSDarwin())
 339       return new DarwinPPC64TargetInfo(Triple, Opts);
 340     switch (os) {
 341     case llvm::Triple::Linux:
 342       return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
 343     case llvm::Triple::Lv2:
 344       return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts);
 345     case llvm::Triple::FreeBSD:
 346       return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
 347     case llvm::Triple::NetBSD:
 348       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
 349     case llvm::Triple::OpenBSD:
 350       return new OpenBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
 351     case llvm::Triple::AIX:
 352       return new AIXPPC64TargetInfo(Triple, Opts);
 353     default:
 354       return new PPC64TargetInfo(Triple, Opts);
 355     }
 356
 357   case llvm::Triple::ppc64le:
 358     switch (os) {
 359     case llvm::Triple::Linux:
 360       return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
 361     case llvm::Triple::NetBSD:
 362       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
 363     case llvm::Triple::OpenBSD:
 364       return new OpenBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
 365     default:
 366       return new PPC64TargetInfo(Triple, Opts);
 367     }
 368
 369   case llvm::Triple::nvptx:
 370     return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32);
 371   case llvm::Triple::nvptx64:
 372     return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64);
 373
 374   case llvm::Triple::amdgcn:
 375   case llvm::Triple::r600:
 376     return new AMDGPUTargetInfo(Triple, Opts);
 377
 378   case llvm::Triple::riscv32:
 379     // TODO: add cases for NetBSD, RTEMS once tested.
 380     switch (os) {
 381     case llvm::Triple::FreeBSD:
 382       return new FreeBSDTargetInfo<RISCV32TargetInfo>(Triple, Opts);
 383     case llvm::Triple::Linux:
 384       return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts);
 385     default:
 386       return new RISCV32TargetInfo(Triple, Opts);
 387     }
 388
 389   case llvm::Triple::riscv64:
 390     // TODO: add cases for NetBSD, RTEMS once tested.
 391     switch (os) {
 392     case llvm::Triple::FreeBSD:
 393       return new FreeBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts);
 394     case llvm::Triple::OpenBSD:
 395       return new OpenBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts);
 396     case llvm::Triple::Fuchsia:
 397       return new FuchsiaTargetInfo<RISCV64TargetInfo>(Triple, Opts);
 398     case llvm::Triple::Linux:
 399       return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts);
 400     default:
 401       return new RISCV64TargetInfo(Triple, Opts);
 402     }
 403
 404   case llvm::Triple::sparc:
 405     switch (os) {
 406     case llvm::Triple::Linux:
 407       return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts);
 408     case llvm::Triple::Solaris:
 409       return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts);
 410     case llvm::Triple::NetBSD:
 411       return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
 412     case llvm::Triple::OpenBSD:
 413       return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
 414     case llvm::Triple::RTEMS:
 415       return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts);
 416     default:
 417       return new SparcV8TargetInfo(Triple, Opts);
 418     }
 419
 420   // The 'sparcel' architecture copies all the above cases except for Solaris.
 421   case llvm::Triple::sparcel:
 422     switch (os) {
 423     case llvm::Triple::Linux:
 424       return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
 425     case llvm::Triple::NetBSD:
 426       return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
 427     case llvm::Triple::OpenBSD:
 428       return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
 429     case llvm::Triple::RTEMS:
 430       return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
 431     default:
 432       return new SparcV8elTargetInfo(Triple, Opts);
 433     }
 434
 435   case llvm::Triple::sparcv9:
 436     switch (os) {
 437     case llvm::Triple::Linux:
 438       return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts);
 439     case llvm::Triple::Solaris:
 440       return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts);
 441     case llvm::Triple::NetBSD:
 442       return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
 443     case llvm::Triple::OpenBSD:
 444       return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
 445     case llvm::Triple::FreeBSD:
 446       return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
 447     default:
 448       return new SparcV9TargetInfo(Triple, Opts);
 449     }
 450
 451   case llvm::Triple::systemz:
 452     switch (os) {
 453     case llvm::Triple::Linux:
 454       return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts);
 455     default:
 456       return new SystemZTargetInfo(Triple, Opts);
 457     }
 458
 459   case llvm::Triple::tce:
 460     return new TCETargetInfo(Triple, Opts);
 461
 462   case llvm::Triple::tcele:
 463     return new TCELETargetInfo(Triple, Opts);
 464
 465   case llvm::Triple::x86:
 466     if (Triple.isOSDarwin())
 467       return new DarwinI386TargetInfo(Triple, Opts);
 468
 469     switch (os) {
 470     case llvm::Triple::Ananas:
 471       return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
 472     case llvm::Triple::CloudABI:
 473       return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
 474     case llvm::Triple::Linux: {
 475       switch (Triple.getEnvironment()) {
 476       default:
 477         return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts);
 478       case llvm::Triple::Android:
 479         return new AndroidX86_32TargetInfo(Triple, Opts);
 480       }
 481     }
 482     case llvm::Triple::DragonFly:
 483       return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
 484     case llvm::Triple::NetBSD:
 485       return new NetBSDI386TargetInfo(Triple, Opts);
 486     case llvm::Triple::OpenBSD:
 487       return new OpenBSDI386TargetInfo(Triple, Opts);
 488     case llvm::Triple::FreeBSD:
 489       return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
 490     case llvm::Triple::Fuchsia:
 491       return new FuchsiaTargetInfo<X86_32TargetInfo>(Triple, Opts);
 492     case llvm::Triple::KFreeBSD:
 493       return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
 494     case llvm::Triple::Minix:
 495       return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts);
 496     case llvm::Triple::Solaris:
 497       return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts);
 498     case llvm::Triple::Win32: {
 499       switch (Triple.getEnvironment()) {
 500       case llvm::Triple::Cygnus:
 501         return new CygwinX86_32TargetInfo(Triple, Opts);
 502       case llvm::Triple::GNU:
 503         return new MinGWX86_32TargetInfo(Triple, Opts);
 504       case llvm::Triple::Itanium:
 505       case llvm::Triple::MSVC:
 506       default: // Assume MSVC for unknown environments
 507         return new MicrosoftX86_32TargetInfo(Triple, Opts);
 508       }
 509     }
 510     case llvm::Triple::Haiku:
 511       return new HaikuX86_32TargetInfo(Triple, Opts);
 512     case llvm::Triple::RTEMS:
 513       return new RTEMSX86_32TargetInfo(Triple, Opts);
 514     case llvm::Triple::NaCl:
 515       return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts);
 516     case llvm::Triple::ELFIAMCU:
 517       return new MCUX86_32TargetInfo(Triple, Opts);
 518     case llvm::Triple::Hurd:
 519       return new HurdTargetInfo<X86_32TargetInfo>(Triple, Opts);
 520     default:
 521       return new X86_32TargetInfo(Triple, Opts);
 522     }
 523
 524   case llvm::Triple::x86_64:
 525     if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
 526       return new DarwinX86_64TargetInfo(Triple, Opts);
 527
 528     switch (os) {
 529     case llvm::Triple::Ananas:
 530       return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
 531     case llvm::Triple::CloudABI:
 532       return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
 533     case llvm::Triple::Linux: {
 534       switch (Triple.getEnvironment()) {
 535       default:
 536         return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts);
 537       case llvm::Triple::Android:
 538         return new AndroidX86_64TargetInfo(Triple, Opts);
 539       }
 540     }
 541     case llvm::Triple::DragonFly:
 542       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
 543     case llvm::Triple::NetBSD:
 544       return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
 545     case llvm::Triple::OpenBSD:
 546       return new OpenBSDX86_64TargetInfo(Triple, Opts);
 547     case llvm::Triple::FreeBSD:
 548       return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
 549     case llvm::Triple::Fuchsia:
 550       return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts);
 551     case llvm::Triple::KFreeBSD:
 552       return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
 553     case llvm::Triple::Solaris:
 554       return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts);
 555     case llvm::Triple::Win32: {
 556       switch (Triple.getEnvironment()) {
 557       case llvm::Triple::Cygnus:
 558         return new CygwinX86_64TargetInfo(Triple, Opts);
 559       case llvm::Triple::GNU:
 560         return new MinGWX86_64TargetInfo(Triple, Opts);
 561       case llvm::Triple::MSVC:
 562       default: // Assume MSVC for unknown environments
 563         return new MicrosoftX86_64TargetInfo(Triple, Opts);
 564       }
 565     }
 566     case llvm::Triple::Haiku:
 567       return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts);
 568     case llvm::Triple::NaCl:
 569       return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts);
 570     case llvm::Triple::PS4:
 571       return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
 572     default:
 573       return new X86_64TargetInfo(Triple, Opts);
 574     }
 575
 576   case llvm::Triple::spir: {
 577     if (Triple.getOS() != llvm::Triple::UnknownOS ||
 578         Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
 579       return nullptr;
 580     return new SPIR32TargetInfo(Triple, Opts);
 581   }
 582   case llvm::Triple::spir64: {
 583     if (Triple.getOS() != llvm::Triple::UnknownOS ||
 584         Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
 585       return nullptr;
 586     return new SPIR64TargetInfo(Triple, Opts);
 587   }
 588   case llvm::Triple::wasm32:
 589     if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
 590         Triple.getVendor() != llvm::Triple::UnknownVendor ||
 591         !Triple.isOSBinFormatWasm())
 592       return nullptr;
 593     switch (Triple.getOS()) {
 594       case llvm::Triple::WASI:
 595         return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
 596       case llvm::Triple::Emscripten:
 597         return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
 598       case llvm::Triple::UnknownOS:
 599         return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
 600       default:
 601         return nullptr;
 602     }
 603   case llvm::Triple::wasm64:
 604     if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
 605         Triple.getVendor() != llvm::Triple::UnknownVendor ||
 606         !Triple.isOSBinFormatWasm())
 607       return nullptr;
 608     switch (Triple.getOS()) {
 609       case llvm::Triple::WASI:
 610         return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
 611       case llvm::Triple::Emscripten:
 612         return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
 613       case llvm::Triple::UnknownOS:
 614         return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
 615       default:
 616         return nullptr;
 617     }
 618
 619   case llvm::Triple::renderscript32:
 620     return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts);
 621   case llvm::Triple::renderscript64:
 622     return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts);
 623
 624   case llvm::Triple::ve:
 625     return new LinuxTargetInfo<VETargetInfo>(Triple, Opts);
 626   }
 627 }
 628 } // namespace targets
 629 } // namespace clang
 630
 631 using namespace clang::targets;
 632 /// CreateTargetInfo - Return the target info object for the specified target
 633 /// options.
 634 TargetInfo *
 635 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
 636                              const std::shared_ptr<TargetOptions> &Opts) {
 637   llvm::Triple Triple(Opts->Triple);
 638
 639   // Construct the target
 640   std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
 641   if (!Target) {
 642     Diags.Report(diag::err_target_unknown_triple) << Triple.str();
 643     return nullptr;
 644   }
 645   Target->TargetOpts = Opts;
 646
 647   // Set the target CPU if specified.
 648   if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
 649     Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
 650     SmallVector<StringRef, 32> ValidList;
 651     Target->fillValidCPUList(ValidList);
 652     if (!ValidList.empty())
 653       Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
 654     return nullptr;
 655   }
 656
 657   // Set the target ABI if specified.
 658   if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
 659     Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
 660     return nullptr;
 661   }
 662
 663   // Set the fp math unit.
 664   if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
 665     Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
 666     return nullptr;
 667   }
 668
 669   // Compute the default target features, we need the target to handle this
 670   // because features may have dependencies on one another.
 671   if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU,
 672                               Opts->FeaturesAsWritten))
 673     return nullptr;
 674
 675   // Add the features to the compile options.
 676   Opts->Features.clear();
 677   for (const auto &F : Opts->FeatureMap)
 678     Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
 679   // Sort here, so we handle the features in a predictable order. (This matters
 680   // when we're dealing with features that overlap.)
 681   llvm::sort(Opts->Features);
 682
 683   if (!Target->handleTargetFeatures(Opts->Features, Diags))
 684     return nullptr;
 685
 686   Target->setSupportedOpenCLOpts();
 687   Target->setOpenCLExtensionOpts();
 688   Target->setMaxAtomicWidth();
 689
 690   if (!Target->validateTarget(Diags))
 691     return nullptr;
 692
 693   Target->CheckFixedPointBits();
 694
 695   return Target.release();
 696 }