1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
|
// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.rules.cpp;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
import com.google.devtools.build.lib.actions.AbstractAction;
import com.google.devtools.build.lib.actions.ActionExecutionContext;
import com.google.devtools.build.lib.actions.ActionExecutionException;
import com.google.devtools.build.lib.actions.ActionInput;
import com.google.devtools.build.lib.actions.ActionOwner;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.actions.Artifact.MiddlemanExpander;
import com.google.devtools.build.lib.actions.ArtifactResolver;
import com.google.devtools.build.lib.actions.ExecException;
import com.google.devtools.build.lib.actions.Executor;
import com.google.devtools.build.lib.actions.PackageRootResolver;
import com.google.devtools.build.lib.actions.ResourceSet;
import com.google.devtools.build.lib.actions.extra.CppCompileInfo;
import com.google.devtools.build.lib.actions.extra.ExtraActionInfo;
import com.google.devtools.build.lib.analysis.RuleContext;
import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
import com.google.devtools.build.lib.analysis.config.PerLabelOptions;
import com.google.devtools.build.lib.collect.CollectionUtils;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadCompatible;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.events.EventHandler;
import com.google.devtools.build.lib.events.EventKind;
import com.google.devtools.build.lib.profiler.Profiler;
import com.google.devtools.build.lib.profiler.ProfilerTask;
import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FeatureConfiguration;
import com.google.devtools.build.lib.rules.cpp.CppConfiguration.Tool;
import com.google.devtools.build.lib.syntax.Label;
import com.google.devtools.build.lib.util.DependencySet;
import com.google.devtools.build.lib.util.FileType;
import com.google.devtools.build.lib.util.Fingerprint;
import com.google.devtools.build.lib.util.OS;
import com.google.devtools.build.lib.util.Pair;
import com.google.devtools.build.lib.util.ShellEscaper;
import com.google.devtools.build.lib.vfs.FileSystemUtils;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import javax.annotation.Nullable;
import javax.annotation.concurrent.GuardedBy;
/**
* Action that represents some kind of C++ compilation step.
*/
@ThreadCompatible
public class CppCompileAction extends AbstractAction implements IncludeScannable {
/**
* Represents logic that determines which artifacts, if any, should be added to the actual inputs
* for each included file (in addition to the included file itself)
*/
public interface IncludeResolver {
/**
* Returns the set of files to be added for an included file (as returned in the .d file)
*/
Collection<Artifact> getInputsForIncludedFile(
Artifact includedFile, ArtifactResolver artifactResolver);
}
public static final IncludeResolver VOID_INCLUDE_RESOLVER = new IncludeResolver() {
@Override
public Collection<Artifact> getInputsForIncludedFile(Artifact includedFile,
ArtifactResolver artifactResolver) {
return ImmutableList.of();
}
};
private static final int VALIDATION_DEBUG = 0; // 0==none, 1==warns/errors, 2==all
private static final boolean VALIDATION_DEBUG_WARN = VALIDATION_DEBUG >= 1;
/**
* A string constant for the c compilation action.
*/
public static final String C_COMPILE = "c-compile";
/**
* A string constant for the c++ compilation action.
*/
public static final String CPP_COMPILE = "c++-compile";
/**
* A string constant for the c++ header parsing.
*/
public static final String CPP_HEADER_PARSING = "c++-header-parsing";
/**
* A string constant for the c++ header preprocessing.
*/
public static final String CPP_HEADER_PREPROCESSING = "c++-header-preprocessing";
/**
* A string constant for the c++ module compilation action.
* Note: currently we don't support C module compilation.
*/
public static final String CPP_MODULE_COMPILE = "c++-module-compile";
/**
* A string constant for the preprocessing assembler action.
*/
public static final String PREPROCESS_ASSEMBLE = "preprocess-assemble";
private final BuildConfiguration configuration;
protected final Artifact outputFile;
private final Label sourceLabel;
private final Artifact dwoFile;
private final Artifact optionalSourceFile;
private final NestedSet<Artifact> mandatoryInputs;
private final CppCompilationContext context;
private final Collection<PathFragment> extraSystemIncludePrefixes;
private final Iterable<IncludeScannable> lipoScannables;
private final CppCompileCommandLine cppCompileCommandLine;
private final boolean usePic;
@VisibleForTesting
final CppConfiguration cppConfiguration;
protected final Class<? extends CppCompileActionContext> actionContext;
private final IncludeResolver includeResolver;
/**
* Identifier for the actual execution time behavior of the action.
*
* <p>Required because the behavior of this class can be modified by injecting code in the
* constructor or by inheritance, and we want to have different cache keys for those.
*/
private final UUID actionClassId;
// This can be read/written from multiple threads, and so accesses should be synchronized.
@GuardedBy("this")
private boolean inputsKnown = false;
/**
* Set when the action prepares for execution. Used to preserve state between preparation and
* execution.
*/
private Collection<Artifact> additionalInputs = null;
/**
* Creates a new action to compile C/C++ source files.
*
* @param owner the owner of the action, usually the configured target that
* emitted it
* @param sourceFile the source file that should be compiled. {@code mandatoryInputs} must
* contain this file
* @param sourceLabel the label of the rule the source file is generated by
* @param mandatoryInputs any additional files that need to be present for the
* compilation to succeed, can be empty but not null, for example, extra sources for FDO.
* @param outputFile the object file that is written as result of the
* compilation, or the fake object for {@link FakeCppCompileAction}s
* @param dotdFile the .d file that is generated as a side-effect of
* compilation
* @param gcnoFile the coverage notes that are written in coverage mode, can
* be null
* @param dwoFile the .dwo output file where debug information is stored for Fission
* builds (null if Fission mode is disabled)
* @param optionalSourceFile an additional optional source file (null if unneeded)
* @param configuration the build configurations
* @param context the compilation context
* @param copts options for the compiler
* @param coptsFilter regular expression to remove options from {@code copts}
*/
protected CppCompileAction(ActionOwner owner,
// TODO(bazel-team): Eventually we will remove 'features'; all functionality in 'features'
// will be provided by 'featureConfiguration'.
ImmutableList<String> features,
FeatureConfiguration featureConfiguration,
Artifact sourceFile,
Label sourceLabel,
NestedSet<Artifact> mandatoryInputs,
Artifact outputFile,
DotdFile dotdFile,
@Nullable Artifact gcnoFile,
@Nullable Artifact dwoFile,
Artifact optionalSourceFile,
BuildConfiguration configuration,
CppConfiguration cppConfiguration,
CppCompilationContext context,
Class<? extends CppCompileActionContext> actionContext,
ImmutableList<String> copts,
ImmutableList<String> pluginOpts,
Predicate<String> coptsFilter,
ImmutableList<PathFragment> extraSystemIncludePrefixes,
@Nullable String fdoBuildStamp,
IncludeResolver includeResolver,
Iterable<IncludeScannable> lipoScannables,
UUID actionClassId,
boolean usePic,
RuleContext ruleContext) {
// getInputs() method is overridden in this class so we pass a dummy empty
// list to the AbstractAction constructor in place of a real input collection.
super(owner,
Artifact.NO_ARTIFACTS,
CollectionUtils.asListWithoutNulls(outputFile, dotdFile.artifact(),
gcnoFile, dwoFile));
this.configuration = configuration;
this.sourceLabel = sourceLabel;
this.outputFile = Preconditions.checkNotNull(outputFile);
this.dwoFile = dwoFile;
this.optionalSourceFile = optionalSourceFile;
this.context = context;
this.extraSystemIncludePrefixes = extraSystemIncludePrefixes;
this.includeResolver = includeResolver;
this.cppConfiguration = cppConfiguration;
if (cppConfiguration != null && !cppConfiguration.shouldScanIncludes()) {
inputsKnown = true;
}
this.cppCompileCommandLine = new CppCompileCommandLine(sourceFile, dotdFile,
context.getCppModuleMap(), copts, coptsFilter, pluginOpts,
(gcnoFile != null), features, featureConfiguration, fdoBuildStamp);
this.actionContext = actionContext;
this.lipoScannables = lipoScannables;
this.actionClassId = actionClassId;
this.usePic = usePic;
// We do not need to include the middleman artifact since it is a generated
// artifact and will definitely exist prior to this action execution.
this.mandatoryInputs = mandatoryInputs;
setInputs(createInputs(mandatoryInputs, context.getCompilationPrerequisites(),
optionalSourceFile));
verifyIncludePaths(ruleContext);
}
/**
* Verifies that the include paths of this action are within the limits of the execution root.
*/
private void verifyIncludePaths(RuleContext ruleContext) {
if (ruleContext == null) {
return;
}
// We currently do not check the output of:
// - getQuoteIncludeDirs(): those only come from includes attributes, and are checked in
// CcCommon.getIncludeDirsFromIncludesAttribute().
// - getBuiltinIncludeDirs(): while in practice this doesn't happen, bazel can be configured
// to use an absolute system root, in which case the builtin include dirs might be absolute.
for (PathFragment include : Iterables.concat(getIncludeDirs(), getSystemIncludeDirs())) {
if (include.isAbsolute()
|| !PathFragment.EMPTY_FRAGMENT.getRelative(include).normalize().isNormalized()) {
ruleContext.ruleError("The include path '" + include
+ "' references a path outside of the execution root.");
}
}
}
private static NestedSet<Artifact> createInputs(
NestedSet<Artifact> mandatoryInputs,
Set<Artifact> prerequisites, Artifact optionalSourceFile) {
NestedSetBuilder<Artifact> builder = NestedSetBuilder.stableOrder();
if (optionalSourceFile != null) {
builder.add(optionalSourceFile);
}
builder.addAll(prerequisites);
builder.addTransitive(mandatoryInputs);
return builder.build();
}
public boolean shouldScanIncludes() {
return cppConfiguration.shouldScanIncludes();
}
@Override
public List<PathFragment> getBuiltInIncludeDirectories() {
return cppConfiguration.getBuiltInIncludeDirectories();
}
@Nullable
@Override
public Artifact getBuiltInIncludeFile() {
return cppConfiguration.getBuiltInIncludeFile();
}
public String getHostSystemName() {
return cppConfiguration.getHostSystemName();
}
@Override
public NestedSet<Artifact> getMandatoryInputs() {
return mandatoryInputs;
}
@Override
public synchronized boolean inputsKnown() {
return inputsKnown;
}
/**
* Returns the list of additional inputs found by dependency discovery, during action preparation,
* and clears the stored list. {@link #prepare} must be called before this method is called, on
* each action execution.
*/
public Collection<? extends ActionInput> getAdditionalInputs() {
Collection<? extends ActionInput> result = Preconditions.checkNotNull(additionalInputs);
additionalInputs = null;
return result;
}
@Override
public boolean discoversInputs() {
return true;
}
@Nullable
@Override
public Collection<Artifact> discoverInputs(ActionExecutionContext actionExecutionContext)
throws ActionExecutionException, InterruptedException {
Executor executor = actionExecutionContext.getExecutor();
Collection<Artifact> initialResult;
try {
initialResult = executor.getContext(actionContext)
.findAdditionalInputs(this, actionExecutionContext);
} catch (ExecException e) {
throw e.toActionExecutionException("Include scanning of rule '" + getOwner().getLabel() + "'",
executor.getVerboseFailures(), this);
}
if (initialResult == null) {
// We will find inputs during execution. Store an empty list to show we did try to discover
// inputs and return null to inform the caller that inputs will be discovered later.
this.additionalInputs = ImmutableList.of();
return null;
}
this.additionalInputs = initialResult;
// In some cases, execution backends need extra files for each included file. Add them
// to the set of inputs the caller may need to be aware of.
Collection<Artifact> result = new HashSet<>();
ArtifactResolver artifactResolver =
executor.getContext(IncludeScanningContext.class).getArtifactResolver();
for (Artifact artifact : initialResult) {
result.addAll(includeResolver.getInputsForIncludedFile(artifact, artifactResolver));
}
for (Artifact artifact : getInputs()) {
result.addAll(includeResolver.getInputsForIncludedFile(artifact, artifactResolver));
}
if (result.isEmpty()) {
result = initialResult;
} else {
result.addAll(initialResult);
}
return result;
}
@Override
public Artifact getPrimaryInput() {
return getSourceFile();
}
@Override
public Artifact getPrimaryOutput() {
return getOutputFile();
}
/**
* Returns the path of the c/cc source for gcc.
*/
public final Artifact getSourceFile() {
return cppCompileCommandLine.sourceFile;
}
/**
* Returns the path where gcc should put its result.
*/
public Artifact getOutputFile() {
return outputFile;
}
/**
* Returns the path of the debug info output file (when debug info is
* spliced out of the .o file via fission).
*/
@Nullable
Artifact getDwoFile() {
return dwoFile;
}
protected PathFragment getInternalOutputFile() {
return outputFile.getExecPath();
}
@VisibleForTesting
public List<String> getPluginOpts() {
return cppCompileCommandLine.pluginOpts;
}
Collection<PathFragment> getExtraSystemIncludePrefixes() {
return extraSystemIncludePrefixes;
}
@Override
public Map<Artifact, Artifact> getLegalGeneratedScannerFileMap() {
Map<Artifact, Artifact> legalOuts = new HashMap<>();
for (Artifact a : context.getDeclaredIncludeSrcs()) {
if (!a.isSourceArtifact()) {
legalOuts.put(a, null);
}
}
for (Pair<Artifact, Artifact> pregreppedSrcs : context.getPregreppedHeaders()) {
Artifact hdr = pregreppedSrcs.getFirst();
Preconditions.checkState(!hdr.isSourceArtifact(), hdr);
legalOuts.put(hdr, pregreppedSrcs.getSecond());
}
return Collections.unmodifiableMap(legalOuts);
}
/**
* Returns the path where gcc should put the discovered dependency
* information.
*/
public DotdFile getDotdFile() {
return cppCompileCommandLine.dotdFile;
}
@Override
public String describeStrategy(Executor executor) {
return executor.getContext(actionContext).strategyLocality();
}
@VisibleForTesting
public CppCompilationContext getContext() {
return context;
}
@Override
public List<PathFragment> getQuoteIncludeDirs() {
return context.getQuoteIncludeDirs();
}
@Override
public List<PathFragment> getIncludeDirs() {
ImmutableList.Builder<PathFragment> result = ImmutableList.builder();
result.addAll(context.getIncludeDirs());
for (String opt : cppCompileCommandLine.copts) {
if (opt.startsWith("-I") && opt.length() > 2) {
// We insist on the combined form "-Idir".
result.add(new PathFragment(opt.substring(2)));
}
}
return result.build();
}
@Override
public List<PathFragment> getSystemIncludeDirs() {
// TODO(bazel-team): parsing the command line flags here couples us to gcc-style compiler
// command lines; use a different way to specify system includes (for example through a
// system_includes attribute in cc_toolchain); note that that would disallow users from
// specifying system include paths via the copts attribute.
// Currently, this works together with the include_paths features because getCommandLine() will
// get the system include paths from the CppCompilationContext instead.
ImmutableList.Builder<PathFragment> result = ImmutableList.builder();
List<String> compilerOptions = getCompilerOptions();
for (int i = 0; i < compilerOptions.size(); i++) {
String opt = compilerOptions.get(i);
if (opt.startsWith("-isystem")) {
if (opt.length() > 8) {
result.add(new PathFragment(opt.substring(8).trim()));
} else if (i + 1 < compilerOptions.size()) {
i++;
result.add(new PathFragment(compilerOptions.get(i)));
} else {
System.err.println("WARNING: dangling -isystem flag in options for " + prettyPrint());
}
}
}
return result.build();
}
@Override
public List<String> getCmdlineIncludes() {
ImmutableList.Builder<String> cmdlineIncludes = ImmutableList.builder();
List<String> args = getArgv();
for (Iterator<String> argi = args.iterator(); argi.hasNext();) {
String arg = argi.next();
if (arg.equals("-include") && argi.hasNext()) {
cmdlineIncludes.add(argi.next());
}
}
return cmdlineIncludes.build();
}
@Override
public Artifact getMainIncludeScannerSource() {
return CppFileTypes.CPP_MODULE_MAP.matches(getSourceFile().getPath())
? Iterables.getFirst(context.getHeaderModuleSrcs(), null)
: getSourceFile();
}
@Override
public Collection<Artifact> getIncludeScannerSources() {
NestedSetBuilder<Artifact> builder = NestedSetBuilder.stableOrder();
// For every header module we use for the build we need the set of sources that it can
// reference.
builder.addTransitive(context.getTransitiveHeaderModuleSrcs());
if (CppFileTypes.CPP_MODULE_MAP.matches(getSourceFile().getPath())) {
// If this is an action that compiles the header module itself, the source we build is the
// module map, and we need to include-scan all headers that are referenced in the module map.
// We need to do include scanning as long as we want to support building code bases that are
// not fully strict layering clean.
builder.addTransitive(context.getHeaderModuleSrcs());
} else {
builder.add(getSourceFile());
}
return builder.build().toCollection();
}
@Override
public Iterable<IncludeScannable> getAuxiliaryScannables() {
return lipoScannables;
}
/**
* Returns the list of "-D" arguments that should be used by this gcc
* invocation. Only used for testing.
*/
@VisibleForTesting
public ImmutableCollection<String> getDefines() {
return context.getDefines();
}
/**
* Returns an (immutable) map of environment key, value pairs to be
* provided to the C++ compiler.
*/
public ImmutableMap<String, String> getEnvironment() {
Map<String, String> environment =
new LinkedHashMap<>(configuration.getDefaultShellEnvironment());
if (configuration.isCodeCoverageEnabled()) {
environment.put("PWD", "/proc/self/cwd");
}
if (OS.getCurrent() == OS.WINDOWS) {
// TODO(bazel-team): Both GCC and clang rely on their execution directories being on
// PATH, otherwise they fail to find dependent DLLs (and they fail silently...). On
// the other hand, Windows documentation says that the directory of the executable
// is always searched for DLLs first. Not sure what to make of it.
// Other options are to forward the system path (brittle), or to add a PATH field to
// the crosstool file.
environment.put("PATH", cppConfiguration.getToolPathFragment(Tool.GCC).getParentDirectory()
.getPathString());
}
return ImmutableMap.copyOf(environment);
}
/**
* Returns a new, mutable list of command and arguments (argv) to be passed
* to the gcc subprocess.
*/
public final List<String> getArgv() {
return getArgv(getInternalOutputFile());
}
protected final List<String> getArgv(PathFragment outputFile) {
return cppCompileCommandLine.getArgv(outputFile);
}
@Override
public ExtraActionInfo.Builder getExtraActionInfo() {
CppCompileInfo.Builder info = CppCompileInfo.newBuilder();
info.setTool(cppConfiguration.getToolPathFragment(Tool.GCC).getPathString());
for (String option : getCompilerOptions()) {
info.addCompilerOption(option);
}
info.setOutputFile(outputFile.getExecPathString());
info.setSourceFile(getSourceFile().getExecPathString());
if (inputsKnown()) {
info.addAllSourcesAndHeaders(Artifact.toExecPaths(getInputs()));
} else {
info.addSourcesAndHeaders(getSourceFile().getExecPathString());
info.addAllSourcesAndHeaders(
Artifact.toExecPaths(context.getDeclaredIncludeSrcs()));
}
return super.getExtraActionInfo()
.setExtension(CppCompileInfo.cppCompileInfo, info.build());
}
/**
* Returns the compiler options.
*/
@VisibleForTesting
public List<String> getCompilerOptions() {
return cppCompileCommandLine.getCompilerOptions();
}
/**
* Enforce that the includes actually visited during the compile were properly
* declared in the rules.
*
* <p>The technique is to walk through all of the reported includes that gcc
* emits into the .d file, and verify that they came from acceptable
* relative include directories. This is done in two steps:
*
* <p>First, each included file is stripped of any include path prefix from
* {@code quoteIncludeDirs} to produce an effective relative include dir+name.
*
* <p>Second, the remaining directory is looked up in {@code declaredIncludeDirs},
* a list of acceptable dirs. This list contains a set of dir fragments that
* have been calculated by the configured target to be allowable for inclusion
* by this source. If no match is found, an error is reported and an exception
* is thrown.
*
* @throws ActionExecutionException iff there was an undeclared dependency
*/
@VisibleForTesting
public void validateInclusions(
MiddlemanExpander middlemanExpander, EventHandler eventHandler)
throws ActionExecutionException {
if (!cppConfiguration.shouldScanIncludes() || !inputsKnown()) {
return;
}
IncludeProblems errors = new IncludeProblems();
IncludeProblems warnings = new IncludeProblems();
Set<Artifact> allowedIncludes = new HashSet<>();
for (Artifact input : mandatoryInputs) {
if (input.isMiddlemanArtifact()) {
middlemanExpander.expand(input, allowedIncludes);
}
allowedIncludes.add(input);
}
if (optionalSourceFile != null) {
allowedIncludes.add(optionalSourceFile);
}
List<PathFragment> cxxSystemIncludeDirs =
cppConfiguration.getBuiltInIncludeDirectories();
Iterable<PathFragment> ignoreDirs = Iterables.concat(cxxSystemIncludeDirs,
extraSystemIncludePrefixes, context.getSystemIncludeDirs());
// Copy the sets to hash sets for fast contains checking.
// Avoid immutable sets here to limit memory churn.
Set<PathFragment> declaredIncludeDirs = Sets.newHashSet(context.getDeclaredIncludeDirs());
Set<PathFragment> warnIncludeDirs = Sets.newHashSet(context.getDeclaredIncludeWarnDirs());
Set<Artifact> declaredIncludeSrcs = Sets.newHashSet(context.getDeclaredIncludeSrcs());
for (Artifact input : getInputs()) {
if (context.getCompilationPrerequisites().contains(input)
|| allowedIncludes.contains(input)) {
continue; // ignore our fixed source in mandatoryInput: we just want includes
}
// Ignore headers from built-in include directories.
if (FileSystemUtils.startsWithAny(input.getExecPath(), ignoreDirs)) {
continue;
}
if (!isDeclaredIn(input, declaredIncludeDirs, declaredIncludeSrcs)) {
// This call can never match the declared include sources (they would be matched above).
// There are no declared include sources we need to warn about, so use an empty set here.
if (isDeclaredIn(input, warnIncludeDirs, ImmutableSet.<Artifact>of())) {
warnings.add(input.getPath().toString());
} else {
errors.add(input.getPath().toString());
}
}
}
if (VALIDATION_DEBUG_WARN) {
synchronized (System.err) {
if (VALIDATION_DEBUG >= 2 || errors.hasProblems() || warnings.hasProblems()) {
if (errors.hasProblems()) {
System.err.println("ERROR: Include(s) were not in declared srcs:");
} else if (warnings.hasProblems()) {
System.err.println("WARN: Include(s) were not in declared srcs:");
} else {
System.err.println("INFO: Include(s) were OK for '" + getSourceFile()
+ "', declared srcs:");
}
for (Artifact a : context.getDeclaredIncludeSrcs()) {
System.err.println(" '" + a.toDetailString() + "'");
}
System.err.println(" or under declared dirs:");
for (PathFragment f : Sets.newTreeSet(context.getDeclaredIncludeDirs())) {
System.err.println(" '" + f + "'");
}
System.err.println(" or under declared warn dirs:");
for (PathFragment f : Sets.newTreeSet(context.getDeclaredIncludeWarnDirs())) {
System.err.println(" '" + f + "'");
}
System.err.println(" with prefixes:");
for (PathFragment dirpath : context.getQuoteIncludeDirs()) {
System.err.println(" '" + dirpath + "'");
}
}
}
}
if (warnings.hasProblems()) {
eventHandler.handle(
new Event(EventKind.WARNING,
getOwner().getLocation(), warnings.getMessage(this, getSourceFile()),
Label.print(getOwner().getLabel())));
}
errors.assertProblemFree(this, getSourceFile());
}
/**
* Returns true if an included artifact is declared in a set of allowed
* include directories. The simple case is that the artifact's parent
* directory is contained in the set, or is empty.
*
* <p>This check also supports a wildcard suffix of '**' for the cases where the
* calculations are inexact.
*
* <p>It also handles unseen non-nested-package subdirs by walking up the path looking
* for matches.
*/
private static boolean isDeclaredIn(Artifact input, Set<PathFragment> declaredIncludeDirs,
Set<Artifact> declaredIncludeSrcs) {
// First check if it's listed in "srcs". If so, then its declared & OK.
if (declaredIncludeSrcs.contains(input)) {
return true;
}
// If it's a derived artifact, then it MUST be listed in "srcs" as checked above.
// We define derived here as being not source and not under the include link tree.
if (!input.isSourceArtifact()
&& !input.getRoot().getExecPath().getBaseName().equals("include")) {
return false;
}
// Need to do dir/package matching: first try a quick exact lookup.
PathFragment includeDir = input.getRootRelativePath().getParentDirectory();
if (includeDir.segmentCount() == 0 || declaredIncludeDirs.contains(includeDir)) {
return true; // OK: quick exact match.
}
// Not found in the quick lookup: try the wildcards.
for (PathFragment declared : declaredIncludeDirs) {
if (declared.getBaseName().equals("**")) {
if (includeDir.startsWith(declared.getParentDirectory())) {
return true; // OK: under a wildcard dir.
}
}
}
// Still not found: see if it is in a subdir of a declared package.
Path root = input.getRoot().getPath();
for (Path dir = input.getPath().getParentDirectory();;) {
if (dir.getRelative("BUILD").exists()) {
return false; // Bad: this is a sub-package, not a subdir of a declared package.
}
dir = dir.getParentDirectory();
if (dir.equals(root)) {
return false; // Bad: at the top, give up.
}
if (declaredIncludeDirs.contains(dir.relativeTo(root))) {
return true; // OK: found under a declared dir.
}
}
}
/**
* Recalculates this action's live input collection, including sources, middlemen.
*
* @throws ActionExecutionException iff any errors happen during update.
*/
@VisibleForTesting
@ThreadCompatible
public final synchronized void updateActionInputs(Path execRoot,
ArtifactResolver artifactResolver, CppCompileActionContext.Reply reply)
throws ActionExecutionException {
if (!cppConfiguration.shouldScanIncludes()) {
return;
}
inputsKnown = false;
NestedSetBuilder<Artifact> inputs = NestedSetBuilder.stableOrder();
Profiler.instance().startTask(ProfilerTask.ACTION_UPDATE, this);
try {
inputs.addTransitive(mandatoryInputs);
if (optionalSourceFile != null) {
inputs.add(optionalSourceFile);
}
inputs.addAll(context.getCompilationPrerequisites());
populateActionInputs(execRoot, artifactResolver, reply, inputs);
inputsKnown = true;
} finally {
Profiler.instance().completeTask(ProfilerTask.ACTION_UPDATE);
synchronized (this) {
setInputs(inputs.build());
}
}
}
private DependencySet processDepset(Path execRoot, CppCompileActionContext.Reply reply)
throws IOException {
DependencySet depSet = new DependencySet(execRoot);
// artifact() is null if we are not using in-memory .d files. We also want to prepare for the
// case where we expected an in-memory .d file, but we did not get an appropriate response.
// Perhaps we produced the file locally.
if (getDotdFile().artifact() != null || reply == null) {
return depSet.read(getDotdFile().getPath());
} else {
// This is an in-memory .d file.
return depSet.process(reply.getContents());
}
}
/**
* Populates the given ordered collection with additional input artifacts
* relevant to the specific action implementation.
*
* <p>The default implementation updates this Action's input set by reading
* dynamically-discovered dependency information out of the .d file.
*
* <p>Artifacts are considered inputs but not "mandatory" inputs.
*
*
* @param reply the reply from the compilation.
* @param inputs the ordered collection of inputs to append to
* @throws ActionExecutionException iff the .d is missing, malformed or has
* unresolvable included artifacts.
*/
@ThreadCompatible
private void populateActionInputs(Path execRoot,
ArtifactResolver artifactResolver, CppCompileActionContext.Reply reply,
NestedSetBuilder<Artifact> inputs)
throws ActionExecutionException {
try {
// Read .d file.
DependencySet depSet = processDepset(execRoot, reply);
// Determine prefixes of allowed absolute inclusions.
CppConfiguration toolchain = cppConfiguration;
List<PathFragment> systemIncludePrefixes = new ArrayList<>();
for (PathFragment includePath : toolchain.getBuiltInIncludeDirectories()) {
if (includePath.isAbsolute()) {
systemIncludePrefixes.add(includePath);
}
}
systemIncludePrefixes.addAll(extraSystemIncludePrefixes);
// Check inclusions.
IncludeProblems problems = new IncludeProblems();
Map<PathFragment, Artifact> allowedDerivedInputsMap = getAllowedDerivedInputsMap();
for (PathFragment execPath : depSet.getDependencies()) {
if (execPath.isAbsolute()) {
// Absolute includes from system paths are ignored.
if (FileSystemUtils.startsWithAny(execPath, systemIncludePrefixes)) {
continue;
}
// Since gcc is given only relative paths on the command line,
// non-system include paths here should never be absolute. If they
// are, it's probably due to a non-hermetic #include, & we should stop
// the build with an error.
if (execPath.startsWith(execRoot.asFragment())) {
execPath = execPath.relativeTo(execRoot.asFragment()); // funky but tolerable path
} else {
problems.add(execPath.getPathString());
continue;
}
}
Artifact artifact = allowedDerivedInputsMap.get(execPath);
if (artifact == null) {
artifact = artifactResolver.resolveSourceArtifact(execPath);
}
if (artifact != null) {
inputs.add(artifact);
// In some cases, execution backends need extra files for each included file. Add them
// to the set of actual inputs.
inputs.addAll(includeResolver.getInputsForIncludedFile(artifact, artifactResolver));
} else {
// Abort if we see files that we can't resolve, likely caused by
// undeclared includes or illegal include constructs.
problems.add(execPath.getPathString());
}
}
problems.assertProblemFree(this, getSourceFile());
} catch (IOException e) {
// Some kind of IO or parse exception--wrap & rethrow it to stop the build.
throw new ActionExecutionException("error while parsing .d file", e, this, false);
}
}
@Override
public Iterable<Artifact> resolveInputsFromCache(
ArtifactResolver artifactResolver, PackageRootResolver resolver,
Collection<PathFragment> inputPaths) {
// Note that this method may trigger a violation of the desirable invariant that getInputs()
// is a superset of getMandatoryInputs(). See bug about an "action not in canonical form"
// error message and the integration test test_crosstool_change_and_failure().
Map<PathFragment, Artifact> allowedDerivedInputsMap = getAllowedDerivedInputsMap();
List<Artifact> inputs = new ArrayList<>();
List<PathFragment> unresolvedPaths = new ArrayList<>();
for (PathFragment execPath : inputPaths) {
Artifact artifact = allowedDerivedInputsMap.get(execPath);
if (artifact != null) {
inputs.add(artifact);
} else {
// Remember this execPath, we will try to resolve it as a source artifact.
unresolvedPaths.add(execPath);
}
}
Map<PathFragment, Artifact> resolvedArtifacts =
artifactResolver.resolveSourceArtifacts(unresolvedPaths, resolver);
if (resolvedArtifacts == null) {
// We are missing some dependencies. We need to rerun this update later.
return null;
}
for (PathFragment execPath : unresolvedPaths) {
Artifact artifact = resolvedArtifacts.get(execPath);
// If PathFragment cannot be resolved into the artifact - ignore it. This could happen if
// rule definition has changed and action no longer depends on, e.g., additional source file
// in the separate package and that package is no longer referenced anywhere else.
// It is safe to ignore such paths because dependency checker would identify change in inputs
// (ignored path was used before) and will force action execution.
if (artifact != null) {
inputs.add(artifact);
}
}
return inputs;
}
@Override
public synchronized void updateInputs(Iterable<Artifact> inputs) {
inputsKnown = true;
synchronized (this) {
setInputs(inputs);
}
}
private Map<PathFragment, Artifact> getAllowedDerivedInputsMap() {
Map<PathFragment, Artifact> allowedDerivedInputMap = new HashMap<>();
addToMap(allowedDerivedInputMap, mandatoryInputs);
addToMap(allowedDerivedInputMap, context.getDeclaredIncludeSrcs());
addToMap(allowedDerivedInputMap, context.getCompilationPrerequisites());
Artifact artifact = getSourceFile();
if (!artifact.isSourceArtifact()) {
allowedDerivedInputMap.put(artifact.getExecPath(), artifact);
}
return allowedDerivedInputMap;
}
private void addToMap(Map<PathFragment, Artifact> map, Iterable<Artifact> artifacts) {
for (Artifact artifact : artifacts) {
if (!artifact.isSourceArtifact()) {
map.put(artifact.getExecPath(), artifact);
}
}
}
@Override
protected String getRawProgressMessage() {
return "Compiling " + getSourceFile().prettyPrint();
}
/**
* Return the directories in which to look for headers (pertains to headers
* not specifically listed in {@code declaredIncludeSrcs}). The return value
* may contain duplicate elements.
*/
public NestedSet<PathFragment> getDeclaredIncludeDirs() {
return context.getDeclaredIncludeDirs();
}
/**
* Return the directories in which to look for headers and issue a warning.
* (pertains to headers not specifically listed in {@code
* declaredIncludeSrcs}). The return value may contain duplicate elements.
*/
public NestedSet<PathFragment> getDeclaredIncludeWarnDirs() {
return context.getDeclaredIncludeWarnDirs();
}
/**
* Return explicit header files (i.e., header files explicitly listed). The
* return value may contain duplicate elements.
*/
public NestedSet<Artifact> getDeclaredIncludeSrcs() {
return context.getDeclaredIncludeSrcs();
}
/**
* Return explicit header files (i.e., header files explicitly listed) in an order
* that is stable between builds.
*/
protected final List<PathFragment> getDeclaredIncludeSrcsInStableOrder() {
List<PathFragment> paths = new ArrayList<>();
for (Artifact declaredIncludeSrc : context.getDeclaredIncludeSrcs()) {
paths.add(declaredIncludeSrc.getExecPath());
}
Collections.sort(paths); // Order is not important, but stability is.
return paths;
}
@Override
public ResourceSet estimateResourceConsumption(Executor executor) {
return executor.getContext(actionContext).estimateResourceConsumption(this);
}
@VisibleForTesting
public Class<? extends CppCompileActionContext> getActionContext() {
return actionContext;
}
/**
* Estimate resource consumption when this action is executed locally.
*/
public ResourceSet estimateResourceConsumptionLocal() {
// We use a local compile, so much of the time is spent waiting for IO,
// but there is still significant CPU; hence we estimate 50% cpu usage.
return ResourceSet.createWithRamCpuIo(/*memoryMb=*/200, /*cpuUsage=*/0.5, /*ioUsage=*/0.0);
}
@Override
public String computeKey() {
Fingerprint f = new Fingerprint();
f.addUUID(actionClassId);
f.addStrings(getArgv());
/*
* getArgv() above captures all changes which affect the compilation
* command and hence the contents of the object file. But we need to
* also make sure that we reexecute the action if any of the fields
* that affect whether validateIncludes() will report an error or warning
* have changed, otherwise we might miss some errors.
*/
f.addPaths(context.getDeclaredIncludeDirs());
f.addPaths(context.getDeclaredIncludeWarnDirs());
f.addPaths(getDeclaredIncludeSrcsInStableOrder());
f.addPaths(getExtraSystemIncludePrefixes());
return f.hexDigestAndReset();
}
@Override
@ThreadCompatible
public void execute(
ActionExecutionContext actionExecutionContext)
throws ActionExecutionException, InterruptedException {
Executor executor = actionExecutionContext.getExecutor();
CppCompileActionContext.Reply reply;
try {
reply = executor.getContext(actionContext).execWithReply(this, actionExecutionContext);
} catch (ExecException e) {
throw e.toActionExecutionException("C++ compilation of rule '" + getOwner().getLabel() + "'",
executor.getVerboseFailures(), this);
}
ensureCoverageNotesFilesExist();
IncludeScanningContext scanningContext = executor.getContext(IncludeScanningContext.class);
updateActionInputs(executor.getExecRoot(), scanningContext.getArtifactResolver(), reply);
reply = null; // Clear in-memory .d files early.
validateInclusions(actionExecutionContext.getMiddlemanExpander(), executor.getEventHandler());
}
/**
* Gcc only creates ".gcno" files if the compilation unit is non-empty.
* To ensure that the set of outputs for a CppCompileAction remains consistent
* and doesn't vary dynamically depending on the _contents_ of the input files,
* we create empty ".gcno" files if gcc didn't create them.
*/
private void ensureCoverageNotesFilesExist() throws ActionExecutionException {
for (Artifact output : getOutputs()) {
if (CppFileTypes.COVERAGE_NOTES.matches(output.getFilename()) // ".gcno"
&& !output.getPath().exists()) {
try {
FileSystemUtils.createEmptyFile(output.getPath());
} catch (IOException e) {
throw new ActionExecutionException(
"Error creating file '" + output.getPath() + "': " + e.getMessage(), e, this, false);
}
}
}
}
/**
* Provides list of include files needed for performing extra actions on this action when run
* remotely. The list of include files is created by performing a header scan on the known input
* files.
*/
@Override
public Iterable<Artifact> getInputFilesForExtraAction(
ActionExecutionContext actionExecutionContext)
throws ActionExecutionException, InterruptedException {
Collection<Artifact> scannedIncludes =
actionExecutionContext.getExecutor().getContext(actionContext)
.getScannedIncludeFiles(this, actionExecutionContext);
// Use a set to eliminate duplicates.
ImmutableSet.Builder<Artifact> result = ImmutableSet.builder();
return result.addAll(getInputs()).addAll(scannedIncludes).build();
}
@Override
public String getMnemonic() { return "CppCompile"; }
@Override
public String describeKey() {
StringBuilder message = new StringBuilder();
message.append(getProgressMessage());
message.append('\n');
message.append(" Command: ");
message.append(
ShellEscaper.escapeString(cppConfiguration.getLdExecutable().getPathString()));
message.append('\n');
// Outputting one argument per line makes it easier to diff the results.
for (String argument : ShellEscaper.escapeAll(getArgv())) {
message.append(" Argument: ");
message.append(argument);
message.append('\n');
}
for (PathFragment path : context.getDeclaredIncludeDirs()) {
message.append(" Declared include directory: ");
message.append(ShellEscaper.escapeString(path.getPathString()));
message.append('\n');
}
for (PathFragment path : getDeclaredIncludeSrcsInStableOrder()) {
message.append(" Declared include source: ");
message.append(ShellEscaper.escapeString(path.getPathString()));
message.append('\n');
}
for (PathFragment path : getExtraSystemIncludePrefixes()) {
message.append(" Extra system include prefix: ");
message.append(ShellEscaper.escapeString(path.getPathString()));
message.append('\n');
}
return message.toString();
}
/**
* The compile command line for the enclosing C++ compile action.
*/
public final class CppCompileCommandLine {
private final Artifact sourceFile;
private final DotdFile dotdFile;
private final CppModuleMap cppModuleMap;
private final List<String> copts;
private final Predicate<String> coptsFilter;
private final List<String> pluginOpts;
private final boolean isInstrumented;
private final Collection<String> features;
private final FeatureConfiguration featureConfiguration;
// The value of the BUILD_FDO_TYPE macro to be defined on command line
@Nullable private final String fdoBuildStamp;
public CppCompileCommandLine(Artifact sourceFile, DotdFile dotdFile, CppModuleMap cppModuleMap,
ImmutableList<String> copts, Predicate<String> coptsFilter,
ImmutableList<String> pluginOpts, boolean isInstrumented,
Collection<String> features, FeatureConfiguration featureConfiguration,
@Nullable String fdoBuildStamp) {
this.sourceFile = Preconditions.checkNotNull(sourceFile);
this.dotdFile = Preconditions.checkNotNull(dotdFile);
this.cppModuleMap = cppModuleMap;
this.copts = Preconditions.checkNotNull(copts);
this.coptsFilter = coptsFilter;
this.pluginOpts = Preconditions.checkNotNull(pluginOpts);
this.isInstrumented = isInstrumented;
this.features = Preconditions.checkNotNull(features);
this.featureConfiguration = featureConfiguration;
this.fdoBuildStamp = fdoBuildStamp;
}
protected List<String> getArgv(PathFragment outputFile) {
List<String> commandLine = new ArrayList<>();
// first: The command name.
commandLine.add(cppConfiguration.getToolPathFragment(Tool.GCC).getPathString());
// second: The compiler options.
commandLine.addAll(getCompilerOptions());
// third: The file to compile!
commandLine.add("-c");
commandLine.add(sourceFile.getExecPathString());
// finally: The output file. (Prefixed with -o).
commandLine.add("-o");
commandLine.add(outputFile.getPathString());
return commandLine;
}
private String getActionName() {
PathFragment sourcePath = sourceFile.getExecPath();
if (CppFileTypes.CPP_MODULE_MAP.matches(sourcePath)) {
return CPP_MODULE_COMPILE;
} else if (CppFileTypes.CPP_HEADER.matches(sourcePath)) {
// TODO(bazel-team): Handle C headers that probably don't work in C++ mode.
if (featureConfiguration.isEnabled(CppRuleClasses.PARSE_HEADERS)) {
return CPP_HEADER_PARSING;
} else if (featureConfiguration.isEnabled(CppRuleClasses.PREPROCESS_HEADERS)) {
return CPP_HEADER_PREPROCESSING;
} else {
// CcCommon.collectCAndCppSources() ensures we do not add headers to
// the compilation artifacts unless either 'parse_headers' or
// 'preprocess_headers' is set.
throw new IllegalStateException();
}
} else if (CppFileTypes.C_SOURCE.matches(sourcePath)) {
return C_COMPILE;
} else if (CppFileTypes.CPP_SOURCE.matches(sourcePath)) {
return CPP_COMPILE;
} else if (CppFileTypes.ASSEMBLER_WITH_C_PREPROCESSOR.matches(sourcePath)) {
return PREPROCESS_ASSEMBLE;
}
// CcLibraryHelper ensures CppCompileAction only gets instantiated for supported file types.
throw new IllegalStateException();
}
public List<String> getCompilerOptions() {
List<String> options = new ArrayList<>();
CppConfiguration toolchain = cppConfiguration;
// pluginOpts has to be added before defaultCopts because -fplugin must precede -plugin-arg.
options.addAll(pluginOpts);
addFilteredOptions(options, toolchain.getCompilerOptions(features));
// Enable instrumentation if requested.
if (isInstrumented) {
addFilteredOptions(options, ImmutableList.of("-fprofile-arcs", "-ftest-coverage"));
}
String sourceFilename = sourceFile.getExecPathString();
if (CppFileTypes.C_SOURCE.matches(sourceFilename)) {
addFilteredOptions(options, toolchain.getCOptions());
}
if (CppFileTypes.CPP_SOURCE.matches(sourceFilename)
|| CppFileTypes.CPP_HEADER.matches(sourceFilename)
|| CppFileTypes.CPP_MODULE_MAP.matches(sourceFilename)) {
addFilteredOptions(options, toolchain.getCxxOptions(features));
}
// Users don't expect the explicit copts to be filtered by coptsFilter, add them verbatim.
options.addAll(copts);
for (String warn : cppConfiguration.getCWarns()) {
options.add("-W" + warn);
}
for (String define : context.getDefines()) {
options.add("-D" + define);
}
// Stamp FDO builds with FDO subtype string
if (fdoBuildStamp != null) {
options.add("-D" + CppConfiguration.FDO_STAMP_MACRO + "=\"" + fdoBuildStamp + "\"");
}
CcToolchainFeatures.Variables.Builder buildVariables =
new CcToolchainFeatures.Variables.Builder();
if (featureConfiguration.isEnabled(CppRuleClasses.MODULE_MAPS) && cppModuleMap != null) {
// If the feature is enabled and cppModuleMap is null, we are about to fail during analysis
// in any case, but don't crash.
buildVariables.addVariable("module_name", cppModuleMap.getName());
buildVariables.addVariable("module_map_file",
cppModuleMap.getArtifact().getExecPathString());
}
if (featureConfiguration.isEnabled(CppRuleClasses.USE_HEADER_MODULES)) {
buildVariables.addSequenceVariable("module_files", getHeaderModulePaths());
}
if (featureConfiguration.isEnabled(CppRuleClasses.INCLUDE_PATHS)) {
buildVariables.addSequenceVariable("include_paths",
getSafePathStrings(context.getIncludeDirs()));
buildVariables.addSequenceVariable("quote_include_paths",
getSafePathStrings(context.getQuoteIncludeDirs()));
buildVariables.addSequenceVariable("system_include_paths",
getSafePathStrings(context.getSystemIncludeDirs()));
}
// TODO(bazel-team): This needs to be before adding getUnfilteredCompilerOptions() and after
// adding the warning flags until all toolchains are migrated; currently toolchains use the
// unfiltered compiler options to inject include paths, which is superseded by the feature
// configuration; on the other hand toolchains switch off warnings for the layering check
// that will be re-added by the feature flags.
options.addAll(featureConfiguration.getCommandLine(getActionName(), buildVariables.build()));
options.addAll(toolchain.getUnfilteredCompilerOptions(features));
// GCC gives randomized names to symbols which are defined in
// an anonymous namespace but have external linkage. To make
// computation of these deterministic, we want to override the
// default seed for the random number generator. It's safe to use
// any value which differs for all translation units; we use the
// path to the object file.
options.add("-frandom-seed=" + outputFile.getExecPathString());
// Add the options of --per_file_copt, if the label or the base name of the source file
// matches the specified regular expression filter.
for (PerLabelOptions perLabelOptions : cppConfiguration.getPerFileCopts()) {
if ((sourceLabel != null && perLabelOptions.isIncluded(sourceLabel))
|| perLabelOptions.isIncluded(sourceFile)) {
options.addAll(perLabelOptions.getOptions());
}
}
// Enable <object>.d file generation.
if (dotdFile != null) {
// Gcc options:
// -MD turns on .d file output as a side-effect (doesn't imply -E)
// -MM[D] enables user includes only, not system includes
// -MF <name> specifies the dotd file name
// Issues:
// -M[M] alone subverts actual .o output (implies -E)
// -M[M]D alone breaks some of the .d naming assumptions
// This combination gets user and system includes with specified name:
// -MD -MF <name>
options.add("-MD");
options.add("-MF");
options.add(dotdFile.getSafeExecPath().getPathString());
}
if (FileType.contains(outputFile, CppFileTypes.ASSEMBLER, CppFileTypes.PIC_ASSEMBLER)) {
options.add("-S");
} else if (FileType.contains(outputFile, CppFileTypes.PREPROCESSED_C,
CppFileTypes.PREPROCESSED_CPP, CppFileTypes.PIC_PREPROCESSED_C,
CppFileTypes.PIC_PREPROCESSED_CPP)) {
options.add("-E");
}
if (cppConfiguration.useFission()) {
options.add("-gsplit-dwarf");
}
if (usePic) {
options.add("-fPIC");
}
return options;
}
/**
* Get the safe path strings for a list of paths to use in the build variables.
*/
private Collection<String> getSafePathStrings(Collection<PathFragment> paths) {
ImmutableSet.Builder<String> result = ImmutableSet.builder();
for (PathFragment path : paths) {
result.add(path.getSafePathString());
}
return result.build();
}
/**
* Select .pcm inputs to pass on the command line depending on whether we are in pic or non-pic
* mode.
*/
private Collection<String> getHeaderModulePaths() {
Collection<String> result = new LinkedHashSet<>();
NestedSet<Artifact> artifacts = featureConfiguration.isEnabled(
CppRuleClasses.HEADER_MODULE_INCLUDES_DEPENDENCIES)
? context.getTopLevelHeaderModules()
: context.getAdditionalInputs();
for (Artifact artifact : artifacts) {
String filename = artifact.getFilename();
if (!filename.endsWith(".pcm")) {
continue;
}
// Depending on whether this specific compile action is pic or non-pic, select the
// corresponding header modules. Note that the compilation context might give us both
// from targets that are built in both modes.
if (usePic == filename.endsWith(".pic.pcm")) {
result.add(artifact.getExecPathString());
}
}
return result;
}
// For each option in 'in', add it to 'out' unless it is matched by the 'coptsFilter' regexp.
private void addFilteredOptions(List<String> out, List<String> in) {
Iterables.addAll(out, Iterables.filter(in, coptsFilter));
}
}
/**
* A reference to a .d file. There are two modes:
* <ol>
* <li>an Artifact that represents a real on-disk file
* <li>just an execPath that refers to a virtual .d file that is not written to disk
* </ol>
*/
public static class DotdFile {
private final Artifact artifact;
private final PathFragment execPath;
public DotdFile(Artifact artifact) {
this.artifact = artifact;
this.execPath = null;
}
public DotdFile(PathFragment execPath) {
this.artifact = null;
this.execPath = execPath;
}
/**
* @return the Artifact or null
*/
public Artifact artifact() {
return artifact;
}
/**
* @return Gets the execPath regardless of whether this is a real Artifact
*/
public PathFragment getSafeExecPath() {
return execPath == null ? artifact.getExecPath() : execPath;
}
/**
* @return the on-disk location of the .d file or null
*/
public Path getPath() {
return artifact.getPath();
}
}
}
|