clang/unittests/Frontend/CompilerInvocationTest.cpp

   1 //===- unittests/Frontend/CompilerInvocationTest.cpp - CI tests //---------===//
   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 #include "clang/Frontend/CompilerInvocation.h"
  10 #include "clang/Basic/TargetOptions.h"
  11 #include "clang/Frontend/CompilerInstance.h"
  12 #include "clang/Frontend/TextDiagnosticBuffer.h"
  13 #include "clang/Lex/PreprocessorOptions.h"
  14 #include "clang/Serialization/ModuleFileExtension.h"
  15 #include "llvm/Support/Host.h"
  16
  17 #include "gmock/gmock.h"
  18 #include "gtest/gtest.h"
  19
  20 using namespace llvm;
  21 using namespace clang;
  22
  23 using ::testing::Contains;
  24 using ::testing::HasSubstr;
  25 using ::testing::StrEq;
  26
  27 namespace {
  28 class CommandLineTest : public ::testing::Test {
  29 public:
  30   IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
  31   SmallVector<const char *, 32> GeneratedArgs;
  32   SmallVector<std::string, 32> GeneratedArgsStorage;
  33   CompilerInvocation Invocation;
  34
  35   const char *operator()(const Twine &Arg) {
  36     return GeneratedArgsStorage.emplace_back(Arg.str()).c_str();
  37   }
  38
  39   CommandLineTest()
  40       : Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions(),
  41                                                   new TextDiagnosticBuffer())) {
  42   }
  43 };
  44
  45 template <typename M>
  46 std::string describeContainsN(M InnerMatcher, unsigned N, bool Negation) {
  47   StringRef Contains = Negation ? "doesn't contain" : "contains";
  48   StringRef Instance = N == 1 ? " instance " : " instances ";
  49   StringRef Element = "of element that ";
  50
  51   std::ostringstream Inner;
  52   InnerMatcher.impl().DescribeTo(&Inner);
  53
  54   return (Contains + " exactly " + Twine(N) + Instance + Element + Inner.str())
  55       .str();
  56 }
  57
  58 MATCHER_P2(ContainsN, InnerMatcher, N,
  59            describeContainsN(InnerMatcher, N, negation)) {
  60   auto InnerMatches = [this](const auto &Element) {
  61     ::testing::internal::DummyMatchResultListener InnerListener;
  62     return InnerMatcher.impl().MatchAndExplain(Element, &InnerListener);
  63   };
  64
  65   return count_if(arg, InnerMatches) == N;
  66 }
  67
  68 TEST(ContainsN, Empty) {
  69   const char *Array[] = {""};
  70
  71   ASSERT_THAT(Array, ContainsN(StrEq("x"), 0));
  72   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
  73   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
  74 }
  75
  76 TEST(ContainsN, Zero) {
  77   const char *Array[] = {"y"};
  78
  79   ASSERT_THAT(Array, ContainsN(StrEq("x"), 0));
  80   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
  81   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
  82 }
  83
  84 TEST(ContainsN, One) {
  85   const char *Array[] = {"a", "b", "x", "z"};
  86
  87   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 0)));
  88   ASSERT_THAT(Array, ContainsN(StrEq("x"), 1));
  89   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
  90 }
  91
  92 TEST(ContainsN, Two) {
  93   const char *Array[] = {"x", "a", "b", "x"};
  94
  95   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 0)));
  96   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
  97   ASSERT_THAT(Array, ContainsN(StrEq("x"), 2));
  98 }
  99
 100 // Boolean option with a keypath that defaults to true.
 101 // The only flag with a negative spelling can set the keypath to false.
 102
 103 TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagNotPresent) {
 104   const char *Args[] = {""};
 105
 106   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 107   ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);
 108
 109   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 110
 111   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-temp-file"))));
 112 }
 113
 114 TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagPresent) {
 115   const char *Args[] = {"-fno-temp-file"};
 116
 117   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 118   ASSERT_FALSE(Invocation.getFrontendOpts().UseTemporary);
 119
 120   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 121
 122   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-temp-file")));
 123 }
 124
 125 TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagUnknownPresent) {
 126   const char *Args[] = {"-ftemp-file"};
 127
 128   // Driver-only flag.
 129   ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 130   ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);
 131 }
 132
 133 // Boolean option with a keypath that defaults to true.
 134 // The flag with negative spelling can set the keypath to false.
 135 // The flag with positive spelling can reset the keypath to true.
 136
 137 TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNone) {
 138   const char *Args[] = {""};
 139
 140   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 141   ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);
 142
 143   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 144   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink"))));
 145   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-autolink"))));
 146 }
 147
 148 TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNegChange) {
 149   const char *Args[] = {"-fno-autolink"};
 150
 151   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 152   ASSERT_FALSE(Invocation.getCodeGenOpts().Autolink);
 153
 154   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 155   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-autolink")));
 156   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink"))));
 157 }
 158
 159 TEST_F(CommandLineTest, BoolOptionDefaultTruePresentPosReset) {
 160   const char *Args[] = {"-fautolink"};
 161
 162   // Driver-only flag.
 163   ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 164   ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);
 165 }
 166
 167 // Boolean option with a keypath that defaults to false.
 168 // The flag with negative spelling can set the keypath to true.
 169 // The flag with positive spelling can reset the keypath to false.
 170
 171 TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNone) {
 172   const char *Args[] = {""};
 173
 174   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 175   ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
 176
 177   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 178   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
 179   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-inline-line-tables"))));
 180 }
 181
 182 TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegChange) {
 183   const char *Args[] = {"-gno-inline-line-tables"};
 184
 185   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 186   ASSERT_TRUE(Invocation.getCodeGenOpts().NoInlineLineTables);
 187
 188   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 189   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gno-inline-line-tables")));
 190   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
 191 }
 192
 193 TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosReset) {
 194   const char *Args[] = {"-ginline-line-tables"};
 195
 196   // Driver-only flag.
 197   ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 198   ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
 199 }
 200
 201 // Boolean option with a keypath that defaults to false.
 202 // The flag with positive spelling can set the keypath to true.
 203 // The flag with negative spelling can reset the keypath to false.
 204
 205 TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNoneX) {
 206   const char *Args[] = {""};
 207
 208   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 209   ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
 210
 211   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 212   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gcodeview-ghash"))));
 213   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash"))));
 214 }
 215
 216 TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosChange) {
 217   const char *Args[] = {"-gcodeview-ghash"};
 218
 219   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 220   ASSERT_TRUE(Invocation.getCodeGenOpts().CodeViewGHash);
 221
 222   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 223   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gcodeview-ghash")));
 224   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash"))));
 225 }
 226
 227 TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegReset) {
 228   const char *Args[] = {"-gno-codeview-ghash"};
 229
 230   // Driver-only flag.
 231   ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 232   ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
 233 }
 234
 235 // Boolean option with a keypath that defaults to an arbitrary expression.
 236 // The flag with positive spelling can set the keypath to true.
 237 // The flag with negative spelling can set the keypath to false.
 238
 239 static constexpr unsigned PassManagerDefault =
 240     !static_cast<unsigned>(LLVM_ENABLE_NEW_PASS_MANAGER);
 241
 242 static constexpr const char *PassManagerResetByFlag =
 243     LLVM_ENABLE_NEW_PASS_MANAGER ? "-fno-legacy-pass-manager"
 244                                  : "-flegacy-pass-manager";
 245
 246 static constexpr const char *PassManagerChangedByFlag =
 247     LLVM_ENABLE_NEW_PASS_MANAGER ? "-flegacy-pass-manager"
 248                                  : "-fno-legacy-pass-manager";
 249
 250 TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentNone) {
 251   const char *Args = {""};
 252
 253   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 254   ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault);
 255
 256   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 257
 258   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
 259   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag))));
 260 }
 261
 262 TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentChange) {
 263   const char *Args[] = {PassManagerChangedByFlag};
 264
 265   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 266   ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, !PassManagerDefault);
 267
 268   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 269   ASSERT_THAT(GeneratedArgs, Contains(StrEq(PassManagerChangedByFlag)));
 270   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
 271 }
 272
 273 TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentReset) {
 274   const char *Args[] = {PassManagerResetByFlag};
 275
 276   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 277   ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault);
 278
 279   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 280   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
 281   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag))));
 282 }
 283
 284 // Boolean option that gets the CC1Option flag from a let statement (which
 285 // is applied **after** the record is defined):
 286 //
 287 //   let Flags = [CC1Option] in {
 288 //     defm option : BoolOption<...>;
 289 //   }
 290
 291 TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNone) {
 292   const char *Args[] = {""};
 293
 294   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 295   ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager);
 296
 297   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 298
 299   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager"))));
 300   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
 301 }
 302
 303 TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentPos) {
 304   const char *Args[] = {"-fdebug-pass-manager"};
 305
 306   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 307   ASSERT_TRUE(Invocation.getCodeGenOpts().DebugPassManager);
 308
 309   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 310
 311   ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fdebug-pass-manager"), 1));
 312   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
 313 }
 314
 315 TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNeg) {
 316   const char *Args[] = {"-fno-debug-pass-manager"};
 317
 318   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 319   ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager);
 320
 321   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 322
 323   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
 324   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager"))));
 325 }
 326
 327 TEST_F(CommandLineTest, CanGenerateCC1CommandLineFlag) {
 328   const char *Args[] = {"-fmodules-strict-context-hash"};
 329
 330   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 331
 332   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 333
 334   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fmodules-strict-context-hash")));
 335 }
 336
 337 TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparate) {
 338   const char *TripleCStr = "i686-apple-darwin9";
 339   const char *Args[] = {"-triple", TripleCStr};
 340
 341   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 342
 343   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 344
 345   ASSERT_THAT(GeneratedArgs, Contains(StrEq(TripleCStr)));
 346 }
 347
 348 TEST_F(CommandLineTest,  CanGenerateCC1CommandLineSeparateRequiredPresent) {
 349   const std::string DefaultTriple =
 350       llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
 351   const char *Args[] = {"-triple", DefaultTriple.c_str()};
 352
 353   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 354
 355   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 356
 357   // Triple should always be emitted even if it is the default
 358   ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
 359 }
 360
 361 TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) {
 362   const std::string DefaultTriple =
 363       llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
 364   const char *Args[] = {""};
 365
 366   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 367
 368   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 369
 370   // Triple should always be emitted even if it is the default
 371   ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
 372 }
 373
 374 TEST_F(CommandLineTest, SeparateEnumNonDefault) {
 375   const char *Args[] = {"-mrelocation-model", "static"};
 376
 377   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 378   ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::Static);
 379
 380   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 381
 382   // Non default relocation model.
 383   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-mrelocation-model")));
 384   ASSERT_THAT(GeneratedArgs, Contains(StrEq("static")));
 385   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=static"))));
 386 }
 387
 388 TEST_F(CommandLineTest, SeparateEnumDefault) {
 389   const char *Args[] = {"-mrelocation-model", "pic"};
 390
 391   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 392   ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::PIC_);
 393
 394   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 395
 396   // Default relocation model.
 397   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model"))));
 398   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("pic"))));
 399   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=pic"))));
 400 }
 401
 402 TEST_F(CommandLineTest, JoinedEnumNonDefault) {
 403   const char *Args[] = {"-fobjc-dispatch-method=non-legacy"};
 404
 405   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 406   ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(),
 407             CodeGenOptions::NonLegacy);
 408
 409   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 410
 411   ASSERT_THAT(GeneratedArgs,
 412               Contains(StrEq("-fobjc-dispatch-method=non-legacy")));
 413   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method="))));
 414   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("non-legacy"))));
 415 }
 416
 417 TEST_F(CommandLineTest, JoinedEnumDefault) {
 418   const char *Args[] = {"-fobjc-dispatch-method=legacy"};
 419
 420   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 421   ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(),
 422             CodeGenOptions::Legacy);
 423
 424   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 425
 426   ASSERT_THAT(GeneratedArgs,
 427               Not(Contains(StrEq("-fobjc-dispatch-method=legacy"))));
 428   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method="))));
 429   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("legacy"))));
 430 }
 431
 432 TEST_F(CommandLineTest, StringVectorEmpty) {
 433   const char *Args[] = {""};
 434
 435   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 436   ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles.empty());
 437
 438   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 439
 440   ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-fmodule-map-file"))));
 441 }
 442
 443 TEST_F(CommandLineTest, StringVectorSingle) {
 444   const char *Args[] = {"-fmodule-map-file=a"};
 445
 446   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 447   ASSERT_EQ(Invocation.getFrontendOpts().ModuleMapFiles,
 448             std::vector<std::string>({"a"}));
 449
 450   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 451
 452   ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1));
 453   ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 1));
 454 }
 455
 456 TEST_F(CommandLineTest, StringVectorMultiple) {
 457   const char *Args[] = {"-fmodule-map-file=a", "-fmodule-map-file=b"};
 458
 459   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 460   ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles ==
 461               std::vector<std::string>({"a", "b"}));
 462
 463   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 464
 465   ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1));
 466   ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=b"), 1));
 467   ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 2));
 468 }
 469
 470 // CommaJoined option with MarshallingInfoStringVector.
 471
 472 TEST_F(CommandLineTest, StringVectorCommaJoinedNone) {
 473   const char *Args[] = {""};
 474
 475   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 476   ASSERT_TRUE(Invocation.getLangOpts()->CommentOpts.BlockCommandNames.empty());
 477
 478   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 479
 480   ASSERT_THAT(GeneratedArgs,
 481               Not(Contains(HasSubstr("-fcomment-block-commands"))));
 482 }
 483
 484 TEST_F(CommandLineTest, StringVectorCommaJoinedSingle) {
 485   const char *Args[] = {"-fcomment-block-commands=x,y"};
 486
 487   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 488   ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames,
 489             std::vector<std::string>({"x", "y"}));
 490
 491   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 492
 493   ASSERT_THAT(GeneratedArgs,
 494               ContainsN(StrEq("-fcomment-block-commands=x,y"), 1));
 495 }
 496
 497 TEST_F(CommandLineTest, StringVectorCommaJoinedMultiple) {
 498   const char *Args[] = {"-fcomment-block-commands=x,y",
 499                         "-fcomment-block-commands=a,b"};
 500
 501   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 502   ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames,
 503             std::vector<std::string>({"x", "y", "a", "b"}));
 504
 505   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 506
 507   ASSERT_THAT(GeneratedArgs,
 508               ContainsN(StrEq("-fcomment-block-commands=x,y,a,b"), 1));
 509 }
 510
 511 // A flag that should be parsed only if a condition is met.
 512
 513 TEST_F(CommandLineTest, ConditionalParsingIfFalseFlagNotPresent) {
 514   const char *Args[] = {""};
 515
 516   CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
 517
 518   ASSERT_FALSE(Diags->hasErrorOccurred());
 519   ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsDevice);
 520   ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
 521   ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);
 522
 523   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 524
 525   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl"))));
 526   ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
 527 }
 528
 529 TEST_F(CommandLineTest, ConditionalParsingIfFalseFlagPresent) {
 530   const char *Args[] = {"-sycl-std=2017"};
 531
 532   CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
 533
 534   ASSERT_FALSE(Diags->hasErrorOccurred());
 535   ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsDevice);
 536   ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
 537   ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);
 538
 539   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 540
 541   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-device"))));
 542   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
 543   ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
 544 }
 545
 546 TEST_F(CommandLineTest, ConditionalParsingIfTrueFlagNotPresent) {
 547   const char *Args[] = {"-fsycl-is-host"};
 548
 549   CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
 550
 551   ASSERT_FALSE(Diags->hasErrorOccurred());
 552   ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);
 553
 554   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 555
 556   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-host")));
 557   ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
 558 }
 559
 560 TEST_F(CommandLineTest, ConditionalParsingIfTrueFlagPresent) {
 561   const char *Args[] = {"-fsycl-is-device", "-sycl-std=2017"};
 562
 563   CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
 564
 565   ASSERT_FALSE(Diags->hasErrorOccurred());
 566   ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);
 567
 568   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 569
 570   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
 571   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-sycl-std=2017")));
 572 }
 573
 574 // Wide integer option.
 575
 576 TEST_F(CommandLineTest, WideIntegerHighValue) {
 577   const char *Args[] = {"-fbuild-session-timestamp=1609827494445723662"};
 578
 579   CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
 580
 581   ASSERT_FALSE(Diags->hasErrorOccurred());
 582   ASSERT_EQ(Invocation.getHeaderSearchOpts().BuildSessionTimestamp,
 583             1609827494445723662ull);
 584 }
 585
 586 // Tree of boolean options that can be (directly or transitively) implied by
 587 // their parent:
 588 //
 589 //   * -cl-unsafe-math-optimizations
 590 //     * -cl-mad-enable
 591 //     * -menable-unsafe-fp-math
 592 //       * -freciprocal-math
 593
 594 TEST_F(CommandLineTest, ImpliedBoolOptionsNoFlagPresent) {
 595   const char *Args[] = {""};
 596
 597   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 598   ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
 599   ASSERT_FALSE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
 600   ASSERT_FALSE(Invocation.getLangOpts()->UnsafeFPMath);
 601   ASSERT_FALSE(Invocation.getLangOpts()->AllowRecip);
 602
 603   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 604
 605   // Not generated - missing.
 606   ASSERT_THAT(GeneratedArgs,
 607               Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
 608   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
 609   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
 610   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
 611 }
 612
 613 TEST_F(CommandLineTest, ImpliedBoolOptionsRootFlagPresent) {
 614   const char *Args[] = {"-cl-unsafe-math-optimizations"};
 615
 616   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 617   // Explicitly provided root flag.
 618   ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
 619   // Directly implied by explicitly provided root flag.
 620   ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
 621   ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
 622   // Transitively implied by explicitly provided root flag.
 623   ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
 624
 625   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 626
 627   // Generated - explicitly provided.
 628   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
 629   // Not generated - implied by the generated root flag.
 630   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
 631   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
 632   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
 633 }
 634
 635 TEST_F(CommandLineTest, ImpliedBoolOptionsAllFlagsPresent) {
 636   const char *Args[] = {"-cl-unsafe-math-optimizations", "-cl-mad-enable",
 637                         "-menable-unsafe-fp-math", "-freciprocal-math"};
 638
 639   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 640   ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
 641   ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
 642   ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
 643   ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
 644
 645   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 646
 647   // Generated - explicitly provided.
 648   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
 649   // Not generated - implied by their generated parent.
 650   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
 651   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
 652   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
 653 }
 654
 655 TEST_F(CommandLineTest, ImpliedBoolOptionsImpliedFlagsPresent) {
 656   const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math",
 657                         "-freciprocal-math"};
 658
 659   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 660   ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
 661   ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
 662   ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
 663   ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
 664
 665   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 666   // Not generated - missing.
 667   ASSERT_THAT(GeneratedArgs,
 668               Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
 669   // Generated - explicitly provided.
 670   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
 671   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
 672   // Not generated - implied by its generated parent.
 673   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
 674 }
 675
 676 TEST_F(CommandLineTest, PresentAndNotImpliedGenerated) {
 677   const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math"};
 678
 679   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 680
 681   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 682
 683   // Present options that were not implied are generated.
 684   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
 685   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
 686 }
 687
 688 // Diagnostic option.
 689
 690 TEST_F(CommandLineTest, DiagnosticOptionPresent) {
 691   const char *Args[] = {"-verify=xyz"};
 692
 693   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 694
 695   ASSERT_EQ(Invocation.getDiagnosticOpts().VerifyPrefixes,
 696             std::vector<std::string>({"xyz"}));
 697
 698   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 699
 700   ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-verify=xyz"), 1));
 701 }
 702
 703 // Option default depends on language standard.
 704
 705 TEST_F(CommandLineTest, DigraphsImplied) {
 706   const char *Args[] = {""};
 707
 708   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 709   ASSERT_TRUE(Invocation.getLangOpts()->Digraphs);
 710
 711   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 712   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-digraphs"))));
 713   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
 714 }
 715
 716 TEST_F(CommandLineTest, DigraphsDisabled) {
 717   const char *Args[] = {"-fno-digraphs"};
 718
 719   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 720   ASSERT_FALSE(Invocation.getLangOpts()->Digraphs);
 721
 722   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 723   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-digraphs")));
 724   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
 725 }
 726
 727 TEST_F(CommandLineTest, DigraphsNotImplied) {
 728   const char *Args[] = {"-std=c89"};
 729
 730   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 731   ASSERT_FALSE(Invocation.getLangOpts()->Digraphs);
 732
 733   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 734   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-digraphs"))));
 735   ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
 736 }
 737
 738 TEST_F(CommandLineTest, DigraphsEnabled) {
 739   const char *Args[] = {"-std=c89", "-fdigraphs"};
 740
 741   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 742   ASSERT_TRUE(Invocation.getLangOpts()->Digraphs);
 743
 744   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 745   ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fdigraphs")));
 746 }
 747
 748 struct DummyModuleFileExtension
 749     : public llvm::RTTIExtends<DummyModuleFileExtension, ModuleFileExtension> {
 750   static char ID;
 751
 752   ModuleFileExtensionMetadata getExtensionMetadata() const override {
 753     return {};
 754   };
 755
 756   llvm::hash_code hashExtension(llvm::hash_code Code) const override {
 757     return {};
 758   }
 759
 760   std::unique_ptr<ModuleFileExtensionWriter>
 761   createExtensionWriter(ASTWriter &Writer) override {
 762     return {};
 763   }
 764
 765   std::unique_ptr<ModuleFileExtensionReader>
 766   createExtensionReader(const ModuleFileExtensionMetadata &Metadata,
 767                         ASTReader &Reader, serialization::ModuleFile &Mod,
 768                         const llvm::BitstreamCursor &Stream) override {
 769     return {};
 770   }
 771 };
 772
 773 char DummyModuleFileExtension::ID = 0;
 774
 775 TEST_F(CommandLineTest, TestModuleFileExtension) {
 776   const char *Args[] = {"-ftest-module-file-extension=first:2:1:0:first",
 777                         "-ftest-module-file-extension=second:3:2:1:second"};
 778
 779   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 780   ASSERT_THAT(Invocation.getFrontendOpts().ModuleFileExtensions.size(), 2);
 781
 782   // Exercise the check that only serializes instances of
 783   // TestModuleFileExtension by providing an instance of another
 784   // ModuleFileExtension subclass.
 785   Invocation.getFrontendOpts().ModuleFileExtensions.push_back(
 786       std::make_shared<DummyModuleFileExtension>());
 787
 788   Invocation.generateCC1CommandLine(GeneratedArgs, *this);
 789
 790   ASSERT_THAT(GeneratedArgs,
 791               ContainsN(HasSubstr("-ftest-module-file-extension="), 2));
 792   ASSERT_THAT(
 793       GeneratedArgs,
 794       Contains(StrEq("-ftest-module-file-extension=first:2:1:0:first")));
 795   ASSERT_THAT(
 796       GeneratedArgs,
 797       Contains(StrEq("-ftest-module-file-extension=second:3:2:1:second")));
 798 }
 799
 800 TEST_F(CommandLineTest, RoundTrip) {
 801   // Testing one marshalled and one manually generated option from each
 802   // CompilerInvocation member.
 803   const char *Args[] = {
 804       "-round-trip-args",
 805       // LanguageOptions
 806       "-std=c17",
 807       "-fmax-tokens=10",
 808       // TargetOptions
 809       "-target-sdk-version=1.2.3",
 810       "-meabi",
 811       "4",
 812       // DiagnosticOptions
 813       "-Wundef-prefix=XY",
 814       "-fdiagnostics-format",
 815       "clang",
 816       // HeaderSearchOptions
 817       "-stdlib=libc++",
 818       "-fimplicit-module-maps",
 819       // PreprocessorOptions
 820       "-DXY=AB",
 821       "-include-pch",
 822       "a.pch",
 823       // AnalyzerOptions
 824       "-analyzer-config",
 825       "ctu-import-threshold=42",
 826       "-unoptimized-cfg",
 827       // MigratorOptions (no manually handled arguments)
 828       "-no-ns-alloc-error",
 829       // CodeGenOptions
 830       "-debug-info-kind=limited",
 831       "-debug-info-macro",
 832       // DependencyOutputOptions
 833       "--show-includes",
 834       "-H",
 835       // FileSystemOptions (no manually handled arguments)
 836       "-working-directory",
 837       "folder",
 838       // FrontendOptions
 839       "-load",
 840       "plugin",
 841       "-ast-merge",
 842       // PreprocessorOutputOptions
 843       "-dD",
 844       "-CC",
 845   };
 846
 847   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
 848
 849   ASSERT_TRUE(Invocation.getLangOpts()->C17);
 850   ASSERT_EQ(Invocation.getLangOpts()->MaxTokens, 10u);
 851
 852   ASSERT_EQ(Invocation.getTargetOpts().SDKVersion, llvm::VersionTuple(1, 2, 3));
 853   ASSERT_EQ(Invocation.getTargetOpts().EABIVersion, EABI::EABI4);
 854
 855   ASSERT_THAT(Invocation.getDiagnosticOpts().UndefPrefixes,
 856               Contains(StrEq("XY")));
 857   ASSERT_EQ(Invocation.getDiagnosticOpts().getFormat(),
 858             TextDiagnosticFormat::Clang);
 859
 860   ASSERT_TRUE(Invocation.getHeaderSearchOpts().UseLibcxx);
 861   ASSERT_TRUE(Invocation.getHeaderSearchOpts().ImplicitModuleMaps);
 862
 863   ASSERT_THAT(Invocation.getPreprocessorOpts().Macros,
 864               Contains(std::make_pair(std::string("XY=AB"), false)));
 865   ASSERT_EQ(Invocation.getPreprocessorOpts().ImplicitPCHInclude, "a.pch");
 866
 867   ASSERT_EQ(Invocation.getAnalyzerOpts()->Config["ctu-import-threshold"], "42");
 868   ASSERT_TRUE(Invocation.getAnalyzerOpts()->UnoptimizedCFG);
 869
 870   ASSERT_TRUE(Invocation.getMigratorOpts().NoNSAllocReallocError);
 871
 872   ASSERT_EQ(Invocation.getCodeGenOpts().getDebugInfo(),
 873             codegenoptions::DebugInfoKind::LimitedDebugInfo);
 874   ASSERT_TRUE(Invocation.getCodeGenOpts().MacroDebugInfo);
 875
 876   ASSERT_EQ(Invocation.getDependencyOutputOpts().ShowIncludesDest,
 877             ShowIncludesDestination::Stdout);
 878   ASSERT_TRUE(Invocation.getDependencyOutputOpts().ShowHeaderIncludes);
 879 }
 880 } // anonymous namespace