I've fixed a bug when propagating a phi-node to both non-merged and merged users. The is stored into memory in the first valid insertion point of its parent block.
I also added a small test example to exercise this issue.

Ignored clang-format changes to unrelated code.

I had run clang-format on the new files. This updated diff also runs clang-format on the other files.

Minor suggestions.

The way I see it, with size level for LTO, we could have a different LTO optimization pipeline for size or runtime performance. For example, we could have a different tuning for inlining, vectorization, etc. We could also use the size level to automatically enable optimizations such as HotColdSplitting, MergeFunctions, etc., instead of relying on specific enabling flags. We could also have other size-specific optimizations in the future, such as MergeSimilarFunctions (https://reviews.llvm.org/D52896).

If reviewers think that this patch is touching in too many files, I could try to focus it only on the LTO related files, converting OptimizationLevel back to two separate values when necessary.

LLVM already has the class PassBuilder::OptimizationLevel that encapsulates the logic of both speed and size optimization levels. This class already checks which values for SpeedLevel and SizeLevel are valid.

Addressed comments.

Simplified test case.

Added test case that exercises this issue.

Thanks everyone for your comments.

Addressed @fhahn 's comment.
Indeed. That's much better.

Addressed @fhahn 's comments.

This the same patch after running clang-format specifically to the llvm::removeUnreachableBlocks() function.

I have fused two loops. Now, for any execution path, only two loops over DeadBlockSet will be performed, instead of the previous worst-case of three loops.

Just a very minor thing.

I understand your point of having a light-weight function merging (FM) to leave always on to reduce code-size/compilation-time.
I agree that perhaps we could have a parametrized merger that enables/disables more powerful comparisons.
That's why I also suggested that a more powerful merger (like my FM by Sequence Alignment) could be only enabled for heavier code-size optimizations (like -Oz) and have a light-weight FM always enabled (or enabled for most of the optimization settings).

This example that I gave in my comment is a simplistic one that gets canonicalized.
However, this patch would handle more interesting examples as well. Such as the following one:

Can someone please commit this patch for me because I believe I don't have commit access.
Thanks!

I've rebased to the patch and changed the name of the unit-test UnrollLoop.cpp to UnrollLoopTest.cpp, similar to the other files in the same folder.

I'd like to confirm that someone can commit this patch for me because I believe I don't have commit access.

I've added the test requirement, as suggested.

I've added the unit-test.

Thanks for the suggestion and the unit-test code. I'll add it to the patch.

I think that this patch is mainly important because these functions are externally visible in the library's API.
In fact, I experienced this problem when using the function llvm::UnrollRuntimeLoopRemainder in one of my own passes and then running it on SPEC2006.
This patch avoids unnecessarily making an implicit contract with the API's user.

I completely agree with your assessment.

Sorry, I'll make sure to upload with a full context in the next time.

Fix of the sanitizer failure as suggested by @sfertile:
https://reviews.llvm.org/rL336000

I have fixed the bug that this patch was producing on Polly.
https://reviews.llvm.org/D49154

It will need to be synchronised with the merge of the other patch.
Otherwise, the other patch would break Polly.

I've fixed the graph printing in Polly.

I've just noticed that last time I uploaded the wrong diff.

Minor update to avoid conflict with the latest LLVM release.

I kept the print functions as they were already present in the code and this change is not related to the heat colors.

Fix remaining code-style standards and option descriptions.

Fix small code-style standards.

Fixed function getNumOfCalls for both full and simplified visualization of the call-graph.

Updates the CFGPrinters to work on a per-module basis.

Changes regarding @davidxl comments.

Some code refactoring was performed, for example, replacing data structures from the C++ STL to equivalent one in LLVM ADT.

Closed due to incorrect configuration.
Another revision will be opened with the correct configuration.