Package ghidra.program.model.data

Class DataUtilities

  • public final class DataUtilities
extends java.lang.Object

    • Method Detail

      • isValidDataTypeName

        public static boolean isValidDataTypeName​(java.lang.String name)
        Determine if the specified name is a valid data-type name
        Parameters:
        name - candidate data-type name
        Returns:
        true if name is valid, else false

      • reconcileAppliedDataType

        public static DataType reconcileAppliedDataType​(DataType originalDataType,
                                                DataType newDataType,
                                                boolean stackPointers)
        Determine the final data-type which should be applied based upon a user applied type of newDataType on an existing originalDataType. Pointer conversion is performed when appropriate, otherwise the newDataType is returned unchanged. If newDataType is a FunctionDefinition, or Typedef to a FunctionDefinition, it will either be stacked with the existing pointer if enabled/applicable, or will be converted to a pointer since FunctionDefinitions may only been used in the form of a pointer. Note that originalDataType and newDataType should be actual applied types. (i.e., do not strip typedefs, pointers, arrays, etc.).
        Parameters:
        originalDataType - existing data type onto which newDataTye is applied
        newDataType - new data-type being applied
        stackPointers - If true the following data type transformation will be performed:
        • If newDataType is a default pointer and the originalDataType is a pointer the new pointer will wrap the existing pointer thus increasing is 'depth' (e.g., int * would become int ** when default pointer applied). If the originalDataType is not a pointer the newDataType will be returned unchanged.
        • If the originalDataType is any type of pointer the supplied newDatatype will replace the pointer's base type (e.g., int * would become db * when newDataType is ByteDataType).

        If false, only required transformations will be applied, Example: if newDataType is a FunctionDefinitionDataType it will be transformed to a pointer before being applied.

        Returns:
        either a combined pointer data-type or the newDataType specified with any required transformation

      • getDataAtLocation

        public static Data getDataAtLocation​(ProgramLocation loc)
        Get the data for the given address; if the code unit at the address is an instruction, return null.
        Parameters:
        loc - the location. This provides the address and subcomponent within the data at the address.
        Returns:
        the data or null if the code unit at the address is an instruction.

      • getDataAtAddress

        public static Data getDataAtAddress​(Program program,
                                    Address address)
        Get the data for the given address.

        This will return a Data if and only if there is data that starts at the given address.

        Parameters:
        program - the program
        address - the data address
        Returns:
        the Data that starts at the given address or null if the address is code or offcut

      • getMaxAddressOfUndefinedRange

        public static Address getMaxAddressOfUndefinedRange​(Program program,
                                                    Address addr)
        Get the maximum address of an undefined data range starting at addr. Both undefined code units and defined data which have an Undefined data type are included in the range.
        Parameters:
        program - the program which will have its code units checked.
        addr - the address where this will start checking for Undefined data. This address can be offcut into an Undefined Data.
        Returns:
        end of undefined range or null if addr does not correspond to an undefined location.

      • isUndefinedData

        public static boolean isUndefinedData​(Program program,
                                      Address addr)
        Determine if the specified addr corresponds to an undefined data location where both undefined code units and defined data which has an Undefined data type is considered to be undefined.
        Parameters:
        program - the program
        addr - the data address
        Returns:
        true if the data is undefined

      • getNextNonUndefinedDataAfter

        public static Data getNextNonUndefinedDataAfter​(Program program,
                                                Address addr,
                                                Address maxAddr)
        Get the next defined data that comes after the address indicated by addr and that is no more than the specified maxAddr and that is not a sized undefined data type.
        Parameters:
        program - the program whose code units are to be checked to find the next non-undefined data.
        addr - start looking for data after this address.
        maxAddr - do not look any further than this address.
        Returns:
        the next defined data that isn't a sized undefined data type, or return null if there isn't one.

      • findFirstConflictingAddress

        public static Address findFirstConflictingAddress​(Program program,
                                                  Address addr,
                                                  int length,
                                                  boolean ignoreUndefinedData)
        Finds the first conflicting address in the given address range.
        Parameters:
        program - The program.
        addr - The starting address of the range.
        length - The length of the range.
        ignoreUndefinedData - True if the search should ignore Undefined data as a potential conflict, or false if Undefined data should trigger conflicts.
        Returns:
        The address of the first conflict in the range, or null if there were no conflicts.

      • isUndefinedRange

        public static boolean isUndefinedRange​(Program program,
                                       Address startAddress,
                                       Address endAddress)
        Determine if there is only undefined data from the specified startAddress to the specified endAddress. The start and end addresses must both be in the same defined block of memory.
        Parameters:
        program - the program whose code units are to be checked.
        startAddress - start looking for undefined data at this address in a defined memory block.
        endAddress - do not look any further than this address. This must be greater than or equal to the startAddress and must be in the same memory block as the start address or false is returned.
        Returns:
        true if the range of addresses in a memory block is where only undefined data exists.