From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2560 invoked by alias); 1 May 2003 15:41:07 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 2553 invoked from network); 1 May 2003 15:41:07 -0000 Received: from unknown (HELO hub.ott.qnx.com) (209.226.137.76) by sources.redhat.com with SMTP; 1 May 2003 15:41:07 -0000 Received: from smtp.ott.qnx.com (smtp.ott.qnx.com [10.0.2.158]) by hub.ott.qnx.com (8.9.3p2/8.9.3) with ESMTP id LAA17435 for ; Thu, 1 May 2003 11:38:52 -0400 Received: from catdog ([10.4.2.2]) by smtp.ott.qnx.com (8.8.8/8.6.12) with SMTP id LAA14400 for ; Thu, 1 May 2003 11:41:06 -0400 Message-ID: <036c01c30ff8$1c97c3c0$0202040a@catdog> From: "Kris Warkentin" To: "Gdb-Patches@Sources.Redhat.Com" Subject: [PATCH] (dagnabbit) QNX Neutrino i386 support Date: Thu, 01 May 2003 15:41:00 -0000 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_NextPart_000_0369_01C30FD6.9579C7B0" X-Priority: 3 X-MSMail-Priority: Normal X-MIMEOLE: Produced By Microsoft MimeOLE V6.00.2800.1165 X-SW-Source: 2003-05/txt/msg00004.txt.bz2 This is a multi-part message in MIME format. ------=_NextPart_000_0369_01C30FD6.9579C7B0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 7bit Content-length: 26138 Well, I'd love to just be submitting a patch to all the already committed stuff but since you guys haven't approved my stuff yet, now I have to submit the whole darn thing again. Serves you right. ;-) I've gone and refactored a bunch of stuff again. I simplified the interface into the backend target stuff since we were doing a lot of work for registers that we didn't need to. The main (and cool) thing that I did was to take all the backend functions, put them into a target vector and create defines for all the functions just like is done in target.h and a few other places. I think it's much more elegant this way and it also will make it possible to create a multi-arch gdb for Neutrino down the road. cheers, Kris ChangeLog * configure.tgt: Add i386nto target * i386-nto-tdep.c: New file. i386 specific support for QNX Neutrino. * nto-tdep.c: New file. Neutrino target support routines. * nto-tdep.h: New file. Neutrino target header. * config/tm-qnxnto.h: New file. * config/i386/i386nto.mt: New file. * config/i386/tm-i386nto.h: New file. Index: configure.tgt =================================================================== RCS file: /cvs/src/src/gdb/configure.tgt,v retrieving revision 1.102 diff -r1.102 configure.tgt 92a93 > i[3456]86-*-nto*) gdb_target=i386nto;; 282a285 > *-*-nto*) gdb_osabi=GDB_OSABI_QNXNTO ;; <<<<<<<<<<<<<<<< i386-nto-tdep.c >>>>>>>>>>>>>>>> /* i386-nto-tdep.c - i386 specific functionality for QNX Neutrino. Copyright 2003 Free Software Foundation, Inc. Contributed by QNX Software Systems Ltd. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "gdb_string.h" #include "gdb_assert.h" #include "defs.h" #include "frame.h" #include "target.h" #include "regcache.h" #include "solib-svr4.h" #include "i386-tdep.h" #include "nto-tdep.h" #include "osabi.h" #include "i387-tdep.h" #ifndef X86_CPU_FXSR #define X86_CPU_FXSR (1L << 12) #endif /* Why 13? Look in our /usr/include/x86/context.h header at the x86_cpu_registers structure and you'll see an 'exx' junk register that is just filler. Don't ask me, ask the kernel guys. */ #define NUM_GPREGS 13 /* Map a GDB register number to an offset in the reg structure. */ static int regmap[] = { (7 * 4), /* eax */ (6 * 4), /* ecx */ (5 * 4), /* edx */ (4 * 4), /* ebx */ (11 * 4), /* esp */ (2 * 4), /* epb */ (1 * 4), /* esi */ (0 * 4), /* edi */ (8 * 4), /* eip */ (10 * 4), /* eflags */ (9 * 4), /* cs */ (12 * 4), /* ss */ (-1 * 4) /* filler */ }; /* Given a gdb regno, return the offset into Neutrino's register structure or -1 if register is unknown. */ static int nto_reg_offset (int regno) { return (regno >= 0 && regno < NUM_GPREGS) ? regmap[regno] : -1; } static void i386nto_supply_gregset (char *gpregs) { unsigned regno; int empty = 0; for (regno = 0; regno < FP0_REGNUM; regno++) { int offset = nto_reg_offset (regno); if (offset == -1) supply_register (regno, (char *) &empty); else supply_register (regno, gpregs + offset); } } static void i386nto_supply_fpregset (char *fpregs) { if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR) i387_supply_fxsave (fpregs); else i387_supply_fsave (fpregs); } static void i386nto_supply_regset (int regset, char *data) { switch (regset) { case NTO_REG_GENERAL: /* QNX has different ordering of GP regs than GDB. */ i386nto_supply_gregset (data); break; case NTO_REG_FLOAT: i386nto_supply_fpregset (data); break; } } static int i386nto_regset_id (int regno) { if (regno == -1) return NTO_REG_END; else if (regno < FP0_REGNUM) return NTO_REG_GENERAL; else if (regno < FPC_REGNUM) return NTO_REG_FLOAT; return -1; /* Error. */ } static int i386nto_register_area (int regno, int regset, unsigned *off) { int len; *off = 0; if (regset == NTO_REG_GENERAL) { if (regno == -1) return NUM_GPREGS * 4; *off = nto_reg_offset (regno); if (*off == -1) return 0; return 4; } else if (regset == NTO_REG_FLOAT) { unsigned off_adjust, regsize, regset_size; if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR) { off_adjust = 32; regsize = 16; regset_size = 512; } else { off_adjust = 28; regsize = 10; regset_size = 128; } if (regno == -1) return regset_size; *off = (regno - FP0_REGNUM) * regsize + off_adjust; return 10; /* Why 10 instead of regsize? GDB only stores 10 bytes per FP register so if we're sending a register back to the target, we only want pdebug to write 10 bytes so as not to clobber the reserved 6 bytes in the fxsave structure. */ } return -1; } static int i386nto_regset_fill (int regset, char *data) { if (regset == NTO_REG_GENERAL) { int regno; for (regno = 0; regno < NUM_GPREGS; regno++) { int offset = nto_reg_offset (regno); if (offset != -1) regcache_collect (regno, data + offset); } } else if (regset == NTO_REG_FLOAT) { if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR) i387_fill_fxsave (data, -1); else i387_fill_fsave (data, -1); } else return -1; return 0; } static struct link_map_offsets * i386nto_svr4_fetch_link_map_offsets (void) { static struct link_map_offsets lmo; static struct link_map_offsets *lmp = NULL; if (lmp == NULL) { lmp = &lmo; lmo.r_debug_size = 8; /* The actual size is 20 bytes, but only 8 bytes are used. */ lmo.r_map_offset = 4; lmo.r_map_size = 4; lmo.link_map_size = 20; /* The actual size is 552 bytes, but only 20 bytes are used. */ lmo.l_addr_offset = 0; lmo.l_addr_size = 4; lmo.l_name_offset = 4; lmo.l_name_size = 4; lmo.l_next_offset = 12; lmo.l_next_size = 4; lmo.l_prev_offset = 16; lmo.l_prev_size = 4; } return lmp; } static int i386nto_pc_in_sigtramp (CORE_ADDR pc, char *name) { return name && strcmp ("__signalstub", name) == 0; } #define SIGCONTEXT_OFFSET 136 static CORE_ADDR i386nto_sigcontext_addr (struct frame_info *frame) { if (get_next_frame (frame)) return get_frame_base (get_next_frame (frame)) + SIGCONTEXT_OFFSET; return read_register (SP_REGNUM) + SIGCONTEXT_OFFSET; } static void init_i386nto_ops () { current_nto_target.nto_regset_id = i386nto_regset_id; current_nto_target.nto_supply_gregset = i386nto_supply_gregset; current_nto_target.nto_supply_fpregset = i386nto_supply_fpregset; current_nto_target.nto_supply_altregset = nto_dummy_supply_regset; current_nto_target.nto_supply_regset = i386nto_supply_regset; current_nto_target.nto_register_area = i386nto_register_area; current_nto_target.nto_regset_fill = i386nto_regset_fill; current_nto_target.nto_fetch_link_map_offsets = i386nto_svr4_fetch_link_map_offsets; } static void i386nto_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* NTO uses ELF. */ i386_elf_init_abi (info, gdbarch); /* Neutrino rewinds to look more normal. */ set_gdbarch_decr_pc_after_break (gdbarch, 0); /* NTO has shared libraries. */ set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section); set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); set_gdbarch_pc_in_sigtramp (gdbarch, i386nto_pc_in_sigtramp); tdep->sigcontext_addr = i386nto_sigcontext_addr; tdep->sc_pc_offset = 56; tdep->sc_sp_offset = 68; /* Setjmp()'s return PC saved in EDX (5). */ tdep->jb_pc_offset = 20; /* 5x32 bit ints in. */ set_solib_svr4_fetch_link_map_offsets (gdbarch, i386nto_svr4_fetch_link_map_offsets); /* Our loader handles solib relocations slightly differently than svr4. */ TARGET_SO_RELOCATE_SECTION_ADDRESSES = nto_relocate_section_addresses; /* Supply a nice function to find our solibs. */ TARGET_SO_FIND_AND_OPEN_SOLIB = nto_find_and_open_solib; init_i386nto_ops (); } void _initialize_i386nto_tdep (void) { gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_QNXNTO, i386nto_init_abi); } <<<<<<<<<<<<<<<<<< i386-nto-tdep.c ends >>>>>>>>>>>>>> <<<<<<<<<<<<<<<< nto-tdep.c >>>>>>>>>>>>>>>> /* nto-tdep.c - general QNX Neutrino target functionality. Copyright 2003 Free Software Foundation, Inc. Contributed by QNX Software Systems Ltd. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include "gdb_string.h" #include "nto-tdep.h" #include "top.h" #include "cli/cli-decode.h" #include "cli/cli-cmds.h" #include "inferior.h" #include "gdbarch.h" #include "bfd.h" #include "elf-bfd.h" #include "solib-svr4.h" #include "gdbcore.h" #ifdef __CYGWIN__ #include #endif #ifdef __CYGWIN__ static char default_nto_target[] = "C:\\QNXsdk\\target\\qnx6"; #elif defined(__sun__) || defined(linux) static char default_nto_target[] = "/opt/QNXsdk/target/qnx6"; #else static char default_nto_target[] = ""; #endif struct nto_target_ops current_nto_target; static char * nto_target (void) { char *p = getenv ("QNX_TARGET"); #ifdef __CYGWIN__ static char buf[PATH_MAX]; if (p) cygwin_conv_to_posix_path (p, buf); else cygwin_conv_to_posix_path (default_nto_target, buf); return buf; #else return p ? p : default_nto_target; #endif } /* Take a string such as i386, rs6000, etc. and map it onto CPUTYPE_X86, CPUTYPE_PPC, etc. as defined in nto-share/dsmsgs.h. */ int nto_map_arch_to_cputype (const char *arch) { if (!strcmp (arch, "i386") || !strcmp (arch, "x86")) return CPUTYPE_X86; if (!strcmp (arch, "rs6000") || !strcmp (arch, "ppc")) return CPUTYPE_PPC; if (!strcmp (arch, "mips")) return CPUTYPE_MIPS; if (!strcmp (arch, "arm")) return CPUTYPE_ARM; if (!strcmp (arch, "sh")) return CPUTYPE_SH; return CPUTYPE_UNKNOWN; } int nto_find_and_open_solib (char *solib, unsigned o_flags, char **temp_pathname) { char *buf, arch_path[PATH_MAX], *nto_root, *endian; const char *arch; char *path_fmt = "%s/lib:%s/usr/lib:%s/usr/photon/lib\ :%s/usr/photon/dll:%s/lib/dll"; nto_root = nto_target (); if (strcmp (TARGET_ARCHITECTURE->arch_name, "i386") == 0) { arch = "x86"; endian = ""; } else if (strcmp (TARGET_ARCHITECTURE->arch_name, "rs6000") == 0) { arch = "ppc"; endian = "be"; } else { arch = TARGET_ARCHITECTURE->arch_name; endian = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "be" : "le"; } sprintf (arch_path, "%s/%s%s", nto_root, arch, endian); buf = alloca (strlen (path_fmt) + strlen (arch_path) * 5 + 1); sprintf (buf, path_fmt, arch_path, arch_path, arch_path, arch_path, arch_path); return openp (buf, 1, solib, o_flags, 0, temp_pathname); } void nto_init_solib_absolute_prefix (void) { char buf[PATH_MAX * 2], arch_path[PATH_MAX]; char *nto_root, *endian; const char *arch; nto_root = nto_target (); if (strcmp (TARGET_ARCHITECTURE->arch_name, "i386") == 0) { arch = "x86"; endian = ""; } else if (strcmp (TARGET_ARCHITECTURE->arch_name, "rs6000") == 0) { arch = "ppc"; endian = "be"; } else { arch = TARGET_ARCHITECTURE->arch_name; endian = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "be" : "le"; } sprintf (arch_path, "%s/%s%s", nto_root, arch, endian); sprintf (buf, "set solib-absolute-prefix %s", arch_path); execute_command (buf, 0); } char ** nto_parse_redirection (char *pargv[], char **pin, char **pout, char **perr) { char **argv; char *in, *out, *err, *p; int argc, i, n; for (n = 0; pargv[n]; n++); if (n == 0) return NULL; in = ""; out = ""; err = ""; argv = xcalloc (n + 1, sizeof argv[0]); argc = n; for (i = 0, n = 0; n < argc; n++) { p = pargv[n]; if (*p == '>') { p++; if (*p) out = p; else out = pargv[++n]; } else if (*p == '<') { p++; if (*p) in = p; else in = pargv[++n]; } else if (*p++ == '2' && *p++ == '>') { if (*p == '&' && *(p + 1) == '1') err = out; else if (*p) err = p; else err = pargv[++n]; } else argv[i++] = pargv[n]; } *pin = in; *pout = out; *perr = err; return argv; } /* The struct lm_info, LM_ADDR, and nto_truncate_ptr are copied from solib-svr4.c to support nto_relocate_section_addresses which is different from the svr4 version. */ struct lm_info { /* Pointer to copy of link map from inferior. The type is char * rather than void *, so that we may use byte offsets to find the various fields without the need for a cast. */ char *lm; }; static CORE_ADDR LM_ADDR (struct so_list *so) { struct link_map_offsets *lmo = nto_fetch_link_map_offsets (); return (CORE_ADDR) extract_signed_integer (so->lm_info->lm + lmo->l_addr_offset, lmo->l_addr_size); } static CORE_ADDR nto_truncate_ptr (CORE_ADDR addr) { if (TARGET_PTR_BIT == sizeof (CORE_ADDR) * 8) /* We don't need to truncate anything, and the bit twiddling below will fail due to overflow problems. */ return addr; else return addr & (((CORE_ADDR) 1 << TARGET_PTR_BIT) - 1); } Elf_Internal_Phdr * find_load_phdr (bfd *abfd) { Elf_Internal_Phdr *phdr; unsigned int i; if (!elf_tdata (abfd)) return NULL; phdr = elf_tdata (abfd)->phdr; for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++) { if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_X)) return phdr; } return NULL; } void nto_relocate_section_addresses (struct so_list *so, struct section_table *sec) { /* Neutrino treats the l_addr base address field in link.h as different than the base address in the System V ABI and so the offset needs to be calculated and applied to relocations. */ Elf_Internal_Phdr *phdr = find_load_phdr (sec->bfd); unsigned vaddr = phdr ? phdr->p_vaddr : 0; sec->addr = nto_truncate_ptr (sec->addr + LM_ADDR (so) - vaddr); sec->endaddr = nto_truncate_ptr (sec->endaddr + LM_ADDR (so) - vaddr); } static void fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which, CORE_ADDR reg_addr) { nto_regset_t regset; nto_init_solib_absolute_prefix (); if (which == NTO_REG_GENERAL) { memcpy ((char *) ®set, core_reg_sect, min (core_reg_size, sizeof (regset))); nto_supply_gregset ((char *) ®set); } else if (which == NTO_REG_FLOAT) { memcpy ((char *) ®set, core_reg_sect, min (core_reg_size, sizeof (regset))); nto_supply_fpregset ((char *) ®set); } else if (which == NTO_REG_ALT) { memcpy ((char *) ®set, core_reg_sect, min (core_reg_size, sizeof (regset))); nto_supply_altregset ((char *) ®set); } } void nto_dummy_supply_regset (char *regs) { /* Do nothing. */ } /* Register that we are able to handle ELF file formats using standard procfs "regset" structures. */ static struct core_fns regset_core_fns = { bfd_target_elf_flavour, /* core_flavour */ default_check_format, /* check_format */ default_core_sniffer, /* core_sniffer */ fetch_core_registers, /* core_read_registers */ NULL /* next */ }; void _initialize_nto_tdep () { add_show_from_set (add_set_cmd ("nto-debug", class_maintenance, var_zinteger, (char *) &nto_internal_debugging, "Set QNX NTO internal debugging.\n\ When non-zero, nto specific debug info is\n\ displayed. Different information is displayed\n\ for different positive values.", &setdebuglist), &showdebuglist); /* We use SIG45 for pulses, or something, so nostop, noprint and pass them. */ signal_stop_update (target_signal_from_name ("SIG45"), 0); signal_print_update (target_signal_from_name ("SIG45"), 0); signal_pass_update (target_signal_from_name ("SIG45"), 1); /* By default we don't want to stop on these two, but we do want to pass. */ #if defined(SIGSELECT) signal_stop_update (SIGSELECT, 0); signal_print_update (SIGSELECT, 0); signal_pass_update (SIGSELECT, 1); #endif #if defined(SIGPHOTON) signal_stop_update (SIGPHOTON, 0); signal_print_update (SIGPHOTON, 0); signal_pass_update (SIGPHOTON, 1); #endif /* Register core file support. */ add_core_fns (®set_core_fns); } <<<<<<<<<<<<<<<<<< nto-tdep.c ends >>>>>>>>>>>>>> <<<<<<<<<<<<<<<< nto-tdep.h >>>>>>>>>>>>>>>> /* nto-tdep.h - QNX Neutrino target header. Copyright 2003 Free Software Foundation, Inc. Contributed by QNX Software Systems Ltd. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef _NTO_TDEP_H #define _NTO_TDEP_H #include "defs.h" #include "solist.h" /* Generic functions in nto-tdep.c. */ extern void nto_init_solib_absolute_prefix PARAMS ((void)); char **nto_parse_redirection PARAMS ((char *start_argv[], char **in, char **out, char **err)); int proc_iterate_over_mappings PARAMS ((int (*func) (int, CORE_ADDR))); void nto_relocate_section_addresses PARAMS ((struct so_list *, struct section_table *)); int nto_map_arch_to_cputype PARAMS ((const char *)); int nto_find_and_open_solib PARAMS ((char *, unsigned, char **)); /* Dummy function for initializing nto_target_ops on targets which do not define a particular regset. */ void nto_dummy_supply_regset PARAMS ((char *regs)); /* Target operations defined for Neutrino targets (-nto-tdep.c). */ struct nto_target_ops { int nto_internal_debugging; unsigned nto_cpuinfo_flags; int nto_cpuinfo_valid; int (*nto_regset_id) (int); void (*nto_supply_gregset) (char *); void (*nto_supply_fpregset) (char *); void (*nto_supply_altregset) (char *); void (*nto_supply_regset) (int, char *); int (*nto_register_area) (int, int, unsigned *); int (*nto_regset_fill) (int, char *); struct link_map_offsets *(*nto_fetch_link_map_offsets) (void); }; extern struct nto_target_ops current_nto_target; /* For 'maintenance debug nto-debug' command. */ #define nto_internal_debugging \ (current_nto_target.nto_internal_debugging) /* The CPUINFO flags from the remote. Currently used by i386 for fxsave but future proofing other hosts. This is initialized in procfs_attach or nto_start_remote depending on our host/target. It would only be invalid if we were talking to an older pdebug which didn't support the cpuinfo message. */ #define nto_cpuinfo_flags \ (current_nto_target.nto_cpuinfo_flags) /* True if successfully retrieved cpuinfo from remote. */ #define nto_cpuinfo_valid \ (current_nto_target.nto_cpuinfo_valid) /* Given a register, return an id that represents the Neutrino regset it came from. If reg == -1 update all regsets. */ #define nto_regset_id(reg) \ (*current_nto_target.nto_regset_id) (reg) #define nto_supply_gregset(regs) \ (*current_nto_target.nto_supply_gregset) (regs) #define nto_supply_fpregset(regs) \ (*current_nto_target.nto_supply_fpregset) (regs) #define nto_supply_altregset(regs) \ (*current_nto_target.nto_supply_altregset) (regs) /* Given a regset, tell gdb about registers stored in data. */ #define nto_supply_regset(regset, data) \ (*current_nto_target.nto_supply_regset) (regset, data) /* Given a register and regset, calculate the offset into the regset and stuff it into the last argument. If regno is -1, calculate the size of the entire regset. Returns length of data, -1 if unknown regset, 0 if unknown register. */ #define nto_register_area(reg, regset, off) \ (*current_nto_target.nto_register_area) (reg, regset, off) /* Build the Neutrino register set info into the data buffer. Return -1 if unknown regset, 0 otherwise. */ #define nto_regset_fill(regset, data) \ (*current_nto_target.nto_regset_fill) (regset, data) /* Gives the fetch_link_map_offsets function exposure outside of solib-svr4.c so that we can override relocate_section_addresses(). */ #define nto_fetch_link_map_offsets() \ (*current_nto_target.nto_fetch_link_map_offsets) () /* Keep this consistant with neutrino syspage.h. */ enum { CPUTYPE_X86, CPUTYPE_PPC, CPUTYPE_MIPS, CPUTYPE_SPARE, CPUTYPE_ARM, CPUTYPE_SH, CPUTYPE_UNKNOWN }; enum { OSTYPE_QNX4, OSTYPE_NTO }; /* These correspond to the DSMSG_* versions in dsmsgs.h. */ enum { NTO_REG_GENERAL, NTO_REG_FLOAT, NTO_REG_SYSTEM, NTO_REG_ALT, NTO_REG_END }; typedef char qnx_reg64[8]; typedef struct _debug_regs { qnx_reg64 padding[1024]; } nto_regset_t; #endif <<<<<<<<<<<<<<<<<< nto-tdep.h ends >>>>>>>>>>>>>> <<<<<<<<<<<<<<<< config/tm-qnxnto.h >>>>>>>>>>>>>>>> /* Target machine sub-description for QNX Neutrino version 6. This is included by other tm-*.h files to specify nto specific stuff. Copyright 2003 Free Software Foundation, Inc. This code was donated by QNX Software Systems Ltd. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef _TM_QNXNTO_H #define _TM_QNXNTO_H #include "tm-sysv4.h" /* Setup the valid realtime signal range. */ #define REALTIME_LO 41 #define REALTIME_HI 56 /* Set up the undefined useable signals. */ #define RAW_SIGNAL_LO 32 #define RAW_SIGNAL_HI (REALTIME_LO - 1) #define TARGET_SIGNAL_RAW_VALUES \ TARGET_SIGNAL_RAW0, \ TARGET_SIGNAL_RAW1, \ TARGET_SIGNAL_RAW2, \ TARGET_SIGNAL_RAW3, \ TARGET_SIGNAL_RAW4, \ TARGET_SIGNAL_RAW5, \ TARGET_SIGNAL_RAW6, \ TARGET_SIGNAL_RAW7, \ TARGET_SIGNAL_RAW8 #define TARGET_SIGNAL_RAW_TABLE \ {"SIGNAL32", "Signal 32"}, \ {"SIGNAL33", "Signal 33"}, \ {"SIGNAL34", "Signal 34"}, \ {"SIGNAL35", "Signal 35"}, \ {"SIGNAL36", "Signal 36"}, \ {"SIGNAL37", "Signal 37"}, \ {"SIGNAL38", "Signal 38"}, \ {"SIGNAL39", "Signal 39"}, \ {"SIGNAL40", "Signal 40"} #endif /* _TM_QNXNTO_H */ <<<<<<<<<<<<<<<<<< config/tm-qnxnto.h ends >>>>>>>>>>>>>> <<<<<<<<<<<<<<<< config/i386/i386nto.mt >>>>>>>>>>>>>>>> # Target: Intel 386 running qnx6. TDEPFILES = i386 - tdep.o i387 - tdep.o corelow.o solib.o solib - svr4.o i386 - nto - tdep.o nto - tdep.o remote - nto.o TM_FILE = tm - i386nto.h <<<<<<<<<<<<<<<<<< config/i386/i386nto.mt ends >>>>>>>>>>>>>> <<<<<<<<<<<<<<<< config/i386/tm-i386nto.h >>>>>>>>>>>>>>>> /* QNX Neutrino target header. Copyright 2003 Free Software Foundation, Inc. This code was donated by QNX Software Systems Ltd. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef TM_I386NTO_H #define TM_I386NTO_H 1 /* Pick up most of what we need from the generic i386 target include file. */ #include "i386/tm-i386.h" #include "tm-qnxnto.h" #include "solib.h" #endif /* TM_I386NTO_H */ <<<<<<<<<<<<<<<<<< config/i386/tm-i386nto.h ends >>>>>>>>>>>>>> ------=_NextPart_000_0369_01C30FD6.9579C7B0 Content-Type: application/x-compressed; name="nto.tgz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="nto.tgz" Content-length: 9634 H4sIANE5sT4AA+w8+3PbNtL91forUHcaS7YcS44fuShJR7Flx/M5ss6SL8k0 GQ5FghJriuTHhx+95n+/3cWDICXa6d21nZuJpo0lYLFYALuLfZH+s+cH22EW bWcuj5863/0Rn0630znc3/+u09k93D3cw797e7td+Iuf7sH+LvQdHuzv7T7b 2z88BPi9vc7hd6zzh1BT+eRpZieMfXfNb+3kmod1cIvrWRLlsRVY7p9B1p/1 2dlkfpkF2Da1sDTmju/5DvPy0Mn8KLQDP7tnXpSwvw8/sCHPs8QPo6eNBmPs KIrvE382z9hup/OMnSScs3HkZbCnnJ1EeejaiKLNzkJHjQhh/DTPuMum94RS DxjfpxlfpOw8cwXwZO6nzPMDzuBvbCcZizx2evzG6I2TaJbYCwTwcPZUIuux +yhnjh2yhLt+Kudkfsbs0N2BxSwi1/fuEQ+0AaE8Ydmcs4wnQAFMgz9Oh1fs lIc8sQM2yqcB7Mq57/Aw5cyGqbElndNCEA+OqNuBHuM+9Cfshicp/Ga7ag6J sM2iBJE07QwpT1gU47gWkHvPAjsrhq5efLFGl/khYZ5HMaxnDghhhbd+ELAp Z3nKvTxoIwoAZu/PJm8vriasP/zI3vcvL/vDycceAGfzCHr5DReo/EUc+IAZ VpXYIbBD5CGGd4PLo7cwpP/m7Pxs8hGWwE7OJsPBeMxOLi5Zn436l5Ozo6vz /iUbXV2OLsaDp4yNOZLFEcEDG+zRGcEmujyz/SAVy/4Ih5oCbYHL5vYNh8N1 uH8DlNnMAV58/OAQiR1E4YwWCcDFNvaY77EwytrsNvGBV7Jo+UhxeJWv22z/ b2zCYYs4GwW2w0GUxjliePasQzv9JkozhH7XZ53dbre73X3WOWyzq3EftmNz p9H4wQ+dIHc5W5+5UwtPMpw9na9X2u005UlWbne5l5ZbPFgKLzeBqpvxysCE zxzbmVcg0yjwp9vpTbJXbidlQYqi1KzVR6k1Su2pvzT+UENCuwcC57EPzw+s o9GVdfJhfNn4AVr8kJcaWbN7zl6+ZN3dVuMHHoLENhqgut7P71n32U+MnUfR NbI7CsxOniY7csKdu+cHOw6oGn4Hy2ZzbqN8gyRIvoNuy4lzCzYB5AbkisGe 506WA7+BfkAJ3AB5STn+ZBv87m6D/ZKH10wNEPKOopVCR5qhlgp4Asd5HIUb oGTSa7YAoca/yETXPAl5wGb5fSqOXK12ePXOOh1dDk7HsCJa3Ds7Bm4GLacn Y2G+mKJ+ipCayPNSnikhB5iCdoEabrYMGN4PM+xd2PHPn9kr9k8guXnINtle q722tgYTcfsOwaH5oNTsqOb9UrOrmvdKzVPV3O2W2tNYtu+WmuOpAi9D+7K5 U55TNT8vNfsKd7cM7gX2LJVdfzN7HNXaLVGTquZtQY1oFUeJPV96dCKnPupB m4EM4o6GURv+wH6LE9DnAcejbseNtDg8fTrIM6DUYC7QM7obGAgYK4xuw+rp NQAjcqglZ2jKEw2jVgNPU9LQpCb2+hXrsCdPBAB7aTBWi/2kGIE6P7MXQESv 8aWhJruJfLeBIo4zpnkcB/fWDGBpVmcOhtLmLMbfYuI8TP1ZCEqX0PWgBSkD BQgXA1DRQ02N6ltShk2arJNRxwKigDrZtrXVwo0h/sQPopILfsWqOyBW31Og Hmsq0FewpFZjTRKvd7cpz0uuosWeEJkaBQ/gSqgdJRbNtiRBctSXR3bOi8tb 5xlbhyQjKCgfP/Qi6wasKxePzWwUbPxbSROKTUI1qqe5S/EGbEr0SButZgmu AvYw8Yp0yWvwvc3EMuDKs8UiUrg6nTntEu6KcXyODTf3cHKBR2ydDoaDy/75 C5QptPPmNpopnscTjmecgEqGa45MuhHNhRo1JPuOCbmUS1nJlkSOOsZpwu3r 3jIJJ+cX/cmL1ZiKY6pDZR40yqNCIMZZcHBVkcTjlUwvGBLRSDlVNA2Gx+qs DHhTMlYOk7tZM/TooaG0CySVsgOkX6i6QZJEidjt2qWSSFhg+9jGctvMZBCt EDZBUOROQHfAQ5oVW4Vi0DskZbayuIomqG7mmlpXcWeC1qYp8COneVxnCMAy zo4CkL/3FAuUt7tCN+1smWq9FzCJZbtoHLRpo/xfeVvumIU/NN3/gU5Y+2dj jRkzwfKf7fawTc4IDd0D3SBnhsb9LoJ9KWnBZVy7z6u4OitwdQnsS+OxY1u1 dnlmcsC2KQRwtmriLYOsyjl19cEpu7ADvAcsa+MJKAxgKqJBFYXBPdzH4FWk CDe9z+BLDAr/ZCSREGJ1cUe4llu+AUZhisYnKCu76J7azrXyEYSB3S6Q3HIx 2S14Syx2+TSfIaxwLPTUMAPoRHA5sM8JoulUWJbiI8w7MPnRvzmQQ6TZJ5V/ xfJTHFuI+cMaDC2dh1X97xFXpRv04dbZAIX8GjaAYL+vuv3XSlf/95LL5NmR U2M5EdhwTqZvclyReY9L1v/94v2fCCvdyrjn+u5GstpIftkeMQBXwimyTWWP h10cfcc8ecElLPDDawusQLmfYPsWlz84fJbH4Va3lqCaaCbIi/9hfMGCjMHH Zg0WMRzu8Or8nCjGHaUm0VbebgH7hDDrpuhpYpFIKQ30vIeX2QTkwgZpAJ+f 2sGy3pWS1sZgRwPuPOQSEsznUp4wTJOn3DVNDjFDQTPMsNdb6pNz75UI06uV vbudOtL293fraFNU1xIXgC50k4K6Tm+5czV5VmgveM2yZGfdQHCli4F4fSz1 1owEO+vGGHnQW+4tRgr2LhgZGKBOicWO5YcwdJYlNrBJ8+jicmD1j48vWewo TYYrKnlL2IDiCtzp4KB1CzGEdpBm+XS9Tf0t5EUhQcpNH5+dHl0MJ4MPE+vi 5GQ8mIC3fqCI0hMX8uTPZPSBDoM1pTBQbMZCHQFuQaJpQxGA+0PsIrWDvU7d JXsOQQSGKRq5dUNAzy2Ra+oGsORcw9cZj/SNu3Jg1V8IfTB95TqjGPSDWIOT J2jXW9gs401lW/kVW7Kfe/XjKub+qxo/4HEM2sxfQqF6HsdhB5lGgs1uvljc lz2mx5HUkfHo+LINXtrGov3h8fqyXzoEbH1gbM2d8Ep5mY/dHrXuJrGRPfW1 aMzcqZ0ABhIO/KfNyj1sU35Rd1FpGMYW2Sb9+6rc2FTDSAZAGcPtjlo1ZYPz E6VZkSyLB55Bl6BhabCM8IAU3fqhm6LlFmAUkmLVYZQs7EAhxf1VpLjcSVBj 2R6eGDmZmrI265SIQ0c5BfUFZl/gTxM78Xm6CidqP4zXWo4NpgJpQfgZcgMx gMQBaGZOqRwyH0wM6bUfGwPBbHLN0aD6XDmFASTYQ1BsIqvq44KIlQqbiMET 2n5dVZeGjJR7jCEOotO3yv5BqSs1ru6D52pvxzz7ZRE3WxSdI1U4OmJoYFHK ZHD8gTX3W2qjBa5fpqVp5HW+f/cMLm+fgn5okssovtgOsV8PWlRqZ+jWX/sa OdL8cZEnwG8Uzp7boRuQFwETwoqCyKGsBLQEmJMDS0KHW+A7BVcosi9XOOlf ng4m1hht3fOLo/5kYI0HR5OziyFdZoPxeDDWVjgh54qR6DB4CkKk95aUGfhH oe9wnTtE6UAmogA90Zkuz35yNjy2+vD/xWgwhIbzszdyWuI/WCXcM1zyujAZ l+8gUjSkYUiEfTDLf+UaRiiCwpBVLKtVKKUsWHPqwXwkWjAQxLKNbqN1Me6/ ObP+PvwAwklnVqg+pS5o/r86qfs7Pn9w6p8+D+f/d7udw24l///ssNv5lv// Mz4gsaXU/0wmS80Uv4xqlAsBvuX9v+X9v+X9/+t5/5fpfbqDdvLT+euvqAZY nXfPokqDE/g78P82GJ9g2K3ucxZupYAADF+e+FGyVICAN2O5Ee7LcgOY0NtL jXVFBYDSgZNWJQFYEWBZRx9P358NLauyN879DOxt2h1ZB7A8QvoZ5PlDl50H pj9DWfD1oxefPoHySd3rT59E+6dP/x/eHaz3AHEAjCAcfrdpgX8WWlaL/fab bgOrLL9rfdU8OyDHO2KiHdG+U0wD7Pg1OAhYLFZ6OwUEmT3LTluvUcK82Si6 TPtHdJKrxDMe3rDmOtBqCZtsHY3N5d3VgT0aPM29n0f9yVvrXf/DZ5XYiUW4 QpwVOBPhjYVmf5T6d1Zsg9g1Y4x2eeVk5QPgyztTjJcmPPxUe6rbYvYT/P9i xcbqHf1Cmf2JfQ0qnQkRY2kOXiYoeGH8JekBmCltBvb4UyoKAXMcNWqEif6j 0dXk42hgfQBIut7k79HoSI1IFdugXkaBJZdux00X6QwkTmgAleZHU1+4rBRF zu5BhTdhR9JMnlXh+OJGf6/CV8LBovKcdWLVas8ddpSiSAbpvRp0YumrEcax U4MQ1l6HcOHHac2od2ejcd0wO1nUjOpfvqsblM5rxozfGmyjGq+G/ze8eD8k 90Edxgq3Q+Xy6YeR8JSxfhVu3AQ7JibeLQKPogfYtM2Emwy9hei02SY5WBHe P5vIm3ZI8ZjK2fcKqYXxlrdAd3T9x3QH6HkBf7D4yfgazyO4ebDlU6PS5gbB CzEOv66TQ6VIkH6XUhgttcdqi6XT1ofr/2wCvuLV5WD7Na0K11swIsZPy4F8 iuC8Evyokx20WqnpltIxXz2n5tb6WZFpl2ed8sq8q8Y+PP0SUgn+5iN40xeX x4NLpOrNyTGm/c/6Q+vN2SkoJ5wa9NN6UFCA+jUGNZR5gpOJT9p0xD+mP6YY mtZ8IjhdzCkiA8BeMLkdoJtOWxeABddUrIKRXdWmcWOCdR86RFJJz02MqgYa LPv4V0rBFejNkDMKUixxd9tMSpEWHtCyZcEpvHntZIuwij2Fv2DsYtrA8++W 7jTzWoL17X5eKXSFMH2l7H0Tkf99ESlz+DoG9IRhqnhqW/IUYTL5GGi/4w5y nRMtFmgKCBwdwadS9ROrgrOacgtdz0REytTFAR2zm58/64si9sPiO/hcxQ+e JObFsYkDC4bFYZsEvwmA8G+s6u8AzmkzHzahKMALReJdTB5+7rFwa0tzbGhw g66sOT8X+DTLoT+ovsOM8nsDD392A7/uHNI6iG6LZNv/lYM3RjN2PtNkSBmK TU+R5SNZQKigLmQvCURQV2IwtFA18bKNKngoXbzxekPVDcRbW7ouYDOW1QCC 9Jg6RGLdaCWsW1uIt1QHY+J/+TB+2qUqetH4CPatLcK/u4GpSP2zWI5BwxMB 04xJVVNTd0MSIM4DFqRpKBMo+qsUytY6Ehtr1ONvbX1e2n2EQ9bFCD0dJ/Gu ogF/CuTwr2FrCQ6WFvec68qAhSVyLOfvKODcJiublGuShxRujrOEkuDg42MY wkuiBdJhOJQOuuuYSYuS7JFQNY68nfugsnyzEBGRksOP+HSwRfjnZUpJKmEN owjkTdRjq+ADxuvJQSBs2oNmtF6y5mFO6ZLRTic2hYUoKI93GNvEa1GEbW45 oLrHkA3VATCVN1DBdBlEYezGhllyDJXxwE11+AYXE3LcLxA2GysiMxV1FyQE ix7VNi/lr+VJ6KRcGlmBD3ch2L2lrNuqoo5IBe1rkh4lg6BI1rdAuWaJ7WSW MKkt3NsZJqbTaPu13Hn8wrZkugQ/MB20mWUQ7Zpe1EelqtditUusZpQQ4NjC 35JX1mhyCbfTBIVQqjlzHZvsudBeWInGmUsPAtA5YERJzoNxvWwO3qbgdjwq TCRlt77rBuiEToF/b6U4iuidZ/sBc3MKTEXAnx4AYOxqGvBFWpSGKGGTabJq fRAl1p6wZtMkuYsPV5QX12LbZBLChg0CzzpDTg/twBrNXWRe8o0wAWXF2IAZ EzCS4F+xWSuGIBwSpH0mvKx8XfrzPWZdM6rPahKeFRcStNBsoFgqwNuvFfri YukxH24UhIT/5aMfChrOeR7mGPLb2moT0qX6c4xjQDtgtkhw4bBHE+v8on+M ilj3iRqvJ2x0Yn1oFUWOipxSIZ5YhWnS1mupVbKnU+EKOrPh8KGHOy2llIqo fcJtVBbAWUIEGFWLyAmErsBbCiX0KcU7Cl2I6kjsAzGmOU4Gl0Wsnv2D9d+c EQenkfkUBLI7KaqpVFFgHTg5xrFdgrZjEVDOIjNhqZi4hnvgUKtsByvffo1H WuKsG5k9JpifmDoq0fxCPplAQyXgsgYoerdYoQ0jlApCI1PoAAS25cNYFEAt okpphFCcGBE1nkuS5qNqJX4x4g9FO5YXN6T+IxGjq65dqDssjrQKtWbUgKjy T+3nPORwtbTkirv0sbLQBV84cEc2iycwdK1paU0NSfrCR5u5tCytbOUDBy1d LrnqwYDqRJWaydWkr6j0/LMIL55D+Lco75//RXQXRVH1hJsqb0XRlOLu4vkY UGTHESZj8IrUDyZA66WqV1MWEpqFpAVBlYhKCKznEVlDD8twQAfmKYV1M+i2 ExdpgmvT8VJ6+hHmXy8KqNPS01dS3dKueGGqStf1b/E4HVYLyGg83jZwI9xE edKmB84IUjQI3aZi0c6cO9eWoLAtHk4zWiqwiCUNST1LWKNFwK7SGgZsqdhP Pu6G19GaeAAEywfVk25L1RNF5YQ4HFAeVjqPbi00ci06P2rCnVmAU0xpKSrM BQfaCew0BQsQzbnQDh3gKjBXrV+leWc+kiVUjlT7NH5GBtL6GKagjPTkgikA pgGefgo/Nd7PeQj8Em7/ypOIAgDFE+yi7F4UlKUI7PppHNj3WFB7rO887Met R2ddJFQFDA5Ao6K4HTEzkfk3HBYS5MAxsMonsHiaBq/qllbAT3CbinZVJPOe 8rBYZLm3TwZLnINcp5gDhnt0waVhmKIEpFkUw3oiiloI6cMLNIZdxQt3oQvC qHrVQnArj100MZuSKWUXnRbVvTbXaer1lohd6ME0x78/Gg/6dwzu6v14c69Y HSVaGMz0xASeIiyIRWR0wJZltxHVSQs4DYRTy+dpjdQdzDQenA+OSDGu2h8N 8OA+1EKZ6zWAcF1GctIkZ/T2YnIxfIAcAfAYOauhKuQoIJMc2m2tQlExCEUp HWfFSyjNWsc1n1S03v9ajdO3T/2nKCD44+Z45P0v3d3O7rf6r7/oY9Z/zcEl WVX3JVznbwVf3wq+vhV8/fcKvsSbTyx03ybHg5H1Vj9jZLY9+IYX9MxTep0L vZ0Cl2+8rylV9SaiuFNODHY+mM8i1PyIiw9n2X83Bq+OcqtorMlM1MoEV0OD ywoJ0B6ZVcl2GckuM9eFqS7Ej+EK9Mws2MsEgygY5sTocQz2cFoQhHDNTVxo ix5bNaIb5KM29PIeyAJobNU4W12UTZNYV6hT7ICROC6NWlVRUtm3Iqijt4dQ oEeMnnNRU48Co700dHArVWFoNNOvVKY73Ah5Ex8zlpxmk471MTCXSN9WsIne v1XOeoVgctolhRNxY8DqEvkIgqp9QmIrFwuYli/Ft9fG+8da5ZRLeU36lQKr XcVSEHDpQdyeMbb02K58lgB5qvRYmmAusrFpQ0R3Oc7U0v7rajAV1XkMTkdR HgPUUMT3BmhpAcUDYQqS/ile0LA8RD0FtgJ1bbZHDK55VEUWZYgUk9Q7v6N+ EdjpBJhmwwgdSE9ehxc2mEzEl9+ltJo52KfGWrPm8bZl6JbOUh6Nrs6GJxdM BPp1ljDhiyjD5+2PBMqAEnXKNKBX6CHPyye88er1cnqvFCi4yKMXnpB9MIer Au46dcPjfzryQje7CFVZdpbZIMOAkpiBtKugAceC6Mg3E0TiLViIVhacAo1n YA/QHUrPFYNV4IfE+Q2R6ABn+pYn+PqC4BpxyBdMBWgjyZcWSA3iu+ibS3dR 2UBSmNgCFKs948uHUX4e/oFzKAHKI0hyinimueMAfrBlYAUJB0XC0QxQc9O5 6DOpmV88pP8V8xNgq/TSJyVU+p1PsEO+K8ythMf4goZQpluUnmsw9YoMNMgc DH8gmXge9EYK8WIMJn12G+w1AZ0ur0DrJAzFtmgJm489aduiuG2rUUJU1l4U 2H0Y3ZK6E0HaVUiVrvt6rIZ2rEerVePX4zW1qURcPkqKg2ccthxf5mVP0fhN jJfARYkQvn+1d309bcNA/J1PEbGXDpXSpkla9taJDqq1sDXdP6EJAS0sWpN2 pFlBE999d2c7OTspbBMUTcQv4LvYsZM7++7nyxWPGPNvQ1uKK6o7ypbxJ6PT hpa2LJQ2wvpS3F6doeXyjckMcFDfkPhgvEguLqyA8aenMQUHJSGMLJXBCDFR kEKjd4quwI/xpX0NTcDQy2yEIelAjKl9LsGqhqtUagrUVZnILJP/qlVn9HR2 hXKebV34fKppD5hS6D7B17a9XGt6wq+TYDrW1JRlepksJEysHhodMZ8liPzC YHFCQ5Vmw5iQnCUt6ssgLliF2B77FzKj78zFEiOWnRUBF6m9OLmez2LcgUDY 42A8kT6dFkTDQk/QlUb7+wovXW1HV17mZ1o8ksrdE11pRYh5vp1M5sJ7Q+s6 wMOchXDpIvUe45t4jvuPjKmfRElIBqMRpM9j9FkVA9B53Qc7t8sJneFA4x/w mowfF7aOuvGRT7z3h5+dalYF905lFBwRqH0+gwcSz2fRWLmge/7A3z/ZUggA uXLZBwN8bsaZa5WR6CyTE/wv/qg74JROX7uge7hHI0NvBr1TMgF/RNcohJ5z 3P7KeNKSkwlYUC5pPOnV4FqM0SA5btRtBxreaifN+GWJwKSfGgF73gV06SK4 3FmE2/Di4AU9Bg58N/5bbzq5/N+uUy/x37WUzGcPwbvA9TtOzsC5is+vgnmK MmiosAI0PcNpIVCKMF7h2IBMbdW+EZpLkUDiOPZGO5ql/QctlZr1j/DySOwI sEUtMYJpFp2WQHMJNJdAcw5oHg1k5gqONHMi/4A43AZb6qejoGUfbN45DVl4 0GBfTxcBuLPi6NmCN2e6/cMu2Ba9Qfekf2Q5jTz5oGe5nurckr2jsgi4EISJ QFeZk8vou/PpxO/tH3b62HvTLmJA/xU+BgxmzbxLlXREXIvNPnb6H7o+GKg5 Vr1aRG0UUu1CarOQ6hRS3UKqV0htFVLbd00TFKrfhVa/NgWxaW9ifI14jVC5 rXJmkzObBtPhTMdgupzpGkyPMz2D2eLMlsFsc2bbYO5y5q7OdOqMCZVbZX9i QARXA5Szp96U11ik/Ydw5Y7MZVMLFw97j3vsv7rteab959rl77+spbyQ5t8r C+OtUak86yqJIkSBMU9BbQMPIt/0+pQCilDtbUqJVZtRcvGshtFB09kS/iNA Qf2FCwhaQDBUNkcDMG2mVQR+Ky6BKqgl3hluvAjlz9KQi/KcFPSRC9d/2PXT R/yQ97hH/+2Gbcb/uC3HLfV/HUWm5F8V8mOVTlnplJVO2WM5ZbDB9WDF1Z0y TrQa5CK9C86/o48UQsc456WE6MXHnepE+lIGANE2KxVZuXSoVSpAmv+Wk1r0 jQRSGRy4uWEmcBK01HjWhvu8jOeylKUsZSlLWf7T8hu/BILaAHgAAA== ------=_NextPart_000_0369_01C30FD6.9579C7B0--