< Beginning of split points

< Clear a range of split points

Get the offset of the address as an integer. \return the offset integer

This routine gets the value from a range of bytes at an arbitrary address. It takes into account the endianness of the underlying space when decoding

Get the address space associated with this address. \return the AddressSpace pointer, or \b NULL if invalid

Return the defining type for this address space. - IPTR_CONSTANT for the constant space - IPTR_PROCESSOR for a normal space - IPTR_INTERNAL for the te

return iterator end (needed for range-based for)

print if -I or -D args provided

This derived method looks for a previously cached page of the underlying memory bank. If the cached page does not exist, it creates it and fills in it

return iterator begin (needed for range-based for)

The name is looked up in the global list of all attributes. If the attribute is not in the list, a special placeholder attribute, ATTRIB_UNKNOWN, is

All address spaces have a unique name associated with them. This routine retrieves the AddrSpace object based on the desired name. \param nm is the na

< Clear all split points

Retrieve the actual pcode translator being used by this machine state \return a pointer to the Translate object

@brief return the type as string @sa https://json.nlohmann.me/api/basic_json/type_name/

add a character to token_buffer

@brief return a string representation of the JSON pointer @sa https://json.nlohmann.me/api/json_pointer/to_string/

@brief create an empty value with a given type @sa https://json.nlohmann.me/api/basic_json/basic_json/

\return the memory state object which this emulator uses

This is a convenience function to construct a full Address from the VarnodeData's address space and offset \return the address of the varnode

@brief return whether value is an object @sa https://json.nlohmann.me/api/basic_json/is_object/

print if -D arg provided

Set the current execution address and cache the pcode translation of the machine instruction at that address \param addr is the address where executio

A PcodeOpRaw is initially created with no input varnodes. Inputs are added with this method. Varnodes are added in order, so the first addInput call

< Get the element's name

return value of the iterator

Each address space has an associated index that can be used as an integer encoding of the space. \return the unique index

return the last read token (for errors only). Will never contain EOF (an arbitrary value that is not a valid char value, often -1), because 255 may l

This routine is used to set a single value in the memory bank at an arbitrary address It takes into account the endianness of the associated address s

\param size is the desired size in bytes \return a value appropriate for masking off the first \e size bytes

@brief returns an iterator to one past the last element @sa https://json.nlohmann.me/api/basic_json/end/

Input varnodes are indexed starting at 0. This retrieves the input varnode by index. The index \e must be in range, or unpredicatable behavior will r

If integer values stored in this space are encoded in this space using the big endian format, then return \b true. \return \b true if the space is big

< Destructor

Pcode represents constant values within an operation as offsets within a special \e constant address space. (See ConstantSpace) \return a pointer to t

! @brief get next character from the input This function provides the interface to the used input adapter. It does not throw in case the

The pcode model for floating point encoding assumes that a consistent encoding is used for all values of a given size. This routine fetches the FloatF

access to successor

The possible types of pcode operations are enumerated by OpCode This routine retrieves the enumeration value for this particular op \return the opcode

\brief Output the given signed integer as an XML attribute value \param s is the output stream \param attr is the name of the attribute \param val is

@brief returns an iterator to the first element @sa https://json.nlohmann.me/api/basic_json/begin/

Most processors have a main address bus, on which the bulk of the processor's RAM is mapped. This matches SLEIGH's notion of the \e default space. For

! @return a string representation of the last read byte */

Handle crash during emulation

This method indicates the number of bytes contained in an \e addressable \e unit of this space. This is almost always 1, but can be any other small i

@brief return whether value is an array @sa https://json.nlohmann.me/api/basic_json/is_array/

Associate the new section with \b nextindex, established prior to parsing \param rtl is the \e named section of p-code \param scope is the associated

boost::hash_combine

@brief return whether value is null @sa https://json.nlohmann.me/api/basic_json/is_null/

\return the number of inputs

* This is a fast avalanche stage, * suitable when input bits are already partially mixed */

Return the number of bytes needed to represent an offset into this space. A space with 2^32 bytes has an address size of 4, for instance. \return the

< Mark end of parsing for the current file or macro

* DISCLAIMER: There are known *seed-dependent* multicollisions here due to * multiplication by zero, affecting hashes of lengths 17 to 240. * * How

! * @internal * @brief Normal stripe processing routine. * * This shuffles the bits so that any bit from @p input impacts several bits in * @p ac