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 407