CbC/CbC_llvm: lib/MC/MCContext.cpp comparison

comparison lib/MC/MCContext.cpp @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	3a76565eade5

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
 //
 //===----------------------------------------------------------------------===//
 #include "llvm/MC/MCContext.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/BinaryFormat/COFF.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmInfo.h"
-#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCLabel.h"
 #include "llvm/MC/MCObjectFileInfo.h"
-#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionMachO.h"
+#include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolCOFF.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCSymbolMachO.h"
-#include "llvm/Support/COFF.h"
+#include "llvm/MC/MCSymbolWasm.h"
+#include "llvm/MC/SectionKind.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ELF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <cstdlib>
+#include <tuple>
+#include <utility>
 using namespace llvm;
 static cl::opt<char*>
 AsSecureLogFileName("as-secure-log-file-name",
 cl::desc("As secure log file name (initialized from "
 "AS_SECURE_LOG_FILE env variable)"),
 cl::init(getenv("AS_SECURE_LOG_FILE")), cl::Hidden);
 MCContext::MCContext(const MCAsmInfo *mai, const MCRegisterInfo *mri,
 const MCObjectFileInfo *mofi, const SourceMgr *mgr,
 bool DoAutoReset)
-: SrcMgr(mgr), MAI(mai), MRI(mri), MOFI(mofi), Allocator(),
+: SrcMgr(mgr), InlineSrcMgr(nullptr), MAI(mai), MRI(mri), MOFI(mofi),
 Symbols(Allocator), UsedNames(Allocator),
-CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0), DwarfLocSeen(false),
+CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0),
-GenDwarfForAssembly(false), GenDwarfFileNumber(0), DwarfVersion(4),
+AutoReset(DoAutoReset) {
-AllowTemporaryLabels(true), DwarfCompileUnitID(0),
-AutoReset(DoAutoReset), HadError(false) {
 SecureLogFile = AsSecureLogFileName;
-SecureLog = nullptr;
-SecureLogUsed = false;
 if (SrcMgr && SrcMgr->getNumBuffers())
 MainFileName =
 SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())->getBufferIdentifier();
 }
 MachOAllocator.DestroyAll();
 MCSubtargetAllocator.DestroyAll();
 UsedNames.clear();
 Symbols.clear();
-SectionSymbols.clear();
 Allocator.Reset();
 Instances.clear();
 CompilationDir.clear();
 MainFileName.clear();
 MCDwarfLineTablesCUMap.clear();
 Sym = createSymbol(NameRef, false, false);
 return Sym;
 }
-MCSymbolELF *MCContext::getOrCreateSectionSymbol(const MCSectionELF &Section) {
-MCSymbolELF *&Sym = SectionSymbols[&Section];
-if (Sym)
-return Sym;
-StringRef Name = Section.getSectionName();
-auto NameIter = UsedNames.insert(std::make_pair(Name, false)).first;
-Sym = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false);
-return Sym;
-}
 MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName,
 unsigned Idx) {
 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
 "$frame_escape_" + Twine(Idx));
 }
 return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
 case MCObjectFileInfo::IsELF:
 return new (Name, *this) MCSymbolELF(Name, IsTemporary);
 case MCObjectFileInfo::IsMachO:
 return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
+case MCObjectFileInfo::IsWasm:
+return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
 }
 }
 return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
 IsTemporary);
 }
 IsTemporary = Name.startswith(MAI->getPrivateGlobalPrefix());
 SmallString<128> NewName = Name;
 bool AddSuffix = AlwaysAddSuffix;
 unsigned &NextUniqueID = NextID[Name];
-for (;;) {
+while (true) {
 if (AddSuffix) {
 NewName.resize(Name.size());
 raw_svector_ostream(NewName) << NextUniqueID++;
 }
 auto NameEntry = UsedNames.insert(std::make_pair(NewName, true));
 SmallString<128> NameSV;
 StringRef NameRef = Name.toStringRef(NameSV);
 return Symbols.lookup(NameRef);
 }
+void MCContext::setSymbolValue(MCStreamer &Streamer,
+StringRef Sym,
+uint64_t Val) {
+auto Symbol = getOrCreateSymbol(Sym);
+Streamer.EmitAssignment(Symbol, MCConstantExpr::create(Val, *this));
+}
 //===----------------------------------------------------------------------===//
 // Section Management
 //===----------------------------------------------------------------------===//
 MCSectionMachO *MCContext::getMachOSection(StringRef Segment, StringRef Section,
 unsigned TypeAndAttributes,
 unsigned Reserved2, SectionKind Kind,
 const char *BeginSymName) {
 // We unique sections by their segment/section pair.  The returned section
 // may not have the same flags as the requested section, if so this should be
 // diagnosed by the client as an error.
 // Form the name to look up.
 .first;
 StringRef CachedName = I->first.SectionName;
 const_cast<MCSectionELF *>(Section)->setSectionName(CachedName);
 }
+MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type,
+unsigned Flags, SectionKind K,
+unsigned EntrySize,
+const MCSymbolELF *Group,
+unsigned UniqueID,
+const MCSymbolELF *Associated) {
+MCSymbolELF *R;
+MCSymbol *&Sym = Symbols[Section];
+// A section symbol can not redefine regular symbols. There may be multiple
+// sections with the same name, in which case the first such section wins.
+if (Sym && Sym->isDefined() &&
+(!Sym->isInSection() || Sym->getSection().getBeginSymbol() != Sym))
+reportError(SMLoc(), "invalid symbol redefinition");
+if (Sym && Sym->isUndefined()) {
+R = cast<MCSymbolELF>(Sym);
+} else {
+auto NameIter = UsedNames.insert(std::make_pair(Section, false)).first;
+R = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false);
+if (!Sym)
+Sym = R;
+}
+R->setBinding(ELF::STB_LOCAL);
+R->setType(ELF::STT_SECTION);
+auto *Ret = new (ELFAllocator.Allocate()) MCSectionELF(
+Section, Type, Flags, K, EntrySize, Group, UniqueID, R, Associated);
+auto *F = new MCDataFragment();
+Ret->getFragmentList().insert(Ret->begin(), F);
+F->setParent(Ret);
+R->setFragment(F);
+return Ret;
+}
 MCSectionELF *MCContext::createELFRelSection(const Twine &Name, unsigned Type,
 unsigned Flags, unsigned EntrySize,
 const MCSymbolELF *Group,
-const MCSectionELF *Associated) {
+const MCSectionELF *RelInfoSection) {
 StringMap<bool>::iterator I;
 bool Inserted;
 std::tie(I, Inserted) =
-ELFRelSecNames.insert(std::make_pair(Name.str(), true));
+RelSecNames.insert(std::make_pair(Name.str(), true));
-return new (ELFAllocator.Allocate())
+return createELFSectionImpl(
-MCSectionELF(I->getKey(), Type, Flags, SectionKind::getReadOnly(),
+I->getKey(), Type, Flags, SectionKind::getReadOnly(), EntrySize, Group,
-EntrySize, Group, true, nullptr, Associated);
+true, cast<MCSymbolELF>(RelInfoSection->getBeginSymbol()));
 }
 MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix,
 const Twine &Suffix, unsigned Type,
 unsigned Flags,
 }
 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
 unsigned Flags, unsigned EntrySize,
 const Twine &Group, unsigned UniqueID,
-const char *BeginSymName) {
+const MCSymbolELF *Associated) {
 MCSymbolELF *GroupSym = nullptr;
 if (!Group.isTriviallyEmpty() && !Group.str().empty())
 GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group));
 return getELFSection(Section, Type, Flags, EntrySize, GroupSym, UniqueID,
-BeginSymName, nullptr);
+Associated);
 }
 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
 unsigned Flags, unsigned EntrySize,
 const MCSymbolELF *GroupSym,
 unsigned UniqueID,
-const char *BeginSymName,
+const MCSymbolELF *Associated) {
-const MCSectionELF *Associated) {
 StringRef Group = "";
 if (GroupSym)
 Group = GroupSym->getName();
 // Do the lookup, if we have a hit, return it.
 auto IterBool = ELFUniquingMap.insert(
 return Entry.second;
 StringRef CachedName = Entry.first.SectionName;
 SectionKind Kind;
-if (Flags & ELF::SHF_EXECINSTR)
+if (Flags & ELF::SHF_ARM_PURECODE)
+Kind = SectionKind::getExecuteOnly();
+else if (Flags & ELF::SHF_EXECINSTR)
 Kind = SectionKind::getText();
 else
 Kind = SectionKind::getReadOnly();
-MCSymbol *Begin = nullptr;
+MCSectionELF *Result = createELFSectionImpl(
-if (BeginSymName)
+CachedName, Type, Flags, Kind, EntrySize, GroupSym, UniqueID, Associated);
-Begin = createTempSymbol(BeginSymName, false);
-MCSectionELF *Result = new (ELFAllocator.Allocate())
-MCSectionELF(CachedName, Type, Flags, Kind, EntrySize, GroupSym, UniqueID,
-Begin, Associated);
 Entry.second = Result;
 return Result;
 }
 MCSectionELF *MCContext::createELFGroupSection(const MCSymbolELF *Group) {
-MCSectionELF *Result = new (ELFAllocator.Allocate())
+return createELFSectionImpl(".group", ELF::SHT_GROUP, 0,
-MCSectionELF(".group", ELF::SHT_GROUP, 0, SectionKind::getReadOnly(), 4,
+SectionKind::getReadOnly(), 4, Group, ~0,
-Group, ~0, nullptr, nullptr);
+nullptr);
-return Result;
 }
 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
 unsigned Characteristics,
 SectionKind Kind,
 return getCOFFSection(Sec->getSectionName(), Characteristics, Sec->getKind(),
 "", 0, UniqueID);
 }
+MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind K,
+const Twine &Group, unsigned UniqueID,
+const char *BeginSymName) {
+MCSymbolWasm *GroupSym = nullptr;
+if (!Group.isTriviallyEmpty() && !Group.str().empty())
+GroupSym = cast<MCSymbolWasm>(getOrCreateSymbol(Group));
+return getWasmSection(Section, K, GroupSym, UniqueID, BeginSymName);
+}
+MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
+const MCSymbolWasm *GroupSym,
+unsigned UniqueID,
+const char *BeginSymName) {
+StringRef Group = "";
+if (GroupSym)
+Group = GroupSym->getName();
+// Do the lookup, if we have a hit, return it.
+auto IterBool = WasmUniquingMap.insert(
+std::make_pair(WasmSectionKey{Section.str(), Group, UniqueID}, nullptr));
+auto &Entry = *IterBool.first;
+if (!IterBool.second)
+return Entry.second;
+StringRef CachedName = Entry.first.SectionName;
+MCSymbol *Begin = nullptr;
+if (BeginSymName)
+Begin = createTempSymbol(BeginSymName, false);
+MCSectionWasm *Result = new (WasmAllocator.Allocate())
+MCSectionWasm(CachedName, Kind, GroupSym, UniqueID, Begin);
+Entry.second = Result;
+return Result;
+}
 MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {
 return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI);
 }
 //===----------------------------------------------------------------------===//
 //===----------------------------------------------------------------------===//
 void MCContext::reportError(SMLoc Loc, const Twine &Msg) {
 HadError = true;
-// If we have a source manager use it. Otherwise just use the generic
+// If we have a source manager use it. Otherwise, try using the inline source
-// report_fatal_error().
+// manager.
-if (!SrcMgr)
+// If that fails, use the generic report_fatal_error().
+if (SrcMgr)
+SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
+else if (InlineSrcMgr)
+InlineSrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
+else
 report_fatal_error(Msg, false);
-// Use the source manager to print the message.
-SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
 }
 void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) {
 reportError(Loc, Msg);

Mercurial > hg > CbC > CbC_llvm

comparison lib/MC/MCContext.cpp @ 121:803732b1fca8