0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1 //===-- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework --------*- C++ -*-===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
3 // The LLVM Compiler Infrastructure
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
4 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
5 // This file is distributed under the University of Illinois Open Source
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
6 // License. See LICENSE.TXT for details.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
7 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
8 //===----------------------------------------------------------------------===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
9 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
10 // This file contains a class to be used as the base class for target specific
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
11 // asm writers. This class primarily handles common functionality used by
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
12 // all asm writers.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
13 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
14 //===----------------------------------------------------------------------===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
15
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
16 #ifndef LLVM_CODEGEN_ASMPRINTER_H
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
17 #define LLVM_CODEGEN_ASMPRINTER_H
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
18
|
|
95
|
19 #include "llvm/ADT/MapVector.h"
|
|
77
|
20 #include "llvm/ADT/Twine.h"
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
21 #include "llvm/CodeGen/MachineFunctionPass.h"
|
|
95
|
22 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
23 #include "llvm/IR/InlineAsm.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
24 #include "llvm/Support/DataTypes.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
25 #include "llvm/Support/ErrorHandling.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
26
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
27 namespace llvm {
|
|
77
|
28 class AsmPrinterHandler;
|
|
|
29 class BlockAddress;
|
|
|
30 class ByteStreamer;
|
|
|
31 class GCStrategy;
|
|
|
32 class Constant;
|
|
|
33 class ConstantArray;
|
|
95
|
34 class DIE;
|
|
|
35 class DIEAbbrev;
|
|
77
|
36 class GCMetadataPrinter;
|
|
|
37 class GlobalValue;
|
|
|
38 class GlobalVariable;
|
|
|
39 class MachineBasicBlock;
|
|
|
40 class MachineFunction;
|
|
|
41 class MachineInstr;
|
|
|
42 class MachineLocation;
|
|
|
43 class MachineLoopInfo;
|
|
|
44 class MachineLoop;
|
|
|
45 class MachineConstantPoolValue;
|
|
|
46 class MachineJumpTableInfo;
|
|
|
47 class MachineModuleInfo;
|
|
|
48 class MCAsmInfo;
|
|
|
49 class MCCFIInstruction;
|
|
|
50 class MCContext;
|
|
83
|
51 class MCExpr;
|
|
77
|
52 class MCInst;
|
|
|
53 class MCSection;
|
|
|
54 class MCStreamer;
|
|
|
55 class MCSubtargetInfo;
|
|
|
56 class MCSymbol;
|
|
95
|
57 class MCTargetOptions;
|
|
77
|
58 class MDNode;
|
|
|
59 class DwarfDebug;
|
|
|
60 class Mangler;
|
|
|
61 class TargetLoweringObjectFile;
|
|
|
62 class DataLayout;
|
|
|
63 class TargetMachine;
|
|
|
64
|
|
|
65 /// This class is intended to be used as a driving class for all asm writers.
|
|
|
66 class AsmPrinter : public MachineFunctionPass {
|
|
|
67 public:
|
|
|
68 /// Target machine description.
|
|
|
69 ///
|
|
|
70 TargetMachine &TM;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
71
|
|
77
|
72 /// Target Asm Printer information.
|
|
|
73 ///
|
|
|
74 const MCAsmInfo *MAI;
|
|
|
75
|
|
|
76 /// This is the context for the output file that we are streaming. This owns
|
|
|
77 /// all of the global MC-related objects for the generated translation unit.
|
|
|
78 MCContext &OutContext;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
79
|
|
77
|
80 /// This is the MCStreamer object for the file we are generating. This
|
|
|
81 /// contains the transient state for the current translation unit that we are
|
|
|
82 /// generating (such as the current section etc).
|
|
95
|
83 std::unique_ptr<MCStreamer> OutStreamer;
|
|
77
|
84
|
|
|
85 /// The current machine function.
|
|
|
86 const MachineFunction *MF;
|
|
|
87
|
|
|
88 /// This is a pointer to the current MachineModuleInfo.
|
|
|
89 MachineModuleInfo *MMI;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
90
|
|
77
|
91 /// Name-mangler for global names.
|
|
|
92 ///
|
|
|
93 Mangler *Mang;
|
|
|
94
|
|
|
95 /// The symbol for the current function. This is recalculated at the beginning
|
|
|
96 /// of each call to runOnMachineFunction().
|
|
|
97 ///
|
|
|
98 MCSymbol *CurrentFnSym;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
99
|
|
77
|
100 /// The symbol used to represent the start of the current function for the
|
|
|
101 /// purpose of calculating its size (e.g. using the .size directive). By
|
|
|
102 /// default, this is equal to CurrentFnSym.
|
|
|
103 MCSymbol *CurrentFnSymForSize;
|
|
|
104
|
|
95
|
105 /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of
|
|
|
106 /// its number of uses by other globals.
|
|
|
107 typedef std::pair<const GlobalVariable *, unsigned> GOTEquivUsePair;
|
|
|
108 MapVector<const MCSymbol *, GOTEquivUsePair> GlobalGOTEquivs;
|
|
|
109
|
|
77
|
110 private:
|
|
95
|
111 MCSymbol *CurrentFnBegin;
|
|
|
112 MCSymbol *CurrentFnEnd;
|
|
|
113 MCSymbol *CurExceptionSym;
|
|
|
114
|
|
77
|
115 // The garbage collection metadata printer table.
|
|
|
116 void *GCMetadataPrinters; // Really a DenseMap.
|
|
|
117
|
|
|
118 /// Emit comments in assembly output if this is true.
|
|
|
119 ///
|
|
|
120 bool VerboseAsm;
|
|
|
121 static char ID;
|
|
|
122
|
|
|
123 /// If VerboseAsm is set, a pointer to the loop info for this function.
|
|
|
124 MachineLoopInfo *LI;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
125
|
|
77
|
126 struct HandlerInfo {
|
|
|
127 AsmPrinterHandler *Handler;
|
|
|
128 const char *TimerName, *TimerGroupName;
|
|
|
129 HandlerInfo(AsmPrinterHandler *Handler, const char *TimerName,
|
|
|
130 const char *TimerGroupName)
|
|
|
131 : Handler(Handler), TimerName(TimerName),
|
|
|
132 TimerGroupName(TimerGroupName) {}
|
|
|
133 };
|
|
|
134 /// A vector of all debug/EH info emitters we should use. This vector
|
|
|
135 /// maintains ownership of the emitters.
|
|
|
136 SmallVector<HandlerInfo, 1> Handlers;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
137
|
|
77
|
138 /// If the target supports dwarf debug info, this pointer is non-null.
|
|
|
139 DwarfDebug *DD;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
140
|
|
77
|
141 protected:
|
|
83
|
142 explicit AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
|
|
77
|
143
|
|
|
144 public:
|
|
95
|
145 ~AsmPrinter() override;
|
|
77
|
146
|
|
|
147 DwarfDebug *getDwarfDebug() { return DD; }
|
|
83
|
148 DwarfDebug *getDwarfDebug() const { return DD; }
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
149
|
|
77
|
150 /// Return true if assembly output should contain comments.
|
|
|
151 ///
|
|
|
152 bool isVerbose() const { return VerboseAsm; }
|
|
|
153
|
|
|
154 /// Return a unique ID for the current function.
|
|
|
155 ///
|
|
|
156 unsigned getFunctionNumber() const;
|
|
|
157
|
|
95
|
158 MCSymbol *getFunctionBegin() const { return CurrentFnBegin; }
|
|
|
159 MCSymbol *getFunctionEnd() const { return CurrentFnEnd; }
|
|
|
160 MCSymbol *getCurExceptionSym();
|
|
|
161
|
|
77
|
162 /// Return information about object file lowering.
|
|
|
163 const TargetLoweringObjectFile &getObjFileLowering() const;
|
|
|
164
|
|
|
165 /// Return information about data layout.
|
|
|
166 const DataLayout &getDataLayout() const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
167
|
|
95
|
168 /// Return the pointer size from the TargetMachine
|
|
|
169 unsigned getPointerSize() const;
|
|
|
170
|
|
77
|
171 /// Return information about subtarget.
|
|
|
172 const MCSubtargetInfo &getSubtargetInfo() const;
|
|
|
173
|
|
|
174 void EmitToStreamer(MCStreamer &S, const MCInst &Inst);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
175
|
|
77
|
176 /// Return the target triple string.
|
|
|
177 StringRef getTargetTriple() const;
|
|
|
178
|
|
|
179 /// Return the current section we are emitting to.
|
|
|
180 const MCSection *getCurrentSection() const;
|
|
|
181
|
|
|
182 void getNameWithPrefix(SmallVectorImpl<char> &Name,
|
|
|
183 const GlobalValue *GV) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
184
|
|
77
|
185 MCSymbol *getSymbol(const GlobalValue *GV) const;
|
|
|
186
|
|
|
187 //===------------------------------------------------------------------===//
|
|
|
188 // MachineFunctionPass Implementation.
|
|
|
189 //===------------------------------------------------------------------===//
|
|
|
190
|
|
|
191 /// Record analysis usage.
|
|
|
192 ///
|
|
|
193 void getAnalysisUsage(AnalysisUsage &AU) const override;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
194
|
|
77
|
195 /// Set up the AsmPrinter when we are working on a new module. If your pass
|
|
|
196 /// overrides this, it must make sure to explicitly call this implementation.
|
|
|
197 bool doInitialization(Module &M) override;
|
|
|
198
|
|
|
199 /// Shut down the asmprinter. If you override this in your pass, you must make
|
|
|
200 /// sure to call it explicitly.
|
|
|
201 bool doFinalization(Module &M) override;
|
|
|
202
|
|
|
203 /// Emit the specified function out to the OutStreamer.
|
|
|
204 bool runOnMachineFunction(MachineFunction &MF) override {
|
|
|
205 SetupMachineFunction(MF);
|
|
|
206 EmitFunctionBody();
|
|
|
207 return false;
|
|
|
208 }
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
209
|
|
77
|
210 //===------------------------------------------------------------------===//
|
|
|
211 // Coarse grained IR lowering routines.
|
|
|
212 //===------------------------------------------------------------------===//
|
|
|
213
|
|
|
214 /// This should be called when a new MachineFunction is being processed from
|
|
|
215 /// runOnMachineFunction.
|
|
|
216 void SetupMachineFunction(MachineFunction &MF);
|
|
|
217
|
|
|
218 /// This method emits the body and trailer for a function.
|
|
|
219 void EmitFunctionBody();
|
|
|
220
|
|
|
221 void emitCFIInstruction(const MachineInstr &MI);
|
|
|
222
|
|
83
|
223 void emitFrameAlloc(const MachineInstr &MI);
|
|
|
224
|
|
77
|
225 enum CFIMoveType { CFI_M_None, CFI_M_EH, CFI_M_Debug };
|
|
|
226 CFIMoveType needsCFIMoves();
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
227
|
|
77
|
228 bool needsSEHMoves();
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
229
|
|
77
|
230 /// Print to the current output stream assembly representations of the
|
|
|
231 /// constants in the constant pool MCP. This is used to print out constants
|
|
|
232 /// which have been "spilled to memory" by the code generator.
|
|
|
233 ///
|
|
|
234 virtual void EmitConstantPool();
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
235
|
|
77
|
236 /// Print assembly representations of the jump tables used by the current
|
|
|
237 /// function to the current output stream.
|
|
|
238 ///
|
|
95
|
239 virtual void EmitJumpTableInfo();
|
|
|
240
|
|
77
|
241 /// Emit the specified global variable to the .s file.
|
|
|
242 virtual void EmitGlobalVariable(const GlobalVariable *GV);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
243
|
|
77
|
244 /// Check to see if the specified global is a special global used by LLVM. If
|
|
|
245 /// so, emit it and return true, otherwise do nothing and return false.
|
|
|
246 bool EmitSpecialLLVMGlobal(const GlobalVariable *GV);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
247
|
|
77
|
248 /// Emit an alignment directive to the specified power of two boundary. For
|
|
|
249 /// example, if you pass in 3 here, you will get an 8 byte alignment. If a
|
|
|
250 /// global value is specified, and if that global has an explicit alignment
|
|
|
251 /// requested, it will override the alignment request if required for
|
|
|
252 /// correctness.
|
|
|
253 ///
|
|
|
254 void EmitAlignment(unsigned NumBits, const GlobalObject *GO = nullptr) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
255
|
|
83
|
256 /// Lower the specified LLVM Constant to an MCExpr.
|
|
100
|
257 virtual const MCExpr *lowerConstant(const Constant *CV);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
258
|
|
77
|
259 /// \brief Print a general LLVM constant to the .s file.
|
|
95
|
260 void EmitGlobalConstant(const DataLayout &DL, const Constant *CV);
|
|
|
261
|
|
|
262 /// \brief Unnamed constant global variables solely contaning a pointer to
|
|
|
263 /// another globals variable act like a global variable "proxy", or GOT
|
|
|
264 /// equivalents, i.e., it's only used to hold the address of the latter. One
|
|
|
265 /// optimization is to replace accesses to these proxies by using the GOT
|
|
|
266 /// entry for the final global instead. Hence, we select GOT equivalent
|
|
|
267 /// candidates among all the module global variables, avoid emitting them
|
|
|
268 /// unnecessarily and finally replace references to them by pc relative
|
|
|
269 /// accesses to GOT entries.
|
|
|
270 void computeGlobalGOTEquivs(Module &M);
|
|
|
271
|
|
|
272 /// \brief Constant expressions using GOT equivalent globals may not be
|
|
|
273 /// eligible for PC relative GOT entry conversion, in such cases we need to
|
|
|
274 /// emit the proxies we previously omitted in EmitGlobalVariable.
|
|
|
275 void emitGlobalGOTEquivs();
|
|
77
|
276
|
|
|
277 //===------------------------------------------------------------------===//
|
|
|
278 // Overridable Hooks
|
|
|
279 //===------------------------------------------------------------------===//
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
280
|
|
77
|
281 // Targets can, or in the case of EmitInstruction, must implement these to
|
|
|
282 // customize output.
|
|
|
283
|
|
|
284 /// This virtual method can be overridden by targets that want to emit
|
|
|
285 /// something at the start of their file.
|
|
|
286 virtual void EmitStartOfAsmFile(Module &) {}
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
287
|
|
77
|
288 /// This virtual method can be overridden by targets that want to emit
|
|
|
289 /// something at the end of their file.
|
|
|
290 virtual void EmitEndOfAsmFile(Module &) {}
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
291
|
|
77
|
292 /// Targets can override this to emit stuff before the first basic block in
|
|
|
293 /// the function.
|
|
|
294 virtual void EmitFunctionBodyStart() {}
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
295
|
|
77
|
296 /// Targets can override this to emit stuff after the last basic block in the
|
|
|
297 /// function.
|
|
|
298 virtual void EmitFunctionBodyEnd() {}
|
|
|
299
|
|
83
|
300 /// Targets can override this to emit stuff at the start of a basic block.
|
|
|
301 /// By default, this method prints the label for the specified
|
|
|
302 /// MachineBasicBlock, an alignment (if present) and a comment describing it
|
|
|
303 /// if appropriate.
|
|
|
304 virtual void EmitBasicBlockStart(const MachineBasicBlock &MBB) const;
|
|
|
305
|
|
77
|
306 /// Targets can override this to emit stuff at the end of a basic block.
|
|
|
307 virtual void EmitBasicBlockEnd(const MachineBasicBlock &MBB) {}
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
308
|
|
77
|
309 /// Targets should implement this to emit instructions.
|
|
|
310 virtual void EmitInstruction(const MachineInstr *) {
|
|
|
311 llvm_unreachable("EmitInstruction not implemented");
|
|
|
312 }
|
|
|
313
|
|
|
314 /// Return the symbol for the specified constant pool entry.
|
|
|
315 virtual MCSymbol *GetCPISymbol(unsigned CPID) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
316
|
|
77
|
317 virtual void EmitFunctionEntryLabel();
|
|
|
318
|
|
|
319 virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV);
|
|
|
320
|
|
|
321 /// Targets can override this to change how global constants that are part of
|
|
|
322 /// a C++ static/global constructor list are emitted.
|
|
95
|
323 virtual void EmitXXStructor(const DataLayout &DL, const Constant *CV) {
|
|
|
324 EmitGlobalConstant(DL, CV);
|
|
|
325 }
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
326
|
|
77
|
327 /// Return true if the basic block has exactly one predecessor and the control
|
|
|
328 /// transfer mechanism between the predecessor and this block is a
|
|
|
329 /// fall-through.
|
|
|
330 virtual bool
|
|
|
331 isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const;
|
|
|
332
|
|
|
333 /// Targets can override this to customize the output of IMPLICIT_DEF
|
|
|
334 /// instructions in verbose mode.
|
|
|
335 virtual void emitImplicitDef(const MachineInstr *MI) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
336
|
|
77
|
337 //===------------------------------------------------------------------===//
|
|
|
338 // Symbol Lowering Routines.
|
|
|
339 //===------------------------------------------------------------------===//
|
|
|
340 public:
|
|
95
|
341 MCSymbol *createTempSymbol(const Twine &Name) const;
|
|
77
|
342
|
|
|
343 /// Return the MCSymbol for a private symbol with global value name as its
|
|
|
344 /// base, with the specified suffix.
|
|
|
345 MCSymbol *getSymbolWithGlobalValueBase(const GlobalValue *GV,
|
|
|
346 StringRef Suffix) const;
|
|
|
347
|
|
|
348 /// Return the MCSymbol for the specified ExternalSymbol.
|
|
|
349 MCSymbol *GetExternalSymbolSymbol(StringRef Sym) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
350
|
|
77
|
351 /// Return the symbol for the specified jump table entry.
|
|
|
352 MCSymbol *GetJTISymbol(unsigned JTID, bool isLinkerPrivate = false) const;
|
|
|
353
|
|
|
354 /// Return the symbol for the specified jump table .set
|
|
|
355 /// FIXME: privatize to AsmPrinter.
|
|
|
356 MCSymbol *GetJTSetSymbol(unsigned UID, unsigned MBBID) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
357
|
|
77
|
358 /// Return the MCSymbol used to satisfy BlockAddress uses of the specified
|
|
|
359 /// basic block.
|
|
|
360 MCSymbol *GetBlockAddressSymbol(const BlockAddress *BA) const;
|
|
|
361 MCSymbol *GetBlockAddressSymbol(const BasicBlock *BB) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
362
|
|
77
|
363 //===------------------------------------------------------------------===//
|
|
|
364 // Emission Helper Routines.
|
|
|
365 //===------------------------------------------------------------------===//
|
|
|
366 public:
|
|
|
367 /// This is just convenient handler for printing offsets.
|
|
|
368 void printOffset(int64_t Offset, raw_ostream &OS) const;
|
|
|
369
|
|
|
370 /// Emit a byte directive and value.
|
|
|
371 ///
|
|
|
372 void EmitInt8(int Value) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
373
|
|
77
|
374 /// Emit a short directive and value.
|
|
|
375 ///
|
|
|
376 void EmitInt16(int Value) const;
|
|
|
377
|
|
|
378 /// Emit a long directive and value.
|
|
|
379 ///
|
|
|
380 void EmitInt32(int Value) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
381
|
|
77
|
382 /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
|
|
|
383 /// is specified by Size and Hi/Lo specify the labels. This implicitly uses
|
|
|
384 /// .set if it is available.
|
|
|
385 void EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
|
|
|
386 unsigned Size) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
387
|
|
77
|
388 /// Emit something like ".long Label+Offset" where the size in bytes of the
|
|
|
389 /// directive is specified by Size and Label specifies the label. This
|
|
|
390 /// implicitly uses .set if it is available.
|
|
|
391 void EmitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
|
|
|
392 unsigned Size, bool IsSectionRelative = false) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
393
|
|
77
|
394 /// Emit something like ".long Label" where the size in bytes of the directive
|
|
|
395 /// is specified by Size and Label specifies the label.
|
|
|
396 void EmitLabelReference(const MCSymbol *Label, unsigned Size,
|
|
|
397 bool IsSectionRelative = false) const {
|
|
|
398 EmitLabelPlusOffset(Label, 0, Size, IsSectionRelative);
|
|
|
399 }
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
400
|
|
77
|
401 //===------------------------------------------------------------------===//
|
|
|
402 // Dwarf Emission Helper Routines
|
|
|
403 //===------------------------------------------------------------------===//
|
|
|
404
|
|
|
405 /// Emit the specified signed leb128 value.
|
|
|
406 void EmitSLEB128(int64_t Value, const char *Desc = nullptr) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
407
|
|
77
|
408 /// Emit the specified unsigned leb128 value.
|
|
|
409 void EmitULEB128(uint64_t Value, const char *Desc = nullptr,
|
|
|
410 unsigned PadTo = 0) const;
|
|
|
411
|
|
|
412 /// Emit a .byte 42 directive that corresponds to an encoding. If verbose
|
|
|
413 /// assembly output is enabled, we output comments describing the encoding.
|
|
|
414 /// Desc is a string saying what the encoding is specifying (e.g. "LSDA").
|
|
|
415 void EmitEncodingByte(unsigned Val, const char *Desc = nullptr) const;
|
|
|
416
|
|
|
417 /// Return the size of the encoding in bytes.
|
|
|
418 unsigned GetSizeOfEncodedValue(unsigned Encoding) const;
|
|
|
419
|
|
|
420 /// Emit reference to a ttype global with a specified encoding.
|
|
|
421 void EmitTTypeReference(const GlobalValue *GV, unsigned Encoding) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
422
|
|
95
|
423 /// Emit a reference to a symbol for use in dwarf. Different object formats
|
|
|
424 /// represent this in different ways. Some use a relocation others encode
|
|
|
425 /// the label offset in its section.
|
|
|
426 void emitDwarfSymbolReference(const MCSymbol *Label,
|
|
|
427 bool ForceOffset = false) const;
|
|
|
428
|
|
|
429 /// Emit the 4-byte offset of a string from the start of its section.
|
|
77
|
430 ///
|
|
95
|
431 /// When possible, emit a DwarfStringPool section offset without any
|
|
|
432 /// relocations, and without using the symbol. Otherwise, defers to \a
|
|
|
433 /// emitDwarfSymbolReference().
|
|
|
434 void emitDwarfStringOffset(DwarfStringPoolEntryRef S) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
435
|
|
77
|
436 /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
|
|
95
|
437 virtual unsigned getISAEncoding() { return 0; }
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
438
|
|
77
|
439 /// EmitDwarfRegOp - Emit a dwarf register operation.
|
|
83
|
440 virtual void EmitDwarfRegOp(ByteStreamer &BS,
|
|
|
441 const MachineLocation &MLoc) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
442
|
|
77
|
443 //===------------------------------------------------------------------===//
|
|
|
444 // Dwarf Lowering Routines
|
|
|
445 //===------------------------------------------------------------------===//
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
446
|
|
77
|
447 /// \brief Emit frame instruction to describe the layout of the frame.
|
|
|
448 void emitCFIInstruction(const MCCFIInstruction &Inst) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
449
|
|
95
|
450 /// \brief Emit Dwarf abbreviation table.
|
|
100
|
451 template <typename T> void emitDwarfAbbrevs(const T &Abbrevs) const {
|
|
|
452 // For each abbreviation.
|
|
|
453 for (const auto &Abbrev : Abbrevs)
|
|
|
454 emitDwarfAbbrev(*Abbrev);
|
|
|
455
|
|
|
456 // Mark end of abbreviations.
|
|
|
457 EmitULEB128(0, "EOM(3)");
|
|
|
458 }
|
|
|
459
|
|
|
460 void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const;
|
|
95
|
461
|
|
|
462 /// \brief Recursively emit Dwarf DIE tree.
|
|
|
463 void emitDwarfDIE(const DIE &Die) const;
|
|
|
464
|
|
77
|
465 //===------------------------------------------------------------------===//
|
|
|
466 // Inline Asm Support
|
|
|
467 //===------------------------------------------------------------------===//
|
|
|
468 public:
|
|
|
469 // These are hooks that targets can override to implement inline asm
|
|
|
470 // support. These should probably be moved out of AsmPrinter someday.
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
471
|
|
77
|
472 /// Print information related to the specified machine instr that is
|
|
|
473 /// independent of the operand, and may be independent of the instr itself.
|
|
|
474 /// This can be useful for portably encoding the comment character or other
|
|
|
475 /// bits of target-specific knowledge into the asmstrings. The syntax used is
|
|
|
476 /// ${:comment}. Targets can override this to add support for their own
|
|
|
477 /// strange codes.
|
|
|
478 virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS,
|
|
|
479 const char *Code) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
480
|
|
77
|
481 /// Print the specified operand of MI, an INLINEASM instruction, using the
|
|
|
482 /// specified assembler variant. Targets should override this to format as
|
|
|
483 /// appropriate. This method can return true if the operand is erroneous.
|
|
|
484 virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
|
|
|
485 unsigned AsmVariant, const char *ExtraCode,
|
|
|
486 raw_ostream &OS);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
487
|
|
77
|
488 /// Print the specified operand of MI, an INLINEASM instruction, using the
|
|
|
489 /// specified assembler variant as an address. Targets should override this to
|
|
|
490 /// format as appropriate. This method can return true if the operand is
|
|
|
491 /// erroneous.
|
|
|
492 virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
|
|
|
493 unsigned AsmVariant, const char *ExtraCode,
|
|
|
494 raw_ostream &OS);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
495
|
|
83
|
496 /// Let the target do anything it needs to do before emitting inlineasm.
|
|
|
497 /// \p StartInfo - the subtarget info before parsing inline asm
|
|
95
|
498 virtual void emitInlineAsmStart() const;
|
|
83
|
499
|
|
77
|
500 /// Let the target do anything it needs to do after emitting inlineasm.
|
|
|
501 /// This callback can be used restore the original mode in case the
|
|
|
502 /// inlineasm contains directives to switch modes.
|
|
|
503 /// \p StartInfo - the original subtarget info before inline asm
|
|
|
504 /// \p EndInfo - the final subtarget info after parsing the inline asm,
|
|
|
505 /// or NULL if the value is unknown.
|
|
|
506 virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo,
|
|
|
507 const MCSubtargetInfo *EndInfo) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
508
|
|
77
|
509 private:
|
|
|
510 /// Private state for PrintSpecial()
|
|
|
511 // Assign a unique ID to this machine instruction.
|
|
|
512 mutable const MachineInstr *LastMI;
|
|
|
513 mutable unsigned LastFn;
|
|
|
514 mutable unsigned Counter;
|
|
95
|
515
|
|
|
516 /// This method emits the header for the current function.
|
|
|
517 virtual void EmitFunctionHeader();
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
518
|
|
77
|
519 /// Emit a blob of inline asm to the output streamer.
|
|
|
520 void
|
|
95
|
521 EmitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
|
|
|
522 const MCTargetOptions &MCOptions,
|
|
|
523 const MDNode *LocMDNode = nullptr,
|
|
77
|
524 InlineAsm::AsmDialect AsmDialect = InlineAsm::AD_ATT) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
525
|
|
77
|
526 /// This method formats and emits the specified machine instruction that is an
|
|
|
527 /// inline asm.
|
|
|
528 void EmitInlineAsm(const MachineInstr *MI) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
529
|
|
77
|
530 //===------------------------------------------------------------------===//
|
|
|
531 // Internal Implementation Details
|
|
|
532 //===------------------------------------------------------------------===//
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
533
|
|
77
|
534 /// This emits visibility information about symbol, if this is suported by the
|
|
|
535 /// target.
|
|
|
536 void EmitVisibility(MCSymbol *Sym, unsigned Visibility,
|
|
|
537 bool IsDefinition = true) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
538
|
|
77
|
539 void EmitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
540
|
|
77
|
541 void EmitJumpTableEntry(const MachineJumpTableInfo *MJTI,
|
|
|
542 const MachineBasicBlock *MBB, unsigned uid) const;
|
|
|
543 void EmitLLVMUsedList(const ConstantArray *InitList);
|
|
|
544 /// Emit llvm.ident metadata in an '.ident' directive.
|
|
|
545 void EmitModuleIdents(Module &M);
|
|
95
|
546 void EmitXXStructorList(const DataLayout &DL, const Constant *List,
|
|
|
547 bool isCtor);
|
|
77
|
548 GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy &C);
|
|
|
549 };
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
550 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
551
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
552 #endif
|
