Currently, the `EliminateAvailableExternallyPass` only converts certain available externally functions to local if `avail-extern-to-local` is set or in contextual profiling mode. For global variables, it only drops their initializers. This PR adds an option to allow the pass to convert global variables in a specified address space to local. The motivation for this change is to correctly support lowering of LDS variables (`__shared__` variables, in more generic terminology) when ThinLTO is enabled for AMDGPU. A `__shared__` variable is lowered to a hidden global variable in a particular address space by the frontend, which is roughly same as a `static` local variable. To properly lower it in the backend, the compiler needs to check all its uses. Enabling ThinLTO currently breaks this when a function containing a `__shared__` variable is imported from another module. Even though the global variable is imported along with its associated function, and the function is privatized by the `EliminateAvailableExternallyPass`, the global variable itself is not. It's safe to privatize such global variables, because they're _local_ to their associated functions. If the function itself is privatized, its associated global variables should also be privatized accordingly.
We will subsequently treat the whole profile as "flat" in the frontend, (i.e flatten and combine with the flat profile section), so we can have a profile for ThinLTO for parts of the application that don't come under the contextual profile. After ThinLTO, we will treat the module(s) containing contextual trees differently: they'll have only the contextual profile pertinent to them. The rest of the modules (non-contextual) will proceed "as usual", off the flattened profile. This patch implements pruning of the contextual profile to enable the above.
Mostly remove the equivalence "no contexts == no CtxProfAnalysis result", and instead check explicitly there are no contextual profiles.
#125983
Identified with misc-include-cleaner.
Fix post #109203
For the modules containing context roots, the way IPO happens will potentially result in imported functions that are differently specialized (even if themselves not inlined) than their originals. So we want to convert them to local rather than elide them. Eventually we'd perform this as a ThinLTO directive.
ThinLTO imports (which appear as `available_externally`) that survive inlining get deleted. With today's inliner that's reasonable, because the way the function would be inlined into in other modules would be the same - because of the bottom-up traversal assumption, and the fact that the inliner doesn't take into account surrounding context [*]. The ModuleInliner invalidates the first assumption, and the ML inliner the second. This patch adds a way to opt-in a module to keep its variant of an imported function, even if it survived past inlining. [*] Almost. Deferred inlining is an exception which can lead to (empirically) infrequent discrepancies. Differential Revision: https://reviews.llvm.org/D150148
Mostly removing includes of InitializePasses.h and Pass.h in passes that no longer has support for the legacy PM.