1//===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===//
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/MC/MCContext.h"
11#include "llvm/ADT/SmallString.h"
12#include "llvm/ADT/Twine.h"
13#include "llvm/MC/MCAsmInfo.h"
14#include "llvm/MC/MCDwarf.h"
15#include "llvm/MC/MCLabel.h"
16#include "llvm/MC/MCObjectFileInfo.h"
17#include "llvm/MC/MCRegisterInfo.h"
18#include "llvm/MC/MCSectionCOFF.h"
19#include "llvm/MC/MCSectionELF.h"
20#include "llvm/MC/MCSectionMachO.h"
21#include "llvm/MC/MCStreamer.h"
22#include "llvm/MC/MCSymbol.h"
23#include "llvm/Support/ELF.h"
24#include "llvm/Support/ErrorHandling.h"
25#include "llvm/Support/FileSystem.h"
26#include "llvm/Support/MemoryBuffer.h"
27#include "llvm/Support/Signals.h"
28#include "llvm/Support/SourceMgr.h"
29#include <map>
30
31using namespace llvm;
32
33MCContext::MCContext(const MCAsmInfo *mai, const MCRegisterInfo *mri,
34                     const MCObjectFileInfo *mofi, const SourceMgr *mgr,
35                     bool DoAutoReset)
36    : SrcMgr(mgr), MAI(mai), MRI(mri), MOFI(mofi), Allocator(),
37      Symbols(Allocator), UsedNames(Allocator),
38      CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0), DwarfLocSeen(false),
39      GenDwarfForAssembly(false), GenDwarfFileNumber(0), DwarfVersion(4),
40      AllowTemporaryLabels(true), DwarfCompileUnitID(0),
41      AutoReset(DoAutoReset) {
42
43  std::error_code EC = llvm::sys::fs::current_path(CompilationDir);
44  if (EC)
45    CompilationDir.clear();
46
47  SecureLogFile = getenv("AS_SECURE_LOG_FILE");
48  SecureLog = nullptr;
49  SecureLogUsed = false;
50
51  if (SrcMgr && SrcMgr->getNumBuffers())
52    MainFileName =
53        SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())->getBufferIdentifier();
54}
55
56MCContext::~MCContext() {
57
58  if (AutoReset)
59    reset();
60
61  // NOTE: The symbols are all allocated out of a bump pointer allocator,
62  // we don't need to free them here.
63
64  // If the stream for the .secure_log_unique directive was created free it.
65  delete (raw_ostream*)SecureLog;
66}
67
68//===----------------------------------------------------------------------===//
69// Module Lifetime Management
70//===----------------------------------------------------------------------===//
71
72void MCContext::reset() {
73  UsedNames.clear();
74  Symbols.clear();
75  Allocator.Reset();
76  Instances.clear();
77  CompilationDir.clear();
78  MainFileName.clear();
79  MCDwarfLineTablesCUMap.clear();
80  SectionStartEndSyms.clear();
81  MCGenDwarfLabelEntries.clear();
82  DwarfDebugFlags = StringRef();
83  DwarfCompileUnitID = 0;
84  CurrentDwarfLoc = MCDwarfLoc(0,0,0,DWARF2_FLAG_IS_STMT,0,0);
85
86  MachOUniquingMap.clear();
87  ELFUniquingMap.clear();
88  COFFUniquingMap.clear();
89
90  NextID.clear();
91  AllowTemporaryLabels = true;
92  DwarfLocSeen = false;
93  GenDwarfForAssembly = false;
94  GenDwarfFileNumber = 0;
95}
96
97//===----------------------------------------------------------------------===//
98// Symbol Manipulation
99//===----------------------------------------------------------------------===//
100
101MCSymbol *MCContext::GetOrCreateSymbol(const Twine &Name) {
102  SmallString<128> NameSV;
103  StringRef NameRef = Name.toStringRef(NameSV);
104
105  assert(!NameRef.empty() && "Normal symbols cannot be unnamed!");
106
107  MCSymbol *&Sym = Symbols[NameRef];
108  if (!Sym)
109    Sym = CreateSymbol(NameRef, false);
110
111  return Sym;
112}
113
114MCSymbol *MCContext::getOrCreateSectionSymbol(const MCSectionELF &Section) {
115  MCSymbol *&Sym = SectionSymbols[&Section];
116  if (Sym)
117    return Sym;
118
119  StringRef Name = Section.getSectionName();
120
121  MCSymbol *&OldSym = Symbols[Name];
122  if (OldSym && OldSym->isUndefined()) {
123    Sym = OldSym;
124    return OldSym;
125  }
126
127  auto NameIter = UsedNames.insert(std::make_pair(Name, true)).first;
128  Sym = new (*this) MCSymbol(NameIter->getKey(), /*isTemporary*/ false);
129
130  if (!OldSym)
131    OldSym = Sym;
132
133  return Sym;
134}
135
136MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName,
137                                                 unsigned Idx) {
138  return GetOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
139                           "$frame_escape_" + Twine(Idx));
140}
141
142MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(StringRef FuncName) {
143  return GetOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
144                           "$parent_frame_offset");
145}
146
147MCSymbol *MCContext::CreateSymbol(StringRef Name, bool AlwaysAddSuffix) {
148  // Determine whether this is an assembler temporary or normal label, if used.
149  bool IsTemporary = false;
150  if (AllowTemporaryLabels)
151    IsTemporary = Name.startswith(MAI->getPrivateGlobalPrefix());
152
153  SmallString<128> NewName = Name;
154  bool AddSuffix = AlwaysAddSuffix;
155  unsigned &NextUniqueID = NextID[Name];
156  for (;;) {
157    if (AddSuffix) {
158      NewName.resize(Name.size());
159      raw_svector_ostream(NewName) << NextUniqueID++;
160    }
161    auto NameEntry = UsedNames.insert(std::make_pair(NewName, true));
162    if (NameEntry.second) {
163      // Ok, we found a name. Have the MCSymbol object itself refer to the copy
164      // of the string that is embedded in the UsedNames entry.
165      MCSymbol *Result =
166          new (*this) MCSymbol(NameEntry.first->getKey(), IsTemporary);
167      return Result;
168    }
169    assert(IsTemporary && "Cannot rename non-temporary symbols");
170    AddSuffix = true;
171  }
172  llvm_unreachable("Infinite loop");
173}
174
175MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix) {
176  SmallString<128> NameSV;
177  raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
178  return CreateSymbol(NameSV, AlwaysAddSuffix);
179}
180
181MCSymbol *MCContext::CreateLinkerPrivateTempSymbol() {
182  SmallString<128> NameSV;
183  raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp";
184  return CreateSymbol(NameSV, true);
185}
186
187MCSymbol *MCContext::CreateTempSymbol() {
188  return createTempSymbol("tmp", true);
189}
190
191unsigned MCContext::NextInstance(unsigned LocalLabelVal) {
192  MCLabel *&Label = Instances[LocalLabelVal];
193  if (!Label)
194    Label = new (*this) MCLabel(0);
195  return Label->incInstance();
196}
197
198unsigned MCContext::GetInstance(unsigned LocalLabelVal) {
199  MCLabel *&Label = Instances[LocalLabelVal];
200  if (!Label)
201    Label = new (*this) MCLabel(0);
202  return Label->getInstance();
203}
204
205MCSymbol *MCContext::getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
206                                                       unsigned Instance) {
207  MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)];
208  if (!Sym)
209    Sym = CreateTempSymbol();
210  return Sym;
211}
212
213MCSymbol *MCContext::CreateDirectionalLocalSymbol(unsigned LocalLabelVal) {
214  unsigned Instance = NextInstance(LocalLabelVal);
215  return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
216}
217
218MCSymbol *MCContext::GetDirectionalLocalSymbol(unsigned LocalLabelVal,
219                                               bool Before) {
220  unsigned Instance = GetInstance(LocalLabelVal);
221  if (!Before)
222    ++Instance;
223  return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
224}
225
226MCSymbol *MCContext::LookupSymbol(const Twine &Name) const {
227  SmallString<128> NameSV;
228  StringRef NameRef = Name.toStringRef(NameSV);
229  return Symbols.lookup(NameRef);
230}
231
232//===----------------------------------------------------------------------===//
233// Section Management
234//===----------------------------------------------------------------------===//
235
236const MCSectionMachO *
237MCContext::getMachOSection(StringRef Segment, StringRef Section,
238                           unsigned TypeAndAttributes, unsigned Reserved2,
239                           SectionKind Kind, const char *BeginSymName) {
240
241  // We unique sections by their segment/section pair.  The returned section
242  // may not have the same flags as the requested section, if so this should be
243  // diagnosed by the client as an error.
244
245  // Form the name to look up.
246  SmallString<64> Name;
247  Name += Segment;
248  Name.push_back(',');
249  Name += Section;
250
251  // Do the lookup, if we have a hit, return it.
252  const MCSectionMachO *&Entry = MachOUniquingMap[Name];
253  if (Entry)
254    return Entry;
255
256  MCSymbol *Begin = nullptr;
257  if (BeginSymName)
258    Begin = createTempSymbol(BeginSymName, false);
259
260  // Otherwise, return a new section.
261  return Entry = new (*this) MCSectionMachO(Segment, Section, TypeAndAttributes,
262                                            Reserved2, Kind, Begin);
263}
264
265void MCContext::renameELFSection(const MCSectionELF *Section, StringRef Name) {
266  StringRef GroupName;
267  if (const MCSymbol *Group = Section->getGroup())
268    GroupName = Group->getName();
269
270  unsigned UniqueID = Section->getUniqueID();
271  ELFUniquingMap.erase(
272      ELFSectionKey{Section->getSectionName(), GroupName, UniqueID});
273  auto I = ELFUniquingMap.insert(std::make_pair(
274                                     ELFSectionKey{Name, GroupName, UniqueID},
275                                     Section)).first;
276  StringRef CachedName = I->first.SectionName;
277  const_cast<MCSectionELF*>(Section)->setSectionName(CachedName);
278}
279
280const MCSectionELF *
281MCContext::createELFRelSection(StringRef Name, unsigned Type, unsigned Flags,
282                               unsigned EntrySize, const MCSymbol *Group,
283                               const MCSectionELF *Associated) {
284  StringMap<bool>::iterator I;
285  bool Inserted;
286  std::tie(I, Inserted) = ELFRelSecNames.insert(std::make_pair(Name, true));
287
288  return new (*this)
289      MCSectionELF(I->getKey(), Type, Flags, SectionKind::getReadOnly(),
290                   EntrySize, Group, true, nullptr, Associated);
291}
292
293const MCSectionELF *MCContext::getELFSection(StringRef Section, unsigned Type,
294                                             unsigned Flags, unsigned EntrySize,
295                                             StringRef Group, unsigned UniqueID,
296                                             const char *BeginSymName) {
297  MCSymbol *GroupSym = nullptr;
298  if (!Group.empty())
299    GroupSym = GetOrCreateSymbol(Group);
300
301  return getELFSection(Section, Type, Flags, EntrySize, GroupSym, UniqueID,
302                       BeginSymName, nullptr);
303}
304
305const MCSectionELF *MCContext::getELFSection(StringRef Section, unsigned Type,
306                                             unsigned Flags, unsigned EntrySize,
307                                             const MCSymbol *GroupSym,
308                                             unsigned UniqueID,
309                                             const char *BeginSymName,
310                                             const MCSectionELF *Associated) {
311  StringRef Group = "";
312  if (GroupSym)
313    Group = GroupSym->getName();
314  // Do the lookup, if we have a hit, return it.
315  auto IterBool = ELFUniquingMap.insert(
316      std::make_pair(ELFSectionKey{Section, Group, UniqueID}, nullptr));
317  auto &Entry = *IterBool.first;
318  if (!IterBool.second)
319    return Entry.second;
320
321  StringRef CachedName = Entry.first.SectionName;
322
323  SectionKind Kind;
324  if (Flags & ELF::SHF_EXECINSTR)
325    Kind = SectionKind::getText();
326  else
327    Kind = SectionKind::getReadOnly();
328
329  MCSymbol *Begin = nullptr;
330  if (BeginSymName)
331    Begin = createTempSymbol(BeginSymName, false);
332
333  MCSectionELF *Result =
334      new (*this) MCSectionELF(CachedName, Type, Flags, Kind, EntrySize,
335                               GroupSym, UniqueID, Begin, Associated);
336  Entry.second = Result;
337  return Result;
338}
339
340const MCSectionELF *MCContext::CreateELFGroupSection() {
341  MCSectionELF *Result = new (*this)
342      MCSectionELF(".group", ELF::SHT_GROUP, 0, SectionKind::getReadOnly(), 4,
343                   nullptr, ~0, nullptr, nullptr);
344  return Result;
345}
346
347const MCSectionCOFF *
348MCContext::getCOFFSection(StringRef Section, unsigned Characteristics,
349                          SectionKind Kind, StringRef COMDATSymName,
350                          int Selection, const char *BeginSymName) {
351  MCSymbol *COMDATSymbol = nullptr;
352  if (!COMDATSymName.empty()) {
353    COMDATSymbol = GetOrCreateSymbol(COMDATSymName);
354    COMDATSymName = COMDATSymbol->getName();
355  }
356
357  // Do the lookup, if we have a hit, return it.
358  COFFSectionKey T{Section, COMDATSymName, Selection};
359  auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
360  auto Iter = IterBool.first;
361  if (!IterBool.second)
362    return Iter->second;
363
364  MCSymbol *Begin = nullptr;
365  if (BeginSymName)
366    Begin = createTempSymbol(BeginSymName, false);
367
368  StringRef CachedName = Iter->first.SectionName;
369  MCSectionCOFF *Result = new (*this) MCSectionCOFF(
370      CachedName, Characteristics, COMDATSymbol, Selection, Kind, Begin);
371
372  Iter->second = Result;
373  return Result;
374}
375
376const MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
377                                               unsigned Characteristics,
378                                               SectionKind Kind,
379                                               const char *BeginSymName) {
380  return getCOFFSection(Section, Characteristics, Kind, "", 0, BeginSymName);
381}
382
383const MCSectionCOFF *MCContext::getCOFFSection(StringRef Section) {
384  COFFSectionKey T{Section, "", 0};
385  auto Iter = COFFUniquingMap.find(T);
386  if (Iter == COFFUniquingMap.end())
387    return nullptr;
388  return Iter->second;
389}
390
391const MCSectionCOFF *
392MCContext::getAssociativeCOFFSection(const MCSectionCOFF *Sec,
393                                     const MCSymbol *KeySym) {
394  // Return the normal section if we don't have to be associative.
395  if (!KeySym)
396    return Sec;
397
398  // Make an associative section with the same name and kind as the normal
399  // section.
400  unsigned Characteristics =
401      Sec->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT;
402  return getCOFFSection(Sec->getSectionName(), Characteristics, Sec->getKind(),
403                        KeySym->getName(),
404                        COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE);
405}
406
407//===----------------------------------------------------------------------===//
408// Dwarf Management
409//===----------------------------------------------------------------------===//
410
411/// GetDwarfFile - takes a file name an number to place in the dwarf file and
412/// directory tables.  If the file number has already been allocated it is an
413/// error and zero is returned and the client reports the error, else the
414/// allocated file number is returned.  The file numbers may be in any order.
415unsigned MCContext::GetDwarfFile(StringRef Directory, StringRef FileName,
416                                 unsigned FileNumber, unsigned CUID) {
417  MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID];
418  return Table.getFile(Directory, FileName, FileNumber);
419}
420
421/// isValidDwarfFileNumber - takes a dwarf file number and returns true if it
422/// currently is assigned and false otherwise.
423bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
424  const SmallVectorImpl<MCDwarfFile>& MCDwarfFiles = getMCDwarfFiles(CUID);
425  if(FileNumber == 0 || FileNumber >= MCDwarfFiles.size())
426    return false;
427
428  return !MCDwarfFiles[FileNumber].Name.empty();
429}
430
431/// finalizeDwarfSections - Emit end symbols for each non-empty code section.
432/// Also remove empty sections from SectionStartEndSyms, to avoid generating
433/// useless debug info for them.
434void MCContext::finalizeDwarfSections(MCStreamer &MCOS) {
435  MCContext &context = MCOS.getContext();
436
437  auto sec = SectionStartEndSyms.begin();
438  while (sec != SectionStartEndSyms.end()) {
439    assert(sec->second.first && "Start symbol must be set by now");
440    MCOS.SwitchSection(sec->first);
441    if (MCOS.mayHaveInstructions()) {
442      MCSymbol *SectionEndSym = context.CreateTempSymbol();
443      MCOS.EmitLabel(SectionEndSym);
444      sec->second.second = SectionEndSym;
445      ++sec;
446    } else {
447      MapVector<const MCSection *, std::pair<MCSymbol *, MCSymbol *> >::iterator
448        to_erase = sec;
449      sec = SectionStartEndSyms.erase(to_erase);
450    }
451  }
452}
453
454void MCContext::FatalError(SMLoc Loc, const Twine &Msg) const {
455  // If we have a source manager and a location, use it. Otherwise just
456  // use the generic report_fatal_error().
457  if (!SrcMgr || Loc == SMLoc())
458    report_fatal_error(Msg, false);
459
460  // Use the source manager to print the message.
461  SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
462
463  // If we reached here, we are failing ungracefully. Run the interrupt handlers
464  // to make sure any special cleanups get done, in particular that we remove
465  // files registered with RemoveFileOnSignal.
466  sys::RunInterruptHandlers();
467  exit(1);
468}
469