|
From: <sv...@va...> - 2008-05-18 07:18:22
|
Author: bart
Date: 2008-05-18 08:18:29 +0100 (Sun, 18 May 2008)
New Revision: 8102
Log:
Reworked according to a proposal by Paul Mackerras.
Modified:
branches/CROSS_COMPILATION/vex-cross-compilation.patch
Modified: branches/CROSS_COMPILATION/vex-cross-compilation.patch
===================================================================
--- branches/CROSS_COMPILATION/vex-cross-compilation.patch 2008-05-18 06:43:09 UTC (rev 8101)
+++ branches/CROSS_COMPILATION/vex-cross-compilation.patch 2008-05-18 07:18:29 UTC (rev 8102)
@@ -1,330 +1,277 @@
-Index: VEX/pub/libvex_guest_offsets_in.h
+Index: VEX/auxprogs/genoffsets.c
===================================================================
---- VEX/pub/libvex_guest_offsets_in.h (revision 0)
-+++ VEX/pub/libvex_guest_offsets_in.h (revision 0)
-@@ -0,0 +1,60 @@
-+#define OFFSET_x86_EAX 0
-+#define OFFSET_x86_EBX 12
-+#define OFFSET_x86_ECX 4
-+#define OFFSET_x86_EDX 8
-+#define OFFSET_x86_ESI 24
-+#define OFFSET_x86_EDI 28
-+#define OFFSET_x86_EBP 20
-+#define OFFSET_x86_ESP 16
-+#define OFFSET_x86_EIP 60
-+#define OFFSET_x86_CS 280
-+#define OFFSET_x86_DS 282
-+#define OFFSET_x86_ES 284
-+#define OFFSET_x86_FS 286
-+#define OFFSET_x86_GS 288
-+#define OFFSET_x86_SS 290
+--- VEX/auxprogs/genoffsets.c (revision 1849)
++++ VEX/auxprogs/genoffsets.c (working copy)
+@@ -46,7 +46,9 @@
+
+ #include <stdio.h>
+
+-/* A program which generates various guest state offsets. */
++/* A program that allows to compute guest state offsets by compiling it to */
++/* assembler code and by filtering the #define statements from the assembly */
++/* output. */
+
+ #include "../pub/libvex_basictypes.h"
+ #include "../pub/libvex_guest_x86.h"
+@@ -54,184 +56,187 @@
+ #include "../pub/libvex_guest_ppc32.h"
+ #include "../pub/libvex_guest_ppc64.h"
+
++#define DEFINE(sym, val) \
++ asm volatile("\n#define " #sym " %0\n" #val : : "i" (val))
+
-+#define OFFSET_amd64_RAX 0
-+#define OFFSET_amd64_RBX 24
-+#define OFFSET_amd64_RCX 8
-+#define OFFSET_amd64_RDX 16
-+#define OFFSET_amd64_RSI 48
-+#define OFFSET_amd64_RDI 56
-+#define OFFSET_amd64_RSP 32
-+#define OFFSET_amd64_RBP 40
-+#define OFFSET_amd64_R8 64
-+#define OFFSET_amd64_R9 72
-+#define OFFSET_amd64_R10 80
-+#define OFFSET_amd64_R11 88
-+#define OFFSET_amd64_R12 96
-+#define OFFSET_amd64_R13 104
-+#define OFFSET_amd64_R14 112
-+#define OFFSET_amd64_R15 120
-+#define OFFSET_amd64_RIP 168
-+
-+#define OFFSET_ppc32_GPR0 0
-+#define OFFSET_ppc32_GPR2 8
-+#define OFFSET_ppc32_GPR3 12
-+#define OFFSET_ppc32_GPR4 16
-+#define OFFSET_ppc32_GPR5 20
-+#define OFFSET_ppc32_GPR6 24
-+#define OFFSET_ppc32_GPR7 28
-+#define OFFSET_ppc32_GPR8 32
-+#define OFFSET_ppc32_GPR9 36
-+#define OFFSET_ppc32_GPR10 40
-+#define OFFSET_ppc32_CIA 896
-+#define OFFSET_ppc32_CR0_0 913
-+
-+#define OFFSET_ppc64_GPR0 0
-+#define OFFSET_ppc64_GPR2 16
-+#define OFFSET_ppc64_GPR3 24
-+#define OFFSET_ppc64_GPR4 32
-+#define OFFSET_ppc64_GPR5 40
-+#define OFFSET_ppc64_GPR6 48
-+#define OFFSET_ppc64_GPR7 56
-+#define OFFSET_ppc64_GPR8 64
-+#define OFFSET_ppc64_GPR9 72
-+#define OFFSET_ppc64_GPR10 80
-+#define OFFSET_ppc64_CIA 1024
-+#define OFFSET_ppc64_CR0_0 1053
-+
-Index: VEX/auxprogs/verifyoffsets.c
-===================================================================
---- VEX/auxprogs/verifyoffsets.c (revision 0)
-+++ VEX/auxprogs/verifyoffsets.c (revision 0)
-@@ -0,0 +1,245 @@
-+
-+/*--------------------------------------------------------------------*/
-+/*--- ---*/
-+/*--- This file (auxprogs/genoffsets.c) is ---*/
-+/*--- Copyright (C) OpenWorks LLP. All rights reserved. ---*/
-+/*--- Copyright (C) 2008 Bart Van Assche <bar...@gm...>---*/
-+/*--- ---*/
-+/*--------------------------------------------------------------------*/
-+
-+/*
-+ This file is part of LibVEX, a library for dynamic binary
-+ instrumentation and translation.
-+
-+ Copyright (C) 2004-2008 OpenWorks LLP. All rights reserved.
-+
-+ This library is made available under a dual licensing scheme.
-+
-+ If you link LibVEX against other code all of which is itself
-+ licensed under the GNU General Public License, version 2 dated June
-+ 1991 ("GPL v2"), then you may use LibVEX under the terms of the GPL
-+ v2, as appearing in the file LICENSE.GPL. If the file LICENSE.GPL
-+ is missing, you can obtain a copy of the GPL v2 from the Free
-+ Software Foundation Inc., 51 Franklin St, Fifth Floor, Boston, MA
-+ 02110-1301, USA.
-+
-+ For any other uses of LibVEX, you must first obtain a commercial
-+ license from OpenWorks LLP. Please contact in...@op...
-+ for information about commercial licensing.
-+
-+ This software is provided by OpenWorks LLP "as is" and any express
-+ or implied warranties, including, but not limited to, the implied
-+ warranties of merchantability and fitness for a particular purpose
-+ are disclaimed. In no event shall OpenWorks LLP be liable for any
-+ direct, indirect, incidental, special, exemplary, or consequential
-+ damages (including, but not limited to, procurement of substitute
-+ goods or services; loss of use, data, or profits; or business
-+ interruption) however caused and on any theory of liability,
-+ whether in contract, strict liability, or tort (including
-+ negligence or otherwise) arising in any way out of the use of this
-+ software, even if advised of the possibility of such damage.
-+
-+ Neither the names of the U.S. Department of Energy nor the
-+ University of California nor the names of its contributors may be
-+ used to endorse or promote products derived from this software
-+ without prior written permission.
-+*/
-+
-+
-+/* A program which verifies various guest state offsets. */
-+
-+#include <stdio.h>
-+#include "../pub/libvex_basictypes.h"
-+#include "../pub/libvex_guest_x86.h"
-+#include "../pub/libvex_guest_amd64.h"
-+#include "../pub/libvex_guest_ppc32.h"
-+#include "../pub/libvex_guest_ppc64.h"
-+#include "../pub/libvex_guest_offsets_in.h"
-+
-+
-+/* Compile-time assertion. */
-+#if ! defined(static_assert)
-+#define static_assert(a) { switch (a) { case 0: { } case (a): { } } }
-+#endif
-+
-+
-+Int main ( void )
-+{
-+ // x86
-+ static_assert(OFFSET_x86_EAX ==
-+ offsetof(VexGuestX86State,guest_EAX));
-+
-+ static_assert(OFFSET_x86_EBX ==
-+ offsetof(VexGuestX86State,guest_EBX));
-+
-+ static_assert(OFFSET_x86_ECX ==
-+ offsetof(VexGuestX86State,guest_ECX));
-+
-+ static_assert(OFFSET_x86_EDX ==
-+ offsetof(VexGuestX86State,guest_EDX));
-+
-+ static_assert(OFFSET_x86_ESI ==
-+ offsetof(VexGuestX86State,guest_ESI));
-+
-+ static_assert(OFFSET_x86_EDI ==
-+ offsetof(VexGuestX86State,guest_EDI));
-+
-+ static_assert(OFFSET_x86_EBP ==
-+ offsetof(VexGuestX86State,guest_EBP));
-+
-+ static_assert(OFFSET_x86_ESP ==
-+ offsetof(VexGuestX86State,guest_ESP));
-+
-+ static_assert(OFFSET_x86_EIP ==
-+ offsetof(VexGuestX86State,guest_EIP));
-+
-+ static_assert(OFFSET_x86_CS ==
-+ offsetof(VexGuestX86State,guest_CS));
-+
-+ static_assert(OFFSET_x86_DS ==
-+ offsetof(VexGuestX86State,guest_DS));
-+
-+ static_assert(OFFSET_x86_ES ==
-+ offsetof(VexGuestX86State,guest_ES));
-+
-+ static_assert(OFFSET_x86_FS ==
-+ offsetof(VexGuestX86State,guest_FS));
-+
-+ static_assert(OFFSET_x86_GS ==
-+ offsetof(VexGuestX86State,guest_GS));
-+
-+ static_assert(OFFSET_x86_SS ==
-+ offsetof(VexGuestX86State,guest_SS));
-+
-+
-+ // amd64
-+ static_assert(OFFSET_amd64_RAX ==
-+ offsetof(VexGuestAMD64State,guest_RAX));
-+
-+ static_assert(OFFSET_amd64_RBX ==
-+ offsetof(VexGuestAMD64State,guest_RBX));
-+
-+ static_assert(OFFSET_amd64_RCX ==
-+ offsetof(VexGuestAMD64State,guest_RCX));
-+
-+ static_assert(OFFSET_amd64_RDX ==
-+ offsetof(VexGuestAMD64State,guest_RDX));
-+
-+ static_assert(OFFSET_amd64_RSI ==
-+ offsetof(VexGuestAMD64State,guest_RSI));
-+
-+ static_assert(OFFSET_amd64_RDI ==
-+ offsetof(VexGuestAMD64State,guest_RDI));
-+
-+ static_assert(OFFSET_amd64_RSP ==
-+ offsetof(VexGuestAMD64State,guest_RSP));
-+
-+ static_assert(OFFSET_amd64_RBP ==
-+ offsetof(VexGuestAMD64State,guest_RBP));
-+
-+ static_assert(OFFSET_amd64_R8 ==
-+ offsetof(VexGuestAMD64State,guest_R8));
-+
-+ static_assert(OFFSET_amd64_R9 ==
-+ offsetof(VexGuestAMD64State,guest_R9));
-+
-+ static_assert(OFFSET_amd64_R10 ==
-+ offsetof(VexGuestAMD64State,guest_R10));
-+
-+ static_assert(OFFSET_amd64_R11 ==
-+ offsetof(VexGuestAMD64State,guest_R11));
-+
-+ static_assert(OFFSET_amd64_R12 ==
-+ offsetof(VexGuestAMD64State,guest_R12));
-+
-+ static_assert(OFFSET_amd64_R13 ==
-+ offsetof(VexGuestAMD64State,guest_R13));
-+
-+ static_assert(OFFSET_amd64_R14 ==
-+ offsetof(VexGuestAMD64State,guest_R14));
-+
-+ static_assert(OFFSET_amd64_R15 ==
-+ offsetof(VexGuestAMD64State,guest_R15));
-+
-+ static_assert(OFFSET_amd64_RIP ==
-+ offsetof(VexGuestAMD64State,guest_RIP));
-+
-+
-+ // ppc32
-+ static_assert(OFFSET_ppc32_GPR0 ==
-+ offsetof(VexGuestPPC32State,guest_GPR0));
-+
-+ static_assert(OFFSET_ppc32_GPR2 ==
-+ offsetof(VexGuestPPC32State,guest_GPR2));
-+
-+ static_assert(OFFSET_ppc32_GPR3 ==
-+ offsetof(VexGuestPPC32State,guest_GPR3));
-+
-+ static_assert(OFFSET_ppc32_GPR4 ==
-+ offsetof(VexGuestPPC32State,guest_GPR4));
-+
-+ static_assert(OFFSET_ppc32_GPR5 ==
-+ offsetof(VexGuestPPC32State,guest_GPR5));
-+
-+ static_assert(OFFSET_ppc32_GPR6 ==
-+ offsetof(VexGuestPPC32State,guest_GPR6));
-+
-+ static_assert(OFFSET_ppc32_GPR7 ==
-+ offsetof(VexGuestPPC32State,guest_GPR7));
-+
-+ static_assert(OFFSET_ppc32_GPR8 ==
-+ offsetof(VexGuestPPC32State,guest_GPR8));
-+
-+ static_assert(OFFSET_ppc32_GPR9 ==
-+ offsetof(VexGuestPPC32State,guest_GPR9));
-+
-+ static_assert(OFFSET_ppc32_GPR10 ==
-+ offsetof(VexGuestPPC32State,guest_GPR10));
-+
-+ static_assert(OFFSET_ppc32_CIA ==
-+ offsetof(VexGuestPPC32State,guest_CIA));
-+
-+ static_assert(OFFSET_ppc32_CR0_0 ==
-+ offsetof(VexGuestPPC32State,guest_CR0_0));
-+
-+
-+ // ppc64
-+ static_assert(OFFSET_ppc64_GPR0 ==
-+ offsetof(VexGuestPPC64State,guest_GPR0));
-+
-+ static_assert(OFFSET_ppc64_GPR2 ==
-+ offsetof(VexGuestPPC64State,guest_GPR2));
-+
-+ static_assert(OFFSET_ppc64_GPR3 ==
-+ offsetof(VexGuestPPC64State,guest_GPR3));
-+
-+ static_assert(OFFSET_ppc64_GPR4 ==
-+ offsetof(VexGuestPPC64State,guest_GPR4));
-+
-+ static_assert(OFFSET_ppc64_GPR5 ==
-+ offsetof(VexGuestPPC64State,guest_GPR5));
-+
-+ static_assert(OFFSET_ppc64_GPR6 ==
-+ offsetof(VexGuestPPC64State,guest_GPR6));
-+
-+ static_assert(OFFSET_ppc64_GPR7 ==
-+ offsetof(VexGuestPPC64State,guest_GPR7));
-+
-+ static_assert(OFFSET_ppc64_GPR8 ==
-+ offsetof(VexGuestPPC64State,guest_GPR8));
-+
-+ static_assert(OFFSET_ppc64_GPR9 ==
-+ offsetof(VexGuestPPC64State,guest_GPR9));
-+
-+ static_assert(OFFSET_ppc64_GPR10 ==
-+ offsetof(VexGuestPPC64State,guest_GPR10));
-+
-+ static_assert(OFFSET_ppc64_CIA ==
-+ offsetof(VexGuestPPC64State,guest_CIA));
-+
-+ static_assert(OFFSET_ppc64_CR0_0 ==
-+ offsetof(VexGuestPPC64State,guest_CR0_0));
-+
-+
-+ return 0;
-+}
+ Int main ( void )
+ {
+ // x86
+- printf("#define OFFSET_x86_EAX %3d\n",
++ DEFINE(OFFSET_x86_EAX,
+ offsetof(VexGuestX86State,guest_EAX));
+
+- printf("#define OFFSET_x86_EBX %3d\n",
++ DEFINE(OFFSET_x86_EBX,
+ offsetof(VexGuestX86State,guest_EBX));
+
+- printf("#define OFFSET_x86_ECX %3d\n",
++ DEFINE(OFFSET_x86_ECX,
+ offsetof(VexGuestX86State,guest_ECX));
+
+- printf("#define OFFSET_x86_EDX %3d\n",
++ DEFINE(OFFSET_x86_EDX,
+ offsetof(VexGuestX86State,guest_EDX));
+
+- printf("#define OFFSET_x86_ESI %3d\n",
++ DEFINE(OFFSET_x86_ESI,
+ offsetof(VexGuestX86State,guest_ESI));
+
+- printf("#define OFFSET_x86_EDI %3d\n",
++ DEFINE(OFFSET_x86_EDI,
+ offsetof(VexGuestX86State,guest_EDI));
+
+- printf("#define OFFSET_x86_EBP %3d\n",
++ DEFINE(OFFSET_x86_EBP,
+ offsetof(VexGuestX86State,guest_EBP));
+
+- printf("#define OFFSET_x86_ESP %3d\n",
++ DEFINE(OFFSET_x86_ESP,
+ offsetof(VexGuestX86State,guest_ESP));
+
+- printf("#define OFFSET_x86_EIP %3d\n",
++ DEFINE(OFFSET_x86_EIP,
+ offsetof(VexGuestX86State,guest_EIP));
+
+- printf("#define OFFSET_x86_CS %3d\n",
++ DEFINE(OFFSET_x86_CS,
+ offsetof(VexGuestX86State,guest_CS));
+
+- printf("#define OFFSET_x86_DS %3d\n",
++ DEFINE(OFFSET_x86_DS,
+ offsetof(VexGuestX86State,guest_DS));
+
+- printf("#define OFFSET_x86_ES %3d\n",
++ DEFINE(OFFSET_x86_ES,
+ offsetof(VexGuestX86State,guest_ES));
+
+- printf("#define OFFSET_x86_FS %3d\n",
++ DEFINE(OFFSET_x86_FS,
+ offsetof(VexGuestX86State,guest_FS));
+
+- printf("#define OFFSET_x86_GS %3d\n",
++ DEFINE(OFFSET_x86_GS,
+ offsetof(VexGuestX86State,guest_GS));
+
+- printf("#define OFFSET_x86_SS %3d\n",
++ DEFINE(OFFSET_x86_SS,
+ offsetof(VexGuestX86State,guest_SS));
+
+ printf("\n");
+
+ // amd64
+- printf("#define OFFSET_amd64_RAX %3d\n",
++ DEFINE(OFFSET_amd64_RAX,
+ offsetof(VexGuestAMD64State,guest_RAX));
+
+- printf("#define OFFSET_amd64_RBX %3d\n",
++ DEFINE(OFFSET_amd64_RBX,
+ offsetof(VexGuestAMD64State,guest_RBX));
+
+- printf("#define OFFSET_amd64_RCX %3d\n",
++ DEFINE(OFFSET_amd64_RCX,
+ offsetof(VexGuestAMD64State,guest_RCX));
+
+- printf("#define OFFSET_amd64_RDX %3d\n",
++ DEFINE(OFFSET_amd64_RDX,
+ offsetof(VexGuestAMD64State,guest_RDX));
+
+- printf("#define OFFSET_amd64_RSI %3d\n",
++ DEFINE(OFFSET_amd64_RSI,
+ offsetof(VexGuestAMD64State,guest_RSI));
+
+- printf("#define OFFSET_amd64_RDI %3d\n",
++ DEFINE(OFFSET_amd64_RDI,
+ offsetof(VexGuestAMD64State,guest_RDI));
+
+- printf("#define OFFSET_amd64_RSP %3d\n",
++ DEFINE(OFFSET_amd64_RSP,
+ offsetof(VexGuestAMD64State,guest_RSP));
+
+- printf("#define OFFSET_amd64_RBP %3d\n",
++ DEFINE(OFFSET_amd64_RBP,
+ offsetof(VexGuestAMD64State,guest_RBP));
+
+- printf("#define OFFSET_amd64_R8 %3d\n",
++ DEFINE(OFFSET_amd64_R8,
+ offsetof(VexGuestAMD64State,guest_R8));
+
+- printf("#define OFFSET_amd64_R9 %3d\n",
++ DEFINE(OFFSET_amd64_R9,
+ offsetof(VexGuestAMD64State,guest_R9));
+
+- printf("#define OFFSET_amd64_R10 %3d\n",
++ DEFINE(OFFSET_amd64_R10,
+ offsetof(VexGuestAMD64State,guest_R10));
+
+- printf("#define OFFSET_amd64_R11 %3d\n",
++ DEFINE(OFFSET_amd64_R11,
+ offsetof(VexGuestAMD64State,guest_R11));
+
+- printf("#define OFFSET_amd64_R12 %3d\n",
++ DEFINE(OFFSET_amd64_R12,
+ offsetof(VexGuestAMD64State,guest_R12));
+
+- printf("#define OFFSET_amd64_R13 %3d\n",
++ DEFINE(OFFSET_amd64_R13,
+ offsetof(VexGuestAMD64State,guest_R13));
+
+- printf("#define OFFSET_amd64_R14 %3d\n",
++ DEFINE(OFFSET_amd64_R14,
+ offsetof(VexGuestAMD64State,guest_R14));
+
+- printf("#define OFFSET_amd64_R15 %3d\n",
++ DEFINE(OFFSET_amd64_R15,
+ offsetof(VexGuestAMD64State,guest_R15));
+
+- printf("#define OFFSET_amd64_RIP %3d\n",
++ DEFINE(OFFSET_amd64_RIP,
+ offsetof(VexGuestAMD64State,guest_RIP));
+
+ printf("\n");
+
+ // ppc32
+- printf("#define OFFSET_ppc32_GPR0 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR0,
+ offsetof(VexGuestPPC32State,guest_GPR0));
+
+- printf("#define OFFSET_ppc32_GPR2 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR2,
+ offsetof(VexGuestPPC32State,guest_GPR2));
+
+- printf("#define OFFSET_ppc32_GPR3 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR3,
+ offsetof(VexGuestPPC32State,guest_GPR3));
+
+- printf("#define OFFSET_ppc32_GPR4 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR4,
+ offsetof(VexGuestPPC32State,guest_GPR4));
+
+- printf("#define OFFSET_ppc32_GPR5 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR5,
+ offsetof(VexGuestPPC32State,guest_GPR5));
+
+- printf("#define OFFSET_ppc32_GPR6 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR6,
+ offsetof(VexGuestPPC32State,guest_GPR6));
+
+- printf("#define OFFSET_ppc32_GPR7 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR7,
+ offsetof(VexGuestPPC32State,guest_GPR7));
+
+- printf("#define OFFSET_ppc32_GPR8 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR8,
+ offsetof(VexGuestPPC32State,guest_GPR8));
+
+- printf("#define OFFSET_ppc32_GPR9 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR9,
+ offsetof(VexGuestPPC32State,guest_GPR9));
+
+- printf("#define OFFSET_ppc32_GPR10 %3d\n",
++ DEFINE(OFFSET_ppc32_GPR10,
+ offsetof(VexGuestPPC32State,guest_GPR10));
+
+- printf("#define OFFSET_ppc32_CIA %3d\n",
++ DEFINE(OFFSET_ppc32_CIA,
+ offsetof(VexGuestPPC32State,guest_CIA));
+
+- printf("#define OFFSET_ppc32_CR0_0 %3d\n",
++ DEFINE(OFFSET_ppc32_CR0_0,
+ offsetof(VexGuestPPC32State,guest_CR0_0));
+
+ printf("\n");
+
+ // ppc64
+- printf("#define OFFSET_ppc64_GPR0 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR0,
+ offsetof(VexGuestPPC64State,guest_GPR0));
+
+- printf("#define OFFSET_ppc64_GPR2 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR2,
+ offsetof(VexGuestPPC64State,guest_GPR2));
+
+- printf("#define OFFSET_ppc64_GPR3 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR3,
+ offsetof(VexGuestPPC64State,guest_GPR3));
+
+- printf("#define OFFSET_ppc64_GPR4 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR4,
+ offsetof(VexGuestPPC64State,guest_GPR4));
+
+- printf("#define OFFSET_ppc64_GPR5 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR5,
+ offsetof(VexGuestPPC64State,guest_GPR5));
+
+- printf("#define OFFSET_ppc64_GPR6 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR6,
+ offsetof(VexGuestPPC64State,guest_GPR6));
+
+- printf("#define OFFSET_ppc64_GPR7 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR7,
+ offsetof(VexGuestPPC64State,guest_GPR7));
+
+- printf("#define OFFSET_ppc64_GPR8 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR8,
+ offsetof(VexGuestPPC64State,guest_GPR8));
+
+- printf("#define OFFSET_ppc64_GPR9 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR9,
+ offsetof(VexGuestPPC64State,guest_GPR9));
+
+- printf("#define OFFSET_ppc64_GPR10 %4d\n",
++ DEFINE(OFFSET_ppc64_GPR10,
+ offsetof(VexGuestPPC64State,guest_GPR10));
+
+- printf("#define OFFSET_ppc64_CIA %4d\n",
++ DEFINE(OFFSET_ppc64_CIA,
+ offsetof(VexGuestPPC64State,guest_CIA));
+
+- printf("#define OFFSET_ppc64_CR0_0 %4d\n",
++ DEFINE(OFFSET_ppc64_CR0_0,
+ offsetof(VexGuestPPC64State,guest_CR0_0));
+
+ printf("\n");
Index: VEX/Makefile
===================================================================
--- VEX/Makefile (revision 1849)
+++ VEX/Makefile (working copy)
-@@ -179,8 +179,8 @@
+@@ -178,9 +178,10 @@
+ @cat priv/main/vex_svnversion.h
@echo
- pub/libvex_guest_offsets.h:
+-pub/libvex_guest_offsets.h:
- $(CC) -Wall -g -o auxprogs/genoffsets auxprogs/genoffsets.c
- ./auxprogs/genoffsets > pub/libvex_guest_offsets.h
-+ $(CC) -Wall -g -c auxprogs/verifyoffsets.c \
-+ && cp pub/libvex_guest_offsets_in.h pub/libvex_guest_offsets.h
++pub/libvex_guest_offsets.h: auxprogs/genoffsets.c Makefile
++ $(CC) -Wall -g -S -o auxprogs/genoffsets.s auxprogs/genoffsets.c
++ sed -n 's/^\(#define.*\)\$$\(.*\)$$/\1\2/p' auxprogs/genoffsets.s \
++ > pub/libvex_guest_offsets.h
ALL_HEADERS = $(PUB_HEADERS) $(PRIV_HEADERS)
|