Changelog

The following is a log containing (semi-)official updates. Updates don't happen too often (usually every 3-6 months) as things are only added as they're needed or requested.

---

June 6, 2022 — f3c1c2f8e3d8cfb6251cd68f879648561878f8cc

• refactored instruction.op_structure (structure offsets) into both instruction.op_structure [help] and instruction.op_structurepath [help] A structure path lets you adjust a delta when applying it to an offset so that you can reference a particular member. So ins.op_strucpath is used for telling IDA the exact member that the operand is relative to and ins.op_struc is when you want IDA to figure out itself what member it should reference.

• introduced the database.types [help] namespace with support for matching, serialization and deserialization, and alternate type libraries (these are non-indexed. so if you have 6-million types that you want to display at the same time.. you better hold on)

• added a number of aliases to anything that uses types within the function module [help] so that gathering the inputs and outputs to a function is more straightforward.

• added support for querying tags (non-indexed) to the structure module which can be used via structure.select [help] and for selecting members from an instance of a structure via instance(structure_t).select [help] (the implicit tags on a structure or a member are the same as address tags in that they only track changes that the user has made)

• added the location_t (tuple) for doing arithmetic with a location and updated the cases for any functions that can use it

• fixed issue #156 which corrects the way pointer types are applied by pythonic types (also updating the refinfo)

• added the priorityhxevent class for receiving notifications from hex-rays (internal, and not instantiated automatically)

• added this page to the wiki (changelog)

• added random snippets page to the wiki (snippets)

• added the ability to cancel any progress bars

• slight fix to the progress bar widget so that it detects whether the GUI is being used

module: instruction

• some minor additions to the register promotion and demotion so that the error message is more clear
• added preliminary support for the condition code type to the AArch32/AArch64 processors
• op_enumeration was not returning the previous value when modifying an operand [help]
• split up the op_structure logic into op_struc [help] and op_strucpath [help]. one for referring to a structure, the other for a path that's relative to a member (op_struc is the number on the left in the operand, op_strpath is the number on the right)

module: database

• added a variety of to the database.types namespace for querying and serialization/deserialization of types within a type library [help]
• some of the functions from the database.set [help] and database.get [help] namespaces, such as database.set.array, database.get.array, and database.set.unknown now use the current selection if one wasn't specified
• tweaked database.get.switch to try "harder" when locating a switch for the given address [help]
• modified one of the cases of database.get.structure to enforce more strict typing (when casting) [help]
• added a matcher (unmangled=) for querying things via the unmangled symbol name [help]
• the address namespace now uses the current selection when one isn't specified

module: function

• fixed blocks.graph so that it supports zero-sized basic-blocks when determining nodes and edges [help]
• blocks.iterate now updates the navigation band when iterating and warns when a yielded block is outside the function
• added cases to both chunk.top and chunk.bottom to allow modifying a chunk's bounds [help]
• added a parameter to xref.down to optionally return the instruction that contains the ref
• corrected the offset calculations in the function.frame [help] so that they're relative to $sp for the frame.args, frame.lvars, and frame.regs namespaces
• fixed some of the functions in the function.frame.args [help] namespace so that both registers and their locations are always returned
• fixed the documentation in the function.type namespace so that it's more clear that it can be used on anything that has a type applied to it
• added some more aliases to the function.xref namespace for grabbing refs to parameters [help]
• moved the logic from frame.regs into the function.type namespace to consolidate prototype stuff in the same place [help]
• the function.type namespace has complete support for reading/writing/renaming all function parameter attributes and result types
• the function.type namespace has complete support for reading most parameter location types (register, location, scatter)
• tweaked the documentation or the function.type namespace in an attempt to make clear that it can be used on anything that has a prototype

module: structure

• improved support for serialization/deserialization of unions (better error messages when attempting to deserialize a duplicate union)
• the (ancient) implementations of structure.members and structure.fragment now export their information as tags instead of just name and type [help]
• added a new "ordinal" property to a structure which can be used to locate its "local type" (instead of having to use structure_t.typeinfo)
• added explicit functions to the structure module for distinguishing unions and modified anything that gets emitted to display whether the structure is a structure or a union

module: custom and misc

• the custom.windbg module (undocumented) had some minor tweaks to better control the way breakpoints are written
• added some additional tools for better scraping things out of Qt widgets to the ui module [help]
• added the ui.message namespace for displaying modal dialog boxes [help]
• tweaked the ui.current.symbol function to return both an identifier and a register_t [help]
• the custom.tags module was modified to use structure and members tags for each used frame when importing or exporting a database [help]

Jan 16, 2022 — 406e1114c0c5d92f0d2c3dff7aaac451d4996825

• tag queries database.select [help], database.selectcontents [help], func.select [help] are sorted before iterating allowing for predictability via the navigation band arrow
• implicit tags are guaranteed to be indexed on-demand and can be disabled if desired
• the hook management classes (ui.hooks.idb, ui.hooks.idp, ui.hooks.ui) have been refactored so that they can be treated like a list where its items are sorted by priority
• the core tuple-based type, reftype_t is now hashable so that it can be used as keys for a dictionary or stored in a set.
• the "allsegs_moved" hook has been deprecated as a result of changes in IDA 7.7 (IDA dispatches the hook at a different time than before)
• improvements to the tag index and contents cache resulting in it being more consistent during a rebase
• fixed a bug in the integer decoder used by the tag system when decoding signed integers [help]
• fixed issue #152 which was related to a race condition that caused a crash in IDA on windows
• fixed issue #154 which allows the referrers of a function chunk to be accessed consistently in multiple versions of IDA

module: database

• added support for the tinfo_t and struc_t to the parameters for database.set.structure [help]
• added a couple more navigators to the database.address [help] namespace for navigating based on tags, blocks, or functions this namespace currently includes navigators for labels, comments, instructions (types, mnemonics, readable and writable operands), stack points and stack delta, references, and the type of an address
• modified the database.search [help] namespace to use the new pattern api when searching or iterating through results this allows you to use binary pattern format with masks (i.e. "4? ?? ??") instead of just bytes types when searching.

module: function

• fixed the function.chunk.owners implementation so that its compatible with all supported versions of IDA [help]

module: custom and misc

• the majority of the gui widgets are now accessible and scriptable from the ui module [help]
• added the custom.tagfix.verify function [help] and related functionality for verifying the consistency of the tag cache