LLVM  10.0.0svn
lto.h
Go to the documentation of this file.
1 /*===-- llvm-c/lto.h - LTO Public C Interface ---------------------*- C -*-===*\
2 |* *|
3 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM *|
4 |* Exceptions. *|
5 |* See https://llvm.org/LICENSE.txt for license information. *|
6 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *|
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 24
48 
49 /**
50  * \since prior to LTO_API_VERSION=3
51  */
52 typedef enum {
53  LTO_SYMBOL_ALIGNMENT_MASK = 0x0000001F, /* log2 of alignment */
64  LTO_SYMBOL_SCOPE_MASK = 0x00003800,
70  LTO_SYMBOL_COMDAT = 0x00004000,
71  LTO_SYMBOL_ALIAS = 0x00008000
73 
74 /**
75  * \since prior to LTO_API_VERSION=3
76  */
77 typedef enum {
81 
82 /**
83  * \since prior to LTO_API_VERSION=3
84  */
85 typedef enum {
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*
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  * 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  * 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
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*
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
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  */
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*
299 
300 /**
301  * Diagnostic severity.
302  *
303  * \since LTO_API_VERSION=7
304  */
305 typedef enum {
308  LTO_DS_REMARK = 3, // Added in LTO_API_VERSION=10.
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  */
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  * 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
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
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
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
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
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
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
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
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
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
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*
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
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
539  lto_bool_t ShouldInternalize);
540 
541 /**
542  * 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
551  lto_bool_t ShouldEmbedUselists);
552 
553 /**
554  * @} // endgoup LLVMCLTO
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;
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  */
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  */
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  */
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  */
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  */
637  unsigned int index);
638 
639 /**
640  * Returns the number of object files produced by the ThinLTO CodeGenerator.
641  *
642  * It usually matches the number of input files, but this is not a guarantee of
643  * the API and may change in future implementation, so the client should not
644  * assume it.
645  *
646  * \since LTO_API_VERSION=21
647  */
649 
650 /**
651  * Returns the path to the ith object file produced by the ThinLTO
652  * CodeGenerator.
653  *
654  * Client should use \p thinlto_module_get_num_object_files() to get the number
655  * of available objects.
656  *
657  * \since LTO_API_VERSION=21
658  */
660  unsigned int index);
661 
662 /**
663  * Sets which PIC code model to generate.
664  * Returns true on error (check lto_get_error_message() for details).
665  *
666  * \since LTO_API_VERSION=18
667  */
670 
671 /**
672  * Sets the path to a directory to use as a storage for temporary bitcode files.
673  * The intention is to make the bitcode files available for debugging at various
674  * stage of the pipeline.
675  *
676  * \since LTO_API_VERSION=18
677  */
679  const char *save_temps_dir);
680 
681 /**
682  * Set the path to a directory where to save generated object files. This
683  * path can be used by a linker to request on-disk files instead of in-memory
684  * buffers. When set, results are available through
685  * thinlto_module_get_object_file() instead of thinlto_module_get_object().
686  *
687  * \since LTO_API_VERSION=21
688  */
690  const char *save_temps_dir);
691 
692 /**
693  * Sets the cpu to generate code for.
694  *
695  * \since LTO_API_VERSION=18
696  */
697 extern void thinlto_codegen_set_cpu(thinlto_code_gen_t cg, const char *cpu);
698 
699 /**
700  * Disable CodeGen, only run the stages till codegen and stop. The output will
701  * be bitcode.
702  *
703  * \since LTO_API_VERSION=19
704  */
706  lto_bool_t disable);
707 
708 /**
709  * Perform CodeGen only: disable all other stages.
710  *
711  * \since LTO_API_VERSION=19
712  */
714  lto_bool_t codegen_only);
715 
716 /**
717  * Parse -mllvm style debug options.
718  *
719  * \since LTO_API_VERSION=18
720  */
721 extern void thinlto_debug_options(const char *const *options, int number);
722 
723 /**
724  * Test if a module has support for ThinLTO linking.
725  *
726  * \since LTO_API_VERSION=18
727  */
729 
730 /**
731  * Adds a symbol to the list of global symbols that must exist in the final
732  * generated code. If a function is not listed there, it might be inlined into
733  * every usage and optimized away. For every single module, the functions
734  * referenced from code outside of the ThinLTO modules need to be added here.
735  *
736  * \since LTO_API_VERSION=18
737  */
739  const char *name,
740  int length);
741 
742 /**
743  * Adds a symbol to the list of global symbols that are cross-referenced between
744  * ThinLTO files. If the ThinLTO CodeGenerator can ensure that every
745  * references from a ThinLTO module to this symbol is optimized away, then
746  * the symbol can be discarded.
747  *
748  * \since LTO_API_VERSION=18
749  */
751  const char *name,
752  int length);
753 
754 /**
755  * @} // endgoup LLVMCTLTO
756  * @defgroup LLVMCTLTO_CACHING ThinLTO Cache Control
757  * @ingroup LLVMCTLTO
758  *
759  * These entry points control the ThinLTO cache. The cache is intended to
760  * support incremental builds, and thus needs to be persistent across builds.
761  * The client enables the cache by supplying a path to an existing directory.
762  * The code generator will use this to store objects files that may be reused
763  * during a subsequent build.
764  * To avoid filling the disk space, a few knobs are provided:
765  * - The pruning interval limits the frequency at which the garbage collector
766  * will try to scan the cache directory to prune expired entries.
767  * Setting to a negative number disables the pruning.
768  * - The pruning expiration time indicates to the garbage collector how old an
769  * entry needs to be to be removed.
770  * - Finally, the garbage collector can be instructed to prune the cache until
771  * the occupied space goes below a threshold.
772  * @{
773  */
774 
775 /**
776  * Sets the path to a directory to use as a cache storage for incremental build.
777  * Setting this activates caching.
778  *
779  * \since LTO_API_VERSION=18
780  */
782  const char *cache_dir);
783 
784 /**
785  * Sets the cache pruning interval (in seconds). A negative value disables the
786  * pruning. An unspecified default value will be applied, and a value of 0 will
787  * force prunning to occur.
788  *
789  * \since LTO_API_VERSION=18
790  */
792  int interval);
793 
794 /**
795  * Sets the maximum cache size that can be persistent across build, in terms of
796  * percentage of the available space on the disk. Set to 100 to indicate
797  * no limit, 50 to indicate that the cache size will not be left over half the
798  * available space. A value over 100 will be reduced to 100, a value of 0 will
799  * be ignored. An unspecified default value will be applied.
800  *
801  * The formula looks like:
802  * AvailableSpace = FreeSpace + ExistingCacheSize
803  * NewCacheSize = AvailableSpace * P/100
804  *
805  * \since LTO_API_VERSION=18
806  */
808  thinlto_code_gen_t cg, unsigned percentage);
809 
810 /**
811  * Sets the expiration (in seconds) for an entry in the cache. An unspecified
812  * default value will be applied. A value of 0 will be ignored.
813  *
814  * \since LTO_API_VERSION=18
815  */
817  unsigned expiration);
818 
819 /**
820  * Sets the maximum size of the cache directory (in bytes). A value over the
821  * amount of available space on the disk will be reduced to the amount of
822  * available space. An unspecified default value will be applied. A value of 0
823  * will be ignored.
824  *
825  * \since LTO_API_VERSION=22
826  */
828  unsigned max_size_bytes);
829 
830 /**
831  * Same as thinlto_codegen_set_cache_size_bytes, except the maximum size is in
832  * megabytes (2^20 bytes).
833  *
834  * \since LTO_API_VERSION=23
835  */
836 extern void
838  unsigned max_size_megabytes);
839 
840 /**
841  * Sets the maximum number of files in the cache directory. An unspecified
842  * default value will be applied. A value of 0 will be ignored.
843  *
844  * \since LTO_API_VERSION=22
845  */
847  unsigned max_size_files);
848 
849 /** Opaque reference to an LTO input file */
850 typedef struct LLVMOpaqueLTOInput *lto_input_t;
851 
852 /**
853  * Creates an LTO input file from a buffer. The path
854  * argument is used for diagnotics as this function
855  * otherwise does not know which file the given buffer
856  * is associated with.
857  *
858  * \since LTO_API_VERSION=24
859  */
860 extern lto_input_t lto_input_create(const void *buffer,
861  size_t buffer_size,
862  const char *path);
863 
864 /**
865  * Frees all memory internally allocated by the LTO input file.
866  * Upon return the lto_module_t is no longer valid.
867  *
868  * \since LTO_API_VERSION=24
869  */
870 extern void lto_input_dispose(lto_input_t input);
871 
872 /**
873  * Returns the number of dependent library specifiers
874  * for the given LTO input file.
875  *
876  * \since LTO_API_VERSION=24
877  */
878 extern unsigned lto_input_get_num_dependent_libraries(lto_input_t input);
879 
880 /**
881  * Returns the ith dependent library specifier
882  * for the given LTO input file. The returned
883  * string is not null-terminated.
884  *
885  * \since LTO_API_VERSION=24
886  */
887 extern const char * lto_input_get_dependent_library(lto_input_t input,
888  size_t index,
889  size_t *size);
890 
891 /**
892  * @} // endgroup LLVMCTLTO_CACHING
893  */
894 
895 #ifdef __cplusplus
896 }
897 #endif
898 
899 #endif /* LLVM_C_LTO_H */
void lto_codegen_set_diagnostic_handler(lto_code_gen_t, lto_diagnostic_handler_t, void *)
Set a diagnostic handler and the related context (void *).
unsigned int thinlto_module_get_num_objects(thinlto_code_gen_t cg)
Returns the number of object files produced by the ThinLTO CodeGenerator.
void thinlto_codegen_set_cpu(thinlto_code_gen_t cg, const char *cpu)
Sets the cpu to generate code for.
lto_module_t lto_module_create_in_local_context(const void *mem, size_t length, const char *path)
Loads an object file in its own context.
lto_code_gen_t lto_codegen_create(void)
Instantiates a code generator.
lto_bool_t lto_module_is_object_file_in_memory(const void *mem, size_t length)
Checks if a buffer is a loadable object file.
struct LLVMOpaqueLTOModule * lto_module_t
opaque reference to a loaded object module
Definition: lto.h:93
lto_module_t lto_module_create(const char *path)
Loads an object file from disk.
lto_codegen_diagnostic_severity_t
Diagnostic severity.
Definition: lto.h:305
lto_bool_t lto_module_is_thinlto(lto_module_t mod)
Test if a module has support for ThinLTO linking.
const char * lto_input_get_dependent_library(lto_input_t input, size_t index, size_t *size)
Returns the ith dependent library specifier for the given LTO input file.
void lto_codegen_set_should_internalize(lto_code_gen_t cg, lto_bool_t ShouldInternalize)
Sets if we should run internalize pass during optimization and code generation.
size_t Size
Definition: lto.h:568
lto_input_t lto_input_create(const void *buffer, size_t buffer_size, const char *path)
Creates an LTO input file from a buffer.
void thinlto_codegen_set_cache_size_files(thinlto_code_gen_t cg, unsigned max_size_files)
Sets the maximum number of files in the cache directory.
void thinlto_codegen_set_cache_size_bytes(thinlto_code_gen_t cg, unsigned max_size_bytes)
Sets the maximum size of the cache directory (in bytes).
lto_symbol_attributes lto_module_get_symbol_attribute(lto_module_t mod, unsigned int index)
Returns the attributes of the ith symbol in the object module.
lto_module_t lto_module_create_from_fd_at_offset(int fd, const char *path, size_t file_size, size_t map_size, off_t offset)
Loads an object file from disk.
lto_bool_t lto_module_is_object_file_in_memory_for_target(const void *mem, size_t length, const char *target_triple_prefix)
Checks if a buffer is a loadable object compiled for requested target.
void thinlto_codegen_set_cache_size_megabytes(thinlto_code_gen_t cg, unsigned max_size_megabytes)
Same as thinlto_codegen_set_cache_size_bytes, except the maximum size is in megabytes (2^20 bytes)...
const void * lto_codegen_compile(lto_code_gen_t cg, size_t *length)
Generates code for all added modules into one native object file.
bool lto_bool_t
Definition: lto.h:29
void lto_codegen_set_module(lto_code_gen_t cg, lto_module_t mod)
Sets the object module for code generation.
std::error_code file_size(const Twine &Path, uint64_t &Result)
Get file size.
Definition: FileSystem.h:696
Type to wrap a single object returned by ThinLTO.
Definition: lto.h:566
void thinlto_codegen_dispose(thinlto_code_gen_t cg)
Frees the generator and all memory it internally allocated.
void lto_codegen_set_assembler_path(lto_code_gen_t cg, const char *path)
Sets the location of the assembler tool to run.
void lto_codegen_set_assembler_args(lto_code_gen_t cg, const char **args, int nargs)
Sets extra arguments that libLTO should pass to the assembler.
void lto_codegen_set_should_embed_uselists(lto_code_gen_t cg, lto_bool_t ShouldEmbedUselists)
Set whether to embed uselists in bitcode.
unsigned int lto_module_get_num_symbols(lto_module_t mod)
Returns the number of symbols in the object module.
lto_module_t lto_module_create_in_codegen_context(const void *mem, size_t length, const char *path, lto_code_gen_t cg)
Loads an object file in the codegen context.
void thinlto_codegen_set_codegen_only(thinlto_code_gen_t cg, lto_bool_t codegen_only)
Perform CodeGen only: disable all other stages.
lto_debug_model
Definition: lto.h:77
lto_bool_t lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model)
Sets which PIC code model to generated.
lto_bool_t lto_module_is_object_file_for_target(const char *path, const char *target_triple_prefix)
Checks if a file is a loadable object compiled for requested target.
unsigned int lto_api_version(void)
Returns the runtime API version.
lto_module_t lto_module_create_from_memory_with_path(const void *mem, size_t length, const char *path)
Loads an object file from memory with an extra path argument.
lto_bool_t lto_codegen_compile_to_file(lto_code_gen_t cg, const char **name)
Generates code for all added modules into one native object file.
void thinlto_debug_options(const char *const *options, int number)
Parse -mllvm style debug options.
void lto_module_set_target_triple(lto_module_t mod, const char *triple)
Sets triple string with which the object will be codegened.
void thinlto_set_generated_objects_dir(thinlto_code_gen_t cg, const char *save_temps_dir)
Set the path to a directory where to save generated object files.
thinlto_code_gen_t thinlto_create_codegen(void)
Instantiates a ThinLTO code generator.
void thinlto_codegen_process(thinlto_code_gen_t cg)
Optimize and codegen all the modules added to the codegenerator using ThinLTO.
struct LLVMOpaqueThinLTOCodeGenerator * thinlto_code_gen_t
opaque reference to a thin code generator
Definition: lto.h:99
void thinlto_codegen_add_module(thinlto_code_gen_t cg, const char *identifier, const char *data, int length)
Add a module to a ThinLTO code generator.
struct LLVMOpaqueLTOCodeGenerator * lto_code_gen_t
opaque reference to a code generator
Definition: lto.h:96
void thinlto_codegen_set_final_cache_size_relative_to_available_space(thinlto_code_gen_t cg, unsigned percentage)
Sets the maximum cache size that can be persistent across build, in terms of percentage of the availa...
lto_module_t lto_module_create_from_memory(const void *mem, size_t length)
Loads an object file from memory.
lto_bool_t thinlto_codegen_set_pic_model(thinlto_code_gen_t cg, lto_codegen_model)
Sets which PIC code model to generate.
void(* lto_diagnostic_handler_t)(lto_codegen_diagnostic_severity_t severity, const char *diag, void *ctxt)
Diagnostic handler type.
Definition: lto.h:321
void lto_codegen_debug_options(lto_code_gen_t cg, const char *)
Sets options to help debug codegen bugs.
LTOObjectBuffer thinlto_module_get_object(thinlto_code_gen_t cg, unsigned int index)
Returns a reference to the ith object file produced by the ThinLTO CodeGenerator. ...
lto_bool_t lto_codegen_optimize(lto_code_gen_t cg)
Runs optimization for the merged module.
auto size(R &&Range, typename std::enable_if< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr) -> decltype(std::distance(Range.begin(), Range.end()))
Get the size of a range.
Definition: STLExtras.h:1146
lto_code_gen_t lto_codegen_create_in_local_context(void)
Instantiate a code generator in its own context.
lto_bool_t lto_module_is_object_file(const char *path)
Checks if a file is a loadable object file.
struct LLVMOpaqueLTOInput * lto_input_t
Opaque reference to an LTO input file.
Definition: lto.h:850
void lto_input_dispose(lto_input_t input)
Frees all memory internally allocated by the LTO input file.
const char * lto_get_version(void)
Returns a printable string.
const char * Buffer
Definition: lto.h:567
void thinlto_codegen_disable_codegen(thinlto_code_gen_t cg, lto_bool_t disable)
Disable CodeGen, only run the stages till codegen and stop.
lto_codegen_model
Definition: lto.h:85
void thinlto_codegen_set_cache_pruning_interval(thinlto_code_gen_t cg, int interval)
Sets the cache pruning interval (in seconds).
unsigned int thinlto_module_get_num_object_files(thinlto_code_gen_t cg)
Returns the number of object files produced by the ThinLTO CodeGenerator.
const char * lto_get_error_message(void)
Returns the last error string or NULL if last operation was successful.
void lto_codegen_set_cpu(lto_code_gen_t cg, const char *cpu)
Sets the cpu to generate code for.
void thinlto_codegen_set_savetemps_dir(thinlto_code_gen_t cg, const char *save_temps_dir)
Sets the path to a directory to use as a storage for temporary bitcode files.
void thinlto_codegen_set_cache_dir(thinlto_code_gen_t cg, const char *cache_dir)
Sets the path to a directory to use as a cache storage for incremental build.
lto_module_t lto_module_create_from_fd(int fd, const char *path, size_t file_size)
Loads an object file from disk.
unsigned lto_input_get_num_dependent_libraries(lto_input_t input)
Returns the number of dependent library specifiers for the given LTO input file.
void lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg, const char *symbol)
Adds to a list of all global symbols that must exist in the final generated code. ...
lto_bool_t lto_module_has_objc_category(const void *mem, size_t length)
Return true if Buffer contains a bitcode file with ObjC code (category or class) in it...
void lto_initialize_disassembler(void)
Initializes LLVM disassemblers.
lto_symbol_attributes
Definition: lto.h:52
void lto_module_dispose(lto_module_t mod)
Frees all memory internally allocated by the module.
void thinlto_codegen_set_cache_entry_expiration(thinlto_code_gen_t cg, unsigned expiration)
Sets the expiration (in seconds) for an entry in the cache.
lto_bool_t lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod)
Add an object module to the set of modules for which code will be generated.
lto_bool_t lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model)
Sets if debug info should be generated.
const char * lto_module_get_linkeropts(lto_module_t mod)
Returns the module&#39;s linker options.
void lto_codegen_dispose(lto_code_gen_t)
Frees all code generator and all memory it internally allocated.
static const char * name
const char * lto_module_get_target_triple(lto_module_t mod)
Returns triple string which the object module was compiled under.
const char * thinlto_module_get_object_file(thinlto_code_gen_t cg, unsigned int index)
Returns the path to the ith object file produced by the ThinLTO CodeGenerator.
void thinlto_codegen_add_cross_referenced_symbol(thinlto_code_gen_t cg, const char *name, int length)
Adds a symbol to the list of global symbols that are cross-referenced between ThinLTO files...
lto_bool_t lto_codegen_write_merged_modules(lto_code_gen_t cg, const char *path)
Writes a new object file at the specified path that contains the merged contents of all modules added...
const char * lto_module_get_symbol_name(lto_module_t mod, unsigned int index)
Returns the name of the ith symbol in the object module.
void thinlto_codegen_add_must_preserve_symbol(thinlto_code_gen_t cg, const char *name, int length)
Adds a symbol to the list of global symbols that must exist in the final generated code...
const void * lto_codegen_compile_optimized(lto_code_gen_t cg, size_t *length)
Generates code for the optimized merged module into one native object file.