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.

---

July 12, 2022 - d5bce4426adc97e61a763341260015918585d42a

• Mostly documentation updates. This involved completely updating the installation page to include the installation methodology using the loader rewrite, more clarifications on the tagging page with regards to implicit tags and how they get indexed, and added another section to its examples with regards to using structure/member tags
• Fixed a race condition(?) during type serialization which would occur when deserializing the type information for a member before IDA has loaded it into its local types
• Added explicit functions to the database module for dealing with mangled and unmangled names in case you want one and not the other
• Fixed an issue in function.frame.args.iterate which would result in not all argument locations being returned if a function doesn't have a prototype applied to it
• Some of the things in the function.type namespace was using the current function instead of the current address, so they would end up having a different effect when used on an import
• The function.name and function.tag functions will now handle name mangling properly using idaapi.get_mangled_name_type api if it's available (only on 7.7)
• Added new properties to the function.type namespace (function.type.has_problem and function.type.is_decompiled)
• Added the ability to list certain attributes as flags to the database.names, database.exports (database.entries), database.imports, database.functions, and database.types namespaces
• Added a bunch of matchers to each of the namespaces such as "tagged", "problems", "typed", "frame". The database.types namespace has a bunch more also so that you can query structures, arrays, enums, pointers, unions, typedefs, etc. without needing to use a chooser
• Some fixes were made so that the plugin and its indexing still works if you prefer to use IDA's debugger instead of windbg
• Some of the symbolic types (such as register_t) can be evaluated (concretized? lol) if the debugger can resolve them

June 25, 2022 - 0459cd4e8bea4590de349d4112459152d678571e

• plugin loader was refactored, installation process is still being tested...but you can likely just put plugins/minsc.py in your IDA plugins directory to install it.

June 24, 2022 — ae461183464aeeb7ff25dbb8d0f9cfdd730bd243

• 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)

• deprecated the "translate" method in all of the native types (named tuples) since they can be translated with implicit operators

• 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)
• renamed the instruction.opt function to instruction.op_decoder and (re-)introduced instruction.op_type (with an alias as instruction.opt) which returns the pythonic type for the operand and all operands are symbolic anyways

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 proper support for reading/writing/renaming most function parameter attributes and result types
• the function.type namespace has proper support for reading most parameter and result 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