2009-06-24 09:03:06 +08:00
|
|
|
//===- lib/MC/MCStreamer.cpp - Streaming Machine Code Output --------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/MC/MCStreamer.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2017-02-08 07:02:00 +08:00
|
|
|
#include "llvm/ADT/StringRef.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/Twine.h"
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/COFF.h"
|
2013-09-09 10:37:14 +08:00
|
|
|
#include "llvm/MC/MCAsmBackend.h"
|
2010-12-07 01:27:56 +08:00
|
|
|
#include "llvm/MC/MCAsmInfo.h"
|
2016-08-27 01:58:37 +08:00
|
|
|
#include "llvm/MC/MCCodeView.h"
|
2010-11-17 05:20:32 +08:00
|
|
|
#include "llvm/MC/MCContext.h"
|
2017-02-08 07:02:00 +08:00
|
|
|
#include "llvm/MC/MCDwarf.h"
|
2010-01-20 02:45:47 +08:00
|
|
|
#include "llvm/MC/MCExpr.h"
|
2015-05-16 06:19:42 +08:00
|
|
|
#include "llvm/MC/MCInst.h"
|
2015-06-19 04:43:22 +08:00
|
|
|
#include "llvm/MC/MCInstPrinter.h"
|
2014-01-24 10:42:26 +08:00
|
|
|
#include "llvm/MC/MCObjectFileInfo.h"
|
2015-03-11 08:51:37 +08:00
|
|
|
#include "llvm/MC/MCSection.h"
|
2016-05-03 07:22:18 +08:00
|
|
|
#include "llvm/MC/MCSectionCOFF.h"
|
2011-04-27 23:21:19 +08:00
|
|
|
#include "llvm/MC/MCSymbol.h"
|
2014-07-17 11:08:50 +08:00
|
|
|
#include "llvm/MC/MCWin64EH.h"
|
2017-02-08 07:02:00 +08:00
|
|
|
#include "llvm/MC/MCWinEH.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/Support/Casting.h"
|
2010-11-01 22:28:48 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2012-08-09 07:56:06 +08:00
|
|
|
#include "llvm/Support/LEB128.h"
|
2017-02-08 07:02:00 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2017-02-08 07:02:00 +08:00
|
|
|
#include <cassert>
|
|
|
|
#include <cstdint>
|
2017-06-06 19:49:48 +08:00
|
|
|
#include <cstdlib>
|
2017-02-08 07:02:00 +08:00
|
|
|
#include <utility>
|
2009-06-24 09:03:06 +08:00
|
|
|
|
2017-02-08 07:02:00 +08:00
|
|
|
using namespace llvm;
|
2014-01-26 14:06:37 +08:00
|
|
|
|
|
|
|
MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
|
|
|
|
S.setTargetStreamer(this);
|
|
|
|
}
|
|
|
|
|
2017-02-08 07:02:00 +08:00
|
|
|
// Pin the vtables to this file.
|
|
|
|
MCTargetStreamer::~MCTargetStreamer() = default;
|
|
|
|
|
2014-01-14 12:25:13 +08:00
|
|
|
void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
|
2013-10-08 21:08:17 +08:00
|
|
|
|
2014-02-01 07:10:26 +08:00
|
|
|
void MCTargetStreamer::finish() {}
|
|
|
|
|
2014-03-20 17:44:49 +08:00
|
|
|
void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {}
|
|
|
|
|
2014-01-26 14:06:37 +08:00
|
|
|
MCStreamer::MCStreamer(MCContext &Ctx)
|
2014-07-14 03:03:36 +08:00
|
|
|
: Context(Ctx), CurrentWinFrameInfo(nullptr) {
|
2013-04-18 05:18:16 +08:00
|
|
|
SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
|
2009-06-24 09:03:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
MCStreamer::~MCStreamer() {
|
2014-07-14 03:03:36 +08:00
|
|
|
for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
|
|
|
|
delete WinFrameInfos[i];
|
2009-06-24 09:03:06 +08:00
|
|
|
}
|
2010-01-20 02:45:47 +08:00
|
|
|
|
2012-12-13 06:59:46 +08:00
|
|
|
void MCStreamer::reset() {
|
2014-09-17 17:25:36 +08:00
|
|
|
DwarfFrameInfos.clear();
|
2014-07-14 03:03:36 +08:00
|
|
|
for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
|
|
|
|
delete WinFrameInfos[i];
|
|
|
|
WinFrameInfos.clear();
|
|
|
|
CurrentWinFrameInfo = nullptr;
|
2014-09-18 01:50:34 +08:00
|
|
|
SymbolOrdering.clear();
|
2012-12-13 06:59:46 +08:00
|
|
|
SectionStack.clear();
|
2013-04-18 05:18:16 +08:00
|
|
|
SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
|
2012-12-13 06:59:46 +08:00
|
|
|
}
|
|
|
|
|
2010-01-23 03:17:48 +08:00
|
|
|
raw_ostream &MCStreamer::GetCommentOS() {
|
|
|
|
// By default, discard comments.
|
|
|
|
return nulls();
|
2013-09-09 10:37:14 +08:00
|
|
|
}
|
|
|
|
|
2014-01-17 00:28:37 +08:00
|
|
|
void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
|
|
|
|
|
2016-07-11 20:42:14 +08:00
|
|
|
void MCStreamer::addExplicitComment(const Twine &T) {}
|
2016-10-11 06:49:37 +08:00
|
|
|
void MCStreamer::emitExplicitComments() {}
|
2016-07-11 20:42:14 +08:00
|
|
|
|
2013-09-10 03:48:37 +08:00
|
|
|
void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) {
|
2014-07-14 03:03:36 +08:00
|
|
|
for (auto &FI : DwarfFrameInfos)
|
|
|
|
FI.CompactUnwindEncoding =
|
|
|
|
(MAB ? MAB->generateCompactUnwindEncoding(FI.Instructions) : 0);
|
2010-01-23 03:17:48 +08:00
|
|
|
}
|
|
|
|
|
2010-01-20 06:03:38 +08:00
|
|
|
/// EmitIntValue - Special case of EmitValue that avoids the client having to
|
|
|
|
/// pass in a MCExpr for constant integers.
|
2013-07-02 23:49:13 +08:00
|
|
|
void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
|
2014-08-21 06:46:38 +08:00
|
|
|
assert(1 <= Size && Size <= 8 && "Invalid size");
|
2010-12-16 07:14:45 +08:00
|
|
|
assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
|
|
|
|
"Invalid size");
|
2010-12-03 10:54:21 +08:00
|
|
|
char buf[8];
|
2013-06-18 15:20:20 +08:00
|
|
|
const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian();
|
2011-06-08 01:31:02 +08:00
|
|
|
for (unsigned i = 0; i != Size; ++i) {
|
|
|
|
unsigned index = isLittleEndian ? i : (Size - i - 1);
|
|
|
|
buf[i] = uint8_t(Value >> (index * 8));
|
|
|
|
}
|
2013-07-02 23:49:13 +08:00
|
|
|
EmitBytes(StringRef(buf, Size));
|
2010-01-20 06:03:38 +08:00
|
|
|
}
|
|
|
|
|
2010-11-03 01:22:24 +08:00
|
|
|
/// EmitULEB128Value - Special case of EmitULEB128Value that avoids the
|
|
|
|
/// client having to pass in a MCExpr for constant integers.
|
2013-07-02 23:49:13 +08:00
|
|
|
void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned Padding) {
|
2012-02-24 05:15:21 +08:00
|
|
|
SmallString<128> Tmp;
|
2010-12-03 09:19:49 +08:00
|
|
|
raw_svector_ostream OSE(Tmp);
|
2012-08-09 07:56:06 +08:00
|
|
|
encodeULEB128(Value, OSE, Padding);
|
2013-07-02 23:49:13 +08:00
|
|
|
EmitBytes(OSE.str());
|
2010-10-01 00:52:03 +08:00
|
|
|
}
|
|
|
|
|
2010-11-03 01:22:24 +08:00
|
|
|
/// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the
|
|
|
|
/// client having to pass in a MCExpr for constant integers.
|
2013-07-02 23:49:13 +08:00
|
|
|
void MCStreamer::EmitSLEB128IntValue(int64_t Value) {
|
2012-02-24 05:15:21 +08:00
|
|
|
SmallString<128> Tmp;
|
2010-12-03 09:19:49 +08:00
|
|
|
raw_svector_ostream OSE(Tmp);
|
2012-08-09 07:56:06 +08:00
|
|
|
encodeSLEB128(Value, OSE);
|
2013-07-02 23:49:13 +08:00
|
|
|
EmitBytes(OSE.str());
|
2010-10-01 00:52:03 +08:00
|
|
|
}
|
|
|
|
|
2015-09-21 07:35:59 +08:00
|
|
|
void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc) {
|
2014-04-23 01:27:29 +08:00
|
|
|
EmitValueImpl(Value, Size, Loc);
|
2010-12-10 15:39:47 +08:00
|
|
|
}
|
|
|
|
|
2014-07-20 05:01:58 +08:00
|
|
|
void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
|
|
|
|
bool IsSectionRelative) {
|
|
|
|
assert((!IsSectionRelative || Size == 4) &&
|
|
|
|
"SectionRelative value requires 4-bytes");
|
|
|
|
|
|
|
|
if (!IsSectionRelative)
|
2015-05-30 09:25:56 +08:00
|
|
|
EmitValueImpl(MCSymbolRefExpr::create(Sym, getContext()), Size);
|
2014-07-20 05:01:58 +08:00
|
|
|
else
|
2017-01-02 11:00:19 +08:00
|
|
|
EmitCOFFSecRel32(Sym, /*Offset=*/0);
|
2010-12-10 15:39:47 +08:00
|
|
|
}
|
|
|
|
|
2016-08-23 00:18:42 +08:00
|
|
|
void MCStreamer::EmitDTPRel64Value(const MCExpr *Value) {
|
|
|
|
report_fatal_error("unsupported directive in streamer");
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::EmitDTPRel32Value(const MCExpr *Value) {
|
|
|
|
report_fatal_error("unsupported directive in streamer");
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::EmitTPRel64Value(const MCExpr *Value) {
|
|
|
|
report_fatal_error("unsupported directive in streamer");
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::EmitTPRel32Value(const MCExpr *Value) {
|
|
|
|
report_fatal_error("unsupported directive in streamer");
|
|
|
|
}
|
|
|
|
|
2012-02-03 12:33:00 +08:00
|
|
|
void MCStreamer::EmitGPRel64Value(const MCExpr *Value) {
|
|
|
|
report_fatal_error("unsupported directive in streamer");
|
|
|
|
}
|
|
|
|
|
2010-11-28 23:09:24 +08:00
|
|
|
void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
|
|
|
|
report_fatal_error("unsupported directive in streamer");
|
|
|
|
}
|
|
|
|
|
2016-06-01 09:59:58 +08:00
|
|
|
/// Emit NumBytes bytes worth of the value specified by FillValue.
|
|
|
|
/// This implements directives such as '.space'.
|
|
|
|
void MCStreamer::emitFill(uint64_t NumBytes, uint8_t FillValue) {
|
2010-01-20 02:45:47 +08:00
|
|
|
for (uint64_t i = 0, e = NumBytes; i != e; ++i)
|
2016-05-28 13:57:48 +08:00
|
|
|
EmitIntValue(FillValue, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::emitFill(uint64_t NumValues, int64_t Size, int64_t Expr) {
|
|
|
|
int64_t NonZeroSize = Size > 4 ? 4 : Size;
|
|
|
|
Expr &= ~0ULL >> (64 - NonZeroSize * 8);
|
|
|
|
for (uint64_t i = 0, e = NumValues; i != e; ++i) {
|
|
|
|
EmitIntValue(Expr, NonZeroSize);
|
|
|
|
if (NonZeroSize < Size)
|
|
|
|
EmitIntValue(0, Size - NonZeroSize);
|
|
|
|
}
|
2010-01-20 02:45:47 +08:00
|
|
|
}
|
2010-04-04 05:35:55 +08:00
|
|
|
|
2016-06-01 09:59:58 +08:00
|
|
|
/// The implementation in this class just redirects to emitFill.
|
2013-07-02 23:49:13 +08:00
|
|
|
void MCStreamer::EmitZeros(uint64_t NumBytes) {
|
2016-06-01 09:59:58 +08:00
|
|
|
emitFill(NumBytes, 0);
|
2013-06-27 22:35:03 +08:00
|
|
|
}
|
|
|
|
|
2014-03-17 09:52:11 +08:00
|
|
|
unsigned MCStreamer::EmitDwarfFileDirective(unsigned FileNo,
|
|
|
|
StringRef Directory,
|
|
|
|
StringRef Filename, unsigned CUID) {
|
2015-05-19 02:43:14 +08:00
|
|
|
return getContext().getDwarfFile(Directory, Filename, FileNo, CUID);
|
2010-11-17 05:20:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
|
|
|
|
unsigned Column, unsigned Flags,
|
|
|
|
unsigned Isa,
|
2011-04-19 04:26:49 +08:00
|
|
|
unsigned Discriminator,
|
|
|
|
StringRef FileName) {
|
2010-11-17 05:20:32 +08:00
|
|
|
getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
|
|
|
|
Discriminator);
|
|
|
|
}
|
|
|
|
|
2014-04-01 16:07:52 +08:00
|
|
|
MCSymbol *MCStreamer::getDwarfLineTableSymbol(unsigned CUID) {
|
|
|
|
MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
|
|
|
|
if (!Table.getLabel()) {
|
|
|
|
StringRef Prefix = Context.getAsmInfo()->getPrivateGlobalPrefix();
|
|
|
|
Table.setLabel(
|
2015-05-19 02:43:14 +08:00
|
|
|
Context.getOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID)));
|
2014-04-01 16:07:52 +08:00
|
|
|
}
|
|
|
|
return Table.getLabel();
|
|
|
|
}
|
|
|
|
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() {
|
|
|
|
if (DwarfFrameInfos.empty())
|
2014-04-13 12:57:38 +08:00
|
|
|
return nullptr;
|
2014-07-14 03:03:36 +08:00
|
|
|
return &DwarfFrameInfos.back();
|
2010-12-10 15:39:47 +08:00
|
|
|
}
|
|
|
|
|
2016-02-25 06:25:18 +08:00
|
|
|
bool MCStreamer::hasUnfinishedDwarfFrameInfo() {
|
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
|
|
|
return CurFrame && !CurFrame->End;
|
|
|
|
}
|
|
|
|
|
2014-07-14 03:03:36 +08:00
|
|
|
void MCStreamer::EnsureValidDwarfFrame() {
|
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-10 15:39:47 +08:00
|
|
|
if (!CurFrame || CurFrame->End)
|
|
|
|
report_fatal_error("No open frame");
|
|
|
|
}
|
|
|
|
|
2016-08-27 01:58:37 +08:00
|
|
|
bool MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename) {
|
|
|
|
return getContext().getCVContext().addFile(FileNo, Filename);
|
2016-01-29 08:49:42 +08:00
|
|
|
}
|
|
|
|
|
2016-09-08 00:15:31 +08:00
|
|
|
bool MCStreamer::EmitCVFuncIdDirective(unsigned FunctionId) {
|
|
|
|
return getContext().getCVContext().recordFunctionId(FunctionId);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MCStreamer::EmitCVInlineSiteIdDirective(unsigned FunctionId,
|
|
|
|
unsigned IAFunc, unsigned IAFile,
|
|
|
|
unsigned IALine, unsigned IACol,
|
|
|
|
SMLoc Loc) {
|
|
|
|
if (getContext().getCVContext().getCVFunctionInfo(IAFunc) == nullptr) {
|
|
|
|
getContext().reportError(Loc, "parent function id not introduced by "
|
|
|
|
".cv_func_id or .cv_inline_site_id");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return getContext().getCVContext().recordInlinedCallSiteId(
|
|
|
|
FunctionId, IAFunc, IAFile, IALine, IACol);
|
|
|
|
}
|
|
|
|
|
2016-01-29 08:49:42 +08:00
|
|
|
void MCStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
|
|
|
|
unsigned Line, unsigned Column,
|
|
|
|
bool PrologueEnd, bool IsStmt,
|
2016-09-08 00:15:31 +08:00
|
|
|
StringRef FileName, SMLoc Loc) {
|
|
|
|
CodeViewContext &CVC = getContext().getCVContext();
|
|
|
|
MCCVFunctionInfo *FI = CVC.getCVFunctionInfo(FunctionId);
|
|
|
|
if (!FI)
|
|
|
|
return getContext().reportError(
|
|
|
|
Loc, "function id not introduced by .cv_func_id or .cv_inline_site_id");
|
|
|
|
|
|
|
|
// Track the section
|
|
|
|
if (FI->Section == nullptr)
|
|
|
|
FI->Section = getCurrentSectionOnly();
|
|
|
|
else if (FI->Section != getCurrentSectionOnly())
|
|
|
|
return getContext().reportError(
|
|
|
|
Loc,
|
|
|
|
"all .cv_loc directives for a function must be in the same section");
|
|
|
|
|
|
|
|
CVC.setCurrentCVLoc(FunctionId, FileNo, Line, Column, PrologueEnd, IsStmt);
|
2016-01-29 08:49:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::EmitCVLinetableDirective(unsigned FunctionId,
|
|
|
|
const MCSymbol *Begin,
|
|
|
|
const MCSymbol *End) {}
|
|
|
|
|
2016-09-08 00:15:31 +08:00
|
|
|
void MCStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
|
|
|
|
unsigned SourceFileId,
|
|
|
|
unsigned SourceLineNum,
|
|
|
|
const MCSymbol *FnStartSym,
|
|
|
|
const MCSymbol *FnEndSym) {}
|
2016-01-30 03:24:12 +08:00
|
|
|
|
2016-02-05 09:55:49 +08:00
|
|
|
void MCStreamer::EmitCVDefRangeDirective(
|
|
|
|
ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
|
|
|
|
StringRef FixedSizePortion) {}
|
|
|
|
|
2011-04-28 20:50:37 +08:00
|
|
|
void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
|
|
|
|
MCSymbol *EHSymbol) {
|
|
|
|
}
|
|
|
|
|
2014-10-16 00:12:52 +08:00
|
|
|
void MCStreamer::InitSections(bool NoExecStack) {
|
2014-01-24 10:42:26 +08:00
|
|
|
SwitchSection(getContext().getObjectFileInfo()->getTextSection());
|
|
|
|
}
|
|
|
|
|
2015-10-05 20:07:05 +08:00
|
|
|
void MCStreamer::AssignFragment(MCSymbol *Symbol, MCFragment *Fragment) {
|
|
|
|
assert(Fragment);
|
|
|
|
Symbol->setFragment(Fragment);
|
2013-09-20 07:21:01 +08:00
|
|
|
|
|
|
|
// As we emit symbols into a section, track the order so that they can
|
|
|
|
// be sorted upon later. Zero is reserved to mean 'unemitted'.
|
|
|
|
SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();
|
|
|
|
}
|
|
|
|
|
2017-02-10 23:13:12 +08:00
|
|
|
void MCStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
|
|
|
|
Symbol->redefineIfPossible();
|
|
|
|
|
|
|
|
if (!Symbol->isUndefined() || Symbol->isVariable())
|
|
|
|
return getContext().reportError(Loc, "invalid symbol redefinition");
|
|
|
|
|
2011-04-27 23:21:19 +08:00
|
|
|
assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
|
2016-10-14 13:47:37 +08:00
|
|
|
assert(getCurrentSectionOnly() && "Cannot emit before setting section!");
|
2015-10-05 20:07:05 +08:00
|
|
|
assert(!Symbol->getFragment() && "Unexpected fragment on symbol data!");
|
2017-02-10 23:13:12 +08:00
|
|
|
assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
|
|
|
|
|
2015-10-05 20:07:05 +08:00
|
|
|
Symbol->setFragment(&getCurrentSectionOnly()->getDummyFragment());
|
2014-01-14 12:25:13 +08:00
|
|
|
|
|
|
|
MCTargetStreamer *TS = getTargetStreamer();
|
|
|
|
if (TS)
|
|
|
|
TS->emitLabel(Symbol);
|
2011-04-27 23:21:19 +08:00
|
|
|
}
|
|
|
|
|
2011-05-10 09:10:18 +08:00
|
|
|
void MCStreamer::EmitCFISections(bool EH, bool Debug) {
|
2011-05-10 21:39:48 +08:00
|
|
|
assert(EH || Debug);
|
2011-05-10 09:10:18 +08:00
|
|
|
}
|
|
|
|
|
2014-11-03 20:19:03 +08:00
|
|
|
void MCStreamer::EmitCFIStartProc(bool IsSimple) {
|
2016-02-25 06:25:18 +08:00
|
|
|
if (hasUnfinishedDwarfFrameInfo())
|
2010-12-10 15:39:47 +08:00
|
|
|
report_fatal_error("Starting a frame before finishing the previous one!");
|
2011-08-03 04:24:22 +08:00
|
|
|
|
2011-08-25 06:31:37 +08:00
|
|
|
MCDwarfFrameInfo Frame;
|
2014-01-28 01:20:25 +08:00
|
|
|
Frame.IsSimple = IsSimple;
|
2014-11-03 20:19:03 +08:00
|
|
|
EmitCFIStartProcImpl(Frame);
|
2012-01-08 06:42:19 +08:00
|
|
|
|
2014-10-07 19:03:09 +08:00
|
|
|
const MCAsmInfo* MAI = Context.getAsmInfo();
|
|
|
|
if (MAI) {
|
|
|
|
for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) {
|
|
|
|
if (Inst.getOperation() == MCCFIInstruction::OpDefCfa ||
|
|
|
|
Inst.getOperation() == MCCFIInstruction::OpDefCfaRegister) {
|
|
|
|
Frame.CurrentCfaRegister = Inst.getRegister();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-14 03:03:36 +08:00
|
|
|
DwarfFrameInfos.push_back(Frame);
|
2012-01-08 06:42:19 +08:00
|
|
|
}
|
2011-08-03 04:24:22 +08:00
|
|
|
|
2014-11-03 20:19:03 +08:00
|
|
|
void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
|
|
|
|
}
|
2012-01-08 06:42:19 +08:00
|
|
|
|
2011-04-13 07:59:07 +08:00
|
|
|
void MCStreamer::EmitCFIEndProc() {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidDwarfFrame();
|
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2012-01-09 08:17:29 +08:00
|
|
|
EmitCFIEndProcImpl(*CurFrame);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
|
2014-06-25 08:13:59 +08:00
|
|
|
// Put a dummy non-null value in Frame.End to mark that this frame has been
|
|
|
|
// closed.
|
|
|
|
Frame.End = (MCSymbol *) 1;
|
2010-11-22 22:27:24 +08:00
|
|
|
}
|
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *MCStreamer::EmitCFILabel() {
|
|
|
|
MCSymbol *Label = getContext().createTempSymbol("cfi", true);
|
2010-12-29 09:42:56 +08:00
|
|
|
EmitLabel(Label);
|
2012-11-24 10:18:49 +08:00
|
|
|
return Label;
|
|
|
|
}
|
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *MCStreamer::EmitCFICommon() {
|
|
|
|
EnsureValidDwarfFrame();
|
|
|
|
return EmitCFILabel();
|
|
|
|
}
|
|
|
|
|
2012-11-24 10:18:49 +08:00
|
|
|
void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
|
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createDefCfa(Label, Register, Offset);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-29 09:42:56 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
2014-10-07 19:03:09 +08:00
|
|
|
CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
|
2010-12-29 09:42:56 +08:00
|
|
|
}
|
|
|
|
|
2011-04-13 07:59:07 +08:00
|
|
|
void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createDefCfaOffset(Label, Offset);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-29 02:36:23 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
2010-11-22 22:27:24 +08:00
|
|
|
}
|
|
|
|
|
2011-04-13 02:53:30 +08:00
|
|
|
void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2011-04-13 02:53:30 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2011-04-13 07:59:07 +08:00
|
|
|
void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createDefCfaRegister(Label, Register);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-29 08:26:06 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
2014-10-07 19:03:09 +08:00
|
|
|
CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
|
2010-11-22 22:27:24 +08:00
|
|
|
}
|
|
|
|
|
2011-04-13 07:59:07 +08:00
|
|
|
void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
2012-11-24 11:10:54 +08:00
|
|
|
MCCFIInstruction::createOffset(Label, Register, Offset);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-29 08:09:59 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
2010-11-22 22:27:24 +08:00
|
|
|
}
|
|
|
|
|
2011-04-13 00:12:03 +08:00
|
|
|
void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createRelOffset(Label, Register, Offset);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2011-04-13 00:12:03 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2011-04-13 07:59:07 +08:00
|
|
|
void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym,
|
2010-12-27 08:36:05 +08:00
|
|
|
unsigned Encoding) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidDwarfFrame();
|
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-10 15:39:47 +08:00
|
|
|
CurFrame->Personality = Sym;
|
2010-12-27 08:36:05 +08:00
|
|
|
CurFrame->PersonalityEncoding = Encoding;
|
2010-11-22 22:27:24 +08:00
|
|
|
}
|
|
|
|
|
2011-04-13 07:59:07 +08:00
|
|
|
void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidDwarfFrame();
|
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-10 15:39:47 +08:00
|
|
|
CurFrame->Lsda = Sym;
|
2010-12-27 23:56:22 +08:00
|
|
|
CurFrame->LsdaEncoding = Encoding;
|
2010-11-22 22:27:24 +08:00
|
|
|
}
|
|
|
|
|
2011-04-13 07:59:07 +08:00
|
|
|
void MCStreamer::EmitCFIRememberState() {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-29 02:36:23 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2011-04-13 07:59:07 +08:00
|
|
|
void MCStreamer::EmitCFIRestoreState() {
|
2010-12-29 02:36:23 +08:00
|
|
|
// FIXME: Error if there is no matching cfi_remember_state.
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2010-12-29 02:36:23 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2011-04-12 23:31:05 +08:00
|
|
|
void MCStreamer::EmitCFISameValue(int64_t Register) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createSameValue(Label, Register);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2011-04-12 23:31:05 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2011-12-30 05:43:03 +08:00
|
|
|
void MCStreamer::EmitCFIRestore(int64_t Register) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createRestore(Label, Register);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2011-12-30 05:43:03 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2011-12-30 04:24:47 +08:00
|
|
|
void MCStreamer::EmitCFIEscape(StringRef Values) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2011-12-30 04:24:47 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
2015-10-07 15:01:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::EmitCFIGnuArgsSize(int64_t Size) {
|
|
|
|
MCSymbol *Label = EmitCFICommon();
|
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createGnuArgsSize(Label, Size);
|
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
2011-12-30 04:24:47 +08:00
|
|
|
}
|
|
|
|
|
2012-01-24 05:51:52 +08:00
|
|
|
void MCStreamer::EmitCFISignalFrame() {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidDwarfFrame();
|
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2012-01-24 05:51:52 +08:00
|
|
|
CurFrame->IsSignalFrame = true;
|
|
|
|
}
|
|
|
|
|
2012-11-24 00:59:41 +08:00
|
|
|
void MCStreamer::EmitCFIUndefined(int64_t Register) {
|
2012-11-24 10:18:49 +08:00
|
|
|
MCSymbol *Label = EmitCFICommon();
|
2012-11-24 10:01:08 +08:00
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createUndefined(Label, Register);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2012-11-24 00:59:41 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2012-11-25 23:14:49 +08:00
|
|
|
void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
|
|
|
|
MCSymbol *Label = EmitCFICommon();
|
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createRegister(Label, Register1, Register2);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2012-11-25 23:14:49 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2013-09-26 22:49:40 +08:00
|
|
|
void MCStreamer::EmitCFIWindowSave() {
|
|
|
|
MCSymbol *Label = EmitCFICommon();
|
|
|
|
MCCFIInstruction Instruction =
|
|
|
|
MCCFIInstruction::createWindowSave(Label);
|
2014-07-14 03:03:36 +08:00
|
|
|
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
|
2013-09-26 22:49:40 +08:00
|
|
|
CurFrame->Instructions.push_back(Instruction);
|
|
|
|
}
|
|
|
|
|
2014-07-14 03:03:36 +08:00
|
|
|
void MCStreamer::EnsureValidWinFrameInfo() {
|
2015-05-30 01:00:57 +08:00
|
|
|
const MCAsmInfo *MAI = Context.getAsmInfo();
|
|
|
|
if (!MAI->usesWindowsCFI())
|
|
|
|
report_fatal_error(".seh_* directives are not supported on this target");
|
2014-07-14 03:03:36 +08:00
|
|
|
if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End)
|
2011-05-19 10:49:00 +08:00
|
|
|
report_fatal_error("No open Win64 EH frame function!");
|
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
|
2015-05-30 01:00:57 +08:00
|
|
|
const MCAsmInfo *MAI = Context.getAsmInfo();
|
|
|
|
if (!MAI->usesWindowsCFI())
|
|
|
|
report_fatal_error(".seh_* directives are not supported on this target");
|
2014-07-14 03:03:36 +08:00
|
|
|
if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
|
2011-05-19 10:49:00 +08:00
|
|
|
report_fatal_error("Starting a function before ending the previous one!");
|
2014-08-04 02:51:17 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *StartProc = EmitCFILabel();
|
2014-08-04 02:51:17 +08:00
|
|
|
|
|
|
|
WinFrameInfos.push_back(new WinEH::FrameInfo(Symbol, StartProc));
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo = WinFrameInfos.back();
|
2016-05-03 07:22:18 +08:00
|
|
|
CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
|
2011-05-19 10:49:00 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFIEndProc() {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
|
|
|
if (CurrentWinFrameInfo->ChainedParent)
|
2011-05-19 10:49:00 +08:00
|
|
|
report_fatal_error("Not all chained regions terminated!");
|
2014-08-04 02:51:17 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-08-04 02:51:17 +08:00
|
|
|
CurrentWinFrameInfo->End = Label;
|
2011-05-16 01:20:01 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFIStartChained() {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
2014-08-04 02:51:17 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *StartProc = EmitCFILabel();
|
2014-08-04 02:51:17 +08:00
|
|
|
|
|
|
|
WinFrameInfos.push_back(new WinEH::FrameInfo(CurrentWinFrameInfo->Function,
|
|
|
|
StartProc, CurrentWinFrameInfo));
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo = WinFrameInfos.back();
|
2016-05-03 07:22:18 +08:00
|
|
|
CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
|
2011-05-19 04:54:10 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFIEndChained() {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
|
|
|
if (!CurrentWinFrameInfo->ChainedParent)
|
2011-05-19 12:04:13 +08:00
|
|
|
report_fatal_error("End of a chained region outside a chained region!");
|
2014-08-04 02:51:17 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-08-04 02:51:17 +08:00
|
|
|
|
|
|
|
CurrentWinFrameInfo->End = Label;
|
|
|
|
CurrentWinFrameInfo =
|
|
|
|
const_cast<WinEH::FrameInfo *>(CurrentWinFrameInfo->ChainedParent);
|
2011-05-19 04:54:10 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
|
|
|
|
bool Except) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
|
|
|
if (CurrentWinFrameInfo->ChainedParent)
|
2011-05-22 01:36:25 +08:00
|
|
|
report_fatal_error("Chained unwind areas can't have handlers!");
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->ExceptionHandler = Sym;
|
2011-05-21 23:57:49 +08:00
|
|
|
if (!Except && !Unwind)
|
2011-05-20 01:46:39 +08:00
|
|
|
report_fatal_error("Don't know what kind of handler this is!");
|
2011-05-21 23:57:49 +08:00
|
|
|
if (Unwind)
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->HandlesUnwind = true;
|
2011-05-21 23:57:49 +08:00
|
|
|
if (Except)
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->HandlesExceptions = true;
|
2011-05-20 01:46:39 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinEHHandlerData() {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
|
|
|
if (CurrentWinFrameInfo->ChainedParent)
|
2011-05-22 01:36:25 +08:00
|
|
|
report_fatal_error("Chained unwind areas can't have handlers!");
|
2011-05-19 04:54:10 +08:00
|
|
|
}
|
|
|
|
|
2016-05-03 07:22:18 +08:00
|
|
|
static MCSection *getWinCFISection(MCContext &Context, unsigned *NextWinCFIID,
|
|
|
|
MCSection *MainCFISec,
|
|
|
|
const MCSection *TextSec) {
|
|
|
|
// If this is the main .text section, use the main unwind info section.
|
|
|
|
if (TextSec == Context.getObjectFileInfo()->getTextSection())
|
|
|
|
return MainCFISec;
|
|
|
|
|
|
|
|
const auto *TextSecCOFF = cast<MCSectionCOFF>(TextSec);
|
|
|
|
unsigned UniqueID = TextSecCOFF->getOrAssignWinCFISectionID(NextWinCFIID);
|
|
|
|
|
|
|
|
// If this section is COMDAT, this unwind section should be COMDAT associative
|
|
|
|
// with its group.
|
|
|
|
const MCSymbol *KeySym = nullptr;
|
|
|
|
if (TextSecCOFF->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT)
|
|
|
|
KeySym = TextSecCOFF->getCOMDATSymbol();
|
|
|
|
|
|
|
|
return Context.getAssociativeCOFFSection(cast<MCSectionCOFF>(MainCFISec),
|
|
|
|
KeySym, UniqueID);
|
|
|
|
}
|
|
|
|
|
|
|
|
MCSection *MCStreamer::getAssociatedPDataSection(const MCSection *TextSec) {
|
|
|
|
return getWinCFISection(getContext(), &NextWinCFIID,
|
|
|
|
getContext().getObjectFileInfo()->getPDataSection(),
|
|
|
|
TextSec);
|
|
|
|
}
|
|
|
|
|
|
|
|
MCSection *MCStreamer::getAssociatedXDataSection(const MCSection *TextSec) {
|
|
|
|
return getWinCFISection(getContext(), &NextWinCFIID,
|
|
|
|
getContext().getObjectFileInfo()->getXDataSection(),
|
|
|
|
TextSec);
|
|
|
|
}
|
|
|
|
|
2015-07-22 18:49:44 +08:00
|
|
|
void MCStreamer::EmitSyntaxDirective() {}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFIPushReg(unsigned Register) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
2014-07-17 11:08:50 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-07-17 11:08:50 +08:00
|
|
|
|
|
|
|
WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->Instructions.push_back(Inst);
|
2011-05-19 04:54:10 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
|
|
|
if (CurrentWinFrameInfo->LastFrameInst >= 0)
|
2011-05-27 09:42:17 +08:00
|
|
|
report_fatal_error("Frame register and offset already specified!");
|
2011-05-22 08:56:20 +08:00
|
|
|
if (Offset & 0x0F)
|
|
|
|
report_fatal_error("Misaligned frame pointer offset!");
|
2014-06-25 20:41:52 +08:00
|
|
|
if (Offset > 240)
|
|
|
|
report_fatal_error("Frame offset must be less than or equal to 240!");
|
2014-07-17 11:08:50 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-07-17 11:08:50 +08:00
|
|
|
|
|
|
|
WinEH::Instruction Inst =
|
|
|
|
Win64EH::Instruction::SetFPReg(Label, Register, Offset);
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->LastFrameInst = CurrentWinFrameInfo->Instructions.size();
|
|
|
|
CurrentWinFrameInfo->Instructions.push_back(Inst);
|
2011-05-16 01:20:01 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFIAllocStack(unsigned Size) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
2014-07-01 08:42:47 +08:00
|
|
|
if (Size == 0)
|
|
|
|
report_fatal_error("Allocation size must be non-zero!");
|
2011-05-22 08:56:20 +08:00
|
|
|
if (Size & 7)
|
|
|
|
report_fatal_error("Misaligned stack allocation!");
|
2014-07-17 11:08:50 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-07-17 11:08:50 +08:00
|
|
|
|
|
|
|
WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->Instructions.push_back(Inst);
|
2011-05-16 01:20:01 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
2011-05-22 08:56:20 +08:00
|
|
|
if (Offset & 7)
|
|
|
|
report_fatal_error("Misaligned saved register offset!");
|
2014-07-17 11:08:50 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-07-17 11:08:50 +08:00
|
|
|
|
|
|
|
WinEH::Instruction Inst =
|
|
|
|
Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->Instructions.push_back(Inst);
|
2011-05-16 01:20:01 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
2011-05-22 08:56:20 +08:00
|
|
|
if (Offset & 0x0F)
|
|
|
|
report_fatal_error("Misaligned saved vector register offset!");
|
2014-07-17 11:08:50 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-07-17 11:08:50 +08:00
|
|
|
|
|
|
|
WinEH::Instruction Inst =
|
|
|
|
Win64EH::Instruction::SaveXMM(Label, Register, Offset);
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->Instructions.push_back(Inst);
|
2011-05-16 01:20:01 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFIPushFrame(bool Code) {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
2017-02-08 07:02:00 +08:00
|
|
|
if (!CurrentWinFrameInfo->Instructions.empty())
|
2011-05-27 09:42:17 +08:00
|
|
|
report_fatal_error("If present, PushMachFrame must be the first UOP");
|
2014-07-17 11:08:50 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-07-17 11:08:50 +08:00
|
|
|
|
|
|
|
WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code);
|
2014-07-14 03:03:36 +08:00
|
|
|
CurrentWinFrameInfo->Instructions.push_back(Inst);
|
2011-05-16 01:20:01 +08:00
|
|
|
}
|
|
|
|
|
2014-06-29 09:52:01 +08:00
|
|
|
void MCStreamer::EmitWinCFIEndProlog() {
|
2014-07-14 03:03:36 +08:00
|
|
|
EnsureValidWinFrameInfo();
|
2014-08-04 02:51:17 +08:00
|
|
|
|
2016-12-01 07:48:26 +08:00
|
|
|
MCSymbol *Label = EmitCFILabel();
|
2014-08-04 02:51:17 +08:00
|
|
|
|
|
|
|
CurrentWinFrameInfo->PrologEnd = Label;
|
2011-05-17 05:13:58 +08:00
|
|
|
}
|
|
|
|
|
2015-05-30 12:56:02 +08:00
|
|
|
void MCStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
|
|
|
|
}
|
|
|
|
|
2013-12-21 02:15:00 +08:00
|
|
|
void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
|
|
|
|
}
|
|
|
|
|
2017-01-02 11:00:19 +08:00
|
|
|
void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {}
|
2011-12-17 09:14:52 +08:00
|
|
|
|
2010-05-21 03:45:09 +08:00
|
|
|
/// EmitRawText - If this file is backed by an assembly streamer, this dumps
|
2010-04-04 05:35:55 +08:00
|
|
|
/// the specified string in the output .s file. This capability is
|
|
|
|
/// indicated by the hasRawTextSupport() predicate.
|
2013-10-25 06:43:10 +08:00
|
|
|
void MCStreamer::EmitRawTextImpl(StringRef String) {
|
2010-04-04 05:35:55 +08:00
|
|
|
errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
|
|
|
|
" something must not be fully mc'ized\n";
|
|
|
|
abort();
|
|
|
|
}
|
2010-04-04 06:12:35 +08:00
|
|
|
|
|
|
|
void MCStreamer::EmitRawText(const Twine &T) {
|
|
|
|
SmallString<128> Str;
|
2013-10-25 06:43:10 +08:00
|
|
|
EmitRawTextImpl(T.toStringRef(Str));
|
2010-04-04 06:12:35 +08:00
|
|
|
}
|
2011-05-10 11:14:15 +08:00
|
|
|
|
2016-10-11 06:49:37 +08:00
|
|
|
void MCStreamer::EmitWindowsUnwindTables() {
|
|
|
|
}
|
|
|
|
|
2012-01-07 11:13:18 +08:00
|
|
|
void MCStreamer::Finish() {
|
2014-07-14 03:03:36 +08:00
|
|
|
if (!DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End)
|
2012-01-07 11:13:18 +08:00
|
|
|
report_fatal_error("Unfinished frame!");
|
|
|
|
|
2014-02-01 07:10:26 +08:00
|
|
|
MCTargetStreamer *TS = getTargetStreamer();
|
|
|
|
if (TS)
|
|
|
|
TS->finish();
|
|
|
|
|
2012-01-07 11:13:18 +08:00
|
|
|
FinishImpl();
|
|
|
|
}
|
2013-02-20 05:57:35 +08:00
|
|
|
|
2014-03-20 17:44:49 +08:00
|
|
|
void MCStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
|
2014-06-26 02:37:33 +08:00
|
|
|
visitUsedExpr(*Value);
|
2014-03-20 17:44:49 +08:00
|
|
|
Symbol->setVariableValue(Value);
|
|
|
|
|
|
|
|
MCTargetStreamer *TS = getTargetStreamer();
|
|
|
|
if (TS)
|
|
|
|
TS->emitAssignment(Symbol, Value);
|
|
|
|
}
|
2014-06-25 08:27:53 +08:00
|
|
|
|
2015-06-19 04:43:22 +08:00
|
|
|
void MCTargetStreamer::prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS,
|
|
|
|
const MCInst &Inst, const MCSubtargetInfo &STI) {
|
|
|
|
InstPrinter.printInst(&Inst, OS, "", STI);
|
|
|
|
}
|
|
|
|
|
2014-06-25 23:45:33 +08:00
|
|
|
void MCStreamer::visitUsedSymbol(const MCSymbol &Sym) {
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCStreamer::visitUsedExpr(const MCExpr &Expr) {
|
|
|
|
switch (Expr.getKind()) {
|
|
|
|
case MCExpr::Target:
|
|
|
|
cast<MCTargetExpr>(Expr).visitUsedExpr(*this);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MCExpr::Constant:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MCExpr::Binary: {
|
|
|
|
const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
|
|
|
|
visitUsedExpr(*BE.getLHS());
|
|
|
|
visitUsedExpr(*BE.getRHS());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case MCExpr::SymbolRef:
|
|
|
|
visitUsedSymbol(cast<MCSymbolRefExpr>(Expr).getSymbol());
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MCExpr::Unary:
|
|
|
|
visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-14 15:44:23 +08:00
|
|
|
void MCStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
|
|
|
|
bool) {
|
2014-06-26 02:37:33 +08:00
|
|
|
// Scan for values.
|
|
|
|
for (unsigned i = Inst.getNumOperands(); i--;)
|
|
|
|
if (Inst.getOperand(i).isExpr())
|
|
|
|
visitUsedExpr(*Inst.getOperand(i).getExpr());
|
|
|
|
}
|
|
|
|
|
2015-06-12 02:58:08 +08:00
|
|
|
void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
|
|
|
|
unsigned Size) {
|
|
|
|
// Get the Hi-Lo expression.
|
|
|
|
const MCExpr *Diff =
|
|
|
|
MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context),
|
|
|
|
MCSymbolRefExpr::create(Lo, Context), Context);
|
|
|
|
|
|
|
|
const MCAsmInfo *MAI = Context.getAsmInfo();
|
2016-06-19 07:25:37 +08:00
|
|
|
if (!MAI->doesSetDirectiveSuppressReloc()) {
|
2015-06-12 02:58:08 +08:00
|
|
|
EmitValue(Diff, Size);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, emit with .set (aka assignment).
|
|
|
|
MCSymbol *SetLabel = Context.createTempSymbol("set", true);
|
|
|
|
EmitAssignment(SetLabel, Diff);
|
|
|
|
EmitSymbolValue(SetLabel, Size);
|
|
|
|
}
|
|
|
|
|
2014-06-25 08:27:53 +08:00
|
|
|
void MCStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {}
|
|
|
|
void MCStreamer::EmitThumbFunc(MCSymbol *Func) {}
|
|
|
|
void MCStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
|
2017-02-28 06:44:37 +08:00
|
|
|
void MCStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
|
|
|
|
llvm_unreachable("this directive only supported on COFF targets");
|
|
|
|
}
|
|
|
|
void MCStreamer::EndCOFFSymbolDef() {
|
|
|
|
llvm_unreachable("this directive only supported on COFF targets");
|
|
|
|
}
|
2014-06-25 08:27:53 +08:00
|
|
|
void MCStreamer::EmitFileDirective(StringRef Filename) {}
|
2017-02-28 06:44:37 +08:00
|
|
|
void MCStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
|
|
|
|
llvm_unreachable("this directive only supported on COFF targets");
|
|
|
|
}
|
|
|
|
void MCStreamer::EmitCOFFSymbolType(int Type) {
|
|
|
|
llvm_unreachable("this directive only supported on COFF targets");
|
|
|
|
}
|
2016-12-02 07:39:08 +08:00
|
|
|
void MCStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
|
Perform symbol binding for .symver versioned symbols
Summary:
In a .symver assembler directive like:
.symver name, name2@@nodename
"name2@@nodename" should get the same symbol binding as "name".
While the ELF object writer is updating the symbol binding for .symver
aliases before emitting the object file, not doing so when the module
inline assembly is handled by the RecordStreamer is causing the wrong
behavior in *LTO mode.
E.g. when "name" is global, "name2@@nodename" must also be marked as
global. Otherwise, the symbol is skipped when iterating over the LTO
InputFile symbols (InputFile::Symbol::shouldSkip). So, for example,
when performing any *LTO via the gold-plugin, the versioned symbol
definition is not recorded by the plugin and passed back to the
linker. If the object was in an archive, and there were no other symbols
needed from that object, the object would not be included in the final
link and references to the versioned symbol are undefined.
The llvm-lto2 tests added will give an error about an unused symbol
resolution without the fix.
Reviewers: rafael, pcc
Reviewed By: pcc
Subscribers: mehdi_amini, llvm-commits
Differential Revision: https://reviews.llvm.org/D30485
llvm-svn: 297332
2017-03-09 08:19:49 +08:00
|
|
|
void MCStreamer::emitELFSymverDirective(MCSymbol *Alias,
|
|
|
|
const MCSymbol *Aliasee) {}
|
2014-06-25 08:27:53 +08:00
|
|
|
void MCStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
|
|
|
|
unsigned ByteAlignment) {}
|
2015-05-22 03:20:38 +08:00
|
|
|
void MCStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
|
2014-06-25 08:27:53 +08:00
|
|
|
uint64_t Size, unsigned ByteAlignment) {}
|
2015-05-22 03:20:38 +08:00
|
|
|
void MCStreamer::ChangeSection(MCSection *, const MCExpr *) {}
|
2014-06-25 08:27:53 +08:00
|
|
|
void MCStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
|
|
|
|
void MCStreamer::EmitBytes(StringRef Data) {}
|
[codeview] Improve readability of type record assembly
Adds the method MCStreamer::EmitBinaryData, which is usually an alias
for EmitBytes. In the MCAsmStreamer case, it is overridden to emit hex
dump output like this:
.byte 0x0e, 0x00, 0x08, 0x10
.byte 0x03, 0x00, 0x00, 0x00
.byte 0x00, 0x00, 0x00, 0x00
.byte 0x00, 0x10, 0x00, 0x00
Also, when verbose asm comments are enabled, this patch prints the dump
output for each comment before its record, like this:
# ArgList (0x1000) {
# TypeLeafKind: LF_ARGLIST (0x1201)
# NumArgs: 0
# Arguments [
# ]
# }
.byte 0x06, 0x00, 0x01, 0x12
.byte 0x00, 0x00, 0x00, 0x00
This should make debugging easier and testing more convenient.
Reviewers: aaboud
Subscribers: majnemer, zturner, amccarth, aaboud, llvm-commits
Differential Revision: http://reviews.llvm.org/D20711
llvm-svn: 271313
2016-06-01 02:45:36 +08:00
|
|
|
void MCStreamer::EmitBinaryData(StringRef Data) { EmitBytes(Data); }
|
2015-09-21 07:35:59 +08:00
|
|
|
void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) {
|
2014-06-26 02:37:33 +08:00
|
|
|
visitUsedExpr(*Value);
|
|
|
|
}
|
2014-06-25 08:27:53 +08:00
|
|
|
void MCStreamer::EmitULEB128Value(const MCExpr *Value) {}
|
|
|
|
void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {}
|
2016-05-28 13:57:48 +08:00
|
|
|
void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {}
|
|
|
|
void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
|
|
|
|
SMLoc Loc) {}
|
2014-06-25 08:27:53 +08:00
|
|
|
void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
|
|
|
|
unsigned ValueSize,
|
|
|
|
unsigned MaxBytesToEmit) {}
|
|
|
|
void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
|
|
|
|
unsigned MaxBytesToEmit) {}
|
2016-12-14 18:43:58 +08:00
|
|
|
void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value,
|
|
|
|
SMLoc Loc) {}
|
2014-06-25 08:27:53 +08:00
|
|
|
void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
|
|
|
|
void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
|
|
|
|
void MCStreamer::FinishImpl() {}
|
|
|
|
void MCStreamer::EmitBundleUnlock() {}
|
2015-03-11 05:35:16 +08:00
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
void MCStreamer::SwitchSection(MCSection *Section, const MCExpr *Subsection) {
|
2015-03-11 05:35:16 +08:00
|
|
|
assert(Section && "Cannot switch to a null section!");
|
|
|
|
MCSectionSubPair curSection = SectionStack.back().first;
|
|
|
|
SectionStack.back().second = curSection;
|
|
|
|
if (MCSectionSubPair(Section, Subsection) != curSection) {
|
2015-05-28 04:52:32 +08:00
|
|
|
ChangeSection(Section, Subsection);
|
2015-03-11 05:35:16 +08:00
|
|
|
SectionStack.back().first = MCSectionSubPair(Section, Subsection);
|
2015-03-24 05:22:04 +08:00
|
|
|
assert(!Section->hasEnded() && "Section already ended");
|
2015-03-11 08:51:37 +08:00
|
|
|
MCSymbol *Sym = Section->getBeginSymbol();
|
|
|
|
if (Sym && !Sym->isInSection())
|
|
|
|
EmitLabel(Sym);
|
2015-03-11 05:35:16 +08:00
|
|
|
}
|
|
|
|
}
|
2015-03-24 05:22:04 +08:00
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSymbol *MCStreamer::endSection(MCSection *Section) {
|
2015-03-24 05:22:04 +08:00
|
|
|
// TODO: keep track of the last subsection so that this symbol appears in the
|
|
|
|
// correct place.
|
|
|
|
MCSymbol *Sym = Section->getEndSymbol(Context);
|
|
|
|
if (Sym->isInSection())
|
|
|
|
return Sym;
|
|
|
|
|
|
|
|
SwitchSection(Section);
|
|
|
|
EmitLabel(Sym);
|
|
|
|
return Sym;
|
|
|
|
}
|