G_MODULE_EXPORT GList * CUT_MODULE_IMPL_INIT (GTypeModule *type_module) { GList *registered_types = NULL; register_type(type_module); if (cut_type_console_ui_factory) registered_types = g_list_prepend(registered_types, (gchar *)g_type_name(cut_type_console_ui_factory)); return registered_types; }
G_MODULE_EXPORT GList * CUT_MODULE_IMPL_INIT (GTypeModule *type_module) { GList *registered_types = NULL; register_type(type_module); if (CUT_TYPE_PDF_REPORT) registered_types = g_list_prepend(registered_types, (gchar *)g_type_name(CUT_TYPE_PDF_REPORT)); return registered_types; }
/* Output one register's contents in the desired format. */ static int get_register (int regnum, int format) { gdb_byte buffer[MAX_REGISTER_SIZE]; int optim; int realnum; CORE_ADDR addr; enum lval_type lval; static struct ui_stream *stb = NULL; stb = ui_out_stream_new (uiout); if (format == 'N') format = 0; frame_register (get_selected_frame (NULL), regnum, &optim, &lval, &addr, &realnum, buffer); if (optim) { mi_error_message = xstrprintf ("Optimized out"); return -1; } if (format == 'r') { int j; char *ptr, buf[1024]; strcpy (buf, "0x"); ptr = buf + 2; for (j = 0; j < register_size (current_gdbarch, regnum); j++) { int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j : register_size (current_gdbarch, regnum) - 1 - j; sprintf (ptr, "%02x", (unsigned char) buffer[idx]); ptr += 2; } ui_out_field_string (uiout, "value", buf); /*fputs_filtered (buf, gdb_stdout); */ } else { val_print (register_type (current_gdbarch, regnum), buffer, 0, 0, stb->stream, format, 1, 0, Val_pretty_default); ui_out_field_stream (uiout, "value", stb); ui_out_stream_delete (stb); } return 1; }
G_MODULE_EXPORT GList * CUT_MODULE_IMPL_INIT (GTypeModule *type_module) { GList *registered_types = NULL; register_type(type_module); if (cut_type_cpp_integration_loader_customizer_factory) { registered_types = g_list_prepend(registered_types, (gchar *)g_type_name(cut_type_cpp_integration_loader_customizer_factory)); } return registered_types; }
// Register a singleton Python type. int qpyqml_register_singleton_type(PyTypeObject *py_type, const char *uri, int major, int minor, const char *type_name, PyObject *factory) { // Initialise the registration data structure. QQmlPrivate::RegisterSingletonType *rt = init_type(py_type, factory); if (!rt) return -1; rt->uri = uri; rt->versionMajor = major; rt->versionMinor = minor; rt->typeName = type_name; return register_type(rt); }
/** * \brief Initializes the item features provided to Lua. */ void LuaContext::register_item_module() { static const luaL_Reg methods[] = { { "get_name", item_api_get_name }, { "get_game", item_api_get_game }, { "get_map", item_api_get_map }, { "get_savegame_variable", item_api_get_savegame_variable }, { "set_savegame_variable", item_api_set_savegame_variable }, { "get_amount_savegame_variable", item_api_get_amount_savegame_variable }, { "set_amount_savegame_variable", item_api_set_amount_savegame_variable }, { "is_obtainable", item_api_is_obtainable }, { "set_obtainable", item_api_set_obtainable }, { "is_assignable", item_api_is_assignable }, { "set_assignable", item_api_set_assignable }, { "get_can_disappear", item_api_get_can_disappear }, { "set_can_disappear", item_api_set_can_disappear }, { "get_brandish_when_picked", item_api_get_brandish_when_picked }, { "set_brandish_when_picked", item_api_set_brandish_when_picked }, { "get_shadow", item_api_get_shadow }, { "set_shadow", item_api_set_shadow }, { "get_sound_when_picked", item_api_get_sound_when_picked }, { "set_sound_when_picked", item_api_set_sound_when_picked }, { "get_sound_when_brandished", item_api_get_sound_when_brandished }, { "set_sound_when_brandished", item_api_set_sound_when_brandished }, { "has_variant", item_api_has_variant }, { "get_variant", item_api_get_variant }, { "set_variant", item_api_set_variant }, { "has_amount", item_api_has_amount }, { "get_amount", item_api_get_amount }, { "set_amount", item_api_set_amount }, { "add_amount", item_api_add_amount }, { "remove_amount", item_api_remove_amount }, { "get_max_amount", item_api_get_max_amount }, { "set_max_amount", item_api_set_max_amount }, { "set_finished", item_api_set_finished }, { NULL, NULL } }; static const luaL_Reg metamethods[] = { { "__gc", userdata_meta_gc }, { "__newindex", userdata_meta_newindex_as_table }, { "__index", userdata_meta_index_as_table }, { NULL, NULL } }; register_type(item_module_name, NULL, methods, metamethods); }
static void get_register_types (int regnum, map_arg arg) { struct type *reg_vtype; int i,n; reg_vtype = register_type (get_current_arch (), regnum); if (TYPE_CODE (reg_vtype) == TYPE_CODE_UNION) { n = TYPE_NFIELDS (reg_vtype); /* limit to 16 types */ if (n > 16) n = 16; for (i = 0; i < n; i++) { Tcl_Obj *ar[3], *list; char *buff; buff = xstrprintf ("%lx", (long)TYPE_FIELD_TYPE (reg_vtype, i)); ar[0] = Tcl_NewStringObj (TYPE_FIELD_NAME (reg_vtype, i), -1); ar[1] = Tcl_NewStringObj (buff, -1); if (TYPE_CODE (TYPE_FIELD_TYPE (reg_vtype, i)) == TYPE_CODE_FLT) ar[2] = Tcl_NewStringObj ("float", -1); else ar[2] = Tcl_NewStringObj ("int", -1); list = Tcl_NewListObj (3, ar); Tcl_ListObjAppendElement (gdbtk_interp, result_ptr->obj_ptr, list); xfree (buff); } } else { Tcl_Obj *ar[3], *list; char *buff; buff = xstrprintf ("%lx", (long)reg_vtype); ar[0] = Tcl_NewStringObj (TYPE_NAME(reg_vtype), -1); ar[1] = Tcl_NewStringObj (buff, -1); if (TYPE_CODE (reg_vtype) == TYPE_CODE_FLT) ar[2] = Tcl_NewStringObj ("float", -1); else ar[2] = Tcl_NewStringObj ("int", -1); list = Tcl_NewListObj (3, ar); xfree (buff); Tcl_ListObjAppendElement (gdbtk_interp, result_ptr->obj_ptr, list); } }
inline void basic_iarchive_impl::load_object( basic_iarchive & ar, void * t, const basic_iserializer & bis ){ m_moveable_objects.is_pointer = false; serialization::state_saver<bool> ss_is_pointer(m_moveable_objects.is_pointer); // if its been serialized through a pointer and the preamble's been done if(t == m_pending.object && & bis == m_pending.bis){ // read data (bis.load_object_data)(ar, t, m_pending.version); return; } const class_id_type cid = register_type(bis); const int i = cid; cobject_id & co = cobject_id_vector[i]; load_preamble(ar, co); // save the current move stack position in case we want to truncate it boost::serialization::state_saver<object_id_type> ss_start(m_moveable_objects.start); // note: extra line used to evade borland issue const bool tracking = co.tracking_level; object_id_type this_id; m_moveable_objects.start = this_id = object_id_type(object_id_vector.size()); // if we tracked this object when the archive was saved if(tracking){ // if it was already read if(!track(ar, t)) // we're done return; // add a new enty into the tracking list object_id_vector.push_back(aobject(t, cid)); // and add an entry for this object m_moveable_objects.end = object_id_type(object_id_vector.size()); } // read data (bis.load_object_data)(ar, t, co.file_version); m_moveable_objects.recent = this_id; }
/** * \brief Initializes the text surface features provided to Lua. */ void LuaContext::register_text_surface_module() { // Functions of sol.surface. static const luaL_Reg functions[] = { { "create", text_surface_api_create }, { nullptr, nullptr }, }; // Methods of the text_surface type. static const luaL_Reg methods[] = { { "get_horizontal_alignment", text_surface_api_get_horizontal_alignment }, { "set_horizontal_alignment", text_surface_api_set_horizontal_alignment }, { "get_vertical_alignment", text_surface_api_get_vertical_alignment }, { "set_vertical_alignment", text_surface_api_set_vertical_alignment }, { "get_font", text_surface_api_get_font }, { "set_font", text_surface_api_set_font }, { "get_rendering_mode", text_surface_api_get_rendering_mode }, { "set_rendering_mode", text_surface_api_set_rendering_mode }, { "get_color", text_surface_api_get_color }, { "set_color", text_surface_api_set_color }, { "get_font_size", text_surface_api_get_font_size }, { "set_font_size", text_surface_api_set_font_size }, { "get_text", text_surface_api_get_text }, { "set_text", text_surface_api_set_text }, { "set_text_key", text_surface_api_set_text_key }, { "get_size", text_surface_api_get_size }, { "draw", drawable_api_draw }, { "draw_region", drawable_api_draw_region }, { "get_blend_mode", drawable_api_get_blend_mode }, { "set_blend_mode", drawable_api_set_blend_mode }, { "fade_in", drawable_api_fade_in }, { "fade_out", drawable_api_fade_out }, { "get_xy", drawable_api_get_xy }, { "set_xy", drawable_api_set_xy }, { "get_movement", drawable_api_get_movement }, { "stop_movement", drawable_api_stop_movement }, { nullptr, nullptr } }; static const luaL_Reg metamethods[] = { { "__gc", drawable_meta_gc }, { nullptr, nullptr } }; register_type(text_surface_module_name, functions, methods, metamethods); }
void register_alias_types_from_declarator_list(DeclaratorList * l) { DeclaratorList *i; for (i = l; i != NULL; i = i->next) { Type *base = l->type; Type *final; if (l->nsizes) final = (Type *) create_array_type(base, l->nsizes, l->array_sizes); else final = base; AliasType *alias = create_alias_type(l->name, final); register_type((Type *) alias); }
LB_API int lbind_newmetatable(lua_State *L, luaL_Reg *libs, const lbind_Type *t) { if (type_exists(L, t)) return 0; lua_createtable(L, 0, 8); if (libs != NULL) luaL_setfuncs(L, libs, 0); /* init type metatable */ lua_pushlightuserdata(L, (void*)t); lua_setfield(L, -2, "__type"); if (!lbind_hasfield(L, -1, "__gc")) { lua_pushcfunction(L, Lgc); lua_setfield(L, -2, "__gc"); } if (!lbind_hasfield(L, -1, "__tostring")) { lua_pushcfunction(L, Ltostring); lua_setfield(L, -2, "__tostring"); } if (t->bases != NULL && t->bases[0] != NULL) { int nups = 0; int freeslots = 0; lbind_Type **bases = t->bases; for (; *bases != NULL; ++nups, ++bases) { if (nups > freeslots) { luaL_checkstack(L, 10, "no space for base types"); freeslots += 10; } if (!lbind_getmetatable(L, *bases)) lua_pushlightuserdata(L, *bases); } lbind_setindexf(L, nups); } else if (!lbind_hasfield(L, -1, "__index")) { lua_pushvalue(L, -1); lua_setfield(L, -2, "__index"); } register_type(L, t->name, (const void*)t); return 1; }
static void m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache, gdb_byte *valbuf) { gdb_byte buf[M68K_MAX_REGISTER_SIZE]; struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT) { struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM); regcache_raw_read (regcache, M68K_FP0_REGNUM, buf); convert_typed_floating (buf, fpreg_type, valbuf, type); } else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4) regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf); else m68k_extract_return_value (type, regcache, valbuf); }
/** * \brief Initializes the sprite features provided to Lua. */ void LuaContext::register_sprite_module() { static const luaL_Reg functions[] = { { "create", sprite_api_create }, { nullptr, nullptr } }; static const luaL_Reg methods[] = { { "get_animation_set", sprite_api_get_animation_set }, { "get_animation", sprite_api_get_animation }, { "set_animation", sprite_api_set_animation }, { "has_animation", sprite_api_has_animation }, { "get_direction", sprite_api_get_direction }, { "set_direction", sprite_api_set_direction }, { "get_num_directions", sprite_api_get_num_directions }, { "get_frame", sprite_api_get_frame }, { "set_frame", sprite_api_set_frame }, { "get_frame_delay", sprite_api_get_frame_delay }, { "set_frame_delay", sprite_api_set_frame_delay }, { "is_paused", sprite_api_is_paused }, { "set_paused", sprite_api_set_paused }, { "set_ignore_suspend", sprite_api_set_ignore_suspend }, { "synchronize", sprite_api_synchronize }, { "draw", drawable_api_draw }, { "draw_region", drawable_api_draw_region }, { "fade_in", drawable_api_fade_in }, { "fade_out", drawable_api_fade_out }, { "get_xy", drawable_api_get_xy }, { "set_xy", drawable_api_set_xy }, { "get_movement", drawable_api_get_movement }, { "stop_movement", drawable_api_stop_movement }, { nullptr, nullptr } }; static const luaL_Reg metamethods[] = { { "__gc", drawable_meta_gc }, { "__newindex", userdata_meta_newindex_as_table }, { "__index", userdata_meta_index_as_table }, { nullptr, nullptr } }; register_type(sprite_module_name, functions, methods, metamethods); }
static void m68k_value_to_register (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *from) { gdb_byte to[M68K_MAX_REGISTER_SIZE]; struct type *fpreg_type = register_type (get_frame_arch (frame), M68K_FP0_REGNUM); /* We only support floating-point values. */ if (TYPE_CODE (type) != TYPE_CODE_FLT) { warning (_("Cannot convert non-floating-point type " "to floating-point register value.")); return; } /* Convert from TYPE. */ convert_typed_floating (from, type, to, fpreg_type); put_frame_register (frame, regnum, to); }
static void m68k_value_to_register (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *from) { gdb_byte to[M68K_MAX_REGISTER_SIZE]; struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM); /* We only support floating-point values. */ if (TYPE_CODE (type) != TYPE_CODE_FLT) { warning (_("Cannot convert non-floating-point type " "to floating-point register value.")); return; } /* Convert from TYPE. This should be a no-op if TYPE is equivalent to the extended floating-point format used by the FPU. */ convert_typed_floating (from, type, to, fpreg_type); put_frame_register (frame, regnum, to); }
static int m68k_register_to_value (struct frame_info *frame, int regnum, struct type *type, gdb_byte *to, int *optimizedp, int *unavailablep) { struct gdbarch *gdbarch = get_frame_arch (frame); gdb_byte from[M68K_MAX_REGISTER_SIZE]; struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM); gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); /* Convert to TYPE. */ if (!get_frame_register_bytes (frame, regnum, 0, register_size (gdbarch, regnum), from, optimizedp, unavailablep)) return 0; target_float_convert (from, fpreg_type, to, type); *optimizedp = *unavailablep = 0; return 1; }
static void m68k_svr4_store_return_value (struct type *type, struct regcache *regcache, const gdb_byte *valbuf) { struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT) { struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM); gdb_byte buf[M68K_MAX_REGISTER_SIZE]; target_float_convert (valbuf, type, buf, fpreg_type); regcache_raw_write (regcache, M68K_FP0_REGNUM, buf); } else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4) { regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf); regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf); } else m68k_store_return_value (type, regcache, valbuf); }
/** * \brief Initializes the surface features provided to Lua. */ void LuaContext::register_surface_module() { static const luaL_Reg methods[] = { { "create", surface_api_create }, { "get_size", surface_api_get_size }, { "fill_color", surface_api_fill_color }, { "set_opacity", surface_api_set_opacity }, { "draw", drawable_api_draw }, { "draw_region", drawable_api_draw_region }, { "fade_in", drawable_api_fade_in }, { "fade_out", drawable_api_fade_out }, { "get_xy", drawable_api_get_xy }, { "set_xy", drawable_api_set_xy }, { "get_movement", drawable_api_get_movement }, { "stop_movement", drawable_api_stop_movement }, { NULL, NULL } }; static const luaL_Reg metamethods[] = { { "__gc", drawable_meta_gc }, { NULL, NULL } }; register_type(surface_module_name, methods, metamethods); }
static CORE_ADDR rs6000_lynx178_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, CORE_ADDR struct_addr) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int ii; int len = 0; int argno; /* current argument number */ int argbytes; /* current argument byte */ gdb_byte tmp_buffer[50]; int f_argno = 0; /* current floating point argno */ int wordsize = gdbarch_tdep (gdbarch)->wordsize; CORE_ADDR func_addr = find_function_addr (function, NULL); struct value *arg = 0; struct type *type; ULONGEST saved_sp; /* The calling convention this function implements assumes the processor has floating-point registers. We shouldn't be using it on PPC variants that lack them. */ gdb_assert (ppc_floating_point_unit_p (gdbarch)); /* The first eight words of ther arguments are passed in registers. Copy them appropriately. */ ii = 0; /* If the function is returning a `struct', then the first word (which will be passed in r3) is used for struct return address. In that case we should advance one word and start from r4 register to copy parameters. */ if (struct_return) { regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, struct_addr); ii++; } /* Effectively indirect call... gcc does... return_val example( float, int); eabi: float in fp0, int in r3 offset of stack on overflow 8/16 for varargs, must go by type. power open: float in r3&r4, int in r5 offset of stack on overflow different both: return in r3 or f0. If no float, must study how gcc emulates floats; pay attention to arg promotion. User may have to cast\args to handle promotion correctly since gdb won't know if prototype supplied or not. */ for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii) { int reg_size = register_size (gdbarch, ii + 3); arg = args[argno]; type = check_typedef (value_type (arg)); len = TYPE_LENGTH (type); if (TYPE_CODE (type) == TYPE_CODE_FLT) { /* Floating point arguments are passed in fpr's, as well as gpr's. There are 13 fpr's reserved for passing parameters. At this point there is no way we would run out of them. Always store the floating point value using the register's floating-point format. */ const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno; gdb_byte reg_val[MAX_REGISTER_SIZE]; struct type *reg_type = register_type (gdbarch, fp_regnum); gdb_assert (len <= 8); convert_typed_floating (value_contents (arg), type, reg_val, reg_type); regcache_cooked_write (regcache, fp_regnum, reg_val); ++f_argno; } if (len > reg_size) { /* Argument takes more than one register. */ while (argbytes < len) { gdb_byte word[MAX_REGISTER_SIZE]; memset (word, 0, reg_size); memcpy (word, ((char *) value_contents (arg)) + argbytes, (len - argbytes) > reg_size ? reg_size : len - argbytes); regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 + ii, word); ++ii, argbytes += reg_size; if (ii >= 8) goto ran_out_of_registers_for_arguments; } argbytes = 0; --ii; } else { /* Argument can fit in one register. No problem. */ int adj = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? reg_size - len : 0; gdb_byte word[MAX_REGISTER_SIZE]; memset (word, 0, reg_size); memcpy (word, value_contents (arg), len); regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word); } ++argno; } ran_out_of_registers_for_arguments: regcache_cooked_read_unsigned (regcache, gdbarch_sp_regnum (gdbarch), &saved_sp); /* Location for 8 parameters are always reserved. */ sp -= wordsize * 8; /* Another six words for back chain, TOC register, link register, etc. */ sp -= wordsize * 6; /* Stack pointer must be quadword aligned. */ sp = align_down (sp, 16); /* If there are more arguments, allocate space for them in the stack, then push them starting from the ninth one. */ if ((argno < nargs) || argbytes) { int space = 0, jj; if (argbytes) { space += align_up (len - argbytes, 4); jj = argno + 1; } else jj = argno; for (; jj < nargs; ++jj) { struct value *val = args[jj]; space += align_up (TYPE_LENGTH (value_type (val)), 4); } /* Add location required for the rest of the parameters. */ space = align_up (space, 16); sp -= space; /* This is another instance we need to be concerned about securing our stack space. If we write anything underneath %sp (r1), we might conflict with the kernel who thinks he is free to use this area. So, update %sp first before doing anything else. */ regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp); /* If the last argument copied into the registers didn't fit there completely, push the rest of it into stack. */ if (argbytes) { write_memory (sp + 24 + (ii * 4), value_contents (arg) + argbytes, len - argbytes); ++argno; ii += align_up (len - argbytes, 4) / 4; } /* Push the rest of the arguments into stack. */ for (; argno < nargs; ++argno) { arg = args[argno]; type = check_typedef (value_type (arg)); len = TYPE_LENGTH (type); /* Float types should be passed in fpr's, as well as in the stack. */ if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13) { gdb_assert (len <= 8); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + f_argno, value_contents (arg)); ++f_argno; } write_memory (sp + 24 + (ii * 4), value_contents (arg), len); ii += align_up (len, 4) / 4; } } /* Set the stack pointer. According to the ABI, the SP is meant to be set _before_ the corresponding stack space is used. On AIX, this even applies when the target has been completely stopped! Not doing this can lead to conflicts with the kernel which thinks that it still has control over this not-yet-allocated stack region. */ regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp); /* Set back chain properly. */ store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp); write_memory (sp, tmp_buffer, wordsize); /* Point the inferior function call's return address at the dummy's breakpoint. */ regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr); target_store_registers (regcache, -1); return sp; }
static enum return_value_convention rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); /* The calling convention this function implements assumes the processor has floating-point registers. We shouldn't be using it on PowerPC variants that lack them. */ gdb_assert (ppc_floating_point_unit_p (gdbarch)); /* AltiVec extension: Functions that declare a vector data type as a return value place that return value in VR2. */ if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype) && TYPE_LENGTH (valtype) == 16) { if (readbuf) regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf); if (writebuf) regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf); return RETURN_VALUE_REGISTER_CONVENTION; } /* If the called subprogram returns an aggregate, there exists an implicit first argument, whose value is the address of a caller- allocated buffer into which the callee is assumed to store its return value. All explicit parameters are appropriately relabeled. */ if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT || TYPE_CODE (valtype) == TYPE_CODE_UNION || TYPE_CODE (valtype) == TYPE_CODE_ARRAY) return RETURN_VALUE_STRUCT_CONVENTION; /* Scalar floating-point values are returned in FPR1 for float or double, and in FPR1:FPR2 for quadword precision. Fortran complex*8 and complex*16 are returned in FPR1:FPR2, and complex*32 is returned in FPR1:FPR4. */ if (TYPE_CODE (valtype) == TYPE_CODE_FLT && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8)) { struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); gdb_byte regval[8]; /* FIXME: kettenis/2007-01-01: Add support for quadword precision and complex. */ if (readbuf) { regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval); convert_typed_floating (regval, regtype, readbuf, valtype); } if (writebuf) { convert_typed_floating (writebuf, valtype, regval, regtype); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval); } return RETURN_VALUE_REGISTER_CONVENTION; } /* Values of the types int, long, short, pointer, and char (length is less than or equal to four bytes), as well as bit values of lengths less than or equal to 32 bits, must be returned right justified in GPR3 with signed values sign extended and unsigned values zero extended, as necessary. */ if (TYPE_LENGTH (valtype) <= tdep->wordsize) { if (readbuf) { ULONGEST regval; /* For reading we don't have to worry about sign extension. */ regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3, ®val); store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order, regval); } if (writebuf) { /* For writing, use unpack_long since that should handle any required sign extension. */ regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, unpack_long (valtype, writebuf)); } return RETURN_VALUE_REGISTER_CONVENTION; } /* Eight-byte non-floating-point scalar values must be returned in GPR3:GPR4. */ if (TYPE_LENGTH (valtype) == 8) { gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT); gdb_assert (tdep->wordsize == 4); if (readbuf) { gdb_byte regval[8]; regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval); regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4, regval + 4); memcpy (readbuf, regval, 8); } if (writebuf) { regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf); regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, writebuf + 4); } return RETURN_VALUE_REGISTER_CONVENTION; } return RETURN_VALUE_STRUCT_CONVENTION; }
void initialize_types() { static bool initialized = false; if(initialized) return; register_type(typeid(k3d::angle_axis), "k3d::angle_axis"); register_type(typeid(k3d::bitmap), "k3d::bitmap"); register_type(typeid(k3d::bitmap*), "k3d::bitmap*"); register_type(typeid(k3d::bool_t), "k3d::bool_t"); register_type(typeid(k3d::bounding_box3), "k3d::bounding_box3"); register_type(typeid(k3d::color), "k3d::color"); register_type(typeid(k3d::double_t), "k3d::double_t"); register_type(typeid(k3d::filesystem::path), "k3d::filesystem::path"); register_type(typeid(k3d::float_t), "k3d::float_t"); register_type(typeid(k3d::gl::context), "k3d::gl::context"); register_type(typeid(k3d::gl::context_factory), "k3d::gl::context_factory"); register_type(typeid(k3d::gl::offscreen_context), "k3d::gl::offscreen_context"); register_type(typeid(k3d::gl::offscreen_context_factory), "k3d::gl::offscreen_context_factory"); register_type(typeid(k3d::gl::ilight), "k3d::gl::ilight"); register_type(typeid(k3d::gl::imesh_painter), "k3d::gl::imesh_painter"); register_type(typeid(k3d::gl::imesh_painter*), "k3d::gl::imesh_painter*"); register_type(typeid(k3d::half_t), "k3d::half_t"); register_type(typeid(k3d::i3d_2d_mapping), "k3d::i3d_2d_mapping"); register_type(typeid(k3d::ibitmap_exporter), "k3d::ibitmap_exporter"); register_type(typeid(k3d::ibitmap_importer), "k3d::ibitmap_importer"); register_type(typeid(k3d::ibitmap_sink), "k3d::ibitmap_sink"); register_type(typeid(k3d::ibitmap_source), "k3d::ibitmap_source"); register_type(typeid(k3d::icamera), "k3d::icamera"); register_type(typeid(k3d::icolor_source), "k3d::icolor_source"); register_type(typeid(k3d::idocument_exporter), "k3d::idocument_exporter"); register_type(typeid(k3d::idocument_importer), "k3d::idocument_importer"); register_type(typeid(k3d::idouble_source), "k3d::idouble_source"); register_type(typeid(k3d::ievent_loop), "k3d::ievent_loop"); register_type(typeid(k3d::ifile_change_notifier), "k3d::ifile_change_notifier"); register_type(typeid(k3d::iint32_source), "k3d::iint32_source"); register_type(typeid(k3d::ikeyframer), "k3d::ikeyframer"); register_type(typeid(k3d::imaterial), "k3d::imaterial"); register_type(typeid(k3d::imaterial*), "k3d::imaterial*"); register_type(typeid(k3d::imesh_selection_algorithm), "k3d::imesh_selection_algorithm"); register_type(typeid(k3d::imesh_sink), "k3d::imesh_sink"); register_type(typeid(k3d::imesh_source), "k3d::imesh_source"); register_type(typeid(k3d::imesh_storage), "k3d::imesh_storage"); register_type(typeid(k3d::imime_type_handler), "k3d::imime_type_handler"); register_type(typeid(k3d::imulti_mesh_sink), "k3d::imulti_mesh_sink"); register_type(typeid(k3d::inode), "k3d::inode"); register_type(typeid(k3d::inode*), "k3d::inode*"); register_type(typeid(k3d::inode_selection), "k3d::inode_selection"); register_type(typeid(k3d::inode_selection*), "k3d::inode_selection*"); register_type(typeid(k3d::int16_t), "k3d::int16_t"); register_type(typeid(k3d::int32_t), "k3d::int32_t"); register_type(typeid(k3d::int64_t), "k3d::int64_t"); register_type(typeid(k3d::int8_t), "k3d::int8_t"); register_type(typeid(k3d::irender_animation), "k3d::irender_animation"); register_type(typeid(k3d::irender_camera_animation), "k3d::irender_camera_animation"); register_type(typeid(k3d::irender_camera_frame), "k3d::irender_camera_frame"); register_type(typeid(k3d::irender_camera_preview), "k3d::irender_camera_preview"); register_type(typeid(k3d::irender_frame), "k3d::irender_frame"); register_type(typeid(k3d::irender_preview), "k3d::irender_preview"); register_type(typeid(k3d::iscript_engine), "k3d::iscript_engine"); register_type(typeid(k3d::istring_source), "k3d::istring_source"); register_type(typeid(k3d::itexture), "k3d::itexture"); register_type(typeid(k3d::itexture*), "k3d::itexture*"); register_type(typeid(k3d::itime_sink), "k3d::itime_sink"); register_type(typeid(k3d::itransform_array_1d), "k3d::itransform_array_1d"); register_type(typeid(k3d::itransform_array_2d), "k3d::itransform_array_2d"); register_type(typeid(k3d::itransform_array_3d), "k3d::itransform_array_3d"); register_type(typeid(k3d::imatrix_sink), "k3d::imatrix_sink"); register_type(typeid(k3d::imatrix_source), "k3d::imatrix_source"); register_type(typeid(k3d::iunknown), "k3d::iunknown"); register_type(typeid(k3d::iunknown*), "k3d::iunknown*"); register_type(typeid(k3d::iuri_handler), "k3d::iuri_handler"); register_type(typeid(k3d::ivector3_source), "k3d::ivector3_source"); register_type(typeid(k3d::matrix4), "k3d::matrix4"); register_type(typeid(k3d::mesh), "k3d::mesh"); register_type(typeid(k3d::mesh*), "k3d::mesh*"); register_type(typeid(k3d::normal3), "k3d::normal3"); register_type(typeid(k3d::point2), "k3d::point2"); register_type(typeid(k3d::point3), "k3d::point3"); register_type(typeid(k3d::point4), "k3d::point4"); register_type(typeid(k3d::ri::idisplacement_shader), "k3d::ri::idisplacement_shader"); register_type(typeid(k3d::ri::iimager_shader), "k3d::ri::iimager_shader"); register_type(typeid(k3d::ri::ilight), "k3d::ri::ilight"); register_type(typeid(k3d::ri::ilight_shader), "k3d::ri::ilight_shader"); register_type(typeid(k3d::ri::imaterial), "k3d::ri::imaterial"); register_type(typeid(k3d::ri::imesh_painter), "k3d::ri::imesh_painter"); register_type(typeid(k3d::ri::imesh_painter*), "k3d::ri::imesh_painter*"); register_type(typeid(k3d::ri::irender_engine), "k3d::ri::irender_engine"); register_type(typeid(k3d::ri::irender_engine*), "k3d::ri::irender_engine*"); register_type(typeid(k3d::ri::isurface_shader), "k3d::ri::isurface_shader"); register_type(typeid(k3d::ri::itexture), "k3d::ri::itexture"); register_type(typeid(k3d::ri::itexture*), "k3d::ri::itexture*"); register_type(typeid(k3d::ri::ivolume_shader), "k3d::ri::ivolume_shader"); register_type(typeid(k3d::rectangle), "k3d::rectangle"); register_type(typeid(k3d::selection::set), "k3d::selection::set"); register_type(typeid(k3d::string_t), "k3d::string_t"); register_type(typeid(k3d::texture3), "k3d::texture3"); register_type(typeid(k3d::uint16_t), "k3d::uint16_t"); register_type(typeid(k3d::uint32_t), "k3d::uint32_t"); register_type(typeid(k3d::uint64_t), "k3d::uint64_t"); register_type(typeid(k3d::uint8_t), "k3d::uint8_t"); register_type(typeid(k3d::vector2), "k3d::vector2"); register_type(typeid(k3d::vector3), "k3d::vector3"); register_type(typeid(k3d::yafray::ilight), "k3d::yafray::ilight"); register_type(typeid(k3d::yafray::imaterial), "k3d::yafray::imaterial"); /** \todo Come up with a more explicit type for these */ register_type(typeid(k3d::typed_array<unsigned int>), "k3d::typed_array<unsigned int>"); register_type(typeid(k3d::typed_array<k3d::double_t>), "k3d::typed_array<k3d::double_t>"); register_type(typeid(std::vector<k3d::point3>), "std::vector<k3d::point3>"); register_type(typeid(std::vector<unsigned int>), "std::vector<unsigned int>"); register_type(typeid(std::vector<k3d::inode*>), "std::vector<k3d::inode*>"); initialized = true; }
inline void GameObjectManager::init_type() { register_type(_type_handle, "GameObjectManager", TypedReferenceCount::get_class_type()); }
CORE_ADDR ppc64_sysv_abi_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, CORE_ADDR struct_addr) { CORE_ADDR func_addr = find_function_addr (function, NULL); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); /* By this stage in the proceedings, SP has been decremented by "red zone size" + "struct return size". Fetch the stack-pointer from before this and use that as the BACK_CHAIN. */ const CORE_ADDR back_chain = read_sp (); /* See for-loop comment below. */ int write_pass; /* Size of the Altivec's vector parameter region, the final value is computed in the for-loop below. */ LONGEST vparam_size = 0; /* Size of the general parameter region, the final value is computed in the for-loop below. */ LONGEST gparam_size = 0; /* Kevin writes ... I don't mind seeing tdep->wordsize used in the calls to align_up(), align_down(), etc. because this makes it easier to reuse this code (in a copy/paste sense) in the future, but it is a 64-bit ABI and asserting that the wordsize is 8 bytes at some point makes it easier to verify that this function is correct without having to do a non-local analysis to figure out the possible values of tdep->wordsize. */ gdb_assert (tdep->wordsize == 8); /* Go through the argument list twice. Pass 1: Compute the function call's stack space and register requirements. Pass 2: Replay the same computation but this time also write the values out to the target. */ for (write_pass = 0; write_pass < 2; write_pass++) { int argno; /* Next available floating point register for float and double arguments. */ int freg = 1; /* Next available general register for non-vector (but possibly float) arguments. */ int greg = 3; /* Next available vector register for vector arguments. */ int vreg = 2; /* The address, at which the next general purpose parameter (integer, struct, float, ...) should be saved. */ CORE_ADDR gparam; /* Address, at which the next Altivec vector parameter should be saved. */ CORE_ADDR vparam; if (!write_pass) { /* During the first pass, GPARAM and VPARAM are more like offsets (start address zero) than addresses. That way the accumulate the total stack space each region requires. */ gparam = 0; vparam = 0; } else { /* Decrement the stack pointer making space for the Altivec and general on-stack parameters. Set vparam and gparam to their corresponding regions. */ vparam = align_down (sp - vparam_size, 16); gparam = align_down (vparam - gparam_size, 16); /* Add in space for the TOC, link editor double word, compiler double word, LR save area, CR save area. */ sp = align_down (gparam - 48, 16); } /* If the function is returning a `struct', then there is an extra hidden parameter (which will be passed in r3) containing the address of that struct.. In that case we should advance one word and start from r4 register to copy parameters. This also consumes one on-stack parameter slot. */ if (struct_return) { if (write_pass) regcache_cooked_write_signed (regcache, tdep->ppc_gp0_regnum + greg, struct_addr); greg++; gparam = align_up (gparam + tdep->wordsize, tdep->wordsize); } for (argno = 0; argno < nargs; argno++) { struct value *arg = args[argno]; struct type *type = check_typedef (value_type (arg)); const bfd_byte *val = value_contents (arg); if (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8) { /* Floats and Doubles go in f1 .. f13. They also consume a left aligned GREG,, and can end up in memory. */ if (write_pass) { if (ppc_floating_point_unit_p (current_gdbarch) && freg <= 13) { gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); convert_typed_floating (val, type, regval, regtype); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + freg, regval); } if (greg <= 10) { /* The ABI states "Single precision floating point values are mapped to the first word in a single doubleword" and "... floating point values mapped to the first eight doublewords of the parameter save area are also passed in general registers"). This code interprets that to mean: store it, left aligned, in the general register. */ gdb_byte regval[MAX_REGISTER_SIZE]; memset (regval, 0, sizeof regval); memcpy (regval, val, TYPE_LENGTH (type)); regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + greg, regval); } write_memory (gparam, val, TYPE_LENGTH (type)); } /* Always consume parameter stack space. */ freg++; greg++; gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize); } else if (TYPE_LENGTH (type) == 16 && TYPE_VECTOR (type) && TYPE_CODE (type) == TYPE_CODE_ARRAY && tdep->ppc_vr0_regnum >= 0) { /* In the Altivec ABI, vectors go in the vector registers v2 .. v13, or when that runs out, a vector annex which goes above all the normal parameters. NOTE: cagney/2003-09-21: This is a guess based on the PowerOpen Altivec ABI. */ if (vreg <= 13) { if (write_pass) regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + vreg, val); vreg++; } else { if (write_pass) write_memory (vparam, val, TYPE_LENGTH (type)); vparam = align_up (vparam + TYPE_LENGTH (type), 16); } } else if ((TYPE_CODE (type) == TYPE_CODE_INT || TYPE_CODE (type) == TYPE_CODE_ENUM || TYPE_CODE (type) == TYPE_CODE_PTR) && TYPE_LENGTH (type) <= 8) { /* Scalars and Pointers get sign[un]extended and go in gpr3 .. gpr10. They can also end up in memory. */ if (write_pass) { /* Sign extend the value, then store it unsigned. */ ULONGEST word = unpack_long (type, val); /* Convert any function code addresses into descriptors. */ if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC) { CORE_ADDR desc = word; convert_code_addr_to_desc_addr (word, &desc); word = desc; } if (greg <= 10) regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + greg, word); write_memory_unsigned_integer (gparam, tdep->wordsize, word); } greg++; gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize); } else { int byte; for (byte = 0; byte < TYPE_LENGTH (type); byte += tdep->wordsize) { if (write_pass && greg <= 10) { gdb_byte regval[MAX_REGISTER_SIZE]; int len = TYPE_LENGTH (type) - byte; if (len > tdep->wordsize) len = tdep->wordsize; memset (regval, 0, sizeof regval); /* WARNING: cagney/2003-09-21: As best I can tell, the ABI specifies that the value should be left aligned. Unfortunately, GCC doesn't do this - it instead right aligns even sized values and puts odd sized values on the stack. Work around that by putting both a left and right aligned value into the register (hopefully no one notices :-^). Arrrgh! */ /* Left aligned (8 byte values such as pointers fill the buffer). */ memcpy (regval, val + byte, len); /* Right aligned (but only if even). */ if (len == 1 || len == 2 || len == 4) memcpy (regval + tdep->wordsize - len, val + byte, len); regcache_cooked_write (regcache, greg, regval); } greg++; } if (write_pass) /* WARNING: cagney/2003-09-21: Strictly speaking, this isn't necessary, unfortunately, GCC appears to get "struct convention" parameter passing wrong putting odd sized structures in memory instead of in a register. Work around this by always writing the value to memory. Fortunately, doing this simplifies the code. */ write_memory (gparam, val, TYPE_LENGTH (type)); if (write_pass) /* WARNING: cagney/2004-06-20: It appears that GCC likes to put structures containing a single floating-point member in an FP register instead of general general purpose. */ /* Always consume parameter stack space. */ gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize); } } if (!write_pass) { /* Save the true region sizes ready for the second pass. */ vparam_size = vparam; /* Make certain that the general parameter save area is at least the minimum 8 registers (or doublewords) in size. */ if (greg < 8) gparam_size = 8 * tdep->wordsize; else gparam_size = gparam; } } /* Update %sp. */ regcache_cooked_write_signed (regcache, SP_REGNUM, sp); /* Write the backchain (it occupies WORDSIZED bytes). */ write_memory_signed_integer (sp, tdep->wordsize, back_chain); /* Point the inferior function call's return address at the dummy's breakpoint. */ regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr); /* Use the func_addr to find the descriptor, and use that to find the TOC. */ { CORE_ADDR desc_addr; if (convert_code_addr_to_desc_addr (func_addr, &desc_addr)) { /* The TOC is the second double word in the descriptor. */ CORE_ADDR toc = read_memory_unsigned_integer (desc_addr + tdep->wordsize, tdep->wordsize); regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 2, toc); } } return sp; }
static enum return_value_convention do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, /* APPLE LOCAL gdb_byte */ struct regcache *regcache, gdb_byte *readbuf, /* APPLE LOCAL gdb_byte */ const gdb_byte *writebuf, int broken_gcc) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); gdb_assert (tdep->wordsize == 4); if (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8 && ppc_floating_point_unit_p (gdbarch)) { if (readbuf) { /* Floats and doubles stored in "f1". Convert the value to the required type. */ gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum + 1); regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval); convert_typed_floating (regval, regtype, readbuf, type); } if (writebuf) { /* Floats and doubles stored in "f1". Convert the value to the register's "double" type. */ gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); convert_typed_floating (writebuf, type, regval, regtype); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval); } return RETURN_VALUE_REGISTER_CONVENTION; } /* APPLE LOCAL: gcc 3.3 had 8 byte long doubles, but gcc 4.0 uses 16 byte long doubles even for 32 bit ppc. They are stored across f1 & f2. */ /* Big floating point values get stored in adjacent floating point registers. */ if (TYPE_CODE (type) == TYPE_CODE_FLT && (TYPE_LENGTH (type) == 16 || TYPE_LENGTH (type) == 32)) { if (writebuf || readbuf != NULL) { int i; for (i = 0; i < TYPE_LENGTH (type) / 8; i++) { if (writebuf != NULL) regcache_cooked_write (regcache, FP0_REGNUM + 1 + i, (const bfd_byte *) writebuf + i * 8); if (readbuf != NULL) regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, (bfd_byte *) readbuf + i * 8); } } return RETURN_VALUE_REGISTER_CONVENTION; } /* END APPLE LOCAL */ if ((TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 8) || (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8)) { if (readbuf) { /* A long long, or a double stored in the 32 bit r3/r4. */ ppc_copy_from_greg (regcache, tdep->ppc_gp0_regnum + 3, tdep->wordsize, 8, (bfd_byte *) readbuf); } if (writebuf) { /* A long long, or a double stored in the 32 bit r3/r4. */ ppc_copy_into_greg (regcache, tdep->ppc_gp0_regnum + 3, tdep->wordsize, 8, writebuf); } return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) <= tdep->wordsize) { if (readbuf) { /* Some sort of integer stored in r3. Since TYPE isn't bigger than the register, sign extension isn't a problem - just do everything unsigned. */ ULONGEST regval; regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3, ®val); store_unsigned_integer (readbuf, TYPE_LENGTH (type), regval); } if (writebuf) { /* Some sort of integer stored in r3. Use unpack_long since that should handle any required sign extension. */ regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, unpack_long (type, writebuf)); } return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_LENGTH (type) == 16 && TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type) && tdep->ppc_vr0_regnum >= 0) { if (readbuf) { /* Altivec places the return value in "v2". */ regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf); } if (writebuf) { /* Altivec places the return value in "v2". */ regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf); } return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_LENGTH (type) == 8 && TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type) && tdep->ppc_ev0_regnum >= 0) { /* The e500 ABI places return values for the 64-bit DSP types (__ev64_opaque__) in r3. However, in GDB-speak, ev3 corresponds to the entire r3 value for e500, whereas GDB's r3 only corresponds to the least significant 32-bits. So place the 64-bit DSP type's value in ev3. */ if (readbuf) regcache_cooked_read (regcache, tdep->ppc_ev0_regnum + 3, readbuf); if (writebuf) regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, writebuf); return RETURN_VALUE_REGISTER_CONVENTION; } if (broken_gcc && TYPE_LENGTH (type) <= 8) { if (readbuf) { /* GCC screwed up. The last register isn't "left" aligned. Need to extract the least significant part of each register and then store that. */ /* Transfer any full words. */ int word = 0; while (1) { ULONGEST reg; int len = TYPE_LENGTH (type) - word * tdep->wordsize; if (len <= 0) break; if (len > tdep->wordsize) len = tdep->wordsize; regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3 + word, ®); store_unsigned_integer (((bfd_byte *) readbuf + word * tdep->wordsize), len, reg); word++; } } if (writebuf) { /* GCC screwed up. The last register isn't "left" aligned. Need to extract the least significant part of each register and then store that. */ /* Transfer any full words. */ int word = 0; while (1) { ULONGEST reg; int len = TYPE_LENGTH (type) - word * tdep->wordsize; if (len <= 0) break; if (len > tdep->wordsize) len = tdep->wordsize; reg = extract_unsigned_integer (((const bfd_byte *) writebuf + word * tdep->wordsize), len); regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3 + word, reg); word++; } } return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_LENGTH (type) <= 8) { if (readbuf) { /* This matches SVr4 PPC, it does not match GCC. */ /* The value is right-padded to 8 bytes and then loaded, as two "words", into r3/r4. */ ppc_copy_from_greg (regcache, tdep->ppc_gp0_regnum + 3, tdep->wordsize, TYPE_LENGTH (type), readbuf); } if (writebuf) { /* This matches SVr4 PPC, it does not match GCC. */ /* The value is padded out to 8 bytes and then loaded, as two "words" into r3/r4. */ gdb_byte regvals[MAX_REGISTER_SIZE * 2]; memset (regvals, 0, sizeof regvals); memcpy (regvals, writebuf, TYPE_LENGTH (type)); regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, regvals + 0 * tdep->wordsize); if (TYPE_LENGTH (type) > tdep->wordsize) regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, regvals + 1 * tdep->wordsize); } return RETURN_VALUE_REGISTER_CONVENTION; } return RETURN_VALUE_STRUCT_CONVENTION; }
void register_type(int code, const char *name) { register_type(code, new_exception(name, m_type.ptr())); }
void initialize() { m_type = new_exception("Error"); register_type(-ENOENT, "NotFoundError"); register_type(-ETIMEDOUT, "TimeoutError"); }
inline const basic_pointer_iserializer * basic_iarchive_impl::load_pointer( basic_iarchive &ar, void * & t, const basic_pointer_iserializer * bpis_ptr, const basic_pointer_iserializer * (*finder)( const boost::serialization::extended_type_info & type_ ) ){ m_moveable_objects.is_pointer = true; serialization::state_saver<bool> w(m_moveable_objects.is_pointer); class_id_type cid; load(ar, cid); if(NULL_POINTER_TAG == cid){ t = NULL; return bpis_ptr; } // if its a new class type - i.e. never been registered if(class_id_type(cobject_info_set.size()) <= cid){ // if its either abstract if(NULL == bpis_ptr // or polymorphic || bpis_ptr->get_basic_serializer().is_polymorphic()){ // is must have been exported char key[BOOST_SERIALIZATION_MAX_KEY_SIZE]; class_name_type class_name(key); load(ar, class_name); // if it has a class name const serialization::extended_type_info *eti = NULL; if(0 != key[0]) eti = serialization::extended_type_info::find(key); if(NULL == eti) boost::serialization::throw_exception( archive_exception(archive_exception::unregistered_class) ); bpis_ptr = (*finder)(*eti); } BOOST_ASSERT(NULL != bpis_ptr); // class_id_type new_cid = register_type(bpis_ptr->get_basic_serializer()); BOOST_VERIFY(register_type(bpis_ptr->get_basic_serializer()) == cid); int i = cid; cobject_id_vector[i].bpis_ptr = bpis_ptr; } int i = cid; cobject_id & co = cobject_id_vector[i]; bpis_ptr = co.bpis_ptr; load_preamble(ar, co); // extra line to evade borland issue const bool tracking = co.tracking_level; // if we're tracking and the pointer has already been read if(tracking && ! track(ar, t)) // we're done return bpis_ptr; // save state serialization::state_saver<object_id_type> w_start(m_moveable_objects.start); // allocate space on the heap for the object - to be constructed later t = bpis_ptr->heap_allocation(); BOOST_ASSERT(NULL != t); if(! tracking){ bpis_ptr->load_object_ptr(ar, t, co.file_version); } else{ serialization::state_saver<void *> x(m_pending.object); serialization::state_saver<const basic_iserializer *> y(m_pending.bis); serialization::state_saver<version_type> z(m_pending.version); m_pending.bis = & bpis_ptr->get_basic_serializer(); m_pending.version = co.file_version; // predict next object id to be created const unsigned int ui = object_id_vector.size(); serialization::state_saver<object_id_type> w_end(m_moveable_objects.end); // add to list of serialized objects so that we can properly handle // cyclic strucures object_id_vector.push_back(aobject(t, cid)); // remember that that the address of these elements could change // when we make another call so don't use the address bpis_ptr->load_object_ptr( ar, t, m_pending.version ); object_id_vector[ui].loaded_as_pointer = true; } return bpis_ptr; }
inline void basic_oarchive_impl::save_object( basic_oarchive & ar, const void *t, const basic_oserializer & bos ){ // if its been serialized through a pointer and the preamble's been done if(t == pending_object && pending_bos == & bos){ // just save the object data ar.end_preamble(); (bos.save_object_data)(ar, t); return; } // get class information for this object const cobject_type & co = register_type(bos); if(bos.class_info()){ if( ! co.m_initialized){ ar.vsave(class_id_optional_type(co.m_class_id)); ar.vsave(tracking_type(bos.tracking(m_flags))); ar.vsave(version_type(bos.version())); (const_cast<cobject_type &>(co)).m_initialized = true; } } // we're not tracking this type of object if(! bos.tracking(m_flags)){ // just windup the preamble - no object id to write ar.end_preamble(); // and save the data (bos.save_object_data)(ar, t); return; } // look for an existing object id object_id_type oid(object_set.size()); // lookup to see if this object has already been written to the archive basic_oarchive_impl::aobject ao(t, co.m_class_id, oid); std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool> aresult = object_set.insert(ao); oid = aresult.first->object_id; // if its a new object if(aresult.second){ // write out the object id ar.vsave(oid); ar.end_preamble(); // and data (bos.save_object_data)(ar, t); return; } // check that it wasn't originally stored through a pointer if(stored_pointers.end() != stored_pointers.find(oid)){ // this has to be a user error. loading such an archive // would create duplicate objects boost::serialization::throw_exception( archive_exception(archive_exception::pointer_conflict) ); } // just save the object id ar.vsave(object_reference_type(oid)); ar.end_preamble(); return; }
/* The 64 bit ABI retun value convention. Return non-zero if the return-value is stored in a register, return 0 if the return-value is instead stored on the stack (a.k.a., struct return convention). For a return-value stored in a register: when WRITEBUF is non-NULL, copy the buffer to the corresponding register return-value location location; when READBUF is non-NULL, fill the buffer from the corresponding register return-value location. */ enum return_value_convention ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* This function exists to support a calling convention that requires floating-point registers. It shouldn't be used on processors that lack them. */ gdb_assert (ppc_floating_point_unit_p (gdbarch)); /* Floats and doubles in F1. */ if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8) { gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); if (writebuf != NULL) { convert_typed_floating (writebuf, valtype, regval, regtype); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval); } if (readbuf != NULL) { regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval); convert_typed_floating (regval, regtype, readbuf, valtype); } return RETURN_VALUE_REGISTER_CONVENTION; } if ((TYPE_CODE (valtype) == TYPE_CODE_INT || TYPE_CODE (valtype) == TYPE_CODE_ENUM) && TYPE_LENGTH (valtype) <= 8) { /* Integers in r3. */ if (writebuf != NULL) { /* Be careful to sign extend the value. */ regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, unpack_long (valtype, writebuf)); } if (readbuf != NULL) { /* Extract the integer from r3. Since this is truncating the value, there isn't a sign extension problem. */ ULONGEST regval; regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3, ®val); store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), regval); } return RETURN_VALUE_REGISTER_CONVENTION; } /* All pointers live in r3. */ if (TYPE_CODE (valtype) == TYPE_CODE_PTR) { /* All pointers live in r3. */ if (writebuf != NULL) regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf); if (readbuf != NULL) regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf); return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_LENGTH (valtype) <= 8 && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1) { /* Small character arrays are returned, right justified, in r3. */ int offset = (register_size (gdbarch, tdep->ppc_gp0_regnum + 3) - TYPE_LENGTH (valtype)); if (writebuf != NULL) regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3, offset, TYPE_LENGTH (valtype), writebuf); if (readbuf != NULL) regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3, offset, TYPE_LENGTH (valtype), readbuf); return RETURN_VALUE_REGISTER_CONVENTION; } /* Big floating point values get stored in adjacent floating point registers. */ if (TYPE_CODE (valtype) == TYPE_CODE_FLT && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32)) { if (writebuf || readbuf != NULL) { int i; for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++) { if (writebuf != NULL) regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i, (const bfd_byte *) writebuf + i * 8); if (readbuf != NULL) regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i, (bfd_byte *) readbuf + i * 8); } } return RETURN_VALUE_REGISTER_CONVENTION; } /* Complex values get returned in f1:f2, need to convert. */ if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16)) { if (regcache != NULL) { int i; for (i = 0; i < 2; i++) { gdb_byte regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (current_gdbarch, tdep->ppc_fp0_regnum); if (writebuf != NULL) { convert_typed_floating ((const bfd_byte *) writebuf + i * (TYPE_LENGTH (valtype) / 2), valtype, regval, regtype); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i, regval); } if (readbuf != NULL) { regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i, regval); convert_typed_floating (regval, regtype, (bfd_byte *) readbuf + i * (TYPE_LENGTH (valtype) / 2), valtype); } } } return RETURN_VALUE_REGISTER_CONVENTION; } /* Big complex values get stored in f1:f4. */ if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32) { if (regcache != NULL) { int i; for (i = 0; i < 4; i++) { if (writebuf != NULL) regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i, (const bfd_byte *) writebuf + i * 8); if (readbuf != NULL) regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i, (bfd_byte *) readbuf + i * 8); } } return RETURN_VALUE_REGISTER_CONVENTION; } return RETURN_VALUE_STRUCT_CONVENTION; }
// save a pointer to an object instance inline void basic_oarchive_impl::save_pointer( basic_oarchive & ar, const void * t, const basic_pointer_oserializer * bpos_ptr ){ const basic_oserializer & bos = bpos_ptr->get_basic_serializer(); std::size_t original_count = cobject_info_set.size(); const cobject_type & co = register_type(bos); if(! co.m_initialized){ ar.vsave(co.m_class_id); // if its a previously unregistered class if((cobject_info_set.size() > original_count)){ if(bos.is_polymorphic()){ const serialization::extended_type_info *eti = & bos.get_eti(); const char * key = NULL; if(NULL != eti) key = eti->get_key(); if(NULL != key){ // the following is required by IBM C++ compiler which // makes a copy when passing a non-const to a const. This // is permitted by the standard but rarely seen in practice const class_name_type cn(key); // write out the external class identifier ar.vsave(cn); } else // without an external class name // we won't be able to de-serialize it so bail now boost::serialization::throw_exception( archive_exception(archive_exception::unregistered_class) ); } } if(bos.class_info()){ ar.vsave(tracking_type(bos.tracking(m_flags))); ar.vsave(version_type(bos.version())); } (const_cast<cobject_type &>(co)).m_initialized = true; } else{ ar.vsave(class_id_reference_type(co.m_class_id)); } // if we're not tracking if(! bos.tracking(m_flags)){ // just save the data itself ar.end_preamble(); serialization::state_saver<const void *> x(pending_object); serialization::state_saver<const basic_oserializer *> y(pending_bos); pending_object = t; pending_bos = & bpos_ptr->get_basic_serializer(); bpos_ptr->save_object_ptr(ar, t); return; } object_id_type oid(object_set.size()); // lookup to see if this object has already been written to the archive basic_oarchive_impl::aobject ao(t, co.m_class_id, oid); std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool> aresult = object_set.insert(ao); oid = aresult.first->object_id; // if the saved object already exists if(! aresult.second){ // append the object id to he preamble ar.vsave(object_reference_type(oid)); // and windup. ar.end_preamble(); return; } // append id of this object to preamble ar.vsave(oid); ar.end_preamble(); // and save the object itself serialization::state_saver<const void *> x(pending_object); serialization::state_saver<const basic_oserializer *> y(pending_bos); pending_object = t; pending_bos = & bpos_ptr->get_basic_serializer(); bpos_ptr->save_object_ptr(ar, t); // add to the set of object initially stored through pointers stored_pointers.insert(oid); }