};
class MCFragment : public ilist_node<MCFragment> {
+ friend class MCAsmLayout;
+
MCFragment(const MCFragment&); // DO NOT IMPLEMENT
void operator=(const MCFragment&); // DO NOT IMPLEMENT
/// initialized.
uint64_t Offset;
- /// FileSize - The file size of this section. This is ~0 until initialized.
- uint64_t FileSize;
+ /// EffectiveSize - The compute size of this section. This is ~0 until
+ /// initialized.
+ uint64_t EffectiveSize;
/// @}
MCSectionData *getParent() const { return Parent; }
void setParent(MCSectionData *Value) { Parent = Value; }
- /// @name Assembler Backend Support
- /// @{
- //
- // FIXME: This could all be kept private to the assembler implementation.
-
- uint64_t getAddress() const;
-
- uint64_t getFileSize() const {
- assert(FileSize != ~UINT64_C(0) && "File size not set!");
- return FileSize;
- }
- void setFileSize(uint64_t Value) { FileSize = Value; }
-
- uint64_t getOffset() const {
- assert(Offset != ~UINT64_C(0) && "File offset not set!");
- return Offset;
- }
- void setOffset(uint64_t Value) { Offset = Value; }
-
- /// @}
-
static bool classof(const MCFragment *O) { return true; }
virtual void dump();
virtual void dump();
};
+// FIXME: This current incarnation of MCInstFragment doesn't make much sense, as
+// it is almost entirely a duplicate of MCDataFragment. If we decide to stick
+// with this approach (as opposed to making MCInstFragment a very light weight
+// object with just the MCInst and a code size, then we should just change
+// MCDataFragment to have an optional MCInst at its end.
class MCInstFragment : public MCFragment {
/// Inst - The instruction this is a fragment for.
MCInst Inst;
/// InstSize - The size of the currently encoded instruction.
- unsigned InstSize;
+ SmallString<8> Code;
+
+ /// Fixups - The list of fixups in this fragment.
+ SmallVector<MCAsmFixup, 1> Fixups;
public:
- MCInstFragment(MCInst _Inst, unsigned _InstSize, MCSectionData *SD = 0)
- : MCFragment(FT_Inst, SD), Inst(_Inst), InstSize(_InstSize) {}
+ typedef SmallVectorImpl<MCAsmFixup>::const_iterator const_fixup_iterator;
+ typedef SmallVectorImpl<MCAsmFixup>::iterator fixup_iterator;
+
+public:
+ MCInstFragment(MCInst _Inst, MCSectionData *SD = 0)
+ : MCFragment(FT_Inst, SD), Inst(_Inst) {
+ }
/// @name Accessors
/// @{
- unsigned getInstSize() const { return InstSize; }
+ SmallVectorImpl<char> &getCode() { return Code; }
+ const SmallVectorImpl<char> &getCode() const { return Code; }
+
+ unsigned getInstSize() const { return Code.size(); }
+ MCInst &getInst() { return Inst; }
const MCInst &getInst() const { return Inst; }
- void setInst(MCInst Inst, unsigned InstSize) {
- this->Inst = Inst;
- this->InstSize = InstSize;
- }
+ void setInst(MCInst Value) { Inst = Value; }
+
+ /// @}
+ /// @name Fixup Access
+ /// @{
+
+ SmallVectorImpl<MCAsmFixup> &getFixups() { return Fixups; }
+ const SmallVectorImpl<MCAsmFixup> &getFixups() const { return Fixups; }
+
+ fixup_iterator fixup_begin() { return Fixups.begin(); }
+ const_fixup_iterator fixup_begin() const { return Fixups.begin(); }
+
+ fixup_iterator fixup_end() {return Fixups.end();}
+ const_fixup_iterator fixup_end() const {return Fixups.end();}
+
+ size_t fixup_size() const { return Fixups.size(); }
/// @}
// we anticipate the fast path being through an MCAssembler, the only reason to
// keep it out is for API abstraction.
class MCSectionData : public ilist_node<MCSectionData> {
+ friend class MCAsmLayout;
+
MCSectionData(const MCSectionData&); // DO NOT IMPLEMENT
void operator=(const MCSectionData&); // DO NOT IMPLEMENT
unsigned getAlignment() const { return Alignment; }
void setAlignment(unsigned Value) { Alignment = Value; }
+ bool hasInstructions() const { return HasInstructions; }
+ void setHasInstructions(bool Value) { HasInstructions = Value; }
+
/// @name Fragment Access
/// @{
bool empty() const { return Fragments.empty(); }
- /// @}
- /// @name Assembler Backend Support
- /// @{
- //
- // FIXME: This could all be kept private to the assembler implementation.
-
- uint64_t getAddress() const {
- assert(Address != ~UINT64_C(0) && "Address not set!");
- return Address;
- }
- void setAddress(uint64_t Value) { Address = Value; }
-
- uint64_t getSize() const {
- assert(Size != ~UINT64_C(0) && "File size not set!");
- return Size;
- }
- void setSize(uint64_t Value) { Size = Value; }
-
- uint64_t getFileSize() const {
- assert(FileSize != ~UINT64_C(0) && "File size not set!");
- return FileSize;
- }
- void setFileSize(uint64_t Value) { FileSize = Value; }
-
- bool hasInstructions() const { return HasInstructions; }
- void setHasInstructions(bool Value) { HasInstructions = Value; }
-
- /// @}
-
void dump();
};
uint64_t getOffset() const { return Offset; }
void setOffset(uint64_t Value) { Offset = Value; }
- uint64_t getAddress() const {
- assert(getFragment() && "Invalid getAddress() on undefined symbol!");
- return getFragment()->getAddress() + getOffset();
- }
-
/// @}
/// @name Symbol Attributes
/// @{
bool FixupNeedsRelaxation(const MCAsmFixup &Fixup, const MCFragment *DF,
const MCAsmLayout &Layout) const;
+ /// Check whether the given fragment needs relaxation.
+ bool FragmentNeedsRelaxation(const MCInstFragment *IF,
+ const MCAsmLayout &Layout) const;
+
/// LayoutSection - Assign offsets and sizes to the fragments in the section
/// \arg SD, and update the section size. The section file offset should
/// already have been computed.
/// Find the symbol which defines the atom containing given address, inside
/// the given section, or null if there is no such symbol.
//
- // FIXME: Eliminate this, it is very slow.
- const MCSymbolData *getAtomForAddress(const MCSectionData *Section,
+ // FIXME-PERF: Eliminate this, it is very slow.
+ const MCSymbolData *getAtomForAddress(const MCAsmLayout &Layout,
+ const MCSectionData *Section,
uint64_t Address) const;
/// Find the symbol which defines the atom containing the given symbol, or
/// null if there is no such symbol.
//
- // FIXME: Eliminate this, it is very slow.
- const MCSymbolData *getAtom(const MCSymbolData *Symbol) const;
+ // FIXME-PERF: Eliminate this, it is very slow.
+ const MCSymbolData *getAtom(const MCAsmLayout &Layout,
+ const MCSymbolData *Symbol) const;
/// Check whether a particular symbol is visible to the linker and is required
/// in the symbol table, or whether it can be discarded by the assembler. This
/// Emit the section contents using the given object writer.
//
// FIXME: Should MCAssembler always have a reference to the object writer?
- void WriteSectionData(const MCSectionData *Section, MCObjectWriter *OW) const;
+ void WriteSectionData(const MCSectionData *Section, const MCAsmLayout &Layout,
+ MCObjectWriter *OW) const;
public:
/// Construct a new assembler instance.