From mboxrd@z Thu Jan 1 00:00:00 1970 From: Scott Bambrough To: James Ingham Cc: Stan Shebs , GDB Patches Mail List Subject: Merge of ARM Linux port with existing ARM code... Date: Wed, 03 Nov 1999 12:02:00 -0000 Message-id: <382093BB.3FA78CBD@netwinder.org> X-SW-Source: 1999-q4/msg00163.html Content-type: multipart/mixed; boundary="----------=_1583534346-29875-0" This is a multi-part message in MIME format... ------------=_1583534346-29875-0 Content-length: 5989 Jim, I have finished merging the ARM code. It will require another round of patches to fix a few warts, but I would appreciate having it looked at. It has regressed a little from my previous version, but I'm almost back to where I was. I've attached a patch, and placed a tarball of the source on netwinder.org at: ftp://ftp.netwinder.org/users/s/scottb/gdb-991103.tar.gz I've made two targets in the configure scripts for ARM: linux and embedded. Basically I have: in gdb/config/arm: embed.mh, embed.mt, nm-embed.h, tm-embed.h, xm-embed.h linux.mh, linux.mt, nm-linux.h, tm-linux.h, xm-linux.h tm-arm.h Most files are very short. The bulk of the definitions are in tm-arm.h. tm-linux.h and tm-embed.h both include this and add/override anything necessary. in gdb: arm-tdep.c, armlinux-nat.c, arm-xdep.o Again, the bulk of the code is in arm-tdep.c. armlinux-nat.c contains stuff specific to linux. I'm not sure what to make of the code in arm-xdep.c. The Linux target makes no use of it, but the embedded target does. Much of it seems geared towards an Acorn machines. I have left it alone. You should have a look at it. If something doesn't seem right, or you don't like what I have done, please say so. Nothing is written in stone. I took the liberty of converting all the code to ANSI (except arm-xdep.c) and started converting all the macros in tm-arm.h to functions in preparation for being multi-arch friendly. I'm certain I have missed a few though. I intend to revisit the code. I have compiled, linked, and run the testsuite for GDB successfully for build = host = target=arm-unknown-linux-gnu. === gdb Summary === # of expected passes 6009 # of unexpected failures 48 # of unexpected successes 2 # of expected failures 195 # of unresolved testcases 3 I have compiled and linked for GDB successfully for: build=host=arm-unknown-linux-gnu, target=arm-elf build=host=arm-unknown-linux-gnu, target=arm-coff build=host=i586-pc-linux-gnu, target=arm-unknown-linux-gnu. build=host=i586-pc-linux-gnu, target=arm-elf build=host=i586-pc-linux-gnu, target=arm-coff This verifies there are no outstanding syntax errors or unresolved externals at least. The testsuite fails in all cases due to the lack of suitable cross compilers and target hardware. I don't believe I will be able to run the testsuites successfully for the embedded targets. The x86 builds wouldn't compile correctly due to the implementations of convert_from_extended(), convert_to_extended(). I have ifdef'd them out ATM, and replaced them with stubs, until I can resolve the problems. I don't have suitable environments to test: build=host=sparc-sun-solaris2.5 build=host=i686-cygwin32 TO DO: Shared library support: Both targets make use of IN_SOLIB_CALL_TRAMPOLINE. This needs to be resolved for ARM-Thumb compatibility. At the moment this is not implemented on Linux, and Thumb is not an issue on Linux (at this very moment at least). I have to get this support going, and I will resolve it then. Thread support: This has been waiting for Cygnus to integrate the threading patches, so I don't redo their efforts. Multi-arch readiness: 1) Remove EXTRA_FRAME_INFO. 2) Replace FRAME_FIND_SAVED_REGS with FRAME_INIT_SAVED_REGS. 3) Convert REGISTER_NAME to a function. 4) Convert to new CALL_DUMMY scheme. 5) Verify functions maintain name space purity. Note: There is code in arm-tdep.c for the new call dummy scheme. It was written by Cygnus, and I think Cygnus should enable it and verify its correctness. Breakpoints: I believe I have resolved Andrew Cagney's objections regarding the breakpoint code. The global BREAKPOINT macros are gone, and have been replaced by arm_breakpoint_from_pc(), and macros used to define the various types of breakpoints. I have added commments as he suggested indicating why things are as they are. The following problem with breakpoints still needs to be resolved however: Consider the following code and the generated instructions: 1 int foo (int a) 2 { 3 int b; 4 5 if (a == 3) 6 b = 10; 7 else 8 b = 20; 9 10 return b; 11 } 00000000 : 0: e1a0c00d mov ip, sp 4: e92dd800 stmdb sp!, {fp, ip, lr, pc} 8: e24cb004 sub fp, ip, #4 c: e3500003 cmp r0, #3 10: 13a00014 movne r0, #20 14: 03a0000a moveq r0, #10 18: e91ba800 ldmdb fp, {fp, sp, pc} The ARM uses a predicated instruction set (the condition in which it will execute is an integral part of the instruction; in the case of the ARM, the 4 most significant bits) which allows the following code: c: e3500003 cmp r0, #3 10: 13a00014 movne r0, #20 14: 03a0000a moveq r0, #10 In the current scheme in GDB, "break 6" will set a breakpoint on line 6 of the C code. This corresponds to the instruction at address 14: being replaced by the breakpoint instruction. Unfortunately it means that GDB stops at line 6 on the ARM all the time, even when a != 3. This could be solved by having breakpoint_from_pc() read the instruction at the PC, and merge the condition bits into the breakpoint. Then the breakpoint will only be executed under the same conditions as the original instruction. This will present a problem for single stepping, particularly with stepping using undefined instructions as breakpoints. What happens if the target of the step is an instruction that is not going to be executed due to its condition failing. Another problem is semantic. The user types "break 0x10" to break at address 10. If I am looking at an assembly dump I usually want the breakpoint to be unconditional. This could lead to unexpected results for the user. Scott -- Scott Bambrough - Software Engineer REBEL.COM http://www.rebel.com NetWinder http://www.netwinder.org gdb.patch.gz ------------=_1583534346-29875-0 Content-Type: application/x-gzip; charset=binary; name="gdb.patch.gz" Content-Disposition: inline; filename="gdb.patch.gz" Content-Transfer-Encoding: base64 Content-Length: 39020 H4sICPGGIDgAA2dkYi5wYXRjaAC8O2l320aSn6lfUVHyYlIEaV66V0lkHY7e WpKfJMc7k83DgkCDxAgEuDgoaxzvb986GhcJSrIzu0rMo1FdXffR3XQ814VO ehXNofMJTn67pbfI8Trx1IoUTJxxN4y8yWs7DFxv0o3TMY2Vvm50Op06sMZd quDaTgC2ob9/0Ns9GO3ih/39jXa7vYSDYa/CBcAA+r2D0eCgvyOwv/wCne2d HWMX2vKGA7YVK/hhbMWebc4se+oFCrxgAxqNMD7qBCoZxw59OzzEV/z64AWO ilobnUajMunIimaLkd+xw0j5G+01TyM1xqcaue8F6acS7ocY/gR62+319Ke9 /NN+r9diBvq97T3iQL8/xcJWx0Jygla2YOTFtvep3x3oRTsNJGtLSG4hzfyN SWzV08gAsZp5rQ3nq1SdRqrrBSVFyUCduuVJ4zIMRIl9GAwPRqODfr9O4Rp6 SeXDg15Z5dtDVjm/ZfLa/OHzNIyTL5ssKoD53N7qbHXmqkXf8C8IZQXHi+Kj zbmV2FNgpmfWvYLkHhLbB/VprtAqHfUPaxKkYC/iOLLBShOezB8EXH3yAjeE sRcjX7EKnM48gsk8Cl2I7BgmqecrmKvIB2uOKiQFqgQ8WiPxPoEzhjiwFt7E SkKcF6SxihabQikpEqDQpOhsCxWqR1mj+WgNcz+Uv5JwC8ygYstmKe709kmK 8laSYmJFE1XIEVdEMYbW2HvJWjIZaRtP/DCO/184ArBHn5DGrZcbMdkbMYY4 FypKuoxydbRqziuPG3fTFI5R7/1tGPQPhsOD7b2qTa9O+agcOFU2DPsc93r4 P37YEcPuGxjZ2j2jh/pAZ+6ilSX0jrIcW37D1GhMNwpnJj5Ds1PORmejU//k gB41fMdVDbdn/G71/8CvceI68nVAX2fhIm7MbcOPGHhlqSSsX6g0ni/jVJdR 9ct8rY4SR827dkWcMlSvHXlWE26G9arR8NWAs713MNwtAk7fGGF8xhdSy+st uBMrx5kkgCABO3QUuOjJCXr6McVouMHYDJc6ejePby5b3Y02zj0JZzOkTRwF alC8PX0DCIAzIH6MEzWLu2zrJ+H8ERmdJtA8aSFte3sGve7T636fXwf8OuTX 7Q6TTzPPI6XgNnSTBxLweZgGjpV4YWDARWAjcuZxsGcMtqFNb33iE773AttP kahNFJUZJ5EXTLrTzfIDO3Td116QqCiwfHzWQP4u9FfiZWYlgAHx5Pr8HHmZ jUM/xqgCb85PYes1rouypMAAd1Ni3fdDTMYTjMd2FMZAtFp2klq+/wgPUYir A1wpD0UcUdTACEHyTmdjDF0B48GBeBqmvoMROWFd+PGYhGk5TtTNl5JJNKbi WMlKs9ABFF8cQpMewI8waMED4xojHTAJEWCqUky5iWczqiQEDNvwMFUBYIS3 74l4NyeqGaPUkU5zbptebPJgs4XYkM2WEPMBU0iUpIGVKP+RFp+pZEpYlI+I xTZioh9ZwYEmCj6MIkxQLS0kmsOYXO8TzUO4WSG0caSsew5tKLkLTHZO8CqB qbVAEXgzRQx46M3IEKYh1YW/d2+ILlQNGzlz4aaBTbayJK7QcaA59hLogReT tFu4xK+KVIb/iBEmS6sSF0pwGYMADdKS7SsrApmPBpLjRiS0+veOcsltLm7N u18/XL4xj09Pb1gvrUZT3lFB/VYBeXn872frYf+swH64qoWGAvP/EDgL4TJn ICK3gStI58SAEz4EzBaaU4CBEI5hzH4VPR7i51kaJ6hploEF8/ABTRb5TB7C boXBm+sPV6fm6fXHq2ZgWC1AigMmAGlpQQfJbi0Df3ivQRGWgNuQgS7No2Bz S26AVEYY3TyXqR0OOiT3GYUbj90RjZipaqMns8Faczs2hwM4gv7hRpsRnfvW hJ1q/MggaG+mjUZmOuls9oja9X2yP/QFdk9aSEe4zIAo19OC1pJhdckncdyl FfCdPQmTpF5onsZTEzGlMwySGAkJy/nFf1yeHcDJ1Aomitd6/+H2V/P45u2H y7Oru1sxO5QLKsxLYvZS5HNh+eE87totFAnjmVtxzNOXjRws/J+/eTSMwWxu RRY6p4rEQttxghHUBpKY8Jm7+EslNsXYSGKLK0IjCA4jf1FqRcgBkgKjoQcF BSZHh3mILJgYxpHSVdYIWkUl1oBZO1WulfoJRGqC0RApD1A2LLQYq2fP9YSQ 4/cnt4ITNE4bMzxssXllc02e+/sfcLQBn2HT6m8a+Drg1yG/jvAVF8VIgbkc 0zMMGSXA5oKBFwy8YOBFBjyixhJ2AHYJWPpEYzDEpmEg+e2FJOEqLuHcdLf5 dYdfd2WVQQ/LPhgMsMLISHLn8aaxiS/wBUp/BDwCzK/yt/X6ULIfpSM0Ti2/ SIw5DBQZhYf9ycS2AbuzBAM9q5HiyQUGe/zMod4nY6XCOI09zo934WSCjccY +1qlOG/MeBI/Z+z/FZKx8YqvcOpshojF/ZGcY5+Td6LYcqmX0TKJNY3oSqzb tycntarNPaZOmh1UcNQjCUasuYg1Fw1rFYxUb0Ys+ohFH7HoIxK9CHRJxwy/ xzD7soReiZZi+D2AfSzuABvPDL4vFPSH8sbLzW2hp4+VINaMI6ruNbzLKF0m 3uWp7jCnhzYlsGakDiCHrzcdbRBV6+mst556A5IE9eYR6wRxRwpzXH+i360o jhSciV/LXytAawBqdNDOdKCVoLWQq2FVC+1MC1oNz+uh/aQeoEYT7UwTWhVa F7kyVnXRznShlaG1katjVRvtTBtQq456h26zQ1NSlbSysCLPGvtKgr3USfCA BSxs0ifHizEBqdnYf+xgHF+E0abktxfqVDugeN4WRfeqz2H+rolrhzru1JKp XkSlgcaa5VYfkWMxSSED82tKVJH4WBa/Wb7nVLMEMIo0imuiBxMrS1C4wNCP A5uHVaDInEeKcmkZMOrI4DLw1oIo0KAcg+AzJ4O9nrG7B+3dkdHf3lnJBnWz UC1LSxs0dvXh3bsN+IJCrWAoCU1DZ8qQb0X4FzVwWMVC7V6pOath7DqYD+yp ybtMWLzEj4EtWqHHJfwiUV2XZFQsQo97IHOVEDOmGgLeH98cX95izSsEG5Tv DfhP2galP0CJRKmNJcDMMX3Un6l8RSUYbLVahy9ZB5oIx9XCCq26c6rWG18n uFtp87icKao37CBtTl6JZd9jMWLZ0lJbGTeRStIo+BmKHkfpJhtOKBnOPax3 iDaquGJv5vlIlMxNMTvLdOA9kICXRE4oR+v0+S9QJweAskrbLxE1PSRxv1j9 FbXT7vYzOs+q2lNpRUJpwqncwxgQSmchUnepUEbSP6qCfakvGRB1xCzG2IUW sQHrm1e2xd009VP45BU1suCHyXfAuCw/LsnTTrENDhLB5P1T1ZAgFVOxegbC D4HrXmSB9stoWDDx7OxRkyyHobnKyqxMl2Lc9T+oV9TtJp7vk1IzPPMo9MNJ ylRZRXPB6rYEZUurluXNI7SdFlliIJ8JTeUhi4siORISoxfgcyrQ+SEJoDoi HFfHcC4OfDkE0Kr8SFSXyNPGTX3PZILQ5EjJ45xbp5mahdEjNb74RZqJXHfo TTcytUc95up8G4fGmfMoR1qaoITBwJoDZ1JXKn1zDlusrfMFsrPRoVSHtmKK hMySOzbRGc25weu2uPAVCfDwoR7QgmXatugV5fIEyny+sTqzhU0LYdWya979 7f2Z+e7s6u3dr9BkAPgJRq1cE8GNzZ/znKiCdMb4TN7/oxcGoH+8mSbZ/+YS jt9cYDFCpjlR0Sb43r1aErR0EGXRsaiL1SjpnlM4XFERxqoxKZqRM26DszuZ lkaSqYadAQuagKxB/XeKzTHOvjl7e3F7d3Zj3l78/azG8zQSZWFTo5tsLjni dIztIkbyDP0/VRTSPl+Y6LKJNisYJM6QEJdBmJTxiE9aZNA1yDnwpAE5b47D f7AeY/L4CBElGaV6dQ2k36TRztwEP48tiu+yLYc0T62FhyUNLYJtEQy6+9vd fldPvlXqgMyH9pq79gFImUYqQlc3xbabLc5Sjkosz4+71dVJEgfYmPmwQA0y D3qhscJZqlhzAE7IgiFOUgmUGon85ZsY1DPyPiKlZM6PS1EgaxbzTdkKnjwh HmQe8RlTVohidA8pwLDA9EbsuNYi5U+4N0SZuZWi/G88Sk8OnFlREE+tBzpg w+BA+7B8bmdU0IzThHY3hff7IHzguBs8AqqYbBPlSmd6XiUYk41XsBC71jhc KJhaqGLqnnVB4BSJWost26apIChiBmtQmgjtx6S+ZWdl634IaUvWRRuvRMR8 AzFz4PpwSFHFXRN1Kh7JJ22fBZuOVf1DJu4LZQOm8Y63HtAiagldCuJVckuO KQYRsz+KyyGpx1FE3vZcdG+DnIIcAXN0cn16pvk5zFht5k/M27ubDyd38N0R T2rBjz9C6emHq4vrq/xhLf9V9o/jOCULQ01JdbMihydFkHntTUqjvB3HrpX7 CtYNOgRxqGKJ5GxjXkCue4dCTT2jRxmjf/65yuhRDaOccbxD/QVZvKLCiqsr 9AohkTeFyVuZzNdMIYW4aqLpFoZ+zucbXqxTBu0sF6ni6SRRIHkuWzydJgo8 z+SLtYlCFFHgeTobXEg0yUrMPKnwtmyBhCMgBU4uINlmDF2UlmSLRkQk0ZlS kCfcAgnNyq0CynmAtpRJmCQakYVUnBCO/4EhyRCFHpRDUr8FFzGVVefvf4ZO 5yd4JCsUW+sfliEHGWRZ6HS+Mw9jcqJei+RWCXfAosUWi7adCZQN4Ihgf14C hJXFc65KjOoP5DRNj70BPPg3CQVX5xdn705vs2gAXrvd0vCfcwRLtRQLycy/ F/wuPaiGG/7Iq5n0UVZEC6eut90oNEXFmUisTvGyxs8V/sirV5YurW2ev7tr 5dCfSzKs0Rhv3hcDOozllLlQ0h1bITUr+ugPfZ/PVsdhSjdS2NwK+ZdSiojh zcXd++vbQhBiD7WE0n6kl6z3PnEmLizYgjOr8eJqYcCep8kuoBGqMDk+bgyw v/eSwqeqSCzCL1O56H3UgV3bbI2r1bDOEarg/Uh4b2DFU/qrrFvnX8v6Yo0t fZJ3rUmdpLhfwDEodT7SEGKBhPUj71RxM+8FBsdl6S51p3NyfXPGJ5zAEEsN kCDihnMrn6p7oZpFlpAZT6KRxig7uXx3/fHs9s58fwK9T4Neg64JiFojTBc0 BOPHpHQCgo3wHMtdOwkj2U+EosXixdkGOeOf3xxfYoo8/u3slPA3Cwrgp6Ni YXJflmPna09FOxud2nNR2X7/tlO+5aNRUstfPxolLP+Ko1HC8+1Ho518c7D2 cPSviG3lcPQb5VYcjsoBPddjLzkbrfK2cjoqvN0p2g0Ss5pH4QSlg7VZyntK vEVOAr88u2RXElurYYBXkx03nDjjK6D1OIsz1yreYp+lDnkRT8pnxU0sx/kS hI4UY9cxFzML9LAODpUZSyDs+EWMQcK9meWbcvsHtvCdo1ARTOI57emW85bc CeF+TNucHEpg7SY1eqK3WTPONFgWKSiIV26OFGzpu4VFC8BHqquXXThRWrDJ srX8TSaL7JU6FmEpv9AkCWQFR/y1SEhojzMMLn4Y3qdzsyo6c/yIci84Ocw4 xcdaW5+l9tdpJYuXl7d/u3xz/c5Eidy+Pzu5OH4nc1o6G3yRNgg/0aWjEgqN oKf7pDx6fpN9k69A4dyZ544V+TM7kiN7sf8nrsAksD+U6Hjp2rWeogPVV/tL Nm+N15TdAi0Bo5Bj4ic6SpFbev2dgbEH7cFwJJd2nyNLaoccrfBBj0yqvcwI u2800ibqbbVmwEHNwOqEClRGPZnjSnyg51W3oyH4UUCzlPozlgGu/Ck4wC+9 oXwhO2XGdwdGn+4njoZGf5ixvoaTWq5lCx1ps1w6DGVLaFbKpZqCplwT1SJY NyeTieaZyOBy0rw5u7z+DUtK1m2+39N8d4NP3l59uMwrlaWKj1rq/KgLV1rQ URdvULveUwx45YpuPZLaqatmSXNN7pMxGrMYssMOCUjZaQMtJIob9LbZYndL FvsChsT18uPcki7F0ON7b56vDc25vWq/c9prr4Uuw6zyqA+XTJqv78b2RwYa aXuwN6B3HFpLBEgk1kE4DWJvQntF8TSMKPDHQebWsvFlZhBmthfQLJY3sC/X KSprTpqM4kfyFtXrSS/2aTzq9aimpoIQPne7XQOiXQP86AvHzgZwpVzMdIuZ PZmJfoQRx4DvY282e26S5RaTaB2eWJ3H0xh4tLPjEjB6pwZeg97O0I92Rr1W I5/T69C0aK8T5bc/vlEYDZr9tcJ4btI6YZTmLQmjKo3GmgWWxFEnDZoJDd1Z 6hYSSjGnYsdZ9uaLJHQdnZKnrRw61uZIho5G11edFkjTFlcPAPJDzQN90q1K qN7nqE4I1W0dKjnYrkEn9k3c5X8enbXNefz3OJm5jh6P598Z8NnqG9bAsIaG NfryBwOVYTQQKd6dG4jJj4y5/SVDhull6c9Fgf7Oauv0B39898cTkDsvhtx+ MeSoBpJ+R1dA4EMSyPdBwN9fvwb8dHREV5bCCEb6njgJlX+KZIfU2+ntTRRr o6HF2c7F2agTZDsTZGONBNsZD40VkZUeLcuo9GhZKKVHy1JoixQajRL3jV9e xHeQ547lAuCFKaMGti5h5LHdD5EEXDg5XCrhGIctaXCIaXAH2sPdYZEG69JH yX/z+bwpRB3G1sXVKXbxnevz8y3mkVppnUEPspxkW0EJ6VT5c7rnkHU2fNxH a5fBJG1VzzkdRTuUq811cbtBH61xRX4gTA72jD7myeH+Lub8J7jEP4TjTZ+u /vkHX8vI6yGk5GZX199lxq+29C9H+D8o3XfJC4Mq/88XR7XTXlgOZROkJDpc 8xCtVIxgNNyjWmi7p41gLcUZY6tk5Eht+lXhYalE4nKRtzrMKtBLhFA/70kp 6NMlqZBG0pdsD7Jf4a6lY6mwE9VRaf0NVNdOeznR26MdIjr/BeRaKupIXnGi lxbiX2NpRC76RBBSANdbUQZmBDO74fOENRoVAzQq5QD//nOffzi9u71n7OS+ WmOKsFYuWVmxFIfoeropm2N8+VR+g0Z31qXDyW5O8HUr9PFr2uB78GI+SHwl 3XpAv2LyFqp8K+A64K2fQBA+KJjxr+EerIC3c50QpvQDJDmblONNvaA1sSg+ yyaiH47HdMJuxfd8GsjC2MXwvI/CyH5Fvl4YetuPTTYuXcl15WKNFwQqyi/B rethZM+zKiZawWBtp7Nn7Ki42CTgWYu3grF2vlGamRkan7odouroH7Yortf5 iX7X1NKusjvoU/rapYuzeRf3JAMgVwrzo96b449y3NvUELKFpXPdUjesQV6c +krHFayjt2g6tOdDv6XUtwHzVFXZWdQbjcs7y2iFokJhfrjPaW13f79Ia89w /0ziWraFgv6v6uezKU8Eke+xU+qRLkhgcjqgAn3dm/bG+cTDJXfSP+0l7wnU Q3mrLEZvyu25sh0QZLEmkwR1re78UN+y3iWn2tsZLrX+ZU65xOXkL5uHbnbB QAb5bkJxvxJxl0OC+FcRkL3AS/RFypIsmrS75yvLRdK88rXAbPyJgzHIBb4G dxlP7ZnYSjTP0s/ebo/Sz/6gtDPyIgbW1Lf/2963d6eRJHv+jc9+iGr1rBtE QQOS9Wz3DJaQm2m9jkDu7nV7WQSFxBhRXAosaT3ez77xylc9AEme2b332NOD oCqfkZmRkZERv7AtRVFV/Jh5ZHL9e6cSHuPPDzrN085B/fi4c3h5cvIHtrz0 M00k+CvLV38tMGrGzg6rZHY3tv3ajju7XBIQBb7YW5WYqxprYH2BAHsMGlvi RkQiaLW6j7sVS8DybJvdsRv3Xc1NzkUPDQff2RySKD5GEnJv2A/EnQs3gkCs hofjcsY4yp0ZscQBKn95oOKPyebb0rzGWOh5SykUSaNQE53KG+jFK+wH94lb hBcTPB5ZDJkvU47OVZn7WNbFNlbMBXF2ukIoZRcTL6BKhr+oQlCaneX5khmt oT3ojnrzEdls6dG1rM9J7HAtz1mDIbaVBb5DMgyFJxTxessEW7F6W/W/cKvO suVel0KctZioLX0XJ6v9FcpWc+Q2uO1NHmhvxce+95LWVATf0AgjHMQqMkUV LEnPkIaun/m6lOmsJmryhT1VzeYRjuhy43V8sFtmsFPuRDgXbzC7r7b8KkIz VEjJrO5DUhqW3CpiV855+gMyM7Kd+dj3xrDc0NafPtn+g6zA1XiLvwrm2k/V I8SfQam25Eblqwe09XUmM3ShtB6nWKonbNqLaZ2xGuc7zfLdBvmmKb6HEyql MSlm775pgLnv5QMr6bmtu6j3m+JH+1nAjkAmYLCjijl2rDIWWMbddDgLrJmy Se/dc4jF3MWMTyQHaxMSToBnAuwZOfKgyQHaRkbEBoFzy/WtMQXwJqNujw2/ yWrK9qFzfUx+iO6GXm3zhxc8VroWX/YBsmQivRF60Si4BvQa8smaORreTtAQ tzeLhGpVRbVdW/5eiWo88fVl0iIrB72EFyeK7zwxQwj3tm9T7u8qtVcgRG9h J7a2/erGK9WNZQ2yC9uRoUYVNBvGt3rhbPbmBd/uxjRYYcAWY9F8MsFpiUYt pHs2dvDGL/rovE5lkDfkWA+lOLE3OTfqw8YPcYs/bYODkElYBma8DuAg2B1Z Gw2cNX8E4TZ2+sXhiQkArmGPl3dYUaT9UMSPQP+0d6NVOYxrh2HyOjWkJDY1 wktygRFCkHwrP4lMndhD+Ekn1pKqCMig1RklzfP4Oc5gsW2QSzDtoakaRaWM grHz2yrPI+/MZLneuv4aoW+6p7c/K0lBfAplDOA4ENsqdVqxpyC62wWT/UTa oFqMN8Fw7VExfDkxLn76iMAaJlMQJhUexoo26X0ZJl81VPuPiR3Lb93RR5ii 03B+zV4P6AtIPhXYI7SWMmfpm/DOG6FgqlwAvFlwC4utO30Qd7ohKkn+Yz6c ks3mqVifzxBEjcxQUWejMis79Mi77aKBBq+5vrNkxP1OG7NKXiiTbvwQ8cCY 1ZsOwkiUNmH8HNPzfepvK8QjgB6Za3TQhOLq1VJ90/GzcIhf4EFRnhMyH5Re 4Rp5D2w89aplYmo3p/g61hROkjUEpnlkrdYni/nhlK3u8ZRlitYVkk6Hx5zN qeX7T8IZ5LeYUttOA7ScikkRBDJ0WAwxvlj8BCpglS/+6AdArHf148uG2FBj de+5tg+FgioaalG218p5RRWnrr3JBW44G3ZH1M8b46OGZGCfIy0OiONmZBv1 4o3naatJ3r39QPFwzmjRNFLlwuL79eUFJTbGutm5+uEcjr9Y44F4Bmn1Bc5r uyXatFjZejvG31bX8SbYdZCAhEArY3Idm0d8OOL075oX7cv6sT2ltF1XWl41 0l9cZyV2o56G4W3K2huaEUG3N3qjjPdt51ozEVFuR0957cZjt+JnsSaXCQhC ful1gjVJISLYFqJJotVZ80SGKzFNtAqCuSEUXq/KuYM4ub15wcujin6pZqbx 7RCWoF2Hw15vPhmqK3SyctYyR0lJIViuZTv4lLKE6laJtmIsjWmxNBWXo7mX xaIrStjWkUbCHQvqFXN3dGEjkRYY8t2QzQimCGY3eXAlLdmd82Q0RAVYghFs A+QyP58gPtr1EJ2kZgjioVxcRn30fy1LISTmjQJWwOMcVch7azfAytewvC49 M2Ou2yH2hJ4jeHgxZgz7xCaZ81LvyboBLZ9x+yNDwVEwIN0WwfFBia0ZOmJ2 cdsC6RAtpNHMgcwQpcmWo3tE+xYRIJqJGxVuXbF9zswNq37hPI9qhObrbDKp KJGYNagJwS2vwKvcaaaUIe2LbfF6uj1iw1km1BmRCOWw1569g+hEqXvT0p1I W77Gz9esX5MyiDO36xdvG22TVe1NruS5YBOThDHPJPyW9DxKZjPSHYxRXOQd B3eQQ2apkMzikB73+uDstE12/9RzKzVbW9uiBVtUK7YDE8t4ywrfx8s5MQdQ xeCo60QadBGEQlQpyhHKYbiWLZshg+0Fdd6+UOZh9oh8xzuIemU7iJpUhZhD 1eXpAQI7f6ZcTEMgEanXhcnhukKbUZ922H1KmGrGyrkRji/HMwcWW7IEPw5E aDJi2V+Q/gayEI6WIAic1dse+8SUSrdoD1tiQQNPrqgHIAgO9l5gF2RBKXkI ZowlCO21yrIG+HKCwzjATTrzxCpOrSJoA5NQKa0R5jyGTwg6aR5bqLTjhRWH FwQfNYbODvvTayyzc1xvtVHNDAtP9luV+ruYK4kZWAt4JeGMx3dKpNwZoL8L OmhPg9GDDCNbhiMbHAWx7fNRUya+odpdw21VJoHMAc8RyzIEb4sn8gOWNb3+ 1ahDC7+YwSOKi1jOQrHed5jgvvYpfI6Q/wiuusqpQApdxkCLK3JE02CV5999 bkDRqgzb6BUek3vhtE+7qOVVDL+oJZNpOAvZtzRrLXMBxtpS0wqrhEXVhJ6/ bVyQFnKEuk1scjR7QF/fcWhqMCcNt2ksg1oFEsNB7diYzzyj7gynPyKJWw2w mZZcDIo0GyMMGXHQJGdoC1OGup+3PdLYb3XR6UpPkyUnKsuFVWAsYNqs8yJe L1iLClchLz80kbCeujPtZWyN6lmtlEfcSz3n4BhDV6sqsZmDj9+iLb8oq1eP 2qItC2tnW3ZIqmyWcVPGzdla5+qVuxHHjrv2rq3nGwxELs7QlnDfYm7xdl3M PW2zlhZ9eeF9j0amA3u3QSRud1wQBiyh75VDiajBxmrLUQlKOBv6HpztesQJ jpEiNptANI3JaDhTaJ7xAlgXZIngtBPR0s7jfKODNef5rPKKcJPYcs1+S5Ew MH2OtyQ4MOC5usMzGD9/ii2mv9LTvbg+i0pYMoZW4Syc5pjCTRY16R7EIjO7 bBlZpauozhkt2iiCpOzNSvtp7ck5pQUoFuUn9qj02m6fvMDeFJMvvmgC8xW4 JiF0hlDLkI/jvfSUznrYDdU+oy1+b2mOP5SZbiz2Z6crFj+U9dBISnEJsJr1 xQgeX+RUizg5/VBOeN2RAj/jxvnsHaAOvQw7D5Oczpws5slEs5pSKsXPdazL yeqgrbTnQRKYsTzfcWSSxVfDvaBk495YMuz0iQu3mHv6mjV5E8uVmxVfsPEt 6Vlr0IIgcOAdlnCADGwHXpXjFdZjbB0CE34UI4D02SoqvW7jAAoxTWes8edy O2CNlqvLimNBuFPSuAAU0CWBGu1CLNnUHkyyFPxOe+1hSeM46l0a07FAI1SB 4kUtN+Dd/j/mER4cHVhDraxRTgYT5W5oWXaEk7hJh3liX/5mOT/CMOPmriyO VVn7lhEc3QHSxXB1awPN4KroZGd8Wu0mcPsc6+vJFC+JB5M5wlqSRQ7+cWz7 8AGQKZFSv7SvsPndSy9f9X76CZahKEohG97VrTXfnXlryJNAcpspj9QqGcNC wzfEKDarUXH68umQLfuEwPYjm8J6AbjeJhEbmiVMZ46M1ZcmNp/lqMW1SsWv 7WKTX8EXY0jgtAf7LbjgLFTSPToeoeMGzWK7vxBnlC80KSzNbPbgez3Xfsa+ i1aWlJgwZgGTRCRFR51VEE65frtobTi1sHg9xbPBbVOmZWbqrMYmjSnSEHAd CNz4Jqvk3xlBv+NkYPTnvEKroahgKa/15vsI6GjNc4S7Lq28aKpIa0HxcfXb UAULqBVDan4cxapPpZgFipJBOIvnr0S/6jPot6g1RastPIvRgxVKMbEBjOqR z+pr5tWaCRugFW8f0b0jHAib2aj6mxvIZrZ3/Z1dcq3JXBjUAWMChQIFWldl eNxYDVSs037Ea55+iGnb8qW1ZLIsR6RWwm42p0gsm+WFFpcU6YB2rNDiWC+/ XqsTBa/WcuWPLHbk3pHY+GuozR/k0IHHkR9QcYFKp1t2FsYLKDLyRZnTCeOG EhzpUjgGixTe1vZYKA9Jo2C/vAunHyO2uJv3PkakyYJ10u0TYGykED6nFZA6 q6hcoXs6WhDxi3HCKoN9tC9vyYRkugEZNzV0HuGKz27CyLr8pMhMCjbxdshX cjoQFF7rkYGba7+aGu3Ny09mUx8VVGqLJRjwdXi67zyAFOjxl16GzuOb1Arl eF0UV6hMhcekJDNPqB7oZqcD49TpgNSEv3T4Oe/9f6+QX6+OQAdPqh840R6f SD2QrkDiEjkcnq5N16hbBZ+/YmO8giuxpkSko4Q+tuhRpHBK0Al8kzmNEHhH +TpOmgxC9BOECB5DCOy9b2iChCii7pCPPUSNxw0r24mptq8X3EFdL/CQEiSd W/oKlIqX7dKJ6lLNJ/1aUYw6x4j9h+xaS7WnyoAsEvVxRI7MeAc+7d6pOHPK EuzTcIqbiTzWga14r9AboXRkCE3Ja9Hadovj5ivEGnFI80rGDqQAZ/AdGQFP Ivux00u/O+smmueYI4hbInCvq/lgAA+OLs5OqPnANNwOCENEnTtdmJg87TPu HNE8vXs4Tqq4tG6mmXZzMAAZSeyFGtVZqKgiU10pxjOmHOd9qc/qrIXVlxf5 Wei71zykC6ajdUHNulSqrkogm6grjwRSVZM1m6pY3qMoajGdGFFJIIzR1dKT GIJxviTJCs4oOEvzJekpoJLYaYV9xcMxS4gdQkLM429fjpbYacU73aMnptpP fWNyMk91Ck8W4mdmd2zLEdUBpLTmKeqojhH82Hl0+i6B6UYy6EZ1x69WQQbd rNb8aoV80pf211N386gVOz9AYKqqRTWnvXDYuxkOZuwigxiZBN9CnpDTKZnh d4j4y+jJwBHmBEzZ0wnMRa5A/ETLklXSrDQV8s+06sT+eNlYue8J7ppaYXQ+ aBOEUF2KTrDvbShVysY2DRKM1pY48qxKXBwe2+8D1uAVB1uslqg2WNrv6scK Rs5ZAPCekOMc/DO3I8zjTMLEW9u3c4wV7mtLKPrJhlDYg+/oGz1ECyju986G 9Ht7k/sda5OZ2Kpw8XTJwsVCvRs6bpP74xJULCftcogTJjrec7pkKGAOr+ht kk/f+QEDg3l4LAgwyDbrG5NQWLNqDAtLQ2Ap6Cui0WZtl/SDr6o7NmpGoqNe iivlatRIpFyVFvvJF3gP3iGXH2n+q23WEm6p6O6p7fKURopWJNJYVHwvvaPj +tvOQcH7q1dFZLx9k9atWZkymvcUoDVvWgREfVXQV2UelJhYZXbinlpnBeWB 8Ig8ivFZXYPW8/q3MwAXqFbJwdCiwSCt6Rvi+QuUJKyG6vbmxiKKmjDFo+EV Riqm4MUuB8DIxqy1ReCgDkYVVtiJqD8YhJnAjqXYUVvpv/ETplRawbEy/Izc C9EUY0Cm4lS3tfsKnaCBJDtVREmEhyv0zN42raSj4WwGDUrJ4UAo/8ec4LeB 0TJ2M7I8y1fO8nqLBfWlG6dG581Fo/7r+VnztO19rtwfNfzK/SF+HB3BR2P7 C/v5Br3wekx3bsPRKLiG6RZOGJcoXuSbeJGNbVUal9v4YjLwnX+iFVeBjx9a NxZLn6gikV4HFTNAZzqaSDSfwNEl6LMpnymoc3R2AcIGef4pXFSutu9h2KbR gw4lBsNRIhqXe1DuZPIQI+1xs912O5Ugtkn8pvnWTgn/EmTUHXIC4LiKQbsj IHAjCDdhTLPTnKg8NFQrddBFi7VhpDTcc9erbpXwIlaAua2ZpQPLUFloN85V 8UxOGMhw4HIzT8kWEKYuGrHY3p1MettXkw4s3PpRML6GU4aOMkZFQvHr8IIO 1eyVgxduETBAKisPC3iM98RRd/pQIAcljg/Ad46s81SRtUYK/PKOMGzQggvL SOs2NhIEfeq2HXfueQNEB6V0ON/sASILopQxosJMg58zRlRUN4OzPGqMuCRr nNIQhFcbNCoqc+RWGTXYh/TuzUprFlgsD1g6TvNuRlOMu5EUYdbpvX2EkB6L ZJNWZDy3b+dbuAFxegpCk4E9LCncHWr7VdXfwCuBndqm/2pT7dordNfLfbEg PEqWpB+OS0pXRCAcBwz1HA1pZZO7NzRs/BF68RHn2PyKLDtguCfhCOZygf1J +ArDXTPN007r7Lj5hlFJ2hf1k3P4edrQK4eGEJdeg4/pAiA95sA+qFZ4c3mE J85Zd6ijaeWn3buC0T0Q9obM73gUPl55OJeVYoN5TI8tWLozn2D7HU0Iz3BS PMOJB+pPaDKUTkECkHEl+UyNBQdcDa6v5oP32pbhzR/tRuuDkwStlCGNUg8t 83Szbf4ydEcv02rNG93bB1ITYZ2k+zB2Hwrkgt/6XnpB2tMLC0pXqCj1Uxud dJwgBCBJCmy7whvvyXBRdLBoEo77kdI7pUOKs0ISS0J0d2t1icl6XP1Ix67X 3gHbKjZ+b8PyI8tG90WrXc94A1nIBjMzW/bb4/qbxrFNkdWWH3fILMI4lvpw zI7/tCzpwDdODVxikDTM3Z4GZLKLcFEuTOIUaHV0URPfdeXhdiQh1fklLtgY QpheoLE1fX6gg9qodhIaAgj3fQztdo0gdnPc8caEY4Tg/niTNJ+gixvj0WBI g+Gt8RZ9ZnvkzrhpoM0e2xxlZj+MITURMg2wfGWIpBuhBxDOh2QRvOe95Ape Gmr79EoZBtinj8q+C3w6m457txN0usci1niYPw27nekaHRepCK0LKbGhtJqA es3R5CNlr5Q6v/LVjxQMOLZIpkFEaVwjdbhh3vgykfcVE+qhKyjKwLsYE65P zb2/96k8Fg3uFViI3gHGjBLYJgvsKMLbCAnXTpE8K6XpLog4I19hADM48IS3 gtG0bEIjPL//zLGIBs/pPxUTo8Hj+8+7YioN4v1PRflVXGUZwm+SdSh2YXOb TO5Bos1OpUrogNWdXUQ4cWBvTTu8nDjj0sSmxfG+WoHtZ4YAau/x9iD8oNdG bhEwYljQcN/FF/YiYmQ2jqZJNVvYWHxX2jG+2x0yKekHDDCW/iLF1i9pKjUO 7jrwVEeo2NmsUKSG6u7Gps+SnvAyFdReooRE3p8U4v3PtfKar/Ai1zA40zzq XpP0g25mVmim8p/jNWQpwQybUPC1yuglCtp39JB4+hcdi+dJu3fazk1rTe5N svftkhMOOHXfLmXu28k31r6dni37rdq3YQL0h9Dp0vx0OvFK997Buxb+mfaH pegG19h1/6ocTofXP8IXDFMLsvH8vjTuzso9fJfy+EWpVFqULfcbMMLDoOdt VL3q7l6lAv/Bl63dF8ViMaNMynOKKPAbXnVjb+PVXg3z7O7SrKr4qCX3X9Vw fRHHA/Htx2PMrtwRoRTc3ATsh3dBNPhmO5Lq7s6Oj5+7+Llbpc8afW7RJ73d 3fWOpkHgtcLB7A5pcwTnwn6Xz5rNca8sPnF84EbDbfiLuyHF5D1847xXZ0vC soRCIyl033sI5+R4OQ36QzyoXs1nFMhOEIJgqg8HHAket2YQiSVsGJzB9XYF /ffeirX1+fxqBPP4eNgL4JSJzlkTfEI+5VdcEEEcZXRt3wuGtELU3XpNVSIl +rCNUCl5EBIeKNbxBDMWCA2J3RokbxYFTEd14MqbcCKumcMZgwewrmAwH/FR Bg1zfmu2fzm7bHv10z+83+oXF/XT9h/7dOeL0QuDTxIhEM9vGPfnDs9f4xlC fFERJ42Lg18gT/1N87jZ/gO3w6Nm+7TRanlHZxde3TuvX7SbB5fH9Qvv/PLi /KzVKFPQZr0lLqDzgMZqGliRmynLHzC8cvAnkJpp0AuGCDrY5fPb0hHk7Y+0 +mIPZYi5j5IY8HifDdSVZsIZW8ofn7q+92oXGCJ51JwjkplX8lpzLGJjo8IE fxNGs5D8orxKrVqtlqoblW3fu2zVRTZF4yqlVQduHqFK3Xo0HA+C6TCcxh7D YgfmGiSfdlhLQy+sVz9FD9GPMBGgnJ/jjyd4gg1SXsxnEYkT+OZFEY+S07EX i9xHLq2i/8zl8Kx3GuK3yn2lEnvRIp9gelWNvTqka3p6VYu9asgJll5u6Jde 7uj8t7OLwxZscbUdK8/BeUvF/cnlqlvYPOVby+FiZ93ro3NIICZ4tsVBbsBt 3E+88QbcxPe1D2kvVSPfb+DrLx5VsG/XrTQCWHm9WuXKuR2DCYgg73c+MA7n TtwZ1Ti78FHGrXkSTTlfLJfcdWkxJzVvLz0vnn+m4SgzMwlygzb0jFqNuC2o 6IA1mOoqfsORdcnsis02snpooKFIKTmcobW/yGCnvx2RKYrIVKwgxPeSCYkO hN1XSgbnxoAQ6NA92ACjOCpYXO6KUwubw0e0T4wIdkX2xQkaPJI94QO0GGGx ELQW1n+0J5yKE9bKtXK1Bi23f9L7MHonFWEomkqlUoP/NnIpj2uVnuQ46f6D DEOxQOuXejsc0+8Kv5Vf6u0FSJXdCP1HNl7he/NbGkQfjPxnNyKvKvrpJ6+6 VfD+SU+o8J/QTAse6MJMOUB23C0JjFdJv32xQcb7RJJOOkLqfIF0fHy+caVl TgfyR74AWwA5JTtzV7fUV+TxFSV80659Y2ZH9+andwPFhmKmRkdQEC/M9cGk W6367lJZn5wE2oLNfXUb3PKqZ1XZ+8oHdGTGMko/88o+Gn8oO4wFk1U/CJCd /K5Zv1HeGj3YPihKS+cVqaVklL1eeMn1aU1SvKfMsv7dPRVGWf0Q62xmysqH r0cGmodJSuCe9JXpAO38jFft+B/iIX7lFje04vbfO3p6J4NRQa0ZlgBnweAe TnF0Nv1x2ajqEmpcwihiGwUrZ21JzirnvHVzPpu6dLO1Og9YTkdHk9C5BsF5 hTbh/pfBHoAqnM5NRjstJPMYLECzki9pXVtp0f87u6b5QUbvUviBpKwupgMn XzDKK66hfycxrOVlyLFgnS1cXoZMKets4fKSnLXUdbYquVFjINgXdzfhKIGi wkD4oY4ry87v4rhBo2QgS5xc5CKOFsZKLnz/QYQ823mJmWWHOhiJXk1uy0im nHHokHCfJW0cbwJuleuAC/RJSa9/Zu4NpoRkxyckL3/e7rxttElqb5EBDx3N OpNhn/aBl4NJQeMxYs6fXBxGD8/SdK2QX7uUKA+hxxZ9mS1ZM17QCjq4qGPa 47UGZcdzgG50klFqH1YzUQeTMmbi0p2yUpriSuiUnOwxicAOlCPTHN3gvaNt 96Ggolrk4NVIJouYqWRDQkqS2PaGXnjuaoaumHni3Ekq1e4HXZj6G90NsaN5 pIGa5QYxxYIKQtgdi+fumTeel5QokQ+8RJ36xPZcF+iIYkqpvKQySlWMfHGp 6ndK6Wq9Z5RvuOOydudEy7xHd5lxqSott7jPfzFXnC2Ffbg6qzDeYqxmHs8M UuMS1iCOESuxhiyun2QZDAfpLDVe6bIxwHF32H9vFpuaU2nbx4orspXFJp+y IjMWpOU3G+uKXKHEVm1sM124fL/KSkvKbTLnnr7MkvLSgiIfu8bSJJClxZsl Y4Hwxrefi/pBo9N6yha0ZBPi7fgRG5CzuHnfwLvRFOSXxP4vlVEpq+/zqyxl UbJNZhyuBT9kRqQSEvbyLDJi1oV7efZOniCBoaC7gXvJVWvwktWq9c4PMnbR xC4/5aiGip1gF8pz/FTrWGihjNBEg5tVXAqHsoq01Kwf4hZDjyxK91C3MPUl kicW8j2fWUpaIw5Wb4TetRgAeJWJrTVZpEtExSfd86+0Uf3Xm9srzOzXWVN7 xf0odV9dZQ3oBmZx12WEeyTpmN2tTDqXqZr5RnIPSUI3w1FfzTuYVIb7msTQ PDm5Evlfe6Wq7xGsA0YFldHMmNdTeqH3AionfhVhAkXPJ+K1r+0rqU7HUJI5 uCaoKSav3DxD29Ixr3if5Rn8z3+qufSzZ0HyyFywtgh7gFRJP7+2i8Kw8EYm ssqyKiGKFTyneBEnk/zB9OdKn10ZMF/u7jyLkaw8RtEi3vP1x4g50b9wjCxW 968YI0fk12P0/XCAt28Ijnt8dvr27yfngpWrFtnwGtgDYgNYxuZ4S/yP2wlf oI8YleW3AHUzGI6CrtdVsBQ0e6f6EVB6Kn5jmBflHEyBFoIIK90d8XsGvvC9 KHSR06gQwrqzQ3PaUr5lYstDHSn7QqivczVXd4xzuawmfqEjCYidMm9ZPS// 9zed84OC7ozuqtedKfOxnjfkZvXCyZDF/ZC2YAVSMwWy4e2ZckEgH2AMHD/v MWuS+23lSuMMAIPs5Ri/FedYwaSExjWOGyeNU06Vs1PlnGSt41wuV91xnh2d 47NdNx0+q1WcZ+cH+KyKTdRoBnRHxUMo0SFjlv1qDZiH/7gS07WimLihcXRK Xz/IpJf0SaQxM77W8rBDVCrgPFVCkXvhrccJho5PA2VPntKUQsHeeOi+BR9A 99LQBMnqO62UfdlExUlcVhxhT+DZNbnoZEL8uP6iePgw7t6Secb4IzmqsMUR XZe+KJYW/MMS+LryHO3geSPs4yoeQVlo5Ub2f0pIeHuGia5H4RV6urFDpyR4 UaxH3u0cd8JIW0v6XuP4yOtL80bSPJg1yAsleEM4ms/4qhgYwO3kR7TNhPnD BAO5bz6GRcyspBvNvFvoFOoUycwz6N2Mh/8xl1totu+eYCgnhUY/3NjZelGk RgR40BYYYtxcrMBN5m67F6L3ThcZAlnLAEts35j4y6ZCsZ9BY0YQzXrk0XHT HV8HitsoaCHB3AbC9ucYnY/icE8m0T5aFZ3U/4CyofGSOVK577oPbgkeW9hQ GSADhBgnJhqyP9WYN6eArA0gaX5YBgKR8Rzw0OHVtDsdBlGBOlQrxCinsH2i OWkrEfAauFdwH/TmNLIUrSTiZNjbK+gMGYABF9tnf6Xxg6eeJFNLUUGfqm+H DOo6jAiSaMrX27Mbsj+bBRMkwKdw9Enhdc4eJkMgPs0MMgrIwYiogIlE2FwN Ga+JRAXzGB5uFOSe3HhyaZEPJjGW9NuN2GZZfUUQXKLXA1nFUTQbBE3CwIdB FwiECwDozO+tW/kXxbgrFo2EGCkb5x21FMgW3Zr87DvTDyg4PZocAakEumyM zjMIPmZ54ahgKcp+DTsImzVxPnvxs2UW7jzziBHMRv0SmQOUo7Bc42iOMA91 KEIJWgbjVuBowzMd1QcHhl3JfHTQt0z8EVmdIjL1tSmtQ6dpIJEpNXgWIfrq /Hq1o2w3v4rId3dGi47Cnanh5QkC+32N6tmgT5j46B1gIbC/KFLxSE61hptm xuzRdUvuikRRaUGHeU7uapR8aAZCzUWkLo2VCc5Y2yK08mkwYiNPmEJjGHhy OaZvZBAO7A93R+0eqPD1ZW9MifqZdxqDjVDjiCk13RJOFxy1h63cGf8+k1v4 TLLsNiBgu8K/647VqI7VYkNRb6zID5xJ29xz6AqbCaE7MG42zGY4Jrd0a4jt IeqSaTPPeVMapQN5fiw9l9ai4TDKc8LYmrpRezxu3EBCnI8exvAOdQXIoXyv B59W1BIcG/QeaM6AHQwjxuW4gvMDmuop9hDJMApDpdTDyHjVhQMya4+wobA4 YTEOMRDRjDi23RPKia4tsHCGHzk8OTUZmvu+8gGvBoD+tOOOpr73Hl0Kvi9t fvgu9zcVRFCJClqwGE2tsAijvpUbfV++r259gN9/Q2bGnHAL0eX60PobkIZM Tgzdp3JixhEX5P0Nffioq1IhbkGwyt8zVphbLWZ8jyV8v/PhO8yM7NswRrl7 oLnW5ZiEarxSekU7X0r8KRwL2vaxJT2Jq02riouirqocAYHyoFelgOBBv4gb vcQ+bHzwSl4Z/l+ryJJU4JSwxlRQqZvhtC9RvZR5mlAKDbzi5SDgSL4MHzuF 7KTVWvzlS0XSF0XFfMP5FNqJTffVgYPdS2jrxDkK/K+Pk1kOQt2Z0z6SQ7HY 2of0yrCRtsZdvalRM07P2g2SDjHlVTidhnc05UX6K99RTBCcUZim+qFsBbth qAZvbYYm7muwbeB2Q2G/kJFp2AB2wuPFiuxFRZMjzzMKGanWxrhY/bCXnG/o dsPTfPODp6e5tJDadh3O4GdymmNOzDicyDSX0JVauA2F5hmTfDj5oJ5bk7yr A22+KHLNe0IoEqGhGzxT1Ky3p6oIHTTc18HMprWWYGROUInKO0oR78HM4LTZ f9v9iFLmRA0yNkU5U4mrHjRa7O0dN3iZAnlu5D3suZarMilR7NTGGx0dSWUn 3tA8Gqre476jpKAqRuvWiRUpk0E7cIazXAtNKHDdEueVMNfotyx6pt6GnkbK lB0qYez7oAcSG58eEI7FO9FJ86yzOCFxCTMZqCaVxOx6GAeQ8XRCPXWlIabs Q+AeeVZT3bILZEEXZbKjOW0Iq8HuDI8gO/NTEEq0o1UdgaW1AWsWjWUO9RSS F91RFD5tt4PFiYResNt5WmKWypRcaGxTfY9kJlsCxM6yXMTdNZSiEaGhllc0 yFcStpGnm+6fjFx8KGRgHYYnXO01d7PP4YHV1KQdQ8igz6Uo4U/dAsisJzaf oRthj8+7Jo4qnHzmo8DNXEvJTH3+kUT+TxRoqB+ovsXlazL+tuUFBDQmnshy sOx8gouRUrAR3Vlay26CQziXK6RtFvYWQrswEzpt1074AdPMUJnfK9XdFA4h U+CGRlvnaPJ009OLMcJ5MCbSIA4QYg2QPbvEyUjpNhaL4LokA8Ace0PxnDJT i07OJx8oJQvz8YTnBRxYIlfMwzGCc08XhtYmKVkXvCgan1DL1xM46VVHVxzz +mRFmcIMNgZVSuX0RRHE6N/Y7Ftf6cxJCUUK6CuYxx8DRBfMhBRVSYDJuNgE knof6/qSrA74yjgYQWXItpxrOOV0GItQjn40DqLBfybECu7zI2Er6N8K2BUm XQzAAu9KCHV5j2WtcRCwT+hVQKcKPIeT6HIDHRzxtOajUqCi3itjIHXREdyi 9Bya4ImkPoDuXpB3Igbj0UqNbhTNbxUKjpTCd2DqwsO+NwlFmLPgsvnscPiG sKWjObJ2FcGVWOpdiIp+aTy7qpgCexzIevTg4ymRde0zy3lXCsI+KCeUfBa2 SL5QsKOqmMtiCRG7AkyI91dz0+Lt2TGai6uifciKWgz1EYf4pFWXcAKJm/N9 Ym8OwceLvyMHj/R34vOhZpxaq+zD5gmInJqdE/EZgS/sM7I+kfwUsXE40kZY qIQvVZGQcyoo/5KA25Zd+hrfItZqKV/O2KWvV6q65iAT5d0D7Z+FH/H2bRCW p6pta6qAifLzUekQCMJ+b/x8MlKQxv+Tqs4ZhQJlmY+8vKLTS6SJ71U4qwzE omxMVZPNQwd8zmtalpVbD0VKfpsv51X7jY+SapryUTLzwjWYz/I38pwNwHaI Spm5L7Xv0UvtfPRSex9xjY/xFIetYgBfoT34//LtjXbsTrxJ+osnkuTaN3Ov Ppl61Vderbq3sbkHX8j923YZT2bL9DQnLAL/lVdE1/G//e1F6XvvlzCaAQsB Djf2LpotwkG7oTvB+ZjWBD4c/u7lN8sbVxHQtfT7YeP8qHncaL3GNSm+pyF+ Rw1ZGYPrTj+WyMYBfmAogvt+MJGvKipB6EFBJx0s57V3f4soFeUbBCg4rbfl 6Vg9fc4AzDLJNFs+ALPcCe5M82tvo4IDUNna29xePgCzZQOwbQ9Am9SKqUOQ hw2lwCqjaCib5YtS29AfKTpj4sJxL5wFpWnf+TEsh5zhuPkG0mui/QhiX3d8 HfXLXXivxmFmjUOredI5e9MiQZsKgxZgYfAcnpXLP8Jv6jKUhK+6Tx2mAA68 /YyVot4tHCqVaDWAhbSMbRCdCGWh5lUre6929zY3EygLW4SxoNcL7PSUHU1D 2ZP0RfHJCwOyWkuBm3VDejB7Mejn8NSZAvSCACPCZw5C6mpR71YZhAVTf/Eg zFYahG0ZBL1m0obhseujuGR9FO31YQ1OxgopfvUVwndn6StEvVs4OCrRowdH Z1xlcHYSK4Tvu+MbigYpQSLaE59ru3EWEhzUSrPeBOkaWw46tbMc7IVHh9vs BYjwC6PwDr79SW4RePCBR6VuOJ/J6xLaIgUzXq0Gl+XJy0zombrM1LtVRvLx y8zJaCHKbMF/SUSZlGW2dCztVaLHJnUt4lDCSazVuHgHxxGTAgZDcj6ZwEpm SCOBlicWEVglIjr9HWRZDzb8rb1qba+yWPRyMi7Y+xGSWm3+cKY+RGOmIV9e wqEDNeV4SkUCe6TRIeIz3E1MEmOkToPmkz8oIJYPIffsbDOuzzLknpJB+0xF 7rHePxe5h6CEvwZyDwW7ejZyD6ERr4Dck06BxyL3EG7x85B7sIjnIfdgCY9C 7uG+Px+5B0t5DnIP5n8kcg9mWYbcYwF5Cwhf95bCTKDJ9/zK0gjOy3M4Y1Z4 6mF05Jl9X6dNg9ABB1eRUESrCNmZQFeqLBh/bVycNo47lxJnHVF1KvQPupK/ PK+/bbS8de/0zfnbQkEaewbzcopgomTRSavnM6nBfLKe/ZJm/jscW7tiL4aO ftRoH/zSaZ4eNS6aZ+QPQkqilknxy1mrTTqjztnFYeNC4ak3Tg+b9dNn8GmR pDJ4qZKzlvBqSfbo7dDKuopoA8UKwlqMX4tNCHJsNK1NiqNROQ66lsamv8Gs fYNZ+wazthxmbTBGX4DTkw6stMbJm8Zh5xdjEB57bIIArMbck4xdLmIewdyL qaw9t4S1c1O/FmsvLmXtjo23QzXM/3SOLlJ/Br9VZ4IlHF2SPYWj21kd0MyU I87mbgZHz5DA3eMP80V9+FmFxX9j7t+Y+zfmvipzP26eXv6eZO76sQ26L3f7 eKevQRpDgXgnFjlC+xC1dI0hsjg/MWqOhY3pWBPIbdJ+Cmsnx6YMG4T/J0yd sJ3R27B/5Sm3MOQG3dmsK+bgOKHQRpxWpTigJjavertdh0oOG/gnBTg0Zt1B /oVk1WGTSV838x6YZ7B7YwTC/oikevvs0duC91qr2RIWJHmVs+ArVJjCvqfM N/iGVsdVav3ReodFfRLAZoE/Zs8DNA7gq/5PgpIKxZVvfnZIcHrWgUKQvHq2 /RZIBCrxbxiQqVeZ4OC7n2CZdsn36Cpg3xpaX+gDdEe8x2u9u9iE6fkgZltx R5myWQa4Cn6pv2t0YLb/aq8BLKLT+qV+AVs16qtt4FjWdd6sEdJmi/tLfCS9 IhNfOC4JyBJ7hiQwW6CDm62ig1OJUm7fdhbq4Ga2Ds5RclZ3jQQAmz9JAMtU cHK2I98pEgJWOwDyE+DZnhfD2t4qxaC2N0qrHPsoCsQCyYAjKvrVGoYSgr/b pFzkXM/fMbz/P3U3j9+IlhbJQfyOwim0Gzllb8S2wNDbWYiGMbxTqI2qTcvF Xp/mCXsmWyV1p+wmECtQMV5e9J1Oq3140Om8sOMl7+tfdNDY12vXjsTHLp1G SdNpNY4bByCcHDdULJBGo6GDPbsgMSpeGs9kDDYG0gyKhmKVJUZONN2jYBT0 ZszpeD/R72hIxPgeW9gdx7aVRa3snOdy1UVJDxtH9cvjds7VPnG4qey+ycCq YjFh5+j4rN5OVHV4donNANntpN7O5TEOINeBdkPiwouk6TBpcNv6q/eSauOa O8MgCDocrbpzNbwmoGRMtpedjKlFxUIOtKwvqFmIBpd7wIseyNAOTQuzq6IC uCx2jNAxvXkpmb7ARlT2SoPxIKaJTCOC9ly2ug20sEr7E8Omis3gYmI4SR9J EJ6/ZAaOPtQM3YyxKiIf91YiD8zM/92dsJl5eEduccLZxDxYvA2IHkhU9D1l T4sqLUk3rEVSVds6qbd+6bQbv7dJmgExX0SWvPx9+dr7P5X7qmruRXAbUlCh gIRPAmdk21LtYswhZOQeTTiqrtfY4RLOD2TqYBmdKZcLh4v6SQsq1+nIaI/w LNCU/ZocZvrh3Rg5UGwdNk9PYUG14fSSH91E/vQmwm6M8M9PIFvB34LNXBKQ PRjTQ/CH4u2idwVqyKl2ZABBdiKGmxifE8bxKpjdYfRPtPv/QZnVwqFyRJ54 ePDujkX5wtIxMxty+rsjd1Uyhr42vjLaCFQs0ZXeRzC0x3CcQmt35RMrPlsO WVqwCNpGsm5f1M9bncbv58ChGoe5mkTUPrO8YixHSNsJkoLh4EMcdHZDwWn/ PzAumGqJnEbikjdGLmk3z0473Jizo6NWo52r2MORmsSryLyr9z91MQItBpzu TUOC63owrWPLfJhso/B67nhcRupuY0oux1F4C0IlurSuKZLyNiFncNt9ncL/ sWOFtlO/m4LEgJ6XyqlnekuWsyoCGg8viacknESieBtFV6R0AcqWdVWcyawc rOk27Hs18j2jBei99GoF707Flex61yEkuAnmUzhFDNmRCjpHgjm5jt4EvY/K Klji1URBEA/fmGeXm7sCN+YSDf1nczhUBGgKjERi22JEzpKTZSQOUBG6xI/F cLggRMI8DO0xvJd5f2uIRnByEYnFaKQs0cnYO3p4S/LVcPwpgA5dE8Lp/yhf YLt0vFMnMo9LrrDf5/DRFVwVQG20Qf5FucJjR6hZMpS4qAKMLB8hghWuqlGA sBiUHya2LjvOWVocZsec+Ao5zSC9qoUPclL/tZGd9p9O2svT1NSG9Xr/p6rO 2wfiZyH+/xSrdMqxCBC9JSLRwPbX6F6huod8MGwTdZaM5IAccghUWEnkcqbM 1smxWO8/0lgO/Ifo+Yy8AuLxjXga9RVcjxynUbFAE45q5mDXCW0DSSvIlc5y 8aTEpaUsd78g1w69ypObBTp3yH7xrI2quGSbsrYnq0upG0ouez+xuV/r1+Z5 5/zi7Pjs7WUDY4jxRuR2GJ/zJqTYIXnLPZ4lFm2WmOSGK9DepblFhGRH0nJT kDTad5q3twHI1Mh4vO5gRn6SMUd1K4pd1MUz3qQnh9Au8pHu6K774EAb0Kyf Umg97Vmm1BcIAoR7gNqoXnii6x0Hd5yJYSJmxLrnEwsxhVJo8vJC5PxUYgyL ICZn1d81DjvnB536EeqOMNJsnmorMHmwX8igiQSMTyDv9TGJfnbYWyBjeaSU ohdJohRvHdeKnKJgESMtPyrfFAJ9EKxAcf2KgtgVuwjXcuvDfxJv8SqI7oP0 Rq5lC3SIIi9/lOyiCWoFF82/NBKldcqejNlUX052a/Da9YNf8XCQatDgkmHd 7rg2b1ggvSYiwiiGa6FGMIhHT7kJkeqfpzPBZ0zmP+g1PUMtT3dMlyAcVt4u CEXWsh0LRQWcQWcHGPEue/xYMa3hHV/TeCaOCq4EWKhQ96fNNlcvQSEnDPwy sMLRDPmwrc8iGNov4vLqliNVDCQDvQAJeggnH7GpWyUAW53WAhd56oJ8hEcy gp1xT+tQc0R+3ukVcut5W4NdTygiukbyGO1Gqs30wSBP1H8ZLpQ9PpGaCbmE U7YZMhobdU2ycICg6O324UmTedGtnAuY4EbbqzZipPEAr32Vv328DWU9bOnV RupGmLvUFXS/ZDduuojS5KkirgIQ4oZIV8gLktRoKJ6/wFsnUutUGKp3Pe/i TVOgEUuCBybLtIuggoiGct8LJqz2wi7CeZZnI+QQl+tu5J2enf8QCQwL3nUP ewG5kuLplyBNou4g4N1thE8Umq/VFRCRkPlf75kR3YD/1VL+V035H2WogsS4 6+14296W98rbpOyPeMYXq/K/ChV7v+L/dErT+gbf6qEDtaICId5JtGYELGAA jgleoCK4ENkOQBJyjmfJXTMg5Cvd1EwYpPP4t/ofLTyfDBmvhXdfZg0Xlw2X U4gcztcylBDPlOG0x2hShs/wnOf7Dt+7GEa94e8+F4MnZO3ZCAev2ZvWIU8c nKPcWHVTzOLwdD6ZwayacRxQxSIyeWKoQcc0eyQwHTzPi+OkvhWeBlQEKWtw 0xe4S+WfrWnIeFsCrKNu5pjO3ejGxAbXsuPFSee40Xlz0aj/en7WPG17nyv3 Rw2/cn+IH0dH8NHY/uJmeBPP0NhWaTlXw8rAx4xEHYMAEvYHiYSJsvsDH1N/ sTfGVTQuvAF+B/9wOt4FP0wV1tPF4TmBsIzlKQxKwOGvzbwwsNx0guHgx88r RAS+4VTGNuLZEBDICZyikVt36XTAqIbIa2iqj4c95l1ShLHA0dgqyKC6ytm2 ZEGmGi8NmrqklFDwYIxWp+I7p7wgXS903QxI5+ji7AQBFvXVoLIc6KEtkLLe cd09VWjcLrW/ulXC2SsBd60dXzQXbFrQ594rHE2NSsIkIHQMiuqIpEP1puwT IKyQc7NdrrXmfMZENcL3KBhfz27UMpIiofh1eDGZiZqs20dMU+luj46u4wDP sd0pHGBnIZXmwMYJ6IegU44UIoTBU03rNhXD0yjoa0FeZFKToYOnSZQdB2OS JZNv9rUk68YnXE9P7sB5+hJBZN8o+ZOjD8coIg4TqZDRDC+WTDTxdbYagzmk QAv7QW9KWkQG9VCnMYtJG5PxIXLymdiSGGwXngKwdExjtYk4haqm3SJxOjps HFwYMZ3yas1f78maD6g5EUAyqfmgVAv1HTFdB2b4UU+IRcoOq4dG3eF9TiTn C/8njknKgLBcuGhQUgekuGA4SFdLWAkgYNzAIZFuTvPhtA+yKS4/Y+YB27DV KOAYQ1ik1I7wGnHzHmiBMcbomMDIOnS7Q0vcG4CMKlYceNMZ7RuDi4v6bwzN y1yXiqFzKuJ7IvwVHl5v6Jrk2opiD8lj/dMlkqXLpr2jOa+8TZmDRuev/YTs 0KeSiA4FTb5nh47gH/suGlGLDeq+V3vl5RXOIjDgCeyZUSg+IMBBmySAsH6S eSJFTTV6LFzYurDqq0JsSZ1enqCVR8urbUmUG2vcjs4T43WpwN/6YW+urxJg eKaTMBL4IhbtGcOl2+9eDeGcJeiFQ4SbQuAf3C/w2jJQ8UX4BoyPWDsV6gDL iIcYJBcmIHNGOg6gMLe7xWliFwjnncQ8yGGYUA72dXCgzV/UuY06qirP6+ZQ 41ixUZBj0dG5iHbK8FVgS2hD57k2ZUibrU3VtnRysYrVJtlyamX18l3zon1Z P+ae7mhUdyd2biSArzEJRKGyS0uc3mU3fnHDjc1wVuMxQv1lq+MuLueXdGLB apIRoROMFKtvEbRKgJsS6SmuMhHX6FtmLFrB8YSBMtqZI8gskKQKrNRPW9/A tdGEhMFZ4yv9vFUQe1Csi6BEvfOWspqQLYnXeEEhsNtLXk4jxA8CRpjUAHZQ scMJMPACSXaJNqvmYogU01g1tOet2IgigY+QwrmdnDNuS6Ik2/lblL/m5o+F gE7L95byVbfcjLGZvbAEKiCvy/KKpj/yndqmFNF1C3h0TLpjDkagyif26smu z3LcumM0SJkseU1P/dP6SSM/LHjJ1O+HH0Qau1Djx9s2Va6w7Bj3tOsQmjYK A//KZ9GB3M+J3hanvyj3p7Hi2RaJ5/0UhKgJQhqK0JwZT0ZWq8lLtVItk5tw /JCsRqAQiUmFoTfC87C6j73S4nkiF7CwAdC3y6I+2b/igTwc99AWta8lyj7a 7Uz5rKQ8HBCZHJmE0IAuRScI/t2XGw+Da2+W+GOpn0V5WkkrUH9VyvNlskv9 Z1C++FzKO1RXxT2Z8p5ZKxrpCUOFY9h3AfGbBdfBtESwvgrFzjF8qm+qfBuU j0DtM7ORQeH2lr9b84q12oa/jdgXj1nSR8f1t52DXK5yX2P9fyX27h2+q+p3 KJARc2mHM9Sus3iPDBBvO2xlM0VUQUWqsae2Bv2HSIRdG5qNAWyZZ/0vPWV+ iF3SuHBoXr66tb4J7K9aW9+BP/h1s5AiGUtqi32uu7IxQvL+SdhqecNW11Pl tFjSliRNkxcK+loQhLV7ssyEjcnqnda00QRhmz5RGhBJ0TbMIdVp4rDp4oWd osYKP514MX/14BEQak8beKlEJuALJBJi0qsS4jytV2tWHvV+Bx/rZFbMGKDC ZiGL/Jj6T1xk8eZx6+IDIjZ5sVZC2swh5GHxPDFgU82rWK1LG04ZS7R3W1K0 FLxsfjiJU4mUOlVkppzGzrkkXoTTrhU8QrRAWticAN/VkmDJ43hgzow5U0GJ 7n0VGok5+ibXkj2pVKdSJxaFCIJHPzuRg2CMcKYhfnX8uJnVJdH2/RD9i3tj H0Ie3yNB6060p+4Em7Ia4ssVkDeY4NXqYLKt7BtJgw8JYSFpdQYrDbPO9vZA 4PRKWUXulN1juBRJZq+g1Em7t3BWHuOGG4ltc4oKA+V5VPPGWn9S/z2lqlxa A2ytRXo2PB4vnU3d7LmUOnaptI5Pk69Ib7vop9HcKWEVujsn76y2ZJLfqW7H 9ucihwT0p0AQ0/DqH3idpWB112BLH/e70/4aQ1djGiX90QP7QLl0HBD60oyD xjIsJDj8TxZz/itz4av5cARnuw62QMyXge7OUwqJ5YnSa/y/0f5zOLCap47q JDmKmyNzJgqQ3L1TltwI2O1gxGYJLwdnp+8aF+3mm2NhQ1ld8n4irvOYlqW0 inEw401DkidcxQT3b0iReh3QyDSfMbsfagyQ6tlFSiqZ4gf8SuDNY+121qqQ AwNvzNHkwcM7A3X2cnsmDjAKydfK0z7TWwPpuaVlfLOgVWqk7vbW6Y7hx3We Mus/8sP+1YgU4cXHV2zL+XECdtpnarILhXwCIcZO+u0zJGrpM354ogJEprDP DzI6kce8Bd97iUkLklZC9yl1Rz4PZceQZfEHPNOZvmQMZ2cWdlT3VZsFOZla DX3OHuVV6UaDLFdzK88Ma5TtSw2r3Y8a6oWDBpsTUcwXCqgBy6UNmBXyzRoC GafkIBRiA+w0/CWU53s4fmqYSs/gzKUlnDlzBuCgLBj9bAnMsPSSt4Sl7wAr X5WLl/4bn0/xAEW4Lt4B4uNPhiOG96doP8Pb4airfJDnUx1Yhvo1VkYU172e fTEGmTuco2PSqcvS1Jf7pvuXrUan1b64PGjz5DlFz4A81NCZ+DQChexiPCed YdkZicnH14EXtzn3Cg1R/HuVxsgd2kzh48dCTpE+FicUa28oisPkQd2JC/HV 1Vc0v1JhLtmMigbFunoTNTMxEPzeUcarSplpNPd48SzdvGi0Ly9O83gN7Xut c55x3md2hbRiQlZgNYmDjvdFDi7PRpsnzeJXQpsnXLY42rx1yGn8jmGVVYc7 kOqyoXkTZPA5nxAAwbYtvHJiOA6GOYKaF9A5jpJnbjNCjFggAC9vVrAvDS7s c1Hog5FT/6RwhYXOKX0hcSpTVH5m5MlK9OhOQOSfTNHo2j6GpZNdsTqL9NdD NDdLUFyxvvhE0bo9PWHQvfF7IGiV/c+f2DLdKjY2W9602HxPjrsZcG/VAfc+ 86h4NOSoQsR4t+9TD2Qf9mUIUQ9Z29r1dze94kal4uohl/JNrsulcoePdvkF k6pDoPmpDaMdEcr84sy1PxdVVFGzNH3OWX74/zmCUMStOVaIQuHTeL//4Ivq 2N42HsFbePNIr08Jl8I18JtkVFvJs0mrLLDUTqQ3H4veYholZMfrSLMbUUt9 9qbHpWpsmPKMLxDco1KBDlp0YSI3mXQv20WnsqCgWLMXJ59sSUQ+7Z8qtGC2 nE/EBM6fty8KFsWSCqFKwdjlYyCkAc8WLfGNOeykFoPwJohjOA04MFcXDmcY II/dkEfBPcVapFB89zNSU2GUJOwfmeuQoRlQnR2Njt9A18gYji0O+TaL7QuG 8RiqEcdbQpUNuwbHDsjv6hdNdDNvdZqnrSbwpDfHZwe/5vtB1PM9kjyAFN+x DFIgaa+YS6fYEoLJdDvkavmqvUsWuVp4YT8O8p4oM0jDbwGHpDPIY5QYVZDs yKN5vO/9IOgi4vj8A/oPeqNw9p0qiUz8dXG9+ZSs+CWeV7wBvo6dKlCWQGc1 09nJJxHIlnOrx3kcakpJ7mPagZoKpqLujM2pExhdOzlhT80aoiNb1xPvk5Tp 3jm6qJ802ETMY+breLewrwqpbgfRdJ9ToGzLnk5Ah/1c7CH3PfEYyti3XOw0 z0O7CWZEHcuhRjsQcf7wdhR0Bz7dcOi4OiluOIMheeKtVodbdlpxHpRnXcQ1 T5vtTpxseVMCpGb+sKBOJ7Ww4YykOi1yYOyZLAfr+MizyoTePSNnCl+s5C+q 1X30RWAXGHm2LYvZ9XOyw6oPJob8ZFOIJF2YXJkeakqJN9JFo37YOTrPF1Iz meUd9abDKz6bqKVArh3oOm2Wl47kOA0+0SW59Y4WR55tVhCpynB3tKWhwTr4 pd48JW+YSC2JH7Sfiw726ImVgQTqjgyZ0fHnBja2kjRRQcn8Et6hE46PsptV E+4fzUNtw4xaQd6w0Gsk6I65ZBYdtQcg8Y45mk6jWzuGoMW23HTJlYV7ptFV 9BWwqTOPdlKy2C1vUTb9pJlFPfCsdBlOfXbqZc586Z5zTn1LPOYyurCo2YaT qJO2lRIlGVj6SVfd1FVODokpTeERzFOJvpfdLqktmTAB9ZWSaUnT0omU2TIl 2K3UukdurmI8gUZL7NkuHlUBxtCbR9rQf2bH+rMiIup7noC3sqsH76gZC1su 6zIWJTiKwt6QPLFoPxviyaqJgBAkxagSfKbQMYIGslc+AZL4DCdQUfjbLYQZ GKKl1V3AlZp419ShfmjC3kIhc+BUZNMBW6GSaT+dUlHmsKijokez2/6V63SA 1iuHZ97pWVs590ovlWF7IGKWhKUUtQqZk5LdI0m4aoMv2wwHOTprHLS5EJIS +SSHjAShMQrEPosESDySsI8yGt3QN4IkAFpQQVQ52tagDRFGSAzHA3LI0NTz mpyoH9xyBHfHyU1hkcjoQRdeKo9bW0yxxc+mRBCfkfU0mtlJIuhgGfoLQ4Lh o3iw+d9t+InC/kYTFAmE6NHkO9/7/IUezPGnT2m+3yy7amZnMaKcpTVUHWu2 prEskgaKj5hyrgJAp+1o1JHm6buzgzpp946aJDzkV2gaJC0INSTsXT6PD0s/ s0Nth12B2LUY9kLvr17F2zOCZQcjDHaA+No3nossiq09CsnnPbXiF7F35cqc xeHdvneUZ3SefhZyaQXxq4Xbkk68bGfy4g0AsaSlj3QorsFH6We1E8ZTw6mm fhxLj586hyOPGdcHkHMiywhNL3ccqYOu1iSUYKKgJIBcBbZ38SdAfpo4mnJ7 8NYUe8AtKVUL2owz1gBWl6CdoALPgSbRmY4DW8OqQz4haxybq2osfq3iEhOf aY9ADZ7y6jgHzqidopTHDV1++aKZyzqM+KTN2tja9DdqXnFje9uv2dqspZPG YAAK5GOkoxMbph7NUSERqWjtILLy+REkEUnMRzJ0MB2OUzbMaEJhbVHCI/xZ ybWXUH/c6csNPAACJ2y2xLrMqAfwkG/txKUXWbTZT8VusFyG6CkMTN8+3aUt ITiigMiKJ66sM+E6ngrd+zce7KPm6aEsd7zmz5ti/UQpfGha0DQ788t8IjvW /98cwecJJXhyIwWLMVImkgQc3P2odn2DioX7VQzdLIVPIm8mBCR0NjLhkJ27 H1a5ra/7niUIUgIb7EUT9/yy9QsupMuTxmm7lR/jWvM9/sQNT1S4PJn0Twb2 Yc1VWoO4HDxlqr/RhD7t0qwHVF4hi0fHSrdP8o/qtgoMGk0YyfYrNVvznuiG FIW3k9mDq8Qhu+EeOofZOp/zA9jWZz3XNEE3qz+/vX3g2Zc8PJc4yGZ66sTZ mcb48PLk5A/WMmRk0/L7MOohLmZMpcQTdiwnSekZOi6SO7IyyLPdGJw+hZOV OqOTJXtxdm433yQsmKUWaYgR8oEGimvfZgcmAnn9ZqXib+16xc3Ktr+F8UO8 VRrLJ3Sxm+f7SWXLlzhHI04L0x0dz4NqtxJUKgPf4++DSmUTvze2j44OG+jj XkrLGsORy7H3FGyarF0lT9GZpZfF63wcVceyarWWBNsDxDkNvqRldCHvHtmQ VKJYjvmqe0h8uuLliWk5AbMOMF9ICN2LkqdonVbKlkD5WthodUReXKSxCEeP bNmMUWuP6PUxSY+EgxhQnLhzkwxD24U902nrv0JELrweYomH4n1Tm9FxR4tj Ztce3ltNpuP81FunHxbTBFnF/gWtkkjkSEjZLWIsmHcPTuXcNNEf9ghnTb4t zjd/7xgq56kZY2Ix2ACs1nP2Ji5Krgb4NjmtU48qR6xzk6WYYpD5T3qkPp3T TpDYMchAwvf0XUUxrulEjSXKXjFXeYIf8yyOGWuEnsqrjxPptpcPFCdbPFLs BZ7dkXTAU76cOtLaEPJfBJl+qNCq2wI3SeHa5+OP8Xuh5mmndXbcfMNTow11 nMPPUwRk88m7rSDqbqZUNINjunkXg6Uz2eneG8cxl9OgbipvksM4paeC9amr U6q1kAlrpqvJRPxzCZYOe3HSOKEcQ0H+c3ElhYCxLliQmabyq0G/8+m2i0YY LMg8rX4aPZ6jlqWOmMA8snHxuZ7ZxBMGwiQA/WBGFnV0UyY4Cl1yGaXmQduH t+gFLRoxxD1hlOHpx4h0RFGylahCO2m90e5LThk/sIZsDYX/NTjRBKM+EkN7 6DIEO3t2lhUuvCTqjvCy4kG0VYJSZLlOzYzuDq/CfOVDC0f/+e1EUMWMd30s OV5K47kZvQ+g1Nr/3KiW6QD+LHLZpBIThscSLJNYEqJmKcFWIxZHbkih2OrU YvnuALb2DqGanrT+OHlzdtxpnTcOmvVjIn3jOP0lKc6Qpq7qGgtDjSgGm5Dq jc9k5Clj5q43c6gqHpJ42dz11uSkv6ZHiidxbLQQgFYwrlR8HQJYo9iUqrGN tmmw9kqnethO1KrJydhsWR3lbiYypE0it3Z0J1D/1FUWDYx1A+7mZ62tDivq TCWtJndbcduNPsKQhnPGqsoaMAfjKwo0vC56XzxiBM3gsa9JfABTx2/p2Kkw UDiAFhpZyjDm6otHsexkdIaxvfowuqU443ix2jhSASBrkBJ+xaFUeawRVccs axvpgZTdgVrMLkdX8WTM7tyZpSfEREYUTaFw/hbyKDnTUBJtHOTVayVAk3MZ gnYU0tIhdnLlfkc8a/G6/isWluiBGWrdAVbtZxbpvbRL9L577aWVS9Y0TomL C4RzJf1T6mXePmTiE7CeGL+12u3O8dn5xdkBKlkexuH44Rbv5Wlu4EuEi2vj ZUfBhdUWs6LnFGbMWDK4BZRx65uJ8NkbDvKYttVmq/Z8PhjR5IKWdMQEO0/j VPqZ7vfxIkWSlCMGTSJTTNNQKjmXOQEJXyn3r6oYDmwLa7buPjL3RwSE9s3M oKYm1hxHIcheZ1xZ6XvCOfToENB8S9K7ezKQh0bgRzzKrxeLggHXV4xFYeBj Vo5E4QR3UrFpnhfXaUHM3tlqMXtnT4/ZG8vqRHhUgaHsIPZZER5XiNkbi+f4 9NhN36I6fovq+C2qowqWlQjZ204J2duUkHZ8xXp7a6JQqUUscVt07Ds79Nua KuURSO3xWFAuUnv8rUFqL0qMgeVI7V8DIb1oMNAJ1APBVdRFtxxWEZcXVlYP Tq/xbeP47LcG7OfnBwTKomDSnmnWTRG/nmnWXfQebdatO/VIs24Jy/ZodWHx K6kLi09SF8ZN8h6vLlwQqGKxutAl2NPVhfEurKoufEr9GerCDL3S4satoC4s EpdLkSSLSyXJpHj2/Cjcs4VRuGerReGePT0Kt5W1PQ9YRqt51creq929zc2E jFbd2FxJSNORtiUm4TcB7ZuA9k1Ae1a004Rwlgi53U4JuZ0hnGkEf0tGW0FI yww5ymtdBxhSMUdVocxuF8cTXT3uqJKGLmlhmupFouLoDgKfDEM9CaZ4CR6P zEC3AIyIoiC4bVkpJfSCb8dekAANMeEqMxIDTJ5P4UcrFsPlRIItUQplDW/P HxPyAV9xuHK86Jgo+xWxFRMPLN6zziXyIvmgqCXUD67m19fk2NEaooWAM2RO UBmJEhvDHG5rXbbcmtyGhD1IVoWqx8lQDxLAj+cexdXL6KE7TxIFLQgnkfuM IrkPH7BD3e9iLIdg8EXL3qkGQAqimzT5xhBGCeUm2EUiwsqeMBi0DvdGU7Qh ML9RVphu8pXT3TB39XEy68AXybLAQsgIJKY1jzbVGezC16rq+X8+z2SOIv9U 92QmX5p38tN9lxe1aJEDczFx8psQJhkzR9o0yAtjaLHOBYc/VL5LieJIg7Hu m6dvjxHaonGO29EE2xjkz9v0xC+XywVvgDsiBYHRUed4DY5YIAnd6hW4Bi3W LgeUq5Ur5XvhPJEPP6vmp4FrpdJq5Zp5p4q7Y/dRswO58VzpnAizcITAAMEk X1CAzYr4pVk/mJR7IhDop1FU7iX3fqX/11DJDpVyVVlp/xUj3cpWT1sanILH 4Z04u5PHIIiIvtd6d7GJV+DBLUy9KQZr4zAJPYIl7APLwy1veG1CZg0xsg9a o2n08j7HDseXb+E0QfsnMfh+OIuUisBnrQPQC6tkbshKWrJduAs4jgDRnAKX SaHoBo0A3xxHu01G+yZiiw54Ki4MdNSANog3AzuHQYkH58eXrc5J/eLXxoW4 o1I4HR+lgBscbBHHgctFNxKiQLYC3iUTUTfM+YKVLQyLrGfBJ45hIXdX+TXU XfQmo3nUQSuJYPqXNQ71dt/FES6U7Y3Obq3F8O0+/FD+QYZXAhmjsQO7zxyQ m8DwWilyNHaBz2z/p250+6N5X7752Z1UzbcHZ6d0L3F+oMw483hbGw4M4Bvf 46171R2tjhlezwnTd2bFm8Fk/7jlGEBwHhn3ZcqQy0Vwzy5/NOaSUuIBRd4/ OCBIQIE9A7JSFA93ysuB2XB68EvWDGrveonOS5c12my7q6LkKvf1aaU0rUKL phVPxU1iMQYagvAhhnQGgF6QilCkZKEXrfP+/gZoVSCXC94Wgr5a0fCa9wbC lZ4MNfw8XlkcHl6odAraSJs6YDwzxKKY9xAtP03BgXZ1QjbxcHZC6th2qSg3 H5+dvv37yXmHxWiJ1JtVDr1VM2xsxyoj32hWrbG74tW0O33Q7b8OScDkwKRd L7rFlBQSRYN7w2FpEo4wMQ2lLLO18mQ0WwOxzDYVgnU9nJG/mGKX+QJvLKo+ CQhFoeDIM5R1S72Z5r101MONZMJAhSF5N0ND1BSJyM36miZJmbAXhAsiD0OH tfmkE0GDrzqm6eoW9eqhA/KdKD81pIMYDEmsOPQJkf0CgxloklmEcNWi1jgP xx0gS0eo4jjtJlFYlqs1Y+XlxUaVFYypw91dMNauBy2yXx2TVkLQPcRHO0sR K8JXqipWiTnNgcScIP1gNjE5+oMVRff8gPcIzZaMk/AMDqUDy7oJDdUjdvKl s7yUUsmK1Mr+PvHJkVyNaLVLljnLVMfekiJJk2xur2myYWhA2/E5QR0DD3J+ jL7AYzrtGEZE2xzaLQ97kGX8Ec+yoZm3qmiCzDWIBXhVzqGX5LocNdFe+Em0 YrECsZmK2em29oMeyBORGp6xKkVLT9NAFzwLjQaIdBbE1JVtINFTzSX4+w42 SeHmcDTG5Q4cBOS0cm9p0GemPfQwHGFfFod+jleZXsi3IfsaQ4YYahVeRSwo afZx+Mdp648TVQwtpowRBgbIQwN9RVsTGaEObUXZty9pXDalUm9pHXxf1wtn szd73oF4eBl9G7K3lJZjiZ+mm/+qRi8qngiv0c2cmw5RKT7jmuNeFIlpVxDq 3cIrDpWILjj+Ph953rZX3dqr1vYqYkmSccHhZEy9GaHoGf72tlfES46//Y0s 0mK3G3RmwbsNPAHiqYD3Tr4auGi2Doa/e/nN8sZV1C+wZaq568iDxIj3HXjJ sbNNn0tvOUomImHqLYf1/rm3HKWvdcuh7HGfd8tRWvGWI50Cj73lUBF3nnHL UXr2LUfpsbcc3Pfn33KUnnnLUXq8GUppBTMUy+3xl7OWfRHgAXXbxw00yGjW T9EnG9PibkGLtoknyAHWaUdLQ/qJ9lwpwr1fYRGpusgdYqLDaLA6AllixDuw hJCXUEK8uo9IrxfNr1jNWvFh5n2C7RIhZzYlbu+QQr1IwGS8DOGcWDw3yhwx YW+YmhB6DNICXyrixhaI8K0iNmPz9ymjiXGAOh8yJxFkDsp6TebfoQrci81K kPiofnncZuDPs4vm2+YpVpvy8vK02W5h5Ej3Hd3KoBE0AV0DIVrNt782j4/p S6vx9p2PD+3/yGiav+o7C/0lI2H8PwXMyw6nwJTH2iakq8x5ZiDTUzh0PtC/ abxFUsDU4YHA3yjJwANb0SR2w4KaAUxCx9xVyjM3WixdJlBcP5pnsH3FCUyY bmRIlL8Krn28aCkIubrRrZdfK1+PwqsRPl+jwwP/Y5g3SnAbfhp5f8EE6IOv E1kpeqPpyBvQK0Uacj+f3cRxAbWe3wZAinnZkX84oyycty9SGoS+4lKf1Hag 8JxBoiuFg5K4iIcLWhCvVLlzc53x7rPnvV1lnayVYCmQPkaURxhLlpewTyFY XTd04yhFdgowOT5GElc3jwl1cFHmnbcFZliRAqLCWJ6oJ+4SepzcgMKxMuqh uAQzjUQEN/iYwWAynEXvQw4K1VXwEIpYT/G+YoSKjY+Cs2xZ4/PZGZ8dpJk1 pRIDuCQBML3KfXXTShRLMPX+UtnYhn/2vKujn5XSnBuokzzfA1BwxURgSNq/ UAlItMKiaVFZtFmZ3L7gZmmPsFta5UpLENqG3RpTRSlUsyl+dh4nuE3ucOKQ wqUU7BKjmveXHd8QMnVy65VtvZ0GQ6GtEcgrz5PDF5iE369mEn7/dJNwK+sq 5kYEuZNmbfQ4edy1PXqKPP7N6uib1dF/Raujx5qF/55uFv573Cx8Nfnd0TNA Gc83p7xfaE55v5o55f3TzSnvH2dOuaH52ykbcSuDG5xj2oaSr1SBz/h6AmmL nhV4GxlX1r5xuG8c7huHW5XDJWwrf4/bVmZwuFwuxuJ0uvq7Rgekx5PmWcs2 TxOTGwmhi+oGpVSgU+u8PO90pxUVZ0zFJBYQIZlwPRwrWrUyAlomZv+Z2GXc r42L08Zx55J1yZX7it2f0wbiZ561mr+jH+b52+ahsprBm4SLztmviFHGmLOX rbfQfjQUFBvAuBHpT/MxtAOkvZ8TvP5ZOuX5NCjfoNmMy4LV4yzurt7nTtD4 aX7tbVS8WnWvsrm3WctSIus8Lj/f3Nmr1gw/r1b9LWDoVX8bGTobUK395TNm 7PQm8y9rMFToL9sdTW666xhOB2roqNev6bG3v/+iCJtIyuvpLb70vvfO3rTO jhvthtd7X619KMTSUVyVe0p6M5mk1DOhSrzh+43NV1sfdrbW4yUMN3a2MAlh X76C3hQ3tvwdxELjlpfWS2E0qNn5uPH0mAq3E1I92zu7HyBDMv2Gm542zmRC ekwpX6AmHxK6tTNtiHBWISaBzq+SOG/pNMKlJ8gbT2uRlwf91QZSqPrqFQ07 OpBNe5Apmo/D6JXdE3iyGYUjJpBK5pSNKcJo0yTY2kxLogt5UYJtB/joAopk Jsjo86x7EwbxtPSQ0z5tmc6u01YpPF20SOE1rbczYIPeKxK9dvYqW4vWqMqi lugmLuvqhrVEN2iJbsSWqIQMyF6kJkHGMrUTLF6oVsqspWolyVqsVhJ7ub6q wEItvqr6u85ytVcV53TWFfXXmY4q0bTnLjrvnx75WMl3d3YRZpiT+9ZLX5OS ILkqF5dfdMvnKfzCy/rH86I/nEav1/5ifpjpupadNz6A1SRxzOg9ZlEQRA4K JvirfAUT8EexfiwH9xM9pxcnSy6bxenpCNMKJp6349Xw/LJXqybX0ZIyYmcZ 132/truDbJD/wAOiEyLmEJoLK3/XvLXTUHTN/8RvwSgAKlMyTgXSS/QikRef Qt4157ebEQNoviiBXPF+GInxzJpMm7UPfBPz+UUx8X7dTUAjH68di4aqzcni /JKM0MvriD6zV14fjLrXEfxdc3K8kIBjbp16cv+LKl11Js6Ce8wmrLN8PUdF KM+B5At3tqWlYFlqMvVqWyhL1UAuqrjzKzWXy6phUlUsVr25u4W8Gv/QjGqc Hb3wct/DidGK3ID6Ph1ChfAv4eAsUcDhqHQNB5AoEmMVjfRBxcAsovgvaIA8 K8Mj2QsuERezc1I/+KV52qDNoJgjQ49PuPwNc+CHxKS61WoFXvI7J/9rnGRr nD6Iur1HbKAxgmGogRQ6wuOFowPvHz02mCc2Mrt7G1vWJrpTI5GH/sADotxf gF8Mex11gYqbqFDkn0aWge+3w0lkfQ1G8PVPKy2/p8fqB3QsHMd/U4pEztn9 xq5OiT+k/JJONdioVHkvcZ/AF2YIBYQipxH73rsIeuH1GLGrcLKhTz1CBak+ jjnABcyt7mjYRdNUvsylmLo8ycj3/kAWLyclH33ULCjfCY4SQof97tg7a5V5 +ldrNP3hT7WykMo559nr4ebOVmncm+KbMHpdih6iT5vSp2JuHMzu8E56Srup mxMn+eaoNA2ughG+xdy0ReMPosg4uIuAUPhnu1KRbzv62y7hTcWLvd3a+ViK wvGDahEmDRlueXt3F3u5U9lgiQU55ovsrq6XunDMHRdUSdNh1BveV8s1aSG5 7KxzDwpuF9SgUoIouB3qQroIH/Z/AZT53H8foAEA ------------=_1583534346-29875-0-- >From jingham@cygnus.com Wed Nov 03 12:13:00 1999 From: James Ingham To: Scott Bambrough Cc: James Ingham , Stan Shebs , GDB Patches Mail List Subject: Re: Merge of ARM Linux port with existing ARM code... Date: Wed, 03 Nov 1999 12:13:00 -0000 Message-id: <14368.38867.162242.687164@leda.cygnus.com> References: <382093BB.3FA78CBD@netwinder.org> X-SW-Source: 1999-q4/msg00164.html Content-length: 6944 Scott, I will check these out give them a whirl, and get back to you as soon as I can. I am excruciatingly busy right now, but this is a high priority for me so I will get to it as soon as I can, with lots of apologies up front for not being as prompt as I would like. Thanks for doing all this! Jim > Jim, > > I have finished merging the ARM code. It will require another round of > patches to fix a few warts, but I would appreciate having it looked at. > It has regressed a little from my previous version, but I'm almost back > to where I was. I've attached a patch, and placed a tarball of the > source on netwinder.org at: > > ftp://ftp.netwinder.org/users/s/scottb/gdb-991103.tar.gz > > I've made two targets in the configure scripts for ARM: linux and > embedded. Basically I have: > > in gdb/config/arm: > > embed.mh, embed.mt, nm-embed.h, tm-embed.h, xm-embed.h > linux.mh, linux.mt, nm-linux.h, tm-linux.h, xm-linux.h > tm-arm.h > > Most files are very short. The bulk of the definitions are in tm-arm.h. > tm-linux.h and tm-embed.h both include this and add/override anything > necessary. > > in gdb: > > arm-tdep.c, armlinux-nat.c, arm-xdep.o > > Again, the bulk of the code is in arm-tdep.c. armlinux-nat.c contains > stuff specific to linux. I'm not sure what to make of the code in > arm-xdep.c. The Linux target makes no use of it, but the embedded > target does. Much of it seems geared towards an Acorn machines. > I have left it alone. You should have a look at it. > > If something doesn't seem right, or you don't like what I have done, > please say so. Nothing is written in stone. I took the liberty of > converting all the code to ANSI (except arm-xdep.c) and started > converting all the macros in tm-arm.h to functions in preparation for > being multi-arch friendly. I'm certain I have missed a few though. I > intend to revisit the code. > > I have compiled, linked, and run the testsuite for GDB successfully for > build = host = target=arm-unknown-linux-gnu. > > === gdb Summary === > > # of expected passes 6009 > # of unexpected failures 48 > # of unexpected successes 2 > # of expected failures 195 > # of unresolved testcases 3 > > I have compiled and linked for GDB successfully for: > > build=host=arm-unknown-linux-gnu, target=arm-elf > build=host=arm-unknown-linux-gnu, target=arm-coff > > build=host=i586-pc-linux-gnu, target=arm-unknown-linux-gnu. > build=host=i586-pc-linux-gnu, target=arm-elf > build=host=i586-pc-linux-gnu, target=arm-coff > > This verifies there are no outstanding syntax errors or unresolved > externals at least. The testsuite fails in all cases due to the lack of > suitable cross compilers and target hardware. I don't believe I will be > able to run the testsuites successfully for the embedded targets. > The x86 builds wouldn't compile correctly due to the implementations of > convert_from_extended(), convert_to_extended(). I have ifdef'd them out > ATM, and replaced them with stubs, until I can resolve the problems. > > I don't have suitable environments to test: > > build=host=sparc-sun-solaris2.5 > build=host=i686-cygwin32 > > TO DO: > > Shared library support: > Both targets make use of IN_SOLIB_CALL_TRAMPOLINE. This needs to be > resolved for ARM-Thumb compatibility. At the moment this is not > implemented on Linux, and Thumb is not an issue on Linux (at this very > moment at least). I have to get this support going, and I will resolve > it then. > > Thread support: > This has been waiting for Cygnus to integrate the threading patches, so > I don't redo their efforts. > > Multi-arch readiness: > 1) Remove EXTRA_FRAME_INFO. > 2) Replace FRAME_FIND_SAVED_REGS with FRAME_INIT_SAVED_REGS. > 3) Convert REGISTER_NAME to a function. > 4) Convert to new CALL_DUMMY scheme. > 5) Verify functions maintain name space purity. > > Note: There is code in arm-tdep.c for the new call dummy scheme. It was > written by Cygnus, and I think Cygnus should enable it and verify its > correctness. > > Breakpoints: > I believe I have resolved Andrew Cagney's objections regarding the > breakpoint code. The global BREAKPOINT macros are gone, and have been > replaced by arm_breakpoint_from_pc(), and macros used to define the > various types of breakpoints. I have added commments as he suggested > indicating why things are as they are. The following problem with > breakpoints still needs to be resolved however: > > Consider the following code and the generated instructions: > > 1 int foo (int a) > 2 { > 3 int b; > 4 > 5 if (a == 3) > 6 b = 10; > 7 else > 8 b = 20; > 9 > 10 return b; > 11 } > > 00000000 : > 0: e1a0c00d mov ip, sp > 4: e92dd800 stmdb sp!, {fp, ip, lr, pc} > 8: e24cb004 sub fp, ip, #4 > c: e3500003 cmp r0, #3 > 10: 13a00014 movne r0, #20 > 14: 03a0000a moveq r0, #10 > 18: e91ba800 ldmdb fp, {fp, sp, pc} > > The ARM uses a predicated instruction set (the condition in which it > will execute is an integral part of the instruction; in the case of the > ARM, the 4 most significant bits) which allows the following code: > > c: e3500003 cmp r0, #3 > 10: 13a00014 movne r0, #20 > 14: 03a0000a moveq r0, #10 > > In the current scheme in GDB, "break 6" will set a breakpoint on line 6 > of the C code. This corresponds to the instruction at address 14: being > replaced by the breakpoint instruction. Unfortunately it means that GDB > stops at line 6 on the ARM all the time, even when a != 3. > > This could be solved by having breakpoint_from_pc() read the instruction > at the PC, and merge the condition bits into the breakpoint. Then the > breakpoint will only be executed under the same conditions as the > original instruction. > > This will present a problem for single stepping, particularly with > stepping using undefined instructions as breakpoints. What happens if > the target of the step is an instruction that is not going to be > executed due to its condition failing. > > Another problem is semantic. The user types "break 0x10" to break at > address 10. If I am looking at an assembly dump I usually want the > breakpoint to be unconditional. This could lead to unexpected results > for the user. > > Scott > > -- > Scott Bambrough - Software Engineer > REBEL.COM http://www.rebel.com > NetWinder http://www.netwinder.org -- ++==++==++==++==++==++==++==++==++==++==++==++==++==++==++==++==++==++==++ Jim Ingham jingham@cygnus.com Cygnus Solutions Inc. >From ac131313@cygnus.com Wed Nov 03 13:58:00 1999 From: Andrew Cagney To: Kevin Buettner Cc: GDB Patches Subject: Re: RFA: remote_address_size changes Date: Wed, 03 Nov 1999 13:58:00 -0000 Message-id: <3820AFC1.700CCEB4@cygnus.com> References: <991103174409.ZM14789@ocotillo.lan> X-SW-Source: 1999-q4/msg00165.html Content-length: 3175 Kevin Buettner wrote: > > Andrew, > > As you know, I'm working on a port for a 64 bit target and am using > the gdbarch machinery. > > When connecting to my remote target, remote_address_size was not > being set properly. The reason for this is because at the time > of initialization in _initialize_remote(), TARGET_PTR_BIT refers > to the ptr_bit field in default_gdbarch instead of in a gdbarch > struct created for the target. As a result, remote_address_size > was set to the pointer size of the host and not the target. Good catch! Have a look at how remote.c registers and then updates the variable tty_input. When ever the user selects a new target, that variable is switched (brutal yes). For remote_address_size you would probably want to do something similar. However: > The other thing that bothers me is that if the user uses the same gdb > session to connect to several different targets with different address > sizes [does anyone ever do this?], the conditional initialization > > if (remote_address_size == 0) > remote_address_size = TARGET_PTR_BIT; > > will not set remote_address_size correctly. The above mechanism binds ``remote_address_size'' to the architecture. If the architecture changes - new binary of a different type then the old selection is lost. Is this a good thing or a dangerous thing? Consider the sequence: set remote address-size 16 file xyz which can have different semantics to: file xyz set remote address-size 16 Making their behavour identical isn't trivial (fortunatly it isn't difficult either). The problem is figuring out exactly what reasonable behavour is - I have no opinion. Andrew > > Kevin > > * remote.c (_initialize_remote): Initialize remote_address_size > to zero. > (remote_open_1, remote_async_open_1): Set remote_address_size > to TARGET_PTR_BIT if not already set by the user (or by > already opening a target). > > Index: remote.c > =================================================================== > RCS file: /cvs/cvsfiles/devo/gdb/remote.c,v > retrieving revision 1.253 > diff -u -r1.253 remote.c > --- remote.c 1999/10/25 08:36:49 1.253 > +++ remote.c 1999/11/03 17:08:38 > @@ -1775,6 +1775,9 @@ > general_thread = -2; > continue_thread = -2; > > + if (remote_address_size == 0) > + remote_address_size = TARGET_PTR_BIT; > + > /* Force remote_write_bytes to check whether target supports > binary downloading. */ > init_packet_config (&remote_protocol_binary_download); > @@ -1859,6 +1862,9 @@ > general_thread = -2; > continue_thread = -2; > > + if (remote_address_size == 0) > + remote_address_size = TARGET_PTR_BIT; > + > /* Force remote_write_bytes to check whether target supports > binary downloading. */ > init_packet_config (&remote_protocol_binary_download); > @@ -5305,7 +5311,7 @@ > &setlist), > &showlist); > > - remote_address_size = TARGET_PTR_BIT; > + remote_address_size = 0; > add_show_from_set > (add_set_cmd ("remoteaddresssize", class_obscure, > var_integer, (char *) &remote_address_size, >From jimb@cygnus.com Wed Nov 03 17:37:00 1999 From: Jim Blandy To: Jimmy Guo Cc: gdb-patches@sourceware.cygnus.com Subject: Re: (patch) hpjyg05: somread.c and related Date: Wed, 03 Nov 1999 17:37:00 -0000 Message-id: References: X-SW-Source: 1999-q4/msg00166.html Content-length: 518 I'm overloaded, probably until the end of next week, so I can't review these immediately. Tom's hash table patches are smaller, so I might be able to do those, but I can't promise anything. > This begins the group of patches for SOM reader and related enhancements > / fixes. I'm trying to balance the size (and inversely the number) of > the patches vs. patch testing (I'm running tests on HP and Linux Redhat > 6.0 for each patch I'm to send out). Let's hope it will turn out to be > 99 patches as Stan joked :) >From guo@cup.hp.com Wed Nov 03 18:05:00 1999 From: Jimmy Guo To: gdb-patches@sourceware.cygnus.com Subject: (patch) hpjyg06: hp-psymtab-read.c etc. Date: Wed, 03 Nov 1999 18:05:00 -0000 Message-id: X-SW-Source: 1999-q4/msg00167.html Content-length: 57727 *** This patch needs to be applied along with the next patch ('hpjyg07', which is for top level include/hp-symtab.h). *** This patch includes changes to psymtab handling for HP platform (mainly demand paging of SLT and some Fortran support setups). - Jimmy Guo, guo@cup.hp.com ChangeLog: 1999-11-03 Jimmy Guo * hp-psymtab-read.c (DUMPING,QUICK_LOOK_UP): Refine to be 0. (hpread_get_textlow): Change return type to CORE_ADDR from unsigned long. (trans_lang): change HP_LANGUAGE_F77 to HP_LANGUAGE_FORTRAN. Declare and initialize default_fortran_main_string to "_main_". (hpread_pxdb_needed,hpread_get_header): Use HP_HEADER instead of "$HEADER$". (scan_procs): 32x64 fix; Fortran demangled name "_MAIN_" support; search quick file table for multiple entries fora given function, and adjust current file entry and ending addr of function. (hpread_quick_traverse): 32x64 fix; use max_LNTT_sym_index if there're no globals. (string_from_vt): New function, for memory tuning. (hpread_symfile_init): Initialize permanent_copy_exists to string_from_vt, for memory tuning; initialize TYPE_VECTOR_LENGTH(objfile) to 0; use header macros instead of literal strings; don't read SLT, will be demand paged in. (hpread_build_psymtabs): Change valu, texthigh type to CORE_ADDR; (hpread_symtab_finish): Free TYPE_VECTOR(objfile); (initialize_slt_page_table,slt_entry_from_page_table): New functions, for SLT demand paging. (hpread_get_slt): Demand page SLT. (hpread_start_psymtab): Adjust texthigh with offset. (hpread_end_psymtab): Don't discard empty psymtabs as all except globals are now empty under the new lookup scheme of searching minimal symbol table instead and expand the related psymtab if a linker symbol is found. * hpread.h: Add declarations for demand paging of SLT. (SLT_PAGE_COUNT,SLT_ENTRIES_PER_PAGE,SLT_PAGE_NUMBER,SLT_LINE_NUMBER, slt_page_frame): Declare. (hpread_symfile_info): Add globals_start,slt_page_table,slt_section, slt_size; change current_function_value type to CORE_ADDR from unsigned int. (HP_HEADER,HP_GNTT,HP_LNTT,HP_SLT,HP_VT): Declare. (GLOBALS_START,SLT_PAGE_TABLE,SLT_SECTION,SLT_SIZE,INDEX): Declare * defs.h (default_main): Declare. * symtab.c: Initialize default_main to "main". (find_main_psymtab): Replace "main" w/ default_main. * blockframe.c (inside_main_func), source.c (select_source_symtab): Replace "main" w/ default_main. Index: gdb/hp-psymtab-read.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/hp-psymtab-read.c gdb/hp-psymtab-read.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/hp-psymtab-read.c Tue Nov 2 16:31:30 1999 --- gdb/hp-psymtab-read.c Wed Nov 3 17:55:20 1999 *************** *** 28,37 **** /* To generate dumping code, uncomment this define. The dumping itself is controlled by routine-local statics called "dumping". */ ! /* #define DUMPING 1 */ /* To use the quick look-up tables, uncomment this define. */ ! #define QUICK_LOOK_UP 1 /* To call PXDB to process un-processed files, uncomment this define. */ #define USE_PXDB 1 --- 28,37 ---- /* To generate dumping code, uncomment this define. The dumping itself is controlled by routine-local statics called "dumping". */ ! #define DUMPING 0 /* To use the quick look-up tables, uncomment this define. */ ! #define QUICK_LOOK_UP 0 /* To call PXDB to process un-processed files, uncomment this define. */ #define USE_PXDB 1 *************** *** 53,59 **** static union dnttentry *hpread_get_gntt PARAMS ((int, struct objfile *)); ! static unsigned long hpread_get_textlow PARAMS ((int, int, struct objfile *, int)); static struct partial_symtab *hpread_start_psymtab --- 53,59 ---- static union dnttentry *hpread_get_gntt PARAMS ((int, struct objfile *)); ! static CORE_ADDR hpread_get_textlow PARAMS ((int, int, struct objfile *, int)); static struct partial_symtab *hpread_start_psymtab *************** *** 99,112 **** else if (in_lang == HP_LANGUAGE_CPLUSPLUS) return language_cplus; ! else if (in_lang == HP_LANGUAGE_F77) return language_fortran; else return language_unknown; } ! static char main_string[] = "main"; /* Call PXDB to process our file. --- 99,112 ---- else if (in_lang == HP_LANGUAGE_CPLUSPLUS) return language_cplus; ! else if (in_lang == HP_LANGUAGE_FORTRAN) return language_fortran; else return language_unknown; } ! char default_fortran_main_string[] = "_main_"; /* Call PXDB to process our file. *************** *** 156,169 **** bfd *sym_bfd; { asection *pinfo_section, *debug_section, *header_section; ! unsigned int do_pxdb; char *buf; bfd_size_type header_section_size; unsigned long tmp; unsigned int pxdbed; ! header_section = bfd_get_section_by_name (sym_bfd, "$HEADER$"); if (!header_section) { return 0; /* No header at all, can't recover... */ --- 156,169 ---- bfd *sym_bfd; { asection *pinfo_section, *debug_section, *header_section; ! unsigned int do_pxdb = false; char *buf; bfd_size_type header_section_size; unsigned long tmp; unsigned int pxdbed; ! header_section = bfd_get_section_by_name (sym_bfd, HP_HEADER); if (!header_section) { return 0; /* No header at all, can't recover... */ *************** *** 516,534 **** organized in a separate routine, although it does take lots of arguments. pai/1997-10-08 */ static int ! scan_procs (curr_pd_p, qPD, max_procs, start_adr, end_adr, pst, vt_bits, objfile) int *curr_pd_p; /* pointer to current proc index */ quick_procedure_entry *qPD; /* the procedure quick lookup table */ int max_procs; /* number of entries in proc. table */ CORE_ADDR start_adr; /* beginning of code range for current psymtab */ ! CORE_ADDR end_adr; /* end of code range for current psymtab */ struct partial_symtab *pst; /* current psymtab */ char *vt_bits; /* strings table of SOM debug space */ struct objfile *objfile; /* current object file */ { union dnttentry *dn_bufp; int symbol_count = 0; /* Total number of symbols in this psymtab */ ! int curr_pd = *curr_pd_p; /* Convenience variable -- avoid dereferencing pointer all the time */ #ifdef DUMPING /* Turn this on for lots of debugging information in this routine */ --- 516,539 ---- organized in a separate routine, although it does take lots of arguments. pai/1997-10-08 */ static int ! scan_procs (curr_pd_p, qPD, max_procs, start_adr, end_adr_p, pst, vt_bits, objfile, curr_fd_p, qFD, max_files) int *curr_pd_p; /* pointer to current proc index */ quick_procedure_entry *qPD; /* the procedure quick lookup table */ int max_procs; /* number of entries in proc. table */ CORE_ADDR start_adr; /* beginning of code range for current psymtab */ ! CORE_ADDR *end_adr_p; /* pointer to end of code range for current psymtab */ struct partial_symtab *pst; /* current psymtab */ char *vt_bits; /* strings table of SOM debug space */ struct objfile *objfile; /* current object file */ + int *curr_fd_p; /* pointer to current file index */ + quick_file_entry *qFD; /* file quick lookup table */ + int max_files; /* number of entries in file table */ { union dnttentry *dn_bufp; int symbol_count = 0; /* Total number of symbols in this psymtab */ ! CORE_ADDR end_adr = *end_adr_p; /* Convenience variables -- avoid dereferencing pointer all the time */ ! int curr_pd = *curr_pd_p; ! int curr_fd = *curr_fd_p; #ifdef DUMPING /* Turn this on for lots of debugging information in this routine */ *************** *** 538,561 **** #ifdef DUMPING if (dumping) { ! printf ("Scan_procs called, addresses %x to %x, proc %x\n", start_adr, end_adr, curr_pd); } #endif while ((CURR_PROC_START <= end_adr) && (curr_pd < max_procs)) { char *rtn_name; /* mangled name */ char *rtn_dem_name; /* qualified demangled name */ - char *class_name; - int class; ! if ((trans_lang ((enum hp_language) qPD[curr_pd].language) == language_cplus) && ! vt_bits[(long) qPD[curr_pd].sbAlias]) /* not a null string */ { - /* Get mangled name for the procedure, and demangle it */ rtn_name = &vt_bits[(long) qPD[curr_pd].sbAlias]; ! rtn_dem_name = cplus_demangle (rtn_name, DMGL_ANSI | DMGL_PARAMS); } else { --- 543,583 ---- #ifdef DUMPING if (dumping) { ! printf ("Scan_procs called, addresses "); ! print_address_numeric (start_adr, 1, gdb_stdout); ! printf (" to "); ! print_address_numeric (end_adr, 1, gdb_stdout); ! printf (", proc [%d]\n", curr_pd); } #endif + /* srikanth, we used to create partial symbols as we iterated over + the quick procedure lookup table created by pxdb. We don't do + this anymore. Instead, we will rely on the linker symbol table to + locate the symbol, use its address to decide which psymtab would + house the partial symbol, were one to exist. + + It would be nice if this whole loop could be eliminated. However, + there is some Fortran specific processing that goes on here that + could not be removed (sigh.) HP compilers provide _MAIN_ as an + alternate name for the (high level) program entry point. So a user + could say b _MAIN_ and expect a breakpoint inserted there. This is + useful since Fortran programs don't have a unique entry point like + `main'. Unfortunately, this information is not present in the + linker symbol table and must be captured here. + */ + while ((CURR_PROC_START <= end_adr) && (curr_pd < max_procs)) { char *rtn_name; /* mangled name */ char *rtn_dem_name; /* qualified demangled name */ ! /* Get the alias name if there is one */ ! if (vt_bits[(long) qPD[curr_pd].sbAlias]) /* not a null string */ { rtn_name = &vt_bits[(long) qPD[curr_pd].sbAlias]; ! rtn_dem_name = &vt_bits[(long) qPD[curr_pd].sbProc]; } else { *************** *** 563,573 **** rtn_dem_name = NULL; } ! /* Hack to get around HP C/C++ compilers' insistence on providing ! "_MAIN_" as an alternate name for "main" */ ! if ((strcmp (rtn_name, "_MAIN_") == 0) && ! (strcmp (&vt_bits[(long) qPD[curr_pd].sbProc], "main") == 0)) ! rtn_dem_name = rtn_name = main_string; #ifdef DUMPING if (dumping) --- 585,632 ---- rtn_dem_name = NULL; } ! /* Hack to get around HP compilers' insistence on providing ! * "_MAIN_" as an alternate name for "main". ! */ ! if (strcmp (rtn_name, "_MAIN_") == 0) ! { ! /* Set mangled name to "main" and demangled_name to "", ! * except for Fortran, where the mangled name is set to ! * "_MAIN_" and the demangled name is "" or the program name. ! * We do this for Fortran because "main" is not a special name ! * and there could be a user subroutine called "main". If ! * there is a program name, we want to save it as the user may ! * reference it to set breakpoints, etc. ! */ ! enum language lang = ! trans_lang ((enum hp_language) qPD[curr_pd].language); ! if (lang == language_fortran) ! { ! if (strcmp (rtn_dem_name, default_main) == 0) ! rtn_dem_name = NULL; ! default_main = rtn_name = default_fortran_main_string; ! ! } ! else ! { ! rtn_name = default_main; ! rtn_dem_name = NULL; ! } ! add_psymbol_with_dem_name_to_list ( ! rtn_name, ! strlen (rtn_name), ! rtn_dem_name, ! strlen (rtn_dem_name), ! VAR_NAMESPACE, ! LOC_BLOCK, ! &objfile->global_psymbols, ! (qPD[curr_pd].adrStart + /* Starting address of rtn */ ! ANOFFSET (objfile->section_offsets, ! SECT_OFF_TEXT)), ! 0, /* core addr?? */ ! lang, ! objfile); ! } #ifdef DUMPING if (dumping) *************** *** 579,624 **** /* Check for module-spanning routines. */ if (CURR_PROC_END > end_adr) { ! TELL_OBJFILE; ! warning ("Procedure \"%s\" [0x%x] spans file or module boundaries.", rtn_name, curr_pd); } - /* Add this routine symbol to the list in the objfile. - Unfortunately we have to go to the LNTT to determine the - correct list to put it on. An alternative (which the - code used to do) would be to not check and always throw - it on the "static" list. But if we go that route, then - symbol_lookup() needs to be tweaked a bit to account - for the fact that the function might not be found on - the correct list in the psymtab. - RT */ - dn_bufp = hpread_get_lntt (qPD[curr_pd].isym, objfile); - if (dn_bufp->dfunc.global) - add_psymbol_with_dem_name_to_list (rtn_name, - strlen (rtn_name), - rtn_dem_name, - strlen (rtn_dem_name), - VAR_NAMESPACE, - LOC_BLOCK, /* "I am a routine" */ - &objfile->global_psymbols, - (qPD[curr_pd].adrStart + /* Starting address of rtn */ - ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT)), - 0, /* core addr?? */ - trans_lang ((enum hp_language) qPD[curr_pd].language), - objfile); - else - add_psymbol_with_dem_name_to_list (rtn_name, - strlen (rtn_name), - rtn_dem_name, - strlen (rtn_dem_name), - VAR_NAMESPACE, - LOC_BLOCK, /* "I am a routine" */ - &objfile->static_psymbols, - (qPD[curr_pd].adrStart + /* Starting address of rtn */ - ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT)), - 0, /* core addr?? */ - trans_lang ((enum hp_language) qPD[curr_pd].language), - objfile); - symbol_count++; *curr_pd_p = ++curr_pd; /* bump up count & reflect in caller */ } /* loop over procedures */ --- 638,667 ---- /* Check for module-spanning routines. */ if (CURR_PROC_END > end_adr) { ! #ifdef DUMPING ! if (dumping) ! { ! printf ("Procedure \"%s\" [%d] spans file or module boundaries.", rtn_name, curr_pd); ! printf ("CURR_PROC_END = 0x%x, end_adr = 0x%x\n", CURR_PROC_END, end_adr); ! } ! #endif ! /* Search through the quick file table for multiple entries for ! * a given function and adjust the current file entry and the ! * the ending address of the function. ipd is the procedure index ! * of the current file entry in the caller. ! */ ! curr_fd = *curr_fd_p; ! while (curr_fd <= max_files ! && qFD[curr_fd].ipd == curr_pd ! && FILE_END (curr_fd) < CURR_PROC_END) ! ++curr_fd; ! if (curr_fd > *curr_fd_p) ! { ! *curr_fd_p = curr_fd; ! *end_adr_p = CURR_PROC_END; ! } } symbol_count++; *curr_pd_p = ++curr_pd; /* bump up count & reflect in caller */ } /* loop over procedures */ *************** *** 671,677 **** int curr_md; /* current module */ int start_sym; /* current psymtab's starting symbol index */ int end_sym; /* current psymtab's ending symbol index */ ! int max_LNTT_sym_index; int syms_in_pst; B_TYPE *class_entered; --- 714,722 ---- int curr_md; /* current module */ int start_sym; /* current psymtab's starting symbol index */ int end_sym; /* current psymtab's ending symbol index */ ! int max_LNTT_sym_index; /* max index of $LNTT$ subspace; ! it's the index of the combined LNTT ! and GNTT symbols after pxdb has run */ int syms_in_pst; B_TYPE *class_entered; *************** *** 715,723 **** for (i = 0; VALID_PROC (i); i++) { idx = (long) qPD[i].sbProc; ! printf ("%s %x..%x\n", &vt_bits[idx], ! (int) PROC_START (i), ! (int) PROC_END (i)); } } #endif --- 760,770 ---- for (i = 0; VALID_PROC (i); i++) { idx = (long) qPD[i].sbProc; ! printf ("%s ", &vt_bits[idx]); ! print_address_numeric (PROC_START (i), 1, gdb_stdout); ! printf (".."); ! print_address_numeric (PROC_END (i), 1, gdb_stdout); ! printf ("\n"); } } #endif *************** *** 732,740 **** for (i = 0; VALID_FILE (i); i++) { idx = (long) qFD[i].sbFile; ! printf ("%s %x..%x\n", &vt_bits[idx], ! (int) FILE_START (i), ! (int) FILE_END (i)); } } #endif --- 779,789 ---- for (i = 0; VALID_FILE (i); i++) { idx = (long) qFD[i].sbFile; ! printf ("%s ", &vt_bits[idx]); ! print_address_numeric (FILE_START (i), 1, gdb_stdout); ! printf (".."); ! print_address_numeric (FILE_END (i), 1, gdb_stdout); ! printf ("\n"); } } #endif *************** *** 837,843 **** while (VALID_CURR_FILE || VALID_CURR_MODULE) { ! char *mod_name_string; char *full_name_string; /* First check for modules like "version.c", which have no code --- 886,892 ---- while (VALID_CURR_FILE || VALID_CURR_MODULE) { ! char *mod_name_string = NULL; char *full_name_string; /* First check for modules like "version.c", which have no code *************** *** 888,895 **** (CURR_MODULE_END == 0) || (CURR_MODULE_END == -1))) { TELL_OBJFILE; ! warning ("Module \"%s\" [0x%x] has non-standard addresses. It starts at 0x%x, ends at 0x%x, and will be skipped.", ! mod_name_string, curr_md, start_adr, end_adr); /* On to next module */ curr_md++; } --- 937,949 ---- (CURR_MODULE_END == 0) || (CURR_MODULE_END == -1))) { TELL_OBJFILE; ! warning_begin (); ! fprintf_filtered ("Module \"%s\" [0x%x] has non-standard addresses. It starts at ", ! mod_name_string, curr_md); ! print_address_numeric (start_adr, 1, gdb_stderr); ! fprintf_filtered (gdb_stderr, ", ends at "); ! print_address_numeric (end_adr, 1, gdb_stderr); ! fprintf_filtered (gdb_stderr, ", and will be skipped.\n"); /* On to next module */ curr_md++; } *************** *** 914,920 **** are in between file or module ranges for some reason (probably indicates a compiler bug */ ! if (CURR_PROC_START < start_adr) { TELL_OBJFILE; warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.", --- 968,974 ---- are in between file or module ranges for some reason (probably indicates a compiler bug */ ! if (VALID_CURR_PROC && (CURR_PROC_START < start_adr)) { TELL_OBJFILE; warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.", *************** *** 931,937 **** if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr)) { TELL_OBJFILE; ! warning ("File \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.", full_name_string, curr_fd); end_adr = FILE_START (curr_fd + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */ } --- 985,991 ---- if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr)) { TELL_OBJFILE; ! warning ("File \"%s\" [%d] has ending address after starting address of next file; adjusting ending address down.", full_name_string, curr_fd); end_adr = FILE_START (curr_fd + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */ } *************** *** 947,954 **** #ifdef DUMPING if (dumping) { ! printf ("Make new psymtab for file %s (%x to %x).\n", ! full_name_string, start_adr, end_adr); } #endif /* Create the basic psymtab, connecting it in the list --- 1001,1012 ---- #ifdef DUMPING if (dumping) { ! printf ("Make new psymtab for file %s [%d] (", ! full_name_string, curr_fd); ! print_address_numeric (start_adr, 1, gdb_stdout); ! printf (" to "); ! print_address_numeric (end_adr, 1, gdb_stdout); ! printf (").\n"); } #endif /* Create the basic psymtab, connecting it in the list *************** *** 976,982 **** file, based on the starting addresses. */ syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries, ! start_adr, end_adr, pst, vt_bits, objfile); /* Get ending symbol offset */ --- 1034,1042 ---- file, based on the starting addresses. */ syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries, ! start_adr, &end_adr, pst, vt_bits, ! objfile, &curr_fd, qFD, ! pxdb_header_p->fd_entries); /* Get ending symbol offset */ *************** *** 1013,1024 **** /* Couldn't find procedure, file, or module, use globals as default */ if (!end_sym) ! end_sym = pxdb_header_p->globals; #ifdef DUMPING if (dumping) { ! printf ("File psymtab indices: %x to %x\n", start_sym, end_sym); } #endif --- 1073,1087 ---- /* Couldn't find procedure, file, or module, use globals as default */ if (!end_sym) ! /* if there are no globals, use max_LNTT_sym_index */ ! end_sym = max_LNTT_sym_index - 1 == pxdb_header_p->globals ? ! max_LNTT_sym_index : pxdb_header_p->globals; #ifdef DUMPING if (dumping) { ! printf ("File psymtab indices: 0x%x to 0x%x\n", ! start_sym, end_sym); } #endif *************** *** 1036,1048 **** record_pst_syms (start_sym, end_sym); if (NULL == pst) ! warning ("No symbols in psymtab for file \"%s\" [0x%x].", full_name_string, curr_fd); #ifdef DUMPING if (dumping) { ! printf ("Made new psymtab for file %s (%x to %x), sym %x to %x.\n", ! full_name_string, start_adr, end_adr, CURR_FILE_ISYM, end_sym); } #endif /* Prepare for the next psymtab. */ --- 1099,1114 ---- record_pst_syms (start_sym, end_sym); if (NULL == pst) ! warning ("No symbols in psymtab for file \"%s\" [%d].", full_name_string, curr_fd); #ifdef DUMPING if (dumping) { ! printf ("Made new psymtab for file %s [%d] (", full_name_string, curr_fd); ! print_address_numeric (start_adr, 1, gdb_stdout); ! printf (" to "); ! print_address_numeric (end_adr, 1, gdb_stdout); ! printf ("), sym 0x%x to 0x%x.\n", CURR_FILE_ISYM, end_sym); } #endif /* Prepare for the next psymtab. */ *************** *** 1100,1106 **** printf ("Maybe skipping file %s which overlaps with module %s\n", &vt_bits[(long) qFD[curr_fd].sbFile], mod_name_string); #endif ! if (CURR_FILE_END > end_adr) { TELL_OBJFILE; warning ("File \"%s\" [0x%x] crosses end of module \"%s\".", --- 1166,1177 ---- printf ("Maybe skipping file %s which overlaps with module %s\n", &vt_bits[(long) qFD[curr_fd].sbFile], mod_name_string); #endif ! /* The following warning is not valid for f90 programs ! where each function is enclosed in a module; ! consequently there may be several modules within ! a file */ ! if ((CURR_FILE_END > end_adr) && ! (qMD[curr_md].language != HP_LANGUAGE_FORTRAN)) { TELL_OBJFILE; warning ("File \"%s\" [0x%x] crosses end of module \"%s\".", *************** *** 1162,1171 **** are in between file or module ranges for some reason (probably indicates a compiler bug */ ! if (CURR_PROC_START < start_adr) { TELL_OBJFILE; ! warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.", &vt_bits[(long) qPD[curr_pd].sbProc], curr_pd); start_adr = CURR_PROC_START; if (CURR_PROC_ISYM < start_sym) --- 1233,1242 ---- are in between file or module ranges for some reason (probably indicates a compiler bug */ ! if (VALID_CURR_PROC && (CURR_PROC_START < start_adr)) { TELL_OBJFILE; ! warning ("Found procedure \"%s\" [%d] that is not in any file or module.", &vt_bits[(long) qPD[curr_pd].sbProc], curr_pd); start_adr = CURR_PROC_START; if (CURR_PROC_ISYM < start_sym) *************** *** 1175,1182 **** #ifdef DUMPING if (dumping) { ! printf ("Make new psymtab for module %s (%x to %x), using file %s\n", ! mod_name_string, start_adr, end_adr, full_name_string); } #endif /* Create the basic psymtab, connecting it in the list --- 1246,1256 ---- #ifdef DUMPING if (dumping) { ! printf ("Make new psymtab for module %s (", mod_name_string); ! print_address_numeric (start_adr, 1, gdb_stdout); ! printf (" to "); ! print_address_numeric (end_adr, 1, gdb_stdout); ! printf ("), using file %s\n", full_name_string); } #endif /* Create the basic psymtab, connecting it in the list *************** *** 1203,1219 **** /* Scan the procedure descriptors for procedures in the current module, based on the starting addresses. */ ! syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries, ! start_adr, end_adr, pst, vt_bits, objfile); /* Get ending symbol offset */ end_sym = 0; /* First check for starting index before previous psymtab */ if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end) { end_sym = find_next_pst_start (start_sym); } /* Look for next start index of a file or module, or procedure */ if (!end_sym) { --- 1277,1303 ---- /* Scan the procedure descriptors for procedures in the current module, based on the starting addresses. */ ! syms_in_pst = scan_procs (&curr_pd, qPD, ! pxdb_header_p->pd_entries, ! start_adr, &end_adr, pst, vt_bits, ! objfile, &curr_fd, qFD, ! pxdb_header_p->fd_entries); /* Get ending symbol offset */ end_sym = 0; /* First check for starting index before previous psymtab */ + /* RM: aCC/pxdb seems to incorrectly emit debug info that + includes LNTT entries from files outside the current modules + address ranges within the current modules LNTT entries. + Disabling the check below works around this, but causes + certain CTTI functionality to break. Take your pick. */ + #if 1 if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end) { end_sym = find_next_pst_start (start_sym); } + #endif /* Look for next start index of a file or module, or procedure */ if (!end_sym) { *************** *** 1246,1252 **** #ifdef DUMPING if (dumping) { ! printf ("Module psymtab indices: %x to %x\n", start_sym, end_sym); } #endif --- 1330,1337 ---- #ifdef DUMPING if (dumping) { ! printf ("Module psymtab indices: 0x%x to 0x%x\n", ! start_sym, end_sym); } #endif *************** *** 1264,1276 **** record_pst_syms (start_sym, end_sym); if (NULL == pst) ! warning ("No symbols in psymtab for module \"%s\" [0x%x].", mod_name_string, curr_md); #ifdef DUMPING if (dumping) { ! printf ("Made new psymtab for module %s (%x to %x), sym %x to %x.\n", ! mod_name_string, start_adr, end_adr, CURR_MODULE_ISYM, end_sym); } #endif --- 1349,1364 ---- record_pst_syms (start_sym, end_sym); if (NULL == pst) ! warning ("No symbols in psymtab for module \"%s\" [%d].", mod_name_string, curr_md); #ifdef DUMPING if (dumping) { ! printf ("Made new psymtab for module %s (", mod_name_string); ! print_address_numeric (start_adr, 1, gdb_stdout); ! printf (" to "); ! print_address_numeric (end_adr, 1, gdb_stdout); ! printf ("), sym %x to %x.\n", CURR_MODULE_ISYM, end_sym); } #endif *************** *** 1292,1303 **** start_adr = CURR_PROC_START; end_adr = qPD[pxdb_header_p->pd_entries - 1].adrEnd; TELL_OBJFILE; ! warning ("Found functions beyond end of all files and modules [0x%x].", curr_pd); #ifdef DUMPING if (dumping) { ! printf ("Orphan functions at end, PD %d and beyond (%x to %x)\n", ! curr_pd, start_adr, end_adr); } #endif pst = hpread_start_psymtab (objfile, --- 1380,1394 ---- start_adr = CURR_PROC_START; end_adr = qPD[pxdb_header_p->pd_entries - 1].adrEnd; TELL_OBJFILE; ! warning ("Found functions beyond end of all files and modules [%d].", curr_pd); #ifdef DUMPING if (dumping) { ! printf ("Orphan functions at end, PD %d and beyond (", curr_pd); ! print_address_numeric (start_adr, 1, gdb_stdout); ! printf (" to "); ! print_address_numeric (end_adr, 1, gdb_stdout); ! printf (")\n"); } #endif pst = hpread_start_psymtab (objfile, *************** *** 1309,1315 **** static_syms); scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries, ! start_adr, end_adr, pst, vt_bits, objfile); pst = hpread_end_psymtab (pst, NULL, /* psymtab_include_list */ --- 1400,1407 ---- static_syms); scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries, ! start_adr, &end_adr, pst, vt_bits, objfile, ! &curr_fd, qFD, pxdb_header_p->fd_entries); pst = hpread_end_psymtab (pst, NULL, /* psymtab_include_list */ *************** *** 1365,1371 **** static int dumping = 0; #endif ! header_section = bfd_get_section_by_name (objfile->obfd, "$HEADER$"); if (!header_section) { /* We don't have either PINFO or DEBUG sections. But --- 1457,1463 ---- static int dumping = 0; #endif ! header_section = bfd_get_section_by_name (objfile->obfd, HP_HEADER); if (!header_section) { /* We don't have either PINFO or DEBUG sections. But *************** *** 1460,1465 **** --- 1552,1574 ---- #endif /* QUICK_LOOK_UP */ + /* Given a string say whether it points to VT */ + static boolean + string_from_vt (objfile, string) + struct objfile *objfile; + char *string; + { + /* don't touch with a barge pole if it ain't kosher */ + if (!string || !objfile) + return 0; + + if ((string >= VT (objfile)) && + (string <= (VT (objfile) + VT_SIZE (objfile)))) + return 1; + + return 0; + } + /* Initialization for reading native HP C debug symbols from OBJFILE. Its only purpose in life is to set up the symbol reader's private *************** *** 1479,1484 **** --- 1588,1599 ---- { asection *vt_section, *slt_section, *lntt_section, *gntt_section; + extern boolean (*permanent_copy_exists) + PARAMS ((struct objfile * objfile, + char *string)); + + permanent_copy_exists = string_from_vt; + /* Allocate struct to keep track of the symfile */ objfile->sym_private = (PTR) xmmalloc (objfile->md, sizeof (struct hpread_symfile_info)); *************** *** 1486,1494 **** /* We haven't read in any types yet. */ TYPE_VECTOR (objfile) = 0; /* Read in data from the $GNTT$ subspace. */ ! gntt_section = bfd_get_section_by_name (objfile->obfd, "$GNTT$"); if (!gntt_section) return; --- 1601,1611 ---- /* We haven't read in any types yet. */ TYPE_VECTOR (objfile) = 0; + TYPE_VECTOR_LENGTH (objfile) = 0; + /* RM: We'll read in the DOOM specific stuff later */ /* Read in data from the $GNTT$ subspace. */ ! gntt_section = bfd_get_section_by_name (objfile->obfd, HP_GNTT); if (!gntt_section) return; *************** *** 1510,1516 **** code, and save startup time. At the moment this data is still used, though. We'd need a way to tell hp-symtab-read.c whether or not to load the LNTT. */ ! lntt_section = bfd_get_section_by_name (objfile->obfd, "$LNTT$"); if (!lntt_section) return; --- 1627,1633 ---- code, and save startup time. At the moment this data is still used, though. We'd need a way to tell hp-symtab-read.c whether or not to load the LNTT. */ ! lntt_section = bfd_get_section_by_name (objfile->obfd, HP_LNTT); if (!lntt_section) return; *************** *** 1524,1546 **** LNTT_SYMCOUNT (objfile) = bfd_section_size (objfile->obfd, lntt_section) / sizeof (struct dntt_type_block); ! /* Read in data from the $SLT$ subspace. $SLT$ contains information ! on source line numbers. */ ! slt_section = bfd_get_section_by_name (objfile->obfd, "$SLT$"); ! if (!slt_section) ! return; ! ! SLT (objfile) = ! obstack_alloc (&objfile->symbol_obstack, ! bfd_section_size (objfile->obfd, slt_section)); ! ! bfd_get_section_contents (objfile->obfd, slt_section, SLT (objfile), ! 0, bfd_section_size (objfile->obfd, slt_section)); /* Read in data from the $VT$ subspace. $VT$ contains things like names and constants. Keep track of the number of symbols in the VT. */ ! vt_section = bfd_get_section_by_name (objfile->obfd, "$VT$"); if (!vt_section) return; --- 1641,1656 ---- LNTT_SYMCOUNT (objfile) = bfd_section_size (objfile->obfd, lntt_section) / sizeof (struct dntt_type_block); + GLOBALS_START (objfile) = 0; ! /* srikanth, 990421, don't read in the slt right now. It is quite likely the ! user may never set a breakpoint in this load module. If the slt is needed ! we will page it in on demand. */ ! SLT (objfile) = 0; /* Read in data from the $VT$ subspace. $VT$ contains things like names and constants. Keep track of the number of symbols in the VT. */ ! vt_section = bfd_get_section_by_name (objfile->obfd, HP_VT); if (!vt_section) return; *************** *** 1576,1582 **** struct objfile *objfile; int mainline; { - #ifdef DUMPING /* Turn this on to get debugging output. */ static int dumping = 0; --- 1686,1691 ---- *************** *** 1590,1598 **** int scan_start = 0; union dnttentry *dn_bufp; ! unsigned long valu; char *p; ! int texthigh = 0; int have_name = 0; /* Current partial symtab */ --- 1699,1707 ---- int scan_start = 0; union dnttentry *dn_bufp; ! CORE_ADDR valu; char *p; ! CORE_ADDR texthigh = 0; int have_name = 0; /* Current partial symtab */ *************** *** 1628,1634 **** --- 1737,1747 ---- (struct partial_symtab **) alloca (dependencies_allocated * sizeof (struct partial_symtab *)); + /* RM: actually this has already been inserted into the cleanup + chain in syms_from_objfile */ + #if 0 old_chain = make_cleanup ((make_cleanup_func) free_objfile, objfile); + #endif last_source_file = 0; *************** *** 1671,1677 **** --- 1784,1792 ---- VT (objfile), &pxdb_header); + #if 0 discard_cleanups (old_chain); + #endif /* Set up to scan the global section of the LNTT. *************** *** 1685,1699 **** done below. */ if (found_modules_in_program) scan_start = pxdb_header.globals; } #ifdef DUMPING else { if (dumping) ! printf ("\nGoing on to old method for %s\n", objfile->name); } #endif ! } #endif /* QUICK_LOOK_UP */ /* Make two passes, one over the GNTT symbols, the other for the --- 1800,1817 ---- done below. */ if (found_modules_in_program) scan_start = pxdb_header.globals; + else + scan_start = 0; } #ifdef DUMPING else { if (dumping) ! printf ("\nGoing on to old method for %s\n", ! objfile->name); } #endif ! } /* End of new method code */ #endif /* QUICK_LOOK_UP */ /* Make two passes, one over the GNTT symbols, the other for the *************** *** 1868,1875 **** case DNTT_TYPE_ENTRY: /* The beginning of a function. DNTT_TYPE_ENTRY may also denote a secondary entry point. */ ! valu = dn_bufp->dfunc.hiaddr + ANOFFSET (objfile->section_offsets, ! SECT_OFF_TEXT); if (valu > texthigh) texthigh = valu; valu = dn_bufp->dfunc.lowaddr + --- 1986,1993 ---- case DNTT_TYPE_ENTRY: /* The beginning of a function. DNTT_TYPE_ENTRY may also denote a secondary entry point. */ ! valu = dn_bufp->dfunc.hiaddr + ! ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); if (valu > texthigh) texthigh = valu; valu = dn_bufp->dfunc.lowaddr + *************** *** 1889,1896 **** continue; case DNTT_TYPE_DOC_FUNCTION: ! valu = dn_bufp->ddocfunc.hiaddr + ANOFFSET (objfile->section_offsets, ! SECT_OFF_TEXT); if (valu > texthigh) texthigh = valu; valu = dn_bufp->ddocfunc.lowaddr + --- 2007,2014 ---- continue; case DNTT_TYPE_DOC_FUNCTION: ! valu = dn_bufp->ddocfunc.hiaddr + ! ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); if (valu > texthigh) texthigh = valu; valu = dn_bufp->ddocfunc.lowaddr + *************** *** 2088,2094 **** --- 2206,2214 ---- 0, dependency_list, dependencies_used); } + #if 0 discard_cleanups (old_chain); + #endif } /* Perform any local cleanups required when we are done with a particular *************** *** 2102,2107 **** --- 2222,2230 ---- { if (objfile->sym_private != NULL) { + /* srikanth, 990311, JAGaa80452, don't forget to forget ... */ + if (TYPE_VECTOR (objfile)) + mfree (objfile->md, TYPE_VECTOR (objfile)); mfree (objfile->md, objfile->sym_private); } } *************** *** 2129,2140 **** &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]); } union sltentry * hpread_get_slt (index, objfile) int index; struct objfile *objfile; { ! return (union sltentry *) &(SLT (objfile)[index * sizeof (union sltentry)]); } /* Get the low address associated with some symbol (typically the start --- 2252,2381 ---- &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]); } + static void + initialize_slt_page_table (objfile) + struct objfile *objfile; + { + + int i; + slt_page_frame *page_table; + asection *slt_section; + + SLT_PAGE_TABLE (objfile) = + page_table = (slt_page_frame *) + obstack_alloc (&objfile->symbol_obstack, + SLT_PAGE_COUNT * sizeof (slt_page_frame)); + + /* allocate the pages upfront, it is no biggie */ + + for (i = 0; i < SLT_PAGE_COUNT; i++) + { + page_table[i].page = (union sltentry *) + obstack_alloc (&objfile->symbol_obstack, + SLT_ENTRIES_PER_PAGE * sizeof (union sltentry)); + page_table[i].page_number = -1; + } + + SLT_SECTION (objfile) = slt_section = + bfd_get_section_by_name (objfile->obfd, HP_SLT); + + SLT_SIZE (objfile) = bfd_section_size (objfile->obfd, slt_section); + + } + + static union sltentry * + slt_entry_from_page_table (index, objfile) + int index; + struct objfile *objfile; + { + int i, j; + + slt_page_frame *page_table; + slt_page_frame this_page_frame, last_page_frame; + asection *slt_section; + int bytes_to_skip, bytes_to_read; + + int page_number; + int line_number; + + /* do we have the page table set up ? */ + + if (SLT_PAGE_TABLE (objfile) == 0) + initialize_slt_page_table (objfile); + + page_table = SLT_PAGE_TABLE (objfile); + + page_number = SLT_PAGE_NUMBER (index); + line_number = SLT_LINE_NUMBER (index); + + if (page_table[0].page_number == page_number) /* common case */ + return &page_table[0].page[line_number]; + + /* Do we have the desired page in memory ? As we scan the list of pages + left to right, looking for the page of interest, we will bubble the page + frames away from the beginning i.e., the "most recently used" slot. This + would create a vacuum in the very first slot. When we find the page we + are looking for, we will move that page to this slot. Alternately, if the + page is not in memory and we have to page it in from disk, we will use + this slot as the destination. This guarentees that the list is sorted on + a MRU basis at all times. + */ + + last_page_frame = page_table[0]; + + for (i = 1; i < SLT_PAGE_COUNT; i++) + { + this_page_frame = page_table[i]; + page_table[i] = last_page_frame; + + if (page_number == this_page_frame.page_number) + { + page_table[0] = this_page_frame; /* Make this MRU */ + return &this_page_frame.page[line_number]; + } + + last_page_frame = this_page_frame; + } + + /* Page fault. At this point, `last_page_frame' points to the least recently + used page. Discard its contents by paging in the new data on top of it. + Make the new page the most recently used one ... + */ + + page_table[0] = last_page_frame; + + bytes_to_skip = page_number * + SLT_ENTRIES_PER_PAGE * sizeof (union sltentry); + + bytes_to_read = SLT_ENTRIES_PER_PAGE * sizeof (union sltentry); + + slt_section = SLT_SECTION (objfile); + + /* last page needs special handling */ + + if (bytes_to_skip + bytes_to_read > SLT_SIZE (objfile)) + bytes_to_read = SLT_SIZE (objfile) - bytes_to_skip; + + bfd_get_section_contents (objfile->obfd, + slt_section, + page_table[0].page, + bytes_to_skip, + bytes_to_read); + + page_table[0].page_number = page_number; + + return &page_table[0].page[line_number]; /* unwrap the toffee */ + } + union sltentry * hpread_get_slt (index, objfile) int index; struct objfile *objfile; { ! if (SLT (objfile)) /* doom mode */ ! return (union sltentry *) &(SLT (objfile)[index * sizeof (union sltentry)]); ! ! return slt_entry_from_page_table (index, objfile); } /* Get the low address associated with some symbol (typically the start *************** *** 2142,2155 **** stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we must infer it from the existance of DNTT_TYPE_FUNCTION symbols. */ ! static unsigned long hpread_get_textlow (global, index, objfile, symcount) int global; int index; struct objfile *objfile; int symcount; { ! union dnttentry *dn_bufp; struct minimal_symbol *msymbol; /* Look for a DNTT_TYPE_FUNCTION symbol. */ --- 2383,2396 ---- stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we must infer it from the existance of DNTT_TYPE_FUNCTION symbols. */ ! static CORE_ADDR hpread_get_textlow (global, index, objfile, symcount) int global; int index; struct objfile *objfile; int symcount; { ! union dnttentry *dn_bufp = NULL; struct minimal_symbol *msymbol; /* Look for a DNTT_TYPE_FUNCTION symbol. */ *************** *** 2215,2220 **** --- 2456,2462 ---- filename, textlow, global_syms, static_syms); result->textlow += offset; + result->texthigh += offset; result->read_symtab_private = (char *) obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc)); LDSYMOFF (result) = ldsymoff; *************** *** 2328,2355 **** This happens in VxWorks. */ free_named_symtabs (pst->filename); ! if (num_includes == 0 ! && number_dependencies == 0 ! && pst->n_global_syms == 0 ! && pst->n_static_syms == 0) ! { ! /* Throw away this psymtab, it's empty. We can't deallocate it, since ! it is on the obstack, but we can forget to chain it on the list. ! Empty psymtabs happen as a result of header files which don't have ! any symbols in them. There can be a lot of them. But this check ! is wrong, in that a psymtab with N_SLINE entries but nothing else ! is not empty, but we don't realize that. Fixing that without slowing ! things down might be tricky. ! It's also wrong if we're using the quick look-up tables, as ! we can get empty psymtabs from modules with no routines in ! them. */ ! ! discard_psymtab (pst); ! ! /* Indicate that psymtab was thrown away. */ ! pst = (struct partial_symtab *) NULL; ! ! } return pst; } --- 2570,2581 ---- This happens in VxWorks. */ free_named_symtabs (pst->filename); ! /* srikanth, 990609, we used to check for and discard empty psymtabs here. ! We can't do this anymore, as currently all psymtabs (except for "globals") ! are empty. The lookup scheme has been changed to search the minimal symbol ! table instead and if a linker symbol is found, use its address to decide ! which psymtab to expand. The textlow and texthigh addresses of a psymtab ! envelop the functions contained ... */ return pst; } Index: gdb/hpread.h /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/hpread.h gdb/hpread.h *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/hpread.h Wed Nov 3 13:17:36 1999 --- gdb/hpread.h Wed Nov 3 17:55:20 1999 *************** *** 40,45 **** --- 40,83 ---- #include "gdbtypes.h" #include "demangle.h" + /* srikanth, 990422, demand paging of SLT... + + A paging scheme to load on demand selected parts of SLT and cache the + contents for future references. Under this scheme, there could be upto + SLT_PAGE_COUNT number of pages per load module and each could hold upto + SLT_ENTRIES_PER_PAGE number of entries. + + When we have allocated SLT_PAGE_COUNT number of pages, we reclaim a page + frame by discarding its cached contents. Eviction is on a "least recently + used" basis. + + Parameters for this paging scheme were chosen such that each page would be + 8 kilo bytes in size (1024 entries * 8 bytes per entry) and there would be + an upper bound of ~50 kilo bytes (6 pages) of SLT space per load module. + + While this may look small, see that more pages is not necessarily better + since the SLT is consulted only during the expansion of a function. By its + very nature, accesses to SLT are highly serialized, localized and in bursts. + Further more, once gdb metabolizes the contents of an SLT page, all further + lookups are to the internalized form. Thus having served its life's mission + a page begins languishing in memory and hence is a good candidate for + replacement. + + All allocation is from the symbol_obstack. + */ + + #define SLT_PAGE_COUNT 6 + #define SLT_ENTRIES_PER_PAGE 1024 /* this must be a power of two */ + #define SLT_PAGE_NUMBER(index) ((index) >> 10) + #define SLT_LINE_NUMBER(index) ((index) & 0x000003ff) + + typedef struct slt_page_frame + { + int page_number; + union sltentry *page; /* actual goodies */ + } + slt_page_frame; + /* Private information attached to an objfile which we use to find and internalize the HP C debug symbols within that objfile. */ *************** *** 50,55 **** --- 88,98 ---- char *lntt; char *slt; char *vt; + unsigned int globals_start; + + slt_page_frame *slt_page_table; + asection *slt_section; + int slt_size; /* We keep the size of the $VT$ section for range checking. */ unsigned int vt_size; *************** *** 71,79 **** /* Keep track of the current function's address. We may need to look up something based on this address. */ ! unsigned int current_function_value; }; /* Accessor macros to get at the fields. */ #define HPUX_SYMFILE_INFO(o) \ ((struct hpread_symfile_info *)((o)->sym_private)) --- 114,128 ---- /* Keep track of the current function's address. We may need to look up something based on this address. */ ! CORE_ADDR current_function_value; }; + #define HP_HEADER "$HEADER$" + #define HP_GNTT "$GNTT$" + #define HP_LNTT "$LNTT$" + #define HP_SLT "$SLT$" + #define HP_VT "$VT$" + /* Accessor macros to get at the fields. */ #define HPUX_SYMFILE_INFO(o) \ ((struct hpread_symfile_info *)((o)->sym_private)) *************** *** 84,94 **** --- 133,155 ---- #define VT_SIZE(o) (HPUX_SYMFILE_INFO(o)->vt_size) #define LNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->lntt_symcount) #define GNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->gntt_symcount) + #define GLOBALS_START(o) (HPUX_SYMFILE_INFO(o)->globals_start) #define TYPE_VECTOR(o) (HPUX_SYMFILE_INFO(o)->type_vector) #define TYPE_VECTOR_LENGTH(o) (HPUX_SYMFILE_INFO(o)->type_vector_length) #define SL_INDEX(o) (HPUX_SYMFILE_INFO(o)->sl_index) #define WITHIN_FUNCTION(o) (HPUX_SYMFILE_INFO(o)->within_function) #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value) + #define SLT_PAGE_TABLE(o) (HPUX_SYMFILE_INFO(o)->slt_page_table) + #define SLT_SECTION(o) (HPUX_SYMFILE_INFO(o)->slt_section) + #define SLT_SIZE(o) (HPUX_SYMFILE_INFO(o)->slt_size) + + /* For DOOM, we combine the GNTT and LNTT into one large table. But we + * need to fixup GNTT indices before using them + */ + + #define INDEX(o, dp) (dp.global ? \ + GLOBALS_START(o) + dp.index : \ + dp.index) /* Given the native debug symbol SYM, set NAMEP to the name associated with the debug symbol. Note we may be called with a debug symbol which *************** *** 138,143 **** --- 199,212 ---- extern struct complaint string_table_offset_complaint; extern struct complaint lbrac_unmatched_complaint; extern struct complaint lbrac_mismatch_complaint; + + /* The SLT is demand paged. This means that + + (a) you cannot do arithmetic on the return value of hpread_get_slt() + (b) you cannot store it for future use. It might evaporate. + (c) you cannot write onto SLT. Currently only doom mode needs to do this. + But demand paging is not applicable for SLT's from doomed .o files. + */ extern union sltentry *hpread_get_slt PARAMS ((int, struct objfile *)); Index: gdb/defs.h /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/defs.h gdb/defs.h *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/defs.h Wed Nov 3 13:23:31 1999 --- gdb/defs.h Wed Nov 3 13:24:23 1999 *************** *** 1252,1255 **** --- 1252,1258 ---- #define ISATTY(FP) (isatty (fileno (FP))) #endif + /* Default string for "main" to allow other possible defaults */ + extern char * default_main; + #endif /* #ifndef DEFS_H */ Index: gdb/symtab.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/symtab.c gdb/symtab.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/symtab.c Wed Nov 3 13:36:34 1999 --- gdb/symtab.c Wed Nov 3 17:55:21 1999 *************** *** 127,132 **** --- 127,134 ---- char no_symtab_msg[] = "No symbol table is loaded. Use the \"file\" command."; + char *default_main = "main"; + /* While the C++ support is still in flux, issue a possibly helpful hint on using the new command completion feature on single quoted demangled C++ symbols. Remove when loose ends are cleaned up. FIXME -fnf */ *************** *** 1172,1178 **** ALL_PSYMTABS (objfile, pst) { ! if (lookup_partial_symbol (pst, "main", 1, VAR_NAMESPACE)) { return (pst); } --- 1174,1180 ---- ALL_PSYMTABS (objfile, pst) { ! if (lookup_partial_symbol (pst, default_main, 1, VAR_NAMESPACE)) { return (pst); } *************** *** 1312,1329 **** ?!? Is checking the current pc correct? Is this routine ever called to look up a symbol from another context? ! FIXME: No, it's not correct. If someone sets a ! conditional breakpoint at an address, then the ! breakpoint's `struct expression' should refer to the ! `struct symbol' appropriate for the breakpoint's ! address, which may not be the PC. ! ! Even if it were never called from another context, ! it's totally bizarre for lookup_symbol's behavior to ! depend on the value of the inferior's current PC. We ! should pass in the appropriate PC as well as the ! block. The interface to lookup_symbol should change ! to require the caller to provide a PC. */ if (SYMBOL_ALIASES (sym)) sym = find_active_alias (sym, read_pc ()); --- 1314,1331 ---- ?!? Is checking the current pc correct? Is this routine ever called to look up a symbol from another context? ! FIXME: No, it's not correct. If someone sets a ! conditional breakpoint at an address, then the ! breakpoint's `struct expression' should refer to the ! `struct symbol' appropriate for the breakpoint's ! address, which may not be the PC. ! ! Even if it were never called from another context, ! it's totally bizarre for lookup_symbol's behavior to ! depend on the value of the inferior's current PC. We ! should pass in the appropriate PC as well as the ! block. The interface to lookup_symbol should change ! to require the caller to provide a PC. */ if (SYMBOL_ALIASES (sym)) sym = find_active_alias (sym, read_pc ()); *************** *** 4497,4504 **** { /* If interrupted, then quit. */ QUIT; ! /* This will cause the symbol table to be read if it has not yet been */ ! s = PSYMTAB_TO_SYMTAB (ps); } for (psym = objfile->static_psymbols.list + ps->statics_offset; --- 4499,4506 ---- { /* If interrupted, then quit. */ QUIT; ! /* This will cause the symbol table to be read if it has not yet been */ ! s = PSYMTAB_TO_SYMTAB (ps); } for (psym = objfile->static_psymbols.list + ps->statics_offset; *************** *** 4507,4514 **** psym++) { QUIT; ! /* This will cause the symbol table to be read if it has not yet been */ ! s = PSYMTAB_TO_SYMTAB (ps); } } --- 4509,4516 ---- psym++) { QUIT; ! /* This will cause the symbol table to be read if it has not yet been */ ! s = PSYMTAB_TO_SYMTAB (ps); } } Index: gdb/blockframe.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/blockframe.c gdb/blockframe.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/blockframe.c Wed Nov 3 13:36:11 1999 --- gdb/blockframe.c Wed Nov 3 13:38:32 1999 *************** *** 127,133 **** { struct symbol *mainsym; ! mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL); if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK) { symfile_objfile->ei.main_func_lowpc = --- 127,133 ---- { struct symbol *mainsym; ! mainsym = lookup_symbol (default_main, NULL, VAR_NAMESPACE, NULL, NULL); if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK) { symfile_objfile->ei.main_func_lowpc = Index: gdb/source.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/source.c gdb/source.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/source.c Wed Nov 3 13:36:13 1999 --- gdb/source.c Wed Nov 3 17:55:21 1999 *************** *** 148,156 **** /* Make the default place to list be the function `main' if one exists. */ ! if (lookup_symbol ("main", 0, VAR_NAMESPACE, 0, NULL)) { ! sals = decode_line_spec ("main", 1); sal = sals.sals[0]; free (sals.sals); current_source_symtab = sal.symtab; --- 148,156 ---- /* Make the default place to list be the function `main' if one exists. */ ! if (lookup_symbol (default_main, 0, VAR_NAMESPACE, 0, NULL)) { ! sals = decode_line_spec (default_main, 1); sal = sals.sals[0]; free (sals.sals); current_source_symtab = sal.symtab; *************** *** 1011,1027 **** current_source_line = line; first_line_listed = line; ! /* Only prints "No such file or directory" once */ ! if ((s != last_source_visited) || (!last_source_error)) ! { ! last_source_visited = s; ! desc = open_source_file (s); ! } ! else ! { ! desc = last_source_error; ! noerror = 1; ! } if (desc < 0) { --- 1011,1027 ---- current_source_line = line; first_line_listed = line; ! /* Only prints "No such file or directory" once */ ! if ((s != last_source_visited) || (!last_source_error)) ! { ! last_source_visited = s; ! desc = open_source_file (s); ! } ! else ! { ! desc = last_source_error; ! noerror = 1; ! } if (desc < 0) { *************** *** 1308,1314 **** { int first_line = sal.line - lines_to_list / 2; ! if (first_line < 1) first_line = 1; print_source_lines (sal.symtab, first_line, first_line + lines_to_list, 0); --- 1308,1315 ---- { int first_line = sal.line - lines_to_list / 2; ! if (first_line < 1) ! first_line = 1; print_source_lines (sal.symtab, first_line, first_line + lines_to_list, 0);