1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
|
//===-- Reader.h - Interface To Bytecode Reading ----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This header file defines the interface to the Bytecode Reader which is
// responsible for correctly interpreting bytecode files (backwards compatible)
// and materializing a module from the bytecode read.
//
//===----------------------------------------------------------------------===//
#ifndef BYTECODE_PARSER_H
#define BYTECODE_PARSER_H
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/GlobalValue.h"
#include "llvm/Function.h"
#include "llvm/ModuleProvider.h"
#include "llvm/Bytecode/Analyzer.h"
#include <utility>
#include <map>
namespace llvm {
class BytecodeHandler; ///< Forward declare the handler interface
/// This class defines the interface for parsing a buffer of bytecode. The
/// parser itself takes no action except to call the various functions of
/// the handler interface. The parser's sole responsibility is the correct
/// interpretation of the bytecode buffer. The handler is responsible for
/// instantiating and keeping track of all values. As a convenience, the parser
/// is responsible for materializing types and will pass them through the
/// handler interface as necessary.
/// @see BytecodeHandler
/// @brief Bytecode Reader interface
class BytecodeReader : public ModuleProvider {
/// @name Constructors
/// @{
public:
/// @brief Default constructor. By default, no handler is used.
BytecodeReader(BytecodeHandler* h = 0) {
decompressedBlock = 0;
Handler = h;
}
~BytecodeReader() {
freeState();
if (decompressedBlock) {
::free(decompressedBlock);
decompressedBlock = 0;
}
}
/// @}
/// @name Types
/// @{
public:
/// @brief A convenience type for the buffer pointer
typedef const unsigned char* BufPtr;
/// @brief The type used for a vector of potentially abstract types
typedef std::vector<PATypeHolder> TypeListTy;
/// This type provides a vector of Value* via the User class for
/// storage of Values that have been constructed when reading the
/// bytecode. Because of forward referencing, constant replacement
/// can occur so we ensure that our list of Value* is updated
/// properly through those transitions. This ensures that the
/// correct Value* is in our list when it comes time to associate
/// constants with global variables at the end of reading the
/// globals section.
/// @brief A list of values as a User of those Values.
class ValueList : public User {
std::vector<Use> Uses;
public:
ValueList() : User(Type::VoidTy, Value::ArgumentVal, 0, 0) {}
// vector compatibility methods
unsigned size() const { return getNumOperands(); }
void push_back(Value *V) {
Uses.push_back(Use(V, this));
OperandList = &Uses[0];
++NumOperands;
}
Value *back() const { return Uses.back(); }
void pop_back() { Uses.pop_back(); --NumOperands; }
bool empty() const { return NumOperands == 0; }
virtual void print(std::ostream& os) const {
for (unsigned i = 0; i < size(); ++i) {
os << i << " ";
getOperand(i)->print(os);
os << "\n";
}
}
};
/// @brief A 2 dimensional table of values
typedef std::vector<ValueList*> ValueTable;
/// This map is needed so that forward references to constants can be looked
/// up by Type and slot number when resolving those references.
/// @brief A mapping of a Type/slot pair to a Constant*.
typedef std::map<std::pair<unsigned,unsigned>, Constant*> ConstantRefsType;
/// For lazy read-in of functions, we need to save the location in the
/// data stream where the function is located. This structure provides that
/// information. Lazy read-in is used mostly by the JIT which only wants to
/// resolve functions as it needs them.
/// @brief Keeps pointers to function contents for later use.
struct LazyFunctionInfo {
const unsigned char *Buf, *EndBuf;
LazyFunctionInfo(const unsigned char *B = 0, const unsigned char *EB = 0)
: Buf(B), EndBuf(EB) {}
};
/// @brief A mapping of functions to their LazyFunctionInfo for lazy reading.
typedef std::map<Function*, LazyFunctionInfo> LazyFunctionMap;
/// @brief A list of global variables and the slot number that initializes
/// them.
typedef std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitsList;
/// This type maps a typeslot/valueslot pair to the corresponding Value*.
/// It is used for dealing with forward references as values are read in.
/// @brief A map for dealing with forward references of values.
typedef std::map<std::pair<unsigned,unsigned>,Value*> ForwardReferenceMap;
/// @}
/// @name Methods
/// @{
public:
/// @brief Main interface to parsing a bytecode buffer.
void ParseBytecode(
const unsigned char *Buf, ///< Beginning of the bytecode buffer
unsigned Length, ///< Length of the bytecode buffer
const std::string &ModuleID ///< An identifier for the module constructed.
);
/// @brief Parse all function bodies
void ParseAllFunctionBodies();
/// @brief Parse the next function of specific type
void ParseFunction(Function* Func) ;
/// This method is abstract in the parent ModuleProvider class. Its
/// implementation is identical to the ParseFunction method.
/// @see ParseFunction
/// @brief Make a specific function materialize.
virtual void materializeFunction(Function *F) {
LazyFunctionMap::iterator Fi = LazyFunctionLoadMap.find(F);
if (Fi == LazyFunctionLoadMap.end()) return;
ParseFunction(F);
}
/// This method is abstract in the parent ModuleProvider class. Its
/// implementation is identical to ParseAllFunctionBodies.
/// @see ParseAllFunctionBodies
/// @brief Make the whole module materialize
virtual Module* materializeModule() {
ParseAllFunctionBodies();
return TheModule;
}
/// This method is provided by the parent ModuleProvde class and overriden
/// here. It simply releases the module from its provided and frees up our
/// state.
/// @brief Release our hold on the generated module
Module* releaseModule() {
// Since we're losing control of this Module, we must hand it back complete
Module *M = ModuleProvider::releaseModule();
freeState();
return M;
}
/// @}
/// @name Parsing Units For Subclasses
/// @{
protected:
/// @brief Parse whole module scope
void ParseModule();
/// @brief Parse the version information block
void ParseVersionInfo();
/// @brief Parse the ModuleGlobalInfo block
void ParseModuleGlobalInfo();
/// @brief Parse a symbol table
void ParseSymbolTable( Function* Func, SymbolTable *ST);
/// @brief Parse functions lazily.
void ParseFunctionLazily();
/// @brief Parse a function body
void ParseFunctionBody(Function* Func);
/// @brief Parse the type list portion of a compaction table
void ParseCompactionTypes(unsigned NumEntries);
/// @brief Parse a compaction table
void ParseCompactionTable();
/// @brief Parse global types
void ParseGlobalTypes();
/// @brief Parse a basic block (for LLVM 1.0 basic block blocks)
BasicBlock* ParseBasicBlock(unsigned BlockNo);
/// @brief parse an instruction list (for post LLVM 1.0 instruction lists
/// with blocks differentiated by terminating instructions.
unsigned ParseInstructionList(
Function* F ///< The function into which BBs will be inserted
);
/// @brief Parse a single instruction.
void ParseInstruction(
std::vector<unsigned>& Args, ///< The arguments to be filled in
BasicBlock* BB ///< The BB the instruction goes in
);
/// @brief Parse the whole constant pool
void ParseConstantPool(ValueTable& Values, TypeListTy& Types,
bool isFunction);
/// @brief Parse a single constant value
Constant* ParseConstantValue(unsigned TypeID);
/// @brief Parse a block of types constants
void ParseTypes(TypeListTy &Tab, unsigned NumEntries);
/// @brief Parse a single type constant
const Type *ParseType();
/// @brief Parse a string constants block
void ParseStringConstants(unsigned NumEntries, ValueTable &Tab);
/// @}
/// @name Data
/// @{
private:
char* decompressedBlock; ///< Result of decompression
BufPtr MemStart; ///< Start of the memory buffer
BufPtr MemEnd; ///< End of the memory buffer
BufPtr BlockStart; ///< Start of current block being parsed
BufPtr BlockEnd; ///< End of current block being parsed
BufPtr At; ///< Where we're currently parsing at
/// Information about the module, extracted from the bytecode revision number.
///
unsigned char RevisionNum; // The rev # itself
/// Flags to distinguish LLVM 1.0 & 1.1 bytecode formats (revision #0)
/// Revision #0 had an explicit alignment of data only for the
/// ModuleGlobalInfo block. This was fixed to be like all other blocks in 1.2
bool hasInconsistentModuleGlobalInfo;
/// Revision #0 also explicitly encoded zero values for primitive types like
/// int/sbyte/etc.
bool hasExplicitPrimitiveZeros;
// Flags to control features specific the LLVM 1.2 and before (revision #1)
/// LLVM 1.2 and earlier required that getelementptr structure indices were
/// ubyte constants and that sequential type indices were longs.
bool hasRestrictedGEPTypes;
/// LLVM 1.2 and earlier had class Type deriving from Value and the Type
/// objects were located in the "Type Type" plane of various lists in read
/// by the bytecode reader. In LLVM 1.3 this is no longer the case. Types are
/// completely distinct from Values. Consequently, Types are written in fixed
/// locations in LLVM 1.3. This flag indicates that the older Type derived
/// from Value style of bytecode file is being read.
bool hasTypeDerivedFromValue;
/// LLVM 1.2 and earlier encoded block headers as two uint (8 bytes), one for
/// the size and one for the type. This is a bit wasteful, especially for
/// small files where the 8 bytes per block is a large fraction of the total
/// block size. In LLVM 1.3, the block type and length are encoded into a
/// single uint32 by restricting the number of block types (limit 31) and the
/// maximum size of a block (limit 2^27-1=134,217,727). Note that the module
/// block still uses the 8-byte format so the maximum size of a file can be
/// 2^32-1 bytes long.
bool hasLongBlockHeaders;
/// LLVM 1.2 and earlier wrote type slot numbers as vbr_uint32. In LLVM 1.3
/// this has been reduced to vbr_uint24. It shouldn't make much difference
/// since we haven't run into a module with > 24 million types, but for safety
/// the 24-bit restriction has been enforced in 1.3 to free some bits in
/// various places and to ensure consistency. In particular, global vars are
/// restricted to 24-bits.
bool has32BitTypes;
/// LLVM 1.2 and earlier did not provide a target triple nor a list of
/// libraries on which the bytecode is dependent. LLVM 1.3 provides these
/// features, for use in future versions of LLVM.
bool hasNoDependentLibraries;
/// LLVM 1.3 and earlier caused blocks and other fields to start on 32-bit
/// aligned boundaries. This can lead to as much as 30% bytecode size overhead
/// in various corner cases (lots of long instructions). In LLVM 1.4,
/// alignment of bytecode fields was done away with completely.
bool hasAlignment;
// In version 4 and earlier, the bytecode format did not support the 'undef'
// constant.
bool hasNoUndefValue;
// In version 4 and earlier, the bytecode format did not save space for flags
// in the global info block for functions.
bool hasNoFlagsForFunctions;
// In version 4 and earlier, there was no opcode space reserved for the
// unreachable instruction.
bool hasNoUnreachableInst;
/// CompactionTypes - If a compaction table is active in the current function,
/// this is the mapping that it contains. We keep track of what resolved type
/// it is as well as what global type entry it is.
std::vector<std::pair<const Type*, unsigned> > CompactionTypes;
/// @brief If a compaction table is active in the current function,
/// this is the mapping that it contains.
std::vector<std::vector<Value*> > CompactionValues;
/// @brief This vector is used to deal with forward references to types in
/// a module.
TypeListTy ModuleTypes;
/// @brief This is an inverse mapping of ModuleTypes from the type to an
/// index. Because refining types causes the index of this map to be
/// invalidated, any time we refine a type, we clear this cache and recompute
/// it next time we need it. These entries are ordered by the pointer value.
std::vector<std::pair<const Type*, unsigned> > ModuleTypeIDCache;
/// @brief This vector is used to deal with forward references to types in
/// a function.
TypeListTy FunctionTypes;
/// When the ModuleGlobalInfo section is read, we create a Function object
/// for each function in the module. When the function is loaded, after the
/// module global info is read, this Function is populated. Until then, the
/// functions in this vector just hold the function signature.
std::vector<Function*> FunctionSignatureList;
/// @brief This is the table of values belonging to the current function
ValueTable FunctionValues;
/// @brief This is the table of values belonging to the module (global)
ValueTable ModuleValues;
/// @brief This keeps track of function level forward references.
ForwardReferenceMap ForwardReferences;
/// @brief The basic blocks we've parsed, while parsing a function.
std::vector<BasicBlock*> ParsedBasicBlocks;
/// This maintains a mapping between <Type, Slot #>'s and forward references
/// to constants. Such values may be referenced before they are defined, and
/// if so, the temporary object that they represent is held here. @brief
/// Temporary place for forward references to constants.
ConstantRefsType ConstantFwdRefs;
/// Constant values are read in after global variables. Because of this, we
/// must defer setting the initializers on global variables until after module
/// level constants have been read. In the mean time, this list keeps track
/// of what we must do.
GlobalInitsList GlobalInits;
// For lazy reading-in of functions, we need to save away several pieces of
// information about each function: its begin and end pointer in the buffer
// and its FunctionSlot.
LazyFunctionMap LazyFunctionLoadMap;
/// This stores the parser's handler which is used for handling tasks other
/// just than reading bytecode into the IR. If this is non-null, calls on
/// the (polymorphic) BytecodeHandler interface (see llvm/Bytecode/Handler.h)
/// will be made to report the logical structure of the bytecode file. What
/// the handler does with the events it receives is completely orthogonal to
/// the business of parsing the bytecode and building the IR. This is used,
/// for example, by the llvm-abcd tool for analysis of byte code.
/// @brief Handler for parsing events.
BytecodeHandler* Handler;
/// @}
/// @name Implementation Details
/// @{
private:
/// @brief Determines if this module has a function or not.
bool hasFunctions() { return ! FunctionSignatureList.empty(); }
/// @brief Determines if the type id has an implicit null value.
bool hasImplicitNull(unsigned TyID );
/// @brief Converts a type slot number to its Type*
const Type *getType(unsigned ID);
/// @brief Converts a pre-sanitized type slot number to its Type* and
/// sanitizes the type id.
inline const Type* getSanitizedType(unsigned& ID );
/// @brief Read in and get a sanitized type id
inline const Type* readSanitizedType();
/// @brief Converts a Type* to its type slot number
unsigned getTypeSlot(const Type *Ty);
/// @brief Converts a normal type slot number to a compacted type slot num.
unsigned getCompactionTypeSlot(unsigned type);
/// @brief Gets the global type corresponding to the TypeId
const Type *getGlobalTableType(unsigned TypeId);
/// This is just like getTypeSlot, but when a compaction table is in use,
/// it is ignored.
unsigned getGlobalTableTypeSlot(const Type *Ty);
/// @brief Get a value from its typeid and slot number
Value* getValue(unsigned TypeID, unsigned num, bool Create = true);
/// @brief Get a value from its type and slot number, ignoring compaction
/// tables.
Value *getGlobalTableValue(unsigned TyID, unsigned SlotNo);
/// @brief Get a basic block for current function
BasicBlock *getBasicBlock(unsigned ID);
/// @brief Get a constant value from its typeid and value slot.
Constant* getConstantValue(unsigned typeSlot, unsigned valSlot);
/// @brief Convenience function for getting a constant value when
/// the Type has already been resolved.
Constant* getConstantValue(const Type *Ty, unsigned valSlot) {
return getConstantValue(getTypeSlot(Ty), valSlot);
}
/// @brief Insert a newly created value
unsigned insertValue(Value *V, unsigned Type, ValueTable &Table);
/// @brief Insert the arguments of a function.
void insertArguments(Function* F );
/// @brief Resolve all references to the placeholder (if any) for the
/// given constant.
void ResolveReferencesToConstant(Constant *C, unsigned Typ, unsigned Slot);
/// @brief Release our memory.
void freeState() {
freeTable(FunctionValues);
freeTable(ModuleValues);
}
/// @brief Free a table, making sure to free the ValueList in the table.
void freeTable(ValueTable &Tab) {
while (!Tab.empty()) {
delete Tab.back();
Tab.pop_back();
}
}
inline void error(std::string errmsg);
BytecodeReader(const BytecodeReader &); // DO NOT IMPLEMENT
void operator=(const BytecodeReader &); // DO NOT IMPLEMENT
/// @}
/// @name Reader Primitives
/// @{
private:
/// @brief Is there more to parse in the current block?
inline bool moreInBlock();
/// @brief Have we read past the end of the block
inline void checkPastBlockEnd(const char * block_name);
/// @brief Align to 32 bits
inline void align32();
/// @brief Read an unsigned integer as 32-bits
inline unsigned read_uint();
/// @brief Read an unsigned integer with variable bit rate encoding
inline unsigned read_vbr_uint();
/// @brief Read an unsigned integer of no more than 24-bits with variable
/// bit rate encoding.
inline unsigned read_vbr_uint24();
/// @brief Read an unsigned 64-bit integer with variable bit rate encoding.
inline uint64_t read_vbr_uint64();
/// @brief Read a signed 64-bit integer with variable bit rate encoding.
inline int64_t read_vbr_int64();
/// @brief Read a string
inline std::string read_str();
/// @brief Read a float value
inline void read_float(float& FloatVal);
/// @brief Read a double value
inline void read_double(double& DoubleVal);
/// @brief Read an arbitrary data chunk of fixed length
inline void read_data(void *Ptr, void *End);
/// @brief Read a bytecode block header
inline void read_block(unsigned &Type, unsigned &Size);
/// @brief Read a type identifier and sanitize it.
inline bool read_typeid(unsigned &TypeId);
/// @brief Recalculate type ID for pre 1.3 bytecode files.
inline bool sanitizeTypeId(unsigned &TypeId );
/// @}
};
/// @brief A function for creating a BytecodeAnalzer as a handler
/// for the Bytecode reader.
BytecodeHandler* createBytecodeAnalyzerHandler(BytecodeAnalysis& bca,
std::ostream* output );
} // End llvm namespace
// vim: sw=2
#endif
|