• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*===-- llvm-c/lto.h - LTO Public C Interface ---------------------*- C -*-===*\
2  |*                                                                            *|
3  |*                     The LLVM Compiler Infrastructure                       *|
4  |*                                                                            *|
5  |* This file is distributed under the University of Illinois Open Source      *|
6  |* License. See LICENSE.TXT for details.                                      *|
7  |*                                                                            *|
8  |*===----------------------------------------------------------------------===*|
9  |*                                                                            *|
10  |* This header provides public interface to an abstract link time optimization*|
11  |* library.  LLVM provides an implementation of this interface for use with   *|
12  |* llvm bitcode files.                                                        *|
13  |*                                                                            *|
14  \*===----------------------------------------------------------------------===*/
15  
16  #ifndef LLVM_C_LTO_H
17  #define LLVM_C_LTO_H
18  
19  #ifdef __cplusplus
20  #include <cstddef>
21  #else
22  #include <stddef.h>
23  #endif
24  #include <sys/types.h>
25  
26  #ifndef __cplusplus
27  #if !defined(_MSC_VER)
28  #include <stdbool.h>
29  typedef bool lto_bool_t;
30  #else
31  /* MSVC in particular does not have anything like _Bool or bool in C, but we can
32     at least make sure the type is the same size.  The implementation side will
33     use C++ bool. */
34  typedef unsigned char lto_bool_t;
35  #endif
36  #else
37  typedef bool lto_bool_t;
38  #endif
39  
40  /**
41   * @defgroup LLVMCLTO LTO
42   * @ingroup LLVMC
43   *
44   * @{
45   */
46  
47  #define LTO_API_VERSION 20
48  
49  /**
50   * \since prior to LTO_API_VERSION=3
51   */
52  typedef enum {
53      LTO_SYMBOL_ALIGNMENT_MASK              = 0x0000001F, /* log2 of alignment */
54      LTO_SYMBOL_PERMISSIONS_MASK            = 0x000000E0,
55      LTO_SYMBOL_PERMISSIONS_CODE            = 0x000000A0,
56      LTO_SYMBOL_PERMISSIONS_DATA            = 0x000000C0,
57      LTO_SYMBOL_PERMISSIONS_RODATA          = 0x00000080,
58      LTO_SYMBOL_DEFINITION_MASK             = 0x00000700,
59      LTO_SYMBOL_DEFINITION_REGULAR          = 0x00000100,
60      LTO_SYMBOL_DEFINITION_TENTATIVE        = 0x00000200,
61      LTO_SYMBOL_DEFINITION_WEAK             = 0x00000300,
62      LTO_SYMBOL_DEFINITION_UNDEFINED        = 0x00000400,
63      LTO_SYMBOL_DEFINITION_WEAKUNDEF        = 0x00000500,
64      LTO_SYMBOL_SCOPE_MASK                  = 0x00003800,
65      LTO_SYMBOL_SCOPE_INTERNAL              = 0x00000800,
66      LTO_SYMBOL_SCOPE_HIDDEN                = 0x00001000,
67      LTO_SYMBOL_SCOPE_PROTECTED             = 0x00002000,
68      LTO_SYMBOL_SCOPE_DEFAULT               = 0x00001800,
69      LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN = 0x00002800,
70      LTO_SYMBOL_COMDAT                      = 0x00004000,
71      LTO_SYMBOL_ALIAS                       = 0x00008000
72  } lto_symbol_attributes;
73  
74  /**
75   * \since prior to LTO_API_VERSION=3
76   */
77  typedef enum {
78      LTO_DEBUG_MODEL_NONE         = 0,
79      LTO_DEBUG_MODEL_DWARF        = 1
80  } lto_debug_model;
81  
82  /**
83   * \since prior to LTO_API_VERSION=3
84   */
85  typedef enum {
86      LTO_CODEGEN_PIC_MODEL_STATIC         = 0,
87      LTO_CODEGEN_PIC_MODEL_DYNAMIC        = 1,
88      LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2,
89      LTO_CODEGEN_PIC_MODEL_DEFAULT        = 3
90  } lto_codegen_model;
91  
92  /** opaque reference to a loaded object module */
93  typedef struct LLVMOpaqueLTOModule *lto_module_t;
94  
95  /** opaque reference to a code generator */
96  typedef struct LLVMOpaqueLTOCodeGenerator *lto_code_gen_t;
97  
98  /** opaque reference to a thin code generator */
99  typedef struct LLVMOpaqueThinLTOCodeGenerator *thinlto_code_gen_t;
100  
101  #ifdef __cplusplus
102  extern "C" {
103  #endif
104  
105  /**
106   * Returns a printable string.
107   *
108   * \since prior to LTO_API_VERSION=3
109   */
110  extern const char*
111  lto_get_version(void);
112  
113  /**
114   * Returns the last error string or NULL if last operation was successful.
115   *
116   * \since prior to LTO_API_VERSION=3
117   */
118  extern const char*
119  lto_get_error_message(void);
120  
121  /**
122   * Checks if a file is a loadable object file.
123   *
124   * \since prior to LTO_API_VERSION=3
125   */
126  extern lto_bool_t
127  lto_module_is_object_file(const char* path);
128  
129  /**
130   * Checks if a file is a loadable object compiled for requested target.
131   *
132   * \since prior to LTO_API_VERSION=3
133   */
134  extern lto_bool_t
135  lto_module_is_object_file_for_target(const char* path,
136                                       const char* target_triple_prefix);
137  
138  /**
139   * Return true if \p Buffer contains a bitcode file with ObjC code (category
140   * or class) in it.
141   *
142   * \since LTO_API_VERSION=20
143   */
144  extern lto_bool_t
145  lto_module_has_objc_category(const void *mem, size_t length);
146  
147  /**
148  * Checks if a buffer is a loadable object file.
149  *
150  * \since prior to LTO_API_VERSION=3
151  */
152  extern lto_bool_t lto_module_is_object_file_in_memory(const void *mem,
153                                                        size_t length);
154  
155  /**
156   * Checks if a buffer is a loadable object compiled for requested target.
157   *
158   * \since prior to LTO_API_VERSION=3
159   */
160  extern lto_bool_t
161  lto_module_is_object_file_in_memory_for_target(const void* mem, size_t length,
162                                                const char* target_triple_prefix);
163  
164  /**
165   * Loads an object file from disk.
166   * Returns NULL on error (check lto_get_error_message() for details).
167   *
168   * \since prior to LTO_API_VERSION=3
169   */
170  extern lto_module_t
171  lto_module_create(const char* path);
172  
173  /**
174   * Loads an object file from memory.
175   * Returns NULL on error (check lto_get_error_message() for details).
176   *
177   * \since prior to LTO_API_VERSION=3
178   */
179  extern lto_module_t
180  lto_module_create_from_memory(const void* mem, size_t length);
181  
182  /**
183   * Loads an object file from memory with an extra path argument.
184   * Returns NULL on error (check lto_get_error_message() for details).
185   *
186   * \since LTO_API_VERSION=9
187   */
188  extern lto_module_t
189  lto_module_create_from_memory_with_path(const void* mem, size_t length,
190                                          const char *path);
191  
192  /**
193   * \brief Loads an object file in its own context.
194   *
195   * Loads an object file in its own LLVMContext.  This function call is
196   * thread-safe.  However, modules created this way should not be merged into an
197   * lto_code_gen_t using \a lto_codegen_add_module().
198   *
199   * Returns NULL on error (check lto_get_error_message() for details).
200   *
201   * \since LTO_API_VERSION=11
202   */
203  extern lto_module_t
204  lto_module_create_in_local_context(const void *mem, size_t length,
205                                     const char *path);
206  
207  /**
208   * \brief Loads an object file in the codegen context.
209   *
210   * Loads an object file into the same context as \c cg.  The module is safe to
211   * add using \a lto_codegen_add_module().
212   *
213   * Returns NULL on error (check lto_get_error_message() for details).
214   *
215   * \since LTO_API_VERSION=11
216   */
217  extern lto_module_t
218  lto_module_create_in_codegen_context(const void *mem, size_t length,
219                                       const char *path, lto_code_gen_t cg);
220  
221  /**
222   * Loads an object file from disk. The seek point of fd is not preserved.
223   * Returns NULL on error (check lto_get_error_message() for details).
224   *
225   * \since LTO_API_VERSION=5
226   */
227  extern lto_module_t
228  lto_module_create_from_fd(int fd, const char *path, size_t file_size);
229  
230  /**
231   * Loads an object file from disk. The seek point of fd is not preserved.
232   * Returns NULL on error (check lto_get_error_message() for details).
233   *
234   * \since LTO_API_VERSION=5
235   */
236  extern lto_module_t
237  lto_module_create_from_fd_at_offset(int fd, const char *path, size_t file_size,
238                                      size_t map_size, off_t offset);
239  
240  /**
241   * Frees all memory internally allocated by the module.
242   * Upon return the lto_module_t is no longer valid.
243   *
244   * \since prior to LTO_API_VERSION=3
245   */
246  extern void
247  lto_module_dispose(lto_module_t mod);
248  
249  /**
250   * Returns triple string which the object module was compiled under.
251   *
252   * \since prior to LTO_API_VERSION=3
253   */
254  extern const char*
255  lto_module_get_target_triple(lto_module_t mod);
256  
257  /**
258   * Sets triple string with which the object will be codegened.
259   *
260   * \since LTO_API_VERSION=4
261   */
262  extern void
263  lto_module_set_target_triple(lto_module_t mod, const char *triple);
264  
265  /**
266   * Returns the number of symbols in the object module.
267   *
268   * \since prior to LTO_API_VERSION=3
269   */
270  extern unsigned int
271  lto_module_get_num_symbols(lto_module_t mod);
272  
273  /**
274   * Returns the name of the ith symbol in the object module.
275   *
276   * \since prior to LTO_API_VERSION=3
277   */
278  extern const char*
279  lto_module_get_symbol_name(lto_module_t mod, unsigned int index);
280  
281  /**
282   * Returns the attributes of the ith symbol in the object module.
283   *
284   * \since prior to LTO_API_VERSION=3
285   */
286  extern lto_symbol_attributes
287  lto_module_get_symbol_attribute(lto_module_t mod, unsigned int index);
288  
289  /**
290   * Returns the module's linker options.
291   *
292   * The linker options may consist of multiple flags. It is the linker's
293   * responsibility to split the flags using a platform-specific mechanism.
294   *
295   * \since LTO_API_VERSION=16
296   */
297  extern const char*
298  lto_module_get_linkeropts(lto_module_t mod);
299  
300  /**
301   * Diagnostic severity.
302   *
303   * \since LTO_API_VERSION=7
304   */
305  typedef enum {
306    LTO_DS_ERROR = 0,
307    LTO_DS_WARNING = 1,
308    LTO_DS_REMARK = 3, // Added in LTO_API_VERSION=10.
309    LTO_DS_NOTE = 2
310  } lto_codegen_diagnostic_severity_t;
311  
312  /**
313   * Diagnostic handler type.
314   * \p severity defines the severity.
315   * \p diag is the actual diagnostic.
316   * The diagnostic is not prefixed by any of severity keyword, e.g., 'error: '.
317   * \p ctxt is used to pass the context set with the diagnostic handler.
318   *
319   * \since LTO_API_VERSION=7
320   */
321  typedef void (*lto_diagnostic_handler_t)(
322      lto_codegen_diagnostic_severity_t severity, const char *diag, void *ctxt);
323  
324  /**
325   * Set a diagnostic handler and the related context (void *).
326   * This is more general than lto_get_error_message, as the diagnostic handler
327   * can be called at anytime within lto.
328   *
329   * \since LTO_API_VERSION=7
330   */
331  extern void lto_codegen_set_diagnostic_handler(lto_code_gen_t,
332                                                 lto_diagnostic_handler_t,
333                                                 void *);
334  
335  /**
336   * Instantiates a code generator.
337   * Returns NULL on error (check lto_get_error_message() for details).
338   *
339   * All modules added using \a lto_codegen_add_module() must have been created
340   * in the same context as the codegen.
341   *
342   * \since prior to LTO_API_VERSION=3
343   */
344  extern lto_code_gen_t
345  lto_codegen_create(void);
346  
347  /**
348   * \brief Instantiate a code generator in its own context.
349   *
350   * Instantiates a code generator in its own context.  Modules added via \a
351   * lto_codegen_add_module() must have all been created in the same context,
352   * using \a lto_module_create_in_codegen_context().
353   *
354   * \since LTO_API_VERSION=11
355   */
356  extern lto_code_gen_t
357  lto_codegen_create_in_local_context(void);
358  
359  /**
360   * Frees all code generator and all memory it internally allocated.
361   * Upon return the lto_code_gen_t is no longer valid.
362   *
363   * \since prior to LTO_API_VERSION=3
364   */
365  extern void
366  lto_codegen_dispose(lto_code_gen_t);
367  
368  /**
369   * Add an object module to the set of modules for which code will be generated.
370   * Returns true on error (check lto_get_error_message() for details).
371   *
372   * \c cg and \c mod must both be in the same context.  See \a
373   * lto_codegen_create_in_local_context() and \a
374   * lto_module_create_in_codegen_context().
375   *
376   * \since prior to LTO_API_VERSION=3
377   */
378  extern lto_bool_t
379  lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod);
380  
381  /**
382   * Sets the object module for code generation. This will transfer the ownership
383   * of the module to the code generator.
384   *
385   * \c cg and \c mod must both be in the same context.
386   *
387   * \since LTO_API_VERSION=13
388   */
389  extern void
390  lto_codegen_set_module(lto_code_gen_t cg, lto_module_t mod);
391  
392  /**
393   * Sets if debug info should be generated.
394   * Returns true on error (check lto_get_error_message() for details).
395   *
396   * \since prior to LTO_API_VERSION=3
397   */
398  extern lto_bool_t
399  lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model);
400  
401  /**
402   * Sets which PIC code model to generated.
403   * Returns true on error (check lto_get_error_message() for details).
404   *
405   * \since prior to LTO_API_VERSION=3
406   */
407  extern lto_bool_t
408  lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model);
409  
410  /**
411   * Sets the cpu to generate code for.
412   *
413   * \since LTO_API_VERSION=4
414   */
415  extern void
416  lto_codegen_set_cpu(lto_code_gen_t cg, const char *cpu);
417  
418  /**
419   * Sets the location of the assembler tool to run. If not set, libLTO
420   * will use gcc to invoke the assembler.
421   *
422   * \since LTO_API_VERSION=3
423   */
424  extern void
425  lto_codegen_set_assembler_path(lto_code_gen_t cg, const char* path);
426  
427  /**
428   * Sets extra arguments that libLTO should pass to the assembler.
429   *
430   * \since LTO_API_VERSION=4
431   */
432  extern void
433  lto_codegen_set_assembler_args(lto_code_gen_t cg, const char **args,
434                                 int nargs);
435  
436  /**
437   * Adds to a list of all global symbols that must exist in the final generated
438   * code. If a function is not listed there, it might be inlined into every usage
439   * and optimized away.
440   *
441   * \since prior to LTO_API_VERSION=3
442   */
443  extern void
444  lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg, const char* symbol);
445  
446  /**
447   * Writes a new object file at the specified path that contains the
448   * merged contents of all modules added so far.
449   * Returns true on error (check lto_get_error_message() for details).
450   *
451   * \since LTO_API_VERSION=5
452   */
453  extern lto_bool_t
454  lto_codegen_write_merged_modules(lto_code_gen_t cg, const char* path);
455  
456  /**
457   * Generates code for all added modules into one native object file.
458   * This calls lto_codegen_optimize then lto_codegen_compile_optimized.
459   *
460   * On success returns a pointer to a generated mach-o/ELF buffer and
461   * length set to the buffer size.  The buffer is owned by the
462   * lto_code_gen_t and will be freed when lto_codegen_dispose()
463   * is called, or lto_codegen_compile() is called again.
464   * On failure, returns NULL (check lto_get_error_message() for details).
465   *
466   * \since prior to LTO_API_VERSION=3
467   */
468  extern const void*
469  lto_codegen_compile(lto_code_gen_t cg, size_t* length);
470  
471  /**
472   * Generates code for all added modules into one native object file.
473   * This calls lto_codegen_optimize then lto_codegen_compile_optimized (instead
474   * of returning a generated mach-o/ELF buffer, it writes to a file).
475   *
476   * The name of the file is written to name. Returns true on error.
477   *
478   * \since LTO_API_VERSION=5
479   */
480  extern lto_bool_t
481  lto_codegen_compile_to_file(lto_code_gen_t cg, const char** name);
482  
483  /**
484   * Runs optimization for the merged module. Returns true on error.
485   *
486   * \since LTO_API_VERSION=12
487   */
488  extern lto_bool_t
489  lto_codegen_optimize(lto_code_gen_t cg);
490  
491  /**
492   * Generates code for the optimized merged module into one native object file.
493   * It will not run any IR optimizations on the merged module.
494   *
495   * On success returns a pointer to a generated mach-o/ELF buffer and length set
496   * to the buffer size.  The buffer is owned by the lto_code_gen_t and will be
497   * freed when lto_codegen_dispose() is called, or
498   * lto_codegen_compile_optimized() is called again. On failure, returns NULL
499   * (check lto_get_error_message() for details).
500   *
501   * \since LTO_API_VERSION=12
502   */
503  extern const void*
504  lto_codegen_compile_optimized(lto_code_gen_t cg, size_t* length);
505  
506  /**
507   * Returns the runtime API version.
508   *
509   * \since LTO_API_VERSION=12
510   */
511  extern unsigned int
512  lto_api_version(void);
513  
514  /**
515   * Sets options to help debug codegen bugs.
516   *
517   * \since prior to LTO_API_VERSION=3
518   */
519  extern void
520  lto_codegen_debug_options(lto_code_gen_t cg, const char *);
521  
522  /**
523   * Initializes LLVM disassemblers.
524   * FIXME: This doesn't really belong here.
525   *
526   * \since LTO_API_VERSION=5
527   */
528  extern void
529  lto_initialize_disassembler(void);
530  
531  /**
532   * Sets if we should run internalize pass during optimization and code
533   * generation.
534   *
535   * \since LTO_API_VERSION=14
536   */
537  extern void
538  lto_codegen_set_should_internalize(lto_code_gen_t cg,
539                                     lto_bool_t ShouldInternalize);
540  
541  /**
542   * \brief Set whether to embed uselists in bitcode.
543   *
544   * Sets whether \a lto_codegen_write_merged_modules() should embed uselists in
545   * output bitcode.  This should be turned on for all -save-temps output.
546   *
547   * \since LTO_API_VERSION=15
548   */
549  extern void
550  lto_codegen_set_should_embed_uselists(lto_code_gen_t cg,
551                                        lto_bool_t ShouldEmbedUselists);
552  
553  /**
554   * @}
555   * @defgroup LLVMCTLTO ThinLTO
556   * @ingroup LLVMC
557   *
558   * @{
559   */
560  
561  /**
562   * Type to wrap a single object returned by ThinLTO.
563   *
564   * \since LTO_API_VERSION=18
565   */
566  typedef struct {
567    const char *Buffer;
568    size_t Size;
569  } LTOObjectBuffer;
570  
571  /**
572   * Instantiates a ThinLTO code generator.
573   * Returns NULL on error (check lto_get_error_message() for details).
574   *
575   *
576   * The ThinLTOCodeGenerator is not intended to be reuse for multiple
577   * compilation: the model is that the client adds modules to the generator and
578   * ask to perform the ThinLTO optimizations / codegen, and finally destroys the
579   * codegenerator.
580   *
581   * \since LTO_API_VERSION=18
582   */
583  extern thinlto_code_gen_t thinlto_create_codegen(void);
584  
585  /**
586   * Frees the generator and all memory it internally allocated.
587   * Upon return the thinlto_code_gen_t is no longer valid.
588   *
589   * \since LTO_API_VERSION=18
590   */
591  extern void thinlto_codegen_dispose(thinlto_code_gen_t cg);
592  
593  /**
594   * Add a module to a ThinLTO code generator. Identifier has to be unique among
595   * all the modules in a code generator. The data buffer stays owned by the
596   * client, and is expected to be available for the entire lifetime of the
597   * thinlto_code_gen_t it is added to.
598   *
599   * On failure, returns NULL (check lto_get_error_message() for details).
600   *
601   *
602   * \since LTO_API_VERSION=18
603   */
604  extern void thinlto_codegen_add_module(thinlto_code_gen_t cg,
605                                         const char *identifier, const char *data,
606                                         int length);
607  
608  /**
609   * Optimize and codegen all the modules added to the codegenerator using
610   * ThinLTO. Resulting objects are accessible using thinlto_module_get_object().
611   *
612   * \since LTO_API_VERSION=18
613   */
614  extern void thinlto_codegen_process(thinlto_code_gen_t cg);
615  
616  /**
617   * Returns the number of object files produced by the ThinLTO CodeGenerator.
618   *
619   * It usually matches the number of input files, but this is not a guarantee of
620   * the API and may change in future implementation, so the client should not
621   * assume it.
622   *
623   * \since LTO_API_VERSION=18
624   */
625  extern unsigned int thinlto_module_get_num_objects(thinlto_code_gen_t cg);
626  
627  /**
628   * Returns a reference to the ith object file produced by the ThinLTO
629   * CodeGenerator.
630   *
631   * Client should use \p thinlto_module_get_num_objects() to get the number of
632   * available objects.
633   *
634   * \since LTO_API_VERSION=18
635   */
636  extern LTOObjectBuffer thinlto_module_get_object(thinlto_code_gen_t cg,
637                                                   unsigned int index);
638  
639  /**
640   * Sets which PIC code model to generate.
641   * Returns true on error (check lto_get_error_message() for details).
642   *
643   * \since LTO_API_VERSION=18
644   */
645  extern lto_bool_t thinlto_codegen_set_pic_model(thinlto_code_gen_t cg,
646                                                  lto_codegen_model);
647  
648  /**
649   * @}
650   * @defgroup LLVMCTLTO_CACHING ThinLTO Cache Control
651   * @ingroup LLVMCTLTO
652   *
653   * These entry points control the ThinLTO cache. The cache is intended to
654   * support incremental build, and thus needs to be persistent accross build.
655   * The client enabled the cache by supplying a path to an existing directory.
656   * The code generator will use this to store objects files that may be reused
657   * during a subsequent build.
658   * To avoid filling the disk space, a few knobs are provided:
659   *  - The pruning interval limit the frequency at which the garbage collector
660   *    will try to scan the cache directory to prune it from expired entries.
661   *    Setting to -1 disable the pruning (default).
662   *  - The pruning expiration time indicates to the garbage collector how old an
663   *    entry needs to be to be removed.
664   *  - Finally, the garbage collector can be instructed to prune the cache till
665   *    the occupied space goes below a threshold.
666   * @{
667   */
668  
669  /**
670   * Sets the path to a directory to use as a cache storage for incremental build.
671   * Setting this activates caching.
672   *
673   * \since LTO_API_VERSION=18
674   */
675  extern void thinlto_codegen_set_cache_dir(thinlto_code_gen_t cg,
676                                            const char *cache_dir);
677  
678  /**
679   * Sets the cache pruning interval (in seconds). A negative value disable the
680   * pruning. An unspecified default value will be applied, and a value of 0 will
681   * be ignored.
682   *
683   * \since LTO_API_VERSION=18
684   */
685  extern void thinlto_codegen_set_cache_pruning_interval(thinlto_code_gen_t cg,
686                                                         int interval);
687  
688  /**
689   * Sets the maximum cache size that can be persistent across build, in terms of
690   * percentage of the available space on the the disk. Set to 100 to indicate
691   * no limit, 50 to indicate that the cache size will not be left over half the
692   * available space. A value over 100 will be reduced to 100, a value of 0 will
693   * be ignored. An unspecified default value will be applied.
694   *
695   * The formula looks like:
696   *  AvailableSpace = FreeSpace + ExistingCacheSize
697   *  NewCacheSize = AvailableSpace * P/100
698   *
699   * \since LTO_API_VERSION=18
700   */
701  extern void thinlto_codegen_set_final_cache_size_relative_to_available_space(
702      thinlto_code_gen_t cg, unsigned percentage);
703  
704  /**
705   * Sets the expiration (in seconds) for an entry in the cache. An unspecified
706   * default value will be applied. A value of 0 will be ignored.
707   *
708   * \since LTO_API_VERSION=18
709   */
710  extern void thinlto_codegen_set_cache_entry_expiration(thinlto_code_gen_t cg,
711                                                         unsigned expiration);
712  
713  /**
714   * @}
715   */
716  
717  /**
718   * Sets the path to a directory to use as a storage for temporary bitcode files.
719   * The intention is to make the bitcode files available for debugging at various
720   * stage of the pipeline.
721   *
722   * \since LTO_API_VERSION=18
723   */
724  extern void thinlto_codegen_set_savetemps_dir(thinlto_code_gen_t cg,
725                                                const char *save_temps_dir);
726  
727  /**
728   * Sets the cpu to generate code for.
729   *
730   * \since LTO_API_VERSION=18
731   */
732  extern void thinlto_codegen_set_cpu(thinlto_code_gen_t cg, const char *cpu);
733  
734  /**
735   * Disable CodeGen, only run the stages till codegen and stop. The output will
736   * be bitcode.
737   *
738   * \since LTO_API_VERSION=19
739   */
740  extern void thinlto_codegen_disable_codegen(thinlto_code_gen_t cg,
741                                              lto_bool_t disable);
742  
743  /**
744   * Perform CodeGen only: disable all other stages.
745   *
746   * \since LTO_API_VERSION=19
747   */
748  extern void thinlto_codegen_set_codegen_only(thinlto_code_gen_t cg,
749                                               lto_bool_t codegen_only);
750  
751  /**
752   * Parse -mllvm style debug options.
753   *
754   * \since LTO_API_VERSION=18
755   */
756  extern void thinlto_debug_options(const char *const *options, int number);
757  
758  /**
759   * Test if a module has support for ThinLTO linking.
760   *
761   * \since LTO_API_VERSION=18
762   */
763  extern lto_bool_t lto_module_is_thinlto(lto_module_t mod);
764  
765  /**
766   * Adds a symbol to the list of global symbols that must exist in the final
767   * generated code. If a function is not listed there, it might be inlined into
768   * every usage and optimized away. For every single module, the functions
769   * referenced from code outside of the ThinLTO modules need to be added here.
770   *
771   * \since LTO_API_VERSION=18
772   */
773  extern void thinlto_codegen_add_must_preserve_symbol(thinlto_code_gen_t cg,
774                                                       const char *name,
775                                                       int length);
776  
777  /**
778   * Adds a symbol to the list of global symbols that are cross-referenced between
779   * ThinLTO files. If the ThinLTO CodeGenerator can ensure that every
780   * references from a ThinLTO module to this symbol is optimized away, then
781   * the symbol can be discarded.
782   *
783   * \since LTO_API_VERSION=18
784   */
785  extern void thinlto_codegen_add_cross_referenced_symbol(thinlto_code_gen_t cg,
786                                                          const char *name,
787                                                          int length);
788  
789  #ifdef __cplusplus
790  }
791  #endif
792  
793  /**
794   * @}
795   */
796  
797  #endif /* LLVM_C_LTO_H */
798