X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Frx-tdep.c;h=2a24ebba2b60312df3224ab3ad1a0f5ffaa43856;hb=ea764154c27a11619ba764a4c92f395ba5007234;hp=94d57913a316e18d5df6410138d981a40fd5d6a6;hpb=e2882c85786571175a0b0bfc3bcd2f14620b1ea3;p=binutils-gdb.git diff --git a/gdb/rx-tdep.c b/gdb/rx-tdep.c index 94d57913a31..2a24ebba2b6 100644 --- a/gdb/rx-tdep.c +++ b/gdb/rx-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for the Renesas RX for GDB, the GNU debugger. - Copyright (C) 2008-2018 Free Software Foundation, Inc. + Copyright (C) 2008-2022 Free Software Foundation, Inc. Contributed by Red Hat, Inc. @@ -32,12 +32,17 @@ #include "frame-base.h" #include "value.h" #include "gdbcore.h" -#include "dwarf2-frame.h" +#include "dwarf2/frame.h" +#include "remote.h" +#include "target-descriptions.h" +#include "gdbarch.h" #include "elf/rx.h" #include "elf-bfd.h" #include +#include "features/rx.c" + /* Certain important register numbers. */ enum { @@ -64,16 +69,16 @@ enum rx_frame_type { }; /* Architecture specific data. */ -struct gdbarch_tdep +struct rx_gdbarch_tdep : gdbarch_tdep { /* The ELF header flags specify the multilib used. */ - int elf_flags; + int elf_flags = 0; /* Type of PSW and BPSW. */ - struct type *rx_psw_type; + struct type *rx_psw_type = nullptr; /* Type of FPSW. */ - struct type *rx_fpsw_type; + struct type *rx_fpsw_type = nullptr; }; /* This structure holds the results of a prologue analysis. */ @@ -114,117 +119,13 @@ struct rx_prologue int reg_offset[RX_NUM_REGS]; }; -/* Implement the "register_name" gdbarch method. */ -static const char * -rx_register_name (struct gdbarch *gdbarch, int regnr) -{ - static const char *const reg_names[] = { - "r0", - "r1", - "r2", - "r3", - "r4", - "r5", - "r6", - "r7", - "r8", - "r9", - "r10", - "r11", - "r12", - "r13", - "r14", - "r15", - "usp", - "isp", - "psw", - "pc", - "intb", - "bpsw", - "bpc", - "fintv", - "fpsw", - "acc" - }; - - return reg_names[regnr]; -} - -/* Construct the flags type for PSW and BPSW. */ - -static struct type * -rx_psw_type (struct gdbarch *gdbarch) -{ - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - - if (tdep->rx_psw_type == NULL) - { - tdep->rx_psw_type = arch_flags_type (gdbarch, "rx_psw_type", 32); - append_flags_type_flag (tdep->rx_psw_type, 0, "C"); - append_flags_type_flag (tdep->rx_psw_type, 1, "Z"); - append_flags_type_flag (tdep->rx_psw_type, 2, "S"); - append_flags_type_flag (tdep->rx_psw_type, 3, "O"); - append_flags_type_flag (tdep->rx_psw_type, 16, "I"); - append_flags_type_flag (tdep->rx_psw_type, 17, "U"); - append_flags_type_flag (tdep->rx_psw_type, 20, "PM"); - append_flags_type_flag (tdep->rx_psw_type, 24, "IPL0"); - append_flags_type_flag (tdep->rx_psw_type, 25, "IPL1"); - append_flags_type_flag (tdep->rx_psw_type, 26, "IPL2"); - append_flags_type_flag (tdep->rx_psw_type, 27, "IPL3"); - } - return tdep->rx_psw_type; -} - -/* Construct flags type for FPSW. */ - -static struct type * -rx_fpsw_type (struct gdbarch *gdbarch) -{ - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - - if (tdep->rx_fpsw_type == NULL) - { - tdep->rx_fpsw_type = arch_flags_type (gdbarch, "rx_fpsw_type", 32); - append_flags_type_flag (tdep->rx_fpsw_type, 0, "RM0"); - append_flags_type_flag (tdep->rx_fpsw_type, 1, "RM1"); - append_flags_type_flag (tdep->rx_fpsw_type, 2, "CV"); - append_flags_type_flag (tdep->rx_fpsw_type, 3, "CO"); - append_flags_type_flag (tdep->rx_fpsw_type, 4, "CZ"); - append_flags_type_flag (tdep->rx_fpsw_type, 5, "CU"); - append_flags_type_flag (tdep->rx_fpsw_type, 6, "CX"); - append_flags_type_flag (tdep->rx_fpsw_type, 7, "CE"); - append_flags_type_flag (tdep->rx_fpsw_type, 8, "DN"); - append_flags_type_flag (tdep->rx_fpsw_type, 10, "EV"); - append_flags_type_flag (tdep->rx_fpsw_type, 11, "EO"); - append_flags_type_flag (tdep->rx_fpsw_type, 12, "EZ"); - append_flags_type_flag (tdep->rx_fpsw_type, 13, "EU"); - append_flags_type_flag (tdep->rx_fpsw_type, 14, "EX"); - append_flags_type_flag (tdep->rx_fpsw_type, 26, "FV"); - append_flags_type_flag (tdep->rx_fpsw_type, 27, "FO"); - append_flags_type_flag (tdep->rx_fpsw_type, 28, "FZ"); - append_flags_type_flag (tdep->rx_fpsw_type, 29, "FU"); - append_flags_type_flag (tdep->rx_fpsw_type, 30, "FX"); - append_flags_type_flag (tdep->rx_fpsw_type, 31, "FS"); - } - - return tdep->rx_fpsw_type; -} - -/* Implement the "register_type" gdbarch method. */ -static struct type * -rx_register_type (struct gdbarch *gdbarch, int reg_nr) -{ - if (reg_nr == RX_PC_REGNUM) - return builtin_type (gdbarch)->builtin_func_ptr; - else if (reg_nr == RX_PSW_REGNUM || reg_nr == RX_BPSW_REGNUM) - return rx_psw_type (gdbarch); - else if (reg_nr == RX_FPSW_REGNUM) - return rx_fpsw_type (gdbarch); - else if (reg_nr == RX_ACC_REGNUM) - return builtin_type (gdbarch)->builtin_unsigned_long_long; - else - return builtin_type (gdbarch)->builtin_unsigned_long; -} +/* RX register names */ +static const char *const rx_register_names[] = { + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", + "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", + "usp", "isp", "psw", "pc", "intb", "bpsw","bpc","fintv", + "fpsw", "acc", +}; /* Function for finding saved registers in a 'struct pv_area'; this @@ -279,7 +180,7 @@ rx_get_opcode_byte (void *handle) static void rx_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc, - enum rx_frame_type frame_type, + enum rx_frame_type frame_type, struct rx_prologue *result) { CORE_ADDR pc, next_pc; @@ -302,14 +203,14 @@ rx_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc, if (frame_type == RX_FRAME_TYPE_FAST_INTERRUPT) { /* This code won't do anything useful at present, but this is - what happens for fast interrupts. */ + what happens for fast interrupts. */ reg[RX_BPSW_REGNUM] = reg[RX_PSW_REGNUM]; reg[RX_BPC_REGNUM] = reg[RX_PC_REGNUM]; } else { /* When an exception occurs, the PSW is saved to the interrupt stack - first. */ + first. */ if (frame_type == RX_FRAME_TYPE_EXCEPTION) { reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); @@ -317,7 +218,7 @@ rx_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc, } /* The call instruction (or an exception/interrupt) has saved the return - address on the stack. */ + address on the stack. */ reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); stack.store (reg[RX_SP_REGNUM], 4, reg[RX_PC_REGNUM]); @@ -495,7 +396,7 @@ rx_analyze_frame_prologue (struct frame_info *this_frame, stop_addr = get_frame_pc (this_frame); /* If we couldn't find any function containing the PC, then - just initialize the prologue cache, but don't do anything. */ + just initialize the prologue cache, but don't do anything. */ if (!func_start) stop_addr = func_start; @@ -551,7 +452,7 @@ rx_frame_type (struct frame_info *this_frame, void **this_cache) else if (opc.id == RXO_rtfi) return RX_FRAME_TYPE_FAST_INTERRUPT; else if (opc.id == RXO_rte) - return RX_FRAME_TYPE_EXCEPTION; + return RX_FRAME_TYPE_EXCEPTION; pc += bytes_read; } @@ -592,7 +493,7 @@ rx_frame_base (struct frame_info *this_frame, void **this_cache) static void rx_frame_this_id (struct frame_info *this_frame, void **this_cache, - struct frame_id *this_id) + struct frame_id *this_id) { *this_id = frame_id_build (rx_frame_base (this_frame, this_cache), get_frame_func (this_frame)); @@ -602,7 +503,7 @@ rx_frame_this_id (struct frame_info *this_frame, void **this_cache, static struct value * rx_frame_prev_register (struct frame_info *this_frame, void **this_cache, - int regnum) + int regnum) { enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache); struct rx_prologue *p @@ -612,21 +513,21 @@ rx_frame_prev_register (struct frame_info *this_frame, void **this_cache, if (regnum == RX_SP_REGNUM) { if (frame_type == RX_FRAME_TYPE_EXCEPTION) - { + { struct value *psw_val; CORE_ADDR psw; psw_val = rx_frame_prev_register (this_frame, this_cache, - RX_PSW_REGNUM); - psw = extract_unsigned_integer (value_contents_all (psw_val), 4, - gdbarch_byte_order ( - get_frame_arch (this_frame))); + RX_PSW_REGNUM); + psw = extract_unsigned_integer + (value_contents_all (psw_val).data (), 4, + gdbarch_byte_order (get_frame_arch (this_frame))); if ((psw & 0x20000 /* U bit */) != 0) return rx_frame_prev_register (this_frame, this_cache, - RX_USP_REGNUM); + RX_USP_REGNUM); - /* Fall through for the case where U bit is zero. */ + /* Fall through for the case where U bit is zero. */ } return frame_unwind_got_constant (this_frame, regnum, frame_base); @@ -635,11 +536,11 @@ rx_frame_prev_register (struct frame_info *this_frame, void **this_cache, if (frame_type == RX_FRAME_TYPE_FAST_INTERRUPT) { if (regnum == RX_PC_REGNUM) - return rx_frame_prev_register (this_frame, this_cache, - RX_BPC_REGNUM); + return rx_frame_prev_register (this_frame, this_cache, + RX_BPC_REGNUM); if (regnum == RX_PSW_REGNUM) - return rx_frame_prev_register (this_frame, this_cache, - RX_BPSW_REGNUM); + return rx_frame_prev_register (this_frame, this_cache, + RX_BPSW_REGNUM); } /* If prologue analysis says we saved this register somewhere, @@ -668,14 +569,14 @@ static int exception_frame_p (enum rx_frame_type frame_type) { return (frame_type == RX_FRAME_TYPE_EXCEPTION - || frame_type == RX_FRAME_TYPE_FAST_INTERRUPT); + || frame_type == RX_FRAME_TYPE_FAST_INTERRUPT); } /* Common code used by both normal and exception frame sniffers. */ static int rx_frame_sniffer_common (const struct frame_unwind *self, - struct frame_info *this_frame, + struct frame_info *this_frame, void **this_cache, int (*sniff_p)(enum rx_frame_type) ) { @@ -686,15 +587,15 @@ rx_frame_sniffer_common (const struct frame_unwind *self, enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache); if (sniff_p (frame_type)) - { + { /* The call below will fill in the cache, including the frame type. */ (void) rx_analyze_frame_prologue (this_frame, frame_type, this_cache); return 1; - } + } else - return 0; + return 0; } else { @@ -708,28 +609,29 @@ rx_frame_sniffer_common (const struct frame_unwind *self, static int rx_frame_sniffer (const struct frame_unwind *self, - struct frame_info *this_frame, + struct frame_info *this_frame, void **this_cache) { return rx_frame_sniffer_common (self, this_frame, this_cache, - normal_frame_p); + normal_frame_p); } /* Frame sniffer for exception frames. */ static int rx_exception_sniffer (const struct frame_unwind *self, - struct frame_info *this_frame, + struct frame_info *this_frame, void **this_cache) { return rx_frame_sniffer_common (self, this_frame, this_cache, - exception_frame_p); + exception_frame_p); } /* Data structure for normal code using instruction-based prologue analyzer. */ static const struct frame_unwind rx_frame_unwind = { + "rx prologue", NORMAL_FRAME, default_frame_unwind_stop_reason, rx_frame_this_id, @@ -742,6 +644,7 @@ static const struct frame_unwind rx_frame_unwind = { analyzer. */ static const struct frame_unwind rx_exception_unwind = { + "rx exception", /* SIGTRAMP_FRAME could be used here, but backtraces are less informative. */ NORMAL_FRAME, default_frame_unwind_stop_reason, @@ -751,40 +654,12 @@ static const struct frame_unwind rx_exception_unwind = { rx_exception_sniffer }; -/* Implement the "unwind_pc" gdbarch method. */ -static CORE_ADDR -rx_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame) -{ - ULONGEST pc; - - pc = frame_unwind_register_unsigned (this_frame, RX_PC_REGNUM); - return pc; -} - -/* Implement the "unwind_sp" gdbarch method. */ -static CORE_ADDR -rx_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame) -{ - ULONGEST sp; - - sp = frame_unwind_register_unsigned (this_frame, RX_SP_REGNUM); - return sp; -} - -/* Implement the "dummy_id" gdbarch method. */ -static struct frame_id -rx_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) -{ - return - frame_id_build (get_frame_register_unsigned (this_frame, RX_SP_REGNUM), - get_frame_pc (this_frame)); -} - /* Implement the "push_dummy_call" gdbarch method. */ static CORE_ADDR rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, - struct value **args, CORE_ADDR sp, int struct_return, + struct value **args, CORE_ADDR sp, + function_call_return_method return_method, CORE_ADDR struct_addr) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); @@ -796,12 +671,12 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct type *func_type = value_type (function); /* Dereference function pointer types. */ - while (TYPE_CODE (func_type) == TYPE_CODE_PTR) + while (func_type->code () == TYPE_CODE_PTR) func_type = TYPE_TARGET_TYPE (func_type); /* The end result had better be a function or a method. */ - gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC - || TYPE_CODE (func_type) == TYPE_CODE_METHOD); + gdb_assert (func_type->code () == TYPE_CODE_FUNC + || func_type->code () == TYPE_CODE_METHOD); /* Functions with a variable number of arguments have all of their variable arguments and the last non-variable argument passed @@ -814,8 +689,8 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, requiring multiple registers, etc. We rely instead on the value of the ``arg_reg'' variable to get these other details correct. */ - if (TYPE_VARARGS (func_type)) - num_register_candidate_args = TYPE_NFIELDS (func_type) - 1; + if (func_type->has_varargs ()) + num_register_candidate_args = func_type->num_fields () - 1; else num_register_candidate_args = 4; @@ -830,12 +705,12 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, sp = align_down (sp - sp_off, 4); sp_off = 0; - if (struct_return) + if (return_method == return_method_struct) { struct type *return_type = TYPE_TARGET_TYPE (func_type); - gdb_assert (TYPE_CODE (return_type) == TYPE_CODE_STRUCT - || TYPE_CODE (func_type) == TYPE_CODE_UNION); + gdb_assert (return_type->code () == TYPE_CODE_STRUCT + || func_type->code () == TYPE_CODE_UNION); if (TYPE_LENGTH (return_type) > 16 || TYPE_LENGTH (return_type) % 4 != 0) @@ -850,24 +725,25 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, for (i = 0; i < nargs; i++) { struct value *arg = args[i]; - const gdb_byte *arg_bits = value_contents_all (arg); + const gdb_byte *arg_bits = value_contents_all (arg).data (); struct type *arg_type = check_typedef (value_type (arg)); ULONGEST arg_size = TYPE_LENGTH (arg_type); - if (i == 0 && struct_addr != 0 && !struct_return - && TYPE_CODE (arg_type) == TYPE_CODE_PTR + if (i == 0 && struct_addr != 0 + && return_method != return_method_struct + && arg_type->code () == TYPE_CODE_PTR && extract_unsigned_integer (arg_bits, 4, byte_order) == struct_addr) { /* This argument represents the address at which C++ (and - possibly other languages) store their return value. - Put this value in R15. */ + possibly other languages) store their return value. + Put this value in R15. */ if (write_pass) regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM, struct_addr); } - else if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT - && TYPE_CODE (arg_type) != TYPE_CODE_UNION + else if (arg_type->code () != TYPE_CODE_STRUCT + && arg_type->code () != TYPE_CODE_UNION && arg_size <= 8) { /* Argument is a scalar. */ @@ -877,8 +753,8 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, && arg_reg <= RX_R4_REGNUM - 1) { /* If argument registers are going to be used to pass - an 8 byte scalar, the ABI specifies that two registers - must be available. */ + an 8 byte scalar, the ABI specifies that two registers + must be available. */ if (write_pass) { regcache_cooked_write_unsigned (regcache, arg_reg, @@ -922,11 +798,11 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { int p_arg_size = 4; - if (TYPE_PROTOTYPED (func_type) - && i < TYPE_NFIELDS (func_type)) + if (func_type->is_prototyped () + && i < func_type->num_fields ()) { struct type *p_arg_type = - TYPE_FIELD_TYPE (func_type, i); + func_type->field (i).type (); p_arg_size = TYPE_LENGTH (p_arg_type); } @@ -943,7 +819,7 @@ rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, else { /* Argument is a struct or union. Pass as much of the struct - in registers, if possible. Pass the rest on the stack. */ + in registers, if possible. Pass the rest on the stack. */ while (arg_size > 0) { if (i < num_register_candidate_args @@ -1001,8 +877,8 @@ rx_return_value (struct gdbarch *gdbarch, ULONGEST valtype_len = TYPE_LENGTH (valtype); if (TYPE_LENGTH (valtype) > 16 - || ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT - || TYPE_CODE (valtype) == TYPE_CODE_UNION) + || ((valtype->code () == TYPE_CODE_STRUCT + || valtype->code () == TYPE_CODE_UNION) && TYPE_LENGTH (valtype) % 4 != 0)) return RETURN_VALUE_STRUCT_CONVENTION; @@ -1069,8 +945,9 @@ static struct gdbarch * rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { struct gdbarch *gdbarch; - struct gdbarch_tdep *tdep; int elf_flags; + tdesc_arch_data_up tdesc_data; + const struct target_desc *tdesc = info.target_desc; /* Extract the elf_flags if available. */ if (info.abfd != NULL @@ -1086,22 +963,48 @@ rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) arches != NULL; arches = gdbarch_list_lookup_by_info (arches->next, &info)) { - if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags) + rx_gdbarch_tdep *tdep + = (rx_gdbarch_tdep *) gdbarch_tdep (arches->gdbarch); + + if (tdep->elf_flags != elf_flags) continue; return arches->gdbarch; } - /* None found, create a new architecture from the information - provided. */ - tdep = XCNEW (struct gdbarch_tdep); + if (tdesc == NULL) + tdesc = tdesc_rx; + + /* Check any target description for validity. */ + if (tdesc_has_registers (tdesc)) + { + const struct tdesc_feature *feature; + bool valid_p = true; + + feature = tdesc_find_feature (tdesc, "org.gnu.gdb.rx.core"); + + if (feature != NULL) + { + tdesc_data = tdesc_data_alloc (); + for (int i = 0; i < RX_NUM_REGS; i++) + valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), i, + rx_register_names[i]); + } + + if (!valid_p) + return NULL; + } + + gdb_assert(tdesc_data != NULL); + + rx_gdbarch_tdep *tdep = new rx_gdbarch_tdep; gdbarch = gdbarch_alloc (&info, tdep); tdep->elf_flags = elf_flags; set_gdbarch_num_regs (gdbarch, RX_NUM_REGS); + tdesc_use_registers (gdbarch, tdesc, std::move (tdesc_data)); + set_gdbarch_num_pseudo_regs (gdbarch, 0); - set_gdbarch_register_name (gdbarch, rx_register_name); - set_gdbarch_register_type (gdbarch, rx_register_type); set_gdbarch_pc_regnum (gdbarch, RX_PC_REGNUM); set_gdbarch_sp_regnum (gdbarch, RX_SP_REGNUM); set_gdbarch_inner_than (gdbarch, core_addr_lessthan); @@ -1110,9 +1013,6 @@ rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_sw_breakpoint_from_kind (gdbarch, rx_breakpoint::bp_from_kind); set_gdbarch_skip_prologue (gdbarch, rx_skip_prologue); - set_gdbarch_unwind_pc (gdbarch, rx_unwind_pc); - set_gdbarch_unwind_sp (gdbarch, rx_unwind_sp); - /* Target builtin data types. */ set_gdbarch_char_signed (gdbarch, 0); set_gdbarch_short_bit (gdbarch, 16); @@ -1122,6 +1022,7 @@ rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_ptr_bit (gdbarch, 32); set_gdbarch_float_bit (gdbarch, 32); set_gdbarch_float_format (gdbarch, floatformats_ieee_single); + if (elf_flags & E_FLAG_RX_64BIT_DOUBLES) { set_gdbarch_double_bit (gdbarch, 64); @@ -1145,10 +1046,8 @@ rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) dwarf2_append_unwinders (gdbarch); frame_unwind_append_unwinder (gdbarch, &rx_frame_unwind); - /* Methods for saving / extracting a dummy frame's ID. - The ID's stack address must match the SP value returned by - PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ - set_gdbarch_dummy_id (gdbarch, rx_dummy_id); + /* Methods setting up a dummy call, and extracting the return value from + a call. */ set_gdbarch_push_dummy_call (gdbarch, rx_push_dummy_call); set_gdbarch_return_value (gdbarch, rx_return_value); @@ -1160,8 +1059,10 @@ rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Register the above initialization routine. */ +void _initialize_rx_tdep (); void -_initialize_rx_tdep (void) +_initialize_rx_tdep () { register_gdbarch_init (bfd_arch_rx, rx_gdbarch_init); + initialize_tdesc_rx (); }