clang/test/Driver/cl-pch.cpp

   1 // Note: %s and %S must be preceded by --, otherwise it may be interpreted as a
   2 // command-line option, e.g. on Mac where %s is commonly under /Users.
   3
   4 // /Yc
   5 // RUN: %clang_cl -Werror /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
   6 // RUN:   | FileCheck -check-prefix=CHECK-YC %s
   7 // 1. Build .pch file.
   8 // CHECK-YC: cc1
   9 // CHECK-YC: -emit-pch
  10 // CHECK-YC: -building-pch-with-obj
  11 // CHECK-YC: -o
  12 // CHECK-YC: pchfile.pch
  13 // CHECK-YC: -x
  14 // CHECK-YC: "c++-header"
  15 // 2. Use .pch file.
  16 // CHECK-YC: cc1
  17 // CHECK-YC: -emit-obj
  18 // CHECK-YC: -building-pch-with-obj
  19 // CHECK-YC: -include-pch
  20 // CHECK-YC: pchfile.pch
  21
  22 // /Yc /Fo
  23 // /Fo overrides the .obj output filename, but not the .pch filename
  24 // RUN: %clang_cl -Werror /Fomyobj.obj /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
  25 // RUN:   | FileCheck -check-prefix=CHECK-YCO %s
  26 // 1. Build .pch file.
  27 // CHECK-YCO: cc1
  28 // CHECK-YCO: -emit-pch
  29 // CHECK-YCO: -building-pch-with-obj
  30 // CHECK-YCO: -o
  31 // CHECK-YCO: pchfile.pch
  32 // 2. Use .pch file.
  33 // CHECK-YCO: cc1
  34 // CHECK-YCO: -emit-obj
  35 // CHECK-YCO: -building-pch-with-obj
  36 // CHECK-YCO: -include-pch
  37 // CHECK-YCO: pchfile.pch
  38 // CHECK-YCO: -o
  39 // CHECK-YCO: myobj.obj
  40
  41 // /Yc /Y-
  42 // /Y- disables pch generation
  43 // RUN: %clang_cl -Werror /Y- /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
  44 // RUN:   | FileCheck -check-prefix=CHECK-YC-Y_ %s
  45 // CHECK-YC-Y_-NOT: -emit-pch
  46 // CHECK-YC-Y_-NOT: -include-pch
  47
  48 // /Yu
  49 // RUN: %clang_cl -Werror /Yupchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
  50 // RUN:   | FileCheck -check-prefix=CHECK-YU %s
  51 // Use .pch file, but don't build it.
  52 // CHECK-YU-NOT: -emit-pch
  53 // CHECK-YU-NOT: -building-pch-with-obj
  54 // CHECK-YU: cc1
  55 // CHECK-YU: -emit-obj
  56 // CHECK-YU: -include-pch
  57 // CHECK-YU: pchfile.pch
  58
  59 // /Yu /Y-
  60 // RUN: %clang_cl -Werror /Y- /Yupchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
  61 // RUN:   | FileCheck -check-prefix=CHECK-YU-Y_ %s
  62 // CHECK-YU-Y_-NOT: -emit-pch
  63 // CHECK-YU-Y_-NOT: -include-pch
  64
  65 // /Yc /Yu -- /Yc overrides /Yc if they both refer to the same file
  66 // RUN: %clang_cl -Werror /Ycpchfile.h /Yupchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
  67 // RUN:   | FileCheck -check-prefix=CHECK-YC-YU %s
  68 // 1. Build .pch file.
  69 // CHECK-YC-YU: cc1
  70 // CHECK-YC-YU: -emit-pch
  71 // CHECK-YC-YU: -building-pch-with-obj
  72 // CHECK-YC-YU: -o
  73 // CHECK-YC-YU: pchfile.pch
  74 // 2. Use .pch file.
  75 // CHECK-YC-YU: cc1
  76 // CHECK-YC-YU: -emit-obj
  77 // CHECK-YC-YU: -include-pch
  78 // CHECK-YC-YU: pchfile.pch
  79
  80 // If /Yc /Yu refer to different files, semantics are pretty wonky.  Since this
  81 // doesn't seem like something that's important in practice, just punt for now.
  82 // RUN: not %clang_cl -Werror /Ycfoo1.h /Yufoo2.h /FIfoo1.h /FIfoo2.h /c -### -- %s 2>&1 \
  83 // RUN:   | FileCheck -check-prefix=CHECK-YC-YU-MISMATCH %s
  84 // CHECK-YC-YU-MISMATCH: error: support for '/Yc' and '/Yu' with different filenames not implemented yet; flags ignored
  85
  86 // Similarly, punt on /Yc with more than one input file.
  87 // RUN: not %clang_cl -Werror /Ycfoo1.h /FIfoo1.h /c -### -- %s %s 2>&1 \
  88 // RUN:   | FileCheck -check-prefix=CHECK-YC-MULTIINPUT %s
  89 // CHECK-YC-MULTIINPUT: error: support for '/Yc' with more than one source file not implemented yet; flag ignored
  90
  91 // /Yc /Yu /Y-
  92 // RUN: %clang_cl -Werror /Ycpchfile.h /Yupchfile.h /FIpchfile.h /Y- /c -### -- %s 2>&1 \
  93 // RUN:   | FileCheck -check-prefix=CHECK-YC-YU-Y_ %s
  94 // CHECK-YC-YU-Y_-NOT: -emit-pch
  95 // CHECK-YC-YU-Y_-NOT: -include-pch
  96
  97 // Test computation of pch filename in various cases.
  98
  99 // /Yu /Fpout.pch => out.pch is filename
 100 // RUN: %clang_cl -Werror /Yupchfile.h /FIpchfile.h /Fpout.pch /c -### -- %s 2>&1 \
 101 // RUN:   | FileCheck -check-prefix=CHECK-YUFP1 %s
 102 // /Yu /Fp:out.pch => out.pch is filename
 103 // RUN: %clang_cl -Werror /Yupchfile.h /FIpchfile.h /Fp:out.pch /c -### -- %s 2>&1 \
 104 // RUN:   | FileCheck -check-prefix=CHECK-YUFP1 %s
 105 // /Yu /Fp: out.pch => out.pch is filename
 106 // RUN: %clang_cl -Werror /Yupchfile.h /FIpchfile.h /Fp: out.pch /c -### -- %s 2>&1 \
 107 // RUN:   | FileCheck -check-prefix=CHECK-YUFP1 %s
 108 // Use .pch file, but don't build it.
 109 // CHECK-YUFP1: -include-pch
 110 // CHECK-YUFP1: out.pch
 111
 112 // /Yu /Fpout => out.pch is filename (.pch gets added if no extension present)
 113 // RUN: %clang_cl -Werror /Yupchfile.h /FIpchfile.h /Fpout.pch /c -### -- %s 2>&1 \
 114 // RUN:   | FileCheck -check-prefix=CHECK-YUFP2 %s
 115 // Use .pch file, but don't build it.
 116 // CHECK-YUFP2: -include-pch
 117 // CHECK-YUFP2: out.pch
 118
 119 // /Yu /Fpout.bmp => out.bmp is filename (.pch not added when extension present)
 120 // RUN: %clang_cl -Werror /Yupchfile.h /FIpchfile.h /Fpout.bmp /c -### -- %s 2>&1 \
 121 // RUN:   | FileCheck -check-prefix=CHECK-YUFP3 %s
 122 // Use .pch file, but don't build it.
 123 // CHECK-YUFP3: -include-pch
 124 // CHECK-YUFP3: out.bmp
 125
 126 // /Yusub/dir.h => sub/dir.pch
 127 // RUN: %clang_cl -Werror /Yusub/pchfile.h /FIsub/pchfile.h /c -### -- %s 2>&1 \
 128 // RUN:   | FileCheck -check-prefix=CHECK-YUFP4 %s
 129 // Use .pch file, but don't build it.
 130 // CHECK-YUFP4: -include-pch
 131 // CHECK-YUFP4: sub/pchfile.pch
 132
 133 // /Yudir.h /Isub => dir.pch
 134 // RUN: %clang_cl -Werror /Yupchfile.h /FIpchfile.h /Isub /c -### -- %s 2>&1 \
 135 // RUN:   | FileCheck -check-prefix=CHECK-YUFP5 %s
 136 // Use .pch file, but don't build it.
 137 // CHECK-YUFP5: -include-pch
 138 // CHECK-YUFP5: pchfile.pch
 139
 140 // FIXME: /Fpdir: use dir/VCx0.pch when dir is directory, where x is major MSVS
 141 // version in use.
 142
 143 // Spot-check one use of /Fp with /Yc too, else trust the /Yu test cases above
 144 // also all assume to /Yc.
 145 // RUN: %clang_cl -Werror /Ycpchfile.h /FIpchfile.h /Fpsub/file.pch /c -### -- %s 2>&1 \
 146 // RUN:   | FileCheck -check-prefix=CHECK-YCFP %s
 147 // 1. Build .pch file.
 148 // CHECK-YCFP: cc1
 149 // CHECK-YCFP: -emit-pch
 150 // CHECK-YCFP: -o
 151 // CHECK-YCFP: sub/file.pch
 152 // 2. Use .pch file.
 153 // CHECK-YCFP: cc1
 154 // CHECK-YCFP: -emit-obj
 155 // CHECK-YCFP: -include-pch
 156 // CHECK-YCFP: sub/file.pch
 157
 158 // /Ycfoo2.h /FIfoo1.h /FIfoo2.h /FIfoo3.h
 159 // => foo1 and foo2 go into pch, foo3 into main compilation
 160 // /Yc
 161 // RUN: %clang_cl -Werror /Ycfoo2.h /FIfoo1.h /FIfoo2.h /FIfoo3.h /c -### -- %s 2>&1 \
 162 // RUN:   | FileCheck -check-prefix=CHECK-YCFIFIFI %s
 163 // 1. Build .pch file: Includes foo1.h (but NOT foo3.h) and compiles foo2.h
 164 // CHECK-YCFIFIFI: cc1
 165 // CHECK-YCFIFIFI: -emit-pch
 166 // CHECK-YCFIFIFI: -pch-through-header=foo2.h
 167 // CHECK-YCFIFIFI: -include
 168 // CHECK-YCFIFIFI: foo1.h
 169 // CHECK-YCFIFIFI: -include
 170 // CHECK-YCFIFIFI: foo2.h
 171 // CHECK-YCFIFIFI: -include
 172 // CHECK-YCFIFIFI: foo3.h
 173 // CHECK-YCFIFIFI: -o
 174 // CHECK-YCFIFIFI: foo2.pch
 175 // CHECK-YCFIFIFI: -x
 176 // CHECK-YCFIFIFI: "c++-header"
 177 // CHECK-YCFIFIFI: cl-pch.cpp
 178 // 2. Use .pch file: Inlucdes foo2.pch and foo3.h
 179 // CHECK-YCFIFIFI: cc1
 180 // CHECK-YCFIFIFI: -emit-obj
 181 // CHECK-YCFIFIFI: -include-pch
 182 // CHECK-YCFIFIFI: foo2.pch
 183 // CHECK-YCFIFIFI: -pch-through-header=foo2.h
 184 // CHECK-YCFIFIFI: -include
 185 // CHECK-YCFIFIFI: foo1.h
 186 // CHECK-YCFIFIFI: -include
 187 // CHECK-YCFIFIFI: foo2.h
 188 // CHECK-YCFIFIFI: -include
 189 // CHECK-YCFIFIFI: foo3.h
 190 // CHECK-YCFIFIFI: -o
 191 // CHECK-YCFIFIFI: cl-pch.obj
 192 // CHECK-YCFIFIFI: -x
 193 // CHECK-YCFIFIFI: "c++"
 194 // CHECK-YCFIFIFI: cl-pch.cpp
 195
 196 // /Yufoo2.h /FIfoo1.h /FIfoo2.h /FIfoo3.h
 197 // => foo1 foo2 filtered out, foo3 into main compilation
 198 // RUN: %clang_cl -Werror /Yufoo2.h /FIfoo1.h /FIfoo2.h /FIfoo3.h /c -### -- %s 2>&1 \
 199 // RUN:   | FileCheck -check-prefix=CHECK-YUFIFIFI %s
 200 // Use .pch file, but don't build it.
 201 // CHECK-YUFIFIFI-NOT: -emit-pch
 202 // CHECK-YUFIFIFI: cc1
 203 // CHECK-YUFIFIFI: -emit-obj
 204 // CHECK-YUFIFIFI: -include-pch
 205 // CHECK-YUFIFIFI: foo2.pch
 206 // CHECK-YUFIFIFI: -pch-through-header=foo2.h
 207 // CHECK-YUFIFIFI: -include
 208 // CHECK-YUFIFIFI: foo1.h
 209 // CHECK-YUFIFIFI: -include
 210 // CHECK-YUFIFIFI: foo2.h
 211 // CHECK-YUFIFIFI: -include
 212 // CHECK-YUFIFIFI: foo3.h
 213
 214 // Test /Ycfoo.h / /Yufoo.h without /FIfoo.h
 215 // RUN: %clang_cl -Werror /Ycfoo.h /c -### -- %s 2>&1 \
 216 // RUN:   | FileCheck -check-prefix=CHECK-YC-NOFI %s
 217 // 1. Precompile
 218 // CHECK-YC-NOFI: cc1
 219 // CHECK-YC-NOFI: -emit-pch
 220 // CHECK-YC-NOFI: -pch-through-header=foo.h
 221 // CHECK-YC-NOFI: -o
 222 // CHECK-YC-NOFI: foo.pch
 223 // CHECK-YC-NOFI: -x
 224 // CHECK-YC-NOFI: c++-header
 225 // CHECK-YC-NOFI: cl-pch.cpp
 226 // 2. Build PCH object
 227 // CHECK-YC-NOFI: cc1
 228 // CHECK-YC-NOFI: -emit-obj
 229 // CHECK-YC-NOFI: -include-pch
 230 // CHECK-YC-NOFI: foo.pch
 231 // CHECK-YC-NOFI: -pch-through-header=foo.h
 232 // CHECK-YC-NOFI: -x
 233 // CHECK-YC-NOFI: c++
 234 // CHECK-YC-NOFI: cl-pch.cpp
 235 // RUN: %clang_cl -Werror /Yufoo.h /c -### -- %s 2>&1 \
 236 // RUN:   | FileCheck -check-prefix=CHECK-YU-NOFI %s
 237 // CHECK-YU-NOFI: cc1
 238 // CHECK-YU-NOFI: -emit-obj
 239 // CHECK-YU-NOFI: -include-pch
 240 // CHECK-YU-NOFI: foo.pch
 241 // CHECK-YU-NOFI: -pch-through-header=foo.h
 242 // CHECK-YU-NOFI: -x
 243 // CHECK-YU-NOFI: c++
 244 // CHECK-YU-NOFI: cl-pch.cpp
 245
 246 // With an actual /I argument.
 247 // RUN: %clang_cl -Werror /Ifoo /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
 248 // RUN:   | FileCheck -check-prefix=CHECK-YC-I3 %s
 249 // 1. This writes pchfile.pch into the root dir, even if this will pick up
 250 //    foo/pchfile.h
 251 // CHECK-YC-I3: cc1
 252 // CHECK-YC-I3: -emit-pch
 253 // CHECK-YC-I3: -o
 254 // CHECK-YC-I3: pchfile.pch
 255 // 2. Use .pch file.
 256 // CHECK-YC-I3: cc1
 257 // CHECK-YC-I3: -emit-obj
 258 // CHECK-YC-I3: -include-pch
 259 // CHECK-YC-I3: pchfile.pch
 260
 261 // But /FIfoo/bar.h /Ycfoo\bar.h does work, as does /FIfOo.h /Ycfoo.H
 262 // RUN: %clang_cl -Werror /YupchFILE.h /FI./pchfile.h /c -### -- %s 2>&1 \
 263 // RUN:   | FileCheck -check-prefix=CHECK-YU-CASE %s
 264 // CHECK-YU-CASE: -pch-through-header=pchFILE.h
 265 // CHECK-YU-CASE: -include
 266 // CHECK-YU-CASE: "./pchfile.h"
 267 // RUN: %clang_cl -Werror /Yu./pchfile.h /FI.\\pchfile.h /c -### -- %s 2>&1 \
 268 // RUN:   | FileCheck -check-prefix=CHECK-YU-SLASH %s
 269 // CHECK-YU-SLASH: -pch-through-header=./pchfile.h
 270 // CHECK-YU-SLASH: -include
 271 // CHECK-YU-SLASH: ".{{[/\\]+}}pchfile.h"
 272
 273 // /Yc without an argument creates a PCH from the code before #pragma hdrstop.
 274 // /Yu without an argument uses a PCH and starts compiling after the
 275 // #pragma hdrstop.
 276 // RUN: %clang_cl -Werror /Yc /Fpycnoarg.pch /c -### -- %s 2>&1 \
 277 // RUN:   | FileCheck -check-prefix=CHECK-YC-NOARG %s
 278 // 1. Create .pch file
 279 // CHECK-YC-NOARG: cc1
 280 // CHECK-YC-NOARG: -emit-pch
 281 // CHECK-YC-NOARG: -pch-through-hdrstop-create
 282 // CHECK-YC-NOARG: -o
 283 // CHECK-YC-NOARG: ycnoarg.pch
 284 // CHECK-YC-NOARG: -x
 285 // CHECK-YC-NOARG: "c++-header"
 286 // CHECK-YC-NOARG: cl-pch.cpp
 287 // 2. Use .pch file: Includes ycnoarg.pch
 288 // CHECK-YC-NOARG: cc1
 289 // CHECK-YC-NOARG: -emit-obj
 290 // CHECK-YC-NOARG: -include-pch
 291 // CHECK-YC-NOARG: ycnoarg.pch
 292 // CHECK-YC-NOARG: -pch-through-hdrstop-create
 293 // CHECK-YC-NOARG: -o
 294 // CHECK-YC-NOARG: cl-pch.obj
 295 // CHECK-YC-NOARG: -x
 296 // CHECK-YC-NOARG: "c++"
 297 // CHECK-YC-NOARG: cl-pch.cpp
 298
 299 // RUN: %clang_cl -Werror /Yu /Fpycnoarg.pch /c -### -- %s 2>&1 \
 300 // RUN:   | FileCheck -check-prefix=CHECK-YU-NOARG %s
 301 // Use .pch file, but don't build it.
 302 // CHECK-YU-NOARG-NOT: -emit-pch
 303 // CHECK-YU-NOARG: cc1
 304 // CHECK-YU-NOARG: -emit-obj
 305 // CHECK-YU-NOARG: -include-pch
 306 // CHECK-YU-NOARG: ycnoarg.pch
 307 // CHECK-YU-NOARG: -pch-through-hdrstop-use
 308 // CHECK-YU-NOARG: -o
 309 // CHECK-YU-NOARG: cl-pch.obj
 310 // CHECK-YU-NOARG: -x
 311 // CHECK-YU-NOARG: "c++"
 312 // CHECK-YU-NOARG: cl-pch.cpp
 313
 314 // /Yc with no argument and no /FP
 315 // RUN: %clang_cl -Werror /Yc /c -### -- %s 2>&1 \
 316 // RUN:   | FileCheck -check-prefix=CHECK-YC-NOARG-NOFP %s
 317 // 1. Create .pch file
 318 // CHECK-YC-NOARG-NOFP: cc1
 319 // CHECK-YC-NOARG-NOFP: -emit-pch
 320 // CHECK-YC-NOARG-NOFP: -pch-through-hdrstop-create
 321 // CHECK-YC-NOARG-NOFP: -o
 322 // CHECK-YC-NOARG-NOFP: cl-pch.pch
 323 // CHECK-YC-NOARG-NOFP: -x
 324 // CHECK-YC-NOARG-NOFP: "c++-header"
 325 // CHECK-YC-NOARG-NOFP: cl-pch.cpp
 326 // 2. Use .pch file: Includes cl-pch.pch
 327 // CHECK-YC-NOARG-NOFP: cc1
 328 // CHECK-YC-NOARG-NOFP: -emit-obj
 329 // CHECK-YC-NOARG-NOFP: -include-pch
 330 // CHECK-YC-NOARG-NOFP: cl-pch.pch
 331 // CHECK-YC-NOARG-NOFP: -pch-through-hdrstop-create
 332 // CHECK-YC-NOARG-NOFP: -o
 333 // CHECK-YC-NOARG-NOFP: cl-pch.obj
 334 // CHECK-YC-NOARG-NOFP: -x
 335 // CHECK-YC-NOARG-NOFP: "c++"
 336 // CHECK-YC-NOARG-NOFP: cl-pch.cpp
 337
 338 // cl.exe warns on multiple /Yc, /Yu, /Fp arguments, but clang-cl silently just
 339 // uses the last one.  This is true for e.g. /Fo too, so not warning on this
 340 // is self-consistent with clang-cl's flag handling.
 341
 342 // /FI without /Yu => pch file not used, even if it exists (different from
 343 // -include, which picks up .gch files if they exist).
 344 // RUN: touch %t.pch
 345 // RUN: not %clang_cl -Werror /FI%t.pch /Fp%t.pch /c -### -- %s 2>&1 \
 346 // RUN:   | FileCheck -check-prefix=CHECK-FI %s
 347 // CHECK-FI-NOT: -include-pch
 348 // CHECK-FI: -include
 349
 350 // Test interaction of /Yc with language mode flags.
 351
 352 // If /TC changes the input language to C, a c pch file should be produced.
 353 // RUN: %clang_cl /TC -Werror /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
 354 // RUN:   | FileCheck -check-prefix=CHECK-YCTC %s
 355 // CHECK-YCTC: cc1
 356 // CHECK-YCTC: -emit-pch
 357 // CHECK-YCTC: -o
 358 // CHECK-YCTC: pchfile.pch
 359 // CHECK-YCTC: -x
 360 // CHECK-YCTC: "c"
 361
 362 // Also check lower-case /Tc variant.
 363 // RUN: %clang_cl -Werror /Ycpchfile.h /FIpchfile.h /c -### /Tc%s 2>&1 \
 364 // RUN:   | FileCheck -check-prefix=CHECK-YCTc %s
 365 // CHECK-YCTc: cc1
 366 // CHECK-YCTc: -emit-pch
 367 // CHECK-YCTc: -o
 368 // CHECK-YCTc: pchfile.pch
 369 // CHECK-YCTc: -x
 370 // CHECK-YCTc: "c"
 371
 372 // Don't crash when a non-source file is passed.
 373 // RUN: not %clang_cl -Werror /Ycpchfile.h /FIpchfile.h /c -### -- %S/Inputs/file.prof 2>&1 \
 374 // RUN:   | FileCheck -check-prefix=CHECK-NoSource %s
 375 // CHECK-NoSource: file.prof:{{.*}}input unused
 376
 377 // ...but if an explicit flag turns the file into a source file, handle it:
 378 // RUN: %clang_cl /TP -Werror /Ycpchfile.h /FIpchfile.h /c -### -- %S/Inputs/file.prof 2>&1 \
 379 // RUN:   | FileCheck -check-prefix=CHECK-NoSourceTP %s
 380 // CHECK-NoSourceTP: cc1
 381 // CHECK-NoSourceTP: -emit-pch
 382 // CHECK-NoSourceTP: -o
 383 // CHECK-NoSourceTP: pchfile.pch
 384 // CHECK-NoSourceTP: -x
 385 // CHECK-NoSourceTP: "c++"
 386
 387 // If only preprocessing, PCH options are ignored.
 388 // RUN: %clang_cl /P /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
 389 // RUN:   | FileCheck -check-prefix=CHECK-YC-P %s
 390 // CHECK-YC-P-NOT: -emit-pch
 391 // CHECK-YC-P-NOT: -include-pch
 392
 393 // RUN: %clang_cl /E /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
 394 // RUN:   | FileCheck -check-prefix=CHECK-YC-E %s
 395 // CHECK-YC-E-NOT: -emit-pch
 396 // CHECK-YC-E-NOT: -include-pch
 397
 398 // RUN: %clang_cl /P /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
 399 // RUN:   | FileCheck -check-prefix=CHECK-YU-P %s
 400 // CHECK-YU-P-NOT: -emit-pch
 401 // CHECK-YU-P-NOT: -include-pch
 402
 403 // RUN: %clang_cl /E /Ycpchfile.h /FIpchfile.h /c -### -- %s 2>&1 \
 404 // RUN:   | FileCheck -check-prefix=CHECK-YU-E %s
 405 // CHECK-YU-E-NOT: -emit-pch
 406 // CHECK-YU-E-NOT: -include-pch