← 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/CodeGen/AsmPrinter.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/CodeGen/AsmPrinter.h
 
1
//===-- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework --------*- 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 file contains a class to be used as the base class for target specific
 
11
// asm writers.  This class primarily handles common functionality used by
 
12
// all asm writers.
 
13
//
 
14
//===----------------------------------------------------------------------===//
 
15
 
 
16
#ifndef LLVM_CODEGEN_ASMPRINTER_H
 
17
#define LLVM_CODEGEN_ASMPRINTER_H
 
18
 
 
19
#include "llvm/CodeGen/MachineFunctionPass.h"
 
20
#include "llvm/Support/DebugLoc.h"
 
21
#include "llvm/Target/TargetMachine.h"
 
22
 
 
23
namespace llvm {
 
24
  class BlockAddress;
 
25
  class GCStrategy;
 
26
  class Constant;
 
27
  class ConstantArray;
 
28
  class ConstantFP;
 
29
  class ConstantInt;
 
30
  class ConstantStruct;
 
31
  class ConstantVector;
 
32
  class GCMetadataPrinter;
 
33
  class GlobalValue;
 
34
  class GlobalVariable;
 
35
  class MachineBasicBlock;
 
36
  class MachineFunction;
 
37
  class MachineInstr;
 
38
  class MachineLoopInfo;
 
39
  class MachineLoop;
 
40
  class MachineConstantPool;
 
41
  class MachineConstantPoolEntry;
 
42
  class MachineConstantPoolValue;
 
43
  class MachineJumpTableInfo;
 
44
  class MachineModuleInfo;
 
45
  class MCInst;
 
46
  class MCContext;
 
47
  class MCSection;
 
48
  class MCStreamer;
 
49
  class MCSymbol;
 
50
  class MDNode;
 
51
  class DwarfWriter;
 
52
  class Mangler;
 
53
  class MCAsmInfo;
 
54
  class TargetLoweringObjectFile;
 
55
  class Twine;
 
56
  class Type;
 
57
  class formatted_raw_ostream;
 
58
 
 
59
  /// AsmPrinter - This class is intended to be used as a driving class for all
 
60
  /// asm writers.
 
61
  class AsmPrinter : public MachineFunctionPass {
 
62
    static char ID;
 
63
 
 
64
    // GCMetadataPrinters - The garbage collection metadata printer table.
 
65
    typedef DenseMap<GCStrategy*,GCMetadataPrinter*> gcp_map_type;
 
66
    typedef gcp_map_type::iterator gcp_iterator;
 
67
    gcp_map_type GCMetadataPrinters;
 
68
 
 
69
    /// If VerboseAsm is set, a pointer to the loop info for this
 
70
    /// function.
 
71
    ///
 
72
    MachineLoopInfo *LI;
 
73
 
 
74
  public:
 
75
    /// MMI - If available, this is a pointer to the current MachineModuleInfo.
 
76
    MachineModuleInfo *MMI;
 
77
    
 
78
  protected:
 
79
    /// DW - If available, this is a pointer to the current dwarf writer.
 
80
    DwarfWriter *DW;
 
81
 
 
82
  public:
 
83
 
 
84
    /// Output stream on which we're printing assembly code.
 
85
    ///
 
86
    formatted_raw_ostream &O;
 
87
 
 
88
    /// Target machine description.
 
89
    ///
 
90
    TargetMachine &TM;
 
91
    
 
92
    /// getObjFileLowering - Return information about object file lowering.
 
93
    TargetLoweringObjectFile &getObjFileLowering() const;
 
94
    
 
95
    /// Target Asm Printer information.
 
96
    ///
 
97
    const MCAsmInfo *MAI;
 
98
 
 
99
    /// Target Register Information.
 
100
    ///
 
101
    const TargetRegisterInfo *TRI;
 
102
 
 
103
    /// OutContext - This is the context for the output file that we are
 
104
    /// streaming.  This owns all of the global MC-related objects for the
 
105
    /// generated translation unit.
 
106
    MCContext &OutContext;
 
107
    
 
108
    /// OutStreamer - This is the MCStreamer object for the file we are
 
109
    /// generating.  This contains the transient state for the current
 
110
    /// translation unit that we are generating (such as the current section
 
111
    /// etc).
 
112
    MCStreamer &OutStreamer;
 
113
    
 
114
    /// The current machine function.
 
115
    const MachineFunction *MF;
 
116
 
 
117
    /// Name-mangler for global names.
 
118
    ///
 
119
    Mangler *Mang;
 
120
 
 
121
    /// The symbol for the current function. This is recalculated at the
 
122
    /// beginning of each call to runOnMachineFunction().
 
123
    ///
 
124
    MCSymbol *CurrentFnSym;
 
125
    
 
126
    /// getCurrentSection() - Return the current section we are emitting to.
 
127
    const MCSection *getCurrentSection() const;
 
128
    
 
129
 
 
130
    /// VerboseAsm - Emit comments in assembly output if this is true.
 
131
    ///
 
132
    bool VerboseAsm;
 
133
 
 
134
    /// Private state for PrintSpecial()
 
135
    // Assign a unique ID to this machine instruction.
 
136
    mutable const MachineInstr *LastMI;
 
137
    mutable const Function *LastFn;
 
138
    mutable unsigned Counter;
 
139
    
 
140
    // Private state for processDebugLoc()
 
141
    mutable const MDNode *PrevDLT;
 
142
 
 
143
  protected:
 
144
    explicit AsmPrinter(formatted_raw_ostream &o, TargetMachine &TM,
 
145
                        MCContext &Ctx, MCStreamer &Streamer,
 
146
                        const MCAsmInfo *T);
 
147
    
 
148
  public:
 
149
    virtual ~AsmPrinter();
 
150
 
 
151
    /// isVerbose - Return true if assembly output should contain comments.
 
152
    ///
 
153
    bool isVerbose() const { return VerboseAsm; }
 
154
 
 
155
    /// getFunctionNumber - Return a unique ID for the current function.
 
156
    ///
 
157
    unsigned getFunctionNumber() const;
 
158
    
 
159
  protected:
 
160
    /// getAnalysisUsage - Record analysis usage.
 
161
    /// 
 
162
    void getAnalysisUsage(AnalysisUsage &AU) const;
 
163
    
 
164
    /// doInitialization - Set up the AsmPrinter when we are working on a new
 
165
    /// module.  If your pass overrides this, it must make sure to explicitly
 
166
    /// call this implementation.
 
167
    bool doInitialization(Module &M);
 
168
 
 
169
    /// EmitStartOfAsmFile - This virtual method can be overridden by targets
 
170
    /// that want to emit something at the start of their file.
 
171
    virtual void EmitStartOfAsmFile(Module &) {}
 
172
    
 
173
    /// EmitEndOfAsmFile - This virtual method can be overridden by targets that
 
174
    /// want to emit something at the end of their file.
 
175
    virtual void EmitEndOfAsmFile(Module &) {}
 
176
    
 
177
    /// doFinalization - Shut down the asmprinter.  If you override this in your
 
178
    /// pass, you must make sure to call it explicitly.
 
179
    bool doFinalization(Module &M);
 
180
    
 
181
    /// PrintSpecial - Print information related to the specified machine instr
 
182
    /// that is independent of the operand, and may be independent of the instr
 
183
    /// itself.  This can be useful for portably encoding the comment character
 
184
    /// or other bits of target-specific knowledge into the asmstrings.  The
 
185
    /// syntax used is ${:comment}.  Targets can override this to add support
 
186
    /// for their own strange codes.
 
187
    virtual void PrintSpecial(const MachineInstr *MI, const char *Code) const;
 
188
 
 
189
    /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM
 
190
    /// instruction, using the specified assembler variant.  Targets should
 
191
    /// override this to format as appropriate.  This method can return true if
 
192
    /// the operand is erroneous.
 
193
    virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 
194
                                 unsigned AsmVariant, const char *ExtraCode);
 
195
    
 
196
    /// PrintAsmMemoryOperand - Print the specified operand of MI, an INLINEASM
 
197
    /// instruction, using the specified assembler variant as an address.
 
198
    /// Targets should override this to format as appropriate.  This method can
 
199
    /// return true if the operand is erroneous.
 
200
    virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
 
201
                                       unsigned AsmVariant, 
 
202
                                       const char *ExtraCode);
 
203
    
 
204
    /// runOnMachineFunction - Emit the specified function out to the
 
205
    /// OutStreamer.
 
206
    virtual bool runOnMachineFunction(MachineFunction &MF) {
 
207
      SetupMachineFunction(MF);
 
208
      EmitFunctionHeader();
 
209
      EmitFunctionBody();
 
210
      return false;
 
211
    }      
 
212
    
 
213
    /// SetupMachineFunction - This should be called when a new MachineFunction
 
214
    /// is being processed from runOnMachineFunction.
 
215
    void SetupMachineFunction(MachineFunction &MF);
 
216
    
 
217
    /// EmitFunctionHeader - This method emits the header for the current
 
218
    /// function.
 
219
    void EmitFunctionHeader();
 
220
    
 
221
    /// EmitFunctionBody - This method emits the body and trailer for a
 
222
    /// function.
 
223
    void EmitFunctionBody();
 
224
 
 
225
    /// EmitInstruction - Targets should implement this to emit instructions.
 
226
    virtual void EmitInstruction(const MachineInstr *) {
 
227
      assert(0 && "EmitInstruction not implemented");
 
228
    }
 
229
    
 
230
    /// EmitFunctionBodyStart - Targets can override this to emit stuff before
 
231
    /// the first basic block in the function.
 
232
    virtual void EmitFunctionBodyStart() {}
 
233
 
 
234
    /// EmitFunctionBodyEnd - Targets can override this to emit stuff after
 
235
    /// the last basic block in the function.
 
236
    virtual void EmitFunctionBodyEnd() {}
 
237
    
 
238
    /// EmitConstantPool - Print to the current output stream assembly
 
239
    /// representations of the constants in the constant pool MCP. This is
 
240
    /// used to print out constants which have been "spilled to memory" by
 
241
    /// the code generator.
 
242
    ///
 
243
    virtual void EmitConstantPool();
 
244
    
 
245
    /// EmitJumpTableInfo - Print assembly representations of the jump tables 
 
246
    /// used by the current function to the current output stream.  
 
247
    ///
 
248
    void EmitJumpTableInfo();
 
249
    
 
250
    /// EmitGlobalVariable - Emit the specified global variable to the .s file.
 
251
    virtual void EmitGlobalVariable(const GlobalVariable *GV);
 
252
    
 
253
    /// EmitSpecialLLVMGlobal - Check to see if the specified global is a
 
254
    /// special global used by LLVM.  If so, emit it and return true, otherwise
 
255
    /// do nothing and return false.
 
256
    bool EmitSpecialLLVMGlobal(const GlobalVariable *GV);
 
257
 
 
258
  public:
 
259
    //===------------------------------------------------------------------===//
 
260
    // Emission and print routines
 
261
    //
 
262
 
 
263
    /// EmitInt8 - Emit a byte directive and value.
 
264
    ///
 
265
    void EmitInt8(int Value) const;
 
266
 
 
267
    /// EmitInt16 - Emit a short directive and value.
 
268
    ///
 
269
    void EmitInt16(int Value) const;
 
270
 
 
271
    /// EmitInt32 - Emit a long directive and value.
 
272
    ///
 
273
    void EmitInt32(int Value) const;
 
274
 
 
275
    /// EmitInt64 - Emit a long long directive and value.
 
276
    ///
 
277
    void EmitInt64(uint64_t Value) const;
 
278
 
 
279
    //===------------------------------------------------------------------===//
 
280
 
 
281
    /// EmitAlignment - Emit an alignment directive to the specified power of
 
282
    /// two boundary.  For example, if you pass in 3 here, you will get an 8
 
283
    /// byte alignment.  If a global value is specified, and if that global has
 
284
    /// an explicit alignment requested, it will unconditionally override the
 
285
    /// alignment request.  However, if ForcedAlignBits is specified, this value
 
286
    /// has final say: the ultimate alignment will be the max of ForcedAlignBits
 
287
    /// and the alignment computed with NumBits and the global.  If UseFillExpr
 
288
    /// is true, it also emits an optional second value FillValue which the
 
289
    /// assembler uses to fill gaps to match alignment for text sections if the
 
290
    /// has specified a non-zero fill value.
 
291
    ///
 
292
    /// The algorithm is:
 
293
    ///     Align = NumBits;
 
294
    ///     if (GV && GV->hasalignment) Align = GV->getalignment();
 
295
    ///     Align = std::max(Align, ForcedAlignBits);
 
296
    ///
 
297
    void EmitAlignment(unsigned NumBits, const GlobalValue *GV = 0,
 
298
                       unsigned ForcedAlignBits = 0,
 
299
                       bool UseFillExpr = true) const;
 
300
 
 
301
    /// printLabel - This method prints a local label used by debug and
 
302
    /// exception handling tables.
 
303
    void printLabel(unsigned Id) const;
 
304
 
 
305
    /// printDeclare - This method prints a local variable declaration used by
 
306
    /// debug tables.
 
307
    void printDeclare(const MachineInstr *MI) const;
 
308
 
 
309
    /// GetGlobalValueSymbol - Return the MCSymbol for the specified global
 
310
    /// value.
 
311
    virtual MCSymbol *GetGlobalValueSymbol(const GlobalValue *GV) const;
 
312
 
 
313
    /// GetSymbolWithGlobalValueBase - Return the MCSymbol for a symbol with
 
314
    /// global value name as its base, with the specified suffix, and where the
 
315
    /// symbol is forced to have private linkage if ForcePrivate is true.
 
316
    MCSymbol *GetSymbolWithGlobalValueBase(const GlobalValue *GV,
 
317
                                           StringRef Suffix,
 
318
                                           bool ForcePrivate = true) const;
 
319
    
 
320
    /// GetExternalSymbolSymbol - Return the MCSymbol for the specified
 
321
    /// ExternalSymbol.
 
322
    MCSymbol *GetExternalSymbolSymbol(StringRef Sym) const;
 
323
    
 
324
    /// GetCPISymbol - Return the symbol for the specified constant pool entry.
 
325
    MCSymbol *GetCPISymbol(unsigned CPID) const;
 
326
 
 
327
    /// GetJTISymbol - Return the symbol for the specified jump table entry.
 
328
    MCSymbol *GetJTISymbol(unsigned JTID, bool isLinkerPrivate = false) const;
 
329
 
 
330
    /// GetJTSetSymbol - Return the symbol for the specified jump table .set
 
331
    /// FIXME: privatize to AsmPrinter.
 
332
    MCSymbol *GetJTSetSymbol(unsigned UID, unsigned MBBID) const;
 
333
 
 
334
    /// GetBlockAddressSymbol - Return the MCSymbol used to satisfy BlockAddress
 
335
    /// uses of the specified basic block.
 
336
    MCSymbol *GetBlockAddressSymbol(const BlockAddress *BA) const;
 
337
    MCSymbol *GetBlockAddressSymbol(const Function *F,
 
338
                                    const BasicBlock *BB) const;
 
339
 
 
340
    /// EmitBasicBlockStart - This method prints the label for the specified
 
341
    /// MachineBasicBlock, an alignment (if present) and a comment describing
 
342
    /// it if appropriate.
 
343
    void EmitBasicBlockStart(const MachineBasicBlock *MBB) const;
 
344
    
 
345
    
 
346
    // Data emission.
 
347
    
 
348
    /// EmitGlobalConstant - Print a general LLVM constant to the .s file.
 
349
    void EmitGlobalConstant(const Constant* CV, unsigned AddrSpace = 0);
 
350
    
 
351
  protected:
 
352
    virtual void EmitFunctionEntryLabel();
 
353
    
 
354
    virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV);
 
355
 
 
356
    /// printOffset - This is just convenient handler for printing offsets.
 
357
    void printOffset(int64_t Offset) const;
 
358
 
 
359
    /// isBlockOnlyReachableByFallthough - Return true if the basic block has
 
360
    /// exactly one predecessor and the control transfer mechanism between
 
361
    /// the predecessor and this block is a fall-through.
 
362
    virtual bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const;
 
363
 
 
364
  private:
 
365
 
 
366
    /// processDebugLoc - Processes the debug information of each machine
 
367
    /// instruction's DebugLoc. 
 
368
    void processDebugLoc(const MachineInstr *MI, bool BeforePrintingInsn);
 
369
    
 
370
    void printLabelInst(const MachineInstr *MI) const;
 
371
 
 
372
    /// printInlineAsm - This method formats and prints the specified machine
 
373
    /// instruction that is an inline asm.
 
374
    void printInlineAsm(const MachineInstr *MI) const;
 
375
 
 
376
    /// printImplicitDef - This method prints the specified machine instruction
 
377
    /// that is an implicit def.
 
378
    void printImplicitDef(const MachineInstr *MI) const;
 
379
 
 
380
    /// printKill - This method prints the specified kill machine instruction.
 
381
    void printKill(const MachineInstr *MI) const;
 
382
 
 
383
    /// EmitVisibility - This emits visibility information about symbol, if
 
384
    /// this is suported by the target.
 
385
    void EmitVisibility(MCSymbol *Sym, unsigned Visibility) const;
 
386
    
 
387
    void EmitLinkage(unsigned Linkage, MCSymbol *GVSym) const;
 
388
    
 
389
    void EmitJumpTableEntry(const MachineJumpTableInfo *MJTI,
 
390
                            const MachineBasicBlock *MBB,
 
391
                            unsigned uid) const;
 
392
    void EmitLLVMUsedList(Constant *List);
 
393
    void EmitXXStructorList(Constant *List);
 
394
    GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy *C);
 
395
  };
 
396
}
 
397
 
 
398
#endif