relocation.h

#ifndef RELOCATION_H
#define RELOCATION_H
 
#include <optional>
#include "../common.h"
#include "location.h"
#include "target.h"
 
namespace Linker
{
    class Resolution;
 
    class Relocation
    {
    public:
        enum reference_kind
        {
            Direct,
            ParagraphAddress,
            SegmentIndex,
            SelectorIndex,
            GOTEntry,
            PLTEntry, // TODO: unimplemented
            TableEntry,
            FarTableEntry,
            TransitionVector,
            SizeOf, // TODO: unimplemented
        }
        kind;
        size_t size;
        Location source;
        Target target;
        Target reference;
        std::optional<Target> secondary_target;
        uint64_t addend;
        EndianType endiantype;
        int shift;
        bool adjusted_shift;
        uint64_t mask;
        bool subtract;
 
        Relocation(reference_kind kind, size_t size, Location source, Target target, Target reference, uint64_t addend, EndianType endiantype)
            : kind(kind), size(size), source(source), target(target), reference(reference), addend(addend), endiantype(endiantype),
                shift(0), adjusted_shift(false), mask(-1), subtract(false)
        {
        }
 
        static Relocation Empty();
 
        static Relocation Absolute(size_t size, Location source, Target target, uint64_t addend, EndianType endiantype);
 
        static Relocation Absolute(size_t size, Location source, Target target, uint64_t addend = 0);
 
        static Relocation Offset(size_t size, Location source, Target target, uint64_t addend, EndianType endiantype);
 
        static Relocation Offset(size_t size, Location source, Target target, uint64_t addend = 0);
 
        static Relocation OffsetFrom(size_t size, Location source, Target target, Target reference, uint64_t addend, EndianType endiantype);
 
        static Relocation OffsetFrom(size_t size, Location source, Target target, Target reference, uint64_t addend = 0);
 
        static Relocation Relative(size_t size, Location source, Target target, uint64_t addend, EndianType endiantype);
 
        static Relocation Relative(size_t size, Location source, Target target, uint64_t addend = 0);
 
        static Relocation Paragraph(Location source, Target target, uint64_t addend = 0);
 
        static Relocation Selector(Location source, Target target, uint64_t addend = 0);
 
        static Relocation Segment(size_t size, Location source, Target target, uint64_t addend = 0);
 
        static Relocation ParagraphDifference(Location source, Target target, Target reference, uint64_t addend = 0);
 
        static Relocation GOTEntryAbsolute(size_t size, Location source, SymbolName target, uint64_t addend, EndianType endiantype);
 
        static Relocation GOTEntryRelative(size_t size, Location source, SymbolName target, uint64_t addend, EndianType endiantype);
 
        static Relocation GOTEntryOffset(size_t size, Location source, SymbolName target, uint64_t addend, EndianType endiantype);
 
        Relocation& SetMask(uint64_t new_mask);
 
        Relocation& SetShift(int new_shift, bool adjusted = false);
 
        Relocation& SetSubtract(bool to_subtract = true);
 
        bool Displace(const Displacement& displacement);
 
        bool Resolve(Module& object, Resolution& resolution);
 
        uint64_t ReadUnsigned();
 
        int64_t ReadSigned();
 
        void WriteWord(uint64_t value);
 
        void AddCurrentValue();
 
        bool IsRelative() const;
 
        bool IsAbsolute() const;
 
        bool IsOffset() const;
 
        void ReplaceTarget(Target new_target);
 
        void ReplaceTarget(Target new_target, Target new_reference);
 
        void ConvertTo(reference_kind new_kind, Target new_target);
 
        void ConvertTo(reference_kind new_kind, Target new_target, Target new_reference);
 
        void ConvertToSegment(bool protected_mode, Target segment_target);
 
        void ConvertToParagraphDifference(Target new_target, Target new_reference);
 
        void ConvertToTransitionVector(Target target_code, Target target_data);
 
        bool Combine(const Relocation& other);
    };
 
    std::ostream& operator<<(std::ostream& out, const Relocation& relocation);
}
 
#endif /* RELOCATION_H */