# C++ SDK 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**                                                 |