enum FragmentType {
FT_Align,
FT_Data,
- FT_Compressed,
FT_CompactEncodedInst,
FT_Fill,
FT_Relaxable,
return false;
case MCFragment::FT_Relaxable:
case MCFragment::FT_CompactEncodedInst:
- case MCFragment::FT_Compressed:
case MCFragment::FT_Data:
return true;
}
static bool classof(const MCFragment *F) {
MCFragment::FragmentType Kind = F->getKind();
- return Kind == MCFragment::FT_Relaxable || Kind == MCFragment::FT_Data ||
- Kind == MCFragment::FT_Compressed;
+ return Kind == MCFragment::FT_Relaxable || Kind == MCFragment::FT_Data;
}
};
/// Fixups - The list of fixups in this fragment.
SmallVector<MCFixup, 4> Fixups;
-protected:
- MCDataFragment(MCFragment::FragmentType FType, MCSectionData *SD = 0)
- : MCEncodedFragmentWithFixups(FType, SD), HasInstructions(false),
- AlignToBundleEnd(false) {}
-
public:
MCDataFragment(MCSectionData *SD = 0)
: MCEncodedFragmentWithFixups(FT_Data, SD),
const_fixup_iterator fixup_end() const override {return Fixups.end();}
static bool classof(const MCFragment *F) {
- return F->getKind() == MCFragment::FT_Data ||
- F->getKind() == MCFragment::FT_Compressed;
+ return F->getKind() == MCFragment::FT_Data;
}
};
-class MCCompressedFragment: public MCDataFragment {
- mutable SmallVector<char, 32> CompressedContents;
-public:
- MCCompressedFragment(MCSectionData *SD = nullptr)
- : MCDataFragment(FT_Compressed, SD) {}
- const SmallVectorImpl<char> &getCompressedContents() const;
- using MCDataFragment::getContents;
- SmallVectorImpl<char> &getContents() override;
-};
-
/// This is a compact (memory-size-wise) fragment for holding an encoded
/// instruction (non-relaxable) that has no fixups registered. When applicable,
/// it can be used instead of MCDataFragment and lead to lower memory
#include "llvm/Support/LEB128.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Compression.h"
-#include "llvm/Support/Host.h"
using namespace llvm;
/* *** */
-const SmallVectorImpl<char> &MCCompressedFragment::getCompressedContents() const {
- assert(getParent()->size() == 1 &&
- "Only compress sections containing a single fragment");
- if (CompressedContents.empty()) {
- // FIXME: could be more efficient if we let zlib::compress append to a
- // buffer rather than always from the start.
- zlib::Status Success =
- zlib::compress(StringRef(getContents().data(), getContents().size()),
- CompressedContents);
- (void)Success;
- assert(Success == zlib::StatusOK);
- static const StringRef Magic = "ZLIB";
- uint64_t Size = getContents().size();
- if (sys::IsLittleEndianHost)
- Size = sys::SwapByteOrder(Size);
- CompressedContents.insert(CompressedContents.begin(),
- Magic.size() + sizeof(Size));
- std::copy(Magic.begin(), Magic.end(), CompressedContents.begin());
- std::copy(reinterpret_cast<char *>(&Size),
- reinterpret_cast<char *>(&Size + 1),
- CompressedContents.begin() + Magic.size());
- }
- return CompressedContents;
-}
-
-SmallVectorImpl<char> &MCCompressedFragment::getContents() {
- assert(CompressedContents.empty() &&
- "Fragment contents should not be altered after compression");
- return MCDataFragment::getContents();
-}
-
-/* *** */
-
MCSectionData::MCSectionData() : Section(0) {}
MCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A)
case MCFragment::FT_Relaxable:
case MCFragment::FT_CompactEncodedInst:
return cast<MCEncodedFragment>(F).getContents().size();
- case MCFragment::FT_Compressed:
- return cast<MCCompressedFragment>(F).getCompressedContents().size();
case MCFragment::FT_Fill:
return cast<MCFillFragment>(F).getSize();
break;
}
- case MCFragment::FT_Compressed:
- ++stats::EmittedDataFragments;
- OW->WriteBytes(cast<MCCompressedFragment>(F).getCompressedContents());
- break;
-
case MCFragment::FT_Data:
++stats::EmittedDataFragments;
writeFragmentContents(F, OW);
ie = SD->end(); it != ie; ++it) {
switch (it->getKind()) {
default: llvm_unreachable("Invalid fragment in virtual section!");
- case MCFragment::FT_Compressed:
case MCFragment::FT_Data: {
// Check that we aren't trying to write a non-zero contents (or fixups)
// into a virtual section. This is to support clients which use standard
switch (getKind()) {
case MCFragment::FT_Align: OS << "MCAlignFragment"; break;
case MCFragment::FT_Data: OS << "MCDataFragment"; break;
- case MCFragment::FT_Compressed:
- OS << "MCCompressedFragment"; break;
case MCFragment::FT_CompactEncodedInst:
OS << "MCCompactEncodedInstFragment"; break;
case MCFragment::FT_Fill: OS << "MCFillFragment"; break;
<< " MaxBytesToEmit:" << AF->getMaxBytesToEmit() << ">";
break;
}
- case MCFragment::FT_Compressed:
case MCFragment::FT_Data: {
const MCDataFragment *DF = cast<MCDataFragment>(this);
OS << "\n ";
#include "llvm/MC/MCSection.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/Support/ErrorHandling.h"
-#include "llvm/MC/MCSectionELF.h"
using namespace llvm;
MCObjectStreamer::MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB,
// When bundling is enabled, we don't want to add data to a fragment that
// already has instructions (see MCELFStreamer::EmitInstToData for details)
if (!F || (Assembler->isBundlingEnabled() && F->hasInstructions())) {
- const auto *Sec = dyn_cast<MCSectionELF>(&getCurrentSectionData()->getSection());
- if (Sec && Sec->getSectionName().startswith(".zdebug_"))
- F = new MCCompressedFragment();
- else
- F = new MCDataFragment();
+ F = new MCDataFragment();
insert(F);
}
return F;