Package ghidra.program.model.address

# Class GenericAddressSpace

java.lang.Object
ghidra.program.model.address.GenericAddressSpace

All Implemented Interfaces:
  `AddressSpace`, `Comparable<AddressSpace>`

Direct Known Subclasses:
  `SegmentedAddressSpace`

public class GenericAddressSpace extends Object
Generic implementation of the AddressSpace interface.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected Address`
  `maxAddress`
  `protected long`
  `maxOffset`
  `protected final Address`
  `minAddress`
  `protected final long`
  `minOffset`
  `protected final int`
  `spaceID`
  `protected long`
  `spaceSize`

  ### Fields inherited from interface ghidra.program.model.address.AddressSpace

  `DEFAULT_REGISTER_SPACE, EXTERNAL_SPACE, HASH_SPACE, ID_SIZE_MASK, ID_SIZE_SHIFT, ID_TYPE_MASK, ID_UNIQUE_SHIFT, OTHER_SPACE, TYPE_CODE, TYPE_CONSTANT, TYPE_DELETED, TYPE_EXTERNAL, TYPE_IPTR_CONSTANT, TYPE_IPTR_INTERNAL, TYPE_IPTR_SPACEBASE, TYPE_JOIN, TYPE_NONE, TYPE_OTHER, TYPE_RAM, TYPE_REGISTER, TYPE_STACK, TYPE_SYMBOL, TYPE_UNIQUE, TYPE_UNKNOWN, TYPE_VARIABLE, VARIABLE_SPACE`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `GenericAddressSpace(String name, int size, int type, int unique)`
  Constructs a new GenericAddress space with the given name, bit size, type and unique value.
  `GenericAddressSpace(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.
  `GenericAddressSpace(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.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `Address`
  `add(Address addr, long displacement)`
  Creates a new address (possibly in a new space) by adding the given displacement from the given address.
  `Address`
  `addNoWrap(Address addr, long displacement)`
  Creates a new address by adding displacement to the given address.
  `Address`
  `addNoWrap(GenericAddress addr, BigInteger displacement)`
  Creates a new address by adding displacement to the given address.
  `Address`
  `addWrap(Address addr, long displacement)`
  Creates a new address by adding displacement to the given address.
  `Address`
  `addWrapSpace(Address addr, long displacement)`
  Creates a new address by adding the displacement to the given address.
  `int`
  `compareTo(AddressSpace space)`
  `boolean`
  `equals(Object obj)`
  `Address`
  `getAddress(long offset)`
  Returns a new address in this space with the given byte offset.
  `Address`
  `getAddress(long offset, boolean isAddressableWordOffset)`
  Returns a new address in this space with the given offset.
  `final Address`
  `getAddress(String addrString)`
  Parses the String into an address within this address space.
  `Address`
  `getAddress(String addrString, boolean caseSensitive)`
  Parses the String into an address within this address space.
  `int`
  `getAddressableUnitSize()`
  Returns the number of data bytes which correspond to each addressable location within this space (i.e., word-size in bytes)..
  `long`
  `getAddressableWordOffset(long byteOffset)`
  Get the addressable memory word offset which corresponds to the specified memory byte offset.
  `Address`
  `getAddressInThisSpaceOnly(long offset)`
  Get a byte address from this address space.
  `Address`
  `getMaxAddress()`
  Get the maximum address allowed for this AddressSpace.
  `Address`
  `getMinAddress()`
  Get the minimum address allowed for this AddressSpace.
  `final String`
  `getName()`
  Returns the name of this address space.
  `Address`
  `getOverlayAddress(Address addr)`
  No overlay translation necessary, this is a base addressSpace.
  `AddressSpace`
  `getPhysicalSpace()`
  Returns the physical space associated with an address space.
  `int`
  `getPointerSize()`
  Returns the absolute size of a pointer into this space (in bytes)..
  `int`
  `getSize()`
  Returns the number of bits that are used to form the address..
  `int`
  `getSpaceID()`
  Get the ID for this space
  `Address`
  `getTruncatedAddress(long offset, boolean isAddressableWordOffset)`
  Returns a new address in this space with the given offset.
  `int`
  `getType()`
  Returns the type of this address space.
  `protected Address`
  `getUncheckedAddress(long offset)`
  Instantiates an address within this space.
  `int`
  `getUnique()`
  Returns the unique id value for this space.
  `final int`
  `hashCode()`
  `boolean`
  `hasMappedRegisters()`
  Returns true if this space has registers that are mapped into it.
  `boolean`
  `hasSignedOffset()`
  Returns true if space uses signed offset.
  `boolean`
  `isConstantSpace()`
  Returns true if this space in the constant space.
  `boolean`
  `isExternalSpace()`
  Returns true if this space in the EXTERNAL_SPACE.
  `boolean`
  `isHashSpace()`
  Returns true if this space represents a location in the HASH space.
  `boolean`
  `isLoadedMemorySpace()`
  Returns true if this space represents a Loaded Memory region (e.g., processor RAM).
  `boolean`
  `isMemorySpace()`
  Returns true if this space represents a memory address..
  `boolean`
  `isNonLoadedMemorySpace()`
  Returns true if this space represents a Non-Loaded storage region for retaining non-loaded file data (e.g., OTHER).
  `boolean`
  `isOverlaySpace()`
  Returns true if this addressSpace is an overlay address space.
  `boolean`
  `isRegisterSpace()`
  Returns true if this space represents a register location.
  `boolean`
  `isStackSpace()`
  Returns true if this space represents a stack location.
  `boolean`
  `isSuccessor(Address addr1, Address addr2)`
  Returns true if addr2 immediately follows addr1; otherwise, false.
  `boolean`
  `isUniqueSpace()`
  Returns true if this space in the unique space.
  `boolean`
  `isValidRange(long byteOffset, long length)`
  Check the specified address range for validity within this space.
  `boolean`
  `isVariableSpace()`
  Returns true if this space represents a variable location.
  `long`
  `makeValidOffset(long offset)`
  Tests if the offset if valid.
  `void`
  `setHasMappedRegisters(boolean hasRegisters)`
  Tag this memory space as having memory mapped registers
  `void`
  `setShowSpaceName(boolean b)`
  `boolean`
  `showSpaceName()`
  Returns true if the address should display its addressSpace name.
  `Address`
  `subtract(Address addr, long displacement)`
  Creates a new address (possibly in a new space) by subtracting the given displacement from the given address.
  `long`
  `subtract(Address addr1, Address addr2)`
  Calculates the displacement between addr1 and addr2 (addr1 - addr2)
  `Address`
  `subtractNoWrap(Address addr, long displacement)`
  Creates a new address by subtracting displacement from addr's offset.
  `Address`
  `subtractWrap(Address addr, long displacement)`
  Creates a new address by subtracting displacement from addr's offset.
  `Address`
  `subtractWrapSpace(Address addr, long displacement)`
  Creates a new address by subtracting the displacement from the given address.
  `protected void`
  `testAddressSpace(Address addr)`
  `String`
  `toString()`
  `long`
  `truncateAddressableWordOffset(long wordOffset)`
  Truncate the specified addressable unit/word offset within this space to produce a valid offset.
  `long`
  `truncateOffset(long offset)`
  Truncate the specified byte offset within this space to produce a valid offset.

  ### Methods inherited from class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- ## Field Details

  - ### minOffset

    protected final long minOffset

  - ### maxOffset

    protected long maxOffset

  - ### minAddress

    protected final Address minAddress

  - ### maxAddress

    protected Address maxAddress

  - ### spaceSize

    protected long spaceSize

  - ### spaceID

    protected final int spaceID

- ## Constructor Details

  - ### GenericAddressSpace

    public GenericAddressSpace(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(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(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 Details

  - ### getName

    public final String getName()
    Description copied from interface: `AddressSpace`
    Returns the name of this address space.. With the exception of `OverlayAddressSpace`, the name of an address space may not change.
    Returns:
      the name of this address space

  - ### 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.
    Parameters:
      `offset` - address offset
    Returns:
      requested unchecked address
    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`
    Returns:
      true if space uses signed offset

  - ### 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`
    Returns:
      the number of bits that are used to form the address.

  - ### 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`
    Returns:
      the number of data bytes which correspond to each addressable location within this space (i.e., word-size in bytes).

  - ### 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

  - ### getPointerSize

    public int getPointerSize()
    Description copied from interface: `AddressSpace`
    Returns the absolute size of a pointer into this space (in bytes)..
    Specified by:
      `getPointerSize` in interface `AddressSpace`
    Returns:
      the absolute size of a pointer into this space (in bytes).
    See Also:
      - `for a user adjustable pointer size which is derived from the CompilerSpec store pointer size.`

  - ### getType

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

  - ### getUnique

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

  - ### getAddress

    public final Address getAddress(String addrString) throws AddressFormatException
    Description copied from interface: `AddressSpace`
    Parses the String into an address within this address space.
    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(String addrString, boolean caseSensitive) throws AddressFormatException
    Description copied from interface: `AddressSpace`
    Parses the String into an address within this address space.
    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, 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`
    Parameters:
      `byteOffset` - The offset
      `length` - The length
    Returns:
      true if range is valid for this space

  - ### isSuccessor

    public boolean isSuccessor(Address addr1, Address addr2)
    Description copied from interface: `AddressSpace`
    Returns true if addr2 immediately follows addr1; otherwise, false.
    Specified by:
      `isSuccessor` in interface `AddressSpace`
    Parameters:
      `addr1` - the first address.
      `addr2` - the second address.
    Returns:
      true if addr2 immediately follows addr1; otherwise, false

  - ### getMaxAddress

    public Address getMaxAddress()
    Description copied from interface: `AddressSpace`
    Get the maximum address allowed for this AddressSpace. NOTE: Use of this method to identify the region associated with an overlay memory block within its overlay address space is no longer supported. Defined regions of an overlay space may now be determined using `OverlayAddressSpace.getOverlayAddressSet()`.
    Specified by:
      `getMaxAddress` in interface `AddressSpace`
    Returns:
      maximum address of this address space.

  - ### getMinAddress

    public Address getMinAddress()
    Description copied from interface: `AddressSpace`
    Get the minimum address allowed for this AddressSpace. For a memory space the returned address will have an offset of 0 within this address space. NOTE: Use of this method to identify the region associated with an overlay memory block within its overlay address space is no longer supported. Defined regions of an overlay space may now be determined using `OverlayAddressSpace.getOverlayAddressSet()`.
    Specified by:
      `getMinAddress` in interface `AddressSpace`
    Returns:
      minimum address of this address space.

  - ### compareTo

    public int compareTo(AddressSpace space)
    Specified by:
      `compareTo` in interface `Comparable<AddressSpace>`

  - ### equals

    public boolean equals(Object obj)
    Overrides:
      `equals` in class `Object`

  - ### hashCode

    public final int hashCode()
    Overrides:
      `hashCode` in class `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 String toString()
    Overrides:
      `toString` in class `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`
    Returns:
      true if the address should display its addressSpace name

  - ### getOverlayAddress

    public Address getOverlayAddress(Address addr)
    No overlay translation necessary, this is a base addressSpace. (non-Javadoc)
    Specified by:
      `getOverlayAddress` in interface `AddressSpace`
    Parameters:
      `addr` - address possibly falling within this overlay space.
    Returns:
      an address relative to this overlay
    See Also:
      - `AddressSpace.getOverlayAddress(ghidra.program.model.address.Address)`

  - ### 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`
    Returns:
      true if this space represents a memory address.
    See Also:
      - `AddressSpace.isLoadedMemorySpace()`
      - `AddressSpace.isNonLoadedMemorySpace()`

  - ### isLoadedMemorySpace

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

  - ### isNonLoadedMemorySpace

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

  - ### 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`
    Returns:
      true if this space represents a location in the HASH space

  - ### isRegisterSpace

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

  - ### isStackSpace

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

  - ### isUniqueSpace

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

  - ### isConstantSpace

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

  - ### isVariableSpace

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

  - ### isExternalSpace

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

  - ### isOverlaySpace

    public boolean isOverlaySpace()
    Description copied from interface: `AddressSpace`
    Returns true if this addressSpace is an overlay address space.
    Specified by:
      `isOverlaySpace` in interface `AddressSpace`
    Returns:
      true if this addressSpace is an overlay address space

  - ### 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.