MCDwarf: Don't save Twine to local variable, this is almost never safe to do
[oota-llvm.git] / lib / MC / MCDwarf.cpp
1 //===- lib/MC/MCDwarf.cpp - MCDwarf implementation ------------------------===//
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 #include "llvm/ADT/FoldingSet.h"
11 #include "llvm/MC/MCAsmInfo.h"
12 #include "llvm/MC/MCDwarf.h"
13 #include "llvm/MC/MCAssembler.h"
14 #include "llvm/MC/MCStreamer.h"
15 #include "llvm/MC/MCSymbol.h"
16 #include "llvm/MC/MCExpr.h"
17 #include "llvm/MC/MCContext.h"
18 #include "llvm/MC/MCObjectWriter.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/Twine.h"
21 #include "llvm/Support/Debug.h"
22 #include "llvm/Support/ErrorHandling.h"
23 #include "llvm/Support/raw_ostream.h"
24 #include "llvm/Target/TargetAsmBackend.h"
25 #include "llvm/Target/TargetAsmInfo.h"
26 using namespace llvm;
27
28 // Given a special op, return the address skip amount (in units of
29 // DWARF2_LINE_MIN_INSN_LENGTH.
30 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
31
32 // The maximum address skip amount that can be encoded with a special op.
33 #define MAX_SPECIAL_ADDR_DELTA          SPECIAL_ADDR(255)
34
35 // First special line opcode - leave room for the standard opcodes.
36 // Note: If you want to change this, you'll have to update the
37 // "standard_opcode_lengths" table that is emitted in DwarfFileTable::Emit().  
38 #define DWARF2_LINE_OPCODE_BASE         13
39
40 // Minimum line offset in a special line info. opcode.  This value
41 // was chosen to give a reasonable range of values.
42 #define DWARF2_LINE_BASE                -5
43
44 // Range of line offsets in a special line info. opcode.
45 # define DWARF2_LINE_RANGE              14
46
47 // Define the architecture-dependent minimum instruction length (in bytes).
48 // This value should be rather too small than too big.
49 # define DWARF2_LINE_MIN_INSN_LENGTH    1
50
51 // Note: when DWARF2_LINE_MIN_INSN_LENGTH == 1 which is the current setting,
52 // this routine is a nop and will be optimized away.
53 static inline uint64_t ScaleAddrDelta(uint64_t AddrDelta)
54 {
55   if (DWARF2_LINE_MIN_INSN_LENGTH == 1)
56     return AddrDelta;
57   if (AddrDelta % DWARF2_LINE_MIN_INSN_LENGTH != 0) {
58     // TODO: report this error, but really only once.
59     ;
60   }
61   return AddrDelta / DWARF2_LINE_MIN_INSN_LENGTH;
62 }
63
64 //
65 // This is called when an instruction is assembled into the specified section
66 // and if there is information from the last .loc directive that has yet to have
67 // a line entry made for it is made.
68 //
69 void MCLineEntry::Make(MCStreamer *MCOS, const MCSection *Section) {
70   if (!MCOS->getContext().getDwarfLocSeen())
71     return;
72
73   // Create a symbol at in the current section for use in the line entry.
74   MCSymbol *LineSym = MCOS->getContext().CreateTempSymbol();
75   // Set the value of the symbol to use for the MCLineEntry.
76   MCOS->EmitLabel(LineSym);
77
78   // Get the current .loc info saved in the context.
79   const MCDwarfLoc &DwarfLoc = MCOS->getContext().getCurrentDwarfLoc();
80
81   // Create a (local) line entry with the symbol and the current .loc info.
82   MCLineEntry LineEntry(LineSym, DwarfLoc);
83
84   // clear DwarfLocSeen saying the current .loc info is now used.
85   MCOS->getContext().ClearDwarfLocSeen();
86
87   // Get the MCLineSection for this section, if one does not exist for this
88   // section create it.
89   const DenseMap<const MCSection *, MCLineSection *> &MCLineSections =
90     MCOS->getContext().getMCLineSections();
91   MCLineSection *LineSection = MCLineSections.lookup(Section);
92   if (!LineSection) {
93     // Create a new MCLineSection.  This will be deleted after the dwarf line
94     // table is created using it by iterating through the MCLineSections
95     // DenseMap.
96     LineSection = new MCLineSection;
97     // Save a pointer to the new LineSection into the MCLineSections DenseMap.
98     MCOS->getContext().addMCLineSection(Section, LineSection);
99   }
100
101   // Add the line entry to this section's entries.
102   LineSection->addLineEntry(LineEntry);
103 }
104
105 //
106 // This helper routine returns an expression of End - Start + IntVal .
107 // 
108 static inline const MCExpr *MakeStartMinusEndExpr(const MCStreamer &MCOS,
109                                                   const MCSymbol &Start,
110                                                   const MCSymbol &End,
111                                                   int IntVal) {
112   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
113   const MCExpr *Res =
114     MCSymbolRefExpr::Create(&End, Variant, MCOS.getContext());
115   const MCExpr *RHS =
116     MCSymbolRefExpr::Create(&Start, Variant, MCOS.getContext());
117   const MCExpr *Res1 =
118     MCBinaryExpr::Create(MCBinaryExpr::Sub, Res, RHS, MCOS.getContext());
119   const MCExpr *Res2 =
120     MCConstantExpr::Create(IntVal, MCOS.getContext());
121   const MCExpr *Res3 =
122     MCBinaryExpr::Create(MCBinaryExpr::Sub, Res1, Res2, MCOS.getContext());
123   return Res3;
124 }
125
126 //
127 // This emits the Dwarf line table for the specified section from the entries
128 // in the LineSection.
129 //
130 static inline void EmitDwarfLineTable(MCStreamer *MCOS,
131                                       const MCSection *Section,
132                                       const MCLineSection *LineSection) {
133   unsigned FileNum = 1;
134   unsigned LastLine = 1;
135   unsigned Column = 0;
136   unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
137   unsigned Isa = 0;
138   MCSymbol *LastLabel = NULL;
139
140   // Loop through each MCLineEntry and encode the dwarf line number table.
141   for (MCLineSection::const_iterator
142          it = LineSection->getMCLineEntries()->begin(),
143          ie = LineSection->getMCLineEntries()->end(); it != ie; ++it) {
144
145     if (FileNum != it->getFileNum()) {
146       FileNum = it->getFileNum();
147       MCOS->EmitIntValue(dwarf::DW_LNS_set_file, 1);
148       MCOS->EmitULEB128IntValue(FileNum);
149     }
150     if (Column != it->getColumn()) {
151       Column = it->getColumn();
152       MCOS->EmitIntValue(dwarf::DW_LNS_set_column, 1);
153       MCOS->EmitULEB128IntValue(Column);
154     }
155     if (Isa != it->getIsa()) {
156       Isa = it->getIsa();
157       MCOS->EmitIntValue(dwarf::DW_LNS_set_isa, 1);
158       MCOS->EmitULEB128IntValue(Isa);
159     }
160     if ((it->getFlags() ^ Flags) & DWARF2_FLAG_IS_STMT) {
161       Flags = it->getFlags();
162       MCOS->EmitIntValue(dwarf::DW_LNS_negate_stmt, 1);
163     }
164     if (it->getFlags() & DWARF2_FLAG_BASIC_BLOCK)
165       MCOS->EmitIntValue(dwarf::DW_LNS_set_basic_block, 1);
166     if (it->getFlags() & DWARF2_FLAG_PROLOGUE_END)
167       MCOS->EmitIntValue(dwarf::DW_LNS_set_prologue_end, 1);
168     if (it->getFlags() & DWARF2_FLAG_EPILOGUE_BEGIN)
169       MCOS->EmitIntValue(dwarf::DW_LNS_set_epilogue_begin, 1);
170
171     int64_t LineDelta = static_cast<int64_t>(it->getLine()) - LastLine;
172     MCSymbol *Label = it->getLabel();
173
174     // At this point we want to emit/create the sequence to encode the delta in
175     // line numbers and the increment of the address from the previous Label
176     // and the current Label.
177     MCOS->EmitDwarfAdvanceLineAddr(LineDelta, LastLabel, Label);
178
179     LastLine = it->getLine();
180     LastLabel = Label;
181   }
182
183   // Emit a DW_LNE_end_sequence for the end of the section.
184   // Using the pointer Section create a temporary label at the end of the
185   // section and use that and the LastLabel to compute the address delta
186   // and use INT64_MAX as the line delta which is the signal that this is
187   // actually a DW_LNE_end_sequence.
188
189   // Switch to the section to be able to create a symbol at its end.
190   MCOS->SwitchSection(Section);
191
192   MCContext &context = MCOS->getContext();
193   // Create a symbol at the end of the section.
194   MCSymbol *SectionEnd = context.CreateTempSymbol();
195   // Set the value of the symbol, as we are at the end of the section.
196   MCOS->EmitLabel(SectionEnd);
197
198   // Switch back the the dwarf line section.
199   MCOS->SwitchSection(context.getTargetAsmInfo().getDwarfLineSection());
200
201   MCOS->EmitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd);
202 }
203
204 //
205 // This emits the Dwarf file and the line tables.
206 //
207 void MCDwarfFileTable::Emit(MCStreamer *MCOS) {
208   MCContext &context = MCOS->getContext();
209   // Switch to the section where the table will be emitted into.
210   MCOS->SwitchSection(context.getTargetAsmInfo().getDwarfLineSection());
211
212   // Create a symbol at the beginning of this section.
213   MCSymbol *LineStartSym = context.CreateTempSymbol();
214   // Set the value of the symbol, as we are at the start of the section.
215   MCOS->EmitLabel(LineStartSym);
216
217   // Create a symbol for the end of the section (to be set when we get there).
218   MCSymbol *LineEndSym = context.CreateTempSymbol();
219
220   // The first 4 bytes is the total length of the information for this
221   // compilation unit (not including these 4 bytes for the length).
222   MCOS->EmitAbsValue(MakeStartMinusEndExpr(*MCOS, *LineStartSym, *LineEndSym,4),
223                      4);
224
225   // Next 2 bytes is the Version, which is Dwarf 2.
226   MCOS->EmitIntValue(2, 2);
227
228   // Create a symbol for the end of the prologue (to be set when we get there).
229   MCSymbol *ProEndSym = context.CreateTempSymbol(); // Lprologue_end
230
231   // Length of the prologue, is the next 4 bytes.  Which is the start of the
232   // section to the end of the prologue.  Not including the 4 bytes for the
233   // total length, the 2 bytes for the version, and these 4 bytes for the
234   // length of the prologue.
235   MCOS->EmitAbsValue(MakeStartMinusEndExpr(*MCOS, *LineStartSym, *ProEndSym,
236                                         (4 + 2 + 4)),
237                   4, 0);
238
239   // Parameters of the state machine, are next.
240   MCOS->EmitIntValue(DWARF2_LINE_MIN_INSN_LENGTH, 1);
241   MCOS->EmitIntValue(DWARF2_LINE_DEFAULT_IS_STMT, 1);
242   MCOS->EmitIntValue(DWARF2_LINE_BASE, 1);
243   MCOS->EmitIntValue(DWARF2_LINE_RANGE, 1);
244   MCOS->EmitIntValue(DWARF2_LINE_OPCODE_BASE, 1);
245
246   // Standard opcode lengths
247   MCOS->EmitIntValue(0, 1); // length of DW_LNS_copy
248   MCOS->EmitIntValue(1, 1); // length of DW_LNS_advance_pc
249   MCOS->EmitIntValue(1, 1); // length of DW_LNS_advance_line
250   MCOS->EmitIntValue(1, 1); // length of DW_LNS_set_file
251   MCOS->EmitIntValue(1, 1); // length of DW_LNS_set_column
252   MCOS->EmitIntValue(0, 1); // length of DW_LNS_negate_stmt
253   MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_basic_block
254   MCOS->EmitIntValue(0, 1); // length of DW_LNS_const_add_pc
255   MCOS->EmitIntValue(1, 1); // length of DW_LNS_fixed_advance_pc
256   MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_prologue_end
257   MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_epilogue_begin
258   MCOS->EmitIntValue(1, 1); // DW_LNS_set_isa
259
260   // Put out the directory and file tables.
261
262   // First the directory table.
263   const std::vector<StringRef> &MCDwarfDirs =
264     context.getMCDwarfDirs();
265   for (unsigned i = 0; i < MCDwarfDirs.size(); i++) {
266     MCOS->EmitBytes(MCDwarfDirs[i], 0); // the DirectoryName
267     MCOS->EmitBytes(StringRef("\0", 1), 0); // the null term. of the string
268   }
269   MCOS->EmitIntValue(0, 1); // Terminate the directory list
270
271   // Second the file table.
272   const std::vector<MCDwarfFile *> &MCDwarfFiles =
273     MCOS->getContext().getMCDwarfFiles();
274   for (unsigned i = 1; i < MCDwarfFiles.size(); i++) {
275     MCOS->EmitBytes(MCDwarfFiles[i]->getName(), 0); // FileName
276     MCOS->EmitBytes(StringRef("\0", 1), 0); // the null term. of the string
277     // the Directory num
278     MCOS->EmitULEB128IntValue(MCDwarfFiles[i]->getDirIndex());
279     MCOS->EmitIntValue(0, 1); // last modification timestamp (always 0)
280     MCOS->EmitIntValue(0, 1); // filesize (always 0)
281   }
282   MCOS->EmitIntValue(0, 1); // Terminate the file list
283
284   // This is the end of the prologue, so set the value of the symbol at the
285   // end of the prologue (that was used in a previous expression).
286   MCOS->EmitLabel(ProEndSym);
287
288   // Put out the line tables.
289   const DenseMap<const MCSection *, MCLineSection *> &MCLineSections =
290     MCOS->getContext().getMCLineSections();
291   const std::vector<const MCSection *> &MCLineSectionOrder =
292     MCOS->getContext().getMCLineSectionOrder();
293   for (std::vector<const MCSection*>::const_iterator it =
294         MCLineSectionOrder.begin(), ie = MCLineSectionOrder.end(); it != ie;
295        ++it) {
296     const MCSection *Sec = *it;
297     const MCLineSection *Line = MCLineSections.lookup(Sec);
298     EmitDwarfLineTable(MCOS, Sec, Line);
299
300     // Now delete the MCLineSections that were created in MCLineEntry::Make()
301     // and used to emit the line table.
302     delete Line;
303   }
304
305   if (MCOS->getContext().getAsmInfo().getLinkerRequiresNonEmptyDwarfLines()
306       && MCLineSectionOrder.begin() == MCLineSectionOrder.end()) {
307     // The darwin9 linker has a bug (see PR8715). For for 32-bit architectures
308     // it requires:  
309     // total_length >= prologue_length + 10
310     // We are 4 bytes short, since we have total_length = 51 and
311     // prologue_length = 45
312
313     // The regular end_sequence should be sufficient.
314     MCDwarfLineAddr::Emit(MCOS, INT64_MAX, 0);
315   }
316
317   // This is the end of the section, so set the value of the symbol at the end
318   // of this section (that was used in a previous expression).
319   MCOS->EmitLabel(LineEndSym);
320 }
321
322 /// Utility function to write the encoding to an object writer.
323 void MCDwarfLineAddr::Write(MCObjectWriter *OW, int64_t LineDelta,
324                             uint64_t AddrDelta) {
325   SmallString<256> Tmp;
326   raw_svector_ostream OS(Tmp);
327   MCDwarfLineAddr::Encode(LineDelta, AddrDelta, OS);
328   OW->WriteBytes(OS.str());
329 }
330
331 /// Utility function to emit the encoding to a streamer.
332 void MCDwarfLineAddr::Emit(MCStreamer *MCOS, int64_t LineDelta,
333                            uint64_t AddrDelta) {
334   SmallString<256> Tmp;
335   raw_svector_ostream OS(Tmp);
336   MCDwarfLineAddr::Encode(LineDelta, AddrDelta, OS);
337   MCOS->EmitBytes(OS.str(), /*AddrSpace=*/0);
338 }
339
340 /// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas.
341 void MCDwarfLineAddr::Encode(int64_t LineDelta, uint64_t AddrDelta,
342                              raw_ostream &OS) {
343   uint64_t Temp, Opcode;
344   bool NeedCopy = false;
345
346   // Scale the address delta by the minimum instruction length.
347   AddrDelta = ScaleAddrDelta(AddrDelta);
348
349   // A LineDelta of INT64_MAX is a signal that this is actually a
350   // DW_LNE_end_sequence. We cannot use special opcodes here, since we want the 
351   // end_sequence to emit the matrix entry.
352   if (LineDelta == INT64_MAX) {
353     if (AddrDelta == MAX_SPECIAL_ADDR_DELTA)
354       OS << char(dwarf::DW_LNS_const_add_pc);
355     else {
356       OS << char(dwarf::DW_LNS_advance_pc);
357       SmallString<32> Tmp;
358       raw_svector_ostream OSE(Tmp);
359       MCObjectWriter::EncodeULEB128(AddrDelta, OSE);
360       OS << OSE.str();
361     }
362     OS << char(dwarf::DW_LNS_extended_op);
363     OS << char(1);
364     OS << char(dwarf::DW_LNE_end_sequence);
365     return;
366   }
367
368   // Bias the line delta by the base.
369   Temp = LineDelta - DWARF2_LINE_BASE;
370
371   // If the line increment is out of range of a special opcode, we must encode
372   // it with DW_LNS_advance_line.
373   if (Temp >= DWARF2_LINE_RANGE) {
374     OS << char(dwarf::DW_LNS_advance_line);
375     SmallString<32> Tmp;
376     raw_svector_ostream OSE(Tmp);
377     MCObjectWriter::EncodeSLEB128(LineDelta, OSE);
378     OS << OSE.str();
379
380     LineDelta = 0;
381     Temp = 0 - DWARF2_LINE_BASE;
382     NeedCopy = true;
383   }
384
385   // Use DW_LNS_copy instead of a "line +0, addr +0" special opcode.
386   if (LineDelta == 0 && AddrDelta == 0) {
387     OS << char(dwarf::DW_LNS_copy);
388     return;
389   }
390
391   // Bias the opcode by the special opcode base.
392   Temp += DWARF2_LINE_OPCODE_BASE;
393
394   // Avoid overflow when addr_delta is large.
395   if (AddrDelta < 256 + MAX_SPECIAL_ADDR_DELTA) {
396     // Try using a special opcode.
397     Opcode = Temp + AddrDelta * DWARF2_LINE_RANGE;
398     if (Opcode <= 255) {
399       OS << char(Opcode);
400       return;
401     }
402
403     // Try using DW_LNS_const_add_pc followed by special op.
404     Opcode = Temp + (AddrDelta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
405     if (Opcode <= 255) {
406       OS << char(dwarf::DW_LNS_const_add_pc);
407       OS << char(Opcode);
408       return;
409     }
410   }
411
412   // Otherwise use DW_LNS_advance_pc.
413   OS << char(dwarf::DW_LNS_advance_pc);
414   SmallString<32> Tmp;
415   raw_svector_ostream OSE(Tmp);
416   MCObjectWriter::EncodeULEB128(AddrDelta, OSE);
417   OS << OSE.str();
418
419   if (NeedCopy)
420     OS << char(dwarf::DW_LNS_copy);
421   else
422     OS << char(Temp);
423 }
424
425 void MCDwarfFile::print(raw_ostream &OS) const {
426   OS << '"' << getName() << '"';
427 }
428
429 void MCDwarfFile::dump() const {
430   print(dbgs());
431 }
432
433 static int getDataAlignmentFactor(MCStreamer &streamer) {
434   MCContext &context = streamer.getContext();
435   const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
436   int size = asmInfo.getPointerSize();
437   if (asmInfo.getStackGrowthDirection() == TargetFrameLowering::StackGrowsUp)
438     return size;
439  else
440    return -size;
441 }
442
443 static unsigned getSizeForEncoding(MCStreamer &streamer,
444                                    unsigned symbolEncoding) {
445   MCContext &context = streamer.getContext();
446   const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
447   unsigned format = symbolEncoding & 0x0f;
448   switch (format) {
449   default:
450     assert(0 && "Unknown Encoding");
451   case dwarf::DW_EH_PE_absptr:
452   case dwarf::DW_EH_PE_signed:
453     return asmInfo.getPointerSize();
454   case dwarf::DW_EH_PE_udata2:
455   case dwarf::DW_EH_PE_sdata2:
456     return 2;
457   case dwarf::DW_EH_PE_udata4:
458   case dwarf::DW_EH_PE_sdata4:
459     return 4;
460   case dwarf::DW_EH_PE_udata8:
461   case dwarf::DW_EH_PE_sdata8:
462     return 8;
463   }
464 }
465
466 static void EmitSymbol(MCStreamer &streamer, const MCSymbol &symbol,
467                        unsigned symbolEncoding) {
468   MCContext &context = streamer.getContext();
469   const MCAsmInfo &asmInfo = context.getAsmInfo();
470   const MCExpr *v = asmInfo.getExprForFDESymbol(&symbol,
471                                                 symbolEncoding,
472                                                 streamer);
473   unsigned size = getSizeForEncoding(streamer, symbolEncoding);
474   streamer.EmitAbsValue(v, size);
475 }
476
477 static void EmitPersonality(MCStreamer &streamer, const MCSymbol &symbol,
478                             unsigned symbolEncoding) {
479   MCContext &context = streamer.getContext();
480   const MCAsmInfo &asmInfo = context.getAsmInfo();
481   const MCExpr *v = asmInfo.getExprForPersonalitySymbol(&symbol,
482                                                         symbolEncoding,
483                                                         streamer);
484   unsigned size = getSizeForEncoding(streamer, symbolEncoding);
485   streamer.EmitValue(v, size);
486 }
487
488 static const MachineLocation TranslateMachineLocation(
489                                                   const TargetAsmInfo &AsmInfo,
490                                                   const MachineLocation &Loc) {
491   unsigned Reg = Loc.getReg() == MachineLocation::VirtualFP ?
492     MachineLocation::VirtualFP :
493     unsigned(AsmInfo.getDwarfRegNum(Loc.getReg(), true));
494   const MachineLocation &NewLoc = Loc.isReg() ?
495     MachineLocation(Reg) : MachineLocation(Reg, Loc.getOffset());
496   return NewLoc;
497 }
498
499 namespace {
500   class FrameEmitterImpl {
501     int CFAOffset;
502     int CIENum;
503     bool UsingCFI;
504
505   public:
506     FrameEmitterImpl(bool usingCFI) : CFAOffset(0), CIENum(0),
507                      UsingCFI(usingCFI) {
508     }
509
510     const MCSymbol &EmitCIE(MCStreamer &streamer,
511                             const MCSymbol *personality,
512                             unsigned personalityEncoding,
513                             const MCSymbol *lsda,
514                             unsigned lsdaEncoding);
515     MCSymbol *EmitFDE(MCStreamer &streamer,
516                       const MCSymbol &cieStart,
517                       const MCDwarfFrameInfo &frame,
518                       bool forceLsda);
519     void EmitCFIInstructions(MCStreamer &streamer,
520                              const std::vector<MCCFIInstruction> &Instrs,
521                              MCSymbol *BaseLabel);
522     void EmitCFIInstruction(MCStreamer &Streamer,
523                             const MCCFIInstruction &Instr);
524   };
525 }
526
527 void FrameEmitterImpl::EmitCFIInstruction(MCStreamer &Streamer,
528                                           const MCCFIInstruction &Instr) {
529   int dataAlignmentFactor = getDataAlignmentFactor(Streamer);
530
531   switch (Instr.getOperation()) {
532   case MCCFIInstruction::Move:
533   case MCCFIInstruction::RelMove: {
534     const MachineLocation &Dst = Instr.getDestination();
535     const MachineLocation &Src = Instr.getSource();
536     const bool IsRelative = Instr.getOperation() == MCCFIInstruction::RelMove;
537
538     // If advancing cfa.
539     if (Dst.isReg() && Dst.getReg() == MachineLocation::VirtualFP) {
540       assert(!Src.isReg() && "Machine move not supported yet.");
541
542       if (Src.getReg() == MachineLocation::VirtualFP) {
543         Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_offset, 1);
544       } else {
545         Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa, 1);
546         Streamer.EmitULEB128IntValue(Src.getReg());
547       }
548
549       if (IsRelative)
550         CFAOffset += Src.getOffset();
551       else
552         CFAOffset = -Src.getOffset();
553
554       Streamer.EmitULEB128IntValue(CFAOffset);
555       return;
556     }
557
558     if (Src.isReg() && Src.getReg() == MachineLocation::VirtualFP) {
559       assert(Dst.isReg() && "Machine move not supported yet.");
560       Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_register, 1);
561       Streamer.EmitULEB128IntValue(Dst.getReg());
562       return;
563     }
564
565     unsigned Reg = Src.getReg();
566
567     int Offset = Dst.getOffset();
568     if (IsRelative)
569       Offset -= CFAOffset;
570     Offset = Offset / dataAlignmentFactor;
571
572     if (Offset < 0) {
573       Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended_sf, 1);
574       Streamer.EmitULEB128IntValue(Reg);
575       Streamer.EmitSLEB128IntValue(Offset);
576     } else if (Reg < 64) {
577       Streamer.EmitIntValue(dwarf::DW_CFA_offset + Reg, 1);
578       Streamer.EmitULEB128IntValue(Offset);
579     } else {
580       Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended, 1);
581       Streamer.EmitULEB128IntValue(Reg);
582       Streamer.EmitULEB128IntValue(Offset);
583     }
584     return;
585   }
586   case MCCFIInstruction::Remember:
587     Streamer.EmitIntValue(dwarf::DW_CFA_remember_state, 1);
588     return;
589   case MCCFIInstruction::Restore:
590     Streamer.EmitIntValue(dwarf::DW_CFA_restore_state, 1);
591     return;
592   case MCCFIInstruction::SameValue: {
593     unsigned Reg = Instr.getDestination().getReg();
594     Streamer.EmitIntValue(dwarf::DW_CFA_same_value, 1);
595     Streamer.EmitULEB128IntValue(Reg);
596     return;
597   }
598   }
599   llvm_unreachable("Unhandled case in switch");
600 }
601
602 /// EmitFrameMoves - Emit frame instructions to describe the layout of the
603 /// frame.
604 void FrameEmitterImpl::EmitCFIInstructions(MCStreamer &streamer,
605                                     const std::vector<MCCFIInstruction> &Instrs,
606                                            MCSymbol *BaseLabel) {
607   for (unsigned i = 0, N = Instrs.size(); i < N; ++i) {
608     const MCCFIInstruction &Instr = Instrs[i];
609     MCSymbol *Label = Instr.getLabel();
610     // Throw out move if the label is invalid.
611     if (Label && !Label->isDefined()) continue; // Not emitted, in dead code.
612
613     // Advance row if new location.
614     if (BaseLabel && Label) {
615       MCSymbol *ThisSym = Label;
616       if (ThisSym != BaseLabel) {
617         streamer.EmitDwarfAdvanceFrameAddr(BaseLabel, ThisSym);
618         BaseLabel = ThisSym;
619       }
620     }
621
622     EmitCFIInstruction(streamer, Instr);
623   }
624 }
625
626 const MCSymbol &FrameEmitterImpl::EmitCIE(MCStreamer &streamer,
627                                           const MCSymbol *personality,
628                                           unsigned personalityEncoding,
629                                           const MCSymbol *lsda,
630                                           unsigned lsdaEncoding) {
631   MCContext &context = streamer.getContext();
632   const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
633   const MCSection &section = *asmInfo.getEHFrameSection();
634   streamer.SwitchSection(&section);
635
636   MCSymbol *sectionStart;
637   if (asmInfo.isFunctionEHFrameSymbolPrivate())
638     sectionStart = context.CreateTempSymbol();
639   else
640     sectionStart = context.GetOrCreateSymbol(Twine("EH_frame") + Twine(CIENum));
641
642   CIENum++;
643
644   MCSymbol *sectionEnd = streamer.getContext().CreateTempSymbol();
645
646   // Length
647   const MCExpr *Length = MakeStartMinusEndExpr(streamer, *sectionStart,
648                                                *sectionEnd, 4);
649   streamer.EmitLabel(sectionStart);
650   streamer.EmitAbsValue(Length, 4);
651
652   // CIE ID
653   streamer.EmitIntValue(0, 4);
654
655   // Version
656   streamer.EmitIntValue(dwarf::DW_CIE_VERSION, 1);
657
658   // Augmentation String
659   SmallString<8> Augmentation;
660   Augmentation += "z";
661   if (personality)
662     Augmentation += "P";
663   if (lsda)
664     Augmentation += "L";
665   Augmentation += "R";
666   streamer.EmitBytes(Augmentation.str(), 0);
667   streamer.EmitIntValue(0, 1);
668
669   // Code Alignment Factor
670   streamer.EmitULEB128IntValue(1);
671
672   // Data Alignment Factor
673   streamer.EmitSLEB128IntValue(getDataAlignmentFactor(streamer));
674
675   // Return Address Register
676   streamer.EmitULEB128IntValue(asmInfo.getDwarfRARegNum(true));
677
678   // Augmentation Data Length (optional)
679
680   unsigned augmentationLength = 0;
681   if (personality) {
682     // Personality Encoding
683     augmentationLength += 1;
684     // Personality
685     augmentationLength += getSizeForEncoding(streamer, personalityEncoding);
686   }
687   if (lsda) {
688     augmentationLength += 1;
689   }
690   // Encoding of the FDE pointers
691   augmentationLength += 1;
692
693   streamer.EmitULEB128IntValue(augmentationLength);
694
695   // Augmentation Data (optional)
696   if (personality) {
697     // Personality Encoding
698     streamer.EmitIntValue(personalityEncoding, 1);
699     // Personality
700     EmitPersonality(streamer, *personality, personalityEncoding);
701   }
702   if (lsda) {
703     // LSDA Encoding
704     streamer.EmitIntValue(lsdaEncoding, 1);
705   }
706   // Encoding of the FDE pointers
707   streamer.EmitIntValue(asmInfo.getFDEEncoding(UsingCFI), 1);
708
709   // Initial Instructions
710
711   const std::vector<MachineMove> Moves = asmInfo.getInitialFrameState();
712   std::vector<MCCFIInstruction> Instructions;
713
714   for (int i = 0, n = Moves.size(); i != n; ++i) {
715     MCSymbol *Label = Moves[i].getLabel();
716     const MachineLocation &Dst =
717       TranslateMachineLocation(asmInfo, Moves[i].getDestination());
718     const MachineLocation &Src =
719       TranslateMachineLocation(asmInfo, Moves[i].getSource());
720     MCCFIInstruction Inst(Label, Dst, Src);
721     Instructions.push_back(Inst);
722   }
723
724   EmitCFIInstructions(streamer, Instructions, NULL);
725
726   // Padding
727   streamer.EmitValueToAlignment(4);
728
729   streamer.EmitLabel(sectionEnd);
730   return *sectionStart;
731 }
732
733 MCSymbol *FrameEmitterImpl::EmitFDE(MCStreamer &streamer,
734                                     const MCSymbol &cieStart,
735                                     const MCDwarfFrameInfo &frame,
736                                     bool forceLsda) {
737   MCContext &context = streamer.getContext();
738   MCSymbol *fdeStart = context.CreateTempSymbol();
739   MCSymbol *fdeEnd = context.CreateTempSymbol();
740   const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
741
742   if (!asmInfo.isFunctionEHFrameSymbolPrivate()) {
743     MCSymbol *EHSym = context.GetOrCreateSymbol(
744       frame.Function->getName() + Twine(".eh"));
745     streamer.EmitEHSymAttributes(frame.Function, EHSym);
746     streamer.EmitLabel(EHSym);
747   }
748
749   // Length
750   const MCExpr *Length = MakeStartMinusEndExpr(streamer, *fdeStart, *fdeEnd, 0);
751   streamer.EmitAbsValue(Length, 4);
752
753   streamer.EmitLabel(fdeStart);
754   // CIE Pointer
755   const MCExpr *offset = MakeStartMinusEndExpr(streamer, cieStart, *fdeStart,
756                                                0);
757   streamer.EmitAbsValue(offset, 4);
758   unsigned fdeEncoding = asmInfo.getFDEEncoding(UsingCFI);
759   unsigned size = getSizeForEncoding(streamer, fdeEncoding);
760
761   // PC Begin
762   EmitSymbol(streamer, *frame.Begin, fdeEncoding);
763
764   // PC Range
765   const MCExpr *Range = MakeStartMinusEndExpr(streamer, *frame.Begin,
766                                               *frame.End, 0);
767   streamer.EmitAbsValue(Range, size);
768
769   // Augmentation Data Length
770   unsigned augmentationLength = 0;
771
772   if (frame.Lsda || forceLsda)
773     augmentationLength += getSizeForEncoding(streamer, frame.LsdaEncoding);
774
775   streamer.EmitULEB128IntValue(augmentationLength);
776
777   // Augmentation Data
778
779   // When running in "CodeGen compatibility mode" a FDE with no LSDA can be
780   // assigned to a CIE that requires one. In that case we output a 0 (as does
781   // CodeGen).
782   if (frame.Lsda)
783     EmitSymbol(streamer, *frame.Lsda, frame.LsdaEncoding);
784   else if (forceLsda)
785     streamer.EmitIntValue(0, getSizeForEncoding(streamer, frame.LsdaEncoding));
786
787   // Call Frame Instructions
788
789   EmitCFIInstructions(streamer, frame.Instructions, frame.Begin);
790
791   // Padding
792   streamer.EmitValueToAlignment(size);
793
794   return fdeEnd;
795 }
796
797 namespace {
798   struct CIEKey {
799     static const CIEKey getEmptyKey() { return CIEKey(0, 0, -1); }
800     static const CIEKey getTombstoneKey() { return CIEKey(0, -1, 0); }
801
802     CIEKey(const MCSymbol* Personality_, unsigned PersonalityEncoding_,
803            unsigned LsdaEncoding_) : Personality(Personality_),
804                                      PersonalityEncoding(PersonalityEncoding_),
805                                      LsdaEncoding(LsdaEncoding_) {
806     }
807     const MCSymbol* Personality;
808     unsigned PersonalityEncoding;
809     unsigned LsdaEncoding;
810   };
811 }
812
813 namespace llvm {
814   template <>
815   struct DenseMapInfo<CIEKey> {
816     static CIEKey getEmptyKey() {
817       return CIEKey::getEmptyKey();
818     }
819     static CIEKey getTombstoneKey() {
820       return CIEKey::getTombstoneKey();
821     }
822     static unsigned getHashValue(const CIEKey &Key) {
823       FoldingSetNodeID ID;
824       ID.AddPointer(Key.Personality);
825       ID.AddInteger(Key.PersonalityEncoding);
826       ID.AddInteger(Key.LsdaEncoding);
827       return ID.ComputeHash();
828     }
829     static bool isEqual(const CIEKey &LHS,
830                         const CIEKey &RHS) {
831       return LHS.Personality == RHS.Personality &&
832         LHS.PersonalityEncoding == RHS.PersonalityEncoding &&
833         LHS.LsdaEncoding == RHS.LsdaEncoding;
834     }
835   };
836 }
837
838 // This is an implementation of CIE and FDE emission that is bug by bug
839 // compatible with the one in CodeGen. It is useful during the transition
840 // to make it easy to compare the outputs, but should probably be removed
841 // afterwards.
842 void MCDwarfFrameEmitter::EmitDarwin(MCStreamer &streamer,
843                                      bool usingCFI) {
844   FrameEmitterImpl Emitter(usingCFI);
845   DenseMap<const MCSymbol*, const MCSymbol*> Personalities;
846   const MCSymbol *aCIE = NULL;
847   const MCDwarfFrameInfo *aFrame = NULL;
848
849   for (unsigned i = 0, n = streamer.getNumFrameInfos(); i < n; ++i) {
850     const MCDwarfFrameInfo &frame = streamer.getFrameInfo(i);
851     if (!frame.Personality)
852       continue;
853     if (Personalities.count(frame.Personality))
854       continue;
855
856     const MCSymbol *cieStart = &Emitter.EmitCIE(streamer, frame.Personality,
857                                                 frame.PersonalityEncoding,
858                                                 frame.Lsda,
859                                                 frame.LsdaEncoding);
860     aCIE = cieStart;
861     aFrame = &frame;
862     Personalities[frame.Personality] = cieStart;
863   }
864
865   if (Personalities.empty()) {
866     const MCDwarfFrameInfo &frame = streamer.getFrameInfo(0);
867     aCIE = &Emitter.EmitCIE(streamer, frame.Personality,
868                             frame.PersonalityEncoding, frame.Lsda,
869                             frame.LsdaEncoding);
870     aFrame = &frame;
871   }
872
873   MCSymbol *fdeEnd = NULL;
874   for (unsigned i = 0, n = streamer.getNumFrameInfos(); i < n; ++i) {
875     const MCDwarfFrameInfo &frame = streamer.getFrameInfo(i);
876     const MCSymbol *cieStart = Personalities[frame.Personality];
877     bool hasLSDA;
878     if (!cieStart) {
879       cieStart = aCIE;
880       hasLSDA = aFrame->Lsda;
881     } else {
882       hasLSDA = true;
883     }
884
885     fdeEnd = Emitter.EmitFDE(streamer, *cieStart, frame,
886                              hasLSDA);
887     if (i != n - 1)
888       streamer.EmitLabel(fdeEnd);
889   }
890
891   const MCContext &context = streamer.getContext();
892   const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
893   streamer.EmitValueToAlignment(asmInfo.getPointerSize());
894   if (fdeEnd)
895     streamer.EmitLabel(fdeEnd);
896 }
897
898 void MCDwarfFrameEmitter::Emit(MCStreamer &streamer,
899                                bool usingCFI) {
900   const MCContext &context = streamer.getContext();
901   const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
902   if (!asmInfo.isFunctionEHFrameSymbolPrivate()) {
903     EmitDarwin(streamer, usingCFI);
904     return;
905   }
906
907   MCSymbol *fdeEnd = NULL;
908   DenseMap<CIEKey, const MCSymbol*> CIEStarts;
909   FrameEmitterImpl Emitter(usingCFI);
910
911   for (unsigned i = 0, n = streamer.getNumFrameInfos(); i < n; ++i) {
912     const MCDwarfFrameInfo &frame = streamer.getFrameInfo(i);
913     CIEKey key(frame.Personality, frame.PersonalityEncoding,
914                frame.LsdaEncoding);
915     const MCSymbol *&cieStart = CIEStarts[key];
916     if (!cieStart)
917       cieStart = &Emitter.EmitCIE(streamer, frame.Personality,
918                                   frame.PersonalityEncoding, frame.Lsda,
919                                   frame.LsdaEncoding);
920     fdeEnd = Emitter.EmitFDE(streamer, *cieStart, frame, false);
921     if (i != n - 1)
922       streamer.EmitLabel(fdeEnd);
923   }
924
925   streamer.EmitValueToAlignment(asmInfo.getPointerSize());
926   if (fdeEnd)
927     streamer.EmitLabel(fdeEnd);
928 }
929
930 void MCDwarfFrameEmitter::EmitAdvanceLoc(MCStreamer &Streamer,
931                                          uint64_t AddrDelta) {
932   SmallString<256> Tmp;
933   raw_svector_ostream OS(Tmp);
934   const TargetAsmInfo &AsmInfo = Streamer.getContext().getTargetAsmInfo();
935   MCDwarfFrameEmitter::EncodeAdvanceLoc(AddrDelta, OS, AsmInfo);
936   Streamer.EmitBytes(OS.str(), /*AddrSpace=*/0);
937 }
938
939 void MCDwarfFrameEmitter::EncodeAdvanceLoc(uint64_t AddrDelta,
940                                            raw_ostream &OS,
941                                            const TargetAsmInfo &AsmInfo) {
942   // This is a small hack to facilitate the transition to CFI on OS X. It
943   // relaxes all address advances which lets us produces identical output
944   // to the one produce by CodeGen.
945   const bool Relax = !AsmInfo.isFunctionEHFrameSymbolPrivate();
946
947   // FIXME: Assumes the code alignment factor is 1.
948   if (AddrDelta == 0) {
949   } else if (isUIntN(6, AddrDelta) && !Relax) {
950     uint8_t Opcode = dwarf::DW_CFA_advance_loc | AddrDelta;
951     OS << Opcode;
952   } else if (isUInt<8>(AddrDelta) && !Relax) {
953     OS << uint8_t(dwarf::DW_CFA_advance_loc1);
954     OS << uint8_t(AddrDelta);
955   } else if (isUInt<16>(AddrDelta) && !Relax) {
956     // FIXME: check what is the correct behavior on a big endian machine.
957     OS << uint8_t(dwarf::DW_CFA_advance_loc2);
958     OS << uint8_t( AddrDelta       & 0xff);
959     OS << uint8_t((AddrDelta >> 8) & 0xff);
960   } else {
961     // FIXME: check what is the correct behavior on a big endian machine.
962     assert(isUInt<32>(AddrDelta));
963     OS << uint8_t(dwarf::DW_CFA_advance_loc4);
964     OS << uint8_t( AddrDelta        & 0xff);
965     OS << uint8_t((AddrDelta >> 8)  & 0xff);
966     OS << uint8_t((AddrDelta >> 16) & 0xff);
967     OS << uint8_t((AddrDelta >> 24) & 0xff);
968
969   }
970 }