2010-06-17 04:04:22 +08:00
|
|
|
//===- lib/MC/MCObjectStreamer.cpp - Object File MCStreamer Interface -----===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/MC/MCObjectStreamer.h"
|
2013-04-18 05:18:16 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2012-03-26 14:58:25 +08:00
|
|
|
#include "llvm/MC/MCAsmBackend.h"
|
2010-06-17 04:04:22 +08:00
|
|
|
#include "llvm/MC/MCAssembler.h"
|
2010-07-30 01:48:06 +08:00
|
|
|
#include "llvm/MC/MCCodeEmitter.h"
|
2016-08-27 01:58:37 +08:00
|
|
|
#include "llvm/MC/MCCodeView.h"
|
2010-12-10 15:39:47 +08:00
|
|
|
#include "llvm/MC/MCContext.h"
|
2010-11-02 00:27:31 +08:00
|
|
|
#include "llvm/MC/MCDwarf.h"
|
2010-07-19 14:13:10 +08:00
|
|
|
#include "llvm/MC/MCExpr.h"
|
2012-03-26 14:58:25 +08:00
|
|
|
#include "llvm/MC/MCObjectWriter.h"
|
2013-06-27 22:35:03 +08:00
|
|
|
#include "llvm/MC/MCSection.h"
|
2014-01-07 19:48:04 +08:00
|
|
|
#include "llvm/MC/MCSymbol.h"
|
2012-03-26 14:58:25 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2016-05-28 13:57:48 +08:00
|
|
|
#include "llvm/Support/SourceMgr.h"
|
2010-06-17 04:04:22 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2017-10-11 09:57:21 +08:00
|
|
|
MCObjectStreamer::MCObjectStreamer(MCContext &Context,
|
|
|
|
std::unique_ptr<MCAsmBackend> TAB,
|
2018-05-19 02:26:45 +08:00
|
|
|
std::unique_ptr<MCObjectWriter> OW,
|
2017-10-12 07:34:47 +08:00
|
|
|
std::unique_ptr<MCCodeEmitter> Emitter)
|
2018-04-27 23:45:27 +08:00
|
|
|
: MCStreamer(Context),
|
2018-05-19 02:26:45 +08:00
|
|
|
Assembler(llvm::make_unique<MCAssembler>(
|
|
|
|
Context, std::move(TAB), std::move(Emitter), std::move(OW))),
|
2015-05-28 04:52:32 +08:00
|
|
|
EmitEHFrame(true), EmitDebugFrame(false) {}
|
2010-06-17 04:04:22 +08:00
|
|
|
|
2017-10-12 07:34:47 +08:00
|
|
|
MCObjectStreamer::~MCObjectStreamer() {}
|
2010-06-17 04:04:25 +08:00
|
|
|
|
[MC] Change AsmParser to leverage Assembler during evaluation
Teach AsmParser to check with Assembler for when evaluating constant
expressions. This improves the handing of preprocessor expressions
that must be resolved at parse time. This idiom can be found as
assembling-time assertion checks in source-level assemblers. Note that
this relies on the MCStreamer to keep sufficient tabs on Section /
Fragment information which the MCAsmStreamer does not. As a result the
textual output may fail where the equivalent object generation would
pass. This can most easily be resolved by folding the MCAsmStreamer
and MCObjectStreamer together which is planned for in a separate
patch.
Currently, this feature is only enabled for assembly input, keeping IR
compilation consistent between assembly and object generation.
Reviewers: echristo, rnk, probinson, espindola, peter.smith
Reviewed By: peter.smith
Subscribers: eraman, peter.smith, arichardson, jyknight, hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D45164
llvm-svn: 331218
2018-05-01 03:22:40 +08:00
|
|
|
// AssemblerPtr is used for evaluation of expressions and causes
|
|
|
|
// difference between asm and object outputs. Return nullptr to in
|
|
|
|
// inline asm mode to limit divergence to assembly inputs.
|
|
|
|
MCAssembler *MCObjectStreamer::getAssemblerPtr() {
|
|
|
|
if (getUseAssemblerInfoForParsing())
|
|
|
|
return Assembler.get();
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2015-04-13 07:42:25 +08:00
|
|
|
void MCObjectStreamer::flushPendingLabels(MCFragment *F, uint64_t FOffset) {
|
2015-10-03 08:57:12 +08:00
|
|
|
if (PendingLabels.empty())
|
|
|
|
return;
|
|
|
|
if (!F) {
|
|
|
|
F = new MCDataFragment();
|
|
|
|
MCSection *CurSection = getCurrentSectionOnly();
|
|
|
|
CurSection->getFragmentList().insert(CurInsertionPoint, F);
|
|
|
|
F->setParent(CurSection);
|
|
|
|
}
|
|
|
|
for (MCSymbol *Sym : PendingLabels) {
|
|
|
|
Sym->setFragment(F);
|
|
|
|
Sym->setOffset(FOffset);
|
2014-10-23 06:38:06 +08:00
|
|
|
}
|
2015-10-03 08:57:12 +08:00
|
|
|
PendingLabels.clear();
|
2014-10-23 06:38:06 +08:00
|
|
|
}
|
|
|
|
|
2018-02-10 01:00:25 +08:00
|
|
|
// As a compile-time optimization, avoid allocating and evaluating an MCExpr
|
|
|
|
// tree for (Hi - Lo) when Hi and Lo are offsets into the same fragment.
|
2018-08-16 19:26:37 +08:00
|
|
|
static Optional<uint64_t>
|
|
|
|
absoluteSymbolDiff(MCAssembler &Asm, const MCSymbol *Hi, const MCSymbol *Lo) {
|
2018-03-16 05:24:04 +08:00
|
|
|
assert(Hi && Lo);
|
2018-08-16 19:26:37 +08:00
|
|
|
if (Asm.getBackendPtr()->requiresDiffExpressionRelocations())
|
|
|
|
return None;
|
|
|
|
|
2018-02-10 01:00:25 +08:00
|
|
|
if (!Hi->getFragment() || Hi->getFragment() != Lo->getFragment() ||
|
|
|
|
Hi->isVariable() || Lo->isVariable())
|
|
|
|
return None;
|
|
|
|
|
|
|
|
return Hi->getOffset() - Lo->getOffset();
|
|
|
|
}
|
|
|
|
|
2015-06-12 02:58:08 +08:00
|
|
|
void MCObjectStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi,
|
2015-05-21 10:41:23 +08:00
|
|
|
const MCSymbol *Lo,
|
|
|
|
unsigned Size) {
|
2018-08-16 19:26:37 +08:00
|
|
|
if (Optional<uint64_t> Diff = absoluteSymbolDiff(getAssembler(), Hi, Lo)) {
|
2018-02-10 01:00:25 +08:00
|
|
|
EmitIntValue(*Diff, Size);
|
2015-06-12 02:58:08 +08:00
|
|
|
return;
|
|
|
|
}
|
2018-02-10 01:00:25 +08:00
|
|
|
MCStreamer::emitAbsoluteSymbolDiff(Hi, Lo, Size);
|
|
|
|
}
|
2015-05-21 10:41:23 +08:00
|
|
|
|
2018-02-10 01:00:25 +08:00
|
|
|
void MCObjectStreamer::emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi,
|
|
|
|
const MCSymbol *Lo) {
|
2018-08-16 19:26:37 +08:00
|
|
|
if (Optional<uint64_t> Diff = absoluteSymbolDiff(getAssembler(), Hi, Lo)) {
|
2018-02-10 01:00:25 +08:00
|
|
|
EmitULEB128IntValue(*Diff);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
MCStreamer::emitAbsoluteSymbolDiffAsULEB128(Hi, Lo);
|
2015-05-21 10:41:23 +08:00
|
|
|
}
|
|
|
|
|
2012-12-13 06:59:46 +08:00
|
|
|
void MCObjectStreamer::reset() {
|
2012-12-15 02:52:11 +08:00
|
|
|
if (Assembler)
|
|
|
|
Assembler->reset();
|
2015-05-27 23:14:11 +08:00
|
|
|
CurInsertionPoint = MCSection::iterator();
|
2014-05-12 22:02:44 +08:00
|
|
|
EmitEHFrame = true;
|
|
|
|
EmitDebugFrame = false;
|
2014-10-23 06:38:06 +08:00
|
|
|
PendingLabels.clear();
|
2012-12-13 06:59:46 +08:00
|
|
|
MCStreamer::reset();
|
|
|
|
}
|
|
|
|
|
2014-05-12 22:02:44 +08:00
|
|
|
void MCObjectStreamer::EmitFrames(MCAsmBackend *MAB) {
|
|
|
|
if (!getNumFrameInfos())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (EmitEHFrame)
|
|
|
|
MCDwarfFrameEmitter::Emit(*this, MAB, true);
|
|
|
|
|
|
|
|
if (EmitDebugFrame)
|
|
|
|
MCDwarfFrameEmitter::Emit(*this, MAB, false);
|
|
|
|
}
|
|
|
|
|
2010-07-19 14:13:10 +08:00
|
|
|
MCFragment *MCObjectStreamer::getCurrentFragment() const {
|
2015-05-28 05:04:14 +08:00
|
|
|
assert(getCurrentSectionOnly() && "No current section!");
|
2010-07-19 14:13:10 +08:00
|
|
|
|
2015-05-28 05:04:14 +08:00
|
|
|
if (CurInsertionPoint != getCurrentSectionOnly()->getFragmentList().begin())
|
2015-10-10 08:13:11 +08:00
|
|
|
return &*std::prev(CurInsertionPoint);
|
2010-07-19 14:13:10 +08:00
|
|
|
|
2014-04-13 12:57:38 +08:00
|
|
|
return nullptr;
|
2010-07-19 14:13:10 +08:00
|
|
|
}
|
|
|
|
|
2018-06-06 17:40:06 +08:00
|
|
|
static bool CanReuseDataFragment(const MCDataFragment &F,
|
|
|
|
const MCAssembler &Assembler,
|
|
|
|
const MCSubtargetInfo *STI) {
|
|
|
|
if (!F.hasInstructions())
|
|
|
|
return true;
|
2013-02-16 06:50:52 +08:00
|
|
|
// When bundling is enabled, we don't want to add data to a fragment that
|
|
|
|
// already has instructions (see MCELFStreamer::EmitInstToData for details)
|
2018-06-06 17:40:06 +08:00
|
|
|
if (Assembler.isBundlingEnabled())
|
|
|
|
return Assembler.getRelaxAll();
|
|
|
|
// If the subtarget is changed mid fragment we start a new fragment to record
|
|
|
|
// the new STI.
|
|
|
|
return !STI || F.getSubtargetInfo() == STI;
|
|
|
|
}
|
|
|
|
|
|
|
|
MCDataFragment *
|
|
|
|
MCObjectStreamer::getOrCreateDataFragment(const MCSubtargetInfo *STI) {
|
|
|
|
MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
|
|
|
|
if (!F || !CanReuseDataFragment(*F, *Assembler, STI)) {
|
2014-04-11 05:53:47 +08:00
|
|
|
F = new MCDataFragment();
|
2013-04-18 05:18:16 +08:00
|
|
|
insert(F);
|
|
|
|
}
|
2010-07-19 14:13:10 +08:00
|
|
|
return F;
|
|
|
|
}
|
|
|
|
|
2017-10-24 14:16:03 +08:00
|
|
|
MCPaddingFragment *MCObjectStreamer::getOrCreatePaddingFragment() {
|
|
|
|
MCPaddingFragment *F =
|
|
|
|
dyn_cast_or_null<MCPaddingFragment>(getCurrentFragment());
|
|
|
|
if (!F) {
|
|
|
|
F = new MCPaddingFragment();
|
|
|
|
insert(F);
|
|
|
|
}
|
|
|
|
return F;
|
|
|
|
}
|
|
|
|
|
2014-06-25 23:29:54 +08:00
|
|
|
void MCObjectStreamer::visitUsedSymbol(const MCSymbol &Sym) {
|
2015-05-30 04:21:02 +08:00
|
|
|
Assembler->registerSymbol(Sym);
|
2014-06-25 23:29:54 +08:00
|
|
|
}
|
|
|
|
|
2014-05-12 22:02:44 +08:00
|
|
|
void MCObjectStreamer::EmitCFISections(bool EH, bool Debug) {
|
|
|
|
MCStreamer::EmitCFISections(EH, Debug);
|
|
|
|
EmitEHFrame = EH;
|
|
|
|
EmitDebugFrame = Debug;
|
|
|
|
}
|
|
|
|
|
2014-04-23 01:27:29 +08:00
|
|
|
void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
|
2015-09-21 07:35:59 +08:00
|
|
|
SMLoc Loc) {
|
2014-06-26 02:37:33 +08:00
|
|
|
MCStreamer::EmitValueImpl(Value, Size, Loc);
|
2010-11-29 07:08:47 +08:00
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
2015-06-27 09:54:17 +08:00
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
2010-11-29 07:08:47 +08:00
|
|
|
|
2016-10-14 13:47:37 +08:00
|
|
|
MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
|
2013-05-26 05:56:53 +08:00
|
|
|
|
2010-11-29 07:08:47 +08:00
|
|
|
// Avoid fixups when possible.
|
|
|
|
int64_t AbsValue;
|
[MC] Change AsmParser to leverage Assembler during evaluation
Teach AsmParser to check with Assembler for when evaluating constant
expressions. This improves the handing of preprocessor expressions
that must be resolved at parse time. This idiom can be found as
assembling-time assertion checks in source-level assemblers. Note that
this relies on the MCStreamer to keep sufficient tabs on Section /
Fragment information which the MCAsmStreamer does not. As a result the
textual output may fail where the equivalent object generation would
pass. This can most easily be resolved by folding the MCAsmStreamer
and MCObjectStreamer together which is planned for in a separate
patch.
Currently, this feature is only enabled for assembly input, keeping IR
compilation consistent between assembly and object generation.
Reviewers: echristo, rnk, probinson, espindola, peter.smith
Reviewed By: peter.smith
Subscribers: eraman, peter.smith, arichardson, jyknight, hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D45164
llvm-svn: 331218
2018-05-01 03:22:40 +08:00
|
|
|
if (Value->evaluateAsAbsolute(AbsValue, getAssemblerPtr())) {
|
2017-05-15 16:43:27 +08:00
|
|
|
if (!isUIntN(8 * Size, AbsValue) && !isIntN(8 * Size, AbsValue)) {
|
|
|
|
getContext().reportError(
|
|
|
|
Loc, "value evaluated as " + Twine(AbsValue) + " is out of range.");
|
|
|
|
return;
|
|
|
|
}
|
2013-07-02 23:49:13 +08:00
|
|
|
EmitIntValue(AbsValue, Size);
|
2010-12-03 10:54:21 +08:00
|
|
|
return;
|
2010-11-29 07:08:47 +08:00
|
|
|
}
|
2012-12-08 03:13:57 +08:00
|
|
|
DF->getFixups().push_back(
|
2015-05-16 03:13:05 +08:00
|
|
|
MCFixup::create(DF->getContents().size(), Value,
|
2014-04-23 01:27:29 +08:00
|
|
|
MCFixup::getKindForSize(Size, false), Loc));
|
2010-12-03 10:54:21 +08:00
|
|
|
DF->getContents().resize(DF->getContents().size() + Size, 0);
|
2010-11-29 07:08:47 +08:00
|
|
|
}
|
|
|
|
|
[MC] Suppress .Lcfi labels when emitting textual assembly
Summary:
This suppresses the generation of .Lcfi labels in our textual assembler.
It was annoying that this generated cascading .Lcfi labels:
llc foo.ll -o - | llvm-mc | llvm-mc
After three trips through MCAsmStreamer, we'd have three labels in the
output when none are necessary. We should only bother creating the
labels and frame data when making a real object file.
This supercedes D38605, which moved the entire .seh_ implementation into
MCObjectStreamer.
This has the advantage that we do more checking when emitting textual
assembly, as a minor efficiency cost. Outputting textual assembly is not
performance critical, so this shouldn't matter.
Reviewers: majnemer, MatzeB
Subscribers: qcolombet, nemanjai, javed.absar, eraman, hiraditya, JDevlieghere, llvm-commits
Differential Revision: https://reviews.llvm.org/D38638
llvm-svn: 315259
2017-10-10 08:57:36 +08:00
|
|
|
MCSymbol *MCObjectStreamer::EmitCFILabel() {
|
|
|
|
MCSymbol *Label = getContext().createTempSymbol("cfi", true);
|
|
|
|
EmitLabel(Label);
|
|
|
|
return Label;
|
|
|
|
}
|
|
|
|
|
2014-11-03 20:19:03 +08:00
|
|
|
void MCObjectStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
|
|
|
|
// We need to create a local symbol to avoid relocations.
|
2015-05-19 02:43:14 +08:00
|
|
|
Frame.Begin = getContext().createTempSymbol();
|
2014-11-03 20:19:03 +08:00
|
|
|
EmitLabel(Frame.Begin);
|
2012-01-08 06:42:19 +08:00
|
|
|
}
|
|
|
|
|
2012-01-09 08:17:29 +08:00
|
|
|
void MCObjectStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
|
2015-05-19 02:43:14 +08:00
|
|
|
Frame.End = getContext().createTempSymbol();
|
2014-06-25 08:13:59 +08:00
|
|
|
EmitLabel(Frame.End);
|
2012-01-09 08:17:29 +08:00
|
|
|
}
|
|
|
|
|
2017-02-10 23:13:12 +08:00
|
|
|
void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
|
|
|
|
MCStreamer::EmitLabel(Symbol, Loc);
|
2010-11-29 01:18:55 +08:00
|
|
|
|
2015-05-30 04:21:02 +08:00
|
|
|
getAssembler().registerSymbol(*Symbol);
|
2014-10-23 06:38:06 +08:00
|
|
|
|
|
|
|
// If there is a current fragment, mark the symbol as pointing into it.
|
|
|
|
// Otherwise queue the label and set its fragment pointer when we emit the
|
|
|
|
// next fragment.
|
2015-04-13 07:42:25 +08:00
|
|
|
auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
|
|
|
|
if (F && !(getAssembler().isBundlingEnabled() &&
|
|
|
|
getAssembler().getRelaxAll())) {
|
2015-05-30 05:45:01 +08:00
|
|
|
Symbol->setFragment(F);
|
2015-05-30 01:48:04 +08:00
|
|
|
Symbol->setOffset(F->getContents().size());
|
2014-10-23 06:38:06 +08:00
|
|
|
} else {
|
2015-05-30 01:41:59 +08:00
|
|
|
PendingLabels.push_back(Symbol);
|
2014-10-23 06:38:06 +08:00
|
|
|
}
|
2010-11-29 01:18:55 +08:00
|
|
|
}
|
|
|
|
|
2017-04-04 05:50:04 +08:00
|
|
|
void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F) {
|
|
|
|
MCStreamer::EmitLabel(Symbol, Loc);
|
|
|
|
getAssembler().registerSymbol(*Symbol);
|
|
|
|
auto *DF = dyn_cast_or_null<MCDataFragment>(F);
|
|
|
|
if (DF)
|
|
|
|
Symbol->setFragment(F);
|
|
|
|
else
|
|
|
|
PendingLabels.push_back(Symbol);
|
|
|
|
}
|
|
|
|
|
2011-04-22 07:39:26 +08:00
|
|
|
void MCObjectStreamer::EmitULEB128Value(const MCExpr *Value) {
|
2010-12-03 09:19:49 +08:00
|
|
|
int64_t IntValue;
|
[MC] Change AsmParser to leverage Assembler during evaluation
Teach AsmParser to check with Assembler for when evaluating constant
expressions. This improves the handing of preprocessor expressions
that must be resolved at parse time. This idiom can be found as
assembling-time assertion checks in source-level assemblers. Note that
this relies on the MCStreamer to keep sufficient tabs on Section /
Fragment information which the MCAsmStreamer does not. As a result the
textual output may fail where the equivalent object generation would
pass. This can most easily be resolved by folding the MCAsmStreamer
and MCObjectStreamer together which is planned for in a separate
patch.
Currently, this feature is only enabled for assembly input, keeping IR
compilation consistent between assembly and object generation.
Reviewers: echristo, rnk, probinson, espindola, peter.smith
Reviewed By: peter.smith
Subscribers: eraman, peter.smith, arichardson, jyknight, hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D45164
llvm-svn: 331218
2018-05-01 03:22:40 +08:00
|
|
|
if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
|
2011-04-22 07:39:26 +08:00
|
|
|
EmitULEB128IntValue(IntValue);
|
2010-12-03 09:19:49 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-04-18 05:18:16 +08:00
|
|
|
insert(new MCLEBFragment(*Value, false));
|
2010-11-03 01:22:24 +08:00
|
|
|
}
|
|
|
|
|
2011-04-22 07:39:26 +08:00
|
|
|
void MCObjectStreamer::EmitSLEB128Value(const MCExpr *Value) {
|
2010-12-03 09:19:49 +08:00
|
|
|
int64_t IntValue;
|
[MC] Change AsmParser to leverage Assembler during evaluation
Teach AsmParser to check with Assembler for when evaluating constant
expressions. This improves the handing of preprocessor expressions
that must be resolved at parse time. This idiom can be found as
assembling-time assertion checks in source-level assemblers. Note that
this relies on the MCStreamer to keep sufficient tabs on Section /
Fragment information which the MCAsmStreamer does not. As a result the
textual output may fail where the equivalent object generation would
pass. This can most easily be resolved by folding the MCAsmStreamer
and MCObjectStreamer together which is planned for in a separate
patch.
Currently, this feature is only enabled for assembly input, keeping IR
compilation consistent between assembly and object generation.
Reviewers: echristo, rnk, probinson, espindola, peter.smith
Reviewed By: peter.smith
Subscribers: eraman, peter.smith, arichardson, jyknight, hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D45164
llvm-svn: 331218
2018-05-01 03:22:40 +08:00
|
|
|
if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
|
2011-04-22 07:39:26 +08:00
|
|
|
EmitSLEB128IntValue(IntValue);
|
2010-12-03 09:19:49 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-04-18 05:18:16 +08:00
|
|
|
insert(new MCLEBFragment(*Value, true));
|
2010-11-03 01:22:24 +08:00
|
|
|
}
|
|
|
|
|
2010-11-01 22:28:48 +08:00
|
|
|
void MCObjectStreamer::EmitWeakReference(MCSymbol *Alias,
|
|
|
|
const MCSymbol *Symbol) {
|
|
|
|
report_fatal_error("This file format doesn't support weak aliases.");
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
void MCObjectStreamer::ChangeSection(MCSection *Section,
|
2013-04-18 05:18:16 +08:00
|
|
|
const MCExpr *Subsection) {
|
2015-03-21 04:00:01 +08:00
|
|
|
changeSectionImpl(Section, Subsection);
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
bool MCObjectStreamer::changeSectionImpl(MCSection *Section,
|
2015-03-21 04:00:01 +08:00
|
|
|
const MCExpr *Subsection) {
|
2010-06-17 04:04:25 +08:00
|
|
|
assert(Section && "Cannot switch to a null section!");
|
2014-10-23 06:38:06 +08:00
|
|
|
flushPendingLabels(nullptr);
|
2017-03-16 08:52:18 +08:00
|
|
|
getContext().clearDwarfLocSeen();
|
2010-06-17 04:04:25 +08:00
|
|
|
|
2015-05-26 23:07:25 +08:00
|
|
|
bool Created = getAssembler().registerSection(*Section);
|
2013-04-18 05:18:16 +08:00
|
|
|
|
|
|
|
int64_t IntSubsection = 0;
|
|
|
|
if (Subsection &&
|
[MC] Change AsmParser to leverage Assembler during evaluation
Teach AsmParser to check with Assembler for when evaluating constant
expressions. This improves the handing of preprocessor expressions
that must be resolved at parse time. This idiom can be found as
assembling-time assertion checks in source-level assemblers. Note that
this relies on the MCStreamer to keep sufficient tabs on Section /
Fragment information which the MCAsmStreamer does not. As a result the
textual output may fail where the equivalent object generation would
pass. This can most easily be resolved by folding the MCAsmStreamer
and MCObjectStreamer together which is planned for in a separate
patch.
Currently, this feature is only enabled for assembly input, keeping IR
compilation consistent between assembly and object generation.
Reviewers: echristo, rnk, probinson, espindola, peter.smith
Reviewed By: peter.smith
Subscribers: eraman, peter.smith, arichardson, jyknight, hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D45164
llvm-svn: 331218
2018-05-01 03:22:40 +08:00
|
|
|
!Subsection->evaluateAsAbsolute(IntSubsection, getAssemblerPtr()))
|
2013-04-18 05:18:16 +08:00
|
|
|
report_fatal_error("Cannot evaluate subsection number");
|
|
|
|
if (IntSubsection < 0 || IntSubsection > 8192)
|
|
|
|
report_fatal_error("Subsection number out of range");
|
|
|
|
CurInsertionPoint =
|
2015-05-28 04:52:32 +08:00
|
|
|
Section->getSubsectionInsertionPoint(unsigned(IntSubsection));
|
2015-03-21 04:00:01 +08:00
|
|
|
return Created;
|
2010-06-17 04:04:25 +08:00
|
|
|
}
|
|
|
|
|
2012-12-08 01:42:41 +08:00
|
|
|
void MCObjectStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
|
2015-05-30 04:21:02 +08:00
|
|
|
getAssembler().registerSymbol(*Symbol);
|
2014-03-20 17:44:49 +08:00
|
|
|
MCStreamer::EmitAssignment(Symbol, Value);
|
2012-12-08 01:42:41 +08:00
|
|
|
}
|
|
|
|
|
2015-05-26 02:34:26 +08:00
|
|
|
bool MCObjectStreamer::mayHaveInstructions(MCSection &Sec) const {
|
|
|
|
return Sec.hasInstructions();
|
|
|
|
}
|
|
|
|
|
2014-06-26 02:37:33 +08:00
|
|
|
void MCObjectStreamer::EmitInstruction(const MCInst &Inst,
|
2017-04-14 15:44:23 +08:00
|
|
|
const MCSubtargetInfo &STI, bool) {
|
2017-10-24 14:16:03 +08:00
|
|
|
getAssembler().getBackend().handleCodePaddingInstructionBegin(Inst);
|
|
|
|
EmitInstructionImpl(Inst, STI);
|
|
|
|
getAssembler().getBackend().handleCodePaddingInstructionEnd(Inst);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCObjectStreamer::EmitInstructionImpl(const MCInst &Inst,
|
|
|
|
const MCSubtargetInfo &STI) {
|
2014-06-26 02:37:33 +08:00
|
|
|
MCStreamer::EmitInstruction(Inst, STI);
|
2010-11-02 00:27:31 +08:00
|
|
|
|
2015-05-28 05:04:14 +08:00
|
|
|
MCSection *Sec = getCurrentSectionOnly();
|
2015-05-26 22:48:11 +08:00
|
|
|
Sec->setHasInstructions(true);
|
2010-11-02 00:27:31 +08:00
|
|
|
|
|
|
|
// Now that a machine instruction has been assembled into this section, make
|
|
|
|
// a line entry for any .loc directive that has been seen.
|
2016-10-14 13:47:37 +08:00
|
|
|
MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
|
2010-11-02 00:27:31 +08:00
|
|
|
|
|
|
|
// If this instruction doesn't need relaxation, just emit it as data.
|
2012-12-21 03:05:53 +08:00
|
|
|
MCAssembler &Assembler = getAssembler();
|
2018-06-06 17:40:06 +08:00
|
|
|
if (!Assembler.getBackend().mayNeedRelaxation(Inst, STI)) {
|
2014-01-29 07:12:49 +08:00
|
|
|
EmitInstToData(Inst, STI);
|
2010-11-02 00:27:31 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-12-21 03:05:53 +08:00
|
|
|
// Otherwise, relax and emit it as data if either:
|
|
|
|
// - The RelaxAll flag was passed
|
|
|
|
// - Bundling is enabled and this instruction is inside a bundle-locked
|
|
|
|
// group. We want to emit all such instructions into the same data
|
|
|
|
// fragment.
|
|
|
|
if (Assembler.getRelaxAll() ||
|
2015-05-26 22:48:11 +08:00
|
|
|
(Assembler.isBundlingEnabled() && Sec->isBundleLocked())) {
|
2010-11-02 00:27:31 +08:00
|
|
|
MCInst Relaxed;
|
2016-07-11 22:23:53 +08:00
|
|
|
getAssembler().getBackend().relaxInstruction(Inst, STI, Relaxed);
|
2018-06-06 17:40:06 +08:00
|
|
|
while (getAssembler().getBackend().mayNeedRelaxation(Relaxed, STI))
|
2016-07-11 22:23:53 +08:00
|
|
|
getAssembler().getBackend().relaxInstruction(Relaxed, STI, Relaxed);
|
2014-01-29 07:12:49 +08:00
|
|
|
EmitInstToData(Relaxed, STI);
|
2010-11-02 00:27:31 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise emit to a separate fragment.
|
2014-01-29 07:12:49 +08:00
|
|
|
EmitInstToFragment(Inst, STI);
|
2010-11-02 00:27:31 +08:00
|
|
|
}
|
|
|
|
|
2014-01-29 07:12:49 +08:00
|
|
|
void MCObjectStreamer::EmitInstToFragment(const MCInst &Inst,
|
|
|
|
const MCSubtargetInfo &STI) {
|
2015-04-13 07:42:25 +08:00
|
|
|
if (getAssembler().getRelaxAll() && getAssembler().isBundlingEnabled())
|
|
|
|
llvm_unreachable("All instructions should have already been relaxed");
|
|
|
|
|
2012-12-21 03:05:53 +08:00
|
|
|
// Always create a new, separate fragment here, because its size can change
|
|
|
|
// during relaxation.
|
2014-01-29 07:12:53 +08:00
|
|
|
MCRelaxableFragment *IF = new MCRelaxableFragment(Inst, STI);
|
2013-04-18 05:18:16 +08:00
|
|
|
insert(IF);
|
2010-12-02 13:44:06 +08:00
|
|
|
|
2011-04-19 04:54:46 +08:00
|
|
|
SmallString<128> Code;
|
|
|
|
raw_svector_ostream VecOS(Code);
|
2015-05-16 03:13:16 +08:00
|
|
|
getAssembler().getEmitter().encodeInstruction(Inst, VecOS, IF->getFixups(),
|
2014-01-29 07:13:07 +08:00
|
|
|
STI);
|
2012-12-08 03:13:57 +08:00
|
|
|
IF->getContents().append(Code.begin(), Code.end());
|
2010-12-02 13:44:06 +08:00
|
|
|
}
|
|
|
|
|
2013-02-16 07:12:33 +08:00
|
|
|
#ifndef NDEBUG
|
2013-07-16 09:17:10 +08:00
|
|
|
static const char *const BundlingNotImplementedMsg =
|
2012-12-21 03:05:53 +08:00
|
|
|
"Aligned bundling is not implemented for this object format";
|
2013-02-16 07:12:33 +08:00
|
|
|
#endif
|
2012-12-21 03:05:53 +08:00
|
|
|
|
|
|
|
void MCObjectStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
|
|
|
|
llvm_unreachable(BundlingNotImplementedMsg);
|
|
|
|
}
|
|
|
|
|
2013-01-08 05:51:08 +08:00
|
|
|
void MCObjectStreamer::EmitBundleLock(bool AlignToEnd) {
|
2012-12-21 03:05:53 +08:00
|
|
|
llvm_unreachable(BundlingNotImplementedMsg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCObjectStreamer::EmitBundleUnlock() {
|
|
|
|
llvm_unreachable(BundlingNotImplementedMsg);
|
|
|
|
}
|
|
|
|
|
2013-06-20 05:27:27 +08:00
|
|
|
void MCObjectStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
|
|
|
|
unsigned Column, unsigned Flags,
|
|
|
|
unsigned Isa,
|
|
|
|
unsigned Discriminator,
|
|
|
|
StringRef FileName) {
|
|
|
|
// In case we see two .loc directives in a row, make sure the
|
|
|
|
// first one gets a line entry.
|
2016-10-14 13:47:37 +08:00
|
|
|
MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
|
2013-06-20 05:27:27 +08:00
|
|
|
|
|
|
|
this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
|
|
|
|
Isa, Discriminator, FileName);
|
|
|
|
}
|
|
|
|
|
2014-08-15 22:31:47 +08:00
|
|
|
static const MCExpr *buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A,
|
|
|
|
const MCSymbol *B) {
|
|
|
|
MCContext &Context = OS.getContext();
|
|
|
|
MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
|
2015-05-30 09:25:56 +08:00
|
|
|
const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context);
|
|
|
|
const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context);
|
2014-08-15 22:31:47 +08:00
|
|
|
const MCExpr *AddrDelta =
|
2015-05-30 09:25:56 +08:00
|
|
|
MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context);
|
2014-08-15 22:31:47 +08:00
|
|
|
return AddrDelta;
|
|
|
|
}
|
|
|
|
|
2015-08-07 23:14:08 +08:00
|
|
|
static void emitDwarfSetLineAddr(MCObjectStreamer &OS,
|
|
|
|
MCDwarfLineTableParams Params,
|
|
|
|
int64_t LineDelta, const MCSymbol *Label,
|
|
|
|
int PointerSize) {
|
2014-08-15 22:43:02 +08:00
|
|
|
// emit the sequence to set the address
|
|
|
|
OS.EmitIntValue(dwarf::DW_LNS_extended_op, 1);
|
|
|
|
OS.EmitULEB128IntValue(PointerSize + 1);
|
|
|
|
OS.EmitIntValue(dwarf::DW_LNE_set_address, 1);
|
|
|
|
OS.EmitSymbolValue(Label, PointerSize);
|
|
|
|
|
|
|
|
// emit the sequence for the LineDelta (from 1) and a zero address delta.
|
2015-08-07 23:14:08 +08:00
|
|
|
MCDwarfLineAddr::Emit(&OS, Params, LineDelta, 0);
|
2014-08-15 22:43:02 +08:00
|
|
|
}
|
|
|
|
|
2010-12-03 08:55:40 +08:00
|
|
|
void MCObjectStreamer::EmitDwarfAdvanceLineAddr(int64_t LineDelta,
|
|
|
|
const MCSymbol *LastLabel,
|
2011-07-14 13:43:07 +08:00
|
|
|
const MCSymbol *Label,
|
|
|
|
unsigned PointerSize) {
|
2010-12-03 08:55:40 +08:00
|
|
|
if (!LastLabel) {
|
2015-08-07 23:14:08 +08:00
|
|
|
emitDwarfSetLineAddr(*this, Assembler->getDWARFLinetableParams(), LineDelta,
|
|
|
|
Label, PointerSize);
|
2010-12-03 08:55:40 +08:00
|
|
|
return;
|
|
|
|
}
|
2014-08-15 22:31:47 +08:00
|
|
|
const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel);
|
2010-12-03 08:55:40 +08:00
|
|
|
int64_t Res;
|
[MC] Change AsmParser to leverage Assembler during evaluation
Teach AsmParser to check with Assembler for when evaluating constant
expressions. This improves the handing of preprocessor expressions
that must be resolved at parse time. This idiom can be found as
assembling-time assertion checks in source-level assemblers. Note that
this relies on the MCStreamer to keep sufficient tabs on Section /
Fragment information which the MCAsmStreamer does not. As a result the
textual output may fail where the equivalent object generation would
pass. This can most easily be resolved by folding the MCAsmStreamer
and MCObjectStreamer together which is planned for in a separate
patch.
Currently, this feature is only enabled for assembly input, keeping IR
compilation consistent between assembly and object generation.
Reviewers: echristo, rnk, probinson, espindola, peter.smith
Reviewed By: peter.smith
Subscribers: eraman, peter.smith, arichardson, jyknight, hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D45164
llvm-svn: 331218
2018-05-01 03:22:40 +08:00
|
|
|
if (AddrDelta->evaluateAsAbsolute(Res, getAssemblerPtr())) {
|
2015-08-07 23:14:08 +08:00
|
|
|
MCDwarfLineAddr::Emit(this, Assembler->getDWARFLinetableParams(), LineDelta,
|
|
|
|
Res);
|
2010-12-03 08:55:40 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-04-18 05:18:16 +08:00
|
|
|
insert(new MCDwarfLineAddrFragment(LineDelta, *AddrDelta));
|
2010-12-03 08:55:40 +08:00
|
|
|
}
|
|
|
|
|
2010-12-28 13:39:27 +08:00
|
|
|
void MCObjectStreamer::EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
|
|
|
|
const MCSymbol *Label) {
|
2014-08-15 22:31:47 +08:00
|
|
|
const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel);
|
2010-12-28 13:39:27 +08:00
|
|
|
int64_t Res;
|
[MC] Change AsmParser to leverage Assembler during evaluation
Teach AsmParser to check with Assembler for when evaluating constant
expressions. This improves the handing of preprocessor expressions
that must be resolved at parse time. This idiom can be found as
assembling-time assertion checks in source-level assemblers. Note that
this relies on the MCStreamer to keep sufficient tabs on Section /
Fragment information which the MCAsmStreamer does not. As a result the
textual output may fail where the equivalent object generation would
pass. This can most easily be resolved by folding the MCAsmStreamer
and MCObjectStreamer together which is planned for in a separate
patch.
Currently, this feature is only enabled for assembly input, keeping IR
compilation consistent between assembly and object generation.
Reviewers: echristo, rnk, probinson, espindola, peter.smith
Reviewed By: peter.smith
Subscribers: eraman, peter.smith, arichardson, jyknight, hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D45164
llvm-svn: 331218
2018-05-01 03:22:40 +08:00
|
|
|
if (AddrDelta->evaluateAsAbsolute(Res, getAssemblerPtr())) {
|
2010-12-28 13:39:27 +08:00
|
|
|
MCDwarfFrameEmitter::EmitAdvanceLoc(*this, Res);
|
|
|
|
return;
|
|
|
|
}
|
2013-04-18 05:18:16 +08:00
|
|
|
insert(new MCDwarfCallFrameFragment(*AddrDelta));
|
2010-12-28 13:39:27 +08:00
|
|
|
}
|
|
|
|
|
2016-01-29 08:49:42 +08:00
|
|
|
void MCObjectStreamer::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) {
|
2018-08-29 07:25:59 +08:00
|
|
|
// Validate the directive.
|
|
|
|
if (!checkCVLocSection(FunctionId, FileNo, Loc))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Emit a label at the current position and record it in the CodeViewContext.
|
|
|
|
MCSymbol *LineSym = getContext().createTempSymbol();
|
|
|
|
EmitLabel(LineSym);
|
|
|
|
getContext().getCVContext().recordCVLoc(getContext(), LineSym, FunctionId,
|
|
|
|
FileNo, Line, Column, PrologueEnd,
|
|
|
|
IsStmt);
|
2016-01-29 08:49:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MCObjectStreamer::EmitCVLinetableDirective(unsigned FunctionId,
|
|
|
|
const MCSymbol *Begin,
|
|
|
|
const MCSymbol *End) {
|
|
|
|
getContext().getCVContext().emitLineTableForFunction(*this, FunctionId, Begin,
|
|
|
|
End);
|
|
|
|
this->MCStreamer::EmitCVLinetableDirective(FunctionId, Begin, End);
|
|
|
|
}
|
|
|
|
|
2016-01-30 03:24:12 +08:00
|
|
|
void MCObjectStreamer::EmitCVInlineLinetableDirective(
|
|
|
|
unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
|
2016-09-08 00:15:31 +08:00
|
|
|
const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) {
|
2016-01-30 03:24:12 +08:00
|
|
|
getContext().getCVContext().emitInlineLineTableForFunction(
|
2016-02-03 01:41:18 +08:00
|
|
|
*this, PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym,
|
2016-09-08 00:15:31 +08:00
|
|
|
FnEndSym);
|
2016-01-30 03:24:12 +08:00
|
|
|
this->MCStreamer::EmitCVInlineLinetableDirective(
|
2016-09-08 00:15:31 +08:00
|
|
|
PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym);
|
2016-01-30 03:24:12 +08:00
|
|
|
}
|
|
|
|
|
2016-02-05 09:55:49 +08:00
|
|
|
void MCObjectStreamer::EmitCVDefRangeDirective(
|
|
|
|
ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
|
|
|
|
StringRef FixedSizePortion) {
|
|
|
|
getContext().getCVContext().emitDefRange(*this, Ranges, FixedSizePortion);
|
|
|
|
this->MCStreamer::EmitCVDefRangeDirective(Ranges, FixedSizePortion);
|
|
|
|
}
|
|
|
|
|
2016-01-29 08:49:42 +08:00
|
|
|
void MCObjectStreamer::EmitCVStringTableDirective() {
|
|
|
|
getContext().getCVContext().emitStringTable(*this);
|
|
|
|
}
|
|
|
|
void MCObjectStreamer::EmitCVFileChecksumsDirective() {
|
|
|
|
getContext().getCVContext().emitFileChecksums(*this);
|
|
|
|
}
|
|
|
|
|
2017-09-20 02:14:45 +08:00
|
|
|
void MCObjectStreamer::EmitCVFileChecksumOffsetDirective(unsigned FileNo) {
|
|
|
|
getContext().getCVContext().emitFileChecksumOffset(*this, FileNo);
|
|
|
|
}
|
2016-01-29 08:49:42 +08:00
|
|
|
|
2013-07-02 23:49:13 +08:00
|
|
|
void MCObjectStreamer::EmitBytes(StringRef Data) {
|
2016-10-14 13:47:37 +08:00
|
|
|
MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
|
2015-06-27 09:54:17 +08:00
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
|
|
|
DF->getContents().append(Data.begin(), Data.end());
|
2012-10-04 21:12:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MCObjectStreamer::EmitValueToAlignment(unsigned ByteAlignment,
|
|
|
|
int64_t Value,
|
|
|
|
unsigned ValueSize,
|
|
|
|
unsigned MaxBytesToEmit) {
|
|
|
|
if (MaxBytesToEmit == 0)
|
|
|
|
MaxBytesToEmit = ByteAlignment;
|
2013-04-18 05:18:16 +08:00
|
|
|
insert(new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit));
|
2012-10-04 21:12:43 +08:00
|
|
|
|
|
|
|
// Update the maximum alignment on the current section if necessary.
|
2016-10-14 13:47:37 +08:00
|
|
|
MCSection *CurSec = getCurrentSectionOnly();
|
2015-05-22 05:02:35 +08:00
|
|
|
if (ByteAlignment > CurSec->getAlignment())
|
|
|
|
CurSec->setAlignment(ByteAlignment);
|
2012-10-04 21:12:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MCObjectStreamer::EmitCodeAlignment(unsigned ByteAlignment,
|
|
|
|
unsigned MaxBytesToEmit) {
|
|
|
|
EmitValueToAlignment(ByteAlignment, 0, 1, MaxBytesToEmit);
|
|
|
|
cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(true);
|
|
|
|
}
|
|
|
|
|
2015-11-05 07:59:18 +08:00
|
|
|
void MCObjectStreamer::emitValueToOffset(const MCExpr *Offset,
|
2016-12-14 18:43:58 +08:00
|
|
|
unsigned char Value,
|
|
|
|
SMLoc Loc) {
|
|
|
|
insert(new MCOrgFragment(*Offset, Value, Loc));
|
2010-12-02 13:59:38 +08:00
|
|
|
}
|
|
|
|
|
2017-10-24 14:16:03 +08:00
|
|
|
void MCObjectStreamer::EmitCodePaddingBasicBlockStart(
|
|
|
|
const MCCodePaddingContext &Context) {
|
|
|
|
getAssembler().getBackend().handleCodePaddingBasicBlockStart(this, Context);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCObjectStreamer::EmitCodePaddingBasicBlockEnd(
|
|
|
|
const MCCodePaddingContext &Context) {
|
|
|
|
getAssembler().getBackend().handleCodePaddingBasicBlockEnd(Context);
|
|
|
|
}
|
|
|
|
|
2016-08-23 00:18:42 +08:00
|
|
|
// Associate DTPRel32 fixup with data and resize data area
|
|
|
|
void MCObjectStreamer::EmitDTPRel32Value(const MCExpr *Value) {
|
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
|
|
|
|
|
|
|
DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
|
|
|
|
Value, FK_DTPRel_4));
|
|
|
|
DF->getContents().resize(DF->getContents().size() + 4, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Associate DTPRel64 fixup with data and resize data area
|
|
|
|
void MCObjectStreamer::EmitDTPRel64Value(const MCExpr *Value) {
|
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
|
|
|
|
|
|
|
DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
|
|
|
|
Value, FK_DTPRel_8));
|
|
|
|
DF->getContents().resize(DF->getContents().size() + 8, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Associate TPRel32 fixup with data and resize data area
|
|
|
|
void MCObjectStreamer::EmitTPRel32Value(const MCExpr *Value) {
|
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
|
|
|
|
|
|
|
DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
|
|
|
|
Value, FK_TPRel_4));
|
|
|
|
DF->getContents().resize(DF->getContents().size() + 4, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Associate TPRel64 fixup with data and resize data area
|
|
|
|
void MCObjectStreamer::EmitTPRel64Value(const MCExpr *Value) {
|
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
|
|
|
|
|
|
|
DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
|
|
|
|
Value, FK_TPRel_8));
|
|
|
|
DF->getContents().resize(DF->getContents().size() + 8, 0);
|
|
|
|
}
|
|
|
|
|
2011-11-24 06:18:04 +08:00
|
|
|
// Associate GPRel32 fixup with data and resize data area
|
|
|
|
void MCObjectStreamer::EmitGPRel32Value(const MCExpr *Value) {
|
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
2015-06-27 09:54:17 +08:00
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
2011-11-24 06:18:04 +08:00
|
|
|
|
2017-04-04 05:50:04 +08:00
|
|
|
DF->getFixups().push_back(
|
|
|
|
MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
|
2011-11-24 06:18:04 +08:00
|
|
|
DF->getContents().resize(DF->getContents().size() + 4, 0);
|
|
|
|
}
|
|
|
|
|
2016-08-23 00:18:42 +08:00
|
|
|
// Associate GPRel64 fixup with data and resize data area
|
2012-08-22 08:49:30 +08:00
|
|
|
void MCObjectStreamer::EmitGPRel64Value(const MCExpr *Value) {
|
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
2015-06-27 09:54:17 +08:00
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
2012-08-22 08:49:30 +08:00
|
|
|
|
2017-04-04 05:50:04 +08:00
|
|
|
DF->getFixups().push_back(
|
|
|
|
MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
|
2012-08-22 08:49:30 +08:00
|
|
|
DF->getContents().resize(DF->getContents().size() + 8, 0);
|
|
|
|
}
|
|
|
|
|
2015-11-12 21:33:00 +08:00
|
|
|
bool MCObjectStreamer::EmitRelocDirective(const MCExpr &Offset, StringRef Name,
|
2018-06-06 17:40:06 +08:00
|
|
|
const MCExpr *Expr, SMLoc Loc,
|
|
|
|
const MCSubtargetInfo &STI) {
|
2015-11-12 21:33:00 +08:00
|
|
|
int64_t OffsetValue;
|
|
|
|
if (!Offset.evaluateAsAbsolute(OffsetValue))
|
|
|
|
llvm_unreachable("Offset is not absolute");
|
|
|
|
|
2016-01-20 07:05:27 +08:00
|
|
|
if (OffsetValue < 0)
|
|
|
|
llvm_unreachable("Offset is negative");
|
|
|
|
|
2018-06-06 17:40:06 +08:00
|
|
|
MCDataFragment *DF = getOrCreateDataFragment(&STI);
|
2015-11-12 21:33:00 +08:00
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
|
|
|
|
2016-01-20 07:05:27 +08:00
|
|
|
Optional<MCFixupKind> MaybeKind = Assembler->getBackend().getFixupKind(Name);
|
|
|
|
if (!MaybeKind.hasValue())
|
2015-11-12 21:33:00 +08:00
|
|
|
return true;
|
|
|
|
|
2016-01-20 07:05:27 +08:00
|
|
|
MCFixupKind Kind = *MaybeKind;
|
|
|
|
|
2015-11-12 21:33:00 +08:00
|
|
|
if (Expr == nullptr)
|
|
|
|
Expr =
|
|
|
|
MCSymbolRefExpr::create(getContext().createTempSymbol(), getContext());
|
|
|
|
DF->getFixups().push_back(MCFixup::create(OffsetValue, Expr, Kind, Loc));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-05-28 13:57:48 +08:00
|
|
|
void MCObjectStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
|
|
|
|
SMLoc Loc) {
|
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
|
|
|
|
2018-01-10 03:29:33 +08:00
|
|
|
assert(getCurrentSectionOnly() && "need a section");
|
2018-05-19 01:45:48 +08:00
|
|
|
insert(new MCFillFragment(FillValue, 1, NumBytes, Loc));
|
2016-05-28 13:57:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
|
|
|
|
int64_t Expr, SMLoc Loc) {
|
|
|
|
int64_t IntNumValues;
|
2018-05-19 01:45:48 +08:00
|
|
|
// Do additional checking now if we can resolve the value.
|
|
|
|
if (NumValues.evaluateAsAbsolute(IntNumValues, getAssemblerPtr())) {
|
|
|
|
if (IntNumValues < 0) {
|
|
|
|
getContext().getSourceManager()->PrintMessage(
|
|
|
|
Loc, SourceMgr::DK_Warning,
|
|
|
|
"'.fill' directive with negative repeat count has no effect");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// Emit now if we can for better errors.
|
|
|
|
int64_t NonZeroSize = Size > 4 ? 4 : Size;
|
|
|
|
Expr &= ~0ULL >> (64 - NonZeroSize * 8);
|
|
|
|
for (uint64_t i = 0, e = IntNumValues; i != e; ++i) {
|
|
|
|
EmitIntValue(Expr, NonZeroSize);
|
|
|
|
if (NonZeroSize < Size)
|
|
|
|
EmitIntValue(0, Size - NonZeroSize);
|
|
|
|
}
|
2016-05-28 13:57:48 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-05-19 01:45:48 +08:00
|
|
|
// Otherwise emit as fragment.
|
|
|
|
MCDataFragment *DF = getOrCreateDataFragment();
|
|
|
|
flushPendingLabels(DF, DF->getContents().size());
|
2016-05-28 13:57:48 +08:00
|
|
|
|
2018-05-19 01:45:48 +08:00
|
|
|
assert(getCurrentSectionOnly() && "need a section");
|
|
|
|
insert(new MCFillFragment(Expr, Size, NumValues, Loc));
|
2016-05-28 13:57:48 +08:00
|
|
|
}
|
|
|
|
|
2017-03-04 05:22:06 +08:00
|
|
|
void MCObjectStreamer::EmitFileDirective(StringRef Filename) {
|
|
|
|
getAssembler().addFileName(Filename);
|
|
|
|
}
|
|
|
|
|
2018-07-18 06:17:18 +08:00
|
|
|
void MCObjectStreamer::EmitAddrsig() {
|
|
|
|
getAssembler().getWriter().emitAddrsigSection();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCObjectStreamer::EmitAddrsigSym(const MCSymbol *Sym) {
|
|
|
|
getAssembler().registerSymbol(*Sym);
|
|
|
|
getAssembler().getWriter().addAddrsigSymbol(Sym);
|
|
|
|
}
|
|
|
|
|
2012-01-07 11:13:18 +08:00
|
|
|
void MCObjectStreamer::FinishImpl() {
|
2018-07-11 20:30:35 +08:00
|
|
|
getContext().RemapDebugPaths();
|
2018-07-10 22:41:54 +08:00
|
|
|
|
2011-12-10 02:09:40 +08:00
|
|
|
// If we are generating dwarf for assembly source files dump out the sections.
|
|
|
|
if (getContext().getGenDwarfForAssembly())
|
2014-04-01 15:35:52 +08:00
|
|
|
MCGenDwarfInfo::Emit(this);
|
|
|
|
|
|
|
|
// Dump out the dwarf file & directory tables and line tables.
|
2015-08-07 23:14:08 +08:00
|
|
|
MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
|
2011-12-10 02:09:40 +08:00
|
|
|
|
2018-07-10 23:32:17 +08:00
|
|
|
flushPendingLabels();
|
2010-06-17 04:04:25 +08:00
|
|
|
getAssembler().Finish();
|
|
|
|
}
|