InitPreprocessor.cpp Source File (original) (raw)

27#include "llvm/ADT/APFloat.h"

28#include "llvm/IR/DataLayout.h"

29#include "llvm/IR/DerivedTypes.h"

30using namespace clang;

33 while (!MacroBody.empty() && isWhitespace(MacroBody.back()))

34 MacroBody = MacroBody.drop_back();

35 return !MacroBody.empty() && MacroBody.back() == '\\';

36}

43 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');

44 StringRef MacroName = MacroPair.first;

45 StringRef MacroBody = MacroPair.second;

46 if (MacroName.size() != Macro.size()) {

48 StringRef::size_type End = MacroBody.find_first_of("\n\r");

49 if (End != StringRef::npos)

50 Diags.Report(diag::warn_fe_macro_contains_embedded_newline)

51 << MacroName;

52 MacroBody = MacroBody.substr(0, End);

57 Builder.defineMacro(MacroName, Twine(MacroBody) + "\\\n");

58 else

59 Builder.defineMacro(MacroName, MacroBody);

60 } else {

62 Builder.defineMacro(Macro);

63 }

64}

71 Builder.append(Twine("#include \"") + File + "\"");

72}

75 Builder.append(Twine("#__include_macros \"") + File + "\"");

77 Builder.append("##");

78}

84 StringRef ImplicitIncludePCH) {

86 std::string(ImplicitIncludePCH), PP.getFileManager(), PCHContainerRdr,

88 if (OriginalFile.empty())

89 return;

92}

96template

97static T PickFP(const llvm::fltSemantics *Sem, T IEEEHalfVal, T IEEESingleVal,

98 T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal,

99 T IEEEQuadVal) {

100 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEhalf())

101 return IEEEHalfVal;

102 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEsingle())

103 return IEEESingleVal;

104 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEdouble())

105 return IEEEDoubleVal;

106 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::x87DoubleExtended())

107 return X87DoubleExtendedVal;

108 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::PPCDoubleDouble())

109 return PPCDoubleDoubleVal;

110 assert(Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEquad());

111 return IEEEQuadVal;

112}

113

115 const llvm::fltSemantics *Sem, StringRef Ext) {

116 const char *DenormMin, *NormMax, *Epsilon, *Max, *Min;

117 NormMax = PickFP(Sem, "6.5504e+4", "3.40282347e+38",

118 "1.7976931348623157e+308", "1.18973149535723176502e+4932",

119 "8.98846567431157953864652595394501e+307",

120 "1.18973149535723176508575932662800702e+4932");

121 DenormMin = PickFP(Sem, "5.9604644775390625e-8", "1.40129846e-45",

122 "4.9406564584124654e-324", "3.64519953188247460253e-4951",

123 "4.94065645841246544176568792868221e-324",

124 "6.47517511943802511092443895822764655e-4966");

125 int Digits = PickFP(Sem, 3, 6, 15, 18, 31, 33);

126 int DecimalDigits = PickFP(Sem, 5, 9, 17, 21, 33, 36);

127 Epsilon = PickFP(Sem, "9.765625e-4", "1.19209290e-7",

128 "2.2204460492503131e-16", "1.08420217248550443401e-19",

129 "4.94065645841246544176568792868221e-324",

130 "1.92592994438723585305597794258492732e-34");

131 int MantissaDigits = PickFP(Sem, 11, 24, 53, 64, 106, 113);

132 int Min10Exp = PickFP(Sem, -4, -37, -307, -4931, -291, -4931);

133 int Max10Exp = PickFP(Sem, 4, 38, 308, 4932, 308, 4932);

134 int MinExp = PickFP(Sem, -13, -125, -1021, -16381, -968, -16381);

135 int MaxExp = PickFP(Sem, 16, 128, 1024, 16384, 1024, 16384);

136 Min = PickFP(Sem, "6.103515625e-5", "1.17549435e-38", "2.2250738585072014e-308",

137 "3.36210314311209350626e-4932",

138 "2.00416836000897277799610805135016e-292",

139 "3.36210314311209350626267781732175260e-4932");

140 Max = PickFP(Sem, "6.5504e+4", "3.40282347e+38", "1.7976931348623157e+308",

141 "1.18973149535723176502e+4932",

142 "1.79769313486231580793728971405301e+308",

143 "1.18973149535723176508575932662800702e+4932");

144

146 DefPrefix = "__";

147 DefPrefix += Prefix;

148 DefPrefix += "_";

149

150 Builder.defineMacro(DefPrefix + "DENORM_MIN__", Twine(DenormMin)+Ext);

151 Builder.defineMacro(DefPrefix + "NORM_MAX__", Twine(NormMax)+Ext);

152 Builder.defineMacro(DefPrefix + "HAS_DENORM__");

153 Builder.defineMacro(DefPrefix + "DIG__", Twine(Digits));

154 Builder.defineMacro(DefPrefix + "DECIMAL_DIG__", Twine(DecimalDigits));

155 Builder.defineMacro(DefPrefix + "EPSILON__", Twine(Epsilon)+Ext);

156 Builder.defineMacro(DefPrefix + "HAS_INFINITY__");

157 Builder.defineMacro(DefPrefix + "HAS_QUIET_NAN__");

158 Builder.defineMacro(DefPrefix + "MANT_DIG__", Twine(MantissaDigits));

159

160 Builder.defineMacro(DefPrefix + "MAX_10_EXP__", Twine(Max10Exp));

161 Builder.defineMacro(DefPrefix + "MAX_EXP__", Twine(MaxExp));

162 Builder.defineMacro(DefPrefix + "MAX__", Twine(Max)+Ext);

163

164 Builder.defineMacro(DefPrefix + "MIN_10_EXP__","("+Twine(Min10Exp)+")");

165 Builder.defineMacro(DefPrefix + "MIN_EXP__", "("+Twine(MinExp)+")");

166 Builder.defineMacro(DefPrefix + "MIN__", Twine(Min)+Ext);

167}

168

169

170

171

172

173static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth,

174 StringRef ValSuffix, bool isSigned,

176 llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth)

177 : llvm::APInt::getMaxValue(TypeWidth);

178 Builder.defineMacro(MacroName, toString(MaxVal, 10, isSigned) + ValSuffix);

179}

180

181

182

187}

188

193 auto Emitter = [&](char Fmt) {

194 Builder.defineMacro(Prefix + "_FMT" + Twine(Fmt) + "__",

195 Twine("\"") + FmtModifier + Twine(Fmt) + "\"");

196 };

198 llvm::for_each(StringRef(IsSigned ? "di" : "ouxX"), Emitter);

199

200

201

202 if (LangOpts.C23 && !IsSigned)

203 llvm::for_each(StringRef("bB"), Emitter);

204}

205

209}

210

213 Builder.defineMacro(MacroName, Twine(TI.getTypeWidth(Ty)));

214}

215

218 Builder.defineMacro(MacroName,

220}

221

222

223

224

230}

231

238

239

240

241 if (TypeWidth == 64)

243

244

245

246 if (TypeWidth == 16)

248

249 const char *Prefix = IsSigned ? "__INT" : "__UINT";

250

251 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);

252 DefineFmt(LangOpts, Prefix + Twine(TypeWidth), Ty, TI, Builder);

253

255 Builder.defineMacro(Prefix + Twine(TypeWidth) + "_C_SUFFIX__", ConstSuffix);

256}

257

263

264

265

266 if (TypeWidth == 64)

268

269

270

271 const char *Prefix = IsSigned ? "__INT" : "__UINT";

272 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);

273}

274

276 unsigned TypeWidth, bool IsSigned,

280 if (Ty == TargetInfo::NoInt)

281 return;

282

283 const char *Prefix = IsSigned ? "__INT_LEAST" : "__UINT_LEAST";

284 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);

285

286

287 if (IsSigned)

289 else

290 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);

291 DefineFmt(LangOpts, Prefix + Twine(TypeWidth), Ty, TI, Builder);

292}

293

297

298

300 if (Ty == TargetInfo::NoInt)

301 return;

302

303 const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST";

304 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);

305

306

307 if (IsSigned)

309 else

310 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);

311 DefineFmt(LangOpts, Prefix + Twine(TypeWidth), Ty, TI, Builder);

312}

313

314

315

316

318

319

320

321

323 return "2";

324

325

326 return "1";

327}

328

329

330

333 Builder.defineMacro("_GLIBCXX_PREDEFINED_OBJC_ARC_IS_SCALAR");

334

335 std::string Result;

336 {

337

338

339

340

341

342 llvm::raw_string_ostream Out(Result);

343

344 Out << "namespace std {\n"

345 << "\n"

346 << "struct __true_type;\n"

347 << "struct __false_type;\n"

348 << "\n";

349

350 Out << "template<typename _Tp> struct __is_scalar;\n"

351 << "\n";

352

353 if (LangOpts.ObjCAutoRefCount) {

354 Out << "template<typename _Tp>\n"

355 << "struct __is_scalar<__attribute__((objc_ownership(strong))) _Tp> {\n"

356 << " enum { __value = 0 };\n"

357 << " typedef __false_type __type;\n"

358 << "};\n"

359 << "\n";

360 }

361

362 if (LangOpts.ObjCWeak) {

363 Out << "template<typename _Tp>\n"

364 << "struct __is_scalar<__attribute__((objc_ownership(weak))) _Tp> {\n"

365 << " enum { __value = 0 };\n"

366 << " typedef __false_type __type;\n"

367 << "};\n"

368 << "\n";

369 }

370

371 if (LangOpts.ObjCAutoRefCount) {

372 Out << "template<typename _Tp>\n"

373 << "struct __is_scalar<__attribute__((objc_ownership(autoreleasing)))"

374 << " _Tp> {\n"

375 << " enum { __value = 0 };\n"

376 << " typedef __false_type __type;\n"

377 << "};\n"

378 << "\n";

379 }

380

381 Out << "}\n";

382 }

383 Builder.append(Result);

384}

385

390 if (LangOpts.HLSL) {

391 Builder.defineMacro("__hlsl_clang");

392

393 Builder.defineMacro("__HLSL_VERSION",

394 Twine((unsigned)LangOpts.getHLSLVersion()));

395

396 if (LangOpts.NativeHalfType)

397 Builder.defineMacro("__HLSL_ENABLE_16_BIT", "1");

398

399

400

401 Builder.defineMacro("__SHADER_STAGE_VERTEX",

402 Twine((uint32_t)ShaderStage::Vertex));

403 Builder.defineMacro("__SHADER_STAGE_PIXEL",

404 Twine((uint32_t)ShaderStage::Pixel));

405 Builder.defineMacro("__SHADER_STAGE_GEOMETRY",

406 Twine((uint32_t)ShaderStage::Geometry));

407 Builder.defineMacro("__SHADER_STAGE_HULL",

408 Twine((uint32_t)ShaderStage::Hull));

409 Builder.defineMacro("__SHADER_STAGE_DOMAIN",

410 Twine((uint32_t)ShaderStage::Domain));

411 Builder.defineMacro("__SHADER_STAGE_COMPUTE",

412 Twine((uint32_t)ShaderStage::Compute));

413 Builder.defineMacro("__SHADER_STAGE_AMPLIFICATION",

414 Twine((uint32_t)ShaderStage::Amplification));

415 Builder.defineMacro("__SHADER_STAGE_MESH",

416 Twine((uint32_t)ShaderStage::Mesh));

417 Builder.defineMacro("__SHADER_STAGE_LIBRARY",

418 Twine((uint32_t)ShaderStage::Library));

419

420 uint32_t StageInteger = static_cast<uint32_t>(

421 hlsl::getStageFromEnvironment(TI.getTriple().getEnvironment()));

422

423 Builder.defineMacro("__SHADER_TARGET_STAGE", Twine(StageInteger));

424

425 if (TI.getTriple().getOS() == llvm::Triple::ShaderModel) {

426 VersionTuple Version = TI.getTriple().getOSVersion();

427 Builder.defineMacro("__SHADER_TARGET_MAJOR", Twine(Version.getMajor()));

428 unsigned Minor = Version.getMinor().value_or(0);

429 Builder.defineMacro("__SHADER_TARGET_MINOR", Twine(Minor));

430 }

431 return;

432 }

433

434

435

436

437

438

439

440 if ((!LangOpts.MSVCCompat || LangOpts.MSVCEnableStdcMacro) &&

441 !LangOpts.TraditionalCPP)

442 Builder.defineMacro("__STDC__");

443

444

445

446 if (LangOpts.Freestanding)

447 Builder.defineMacro("__STDC_HOSTED__", "0");

448 else

449 Builder.defineMacro("__STDC_HOSTED__");

450

451

452

453

454

455 if (!LangOpts.CPlusPlus) {

456 if (LangOpts.C2y)

457 Builder.defineMacro("__STDC_VERSION__", "202400L");

458 else if (LangOpts.C23)

459 Builder.defineMacro("__STDC_VERSION__", "202311L");

460 else if (LangOpts.C17)

461 Builder.defineMacro("__STDC_VERSION__", "201710L");

462 else if (LangOpts.C11)

463 Builder.defineMacro("__STDC_VERSION__", "201112L");

464 else if (LangOpts.C99)

465 Builder.defineMacro("__STDC_VERSION__", "199901L");

466 else if (!LangOpts.GNUMode && LangOpts.Digraphs)

467 Builder.defineMacro("__STDC_VERSION__", "199409L");

468 } else {

469

470 if (LangOpts.CPlusPlus26)

471

472 Builder.defineMacro("__cplusplus", "202400L");

473 else if (LangOpts.CPlusPlus23)

474 Builder.defineMacro("__cplusplus", "202302L");

475

476 else if (LangOpts.CPlusPlus20)

477 Builder.defineMacro("__cplusplus", "202002L");

478

479 else if (LangOpts.CPlusPlus17)

480 Builder.defineMacro("__cplusplus", "201703L");

481

482

483 else if (LangOpts.CPlusPlus14)

484 Builder.defineMacro("__cplusplus", "201402L");

485

486

487 else if (LangOpts.CPlusPlus11)

488 Builder.defineMacro("__cplusplus", "201103L");

489

490

491 else

492 Builder.defineMacro("__cplusplus", "199711L");

493

494

495

496

497

498

499 Builder.defineMacro("__STDCPP_DEFAULT_NEW_ALIGNMENT__",

502

503

504

505

506 if (LangOpts.getThreadModel() == LangOptions::ThreadModelKind::POSIX)

507 Builder.defineMacro("__STDCPP_THREADS__", "1");

508 }

509

510

511

512

513

514

515 Builder.defineMacro("__STDC_UTF_16__", "1");

516 Builder.defineMacro("__STDC_UTF_32__", "1");

517

518

519 Builder.defineMacro("__STDC_EMBED_NOT_FOUND__",

520 llvm::itostr(static_cast<int>(EmbedResult::NotFound)));

521 Builder.defineMacro("__STDC_EMBED_FOUND__",

522 llvm::itostr(static_cast<int>(EmbedResult::Found)));

523 Builder.defineMacro("__STDC_EMBED_EMPTY__",

524 llvm::itostr(static_cast<int>(EmbedResult::Empty)));

525

526 if (LangOpts.ObjC)

527 Builder.defineMacro("__OBJC__");

528

529

530 if (LangOpts.OpenCL) {

531 if (LangOpts.CPlusPlus) {

532 switch (LangOpts.OpenCLCPlusPlusVersion) {

533 case 100:

534 Builder.defineMacro("__OPENCL_CPP_VERSION__", "100");

535 break;

536 case 202100:

537 Builder.defineMacro("__OPENCL_CPP_VERSION__", "202100");

538 break;

539 default:

540 llvm_unreachable("Unsupported C++ version for OpenCL");

541 }

542 Builder.defineMacro("__CL_CPP_VERSION_1_0__", "100");

543 Builder.defineMacro("__CL_CPP_VERSION_2021__", "202100");

544 } else {

545

546

547

548

549

550

551

552 switch (LangOpts.OpenCLVersion) {

553 case 100:

554 Builder.defineMacro("__OPENCL_C_VERSION__", "100");

555 break;

556 case 110:

557 Builder.defineMacro("__OPENCL_C_VERSION__", "110");

558 break;

559 case 120:

560 Builder.defineMacro("__OPENCL_C_VERSION__", "120");

561 break;

562 case 200:

563 Builder.defineMacro("__OPENCL_C_VERSION__", "200");

564 break;

565 case 300:

566 Builder.defineMacro("__OPENCL_C_VERSION__", "300");

567 break;

568 default:

569 llvm_unreachable("Unsupported OpenCL version");

570 }

571 }

572 Builder.defineMacro("CL_VERSION_1_0", "100");

573 Builder.defineMacro("CL_VERSION_1_1", "110");

574 Builder.defineMacro("CL_VERSION_1_2", "120");

575 Builder.defineMacro("CL_VERSION_2_0", "200");

576 Builder.defineMacro("CL_VERSION_3_0", "300");

577

579 Builder.defineMacro("__ENDIAN_LITTLE__");

580

581 if (LangOpts.FastRelaxedMath)

582 Builder.defineMacro("__FAST_RELAXED_MATH__");

583 }

584

585 if (LangOpts.SYCLIsDevice || LangOpts.SYCLIsHost) {

586

587 if (LangOpts.getSYCLVersion() == LangOptions::SYCL_2017)

588 Builder.defineMacro("CL_SYCL_LANGUAGE_VERSION", "121");

589 else if (LangOpts.getSYCLVersion() == LangOptions::SYCL_2020)

590 Builder.defineMacro("SYCL_LANGUAGE_VERSION", "202012L");

591 }

592

593

594 if (LangOpts.AsmPreprocessor)

595 Builder.defineMacro("__ASSEMBLER__");

596 if (LangOpts.CUDA) {

597 if (LangOpts.GPURelocatableDeviceCode)

598 Builder.defineMacro("__CLANG_RDC__");

599 if (!LangOpts.HIP)

600 Builder.defineMacro("__CUDA__");

602 LangOptions::GPUDefaultStreamKind::PerThread)

603 Builder.defineMacro("CUDA_API_PER_THREAD_DEFAULT_STREAM");

604 }

605 if (LangOpts.HIP) {

606 Builder.defineMacro("__HIP__");

607 Builder.defineMacro("__HIPCC__");

608 Builder.defineMacro("__HIP_MEMORY_SCOPE_SINGLETHREAD", "1");

609 Builder.defineMacro("__HIP_MEMORY_SCOPE_WAVEFRONT", "2");

610 Builder.defineMacro("__HIP_MEMORY_SCOPE_WORKGROUP", "3");

611 Builder.defineMacro("__HIP_MEMORY_SCOPE_AGENT", "4");

612 Builder.defineMacro("__HIP_MEMORY_SCOPE_SYSTEM", "5");

613 if (LangOpts.HIPStdPar) {

614 Builder.defineMacro("__HIPSTDPAR__");

615 if (LangOpts.HIPStdParInterposeAlloc)

616 Builder.defineMacro("__HIPSTDPAR_INTERPOSE_ALLOC__");

617 }

618 if (LangOpts.CUDAIsDevice) {

619 Builder.defineMacro("__HIP_DEVICE_COMPILE__");

621 Builder.defineMacro("__HIP_NO_IMAGE_SUPPORT__", "1");

622

623 Builder.defineMacro("__HIP_NO_IMAGE_SUPPORT", "1");

624 }

625 }

627 LangOptions::GPUDefaultStreamKind::PerThread) {

628 Builder.defineMacro("__HIP_API_PER_THREAD_DEFAULT_STREAM__");

629

630 Builder.defineMacro("HIP_API_PER_THREAD_DEFAULT_STREAM");

631 }

632 }

633

634 if (LangOpts.OpenACC) {

635

636

637

638

641 else

642 Builder.defineMacro("_OPENACC", "1");

643 }

644}

645

646

647

650

651 if (LangOpts.RTTI)

652 Builder.defineMacro("__cpp_rtti", "199711L");

653 if (LangOpts.CXXExceptions)

654 Builder.defineMacro("__cpp_exceptions", "199711L");

655

656

657 if (LangOpts.CPlusPlus11) {

658 Builder.defineMacro("__cpp_unicode_characters", "200704L");

659 Builder.defineMacro("__cpp_raw_strings", "200710L");

660 Builder.defineMacro("__cpp_unicode_literals", "200710L");

661 Builder.defineMacro("__cpp_user_defined_literals", "200809L");

662 Builder.defineMacro("__cpp_lambdas", "200907L");

663 Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus26 ? "202406L"

664 : LangOpts.CPlusPlus23 ? "202211L"

665 : LangOpts.CPlusPlus20 ? "201907L"

666 : LangOpts.CPlusPlus17 ? "201603L"

667 : LangOpts.CPlusPlus14 ? "201304L"

668 : "200704");

669 Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L");

670 Builder.defineMacro("__cpp_range_based_for",

671 LangOpts.CPlusPlus23 ? "202211L"

672 : LangOpts.CPlusPlus17 ? "201603L"

673 : "200907");

674

675

676 Builder.defineMacro("__cpp_static_assert", "202306L");

677 Builder.defineMacro("__cpp_decltype", "200707L");

678 Builder.defineMacro("__cpp_attributes", "200809L");

679 Builder.defineMacro("__cpp_rvalue_references", "200610L");

680 Builder.defineMacro("__cpp_variadic_templates", "200704L");

681 Builder.defineMacro("__cpp_initializer_lists", "200806L");

682 Builder.defineMacro("__cpp_delegating_constructors", "200604L");

683 Builder.defineMacro("__cpp_nsdmi", "200809L");

684 Builder.defineMacro("__cpp_inheriting_constructors", "201511L");

685 Builder.defineMacro("__cpp_ref_qualifiers", "200710L");

686 Builder.defineMacro("__cpp_alias_templates", "200704L");

687 }

688 if (LangOpts.ThreadsafeStatics)

689 Builder.defineMacro("__cpp_threadsafe_static_init", "200806L");

690

691

692 if (LangOpts.CPlusPlus14) {

693 Builder.defineMacro("__cpp_binary_literals", "201304L");

694 Builder.defineMacro("__cpp_digit_separators", "201309L");

695 Builder.defineMacro("__cpp_init_captures",

696 LangOpts.CPlusPlus20 ? "201803L" : "201304L");

697 Builder.defineMacro("__cpp_generic_lambdas",

698 LangOpts.CPlusPlus20 ? "201707L" : "201304L");

699 Builder.defineMacro("__cpp_decltype_auto", "201304L");

700 Builder.defineMacro("__cpp_return_type_deduction", "201304L");

701 Builder.defineMacro("__cpp_aggregate_nsdmi", "201304L");

702 Builder.defineMacro("__cpp_variable_templates", "201304L");

703 }

704 if (LangOpts.SizedDeallocation)

705 Builder.defineMacro("__cpp_sized_deallocation", "201309L");

706

707

708 if (LangOpts.CPlusPlus17) {

709 Builder.defineMacro("__cpp_hex_float", "201603L");

710 Builder.defineMacro("__cpp_inline_variables", "201606L");

711 Builder.defineMacro("__cpp_noexcept_function_type", "201510L");

712 Builder.defineMacro("__cpp_capture_star_this", "201603L");

713 Builder.defineMacro("__cpp_if_constexpr", "201606L");

714 Builder.defineMacro("__cpp_deduction_guides", "201703L");

715 Builder.defineMacro("__cpp_template_auto", "201606L");

716 Builder.defineMacro("__cpp_namespace_attributes", "201411L");

717 Builder.defineMacro("__cpp_enumerator_attributes", "201411L");

718 Builder.defineMacro("__cpp_nested_namespace_definitions", "201411L");

719 Builder.defineMacro("__cpp_variadic_using", "201611L");

720 Builder.defineMacro("__cpp_aggregate_bases", "201603L");

721 Builder.defineMacro("__cpp_structured_bindings", "202403L");

722 Builder.defineMacro("__cpp_nontype_template_args",

723 "201411L");

724 Builder.defineMacro("__cpp_fold_expressions", "201603L");

725 Builder.defineMacro("__cpp_guaranteed_copy_elision", "201606L");

726 Builder.defineMacro("__cpp_nontype_template_parameter_auto", "201606L");

727 }

728 if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)

729 Builder.defineMacro("__cpp_aligned_new", "201606L");

730 if (LangOpts.RelaxedTemplateTemplateArgs)

731 Builder.defineMacro("__cpp_template_template_args", "201611L");

732

733

734 if (LangOpts.CPlusPlus20) {

735 Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");

736

737 Builder.defineMacro("__cpp_concepts", "202002");

738 Builder.defineMacro("__cpp_conditional_explicit", "201806L");

739 Builder.defineMacro("__cpp_consteval", "202211L");

740 Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");

741 Builder.defineMacro("__cpp_constinit", "201907L");

742 Builder.defineMacro("__cpp_impl_coroutine", "201902L");

743 Builder.defineMacro("__cpp_designated_initializers", "201707L");

744 Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");

745

746 Builder.defineMacro("__cpp_using_enum", "201907L");

747 }

748

749 if (LangOpts.CPlusPlus23) {

750 Builder.defineMacro("__cpp_implicit_move", "202207L");

751 Builder.defineMacro("__cpp_size_t_suffix", "202011L");

752 Builder.defineMacro("__cpp_if_consteval", "202106L");

753 Builder.defineMacro("__cpp_multidimensional_subscript", "202211L");

754 Builder.defineMacro("__cpp_auto_cast", "202110L");

755 Builder.defineMacro("__cpp_explicit_this_parameter", "202110L");

756 }

757

758

759

760 if (LangOpts.CPlusPlus11)

761 Builder.defineMacro("__cpp_static_call_operator", "202207L");

762 Builder.defineMacro("__cpp_named_character_escapes", "202207L");

763 Builder.defineMacro("__cpp_placeholder_variables", "202306L");

764

765

766 Builder.defineMacro("__cpp_pack_indexing", "202311L");

767 Builder.defineMacro("__cpp_deleted_function", "202403L");

768 Builder.defineMacro("__cpp_variadic_friend", "202403L");

769

770 if (LangOpts.Char8)

771 Builder.defineMacro("__cpp_char8_t", "202207L");

772 Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");

773}

774

775

776

781

782

783 auto defineOpenCLExtMacro = [&](llvm::StringRef Name, auto... OptArgs) {

784

785

788 Builder.defineMacro(Name);

789 };

790#define OPENCL_GENERIC_EXTENSION(Ext, ...) \

791 defineOpenCLExtMacro(#Ext, __VA_ARGS__);

792#include "clang/Basic/OpenCLExtensions.def"

793

794

795 Builder.defineMacro("__opencl_c_int64");

796}

797

799 llvm::StringRef Suffix) {

800 if (Val.isSigned() && Val == llvm::APFixedPoint::getMin(Val.getSemantics())) {

801

802

803

804

805

806

807

808

809

810

812 Literal.push_back('(');

815 Literal += HalfStr;

816 Literal += HalfStr;

817 Literal.push_back(')');

818 return Literal;

819 }

820

822 Str += Suffix;

823 return Str;

824}

825

827 llvm::StringRef TypeName, llvm::StringRef Suffix,

828 unsigned Width, unsigned Scale, bool Signed) {

829

830

831 llvm::FixedPointSemantics FXSema(

832 Width, Scale, Signed, false,

836 Builder.defineMacro(MacroPrefix + "_EPSILON__",

838 llvm::APFixedPoint::getEpsilon(FXSema), Suffix));

839 Builder.defineMacro(MacroPrefix + "_FBIT__", Twine(Scale));

840 Builder.defineMacro(

841 MacroPrefix + "_MAX__",

843

844

845

847 Builder.defineMacro(

848 MacroPrefix + "_MIN__",

850}

851

857

858 Builder.defineMacro("__llvm__");

859 Builder.defineMacro("__clang__");

860#define TOSTR2(X) #X

861#define TOSTR(X) TOSTR2(X)

862 Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR));

863 Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR));

864 Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL));

865#undef TOSTR

866#undef TOSTR2

867 Builder.defineMacro("__clang_version__",

868 "\"" CLANG_VERSION_STRING " "

870

871 if (LangOpts.GNUCVersion != 0) {

872

873

874 unsigned GNUCMajor = LangOpts.GNUCVersion / 100 / 100;

875 unsigned GNUCMinor = LangOpts.GNUCVersion / 100 % 100;

876 unsigned GNUCPatch = LangOpts.GNUCVersion % 100;

877 Builder.defineMacro("__GNUC__", Twine(GNUCMajor));

878 Builder.defineMacro("__GNUC_MINOR__", Twine(GNUCMinor));

879 Builder.defineMacro("__GNUC_PATCHLEVEL__", Twine(GNUCPatch));

880 Builder.defineMacro("__GXX_ABI_VERSION", "1002");

881

882 if (LangOpts.CPlusPlus) {

883 Builder.defineMacro("__GNUG__", Twine(GNUCMajor));

884 Builder.defineMacro("__GXX_WEAK__");

885 }

886 }

887

888

889 Builder.defineMacro("__ATOMIC_RELAXED", "0");

890 Builder.defineMacro("__ATOMIC_CONSUME", "1");

891 Builder.defineMacro("__ATOMIC_ACQUIRE", "2");

892 Builder.defineMacro("__ATOMIC_RELEASE", "3");

893 Builder.defineMacro("__ATOMIC_ACQ_REL", "4");

894 Builder.defineMacro("__ATOMIC_SEQ_CST", "5");

895

896

897 Builder.defineMacro("__MEMORY_SCOPE_SYSTEM", "0");

898 Builder.defineMacro("__MEMORY_SCOPE_DEVICE", "1");

899 Builder.defineMacro("__MEMORY_SCOPE_WRKGRP", "2");

900 Builder.defineMacro("__MEMORY_SCOPE_WVFRNT", "3");

901 Builder.defineMacro("__MEMORY_SCOPE_SINGLE", "4");

902

903

904

905 static_assert(

910 "Invalid OpenCL memory scope enum definition");

911 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_ITEM", "0");

912 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_GROUP", "1");

913 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_DEVICE", "2");

914 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES", "3");

915 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_SUB_GROUP", "4");

916

917

918 Builder.defineMacro("__FPCLASS_SNAN", "0x0001");

919 Builder.defineMacro("__FPCLASS_QNAN", "0x0002");

920 Builder.defineMacro("__FPCLASS_NEGINF", "0x0004");

921 Builder.defineMacro("__FPCLASS_NEGNORMAL", "0x0008");

922 Builder.defineMacro("__FPCLASS_NEGSUBNORMAL", "0x0010");

923 Builder.defineMacro("__FPCLASS_NEGZERO", "0x0020");

924 Builder.defineMacro("__FPCLASS_POSZERO", "0x0040");

925 Builder.defineMacro("__FPCLASS_POSSUBNORMAL", "0x0080");

926 Builder.defineMacro("__FPCLASS_POSNORMAL", "0x0100");

927 Builder.defineMacro("__FPCLASS_POSINF", "0x0200");

928

929

930 Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");

931

932

933

934 Builder.defineMacro("__VERSION__", "\"" +

936

937

938

939

940 if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)

941 Builder.defineMacro("__STRICT_ANSI__");

942

943 if (LangOpts.GNUCVersion && LangOpts.CPlusPlus11)

944 Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");

945

946 if (TI.getTriple().isWindowsGNUEnvironment()) {

947

948

949 Builder.defineMacro("__GXX_TYPEINFO_EQUALITY_INLINE", "0");

950 }

951

952 if (LangOpts.ObjC) {

954 Builder.defineMacro("__OBJC2__");

955

956 if (LangOpts.ObjCExceptions)

957 Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS");

958 }

959

960 if (LangOpts.getGC() != LangOptions::NonGC)

961 Builder.defineMacro("__OBJC_GC__");

962

964 Builder.defineMacro("__NEXT_RUNTIME__");

965

968 std::string versionString = "1";

969

970

971

972 if (version >= VersionTuple(2, 0))

973 Builder.defineMacro("__OBJC_GNUSTEP_RUNTIME_ABI__", "20");

974 else

975 Builder.defineMacro(

976 "__OBJC_GNUSTEP_RUNTIME_ABI__",

977 "1" + Twine(std::min(8U, version.getMinor().value_or(0))));

978 }

979

982 unsigned minor = tuple.getMinor().value_or(0);

983 unsigned subminor = tuple.getSubminor().value_or(0);

984 Builder.defineMacro("__OBJFW_RUNTIME_ABI__",

985 Twine(tuple.getMajor() * 10000 + minor * 100 +

986 subminor));

987 }

988

989 Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))");

990 Builder.defineMacro("IBOutletCollection(ClassName)",

991 "__attribute__((iboutletcollection(ClassName)))");

992 Builder.defineMacro("IBAction", "void)__attribute__((ibaction)");

993 Builder.defineMacro("IBInspectable", "");

994 Builder.defineMacro("IB_DESIGNABLE", "");

995 }

996

997

998

999 Builder.defineMacro("__OBJC_BOOL_IS_BOOL",

1001

1002 if (LangOpts.CPlusPlus)

1004

1005

1006

1007 if (!LangOpts.NoConstantCFStrings)

1008 Builder.defineMacro("__CONSTANT_CFSTRINGS__");

1009

1010 if (LangOpts.ObjC)

1011 Builder.defineMacro("OBJC_NEW_PROPERTIES");

1012

1013 if (LangOpts.PascalStrings)

1014 Builder.defineMacro("__PASCAL_STRINGS__");

1015

1016 if (LangOpts.Blocks) {

1017 Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");

1018 Builder.defineMacro("__BLOCKS__");

1019 }

1020

1021 if (!LangOpts.MSVCCompat && LangOpts.Exceptions)

1022 Builder.defineMacro("__EXCEPTIONS");

1023 if (LangOpts.GNUCVersion && LangOpts.RTTI)

1024 Builder.defineMacro("__GXX_RTTI");

1025

1027 Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");

1029 Builder.defineMacro("__SEH__");

1032 Builder.defineMacro("__ARM_DWARF_EH__");

1034 Builder.defineMacro("__WASM_EXCEPTIONS__");

1035

1036 if (LangOpts.Deprecated)

1037 Builder.defineMacro("__DEPRECATED");

1038

1039 if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus)

1040 Builder.defineMacro("__private_extern__", "extern");

1041

1042 if (LangOpts.MicrosoftExt) {

1043 if (LangOpts.WChar) {

1044

1045 Builder.defineMacro("_WCHAR_T_DEFINED");

1046 Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED");

1047 }

1048 }

1049

1050

1051

1052

1053 Builder.defineMacro("__clang_literal_encoding__", "\"UTF-8\"");

1055

1056

1057 Builder.defineMacro("__clang_wide_literal_encoding__", "\"UTF-32\"");

1058 } else {

1059

1060

1061

1062 Builder.defineMacro("__clang_wide_literal_encoding__", "\"UTF-16\"");

1063 }

1064

1065 if (LangOpts.Optimize)

1066 Builder.defineMacro("__OPTIMIZE__");

1067 if (LangOpts.OptimizeSize)

1068 Builder.defineMacro("__OPTIMIZE_SIZE__");

1069

1070 if (LangOpts.FastMath)

1071 Builder.defineMacro("__FAST_MATH__");

1072

1073

1074

1075

1076

1077

1078

1079

1080 Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234");

1081 Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321");

1082 Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412");

1084 Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__");

1085 Builder.defineMacro("__BIG_ENDIAN__");

1086 } else {

1087 Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__");

1088 Builder.defineMacro("__LITTLE_ENDIAN__");

1089 }

1090

1093 Builder.defineMacro("_LP64");

1094 Builder.defineMacro("__LP64__");

1095 }

1096

1099 Builder.defineMacro("_ILP32");

1100 Builder.defineMacro("__ILP32__");

1101 }

1102

1103

1104 assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");

1105 Builder.defineMacro("__CHAR_BIT__", Twine(TI.getCharWidth()));

1106

1107

1108

1109

1110

1111

1112

1113

1114

1115 Builder.defineMacro("__BOOL_WIDTH__", "1");

1116 Builder.defineMacro("__SHRT_WIDTH__", Twine(TI.getShortWidth()));

1117 Builder.defineMacro("__INT_WIDTH__", Twine(TI.getIntWidth()));

1118 Builder.defineMacro("__LONG_WIDTH__", Twine(TI.getLongWidth()));

1119 Builder.defineMacro("__LLONG_WIDTH__", Twine(TI.getLongLongWidth()));

1120

1122 assert(BitIntMaxWidth <= llvm::IntegerType::MAX_INT_BITS &&

1123 "Target defined a max bit width larger than LLVM can support!");

1125 "Target defined a max bit width smaller than the C standard allows!");

1126 Builder.defineMacro("__BITINT_MAXWIDTH__", Twine(BitIntMaxWidth));

1127

1128 DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder);

1129 DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder);

1130 DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder);

1131 DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder);

1132 DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder);

1137

1140 Builder);

1143

1151 TI, Builder);

1155 Builder);

1164

1167 Builder.defineMacro("__INTMAX_C_SUFFIX__",

1171 Builder.defineMacro("__UINTMAX_C_SUFFIX__",

1175 Builder);

1183 if (LangOpts.C23)

1187

1190

1191

1192

1195 "uintptr_t and intptr_t have different widths?");

1198 "uintmax_t and intmax_t have different widths?");

1199

1200 if (LangOpts.FixedPoint) {

1201

1230

1231 Builder.defineMacro("__SACCUM_IBIT__", Twine(TI.getShortAccumIBits()));

1232 Builder.defineMacro("__USACCUM_IBIT__",

1234 Builder.defineMacro("__ACCUM_IBIT__", Twine(TI.getAccumIBits()));

1236 Builder.defineMacro("__LACCUM_IBIT__", Twine(TI.getLongAccumIBits()));

1237 Builder.defineMacro("__ULACCUM_IBIT__",

1239 }

1240

1246

1247

1248 Builder.defineMacro("__POINTER_WIDTH__",

1250

1251

1252 Builder.defineMacro("__BIGGEST_ALIGNMENT__",

1254

1255 if (!LangOpts.CharIsSigned)

1256 Builder.defineMacro("__CHAR_UNSIGNED__");

1257

1259 Builder.defineMacro("__WCHAR_UNSIGNED__");

1260

1262 Builder.defineMacro("__WINT_UNSIGNED__");

1263

1264

1266

1269

1272

1275

1278

1282

1287 }

1288

1293 }

1294

1299 }

1300

1303 Builder);

1306 }

1307

1316

1325

1326 Builder.defineMacro("__USER_LABEL_PREFIX__", TI.getUserLabelPrefix());

1327

1328 if (!LangOpts.MathErrno)

1329 Builder.defineMacro("__NO_MATH_ERRNO__");

1330

1331 if (LangOpts.FastMath || (LangOpts.NoHonorInfs && LangOpts.NoHonorNaNs))

1332 Builder.defineMacro("__FINITE_MATH_ONLY__", "1");

1333 else

1334 Builder.defineMacro("__FINITE_MATH_ONLY__", "0");

1335

1336 if (LangOpts.GNUCVersion) {

1337 if (LangOpts.GNUInline || LangOpts.CPlusPlus)

1338 Builder.defineMacro("__GNUC_GNU_INLINE__");

1339 else

1340 Builder.defineMacro("__GNUC_STDC_INLINE__");

1341

1342

1343

1344 Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");

1345 }

1346

1347

1348

1350 Builder.defineMacro("__GCC_DESTRUCTIVE_SIZE", Twine(Destructive));

1351 Builder.defineMacro("__GCC_CONSTRUCTIVE_SIZE", Twine(Constructive));

1352

1353

1354 Builder.append("#pragma push_macro(\"__GCC_DESTRUCTIVE_SIZE\")");

1355 Builder.append("#pragma push_macro(\"__GCC_CONSTRUCTIVE_SIZE\")");

1356

1357 auto addLockFreeMacros = [&](const llvm::Twine &Prefix) {

1358

1359#define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \

1360 Builder.defineMacro(Prefix + #TYPE "_LOCK_FREE", \

1361 getLockFreeValue(TI.get##Type##Width(), TI));

1364

1365

1366 if (LangOpts.Char8 || LangOpts.C23)

1375 Builder.defineMacro(

1376 Prefix + "POINTER_LOCK_FREE",

1378#undef DEFINE_LOCK_FREE_MACRO

1379 };

1380 addLockFreeMacros("__CLANG_ATOMIC_");

1381 if (LangOpts.GNUCVersion)

1382 addLockFreeMacros("__GCC_ATOMIC_");

1383

1384 if (LangOpts.NoInlineDefine)

1385 Builder.defineMacro("__NO_INLINE__");

1386

1387 if (unsigned PICLevel = LangOpts.PICLevel) {

1388 Builder.defineMacro("__PIC__", Twine(PICLevel));

1389 Builder.defineMacro("__pic__", Twine(PICLevel));

1390 if (LangOpts.PIE) {

1391 Builder.defineMacro("__PIE__", Twine(PICLevel));

1392 Builder.defineMacro("__pie__", Twine(PICLevel));

1393 }

1394 }

1395

1396

1397 Builder.defineMacro("__FLT_RADIX__", "2");

1398 Builder.defineMacro("__DECIMAL_DIG__", "__LDBL_DECIMAL_DIG__");

1399

1400 if (LangOpts.getStackProtector() == LangOptions::SSPOn)

1401 Builder.defineMacro("__SSP__");

1402 else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)

1403 Builder.defineMacro("__SSP_STRONG__", "2");

1404 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)

1405 Builder.defineMacro("__SSP_ALL__", "3");

1406

1408 Builder.defineMacro("__clang_analyzer__");

1409

1410 if (LangOpts.FastRelaxedMath)

1411 Builder.defineMacro("__FAST_RELAXED_MATH__");

1412

1414 LangOpts.getGC() != LangOptions::NonGC) {

1415 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");

1416 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");

1417 Builder.defineMacro("__autoreleasing", "");

1418 Builder.defineMacro("__unsafe_unretained", "");

1419 } else if (LangOpts.ObjC) {

1420 Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))");

1421 Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))");

1422 Builder.defineMacro("__autoreleasing",

1423 "__attribute__((objc_ownership(autoreleasing)))");

1424 Builder.defineMacro("__unsafe_unretained",

1425 "__attribute__((objc_ownership(none)))");

1426 }

1427

1428

1429

1430 if (TI.getTriple().isOSDarwin()) {

1431 Builder.defineMacro("__nonnull", "_Nonnull");

1432 Builder.defineMacro("__null_unspecified", "_Null_unspecified");

1433 Builder.defineMacro("__nullable", "_Nullable");

1434 }

1435

1436

1437

1438 if (TI.getTriple().isOSDarwin() && TI.getTriple().isSimulatorEnvironment())

1439 Builder.defineMacro("__APPLE_EMBEDDED_SIMULATOR__", "1");

1440

1441

1442

1443

1444

1445

1446

1447 if (!LangOpts.OpenMPSimd) {

1448 switch (LangOpts.OpenMP) {

1449 case 0:

1450 break;

1451 case 31:

1452 Builder.defineMacro("_OPENMP", "201107");

1453 break;

1454 case 40:

1455 Builder.defineMacro("_OPENMP", "201307");

1456 break;

1457 case 45:

1458 Builder.defineMacro("_OPENMP", "201511");

1459 break;

1460 case 50:

1461 Builder.defineMacro("_OPENMP", "201811");

1462 break;

1463 case 52:

1464 Builder.defineMacro("_OPENMP", "202111");

1465 break;

1466 default:

1467

1468 Builder.defineMacro("_OPENMP", "202011");

1469 break;

1470 }

1471 }

1472

1473

1474 if (LangOpts.CUDAIsDevice && !LangOpts.HIP) {

1475

1476

1477 Builder.defineMacro("__CUDA_ARCH__");

1478 }

1479

1480

1481

1482 if (LangOpts.GPUDeviceApproxTranscendentals)

1483 Builder.defineMacro("__CLANG_GPU_APPROX_TRANSCENDENTALS__");

1484

1485

1486

1487 if (LangOpts.SYCLIsDevice) {

1488 Builder.defineMacro("__SYCL_DEVICE_ONLY__", "1");

1489 }

1490

1491

1492 if (LangOpts.OpenCL) {

1494

1496 Builder.defineMacro("__IMAGE_SUPPORT__");

1497 }

1498

1499 if (TI.hasInt128Type() && LangOpts.CPlusPlus && LangOpts.GNUMode) {

1500

1501

1502

1503 Builder.defineMacro("__GLIBCXX_TYPE_INT_N_0", "__int128");

1504 Builder.defineMacro("__GLIBCXX_BITSIZE_INT_N_0", "128");

1505 }

1506

1507

1508 if (TI.getTriple().isOSBinFormatELF())

1509 Builder.defineMacro("__ELF__");

1510

1511

1513 const llvm::Triple &Triple = TI.getTriple();

1514#define TARGET_OS(Name, Predicate) \

1515 Builder.defineMacro(#Name, (Predicate) ? "1" : "0");

1516#include "clang/Basic/TargetOSMacros.def"

1517#undef TARGET_OS

1518 }

1519

1520

1522}

1523

1527 Builder.defineMacro("__LLVM_INSTR_PROFILE_GENERATE");

1528

1530 Builder.defineMacro("__LLVM_INSTR_PROFILE_USE");

1531}

1532

1533

1534

1541 std::string PredefineBuffer;

1542 PredefineBuffer.reserve(4080);

1543 llvm::raw_string_ostream Predefines(PredefineBuffer);

1545

1546

1547

1548

1549 Builder.append("# 1 \"\" 3");

1550

1551

1553

1554

1555 if ((LangOpts.CUDA || LangOpts.OpenMPIsTargetDevice ||

1556 LangOpts.SYCLIsDevice) &&

1560

1563

1564

1565

1566 if (LangOpts.ObjC && LangOpts.CPlusPlus &&

1567 (LangOpts.ObjCAutoRefCount || LangOpts.ObjCWeak)) {

1571 break;

1572

1575 break;

1576 }

1577 }

1578 }

1579

1580

1581

1582

1584 FEOpts, Builder);

1585

1586

1587

1588

1590

1591

1592

1593 Builder.append("# 1 \"\" 1");

1594

1595

1596 for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {

1597 if (InitOpts.Macros[i].second)

1598 Builder.undefineMacro(InitOpts.Macros[i].first);

1599 else

1602 }

1603

1604

1605 Builder.append("# 1 \"\" 2");

1606

1607

1608

1609 for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)

1611

1612

1616

1617

1618 for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {

1619 const std::string &Path = InitOpts.Includes[i];

1621 }

1622

1623

1626

1627

1629}

Defines the clang::FileManager interface and associated types.

Defines helper utilities for supporting the HLSL runtime environment.

static void AddImplicitIncludePCH(MacroBuilder &Builder, Preprocessor &PP, const PCHContainerReader &PCHContainerRdr, StringRef ImplicitIncludePCH)

Add an implicit #include using the original file used to generate a PCH file.

static void AddImplicitInclude(MacroBuilder &Builder, StringRef File)

AddImplicitInclude - Add an implicit #include of the specified file to the predefines buffer.

static void DefineTypeWidth(const Twine &MacroName, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)

static bool MacroBodyEndsInBackslash(StringRef MacroBody)

static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth, const TargetInfo &TI, MacroBuilder &Builder)

static void DefineFmt(const LangOptions &LangOpts, const Twine &Prefix, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)

static void InitializePredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, const PreprocessorOptions &PPOpts, MacroBuilder &Builder)

static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix, const llvm::fltSemantics *Sem, StringRef Ext)

static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth, StringRef ValSuffix, bool isSigned, MacroBuilder &Builder)

DefineTypeSize - Emit a macro to the predefines buffer that declares a macro named MacroName with the...

static void DefineExactWidthIntTypeSize(TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)

void DefineFixedPointMacros(const TargetInfo &TI, MacroBuilder &Builder, llvm::StringRef TypeName, llvm::StringRef Suffix, unsigned Width, unsigned Scale, bool Signed)

static void InitializePGOProfileMacros(const CodeGenOptions &CodeGenOpts, MacroBuilder &Builder)

void InitializeOpenCLFeatureTestMacros(const TargetInfo &TI, const LangOptions &Opts, MacroBuilder &Builder)

InitializeOpenCLFeatureTestMacros - Define OpenCL macros based on target settings and language versio...

static void AddImplicitIncludeMacros(MacroBuilder &Builder, StringRef File)

static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts, MacroBuilder &Builder)

Add definitions required for a smooth interaction between Objective-C++ automated reference counting ...

static void DefineExactWidthIntType(const LangOptions &LangOpts, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)

llvm::SmallString< 32 > ConstructFixedPointLiteral(llvm::APFixedPoint Val, llvm::StringRef Suffix)

static void DefineLeastWidthIntType(const LangOptions &LangOpts, unsigned TypeWidth, bool IsSigned, const TargetInfo &TI, MacroBuilder &Builder)

static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts, MacroBuilder &Builder)

Initialize the predefined C++ language feature test macros defined in ISO/IEC JTC1/SC22/WG21 (C++) SD...

static const char * getLockFreeValue(unsigned TypeWidth, const TargetInfo &TI)

Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with the specified properties.

static void DefineTypeSizeAndWidth(const Twine &Prefix, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)

static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty, MacroBuilder &Builder)

static T PickFP(const llvm::fltSemantics *Sem, T IEEEHalfVal, T IEEESingleVal, T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal, T IEEEQuadVal)

PickFP - This is used to pick a value based on the FP semantics of the specified FP model.

static void DefineBuiltinMacro(MacroBuilder &Builder, StringRef Macro, DiagnosticsEngine &Diags)

#define DEFINE_LOCK_FREE_MACRO(TYPE, Type)

static void InitializeStandardPredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, MacroBuilder &Builder)

static void DefineFastIntType(const LangOptions &LangOpts, unsigned TypeWidth, bool IsSigned, const TargetInfo &TI, MacroBuilder &Builder)

Defines the clang::MacroBuilder utility class.

Defines the clang::Preprocessor interface.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

Defines the SourceManager interface.

Provides definitions for the atomic synchronization scopes.

Defines version macros and version-related utility functions for Clang.

StringRef getOriginalSourceFile()

Retrieve the name of the original source file name for the primary module file.

CodeGenOptions - Track various options which control how the code is optimized and passed to the back...

bool hasProfileInstr() const

Check if any form of instrumentation is on.

bool hasProfileIRUse() const

Check if IR level profile use is on.

bool hasProfileClangUse() const

Check if Clang profile use is on.

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

FrontendOptions - Options for controlling the behavior of the frontend.

frontend::ActionKind ProgramAction

The frontend action to perform.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

bool hasWasmExceptions() const

clang::ObjCRuntime ObjCRuntime

bool hasSjLjExceptions() const

bool hasDWARFExceptions() const

bool hasSEHExceptions() const

std::string OpenACCMacroOverride

GPUDefaultStreamKind GPUDefaultStream

The default stream kind used for HIP kernel launching.

bool isNeXTFamily() const

Is this runtime basically of the NeXT family of runtimes?

const VersionTuple & getVersion() const

bool isNonFragile() const

Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?

@ GNUstep

'gnustep' is the modern non-fragile GNUstep runtime.

@ ObjFW

'objfw' is the Objective-C runtime included in ObjFW

static bool isOpenCLOptionAvailableIn(const LangOptions &LO, Args &&... args)

This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...

PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...

std::vector< std::string > MacroIncludes

std::vector< std::string > Includes

std::pair< unsigned, bool > PrecompiledPreambleBytes

If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...

ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary

The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...

bool DefineTargetOSMacros

Indicates whether to predefine target OS macros.

std::string ImplicitPCHInclude

The implicit PCH included at the start of the translation unit, or empty.

bool UsePredefines

Initialize the preprocessor with the compiler and target specific predefines.

bool SetUpStaticAnalyzer

Set up preprocessor for RunAnalysis action.

std::vector< std::pair< std::string, bool > > Macros

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

const TargetInfo * getAuxTargetInfo() const

const TargetInfo & getTargetInfo() const

FileManager & getFileManager() const

PreprocessorOptions & getPreprocessorOpts() const

Retrieve the preprocessor options used to initialize this preprocessor.

void setPredefines(std::string P)

Set the predefines for this Preprocessor.

void setSkipMainFilePreamble(unsigned Bytes, bool StartOfLine)

Instruct the preprocessor to skip part of the main source file.

const LangOptions & getLangOpts() const

DiagnosticsEngine & getDiagnostics() const

Exposes information about the current target.

unsigned getNewAlign() const

Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' is g...

unsigned getUnsignedLongFractScale() const

getUnsignedLongFractScale - Return the number of fractional bits in a 'unsigned long _Fract' type.

unsigned getShortWidth() const

getShortWidth/Align - Return the size of 'signed short' and 'unsigned short' for this target,...

unsigned getUnsignedAccumScale() const

getUnsignedAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned _Accum' ty...

unsigned getUnsignedAccumIBits() const

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

unsigned getAccumWidth() const

getAccumWidth/Align - Return the size of 'signed _Accum' and 'unsigned _Accum' for this target,...

IntType getUIntPtrType() const

IntType getInt64Type() const

unsigned getUnsignedFractScale() const

getUnsignedFractScale - Return the number of fractional bits in a 'unsigned _Fract' type.

virtual IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const

Return the smallest integer type with at least the specified width.

virtual bool hasFeatureEnabled(const llvm::StringMap< bool > &Features, StringRef Name) const

Check if target has a given feature enabled.

virtual size_t getMaxBitIntWidth() const

unsigned getTypeWidth(IntType T) const

Return the width (in bits) of the specified integer type enum.

unsigned getLongAccumScale() const

getLongAccumScale/IBits - Return the number of fractional/integral bits in a 'signed long _Accum' typ...

unsigned getLongFractScale() const

getLongFractScale - Return the number of fractional bits in a 'signed long _Fract' type.

uint64_t getPointerWidth(LangAS AddrSpace) const

Return the width of pointers on this target, for the specified address space.

static bool isTypeSigned(IntType T)

Returns true if the type is signed; false otherwise.

virtual std::pair< unsigned, unsigned > hardwareInterferenceSizes() const

The first value in the pair is the minimum offset between two objects to avoid false sharing (destruc...

bool useSignedCharForObjCBool() const

Check if the Objective-C built-in boolean type should be signed char.

virtual bool hasInt128Type() const

Determine whether the __int128 type is supported on this target.

unsigned getAccumIBits() const

IntType getSigAtomicType() const

unsigned getAccumScale() const

getAccumScale/IBits - Return the number of fractional/integral bits in a 'signed _Accum' type.

virtual bool hasFloat16Type() const

Determine whether the _Float16 type is supported on this target.

unsigned getIntWidth() const

getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...

IntType getPtrDiffType(LangAS AddrSpace) const

bool isLittleEndian() const

unsigned getShortAccumIBits() const

unsigned getFloatWidth() const

getFloatWidth/Align/Format - Return the size/align/format of 'float'.

unsigned getLongAccumIBits() const

IntType getSizeType() const

IntType getWIntType() const

virtual void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const =0

===-— Other target property query methods -----------------------—===//

unsigned getLongAccumWidth() const

getLongAccumWidth/Align - Return the size of 'signed long _Accum' and 'unsigned long _Accum' for this...

unsigned getShortAccumScale() const

getShortAccumScale/IBits - Return the number of fractional/integral bits in a 'signed short _Accum' t...

const llvm::fltSemantics & getDoubleFormat() const

static const char * getTypeName(IntType T)

Return the user string for the specified integer type enum.

unsigned getLongLongWidth() const

getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...

virtual bool hasBuiltinAtomic(uint64_t AtomicSizeInBits, uint64_t AlignmentInBits) const

Returns true if the given target supports lock-free atomic operations at the specified width and alig...

IntType getIntPtrType() const

IntType getInt16Type() const

const llvm::fltSemantics & getHalfFormat() const

llvm::StringMap< bool > & getSupportedOpenCLOpts()

Get supported OpenCL extensions and optional core features.

IntType getWCharType() const

IntType getUInt16Type() const

const char * getUserLabelPrefix() const

Returns the default value of the USER_LABEL_PREFIX macro, which is the prefix given to user symbols b...

IntType getChar16Type() const

unsigned getUnsignedShortAccumIBits() const

IntType getChar32Type() const

IntType getUInt64Type() const

unsigned getUnsignedLongAccumScale() const

getUnsignedLongAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned long _...

unsigned getUnsignedLongAccumIBits() const

unsigned getUnsignedShortFractScale() const

getUnsignedShortFractScale - Return the number of fractional bits in a 'unsigned short _Fract' type.

const llvm::fltSemantics & getLongDoubleFormat() const

const llvm::fltSemantics & getFloatFormat() const

const char * getTypeConstantSuffix(IntType T) const

Return the constant suffix for the specified integer type enum.

unsigned getDoubleWidth() const

getDoubleWidth/Align/Format - Return the size/align/format of 'double'.

unsigned getShortAccumWidth() const

getShortAccumWidth/Align - Return the size of 'signed short _Accum' and 'unsigned short _Accum' for t...

unsigned getSuitableAlign() const

Return the alignment that is the largest alignment ever used for any scalar/SIMD data type on the tar...

unsigned getCharWidth() const

unsigned getLongWidth() const

getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...

unsigned getLongFractWidth() const

getLongFractWidth/Align - Return the size of 'signed long _Fract' and 'unsigned long _Fract' for this...

IntType getIntMaxType() const

unsigned getFractScale() const

getFractScale - Return the number of fractional bits in a 'signed _Fract' type.

unsigned getFractWidth() const

getFractWidth/Align - Return the size of 'signed _Fract' and 'unsigned _Fract' for this target,...

unsigned getShortFractScale() const

getShortFractScale - Return the number of fractional bits in a 'signed short _Fract' type.

unsigned getShortFractWidth() const

getShortFractWidth/Align - Return the size of 'signed short _Fract' and 'unsigned short _Fract' for t...

virtual bool hasHIPImageSupport() const

Whether to support HIP image/texture API's.

static const char * getTypeFormatModifier(IntType T)

Return the printf format modifier for the specified integer type enum.

unsigned getUnsignedShortAccumScale() const

getUnsignedShortAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned short...

bool doUnsignedFixedPointTypesHavePadding() const

In the event this target uses the same number of fractional bits for its unsigned types as it does wi...

IntType getUIntMaxType() const

unsigned getLongDoubleWidth() const

getLongDoubleWidth/Align/Format - Return the size/align/format of 'long double'.

Defines the clang::TargetInfo interface.

@ RewriteObjC

ObjC->C Rewriter.

The JSON file list parser is used to communicate input to InstallAPI.

void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts, const CodeGenOptions &CodeGenOpts)

InitializePreprocessor - Initialize the preprocessor getting it and the environment ready to process ...

@ ARCXX_libstdcxx

libstdc++

LLVM_READONLY bool isWhitespace(unsigned char c)

Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...

const FunctionProtoType * T

std::string getClangFullRepositoryVersion()

Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...

std::string getClangFullCPPVersion()

Retrieves a string representing the complete clang version suitable for use in the CPP VERSION macro,...

IntType

===-— Target Data Type Query Methods ----------------------------—===//