typedef FragmentListType::const_reverse_iterator const_reverse_iterator;
typedef FragmentListType::reverse_iterator reverse_iterator;
- /// \brief Express the state of bundle locked groups while emitting code.
- enum BundleLockStateType {
- NotBundleLocked,
- BundleLocked,
- BundleLockedAlignToEnd
- };
-
private:
FragmentListType Fragments;
MCSection *Section;
- /// \brief Keeping track of bundle-locked state.
- BundleLockStateType BundleLockState;
-
- /// \brief Current nesting depth of bundle_lock directives.
- unsigned BundleLockNestingDepth;
-
- /// \brief We've seen a bundle_lock directive but not its first instruction
- /// yet.
- bool BundleGroupBeforeFirstInst;
-
/// \name Assembler Backend Data
/// @{
//
iterator getSubsectionInsertionPoint(unsigned Subsection);
- bool isBundleLocked() const { return BundleLockState != NotBundleLocked; }
-
- BundleLockStateType getBundleLockState() const { return BundleLockState; }
-
- void setBundleLockState(BundleLockStateType NewState);
-
- bool isBundleGroupBeforeFirstInst() const {
- return BundleGroupBeforeFirstInst;
- }
-
- void setBundleGroupBeforeFirstInst(bool IsFirst) {
- BundleGroupBeforeFirstInst = IsFirst;
- }
-
void dump();
/// @}
public:
enum SectionVariant { SV_COFF = 0, SV_ELF, SV_MachO };
+ /// \brief Express the state of bundle locked groups while emitting code.
+ enum BundleLockStateType {
+ NotBundleLocked,
+ BundleLocked,
+ BundleLockedAlignToEnd
+ };
+
private:
MCSection(const MCSection &) = delete;
void operator=(const MCSection &) = delete;
/// The index of this section in the layout order.
unsigned LayoutOrder;
+ /// \brief Keeping track of bundle-locked state.
+ BundleLockStateType BundleLockState = NotBundleLocked;
+
+ /// \brief Current nesting depth of bundle_lock directives.
+ unsigned BundleLockNestingDepth = 0;
+
+ /// \brief We've seen a bundle_lock directive but not its first instruction
+ /// yet.
+ bool BundleGroupBeforeFirstInst = false;
+
protected:
MCSection(SectionVariant V, SectionKind K, MCSymbol *Begin)
: Begin(Begin), Variant(V), Kind(K) {}
unsigned getLayoutOrder() const { return LayoutOrder; }
void setLayoutOrder(unsigned Value) { LayoutOrder = Value; }
+ BundleLockStateType getBundleLockState() const { return BundleLockState; }
+ void setBundleLockState(BundleLockStateType NewState);
+ bool isBundleLocked() const { return BundleLockState != NotBundleLocked; }
+
+ bool isBundleGroupBeforeFirstInst() const {
+ return BundleGroupBeforeFirstInst;
+ }
+ void setBundleGroupBeforeFirstInst(bool IsFirst) {
+ BundleGroupBeforeFirstInst = IsFirst;
+ }
+
virtual void PrintSwitchToSection(const MCAsmInfo &MAI, raw_ostream &OS,
const MCExpr *Subsection) const = 0;
MCSectionData::MCSectionData() : Section(nullptr) {}
MCSectionData::MCSectionData(MCSection &Section, MCAssembler *A)
- : Section(&Section), BundleLockState(NotBundleLocked),
- BundleLockNestingDepth(0), BundleGroupBeforeFirstInst(false),
- HasInstructions(false) {
+ : Section(&Section), HasInstructions(false) {
if (A)
A->getSectionList().push_back(this);
}
return IP;
}
-void MCSectionData::setBundleLockState(BundleLockStateType NewState) {
- if (NewState == NotBundleLocked) {
- if (BundleLockNestingDepth == 0) {
- report_fatal_error("Mismatched bundle_lock/unlock directives");
- }
- if (--BundleLockNestingDepth == 0) {
- BundleLockState = NotBundleLocked;
- }
- return;
- }
-
- // If any of the directives is an align_to_end directive, the whole nested
- // group is align_to_end. So don't downgrade from align_to_end to just locked.
- if (BundleLockState != BundleLockedAlignToEnd) {
- BundleLockState = NewState;
- }
- ++BundleLockNestingDepth;
-}
-
/* *** */
MCAssembler::MCAssembler(MCContext &Context_, MCAsmBackend &Backend_,
using namespace llvm;
bool MCELFStreamer::isBundleLocked() const {
- return getCurrentSectionData()->isBundleLocked();
+ return getCurrentSectionData()->getSection().isBundleLocked();
}
MCELFStreamer::~MCELFStreamer() {
if (Assembler.isBundlingEnabled()) {
MCSectionData *SD = getCurrentSectionData();
+ MCSection &Sec = SD->getSection();
if (Assembler.getRelaxAll() && isBundleLocked())
// If the -mc-relax-all flag is used and we are bundle-locked, we re-use
// the current bundle group.
// we create a new temporary fragment which will be later merged into
// the current fragment.
DF = new MCDataFragment();
- else if (isBundleLocked() && !SD->isBundleGroupBeforeFirstInst())
+ else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst())
// If we are bundle-locked, we re-use the current fragment.
// The bundle-locking directive ensures this is a new data fragment.
DF = cast<MCDataFragment>(getCurrentFragment());
DF = new MCDataFragment();
insert(DF);
}
- if (SD->getBundleLockState() == MCSectionData::BundleLockedAlignToEnd) {
+ if (Sec.getBundleLockState() == MCSection::BundleLockedAlignToEnd) {
// If this fragment is for a group marked "align_to_end", set a flag
// in the fragment. This can happen after the fragment has already been
// created if there are nested bundle_align groups and an inner one
// We're now emitting an instruction in a bundle group, so this flag has
// to be turned off.
- SD->setBundleGroupBeforeFirstInst(false);
+ Sec.setBundleGroupBeforeFirstInst(false);
} else {
DF = getOrCreateDataFragment();
}
void MCELFStreamer::EmitBundleLock(bool AlignToEnd) {
MCSectionData *SD = getCurrentSectionData();
+ MCSection &Sec = SD->getSection();
// Sanity checks
//
report_fatal_error(".bundle_lock forbidden when bundling is disabled");
if (!isBundleLocked())
- SD->setBundleGroupBeforeFirstInst(true);
+ Sec.setBundleGroupBeforeFirstInst(true);
if (getAssembler().getRelaxAll() && !isBundleLocked()) {
// TODO: drop the lock state and set directly in the fragment
BundleGroups.push_back(DF);
}
- SD->setBundleLockState(AlignToEnd ? MCSectionData::BundleLockedAlignToEnd :
- MCSectionData::BundleLocked);
+ Sec.setBundleLockState(AlignToEnd ? MCSection::BundleLockedAlignToEnd
+ : MCSection::BundleLocked);
}
void MCELFStreamer::EmitBundleUnlock() {
MCSectionData *SD = getCurrentSectionData();
+ MCSection &Sec = SD->getSection();
// Sanity checks
if (!getAssembler().isBundlingEnabled())
report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
else if (!isBundleLocked())
report_fatal_error(".bundle_unlock without matching lock");
- else if (SD->isBundleGroupBeforeFirstInst())
+ else if (Sec.isBundleGroupBeforeFirstInst())
report_fatal_error("Empty bundle-locked group is forbidden");
// When the -mc-relax-all flag is used, we emit instructions to fragments
MCDataFragment *DF = BundleGroups.back();
// FIXME: Use BundleGroups to track the lock state instead.
- SD->setBundleLockState(MCSectionData::NotBundleLocked);
+ Sec.setBundleLockState(MCSection::NotBundleLocked);
// FIXME: Use more separate fragments for nested groups.
if (!isBundleLocked()) {
delete DF;
}
- if (SD->getBundleLockState() != MCSectionData::BundleLockedAlignToEnd)
+ if (Sec.getBundleLockState() != MCSection::BundleLockedAlignToEnd)
getOrCreateDataFragment()->setAlignToBundleEnd(false);
} else
- SD->setBundleLockState(MCSectionData::NotBundleLocked);
+ Sec.setBundleLockState(MCSection::NotBundleLocked);
}
void MCELFStreamer::Flush() {
// group. We want to emit all such instructions into the same data
// fragment.
if (Assembler.getRelaxAll() ||
- (Assembler.isBundlingEnabled() && SD->isBundleLocked())) {
+ (Assembler.isBundlingEnabled() && SD->getSection().isBundleLocked())) {
MCInst Relaxed;
getAssembler().getBackend().relaxInstruction(Inst, Relaxed);
while (getAssembler().getBackend().mayNeedRelaxation(Relaxed))
MCSection::~MCSection() {
}
+void MCSection::setBundleLockState(BundleLockStateType NewState) {
+ if (NewState == NotBundleLocked) {
+ if (BundleLockNestingDepth == 0) {
+ report_fatal_error("Mismatched bundle_lock/unlock directives");
+ }
+ if (--BundleLockNestingDepth == 0) {
+ BundleLockState = NotBundleLocked;
+ }
+ return;
+ }
+
+ // If any of the directives is an align_to_end directive, the whole nested
+ // group is align_to_end. So don't downgrade from align_to_end to just locked.
+ if (BundleLockState != BundleLockedAlignToEnd) {
+ BundleLockState = NewState;
+ }
+ ++BundleLockNestingDepth;
+}