← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm-c/lto.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm-c/lto.h
 
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 LTO_H
 
17
#define LTO_H  1
 
18
 
 
19
#include <stdbool.h>
 
20
#include <stddef.h>
 
21
 
 
22
#define LTO_API_VERSION 3
 
23
 
 
24
typedef enum {
 
25
    LTO_SYMBOL_ALIGNMENT_MASK         = 0x0000001F,    /* log2 of alignment */
 
26
    LTO_SYMBOL_PERMISSIONS_MASK       = 0x000000E0,    
 
27
    LTO_SYMBOL_PERMISSIONS_CODE       = 0x000000A0,    
 
28
    LTO_SYMBOL_PERMISSIONS_DATA       = 0x000000C0,    
 
29
    LTO_SYMBOL_PERMISSIONS_RODATA     = 0x00000080,    
 
30
    LTO_SYMBOL_DEFINITION_MASK        = 0x00000700,    
 
31
    LTO_SYMBOL_DEFINITION_REGULAR     = 0x00000100,    
 
32
    LTO_SYMBOL_DEFINITION_TENTATIVE   = 0x00000200,    
 
33
    LTO_SYMBOL_DEFINITION_WEAK        = 0x00000300,    
 
34
    LTO_SYMBOL_DEFINITION_UNDEFINED   = 0x00000400,    
 
35
    LTO_SYMBOL_DEFINITION_WEAKUNDEF   = 0x00000500,
 
36
    LTO_SYMBOL_SCOPE_MASK             = 0x00003800,    
 
37
    LTO_SYMBOL_SCOPE_INTERNAL         = 0x00000800,    
 
38
    LTO_SYMBOL_SCOPE_HIDDEN           = 0x00001000,    
 
39
    LTO_SYMBOL_SCOPE_PROTECTED        = 0x00002000,    
 
40
    LTO_SYMBOL_SCOPE_DEFAULT          = 0x00001800    
 
41
} lto_symbol_attributes;
 
42
 
 
43
typedef enum {
 
44
    LTO_DEBUG_MODEL_NONE         = 0,
 
45
    LTO_DEBUG_MODEL_DWARF        = 1
 
46
} lto_debug_model;
 
47
 
 
48
typedef enum {
 
49
    LTO_CODEGEN_PIC_MODEL_STATIC         = 0,
 
50
    LTO_CODEGEN_PIC_MODEL_DYNAMIC        = 1,
 
51
    LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2
 
52
} lto_codegen_model;
 
53
 
 
54
 
 
55
/** opaque reference to a loaded object module */
 
56
typedef struct LTOModule*         lto_module_t;
 
57
 
 
58
/** opaque reference to a code generator */
 
59
typedef struct LTOCodeGenerator*  lto_code_gen_t;
 
60
 
 
61
#ifdef __cplusplus
 
62
extern "C" {
 
63
#endif
 
64
 
 
65
/**
 
66
 * Returns a printable string.
 
67
 */
 
68
extern const char*
 
69
lto_get_version(void);
 
70
 
 
71
 
 
72
/**
 
73
 * Returns the last error string or NULL if last operation was sucessful.
 
74
 */
 
75
extern const char*
 
76
lto_get_error_message(void);
 
77
 
 
78
/**
 
79
 * Checks if a file is a loadable object file.
 
80
 */
 
81
extern bool
 
82
lto_module_is_object_file(const char* path);
 
83
 
 
84
 
 
85
/**
 
86
 * Checks if a file is a loadable object compiled for requested target.
 
87
 */
 
88
extern bool
 
89
lto_module_is_object_file_for_target(const char* path, 
 
90
                                     const char* target_triple_prefix);
 
91
 
 
92
 
 
93
/**
 
94
 * Checks if a buffer is a loadable object file.
 
95
 */
 
96
extern bool
 
97
lto_module_is_object_file_in_memory(const void* mem, size_t length);
 
98
 
 
99
 
 
100
/**
 
101
 * Checks if a buffer is a loadable object compiled for requested target.
 
102
 */
 
103
extern bool
 
104
lto_module_is_object_file_in_memory_for_target(const void* mem, size_t length, 
 
105
                                               const char* target_triple_prefix);
 
106
 
 
107
 
 
108
/**
 
109
 * Loads an object file from disk.
 
110
 * Returns NULL on error (check lto_get_error_message() for details).
 
111
 */
 
112
extern lto_module_t
 
113
lto_module_create(const char* path);
 
114
 
 
115
 
 
116
/**
 
117
 * Loads an object file from memory.
 
118
 * Returns NULL on error (check lto_get_error_message() for details).
 
119
 */
 
120
extern lto_module_t
 
121
lto_module_create_from_memory(const void* mem, size_t length);
 
122
 
 
123
 
 
124
/**
 
125
 * Frees all memory internally allocated by the module.
 
126
 * Upon return the lto_module_t is no longer valid.
 
127
 */
 
128
extern void
 
129
lto_module_dispose(lto_module_t mod);
 
130
 
 
131
 
 
132
/**
 
133
 * Returns triple string which the object module was compiled under.
 
134
 */
 
135
extern const char*
 
136
lto_module_get_target_triple(lto_module_t mod);
 
137
 
 
138
 
 
139
/**
 
140
 * Returns the number of symbols in the object module.
 
141
 */
 
142
extern unsigned int
 
143
lto_module_get_num_symbols(lto_module_t mod);
 
144
 
 
145
 
 
146
/**
 
147
 * Returns the name of the ith symbol in the object module.
 
148
 */
 
149
extern const char*
 
150
lto_module_get_symbol_name(lto_module_t mod, unsigned int index);
 
151
 
 
152
 
 
153
/**
 
154
 * Returns the attributes of the ith symbol in the object module.
 
155
 */
 
156
extern lto_symbol_attributes
 
157
lto_module_get_symbol_attribute(lto_module_t mod, unsigned int index);
 
158
 
 
159
 
 
160
/**
 
161
 * Instantiates a code generator.
 
162
 * Returns NULL on error (check lto_get_error_message() for details).
 
163
 */
 
164
extern lto_code_gen_t
 
165
lto_codegen_create(void);
 
166
 
 
167
 
 
168
/**
 
169
 * Frees all code generator and all memory it internally allocated.
 
170
 * Upon return the lto_code_gen_t is no longer valid.
 
171
 */
 
172
extern void
 
173
lto_codegen_dispose(lto_code_gen_t);
 
174
 
 
175
 
 
176
 
 
177
/**
 
178
 * Add an object module to the set of modules for which code will be generated.
 
179
 * Returns true on error (check lto_get_error_message() for details).
 
180
 */
 
181
extern bool
 
182
lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod);
 
183
 
 
184
 
 
185
 
 
186
/**
 
187
 * Sets if debug info should be generated.
 
188
 * Returns true on error (check lto_get_error_message() for details).
 
189
 */
 
190
extern bool
 
191
lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model);
 
192
 
 
193
 
 
194
/**
 
195
 * Sets which PIC code model to generated.
 
196
 * Returns true on error (check lto_get_error_message() for details).
 
197
 */
 
198
extern bool
 
199
lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model);
 
200
 
 
201
 
 
202
/**
 
203
 * Sets the location of the "gcc" to run. If not set, libLTO will search for
 
204
 * "gcc" on the path.
 
205
 */
 
206
extern void
 
207
lto_codegen_set_gcc_path(lto_code_gen_t cg, const char* path);
 
208
 
 
209
 
 
210
/**
 
211
 * Sets the location of the assembler tool to run. If not set, libLTO
 
212
 * will use gcc to invoke the assembler.
 
213
 */
 
214
extern void
 
215
lto_codegen_set_assembler_path(lto_code_gen_t cg, const char* path);
 
216
 
 
217
 
 
218
/**
 
219
 * Adds to a list of all global symbols that must exist in the final
 
220
 * generated code.  If a function is not listed, it might be
 
221
 * inlined into every usage and optimized away.
 
222
 */
 
223
extern void
 
224
lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg, const char* symbol);
 
225
 
 
226
 
 
227
/**
 
228
 * Writes a new object file at the specified path that contains the
 
229
 * merged contents of all modules added so far.
 
230
 * Returns true on error (check lto_get_error_message() for details).
 
231
 */
 
232
extern bool
 
233
lto_codegen_write_merged_modules(lto_code_gen_t cg, const char* path);
 
234
 
 
235
 
 
236
/**
 
237
 * Generates code for all added modules into one native object file.
 
238
 * On sucess returns a pointer to a generated mach-o/ELF buffer and
 
239
 * length set to the buffer size.  The buffer is owned by the 
 
240
 * lto_code_gen_t and will be freed when lto_codegen_dispose()
 
241
 * is called, or lto_codegen_compile() is called again.
 
242
 * On failure, returns NULL (check lto_get_error_message() for details).
 
243
 */
 
244
extern const void*
 
245
lto_codegen_compile(lto_code_gen_t cg, size_t* length);
 
246
 
 
247
 
 
248
/**
 
249
 * Sets options to help debug codegen bugs.
 
250
 */
 
251
extern void
 
252
lto_codegen_debug_options(lto_code_gen_t cg, const char *);
 
253
#ifdef __cplusplus
 
254
}
 
255
#endif
 
256
 
 
257
 
 
258
#endif