libLTO: add a ThinLTOCodeGenerator on the model of LTOCodeGenerator.

[mehdi_amini]

Summary

This is intended to provide a parallel (threaded) ThinLTO scheme
for linker plugin use through the libLTO C API.

[mehdi_amini]

(Remove empty line change)

[tejohnson]

Did an initial pass through, some comments and questions below.

include/llvm-c/lto.h

562

Wraps a single returned object file? (Comment for this and following structure are currently identical)

585

Why "prior to" here and other places?

624

Document return type?

include/llvm/LTO/ThinLTOCodeGenerator.h

53

do you mean "If a symbol is not listed there, it will be optimized away if it is inlined into every usage"?

83

Doxygen comments on these and other members as well?

lib/LTO/ThinLTOCodeGenerator.cpp

65

No, should not be lazy. That is just for reading the combined index.

176

Why don't we want to set an opt level?

249

This case was already handled above.

298

So the linker must place any external symbols with references from other modules in this set, right? I see that you added a comment that suggest that to the thinlto_codegen_add_must_preserve_symbol interface. Might want to add something to that effect here as well.

tools/llvm-lto/llvm-lto.cpp

279

Is this temporary?

291

Why are all these commented out?

tools/lto/lto.cpp

282

Why the FIXME?

[mehdi_amini]

Thanks for the review, I'll fix all of what you found :)

include/llvm-c/lto.h

562

Yes this is a single object, I'll update the comment.

585

"prior to" is an unfortunate copy/paste, I'll remove.

624

I'll add.

include/llvm/LTO/ThinLTOCodeGenerator.h

53

Basically I expect the linker to tell me the list of symbols for which there is a reference from *outside* the ThinLTO modules.

83

Sure!

lib/LTO/ThinLTOCodeGenerator.cpp

65

OK

176

Not sure, we don't have a linker flag to do that, with current full LTO there is none either I think. Maybe passing -mllvm -O3 can have an impact? (I think the -mllvm are supposed to be "debug" flags though)

This is something we'd like to figure out but not completely sure what is the best way (the front-end could encode this information in the bitcode for example).

249

Good catch :)

298

Any symbols with reference from other *non thinlto* modules to be exact.
I'll add a comment here.

tools/llvm-lto/llvm-lto.cpp

279

Yes! Will clean up

291

Some debug code left over, I'll clean it up.

tools/lto/lto.cpp

282

Oh this API should just be removed.
(Early stage of prototyping I was expecting the linker to tell me the exported/preserved symbols *for each individual files*, but I could see any benefit from it later so I reverted to a global list).

[tejohnson]

lib/LTO/ThinLTOCodeGenerator.cpp

298

So an external symbol with a reference from another thinlto module would not be in this set and would be internalized? I realize that you are remembering the original linkage and later setting it back. But what happens in the mean time with the internalize and globalDCE passes? Couldn't they cause one of the symbols referenced from another thinlto module to be internalized and then eliminated, since you don't see those references here?

[mehdi_amini]

lib/LTO/ThinLTOCodeGenerator.cpp

298

You're right!
What has to be inside are functions that are cross-referenced as well.
I was confused because I move the set of preserved symbols from "per module" to be on the code generator (i.e. one for all), but it is the union of the individual sets (if they still existed).

[mehdi_amini]

Update following Teresa's comment

[mehdi_amini]

Cleanup!

[mehdi_amini]

All comments should be addressed!

[mehdi_amini]

More cleanup and a bugfix: cannot run globalopt too early because it breaks ThinLTO.

The issue is that globalopt (after internalize) may turning (former) globals into "unnamed address".
However this happens when optimizing the module, not when the module is used for importing in other modules. The global will be imported as available externally in these modules but won't be available in the source module because the "unamed address".

[tejohnson]

Mostly comment typo and wording suggestions

include/llvm-c/lto.h

580

"Frees the code generator..."

589

typo s/stay/stays/

599

Inconsistent capitalization. Some parameters here and in other interfaces are lower case, some here and other places start with upper case.

613

s/match/matches/

614

maybe "and in future implementations may change" or "and may change in future implementations"

651

Maybe "The intention is to make the bitcode files available for debugging after..."

include/llvm/LTO/ThinLTOCodeGenerator.h

12

s/provide/provides/

45

s/provide/provides/

55

Think this comment is clearer if the last sentence changed to "If a symbol is not listed there, it will be optimized away if it is inlined into every usage."

lib/LTO/ThinLTOCodeGenerator.cpp

150

s/let/let's/ or s/let/so/

151

This will be hard to correlate with the original file. How about using some part of the source file name saved in the module here and in the later opt.bc dump? I.e. use the base name of the path returned by getSourceFileName(), but still add in 'count' to avoid conflicts when the same file name is used at multiple paths.

209

s/let/let's/ or s/let/so/

227

s/possible/possibly/

483

Do we expect to reuse the same code generator multiple times?

[mehdi_amini]

Update with a good candidate to be integrated as a first Proof-of-concept.

I am able to link every target in clang/llvm with this implementation.

Beyong the actual implementation of the CodeGenerator, I am especially interested to
"lock-down" the libLTO API so that we can start to have linker support for it.

[tejohnson]

Some misc comments below.

include/llvm-c/lto.h

666

What is the default?

include/llvm/LTO/ThinLTOCodeGenerator.h

2

Fix file name.

47

How do PruningInterval and Expiration interact? Are they mutually exclusive, or does a module get pruned at the min of these?

100

s/controling/controlling/

lib/LTO/ThinLTOCodeGenerator.cpp

66

Why not lazy load metadata too?

85

Include Module's SourceFileName to get more meaningful dump file names?

97

This is doing more than internalization, so name should probably be adjusted to reflect that. I don't have a good name off the top of my head. Maybe split into 2 and call the first something like resolveLinkOnceAndWeak, and if that returns false then invoke the internalization handling (maybe outline keepIfPreserved and make it return a bool).

105

Should available_externally also be kept in SingleModule mode?

113

I'm confused by the comment. It is already local if private, so no need to internalize or add to Keep, which is consistent with what the code is doing. I just don't understand what the comment about being restrictive is saying.

161

Combine the LinkOnce cases and just pick the appropriate Weak linkage based on the LinkOnce linkage, the handling is identical otherwise.

181

Combine the Weak* cases, the handling is identical.

212

This is doing more than internalization. How about a more generic name such as LinkageOptimization or something like that?

272

This handling is already outlined in the other InternalizeModule() function, invoke here.

318

Does this need to be guarded by lock? Comments for LockM indicate it is just to guard optimization.

330

Why don't we want to do this when there are no preserved or cross referenced symbols? Couldn't the internalization be even more aggressive in that case? Also, wouldn't we at least want the linkonce/weak handling?

344

Needs doxygen class description. Is "EarlyOptimizedModuleMap" more accurate though?

346

When would this not be the case?

353

Out of curiosity, why a StringMap for ModuleMap and an unordered_map from string here? They are both index by the identifier string.

411

crossImportIntoModule?

593

Doesn't instantiating here mean that the map isn't leveraged across threads? Oh, I see that this routine and the above promote() are only invoked from llvm-lto. Is there a reason why llvm-lto doesn't use ThinLTOCodeGenerator::run()?

[mehdi_amini]

Adding Sergei as a reviewer as he expressed interest in the past.

lib/LTO/ThinLTOCodeGenerator.cpp

151

The problem is that with static library, the name is funky. We need to replace parentheses and other special character with something like underscore.

[ygao]

include/llvm-c/lto.h

699

This, and the two functions that ensue, may also need to say LTO_API_VERSION=18?
I think it is more natural to say "a list of global symbols" than "a list of all global symbols", but English is not my first language.

lib/LTO/ThinLTOCodeGenerator.cpp

2

This is probably copied from LTOCodeGenerator.cpp. Can you confirm that the summary line is accurate?

45

Do you need unordered_set here? I did not see unordered_set being used in this file.

[mehdi_amini]

Thanks Gao!

include/llvm-c/lto.h

699

Good catch. Will fix (both).

lib/LTO/ThinLTOCodeGenerator.cpp

45

It used in a more elaborate version of this code that I have locally, but not needed here. Will remove.

[bruno]

Hi Mehdi,

lib/LTO/ThinLTOCodeGenerator.cpp

427

Although not really necessary for this patch, it would be nice to have the flags to disable the inliner and vectorizer like we currently have in full LTO. This is specially useful when investigating differences between full and thin.

[mehdi_amini]

Thanks Teresa for the review. See answers inlined.

include/llvm-c/lto.h

666

No guarantee provided by the API :)

include/llvm/LTO/ThinLTOCodeGenerator.h

47

PruningInterval controls the interval between two check on the cache: i.e. if you set 2h the plugin will not bother checking for cache invalidation for the next two hours.
Cache Expiration is per entry: when pruning you are deleting the entries older than this value.
I documented getter/setter, not enough?

lib/LTO/ThinLTOCodeGenerator.cpp

2

It is not very helpful, but matches LTOCodeGenerator indeed.

66

Aren't they almost immediately materialized anyway? I thought that laziness would have a cost for no real benefit maybe?
(I didn't see a change on the memory profile when lazy loading or not)

85

SourceFileName can fit! Good point.

97

I remove the internalization phase from this patch for now. This will change a lot with the graph in the summary.

105

Good point. Dunno.

113

This is copy/pasted from LTOCodeGenerator::applyRestriction. I read it as "don't need to do anything thing you won't internalize any more something already private"

161

OK, I'll keep this for a future version of the patch, I removed the internalize for now.

318

You need to block "reader" of OptimizedBuffer in case there is already a writer populating it.
(in case of contention on the lock with too many reader there would be a possible mitigation with atomic flags for a fast-path, but not worth it here I think)

330

No preserved or cross referenced symbols means that you will internalize *everything* and then global DCE will remove *everything*. This is of little interest. So I just considered that empty() means the linker didn't provide any information at all. It helps implementing testing with llvm-lto as well.

346

The buffers identifier are supplied by the linker and can be anything:

extern void thinlto_codegen_add_module(thinlto_code_gen_t cg,
                                       const char *identifier, const char *data,
                                       int length);

353

Here there is no good reason I think. I think that StringMap will allocate the entry with the key, so you want a value that is quite small (for rehashing / growing the map).

427

Good point, will update to try using a set of flags as close as possible the LTOCodeGenerator

593

The reason llvm-lto does not use run() is to test steps in isolation.

[mehdi_amini]

Update: taking into account most comments, and removing the internalize phase as it will be very different with the summary-based importing coming next.

[tejohnson]

include/llvm-c/lto.h

668

Is the max cache size set via the space that was available at the start of the compilation, or is the threshold updated so that if something else comes along and eats up some disk space the allowable max cache size is adjusted downward?

include/llvm/LTO/ThinLTOCodeGenerator.h

48

It just wasn't clear how they interact, although your explanation was what I guessed. Maybe for the thinlto_codegen_set_cache_entry_expiration interface add that the module may be removed earlier due to the pruning interval.

lib/LTO/LTOModule.cpp

85

Also for future consider caching value unless it is expected to be called only once per module.

lib/LTO/ThinLTOCodeGenerator.cpp

67

The when lazy metadata linking is enabled, metadata parsing should be postponed until we actually go to do the import and linkInModule during the bulk importing. Since the source module is destroyed at the end of linkInModule, this should reduce the max amount of live metadata to one module at a time, rather than all modules we are importing from. I'm surprised it didn't reduce the max memory usage in a debug build.

If we ever go back to post-pass metadata linking in the function importer (i.e. if we decide to do iterative importing rather than a single bulk import from each module), this will become more critical. However, if we move to summary-only importing decisions it will obviate the need to do this.

Until we go to summary only import decisions, I would think it should reduce the max memory usage as per my first paragraph. Did you see a cost going with lazy metadata loading?

86

Is this a TODO? If so, please add TODO comment.

110

Add doxygyen comment describing ModuleMap.

114

Ok. When you put this support back in your description above ("don't need to do anything thing you won't internalize any more something already private") is better than the comment about restriction.

331

Ok, but I think you still want the linkonce/weak linkage changes? When you put this back this is more reason to split the internalization and linkonce/weak linkage changes into two routines and only invoke the latter if the sets are empty.

359

What is the difference between this ModuleBuffer and the one loaded out of the ModuleMap in the below call to loadModuleFromBuffer? If they are the same, can loadModuleFromBuffer be called a single time and the resulting module optionally saved after?

379

Unfortunately this means that ThinLTOCodeGenerator::run() is currently untested. Consider adding a mode to llvm-lto that does all thinlto steps (thin-action=all?) to test all the steps via this interface.

tools/llvm-lto/llvm-lto.cpp

85

Actual option below is "functionindex". But per the ref graph patch, this is broader than a function index, so I am looking at changing references to function index to something else anyway. So I would suggest changing the actual option below to "thinlto-index".

272

What if there is more than one occurrence?

339

s/mentionned/mentioned/ (here and below for import()).

351

Adding all the modules isn't needed for promotion. Should be able to remove this loop.

376

There is a lot of code duplication between these various functions, consider refactoring possibly in a follow-on patch.

392

Why is the import() step a superset of promote and import, whereas the other steps (e.g. optimize()) only doing one thing?

406

Untested.

[mehdi_amini]

include/llvm-c/lto.h

668

Mmmm, this is yet to be implemented.
I'd say it applies to what we store on disk when the linker is *not running*. I.e. during the link you are allowed to use extra space without any limit.

include/llvm/LTO/ThinLTOCodeGenerator.h

48

Now I'm unsure it was clear enough, because you wrote " the module may be removed earlier due to the pruning interval". A cache entry *can't* be remove earlier. The pruning interval means that will only *check* the entries.

lib/LTO/ThinLTOCodeGenerator.cpp

86

Will do.

110

Will do.

331

Good point.

(I expect this to come back with a very different summary-based implementation)

359

Good point, this is legacy from when there was all the internalization stage, will cleanup!

379

OK.

tools/llvm-lto/llvm-lto.cpp

272

I'll add a check and error.

351

It isn't needed... for now ;)
I wrote this code against my prototype of summary-based importing where the promotion is driven by what the other modules export.
(I'll remove for now).

376

OK

392

Same reason as above: when I wrote it against the pure summary-based importing, it was needed/helpful. I'll remove for now.

406

Any suggestion on how to test that? This is basically like testing opt -O3?

[tejohnson]

include/llvm-c/lto.h

668

I don't really understand what you mean by this, particularly the last sentence about using extra space during the link without any limit. Isn't this set/used during the link (which is running the ThinLTO steps in process)?

include/llvm/LTO/ThinLTOCodeGenerator.h

48

Ah, so a clarifying comment would help then since I misunderstood. It sounds like the modules will be checked for expiration (and pruned from the cache) at the pruning interval. So with the default pruning interval of -1, the expiration is unused? I took these to be separate, complimentary, mechanisms for keeping the cache size down. Another option beyond just documenting the interactions well is to combine these parameters into a single interface that takes both the pruning interval and the expiration.

tools/llvm-lto/llvm-lto.cpp

406

Not sure, maybe just invoke this stage in your test after the importing action to make sure it succeeds (without necessarily checking for any specific optimization)?

[slarin]

Sorry for the late entry... Some of my questions could have been already answered.

include/llvm-c/lto.h

736

Does this handles commons properly?

include/llvm/LTO/ThinLTOCodeGenerator.h

149

Can we theoretically have a mixture of opt levels? -O2/-Os? Should I be able to respect per library opt level?

lib/LTO/ThinLTOCodeGenerator.cpp

68

I do not know if it is relevant at this point, but for what it worth - my IR might have metadata that changes opt/codegen.

82

Default to /tmp?

141

Yes! ...and default should probably be O2...

145

So I assume I should be able to control all of those...

185

Sorry, I miss something - why is this unconditional?

364

In general - don't you want to verify modules as they progress through the stages? I do it in regular LTO and it did help on more than one occasion :)

379

+1 on Teresa's point about llvm-lto.

tools/llvm-lto/llvm-lto.cpp

420

Verify TheModule?

[mehdi_amini]

Thanks for all the comments!
(Please see inline for the discussion)

include/llvm-c/lto.h

736

Can you be more specific? I'm not sure what is specific with common on this aspect?

include/llvm/LTO/ThinLTOCodeGenerator.h

149

Ideally I think we'd want this parameter to be recorded in the bitcode itself, what do you think?
Right now we don't even expose any linker flag for that.

Here it is about the *codegen* opt level though, it won't impact the optimizer.

lib/LTO/ThinLTOCodeGenerator.cpp

68

slarin: how does it play with cross-module importing? If a function is defined in a module compiled with O3 but imported in a module compiled with O2?

82

The way the client is enabling dumping temporaries is by providing a path.
Having a default would mean either always dumping temporaries (we don't want that...) or having a more complicated way of enabling dumping.

145

Yes, but we don't have an interface for these as of today. A serialization of the PMB options in the bitcode would help.

185

As mentioned above, this is conditional in the saveTempBitcode function itself, which starts with

if (SaveTempsDir.empty()) return;

makes sense?

364

We'll always verify the module once at the beginning of the optimizer pipeline, but I guess we could do it more frequently in assert builds.

tools/llvm-lto/llvm-lto.cpp

85

Will do.

420

This is done in optimized()

(see line 143 in ThinLTOCodeGenerator.cpp PMB.VerifyInput = true;)

[slarin]

include/llvm-c/lto.h

736

I probably not fully understand how this list should work... but this is not the proper place to figure it out - please ignore this comment for now.

include/llvm/LTO/ThinLTOCodeGenerator.h

149

Ideally I think we'd want this parameter to be recorded in the bitcode itself, what do you think?

Yes. Certainly.

it is about the *codegen*

...yes. My target has codegen properties that are exposed to a user, which might produce drastically different results if not set properly, but once again, ideally it should come from bitcode.

lib/LTO/ThinLTOCodeGenerator.cpp

68

If I know settings for each module I can handle these situations in platform specific way. Besides rough optimization levels I have different addressing modes used in different modules, and I might chose not to mix certain features at all... At this point my main concern seems to be revolving around general LTO issues (like mixing different optimization scopes into one) and might not be "thin"-lto specific. We had to jump through hoops for regular LTO, and I see very similar set of issues being designed in here as well...

82

I see...

185

Totally

[mehdi_amini]

Taking comment into account

[mehdi_amini]

Thanks for the great review. Hopefully I didn't forget anything with this update.

include/llvm/LTO/ThinLTOCodeGenerator.h

48

Tried to make the doc very explicit, let me know what you think.

lib/LTO/LTOModule.cpp

85

It is supposed to be called once indeed. I think we can update the implementation in the future if needed.

lib/LTO/ThinLTOCodeGenerator.cpp

67

So just tested:

With lazy loading of metadata: getLazyBitcodeModule takes 237ms and materializeMetadata takes 74ms (total 314ms)
without lazy loading of metadata: getLazyBitcodeModule takes 316ms

So no perf diff.

I probably don't see any diff on the memory because most metadata will leak to the context and being free'd with the Module. So there is no real impact on the peak memory (just delaying a little bit).

379

Done, it was valuable :)

[tejohnson]

Thanks for adding the description! I do think that the formula for the new cache size is not right, see suggested fix below.

A couple misc comment typos, but LGTM once these the above is addressed.

include/llvm-c/lto.h

687

s/term/terms/

690

"left over half the available space"? (i.e. add "half") Either that or "left over the free space" (since AvailableSpace = FreeSpace + CacheSize)?

694

This doesn't seem right. I think P should be divided by 100 and not multiplied by it, since it is a percentage. And I think the percentage needs to be multiplied by something, not divided by AvailableSpace?

Should this be:
NewCacheSize = AvailableSpace * P/100

since it is described as the percentage of available space used for the cache.

For this and the above suggestion, any change needs to be replicated below in ThinLTOCodeGenerator.h.

include/llvm/LTO/ThinLTOCodeGenerator.h

105

move 'an' to next line.

lib/LTO/ThinLTOCodeGenerator.cpp

67

Ok, thanks for checking!

[mehdi_amini]

r262977

include/llvm-c/lto.h

 
 /**
  * @defgroup LLVMCLTO LTO
  * @ingroup LLVMC
  *
  * @{
  */
 
-#define LTO_API_VERSION 17
+#define LTO_API_VERSION 18
 
 /**
  * \since prior to LTO_API_VERSION=3
  */
 typedef enum {
     LTO_SYMBOL_ALIGNMENT_MASK              = 0x0000001F, /* log2 of alignment */
     LTO_SYMBOL_PERMISSIONS_MASK            = 0x000000E0,
     LTO_SYMBOL_PERMISSIONS_CODE            = 0x000000A0,

 } lto_codegen_model;
 
 /** opaque reference to a loaded object module */
 typedef struct LLVMOpaqueLTOModule *lto_module_t;
 
 /** opaque reference to a code generator */
 typedef struct LLVMOpaqueLTOCodeGenerator *lto_code_gen_t;
 
+/** opaque reference to a thin code generator */
+typedef struct LLVMOpaqueThinLTOCodeGenerator *thinlto_code_gen_t;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**
  * Returns a printable string.
  *
  * \since prior to LTO_API_VERSION=3

 /**
  * Sets triple string with which the object will be codegened.
  *
  * \since LTO_API_VERSION=4
  */
 extern void
 lto_module_set_target_triple(lto_module_t mod, const char *triple);
 
-
 /**
  * Returns the number of symbols in the object module.
  *
  * \since prior to LTO_API_VERSION=3
  */
 extern unsigned int
 lto_module_get_num_symbols(lto_module_t mod);
 

  * output bitcode.  This should be turned on for all -save-temps output.
  *
  * \since LTO_API_VERSION=15
  */
 extern void
 lto_codegen_set_should_embed_uselists(lto_code_gen_t cg,
                                       lto_bool_t ShouldEmbedUselists);
 
+/**
+ * @}
+ * @defgroup LLVMCLTO ThinLTO
+ * @ingroup LLVMC
+ *
+ * @{
+ */
+
+/**
+ * Type to wrap returned objects to the linker for ThinLTO.
+ *
+ * \since LTO_API_VERSION=18
+ */
+typedef struct {
+  void *Buffer;
+  size_t Size;
+} LTOObjectBuffer;
+
+/**
+ * Type to wrap returned objects to the linker for ThinLTO.
+ *
+ * \since LTO_API_VERSION=18
+ */
+typedef struct {
+  LTOObjectBuffer *Objects;
+  size_t Size;
+} LTOObjectBuffers;
+
+/**
+ * Instantiates a ThinLTO code generator.
+ * Returns NULL on error (check lto_get_error_message() for details).
+ *
+ * \since prior to LTO_API_VERSION=18
+ */
+thinlto_code_gen_t thinlto_create_codegen();
+
+/**
+ * Add a module to a ThinLTO code generator. Identifier has to be unique among
+ * all the modules in a code generator.
+ *
+ * \since prior to LTO_API_VERSION=18
+ */
+void thinlto_codegen_add_module(thinlto_code_gen_t cg, const char *Identifier,
+                                const char *Data, int Length);
+
+/**
+ * Sets which PIC code model to generate.
+ * Returns true on error (check lto_get_error_message() for details).
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern lto_bool_t thinlto_codegen_set_pic_model(thinlto_code_gen_t cg,
+                                                lto_codegen_model);
+
+/**
+ * Sets the path to a directory to use as a cache storage for incremental build.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_set_cache_dir(thinlto_code_gen_t cg,
+                                          const char *cache_dir);
+
+/**
+ * Sets the cpu to generate code for.
+ *
+ * \since LTO_API_VERSION=18
+ */
+extern void thinlto_codegen_set_cpu(thinlto_code_gen_t cg, const char *cpu);
+
+/**
+ * Optimize and codegen all the modules added to the codegenerator using
+ * ThinLTO.
+ *
+ * \since prior to LTO_API_VERSION=18
+ */
+LTOObjectBuffers thinlto_codegen_process(thinlto_code_gen_t cg);
+
+/**
+ * Parse -mllvm style debug options.
+ *
+ * \since prior to LTO_API_VERSION=18
+ */
+void thinlto_debug_options(const char *const *options, int number);
+
+/**
+ * Test if a module was produced for ThinLTO linking.
+ */
+bool lto_module_is_thinlto(lto_module_t mod);
+
+/**
+ * Adds to a list of all global symbols that must exist in the final generated
+ * code. If a function is not listed there, it might be inlined into every usage
+ * and optimized away.
+ */
+void thinlto_codegen_add_must_preserve_symbol(thinlto_code_gen_t cg,
+                                              const char *Name, int Length);
+
 #ifdef __cplusplus
 }
 #endif
 
 /**
  * @}
  */
 
 #endif

include/llvm/LTO/LTOModule.h

 
 public:
   ~LTOModule();
 
   /// Returns 'true' if the file or memory contents is LLVM bitcode.
   static bool isBitcodeFile(const void *mem, size_t length);
   static bool isBitcodeFile(const char *path);
 
+  /// Returns 'true' if the Module is produced for ThinLTO.
+  bool isThinLTO();
+
   /// Returns 'true' if the memory buffer is LLVM bitcode for the specified
   /// triple.
   static bool isBitcodeForTarget(MemoryBuffer *memBuffer,
                                  StringRef triplePrefix);
 
   /// Returns a string representing the producer identification stored in the
   /// bitcode, or "" if the bitcode does not contains any.
   ///

include/llvm/LTO/ThinLTOCodeGenerator.h

+//===-LTOCodeGenerator.h - LLVM Link Time Optimizer -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the ThinLTOCodeGenerator class, similar to the
+// LTOCodeGenerator but for the ThinLTO scheme. It provide an interface for
+// linker plugin.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LTO_THINLTOCODEGENERATOR_H
+#define LLVM_LTO_THINLTOCODEGENERATOR_H
+
+#include "llvm-c/lto.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Target/TargetOptions.h"
+
+#include <string>
+
+namespace llvm {
+class TargetMachine;
+
+/// Helper to gather options relevant to the target machine creation
+struct TargetMachineBuilder {
+  Triple TheTriple;
+  std::string MCpu;
+  std::string MAttr;
+  TargetOptions Options;
+  Reloc::Model RelocModel = Reloc::Default;
+  CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
+
+  std::unique_ptr<TargetMachine> create() const;
+};
+
+class ThinLTOCodeGenerator {
+public:
+  /// Add given module.
+  void addModule(StringRef Identifier, StringRef Data);
+
+  /**
+   * Adds to a list of all global symbols that must exist in the final generated
+   * code. If a symbol is not listed there, it might be inlined into every usage
+   * and optimized away.
+   */
+  void preserveSymbol(StringRef Name);
+
+  /**
+   * Process all the modules that were added to the code generator in parallel.
+   * \return a LTOObjectBuffers structure that contains the object files in
+   * memory.
+   */
+  LTOObjectBuffers run();
+
+  // Option setters
+  void setCacheDir(std::string Path) { CacheDir = std::move(Path); }
+  void setCpu(std::string Cpu) { TMBuilder.MCpu = std::move(Cpu); }
+  void setAttr(std::string MAttr) { TMBuilder.MAttr = std::move(MAttr); }
+  void setTargetOptions(TargetOptions Options) {
+    TMBuilder.Options = std::move(Options);
+  }
+  void setCodePICModel(Reloc::Model Model) { TMBuilder.RelocModel = Model; }
+  void setCodeGenOptLevel(CodeGenOpt::Level CGOptLevel) {
+    TMBuilder.CGOptLevel = CGOptLevel;
+  }
+
+private:
+  void setTriple(Triple TheTriple) {
+    TMBuilder.TheTriple = std::move(TheTriple);
+  }
+  TargetMachineBuilder TMBuilder;
+
+  std::vector<MemoryBufferRef> Modules;
+  StringSet<> PreservedSymbols;
+  /// Cache for incremental build.
+  std::string CacheDir;
+};
+}
+#endif

lib/LTO/CMakeLists.txt

 add_llvm_library(LLVMLTO
   LTOModule.cpp
   LTOCodeGenerator.cpp
+  ThinLTOCodeGenerator.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/LTO
   )
 
 add_dependencies(LLVMLTO intrinsics_gen)

lib/LTO/LTOModule.cpp

bool LTOModule::isBitcodeFile(const char *Path) {
   if (!BufferOrErr)
     return false;
 
   ErrorOr<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
       BufferOrErr.get()->getMemBufferRef());
   return bool(BCData);
 }
 
+bool LTOModule::isThinLTO() {
+  // Right now the detection is only based on the summary presence. We may want
+  // to add a dedicated flag at some point.
+  return hasFunctionSummary(IRFile->getMemoryBufferRef(),
+                            [](const DiagnosticInfo &DI) {
+                              DiagnosticPrinterRawOStream DP(errs());
+                              DI.print(DP);
+                              errs() << '\n';
+                              return;
+                            });
+}
+
 bool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer,
                                    StringRef TriplePrefix) {
   ErrorOr<MemoryBufferRef> BCOrErr =
       IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
   if (!BCOrErr)
     return false;
   LLVMContext Context;
   std::string Triple = getBitcodeTargetTriple(*BCOrErr, Context);

lib/LTO/ThinLTOCodeGenerator.cpp

+//===-ThinLTOCodeGenerator.cpp - LLVM Link Time Optimizer -----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the Thin Link Time Optimization library. This library is
+// intended to be used by linker to optimize code at link time.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/LTO/ThinLTOCodeGenerator.h"
+
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/Support/ThreadPool.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/Mangler.h"
+#include "llvm/IRReader/IRReader.h"
+#include "llvm/Linker/Linker.h"
+#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Object/FunctionIndexObjectFile.h"
+#include "llvm/Support/raw_sha1_ostream.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/IPO/FunctionImport.h"
+#include "llvm/Transforms/IPO/PassManagerBuilder.h"
+
+using namespace llvm;
+
+static void diagnosticHandler(const DiagnosticInfo &DI) {
+  DiagnosticPrinterRawOStream DP(errs());
+  DI.print(DP);
+  errs() << '\n';
+}
+
+static std::unique_ptr<Module> loadModuleFromBuffer(MemoryBufferRef &Buffer,
+                                                    LLVMContext &Context) {
+  SMDiagnostic Err;
+  auto Module = parseIR(Buffer, Err, Context);
+  if (!Module) {
+    Err.print("function-import", errs());
+    report_fatal_error("Can't load module, abort.");
+  }
+  return Module;
+}
+
+/// Produce the combined function index from all the bitcode files: "thin-link".
+static std::unique_ptr<FunctionInfoIndex>
+linkCombinedIndex(const std::vector<MemoryBufferRef> &Modules) {
+  std::unique_ptr<FunctionInfoIndex> CombinedIndex;
+  uint64_t NextModuleId = 0;
+  for (auto &ModuleBuffer : Modules) {
+    ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr =
+        object::FunctionIndexObjectFile::create(
+            ModuleBuffer, diagnosticHandler,
+            false); // FIXME Should it be lazy?
+    if (std::error_code EC = ObjOrErr.getError()) {
+      // FIXME diagnose
+      errs() << "error: can't create FunctionIndexObjectFile for buffer: "
+             << EC.message() << "\n";
+      return nullptr;
+    }
+    auto Index = (*ObjOrErr)->takeIndex();
+    if (CombinedIndex) {
+      CombinedIndex->mergeFrom(std::move(Index), ++NextModuleId);
+    } else {
+      CombinedIndex = std::move(Index);
+    }
+  }
+  return CombinedIndex;
+}
+
+namespace {
+
+/// Provide a "loader" for the FunctionImporter to access function from other
+/// modules.
+class ModuleLoader {
+  /// The context that will be used for importing.
+  LLVMContext &Context;
+
+  /// Map of Module Identifier to MemoryBuffer used to load a Module.
+  StringMap<MemoryBufferRef> &PathToModules;
+
+public:
+  ModuleLoader(LLVMContext &Context, StringMap<MemoryBufferRef> &PathToModules)
+      : Context(Context), PathToModules(PathToModules) {}
+
+  /// Load a module on demand.
+  std::unique_ptr<Module> operator()(StringRef Identifier) {
+    SMDiagnostic Err;
+    auto BufferRef = PathToModules.find(Identifier);
+    if (BufferRef == PathToModules.end()) {
+      report_fatal_error(
+          std::string("ThinLTO lazy load error, unknown Module:") + Identifier);
+    }
+    auto LazyModule =
+        getLazyIRModule(MemoryBuffer::getMemBuffer(BufferRef->second, false),
+                        Err, Context, /* ShouldLazyLoadMetadata */ false);
+    if (!LazyModule) {
+      Err.print("function-import", errs());
+      report_fatal_error("Can't load module, abort.");
+    }
+    return LazyModule;
+  }
+};
+
+static std::string toHex(StringRef Input) {
+  static const char *const LUT = "0123456789ABCDEF";
+  size_t Length = Input.size();
+
+  std::string Output;
+  Output.reserve(2 * Length);
+  for (size_t i = 0; i < Length; ++i) {
+    const unsigned char c = Input[i];
+    Output.push_back(LUT[c >> 4]);
+    Output.push_back(LUT[c & 15]);
+  }
+  return Output;
+}
+
+static LTOObjectBuffer ProcessThinLTOModule(
+    std::unique_ptr<Module> TheModule, const FunctionInfoIndex &Index,
+    StringMap<MemoryBufferRef> &PathToModules,
+    std::unique_ptr<TargetMachine> TM, const std::string &CacheDir) {
+  // Promote static to global
+  if (renameModuleForThinLTO(*TheModule, &Index)) {
+    report_fatal_error("renameModuleForThinLTO failed");
+  }
+
+  ModuleLoader Loader(TheModule->getContext(), PathToModules);
+  FunctionImporter Importer(Index, Loader);
+  Importer.importFunctions(*TheModule);
+
+  std::string CachedFilename;
+  if (!CacheDir.empty()) {
+    // Compute the hash of the IR
+    raw_sha1_ostream HashStream;
+    WriteBitcodeToFile(TheModule.get(), HashStream);
+    auto Hash = toHex(HashStream.sha1());
+
+    // Check if this IR has already an object file in the cache
+    sys::fs::file_status Status;
+    CachedFilename = (Twine(CacheDir) + "/" + Hash + ".o").str();
+    sys::fs::status(CachedFilename, Status);
+    if (sys::fs::exists(Status)) {
+      // Cache Hit!
+      auto FileLoaded =
+          MemoryBuffer::getFile(CachedFilename, Status.getSize(), false);
+      if (!FileLoaded) {
+        errs() << "ThinLTO: error opening the file '" << CachedFilename
+               << "': " << FileLoaded.getError().message() << "\n";
+        report_fatal_error("FAILURE");
+      }
+      auto MemBuffer = FileLoaded->release(); // Leak
+      return LTOObjectBuffer{(void *)MemBuffer->getBufferStart(),
+                             MemBuffer->getBufferSize()};
+    }
+    // Cache miss, move on
+  }
+
+  auto OutputBuffer = new SmallVector<char, 0>();
+  {
+    // Optimize and codegen
+    PassManagerBuilder PMB;
+    PMB.LibraryInfo = new TargetLibraryInfoImpl(TM->getTargetTriple());
+    PMB.Inliner = createFunctionInliningPass();
+    //  PMB.OptLevel = OptLevel;
+    PMB.VerifyInput = false;
+    PMB.VerifyOutput = false;
+    PMB.SLPVectorize = true;
+    legacy::PassManager PM;
+    PMB.populateLTOPassManager(PM);
+
+    raw_svector_ostream OS(*OutputBuffer);
+    if (TM->addPassesToEmitFile(PM, OS, TargetMachine::CGFT_ObjectFile,
+                                /* DisableVerify */ true))
+      report_fatal_error("Failed to setup codegen");
+
+    PM.run(*TheModule);
+  }
+
+  if (!CachedFilename.empty()) {
+    // Cache the Produced object file
+
+    // Write to a temporary to avoid race condition
+    SmallString<128> TempFilename;
+    int TempFD;
+    std::error_code EC =
+        sys::fs::createTemporaryFile("Thin", "tmp.o", TempFD, TempFilename);
+    if (EC) {
+      errs() << "Error: " << EC.message() << "\n";
+      report_fatal_error("ThinLTO: Can't get a temporary file");
+    }
+    {
+      raw_fd_ostream OS(TempFD, /* ShouldClose */ true);
+      OS << *OutputBuffer;
+    }
+    // Rename to final destination (hopefully race condition won't matter here)
+    sys::fs::rename(TempFilename, CachedFilename);
+  }
+
+  // we leak OutputBuffer... :(
+  return LTOObjectBuffer{OutputBuffer->begin(), OutputBuffer->size()};
+}
+
+/// Process a global adjusting its linkage, adding it to the "Keep" set if
+/// needed.
+/// \return true if the global will be internalized.
+static bool InternalizeGlobal(Module &TheModule, GlobalValue &GV,
+                              StringSet<> &Keep, const FunctionInfoIndex &Index,
+                              const StringSet<> &PreservedSymbols,
+                              bool IsFunction) {
+  Mangler Mang;
+  SmallString<128> Buffer;
+
+  if (GV.hasAvailableExternallyLinkage()) {
+    Keep.insert(GV.getName());
+    return false;
+  }
+  // There are no restrictions to apply to declarations.
+  if (GV.isDeclaration())
+    return false;
+
+  // There is nothing more restrictive than private linkage.
+  if (GV.hasPrivateLinkage())
+    return false;
+
+  auto IsFirstDefinition = [&](GlobalValue &GV) {
+    auto It = Index.findFunctionInfoList(GV.getName());
+    assert(It != Index.end());
+    return ((*It->second.begin())->functionSummary()->modulePath() ==
+            TheModule.getModuleIdentifier());
+  };
+
+  auto HasMultipleCopies = [&](GlobalValue &GV) {
+    return Index.findFunctionInfoList(GV.getName())->second.size() > 1;
+  };
+
+  auto Linkage = GV.getLinkage();
+  if (Linkage == GlobalValue::AvailableExternallyLinkage) {
+    Keep.insert(GV.getName());
+    return false;
+  }
+  if (Linkage == GlobalValue::LinkOnceAnyLinkage) {
+    // We need to emit only one of these, the first module will keep
+    // it, but turned into a weak while the others will drop it.
+    if (IsFunction && HasMultipleCopies(GV)) {
+      if (IsFirstDefinition(GV))
+        GV.setLinkage(GlobalValue::WeakAnyLinkage);
+      else
+        GV.setLinkage(GlobalValue::AvailableExternallyLinkage);
+    }
+    Keep.insert(GV.getName());
+    return false;
+  }
+  if (Linkage == GlobalValue::LinkOnceODRLinkage) {
+    // We need to emit only one of these, the first module will keep
+    // it, but turned into a weak while the others will drop it.
+    if (IsFunction && HasMultipleCopies(GV)) {
+      if (IsFirstDefinition(GV))
+        GV.setLinkage(GlobalValue::WeakODRLinkage);
+      else
+        GV.setLinkage(GlobalValue::AvailableExternallyLinkage);
+    }
+    Keep.insert(GV.getName());
+    return false;
+  }
+  if (Linkage == GlobalValue::WeakAnyLinkage) {
+    // We need to emit only one of these, the first module will keep
+    // it "as is" and the others will drop it
+    if (IsFunction && !IsFirstDefinition(GV))
+      GV.setLinkage(GlobalValue::AvailableExternallyLinkage);
+    Keep.insert(GV.getName());
+    return false;
+  }
+  if (Linkage == GlobalValue::WeakODRLinkage) {
+    // We need to emit only one of these, the first module will keep
+    // it "as is" and the others will drop it
+    if (IsFunction && !IsFirstDefinition(GV))
+      ; // We need to have "IsFirstWeakODRDefinition() instead.
+        // In case of extern template the first definition might be
+        // an "available externally" one.
+    //                GV.setLinkage(GlobalValue::AvailableExternallyLinkage);
+    Keep.insert(GV.getName());
+    return false;
+  }
+  Buffer.clear();
+  Mang.getNameWithPrefix(Buffer, &GV, false);
+  if (PreservedSymbols.count(Buffer)) {
+    Keep.insert(GV.getName());
+    return false;
+  }
+
+  return true;
+}
+
+// Helper function running internalize for ThinLTO
+static void InternalizeModule(Module &TheModule, const FunctionInfoIndex &Index,
+                              const StringSet<> &PreservedSymbols) {
+
+  // Keep track of the original linkage, needed to be restored
+  // The issue is that even if a function is not accessed from outside the
+  // current module before ThinLTO, it can't be internalized because it
+  // potentially has a caller in the current module and this caller can be
+  // imported in another module.
+  StringMap<std::pair<GlobalValue::LinkageTypes, GlobalValue::VisibilityTypes>>
+      OriginalLinkages;
+
+  auto RememberOriginalLinkage = [&](GlobalValue &GV) {
+    OriginalLinkages[GV.getName()] =
+        std::make_pair(GV.getLinkage(), GV.getVisibility());
+  };
+
+  // Set of symbol to preserve during Internalize
+  StringSet<> Keep;
+
+  for (Function &GV : TheModule) {
+    if (InternalizeGlobal(TheModule, GV, Keep, Index, PreservedSymbols, true))
+      RememberOriginalLinkage(GV);
+  }
+  for (GlobalVariable &GV : TheModule.globals()) {
+    if (InternalizeGlobal(TheModule, GV, Keep, Index, PreservedSymbols, false))
+      RememberOriginalLinkage(GV);
+  }
+  for (GlobalAlias &GV : TheModule.aliases()) {
+    if (InternalizeGlobal(TheModule, GV, Keep, Index, PreservedSymbols, false))
+      RememberOriginalLinkage(GV);
+  }
+
+  {
+    // Run the internalize pass and some trivial optimizations
+    legacy::PassManager PM;
+    PM.add(createInternalizePass(std::move(Keep)));
+    PM.add(createGlobalDCEPass());
+    // apply scope restrictions
+    PM.run(TheModule);
+  }
+
+  // Restore the original linkage for function that haven't been eliminated
+  for (auto &GVInfo : OriginalLinkages) {
+    if (auto *GV = TheModule.getNamedValue(GVInfo.first())) {
+      GV->setLinkage(GVInfo.second.first);
+      GV->setVisibility(GVInfo.second.second);
+    }
+  }
+}
+} // end anonymous namespace
+
+void ThinLTOCodeGenerator::addModule(StringRef Identifier, StringRef Data) {
+  MemoryBufferRef Buffer(Data, Identifier);
+  if (Modules.empty()) {
+    // First module added, let initialize the triple and some options
+    LLVMContext Context;
+    Triple TheTriple(getBitcodeTargetTriple(Buffer, Context));
+
+    // Set a default CPU for Darwin triples (copied from LTOCodeGenerator).
+    if (TMBuilder.MCpu.empty() && TheTriple.isOSDarwin()) {
+      if (TheTriple.getArch() == llvm::Triple::x86_64)
+        TMBuilder.MCpu = "core2";
+      else if (TheTriple.getArch() == llvm::Triple::x86)
+        TMBuilder.MCpu = "yonah";
+      else if (TheTriple.getArch() == llvm::Triple::aarch64)
+        TMBuilder.MCpu = "cyclone";
+    }
+
+    setTriple(TheTriple);
+  }
+#ifndef NDEBUG
+  else {
+    LLVMContext Context;
+    assert(TMBuilder.TheTriple.str() ==
+               getBitcodeTargetTriple(Buffer, Context) &&
+           "ThinLTO modules with different triple not supported");
+  }
+#endif
+  Modules.push_back(Buffer);
+}
+
+void ThinLTOCodeGenerator::preserveSymbol(StringRef Name) {
+  PreservedSymbols.insert(Name);
+}
+
+// TargetMachine factory
+std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const {
+  std::string ErrMsg;
+  const Target *TheTarget =
+      TargetRegistry::lookupTarget(TheTriple.str(), ErrMsg);
+  if (!TheTarget) {
+    report_fatal_error("Can't load target for this Triple");
+  }
+
+  // Use MAttr as the default set of features.
+  SubtargetFeatures Features(MAttr);
+  Features.getDefaultSubtargetFeatures(TheTriple);
+  std::string FeatureStr = Features.getString();
+  return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
+      TheTriple.str(), MCpu, FeatureStr, Options, RelocModel,
+      CodeModel::Default, CGOptLevel));
+}
+
+// Main entry point for the ThinLTO processing
+LTOObjectBuffers ThinLTOCodeGenerator::run() {
+  // Sequential linking phase
+  auto Index = linkCombinedIndex(Modules);
+
+  // Prepare the resulting object to return to the linker
+  LTOObjectBuffers Result;
+  Result.Objects =
+      (LTOObjectBuffer *)malloc(sizeof(LTOObjectBuffer) * Modules.size());
+  Result.Size = Modules.size();
+
+  // Helper map to find a Module from its identifier
+  // !! Relies on having a unique getBufferIdentifier() !!
+  StringMap<MemoryBufferRef> PathToModules;
+  for (auto &ModuleBuffer : Modules) {
+    assert(PathToModules.find(ModuleBuffer.getBufferIdentifier()) ==
+           PathToModules.end());
+    PathToModules[ModuleBuffer.getBufferIdentifier()] = ModuleBuffer;
+  }
+
+  // Parallel optimizer + codegen
+  {
+    ThreadPool Pool;
+    int count = 0;
+    for (auto &ModuleBuffer : Modules) {
+      Pool.async([&](int count) {
+
+        // Parse module now
+        LLVMContext Context;
+        auto TheModule = loadModuleFromBuffer(ModuleBuffer, Context);
+
+        InternalizeModule(*TheModule, *Index, PreservedSymbols);
+
+        Result.Objects[count] =
+            ProcessThinLTOModule(std::move(TheModule), *Index, PathToModules,
+                                 TMBuilder.create(), CacheDir);
+      }, count);
+      count++;
+    }
+  }
+  return Result;
+}

tools/llvm-lto/llvm-lto.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/LTO/LTOCodeGenerator.h"
+#include "llvm/LTO/ThinLTOCodeGenerator.h"
 #include "llvm/LTO/LTOModule.h"
 #include "llvm/Object/FunctionIndexObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include <list>
 
 using namespace llvm;
 
+static cl::opt<std::string> ThinLTODestinationDirectory(
+    "thinlto-dir", cl::init(""),
+    cl::desc("Enable ThinLTO and produce the output to this directory"),
+    cl::value_desc("dirname"));
+
 static cl::opt<char>
 OptLevel("O",
          cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
                   "(default = '-O2')"),
          cl::Prefix,
          cl::ZeroOrMore,
          cl::init('2'));
 

 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::OneOrMore,
   cl::desc("<input bitcode files>"));
 
 static cl::opt<std::string>
 OutputFilename("o", cl::init(""),
   cl::desc("Override output filename"),
   cl::value_desc("filename"));
 
 static cl::list<std::string>
 ExportedSymbols("exported-symbol",
   cl::desc("Symbol to export from the resulting object file"),
   cl::ZeroOrMore);
 
 static cl::list<std::string>
 DSOSymbols("dso-symbol",
   cl::desc("Symbol to put in the symtab in the resulting dso"),
int main(int argc, char **argv) {
   // set up the TargetOptions for the machine
   TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 
   if (ListSymbolsOnly) {
     listSymbols(Options);
     return 0;
   }
 
+  if (!ThinLTODestinationDirectory.empty()) {
+    ThinLTOCodeGenerator CodeGen;
+    for (auto &Filename : InputFilenames) {
+      std::string ErrorMsg;
+      //      auto Module =
+      //      std::unique_ptr<LTOModule>(LTOModule::createFromFile(Filename.c_str(),
+      //      InitTargetOptionsFromCodeGenFlags(), ErrorMsg));
+      // Can't do that, we want to leak the buffer instead, ld64 style!
+      ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+          MemoryBuffer::getFile(Filename);
+      if (std::error_code EC = BufferOrErr.getError()) {
+        errs() << "Can't open file: " << EC.message() << "\n";
+        return 1;
+      }
+      // YEAH: memory leak
+      MemoryBuffer *Buffer = BufferOrErr->release();
+      CodeGen.addModule(Filename, StringRef(Buffer->getBufferStart(),
+                                            Buffer->getBufferSize()));
+    }
+    //    CodeGen.linkProfile(ThinLTODestinationDirectory + "summary.bc");
+    //    CodeGen.optimize(ThinLTODestinationDirectory);
+    //    CodeGen.codegen(ThinLTODestinationDirectory);
+    errs() << "\n===\nThinLTO done\n";
+    return 0;
+  }
+
   if (ThinLTO) {
     createCombinedFunctionIndex();
     return 0;
   }
 
   unsigned BaseArg = 0;
 
   LLVMContext Context;
for (unsigned i = BaseArg; i < InputFilenames.size(); ++i) {
 
     unsigned NumSyms = Module->getSymbolCount();
     for (unsigned I = 0; I < NumSyms; ++I) {
       StringRef Name = Module->getSymbolName(I);
       if (!DSOSymbolsSet.count(Name))
         continue;
       lto_symbol_attributes Attrs = Module->getSymbolAttributes(I);
       unsigned Scope = Attrs & LTO_SYMBOL_SCOPE_MASK;
       if (Scope != LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN)
         KeptDSOSyms.push_back(Name);
     }
 
     // We use the first input module as the destination module when
     // SetMergedModule is true.
     if (SetMergedModule && i == BaseArg) {
       // Transfer ownership to the code generator.
       CodeGen.setModule(std::move(Module));
     } else if (!CodeGen.addModule(Module.get())) {
       // Print a message here so that we know addModule() did not abort.
       errs() << argv[0] << ": error adding file '" << InputFilenames[i] << "'\n";
       return 1;
     }
   }
 
   // Add all the exported symbols to the table of symbols to preserve.
   for (unsigned i = 0; i < ExportedSymbols.size(); ++i)
     CodeGen.addMustPreserveSymbol(ExportedSymbols[i].c_str());
 
   // Add all the dso symbols to the table of symbols to expose.
   for (unsigned i = 0; i < KeptDSOSyms.size(); ++i)
     CodeGen.addMustPreserveSymbol(KeptDSOSyms[i].c_str());
 
   // Set cpu and attrs strings for the default target/subtarget.
   CodeGen.setCpu(MCPU.c_str());
 
   CodeGen.setOptLevel(OptLevel - '0');
 
   std::string attrs;
   for (unsigned i = 0; i < MAttrs.size(); ++i) {
     if (i > 0)
       attrs.append(",");
     attrs.append(MAttrs[i]);
   }
 
   if (!attrs.empty())
     CodeGen.setAttr(attrs.c_str());
 
   if (FileType.getNumOccurrences())
     CodeGen.setFileType(FileType);
 
   if (!OutputFilename.empty()) {
     if (!CodeGen.optimize(DisableVerify, DisableInline, DisableGVNLoadPRE,
                           DisableLTOVectorization)) {
       // Diagnostic messages should have been printed by the handler.
       errs() << argv[0] << ": error optimizing the code\n";
       return 1;
     }
 
     if (SaveModuleFile) {
       std::string ModuleFilename = OutputFilename;
       ModuleFilename += ".merged.bc";
       std::string ErrMsg;
 
       if (!CodeGen.writeMergedModules(ModuleFilename.c_str())) {
         errs() << argv[0] << ": writing merged module failed.\n";
         return 1;
       }
     }
 
     std::list<tool_output_file> OSs;
     std::vector<raw_pwrite_stream *> OSPtrs;
     for (unsigned I = 0; I != Parallelism; ++I) {
       std::string PartFilename = OutputFilename;
       if (Parallelism != 1)
         PartFilename += "." + utostr(I);
       std::error_code EC;
       OSs.emplace_back(PartFilename, EC, sys::fs::F_None);
       if (EC) {
         errs() << argv[0] << ": error opening the file '" << PartFilename
                << "': " << EC.message() << "\n";
         return 1;
       }
       OSPtrs.push_back(&OSs.back().os());
     }
 
     if (!CodeGen.compileOptimized(OSPtrs)) {
       // Diagnostic messages should have been printed by the handler.
       errs() << argv[0] << ": error compiling the code\n";
       return 1;
     }
 
     for (tool_output_file &OS : OSs)
       OS.keep();
   } else {
     if (Parallelism != 1) {
       errs() << argv[0] << ": -j must be specified together with -o\n";
       return 1;
     }

tools/lto/lto.cpp

 #include "llvm-c/lto.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/LTO/LTOCodeGenerator.h"
 #include "llvm/LTO/LTOModule.h"
+#include "llvm/LTO/ThinLTOCodeGenerator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 
 // extra command-line flags needed for LTOCodeGenerator
 static cl::opt<char>
 OptLevel("O",
struct LibLTOCodeGenerator : LTOCodeGenerator {
 
   std::unique_ptr<MemoryBuffer> NativeObjectFile;
   std::unique_ptr<LLVMContext> OwnedContext;
 };
 
 }
 
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LibLTOCodeGenerator, lto_code_gen_t)
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThinLTOCodeGenerator, thinlto_code_gen_t)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LTOModule, lto_module_t)
 
 // Convert the subtarget features into a string to pass to LTOCodeGenerator.
 static void lto_add_attrs(lto_code_gen_t cg) {
   LTOCodeGenerator *CG = unwrap(cg);
   if (MAttrs.size()) {
     std::string attrs;
     for (unsigned i = 0; i < MAttrs.size(); ++i) {

 const char* lto_module_get_target_triple(lto_module_t mod) {
   return unwrap(mod)->getTargetTriple().c_str();
 }
 
 void lto_module_set_target_triple(lto_module_t mod, const char *triple) {
   return unwrap(mod)->setTargetTriple(triple);
 }
 
+void lto_module_set_preserved(lto_module_t mod, const char *symbol) {
+  return; // FIXME  unwrap(mod)->addPreservedSymbols(symbol);
+}
+
 unsigned int lto_module_get_num_symbols(lto_module_t mod) {
   return unwrap(mod)->getSymbolCount();
 }
 
 const char* lto_module_get_symbol_name(lto_module_t mod, unsigned int index) {
   return unwrap(mod)->getSymbolName(index);
 }
 
void lto_codegen_set_should_internalize(lto_code_gen_t cg,
                                         bool ShouldInternalize) {
   unwrap(cg)->setShouldInternalize(ShouldInternalize);
 }
 
 void lto_codegen_set_should_embed_uselists(lto_code_gen_t cg,
                                            lto_bool_t ShouldEmbedUselists) {
   unwrap(cg)->setShouldEmbedUselists(ShouldEmbedUselists);
 }
+
+// ThinLTO API below
+
+thinlto_code_gen_t thinlto_create_codegen() {
+  lto_initialize();
+  ThinLTOCodeGenerator *CodeGen = new ThinLTOCodeGenerator();
+  CodeGen->setTargetOptions(InitTargetOptionsFromCodeGenFlags());
+
+  return wrap(CodeGen);
+}
+
+void thinlto_codegen_add_module(thinlto_code_gen_t cg, const char *Identifier,
+                                const char *Data, int Length) {
+  unwrap(cg)->addModule(Identifier, StringRef(Data, Length));
+}
+
+LTOObjectBuffers thinlto_codegen_process(thinlto_code_gen_t cg) {
+  return unwrap(cg)->run();
+}
+
+void thinlto_debug_options(const char *const *options, int number) {
+  // if options were requested, set them
+  if (number && options) {
+    std::vector<const char *> CodegenArgv(1, "libLTO");
+    for (auto Arg : ArrayRef<const char *>(options, number))
+      CodegenArgv.push_back(Arg);
+    cl::ParseCommandLineOptions(CodegenArgv.size(), CodegenArgv.data());
+  }
+}
+
+bool lto_module_is_thinlto(lto_module_t mod) {
+  return unwrap(mod)->isThinLTO();
+}
+
+void thinlto_codegen_add_must_preserve_symbol(thinlto_code_gen_t cg,
+                                              const char *Name, int Length) {
+  unwrap(cg)->preserveSymbol(StringRef(Name, Length));
+}
+
+void thinlto_codegen_set_cpu(thinlto_code_gen_t cg, const char *cpu) {
+  return unwrap(cg)->setCpu(cpu);
+}
+
+void thinlto_codegen_set_cache_dir(thinlto_code_gen_t cg,
+                                   const char *cache_dir) {
+  return unwrap(cg)->setCacheDir(cache_dir);
+}
+
+lto_bool_t thinlto_codegen_set_pic_model(thinlto_code_gen_t cg,
+                                         lto_codegen_model model) {
+  switch (model) {
+  case LTO_CODEGEN_PIC_MODEL_STATIC:
+    unwrap(cg)->setCodePICModel(Reloc::Static);
+    return false;
+  case LTO_CODEGEN_PIC_MODEL_DYNAMIC:
+    unwrap(cg)->setCodePICModel(Reloc::PIC_);
+    return false;
+  case LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC:
+    unwrap(cg)->setCodePICModel(Reloc::DynamicNoPIC);
+    return false;
+  case LTO_CODEGEN_PIC_MODEL_DEFAULT:
+    unwrap(cg)->setCodePICModel(Reloc::Default);
+    return false;
+  }
+  sLastErrorString = "Unknown PIC model";
+  return true;
+}

tools/lto/lto.exports

 lto_codegen_compile_optimized
 lto_codegen_set_should_internalize
 lto_codegen_set_should_embed_uselists
 LLVMCreateDisasm
 LLVMCreateDisasmCPU
 LLVMDisasmDispose
 LLVMDisasmInstruction
 LLVMSetDisasmOptions
+lto_module_is_thinlto
+thinlto_codegen_add_module
+thinlto_codegen_add_must_preserve_symbol
+thinlto_codegen_process
+thinlto_codegen_set_cache_dir
+thinlto_codegen_set_cpu
+thinlto_codegen_set_pic_model
+thinlto_create_codegen
+thinlto_debug_options