[WIP][llvm] A Unified LTO Bitcode Frontend

[ormris]

Summary

Here's a high level summary of the changes in this patch. For more information
on rational, see the RFC (https://discourse.llvm.org/t/rfc-a-unified-lto-bitcode-frontend/61774).

• Add config parameter to LTO backend, specifying which LTO mode is desired when using unified LTO.
• Add unified LTO flag to the summary index for efficiency. Unified LTO modules can be detected without parsing the module.
• Make sure that the ModuleID is generated by incorporating more types of symbols.

[mehdi_amini]

llvm/lib/Passes/PassBuilder.cpp

1144

It is concerning to me that we add one mode different code path / behavior to maintain instead of unifying everything.

If UnifiedLTO is able to use the LTO pipeline effectively, what would be the reason for ThinLTO to not align?

[tejohnson]

llvm/lib/Passes/PassBuilder.cpp

1144

If UnifiedLTO is able to use the LTO pipeline effectively, what would be the reason for ThinLTO to not align?

Perhaps it can eventually, but I would not want to make a major change to the ThinLTO pipelines without a lot of experimentation. I don't personally have the bandwidth to do that right now, but if this was in as an alternative mode under an option, it could be done more easily at some point on a wider range of applications. I'd be concerned for example of side effects on importing behavior which is based on instruction count thresholds.

[mehdi_amini]

llvm/lib/Passes/PassBuilder.cpp

1144

Right, but your objection is exactly the root of my concerned with this new mode in the first place right now.

[tejohnson]

llvm/lib/Passes/PassBuilder.cpp

1144

Yeah, it isn't ideal to have added complexity, but I do understand the different constraints. The new mode seems to work well enough for Sony's needs, but for users such as mine at Google that want to maximize performance from ThinLTO, it may not be the best approach (or may be ok, but needs to be carefully evaluated). Unfortunately, I don't have a good immediate solution to balancing those two sets of needs at the moment, other than supporting different modes.

I wonder if we can get partly to a more common approach but just have a flag to switch between the different pass managers in the pre and post LTO optimization pipelines. I haven't had a chance to look closely at the patches yet, but my sense is that the other major change is enabling "split" LTO bitcode files always, for which I don't yet have a good understanding of the implications. I'll try to spend some time looking at the patches in more detail in the next few days.

[tejohnson]

llvm/lib/Passes/PassBuilder.cpp

1144

Per discussion on the RFC, the unified LTO mode added here requires split thin/regular LTO units. This is not something we have been able to use internally because of the scalability of the regular LTO portions. So we will need to keep the usual "pure" ThinLTO mode operational.

[tejohnson]

llvm/lib/LTO/LTO.cpp

739

Why is this needed?

1128

Why is this needed?

1148

Why is this needed?

1547

Why is this needed?

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

212

Rather than adding the many checks in the file below, can the Perform* and PrepareFor* options just be initialized differently under the UnifiedLTO mode?

llvm/lib/Transforms/Utils/ModuleUtils.cpp

225

As noted elsewhere, I'd prefer the UnifiedLTO not imply splitting. But regardless, this seems like a useful change whenever LTO unit is enabled - why not always compute the module hash this way?

[ormris]

llvm/lib/LTO/LTO.cpp

739

If cfi.functions isn't removed, LowerTypeTests will rename local functions in the merged module as "<function name>.1" when the regular LTO backend is used. This causes linking errors, since other parts of the module expect the original function name. We saw this happen in internal testing.

1128

Looks like it's not needed. I'll remove it.

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

212

No, I don't think so. The UnifiedLTO flag doesn't match any of those variables. I don't see a combination Perform*/PrepareFor* that would cleanly produce the result we want. I would also worry that reusing these variables would make this code less clear. Looking at it now, I wonder if it should be called PrepareForUnifiedLTO, though.

[ormris]

Remove ModuleID changes, as discussed here: https://discourse.llvm.org/t/rfc-a-unified-lto-bitcode-frontend/61774/15

[ormris]

Changelog:

• Rebased
• Remove legacy pipeline

[nikic]

llvm/lib/Passes/PassBuilder.cpp

1144

I feel like I'm missing something here. Why do we need to force the use of the (known-broken, lower quality) full LTO pre-link pipeline here, rather than sticking to the thin LTO pre-link pipeline?

[ormris]

Attempt to fix pre-merge checks

[mehdi_amini]

llvm/lib/Passes/PassBuilder.cpp

1144

Can you elaborate on what is known-broken with the full LTO pre-link pipeline? And if we were to adopt the ThinLTO pipeline here for FullLTO, what does it mean for the FullLTO pipeline at link time? The two goes hand-in-hand somehow and the current situation (as far as I remember) balances compile time between the two phases (which is much more sensitive for FullLTO since the link phase is sequential).

The new mode seems to work well enough for Sony's needs, but for users such as mine at Google that want to maximize performance from ThinLTO, it may not be the best approach (or may be ok, but needs to be carefully evaluated). Unfortunately, I don't have a good immediate solution to balancing those two sets of needs at the moment, other than supporting different modes.

I am still concerned with divergence that wouldn't be just temporary: what would be the timeline to reconcile the paths? I understand you may not have time just now, but I don't think it is reasonable to just keep code in-tree forever "because Google can't evaluate changes to the pipeline", it is akin to have a dedicated pipeline in-tree and a clang option -flto=google-pipeline (or -Ogoogle instead of -O2). You're getting into "this belongs to your downstream fork" territory IMO.
The point of having a limited set of configuration in-tree is that every user contribute also to the testing of these pipelines. Having a feature for "unified LTO" that isn't orthogonal to the optimization pipelines doesn't seem right to me in term of product.

[tejohnson]

llvm/lib/Passes/PassBuilder.cpp

1144

And if we were to adopt the ThinLTO pipeline here for FullLTO, what does it mean for the FullLTO pipeline at link time? The two goes hand-in-hand somehow and the current situation (as far as I remember) balances compile time between the two phases (which is much more sensitive for FullLTO since the link phase is sequential).

The reverse is also a question - if we are to adopt the full LTO pipeline here, what does it mean for ThinLTO performance (and compile time, given what appears to be a requirement that split modules be used which means that ThinLTO now would be required to include some amount of full LTO)? The current ThinLTO pipeline attempts to maximize performance since we don't have to worry about the full LTO scalability issues.

I am still concerned with divergence that wouldn't be just temporary: what would be the timeline to reconcile the paths? I understand you may not have time just now, but I don't think it is reasonable to just keep code in-tree forever "because Google can't evaluate changes to the pipeline", it is akin to have a dedicated pipeline in-tree and a clang option -flto=google-pipeline (or -Ogoogle instead of -O2). You're getting into "this belongs to your downstream fork" territory IMO.

Google is not the one asking for a major change to the ThinLTO pipelines, which have been set up roughly this way since inception. While we certainly rely on ThinLTO for performance with scalability, we're also certainly not the only users of ThinLTO. IMO a major change such as this should go in under an experimental option, so that existing users are easily able to try it out, without being expected to patch in multiple patches and do that manually. It will be a lot easier to try it out if this is under an option in the upstream sources.

Having a feature for "unified LTO" that isn't orthogonal to the optimization pipelines doesn't seem right to me in term of product.

Since Unified LTO is an intermediate between Thin and Full LTO, which have their own pipelines already to balance their different needs, having a different pipeline for a different LTO mode with different needs doesn't seem like a terrible thing to me.

What happens if Unified LTO does degrade performance and/or compile time for existing ThinLTO users?

1146

It is a bit odd to see that under unified LTO the regular LTO "pre-link" pipeline is used during the post link phase. I don't remember the reasons for this, maybe it is in the RFC, but it at least needs a clear comment.

[mehdi_amini]

llvm/lib/Passes/PassBuilder.cpp

1144

Google is not the one asking for a major change to the ThinLTO pipelines,

Right, but it came across to me that you were blocking it by lack of time for testing: it is fine to ask about a testing plan and some plan ahead of time on resources to commit, but it didn't seem like the dynamic at play here.

which have been set up roughly this way since inception. While we certainly rely on ThinLTO for performance with scalability, we're also certainly not the only users of ThinLTO. IMO a major change such as this should go in under an experimental option, so that existing users are easily able to try it out, without being expected to patch in multiple patches and do that manually. It will be a lot easier to try it out if this is under an option in the upstream sources.

So basically, IIUC, we should:

1. add an option to use ThinLTO with an new pipeline
2. have plan and a timeline for users to test this pipeline, and criteria of acceptation.
3. either graduate this pipeline to replace the existing one, or kill this option if unsuccessful.

This seems very reasonable to me, but the stakeholder in keeping the feature working should be ready to participate in 2).

What happens if Unified LTO does degrade performance and/or compile time for existing ThinLTO users?

Isn't the premise of the proposal that the author believe they can get the same performance as ThinLTO? Re-reading the original RFC, it does not say much about the performance claim, hence my impression that UnifiedLTO was proposed as an "orthogonal feature" to the compilation pipelines. Some clarifications may be needed on this?

[nikic]

llvm/lib/Passes/PassBuilder.cpp

1144

Can you elaborate on what is known-broken with the full LTO pre-link pipeline? And if we were to adopt the ThinLTO pipeline here for FullLTO, what does it mean for the FullLTO pipeline at link time? The two goes hand-in-hand somehow and the current situation (as far as I remember) balances compile time between the two phases (which is much more sensitive for FullLTO since the link phase is sequential).

Basically, the only difference between the thin LTO and the full LTO pre-link pipelines is that full LTO runs module optimization pre-link, while thin LTO does not. Running module optimization pre-link is detrimental to both performance and compile time. The full LTO pre-link pipeline will be made the same as the thin LTO pre-link pipeline in D148010, but it might take a while until we're ready to land that change.

Once that change lands this question won't matter anymore as the pipelines will be the same, but until that time it would make a lot more sense to me to use the thin LTO pre-link pipeline here, as that's the one we're ultimately going to adopt.

[mehdi_amini]

llvm/lib/Passes/PassBuilder.cpp

1144

Running module optimization pre-link is detrimental to both performance and compile time

I have a different experience: I tried to align FullLTO on the ThinLTO pipeline while we were building ThinLTO (circa 2016), and ninja clang (with FullLTO enabled) would take basically twice more time. This is because you're basically shifting compile time from the parallel compile phase to the sequential link-time phase.

I ended up proposing a patch here: https://reviews.llvm.org/D29376 which was tested on the performance aspect on games and embedded system (see the comment thread), without a good conclusion.
The compile-time impact was deemed too high for it to be worthwhile to pursue at the time.

[nikic]

llvm/lib/Passes/PassBuilder.cpp

1144

From a quick look, what you were trying to do is align both the pre-link and the post-link full LTO pipelines. I'm talking only about the pre-link pipeline here. Making the post-link full LTO pipeline the same as the thin LTO pipeline would indeed likely run into compile-time issues.

[tejohnson]

llvm/lib/Passes/PassBuilder.cpp

1144

Basically, the only difference between the thin LTO and the full LTO pre-link pipelines is that full LTO runs module optimization pre-link, while thin LTO does not. Running module optimization pre-link is detrimental to both performance and compile time. The full LTO pre-link pipeline will be made the same as the thin LTO pre-link pipeline in D148010, but it might take a while until we're ready to land that change.

Also, the odd thing here (see my comment a couple lines below), is that this case is where the post-link pipeline has been requested, where we normally run the "ThinLTODefault" pipeline (not the pre-link). With UnifiedLTO the code is instead running the full LTO pre-link, however. But this code is just used for pipeline testing via opt I believe. The pipeline setup code in the companion clang patch seems to be doing the intended thing (using full LTO pre-link instead of thin LTO pre-link under the unified LTO option). However, as you note, it isn't clear whether that is what we want.

@ormris is this a bug here?

1144

Right, but it came across to me that you were blocking it by lack of time for testing: it is fine to ask about a testing plan and some plan ahead of time on resources to commit, but it didn't seem like the dynamic at play here.

Not trying to block, I was just trying to agree with the approach here in putting it upstream under an option. If it is in under an option, it is a lot easier for a wider range of people to try it out in parallel. For example, it will be a lot easier to send it through our various pre-release compile-time and performance testing suites with potentially multiple people looking at it.

So basically, IIUC, we should:

1. add an option to use ThinLTO with an new pipeline
2. have plan and a timeline for users to test this pipeline, and criteria of acceptation.
3. either graduate this pipeline to replace the existing one, or kill this option if unsuccessful.

Agree, although regarding 3 my understanding is that they are trying to solve a specific problem, by allowing the decision about thin vs full LTO to be delayed until the LTO link time and simplifying deploying bitcode libraries. So the criteria for success for Sony and anyone else who wants these benefits is likely going to be different than from ThinLTO users who don't care about this and just want the best performance/build time tradeoff.

[ormris]

llvm/lib/Passes/PassBuilder.cpp

1146

After looking into this, it appears that this was added for testing purposes a while back, but is no longer in use. The correct pipelines are setup by the various frontends. While it's technically not a necessary part of this patch, I'd like to make sure that opt --passes="thinlto-pre-link<O1>" --unified-lto does the right thing, so moving it to the prelink condition seems best.

[ormris]

llvm/lib/Passes/PassBuilder.cpp

1144

They are trying to solve a specific problem, by allowing the decision about thin vs full LTO to be delayed until the LTO link time and simplifying deploying bitcode libraries.

Correct. There are specific aspects of the LTO UX that we wanted to change, as noted in the RFC.

it is a lot easier for a wider range of people to try it out in parallel

A few others have expressed interest on discourse in using this pipeline for other projects. I think it's likely we would see other projects testing this pipeline if it was committed.

[mehdi_amini]

llvm/lib/Passes/PassBuilder.cpp

1144

They are trying to solve a specific problem, by allowing the decision about thin vs full LTO to be delayed until the LTO link time and simplifying deploying bitcode libraries.

Correct. There are specific aspects of the LTO UX that we wanted to change, as noted in the RFC.

That isn't answering the performance goals questions with respect to current ThinLTO as well as the long term alignment of the pipelines?

[ormris]

Update opt to set the UnifiedLTO pipeline tuning option correctly. Fix pipeline parsing. Add testing for UnifiedLTO prelink pipeline.

[ormris]

llvm/lib/Passes/PassBuilder.cpp

1144

That isn't answering the performance goals questions with respect to current ThinLTO as well as the long term alignment of the pipelines?

Our goal was to make these UX changes without severely impacting ThinLTO compile time and runtime performance. Our performance testing showed that runtime performance was the same or better, and that compile time performance was about 1% worse. So there is an impact on compile time performance, but it's far from severe. On the alignment question, this patch is able to optionally provide limited alignment. This alignment has consistently provided good performance for us, so we think it's in a good state for broader testing. I'm not sure that replacing the current ThinLTO pipeline with this pipeline makes sense at the moment. This pipeline provides different advantages and disadvantages to the current pipelines, and I think they can co-exist with minimal maintenance overhead. That's definitely been our experience maintaining this feature downstream. In the long term, full alignment of all LTO pipelines could be a good route, but it seems like the proposal is still being explored. We're ready to get more concrete feedback on our approach and we think it's likely to be useful in its current state.

1146

Fixed.

[mehdi_amini]

llvm/lib/Passes/PassBuilder.cpp

1144

I raised the discussion in the RFC, it seems more appropriate to discuss design discussions like this there. There is definitely a tradeoff to explore there, but I don't feel I've seen it called out in the RFC and enough data provided to justify it going one way or the other.

[ormris]

clang-format

[ormris]

Use the ThinLTO pre-link pipeline as the Unified LTO pre-link pipeline, as discussed in the RFC.

[ormris]

gentle ping

[mehdi_amini]

The alignment in the pass pipeline LGTM, I don't know about all the aspects involved here so probably not the best person to approve the patch.

[tejohnson]

Looks pretty good but I have some mostly minor comments and questions.

Patch summary needs slight change to remove this note since that got refactored out of this patch:

Make sure that the ModuleID is generated by incorporating more types of symbols.

Also, is there still a requirement that split LTO units be enabled for Unified LTO? I cannot remember why that was the case, and I see some tests specify split LTO units and some don't. IMO it is better for split LTO and Unified LTO to be orthogonal if possible.

llvm/include/llvm/LTO/Config.h

174

Document. However, the only use I could find of this field is immediately after it is set, in the same scope. Does it need to be a Config field?

llvm/include/llvm/LTO/LTO.h

242

Document

416

Document

llvm/include/llvm/Passes/PassBuilder.h

74

s/our/the/ ?

llvm/include/llvm/Transforms/IPO/ThinLTOBitcodeWriter.h

34

This isn't used - remove?

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

7433

Comment needs update. Also, what should the value of UnifiedLTO be set to in this case? I suppose it defaults to false, which seems correct, but it would be good to explicitly set/note that.

I think though it might be better to change this function to return a tuple of the 2 flags, since there are other fields in the BitcodeLTOInfo that are not being set here. I see that they are set by the caller, but this is a bit confusing IMO. Alternatively, change this function to a name "setEnable..." (s/get/set), and note explicitly in a comment above the function that the caller is expected to set the other fields.

llvm/lib/LTO/LTO.cpp

739

Please document this rationale in a comment, and note that this metadata is only needed for ThinLTO (which appears to be the case).

1128

Ping on this question, I think it should be removed? EnableLTOInternalization is an internal option that defaults to true anyway.

1148

Ping on this question - please add comment about why this is needed.

1547

Ping on this question. Please add comment about why needed.

llvm/lib/Passes/PassBuilder.cpp

1148

Add comment summarizing the decision/rationale for this.

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

265

Since you are asserting that UnifiedLTO is false a few lines up, can this just be a constant false?

271

Diito

llvm/test/LTO/Resolution/X86/local-def-dllimport.ll

1–2

Why change this test? I assume it should still work with the old options. If you want to test also with Unified LTO, just duplicate the RUN lines so that it tests in both modes.

llvm/test/LTO/X86/unified-cfi.ll

89

Does the test need to include the textual summary, or will the correct summary be generated with -thinlto-bc?

llvm/test/LTO/X86/whole-program-no-crash.ll

3

Is this comment about crashing in previous versions of the compiler copied from another test? Is the crash related to unified LTO somehow?

(also typo in "devirtualizaiton")

91

Similar question to the other test - do we need to include the textual summary or does it get automatically generated by -thinlto-bc?

llvm/test/ThinLTO/X86/dup-cgprofile-flag.ll

2

Add comment at the top about what the test is testing (it isn't clear to me).

llvm/test/Transforms/ThinLTOBitcodeWriter/split-unified.ll

3

Can you add some checking of the generated minimized bitcode file %t2? Also, it is not just without the debug metadata, it is without all IR.

7

Why this checking?

llvm/tools/llvm-lto2/llvm-lto2.cpp

158

Note the 2 accepted values in the message. Should it also accept "default"? Looks like the code will not, but we might want to for completeness.

338

Needs comment about why

llvm/tools/opt/opt.cpp

121

Note that it is ignored unless -thinlto-bc specified

[ormris]

llvm/include/llvm/LTO/Config.h

174

I can derive this from other values. Removed.

llvm/include/llvm/LTO/LTO.h

242

Fixed.

416

Fixed.

llvm/include/llvm/Passes/PassBuilder.h

74

Fixed.

llvm/include/llvm/Transforms/IPO/ThinLTOBitcodeWriter.h

34

Fixed

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

7433

Yeah, I see what you mean. I think it would be best to make this function return a tuple. Fixed.

llvm/lib/LTO/LTO.cpp

739

Fixed.

1128

Fixed.

1148

Fixed.

1547

Now that we're using the ThinLTO pre-link pipeline, we can remove this.

llvm/lib/Passes/PassBuilder.cpp

1148

Fixed

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

265

Fixed

271

Fixed

llvm/test/LTO/Resolution/X86/local-def-dllimport.ll

1–2

Fixed

llvm/test/LTO/X86/unified-cfi.ll

89

No, that's not needed. Fixed.

llvm/test/LTO/X86/whole-program-no-crash.ll

3

Yes, it was. This is a very old test for a crash that's long been fixed. Essentially, the issue was that type test instructions were not being removed, and that caused crashes during codegen. Honestly, I think it would be best to keep this test private. It's good for our internal test suite, but I'm not sure it adds value here.

91

It's auto-generated. I'll remove this.

llvm/test/ThinLTO/X86/dup-cgprofile-flag.ll

2

Fixed.

llvm/tools/llvm-lto2/llvm-lto2.cpp

158

Yes, that makes sense. Fixed.

llvm/tools/opt/opt.cpp

121

Fixed

[ormris]

Address feedback.

[tejohnson]

There are a few comments that don't appear to be addressed, noted in the patch below, but also the below comment and question about split LTO - can you clarify whether that is still required for unified LTO? I also realized after going through the changes that there are a few things that need more testing, see comments.

In D123803#4411375, @tejohnson wrote:

Looks pretty good but I have some mostly minor comments and questions.

Patch summary needs slight change to remove this note since that got refactored out of this patch:

Make sure that the ModuleID is generated by incorporating more types of symbols.

Also, is there still a requirement that split LTO units be enabled for Unified LTO? I cannot remember why that was the case, and I see some tests specify split LTO units and some don't. IMO it is better for split LTO and Unified LTO to be orthogonal if possible.

llvm/lib/LTO/LTO.cpp

1148

Specifically, why only in UnifiedRegular LTO mode?

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

265

Document const parameter

271

Ditto

llvm/test/LTO/Resolution/X86/unified-lto-check.ll

3

Is this a correct description? It seems to give an error, not silently handle it.

llvm/test/ThinLTO/X86/dup-cgprofile-flag.ll

2

I'm still unclear as to what is happening in the test. It seems that there is an error when running LTO without specifying a --lto= option. It isn't clear to me why, or why specifically that case duplicates a module flag.

This raises a couple questions:

1. is it unsupported to LTO link unifiedLTO IR objects without specifying a non-default LTO mode via --lto=[thin|full]?
2. is it unsupported to specify an LTO mode other than default via --lto=[thin|full] for non-unifiedLTO IR objects?

The unified-lto-check.ll test does test a few of these option combinations, but not all of them. There should be a test for all combinations, with a clear error for any that are not supported. IMO it might be nice to handle case 1 silently with a reasonable default (probably ThinLTO since that's the pre-link pipeline used).

It would also be good to have a test that more explicitly ensures that we get the expected ThinLTO vs RegularLTO backend handling for unifiedLTO IR objects with both --lto=thin and --lto=full (maybe this exists, but I don't see such a test right now scanning the patch again).

llvm/test/Transforms/ThinLTOBitcodeWriter/split-unified.ll

3

ping on the comments in this test.

llvm/tools/llvm-lto2/llvm-lto2.cpp

158

Needs a test.

338

Ping on why the CallGraphProfile is related to the Unified LTO setting. Especially now that the similar handling was removed from LTO.cpp.

[ormris]

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

265

Fixed? Does this need more explanation?

271

Fixed?

llvm/test/LTO/Resolution/X86/unified-lto-check.ll

3

Fixed

llvm/test/ThinLTO/X86/dup-cgprofile-flag.ll

2

OK. I've added further details to the comment. Let me know if that makes sense.

is it unsupported to LTO link unifiedLTO IR objects without specifying a non-default LTO mode via --lto=[thin|full]?

I think that should be unsupported. Otherwise, small pipeline differences could catch users by surprise. A default of ThinLTO does make sense. Fixed.

is it unsupported to specify an LTO mode other than default via --lto=[thin|full] for non-unifiedLTO IR objects?

It probably should be. There's a chance that someone could use the switch by accident and get a strange result. Fixed.

There should be a test for all combinations

Agreed. I've added the rest of these cases to unified-lto-check.ll.

It would also be good to have a test that more explicitly ensures that we get the expected ThinLTO vs RegularLTO backend

Yes, that would be useful. Fixed.

llvm/test/Transforms/ThinLTOBitcodeWriter/split-unified.ll

3

Sorry for the delay here. This test is named incorrectly. It was intended to test the case where the ModuleID is not generated. Since we've removed that case from discussion, I've changed this test to cover the normal case.

7

See above

llvm/tools/llvm-lto2/llvm-lto2.cpp

338

This can also be removed, since we're using the ThinLTO pre-link pipeline.

[ormris]

Address comments

[ormris]

ping

[tejohnson]

Sorry for the delay, couple more follow ups below.

llvm/lib/LTO/LTO.cpp

1150

We can have split LTO units without UnifiedLTO, however.

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

265

Yep, this is what I meant.

271

yep

llvm/test/LTO/Resolution/X86/unified-lto-check.ll

15

Since this option is only about UnifiedLTO and will give an error in this usage, it would be better to rename it to --unified-lto=.

llvm/test/ThinLTO/X86/dup-cgprofile-flag.ll

2

is it unsupported to LTO link unifiedLTO IR objects without specifying a non-default LTO mode via --lto=[thin|full]?

I think that should be unsupported. Otherwise, small pipeline differences could catch users by surprise. A default of ThinLTO does make sense. Fixed.

The first 2 sentences contradict the second 2 I think? In any case, I think it makes sense to have a reasonable default, which seems to be implemented now.

is it unsupported to specify an LTO mode other than default via --lto=[thin|full] for non-unifiedLTO IR objects?

It probably should be. There's a chance that someone could use the switch by accident and get a strange result. Fixed.

See my comment in one of the tests, I think the option name should be clearer that it is just about UnifiedLTO.

It would also be good to have a test that more explicitly ensures that we get the expected ThinLTO vs RegularLTO backend

Yes, that would be useful. Fixed.

I don't think the new debug messages being emitted and tested are correctly testing this, however, since runRegularLTO and runThinLTO are both essentially unconditionally invoked (see callsites in LTO::run). It would be better to add the messages to lto::backend and lto::thinBackend.

[ormris]

Address feedback

llvm/lib/LTO/LTO.cpp

1150

True. Added a bit more to the comment.

llvm/test/LTO/Resolution/X86/unified-lto-check.ll

15

That makes sense. Fixed.

llvm/test/ThinLTO/X86/dup-cgprofile-flag.ll

2

Fixed

[ormris]

Address feedback

[tejohnson]

lgtm

[ormris]

Thanks @tejohnson and @mehdi_amini for all the feedback and review!

llvm/include/llvm/Bitcode/BitcodeReader.h

typedef llvm::function_ref<Optional<std::string>(StringRef)>
 
   struct BitcodeFileContents;
 
   /// Basic information extracted from a bitcode module to be used for LTO.
   struct BitcodeLTOInfo {
     bool IsThinLTO;
     bool HasSummary;
     bool EnableSplitLTOUnit;
+    bool UnifiedLTO;
   };
 
   /// Represents a module in a bitcode file.
   class BitcodeModule {
     // This covers the identification (if present) and module blocks.
     ArrayRef<uint8_t> Buffer;
     StringRef ModuleIdentifier;
 

llvm/include/llvm/IR/ModuleSummaryIndex.h

private:
   /// the IR from assembly. The value of 'false' means we're reading summary
   /// from BC or YAML source. Affects the type of value stored in NameOrGV
   /// union.
   bool HaveGVs;
 
   // True if the index was created for a module compiled with -fsplit-lto-unit.
   bool EnableSplitLTOUnit;
 
+  // True if the index was created for a module compiled with -funified-lto
+  bool UnifiedLTO;
+
   // True if some of the modules were compiled with -fsplit-lto-unit and
   // some were not. Set when the combined index is created during the thin link.
   bool PartiallySplitLTOUnits = false;
 
   /// True if some of the FunctionSummary contains a ParamAccess.
   bool HasParamAccess = false;
 
   std::set<std::string> CfiFunctionDefs;
private:
   GlobalValueSummaryMapTy::value_type *
   getOrInsertValuePtr(GlobalValue::GUID GUID) {
     return &*GlobalValueMap.emplace(GUID, GlobalValueSummaryInfo(HaveGVs))
                  .first;
   }
 
 public:
   // See HaveGVs variable comment.
-  ModuleSummaryIndex(bool HaveGVs, bool EnableSplitLTOUnit = false)
-      : HaveGVs(HaveGVs), EnableSplitLTOUnit(EnableSplitLTOUnit), Saver(Alloc),
-        BlockCount(0) {}
+  ModuleSummaryIndex(bool HaveGVs, bool EnableSplitLTOUnit = false,
+                     bool UnifiedLTO = false)
+      : HaveGVs(HaveGVs), EnableSplitLTOUnit(EnableSplitLTOUnit), UnifiedLTO(UnifiedLTO),
+        Saver(Alloc), BlockCount(0) {}
 
   // Current version for the module summary in bitcode files.
   // The BitcodeSummaryVersion should be bumped whenever we introduce changes
   // in the way some record are interpreted, like flags for instance.
   // Note that incrementing this may require changes in both BitcodeReader.cpp
   // and BitcodeWriter.cpp.
   static constexpr uint64_t BitcodeSummaryVersion = 9;
 
public:
   }
   void setSkipModuleByDistributedBackend() {
     SkipModuleByDistributedBackend = true;
   }
 
   bool enableSplitLTOUnit() const { return EnableSplitLTOUnit; }
   void setEnableSplitLTOUnit() { EnableSplitLTOUnit = true; }
 
+  bool hasUnifiedLTO() const { return UnifiedLTO; }
+  void setUnifiedLTO() { UnifiedLTO = true; }
+
   bool partiallySplitLTOUnits() const { return PartiallySplitLTOUnits; }
   void setPartiallySplitLTOUnits() { PartiallySplitLTOUnits = true; }
 
   bool hasParamAccess() const { return HasParamAccess; }
 
   bool isGlobalValueLive(const GlobalValueSummary *GVS) const {
     return !WithGlobalValueDeadStripping || GVS->isLive();
   }

llvm/include/llvm/LTO/Config.h

struct Config {
   std::vector<std::string> ThinLTOModulesToCompile;
 
   /// Time trace enabled.
   bool TimeTraceEnabled = false;
 
   /// Time trace granularity.
   unsigned TimeTraceGranularity = 500;
 
+  bool UnifiedLTO = false;
+
   bool ShouldDiscardValueNames = true;
   DiagnosticHandlerFunction DiagHandler;
 
   /// Add FSAFDO discriminators.
   bool AddFSDiscriminator = false;
 
   /// If this field is set, LTO will write input file paths and symbol
   /// resolutions here in llvm-lto2 command line flag format. This can be

llvm/include/llvm/LTO/LTO.h

 ///   native object files that LTO may add to the link.
 /// - Call the run() function. This function will use the supplied AddStream
 ///   and Cache functions to add up to getMaxTasks() native object files to
 ///   the link.
 class LTO {
   friend InputFile;
 
 public:
+
+  enum LTOKind {
+    LTOK_Default,
+    LTOK_UnifiedRegular,
+    LTOK_UnifiedThin,
+  };
+
   /// Create an LTO object. A default constructed LTO object has a reasonable
   /// production configuration, but you can customize it by passing arguments to
   /// this constructor.
   /// FIXME: We do currently require the DiagHandler field to be set in Conf.
   /// Until that is fixed, a Config argument is required.
   LTO(Config Conf, ThinBackend Backend = nullptr,
-      unsigned ParallelCodeGenParallelismLevel = 1);
+      unsigned ParallelCodeGenParallelismLevel = 1,
+      LTOKind LTOMode = LTOK_Default);
   ~LTO();
 
   /// Add an input file to the LTO link, using the provided symbol resolutions.
   /// The symbol resolutions must appear in the enumeration order given by
   /// InputFile::symbols().
   Error add(std::unique_ptr<InputFile> Obj, ArrayRef<SymbolResolution> Res);
 
   /// Returns an upper bound on the number of tasks that the client may expect.
private:
   Error runRegularLTO(AddStreamFn AddStream);
   Error runThinLTO(AddStreamFn AddStream, FileCache Cache,
                    const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols);
 
   Error checkPartiallySplit();
 
   mutable bool CalledGetMaxTasks = false;
 
+  LTOKind LTOMode;
+
   // Use Optional to distinguish false from not yet initialized.
   Optional<bool> EnableSplitLTOUnit;
 
   // Identify symbols exported dynamically, and that therefore could be
   // referenced by a shared library not visible to the linker.
   DenseSet<GlobalValue::GUID> DynamicExportSymbols;
 
   // Diagnostic optimization remarks file

llvm/include/llvm/Passes/PassBuilder.h

public:
   /// Tuning option to disable promotion to scalars in LICM with MemorySSA, if
   /// the number of access is too large.
   unsigned LicmMssaNoAccForPromotionCap;
 
   /// Tuning option to enable/disable call graph profile. Its default value is
   /// that of the flag: `-enable-npm-call-graph-profile`.
   bool CallGraphProfile;
 
+  // Add LTO pipeline tuning option to enable our unified LTO pipeline.
+  bool UnifiedLTO;
+
   /// Tuning option to enable/disable function merging. Its default value is
   /// false.
   bool MergeFunctions;
 
   // Experimental option to eagerly invalidate more analyses. This has the
   // potential to decrease max memory usage in exchange for more compile time.
   // This may affect codegen due to either passes using analyses only when
   // cached, or invalidating and recalculating an analysis that was

llvm/include/llvm/Transforms/IPO.h

 //===----------------------------------------------------------------------===//
 // SampleProfilePass - Loads sample profile data from disk and generates
 // IR metadata to reflect the profile.
 ModulePass *createSampleProfileLoaderPass();
 ModulePass *createSampleProfileLoaderPass(StringRef Name);
 
 /// Write ThinLTO-ready bitcode to Str.
 ModulePass *createWriteThinLTOBitcodePass(raw_ostream &Str,
-                                          raw_ostream *ThinLinkOS = nullptr);
+                                          raw_ostream *ThinLinkOS = nullptr,
+                                          bool UnifiedLTO = false);
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Transforms/IPO/PassManagerBuilder.h

public:
   bool DisableGVNLoadPRE;
   bool ForgetAllSCEVInLoopUnroll;
   bool VerifyInput;
   bool VerifyOutput;
   bool MergeFunctions;
   bool PrepareForLTO;
   bool PrepareForThinLTO;
   bool PerformThinLTO;
+  bool UnifiedLTO;
   bool DivergentTarget;
   unsigned LicmMssaOptCap;
   unsigned LicmMssaNoAccForPromotionCap;
 
   /// Enable profile instrumentation pass.
   bool EnablePGOInstrGen;
   /// Enable profile context sensitive instrumentation pass.
   bool EnablePGOCSInstrGen;

llvm/include/llvm/Transforms/IPO/ThinLTOBitcodeWriter.h

 class ThinLTOBitcodeWriterPass
     : public PassInfoMixin<ThinLTOBitcodeWriterPass> {
   raw_ostream &OS;
   raw_ostream *ThinLinkOS;
 
 public:
   // Writes bitcode to OS. Also write thin link file to ThinLinkOS, if
   // it's not nullptr.
-  ThinLTOBitcodeWriterPass(raw_ostream &OS, raw_ostream *ThinLinkOS)
+  ThinLTOBitcodeWriterPass(raw_ostream &OS, raw_ostream *ThinLinkOS,
+                           bool UnifiedLTO = false)
       : OS(OS), ThinLinkOS(ThinLinkOS) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

 /// members.
 ///
 /// This identifier is normally guaranteed to be unique, or the program would
 /// fail to link due to multiply defined symbols.
 ///
 /// If the module has no strong external symbols (such a module may still have a
 /// semantic effect if it performs global initialization), we cannot produce a
 /// unique identifier for this module, so we return the empty string.
-std::string getUniqueModuleId(Module *M);
+std::string getUniqueModuleId(Module *M, bool UnifiedLTO = false);
 
 /// Embed the memory buffer \p Buf into the module \p M as a global using the
 /// specified section name.
 void embedBufferInModule(Module &M, MemoryBufferRef Buf, StringRef SectionName);
 
 class CallInst;
 namespace VFABI {
 /// Overwrite the Vector Function ABI variants attribute with the names provide
 /// in \p VariantMappings.
 void setVectorVariantNames(CallInst *CI, ArrayRef<std::string> VariantMappings);
 } // End VFABI namespace
 } // End llvm namespace
 
 #endif // LLVM_TRANSFORMS_UTILS_MODULEUTILS_H

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

 
 ModuleSummaryIndex llvm::buildModuleSummaryIndex(
     const Module &M,
     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
     ProfileSummaryInfo *PSI,
     std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback) {
   assert(PSI);
   bool EnableSplitLTOUnit = false;
+  bool UnifiedLTO = false;
   if (auto *MD = mdconst::extract_or_null<ConstantInt>(
           M.getModuleFlag("EnableSplitLTOUnit")))
     EnableSplitLTOUnit = MD->getZExtValue();
-  ModuleSummaryIndex Index(/*HaveGVs=*/true, EnableSplitLTOUnit);
+  if (auto *MD = mdconst::extract_or_null<ConstantInt>(
+          M.getModuleFlag("UnifiedLTO")))
+    UnifiedLTO = MD->getZExtValue();
+  ModuleSummaryIndex Index(/*HaveGVs=*/true, EnableSplitLTOUnit, UnifiedLTO);
 
   // Identify the local values in the llvm.used and llvm.compiler.used sets,
   // which should not be exported as they would then require renaming and
   // promotion, but we may have opaque uses e.g. in inline asm. We collect them
   // here because we use this information to mark functions containing inline
   // assembly calls as not importable.
   SmallPtrSet<GlobalValue *, 4> LocalsUsed;
   SmallVector<GlobalValue *, 4> Used;

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, *Index,
                                     ModuleIdentifier, 0);
 
   if (Error Err = R.parseModule())
     return std::move(Err);
 
   return std::move(Index);
 }
 
-static Expected<bool> getEnableSplitLTOUnitFlag(BitstreamCursor &Stream,
+static Error getEnableSplitLTOUnitAndUnifiedFlag(BitstreamCursor &Stream,
+                                                unsigned ID, BitcodeLTOInfo &LTOInfo) {
+  if (Error Err = Stream.EnterSubBlock(ID))
+    return std::move(Err);
+  SmallVector<uint64_t, 64> Record;
+
+  while (true) {
+    BitstreamEntry Entry;
+    if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
+      return std::move(E);
+
+    switch (Entry.Kind) {
+    case BitstreamEntry::SubBlock: // Handled for us already.
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock: {
+      // If no flags record found, conservatively return true to mimic
+      // behavior before this flag was added.
+      LTOInfo.EnableSplitLTOUnit = true;
+      return Error::success();
+    }
+    case BitstreamEntry::Record:
+      // The interesting case.
+      break;
+    }
+
+    // Look for the FS_FLAGS record.
+    Record.clear();
+    Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
+    if (!MaybeBitCode)
+      return MaybeBitCode.takeError();
+    switch (MaybeBitCode.get()) {
+    default: // Default behavior: ignore.
+      break;
+    case bitc::FS_FLAGS: { // [flags]
+      uint64_t Flags = Record[0];
+      // Scan flags.
+      assert(Flags <= 0x7ff && "Unexpected bits in flag");
+
+      LTOInfo.EnableSplitLTOUnit = Flags & 0x8;
+      LTOInfo.UnifiedLTO = Flags & 0x80;
+
+      return Error::success();
+    }
+    }
+  }
+  llvm_unreachable("Exit infinite loop");
+}
+
+static Expected<bool> getUnifiedLTOFlag(BitstreamCursor &Stream,
                                                 unsigned ID) {
   if (Error Err = Stream.EnterSubBlock(ID))
     return std::move(Err);
   SmallVector<uint64_t, 64> Record;
 
   while (true) {
     BitstreamEntry Entry;
     if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
       return std::move(E);
 
     switch (Entry.Kind) {
     case BitstreamEntry::SubBlock: // Handled for us already.
     case BitstreamEntry::Error:
       return error("Malformed block");
     case BitstreamEntry::EndBlock:
       // If no flags record found, conservatively return true to mimic
       // behavior before this flag was added.
       return true;
     case BitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Look for the FS_FLAGS record.
     Record.clear();
     Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
     if (!MaybeBitCode)
       return MaybeBitCode.takeError();
     switch (MaybeBitCode.get()) {
     default: // Default behavior: ignore.
       break;
     case bitc::FS_FLAGS: { // [flags]
       uint64_t Flags = Record[0];
       // Scan flags.
       assert(Flags <= 0x7f && "Unexpected bits in flag");
 
-      return Flags & 0x8;
+      return Flags & 0x80;
     }
     }
   }
   llvm_unreachable("Exit infinite loop");
 }
 
 // Check if the given bitcode buffer contains a global value summary block.
 Expected<BitcodeLTOInfo> BitcodeModule::getLTOInfo() {
while (true) {
     if (Error E = Stream.advance().moveInto(Entry))
       return std::move(E);
 
     switch (Entry.Kind) {
     case BitstreamEntry::Error:
       return error("Malformed block");
     case BitstreamEntry::EndBlock:
       return BitcodeLTOInfo{/*IsThinLTO=*/false, /*HasSummary=*/false,
-                            /*EnableSplitLTOUnit=*/false};
+                            /*EnableSplitLTOUnit=*/false, /*UnifiedLTO=*/false};
 
     case BitstreamEntry::SubBlock:
       if (Entry.ID == bitc::GLOBALVAL_SUMMARY_BLOCK_ID) {
-        Expected<bool> EnableSplitLTOUnit =
-            getEnableSplitLTOUnitFlag(Stream, Entry.ID);
-        if (!EnableSplitLTOUnit)
-          return EnableSplitLTOUnit.takeError();
-        return BitcodeLTOInfo{/*IsThinLTO=*/true, /*HasSummary=*/true,
-                              *EnableSplitLTOUnit};
+        BitcodeLTOInfo LTOInfo;
+        if (Error E = getEnableSplitLTOUnitAndUnifiedFlag(Stream, Entry.ID, LTOInfo))
+          return std::move(E);
+        LTOInfo.IsThinLTO = true;
+        LTOInfo.HasSummary = true;
+        return LTOInfo;
       }
 
       if (Entry.ID == bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID) {
-        Expected<bool> EnableSplitLTOUnit =
-            getEnableSplitLTOUnitFlag(Stream, Entry.ID);
-        if (!EnableSplitLTOUnit)
-          return EnableSplitLTOUnit.takeError();
-        return BitcodeLTOInfo{/*IsThinLTO=*/false, /*HasSummary=*/true,
-                              *EnableSplitLTOUnit};
+        BitcodeLTOInfo LTOInfo;
+        if (Error E = getEnableSplitLTOUnitAndUnifiedFlag(Stream, Entry.ID, LTOInfo))
+          return std::move(E);
+        LTOInfo.IsThinLTO = false;
+        LTOInfo.HasSummary = true;
+        return LTOInfo;
       }
 
       // Ignore other sub-blocks.
       if (Error Err = Stream.SkipBlock())
         return std::move(Err);
       continue;
 
     case BitstreamEntry::Record:

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

Stream.EmitRecord(
       bitc::FS_VERSION,
       ArrayRef<uint64_t>{ModuleSummaryIndex::BitcodeSummaryVersion});
 
   // Write the index flags.
   uint64_t Flags = 0;
   // Bits 1-3 are set only in the combined index, skip them.
   if (Index->enableSplitLTOUnit())
     Flags |= 0x8;
+  if (Index->hasUnifiedLTO())
+    Flags |= 0x80;
+
   Stream.EmitRecord(bitc::FS_FLAGS, ArrayRef<uint64_t>{Flags});
 
   if (Index->begin() == Index->end()) {
     Stream.ExitBlock();
     return;
   }
 
   for (const auto &GVI : valueIds()) {

llvm/lib/IR/ModuleSummaryIndex.cpp

uint64_t ModuleSummaryIndex::getFlags() const {
   if (enableSplitLTOUnit())
     Flags |= 0x8;
   if (partiallySplitLTOUnits())
     Flags |= 0x10;
   if (withAttributePropagation())
     Flags |= 0x20;
   if (withDSOLocalPropagation())
     Flags |= 0x40;
+  if (hasUnifiedLTO())
+    Flags |= 0x50;
   return Flags;
 }
 
 void ModuleSummaryIndex::setFlags(uint64_t Flags) {
-  assert(Flags <= 0x7f && "Unexpected bits in flag");
+  assert(Flags <= 0x7ff && "Unexpected bits in flag");
   // 1 bit: WithGlobalValueDeadStripping flag.
   // Set on combined index only.
   if (Flags & 0x1)
     setWithGlobalValueDeadStripping();
   // 1 bit: SkipModuleByDistributedBackend flag.
   // Set on combined index only.
   if (Flags & 0x2)
     setSkipModuleByDistributedBackend();
void ModuleSummaryIndex::setFlags(uint64_t Flags) {
   // 1 bit: WithAttributePropagation flag.
   // Set on combined index only.
   if (Flags & 0x20)
     setWithAttributePropagation();
   // 1 bit: WithDSOLocalPropagation flag.
   // Set on combined index only.
   if (Flags & 0x40)
     setWithDSOLocalPropagation();
+  // 1 bit: WithUnifiedLTO flag.
+  // Set on combined index only.
+  if (Flags & 0x80)
+    setUnifiedLTO();
 }
 
 // Collect for the given module the list of function it defines
 // (GUID -> Summary).
 void ModuleSummaryIndex::collectDefinedFunctionsForModule(
     StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const {
   for (auto &GlobalList : *this) {
     auto GUID = GlobalList.first;

llvm/lib/LTO/LTO.cpp

 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend)
     : Backend(Backend), CombinedIndex(/*HaveGVs*/ false) {
   if (!Backend)
     this->Backend =
         createInProcessThinBackend(llvm::heavyweight_hardware_concurrency());
 }
 
 LTO::LTO(Config Conf, ThinBackend Backend,
-         unsigned ParallelCodeGenParallelismLevel)
+         unsigned ParallelCodeGenParallelismLevel,
+         LTOKind LTOMode)
     : Conf(std::move(Conf)),
       RegularLTO(ParallelCodeGenParallelismLevel, this->Conf),
-      ThinLTO(std::move(Backend)) {}
+      ThinLTO(std::move(Backend)),
+      LTOMode(LTOMode) {}
 
 // Requires a destructor for MapVector<BitcodeModule>.
 LTO::~LTO() = default;
 
 // Add the symbols in the given module to the GlobalResolutions map, and resolve
 // their partitions.
 void LTO::addModuleToGlobalRes(ArrayRef<InputFile::Symbol> Syms,
                                ArrayRef<SymbolResolution> Res,
if (EnableSplitLTOUnit.hasValue()) {
     // we can skip or error on optimizations that need consistently split
     // modules (whole program devirt and lower type tests).
     if (EnableSplitLTOUnit.getValue() != LTOInfo->EnableSplitLTOUnit)
       ThinLTO.CombinedIndex.setPartiallySplitLTOUnits();
   } else
     EnableSplitLTOUnit = LTOInfo->EnableSplitLTOUnit;
 
   BitcodeModule BM = Input.Mods[ModI];
+
+  if ((LTOMode == LTOK_UnifiedRegular || LTOMode == LTOK_UnifiedThin) &&
+      !LTOInfo->UnifiedLTO)
+    return make_error<StringError>(
+        "unified LTO compilation must use "
+        "compatible bitcode modules (use -funified-lto)",
+        inconvertibleErrorCode());
+
+  bool IsThinLTO = LTOInfo->IsThinLTO && (LTOMode != LTOK_UnifiedRegular);
+
   auto ModSyms = Input.module_symbols(ModI);
   addModuleToGlobalRes(ModSyms, {ResI, ResE},
-                       LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
+                       IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
                        LTOInfo->HasSummary);
 
-  if (LTOInfo->IsThinLTO)
+  if (IsThinLTO)
     return addThinLTO(BM, ModSyms, ResI, ResE);
 
   RegularLTO.EmptyCombinedModule = false;
   Expected<RegularLTOState::AddedModule> ModOrErr =
       addRegularLTO(BM, ModSyms, ResI, ResE);
   if (!ModOrErr)
     return ModOrErr.takeError();
 
Expected<std::unique_ptr<Module>> MOrErr =
                        /*IsImporting*/ false);
   if (!MOrErr)
     return MOrErr.takeError();
   Module &M = **MOrErr;
   Mod.M = std::move(*MOrErr);
 
   if (Error Err = M.materializeMetadata())
     return std::move(Err);
+
+  if (LTOMode == LTOK_UnifiedRegular)
+    if (NamedMDNode *CfiFunctionsMD = M.getNamedMetadata("cfi.functions"))
+      M.eraseNamedMetadata(CfiFunctionsMD);
+
   UpgradeDebugInfo(M);
 
   ModuleSymbolTable SymTab;
   SymTab.addModule(&M);
 
   for (GlobalVariable &GV : M.globals())
     if (GV.hasAppendingLinkage())
       Mod.Keep.push_back(&GV);
Error LTO::runRegularLTO(AddStreamFn AddStream) {
   updateVCallVisibilityInModule(*RegularLTO.CombinedModule,
                                 Conf.HasWholeProgramVisibility,
                                 DynamicExportSymbols);
 
   if (Conf.PreOptModuleHook &&
       !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
     return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
 
+  if (LTOMode == LTOKind::LTOK_UnifiedRegular)
+    EnableLTOInternalization = true;
+
   if (!Conf.CodeGenOnly) {
     for (const auto &R : GlobalResolutions) {
+      GlobalValue *GV =
+          RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
       if (!R.second.isPrevailingIRSymbol())
         continue;
       if (R.second.Partition != 0 &&
           R.second.Partition != GlobalResolution::External)
         continue;
 
-      GlobalValue *GV =
-          RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
       // Ignore symbols defined in other partitions.
       // Also skip declarations, which are not allowed to have internal linkage.
       if (!GV || GV->hasLocalLinkage() || GV->isDeclaration())
         continue;
+      if ((LTOMode == LTOKind::LTOK_UnifiedRegular) &&
+          ((GV->getDLLStorageClass() != GlobalValue::DefaultStorageClass)
+            || GV->hasAvailableExternallyLinkage()
+            || GV->hasAppendingLinkage()))
+        continue;
+
       GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
                                               : GlobalValue::UnnamedAddr::None);
       if (EnableLTOInternalization && R.second.Partition == 0)
         GV->setLinkage(GlobalValue::InternalLinkage);
     }
 
     RegularLTO.CombinedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
 
     if (Conf.PostInternalizeModuleHook &&
Error LTO::runThinLTO(AddStreamFn AddStream, FileCache Cache,
 
   auto isPrevailing = [&](GlobalValue::GUID GUID,
                           const GlobalValueSummary *S) {
     return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
   };
   thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported,
                                       isPrevailing);
 
+  Conf.UnifiedLTO = (LTOMode != LTOK_Default);
+  if (Conf.UnifiedLTO)
+    Conf.PTO.CallGraphProfile = false;
+
   auto recordNewLinkage = [&](StringRef ModuleIdentifier,
                               GlobalValue::GUID GUID,
                               GlobalValue::LinkageTypes NewLinkage) {
     ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
   };
   thinLTOResolvePrevailingInIndex(Conf, ThinLTO.CombinedIndex, isPrevailing,
                                   recordNewLinkage, GUIDPreservedSymbols);
 

llvm/lib/Passes/PassBuilder.cpp

if (startsWithDefaultPipelineAliasPrefix(Name)) {
     PTO.SLPVectorization =
         L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
 
     if (Matches[1] == "default") {
       MPM.addPass(buildPerModuleDefaultPipeline(L));
     } else if (Matches[1] == "thinlto-pre-link") {
       MPM.addPass(buildThinLTOPreLinkDefaultPipeline(L));
     } else if (Matches[1] == "thinlto") {
+      if (!PTO.UnifiedLTO)
         MPM.addPass(buildThinLTODefaultPipeline(L, nullptr));
+      else
+        MPM.addPass(buildLTOPreLinkDefaultPipeline(L));
     } else if (Matches[1] == "lto-pre-link") {
       MPM.addPass(buildLTOPreLinkDefaultPipeline(L));
     } else {
       assert(Matches[1] == "lto" && "Not one of the matched options!");
       MPM.addPass(buildLTODefaultPipeline(L, nullptr));
     }
     return Error::success();
   }
 
   // Finally expand the basic registered passes from the .inc file.

llvm/lib/Passes/PassBuilderPipelines.cpp

PipelineTuningOptions::PipelineTuningOptions() {
   LoopInterleaving = true;
   LoopVectorization = true;
   SLPVectorization = false;
   LoopUnrolling = true;
   ForgetAllSCEVInLoopUnroll = ForgetSCEVInLoopUnroll;
   LicmMssaOptCap = SetLicmMssaOptCap;
   LicmMssaNoAccForPromotionCap = SetLicmMssaNoAccForPromotionCap;
   CallGraphProfile = true;
+  UnifiedLTO = false;
   MergeFunctions = EnableMergeFunctions;
   EagerlyInvalidateAnalyses = EnableEagerlyInvalidateAnalyses;
 }
 
 namespace llvm {
 
 extern cl::opt<unsigned> MaxDevirtIterations;
 extern cl::opt<bool> EnableConstraintElimination;

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

PassManagerBuilder::PassManagerBuilder() {
     EnablePGOInstrGen = false;
     EnablePGOCSInstrGen = false;
     EnablePGOCSInstrUse = false;
     PGOInstrGen = "";
     PGOInstrUse = "";
     PGOSampleUse = "";
     PrepareForThinLTO = EnablePrepareForThinLTO;
     PerformThinLTO = EnablePerformThinLTO;
+    UnifiedLTO = false;
     DivergentTarget = false;
     CallGraphProfile = true;
 }
 
 PassManagerBuilder::~PassManagerBuilder() {
   delete LibraryInfo;
   delete Inliner;
 }
if (OptLevel == 0) {
     // that pass manager. To prevent this we insert a no-op module pass to reset
     // the pass manager to get the same behavior as EP_OptimizerLast in non-O0
     // builds. The function merging pass is
     if (MergeFunctions)
       MPM.add(createMergeFunctionsPass());
     else if (GlobalExtensionsNotEmpty() || !Extensions.empty())
       MPM.add(createBarrierNoopPass());
 
-    if (PerformThinLTO) {
+    if (PerformThinLTO && !UnifiedLTO) {
       MPM.add(createLowerTypeTestsPass(nullptr, nullptr, true));
       // Drop available_externally and unreferenced globals. This is necessary
       // with ThinLTO in order to avoid leaving undefined references to dead
       // globals in the object file.
       MPM.add(createEliminateAvailableExternallyPass());
       MPM.add(createGlobalDCEPass());
     }
 
void PassManagerBuilder::populateModulePassManager(
 
   // For ThinLTO there are two passes of indirect call promotion. The
   // first is during the compile phase when PerformThinLTO=false and
   // intra-module indirect call targets are promoted. The second is during
   // the ThinLTO backend when PerformThinLTO=true, when we promote imported
   // inter-module indirect calls. For that we perform indirect call promotion
   // earlier in the pass pipeline, here before globalopt. Otherwise imported
   // available_externally functions look unreferenced and are removed.
-  if (PerformThinLTO) {
+  if (PerformThinLTO && !UnifiedLTO) {
     MPM.add(createPGOIndirectCallPromotionLegacyPass(/*InLTO = */ true,
                                                      !PGOSampleUse.empty()));
     MPM.add(createLowerTypeTestsPass(nullptr, nullptr, true));
   }
 
   // For SamplePGO in ThinLTO compile phase, we do not want to unroll loops
   // as it will change the CFG too much to make the 2nd profile annotation
   // in backend more difficult.
   bool PrepareForThinLTOUsingPGOSampleProfile =
       PrepareForThinLTO && !PGOSampleUse.empty();
-  if (PrepareForThinLTOUsingPGOSampleProfile)
+  if (PrepareForThinLTOUsingPGOSampleProfile && !UnifiedLTO)
     DisableUnrollLoops = true;
 
   // Infer attributes about declarations if possible.
   MPM.add(createInferFunctionAttrsLegacyPass());
 
   // Infer attributes on declarations, call sites, arguments, etc.
   if (AttributorRun & AttributorRunOption::MODULE)
     MPM.add(createAttributorLegacyPass());
void PassManagerBuilder::populateModulePassManager(
   if (RunInliner) {
     MPM.add(createGlobalOptimizerPass());
     MPM.add(createGlobalDCEPass());
   }
 
   // If we are planning to perform ThinLTO later, let's not bloat the code with
   // unrolling/vectorization/... now. We'll first run the inliner + CGSCC passes
   // during ThinLTO and perform the rest of the optimizations afterward.
-  if (PrepareForThinLTO) {
+  if (PrepareForThinLTO && !UnifiedLTO) {
     // Ensure we perform any last passes, but do so before renaming anonymous
     // globals in case the passes add any.
     addExtensionsToPM(EP_OptimizerLast, MPM);
     MPM.add(createCanonicalizeAliasesPass());
     // Rename anon globals to be able to export them in the summary.
     MPM.add(createNameAnonGlobalPass());
     return;
   }
 
-  if (PerformThinLTO)
+  if (PerformThinLTO && !UnifiedLTO)
     // Optimize globals now when performing ThinLTO, this enables more
     // optimizations later.
     MPM.add(createGlobalOptimizerPass());
 
   // Scheduling LoopVersioningLICM when inlining is over, because after that
   // we may see more accurate aliasing. Reason to run this late is that too
   // early versioning may prevent further inlining due to increase of code
   // size. By placing it just after inlining other optimizations which runs
void PassManagerBuilder::populateModulePassManager(
 
   // LoopSink (and other loop passes since the last simplifyCFG) might have
   // resulted in single-entry-single-exit or empty blocks. Clean up the CFG.
   MPM.add(createCFGSimplificationPass(
       SimplifyCFGOptions().convertSwitchRangeToICmp(true)));
 
   addExtensionsToPM(EP_OptimizerLast, MPM);
 
-  if (PrepareForLTO) {
+  // Anonymous globals need a name to ensure that CFI works in both Thin and
+  // Full LTO
+  if (PrepareForLTO || (PrepareForThinLTO && UnifiedLTO)) {
     MPM.add(createCanonicalizeAliasesPass());
     // Rename anon globals to be able to handle them in the summary
     MPM.add(createNameAnonGlobalPass());
   }
 
   MPM.add(createAnnotationRemarksLegacyPass());
 }
 
void PassManagerBuilder::addLateLTOOptimizationPasses(
   // currently it damages debug info.
   if (MergeFunctions)
     PM.add(createMergeFunctionsPass());
 }
 
 void PassManagerBuilder::populateThinLTOPassManager(
     legacy::PassManagerBase &PM) {
   PerformThinLTO = true;
+  UnifiedLTO = false;
   if (LibraryInfo)
     PM.add(new TargetLibraryInfoWrapperPass(*LibraryInfo));
 
   if (VerifyInput)
     PM.add(createVerifierPass());
 
   if (ImportSummary) {
     // This pass imports type identifier resolutions for whole-program

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

static void cloneUsedGlobalVariables(const Module &SrcM, Module &DestM,
   }
   // Finally, add them to a llvm[.compiler].used variable in DestM.
   if (CompilerUsed)
     appendToCompilerUsed(DestM, NewUsed);
   else
     appendToUsed(DestM, NewUsed);
 }
 
+bool enableUnifiedLTO(Module &M) {
+  bool UnifiedLTO = false;
+  if (auto *MD = mdconst::extract_or_null<ConstantInt>(
+          M.getModuleFlag("UnifiedLTO")))
+    UnifiedLTO = MD->getZExtValue();
+  return UnifiedLTO;
+}
+
 // If it's possible to split M into regular and thin LTO parts, do so and write
 // a multi-module bitcode file with the two parts to OS. Otherwise, write only a
 // regular LTO bitcode file to OS.
 void splitAndWriteThinLTOBitcode(
     raw_ostream &OS, raw_ostream *ThinLinkOS,
     function_ref<AAResults &(Function &)> AARGetter, Module &M) {
-  std::string ModuleId = getUniqueModuleId(&M);
+  bool UnifiedLTO = enableUnifiedLTO(M);
+  std::string ModuleId = getUniqueModuleId(&M, UnifiedLTO);
   if (ModuleId.empty()) {
+    assert(!UnifiedLTO);
     // We couldn't generate a module ID for this module, write it out as a
     // regular LTO module with an index for summary-based dead stripping.
     ProfileSummaryInfo PSI(M);
     M.addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
     ModuleSummaryIndex Index = buildModuleSummaryIndex(M, nullptr, &PSI);
-    WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, &Index);
+    WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, &Index,
+                       /*GenerateHash=*/ UnifiedLTO);
 
     if (ThinLinkOS)
       // We don't have a ThinLTO part, but still write the module to the
       // ThinLinkOS if requested so that the expected output file is produced.
       WriteBitcodeToFile(M, *ThinLinkOS, /*ShouldPreserveUseListOrder=*/false,
-                         &Index);
+                         &Index, UnifiedLTO);
 
     return;
   }
 
   promoteTypeIds(M, ModuleId);
 
   // Returns whether a global or its associated global has attached type
   // metadata. The former may participate in CFI or whole-program

 
 public:
   static char ID; // Pass identification, replacement for typeid
   WriteThinLTOBitcode() : ModulePass(ID), OS(dbgs()), ThinLinkOS(nullptr) {
     initializeWriteThinLTOBitcodePass(*PassRegistry::getPassRegistry());
   }
 
   explicit WriteThinLTOBitcode(raw_ostream &o, raw_ostream *ThinLinkOS)
-      : ModulePass(ID), OS(o), ThinLinkOS(ThinLinkOS) {
+      :  ModulePass(ID), OS(o), ThinLinkOS(ThinLinkOS) {
     initializeWriteThinLTOBitcodePass(*PassRegistry::getPassRegistry());
   }
 
   StringRef getPassName() const override { return "ThinLTO Bitcode Writer"; }
 
   bool runOnModule(Module &M) override {
     const ModuleSummaryIndex *Index =
         &(getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex());
INITIALIZE_PASS_BEGIN(WriteThinLTOBitcode, "write-thinlto-bitcode",
                       "Write ThinLTO Bitcode", false, true)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(ModuleSummaryIndexWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_END(WriteThinLTOBitcode, "write-thinlto-bitcode",
                     "Write ThinLTO Bitcode", false, true)
 
 ModulePass *llvm::createWriteThinLTOBitcodePass(raw_ostream &Str,
-                                                raw_ostream *ThinLinkOS) {
+                                                raw_ostream *ThinLinkOS,
+                                                bool UnifiedLTO) {
   return new WriteThinLTOBitcode(Str, ThinLinkOS);
 }
 
 PreservedAnalyses
 llvm::ThinLTOBitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {
   FunctionAnalysisManager &FAM =
       AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
   writeThinLTOBitcode(OS, ThinLinkOS,
                       [&FAM](Function &F) -> AAResults & {
                         return FAM.getResult<AAManager>(F);
                       },
                       M, &AM.getResult<ModuleSummaryIndexAnalysis>(M));
   return PreservedAnalyses::all();
 }

llvm/lib/Transforms/Utils/ModuleUtils.cpp

void llvm::filterDeadComdatFunctions(
 
   // Only keep functions which have no comdat or a dead comdat.
   erase_if(DeadComdatFunctions, [&](Function *F) {
     Comdat *C = F->getComdat();
     return C && !DeadComdats.contains(C);
   });
 }
 
-std::string llvm::getUniqueModuleId(Module *M) {
+std::string llvm::getUniqueModuleId(Module *M, bool UnifiedLTO) {
   MD5 Md5;
   bool ExportsSymbols = false;
   auto AddGlobal = [&](GlobalValue &GV) {
     if (GV.isDeclaration() || GV.getName().startswith("llvm.") ||
-        !GV.hasExternalLinkage() || GV.hasComdat())
+        (!GV.hasExternalLinkage() &&
+         (!UnifiedLTO ||
+          !(GV.hasWeakLinkage() || GV.hasWeakAnyLinkage() ||
+            GV.hasWeakODRLinkage() || GV.hasLinkOnceLinkage() ||
+            GV.hasLinkOnceODRLinkage() || GV.hasCommonLinkage() ||
+            GV.hasComdat()))) ||
+        (!UnifiedLTO && GV.hasComdat()))
       return;
     ExportsSymbols = true;
     Md5.update(GV.getName());
     Md5.update(ArrayRef<uint8_t>{0});
   };
 
+  // When UnifiedLTO is enabled, we always need to generate split modules which
+  // requires a ModuleID. Using more types of metadata to generate this hash
+  // helps to ensure this.
+  if (UnifiedLTO) {
+    if (auto *Used = M->getNamedGlobal("llvm.used")) {
+      if (const auto *A = dyn_cast<ConstantArray>(Used->getInitializer())) {
+        for (const Value *Op : A->operands()) {
+          if (const auto *GV = dyn_cast<GlobalValue>(Op->stripPointerCasts())) {
+            Md5.update(GV->getName());
+            Md5.update(ArrayRef<uint8_t>{0});
+          }
+        }
+      }
+    }
+    if (auto *Used = M->getNamedGlobal("llvm.global_ctors")) {
+      if (const auto *A = dyn_cast<ConstantArray>(Used->getInitializer())) {
+        for (const Value *Op : A->operands()) {
+          if (const auto *GV = dyn_cast<ConstantStruct>(Op)) {
+            auto *Elt = GV->getAggregateElement(1);
+            Md5.update(Elt->getName());
+            Md5.update(ArrayRef<uint8_t>{0});
+          }
+        }
+      }
+    }
+
+    Md5.update(M->getModuleIdentifier());
+    Md5.update(ArrayRef<uint8_t>{0});
+    ExportsSymbols = true;
+  }
+
   for (auto &F : *M)
     AddGlobal(F);
   for (auto &GV : M->globals())
     AddGlobal(GV);
   for (auto &GA : M->aliases())
     AddGlobal(GA);
   for (auto &IF : M->ifuncs())
     AddGlobal(IF);
 
   if (!ExportsSymbols)
     return "";
 
   MD5::MD5Result R;
   Md5.final(R);
 
   SmallString<32> Str;
   MD5::stringifyResult(R, Str);
+
+  LLVM_DEBUG(dbgs() << "Generated ModuleID: " << Str.str() << "\n");
+
   return ("." + Str).str();
 }
 
 void VFABI::setVectorVariantNames(CallInst *CI,
                                   ArrayRef<std::string> VariantMappings) {
   if (VariantMappings.empty())
     return;
 

llvm/test/LTO/Resolution/X86/llvm-used-moduleid.ll

+; RUN: opt <%s -unified-lto -thinlto-bc -thinlto-split-lto-unit -o %t0
+; RUN: llvm-bcanalyzer %t0 | FileCheck %s
+
+target triple="x86_64-pc-linux-gnu"
+
[e-mail] = appending global [1 x i8*] [i8* bitcast (void ()* @a to i8*)], !type !0
+
+declare i1 @llvm.type.test(i8*, metadata)
+declare void @llvm.assume(i1)
+
+; CHECK: GLOBALVAL_SUMMARY_BLOCK
+; CHECK: FULL_LTO_GLOBALVAL_SUMMARY_BLOCK
+define internal void @a() {
+  %1 = call i1 @llvm.type.test(i8* undef, metadata !"a")
+  call void @llvm.assume(i1 %1)
+  ret void
+}
+
+!0 = !{i64 16, !"a"}

llvm/test/LTO/Resolution/X86/local-def-dllimport.ll

-; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t0.bc %s
+; RUN: opt --unified-lto -thinlto-split-lto-unit -thinlto-bc -o %t0.bc %s
+
 ; RUN: llvm-lto2 run -r %t0.bc,__imp_f,l \
-; RUN:               -r %t0.bc,g,p \
 ; RUN:               -r %t0.bc,g,l \
+; RUN:               -r %t0.bc,g,p \
 ; RUN:               -r %t0.bc,e,l \
 ; RUN:               -r %t0.bc,main,x \
-; RUN:               -save-temps -o %t1 %t0.bc
+; RUN:               -save-temps -o %t1 %t0.bc \
+; RUN:               --lto=thin
 ; RUN: llvm-dis %t1.1.3.import.bc -o - | FileCheck %s
 source_filename = "test.cpp"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 $g = comdat any
 @g = global i8 42, comdat, !type !0
 

llvm/test/LTO/Resolution/X86/unified-lto-check.ll

+; Test to ensure that the Unified LTO flag is set properly in the summary, and
+; that we correctly silently handle linking bitcode files with different values
+; of this flag.
+
+; Linking bitcode both without UnifiedLTO set should work
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t1 %s
+; RUN: llvm-bcanalyzer -dump %t1 | FileCheck %s --check-prefix=NOUNIFIEDLTO
+; RUN: llvm-dis -o - %t1 | FileCheck %s --check-prefix=NOUNIFIEDLTOFLAG
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t2 %s
+; RUN: llvm-bcanalyzer -dump %t2 | FileCheck %s --check-prefix=NOUNIFIEDLTO
+; RUN: llvm-dis -o - %t2 | FileCheck %s --check-prefix=NOUNIFIEDLTOFLAG
+; RUN: llvm-lto2 run -o %t3 %t1 %t2
+
+; Linking bitcode with different values of UnifiedLTO should fail
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t1 %s
+; RUN: llvm-bcanalyzer -dump %t1 | FileCheck %s --check-prefix=NOUNIFIEDLTO
+; RUN: llvm-dis -o - %t1 | FileCheck %s --check-prefix=NOUNIFIEDLTOFLAG
+; RUN: opt -unified-lto -thinlto-bc -thinlto-split-lto-unit -o %t2 %s
+; RUN: llvm-bcanalyzer -dump %t2 | FileCheck %s --check-prefix=UNIFIEDLTO
+; RUN: llvm-dis -o - %t2 | FileCheck %s --check-prefix=UNIFIEDLTOFLAG
+; RUN: not llvm-lto2 run --lto=thin -o %t3 %t1 %t2 2>&1 | \
+; RUN: FileCheck --allow-empty %s --check-prefix UNIFIEDERR
+
+; Linking bitcode with identical Unified LTO flags should succeed
+; RUN: opt -unified-lto -thinlto-bc -thinlto-split-lto-unit -o %t1 %s
+; RUN: llvm-bcanalyzer -dump %t1 | FileCheck %s --check-prefix=UNIFIEDLTO
+; RUN: llvm-dis -o - %t1 | FileCheck %s --check-prefix=UNIFIEDLTOFLAG
+; RUN: opt -unified-lto -thinlto-bc -thinlto-split-lto-unit -o %t2 %s
+; RUN: llvm-bcanalyzer -dump %t2 | FileCheck %s --check-prefix=UNIFIEDLTO
+; RUN: llvm-dis -o - %t2 | FileCheck %s --check-prefix=UNIFIEDLTOFLAG
+; RUN: llvm-lto2 run --lto=thin -o %t3 %t1 %t2 | \
+; RUN: FileCheck --allow-empty %s --check-prefix NOUNIFIEDERR
+
+; UNIFIEDERR: unified LTO compilation must use compatible bitcode modules
+; NOUNIFIEDERR-NOT: unified LTO compilation must use compatible bitcode modules
+
+; The flag should be set when UnifiedLTO is enabled
+; UNIFIEDLTO: <FLAGS op0=136/>
+; NOUNIFIEDLTO: <FLAGS op0=8/>
+
+; Check that the corresponding module flag is set when expected.
+; UNIFIEDLTOFLAG: !{i32 1, !"UnifiedLTO", i32 1}
+; NOUNIFIEDLTOFLAG-NOT: !{i32 1, !"UnifiedLTO", i32 1}
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"

llvm/test/LTO/Resolution/X86/weak-linkage-moduleid.ll

+; RUN: opt <%s -unified-lto -thinlto-bc -thinlto-split-lto-unit -o %t0
+; RUN: llvm-bcanalyzer %t0 | FileCheck %s
+
+target triple="x86_64-pc-linux-gnu"
+
+@p = weak global void ()* @a, !type !0
+
+declare i1 @llvm.type.test(i8*, metadata)
+declare void @llvm.assume(i1)
+
+; CHECK: GLOBALVAL_SUMMARY_BLOCK
+; CHECK: FULL_LTO_GLOBALVAL_SUMMARY_BLOCK
+define internal void @a() {
+  %1 = call i1 @llvm.type.test(i8* undef, metadata !"a")
+  call void @llvm.assume(i1 %1)
+  ret void
+}
+
+!0 = !{i64 16, !"a"}

llvm/test/LTO/X86/cfi-func-remove.ll

+; RUN: opt -thinlto-bc -thinlto-split-lto-unit -unified-lto <%s -o %t0
+; RUN: llvm-lto2 run --use-new-pm=0 -o %t1 --lto=full --save-temps %t0
+; RUN: llvm-dis <%t1.0.0.preopt.bc 2>&1 | FileCheck %s --implicit-check-not warning:
+; RUN: llvm-lto2 run --use-new-pm=1 -o %t1 --lto=full --save-temps %t0
+; RUN: llvm-dis <%t1.0.0.preopt.bc 2>&1 | FileCheck %s --implicit-check-not warning:
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-linux-gnu"
+
+!cfi.functions = !{!2}
+; CHECK-NOT: cfi.functions
+
+!2 = !{!"main", i8 0}

llvm/test/LTO/X86/path-moduleid.ll

+; REQUIRES: asserts
+; Test that chaning the path to the module doesn't effect the ModuleID. This
+; file and Inputs/path-moduleid.ll have the same content, and thus should have
+; the same ModuleID.
+; RUN: opt -o /dev/null -unified-lto -thinlto-bc -thinlto-split-lto-unit=1 --debug-only=moduleutils %s 2>%t0
+; RUN: mkdir -p %t; cp %s %t/path-moduleid.ll
+; RUN: opt -o /dev/null -unified-lto -thinlto-bc -thinlto-split-lto-unit=1 --debug-only=moduleutils %t/path-moduleid.ll 2>%t1
+; RUN: FileCheck %s <%t0
+; RUN: FileCheck %s <%t1
+; RUN: not diff %t0 %t1
+
+; CHECK: Generated ModuleID:
+target triple="x86_64-pc-linux-gnu"
+
[e-mail] = appending global [1 x i8*] [i8* bitcast (void ()* @a to i8*)], !type !0
+
+declare i1 @llvm.type.test(i8*, metadata)
+declare void @llvm.assume(i1)
+
+define internal void @a() {
+  %1 = call i1 @llvm.type.test(i8* undef, metadata !"a")
+  call void @llvm.assume(i1 %1)
+  ret void
+}
+
+
+!0 = !{i64 16, !"a"}

llvm/test/LTO/X86/unified-cfi.ll

+; Test for the expected CFI codegen in a module with CFI metadata.
+; RUN: opt -unified-lto -thinlto-bc -o %t0.o %s
+; RUN: llvm-lto --exported-symbol=main -filetype=asm -o - %t0.o | FileCheck %s
+
+; CHECK-LABEL: main
+
+; CHECK: jbe
+; CHECK-NEXT: ud2
+; CHECK-NEXT: ud2
+
+; ModuleID = 'llvm/test/LTO/X86/unified-cfi.ll'
+source_filename = "cfi.cpp"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-scei-ps4"
+
+@func = hidden global [3 x i32 ()*] [i32 ()* @_Z1av, i32 ()* @_Z1bv, i32 ()* @_Z1cv], align 16
+@.src = private unnamed_addr constant [8 x i8] c"cfi.cpp\00", align 1
+@anon.9260195284c792ab5c6ef4d97bfcf95d.0 = private unnamed_addr constant { i16, i16, [9 x i8] } { i16 -1, i16 0, [9 x i8] c"'int ()'\00" }
+
+; Function Attrs: noinline nounwind optnone sspstrong uwtable
+define hidden i32 @_Z1av() #0 !type !3 !type !4 {
+entry:
+  ret i32 1
+}
+
+; Function Attrs: noinline nounwind optnone sspstrong uwtable
+define hidden i32 @_Z1bv() #0 !type !3 !type !4 {
+entry:
+  ret i32 2
+}
+
+; Function Attrs: noinline nounwind optnone sspstrong uwtable
+define hidden i32 @_Z1cv() #0 !type !3 !type !4 {
+entry:
+  ret i32 3
+}
+
+; Function Attrs: noinline norecurse nounwind optnone sspstrong uwtable
+define hidden i32 @main(i32 %argc, i8** %argv) #1 !type !5 !type !6 {
+entry:
+  %retval = alloca i32, align 4
+  %argc.addr = alloca i32, align 4
+  %argv.addr = alloca i8**, align 8
+  store i32 0, i32* %retval, align 4
+  store i32 %argc, i32* %argc.addr, align 4
+  store i8** %argv, i8*** %argv.addr, align 8
+  %0 = load i32, i32* %argc.addr, align 4
+  %idxprom = sext i32 %0 to i64
+  %arrayidx = getelementptr inbounds [3 x i32 ()*], [3 x i32 ()*]* @func, i64 0, i64 %idxprom
+  %1 = load i32 ()*, i32 ()** %arrayidx, align 8
+  %2 = bitcast i32 ()* %1 to i8*, !nosanitize !7
+  %3 = call i1 @llvm.type.test(i8* %2, metadata !"_ZTSFivE"), !nosanitize !7
+  br i1 %3, label %cont, label %trap, !nosanitize !7
+
+trap:                                             ; preds = %entry
+  call void @llvm.trap() #4, !nosanitize !7
+  unreachable, !nosanitize !7
+
+cont:                                             ; preds = %entry
+  %call = call i32 %1()
+  ret i32 %call
+}
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare i1 @llvm.type.test(i8*, metadata) #2
+
+; Function Attrs: cold noreturn nounwind
+declare void @llvm.trap() #3
+
+attributes #0 = { noinline nounwind optnone sspstrong uwtable }
+attributes #1 = { noinline norecurse nounwind optnone sspstrong uwtable }
+attributes #2 = { nofree nosync nounwind readnone speculatable willreturn }
+attributes #3 = { cold noreturn nounwind }
+attributes #4 = { noreturn nounwind }
+
+!llvm.module.flags = !{!0, !1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, !"wchar_size", i32 2}
+!1 = !{i32 7, !"PIC Level", i32 2}
+!2 = !{!"clang version 7.0.0 (PS4 clang version 99.99.0.1562 432a534f checking)"}
+!3 = !{i64 0, !"_ZTSFivE"}
+!4 = !{i64 0, !"_ZTSFivE.generalized"}
+!5 = !{i64 0, !"_ZTSFiiPPcE"}
+!6 = !{i64 0, !"_ZTSFiiPvE.generalized"}
+!7 = !{}
+
+^0 = module: (path: "llvm/test/LTO/X86/unified-cfi.ll", hash: (0, 0, 0, 0, 0))
+^1 = gv: (name: "llvm.type.test") ; guid = 608142985856744218
+^2 = gv: (name: "_Z1cv", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 1, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1))) ; guid = 1031113446561889624
+^3 = gv: (name: "_Z1bv", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 1, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1))) ; guid = 2000451273547961259
+^4 = gv: (name: "_Z1av", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 1, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1))) ; guid = 3456846378323757990
+^5 = gv: (name: ".src", summaries: (variable: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0)))) ; guid = 5614330533059031665
+^6 = gv: (name: "llvm.trap") ; guid = 6116349651215144041
+^7 = gv: (name: "func", summaries: (variable: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0), refs: (^4, ^3, ^2)))) ; guid = 7289175272376759421
+^8 = gv: (name: "anon.9260195284c792ab5c6ef4d97bfcf95d.0", summaries: (variable: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0)))) ; guid = 10197562899942851386
+^9 = gv: (name: "main", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 1, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 17, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 0, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0), typeIdInfo: (typeTests: (194679795792225349)), refs: (^7)))) ; guid = 15822663052811949562
+^10 = blockcount: 0

llvm/test/LTO/X86/unified-internalize.ll

+; RUN: opt <%s -unified-lto -thinlto-split-lto-unit -thinlto-bc -o %t.bc
+
+; Test internalization during unified LTO. This makes sure internalization does
+; happen in runRegularLTO().
+; RUN: llvm-lto2 run %t.bc --use-new-pm=0 -o %t.o -save-temps --lto=full \
+; RUN:     -r=%t.bc,salad,pxl \
+; RUN:     -r=%t.bc,balsamic,pl \
+; RUN:     -r=%t.bc,thousandisland,pl \
+; RUN:     -r=%t.bc,main,pxl \
+; RUN:     -r %t.bc,ranch,px \
+; RUN:     -r %t.bc,egg, \
+; RUN:     -r %t.bc,bar,px
+; RUN: llvm-dis < %t.o.0.2.internalize.bc | FileCheck  %s
+; RUN: llvm-lto2 run %t.bc --use-new-pm=1 -o %t.o -save-temps --lto=full \
+; RUN:     -r=%t.bc,salad,pxl \
+; RUN:     -r=%t.bc,balsamic,pl \
+; RUN:     -r=%t.bc,thousandisland,pl \
+; RUN:     -r=%t.bc,main,pxl \
+; RUN:     -r %t.bc,ranch,px \
+; RUN:     -r %t.bc,egg, \
+; RUN:     -r %t.bc,bar,px
+; RUN: llvm-dis < %t.o.0.2.internalize.bc | FileCheck  %s
+
+; CHECK: @llvm.used = appending global {{.*}} @bar
+; CHECK: define dso_local dllexport void @thousandisland
+; CHECK: define dso_local void @salad
+; CHECK: define internal void @balsamic
+; CHECK: define dso_local void @main
+; CHECK: define available_externally void @egg()
+
+target triple = "x86_64-scei-ps4"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @salad() {
+    call void @balsamic()
+    ret void
+}
+define void @balsamic() {
+    ret void
+}
+define dllexport void @thousandisland() {
+    ret void
+}
+
+define void @main() {
+    ret void
+}
+
+define void ()* @ranch() {
+  ret void ()* @egg
+}
+
+define available_externally void @egg() {
+  ret void
+}
+
+%"foo.1" = type { i8, i8 }
+declare dso_local i32 @bar(%"foo.1"* nocapture readnone %this) local_unnamed_addr
[e-mail] = appending global [2 x i8*] [i8* bitcast (i32 (%"foo.1"*)* @bar to i8*), i8* bitcast (void ()* @thousandisland to i8*)], section "llvm.metadata"

llvm/test/LTO/X86/whole-program-no-crash.ll

+; Run the ThinLTO and LTO backends on a module with
+; devirtualizaiton metadata. In previous versions of the compiler,
+; this crashed.
+; RUN: opt -unified-lto -thinlto-bc <%s -o %t0.o
+; RUN: llvm-lto --thinlto-action=run %t0.o -thinlto-save-objects=%t
+; RUN: llvm-lto %t0.o
+
+; ModuleID = 'llvm/test/LTO/X86/whole-program-no-crash.ll
+source_filename = "main.cpp"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-scei-ps4"
+
+%struct.Square = type { %struct.Shape, double }
+%struct.Shape = type { i32 (...)** }
+
+@.str = private unnamed_addr constant [21 x i8] c"Area of a circle: %e\00", align 1
+@.str.1 = private unnamed_addr constant [21 x i8] c"Area of a square: %e\00", align 1
+@.str.2 = private unnamed_addr constant [30 x i8] c"Area of a circle, squared: %f\00", align 1
+@.str.3 = private unnamed_addr constant [30 x i8] c"Area of a square, squared: %f\00", align 1
+
+; Function Attrs: norecurse nounwind uwtable
+define hidden i32 @main(i32 %argc, i8** nocapture readnone %argv) local_unnamed_addr #0 {
+entry:
+  %call = tail call i8* @_Znwm(i64 16) #6
+  %0 = bitcast i8* %call to %struct.Square*
+  tail call void @_ZN6SquareC1Ed(%struct.Square* nonnull %0, double 1.000000e+00) #3
+  %1 = bitcast i8* %call to %struct.Shape*
+  %call1 = tail call i8* @_Znwm(i64 16) #6
+  %2 = bitcast i8* %call1 to %struct.Square*
+  tail call void @_ZN6SquareC1Ed(%struct.Square* nonnull %2, double 1.000000e+00) #3
+  %3 = bitcast i8* %call1 to %struct.Shape*
+  %4 = bitcast i8* %call to double (%struct.Shape*)***
+  %vtable = load double (%struct.Shape*)**, double (%struct.Shape*)*** %4, align 8, !tbaa !3
+  %5 = bitcast double (%struct.Shape*)** %vtable to i8*
+  %6 = tail call i1 @llvm.type.test(i8* %5, metadata !"_ZTS5Shape")
+  tail call void @llvm.assume(i1 %6)
+  %7 = load double (%struct.Shape*)*, double (%struct.Shape*)** %vtable, align 8
+  %call2 = tail call double %7(%struct.Shape* nonnull %1) #3
+  %call3 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), double %call2)
+  %8 = bitcast i8* %call1 to double (%struct.Shape*)***
+  %vtable4 = load double (%struct.Shape*)**, double (%struct.Shape*)*** %8, align 8, !tbaa !3
+  %9 = bitcast double (%struct.Shape*)** %vtable4 to i8*
+  %10 = tail call i1 @llvm.type.test(i8* %9, metadata !"_ZTS5Shape")
+  tail call void @llvm.assume(i1 %10)
+  %11 = load double (%struct.Shape*)*, double (%struct.Shape*)** %vtable4, align 8
+  %call6 = tail call double %11(%struct.Shape* nonnull %3) #3
+  %call7 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), double %call6)
+  %call8 = tail call double @_Z14circle_squaredP5Shape(%struct.Shape* nonnull %1) #3
+  %call9 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), double %call8)
+  %call10 = tail call double @_Z14square_squaredP5Shape(%struct.Shape* nonnull %3) #3
+  %call11 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), double %call10)
+  ret i32 0
+}
+
+; Function Attrs: nobuiltin
+declare noalias nonnull i8* @_Znwm(i64) local_unnamed_addr #1
+
+declare void @_ZN6SquareC1Ed(%struct.Square*, double) unnamed_addr
+
+; Function Attrs: nounwind
+declare i32 @printf(i8* nocapture readonly, ...) local_unnamed_addr #3
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare i1 @llvm.type.test(i8*, metadata) #4
+
+; Function Attrs: inaccessiblememonly nofree nosync nounwind willreturn
+declare void @llvm.assume(i1 noundef) #5
+
+declare double @_Z14circle_squaredP5Shape(%struct.Shape*) local_unnamed_addr
+
+declare double @_Z14square_squaredP5Shape(%struct.Shape*) local_unnamed_addr
+
+attributes #0 = { norecurse nounwind uwtable }
+attributes #1 = { nobuiltin }
+attributes #3 = { nounwind }
+attributes #4 = { nofree nosync nounwind readnone speculatable willreturn }
+attributes #5 = { inaccessiblememonly nofree nosync nounwind willreturn }
+attributes #6 = { builtin nounwind }
+
+!llvm.module.flags = !{!0, !1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, !"wchar_size", i32 2}
+!1 = !{i32 7, !"PIC Level", i32 2}
+!2 = !{!"clang version 7.0.0 (PS4 clang version 99.99.0.1564 e05e1b5f checking)"}
+!3 = !{!4, !4, i64 0}
+!4 = !{!"vtable pointer", !5, i64 0}
+!5 = !{!"Simple C++ TBAA"}
+
+^0 = module: (path: "llvm/test/LTO/X86/whole-program-no-crash.ll", hash: (160140095, 1084170952, 2125434145, 3248440305, 919813895))
+^1 = gv: (name: "llvm.type.test") ; guid = 608142985856744218
+^2 = gv: (name: ".str", summaries: (variable: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0)))) ; guid = 3057614271122621510
+^3 = gv: (name: ".str.1", summaries: (variable: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0)))) ; guid = 5124566073124437459
+^4 = gv: (name: "_Z14circle_squaredP5Shape") ; guid = 6033955522051173057
+^5 = gv: (name: "llvm.assume") ; guid = 6385187066495850096
+^6 = gv: (name: "printf") ; guid = 7383291119112528047
+^7 = gv: (name: ".str.3", summaries: (variable: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0)))) ; guid = 8135577886398900316
+^8 = gv: (name: "_Z14square_squaredP5Shape") ; guid = 8213923296236276854
+^9 = gv: (name: "_ZN6SquareC1Ed") ; guid = 10727975616611545044
+^10 = gv: (name: "main", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 29, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 0, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0), calls: ((callee: ^11), (callee: ^9), (callee: ^6), (callee: ^4), (callee: ^8)), typeIdInfo: (typeTestAssumeConstVCalls: ((vFuncId: (guid: 14923871475266172186, offset: 0)))), refs: (^2, ^3, ^12, ^7)))) ; guid = 15822663052811949562
+^11 = gv: (name: "_Znwm") ; guid = 16793709562209971782
+^12 = gv: (name: ".str.2", summaries: (variable: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0)))) ; guid = 17414738078732285526
+^13 = blockcount: 0

llvm/test/ThinLTO/X86/dup-cgprofile-flag.ll

+; RUN: opt <%s -unified-lto -thinlto-bc -thinlto-split-lto-unit -o %t0
+; Old PM
+; RUN: llvm-lto2 run %t0 --use-new-pm=0 --lto=full -o %t1 \
+; RUN:   -r=%t0,freq,px \
+; RUN:   -r=%t0,a,px \
+; RUN:   -r=%t0,b,px \
+; RUN:   -r=%t0,func1,px \
+; RUN:   -r=%t0,func2,px \
+; RUN:   -r=%t0,func3,px \
+; RUN:   -r=%t0,func4,px \
+; RUN:   -r=%t0,foo,px
+; RUN: llvm-lto2 run %t0 --use-new-pm=0 --lto=thin -o %t1 \
+; RUN:   -r=%t0,freq,px \
+; RUN:   -r=%t0,a,px \
+; RUN:   -r=%t0,b,px \
+; RUN:   -r=%t0,func1,px \
+; RUN:   -r=%t0,func2,px \
+; RUN:   -r=%t0,func3,px \
+; RUN:   -r=%t0,func4,px \
+; RUN:   -r=%t0,foo,px
+; RUN: not --crash llvm-lto2 run %t0 --use-new-pm=0 -o %t1 \
+; RUN:   -r=%t0,freq,px \
+; RUN:   -r=%t0,a,px \
+; RUN:   -r=%t0,b,px \
+; RUN:   -r=%t0,func1,px \
+; RUN:   -r=%t0,func2,px \
+; RUN:   -r=%t0,func3,px \
+; RUN:   -r=%t0,func4,px \
+; RUN:   -r=%t0,foo,px 2>&1 | FileCheck %s
+; New PM
+; RUN: llvm-lto2 run %t0 --use-new-pm=1 --lto=full -o %t1 \
+; RUN:   -r=%t0,freq,px \
+; RUN:   -r=%t0,a,px \
+; RUN:   -r=%t0,b,px \
+; RUN:   -r=%t0,func1,px \
+; RUN:   -r=%t0,func2,px \
+; RUN:   -r=%t0,func3,px \
+; RUN:   -r=%t0,func4,px \
+; RUN:   -r=%t0,foo,px
+; RUN: llvm-lto2 run %t0 --use-new-pm=1 --lto=thin -o %t1 \
+; RUN:   -r=%t0,freq,px \
+; RUN:   -r=%t0,a,px \
+; RUN:   -r=%t0,b,px \
+; RUN:   -r=%t0,func1,px \
+; RUN:   -r=%t0,func2,px \
+; RUN:   -r=%t0,func3,px \
+; RUN:   -r=%t0,func4,px \
+; RUN:   -r=%t0,foo,px
+; RUN: not --crash llvm-lto2 run %t0 --use-new-pm=1 -o %t1 \
+; RUN:   -r=%t0,freq,px \
+; RUN:   -r=%t0,a,px \
+; RUN:   -r=%t0,b,px \
+; RUN:   -r=%t0,func1,px \
+; RUN:   -r=%t0,func2,px \
+; RUN:   -r=%t0,func3,px \
+; RUN:   -r=%t0,func4,px \
+; RUN:   -r=%t0,foo,px 2>&1 | FileCheck %s
+
+; CHECK: module flag identifiers must be unique
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-linux-gnu"
+
+@foo = common global i32 ()* null, align 8
+
+declare void @b()
+
+define void @a() !prof !1 {
+  call void @b()
+  ret void
+}
+
+declare i32 @func1()
+declare i32 @func2()
+declare i32 @func3()
+declare i32 @func4()
+
+define void @freq(i1 %cond) !prof !1 {
+  %tmp = load i32 ()*, i32 ()** @foo, align 8
+  call i32 %tmp(), !prof !3
+  br i1 %cond, label %A, label %B, !prof !2
+A:
+  call void @a();
+  ret void
+B:
+  call void @b();
+  ret void
+}
+
+!1 = !{!"function_entry_count", i64 32}
+!2 = !{!"branch_weights", i32 5, i32 10}
+!3 = !{!"VP", i32 0, i64 1600, i64 7651369219802541373, i64 1030, i64 -4377547752858689819, i64 410, i64 -6929281286627296573, i64 150, i64 -2545542355363006406, i64 10}
+
+!llvm.module.flags = !{!4}
+!4 = !{i32 5, !"CG Profile", !5}
+!5 = !{!6,!7,!8,!6,!10,!11,!12}
+!6 = !{void ()* @a, void ()* @b, i64 32}
+!7 = !{void (i1)* @freq, i32 ()* @func4, i64 1030}
+!8 = !{void (i1)* @freq, i32 ()* @func2, i64 410}
+!9 = !{void (i1)* @freq, i32 ()* @func3, i64 150}
+!10 = !{void (i1)* @freq, i32 ()* @func1, i64 10}
+!11 = !{void (i1)* @freq, void ()* @a, i64 11}
+!12 = !{void (i1)* @freq, void ()* @b, i64 21}

llvm/test/Transforms/ThinLTOBitcodeWriter/split-unified.ll

+; Generate bitcode files with summary, as well as minimized bitcode without
+; the debug metadata for the thin link.
+; RUN: opt -unified-lto -thinlto-bc -thin-link-bitcode-file=%t2 -o %t %s
+
+; RUN: llvm-modextract -b -n 0 -o %t0.bc %t
+; RUN: not llvm-modextract -b -n 1 -o - %t 2>&1 | FileCheck --check-prefix=ERROR %s
+; RUN: llvm-dis -o - %t0.bc | FileCheck --check-prefix=M0 %s
+; RUN: llvm-bcanalyzer -dump %t0.bc | FileCheck --check-prefix=BCA0 %s
+
+; ERROR: llvm-modextract: error: module index out of range; bitcode file contains 1 module(s)
+
+; BCA0: <GLOBALVAL_SUMMARY_BLOCK
+; 16 = not eligible to import
+
+$g = comdat any
+
+@g = global i8 42, comdat, !type !0
+
+; M0: define i8* @f()
+define i8* @f() {
+  ret i8* @g
+}
+
+; M0: !0 = !{i32 0, !"typeid"}
+!0 = !{i32 0, !"typeid"}

llvm/test/Transforms/Util/generate-moduleid.ll

+; REQUIRES: asserts
+; RUN: opt -unified-lto --thinlto-split-lto-unit=1 --thinlto-bc -o %t0 -debug-only=moduleutils <%s 2>&1 | FileCheck %s
+; CHECK: Generated ModuleID
+
+target triple="x86_64-pc-linux-gnu"
+
+declare i1 @llvm.type.test(i8*, metadata)
+
+define internal void @foo() !type !1{
+entry:
+  %0 = tail call i1 @llvm.type.test(i8* null, metadata !"")
+  ret void
+}
+
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 103, void ()* @foo, i8* null }]
+
+!1 = !{i64 0, !"foo"}

llvm/tools/llvm-lto2/llvm-lto2.cpp

 
 static cl::opt<std::string>
     StatsFile("stats-file", cl::desc("Filename to write statistics to"));
 
 static cl::list<std::string>
     PassPlugins("load-pass-plugin",
                 cl::desc("Load passes from plugin library"));
 
+static cl::opt<std::string> UnifiedLTOMode("lto", cl::Optional,
+                                           cl::desc("Set LTO mode"),
+                                           cl::value_desc("mode"));
+
 static cl::opt<bool> EnableFreestanding(
     "lto-freestanding",
     cl::desc("Enable Freestanding (disable builtins / TLI) during LTO"),
     cl::init(false), cl::Hidden);
 
 static void check(Error E, std::string Msg) {
   if (!E)
     return;
static int run(int argc, char **argv) {
   Conf.DiagHandler = [&](const DiagnosticInfo &DI) {
     DiagnosticPrinterRawOStream DP(errs());
     DI.print(DP);
     errs() << '\n';
     if (DI.getSeverity() == DS_Error)
       HasErrors = true;
   };
 
-  LTO Lto(std::move(Conf), std::move(Backend));
+  LTO::LTOKind LTOMode = LTO::LTOK_Default;
+
+  if (UnifiedLTOMode == "full") {
+    LTOMode = LTO::LTOK_UnifiedRegular;
+  } else if (UnifiedLTOMode == "thin") {
+    LTOMode = LTO::LTOK_UnifiedThin;
+  } else if (!UnifiedLTOMode.empty()) {
+    llvm::errs() << "invalid LTO mode\n";
+    return 1;
+  }
+
+
+  Conf.UnifiedLTO = (LTOMode != LTO::LTOK_Default);
+  Conf.PTO.CallGraphProfile = !Conf.UnifiedLTO;
+
+  LTO Lto(std::move(Conf), std::move(Backend), 1, LTOMode);
 
   for (std::string F : InputFilenames) {
     std::unique_ptr<MemoryBuffer> MB = check(MemoryBuffer::getFile(F), F);
     std::unique_ptr<InputFile> Input =
         check(InputFile::create(MB->getMemBufferRef()), F);
 
     std::vector<SymbolResolution> Res;
     for (const InputFile::Symbol &Sym : Input->symbols()) {

llvm/tools/opt/NewPMDriver.h

bool runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
                      TargetLibraryInfoImpl *TLII, ToolOutputFile *Out,
                      ToolOutputFile *ThinLinkOut, ToolOutputFile *OptRemarkFile,
                      StringRef PassPipeline, ArrayRef<StringRef> PassInfos,
                      ArrayRef<PassPlugin> PassPlugins, opt_tool::OutputKind OK,
                      opt_tool::VerifierKind VK,
                      bool ShouldPreserveAssemblyUseListOrder,
                      bool ShouldPreserveBitcodeUseListOrder,
                      bool EmitSummaryIndex, bool EmitModuleHash,
-                     bool EnableDebugify);
+                     bool EnableDebugify, bool UnifiedLTO = false);
 } // namespace llvm
 
 #endif

llvm/tools/opt/NewPMDriver.cpp

bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
                            ToolOutputFile *ThinLTOLinkOut,
                            ToolOutputFile *OptRemarkFile,
                            StringRef PassPipeline, ArrayRef<StringRef> Passes,
                            ArrayRef<PassPlugin> PassPlugins,
                            OutputKind OK, VerifierKind VK,
                            bool ShouldPreserveAssemblyUseListOrder,
                            bool ShouldPreserveBitcodeUseListOrder,
                            bool EmitSummaryIndex, bool EmitModuleHash,
-                           bool EnableDebugify) {
+                           bool EnableDebugify, bool UnifiedLTO) {
   bool VerifyEachPass = VK == VK_VerifyEachPass;
 
   Optional<PGOOptions> P;
   switch (PGOKindFlag) {
   case InstrGen:
     P = PGOOptions(ProfileFile, "", "", PGOOptions::IRInstr);
     break;
   case InstrUse:
bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
   if (DebugifyEach)
     Debugify.registerCallbacks(PIC);
 
   PipelineTuningOptions PTO;
   // LoopUnrolling defaults on to true and DisableLoopUnrolling is initialized
   // to false above so we shouldn't necessarily need to check whether or not the
   // option has been enabled.
   PTO.LoopUnrolling = !DisableLoopUnrolling;
+  PTO.UnifiedLTO = UnifiedLTO;
   PassBuilder PB(TM, PTO, P, &PIC);
   registerEPCallbacks(PB);
 
   // For any loaded plugins, let them register pass builder callbacks.
   for (auto &PassPlugin : PassPlugins)
     PassPlugin.registerPassBuilderCallbacks(PB);
 
   PB.registerPipelineParsingCallback(
MPM.addPass(
         PrintModulePass(Out->os(), "", ShouldPreserveAssemblyUseListOrder));
     break;
   case OK_OutputBitcode:
     MPM.addPass(BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder,
                                   EmitSummaryIndex, EmitModuleHash));
     break;
   case OK_OutputThinLTOBitcode:
     MPM.addPass(ThinLTOBitcodeWriterPass(
-        Out->os(), ThinLTOLinkOut ? &ThinLTOLinkOut->os() : nullptr));
+        Out->os(), ThinLTOLinkOut ? &ThinLTOLinkOut->os() : nullptr,
+        /*UseDistinctLTOPipelines=*/ !UnifiedLTO));
     break;
   }
 
   // Before executing passes, print the final values of the LLVM options.
   cl::PrintOptionValues();
 
   // Print a textual, '-passes=' compatible, representation of pipeline if
   // requested.

llvm/tools/opt/opt.cpp

 static cl::opt<bool>
     OutputThinLTOBC("thinlto-bc",
                     cl::desc("Write output as ThinLTO-ready bitcode"));
 
 static cl::opt<bool>
     SplitLTOUnit("thinlto-split-lto-unit",
                  cl::desc("Enable splitting of a ThinLTO LTOUnit"));
 
+static cl::opt<bool>
+    UnifiedLTO("unified-lto",
+                            cl::desc("Use unified LTO piplines"),
+                            cl::Hidden, cl::init(false));
+
 static cl::opt<std::string> ThinLinkBitcodeFile(
     "thin-link-bitcode-file", cl::value_desc("filename"),
     cl::desc(
         "A file in which to write minimized bitcode for the thin link only"));
 
 static cl::opt<bool>
 NoVerify("disable-verify", cl::desc("Do not run the verifier"), cl::Hidden);
 
#endif
 
   // If the output is set to be emitted to standard out, and standard out is a
   // console, print out a warning message and refuse to do it.  We don't
   // impress anyone by spewing tons of binary goo to a terminal.
   if (!Force && !NoOutput && !OutputAssembly)
     if (CheckBitcodeOutputToConsole(Out->os()))
       NoOutput = true;
 
-  if (OutputThinLTOBC)
+  if (OutputThinLTOBC) {
     M->addModuleFlag(Module::Error, "EnableSplitLTOUnit", SplitLTOUnit);
+    if (UnifiedLTO)
+      M->addModuleFlag(Module::Error, "UnifiedLTO", 1);
+  }
 
   // Add an appropriate TargetLibraryInfo pass for the module's triple.
   TargetLibraryInfoImpl TLII(ModuleTriple);
 
   // The -disable-simplify-libcalls flag actually disables all builtin optzns.
   if (DisableSimplifyLibCalls)
     TLII.disableAllFunctions();
   else {
if (UseNPM) {
 
     // The user has asked to use the new pass manager and provided a pipeline
     // string. Hand off the rest of the functionality to the new code for that
     // layer.
     return runPassPipeline(argv[0], *M, TM.get(), &TLII, Out.get(),
                            ThinLinkOut.get(), RemarksFile.get(), Pipeline,
                            Passes, PluginList, OK, VK, PreserveAssemblyUseListOrder,
                            PreserveBitcodeUseListOrder, EmitSummaryIndex,
-                           EmitModuleHash, EnableDebugify)
+                           EmitModuleHash, EnableDebugify, UnifiedLTO)
                ? 0
                : 1;
   }
 
   // Create a PassManager to hold and optimize the collection of passes we are
   // about to build. If the -debugify-each option is set, wrap each pass with
   // the (-check)-debugify passes.
   DebugifyCustomPassManager Passes;
if (ShouldEmitOutput || RunTwice) {
     if (OutputAssembly) {
       if (EmitSummaryIndex)
         report_fatal_error("Text output is incompatible with -module-summary");
       if (EmitModuleHash)
         report_fatal_error("Text output is incompatible with -module-hash");
       Passes.add(createPrintModulePass(*OS, "", PreserveAssemblyUseListOrder));
     } else if (OutputThinLTOBC)
       Passes.add(createWriteThinLTOBitcodePass(
-          *OS, ThinLinkOut ? &ThinLinkOut->os() : nullptr));
+          *OS, ThinLinkOut ? &ThinLinkOut->os() : nullptr,
+          /*UnifiedLTO=*/ UnifiedLTO));
     else
       Passes.add(createBitcodeWriterPass(*OS, PreserveBitcodeUseListOrder,
                                          EmitSummaryIndex, EmitModuleHash));
   }
 
   // Before executing passes, print the final values of the LLVM options.
   cl::PrintOptionValues();