# Porting Guide from IDA 8.x to 9.0

IDA 9.0 API Changes and porting guide

* [Introduction](#introduction)
* [struct.hpp](#structhpp)
  * [Removed classes](#removed-classes)
  * [Removed APIs](#removed-apis)
* [enum.hpp](#enumhpp)
  * [Removed APIs](#removed-apis-1)
* [bytes.hpp](#byteshpp)
  * [Added APIs](#added-apis)
  * [Modified APIs](#modified-apis)
  * [Removed APIs](#removed-apis-2)
* [dirtree.hpp](#dirtreehpp)
  * [Modified APIs](#modified-apis-1)
* [diskio.hpp](#diskiohpp)
  * [Modified APIs](#modified-apis-2)
  * [Removed APIs](#removed-apis-3)
* [err.h](#errh)
  * [Removed APIs](#removed-apis-4)
* [expr.hpp](#exprhpp)
  * [Modified APIs](#modified-apis-3)
* [frame.hpp](#framehpp)
  * [Added APIs](#added-apis-1)
  * [Modified PIs](#modified-pis)
  * [Removed APIs](#removed-apis-5)
* [funcs.hpp](#funcshpp)
  * [Added APIs](#added-apis-2)
  * [Removed APIs](#removed-apis-6)
* [gdl.hpp](#gdlhpp)
  * [Added classes/structures](#added-classesstructures)
* [hexrays.hpp](#hexrayshpp)
  * [Added classes/structures](#added-classesstructures-1)
  * [Added APIs](#added-apis-3)
    * [lvar\_t](#lvar_t)
    * [lvars\_t](#lvars_t)
    * [simple\_graph\_t](#simple_graph_t)
    * [fnumber\_t](#fnumber_t)
    * [minsn\_t](#minsn_t)
    * [mba\_t](#mba_t)
    * [codegen\_t](#codegen_t)
    * [vd\_failure\_t](#vd_failure_t)
  * [Modified APIs](#modified-apis-4)
    * [stkvar\_ref\_t](#stkvar_ref_t)
    * [mop\_t](#mop_t)
    * [mba\_t](#mba_t-1)
    * [valrng\_t](#valrng_t)
  * [Removed APIs:](#removed-apis-7)
    * [valrng\_t](#valrng_t-1)
    * [ctree\_item\_t](#ctree_item_t)
    * [ctree\_parentee\_t](#ctree_parentee_t)
    * [vdui\_t](#vdui_t)
* [graph.hpp](#graphhpp)
  * [Removed classes/structures](#removed-classesstructures)
  * [Modified classes/structures](#modified-classesstructures)
  * [Modified APIs](#modified-apis-5)
* [idalib.hpp](#idalibhpp)
  * [Added APIs](#added-apis-4)
* [idd.hpp](#iddhpp)
  * [Added APIs](#added-apis-5)
* [idp.hpp](#idphpp)
  * [Removed APIs:](#removed-apis-8)
  * [Modified APIs:](#modified-apis-6)
  * [Added APIs](#added-apis-6)
    * [procmod\_t](#procmod_t)
* [kernwin.hpp](#kernwinhpp)
  * [Removed APIs](#removed-apis-9)
  * [Removed classes/structures](#removed-classesstructures-1)
  * [Added APIs](#added-apis-7)
    * [tagged\_line\_section\_t](#tagged_line_section_t)
    * [chooser\_base\_t](#chooser_base_t)
  * [Modified APIs](#modified-apis-7)
* [lex.hpp](#lexhpp)
  * [Modified APIs](#modified-apis-8)
* [lines.hpp](#lineshpp)
  * [Removed APIs](#removed-apis-10)
  * [Modified APIs](#modified-apis-9)
* [nalt.hpp](#nalthpp)
  * [Modified APIs](#modified-apis-10)
* [parsejson.hpp](#parsejsonhpp)
  * [Added APIs](#added-apis-8)
    * [jvalue\_t](#jvalue_t)
    * [jobj\_t](#jobj_t)
* [pro.h](#proh)
  * [Removed APIs](#removed-apis-11)
  * [Added APIs](#added-apis-9)
    * [bytevec\_t](#bytevec_t)
    * [qlist](#qlist)
  * [Added classes/structures](#added-classesstructures-2)
* [regex.hpp](#regexhpp)
  * [Removed APIs](#removed-apis-12)
* [regfinder.hpp](#regfinderhpp)
  * [Modified APIs](#modified-apis-11)
  * [Removed APIs](#removed-apis-13)
  * [Added APIs](#added-apis-10)
* [registry.hpp](#registryhpp)
  * [Removed APIs](#removed-apis-14)
* [search.hpp](#searchhpp)
  * [Removed APIs](#removed-apis-15)
* [typeinf.hpp](#typeinfhpp)
  * [Removed APIs](#removed-apis-16)
  * [Modified APIs](#modified-apis-12)
  * [Added classes/structures](#added-classesstructures-3)
  * [Added APIs](#added-apis-11)
    * [til\_t](#til_t)
    * [callregs\_t](#callregs_t)
    * [tinfo\_t](#tinfo_t)
    * [func\_type\_data\_t](#func_type_data_t)
    * [enum\_type\_data\_t](#enum_type_data_t)
    * [udm\_t](#udm_t)
    * [udt\_type\_data\_t](#udt_type_data_t)
* [IDB events](#idb-events)

## Introduction

The largest change is the removal of two headers:

* `struct.hpp`
* `enum.hpp`

The functionalities for working with user-defined types are now available in `typeinf.hpp` (`tinfo_t` class).

## struct.hpp

### Removed classes

* `class member_t;`
* `class struc_t;`

struc\_t is replaced by the notion of "user-defined type" (`udt_type_data_t` class) and member\_t by dt member (`udm_t` class).

### Removed APIs

* `get_struc_qty()` Rough equivalent is `get_ordinal_limit()` or `get_ordinal_count()` but note that it also includes enums and typedefs.
* `get_first_struc_idx()`
* `get_last_struc_idx()`
* `get_prev_struc_idx()`
* `get_next_struc_idx()`

Local type ordinals always start at 1 (0 is invalid ordinal) and go up to `get_ordinal_limit()`.

* `get_struc_idx(tid_t id)`
* `get_struc_by_idx(uval_t idx)`

## enum.hpp

Enumerations are now manipulated via:

* `tinfo_t` class
* `enum_type_data_t` class
* `edm_t` class. in `typeinf.hpp`

### Removed APIs

* `get_enum_qty(void)`
* `getn_enum(size_t idx)`
* `get_enum_idx(enum_t id)`
* `get_enum(const char *name)`
* `is_bf(enum_t id)`
* `is_enum_hidden(enum_t id)`
* `set_enum_hidden(enum_t id, bool hidden)`
* `is_enum_fromtil(enum_t id)`
* `set_enum_fromtil(enum_t id, bool fromtil)`
* `is_ghost_enum(enum_t id)`
* `set_enum_ghost(enum_t id, bool ghost)`
* `get_enum_name(qstring *out, enum_t id)`
* `get_enum_name2(qstring *out, enum_t id, int flags=0)`
* `get_enum_name(tid_t id, int flags=0)`
* `get_enum_width(enum_t id)`
* `set_enum_width(enum_t id, int width)`
* `get_enum_cmt(qstring *buf, enum_t id, bool repeatable)`
* `get_enum_size(enum_t id)`
* `get_enum_flag(enum_t id)`
* `get_enum_member_by_name(const char *name)`
* `get_enum_member_value(const_t id)`
* `get_enum_member_enum(const_t id)`
* `get_enum_member_bmask(const_t id)`
* `get_enum_member(enum_t id, uval_t value, int serial, bmask_t mask)`
* `get_first_bmask(enum_t enum_id)`
* `get_last_bmask(enum_t enum_id)`
* `get_next_bmask(enum_t enum_id, bmask_t bmask\)`
* `get_prev_bmask(enum_t enum_id, bmask_t bmask)`
* `get_first_enum_member(enum_t id, bmask_t bmask=DEFMASK)`
* `get_last_enum_member(enum_t id, bmask_t bmask=DEFMASK)`
* `get_next_enum_member(enum_t id, uval_t value, bmask_t bmask=DEFMASK)`
* `get_prev_enum_member(enum_t id, uval_t value, bmask_t bmask=DEFMASK)`
* `get_enum_member_name(qstring *out, const_t id)`
* `get_enum_member_cmt(qstring *buf, const_t id, bool repeatable)`
* `get_first_serial_enum_member(uchar *out_serial, enum_t id, uval_t value, bmask_t bmask)`
* `get_last_serial_enum_member(uchar *out_serial, enum_t id, uval_t value, bmask_t bmask)`
* `get_next_serial_enum_member(uchar *in_out_serial, const_t first_cid)`
* `get_prev_serial_enum_member(uchar *in_out_serial, const_t first_cid)`
* `for_all_enum_members(enum_t id, enum_member_visitor_t &cv)`
* `ida_export get_enum_member_serial(const_t cid)`
* `get_enum_type_ordinal(enum_t id)`
* `set_enum_type_ordinal(enum_t id, int32 ord)`
* `add_enum(size_t idx, const char *name, flags64_t flag)`
* `del_enum(enum_t id)`
* `set_enum_idx(enum_t id, size_t idx)`
* `set_enum_bf(enum_t id, bool bf)`
* `set_enum_name(enum_t id, const char *name)`
* `set_enum_cmt(enum_t id, const char *cmt, bool repeatable)`
* `set_enum_flag(enum_t id, flags64_t flag)`
* `add_enum_member(enum_t id, const char *name, uval_t value, bmask_t bmask=DEFMASK)`
* `del_enum_member(enum_t id, uval_t value, uchar serial, bmask_t bmask)`
* `set_enum_member_name(const_t id, const char *name)`
* `set_enum_member_cmt(const_t id, const char *cmt, bool repeatable)`
* `is_one_bit_mask(bmask_t mask)`
* `set_bmask_name(enum_t id, bmask_t bmask, const char *name)`
* `get_bmask_name(qstring *out, enum_t id, bmask_t bmask)`
* `set_bmask_cmt(enum_t id, bmask_t bmask, const char *cmt, bool repeatable)`
* `get_bmask_cmt(qstring *buf, enum_t id, bmask_t bmask, bool repeatable)`

## bytes.hpp

### Added APIs

* `idaman ea_t ida_export find_binary(ea_t startea, ea_t endea, const char *ubinstr, int radix, int sflag, int strlits_encoding=0)`

### Modified APIs

| In 8.4                                                                                                                                  | In 9.0                                                                                                                                         |
| --------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `idaman bool ida_export get_octet2(uchar *out, octet_generator_t *ogen)`                                                                | `idaman bool ida_export get_octet(uchar *out, octet_generator_t *ogen)`                                                                        |
| `idaman bool ida_export op_enum(ea_t ea, int n, enum_t id, uchar serial=0)`                                                             | `idaman bool ida_export op_enum(ea_t ea, int n, tid_t id, uchar serial=0)`                                                                     |
| `idaman enum_t ida_export get_enum_id(uchar *serial, ea_t ea, int n)`                                                                   | `idaman tid_t ida_export get_enum_id(uchar *serial, ea_t ea, int n)`                                                                           |
| `idaman ea_t ida_export bin_search3(size_t *out_matched_idx, ea_t start_ea, ea_t end_ea, const compiled_binpat_vec_t &data, int flags)` | `idaman ea_t ida_export bin_search(ea_t start_ea, ea_t end_ea, const compiled_binpat_vec_t &data, int flags, size_t *out_matched_idx=nullptr)` |

### Removed APIs

* `bin_search2(ea_t start_ea, ea_t end_ea, const compiled_binpat_vec_t &data, int flags)`
* `bin_search(ea_t, ea_t, const uchar *, const uchar *, size_t, int, int)`
* `get_8bit(ea_t *ea, uint32 *v, int *nbit)`
* `get_octet(ea_t *ea, uint64 *v, int *nbit)`
* `free_chunk(ea_t bottom, asize_t size, int32 step)`

## dirtree.hpp

### Modified APIs

| In 8.4                                                                                                                                            | In 9.0                                                                                                                                           |
| ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `idaman bool ida_export dirtree_get_abspath_by_cursor2(qstring *out, const dirtree_impl_t *d, const dirtree_cursor_t &cursor, uint32 name_flags)` | `idaman bool ida_export dirtree_get_abspath_by_cursor(qstring *out, const dirtree_impl_t *d, const dirtree_cursor_t &cursor, uint32 name_flags)` |

## diskio.hpp

### Modified APIs

| In 8.4                                                                                                                                             | In 9.0                                                                                                                                            |
| -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `idaman THREAD_SAFE int ida_export enumerate_files2(char *answer, size_t answer_size, const char *path, const char *fname, file_enumerator_t &fv)` | `idaman THREAD_SAFE int ida_export enumerate_files(char *answer, size_t answer_size, const char *path, const char *fname, file_enumerator_t &fv)` |

### Removed APIs

* `ecreate(const char *file)`
* `eclose(FILE *fp)`
* `eread(FILE *fp, void *buf, size_t size)`
* `ewrite(FILE *fp, const void *buf, size_t size)`
* `eseek(FILE *fp, qoff64_t pos)`
* `enumerate_files(char *answer, size_t answer_size, const char *path, const char *fname, int (idaapi*func)(const char *file,void *ud), void *ud=nullptr)`

## err.h

### Removed APIs

* `qerrcode(int new_code=-1)`

## expr.hpp

### Modified APIs

| In 8.4                                                                      | In 9.0                                                                                                       |
| --------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `bool extlang_t::(idaapi *compile_file)(const char *file, qstring *errbuf)` | `bool extlang_t::(idaapi *compile_file)(const char *file, const char *requested_namespace, qstring *errbuf)` |

## frame.hpp

### Added APIs

* `idaman bool ida_export add_frame_member(const func_t *pfn, const char *name, uval_t offset, const tinfo_t &tif, const struct value_repr_t *repr=nullptr, uint etf_flags=0)`
* `THREAD_SAFE bool is_anonymous_member_name(const char *name)`
* `THREAD_SAFE bool is_dummy_member_name(const char *name)`
* `idaman bool ida_export is_special_frame_member(tid_t tid)`
* `idaman bool ida_export set_frame_member_type(const func_t *pfn, uval_t offset, const tinfo_t &tif, const struct value_repr_t *repr=nullptr, uint etf_flags=0)`
* `idaman bool ida_export delete_frame_members(const func_t *pfn, uval_t start_offset, uval_t end_offset)`
* `idaman sval_t ida_export calc_frame_offset(func_t *pfn, sval_t off, const insn_t *insn = nullptr, const op_t *op = nullptr)`

### Modified PIs

| In 8.4                                                                                                                                 | In 9.0                                                                                                                                         |
| -------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `idaman struc_t *ida_export get_frame(const func_t *pfn)`                                                                              | `idaman bool ida_export get_func_frame(tinfo_t *out, const func_t *pfn)`                                                                       |
| `idaman bool ida_export define_stkvar(func_t *pfn, const char *name, sval_t off, flags64_t flags, const opinfo_t *ti, asize_t nbytes)` | `idaman bool ida_export define_stkvar(func_t *pfn, const char *name, sval_t off, const tinfo_t &tif, const struct value_repr_t *repr=nullptr)` |
| `idaman void ida_export build_stkvar_xrefs(xreflist_t *out, func_t *pfn, const member_t *mptr)`                                        | `idaman void ida_export build_stkvar_xrefs(xreflist_t *out, func_t *pfn, uval_t start_offset, uval_t end_offset)`                              |

### Removed APIs

* `get_frame_member_by_id(qstring *out_mname, struc_t **out_fptr, tid_t mid)`
* `get_stkvar(sval_t *actval, const insn_t &insn, const op_t &x, sval_t v)` See get\_stkvar in ida\_typeinf.tinfo\_t
* `get_min_spd_ea(func_t *pfn)`
* `delete_unreferenced_stkvars(func_t *pfn)`
* `delete_wrong_stkvar_ops(func_t *pfn)`

## funcs.hpp

### Added APIs

* `bool func_item_iterator_t::set_ea(ea_t _ea)`

### Removed APIs

* `save_signatures(void)`
* `invalidate_sp_analysis(func_t *pfn)`
* `invalidate_sp_analysis(ea_t ea)`

## gdl.hpp

### Added classes/structures

* `struct edge_t`
* `class node_ordering_t`

## hexrays.hpp

### Added classes/structures

* `class control_graph_t`
* `class edge_mapper_t`
* `class node_bitset_t`
* `class array_of_node_bitset_t`
* `struct ctry_t`
* `struct cthrow_t`
* `struct catchexpr_t`
* `struct ccatch_t`
* `struct cblock_pos_t`

### Added APIs

* `uvlr_t max_vlr_value(int size)`
* `uvlr_t min_vlr_svalue(int size)`
* `uvlr_t max_vlr_svalue(int size)`
* `bool is_unsigned_cmpop(cmpop_t cmpop)`
* `bool is_signed_cmpop(cmpop_t cmpop)`
* `bool is_cmpop_with_eq(cmpop_t cmpop)`
* `bool is_cmpop_without_eq(cmpop_t cmpop)`

#### lvar\_t

* `bool was_scattered_arg() const`
* `void set_scattered_arg()`
* `void clr_scattered_arg()`

#### lvars\_t

* `int find_input_reg(int reg, int _size=1)`

#### simple\_graph\_t

* `virtual bool ignore_edge(int /*src*/, int /*dst*/ ) const`
* `void hexapi compute_dominators(array_of_node_bitset_t &domin, bool post=false) const`
* `void hexapi compute_immediate_dominators(const array_of_node_bitset_t &domin, intvec_t &idomin, bool post=false) const`
* `int hexapi depth_first_preorder(node_ordering_t *pre) const`
* `int hexapi depth_first_postorder(node_ordering_t *post) const`
* `void depth_first_postorder(node_ordering_t *post, edge_mapper_t *et) const`
* `void depth_first_postorder_for_all_entries(node_ordering_t *post) const`
* `intvec_t find_dead_nodes() const`
* `void find_reaching_nodes(int n, node_bitset_t &reaching) const`
* `bool path_exists(int m, int n) const`
* `bool path_back(const array_of_node_bitset_t &domin, int m, int n) const`
* `bool path_back(const edge_mapper_t &et, int m, int n) const`
* `iterator begin() const`
* `iterator end()`
* `int front()`
* `void inc(iterator &p, int n=1) const`
* `virtual int hexapi goup(int node) const`

#### fnumber\_t

* `int calc_max_exp() const`
* `bool is_nan() const`

#### minsn\_t

* `bool was_unpaired() const`

#### mba\_t

* `mblock_t *hexapi split_block(mblock_t *blk, minsn_t *start_insn)`
* `merror_t hexapi inline_func(codegen_t &cdg, int blknum, mba_ranges_t &ranges, int decomp_flags=0, int inline_flags=0)`
* `const stkpnt_t *hexapi locate_stkpnt(ea_t ea) const`

#### codegen\_t

* `void hexapi clear()`

#### vd\_failure\_t

* `virtual const char *what() const noexcept override`

### Modified APIs

| In 8.4                                                                                                       | In 9.0                                                                                                      |
| ------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |
| `void hexapi save_user_labels2(ea_t func_ea, const user_labels_t *user_labels, const cfunc_t *func=nullptr)` | `void hexapi save_user_labels(ea_t func_ea, const user_labels_t *user_labels, const cfunc_t *func=nullptr)` |
| `user_labels_t *hexapi restore_user_labels2(ea_t func_ea, const cfunc_t *func=nullptr)`                      | `user_labels_t *hexapi restore_user_labels(ea_t func_ea, const cfunc_t *func=nullptr)`                      |

#### stkvar\_ref\_t

| In 8.4                                                     | In 9.0                                                                       |
| ---------------------------------------------------------- | ---------------------------------------------------------------------------- |
| `member_t *hexapi get_stkvar(uval_t *p_off=nullptr) const` | `ssize_t hexapi get_stkvar(udm_t *udm=nullptr, uval_t *p_off=nullptr) const` |

#### mop\_t

| In 8.4                                      | In 9.0                                                                |
| ------------------------------------------- | --------------------------------------------------------------------- |
| `member_t *get_stkvar(uval_t *p_off) const` | `ssize_t get_stkvar(udm_t *udm=nullptr, uval_t *p_off=nullptr) const` |

#### mba\_t

| In 8.4                                                       | In 9.0                                                                         |
| ------------------------------------------------------------ | ------------------------------------------------------------------------------ |
| `member_t *get_stkvar(sval_t vd_stkoff, uval_t *poff) const` | `ssize_t get_stkvar(udm_t *udm, sval_t vd_stkoff, uval_t *poff=nullptr) const` |
| `const mblock_t *get_mblock(int n) const`                    | `const mblock_t *get_mblock(uint n) const`                                     |
| `mblock_t *get_mblock(int n)`                                | `mblock_t *get_mblock(uint n)`                                                 |
| `bool hexapi combine_blocks()`                               | `bool hexapi merge_blocks()`                                                   |

#### valrng\_t

| In 8.4                                                          | In 9.0                                                       |
| --------------------------------------------------------------- | ------------------------------------------------------------ |
| `bool cvt_to_cmp(cmpop_t *cmp, uvlr_t *val, bool strict) const` | `bool valrng_t::cvt_to_cmp(cmpop_t *cmp, uvlr_t *val) const` |

### Removed APIs:

* `bool hexapi get_member_type(const member_t *mptr, tinfo_t *type)`
* `bool hexapi checkout_hexrays_license(bool silent)`
* `bool get_member_type(const member_t *mptr, tinfo_t *type)`

#### valrng\_t

* `static uvlr_t max_value(int size_)`
* `static uvlr_t min_svalue(int size_)`
* `static uvlr_t max_svalue(int size_)`

#### ctree\_item\_t

* `member_t *hexapi get_memptr(struc_t **p_sptr=nullptr) const`

#### ctree\_parentee\_t

* `cblock_t *get_block()`

#### vdui\_t

* `bool hexapi set_strmem_type(struc_t *sptr, member_t *mptr)`
* `bool hexapi rename_strmem(struc_t *sptr, member_t *mptr)`

## graph.hpp

### Removed classes/structures

* `class node_ordering_t` See [`code`](#gdlhpp)
* `struct edge_t` See [`code`](#gdlhpp)

### Modified classes/structures

| In 8.4                   | In 9.0                      |
| ------------------------ | --------------------------- |
| `class abstract_graph_t` | `class drawable_graph_t`    |
| `class mutable_graph_t`  | `class interactive_graph_t` |

### Modified APIs

| In 8.4                                                                      | In 9.0                                                                       |
| --------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| `mutable_graph_t *idaapi create_mutable_graph(uval_t id)`                   | `interactive_graph_t *idaapi create_interactive_graph(uval_t id)`            |
| `mutable_graph_t *idaapi create_disasm_graph(ea_t ea)`                      | `interactive_graph_t *idaapi create_disasm_graph(ea_t ea)`                   |
| `mutable_graph_t *idaapi create_disasm_graph(const rangevec_t &ranges)`     | `interactive_graph_t *idaapi create_disasm_graph(const rangevec_t &ranges)`  |
| `mutable_graph_t *idaapi get_viewer_graph(graph_viewer_t *gv)`              | `interactive_graph_t *idaapi get_viewer_graph(graph_viewer_t *gv)`           |
| `void idaapi set_viewer_graph(graph_viewer_t *gv, mutable_graph_t *g)`      | `void idaapi set_viewer_graph(graph_viewer_t *gv, interactive_graph_t *g)`   |
| `void idaapi delete_mutable_graph(mutable_graph_t *g)`                      | `void idaapi delete_interactive_graph(interactive_graph_t *g)`               |
| `void idaapi mutable_graph_t::del_custom_layout(void)`                      | `void idaapi interactive_graph_t::del_custom_layout(void)`                   |
| `void idaapi mutable_graph_t::set_custom_layout(void) const`                | `void idaapi interactive_graph_t::set_custom_layout(void) const`             |
| `void idaapi mutable_graph_t::set_graph_groups(void) const`                 | `void idaapi interactive_graph_t::set_graph_groups(void) const`              |
| `void idaapi mutable_graph_t::clear(void)`                                  | `void idaapi interactive_graph_t::clear(void)`                               |
| `bool idaapi mutable_graph_t::create_digraph_layout(void)`                  | `bool idaapi interactive_graph_t::create_digraph_layout(void)`               |
| `bool idaapi abstract_graph_t::create_tree_layout(void)`                    | `bool idaapi drawable_graph_t::create_tree_layout(void)`                     |
| `bool idaapi abstract_graph_t::create_circle_layout(point_t c, int radius)` | `bool idaapi drawable_graph_t::create_circle_layout(point_t c, int radius)`  |
| `int idaapi mutable_graph_t::get_node_representative(int node)`             | `int idaapi interactive_graph_t::get_node_representative(int node)`          |
| `int idaapi mutable_graph_t::_find_subgraph_node(int gr, int n) const`      | `int idaapi interactive_graph_t::_find_subgraph_node(int gr, int n) const`   |
| `int idaapi mutable_graph_t::create_group(const intvec_t &_nodes)`          | `int idaapi interactive_graph_t::create_group(const intvec_t &_nodes)`       |
| `bool idaapi mutable_graph_t::get_custom_layout(void)`                      | `bool idaapi interactive_graph_t::get_custom_layout(void)`                   |
| `bool idaapi mutable_graph_t::get_graph_groups(void)`                       | `bool idaapi interactive_graph_t::get_graph_groups(void)`                    |
| `bool idaapi mutable_graph_t::empty(void) const`                            | `bool idaapi interactive_graph_t::empty(void) const`                         |
| `bool idaapi mutable_graph_t::is_visible_node(int node) const`              | `bool idaapi interactive_graph_t::is_visible_node(int node) const`           |
| `bool idaapi mutable_graph_t::delete_group(int group)`                      | `bool idaapi interactive_graph_t::delete_group(int group)`                   |
| `bool idaapi mutable_graph_t::change_group_visibility(int gr, bool exp)`    | `bool idaapi interactive_graph_t::change_group_visibility(int gr, bool exp)` |
| `bool idaapi mutable_graph_t::set_edge(edge_t e, const edge_info_t *ei)`    | `bool idaapi interactive_graph_t::set_edge(edge_t e, const edge_info_t *ei)` |
| `int idaapi mutable_graph_t::node_qty(void) const`                          | `int idaapi interactive_graph_t::node_qty(void) const`                       |
| `rect_t &idaapi mutable_graph_t::nrect(int n)`                              | `rect_t &idaapi interactive_graph_t::nrect(int n)`                           |

## idalib.hpp

The new header for the IDA library

### Added APIs

* `idaman int ida_export init_library(int argc = 0, char *argv[] = nullptr)`
* `idaman int ida_export open_database(const char *file_path, bool run_auto)`
* `idaman void ida_export close_database(bool save)`

## idd.hpp

### Added APIs

* `idaman int ida_export cpu2ieee(fpvalue_t *ieee_out, const void *cpu_fpval, int size)`
* `idaman int ida_export ieee2cpu(void *cpu_fpval, const fpvalue_t &ieee_out, int size)`

## idp.hpp

### Removed APIs:

* `processor_t::has_realcvt(void) const`

### Modified APIs:

| In 8.4                                                                                            | In 9.0                                                                                                     |
| ------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| `static ssize_t processor_t::gen_stkvar_def(outctx_t &ctx, const class member_t *mptr, sval_t v)` | `static ssize_t processor_t::gen_stkvar_def(outctx_t &ctx, const struct udm_t *mptr, sval_t v, tid_t tid)` |

### Added APIs

#### procmod\_t

* `const op_t *procmod_t::make_op_reg(op_t *op, int reg, int8 dtype = -1) const`
* `const op_t *procmod_t::make_op_imm(op_t *op, uval_t val, int8 dtype = -1) const`
* `const op_t *procmod_t::make_op_displ(op_t *op, int base_reg, uval_t displ, int8 dtype = -1) const`
* `const op_t *procmod_t::make_op_phrase(op_t *op, int base_reg, int index_reg, int8 dtype = -1) const`

See also [IDB events](#idb-events) for a table providing a list a event replacement and removal.

## kernwin.hpp

### Removed APIs

* `open_enums_window(tid_t const_id=BADADDR)`
* `open_structs_window(tid_t id=BADADDR, uval_t offset=0)`
* `choose_struc(const char *title)`
* `choose_enum_by_value(const char *title, enum_t default_id, uint64 value, int nbytes, uchar *serial)`

### Removed classes/structures

* `class enumplace_t`
* `class structplace_t`

### Added APIs

* `bool is_ida_library(char *path, size_t pathsize, void** handle)`

#### tagged\_line\_section\_t

* `const tagged_line_section_t::tagged_line_section_t *nearest_before(const tagged_line_section_t &range, cpidx_t start, color_t tag=0) const`
* `const tagged_line_section_t::tagged_line_section_t *nearest_after(const tagged_line_section_t &range, cpidx_t start, color_t tag=0) const`

#### chooser\_base\_t

* `bool chooser_base_t::has_widget_lifecycle() const`

### Modified APIs

| In 8.4                                                                      | In 9.0                                                                                                                  |
| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `ea_t choose_stkvar_xref(func_t *pfn, member_t *mptr)`                      | `ea_t choose_stkvar_xref(func_t *pfn, tid_t srkvar_tid)`                                                                |
| `bool tagged_line_section_t::substr(qstring *out, const qstring &in) const` | `bool tagged_line_section_t::substr(qstring *out,,const qstring &in, const tagged_line_section_t *end = nullptr) const` |

## lex.hpp

### Modified APIs

| In 8.4                                                                                            | In 9.0                                                                                                                  |
| ------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `idaman lexer_t *ida_export create_lexer(const char *const *keys, size_t size, void *ud=nullptr)` | `idaman lexer_t *ida_export create_lexer(const char *const *keys, size_t size, void *ud=nullptr, uint32 macro_flags=0)` |

## lines.hpp

### Removed APIs

* `set_user_defined_prefix(size_t width, void (idaapi *get_user_defined_prefix)(qstring *buf, ea_t ea, int lnnum, int indent, const char *line))`

### Modified APIs

| In 8.4                                                                        | In 9.0                                                                        |
| ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| `idaman void ida_export update_extra_cmt(ea_t ea, int what, const char *str)` | `idaman bool ida_export update_extra_cmt(ea_t ea, int what, const char *str)` |
| `idaman void ida_export del_extra_cmt(ea_t ea, int what)`                     | `idaman bool ida_export del_extra_cmt(ea_t ea, int what)`                     |

## nalt.hpp

### Modified APIs

| In 8.4                                                      | In 9.0                                                     |
| ----------------------------------------------------------- | ---------------------------------------------------------- |
| `idaman int ida_export validate_idb_names2(bool do_repair)` | `idaman int ida_export validate_idb_names(bool do_repair)` |

## parsejson.hpp

### Added APIs

#### jvalue\_t

* `void jvalue_t::set_str(const char *s)`

#### jobj\_t

* `void jobj_t::put(const char *key, const jobj_t &value)`

## pro.h

### Removed APIs

* `unpack_memory(void *buf, size_t size, const uchar **pptr, const uchar *end)`

### Added APIs

* `idaman THREAD_SAFE bool ida_export get_login_name(qstring *out)`
* `idaman void *ida_export pipe_process(qhandle_t *read_handle, qhandle_t *write_handle, launch_process_params_t *lpp, qstring *errbuf=nullptr)`

#### bytevec\_t

* `qstring bytevec_t::tohex(bool upper_case=true) const`

#### qlist

* `void qlist::splice(iterator pos, qlist &other, iterator first, iterator last)`

### Added classes/structures

* `struct memory_serializer_t`

## regex.hpp

### Removed APIs

* `regcomp(struct regex_t *preg, const char *pattern, int cflags)`
* `regerror(int errcode, const struct regex_t *preg, char *errbuf, size_t errbuf_size)`
* `regexec(const struct regex_t *preg, const char *str, size_t nmatch, struct regmatch_t pmatch[], int eflags)`
* `regfree(struct regex_t *preg)`

## regfinder.hpp

### Modified APIs

| In 8.4                                                                                                                                          | In 9.0                                                                                                                                                         |
| ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `void ida_export reg_finder_invalidate_cache(reg_finder_t *_this, ea_t ea)`                                                                     | `void ida_export reg_finder_invalidate_cache(reg_finder_t *_this, ea_t to, ea_t from)`                                                                         |
| `bool ida_export reg_finder_calc_op_addr(reg_finder_t *_this, reg_value_info_t *addr, const op_t *memop, const insn_t *insn, ea_t ea, ea_t ds)` | `bool ida_export reg_finder_calc_op_addr(reg_finder_t *_this, reg_value_info_t *addr, const op_t *memop, const insn_t *insn, ea_t ea, ea_t ds, int max_depth)` |
| `bool ida_export reg_finder_may_modify_stkvars(const reg_finder_t *_this, reg_finder_op_t op, const insn_t *insn)`                              | `bool ida_export reg_finder_may_modify_stkvar(const reg_finder_t *_this, reg_finder_op_t op, const insn_t *insn)`                                              |
| `void idaapi invalidate_regfinder_cache(ea_t ea = BADADDR)`                                                                                     | `void idaapi invalidate_regfinder_cache(ea_t to = BADADDR, ea_t from = BADADDR)`                                                                               |

### Removed APIs

* `reg_finder_op_make_rfop(func_t *pfn, const insn_t &insn, const op_t &op)`

### Added APIs

* `void reg_value_info_t::movt(const reg_value_info_t &r, const insn_t &insn)`
* `static int reg_finder_op_t::get_op_width(const op_t &op)`
* `static reg_finder_op_t reg_finder_op_t::make_stkoff(sval_t stkoff, int width)`

## registry.hpp

### Removed APIs

* `reg_load(void)`
* `reg_flush(void)`

## search.hpp

### Removed APIs

* `user2bin(uchar *, uchar *, ea_t, const char *, int, bool)`
* `find_binary(ea_t, ea_t, const char *, int, int)`

## typeinf.hpp

### Removed APIs

* `set_numbered_type(til_t *ti, uint32 ordinal, int ntf_flags, const char *name, const type_t *type, const p_list *fields=nullptr, const char *cmt=nullptr, const p_list *fldcmts=nullptr, const sclass_t *sclass=nullptr)`
* `get_ordinal_from_idb_type(const char *name, const type_t *type)`
* `is_autosync(const char *name, const type_t *type)`
* `is_autosync(const char *name, const tinfo_t &tif)`
* `import_type(const til_t *til, int idx, const char *name, int flags=0)`
* `get_udm_tid(const udm_t *udm, const char *udt_name)`

### Modified APIs

| In 8.4                                                                                                                                                       | In 9.0                                                                                                                                                      |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `bool ida_export create_tinfo2(tinfo_t *_this, type_t bt, type_t bt2, void *ptr)`                                                                            | `bool ida_export create_tinfo(tinfo_t *_this, type_t bt, type_t bt2, void *ptr)`                                                                            |
| `int ida_export verify_tinfo(uint32 typid)`                                                                                                                  | `int ida_export verify_tinfo(typid_t typid)`                                                                                                                |
| `bool ida_export get_tinfo_details2(uint32 typid, type_t bt2, void *buf)`                                                                                    | `bool ida_export get_tinfo_details(typid_t typid, type_t bt2, void *buf)`                                                                                   |
| `size_t ida_export get_tinfo_size(uint32 *p_effalign, uint32 typid, int gts_code)`                                                                           | `size_t ida_export get_tinfo_size(uint32 *p_effalign, typid_t typid, int gts_code)`                                                                         |
| `size_t ida_export get_tinfo_pdata(void *outptr, uint32 typid, int what)`                                                                                    | `size_t ida_export get_tinfo_pdata(void *outptr, typid_t typid, int what)`                                                                                  |
| `size_t ida_export get_tinfo_property(uint32 typid, int gta_prop)`                                                                                           | `size_t ida_export get_tinfo_property(typid_t typid, int gta_prop)`                                                                                         |
| `size_t ida_export get_tinfo_property4(uint32 typid, int gta_prop, size_t p1, size_t p2, size_t p3, size_t p4)`                                              | `size_t ida_export get_tinfo_property4(typid_t typid, int gta_prop, size_t p1, size_t p2, size_t p3, size_t p4)`                                            |
| `bool ida_export deserialize_tinfo2(tinfo_t *tif, const til_t *til, const type_t **ptype, const p_list **pfields, const p_list **pfldcmts, const char *cmt)` | `bool ida_export deserialize_tinfo(tinfo_t *tif, const til_t *til, const type_t **ptype, const p_list **pfields, const p_list **pfldcmts, const char *cmt)` |
| `int ida_export find_tinfo_udt_member(udm_t *udm, uint32 typid, int strmem_flags)`                                                                           | `int ida_export find_tinfo_udt_member(udm_t *udm, typid_t typid, int strmem_flags)`                                                                         |
| `bool ida_export compare_tinfo(uint32 t1, uint32 t2, int tcflags)`                                                                                           | `bool ida_export compare_tinfo(typid_t t1, typid_t t2, int tcflags)`                                                                                        |
| `int ida_export lexcompare_tinfo(uint32 t1, uint32 t2, int)`                                                                                                 | `int ida_export lexcompare_tinfo(typid_t t1, typid_t t2, int)`                                                                                              |
| `uint64 ida_export read_tinfo_bitfield_value(uint32 typid, uint64 v, int bitoff)`                                                                            | `uint64 ida_export read_tinfo_bitfield_value(typid_t typid, uint64 v, int bitoff)`                                                                          |
| `uint64 ida_export write_tinfo_bitfield_value(uint32 typid, uint64 dst, uint64 v, int bitoff)`                                                               | `uint64 ida_export write_tinfo_bitfield_value(typid_t typid, uint64 dst, uint64 v, int bitoff)`                                                             |
| `bool ida_export get_tinfo_attr(uint32 typid, const qstring &key, bytevec_t *bv, bool all_attrs)`                                                            | `bool ida_export get_tinfo_attr(typid_t typid, const qstring &key, bytevec_t *bv, bool all_attrs)`                                                          |
| `bool ida_export get_tinfo_attrs(uint32 typid, type_attrs_t *tav, bool include_ref_attrs)`                                                                   | `bool ida_export get_tinfo_attrs(typid_t typid, type_attrs_t *tav, bool include_ref_attrs)`                                                                 |
| `bool ida_export append_tinfo_covered(rangeset_t *out, uint32 typid, uint64 offset)`                                                                         | `bool ida_export append_tinfo_covered(rangeset_t *out, typid_t typid, uint64 offset)`                                                                       |
| `bool ida_export calc_tinfo_gaps(rangeset_t *out, uint32 typid)`                                                                                             | `bool ida_export calc_tinfo_gaps(rangeset_t *out, typid_t typid)`                                                                                           |
| `bool ida_export name_requires_qualifier(qstring *out, uint32 typid, const char *name, uint64 offset)`                                                       | `bool ida_export name_requires_qualifier(qstring *out, typid_t typid, const char *name, uint64 offset)`                                                     |
| `void ida_export tinfo_get_innermost_udm(tinfo_t *itif, const tinfo_t *tif, uint64 offset, size_t *udm_idx, uint64 *bit_offset)`                             | `void ida_export tinfo_get_innermost_udm(tinfo_t *itif, const tinfo_t *tif, uint64 offset, size_t *udm_idx, uint64 *bit_offset, bool return_member_type)`   |
| `tinfo_code_t tinfo_t::find_edm(edm_t *edm, uint64 value, bmask64_t bmask=DEFMASK64, uchar serial=0) const`                                                  | `ssize_t tinfo_t::find_edm(edm_t *edm, uint64 value, bmask64_t bmask=DEFMASK64, uchar serial=0) const`                                                      |
| `tinfo_code_t tinfo_t::find_edm(edm_t *edm, const char *name) const`                                                                                         | `ssize_t tinfo_t::find_edm(edm_t *edm, const char *name) const`                                                                                             |
| `bool tinfo_t::get_type_by_edm_name(const char *mname, til_t *til=nullptr)`                                                                                  | `ssize_t tinfo_t::get_edm_by_name(const char *mname, const til_t *til=nullptr)`                                                                             |
| `void ida_export gen_use_arg_tinfos2(struct argtinfo_helper_t *_this, ea_t caller, func_type_data_t *fti, funcargvec_t *rargs)`                              | `void ida_export gen_use_arg_tinfos(struct argtinfo_helper_t *_this, ea_t caller, func_type_data_t *fti, funcargvec_t *rargs)`                              |

### Added classes/structures

* `struct udm_visitor_t`

### Added APIs

* `bool ida_export detach_tinfo_t(tinfo_t *_this)`
* `bool stroff_as_size(int plen, const tinfo_t &tif, asize_t value)`
* `int ida_export visit_stroff_udms(udm_visitor_t &sfv, const tid_t *path, int plen, adiff_t *disp, bool appzero)`
* `bool is_one_bit_mask(uval_t mask)`

#### til\_t

* `til_t *til_t::find_base(const char *n)`

#### callregs\_t

* `void callregs_t::set_registers(reg_kind_t kind, int first_reg, int last_reg)`

#### tinfo\_t

* `bool tinfo_t::get_named_type(const char *name, type_t decl_type=BTF_TYPEDEF, bool resolve=true, bool try_ordinal=true)`
* `bool tinfo_t::get_numbered_type(uint32 ordinal, type_t decl_type=BTF_TYPEDEF, bool resolve=true)`
* `bool tinfo_t::detach()`
* `bool tinfo_t::is_punknown()`
* `int tinfo_t::find_udm(uint64 offset, int strmem_flags=0) const`
* `int tinfo_t::find_udm(const char *name, int strmem_flags=0) const`
* `size_t tinfo_t::get_enum_nmembers() const`
* `bool tinfo_t::is_empty_enum() const`
* `tinfo_code_t tinfo_t::get_enum_repr(value_repr_t *repr) const`
* `int tinfo_t::get_enum_width() const`
* `uint64 tinfo_t::calc_enum_mask() const`
* `tid_t tnfo_t::get_edm_tid(size_t idx) const`
* `tinfo_t tinfo_t::get_innermost_member_type(uint64 bitoffset, uint64 *out_bitoffset=nullptr) const`
* `bool tinfo_t::is_udm_by_til(size_t idx) const`
* `tinfo_code_t tinfo_t::set_udm_by_til(size_t idx, bool on=true, uint etf_flags=0)`
* `tinfo_code_t tinfo_t::set_fixed_struct(bool on=true)`
* `tinfo_code_t tinfo_t::set_struct_size(size_t new_size)`
* `bool tinfo_t::is_fixed_struct() const`
* `bool tinfo_t::get_func_frame(const func_t *pfn)`
* `bool tinfo_t::is_frame() const`
* `ea_t tinfo_t::get_frame_func() const`
* `ssize_t tinfo_t::get_stkvar(sval_t *actval, const insn_t &insn, const op_t *x, sval_t v)`
* `tinfo_code_t tinfo_t::set_enum_radix(int radix, bool sign, uint etf_flags=0)`
* `tinfo_code_t tinfo_t::set_funcarg_type(size_t index, const tinfo_t &tif, uint etf_flags=0)`
* `tinfo_code_t tinfo_t::set_func_rettype(const tinfo_t &tif, uint etf_flags=0)`
* `tinfo_code_t tinfo_t::del_funcargs(size_t idx1, size_t idx2, uint etf_flags=0)`
* `tinfo_code_t tinfo_t::del_funcarg(size_t idx, uint etf_flags=0)`
* `tinfo_code_t tinfo_t::add_funcarg(const funcarg_t &farg, uint etf_flags=0, ssize_t idx=-1)`
* `tinfo_code_t tinfo_t::set_func_cc(cm_t cc, uint etf_flags=0)`
* `tinfo_code_t tinfo_t::set_funcarg_loc(size_t index, const argloc_t &argloc, uint etf_flags=0)`
* `tinfo_code_t tinfo_t::et_func_retloc(const argloc_t &argloc, uint etf_flags=0)`

#### func\_type\_data\_t

* `ssize_t func_type_data_t::find_argument(const char *name, size_t from=0, size_t to=size_t(-1)) const`

#### enum\_type\_data\_t

* `tinfo_code_t enum_type_data_t::get_value_repr(value_repr_t *repr) const`
* `uchar enum_type_data_t::get_serial(size_t index) const`
* `uchar enum_type_data_t::get_max_serial(uint64 value) const`

#### udm\_t

* `bool udm_t::is_retaddr() const`
* `bool udm_t::is_savregs() const`
* `bool udm_t::is_special_member() const`
* `bool udm_t::is_by_til() const`
* `void udm_t::set_retaddr(bool on=true)`
* `void udm_t::set_savregs(bool on=true)`
* `void udm_t::set_by_til(bool on=true)`

#### udt\_type\_data\_t

* `bool udt_type_data_t::is_fixed() const`
* `void udt_type_data_t::set_fixed(bool on=true)`

## IDB events

The following table provide a list of IDB events that have been replaced or, in some cases, removed.

| Since 7                 | In 9.0                                                   |
| ----------------------- | -------------------------------------------------------- |
| `truc_created`          | `local_types_changed`                                    |
| `deleting_struc`        | **none**                                                 |
| `struc_deleted`         | `local_types_changed`                                    |
| `changing_struc_align`  | **none**                                                 |
| `struc_align_changed`   | `local_types_changed`                                    |
| `renaming_struc`        | **none**                                                 |
| `struc_renamed`         | `local_types_changed`                                    |
| `expanding_struc`       | **none**                                                 |
| `struc_expanded`        | `lt_udt_expanded, frame_expanded, local_types_changed`   |
| `struc_member_created`  | `lt_udm_created, frame_udm_created, local_types_changed` |
| `deleting_struc_member` | **none**                                                 |
| `struc_member_deleted`  | `lt_udm_deleted, frame_udm_deleted, local_types_changed` |
| `renaming_struc_member` | **none**                                                 |
| `struc_member_renamed`  | `lt_udm_renamed, frame_udm_renamed, local_types_changed` |
| `changing_struc_member` | **none**                                                 |
| `struc_member_changed`  | `lt_udm_changed, frame_udm_changed, local_types_changed` |
| `changing_struc_cmt`    | **none**                                                 |
| `struc_cmt_changed`     | `local_types_changed`                                    |
| `enum_created`          | `local_types_changed`                                    |
| `deleting_enum`         | **none**                                                 |
| `enum_deleted`          | `local_types_changed`                                    |
| `renaming_enum`         | **none**                                                 |
| `enum_renamed`          | `local_types_changed`                                    |
| `changing_enum_bf`      | `local_types_changed`                                    |
| `enum_bf_changed`       | `local_types_changed`                                    |
| `changing_enum_cmt`     | **none**                                                 |
| `enum_cmt_changed`      | `local_types_changed`                                    |
| `enum_member_created`   | `local_types_changed`                                    |
| `deleting_enum_member`  | **none**                                                 |
| `enum_member_deleted`   | `local_types_changed`                                    |
| `enum_width_changed`    | `local_types_changed`                                    |
| `enum_flag_changed`     | `local_types_changed`                                    |
| `enum_ordinal_changed`  | **none**                                                 |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hex-rays.com/9.0sp1/developer-guide/c++-sdk/c++-sdk-porting-guide-ida-9.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.