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);
}
