Package ghidra.program.model.pcode

# Class HighFunction

java.lang.Object
ghidra.program.model.pcode.PcodeSyntaxTree
ghidra.program.model.pcode.HighFunction

All Implemented Interfaces:
  `PcodeFactory`

public class HighFunction extends PcodeSyntaxTree
High-level abstraction associated with a low level function made up of assembly instructions. Based on information the decompiler has produced after working on a function.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final String`
  `DECOMPILER_TAG_MAP`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `HighFunction(Function function, Language language, CompilerSpec compilerSpec, PcodeDataTypeManager dtManager)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static boolean`
  `clearNamespace(SymbolTable symtab, Namespace space)`
  `static final boolean`
  `collapseToGlobal(Namespace namespace)`
  The decompiler treats some namespaces as equivalent to the "global" namespace.
  `static void`
  `createLabelSymbol(SymbolTable symtab, Address addr, String name, Namespace namespace, SourceType source, boolean useLocalNamespace)`
  `void`
  `decode(Decoder decoder)`
  `static void`
  `deleteSymbol(SymbolTable symtab, Address addr, String name, Namespace space)`
  `void`
  `encode(Encoder encoder, long id, Namespace namespace, Address entryPoint, int size)`
  Encode this HighFunction to a stream.
  `static void`
  `encodeNamespace(Encoder encoder, Namespace namespace, NameTransformer transformer)`
  Encode <parent> element to the stream describing the formal path elements from the root (global) namespace up to the given namespace
  `static Namespace`
  `findCreateNamespace(SymbolTable symtab, Namespace parentspace, String name)`
  `static Namespace`
  `findCreateOverrideSpace(Function func)`
  `static Namespace`
  `findNamespace(SymbolTable symtab, Namespace parent, String name)`
  `static Namespace`
  `findOverrideSpace(Function func)`
  `CompilerSpec`
  `getCompilerSpec()`
  `Function`
  `getFunction()`
  `FunctionPrototype`
  `getFunctionPrototype()`
  `GlobalSymbolMap`
  `getGlobalSymbolMap()`
  `long`
  `getID()`
  Get the id with the associated function symbol, if it exists.
  `JumpTable[]`
  `getJumpTables()`
  `Language`
  `getLanguage()`
  `LocalSymbolMap`
  `getLocalSymbolMap()`
  `HighSymbol`
  `getMappedSymbol(Address addr, Address pcaddr)`
  `protected Address`
  `getPCAddress(Varnode rep)`
  `HighSymbol`
  `getSymbol(long symbolId)`
  Get the high symbol matching the given id that has been registered with this object
  `void`
  `grabFromFunction(int overrideExtrapop, boolean includeDefaultNames, boolean doOverride)`
  Populate the information for the HighFunction from the information in the Function object.
  `void`
  `setVolatile(Varnode vn, boolean val)`
  Mark (or unmark) the given Varnode with the "volatile" property
  `HighVariable`
  `splitOutMergeGroup(HighVariable high, Varnode vn)`
  If a HighVariable consists of more than one (forced) merge group, split out the group that contains vn as a separate HighVariable.
  `static String`
  `tagFindExclude(String tagname, String doc)`

  ### Methods inherited from class ghidra.program.model.pcode.PcodeSyntaxTree

  `buildStorage, clear, delete, findInputVarnode, findVarnode, findVarnode, getAddressFactory, getBasicBlocks, getDataTypeManager, getJoinAddress, getJoinStorage, getNumVarnodes, getOpRef, getPcodeOp, getPcodeOps, getPcodeOps, getRef, getVarnodes, getVarnodes, getVarnodes, insertAfter, insertBefore, locRange, newOp, newVarnode, newVarnode, setAddrTied, setDataType, setInput, setInput, setMergeGroup, setOpcode, setOutput, setPersistent, setUnaffected, unInsert, unlink, unSetInput, unSetOutput`

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

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### DECOMPILER_TAG_MAP

    public static final String DECOMPILER_TAG_MAP
    See Also:
      - Constant Field Values

- ## Constructor Details

  - ### HighFunction

    public HighFunction(Function function, Language language, CompilerSpec compilerSpec, PcodeDataTypeManager dtManager)
    Parameters:
      `function` - function associated with the higher level function abstraction.
      `language` - description of the processor language of the function
      `compilerSpec` - description of the compiler that produced the function
      `dtManager` - data type manager

- ## Method Details

  - ### getFunction

    public Function getFunction()
    Returns:
      get the associated low level function

  - ### getID

    public long getID()
    Get the id with the associated function symbol, if it exists. Otherwise return a dynamic id based on the entry point.
    Returns:
      the symbol id, or possibly a dynamic id

  - ### getLanguage

    public Language getLanguage()
    Returns:
      get the language parser used to disassemble

  - ### getCompilerSpec

    public CompilerSpec getCompilerSpec()

  - ### getFunctionPrototype

    public FunctionPrototype getFunctionPrototype()
    Returns:
      the function prototype for the function (how things are passed/returned)

  - ### getJumpTables

    public JumpTable[] getJumpTables()
    Returns:
      an array of jump table definitions found for this function decompilation

  - ### getLocalSymbolMap

    public LocalSymbolMap getLocalSymbolMap()
    Returns:
      the local variable map describing the defined local variables

  - ### getGlobalSymbolMap

    public GlobalSymbolMap getGlobalSymbolMap()
    Returns:
      a map describing global variables accessed by this function

  - ### getMappedSymbol

    public HighSymbol getMappedSymbol(Address addr, Address pcaddr)

  - ### getSymbol

    public HighSymbol getSymbol(long symbolId)
    Description copied from interface: `PcodeFactory`
    Get the high symbol matching the given id that has been registered with this object
    Specified by:
      `getSymbol` in interface `PcodeFactory`
    Overrides:
      `getSymbol` in class `PcodeSyntaxTree`
    Parameters:
      `symbolId` - is the given id
    Returns:
      the matching HighSymbol or null

  - ### grabFromFunction

    public void grabFromFunction(int overrideExtrapop, boolean includeDefaultNames, boolean doOverride)
    Populate the information for the HighFunction from the information in the Function object.
    Parameters:
      `overrideExtrapop` - is the value to use if extrapop is overridden
      `includeDefaultNames` - is true if default symbol names should be considered locked
      `doOverride` - is true if extrapop is overridden

  - ### decode

    public void decode(Decoder decoder) throws DecoderException
    Overrides:
      `decode` in class `PcodeSyntaxTree`
    Throws:
      `DecoderException`

  - ### getPCAddress

    protected Address getPCAddress(Varnode rep)

  - ### splitOutMergeGroup

    public HighVariable splitOutMergeGroup(HighVariable high, Varnode vn) throws PcodeException
    If a HighVariable consists of more than one (forced) merge group, split out the group that contains vn as a separate HighVariable. Otherwise just return the original high.
    Parameters:
      `high` - is the HighVariable to split
      `vn` - is a representative of the merge group to split out
    Returns:
      a HighVariable containing just the forced merge group of vn
    Throws:
      `PcodeException` - if the split can't be performed

  - ### encode

    public void encode(Encoder encoder, long id, Namespace namespace, Address entryPoint, int size) throws IOException
    Encode this HighFunction to a stream. The size describes how many bytes starting from the entry point are used by the function, but this doesn't need to be strictly accurate as it is only used to associate the function with addresses near its entry point.
    Parameters:
      `encoder` - is the stream encoder
      `id` - is the id associated with the function symbol
      `namespace` - is the namespace containing the function symbol
      `entryPoint` - pass null to use the function entryPoint, pass an address to force an entry point
      `size` - describes how many bytes the function occupies as code
    Throws:
      `IOException` - for errors in the underlying stream

  - ### setVolatile

    public void setVolatile(Varnode vn, boolean val)
    Description copied from interface: `PcodeFactory`
    Mark (or unmark) the given Varnode with the "volatile" property
    Specified by:
      `setVolatile` in interface `PcodeFactory`
    Overrides:
      `setVolatile` in class `PcodeSyntaxTree`
    Parameters:
      `vn` - is the given Varnode
      `val` - is true if the Varnode should be marked volatile

  - ### findOverrideSpace

    public static Namespace findOverrideSpace(Function func)

  - ### findCreateOverrideSpace

    public static Namespace findCreateOverrideSpace(Function func)

  - ### findNamespace

    public static Namespace findNamespace(SymbolTable symtab, Namespace parent, String name)

  - ### createLabelSymbol

    public static void createLabelSymbol(SymbolTable symtab, Address addr, String name, Namespace namespace, SourceType source, boolean useLocalNamespace) throws InvalidInputException
    Throws:
      `InvalidInputException`

  - ### deleteSymbol

    public static void deleteSymbol(SymbolTable symtab, Address addr, String name, Namespace space) throws InvalidInputException
    Throws:
      `InvalidInputException`

  - ### clearNamespace

    public static boolean clearNamespace(SymbolTable symtab, Namespace space) throws InvalidInputException
    Throws:
      `InvalidInputException`

  - ### findCreateNamespace

    public static Namespace findCreateNamespace(SymbolTable symtab, Namespace parentspace, String name)

  - ### collapseToGlobal

    public static final boolean collapseToGlobal(Namespace namespace)
    The decompiler treats some namespaces as equivalent to the "global" namespace. Return true if the given namespace is treated as equivalent.
    Parameters:
      `namespace` - is the namespace
    Returns:
      true if equivalent

  - ### encodeNamespace

    public static void encodeNamespace(Encoder encoder, Namespace namespace, NameTransformer transformer) throws IOException
    Encode <parent> element to the stream describing the formal path elements from the root (global) namespace up to the given namespace
    Parameters:
      `encoder` - is the stream encoder
      `namespace` - is the namespace being described
      `transformer` - is used to computer the displayed version of each namespace
    Throws:
      `IOException` - for errors in the underlying stream

  - ### tagFindExclude

    public static String tagFindExclude(String tagname, String doc)
    Parameters:
      `tagname` - -- Name of tag to search for
      `doc` - -- String through which to search for tags
    Returns:
      all characters between beginning and ending XML tags, excluding tags themselves