[BOLT] Check no-LBR samples in mayHaveProfileData

[Amir]

Summary

No-LBR mode wasn't tested and slipped when mayHaveProfileData was added for
Lite mode. This enables processing of profiles collected without LBR and
converted with perf2bolt -nl option.

Test Plan:
bin/llvm-lit -a tools/bolt/test/X86/nolbr.s
https://github.com/rafaelauler/bolt-tests/pull/20

[maksfb]

Thanks for the fix! Anyway we can get link_fdata to work with the sample data (if it doesn't already) to remove the necessity for the binary test?

[Amir]

Add X86/nolbr.s test, update link_fdata to accept no-lbr profile

[Amir]

Fixup DataAggregator::processProfile (mark the function as profiled).
TBD: attach profile to basic blocks (add convertSampleData following
convertBranchData as example)

[rafauler]

bolt/test/X86/nolbr.s

29

fix tabs in your editor

[Amir]

Fix indenting in test

bolt/lib/Profile/DataAggregator.cpp

void DataAggregator::processProfile(BinaryContext &BC) {
   else
     processBranchEvents();
 
   processMemEvents();
 
   // Mark all functions with registered events as having a valid profile.
   for (auto &BFI : BC.getBinaryFunctions()) {
     BinaryFunction &BF = BFI.second;
-    if (getBranchData(BF)) {
+    if (getBranchData(BF) || getFuncSampleData(BF.getNames())) {
       const auto Flags = opts::BasicAggregation ? BinaryFunction::PF_SAMPLE
                                                 : BinaryFunction::PF_LBR;
       BF.markProfiled(Flags);
     }
   }
 
   // Release intermediate storage.
   clear(BranchLBRs);

bolt/lib/Profile/DataReader.cpp

 }
 
 }
 
 bool DataReader::mayHaveProfileData(const BinaryFunction &Function) {
   if (getBranchData(Function) || getMemData(Function))
     return true;
 
-  if (getBranchDataForNames(Function.getNames()) ||
+  if (getFuncSampleData(Function.getNames()) ||
+      getBranchDataForNames(Function.getNames()) ||
       getMemDataForNames(Function.getNames()))
     return true;
 
   if (!hasVolatileName(Function))
     return false;
 
   const std::vector<FuncBranchData *> AllBranchData =
       getBranchDataForNamesRegex(Function.getNames());

bolt/test/X86/nolbr.s

+# This reproduces a bug where profile collected from perf without LBRs and
+# converted into fdata-no-lbr format is reported to not contain profile for any
+# functions.
+
+# REQUIRES: system-linux
+
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
+# RUN:   %s -o %t.o
+# RUN: link_fdata --no-lbr %s %t.o %t.fdata
+# RUN: FileCheck %s --input-file %t.fdata --check-prefix=CHECK-FDATA
+# RUN: llvm-strip --strip-unneeded %t.o
+# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
+# RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata --dyno-stats -nl \
+# RUN:    --print-only=_start 2>&1 | FileCheck %s --check-prefix=CHECK-BOLT
+
+# CHECK-FDATA:      no_lbr
+# CHECK-FDATA-NEXT: 1 _start [[#]] 1
+
+# CHECK-BOLT: BOLT-INFO: pre-processing profile using branch profile reader
+# CHECK-BOLT: BOLT-INFO: operating with basic samples profiling data (no LBR).
+# CHECK-BOLT: BOLT-INFO: 1 out of 1 functions in the binary (100.0%) have non-empty execution profile
+
+  .globl _start
+  .type _start, %function
+_start:
+  pushq %rbp
+  movq  %rsp, %rbp
+  cmpl  $0x0, %eax
+a:
+# FDATA: 1 _start #a# 1
+  je b
+  movl  $0x0, %eax
+  jmp c
+b:
+  movl  $0x1, %eax
+c:
+  popq  %rbp
+  retq
+.size _start, .-_start

bolt/test/link_fdata.py

 import re
 
 parser = argparse.ArgumentParser()
 parser.add_argument("input")
 parser.add_argument("objfile", help="Object file to extract symbol values from")
 parser.add_argument("output")
 parser.add_argument("prefix", nargs="?", default="FDATA", help="Custom FDATA prefix")
 parser.add_argument("--nmtool", default="nm", help="Path to nm tool")
+parser.add_argument("--no-lbr", action='store_true')
 
 args = parser.parse_args()
 
 # Regexes to extract FDATA lines from input and parse FDATA and pre-aggregated
 # profile data
 prefix_pat = re.compile(f"^# {args.prefix}: (.*)")
 
 # FDATA records:
 # <is symbol?> <closest elf symbol or DSO name> <relative FROM address>
 # <is symbol?> <closest elf symbol or DSO name> <relative TO address>
 # <number of mispredictions> <number of branches>
 fdata_pat = re.compile(r"([01].*) (?P<exec>\d+) (?P<mispred>\d+)")
 
 # Pre-aggregated profile:
 # {B|F|f} [<start_id>:]<start_offset> [<end_id>:]<end_offset> <count>
 # [<mispred_count>]
 preagg_pat = re.compile(r"(?P<type>[BFf]) (?P<offsets_count>.*)")
 
+# No-LBR profile:
+# <is symbol?> <closest elf symbol or DSO name> <relative address> <count>
+nolbr_pat = re.compile(r"([01].*) (?P<count>\d+)")
+
 # Replacement symbol: #symname#
 replace_pat = re.compile(r"#(?P<symname>[^#]+)#")
 
 # Read input and construct the representation of fdata expressions
 # as (src_tuple, dst_tuple, mispred_count, exec_count) tuples, where src and dst
 # are represented as (is_sym, anchor, offset) tuples
 exprs = []
 with open(args.input, 'r') as f:
     for line in f.readlines():
         prefix_match = prefix_pat.match(line)
         if not prefix_match:
             continue
         profile_line = prefix_match.group(1)
         fdata_match = fdata_pat.match(profile_line)
         preagg_match = preagg_pat.match(profile_line)
+        nolbr_match = nolbr_pat.match(profile_line)
         if fdata_match:
             src_dst, execnt, mispred = fdata_match.groups()
             # Split by whitespaces not preceded by a backslash (negative lookbehind)
             chunks = re.split(r'(?<!\\) +', src_dst)
             # Check if the number of records separated by non-escaped whitespace
             # exactly matches the format.
             assert len(chunks) == 6, f"ERROR: wrong format/whitespaces must be escaped:\n{line}"
             exprs.append(('FDATA', (*chunks, execnt, mispred)))
+        elif nolbr_match:
+            loc, count = nolbr_match.groups()
+            # Split by whitespaces not preceded by a backslash (negative lookbehind)
+            chunks = re.split(r'(?<!\\) +', loc)
+            # Check if the number of records separated by non-escaped whitespace
+            # exactly matches the format.
+            assert len(chunks) == 3, f"ERROR: wrong format/whitespaces must be escaped:\n{line}"
+            exprs.append(('NOLBR', (*chunks, count)))
         elif preagg_match:
             exprs.append(('PREAGG', preagg_match.groups()))
         else:
             exit("ERROR: unexpected input:\n%s" % line)
 
 # Read nm output: <symbol value> <symbol type> <symbol name>
 nm_output = subprocess.run([args.nmtool, '--defined-only', args.objfile],
                            text = True, capture_output = True).stdout
def replace_symbol(matchobj):
     '''
     Expects matchobj to only capture one group which contains the symbol name.
     '''
     symname = matchobj.group('symname')
     assert symname in symbols, f"ERROR: symbol {symname} is not defined in binary"
     return symbols[symname]
 
 with open(args.output, 'w', newline='\n') as f:
+    if args.no_lbr:
+        print('no_lbr', file = f)
     for etype, expr in exprs:
         if etype == 'FDATA':
             issym1, anchor1, offsym1, issym2, anchor2, offsym2, execnt, mispred = expr
             print(evaluate_symbol(issym1, anchor1, offsym1),
                   evaluate_symbol(issym2, anchor2, offsym2),
                   execnt, mispred, file = f)
+        elif etype == 'NOLBR':
+            issym, anchor, offsym, count = expr
+            print(evaluate_symbol(issym, anchor, offsym), count, file = f)
         elif etype == 'PREAGG':
             # Replace all symbols enclosed in ##
             print(expr[0], re.sub(replace_pat, replace_symbol, expr[1]),
                   file = f)
         else:
             exit("ERROR: unhandled expression type:\n%s" % etype)