| #!/bin/bash -u |
| # Copyright 2018 Google Inc. |
| # |
| # 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: |
| # |
| # 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. |
| # |
| ################################################################################ |
| cd $OUT |
|
|
| if (( $# > 0 )); then |
| FUZZ_TARGETS="$@" |
| else |
| FUZZ_TARGETS="$(find . -maxdepth 1 -type f -executable -printf '%P\n' | \ |
| grep -v -x -F \ |
| -e 'llvm-symbolizer' \ |
| -e 'jazzer_agent_deploy.jar' \ |
| -e 'jazzer_driver' \ |
| -e 'jazzer_driver_with_sanitizer' \ |
| -e 'sanitizer_with_fuzzer.so')" |
| fi |
|
|
| COVERAGE_OUTPUT_DIR=${COVERAGE_OUTPUT_DIR:-$OUT} |
|
|
| DUMPS_DIR="$COVERAGE_OUTPUT_DIR/dumps" |
| FUZZERS_COVERAGE_DUMPS_DIR="$DUMPS_DIR/fuzzers_coverage" |
| MERGED_COVERAGE_DIR="$COVERAGE_OUTPUT_DIR/merged_coverage" |
| FUZZER_STATS_DIR="$COVERAGE_OUTPUT_DIR/fuzzer_stats" |
| TEXTCOV_REPORT_DIR="$COVERAGE_OUTPUT_DIR/textcov_reports" |
| LOGS_DIR="$COVERAGE_OUTPUT_DIR/logs" |
| REPORT_ROOT_DIR="$COVERAGE_OUTPUT_DIR/report" |
| REPORT_BY_TARGET_ROOT_DIR="$COVERAGE_OUTPUT_DIR/report_target" |
| PLATFORM=linux |
| REPORT_PLATFORM_DIR="$COVERAGE_OUTPUT_DIR/report/$PLATFORM" |
|
|
| for directory in $DUMPS_DIR $FUZZER_STATS_DIR $LOGS_DIR $REPORT_ROOT_DIR $TEXTCOV_REPORT_DIR\ |
| $REPORT_PLATFORM_DIR $REPORT_BY_TARGET_ROOT_DIR $FUZZERS_COVERAGE_DUMPS_DIR $MERGED_COVERAGE_DIR; do |
| rm -rf $directory |
| mkdir -p $directory |
| done |
|
|
| PROFILE_FILE="$DUMPS_DIR/merged.profdata" |
| SUMMARY_FILE="$REPORT_PLATFORM_DIR/summary.json" |
| COVERAGE_TARGET_FILE="$FUZZER_STATS_DIR/coverage_targets.txt" |
|
|
| # Use path mapping, as $SRC directory from the builder is copied into $OUT/$SRC. |
| PATH_EQUIVALENCE_ARGS="-path-equivalence=/,$OUT" |
|
|
| # It's important to use $COVERAGE_EXTRA_ARGS as the last argument, because it |
| # can contain paths to source files / directories which are positional args. |
| LLVM_COV_COMMON_ARGS="$PATH_EQUIVALENCE_ARGS \ |
| -ignore-filename-regex=.*src/libfuzzer/.* $COVERAGE_EXTRA_ARGS" |
| |
| # Options to extract branch coverage. |
| BRANCH_COV_ARGS="--show-branches=count --show-expansions" |
| |
| # Timeout for running a single fuzz target. |
| TIMEOUT=1h |
| |
| # This will be used by llvm-cov command to generate the actual report. |
| objects="" |
| |
| # Number of CPUs available, this is needed for running tests in parallel. |
| # Set the max number of parallel jobs to be the CPU count and a max of 10. |
| NPROC=$(nproc) |
| MAX_PARALLEL_COUNT=10 |
| |
| CORPUS_DIR=${CORPUS_DIR:-"/corpus"} |
| |
| function run_fuzz_target { |
| local target=$1 |
| |
| # '%1m' will produce separate dump files for every object. For example, if a |
| # fuzz target loads a shared library, we will have dumps for both of them. |
| local profraw_file="$DUMPS_DIR/$target.%1m.profraw" |
| local profraw_file_mask="$DUMPS_DIR/$target.*.profraw" |
| local profdata_file="$DUMPS_DIR/$target.profdata" |
| local corpus_real="$CORPUS_DIR/${target}" |
| |
| # -merge=1 requires an output directory, create a new, empty dir for that. |
| local corpus_dummy="$OUT/dummy_corpus_dir_for_${target}" |
| rm -rf $corpus_dummy && mkdir -p $corpus_dummy |
| |
| # Use -merge=1 instead of -runs=0 because merge is crash resistant and would |
| # let to get coverage using all corpus files even if there are crash inputs. |
| # Merge should not introduce any significant overhead compared to -runs=0, |
| # because (A) corpuses are already minimized; (B) we do not use sancov, and so |
| # libFuzzer always finishes merge with an empty output dir. |
| # Use 100s timeout instead of 25s as code coverage builds can be very slow. |
| local args="-merge=1 -timeout=100 $corpus_dummy $corpus_real" |
| |
| export LLVM_PROFILE_FILE=$profraw_file |
| timeout $TIMEOUT $OUT/$target $args &> $LOGS_DIR/$target.log |
| if (( $? != 0 )); then |
| echo "Error occured while running $target:" |
| cat $LOGS_DIR/$target.log |
| fi |
| |
| rm -rf $corpus_dummy |
| if (( $(du -c $profraw_file_mask | tail -n 1 | cut -f 1) == 0 )); then |
| # Skip fuzz targets that failed to produce profile dumps. |
| return 0 |
| fi |
| |
| # If necessary translate to latest profraw version. |
| if [[ $target == *"@"* ]]; then |
| # Extract fuzztest binary name from fuzztest wrapper script. |
| target=(${target//@/ }[0]) |
| fi |
| profraw_update.py $OUT/$target -i $profraw_file_mask |
| llvm-profdata merge -j=1 -sparse $profraw_file_mask -o $profdata_file |
| |
| # Delete unnecessary and (potentially) large .profraw files. |
| rm $profraw_file_mask |
| |
| shared_libraries=$(coverage_helper shared_libs -build-dir=$OUT -object=$target) |
| |
| llvm-cov export -summary-only -instr-profile=$profdata_file -object=$target \ |
| $shared_libraries $LLVM_COV_COMMON_ARGS > $FUZZER_STATS_DIR/$target.json |
| |
| # For introspector. |
| llvm-cov show -instr-profile=$profdata_file -object=$target -line-coverage-gt=0 $shared_libraries $BRANCH_COV_ARGS $LLVM_COV_COMMON_ARGS > ${TEXTCOV_REPORT_DIR}/$target.covreport |
| } |
| |
| function run_go_fuzz_target { |
| local target=$1 |
| |
| echo "Running go target $target" |
| export FUZZ_CORPUS_DIR="$CORPUS_DIR/${target}/" |
| export FUZZ_PROFILE_NAME="$DUMPS_DIR/$target.perf" |
| |
| # setup for native go fuzzers |
| cd $OUT |
| mkdir -p "testdata/fuzz/${target}" |
| cp -r "${FUZZ_CORPUS_DIR}" "testdata/fuzz/" |
| |
| # rewrite libFuzzer corpus to Std Go corpus if native fuzzing |
| grep "TestFuzzCorpus" $target > /dev/null 2>&1 && $SYSGOPATH/bin/convertcorpus $target "testdata/fuzz/${target}" |
| cd - |
| |
| timeout $TIMEOUT $OUT/$target -test.coverprofile $DUMPS_DIR/$target.profdata &> $LOGS_DIR/$target.log |
| if (( $? != 0 )); then |
| echo "Error occured while running $target:" |
| cat $LOGS_DIR/$target.log |
| fi |
| |
| # cleanup after native go fuzzers |
| rm -r "${OUT}/testdata/fuzz/${target}" |
| |
| # The Go 1.18 fuzzers are renamed to "*_fuzz_.go" during "infra/helper.py build_fuzzers". |
| # They are are therefore refered to as "*_fuzz_.go" in the profdata files. |
| # Since the copies named "*_fuzz_.go" do not exist in the file tree during |
| # the coverage build, we change the references in the .profdata files |
| # to the original file names. |
| #sed -i "s/_test.go_fuzz_.go/_test.go/g" $DUMPS_DIR/$target.profdata |
| # translate from golangish paths to current absolute paths |
| cat $OUT/$target.gocovpath | while read i; do sed -i $i $DUMPS_DIR/$target.profdata; done |
| # cf PATH_EQUIVALENCE_ARGS |
| sed -i 's=/='$OUT'/=' $DUMPS_DIR/$target.profdata |
| $SYSGOPATH/bin/gocovsum $DUMPS_DIR/$target.profdata > $FUZZER_STATS_DIR/$target.json |
| } |
| |
| function run_python_fuzz_target { |
| local target=$1 |
| local zipped_sources="$DUMPS_DIR/$target.deps.zip" |
| local corpus_real="$CORPUS_DIR/${target}" |
| # Write dummy stats file |
| echo "{}" > "$FUZZER_STATS_DIR/$target.json" |
| |
| # Run fuzzer |
| $OUT/$target $corpus_real -atheris_runs=$(ls -la $corpus_real | wc -l) > $LOGS_DIR/$target.log 2>&1 |
| if (( $? != 0 )); then |
| echo "Error happened getting coverage of $target" |
| echo "This is likely because Atheris did not exit gracefully" |
| cat $LOGS_DIR/$target.log |
| return 0 |
| fi |
| mv .coverage $OUT/.coverage_$target |
| } |
| |
| function run_java_fuzz_target { |
| local target=$1 |
| |
| local exec_file="$DUMPS_DIR/$target.exec" |
| local class_dump_dir="$DUMPS_DIR/${target}_classes/" |
| mkdir "$class_dump_dir" |
| local corpus_real="$CORPUS_DIR/${target}" |
| |
| # -merge=1 requires an output directory, create a new, empty dir for that. |
| local corpus_dummy="$OUT/dummy_corpus_dir_for_${target}" |
| rm -rf $corpus_dummy && mkdir -p $corpus_dummy |
| |
| # Use 100s timeout instead of 25s as code coverage builds can be very slow. |
| local jacoco_args="destfile=$exec_file,classdumpdir=$class_dump_dir,excludes=com.code_intelligence.jazzer.*\\:com.sun.tools.attach.VirtualMachine" |
| local args="-merge=1 -timeout=100 --nohooks \ |
| --additional_jvm_args=-javaagent\\:/opt/jacoco-agent.jar=$jacoco_args \ |
| $corpus_dummy $corpus_real" |
| |
| timeout $TIMEOUT $OUT/$target $args &> $LOGS_DIR/$target.log |
| if (( $? != 0 )); then |
| echo "Error occured while running $target:" |
| cat $LOGS_DIR/$target.log |
| fi |
| |
| if (( $(du -c $exec_file | tail -n 1 | cut -f 1) == 0 )); then |
| # Skip fuzz targets that failed to produce .exec files. |
| echo "$target failed to produce .exec file." |
| return 0 |
| fi |
| |
| # Generate XML report only as input to jacoco_report_converter. |
| # Source files are not needed for the summary. |
| local xml_report="$DUMPS_DIR/${target}.xml" |
| local summary_file="$FUZZER_STATS_DIR/$target.json" |
| java -jar /opt/jacoco-cli.jar report $exec_file \ |
| --xml $xml_report \ |
| --classfiles $class_dump_dir |
| |
| # Write llvm-cov summary file. |
| jacoco_report_converter.py $xml_report $summary_file |
| } |
| |
| function run_javascript_fuzz_target { |
| local target=$1 |
| local corpus_real="$CORPUS_DIR/${target}" |
| |
| # -merge=1 requires an output directory, create a new, empty dir for that. |
| local corpus_dummy="$OUT/dummy_corpus_dir_for_${target}" |
| rm -rf $corpus_dummy && mkdir -p $corpus_dummy |
| |
| # IstanbulJS currently does not work when the tested program creates |
| # subprocesses. For this reason, we first minimize the corpus removing |
| # any crashing inputs so that we can report source-based code coverage |
| # with a single sweep over the minimized corpus |
| local merge_args="-merge=1 -timeout=100 $corpus_dummy $corpus_real" |
| timeout $TIMEOUT $OUT/$target $merge_args &> $LOGS_DIR/$target.log |
| |
| # nyc saves the coverage reports in a directory with the default name "coverage" |
| local coverage_dir="$DUMPS_DIR/coverage_dir_for_${target}" |
| rm -rf $coverage_dir && mkdir -p $coverage_dir |
| |
| local nyc_json_coverage_file="$coverage_dir/coverage-final.json" |
| local nyc_json_summary_file="$coverage_dir/coverage-summary.json" |
| |
| local args="-runs=0 $corpus_dummy" |
| local jazzerjs_args="--coverage --coverageDirectory $coverage_dir --coverageReporters json --coverageReporters json-summary" |
| |
| JAZZERJS_EXTRA_ARGS=$jazzerjs_args $OUT/$target $args &> $LOGS_DIR/$target.log |
| |
| if (( $? != 0 )); then |
| echo "Error occured while running $target:" |
| cat $LOGS_DIR/$target.log |
| fi |
| |
| if [ ! -s $nyc_json_coverage_file ]; then |
| # Skip fuzz targets that failed to produce coverage-final.json file. |
| echo "$target failed to produce coverage-final.json file." |
| return 0 |
| fi |
| |
| cp $nyc_json_coverage_file $FUZZERS_COVERAGE_DUMPS_DIR/$target.json |
| |
| local summary_file="$FUZZER_STATS_DIR/$target.json" |
| |
| nyc_report_converter.py $nyc_json_summary_file $summary_file |
| } |
| |
| function generate_html { |
| local profdata=$1 |
| local shared_libraries=$2 |
| local objects=$3 |
| local output_dir=$4 |
| |
| rm -rf "$output_dir" |
| mkdir -p "$output_dir/$PLATFORM" |
| |
| local llvm_cov_args="-instr-profile=$profdata $objects $LLVM_COV_COMMON_ARGS" |
| llvm-cov show -format=html -output-dir=$output_dir -Xdemangler rcfilt $llvm_cov_args |
| |
| # Export coverage summary in JSON format. |
| local summary_file=$output_dir/$PLATFORM/summary.json |
| |
| llvm-cov export -summary-only $llvm_cov_args > $summary_file |
| |
| coverage_helper -v post_process -src-root-dir=/ -summary-file=$summary_file \ |
| -output-dir=$output_dir $PATH_EQUIVALENCE_ARGS |
| } |
| |
| export SYSGOPATH=$GOPATH |
| export GOPATH=$OUT/$GOPATH |
| # Run each fuzz target, generate raw coverage dumps. |
| for fuzz_target in $FUZZ_TARGETS; do |
| # Test if fuzz target is a golang one. |
| if [[ $FUZZING_LANGUAGE == "go" ]]; then |
| # Continue if not a fuzz target. |
| if [[ $FUZZING_ENGINE != "none" ]]; then |
| grep "FUZZ_CORPUS_DIR" $fuzz_target > /dev/null 2>&1 || grep "testing\.T" $fuzz_target > /dev/null 2>&1 || continue |
| fi |
| # Log the target in the targets file. |
| echo ${fuzz_target} >> $COVERAGE_TARGET_FILE |
| |
| # Run the coverage collection. |
| run_go_fuzz_target $fuzz_target & |
| elif [[ $FUZZING_LANGUAGE == "python" ]]; then |
| echo "Entering python fuzzing" |
| # Log the target in the targets file. |
| echo ${fuzz_target} >> $COVERAGE_TARGET_FILE |
| |
| # Run the coverage collection. |
| run_python_fuzz_target $fuzz_target |
| elif [[ $FUZZING_LANGUAGE == "jvm" ]]; then |
| # Continue if not a fuzz target. |
| if [[ $FUZZING_ENGINE != "none" ]]; then |
| grep "LLVMFuzzerTestOneInput" $fuzz_target > /dev/null 2>&1 || continue |
| fi |
| |
| echo "Running $fuzz_target" |
| # Log the target in the targets file. |
| echo ${fuzz_target} >> $COVERAGE_TARGET_FILE |
| |
| # Run the coverage collection. |
| run_java_fuzz_target $fuzz_target & |
| elif [[ $FUZZING_LANGUAGE == "javascript" ]]; then |
| # Continue if not a fuzz target. |
| if [[ $FUZZING_ENGINE != "none" ]]; then |
| grep "LLVMFuzzerTestOneInput" $fuzz_target > /dev/null 2>&1 || continue |
| fi |
| |
| echo "Running $fuzz_target" |
| # Log the target in the targets file. |
| echo ${fuzz_target} >> $COVERAGE_TARGET_FILE |
| |
| # Run the coverage collection. |
| run_javascript_fuzz_target $fuzz_target & |
| else |
| # Continue if not a fuzz target. |
| if [[ $FUZZING_ENGINE != "none" ]]; then |
| grep "LLVMFuzzerTestOneInput" $fuzz_target > /dev/null 2>&1 || continue |
| fi |
| |
| echo "Running $fuzz_target" |
| # Log the target in the targets file. |
| echo ${fuzz_target} >> $COVERAGE_TARGET_FILE |
| |
| # Run the coverage collection. |
| run_fuzz_target $fuzz_target & |
| |
| # Rewrite object if its a FUZZTEST target |
| if [[ $fuzz_target == *"@"* ]]; then |
| # Extract fuzztest binary name from fuzztest wrapper script. |
| fuzz_target=(${fuzz_target//@/ }[0]) |
| fi |
| if [[ -z $objects ]]; then |
| # The first object needs to be passed without -object= flag. |
| objects="$fuzz_target" |
| else |
| objects="$objects -object=$fuzz_target" |
| fi |
| fi |
| |
| |
| # Limit the number of processes to be spawned. |
| n_child_proc=$(jobs -rp | wc -l) |
| while [[ "$n_child_proc" -eq "$NPROC" || "$n_child_proc" -gt "$MAX_PARALLEL_COUNT" ]]; do |
| sleep 4 |
| n_child_proc=$(jobs -rp | wc -l) |
| done |
| done |
| |
| # Wait for background processes to finish. |
| wait |
| |
| if [[ $FUZZING_LANGUAGE == "go" ]]; then |
| echo $DUMPS_DIR |
| $SYSGOPATH/bin/gocovmerge $DUMPS_DIR/*.profdata > fuzz.cov |
| gotoolcover -html=fuzz.cov -o $REPORT_ROOT_DIR/index.html |
| $SYSGOPATH/bin/gocovsum fuzz.cov > $SUMMARY_FILE |
| cp $REPORT_ROOT_DIR/index.html $REPORT_PLATFORM_DIR/index.html |
| $SYSGOPATH/bin/pprof-merge $DUMPS_DIR/*.perf.cpu.prof |
| mv merged.data $REPORT_ROOT_DIR/cpu.prof |
| $SYSGOPATH/bin/pprof-merge $DUMPS_DIR/*.perf.heap.prof |
| mv merged.data $REPORT_ROOT_DIR/heap.prof |
| #TODO some proxy for go tool pprof -http=127.0.0.1:8001 $DUMPS_DIR/cpu.prof |
| echo "Finished generating code coverage report for Go fuzz targets." |
| elif [[ $FUZZING_LANGUAGE == "python" ]]; then |
| # Extract source files from all dependency zip folders |
| mkdir -p /pythoncovmergedfiles/medio |
| PYCOVDIR=/pycovdir/ |
| mkdir $PYCOVDIR |
| for fuzzer in $FUZZ_TARGETS; do |
| fuzzer_deps=${fuzzer}.pkg.deps.zip |
| unzip $OUT/${fuzzer_deps} |
| rsync -r ./medio /pythoncovmergedfiles/medio |
| rm -rf ./medio |
| |
| # Translate paths in unzipped folders to paths that we can use |
| mv $OUT/.coverage_$fuzzer .coverage |
| python3 /usr/local/bin/python_coverage_runner_help.py translate /pythoncovmergedfiles/medio |
| cp .new_coverage $PYCOVDIR/.coverage_$fuzzer |
| cp .new_coverage $OUT/coverage_d_$fuzzer |
| done |
| |
| # Combine coverage |
| cd $PYCOVDIR |
| python3 /usr/local/bin/python_coverage_runner_help.py combine .coverage_* |
| python3 /usr/local/bin/python_coverage_runner_help.py html |
| # Produce all_cov file used by fuzz introspector. |
| python3 /usr/local/bin/python_coverage_runner_help.py json -o ${TEXTCOV_REPORT_DIR}/all_cov.json |
| |
| # Generate .json with similar format to llvm-cov output. |
| python3 /usr/local/bin/python_coverage_runner_help.py \ |
| convert-to-summary-json ${TEXTCOV_REPORT_DIR}/all_cov.json $SUMMARY_FILE |
| |
| # Copy coverage date out |
| cp htmlcov/status.json ${TEXTCOV_REPORT_DIR}/html_status.json |
| |
| mv htmlcov/* $REPORT_PLATFORM_DIR/ |
| mv .coverage_* $REPORT_PLATFORM_DIR/ |
| elif [[ $FUZZING_LANGUAGE == "jvm" ]]; then |
| |
| # From this point on the script does not tolerate any errors. |
| set -e |
| |
| # Merge .exec files from the individual targets. |
| jacoco_merged_exec=$DUMPS_DIR/jacoco.merged.exec |
| java -jar /opt/jacoco-cli.jar merge $DUMPS_DIR/*.exec \ |
| --destfile $jacoco_merged_exec |
| |
| # Prepare classes directory for jacoco process |
| classes_dir=$DUMPS_DIR/classes |
| mkdir $classes_dir |
| |
| # Only copy class files found in $OUT/$SRC to ensure they are |
| # lively compiled from the project, avoiding inclusion of |
| # dependency classes. This also includes the fuzzer classes. |
| find "$OUT/$SRC" -type f -name "*.class" | while read -r class_file; do |
| # Skip module-info.class |
| if [[ "$(basename "$class_file")" == "module-info.class" ]]; then |
| continue |
| fi |
| |
| # Use javap to extract the fully qualified name of the class and copy it to $classes_dir |
| fqn=$(javap -verbose "$class_file" 2>/dev/null | grep "this_class:" | grep -oP '(?<= |
| if [ -n "$fqn" ]; then |
| mkdir -p $classes_dir/$(dirname $fqn) |
| cp $class_file $classes_dir/$fqn.class |
| fi |
| done |
|
|
| # Heuristically determine source directories based on Maven structure. |
| # Always include the $SRC root as it likely contains the fuzzer sources. |
| sourcefiles_args=(--sourcefiles $OUT/$SRC) |
| source_dirs=$(find $OUT/$SRC -type d -name 'java') |
| for source_dir in $source_dirs; do |
| sourcefiles_args+=(--sourcefiles "$source_dir") |
| done |
|
|
| # Generate HTML and XML reports. |
| xml_report=$REPORT_PLATFORM_DIR/index.xml |
| java -jar /opt/jacoco-cli.jar report $jacoco_merged_exec \ |
| --html $REPORT_PLATFORM_DIR \ |
| --xml $xml_report \ |
| --classfiles $classes_dir \ |
| "${sourcefiles_args[@]}" |
|
|
| # Also serve the raw exec file and XML report, which can be useful for |
| # automated analysis. |
| cp $jacoco_merged_exec $REPORT_PLATFORM_DIR/jacoco.exec |
| cp $xml_report $REPORT_PLATFORM_DIR/jacoco.xml |
| cp $xml_report $TEXTCOV_REPORT_DIR/jacoco.xml |
|
|
| # Write llvm-cov summary file. |
| jacoco_report_converter.py $xml_report $SUMMARY_FILE |
|
|
| set +e |
| elif [[ $FUZZING_LANGUAGE == "javascript" ]]; then |
|
|
| # From this point on the script does not tolerate any errors. |
| set -e |
|
|
| json_report=$MERGED_COVERAGE_DIR/coverage.json |
| nyc merge $FUZZERS_COVERAGE_DUMPS_DIR $json_report |
|
|
| nyc report -t $MERGED_COVERAGE_DIR --report-dir $REPORT_PLATFORM_DIR --reporter=html --reporter=json-summary |
|
|
| nyc_json_summary_file=$REPORT_PLATFORM_DIR/coverage-summary.json |
|
|
| # Write llvm-cov summary file. |
| nyc_report_converter.py $nyc_json_summary_file $SUMMARY_FILE |
|
|
| set +e |
| else |
|
|
| # From this point on the script does not tolerate any errors. |
| set -e |
|
|
| # Merge all dumps from the individual targets. |
| rm -f $PROFILE_FILE |
| llvm-profdata merge -sparse $DUMPS_DIR |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
