Package ghidra.program.model.address
Class OverlayAddressSpace
- java.lang.Object
-
- ghidra.program.model.address.OverlayAddressSpace
-
- All Implemented Interfaces:
AddressSpace
,java.lang.Comparable<AddressSpace>
public class OverlayAddressSpace extends java.lang.Object
-
-
Field Summary
Fields Modifier and Type Field Description protected Address
maxAddress
protected long
maxOffset
protected Address
minAddress
protected long
minOffset
protected java.lang.String
name
static java.lang.String
OV_SEPARATER
protected boolean
signed
protected int
size
protected int
spaceID
protected long
spaceSize
protected int
type
protected int
unitSize
-
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 OverlayAddressSpace(java.lang.String name, AddressSpace originalSpace, int unique, long minOffset, long maxOffset)
-
Method Summary
All Methods Instance Methods Concrete Methods 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, java.math.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
contains(long offset)
boolean
equals(java.lang.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.Address
getAddress(java.lang.String addrString)
Parses the String into an address.Address
getAddress(java.lang.String addrString, boolean caseSensitive)
Parses the String into an address.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.int
getBaseSpaceID()
long
getDatabaseKey()
Address
getMaxAddress()
Get the max address allowed for this AddressSpace.long
getMaxOffset()
Address
getMinAddress()
Get the min address allowed for this AddressSpacelong
getMinOffset()
java.lang.String
getName()
Returns the name of this address space.Address
getOverlayAddress(Address addr)
No overlay translation necessary, this is a base addressSpace.AddressSpace
getOverlayedSpace()
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 spaceAddress
getTruncatedAddress(long offset, boolean isAddressableWordOffset)
Returns a new address in this space with the given offset.int
getType()
Returns the type of this address spaceprotected Address
getUncheckedAddress(long offset)
Instantiates an address within this space.int
getUnique()
Returns the unique id value for this space.int
hashCode()
boolean
hasMappedRegisters()
Returns true if this space has registers that are mapped into it.boolean
hasSignedOffset()
Returns true if space uses signed offsetboolean
isConstantSpace()
Returns true if this space in the constant spaceboolean
isExternalSpace()
Returns true if this space in the EXTERNAL_SPACEboolean
isHashSpace()
Returns true if this space represents a location in the HASH space.boolean
isLoadedMemorySpace()
Returns true if this space represents 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 represents a Non-Loaded storage region for retaining non-loaded file data (e.g., OTHER)boolean
isOverlaySpace()
Returns true if this addressSpace is an OverlayAddressSpaceboolean
isRegisterSpace()
Returns true if this space represents a register locationboolean
isStackSpace()
Returns true if this space represents a stack locationboolean
isSuccessor(Address addr1, Address addr2)
Tests whether addr2 immediately follows addr1.boolean
isUniqueSpace()
Returns true if this space in the unique spaceboolean
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 locationlong
makeValidOffset(long offset)
Tests if the offset if valid.void
setDatabaseKey(long key)
void
setHasMappedRegisters(boolean hasRegisters)
Tag this memory space as having memory mapped registersvoid
setName(java.lang.String newName)
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)
java.lang.String
toString()
Address
translateAddress(Address addr)
If the given address is outside the overlay block, then the address is tranlated to an address in the base space with the same offset, otherwise (if the address exists in the overlay block), it is returnedAddress
translateAddress(Address addr, boolean forceTranslation)
Tranlated an overlay-space address (addr, which may exceed the bounds of the overlay space) to an address in the base space with the same offset.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.
-
-
-
Field Detail
-
OV_SEPARATER
public static final java.lang.String OV_SEPARATER
- See Also:
- Constant Field Values
-
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
-
OverlayAddressSpace
public OverlayAddressSpace(java.lang.String name, AddressSpace originalSpace, int unique, long minOffset, long maxOffset)
-
-
Method Detail
-
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 interfaceAddressSpace
- 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.
-
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 interfaceAddressSpace
- Parameters:
addr1
- the address to subtract from.addr2
- the address to subtract.- Returns:
- the difference. (
addr1.offset - addr2.offset
).
-
isOverlaySpace
public boolean isOverlaySpace()
Description copied from interface:AddressSpace
Returns true if this addressSpace is an OverlayAddressSpace- Specified by:
isOverlaySpace
in interfaceAddressSpace
-
getOverlayedSpace
public AddressSpace getOverlayedSpace()
-
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 interfaceAddressSpace
- Returns:
- the associated physical space.
-
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 interfaceAddressSpace
- Returns:
- true if this space has any registers mapped in it.
-
getMinOffset
public long getMinOffset()
-
getMaxOffset
public long getMaxOffset()
-
contains
public boolean contains(long offset)
-
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.
-
getAddress
public Address getAddress(long offset)
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
-
getUncheckedAddress
protected Address getUncheckedAddress(long offset)
Instantiates an address within this space. No offset validation should be performed.
-
getOverlayAddress
public Address getOverlayAddress(Address addr)
No overlay translation necessary, this is a base addressSpace. (non-Javadoc)- Specified by:
getOverlayAddress
in interfaceAddressSpace
- 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)
-
translateAddress
public Address translateAddress(Address addr)
If the given address is outside the overlay block, then the address is tranlated to an address in the base space with the same offset, otherwise (if the address exists in the overlay block), it is returned- Parameters:
addr
- the address to translate to the base space if it is outside the overlay block- Returns:
- either the given address if it is contained in the overlay memory block or an address in the base space with the same offset as the given address.
-
translateAddress
public Address translateAddress(Address addr, boolean forceTranslation)
Tranlated an overlay-space address (addr, which may exceed the bounds of the overlay space) to an address in the base space with the same offset. If forceTranslation is false and addr is contained within the overlay-space the original addr is returned.- Parameters:
addr
- the address to translate to the base spaceforceTranslation
- if true addr will be translated even if addr falls within the bounds of this overlay-space.- Returns:
- either the given address if it is contained in the overlay memory block or an address in the base space with the same offset as the given address.
-
getBaseSpaceID
public int getBaseSpaceID()
- Returns:
- the ID of the address space underlying this space
-
toString
public java.lang.String toString()
-
setName
public void setName(java.lang.String newName)
-
setDatabaseKey
public void setDatabaseKey(long key)
-
getDatabaseKey
public long getDatabaseKey()
-
equals
public boolean equals(java.lang.Object obj)
-
hasSignedOffset
public boolean hasSignedOffset()
Description copied from interface:AddressSpace
Returns true if space uses signed offset- Specified by:
hasSignedOffset
in interfaceAddressSpace
-
getName
public java.lang.String getName()
Description copied from interface:AddressSpace
Returns the name of this address space.- Specified by:
getName
in interfaceAddressSpace
-
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 interfaceAddressSpace
-
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 methodAddressSpace.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 interfaceAddressSpace
-
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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
-
getUnique
public int getUnique()
Returns the unique id value for this space.- Specified by:
getUnique
in interfaceAddressSpace
-
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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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. SeeAddressSpace.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 interfaceAddressSpace
- 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. SeeAddressSpace.getAddressableUnitSize()
to understand the distinction (i.e., wordOffset = byteOffset * addressableUnitSize).- Returns:
- address with given byte offset truncated to the physical space size
-
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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
- Parameters:
addr
- the original addressdisplacement
- 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 interfaceAddressSpace
- Parameters:
addr
- original address being subtracted fromdisplacement
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
- Parameters:
addr
- original address being subtracted fromdisplacement
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
- Parameters:
addr1
- the first address.addr2
- the second address.
-
getMaxAddress
public Address getMaxAddress()
Description copied from interface:AddressSpace
Get the max address allowed for this AddressSpace.- Specified by:
getMaxAddress
in interfaceAddressSpace
-
getMinAddress
public Address getMinAddress()
Description copied from interface:AddressSpace
Get the min address allowed for this AddressSpace- Specified by:
getMinAddress
in interfaceAddressSpace
-
compareTo
public int compareTo(AddressSpace space)
- Specified by:
compareTo
in interfacejava.lang.Comparable<AddressSpace>
-
hashCode
public int hashCode()
- Overrides:
hashCode
in classjava.lang.Object
-
getSpaceID
public int getSpaceID()
Description copied from interface:AddressSpace
Get the ID for this space- Specified by:
getSpaceID
in interfaceAddressSpace
- Returns:
- space ID
-
testAddressSpace
protected void testAddressSpace(Address addr)
-
showSpaceName
public boolean showSpaceName()
Description copied from interface:AddressSpace
Returns true if the address should display its addressSpace name.- Specified by:
showSpaceName
in interfaceAddressSpace
-
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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
- 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 interfaceAddressSpace
-
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 interfaceAddressSpace
-
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 interfaceAddressSpace
-
isRegisterSpace
public boolean isRegisterSpace()
Description copied from interface:AddressSpace
Returns true if this space represents a register location- Specified by:
isRegisterSpace
in interfaceAddressSpace
-
isStackSpace
public boolean isStackSpace()
Description copied from interface:AddressSpace
Returns true if this space represents a stack location- Specified by:
isStackSpace
in interfaceAddressSpace
-
isUniqueSpace
public boolean isUniqueSpace()
Description copied from interface:AddressSpace
Returns true if this space in the unique space- Specified by:
isUniqueSpace
in interfaceAddressSpace
-
isConstantSpace
public boolean isConstantSpace()
Description copied from interface:AddressSpace
Returns true if this space in the constant space- Specified by:
isConstantSpace
in interfaceAddressSpace
-
isVariableSpace
public boolean isVariableSpace()
Description copied from interface:AddressSpace
Returns true if this space represents a variable location- Specified by:
isVariableSpace
in interfaceAddressSpace
-
isExternalSpace
public boolean isExternalSpace()
Description copied from interface:AddressSpace
Returns true if this space in the EXTERNAL_SPACE- Specified by:
isExternalSpace
in interfaceAddressSpace
-
setShowSpaceName
public void setShowSpaceName(boolean b)
-
setHasMappedRegisters
public void setHasMappedRegisters(boolean hasRegisters)
Tag this memory space as having memory mapped registers- Parameters:
hasRegisters
- true if it has registers, false otherwise
-
-