[BOLT] Disable -lite when split function is present

[nhuhuan]

Summary

In lite mode, BOLT only transforms a subset of functions, leave the
remaining functions intact.

For NoPIC, it is fine. BOLT can scan relocations and fix-up all refs
that point to any function body in the subset.

For no-split function PIC, it is fine. Since jump tables are intra-
procedural transfer, BOLT can find both the jump table base and the
target within same function. Thus, BOLT can update and/or move jump
tables.

However, it is wrong to process a subset of functions in split function
PIC. This is because BOLT does not know if functions in the subset are
isolated, i.e., cannot be accessed by functions out of the subset,
especially via split jump table.

For example, BOLT only process three functions A, B and C. Suppose that
A is reached via jump table from A.cold, which is not processed. When
A is moved (due to optimization), the jump table in A.cold is invalid.
We cannot fix-up this jump table since it is only recognized in A.cold,
which BOLT does not process.

Solution: Disable lite mode if split function is present.

Future improvement: In lite mode, if split function is found, BOLT
processes both functions in the subset and all of their sibling
fragments.

Test Plan:

ninja check-bolt

[Amir]

bolt/lib/Rewrite/RewriteInstance.cpp

1444

Let's move it under !PrintedWarning to only print it once.

[nhuhuan]

Avoid printing duplicate warnings.

[nhuhuan]

Clang-formatted.

[Amir]

Thanks!

[maksfb]

bolt/lib/Rewrite/RewriteInstance.cpp

1439

Check if the lite mode is enabled before issuing the warning.

[nhuhuan]

Check before issue the warning.

[maksfb]

bolt/lib/Rewrite/RewriteInstance.cpp

1441

nit: drop the trailing period.

[nhuhuan]

Remove trailing dots.

bolt/lib/Rewrite/RewriteInstance.cpp

for (auto BFI = BC->getBinaryFunctions().begin(),
     if (std::next(BFI) != BFE)
       NextFunction = &std::next(BFI)->second;
 
     // Check if it's a fragment of a function.
     Optional<StringRef> FragName =
         Function.hasRestoredNameRegex(".*\\.cold(\\.[0-9]+)?");
     if (FragName) {
       static bool PrintedWarning = false;
-      if (BC->HasRelocations && !PrintedWarning) {
-        errs() << "BOLT-WARNING: split function detected on input : "
-               << *FragName << ". The support is limited in relocation mode.\n";
+      if (!PrintedWarning) {
         PrintedWarning = true;
+        errs() << "BOLT-WARNING: split function detected on input : "
+               << *FragName;
+        if (BC->HasRelocations)
+          errs() << ". The support is limited in relocation mode";
+        if (opts::Lite) {
+          opts::Lite = false;
+          errs() << "\nBOLT-WARNING: disabling lite mode (-lite) when split "
+                 << "functions are present\n";
+        }
       }
       Function.IsFragment = true;
     }
 
     // Check if there's a symbol or a function with a larger address in the
     // same section. If there is - it determines the maximum size for the
     // current function. Otherwise, it is the size of a containing section
     // the defines it.
     //
     // NOTE: ignore some symbols that could be tolerated inside the body