static void * build_java_types (struct gdbarch *gdbarch) { struct builtin_java_type *builtin_java_type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_java_type); builtin_java_type->builtin_int = arch_integer_type (gdbarch, 32, 0, "int"); builtin_java_type->builtin_short = arch_integer_type (gdbarch, 16, 0, "short"); builtin_java_type->builtin_long = arch_integer_type (gdbarch, 64, 0, "long"); builtin_java_type->builtin_byte = arch_integer_type (gdbarch, 8, 0, "byte"); builtin_java_type->builtin_boolean = arch_boolean_type (gdbarch, 8, 0, "boolean"); builtin_java_type->builtin_char = arch_character_type (gdbarch, 16, 1, "char"); builtin_java_type->builtin_float = arch_float_type (gdbarch, 32, "float", NULL); builtin_java_type->builtin_double = arch_float_type (gdbarch, 64, "double", NULL); builtin_java_type->builtin_void = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); return builtin_java_type; }
static void * build_fortran_types (struct gdbarch *gdbarch) { struct builtin_f_type *builtin_f_type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_f_type); builtin_f_type->builtin_void = arch_type (gdbarch, TYPE_CODE_VOID, 1, "VOID"); builtin_f_type->builtin_character = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 0, "character"); builtin_f_type->builtin_logical_s1 = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "logical*1"); builtin_f_type->builtin_integer_s2 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), 0, "integer*2"); builtin_f_type->builtin_logical_s2 = arch_boolean_type (gdbarch, gdbarch_short_bit (gdbarch), 1, "logical*2"); builtin_f_type->builtin_logical_s8 = arch_boolean_type (gdbarch, gdbarch_long_long_bit (gdbarch), 1, "logical*8"); builtin_f_type->builtin_integer = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "integer"); builtin_f_type->builtin_logical = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "logical*4"); builtin_f_type->builtin_real = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "real", NULL); builtin_f_type->builtin_real_s8 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), "real*8", NULL); builtin_f_type->builtin_real_s16 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), "real*16", NULL); builtin_f_type->builtin_complex_s8 = arch_complex_type (gdbarch, "complex*8", builtin_f_type->builtin_real); builtin_f_type->builtin_complex_s16 = arch_complex_type (gdbarch, "complex*16", builtin_f_type->builtin_real_s8); builtin_f_type->builtin_complex_s32 = arch_complex_type (gdbarch, "complex*32", builtin_f_type->builtin_real_s16); return builtin_f_type; }
static void * build_go_types (struct gdbarch *gdbarch) { struct builtin_go_type *builtin_go_type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_go_type); builtin_go_type->builtin_void = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); builtin_go_type->builtin_char = arch_character_type (gdbarch, 8, 1, "char"); builtin_go_type->builtin_bool = arch_boolean_type (gdbarch, 8, 0, "bool"); builtin_go_type->builtin_int = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "int"); builtin_go_type->builtin_uint = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "uint"); builtin_go_type->builtin_uintptr = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr"); builtin_go_type->builtin_int8 = arch_integer_type (gdbarch, 8, 0, "int8"); builtin_go_type->builtin_int16 = arch_integer_type (gdbarch, 16, 0, "int16"); builtin_go_type->builtin_int32 = arch_integer_type (gdbarch, 32, 0, "int32"); builtin_go_type->builtin_int64 = arch_integer_type (gdbarch, 64, 0, "int64"); builtin_go_type->builtin_uint8 = arch_integer_type (gdbarch, 8, 1, "uint8"); builtin_go_type->builtin_uint16 = arch_integer_type (gdbarch, 16, 1, "uint16"); builtin_go_type->builtin_uint32 = arch_integer_type (gdbarch, 32, 1, "uint32"); builtin_go_type->builtin_uint64 = arch_integer_type (gdbarch, 64, 1, "uint64"); builtin_go_type->builtin_float32 = arch_float_type (gdbarch, 32, "float32", floatformats_ieee_single); builtin_go_type->builtin_float64 = arch_float_type (gdbarch, 64, "float64", floatformats_ieee_double); builtin_go_type->builtin_complex64 = arch_complex_type (gdbarch, "complex64", builtin_go_type->builtin_float32); builtin_go_type->builtin_complex128 = arch_complex_type (gdbarch, "complex128", builtin_go_type->builtin_float64); return builtin_go_type; }
/* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable', described above, laid out appropriately for ARCH. We use this function as the gdbarch per-architecture data initialization function. */ static void * build_gdb_vtable_type (struct gdbarch *arch) { struct type *t; struct field *field_list, *field; int offset; struct type *void_ptr_type = builtin_type (arch)->builtin_data_ptr; struct type *ptr_to_void_fn_type = builtin_type (arch)->builtin_func_ptr; /* ARCH can't give us the true ptrdiff_t type, so we guess. */ struct type *ptrdiff_type = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t"); /* We assume no padding is necessary, since GDB doesn't know anything about alignment at the moment. If this assumption bites us, we should add a gdbarch method which, given a type, returns the alignment that type requires, and then use that here. */ /* Build the field list. */ field_list = xmalloc (sizeof (struct field [4])); memset (field_list, 0, sizeof (struct field [4])); field = &field_list[0]; offset = 0; /* ptrdiff_t vcall_and_vbase_offsets[0]; */ FIELD_NAME (*field) = "vcall_and_vbase_offsets"; FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1); SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT); offset += TYPE_LENGTH (FIELD_TYPE (*field)); field++; /* ptrdiff_t offset_to_top; */ FIELD_NAME (*field) = "offset_to_top"; FIELD_TYPE (*field) = ptrdiff_type; SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT); offset += TYPE_LENGTH (FIELD_TYPE (*field)); field++; /* void *type_info; */ FIELD_NAME (*field) = "type_info"; FIELD_TYPE (*field) = void_ptr_type; SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT); offset += TYPE_LENGTH (FIELD_TYPE (*field)); field++; /* void (*virtual_functions[0]) (); */ FIELD_NAME (*field) = "virtual_functions"; FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1); SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT); offset += TYPE_LENGTH (FIELD_TYPE (*field)); field++; /* We assumed in the allocation above that there were four fields. */ gdb_assert (field == (field_list + 4)); t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL); TYPE_NFIELDS (t) = field - field_list; TYPE_FIELDS (t) = field_list; TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable"; INIT_CPLUS_SPECIFIC (t); return t; }
struct type * linux_get_siginfo_type (struct gdbarch *gdbarch) { struct type *int_type, *uint_type, *long_type, *void_ptr_type; struct type *uid_type, *pid_type; struct type *sigval_type, *clock_type; struct type *siginfo_type, *sifields_type; struct type *type; /* TODO: muck around in gdbtypes.[ch] until this all works: */ int_type = arch_integer_type(gdbarch, gdbarch_int_bit(gdbarch), 0, "int"); uint_type = arch_integer_type(gdbarch, gdbarch_int_bit(gdbarch), 1, "unsigned int"); long_type = arch_integer_type(gdbarch, gdbarch_long_bit(gdbarch), 0, "long"); void_ptr_type = lookup_pointer_type(get_builtin_type(gdbarch)->builtin_void); /* sigval_t */ sigval_type = arch_composite_type(gdbarch, NULL, TYPE_CODE_UNION); TYPE_NAME(sigval_type) = xstrdup("sigval_t"); append_composite_type_field(sigval_type, "sival_int", int_type); append_composite_type_field(sigval_type, "sival_ptr", void_ptr_type); /* __pid_t */ pid_type = arch_type(gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH(int_type), xstrdup("__pid_t")); TYPE_TARGET_TYPE(pid_type) = int_type; TYPE_TARGET_STUB(pid_type) = (struct type *)1; /* __uid_t */ uid_type = arch_type(gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH(uint_type), xstrdup("__uid_t")); TYPE_TARGET_TYPE(uid_type) = uint_type; TYPE_TARGET_STUB(uid_type) = (struct type *)1; /* __clock_t */ clock_type = arch_type(gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH(long_type), xstrdup("__clock_t")); TYPE_TARGET_TYPE(clock_type) = long_type; TYPE_TARGET_STUB(clock_type) = (struct type *)1; /* _sifields */ sifields_type = arch_composite_type(gdbarch, NULL, TYPE_CODE_UNION); { const int si_max_size = 128; int si_pad_size; int size_of_int = (gdbarch_int_bit(gdbarch) / HOST_CHAR_BIT); /* _pad */ if (gdbarch_ptr_bit(gdbarch) == 64) si_pad_size = ((si_max_size / size_of_int) - 4); else si_pad_size = ((si_max_size / size_of_int) - 3); append_composite_type_field(sifields_type, "_pad", init_vector_type(int_type, si_pad_size)); } /* _kill */ type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_pid", pid_type); append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (sifields_type, "_kill", type); /* _timer */ type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_tid", int_type); append_composite_type_field (type, "si_overrun", int_type); append_composite_type_field (type, "si_sigval", sigval_type); append_composite_type_field (sifields_type, "_timer", type); /* _rt */ type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_pid", pid_type); append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (type, "si_sigval", sigval_type); append_composite_type_field (sifields_type, "_rt", type); /* _sigchld */ type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_pid", pid_type); append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (type, "si_status", int_type); append_composite_type_field (type, "si_utime", clock_type); append_composite_type_field (type, "si_stime", clock_type); append_composite_type_field (sifields_type, "_sigchld", type); /* _sigfault */ type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_addr", void_ptr_type); append_composite_type_field (sifields_type, "_sigfault", type); /* _sigpoll */ type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_band", long_type); append_composite_type_field (type, "si_fd", int_type); append_composite_type_field (sifields_type, "_sigpoll", type); /* struct siginfo */ siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); TYPE_NAME (siginfo_type) = xstrdup ("siginfo"); append_composite_type_field (siginfo_type, "si_signo", int_type); append_composite_type_field (siginfo_type, "si_errno", int_type); append_composite_type_field (siginfo_type, "si_code", int_type); append_composite_type_field_aligned (siginfo_type, "_sifields", sifields_type, TYPE_LENGTH (long_type)); return siginfo_type; }
static void * build_d_types (struct gdbarch *gdbarch) { struct builtin_d_type *builtin_d_type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type); /* Basic types. */ builtin_d_type->builtin_void = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); builtin_d_type->builtin_bool = arch_boolean_type (gdbarch, 8, 1, "bool"); builtin_d_type->builtin_byte = arch_integer_type (gdbarch, 8, 0, "byte"); builtin_d_type->builtin_ubyte = arch_integer_type (gdbarch, 8, 1, "ubyte"); builtin_d_type->builtin_short = arch_integer_type (gdbarch, 16, 0, "short"); builtin_d_type->builtin_ushort = arch_integer_type (gdbarch, 16, 1, "ushort"); builtin_d_type->builtin_int = arch_integer_type (gdbarch, 32, 0, "int"); builtin_d_type->builtin_uint = arch_integer_type (gdbarch, 32, 1, "uint"); builtin_d_type->builtin_long = arch_integer_type (gdbarch, 64, 0, "long"); builtin_d_type->builtin_ulong = arch_integer_type (gdbarch, 64, 1, "ulong"); builtin_d_type->builtin_cent = arch_integer_type (gdbarch, 128, 0, "cent"); builtin_d_type->builtin_ucent = arch_integer_type (gdbarch, 128, 1, "ucent"); builtin_d_type->builtin_float = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "float", NULL); builtin_d_type->builtin_double = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), "double", NULL); builtin_d_type->builtin_real = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), "real", NULL); TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte) |= TYPE_INSTANCE_FLAG_NOTTEXT; TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte) |= TYPE_INSTANCE_FLAG_NOTTEXT; /* Imaginary and complex types. */ builtin_d_type->builtin_ifloat = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "ifloat", NULL); builtin_d_type->builtin_idouble = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), "idouble", NULL); builtin_d_type->builtin_ireal = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), "ireal", NULL); builtin_d_type->builtin_cfloat = arch_complex_type (gdbarch, "cfloat", builtin_d_type->builtin_float); builtin_d_type->builtin_cdouble = arch_complex_type (gdbarch, "cdouble", builtin_d_type->builtin_double); builtin_d_type->builtin_creal = arch_complex_type (gdbarch, "creal", builtin_d_type->builtin_real); /* Character types. */ builtin_d_type->builtin_char = arch_character_type (gdbarch, 8, 1, "char"); builtin_d_type->builtin_wchar = arch_character_type (gdbarch, 16, 1, "wchar"); builtin_d_type->builtin_dchar = arch_character_type (gdbarch, 32, 1, "dchar"); return builtin_d_type; }
static struct gdbarch * ft32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { struct gdbarch *gdbarch; struct gdbarch_tdep *tdep; struct type *void_type; struct type *func_void_type; /* If there is already a candidate, use it. */ arches = gdbarch_list_lookup_by_info (arches, &info); if (arches != NULL) return arches->gdbarch; /* Allocate space for the new architecture. */ tdep = XNEW (struct gdbarch_tdep); gdbarch = gdbarch_alloc (&info, tdep); /* Create a type for PC. We can't use builtin types here, as they may not be defined. */ void_type = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); func_void_type = make_function_type (void_type, NULL); tdep->pc_type = arch_type (gdbarch, TYPE_CODE_PTR, 4, NULL); TYPE_TARGET_TYPE (tdep->pc_type) = func_void_type; TYPE_UNSIGNED (tdep->pc_type) = 1; TYPE_INSTANCE_FLAGS (tdep->pc_type) |= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1; set_gdbarch_read_pc (gdbarch, ft32_read_pc); set_gdbarch_write_pc (gdbarch, ft32_write_pc); set_gdbarch_unwind_sp (gdbarch, ft32_unwind_sp); set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS); set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM); set_gdbarch_pc_regnum (gdbarch, FT32_PC_REGNUM); set_gdbarch_register_name (gdbarch, ft32_register_name); set_gdbarch_register_type (gdbarch, ft32_register_type); set_gdbarch_return_value (gdbarch, ft32_return_value); set_gdbarch_pointer_to_address (gdbarch, ft32_pointer_to_address); set_gdbarch_skip_prologue (gdbarch, ft32_skip_prologue); set_gdbarch_inner_than (gdbarch, core_addr_lessthan); set_gdbarch_breakpoint_from_pc (gdbarch, ft32_breakpoint_from_pc); set_gdbarch_frame_align (gdbarch, ft32_frame_align); frame_base_set_default (gdbarch, &ft32_frame_base); /* 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, ft32_dummy_id); set_gdbarch_unwind_pc (gdbarch, ft32_unwind_pc); set_gdbarch_print_insn (gdbarch, print_insn_ft32); /* Hook in ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); /* Hook in the default unwinders. */ frame_unwind_append_unwinder (gdbarch, &ft32_frame_unwind); /* Support simple overlay manager. */ set_gdbarch_overlay_update (gdbarch, simple_overlay_update); set_gdbarch_address_class_type_flags (gdbarch, ft32_address_class_type_flags); set_gdbarch_address_class_name_to_type_flags (gdbarch, ft32_address_class_name_to_type_flags); set_gdbarch_address_class_type_flags_to_name (gdbarch, ft32_address_class_type_flags_to_name); return gdbarch; }