Package ghidra.program.model.address

Class GenericAddressSpace

  • All Implemented Interfaces:
    AddressSpace, java.lang.Comparable<AddressSpace>
    Direct Known Subclasses:
    SegmentedAddressSpace
    public class GenericAddressSpace
extends java.lang.Object
    Generic implementation of the AddressSpace interface.

    • Field Detail

      • name

        protected java.lang.String name

      • size

        protected int size

      • unitSize

        protected int unitSize

      • type

        protected int type

      • spaceSize

        protected long spaceSize

      • signed

        protected boolean signed

      • minOffset

        protected long minOffset

      • maxOffset

        protected long maxOffset

      • minAddress

        protected Address minAddress

      • maxAddress

        protected Address maxAddress

      • spaceID

        protected int spaceID

    • Constructor Detail

      • GenericAddressSpace

        public GenericAddressSpace​(java.lang.String name,
                           int size,
                           int type,
                           int unique)
        Constructs a new GenericAddress space with the given name, bit size, type and unique value.
        Parameters:
        name - the name of the space.
        size - the number of bits required to represent the largest address the space.
        type - the type of the space
        unique - the unique id for this space.

      • GenericAddressSpace

        public GenericAddressSpace​(java.lang.String name,
                           int size,
                           int type,
                           int unique,
                           boolean showSpaceName)
        Constructs a new GenericAddress space with the given name, bit size, type and unique value.
        Parameters:
        name - the name of the space.
        size - the number of bits required to represent the largest address the space.
        type - the type of the space
        unique - the unique id for this space.
        showSpaceName - whether to show the space name in toString()

      • GenericAddressSpace

        public GenericAddressSpace​(java.lang.String name,
                           int size,
                           int unitSize,
                           int type,
                           int unique)
        Constructs a new GenericAddress space with the given name, bit size, type and unique value.
        Parameters:
        name - the name of the space.
        size - the number of bits required to represent the largest address the space.
        unitSize - number of bytes contained at each addressable location (1, 2, 4 or 8)
        type - the type of the space
        unique - the unique id for this space.

    • Method Detail

      • getAddress

        public Address getAddress​(long offset)
                   throws AddressOutOfBoundsException
        Description copied from interface: AddressSpace
        Returns a new address in this space with the given byte offset. NOTE: This method is the same as invoking getAddress(long byteOffset, false).
        Parameters:
        offset - the byte offset for the new address.
        Returns:
        address with given byte offset
        Throws:
        AddressOutOfBoundsException - if the offset is less than 0 or greater than the max offset allowed for this space.
        See Also:
        AddressSpace.getAddress(long)

      • getAddressInThisSpaceOnly

        public Address getAddressInThisSpaceOnly​(long offset)
        Description copied from interface: AddressSpace
        Get a byte address from this address space. Don't allow overlay spaces to remap the address into a base space when the address is not contained in the bounds of the overlay region.
        Parameters:
        offset - the byte offset for the new address.
        Returns:
        an address if the offset is valid.
        See Also:
        AddressSpace.getAddressInThisSpaceOnly(long)

      • getUncheckedAddress

        protected Address getUncheckedAddress​(long offset)
        Instantiates an address within this space. No offset validation should be performed.
        See Also:
        AbstractAddressSpace.getUncheckedAddress(long)

      • hasSignedOffset

        public boolean hasSignedOffset()
        Description copied from interface: AddressSpace
        Returns true if space uses signed offset
        Specified by:
        hasSignedOffset in interface AddressSpace

      • getName

        public java.lang.String getName()
        Description copied from interface: AddressSpace
        Returns the name of this address space.
        Specified by:
        getName in interface AddressSpace

      • getSize

        public int getSize()
        Description copied from interface: AddressSpace
        Returns the number of bits that are used to form the address. Thus the maximum offset for this address space will be 2^size-1.
        Specified by:
        getSize in interface AddressSpace

      • getAddressableUnitSize

        public int getAddressableUnitSize()
        Description copied from interface: AddressSpace
        Returns the number of data bytes which correspond to each addressable location within this space (i.e., word-size in bytes). NOTE: When transforming a byte-offset to an addressable word offset the method AddressSpace.getAddressableWordOffset(long) should be used instead of simple division. When transforming an addressable word-offset to a byte-offset simple multiplication may be used. Neither of these transformations perform address space bounds checking. 
           byteOffset = wordOffset * addressUnitSize
   wordOffset = getAddressableWordOffset(byteOffset)
        Specified by:
        getAddressableUnitSize in interface AddressSpace

      • getAddressableWordOffset

        public long getAddressableWordOffset​(long byteOffset)
        Description copied from interface: AddressSpace
        Get the addressable memory word offset which corresponds to the specified memory byte offset. This method handles some of the issues of unsigned math when stuck using Java's signed long primitives. No space bounds checking is performed.
        Specified by:
        getAddressableWordOffset in interface AddressSpace
        Parameters:
        byteOffset - memory byte offset
        Returns:
        addressable memory word offset

      • getType

        public int getType()
        Description copied from interface: AddressSpace
        Returns the type of this address space
        Specified by:
        getType in interface AddressSpace

      • getUnique

        public int getUnique()
        Returns the unique id value for this space.
        Specified by:
        getUnique in interface AddressSpace

      • getAddress

        public Address getAddress​(java.lang.String addrString)
                   throws AddressFormatException
        Description copied from interface: AddressSpace
        Parses the String into an address.
        Specified by:
        getAddress in interface AddressSpace
        Parameters:
        addrString - the string to parse as an address.
        Returns:
        an address if the string parsed successfully or null if the AddressSpace specified in the addrString is not this space.
        Throws:
        AddressFormatException - if the string cannot be parsed or the parsed offset is larger than the size for this space.

      • getAddress

        public Address getAddress​(java.lang.String addrString,
                          boolean caseSensitive)
                   throws AddressFormatException
        Description copied from interface: AddressSpace
        Parses the String into an address.
        Specified by:
        getAddress in interface AddressSpace
        Parameters:
        addrString - the string to parse as an address.
        caseSensitive - specifies if addressSpace names must match case.
        Returns:
        an address if the string parsed successfully or null if the AddressSpace specified in the addrString is not this space.
        Throws:
        AddressFormatException - if the string cannot be parsed or the parsed offset is larger than the size for this space.

      • getAddress

        public Address getAddress​(long offset,
                          boolean isAddressableWordOffset)
                   throws AddressOutOfBoundsException
        Description copied from interface: AddressSpace
        Returns a new address in this space with the given offset. NOTE: for those spaces with an addressable unit size other than 1, the address returned may not correspond to an addressable unit/word boundary if a byte-offset is specified.
        Specified by:
        getAddress in interface AddressSpace
        Parameters:
        offset - the offset for the new address.
        isAddressableWordOffset - if true the specified offset is an addressable unit/word offset, otherwise offset is a byte offset. See AddressSpace.getAddressableUnitSize() to understand the distinction (i.e., wordOffset = byteOffset * addressableUnitSize).
        Returns:
        address with given offset
        Throws:
        AddressOutOfBoundsException - if the offset is less than 0 or greater than the max offset allowed for this space.

      • getTruncatedAddress

        public Address getTruncatedAddress​(long offset,
                                   boolean isAddressableWordOffset)
        Description copied from interface: AddressSpace
        Returns a new address in this space with the given offset. The specified offset will be truncated within the space and will not throw an exception. NOTE: for those spaces with an addressable unit size other than 1, the address returned may not correspond to a word boundary (addressable unit) if a byte-offset is specified.
        Specified by:
        getTruncatedAddress in interface AddressSpace
        Parameters:
        offset - the offset for the new address.
        isAddressableWordOffset - if true the specified offset is an addressable unit/word offset, otherwise offset is a byte offset. See AddressSpace.getAddressableUnitSize() to understand the distinction (i.e., wordOffset = byteOffset * addressableUnitSize).
        Returns:
        address with given byte offset truncated to the physical space size

      • subtract

        public long subtract​(Address addr1,
                     Address addr2)
        Description copied from interface: AddressSpace
        Calculates the displacement between addr1 and addr2 (addr1 - addr2)
        Specified by:
        subtract in interface AddressSpace
        Parameters:
        addr1 - the address to subtract from.
        addr2 - the address to subtract.
        Returns:
        the difference. (addr1.offset - addr2.offset).

      • subtractWrap

        public Address subtractWrap​(Address addr,
                            long displacement)
        Description copied from interface: AddressSpace
        Creates a new address by subtracting displacement from addr's offset.
        Specified by:
        subtractWrap in interface AddressSpace
        Parameters:
        addr - the original address. The new address will wrap in a manner that depends on the address space. For a generic address space this will wrap at the extents of the address space. For a segmented address space it will wrap at the extents of the segment.
        displacement - the displacement to subtract.
        Returns:
        a new address created by subtracting the displacement from addr.offset.

      • subtractWrapSpace

        public Address subtractWrapSpace​(Address addr,
                                 long displacement)
        Description copied from interface: AddressSpace
        Creates a new address by subtracting the displacement from the given address. If the offset is greater than the max offset of the address space, the high order bits are masked off, making the address wrap. For non-segmented addresses this will be the same as subtractWrap(). For segmented addresses, the address will wrap when the 20 bit (oxfffff) offset is exceeded, as opposed to when the segment offset is exceeded.
        Specified by:
        subtractWrapSpace in interface AddressSpace
        Parameters:
        addr - the address to subtract the displacement from.
        displacement - the displacement to subtract.
        Returns:
        The new Address formed by subtracting the displacement from the specified address.

      • subtractNoWrap

        public Address subtractNoWrap​(Address addr,
                              long displacement)
                       throws AddressOverflowException
        Description copied from interface: AddressSpace
        Creates a new address by subtracting displacement from addr's offset. The new offset will NOT wrap!
        Specified by:
        subtractNoWrap in interface AddressSpace
        Parameters:
        addr - the original address
        displacement - the displacement to subtract.
        Returns:
        The new address created by subtracting displacement from addr.offset.
        Throws:
        AddressOverflowException - if the subtraction would cause a wrap,

      • subtract

        public Address subtract​(Address addr,
                        long displacement)
        Description copied from interface: AddressSpace
        Creates a new address (possibly in a new space) by subtracting the given displacement from the given address.
        Specified by:
        subtract in interface AddressSpace
        Parameters:
        addr - original address being subtracted from
        displacement - amount to subtract
        Returns:
        the new address

      • addWrap

        public Address addWrap​(Address addr,
                       long displacement)
        Description copied from interface: AddressSpace
        Creates a new address by adding displacement to the given address. The resulting address may wrap. The new address will wrap in a manner that depends on the address space. For a generic address space this will wrap at the extents of the address space. For a segmented address space it will wrap at the extents of the segment.
        Specified by:
        addWrap in interface AddressSpace
        Parameters:
        addr - the original address.
        displacement - the displacement to add.
        Returns:
        the new address created by adding displacement to addr.offset.

      • addWrapSpace

        public Address addWrapSpace​(Address addr,
                            long displacement)
        Description copied from interface: AddressSpace
        Creates a new address by adding the displacement to the given address. If the offset is greater than the max offset of the address space, the high order bits are masked off, making the address wrap. For non-segmented addresses this will be the same as addWrap(). For segmented addresses, the address will wrap when the 20 bit (oxfffff) offset is exceeded, as opposed to when the segment offset is exceeded.
        Specified by:
        addWrapSpace in interface AddressSpace
        Parameters:
        addr - the address to add the displacement to.
        displacement - the displacement to add.
        Returns:
        The new Address formed by adding the displacement to the specified addresst.

      • addNoWrap

        public Address addNoWrap​(Address addr,
                         long displacement)
                  throws AddressOverflowException
        Description copied from interface: AddressSpace
        Creates a new address by adding displacement to the given address. The new address will NOT wrap!
        Specified by:
        addNoWrap in interface AddressSpace
        Parameters:
        addr - the original address.
        displacement - the displacement to add.
        Returns:
        The new address created by adding displacement to addr.offset.
        Throws:
        AddressOverflowException - if the addition would cause a wrap,

      • addNoWrap

        public Address addNoWrap​(GenericAddress addr,
                         java.math.BigInteger displacement)
                  throws AddressOverflowException
        Description copied from interface: AddressSpace
        Creates a new address by adding displacement to the given address. The new address will NOT wrap!
        Specified by:
        addNoWrap in interface AddressSpace
        Parameters:
        addr - the original address.
        displacement - the displacement to add.
        Returns:
        The new address created by adding displacement to addr.offset.
        Throws:
        AddressOverflowException - if the addition would cause a wrap,

      • add

        public Address add​(Address addr,
                   long displacement)
            throws AddressOutOfBoundsException
        Description copied from interface: AddressSpace
        Creates a new address (possibly in a new space) by adding the given displacement from the given address.
        Specified by:
        add in interface AddressSpace
        Parameters:
        addr - original address being subtracted from
        displacement - amount to subtract
        Returns:
        the new address
        Throws:
        AddressOutOfBoundsException - if the result does not correspond to any address.

      • isValidRange

        public boolean isValidRange​(long byteOffset,
                            long length)
        Description copied from interface: AddressSpace
        Check the specified address range for validity within this space. Segmented spaces will restrict a range to a single segment.
        Specified by:
        isValidRange in interface AddressSpace
        Returns:
        true if range is valid for this space

      • isSuccessor

        public boolean isSuccessor​(Address addr1,
                           Address addr2)
        Description copied from interface: AddressSpace
        Tests whether addr2 immediately follows addr1.
        Specified by:
        isSuccessor in interface AddressSpace
        Parameters:
        addr1 - the first address.
        addr2 - the second address.

      • compareTo

        public int compareTo​(AddressSpace space)
        Specified by:
        compareTo in interface java.lang.Comparable<AddressSpace>

      • equals

        public boolean equals​(java.lang.Object obj)
        Overrides:
        equals in class java.lang.Object

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class java.lang.Object

      • getSpaceID

        public int getSpaceID()
        Description copied from interface: AddressSpace
        Get the ID for this space
        Specified by:
        getSpaceID in interface AddressSpace
        Returns:
        space ID

      • testAddressSpace

        protected void testAddressSpace​(Address addr)

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object

      • showSpaceName

        public boolean showSpaceName()
        Description copied from interface: AddressSpace
        Returns true if the address should display its addressSpace name.
        Specified by:
        showSpaceName in interface AddressSpace

      • makeValidOffset

        public long makeValidOffset​(long offset)
                     throws AddressOutOfBoundsException
        Description copied from interface: AddressSpace
        Tests if the offset if valid. If the space is signed, then it sign extends the offset.
        Specified by:
        makeValidOffset in interface AddressSpace
        Parameters:
        offset - the offset to test and/or sign extend
        Returns:
        the valid positive offset or appropriate sign extended offset.
        Throws:
        AddressOutOfBoundsException - if offset is invalid

      • truncateOffset

        public long truncateOffset​(long offset)
        Description copied from interface: AddressSpace
        Truncate the specified byte offset within this space to produce a valid offset.
        Specified by:
        truncateOffset in interface AddressSpace
        Parameters:
        offset - any byte offset
        Returns:
        truncated byte offset

      • truncateAddressableWordOffset

        public long truncateAddressableWordOffset​(long wordOffset)
        Description copied from interface: AddressSpace
        Truncate the specified addressable unit/word offset within this space to produce a valid offset.
        Specified by:
        truncateAddressableWordOffset in interface AddressSpace
        Parameters:
        wordOffset - any addressable unit/word offset
        Returns:
        truncated word offset

      • isMemorySpace

        public boolean isMemorySpace()
        Description copied from interface: AddressSpace
        Returns true if this space represents a memory address. NOTE: It is important to make the distinction between Loaded and Non-Loaded memory addresses. Program importers may create memory blocks associated with Non-Loaded file content which are not associated with processor defined memory regions. While Loaded file content is placed into memory blocks which are associated with specific memory address spaces defined by the processor language specification.
        Specified by:
        isMemorySpace in interface AddressSpace
        See Also:
        AddressSpace.isLoadedMemorySpace(), AddressSpace.isNonLoadedMemorySpace()

      • isLoadedMemorySpace

        public boolean isLoadedMemorySpace()
        Description copied from interface: AddressSpace
        Returns true if this space represents represents a Loaded Memory region (e.g., processor RAM).
        Specified by:
        isLoadedMemorySpace in interface AddressSpace

      • isNonLoadedMemorySpace

        public boolean isNonLoadedMemorySpace()
        Description copied from interface: AddressSpace
        Returns true if this space represents represents a Non-Loaded storage region for retaining non-loaded file data (e.g., OTHER)
        Specified by:
        isNonLoadedMemorySpace in interface AddressSpace

      • isHashSpace

        public boolean isHashSpace()
        Description copied from interface: AddressSpace
        Returns true if this space represents a location in the HASH space.
        Specified by:
        isHashSpace in interface AddressSpace

      • isRegisterSpace

        public boolean isRegisterSpace()
        Description copied from interface: AddressSpace
        Returns true if this space represents a register location
        Specified by:
        isRegisterSpace in interface AddressSpace

      • isStackSpace

        public boolean isStackSpace()
        Description copied from interface: AddressSpace
        Returns true if this space represents a stack location
        Specified by:
        isStackSpace in interface AddressSpace

      • isUniqueSpace

        public boolean isUniqueSpace()
        Description copied from interface: AddressSpace
        Returns true if this space in the unique space
        Specified by:
        isUniqueSpace in interface AddressSpace

      • isConstantSpace

        public boolean isConstantSpace()
        Description copied from interface: AddressSpace
        Returns true if this space in the constant space
        Specified by:
        isConstantSpace in interface AddressSpace

      • isVariableSpace

        public boolean isVariableSpace()
        Description copied from interface: AddressSpace
        Returns true if this space represents a variable location
        Specified by:
        isVariableSpace in interface AddressSpace

      • isExternalSpace

        public boolean isExternalSpace()
        Description copied from interface: AddressSpace
        Returns true if this space in the EXTERNAL_SPACE
        Specified by:
        isExternalSpace in interface AddressSpace

      • isOverlaySpace

        public boolean isOverlaySpace()
        Description copied from interface: AddressSpace
        Returns true if this addressSpace is an OverlayAddressSpace
        Specified by:
        isOverlaySpace in interface AddressSpace

      • setShowSpaceName

        public void setShowSpaceName​(boolean b)

      • hasMappedRegisters

        public boolean hasMappedRegisters()
        Description copied from interface: AddressSpace
        Returns true if this space has registers that are mapped into it. This means that registers could actually have pointers to them.
        Specified by:
        hasMappedRegisters in interface AddressSpace
        Returns:
        true if this space has any registers mapped in it.

      • setHasMappedRegisters

        public void setHasMappedRegisters​(boolean hasRegisters)
        Tag this memory space as having memory mapped registers
        Parameters:
        hasRegisters - true if it has registers, false otherwise

      • getPhysicalSpace

        public AddressSpace getPhysicalSpace()
        Description copied from interface: AddressSpace
        Returns the physical space associated with an address space. There is always exactly one physical space associated with an address space (it may be its own physical space).
        Specified by:
        getPhysicalSpace in interface AddressSpace
        Returns:
        the associated physical space.